tessmono.c File Reference

#include "gluos.h"
#include <stdlib.h>
#include "geom.h"
#include "mesh.h"
#include "tessmono.h"
#include <assert.h>

Include dependency graph for tessmono.c:

Go to the source code of this file.

Macros
#define	AddWinding(eDst, eSrc)
#define	MARKED_FOR_DELETION   0x7fffffff

Functions
int	__gl_meshTessellateMonoRegion (GLUface *face)
int	__gl_meshTessellateInterior (GLUmesh *mesh)
void	__gl_meshDiscardExterior (GLUmesh *mesh)
int	__gl_meshSetWindingNumber (GLUmesh *mesh, int value, GLboolean keepOnlyBoundary)

Macro Definition Documentation

AddWinding

#define AddWinding	(		eDst,
			eSrc
	)

Value:

         (eDst->winding += eSrc->winding, \
         eDst->Sym->winding += eSrc->Sym->winding)

MARKED_FOR_DELETION

#define MARKED_FOR_DELETION   0x7fffffff

Function Documentation

__gl_meshDiscardExterior()

void __gl_meshDiscardExterior

(

GLUmesh *

mesh

)

{
  GLUface *f, *next;
 
  /*LINTED*/
  for( f = mesh->fHead.next; f != &mesh->fHead; f = next ) {
    /* Since f will be destroyed, save its next pointer. */
    next = f->next;
    if( ! f->inside ) {
      __gl_meshZapFace( f );
    }
  }
}

References __gl_meshZapFace(), GLUmesh::fHead, GLUface::inside, and GLUface::next.

Referenced by gluTessEndPolygon().

Here is the call graph for this function:

Here is the caller graph for this function:

__gl_meshSetWindingNumber()

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;
}

References __gl_meshDelete(), GLUmesh::eHead, GLUface::inside, GLUhalfEdge::Lface, GLUhalfEdge::next, and GLUhalfEdge::winding.

Referenced by gluTessEndPolygon().

Here is the call graph for this function:

Here is the caller graph for this function:

__gl_meshTessellateInterior()

int __gl_meshTessellateInterior

(

GLUmesh *

mesh

)

{
  GLUface *f, *next;
 
  /*LINTED*/
  for( f = mesh->fHead.next; f != &mesh->fHead; f = next ) {
    /* Make sure we don''t try to tessellate the new triangles. */
    next = f->next;
    if( f->inside ) {
      if ( !__gl_meshTessellateMonoRegion( f ) ) return 0;
    }
  }
 
  return 1;
}

References __gl_meshTessellateMonoRegion(), GLUmesh::fHead, GLUface::inside, and GLUface::next.

Referenced by gluTessEndPolygon().

Here is the call graph for this function:

Here is the caller graph for this function:

__gl_meshTessellateMonoRegion()

int __gl_meshTessellateMonoRegion

(

GLUface *

face

)

{
  GLUhalfEdge *up, *lo;
 
  /* All edges are oriented CCW around the boundary of the region.
   * First, find the half-edge whose origin vertex is rightmost.
   * Since the sweep goes from left to right, face->anEdge should
   * be close to the edge we want.
   */
  up = face->anEdge;
  assert( up->Lnext != up && up->Lnext->Lnext != up );
 
  for( ; VertLeq( up->Dst, up->Org ); up = up->Lprev )
    ;
  for( ; VertLeq( up->Org, up->Dst ); up = up->Lnext )
    ;
  lo = up->Lprev;
 
  while( up->Lnext != lo ) {
    if( VertLeq( up->Dst, lo->Org )) {
      /* up->Dst is on the left.  It is safe to form triangles from lo->Org.
       * The EdgeGoesLeft test guarantees progress even when some triangles
       * are CW, given that the upper and lower chains are truly monotone.
       */
      while( lo->Lnext != up && (EdgeGoesLeft( lo->Lnext )
       || EdgeSign( lo->Org, lo->Dst, lo->Lnext->Dst ) <= 0 )) {
  GLUhalfEdge *tempHalfEdge= __gl_meshConnect( lo->Lnext, lo );
  if (tempHalfEdge == NULL) return 0;
  lo = tempHalfEdge->Sym;
      }
      lo = lo->Lprev;
    } else {
      /* lo->Org is on the left.  We can make CCW triangles from up->Dst. */
      while( lo->Lnext != up && (EdgeGoesRight( up->Lprev )
       || EdgeSign( up->Dst, up->Org, up->Lprev->Org ) >= 0 )) {
  GLUhalfEdge *tempHalfEdge= __gl_meshConnect( up, up->Lprev );
  if (tempHalfEdge == NULL) return 0;
  up = tempHalfEdge->Sym;
      }
      up = up->Lnext;
    }
  }
 
  /* Now lo->Org == up->Dst == the leftmost vertex.  The remaining region
   * can be tessellated in a fan from this leftmost vertex.
   */
  assert( lo->Lnext != up );
  while( lo->Lnext->Lnext != up ) {
    GLUhalfEdge *tempHalfEdge= __gl_meshConnect( lo->Lnext, lo );
    if (tempHalfEdge == NULL) return 0;
    lo = tempHalfEdge->Sym;
  }
 
  return 1;
}

References __gl_meshConnect(), GLUface::anEdge, EdgeGoesLeft, EdgeGoesRight, EdgeSign, GLUhalfEdge::Lnext, GLUhalfEdge::Org, GLUhalfEdge::Sym, and VertLeq.

Referenced by __gl_meshTessellateInterior().

Here is the call graph for this function:

Here is the caller graph for this function: