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

Normal quotes

Browse source
This commit is contained in:
James Gregory 2013-12-30 18:34:31 +11:00
commit 18011c595a
352 changed files with 6040 additions and 6040 deletions
Download patch file Download diff file Expand all files Collapse all files

26
41-04.md
View file

@ -11,10 +11,10 @@
failed. All C code tested with Borland C++.
If the polygon shape is known in advance, speedier processing may be
enabled by specifying the shape as follows: “convex” - a rubber band
enabled by specifying the shape as follows: "convex" - a rubber band
stretched around the polygon would touch every vertex in order;
”nonconvex” - the polygon is not self-intersecting, but need not be
convex; “complex” - the polygon may be self-intersecting, or, indeed,
"nonconvex" - the polygon is not self-intersecting, but need not be
convex; "complex" - the polygon may be self-intersecting, or, indeed,
any sort of polygon at all. Complex will work for all polygons; convex
is fastest. Undefined results will occur if convex is specified for a
nonconvex or complex polygon.
@ -32,7 +32,7 @@
#else /* MSC */
#include <malloc.h>
#endif
#include “polygon.h”
#include "polygon.h"
#define SWAP(a,b) {temp = a; a = b; b = temp;}
@ -84,7 +84,7 @@
if ((EdgeTableBuffer =
(struct EdgeState *) (malloc(sizeof(struct EdgeState) *
VertexList->Length))) == NULL)
return(0); /* couldn’t get memory for the edge table */
return(0); /* couldn't get memory for the edge table */
/* Build the global edge table */
BuildGET(VertexList, EdgeTableBuffer, XOffset, YOffset);
/* Scan down through the polygon edges, one scan line at a time,
@ -98,7 +98,7 @@
XSortAET(); /* resort on X */
CurrentY++; /* advance to the next scan line */
}
/* Release the memory we’ve allocated and we’re done */
/* Release the memory we've allocated and we're done */
free(EdgeTableBuffer);
return(1);
}
@ -138,9 +138,9 @@
SWAP(StartX, EndX);
SWAP(StartY, EndY);
}
/* Skip if this can’t ever be an active edge (has 0 height) */
/* Skip if this can't ever be an active edge (has 0 height) */
if ((DeltaY = EndY - StartY) != 0) {
/* Allocate space for this edge’s info, and fill in the
/* Allocate space for this edge's info, and fill in the
structure */
NewEdgePtr = NextFreeEdgeStruc++;
NewEdgePtr->XDirection = /* direction in which X moves */
@ -224,9 +224,9 @@
/* This edge is finished, so remove it from the AET */
*CurrentEdgePtr = CurrentEdge->NextEdge;
} else {
/* Advance the edge’s X coordinate by minimum move */
/* Advance the edge's X coordinate by minimum move */
CurrentEdge->X += CurrentEdge->WholePixelXMove;
/* Determine whether it’s time for X to advance one extra */
/* Determine whether it's time for X to advance one extra */
if ((CurrentEdge->ErrorTerm +=
CurrentEdge->ErrorTermAdjUp) > 0) {
CurrentEdge->X += CurrentEdge->XDirection;
@ -244,7 +244,7 @@
int CurrentX;
/* The GET is Y sorted. Any edges that start at the desired Y
coordinate will be first in the GET, so we’ll move edges from
coordinate will be first in the GET, so we'll move edges from
the GET to AET until the first edge left in the GET is no longer
at the desired Y coordinate. Also, the GET is X sorted within
each Y coordinate, so each successive edge we add to the AET is
@ -331,11 +331,11 @@
Is monotone-vertical polygon detection worth all this trouble? Under the
right circumstances, you bet. In a situation where a great many polygons
are being drawn, and the application either doesn’t know whether they’re
are being drawn, and the application either doesn't know whether they're
monotone-vertical or has no way to tell the polygon filler that they
are, performance can be increased considerably if most polygons are, in
fact, monotone-vertical. This potential performance advantage is helped
along by the surprising fact that Jim’s test for monotone-vertical
along by the surprising fact that Jim's test for monotone-vertical
status is simpler and faster than my original, nonfunctional test for
convexity.