void GLU_APIENTRY gluTessVertex(GLUtesselator* tess, GLfloat coords[3], void* data)
{
int i;
int tooLarge=FALSE;
GLfloat 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);
}
}
/* Returns tessellator property */
void REGALGLU_CALL
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() */
static void CallCombine( GLUtesselator *tess, GLUvertex *isect,
void *data[4], GLfloat weights[4], int needed )
{
GLdouble coords[3];
/* Copy coord data in case the callback changes it. */
coords[0] = isect->coords[0];
coords[1] = isect->coords[1];
coords[2] = isect->coords[2];
isect->data = NULL;
CALL_COMBINE_OR_COMBINE_DATA( coords, data, weights, &isect->data );
if( isect->data == NULL ) {
if( ! needed ) {
isect->data = data[0];
} else if( ! tess->fatalError ) {
/* The only way fatal error is when two edges are found to intersect,
* but the user has not provided the callback necessary to handle
* generated intersection points.
*/
CALL_ERROR_OR_ERROR_DATA( GLU_TESS_NEED_COMBINE_CALLBACK );
tess->fatalError = TRUE;
}
}
}
void REGALWRATH_GLU_CALL
wrath_gluTessVertex( wrath_GLUtesselator *tess, const double coords[3], void *data )
{
int i, tooLarge = FALSE;
double x, clamped[3];
RequireState( tess, T_IN_CONTOUR );
if( tess->emptyCache ) {
if ( !EmptyCache( tess ) ) {
CALL_ERROR_OR_ERROR_DATA( WRATH_GLU_OUT_OF_MEMORY );
return;
}
tess->lastEdge = NULL;
}
for( i = 0; i < 3; ++i ) {
x = coords[i];
if( x < - WRATH_GLU_TESS_MAX_COORD ) {
x = - WRATH_GLU_TESS_MAX_COORD;
tooLarge = TRUE;
}
if( x > WRATH_GLU_TESS_MAX_COORD ) {
x = WRATH_GLU_TESS_MAX_COORD;
tooLarge = TRUE;
}
clamped[i] = x;
}
if( tooLarge ) {
CALL_ERROR_OR_ERROR_DATA( WRATH_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( WRATH_GLU_OUT_OF_MEMORY );
return;
}
}
if ( !AddVertex( tess, clamped, data ) ) {
CALL_ERROR_OR_ERROR_DATA( WRATH_GLU_OUT_OF_MEMORY );
}
}
GLU_API void GLU_APIENTRY gluTessProperty(GLUtesselator* tess, GLenum which, GLfloat value)
{
GLenum windingRule;
switch (which)
{
case GLU_TESS_TOLERANCE:
if (value<0.0f || value>1.0f)
{
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;
}
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);
}
static void GotoState(GLUtesselator* tess, enum TessState newState)
{
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:
break;
}
}
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:
break;
}
}
}
}
void REGALFASTUIDRAW_GLU_CALL
fastuidraw_gluTessVertex( fastuidraw_GLUtesselator *tess, double x, double y, unsigned int data )
{
int tooLarge = FALSE;
RequireState( tess, T_IN_CONTOUR );
if( tess->emptyCache ) {
if ( !EmptyCache( tess ) ) {
CALL_ERROR_OR_ERROR_DATA( FASTUIDRAW_GLU_OUT_OF_MEMORY );
return;
}
tess->lastEdge = NULL;
}
checkTooLarge(&x, &tooLarge);
checkTooLarge(&y, &tooLarge);
if( tooLarge ) {
CALL_ERROR_OR_ERROR_DATA( FASTUIDRAW_GLU_TESS_COORD_TOO_LARGE );
}
if( tess->mesh == NULL ) {
if( tess->cacheCount < TESS_MAX_CACHE ) {
CacheVertex( tess, x, y, data );
return;
}
if ( !EmptyCache( tess ) ) {
CALL_ERROR_OR_ERROR_DATA( FASTUIDRAW_GLU_OUT_OF_MEMORY );
return;
}
}
if ( !AddVertex( tess, x, y, data ) ) {
CALL_ERROR_OR_ERROR_DATA( FASTUIDRAW_GLU_OUT_OF_MEMORY );
}
}
void REGALGLU_CALL
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;
}
void REGALGLU_CALL
gluTessCallback( GLUtesselator *tess, GLenum which, _GLUfuncptr fn)
{
switch( which ) {
case GLU_TESS_BEGIN:
tess->callBegin = (fn == NULL) ? &noBegin : (void (REGALGLU_CALL *)(GLenum)) fn;
return;
case GLU_TESS_BEGIN_DATA:
tess->callBeginData = (fn == NULL) ?
&__gl_noBeginData : (void (REGALGLU_CALL *)(GLenum, void *)) fn;
return;
case GLU_TESS_EDGE_FLAG:
tess->callEdgeFlag = (fn == NULL) ? &noEdgeFlag :
(void (REGALGLU_CALL *)(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 (REGALGLU_CALL *)(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 (REGALGLU_CALL *)(void *)) fn;
return;
case GLU_TESS_VERTEX_DATA:
tess->callVertexData = (fn == NULL) ?
&__gl_noVertexData : (void (REGALGLU_CALL *)(void *, void *)) fn;
return;
case GLU_TESS_END:
tess->callEnd = (fn == NULL) ? &noEnd : (void (REGALGLU_CALL *)(void)) fn;
return;
case GLU_TESS_END_DATA:
tess->callEndData = (fn == NULL) ? &__gl_noEndData :
(void (REGALGLU_CALL *)(void *)) fn;
return;
case GLU_TESS_ERROR:
tess->callError = (fn == NULL) ? &noError : (void (REGALGLU_CALL *)(GLenum)) fn;
return;
case GLU_TESS_ERROR_DATA:
tess->callErrorData = (fn == NULL) ?
&__gl_noErrorData : (void (REGALGLU_CALL *)(GLenum, void *)) fn;
return;
case GLU_TESS_COMBINE:
tess->callCombine = (fn == NULL) ? &noCombine :
(void (REGALGLU_CALL *)(GLdouble [3],void *[4], GLfloat [4], void ** )) fn;
return;
case GLU_TESS_COMBINE_DATA:
tess->callCombineData = (fn == NULL) ? &__gl_noCombineData :
(void (REGALGLU_CALL *)(GLdouble [3],
void *[4],
GLfloat [4],
void **,
void *)) fn;
return;
case GLU_TESS_MESH:
tess->callMesh = (fn == NULL) ? &noMesh : (void (REGALGLU_CALL *)(GLUmesh *)) fn;
return;
default:
CALL_ERROR_OR_ERROR_DATA( GLU_INVALID_ENUM );
return;
}
}
void REGALFASTUIDRAW_GLU_CALL
fastuidraw_gluTessCallback( fastuidraw_GLUtesselator *tess, FASTUIDRAW_GLUenum which, FASTUIDRAW_GLUfuncptr fn)
{
switch( which ) {
case FASTUIDRAW_GLU_TESS_BEGIN:
tess->callBegin = (fn == NULL) ? &noBegin : (void (REGALFASTUIDRAW_GLU_CALL *)(FASTUIDRAW_GLUenum, int)) fn;
return;
case FASTUIDRAW_GLU_TESS_BEGIN_DATA:
tess->callBeginData = (fn == NULL) ?
&glu_fastuidraw_gl_noBeginData : (void (REGALFASTUIDRAW_GLU_CALL *)(FASTUIDRAW_GLUenum, int, void *)) fn;
return;
case FASTUIDRAW_GLU_TESS_VERTEX:
tess->callVertex = (fn == NULL) ? &noVertex :
(void (REGALFASTUIDRAW_GLU_CALL *)(unsigned int)) fn;
return;
case FASTUIDRAW_GLU_TESS_VERTEX_DATA:
tess->callVertexData = (fn == NULL) ?
&glu_fastuidraw_gl_noVertexData : (void (REGALFASTUIDRAW_GLU_CALL *)(unsigned int, void *)) fn;
return;
case FASTUIDRAW_GLU_TESS_END:
tess->callEnd = (fn == NULL) ? &noEnd : (void (REGALFASTUIDRAW_GLU_CALL *)(void)) fn;
return;
case FASTUIDRAW_GLU_TESS_END_DATA:
tess->callEndData = (fn == NULL) ? &glu_fastuidraw_gl_noEndData :
(void (REGALFASTUIDRAW_GLU_CALL *)(void *)) fn;
return;
case FASTUIDRAW_GLU_TESS_ERROR:
tess->callError = (fn == NULL) ? &noError : (void (REGALFASTUIDRAW_GLU_CALL *)(FASTUIDRAW_GLUenum)) fn;
return;
case FASTUIDRAW_GLU_TESS_ERROR_DATA:
tess->callErrorData = (fn == NULL) ?
&glu_fastuidraw_gl_noErrorData : (void (REGALFASTUIDRAW_GLU_CALL *)(FASTUIDRAW_GLUenum, void *)) fn;
return;
case FASTUIDRAW_GLU_TESS_COMBINE:
tess->callCombine = (fn == NULL) ? &noCombine :
(void (REGALFASTUIDRAW_GLU_CALL *)(double , double, unsigned int[4], float [4], unsigned int* )) fn;
return;
case FASTUIDRAW_GLU_TESS_COMBINE_DATA:
tess->callCombineData = (fn == NULL) ? &glu_fastuidraw_gl_noCombineData :
(void (REGALFASTUIDRAW_GLU_CALL *)(double,
double,
unsigned int[4],
float [4],
unsigned int*,
void *)) fn;
return;
case FASTUIDRAW_GLU_TESS_MESH:
tess->callMesh = (fn == NULL) ? &noMesh : (void (REGALFASTUIDRAW_GLU_CALL *)(GLUmesh *)) fn;
return;
case FASTUIDRAW_GLU_TESS_WINDING_CALLBACK:
tess->callWinding=(fn==NULL)? &noWinding: (FASTUIDRAW_GLUboolean (REGALFASTUIDRAW_GLU_CALL *)(int)) fn;
return;
case FASTUIDRAW_GLU_TESS_WINDING_CALLBACK_DATA:
tess->callWindingData=(fn==NULL)? &glu_fastuidraw_gl_noWindingData: (FASTUIDRAW_GLUboolean (REGALFASTUIDRAW_GLU_CALL *)(int, void*)) fn;
return;
default:
CALL_ERROR_OR_ERROR_DATA( FASTUIDRAW_GLU_INVALID_ENUM );
return;
}
}
