tess.c File Reference

#include "gluos.h"
#include <stddef.h>
#include <assert.h>
#include <setjmp.h>
#include "memalloc.h"
#include "tess.h"
#include "mesh.h"
#include "normal.h"
#include "sweep.h"
#include "tessmono.h"
#include "render.h"

Include dependency graph for tess.c:

Go to the source code of this file.

Classes
struct	EdgePair

Macros
#define	GLU_TESS_DEFAULT_TOLERANCE   0.0
#define	GLU_TESS_MESH   100112 /* void (*)(GLUmesh *mesh) */
#define	TRUE   1
#define	FALSE   0
#define	MAX(a, b)   ((a) > (b) ? (a) : (b))
#define	MAX_FAST_ALLOC
#define	RequireState(tess, s)   if( tess->state != s ) GotoState(tess,s)

Functions
static void GLAPIENTRY	noBegin (GLenum type)
static void GLAPIENTRY	noEdgeFlag (GLboolean boundaryEdge)
static void GLAPIENTRY	noVertex (void *data)
static void GLAPIENTRY	noEnd (void)
static void GLAPIENTRY	noError (GLenum errnum)
static void GLAPIENTRY	noCombine (GLdouble coords[3], void *data[4], GLfloat weight[4], void **dataOut)
static void GLAPIENTRY	noMesh (GLUmesh *mesh)
void GLAPIENTRY	__gl_noBeginData (GLenum type, void *polygonData)
void GLAPIENTRY	__gl_noEdgeFlagData (GLboolean boundaryEdge, void *polygonData)
void GLAPIENTRY	__gl_noVertexData (void *data, void *polygonData)
void GLAPIENTRY	__gl_noEndData (void *polygonData)
void GLAPIENTRY	__gl_noErrorData (GLenum errnum, void *polygonData)
void GLAPIENTRY	__gl_noCombineData (GLdouble coords[3], void *data[4], GLfloat weight[4], void **outData, void *polygonData)
GLUtesselator *GLAPIENTRY	gluNewTess (void)
static void	MakeDormant (GLUtesselator *tess)
static void	GotoState (GLUtesselator *tess, enum TessState newState)
void GLAPIENTRY	gluDeleteTess (GLUtesselator *tess)
void GLAPIENTRY	gluTessProperty (GLUtesselator *tess, GLenum which, GLdouble value)
void GLAPIENTRY	gluGetTessProperty (GLUtesselator *tess, GLenum which, GLdouble *value)
void GLAPIENTRY	gluTessNormal (GLUtesselator *tess, GLdouble x, GLdouble y, GLdouble z)
void GLAPIENTRY	gluTessCallback (GLUtesselator *tess, GLenum which, _GLUfuncptr fn)
static int	AddVertex (GLUtesselator *tess, GLdouble coords[3], void *data)
static void	CacheVertex (GLUtesselator *tess, GLdouble coords[3], void *data)
static int	EmptyCache (GLUtesselator *tess)
void GLAPIENTRY	gluTessVertex (GLUtesselator *tess, GLdouble coords[3], void *data)
void GLAPIENTRY	gluTessBeginPolygon (GLUtesselator *tess, void *data)
void GLAPIENTRY	gluTessBeginContour (GLUtesselator *tess)
void GLAPIENTRY	gluTessEndContour (GLUtesselator *tess)
void GLAPIENTRY	gluTessEndPolygon (GLUtesselator *tess)
void GLAPIENTRY	gluBeginPolygon (GLUtesselator *tess)
void GLAPIENTRY	gluNextContour (GLUtesselator *tess, GLenum type)
void GLAPIENTRY	gluEndPolygon (GLUtesselator *tess)

---

Class Documentation

EdgePair

struct EdgePair

Collaboration diagram for EdgePair:

Class Members
GLUhalfEdge	e
GLUhalfEdge	eSym

Macro Definition Documentation

FALSE

#define FALSE   0

GLU_TESS_DEFAULT_TOLERANCE

#define GLU_TESS_DEFAULT_TOLERANCE   0.0

GLU_TESS_MESH

#define GLU_TESS_MESH   100112 /* void (*)(GLUmesh *mesh) */

MAX

#define MAX	(		a,
			b
	)		((a) > (b) ? (a) : (b))

MAX_FAST_ALLOC

#define MAX_FAST_ALLOC

Value:

                         (MAX(sizeof(EdgePair), \
                         MAX(sizeof(GLUvertex),sizeof(GLUface))))

RequireState

#define RequireState	(		tess,
			s
	)		if( tess->state != s ) GotoState(tess,s)

TRUE

#define TRUE   1

Function Documentation

__gl_noBeginData()

void GLAPIENTRY __gl_noBeginData	(	GLenum	type,
		void *	polygonData
	)

                                   {}

Referenced by gluNewTess(), gluTessCallback(), and gluTessEndPolygon().

Here is the caller graph for this function:

__gl_noCombineData()

void GLAPIENTRY __gl_noCombineData	(	GLdouble	coords[3],
		void *	data[4],
		GLfloat	weight[4],
		void **	outData,
		void *	polygonData
	)

                                     {}

Referenced by gluNewTess(), and gluTessCallback().

Here is the caller graph for this function:

__gl_noEdgeFlagData()

void GLAPIENTRY __gl_noEdgeFlagData	(	GLboolean	boundaryEdge,
		void *	polygonData
	)

                                   {}

Referenced by gluNewTess(), gluTessCallback(), and gluTessEndPolygon().

Here is the caller graph for this function:

__gl_noEndData()

void GLAPIENTRY __gl_noEndData

(

void *

polygonData

)

{}

Referenced by gluNewTess(), gluTessCallback(), and gluTessEndPolygon().

Here is the caller graph for this function:

__gl_noErrorData()

void GLAPIENTRY __gl_noErrorData	(	GLenum	errnum,
		void *	polygonData
	)

                                   {}

Referenced by gluNewTess(), and gluTessCallback().

Here is the caller graph for this function:

__gl_noVertexData()

void GLAPIENTRY __gl_noVertexData	(	void *	data,
		void *	polygonData
	)

                                    {}

Referenced by gluNewTess(), gluTessCallback(), and gluTessEndPolygon().

Here is the caller graph for this function:

AddVertex()

static int AddVertex ( GLUtesselator *  tess, GLdouble  coords[3], void *  data  )

static

{
  GLUhalfEdge *e;
 
  e = tess->lastEdge;
  if( e == NULL ) {
    /* Make a self-loop (one vertex, one edge). */
 
    e = __gl_meshMakeEdge( tess->mesh );
    if (e == NULL) return 0;
    if ( !__gl_meshSplice( e, e->Sym ) ) return 0;
  } else {
    /* Create a new vertex and edge which immediately follow e
     * in the ordering around the left face.
     */
    if (__gl_meshSplitEdge( e ) == NULL) return 0;
    e = e->Lnext;
  }
 
  /* The new vertex is now e->Org. */
  e->Org->data = data;
  e->Org->coords[0] = coords[0];
  e->Org->coords[1] = coords[1];
  e->Org->coords[2] = coords[2];
 
  /* The winding of an edge says how the winding number changes as we
   * cross from the edge''s right face to its left face.  We add the
   * vertices in such an order that a CCW contour will add +1 to
   * the winding number of the region inside the contour.
   */
  e->winding = 1;
  e->Sym->winding = -1;
 
  tess->lastEdge = e;
 
  return 1;
}

References __gl_meshMakeEdge(), __gl_meshSplice(), __gl_meshSplitEdge(), GLUvertex::coords, GLUvertex::data, GLUtesselator::lastEdge, GLUhalfEdge::Lnext, GLUtesselator::mesh, GLUhalfEdge::Org, GLUhalfEdge::Sym, and GLUhalfEdge::winding.

Referenced by EmptyCache(), and gluTessVertex().

Here is the call graph for this function:

Here is the caller graph for this function:

CacheVertex()

static void CacheVertex ( GLUtesselator *  tess, GLdouble  coords[3], void *  data  )

static

{
  CachedVertex *v = &tess->cache[tess->cacheCount];
 
  v->data = data;
  v->coords[0] = coords[0];
  v->coords[1] = coords[1];
  v->coords[2] = coords[2];
  ++tess->cacheCount;
}

References GLUtesselator::cache, GLUtesselator::cacheCount, CachedVertex::coords, and CachedVertex::data.

Referenced by gluTessVertex().

Here is the caller graph for this function:

EmptyCache()

static int EmptyCache ( GLUtesselator *  tess )

static

{
  CachedVertex *v = tess->cache;
  CachedVertex *vLast;
 
  tess->mesh = __gl_meshNewMesh();
  if (tess->mesh == NULL) return 0;
 
  for( vLast = v + tess->cacheCount; v < vLast; ++v ) {
    if ( !AddVertex( tess, v->coords, v->data ) ) return 0;
  }
  tess->cacheCount = 0;
  tess->emptyCache = FALSE;
 
  return 1;
}

References __gl_meshNewMesh(), AddVertex(), GLUtesselator::cache, GLUtesselator::cacheCount, CachedVertex::coords, CachedVertex::data, GLUtesselator::emptyCache, FALSE, and GLUtesselator::mesh.

Referenced by gluTessEndPolygon(), and gluTessVertex().

Here is the call graph for this function:

Here is the caller graph for this function:

gluBeginPolygon()

void GLAPIENTRY gluBeginPolygon

(

GLUtesselator *

tess

)

{
  gluTessBeginPolygon( tess, NULL );
  gluTessBeginContour( tess );
}

References gluTessBeginContour, and gluTessBeginPolygon.

gluDeleteTess()

void GLAPIENTRY gluDeleteTess

(

GLUtesselator *

tess

)

{
  RequireState( tess, T_DORMANT );
  memFree( tess );
}

References memFree, RequireState, and T_DORMANT.

gluEndPolygon()

void GLAPIENTRY gluEndPolygon

(

GLUtesselator *

tess

)

{
  gluTessEndContour( tess );
  gluTessEndPolygon( tess );
}

References gluTessEndContour, and gluTessEndPolygon.

gluGetTessProperty()

void GLAPIENTRY gluGetTessProperty	(	GLUtesselator *	tess,
		GLenum	which,
		GLdouble *	value
	)

{
   switch (which) {
   case GLU_TESS_TOLERANCE:
      /* tolerance should be in range [0..1] */
      assert(0.0 <= tess->relTolerance && tess->relTolerance <= 1.0);
      *value= tess->relTolerance;
      break;
   case GLU_TESS_WINDING_RULE:
      assert(tess->windingRule == GLU_TESS_WINDING_ODD ||
       tess->windingRule == GLU_TESS_WINDING_NONZERO ||
       tess->windingRule == GLU_TESS_WINDING_POSITIVE ||
       tess->windingRule == GLU_TESS_WINDING_NEGATIVE ||
       tess->windingRule == GLU_TESS_WINDING_ABS_GEQ_TWO);
      *value= tess->windingRule;
      break;
   case GLU_TESS_BOUNDARY_ONLY:
      assert(tess->boundaryOnly == TRUE || tess->boundaryOnly == FALSE);
      *value= tess->boundaryOnly;
      break;
   default:
      *value= 0.0;
      CALL_ERROR_OR_ERROR_DATA( GLU_INVALID_ENUM );
      break;
   }
} /* gluGetTessProperty() */

References GLUtesselator::boundaryOnly, CALL_ERROR_OR_ERROR_DATA, FALSE, GLU_INVALID_ENUM, GLU_TESS_BOUNDARY_ONLY, GLU_TESS_TOLERANCE, GLU_TESS_WINDING_ABS_GEQ_TWO, GLU_TESS_WINDING_NEGATIVE, GLU_TESS_WINDING_NONZERO, GLU_TESS_WINDING_ODD, GLU_TESS_WINDING_POSITIVE, GLU_TESS_WINDING_RULE, GLUtesselator::relTolerance, TRUE, and GLUtesselator::windingRule.

gluNewTess()

GLUtesselator *GLAPIENTRY gluNewTess

(

void

)

{
  GLUtesselator *tess;
 
  /* Only initialize fields which can be changed by the api.  Other fields
   * are initialized where they are used.
   */
 
  if (memInit( MAX_FAST_ALLOC ) == 0) {
     return 0;      /* out of memory */
  }
  tess = (GLUtesselator *)memAlloc( sizeof( GLUtesselator ));
  if (tess == NULL) {
     return 0;      /* out of memory */
  }
 
  tess->state = T_DORMANT;
 
  tess->normal[0] = 0;
  tess->normal[1] = 0;
  tess->normal[2] = 0;
 
  tess->relTolerance = GLU_TESS_DEFAULT_TOLERANCE;
  tess->windingRule = GLU_TESS_WINDING_ODD;
  tess->flagBoundary = FALSE;
  tess->boundaryOnly = FALSE;
 
  tess->callBegin = &noBegin;
  tess->callEdgeFlag = &noEdgeFlag;
  tess->callVertex = &noVertex;
  tess->callEnd = &noEnd;
 
  tess->callError = &noError;
  tess->callCombine = &noCombine;
  tess->callMesh = &noMesh;
 
  tess->callBeginData= &__gl_noBeginData;
  tess->callEdgeFlagData= &__gl_noEdgeFlagData;
  tess->callVertexData= &__gl_noVertexData;
  tess->callEndData= &__gl_noEndData;
  tess->callErrorData= &__gl_noErrorData;
  tess->callCombineData= &__gl_noCombineData;
 
  tess->polygonData= NULL;
 
  return tess;
}

References __gl_noBeginData(), __gl_noCombineData(), __gl_noEdgeFlagData(), __gl_noEndData(), __gl_noErrorData(), __gl_noVertexData(), GLUtesselator::boundaryOnly, FALSE, GLUtesselator::flagBoundary, GLU_TESS_DEFAULT_TOLERANCE, GLU_TESS_WINDING_ODD, MAX_FAST_ALLOC, memAlloc, memInit, noBegin(), noCombine(), noEdgeFlag(), noEnd(), noError(), noMesh(), GLUtesselator::normal, noVertex(), GLUtesselator::polygonData, GLUtesselator::relTolerance, GLUtesselator::state, T_DORMANT, and GLUtesselator::windingRule.

Here is the call graph for this function:

gluNextContour()

void GLAPIENTRY gluNextContour	(	GLUtesselator *	tess,
		GLenum	type
	)

{
  gluTessEndContour( tess );
  gluTessBeginContour( tess );
}

References gluTessBeginContour, and gluTessEndContour.

gluTessBeginContour()

void GLAPIENTRY gluTessBeginContour

(

GLUtesselator *

tess

)

{
  RequireState( tess, T_IN_POLYGON );
 
  tess->state = T_IN_CONTOUR;
  tess->lastEdge = NULL;
  if( tess->cacheCount > 0 ) {
    /* Just set a flag so we don't get confused by empty contours
     * -- these can be generated accidentally with the obsolete
     * NextContour() interface.
     */
    tess->emptyCache = TRUE;
  }
}

References GLUtesselator::cacheCount, GLUtesselator::emptyCache, GLUtesselator::lastEdge, RequireState, GLUtesselator::state, T_IN_CONTOUR, T_IN_POLYGON, and TRUE.

gluTessBeginPolygon()

void GLAPIENTRY gluTessBeginPolygon	(	GLUtesselator *	tess,
		void *	data
	)

{
  RequireState( tess, T_DORMANT );
 
  tess->state = T_IN_POLYGON;
  tess->cacheCount = 0;
  tess->emptyCache = FALSE;
  tess->mesh = NULL;
 
  tess->polygonData= data;
}

References GLUtesselator::cacheCount, GLUtesselator::emptyCache, FALSE, GLUtesselator::mesh, GLUtesselator::polygonData, RequireState, GLUtesselator::state, T_DORMANT, and T_IN_POLYGON.

gluTessCallback()

void GLAPIENTRY gluTessCallback	(	GLUtesselator *	tess,
		GLenum	which,
		_GLUfuncptr	fn
	)

{
  switch( which ) {
  case GLU_TESS_BEGIN:
    tess->callBegin = (fn == NULL) ? &noBegin : (void (GLAPIENTRY *)(GLenum)) fn;
    return;
  case GLU_TESS_BEGIN_DATA:
    tess->callBeginData = (fn == NULL) ?
  &__gl_noBeginData : (void (GLAPIENTRY *)(GLenum, void *)) fn;
    return;
  case GLU_TESS_EDGE_FLAG:
    tess->callEdgeFlag = (fn == NULL) ? &noEdgeFlag :
          (void (GLAPIENTRY *)(GLboolean)) fn;
    /* If the client wants boundary edges to be flagged,
     * we render everything as separate triangles (no strips or fans).
     */
    tess->flagBoundary = (fn != NULL);
    return;
  case GLU_TESS_EDGE_FLAG_DATA:
    tess->callEdgeFlagData= (fn == NULL) ?
  &__gl_noEdgeFlagData : (void (GLAPIENTRY *)(GLboolean, void *)) fn;
    /* If the client wants boundary edges to be flagged,
     * we render everything as separate triangles (no strips or fans).
     */
    tess->flagBoundary = (fn != NULL);
    return;
  case GLU_TESS_VERTEX:
    tess->callVertex = (fn == NULL) ? &noVertex :
              (void (GLAPIENTRY *)(void *)) fn;
    return;
  case GLU_TESS_VERTEX_DATA:
    tess->callVertexData = (fn == NULL) ?
  &__gl_noVertexData : (void (GLAPIENTRY *)(void *, void *)) fn;
    return;
  case GLU_TESS_END:
    tess->callEnd = (fn == NULL) ? &noEnd : (void (GLAPIENTRY *)(void)) fn;
    return;
  case GLU_TESS_END_DATA:
    tess->callEndData = (fn == NULL) ? &__gl_noEndData :
               (void (GLAPIENTRY *)(void *)) fn;
    return;
  case GLU_TESS_ERROR:
    tess->callError = (fn == NULL) ? &noError : (void (GLAPIENTRY *)(GLenum)) fn;
    return;
  case GLU_TESS_ERROR_DATA:
    tess->callErrorData = (fn == NULL) ?
  &__gl_noErrorData : (void (GLAPIENTRY *)(GLenum, void *)) fn;
    return;
  case GLU_TESS_COMBINE:
    tess->callCombine = (fn == NULL) ? &noCombine :
  (void (GLAPIENTRY *)(GLdouble [3],void *[4], GLfloat [4], void ** )) fn;
    return;
  case GLU_TESS_COMBINE_DATA:
    tess->callCombineData = (fn == NULL) ? &__gl_noCombineData :
             (void (GLAPIENTRY *)(GLdouble [3],
                 void *[4],
                 GLfloat [4],
                 void **,
                 void *)) fn;
    return;
  case GLU_TESS_MESH:
    tess->callMesh = (fn == NULL) ? &noMesh : (void (GLAPIENTRY *)(GLUmesh *)) fn;
    return;
  default:
    CALL_ERROR_OR_ERROR_DATA( GLU_INVALID_ENUM );
    return;
  }
}

References __gl_noBeginData(), __gl_noCombineData(), __gl_noEdgeFlagData(), __gl_noEndData(), __gl_noErrorData(), __gl_noVertexData(), CALL_ERROR_OR_ERROR_DATA, GLUtesselator::flagBoundary, GLAPIENTRY, GLU_INVALID_ENUM, GLU_TESS_BEGIN, GLU_TESS_BEGIN_DATA, GLU_TESS_COMBINE, GLU_TESS_COMBINE_DATA, GLU_TESS_EDGE_FLAG, GLU_TESS_EDGE_FLAG_DATA, GLU_TESS_END, GLU_TESS_END_DATA, GLU_TESS_ERROR, GLU_TESS_ERROR_DATA, GLU_TESS_MESH, GLU_TESS_VERTEX, GLU_TESS_VERTEX_DATA, noBegin(), noCombine(), noEdgeFlag(), noEnd(), noError(), noMesh(), noVertex(), and void().

Here is the call graph for this function:

gluTessEndContour()

void GLAPIENTRY gluTessEndContour

(

GLUtesselator *

tess

)

{
  RequireState( tess, T_IN_CONTOUR );
  tess->state = T_IN_POLYGON;
}

References RequireState, GLUtesselator::state, T_IN_CONTOUR, and T_IN_POLYGON.

gluTessEndPolygon()

void GLAPIENTRY gluTessEndPolygon

(

GLUtesselator *

tess

)

{
  GLUmesh *mesh;
 
  if (setjmp(tess->env) != 0) { 
     /* come back here if out of memory */
     CALL_ERROR_OR_ERROR_DATA( GLU_OUT_OF_MEMORY );
     return;
  }
 
  RequireState( tess, T_IN_POLYGON );
  tess->state = T_DORMANT;
 
  if( tess->mesh == NULL ) {
    if( ! tess->flagBoundary && tess->callMesh == &noMesh ) {
 
      /* Try some special code to make the easy cases go quickly
       * (eg. convex polygons).  This code does NOT handle multiple contours,
       * intersections, edge flags, and of course it does not generate
       * an explicit mesh either.
       */
      if( __gl_renderCache( tess )) {
  tess->polygonData= NULL;
  return;
      }
    }
    if ( !EmptyCache( tess ) ) longjmp(tess->env,1); /* could've used a label*/
  }
 
  /* Determine the polygon normal and project vertices onto the plane
   * of the polygon.
   */
  __gl_projectPolygon( tess );
 
  /* __gl_computeInterior( tess ) computes the planar arrangement specified
   * by the given contours, and further subdivides this arrangement
   * into regions.  Each region is marked "inside" if it belongs
   * to the polygon, according to the rule given by tess->windingRule.
   * Each interior region is guaranteed be monotone.
   */
  if ( !__gl_computeInterior( tess ) ) {
     longjmp(tess->env,1);  /* could've used a label */
  }
 
  mesh = tess->mesh;
  if( ! tess->fatalError ) {
    int rc = 1;
 
    /* If the user wants only the boundary contours, we throw away all edges
     * except those which separate the interior from the exterior.
     * Otherwise we tessellate all the regions marked "inside".
     */
    if( tess->boundaryOnly ) {
      rc = __gl_meshSetWindingNumber( mesh, 1, TRUE );
    } else {
      rc = __gl_meshTessellateInterior( mesh );
    }
    if (rc == 0) longjmp(tess->env,1);  /* could've used a label */
 
    __gl_meshCheckMesh( mesh );
 
    if( tess->callBegin != &noBegin || tess->callEnd != &noEnd
       || tess->callVertex != &noVertex || tess->callEdgeFlag != &noEdgeFlag
       || tess->callBeginData != &__gl_noBeginData
       || tess->callEndData != &__gl_noEndData
       || tess->callVertexData != &__gl_noVertexData
       || tess->callEdgeFlagData != &__gl_noEdgeFlagData )
    {
      if( tess->boundaryOnly ) {
  __gl_renderBoundary( tess, mesh );  /* output boundary contours */
      } else {
  __gl_renderMesh( tess, mesh );     /* output strips and fans */
      }
    }
    if( tess->callMesh != &noMesh ) {
 
      /* Throw away the exterior faces, so that all faces are interior.
       * This way the user doesn't have to check the "inside" flag,
       * and we don't need to even reveal its existence.  It also leaves
       * the freedom for an implementation to not generate the exterior
       * faces in the first place.
       */
      __gl_meshDiscardExterior( mesh );
      (*tess->callMesh)( mesh );    /* user wants the mesh itself */
      tess->mesh = NULL;
      tess->polygonData= NULL;
      return;
    }
  }
  __gl_meshDeleteMesh( mesh );
  tess->polygonData= NULL;
  tess->mesh = NULL;
}

References __gl_computeInterior(), __gl_meshCheckMesh(), __gl_meshDeleteMesh(), __gl_meshDiscardExterior(), __gl_meshSetWindingNumber(), __gl_meshTessellateInterior(), __gl_noBeginData(), __gl_noEdgeFlagData(), __gl_noEndData(), __gl_noVertexData(), __gl_projectPolygon(), __gl_renderBoundary(), __gl_renderCache(), __gl_renderMesh(), GLUtesselator::boundaryOnly, CALL_ERROR_OR_ERROR_DATA, EmptyCache(), GLUtesselator::env, GLUtesselator::fatalError, GLUtesselator::flagBoundary, GLU_OUT_OF_MEMORY, GLUtesselator::mesh, noBegin(), noEdgeFlag(), noEnd(), noMesh(), noVertex(), GLUtesselator::polygonData, RequireState, GLUtesselator::state, T_DORMANT, T_IN_POLYGON, and TRUE.

Here is the call graph for this function:

gluTessNormal()

void GLAPIENTRY gluTessNormal	(	GLUtesselator *	tess,
		GLdouble	x,
		GLdouble	y,
		GLdouble	z
	)

{
  tess->normal[0] = x;
  tess->normal[1] = y;
  tess->normal[2] = z;
}

References GLUtesselator::normal.

gluTessProperty()

void GLAPIENTRY gluTessProperty	(	GLUtesselator *	tess,
		GLenum	which,
		GLdouble	value
	)

{
  GLenum windingRule;
 
  switch( which ) {
  case GLU_TESS_TOLERANCE:
    if( value < 0.0 || value > 1.0 ) break;
    tess->relTolerance = value;
    return;
 
  case GLU_TESS_WINDING_RULE:
    windingRule = (GLenum) value;
    if( windingRule != value ) break; /* not an integer */
 
    switch( windingRule ) {
    case GLU_TESS_WINDING_ODD:
    case GLU_TESS_WINDING_NONZERO:
    case GLU_TESS_WINDING_POSITIVE:
    case GLU_TESS_WINDING_NEGATIVE:
    case GLU_TESS_WINDING_ABS_GEQ_TWO:
      tess->windingRule = windingRule;
      return;
    default:
      break;
    }
 
  case GLU_TESS_BOUNDARY_ONLY:
    tess->boundaryOnly = (value != 0);
    return;
 
  default:
    CALL_ERROR_OR_ERROR_DATA( GLU_INVALID_ENUM );
    return;
  }
  CALL_ERROR_OR_ERROR_DATA( GLU_INVALID_VALUE );
}

References GLUtesselator::boundaryOnly, CALL_ERROR_OR_ERROR_DATA, GLU_INVALID_ENUM, GLU_INVALID_VALUE, GLU_TESS_BOUNDARY_ONLY, GLU_TESS_TOLERANCE, GLU_TESS_WINDING_ABS_GEQ_TWO, GLU_TESS_WINDING_NEGATIVE, GLU_TESS_WINDING_NONZERO, GLU_TESS_WINDING_ODD, GLU_TESS_WINDING_POSITIVE, GLU_TESS_WINDING_RULE, GLUtesselator::relTolerance, and GLUtesselator::windingRule.

gluTessVertex()

void GLAPIENTRY gluTessVertex	(	GLUtesselator *	tess,
		GLdouble	coords[3],
		void *	data
	)

{
  int i, tooLarge = FALSE;
  GLdouble x, clamped[3];
 
  RequireState( tess, T_IN_CONTOUR );
 
  if( tess->emptyCache ) {
    if ( !EmptyCache( tess ) ) {
       CALL_ERROR_OR_ERROR_DATA( GLU_OUT_OF_MEMORY );
       return;
    }
    tess->lastEdge = NULL;
  }
  for( i = 0; i < 3; ++i ) {
    x = coords[i];
    if( x < - GLU_TESS_MAX_COORD ) {
      x = - GLU_TESS_MAX_COORD;
      tooLarge = TRUE;
    }
    if( x > GLU_TESS_MAX_COORD ) {
      x = GLU_TESS_MAX_COORD;
      tooLarge = TRUE;
    }
    clamped[i] = x;
  }
  if( tooLarge ) {
    CALL_ERROR_OR_ERROR_DATA( GLU_TESS_COORD_TOO_LARGE );
  }
 
  if( tess->mesh == NULL ) {
    if( tess->cacheCount < TESS_MAX_CACHE ) {
      CacheVertex( tess, clamped, data );
      return;
    }
    if ( !EmptyCache( tess ) ) {
       CALL_ERROR_OR_ERROR_DATA( GLU_OUT_OF_MEMORY );
       return;
    }
  }
  if ( !AddVertex( tess, clamped, data ) ) {
       CALL_ERROR_OR_ERROR_DATA( GLU_OUT_OF_MEMORY );
  }
}

References AddVertex(), GLUtesselator::cacheCount, CacheVertex(), CALL_ERROR_OR_ERROR_DATA, EmptyCache(), GLUtesselator::emptyCache, FALSE, GLU_OUT_OF_MEMORY, GLU_TESS_COORD_TOO_LARGE, GLU_TESS_MAX_COORD, GLUtesselator::lastEdge, GLUtesselator::mesh, RequireState, T_IN_CONTOUR, TESS_MAX_CACHE, and TRUE.

Here is the call graph for this function:

GotoState()

static void GotoState ( GLUtesselator *  tess, enum TessState  newState  )

static

{
  while( tess->state != newState ) {
    /* We change the current state one level at a time, to get to
     * the desired state.
     */
    if( tess->state < newState ) {
      switch( tess->state ) {
      case T_DORMANT:
  CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_BEGIN_POLYGON );
  gluTessBeginPolygon( tess, NULL );
  break;
      case T_IN_POLYGON:
  CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_BEGIN_CONTOUR );
  gluTessBeginContour( tess );
  break;
      default:
   ;
      }
    } else {
      switch( tess->state ) {
      case T_IN_CONTOUR:
  CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_END_CONTOUR );
  gluTessEndContour( tess );
  break;
      case T_IN_POLYGON:
  CALL_ERROR_OR_ERROR_DATA( GLU_TESS_MISSING_END_POLYGON );
  /* gluTessEndPolygon( tess ) is too much work! */
  MakeDormant( tess );
  break;
      default:
   ;
      }
    }
  }
}

References CALL_ERROR_OR_ERROR_DATA, GLU_TESS_MISSING_BEGIN_CONTOUR, GLU_TESS_MISSING_BEGIN_POLYGON, GLU_TESS_MISSING_END_CONTOUR, GLU_TESS_MISSING_END_POLYGON, gluTessBeginContour, gluTessBeginPolygon, gluTessEndContour, MakeDormant(), GLUtesselator::state, T_DORMANT, T_IN_CONTOUR, and T_IN_POLYGON.

Here is the call graph for this function:

MakeDormant()

static void MakeDormant ( GLUtesselator *  tess )

static

{
  /* Return the tessellator to its original dormant state. */
 
  if( tess->mesh != NULL ) {
    __gl_meshDeleteMesh( tess->mesh );
  }
  tess->state = T_DORMANT;
  tess->lastEdge = NULL;
  tess->mesh = NULL;
}

References __gl_meshDeleteMesh(), GLUtesselator::lastEdge, GLUtesselator::mesh, GLUtesselator::state, and T_DORMANT.

Referenced by GotoState().

Here is the call graph for this function:

Here is the caller graph for this function:

noBegin()

static void GLAPIENTRY noBegin ( GLenum  type )

static

{}

Referenced by gluNewTess(), gluTessCallback(), and gluTessEndPolygon().

Here is the caller graph for this function:

noCombine()

static void GLAPIENTRY noCombine ( GLdouble  coords[3], void *  data[4], GLfloat  weight[4], void **  dataOut  )

static

                                                {}

Referenced by gluNewTess(), and gluTessCallback().

Here is the caller graph for this function:

noEdgeFlag()

static void GLAPIENTRY noEdgeFlag ( GLboolean  boundaryEdge )

static

{}

Referenced by gluNewTess(), gluTessCallback(), and gluTessEndPolygon().

Here is the caller graph for this function:

noEnd()

static void GLAPIENTRY noEnd ( void  )

static

{}

Referenced by gluNewTess(), gluTessCallback(), and gluTessEndPolygon().

Here is the caller graph for this function:

noError()

static void GLAPIENTRY noError ( GLenum  errnum )

static

{}

Referenced by gluNewTess(), and gluTessCallback().

Here is the caller graph for this function:

noMesh()

static void GLAPIENTRY noMesh ( GLUmesh *  mesh )

static

{}

Referenced by gluNewTess(), gluTessCallback(), and gluTessEndPolygon().

Here is the caller graph for this function:

noVertex()

static void GLAPIENTRY noVertex ( void *  data )

static

{}

Referenced by gluNewTess(), gluTessCallback(), and gluTessEndPolygon().

Here is the caller graph for this function: