Ideally you would quickly generate the simplest tessellation that adequately represents surfaces of interest. What is adequate depends on your particular rendering task. You may want to generate several tessellations with varying degrees of complexity and accuracy for one opRep and place them in level-of-detail nodes, as discussed in Chapter 4, “Rendering Appropriate Levels of Detail.” The tessellators include accessor functions to help you assess the load they create for the graphics hardware.

The control parameter for tessellations specifies the maximum deviation from the exact surface. Figure 11-2 illustrates the effects of varying the deviation. The upper left image is appropriate for accurate representation of the surface, the lower right image would be appropriate if the object were in the distant background of a scene.

Figure 11-2. Tessellations Varying With Changes in Control Parameter

opReal profile( opReal t ) { return 0.5*cos(t*6.0) + 1.25; };
opSuperQuadCurve3d *cross = 
        new opSuperQuadCurve3d( 0.75, new opVec3(0.0, 0.0, 0.0), 3.0 );
opCircle3d *path = new opCircle3d( 1.75, new opVec3(0.0, 0.0, 0.0) );
opFrenetSweptSurface *fswept = 
                      new opFrenetSweptSurface( cross, path, profile );
fswept->setHandednessHint( true );

You can apply a tessellator either to a scene graph or to just one node. The tessellators produce a csGeoSet from an opRep and place that csGeoSet in the csShape that holds the opRep.

A tessellation begins with a discrete set of vertices at surface edges. To prevent cracks from appearing between adjacent surfaces, the same set of vertices should be used to tessellate both surfaces.

To address the crack problem, you have several options, which are discussed in “Building Topology: Computing and Using Connectivity Information”. Table 10-1 lists the different approaches to topology building, and the methods to use for each.

If you create several subclasses of opTessellateAction and call opTessellateAction::apply(), then for each surface encountered during the tessellation traversal, the algorithm used to perform the tessellation is that of the most derived instance of opTessellateAction that is appropriate for the surface. Thus, a call to the base class method will do the right thing for each opParaSurface, if you create instances of subclasses that provide the algorithms for doing so.

A tessellator won't tessellate an opRep if getGeometryCount is not zero. If you want to retessellate an opRep, you must call clearTessellation() for opParaSurface and call removeGeometry() for opCurve2d or opCurve3d. See the example in /Optimizer/src/apps/removetess/main.cxx for details.

The class has the following main methods:

class opTessellateAction : public csDispatch
{
public:
// Creating and destroying
opTessellateAction( void );
~opTessellateAction( void );

// Accessor functions
void setExtSize( int s );
int getExtSize( ) 
int getTriangleCount() 
int getTriStripCount() 
int getTriFanCount()   

void setReverseTrimLoop( opBool enable ) 
opBool getReverseTrimLoop()            

void setBuildTopoWhileTess(opBool _buildTopoWhileTess) 
opBool getBuildTopoWhileTess() 

void    setTopo(opTopo * _topo)
opTopo *getTopo( void )

// Recursive action application
void apply  ( csNode *node );
void mpApply( csNode *node );
};

The class has the following main methods:

class OP_DLLEXPORT opTessCurve3dAction : public opTessellateAction
{
public:
// Creating and destroying
opTessCurve3dAction( );
opTessCurve3dAction( opReal chordalDevTol, 
                     opBool scaleTolByCurvature, 
                     int samples );
~opTessCurve3dAction();

// Accessor functions
void setChordalDevTol( const opReal chordalDevTol );
opReal getChordalDevTol( );
void setScaleTolByCurvature( const opReal scaleTolByCurvature );
opBool getScaleTolByCurvature( );
void setSampling( const int samples );
int getSampling( );
};

The class has the following main methods:

class opTessCuboidAction : public opTessellateAction
{
public:
opTessCuboidAction( );
~opTessCuboidAction( );

// Tessellate action
static void tessellate( csDispatch *action, csObject *object);

// The actual cuboid tessellator
void tessellator( opCuboid &c);
};

The methods tessellate() and tessellator() occur for all subclasses of opTessellateAction; you will rarely need to use them (see “Base Class opTessellateAction” for more details about these functions).

The opTessParaSurfaceAction class develops tessellations of any opParaSurface. If a surface has boundary curves, the tessellator starts there and specifies vertices at the edges of the surface. The tessellator then covers the surface with csTriStripSets or csTriFanSets, using the boundary vertices to “pin” the edges of the tessellation. If necessary, the tessellator creates edge vertices by constructing a discrete version of the boundary curve associated with each of the surface's opEdges. An advantage of starting all tessellations at boundaries is easy coordination of tessellations by several processors.

As part of the tessellation process, you can generate the u-v coordinates for each vertex created by the tessellator.

To control the accuracy of a tessellation, you specify a chordal deviation parameter which constrains the distance of edges in the tessellation from the original surface.

class opTessParaSurfaceAction : public opTessellateAction
{
public:
opTessParaSurfaceAction();
opTessParaSurfaceAction( opReal chordalDevTol, 
                         opBool scaleTolByCurvature, int samples);
~opTessParaSurfaceAction();

// Accessor functions
void   setChordalDevTol( const opReal chordalDevTol ); 
opReal getChordalDevTol( );
  
void   setScaleTolByCurvature( const opReal scaleTolByCurvature ) 
opBool   getScaleTolByCurvature()

void setSampling( const int samples ) 
int  getSampling( ) 

void setNonUniformSampling(const opBool samples);
opBool getNonUniformSampline();

void setGenUVCoordinates( const opBool genUVCoordinates );
opBool getGenUVCoordinates( );

opBool   capUbegin;
opBool   capUend;
opBool   capVbegin;
opBool   capVend;
};

The sample code in this section not only illustrates the main code elements for tessellating an opParaSurface but describes the steps in the rendering process. The lines of code perform the following procedures:

The code in this section comes mainly from the functions main(), in the file /usr/share/Optimizer/src/apps/repTest/main.cxx, and makeShape() and makeObjects() in the file /usr/share/Optimizer/apps/repTest/repTest.cxx.

The opTessNurbSurfaceAction class tesselates surfaces using OpenGL NURBS utilities. As a result, the tessellation developed by opTessNurbSurfaceAction is well tuned for rendering. For more details about the OpenGL utilities, see the section “The GLU NURBS Interface” in Chapter 12 of the OpenGL Programming Guide, Second Edition.

The only member function of note is the constructor, which takes a chordal deviation parameter that has the same effect as that for opTessParaSurfaceAction.

The last two mesh tessellators return what are known as “hedgehog” plots of the vector fields. They are both trivial derivations of the base class opTessVecAction:

The opTessIsoAction class interprets discrete versions of opReal-valued functions defined on three-dimensional space. That is, opTessIsoAction acts on an opRegMesh<opReal> and tessellates the mesh function's iso-surfaces.

class opTessIsoAction : public opTessellateAction
{

public:

// Creating and destroying
opTessIsoAction ();
opTessIsoAction (opReal threshold, int stride = 1);
~opTessIsoAction ();

// Accessor functions
void  setThreshold (opReal thresh) 
opReal getThreshold ()              

void  setStride (int _stride)       
int   getStride ()                     
};

The opTessSliceAction class interprets discrete versions of opReal-valued functions defined on three-dimensional space. That is, opTessSliceAction acts on an opRegMesh<opReal> and shows, by a simple rainbow map, values of the functions that lie on a plane. opTessSliceAction uses one of three possible planes perpendicular to the coordinate axes.

class opTessSliceAction : public opTessellateAction
{
public:

opTessSliceAction();
opTessSliceAction (opReal position, char axis);

~opTessSliceAction();

// Accessor functions
void   setPosition (opReal _position) 
opReal getPosition ()                 

void   setAxis (int _axis)
char   getAxis () 
};

opTessVecAction is the base class for the tessellators that act on an opRegMesh<opVec2> or an opRegMesh<opVec3>. The latter are trivial derivations from an opTessVecAction.

class opTessVecAction : public opTessellateAction
{
public:

opTessVecAction( );
~opTessVecAction( );

// --- Accessors
void setMagScale (opReal _scale)      
void setInitialColor (csVec4f _iColor) 
void setTerminalColor (csVec4f _tColor) 
                                        
opReal  getMagScale()
csVec4f getInitialColor()
csVec4f getTerminalColor()
};

The following discussion highlights the basic structure of the opviz sample application, to orient you when you look at the source files.

The application opviz uses calls to OpenGL Optimizer's three-dimensional opRegMesh tessellators, and uses the opVizViewer class, which is derived from opViewer, to control scene graph interactions and rendering. The application opviz can read Plot3D data files, (three samples are included in the OpenGL Optimizer library to illustrate mesh tessellation). For more information on Plot3D data format, see, for example, http://www.nas.nasa.gov/NAS/FAST/RND-93-010.walatka-clucas/htmldocs/
chp_21.formats.html.

The application opviz runs tessellators on an opThreadManager, which uses an opFunctionAction to distribute tessellation tasks. For more information on opThreadManager and opFunctionAction, see “Overview of the Thread Manager”.

The following sections first present controls added to opViewer by the class opVizViewer, and then cover these components of opviz: