Misc/abrash-black-book
Watch
1
0
Fork
You've already forked abrash-black-book
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Replace invalid characters with HTML entities

Browse source 
— with —
’ with ’
+ with +
× with x
ç with ç
“ with “
” with ”
‘ with ‘
• with •
– with -
µ with µ
† with †
Fix C++
θ with θ
Yen symbol instead of times
Fix broken apos
Bullet again
E-circumflex
This commit is contained in:
James Gregory 2013-12-30 12:50:32 +11:00
commit 500e7f5654
353 changed files with 5091 additions and 5091 deletions
Download patch file Download diff file Expand all files Collapse all files

84
36-03.html
View file

@ -37,20 +37,20 @@
</CENTER>
<P><BR></P>
<H3><A NAME="Heading5"></A><FONT COLOR="#000077">Run-Length Slice Details</FONT></H3>
<P>A couple of run-length slice implementation details yet remain. First is the matter of how error-term turnover is detected. This is done in much the same way as it is with standard Bresenham&#146;s: The error term is maintained as a negative valve and advances for each step; when the error term reaches 0, it&#146;s time to add an extra pixel to the current run. This means that we only have to test for carry after advancing the error term to determine whether or not to add an extra pixel to each run. (Actually, the code in this chapter tests for the error term being greater than zero, but the assembly code in the next chapter will use the very efficient carry approach.)
<P>A couple of run-length slice implementation details yet remain. First is the matter of how error-term turnover is detected. This is done in much the same way as it is with standard Bresenham&rsquo;s: The error term is maintained as a negative valve and advances for each step; when the error term reaches 0, it&rsquo;s time to add an extra pixel to the current run. This means that we only have to test for carry after advancing the error term to determine whether or not to add an extra pixel to each run. (Actually, the code in this chapter tests for the error term being greater than zero, but the assembly code in the next chapter will use the very efficient carry approach.)
</P>
<P>The second and more difficult detail is balancing the runs so that they&#146;re centered around the ideal line, and therefore draw the same pixels that standard Bresenham&#146;s would draw. If we just drew full-length runs from the start, we&#146;d end up with an unbalanced line, as shown in Figure 36.5. Instead, we have to split the initial pixel plus one full run as evenly as possible between the first and last runs of the line, and adjust the initial error term appropriately for the initial half-run.</P>
<P>The second and more difficult detail is balancing the runs so that they&rsquo;re centered around the ideal line, and therefore draw the same pixels that standard Bresenham&rsquo;s would draw. If we just drew full-length runs from the start, we&rsquo;d end up with an unbalanced line, as shown in Figure 36.5. Instead, we have to split the initial pixel plus one full run as evenly as possible between the first and last runs of the line, and adjust the initial error term appropriately for the initial half-run.</P>
<P>The initial error term is advanced by one-half of the normal per-step fractional advance, because the initial step is only one-half pixel along the minor axis. This half-step gets us exactly halfway between the initial pixel and the next pixel along the minor axis. All the error-term adjustments are scaled up by two times precisely so that we can scale up this halved error term for the initial run by two times, and thereby make it an integer.</P>
<P>The other trick here is that if an odd number of pixels are allocated between the first and last partial runs, we&#146;ll end up with an odd pixel, since we are unable to draw a half-pixel. This odd pixel is accounted for by adding half a pixel to the error term.</P>
<P>That&#146;s all there is to run-length slice line drawing; the partial first and last runs are the only tricky part. Listing 36.1 is a run-length slice implementation in C. This is not an optimized implementation, nor is it meant to be; this listing is provided so that you can see how the run-length slice algorithm works. In the next chapter, I&#146;ll move on to an optimized version, but for now, Listing 36.1 will make it much easier to grasp the principles of run-length slice drawing, and to understand the optimized code I&#146;ll present in the next chapter.</P>
<P>The other trick here is that if an odd number of pixels are allocated between the first and last partial runs, we&rsquo;ll end up with an odd pixel, since we are unable to draw a half-pixel. This odd pixel is accounted for by adding half a pixel to the error term.</P>
<P>That&rsquo;s all there is to run-length slice line drawing; the partial first and last runs are the only tricky part. Listing 36.1 is a run-length slice implementation in C. This is not an optimized implementation, nor is it meant to be; this listing is provided so that you can see how the run-length slice algorithm works. In the next chapter, I&rsquo;ll move on to an optimized version, but for now, Listing 36.1 will make it much easier to grasp the principles of run-length slice drawing, and to understand the optimized code I&rsquo;ll present in the next chapter.</P>
<P><A NAME="Fig5"><!-- </A><A HREF="javascript:displayWindow('images/36-05.jpg',412,327 )"> --><IMG SRC="images/36-05.jpg"><BR><!-- </A>
<BR><A HREF="javascript:displayWindow('images/36-05.jpg',412,327)"> --><FONT COLOR="#000077"><B>Figure 36.5</B></FONT></A>&nbsp;&nbsp;<I>Balancing run-length slice lines: a) unbalanced; b) balanced.</I>
</P>
<P><B>LISTING 36.1 L36-1.C</B></P>
<!-- CODE //-->
<PRE>
/* Run-length slice line drawing implementation for mode 0x13, the VGA&#146;s
320x200 256-color mode. Not optimized! Tested with Borland C&#43;&#43; in
/* Run-length slice line drawing implementation for mode 0x13, the VGA&rsquo;s
320x200 256-color mode. Not optimized! Tested with Borland C++ in
the small model. */
#include &ltdos.h&gt
@ -69,7 +69,7 @@ void LineDraw(int XStart, int YStart, int XEnd, int YEnd, int Color)
int WholeStep, InitialPixelCount, FinalPixelCount, i, RunLength;
char far *ScreenPtr;
/* We&#146;ll always draw top to bottom, to reduce the number of cases we have to
/* We&rsquo;ll always draw top to bottom, to reduce the number of cases we have to
handle, and to make lines between the same endpoints draw the same pixels */
if (YStart &gt YEnd) {
Temp = YStart;
@ -80,9 +80,9 @@ void LineDraw(int XStart, int YStart, int XEnd, int YEnd, int Color)
XEnd = Temp;
}
/* Point to the bitmap address first pixel to draw */
ScreenPtr = MK_FP(SCREEN_SEGMENT, YStart * SCREEN_WIDTH &#43; XStart);
ScreenPtr = MK_FP(SCREEN_SEGMENT, YStart * SCREEN_WIDTH + XStart);
/* Figure out whether we&#146;re going left or right, and how far we&#146;re
/* Figure out whether we&rsquo;re going left or right, and how far we&rsquo;re
going horizontally */
if ((XDelta = XEnd - XStart) &lt 0)
{
@ -93,7 +93,7 @@ void LineDraw(int XStart, int YStart, int XEnd, int YEnd, int Color)
{
XAdvance = 1;
}
/* Figure out how far we&#146;re going vertically */
/* Figure out how far we&rsquo;re going vertically */
YDelta = YEnd - YStart;
/* Special-case horizontal, vertical, and diagonal lines, for speed
@ -101,30 +101,30 @@ void LineDraw(int XStart, int YStart, int XEnd, int YEnd, int Color)
if (XDelta == 0)
{
/* Vertical line */
for (i=0; i&lt=YDelta; i&#43;&#43;)
for (i=0; i&lt=YDelta; i++)
{
*ScreenPtr = Color;
ScreenPtr &#43;= SCREEN_WIDTH;
ScreenPtr += SCREEN_WIDTH;
}
return;
}
if (YDelta == 0)
{
/* Horizontal line */
for (i=0; i&lt=XDelta; i&#43;&#43;)
for (i=0; i&lt=XDelta; i++)
{
*ScreenPtr = Color;
ScreenPtr &#43;= XAdvance;
ScreenPtr += XAdvance;
}
return;
}
if (XDelta == YDelta)
{
/* Diagonal line */
for (i=0; i&lt=XDelta; i&#43;&#43;)
for (i=0; i&lt=XDelta; i++)
{
*ScreenPtr = Color;
ScreenPtr &#43;= XAdvance &#43; SCREEN_WIDTH;
ScreenPtr += XAdvance + SCREEN_WIDTH;
}
return;
}
@ -152,38 +152,38 @@ void LineDraw(int XStart, int YStart, int XEnd, int YEnd, int Color)
/* The initial and last runs are partial, because Y advances only 0.5
for these runs, rather than 1. Divide one full run, plus the
initial pixel, between the initial and last runs */
InitialPixelCount = (WholeStep / 2) &#43; 1;
InitialPixelCount = (WholeStep / 2) + 1;
FinalPixelCount = InitialPixelCount;
/* If the basic run length is even and there&#146;s no fractional
/* If the basic run length is even and there&rsquo;s no fractional
advance, we have one pixel that could go to either the initial
or last partial run, which we&#146;ll arbitrarily allocate to the
or last partial run, which we&rsquo;ll arbitrarily allocate to the
last run */
if ((AdjUp == 0) &amp&amp ((WholeStep &amp 0x01) == 0))
{
InitialPixelCount--;
}
/* If there&#146;re an odd number of pixels per run, we have 1 pixel that can&#146;t
be allocated to either the initial or last partial run, so we&#146;ll add 0.5
/* If there&rsquo;re an odd number of pixels per run, we have 1 pixel that can&rsquo;t
be allocated to either the initial or last partial run, so we&rsquo;ll add 0.5
to error term so this pixel will be handled by the normal full-run loop */
if ((WholeStep &amp 0x01) != 0)
{
ErrorTerm &#43;= YDelta;
ErrorTerm += YDelta;
}
/* Draw the first, partial run of pixels */
DrawHorizontalRun(&ampScreenPtr, XAdvance, InitialPixelCount, Color);
/* Draw all full runs */
for (i=0; i&lt(YDelta-1); i&#43;&#43;)
for (i=0; i&lt(YDelta-1); i++)
{
RunLength = WholeStep; /* run is at least this long */
/* Advance the error term and add an extra pixel if the error
term so indicates */
if ((ErrorTerm &#43;= AdjUp) &gt 0)
if ((ErrorTerm += AdjUp) &gt 0)
{
RunLength&#43;&#43;;
RunLength++;
ErrorTerm -= AdjDown; /* reset the error term */
}
/* Draw this scan line&#146;s run */
/* Draw this scan line&rsquo;s run */
DrawHorizontalRun(&ampScreenPtr, XAdvance, RunLength, Color);
}
/* Draw the final run of pixels */
@ -212,39 +212,39 @@ void LineDraw(int XStart, int YStart, int XEnd, int YEnd, int Color)
/* The initial and last runs are partial, because X advances only 0.5
for these runs, rather than 1. Divide one full run, plus the
initial pixel, between the initial and last runs */
InitialPixelCount = (WholeStep / 2) &#43; 1;
InitialPixelCount = (WholeStep / 2) + 1;
FinalPixelCount = InitialPixelCount;
/* If the basic run length is even and there&#146;s no fractional advance, we
/* If the basic run length is even and there&rsquo;s no fractional advance, we
have 1 pixel that could go to either the initial or last partial run,
which we&#146;ll arbitrarily allocate to the last run */
which we&rsquo;ll arbitrarily allocate to the last run */
if ((AdjUp == 0) &amp&amp ((WholeStep &amp 0x01) == 0))
{
InitialPixelCount--;
}
/* If there are an odd number of pixels per run, we have one pixel
that can&#146;t be allocated to either the initial or last partial
run, so we&#146;ll add 0.5 to the error term so this pixel will be
that can&rsquo;t be allocated to either the initial or last partial
run, so we&rsquo;ll add 0.5 to the error term so this pixel will be
handled by the normal full-run loop */
if ((WholeStep &amp 0x01) != 0)
{
ErrorTerm &#43;= XDelta;
ErrorTerm += XDelta;
}
/* Draw the first, partial run of pixels */
DrawVerticalRun(&ampScreenPtr, XAdvance, InitialPixelCount, Color);
/* Draw all full runs */
for (i=0; i&lt(XDelta-1); i&#43;&#43;)
for (i=0; i&lt(XDelta-1); i++)
{
RunLength = WholeStep; /* run is at least this long */
/* Advance the error term and add an extra pixel if the error
term so indicates */
if ((ErrorTerm &#43;= AdjUp) &gt 0)
if ((ErrorTerm += AdjUp) &gt 0)
{
RunLength&#43;&#43;;
RunLength++;
ErrorTerm -= AdjDown; /* reset the error term */
}
/* Draw this scan line&#146;s run */
/* Draw this scan line&rsquo;s run */
DrawVerticalRun(&ampScreenPtr, XAdvance, RunLength, Color);
}
/* Draw the final run of pixels */
@ -260,13 +260,13 @@ void DrawHorizontalRun(char far **ScreenPtr, int XAdvance,
int i;
char far *WorkingScreenPtr = *ScreenPtr;
for (i=0; i&ltRunLength; i&#43;&#43;)
for (i=0; i&ltRunLength; i++)
{
*WorkingScreenPtr = Color;
WorkingScreenPtr &#43;= XAdvance;
WorkingScreenPtr += XAdvance;
}
/* Advance to the next scan line */
WorkingScreenPtr &#43;= SCREEN_WIDTH;
WorkingScreenPtr += SCREEN_WIDTH;
*ScreenPtr = WorkingScreenPtr;
}
/* Draws a vertical run of pixels, then advances the bitmap pointer to
@ -277,13 +277,13 @@ void DrawVerticalRun(char far **ScreenPtr, int XAdvance,
int i;
char far *WorkingScreenPtr = *ScreenPtr;
for (i=0; i&ltRunLength; i&#43;&#43;)
for (i=0; i&ltRunLength; i++)
{
*WorkingScreenPtr = Color;
WorkingScreenPtr &#43;= SCREEN_WIDTH;
WorkingScreenPtr += SCREEN_WIDTH;
}
/* Advance to the next column */
WorkingScreenPtr &#43;= XAdvance;
WorkingScreenPtr += XAdvance;
*ScreenPtr = WorkingScreenPtr;
}