/*
* Written by Brian Kelleher; Oct. 1985
*
* Routine to fill a polygon. Two fill rules are supported: frWINDING and
* frEVENODD.
*/
static Bool
miFillGeneralPoly(DrawablePtr dst, GCPtr pgc, int count, DDXPointPtr ptsIn)
{
EdgeTableEntry *pAET; /* the Active Edge Table */
int y; /* the current scanline */
int nPts = 0; /* number of pts in buffer */
EdgeTableEntry *pWETE; /* Winding Edge Table */
ScanLineList *pSLL; /* Current ScanLineList */
DDXPointPtr ptsOut; /* ptr to output buffers */
int *width;
DDXPointRec FirstPoint[NUMPTSTOBUFFER]; /* the output buffers */
int FirstWidth[NUMPTSTOBUFFER];
EdgeTableEntry *pPrevAET; /* previous AET entry */
EdgeTable ET; /* Edge Table header node */
EdgeTableEntry AET; /* Active ET header node */
EdgeTableEntry *pETEs; /* Edge Table Entries buff */
ScanLineListBlock SLLBlock; /* header for ScanLineList */
int fixWAET = 0;
if (count < 3)
return TRUE;
if (!(pETEs = malloc(sizeof(EdgeTableEntry) * count)))
return FALSE;
ptsOut = FirstPoint;
width = FirstWidth;
if (!miCreateETandAET(count, ptsIn, &ET, &AET, pETEs, &SLLBlock)) {
free(pETEs);
return FALSE;
}
pSLL = ET.scanlines.next;
if (pgc->fillRule == EvenOddRule) {
/*
* for each scanline
*/
for (y = ET.ymin; y < ET.ymax; y++) {
/*
* Add a new edge to the active edge table when we
* get to the next edge.
*/
if (pSLL && y == pSLL->scanline) {
miloadAET(&AET, pSLL->edgelist);
pSLL = pSLL->next;
}
pPrevAET = &AET;
pAET = AET.next;
/*
* for each active edge
*/
while (pAET) {
ptsOut->x = pAET->bres.minor;
ptsOut++->y = y;
*width++ = pAET->next->bres.minor - pAET->bres.minor;
nPts++;
/*
* send out the buffer when its full
*/
if (nPts == NUMPTSTOBUFFER) {
(*pgc->ops->FillSpans) (dst, pgc,
nPts, FirstPoint, FirstWidth, 1);
ptsOut = FirstPoint;
width = FirstWidth;
nPts = 0;
}
EVALUATEEDGEEVENODD(pAET, pPrevAET, y);
EVALUATEEDGEEVENODD(pAET, pPrevAET, y);
}
miInsertionSort(&AET);
}
}
else { /* default to WindingNumber */
/*
* for each scanline
*/
for (y = ET.ymin; y < ET.ymax; y++) {
/*
* Add a new edge to the active edge table when we
* get to the next edge.
*/
if (pSLL && y == pSLL->scanline) {
miloadAET(&AET, pSLL->edgelist);
micomputeWAET(&AET);
pSLL = pSLL->next;
}
pPrevAET = &AET;
pAET = AET.next;
pWETE = pAET;
/*
* for each active edge
*/
while (pAET) {
/*
* if the next edge in the active edge table is
* also the next edge in the winding active edge
* table.
*/
if (pWETE == pAET) {
ptsOut->x = pAET->bres.minor;
ptsOut++->y = y;
*width++ = pAET->nextWETE->bres.minor - pAET->bres.minor;
nPts++;
/*
* send out the buffer
*/
if (nPts == NUMPTSTOBUFFER) {
(*pgc->ops->FillSpans) (dst, pgc, nPts, FirstPoint,
FirstWidth, 1);
ptsOut = FirstPoint;
width = FirstWidth;
nPts = 0;
}
pWETE = pWETE->nextWETE;
while (pWETE != pAET)
EVALUATEEDGEWINDING(pAET, pPrevAET, y, fixWAET);
pWETE = pWETE->nextWETE;
}
EVALUATEEDGEWINDING(pAET, pPrevAET, y, fixWAET);
}
/*
* reevaluate the Winding active edge table if we
* just had to resort it or if we just exited an edge.
*/
if (miInsertionSort(&AET) || fixWAET) {
micomputeWAET(&AET);
fixWAET = 0;
}
}
}
/*
* Get any spans that we missed by buffering
*/
(*pgc->ops->FillSpans) (dst, pgc, nPts, FirstPoint, FirstWidth, 1);
free(pETEs);
miFreeStorage(SLLBlock.next);
return TRUE;
}
static bool
miCreateETandAET(int count, DDXPointPtr pts, EdgeTable *ET,
EdgeTableEntry *AET, EdgeTableEntry *pETEs, ScanLineListBlock *pSLLBlock)
{
register DDXPointPtr top, bottom;
register DDXPointPtr PrevPt, CurrPt;
int iSLLBlock = 0;
int dy;
if (count < 2) return TRUE;
/*
* initialize the Active Edge Table
*/
AET->next = 0;
AET->back = 0;
AET->nextWETE = 0;
AET->bres.minor = MININT;
/*
* initialize the Edge Table.
*/
ET->scanlines.next = 0;
ET->ymax = MININT;
ET->ymin = MAXINT;
pSLLBlock->next = 0;
PrevPt = &pts[count-1];
/*
* for each vertex in the array of points.
* In this loop we are dealing with two vertices at
* a time -- these make up one edge of the polygon.
*/
while (count--)
{
CurrPt = pts++;
/*
* find out which point is above and which is below.
*/
if (PrevPt->y > CurrPt->y)
{
bottom = PrevPt, top = CurrPt;
pETEs->ClockWise = 0;
}
else
{
bottom = CurrPt, top = PrevPt;
pETEs->ClockWise = 1;
}
/*
* don't add horizontal edges to the Edge table.
*/
if (bottom->y != top->y)
{
pETEs->ymax = bottom->y-1; /* -1 so we don't get last scanline */
/*
* initialize integer edge algorithm
*/
dy = bottom->y - top->y;
BRESINITPGONSTRUCT(dy, top->x, bottom->x, pETEs->bres)
if (!miInsertEdgeInET(ET, pETEs, top->y, &pSLLBlock, &iSLLBlock))
{
miFreeStorage(pSLLBlock->next);
return FALSE;
}
ET->ymax = QMAX(ET->ymax, PrevPt->y);
ET->ymin = QMIN(ET->ymin, PrevPt->y);
pETEs++;
}
PrevPt = CurrPt;
}
/* ARGS: count = number of points, ptsIn = the points */
void
miFillGeneralPoly (miPaintedSet *paintedSet, const miGC *pGC, int count, const miPoint *ptsIn)
{
EdgeTableEntry *pAET; /* the Active Edge Table */
int y; /* the current scanline */
int nPts = 0; /* number of pts in buffer */
EdgeTableEntry *pWETE; /* Winding Edge Table */
ScanLineList *pSLL; /* Current ScanLineList */
miPoint *ptsOut; /* ptr to output buffers */
unsigned int *width;
miPoint FirstPoint[NUMPTSTOBUFFER]; /* the output buffers */
unsigned int FirstWidth[NUMPTSTOBUFFER];
EdgeTableEntry *pPrevAET; /* previous AET entry */
EdgeTable ET; /* Edge Table header node */
EdgeTableEntry AET; /* Active ET header node */
EdgeTableEntry *pETEs; /* Edge Table Entries buff */
ScanLineListBlock SLLBlock; /* header for ScanLineList */
bool fixWAET = false;
if (count <= 2)
return;
pETEs = (EdgeTableEntry *) mi_xmalloc(sizeof(EdgeTableEntry) * count);
ptsOut = FirstPoint;
width = FirstWidth;
miCreateETandAET (count, ptsIn, &ET, &AET, pETEs, &SLLBlock);
pSLL = ET.scanlines.next;
if (pGC->fillRule == (int)MI_EVEN_ODD_RULE)
{
/*
* for each scanline
*/
for (y = ET.ymin; y < ET.ymax; y++)
{
/*
* Add a new edge to the active edge table when we
* get to the next edge.
*/
if (pSLL && y == pSLL->scanline)
{
miloadAET(&AET, pSLL->edgelist);
pSLL = pSLL->next;
}
pPrevAET = &AET;
pAET = AET.next;
/*
* for each active edge
*/
while (pAET)
{
ptsOut->x = pAET->bres.minor_axis;
ptsOut++->y = y;
*width++ = (unsigned int)(pAET->next->bres.minor_axis - pAET->bres.minor_axis);
nPts++;
/*
* send out the buffer when its full
*/
if (nPts == NUMPTSTOBUFFER)
{
MI_COPY_AND_PAINT_SPANS(paintedSet, pGC->pixels[1], nPts, FirstPoint, FirstWidth)
ptsOut = FirstPoint;
width = FirstWidth;
nPts = 0;
}
EVALUATEEDGEEVENODD(pAET, pPrevAET, y)
EVALUATEEDGEEVENODD(pAET, pPrevAET, y);
}
miInsertionSort(&AET);
}
}
else /* default to WindingNumber */
{
/*
* for each scanline
*/
for (y = ET.ymin; y < ET.ymax; y++)
{
/*
* Add a new edge to the active edge table when we
* get to the next edge.
*/
if (pSLL && y == pSLL->scanline)
{
miloadAET(&AET, pSLL->edgelist);
micomputeWAET(&AET);
pSLL = pSLL->next;
}
pPrevAET = &AET;
pAET = AET.next;
pWETE = pAET;
/*
* for each active edge
*/
while (pAET)
{
/*
* if the next edge in the active edge table is
* also the next edge in the winding active edge
* table.
*/
if (pWETE == pAET)
{
ptsOut->x = pAET->bres.minor_axis;
ptsOut++->y = y;
*width++ = (unsigned int)(pAET->nextWETE->bres.minor_axis - pAET->bres.minor_axis);
nPts++;
/*
* send out the buffer
*/
if (nPts == NUMPTSTOBUFFER)
{
MI_COPY_AND_PAINT_SPANS(paintedSet, pGC->pixels[1], nPts, FirstPoint, FirstWidth)
ptsOut = FirstPoint;
width = FirstWidth;
nPts = 0;
}
pWETE = pWETE->nextWETE;
while (pWETE != pAET)
EVALUATEEDGEWINDING(pAET, pPrevAET, y, fixWAET);
pWETE = pWETE->nextWETE;
}
EVALUATEEDGEWINDING(pAET, pPrevAET, y, fixWAET);
}
/*
* reevaluate the Winding active edge table if we
* just had to resort it or if we just exited an edge.
*/
if (miInsertionSort(&AET) || fixWAET)
{
micomputeWAET(&AET);
fixWAET = false;
}
}
}
/*
* Get any spans that we missed by buffering
*/
MI_COPY_AND_PAINT_SPANS(paintedSet, pGC->pixels[1], nPts, FirstPoint, FirstWidth)
free (pETEs);
miFreeStorage(SLLBlock.next);
}
