render File Reference

#include "mesh"
#include "_tess"

Include dependency graph for render:

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

Go to the source code of this file.

Classes
struct	FaceCount
	inlined C code : /////////////////////////////////// More...

Macros
#define	tools_glutess_render
#define	Marked(f)   (! (f)->inside || (f)->marked)
#define	AddToTrail(f, t)   ((f)->trail = (t), (t) = (f), (f)->marked = TOOLS_GLU_TRUE)
#define	FreeTrail(t)   do { while( (t) != NULL ) { (t)->marked = TOOLS_GLU_FALSE; t = (t)->trail; } } while(false)
#define	IsEven(n)   (((n) & 1) == 0)

Functions
inline struct FaceCount	static_MaximumFan (GLUhalfEdge *eOrig)
inline struct FaceCount	static_MaximumStrip (GLUhalfEdge *eOrig)
inline void	static_RenderFan (GLUtesselator *tess, GLUhalfEdge *eStart, long size)
inline void	static_RenderStrip (GLUtesselator *tess, GLUhalfEdge *eStart, long size)
inline void	static_RenderTriangle (GLUtesselator *tess, GLUhalfEdge *eStart, long size)
inline void	static_RenderMaximumFaceGroup (GLUtesselator *tess, GLUface *fOrig)
inline void	static_RenderLonelyTriangles (GLUtesselator *tess, GLUface *head)
void	__gl_renderMesh (GLUtesselator *tess, GLUmesh *mesh)
void	__gl_renderBoundary (GLUtesselator *tess, GLUmesh *mesh)
int	SIGN_INCONSISTENT ()
inline int	static_ComputeNormal (GLUtesselator *tess, GLUdouble norm[3], int check)
GLUboolean	__gl_renderCache (GLUtesselator *tess)

Macro Definition Documentation

AddToTrail

#define AddToTrail	(		f,
			t
	)		((f)->trail = (t), (t) = (f), (f)->marked = TOOLS_GLU_TRUE)

Definition at line 125 of file render.

FreeTrail

#define FreeTrail

(

t

)

do { while( (t) != NULL ) { (t)->marked = TOOLS_GLU_FALSE; t = (t)->trail; } } while(false)

Definition at line 128 of file render.

IsEven

#define IsEven

(

n

)

(((n) & 1) == 0)

Definition at line 155 of file render.

Marked

#define Marked

(

f

)

(! (f)->inside || (f)->marked)

Definition at line 123 of file render.

tools_glutess_render

#define tools_glutess_render

Definition at line 4 of file render.

Function Documentation

__gl_renderBoundary()

void __gl_renderBoundary ( GLUtesselator *  tess, GLUmesh *  mesh  )

inline

Definition at line 312 of file render.

{
  GLUface *f;
  GLUhalfEdge *e;
 
  for( f = mesh->fHead.next; f != &mesh->fHead; f = f->next ) {
    if( f->inside ) {
      CALL_BEGIN_OR_BEGIN_DATA( GLU_LINE_LOOP );
      e = f->anEdge;
      do {
        CALL_VERTEX_OR_VERTEX_DATA( e->Org->data ); 
    e = e->Lnext;
      } while( e != f->anEdge );
      CALL_END_OR_END_DATA();
    }
  }
}

__gl_renderCache()

GLUboolean __gl_renderCache ( GLUtesselator *  tess )

inline

Definition at line 418 of file render.

{
  CachedVertex *v0 = tess->cache;
  CachedVertex *vn = v0 + tess->cacheCount;
  CachedVertex *vc;
  GLUdouble norm[3];
  int sign;
 
  if( tess->cacheCount < 3 ) {
    /* Degenerate contour -- no output */
    return TOOLS_GLU_TRUE;
  }
 
  norm[0] = tess->normal[0];
  norm[1] = tess->normal[1];
  norm[2] = tess->normal[2];
  if( norm[0] == 0 && norm[1] == 0 && norm[2] == 0 ) {
    static_ComputeNormal( tess, norm, TOOLS_GLU_FALSE );
  }
 
  sign = static_ComputeNormal( tess, norm, TOOLS_GLU_TRUE );
  if( sign == SIGN_INCONSISTENT() ) {
    /* Fan triangles did not have a consistent orientation */
    return TOOLS_GLU_FALSE;
  }
  if( sign == 0 ) {
    /* All triangles were degenerate */
    return TOOLS_GLU_TRUE;
  }
 
  /* Make sure we do the right thing for each winding rule */
  switch( tess->windingRule ) {
  case GLU_TESS_WINDING_ODD:
  case GLU_TESS_WINDING_NONZERO:
    break;
  case GLU_TESS_WINDING_POSITIVE:
    if( sign < 0 ) return TOOLS_GLU_TRUE;
    break;
  case GLU_TESS_WINDING_NEGATIVE:
    if( sign > 0 ) return TOOLS_GLU_TRUE;
    break;
  case GLU_TESS_WINDING_ABS_GEQ_TWO:
    return TOOLS_GLU_TRUE;
  }
 
  CALL_BEGIN_OR_BEGIN_DATA( tess->boundaryOnly ? GLU_LINE_LOOP
              : (tess->cacheCount > 3) ? GLU_TRIANGLE_FAN
              : GLU_TRIANGLES );
 
  CALL_VERTEX_OR_VERTEX_DATA( v0->data ); 
  if( sign > 0 ) {
    for( vc = v0+1; vc < vn; ++vc ) {
      CALL_VERTEX_OR_VERTEX_DATA( vc->data ); 
    }
  } else {
    for( vc = vn-1; vc > v0; --vc ) {
      CALL_VERTEX_OR_VERTEX_DATA( vc->data ); 
    }
  }
  CALL_END_OR_END_DATA();
  return TOOLS_GLU_TRUE;
}

__gl_renderMesh()

void __gl_renderMesh ( GLUtesselator *  tess, GLUmesh *  mesh  )

inline

Definition at line 59 of file render.

{
  GLUface *f;
 
  /* Make a list of separate triangles so we can render them all at once */
  tess->lonelyTriList = NULL;
 
  for( f = mesh->fHead.next; f != &mesh->fHead; f = f->next ) {
    f->marked = TOOLS_GLU_FALSE;
  }
  for( f = mesh->fHead.next; f != &mesh->fHead; f = f->next ) {
 
    /* We examine all faces in an arbitrary order.  Whenever we find
     * an unprocessed face F, we output a group of faces including F
     * whose size is maximum.
     */
    if( f->inside && ! f->marked ) {
      static_RenderMaximumFaceGroup( tess, f );
      assert( f->marked );
    }
  }
  if( tess->lonelyTriList != NULL ) {
    static_RenderLonelyTriangles( tess, tess->lonelyTriList );
    tess->lonelyTriList = NULL;
  }
}

SIGN_INCONSISTENT()

int SIGN_INCONSISTENT ( )

inline

Definition at line 334 of file render.

                               {
  static const int s_value = 2;
  return s_value;
}

static_ComputeNormal()

inline int static_ComputeNormal	(	GLUtesselator *	tess,
		GLUdouble	norm[3],
		int	check
	)

Definition at line 339 of file render.

{
  CachedVertex *v0 = tess->cache;
  CachedVertex *vn = v0 + tess->cacheCount;
  CachedVertex *vc;
  GLUdouble dot, xc, yc, zc, xp, yp, zp, n[3];
  int sign = 0;
 
  /* Find the polygon normal.  It is important to get a reasonable
   * normal even when the polygon is self-intersecting (eg. a bowtie).
   * Otherwise, the computed normal could be very tiny, but perpendicular
   * to the true plane of the polygon due to numerical noise.  Then all
   * the triangles would appear to be degenerate and we would incorrectly
   * decompose the polygon as a fan (or simply not render it at all).
   *
   * We use a sum-of-triangles normal algorithm rather than the more
   * efficient sum-of-trapezoids method (used in CheckOrientation()
   * in normal.c).  This lets us explicitly reverse the signed area
   * of some triangles to get a reasonable normal in the self-intersecting
   * case.
   */
  if( ! check ) {
    norm[0] = norm[1] = norm[2] = 0.0;
  }
 
  vc = v0 + 1;
  xc = vc->coords[0] - v0->coords[0];
  yc = vc->coords[1] - v0->coords[1];
  zc = vc->coords[2] - v0->coords[2];
  while( ++vc < vn ) {
    xp = xc; yp = yc; zp = zc;
    xc = vc->coords[0] - v0->coords[0];
    yc = vc->coords[1] - v0->coords[1];
    zc = vc->coords[2] - v0->coords[2];
 
    /* Compute (vp - v0) cross (vc - v0) */
    n[0] = yp*zc - zp*yc;
    n[1] = zp*xc - xp*zc;
    n[2] = xp*yc - yp*xc;
 
    dot = n[0]*norm[0] + n[1]*norm[1] + n[2]*norm[2];
    if( ! check ) {
      /* Reverse the contribution of back-facing triangles to get
       * a reasonable normal for self-intersecting polygons (see above)
       */
      if( dot >= 0 ) {
    norm[0] += n[0]; norm[1] += n[1]; norm[2] += n[2];
      } else {
    norm[0] -= n[0]; norm[1] -= n[1]; norm[2] -= n[2];
      }
    } else if( dot != 0 ) {
      /* Check the new orientation for consistency with previous triangles */
      if( dot > 0 ) {
    if( sign < 0 ) return SIGN_INCONSISTENT();
    sign = 1;
      } else {
    if( sign > 0 ) return SIGN_INCONSISTENT();
    sign = -1;
      }
    }
  }
  return sign;
}

static_MaximumFan()

struct FaceCount static_MaximumFan

(

GLUhalfEdge *

eOrig

)

Definition at line 130 of file render.

{
  /* eOrig->Lface is the face we want to render.  We want to find the size
   * of a maximal fan around eOrig->Org.  To do this we just walk around
   * the origin vertex as far as possible in both directions.
   */
  struct FaceCount newFace = { 0, NULL, &static_RenderFan };
  GLUface *trail = NULL;
  GLUhalfEdge *e;
 
  for( e = eOrig; ! Marked( e->Lface ); e = e->Onext ) {
    AddToTrail( e->Lface, trail );
    ++newFace.size;
  }
  for( e = eOrig; ! Marked( e->Rface ); e = e->Oprev ) {
    AddToTrail( e->Rface, trail );
    ++newFace.size;
  }
  newFace.eStart = e;
  /*LINTED*/
  FreeTrail( trail );
  return newFace;
}

static_MaximumStrip()

struct FaceCount static_MaximumStrip

(

GLUhalfEdge *

eOrig

)

Definition at line 157 of file render.

{
  /* Here we are looking for a maximal strip that contains the vertices
   * eOrig->Org, eOrig->Dst, eOrig->Lnext->Dst (in that order or the
   * reverse, such that all triangles are oriented CCW).
   *
   * Again we walk forward and backward as far as possible.  However for
   * strips there is a twist: to get CCW orientations, there must be
   * an *even* number of triangles in the strip on one side of eOrig.
   * We walk the strip starting on a side with an even number of triangles;
   * if both side have an odd number, we are forced to shorten one side.
   */
  struct FaceCount newFace = { 0, NULL, &static_RenderStrip };
  long headSize = 0, tailSize = 0;
  GLUface *trail = NULL;
  GLUhalfEdge *e, *eTail, *eHead;
 
  for( e = eOrig; ! Marked( e->Lface ); ++tailSize, e = e->Onext ) {
    AddToTrail( e->Lface, trail );
    ++tailSize;
    e = e->Dprev;
    if( Marked( e->Lface )) break;
    AddToTrail( e->Lface, trail );
  }
  eTail = e;
 
  for( e = eOrig; ! Marked( e->Rface ); ++headSize, e = e->Dnext ) {
    AddToTrail( e->Rface, trail );
    ++headSize;
    e = e->Oprev;
    if( Marked( e->Rface )) break;
    AddToTrail( e->Rface, trail );
  }
  eHead = e;
 
  newFace.size = tailSize + headSize;
  if( IsEven( tailSize )) {
    newFace.eStart = eTail->Sym;
  } else if( IsEven( headSize )) {
    newFace.eStart = eHead;
  } else {
    /* Both sides have odd length, we must shorten one of them.  In fact,
     * we must start from eHead to guarantee inclusion of eOrig->Lface.
     */
    --newFace.size;
    newFace.eStart = eHead->Onext;
  }
  /*LINTED*/
  FreeTrail( trail );
  return newFace;
}

static_RenderFan()

void static_RenderFan	(	GLUtesselator *	tess,
		GLUhalfEdge *	eStart,
		long	size
	)

Definition at line 256 of file render.

{
  /* Render as many CCW triangles as possible in a fan starting from
   * edge "e".  The fan *should* contain exactly "size" triangles
   * (otherwise we've goofed up somewhere).
   */
  CALL_BEGIN_OR_BEGIN_DATA( GLU_TRIANGLE_FAN ); 
  CALL_VERTEX_OR_VERTEX_DATA( e->Org->data ); 
  CALL_VERTEX_OR_VERTEX_DATA( e->Dst->data ); 
 
  while( ! Marked( e->Lface )) {
    e->Lface->marked = TOOLS_GLU_TRUE;
    --size;
    e = e->Onext;
    CALL_VERTEX_OR_VERTEX_DATA( e->Dst->data ); 
  }
 
  assert( size == 0 );
  CALL_END_OR_END_DATA();
}

static_RenderLonelyTriangles()

void static_RenderLonelyTriangles	(	GLUtesselator *	tess,
		GLUface *	head
	)

Definition at line 221 of file render.

{
  /* Now we render all the separate triangles which could not be
   * grouped into a triangle fan or strip.
   */
  GLUhalfEdge *e;
  int newState;
  int edgeState = -1;   /* force edge state output for first vertex */
 
  CALL_BEGIN_OR_BEGIN_DATA( GLU_TRIANGLES );
 
  for( ; f != NULL; f = f->trail ) {
    /* Loop once for each edge (there will always be 3 edges) */
 
    e = f->anEdge;
    do {
      if( tess->flagBoundary ) {
    /* Set the "edge state" to TOOLS_GLU_TRUE just before we output the
     * first vertex of each edge on the polygon boundary.
     */
    newState = ! e->Rface->inside;
    if( edgeState != newState ) {
      edgeState = newState;
          CALL_EDGE_FLAG_OR_EDGE_FLAG_DATA( edgeState );
    }
      }
      CALL_VERTEX_OR_VERTEX_DATA( e->Org->data );
 
      e = e->Lnext;
    } while( e != f->anEdge );
  }
  CALL_END_OR_END_DATA();
}

static_RenderMaximumFaceGroup()

void static_RenderMaximumFaceGroup	(	GLUtesselator *	tess,
		GLUface *	fOrig
	)

Definition at line 87 of file render.

{
  /* We want to find the largest triangle fan or strip of unmarked faces
   * which includes the given face fOrig.  There are 3 possible fans
   * passing through fOrig (one centered at each vertex), and 3 possible
   * strips (one for each CCW permutation of the vertices).  Our strategy
   * is to try all of these, and take the primitive which uses the most
   * triangles (a greedy approach).
   */
  GLUhalfEdge *e = fOrig->anEdge;
  struct FaceCount max, newFace;
 
  max.size = 1;
  max.eStart = e;
  max.render = &static_RenderTriangle;
 
  if( ! tess->flagBoundary ) {
    newFace = static_MaximumFan( e ); if( newFace.size > max.size ) { max = newFace; }
    newFace = static_MaximumFan( e->Lnext ); if( newFace.size > max.size ) { max = newFace; }
    newFace = static_MaximumFan( e->Lprev ); if( newFace.size > max.size ) { max = newFace; }
 
    newFace = static_MaximumStrip( e ); if( newFace.size > max.size ) { max = newFace; }
    newFace = static_MaximumStrip( e->Lnext ); if( newFace.size > max.size ) { max = newFace; }
    newFace = static_MaximumStrip( e->Lprev ); if( newFace.size > max.size ) { max = newFace; }
  }
  (*(max.render))( tess, max.eStart, max.size );
}

static_RenderStrip()

void static_RenderStrip	(	GLUtesselator *	tess,
		GLUhalfEdge *	eStart,
		long	size
	)

Definition at line 278 of file render.

{
  /* Render as many CCW triangles as possible in a strip starting from
   * edge "e".  The strip *should* contain exactly "size" triangles
   * (otherwise we've goofed up somewhere).
   */
  CALL_BEGIN_OR_BEGIN_DATA( GLU_TRIANGLE_STRIP );
  CALL_VERTEX_OR_VERTEX_DATA( e->Org->data ); 
  CALL_VERTEX_OR_VERTEX_DATA( e->Dst->data ); 
 
  while( ! Marked( e->Lface )) {
    e->Lface->marked = TOOLS_GLU_TRUE;
    --size;
    e = e->Dprev;
    CALL_VERTEX_OR_VERTEX_DATA( e->Org->data ); 
    if( Marked( e->Lface )) break;
 
    e->Lface->marked = TOOLS_GLU_TRUE;
    --size;
    e = e->Onext;
    CALL_VERTEX_OR_VERTEX_DATA( e->Dst->data ); 
  }
 
  assert( size == 0 );
  CALL_END_OR_END_DATA();
}

static_RenderTriangle()

void static_RenderTriangle	(	GLUtesselator *	tess,
		GLUhalfEdge *	eStart,
		long	size
	)

Definition at line 210 of file render.

{
  /* Just add the triangle to a triangle list, so we can render all
   * the separate triangles at once.
   */
  assert( size == 1 );
  AddToTrail( e->Lface, tess->lonelyTriList );
  (void)size;
}