render.h File Reference

#include "mesh.h"

Include dependency graph for render.h:

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

Go to the source code of this file.

Functions
void	__gl_renderMesh (GLUtesselator *tess, GLUmesh *mesh)
void	__gl_renderBoundary (GLUtesselator *tess, GLUmesh *mesh)
GLboolean	__gl_renderCache (GLUtesselator *tess)

Function Documentation

__gl_renderBoundary()

void __gl_renderBoundary	(	GLUtesselator *	tess,
		GLUmesh *	mesh
	)

{
  GLUface *f;
  GLUhalfEdge *e;
 
  for( f = mesh->fHead.next; f != &mesh->fHead; f = f->next ) {
    if( f->inside ) {
      CALL_BEGIN_OR_BEGIN_DATA( GL_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();
    }
  }
}

References GLUface::anEdge, CALL_BEGIN_OR_BEGIN_DATA, CALL_END_OR_END_DATA, CALL_VERTEX_OR_VERTEX_DATA, GLUvertex::data, GLUmesh::fHead, GL_LINE_LOOP, GLUface::inside, GLUhalfEdge::Lnext, GLUface::next, and GLUhalfEdge::Org.

Referenced by gluTessEndPolygon().

Here is the caller graph for this function:

__gl_renderCache()

GLboolean __gl_renderCache

(

GLUtesselator *

tess

)

{
  CachedVertex *v0 = tess->cache;
  CachedVertex *vn = v0 + tess->cacheCount;
  CachedVertex *vc;
  GLdouble norm[3];
  int sign;
 
  if( tess->cacheCount < 3 ) {
    /* Degenerate contour -- no output */
    return 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 ) {
    ComputeNormal( tess, norm, FALSE );
  }
 
  sign = ComputeNormal( tess, norm, TRUE );
  if( sign == SIGN_INCONSISTENT ) {
    /* Fan triangles did not have a consistent orientation */
    return FALSE;
  }
  if( sign == 0 ) {
    /* All triangles were degenerate */
    return 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 TRUE;
    break;
  case GLU_TESS_WINDING_NEGATIVE:
    if( sign > 0 ) return TRUE;
    break;
  case GLU_TESS_WINDING_ABS_GEQ_TWO:
    return TRUE;
  }
 
  CALL_BEGIN_OR_BEGIN_DATA( tess->boundaryOnly ? GL_LINE_LOOP
        : (tess->cacheCount > 3) ? GL_TRIANGLE_FAN
        : GL_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 TRUE;
}

References GLUtesselator::boundaryOnly, GLUtesselator::cache, GLUtesselator::cacheCount, CALL_BEGIN_OR_BEGIN_DATA, CALL_END_OR_END_DATA, CALL_VERTEX_OR_VERTEX_DATA, ComputeNormal(), CachedVertex::data, FALSE, GL_LINE_LOOP, GL_TRIANGLE_FAN, GL_TRIANGLES, GLU_TESS_WINDING_ABS_GEQ_TWO, GLU_TESS_WINDING_NEGATIVE, GLU_TESS_WINDING_NONZERO, GLU_TESS_WINDING_ODD, GLU_TESS_WINDING_POSITIVE, GLUtesselator::normal, sign(), SIGN_INCONSISTENT, TRUE, and GLUtesselator::windingRule.

Referenced by gluTessEndPolygon().

Here is the call graph for this function:

Here is the caller graph for this function:

__gl_renderMesh()

void __gl_renderMesh	(	GLUtesselator *	tess,
		GLUmesh *	mesh
	)

{
  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 = 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 ) {
      RenderMaximumFaceGroup( tess, f );
      assert( f->marked );
    }
  }
  if( tess->lonelyTriList != NULL ) {
    RenderLonelyTriangles( tess, tess->lonelyTriList );
    tess->lonelyTriList = NULL;
  }
}

References FALSE, GLUmesh::fHead, GLUface::inside, GLUtesselator::lonelyTriList, GLUface::marked, GLUface::next, RenderLonelyTriangles(), and RenderMaximumFaceGroup().

Referenced by gluTessEndPolygon().

Here is the call graph for this function:

Here is the caller graph for this function: