glu-libtess.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	USE_MGL_NAMESPACE
#define	gluNewTess   mgluNewTess
#define	gluDeleteTess   mgluDeleteTess
#define	gluTessBeginPolygon   mgluTessBeginPolygon
#define	gluTessBeginContour   mgluTessBeginContour
#define	gluTessVertex   mgluTessVertex
#define	gluTessEndPolygon   mgluTessEndPolygon
#define	gluTessEndContour   mgluTessEndContour
#define	gluTessProperty   mgluTessProperty
#define	gluTessNormal   mgluTessNormal
#define	gluTessCallback   mgluTessCallback
#define	gluGetTessProperty   mgluGetTessProperty
#define	gluBeginPolygon   mgluBeginPolygon
#define	gluNextContour   mgluNextContour
#define	gluEndPolygon   mgluEndPolygon
#define	GLAPI   extern
#define	GLAPIENTRY
#define	GL_TRUE   1
#define	GL_FALSE   0
#define	GL_LINE_LOOP   0x0002
#define	GL_TRIANGLES   0x0004
#define	GL_TRIANGLE_STRIP   0x0005
#define	GL_TRIANGLE_FAN   0x0006
#define	GLAPIENTRYP   GLAPIENTRY *
#define	GLU_VERSION   100800
#define	GLU_EXTENSIONS   100801
#define	GLU_INVALID_ENUM   100900
#define	GLU_INVALID_VALUE   100901
#define	GLU_OUT_OF_MEMORY   100902
#define	GLU_INCOMPATIBLE_GL_VERSION   100903
#define	GLU_INVALID_OPERATION   100904
#define	GLU_TESS_BEGIN   100100
#define	GLU_BEGIN   100100
#define	GLU_TESS_VERTEX   100101
#define	GLU_VERTEX   100101
#define	GLU_TESS_END   100102
#define	GLU_END   100102
#define	GLU_TESS_ERROR   100103
#define	GLU_TESS_EDGE_FLAG   100104
#define	GLU_EDGE_FLAG   100104
#define	GLU_TESS_COMBINE   100105
#define	GLU_TESS_BEGIN_DATA   100106
#define	GLU_TESS_VERTEX_DATA   100107
#define	GLU_TESS_END_DATA   100108
#define	GLU_TESS_ERROR_DATA   100109
#define	GLU_TESS_EDGE_FLAG_DATA   100110
#define	GLU_TESS_COMBINE_DATA   100111
#define	GLU_CW   100120
#define	GLU_CCW   100121
#define	GLU_INTERIOR   100122
#define	GLU_EXTERIOR   100123
#define	GLU_UNKNOWN   100124
#define	GLU_TESS_WINDING_RULE   100140
#define	GLU_TESS_BOUNDARY_ONLY   100141
#define	GLU_TESS_TOLERANCE   100142
#define	GLU_TESS_ERROR1   100151
#define	GLU_TESS_ERROR2   100152
#define	GLU_TESS_ERROR3   100153
#define	GLU_TESS_ERROR4   100154
#define	GLU_TESS_ERROR5   100155
#define	GLU_TESS_ERROR6   100156
#define	GLU_TESS_ERROR7   100157
#define	GLU_TESS_ERROR8   100158
#define	GLU_TESS_MISSING_BEGIN_POLYGON   100151
#define	GLU_TESS_MISSING_BEGIN_CONTOUR   100152
#define	GLU_TESS_MISSING_END_POLYGON   100153
#define	GLU_TESS_MISSING_END_CONTOUR   100154
#define	GLU_TESS_COORD_TOO_LARGE   100155
#define	GLU_TESS_NEED_COMBINE_CALLBACK   100156
#define	GLU_TESS_WINDING_ODD   100130
#define	GLU_TESS_WINDING_NONZERO   100131
#define	GLU_TESS_WINDING_POSITIVE   100132
#define	GLU_TESS_WINDING_NEGATIVE   100133
#define	GLU_TESS_WINDING_ABS_GEQ_TWO   100134
#define	GLU_TESS_MAX_COORD   1.0e150

Typedefs
typedef unsigned int	GLenum
typedef unsigned char	GLboolean
typedef unsigned int	GLbitfield
typedef signed char	GLbyte
typedef short	GLshort
typedef int	GLint
typedef int	GLsizei
typedef unsigned char	GLubyte
typedef unsigned short	GLushort
typedef unsigned int	GLuint
typedef float	GLfloat
typedef float	GLclampf
typedef double	GLdouble
typedef double	GLclampd
typedef void	GLvoid
typedef struct GLUtesselator	GLUtesselator
typedef GLUtesselator	GLUtesselatorObj
typedef GLUtesselator	GLUtriangulatorObj

Functions
typedef	void (GLAPIENTRYP _GLUfuncptr)(void)
GLAPI void GLAPIENTRY	gluBeginPolygon (GLUtesselator *tess)
GLAPI void GLAPIENTRY	gluDeleteTess (GLUtesselator *tess)
GLAPI void GLAPIENTRY	gluEndPolygon (GLUtesselator *tess)
GLAPI void GLAPIENTRY	gluGetTessProperty (GLUtesselator *tess, GLenum which, GLdouble *data)
GLAPI void GLAPIENTRY	gluNextContour (GLUtesselator *tess, GLenum type)
GLAPI void GLAPIENTRY	gluTessBeginContour (GLUtesselator *tess)
GLAPI void GLAPIENTRY	gluTessBeginPolygon (GLUtesselator *tess, GLvoid *data)
GLAPI void GLAPIENTRY	gluTessCallback (GLUtesselator *tess, GLenum which, _GLUfuncptr CallBackFunc)
GLAPI void GLAPIENTRY	gluTessEndContour (GLUtesselator *tess)
GLAPI void GLAPIENTRY	gluTessEndPolygon (GLUtesselator *tess)
GLAPI void GLAPIENTRY	gluTessNormal (GLUtesselator *tess, GLdouble valueX, GLdouble valueY, GLdouble valueZ)
GLAPI void GLAPIENTRY	gluTessProperty (GLUtesselator *tess, GLenum which, GLdouble data)
GLAPI void GLAPIENTRY	gluTessVertex (GLUtesselator *tess, GLdouble *location, GLvoid *data)

Macro Definition Documentation

GL_FALSE

#define GL_FALSE   0

GL_LINE_LOOP

#define GL_LINE_LOOP   0x0002

GL_TRIANGLE_FAN

#define GL_TRIANGLE_FAN   0x0006

GL_TRIANGLE_STRIP

#define GL_TRIANGLE_STRIP   0x0005

GL_TRIANGLES

#define GL_TRIANGLES   0x0004

GL_TRUE

#define GL_TRUE   1

GLAPI

#define GLAPI   extern

GLAPIENTRY

#define GLAPIENTRY

GLAPIENTRYP

#define GLAPIENTRYP   GLAPIENTRY *

GLU_BEGIN

#define GLU_BEGIN   100100

GLU_CCW

#define GLU_CCW   100121

GLU_CW

#define GLU_CW   100120

GLU_EDGE_FLAG

#define GLU_EDGE_FLAG   100104

GLU_END

#define GLU_END   100102

GLU_EXTENSIONS

#define GLU_EXTENSIONS   100801

GLU_EXTERIOR

#define GLU_EXTERIOR   100123

GLU_INCOMPATIBLE_GL_VERSION

#define GLU_INCOMPATIBLE_GL_VERSION   100903

GLU_INTERIOR

#define GLU_INTERIOR   100122

GLU_INVALID_ENUM

#define GLU_INVALID_ENUM   100900

GLU_INVALID_OPERATION

#define GLU_INVALID_OPERATION   100904

GLU_INVALID_VALUE

#define GLU_INVALID_VALUE   100901

GLU_OUT_OF_MEMORY

#define GLU_OUT_OF_MEMORY   100902

GLU_TESS_BEGIN

#define GLU_TESS_BEGIN   100100

GLU_TESS_BEGIN_DATA

#define GLU_TESS_BEGIN_DATA   100106

GLU_TESS_BOUNDARY_ONLY

#define GLU_TESS_BOUNDARY_ONLY   100141

GLU_TESS_COMBINE

#define GLU_TESS_COMBINE   100105

GLU_TESS_COMBINE_DATA

#define GLU_TESS_COMBINE_DATA   100111

GLU_TESS_COORD_TOO_LARGE

#define GLU_TESS_COORD_TOO_LARGE   100155

GLU_TESS_EDGE_FLAG

#define GLU_TESS_EDGE_FLAG   100104

GLU_TESS_EDGE_FLAG_DATA

#define GLU_TESS_EDGE_FLAG_DATA   100110

GLU_TESS_END

#define GLU_TESS_END   100102

GLU_TESS_END_DATA

#define GLU_TESS_END_DATA   100108

GLU_TESS_ERROR

#define GLU_TESS_ERROR   100103

GLU_TESS_ERROR1

#define GLU_TESS_ERROR1   100151

GLU_TESS_ERROR2

#define GLU_TESS_ERROR2   100152

GLU_TESS_ERROR3

#define GLU_TESS_ERROR3   100153

GLU_TESS_ERROR4

#define GLU_TESS_ERROR4   100154

GLU_TESS_ERROR5

#define GLU_TESS_ERROR5   100155

GLU_TESS_ERROR6

#define GLU_TESS_ERROR6   100156

GLU_TESS_ERROR7

#define GLU_TESS_ERROR7   100157

GLU_TESS_ERROR8

#define GLU_TESS_ERROR8   100158

GLU_TESS_ERROR_DATA

#define GLU_TESS_ERROR_DATA   100109

GLU_TESS_MAX_COORD

#define GLU_TESS_MAX_COORD   1.0e150

GLU_TESS_MISSING_BEGIN_CONTOUR

#define GLU_TESS_MISSING_BEGIN_CONTOUR   100152

GLU_TESS_MISSING_BEGIN_POLYGON

#define GLU_TESS_MISSING_BEGIN_POLYGON   100151

GLU_TESS_MISSING_END_CONTOUR

#define GLU_TESS_MISSING_END_CONTOUR   100154

GLU_TESS_MISSING_END_POLYGON

#define GLU_TESS_MISSING_END_POLYGON   100153

GLU_TESS_NEED_COMBINE_CALLBACK

#define GLU_TESS_NEED_COMBINE_CALLBACK   100156

GLU_TESS_TOLERANCE

#define GLU_TESS_TOLERANCE   100142

GLU_TESS_VERTEX

#define GLU_TESS_VERTEX   100101

GLU_TESS_VERTEX_DATA

#define GLU_TESS_VERTEX_DATA   100107

GLU_TESS_WINDING_ABS_GEQ_TWO

#define GLU_TESS_WINDING_ABS_GEQ_TWO   100134

GLU_TESS_WINDING_NEGATIVE

#define GLU_TESS_WINDING_NEGATIVE   100133

GLU_TESS_WINDING_NONZERO

#define GLU_TESS_WINDING_NONZERO   100131

GLU_TESS_WINDING_ODD

#define GLU_TESS_WINDING_ODD   100130

GLU_TESS_WINDING_POSITIVE

#define GLU_TESS_WINDING_POSITIVE   100132

GLU_TESS_WINDING_RULE

#define GLU_TESS_WINDING_RULE   100140

GLU_UNKNOWN

#define GLU_UNKNOWN   100124

GLU_VERSION

#define GLU_VERSION   100800

GLU_VERTEX

#define GLU_VERTEX   100101

gluBeginPolygon

#define gluBeginPolygon   mgluBeginPolygon

gluDeleteTess

#define gluDeleteTess   mgluDeleteTess

gluEndPolygon

#define gluEndPolygon   mgluEndPolygon

gluGetTessProperty

#define gluGetTessProperty   mgluGetTessProperty

gluNewTess

GLAPI GLUtesselator *GLAPIENTRY gluNewTess   mgluNewTess

gluNextContour

#define gluNextContour   mgluNextContour

gluTessBeginContour

#define gluTessBeginContour   mgluTessBeginContour

gluTessBeginPolygon

#define gluTessBeginPolygon   mgluTessBeginPolygon

gluTessCallback

#define gluTessCallback   mgluTessCallback

gluTessEndContour

#define gluTessEndContour   mgluTessEndContour

gluTessEndPolygon

#define gluTessEndPolygon   mgluTessEndPolygon

gluTessNormal

#define gluTessNormal   mgluTessNormal

gluTessProperty

#define gluTessProperty   mgluTessProperty

gluTessVertex

#define gluTessVertex   mgluTessVertex

USE_MGL_NAMESPACE

#define USE_MGL_NAMESPACE

Typedef Documentation

GLbitfield

typedef unsigned int GLbitfield

GLboolean

typedef unsigned char GLboolean

GLbyte

typedef signed char GLbyte

GLclampd

typedef double GLclampd

GLclampf

typedef float GLclampf

GLdouble

typedef double GLdouble

GLenum

typedef unsigned int GLenum

GLfloat

typedef float GLfloat

GLint

typedef int GLint

GLshort

typedef short GLshort

GLsizei

typedef int GLsizei

GLubyte

typedef unsigned char GLubyte

GLuint

typedef unsigned int GLuint

GLushort

typedef unsigned short GLushort

GLUtesselator

typedef struct GLUtesselator GLUtesselator

GLUtesselatorObj

typedef GLUtesselator GLUtesselatorObj

GLUtriangulatorObj

typedef GLUtesselator GLUtriangulatorObj

GLvoid

typedef void GLvoid

Function Documentation

gluBeginPolygon()

GLAPI void GLAPIENTRY gluBeginPolygon

(

GLUtesselator *

tess

)

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

References gluTessBeginContour, and gluTessBeginPolygon.

gluDeleteTess()

GLAPI void GLAPIENTRY gluDeleteTess

(

GLUtesselator *

tess

)

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

References memFree, RequireState, and T_DORMANT.

gluEndPolygon()

GLAPI void GLAPIENTRY gluEndPolygon

(

GLUtesselator *

tess

)

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

References gluTessEndContour, and gluTessEndPolygon.

gluGetTessProperty()

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

{
   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.

gluNextContour()

GLAPI void GLAPIENTRY gluNextContour	(	GLUtesselator *	tess,
		GLenum	type
	)

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

References gluTessBeginContour, and gluTessEndContour.

gluTessBeginContour()

GLAPI 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()

GLAPI void GLAPIENTRY gluTessBeginPolygon	(	GLUtesselator *	tess,
		GLvoid *	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()

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

{
  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()

GLAPI 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()

GLAPI 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()

GLAPI void GLAPIENTRY gluTessNormal	(	GLUtesselator *	tess,
		GLdouble	valueX,
		GLdouble	valueY,
		GLdouble	valueZ
	)

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

References GLUtesselator::normal.

gluTessProperty()

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

{
  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()

GLAPI void GLAPIENTRY gluTessVertex	(	GLUtesselator *	tess,
		GLdouble *	location,
		GLvoid *	data
	)

void()

typedef void

(

GLAPIENTRYP

_GLUfuncptr

)

Referenced by Slic3r::GUI::FileArchiveDialog::FileArchiveDialog(), Slic3r::GUI::GalleryDialog::GalleryDialog(), Slic3r::Geometry::MedialAxis::MedialAxis(), igl::copyleft::cgal::SelfIntersectMesh< Kernel, DerivedV, DerivedF, DerivedVV, DerivedFF, DerivedIF, DerivedJ, DerivedIM >::SelfIntersectMesh(), Slic3r::GUI::Sidebar::Sidebar(), Slic3r::GCode::_do_export(), Slic3r::sla::DefaultSupportTree::add_pinheads(), arduino_read_sig_bytes(), avr_tpi_poll_nvmbsy(), avrdude_message_handler_null(), avrdude_progress_handler_null(), Slic3r::GUI::MainFrame::bind_diff_dialog(), igl::bounding_box(), CheckForIntersect(), Slic3r::sla::anonymous_namespace{Clustering.cpp}::cluster(), ConnectRightVertex(), igl::xml::serialization_xml::deserialize(), igl::dfs(), Slic3r::sla::DefaultSupportTree::execute(), igl::fast_winding_number(), Slic3r::FillLightning::Layer::fillLocator(), igl::forward_kinematics(), Slic3r::GUI::generate_system_info_json(), Slic3r::PresetUpdater::priv::get_file(), Slic3r::getExtrusionPathsFromEntity(), gluTessCallback(), igl::grid_search(), Slic3r::has_polygons_nothing_inside(), Slic3r::Http::priv::http_perform(), Slic3r::PrintConfigDef::init_fff_params(), jtag3_disable(), jtagmkI_disable(), jtagmkII_disable(), jtagmkII_getsync(), jtagmkII_initialize(), jtagmkII_program_disable(), jtagmkII_program_enable(), jtagmkII_reset(), Slic3r::GUI::ConfigWizard::priv::load_pages(), Slic3r::Bonjour::priv::lookup_perform(), miniz_def_alloc_func(), miniz_def_free_func(), miniz_def_realloc_func(), mz_deflateBound(), mz_zip_add_mem_to_archive_file_in_place_v2(), mz_zip_compute_crc32_callback(), mz_zip_file_write_callback(), mz_zip_reader_init_internal(), mz_zip_reader_is_file_a_directory(), mz_zip_writer_create_central_dir_header(), mz_zip_writer_create_local_dir_header(), mz_zip_writer_init_from_reader_v2(), igl::nchoosek(), igl::octree(), Slic3r::GUI::FileArchiveDialog::on_all_button(), Slic3r::GUI::FileArchiveDialog::on_none_button(), Slic3r::GUI::FileArchiveDialog::on_open_button(), Slic3r::BonjourDialog::on_reply(), Slic3r::GUI::GLGizmoSimplify::process(), igl::qslim(), igl::ramer_douglas_peucker(), Slic3r::GUI::GLCanvas3D::render(), Slic3r::GUI::GCodeViewer::render_legend(), Slic3r::Bonjour::priv::resolve_perform(), Slic3r::GUI::PageMaterials::select_all(), serbb_close(), igl::copyleft::cgal::SelfIntersectMesh< Kernel, DerivedV, DerivedF, DerivedVV, DerivedFF, DerivedIF, DerivedJ, DerivedIM >::single_shared_vertex(), igl::sort2(), igl::sort3(), Slic3r::Interrupter::start(), stk500_close(), Slic3r::GUI::Tab::tree_sel_change_delayed(), Slic3r::GUI::PageMaterials::update_lists(), and WalkDirtyRegions().