static void RemoveDegenerateEdges( GLUtesselator *tess )
/*
* Remove zero-length edges, and contours with fewer than 3 vertices.
*/
{
GLUhalfEdge *e, *eNext, *eLnext;
GLUhalfEdge *eHead = &tess->mesh->eHead;
/*LINTED*/
for( e = eHead->next; e != eHead; e = eNext ) {
eNext = e->next;
eLnext = e->Lnext;
if( VertEq( e->Org, e->Dst ) && e->Lnext->Lnext != e ) {
/* Zero-length edge, contour has at least 3 edges */
SpliceMergeVertices( tess, eLnext, e ); /* deletes e->Org */
if ( !__gl_meshDelete( e ) ) longjmp(tess->env,1); /* e is a self-loop */
e = eLnext;
eLnext = e->Lnext;
}
if( eLnext->Lnext == e ) {
/* Degenerate contour (one or two edges) */
if( eLnext != e ) {
if( eLnext == eNext || eLnext == eNext->Sym ) { eNext = eNext->next; }
if ( !__gl_meshDelete( eLnext ) ) longjmp(tess->env,1);
}
if( e == eNext || e == eNext->Sym ) { eNext = eNext->next; }
if ( !__gl_meshDelete( e ) ) longjmp(tess->env,1);
}
}
}
static void ConnectLeftDegenerate( GLUtesselator *tess,
ActiveRegion *regUp, GLUvertex *vEvent )
/*
* The event vertex lies exacty on an already-processed edge or vertex.
* Adding the new vertex involves splicing it into the already-processed
* part of the mesh.
*/
{
GLUhalfEdge *e, *eTopLeft, *eTopRight, *eLast;
ActiveRegion *reg;
e = regUp->eUp;
if( VertEq( e->Org, vEvent )) {
/* e->Org is an unprocessed vertex - just combine them, and wait
* for e->Org to be pulled from the queue
*/
assert( TOLERANCE_NONZERO );
SpliceMergeVertices( tess, e, vEvent->anEdge );
return;
}
if( ! VertEq( e->Dst, vEvent )) {
/* General case -- splice vEvent into edge e which passes through it */
if (__gl_meshSplitEdge( e->Sym ) == NULL) longjmp(tess->env,1);
if( regUp->fixUpperEdge ) {
/* This edge was fixable -- delete unused portion of original edge */
if ( !__gl_meshDelete( e->Onext ) ) longjmp(tess->env,1);
regUp->fixUpperEdge = FALSE;
}
if ( !__gl_meshSplice( vEvent->anEdge, e ) ) longjmp(tess->env,1);
SweepEvent( tess, vEvent ); /* recurse */
return;
}
/* vEvent coincides with e->Dst, which has already been processed.
* Splice in the additional right-going edges.
*/
assert( TOLERANCE_NONZERO );
regUp = TopRightRegion( regUp );
reg = RegionBelow( regUp );
eTopRight = reg->eUp->Sym;
eTopLeft = eLast = eTopRight->Onext;
if( reg->fixUpperEdge ) {
/* Here e->Dst has only a single fixable edge going right.
* We can delete it since now we have some real right-going edges.
*/
assert( eTopLeft != eTopRight ); /* there are some left edges too */
DeleteRegion( tess, reg );
if ( !__gl_meshDelete( eTopRight ) ) longjmp(tess->env,1);
eTopRight = eTopLeft->Oprev;
}
if ( !__gl_meshSplice( vEvent->anEdge, eTopRight ) ) longjmp(tess->env,1);
if( ! EdgeGoesLeft( eTopLeft )) {
/* e->Dst had no left-going edges -- indicate this to AddRightEdges() */
eTopLeft = NULL;
}
AddRightEdges( tess, regUp, eTopRight->Onext, eLast, eTopLeft, TRUE );
}
static int RemoveDegenerateFaces( GLUmesh *mesh )
/*
* Delete any degenerate faces with only two edges. WalkDirtyRegions()
* will catch almost all of these, but it won't catch degenerate faces
* produced by splice operations on already-processed edges.
* The two places this can happen are in FinishLeftRegions(), when
* we splice in a "temporary" edge produced by ConnectRightVertex(),
* and in CheckForLeftSplice(), where we splice already-processed
* edges to ensure that our dictionary invariants are not violated
* by numerical errors.
*
* In both these cases it is *very* dangerous to delete the offending
* edge at the time, since one of the routines further up the stack
* will sometimes be keeping a pointer to that edge.
*/
{
GLUface *f, *fNext;
GLUhalfEdge *e;
/*LINTED*/
for( f = mesh->fHead.next; f != &mesh->fHead; f = fNext ) {
fNext = f->next;
e = f->anEdge;
assert( e->Lnext != e );
if( e->Lnext->Lnext == e ) {
/* A face with only two edges */
AddWinding( e->Onext, e );
if ( !__gl_meshDelete( e ) ) return 0;
}
}
return 1;
}
static int FixUpperEdge( ActiveRegion *reg, GLUhalfEdge *newEdge )
/*
* Replace an upper edge which needs fixing (see ConnectRightVertex).
*/
{
assert( reg->fixUpperEdge );
if ( !__gl_meshDelete( reg->eUp ) ) return 0;
reg->fixUpperEdge = FALSE;
reg->eUp = newEdge;
newEdge->activeRegion = reg;
return 1;
}
/* __gl_meshSetWindingNumber( mesh, value, keepOnlyBoundary ) resets the
* winding numbers on all edges so that regions marked "inside" the
* polygon have a winding number of "value", and regions outside
* have a winding number of 0.
*
* If keepOnlyBoundary is TRUE, it also deletes all edges which do not
* separate an interior region from an exterior one.
*/
int __gl_meshSetWindingNumber( GLUmesh *mesh, int value,
GLboolean keepOnlyBoundary )
{
GLUhalfEdge *e, *eNext;
for( e = mesh->eHead.next; e != &mesh->eHead; e = eNext ) {
eNext = e->next;
if( e->Rface->inside != e->Lface->inside ) {
/* This is a boundary edge (one side is interior, one is exterior). */
e->winding = (e->Lface->inside) ? value : -value;
} else {
/* Both regions are interior, or both are exterior. */
if( ! keepOnlyBoundary ) {
e->winding = 0;
} else {
if ( !__gl_meshDelete( e ) ) return 0;
}
}
}
return 1;
}
static void WalkDirtyRegions( GLUtesselator *tess, ActiveRegion *regUp )
/*
* When the upper or lower edge of any region changes, the region is
* marked "dirty". This routine walks through all the dirty regions
* and makes sure that the dictionary invariants are satisfied
* (see the comments at the beginning of this file). Of course
* new dirty regions can be created as we make changes to restore
* the invariants.
*/
{
ActiveRegion *regLo = RegionBelow(regUp);
GLUhalfEdge *eUp, *eLo;
for( ;; ) {
/* Find the lowest dirty region (we walk from the bottom up). */
while( regLo->dirty ) {
regUp = regLo;
regLo = RegionBelow(regLo);
}
if( ! regUp->dirty ) {
regLo = regUp;
regUp = RegionAbove( regUp );
if( regUp == NULL || ! regUp->dirty ) {
/* We've walked all the dirty regions */
return;
}
}
regUp->dirty = FALSE;
eUp = regUp->eUp;
eLo = regLo->eUp;
if( eUp->Dst != eLo->Dst ) {
/* Check that the edge ordering is obeyed at the Dst vertices. */
if( CheckForLeftSplice( tess, regUp )) {
/* If the upper or lower edge was marked fixUpperEdge, then
* we no longer need it (since these edges are needed only for
* vertices which otherwise have no right-going edges).
*/
if( regLo->fixUpperEdge ) {
DeleteRegion( tess, regLo );
if ( !__gl_meshDelete( eLo ) ) longjmp(tess->env,1);
regLo = RegionBelow( regUp );
eLo = regLo->eUp;
} else if( regUp->fixUpperEdge ) {
DeleteRegion( tess, regUp );
if ( !__gl_meshDelete( eUp ) ) longjmp(tess->env,1);
regUp = RegionAbove( regLo );
eUp = regUp->eUp;
}
}
}
if( eUp->Org != eLo->Org ) {
if( eUp->Dst != eLo->Dst
&& ! regUp->fixUpperEdge && ! regLo->fixUpperEdge
&& (eUp->Dst == tess->event || eLo->Dst == tess->event) )
{
/* When all else fails in CheckForIntersect(), it uses tess->event
* as the intersection location. To make this possible, it requires
* that tess->event lie between the upper and lower edges, and also
* that neither of these is marked fixUpperEdge (since in the worst
* case it might splice one of these edges into tess->event, and
* violate the invariant that fixable edges are the only right-going
* edge from their associated vertex).
*/
if( CheckForIntersect( tess, regUp )) {
/* WalkDirtyRegions() was called recursively; we're done */
return;
}
} else {
/* Even though we can't use CheckForIntersect(), the Org vertices
* may violate the dictionary edge ordering. Check and correct this.
*/
(void) CheckForRightSplice( tess, regUp );
}
}
if( eUp->Org == eLo->Org && eUp->Dst == eLo->Dst ) {
/* A degenerate loop consisting of only two edges -- delete it. */
AddWinding( eLo, eUp );
DeleteRegion( tess, regUp );
if ( !__gl_meshDelete( eUp ) ) longjmp(tess->env,1);
regUp = RegionAbove( regLo );
}
}
}
static void AddRightEdges( GLUtesselator *tess, ActiveRegion *regUp,
GLUhalfEdge *eFirst, GLUhalfEdge *eLast, GLUhalfEdge *eTopLeft,
GLboolean cleanUp )
/*
* Purpose: insert right-going edges into the edge dictionary, and update
* winding numbers and mesh connectivity appropriately. All right-going
* edges share a common origin vOrg. Edges are inserted CCW starting at
* eFirst; the last edge inserted is eLast->Oprev. If vOrg has any
* left-going edges already processed, then eTopLeft must be the edge
* such that an imaginary upward vertical segment from vOrg would be
* contained between eTopLeft->Oprev and eTopLeft; otherwise eTopLeft
* should be NULL.
*/
{
ActiveRegion *reg, *regPrev;
GLUhalfEdge *e, *ePrev;
int firstTime = TRUE;
/* Insert the new right-going edges in the dictionary */
e = eFirst;
do {
assert( VertLeq( e->Org, e->Dst ));
AddRegionBelow( tess, regUp, e->Sym );
e = e->Onext;
} while ( e != eLast );
/* Walk *all* right-going edges from e->Org, in the dictionary order,
* updating the winding numbers of each region, and re-linking the mesh
* edges to match the dictionary ordering (if necessary).
*/
if( eTopLeft == NULL ) {
eTopLeft = RegionBelow( regUp )->eUp->Rprev;
}
regPrev = regUp;
ePrev = eTopLeft;
for( ;; ) {
reg = RegionBelow( regPrev );
e = reg->eUp->Sym;
if( e->Org != ePrev->Org ) break;
if( e->Onext != ePrev ) {
/* Unlink e from its current position, and relink below ePrev */
if ( !__gl_meshSplice( e->Oprev, e ) ) longjmp(tess->env,1);
if ( !__gl_meshSplice( ePrev->Oprev, e ) ) longjmp(tess->env,1);
}
/* Compute the winding number and "inside" flag for the new regions */
reg->windingNumber = regPrev->windingNumber - e->winding;
reg->inside = IsWindingInside( tess, reg->windingNumber );
/* Check for two outgoing edges with same slope -- process these
* before any intersection tests (see example in __gl_computeInterior).
*/
regPrev->dirty = TRUE;
if( ! firstTime && CheckForRightSplice( tess, regPrev )) {
AddWinding( e, ePrev );
DeleteRegion( tess, regPrev );
if ( !__gl_meshDelete( ePrev ) ) longjmp(tess->env,1);
}
firstTime = FALSE;
regPrev = reg;
ePrev = e;
}
regPrev->dirty = TRUE;
assert( regPrev->windingNumber - e->winding == reg->windingNumber );
if( cleanUp ) {
/* Check for intersections between newly adjacent edges. */
WalkDirtyRegions( tess, regPrev );
}
}
