The base class opSimplify describes mesh simplifiers that create varying levels of detail from a given csGeoSet. The levels of detail allow you to eliminate unnecessary triangles when rendering. opSimplify lets you derive your own simplifiers.

OpenGL Optimizer includes two opSimplify classes, opSRASimplify (see “Creating LODs: opSRASimplify”) and opLatticeSimplify (see “Rossignac Simplification Algorithm: opLatticeSimplify”), which provide different mesh-simplifying algorithms. The algorithm available through opSRASimplify is more sophisticated and provides more detailed control than is available through opLatticeSimplify, but the algorithm in opLatticeSimplify is faster. By extending the opSRASimplify class, application developers can define their own evaluation function, thereby changing the order of simplification. (See “Evaluation Function” for more information.)

In OpenGL Optimizer 1.1 and later, opSRASimplify has enhanced decimation functionality. It also supports all polygonal geoset types as inputs and produces indext tristrips as output. opSRASimplify also has a method that recalculates the normals of a given csGeoSet, based on the orientation of its triangles. The method has the following prototype:

csGeoSet* calculateNormals(csGeoSet* srsGset)

Typically you place a set of simplified objects below a level-of-detail node (a LOD). This node allows you to control the trade-off between interactivity and rendering accuracy; costly detail is drawn only when you can see it.

The children of an LOD node represent objects with varying degrees of resolution, that is, varying numbers of triangles. Typically, as the index of the child of an LOD increases, resolution decreases and rendering rate, therefore, increases. In an extreme case, you may not want to render an object at all. The tool for this operation is discussed in “Detail Culling”.

Cosmo3D provides csLOD scene-graph nodes to allow you to set the appropriate level of surface detail for a particular view during a draw action. A csLOD is a switch node that selects among its children based on the distance from the viewpoint. See the Cosmo 3D Programmer's Guide for more details.

When you decide where to place an LOD in a scene graph, consider how much “popping” you can tolerate as the LOD switches between children during rendering. For example, you could have one LOD near the root node, or many LODs, one above each object in a scene.

You can insert a csLOD node below a csGroup node by calling the csGroup methods to add or replace a child node. See the Cosmo 3D Programmer's Guide for more details.

OpenGL Optimizer provides the function addLODChild() as an example for inserting an LOD node. The function takes care of initializations required before you add a child with the method from csGroup. The function addLODChild() is in /usr/share/Optimizer/src/apps/opoptimize/addLOD.cxx.

The class opMergeScenes lets you combine entire scene graphs that differ only in the levels of detail in their csGeoSets.

The class has the following main methods:

class opSimplify
{
public:
opSimplify(void);
~opSimplify(void);

public:
// Which child in csGroup to simplify from
enum WhichSrcEnum
{
SRC,  // Usually LOD 0
PREV  // Usually coarsest LOD
};

void   simplifyGraph( csNode *rootNode, int relativeDepth,
                                opLengthUnits units, int threadId );

// Simplify from the source
void simplifyFromSrc( int lodLevel );

// Simplify from the previous level
void simplifyFromPrev( int lodLevel );

// Simplifier precision parameter settings
void setRelativePercent( int lodLevel, opReal percent);
void setAbsolutePercent( int lodLevel,opReal percent);
void setPolyCount( int lodLevel, int polyCount);
void setAbsoluteTol( int lodLevel,opReal Tol);
void setRelativeTol( int lodLevel,opReal Tol );

opReal getRelativePercent( int lodLevel );
opReal getAbsolutePercent( int lodLevel );
int getPolyCount( int lodLevel );
opReal getAbsoluteTol( int lodLevel );
opReal getRelativeTol( int lodLevel );
};

The remaining methods set and get parameters that characterize the simplification process.

opSRASimplify::decimateGeoSet() makes a copy of a csGeoSet and returns a simplified version of it (using the indexed csTriSet format) based on the following parameters:

If the simplification parameters do not allow any vertices to be removed, the returned csGeoSet is the same as the input csGeoSet.

---

Note: For an example of using opSRASimplify to simplify all csGeoSets in a scene, see “Sample Traversal Function From the opoptimize Sample Application” and the file /usr/share/Optimizer/src/apps/opoptimize/simplify.cxx.

---

The following sections discuss the opSRASimplify parameters.

vertexWeight = W 0 *distance + W 1 *normalDeviation + W 2 *curvature

The illustrations below illustrate the effects of decimateGeoSet() for specific simplification parameters.

Figure 4-2 shows the original model. The following three models are obtained after applying decimateGeoSet() to the original with the arguments:

Notice what happens to the horizontal edge of the wing.

Figure 4-2. Original Model Used for Simplification

Figure 4-3. Model Simplified using percent 50 weights 100

Figure 4-4. Model Simplified using percent 50 weights 010

Figure 4-5. Model Simplified using percent 50 weights 001

Because the horizontal edge of the wing is a high curvature region, it is approximated by a lot of small triangles. Thus, simplification with weights 1 0 0 removes these vertices, and you can see small dents beginning to form in the model. Simplification with weights 0 0 1 preserves high curvature regions, and the edge of the wing in the model is left intact.

The Simplifier has a number of flags you can set that define

Look at the opSRASimplify reference pages for a detailed description.

If you simplify a csGeoSet with two adjacent triangles that were originally specified independently, cracks can appear in surfaces rendered after simplification. The cracks result from shared vertices that are identical but have a double entry in the csCoordSet array. The simplifier might eliminate one of the triangles, but not the other. The effect is an apparent tear or crack in the surface.

The simplifier doesn't check for intersecting triangles upon removal of a vertex and retriangulation. Self-intersecting meshes are therefore a possible result of simplification.

The class has the following main methods:

class opLatticeSimplify : public opSimplify
{
public:
opLatticeSimplify(float gridSpacing);
virtual ~opLatticeSimplify();

csGeoSet *simplify(csGeoSet *);

The class has the following main methods:

class opMergeScenes : public csAction
{
public:
typedef bool (*LODCallback)(csNode *);

opMergeScenes(int maxScenes,int goalMin,int goalMax,
                                         opMergeScenes::LODCallback f);
~opMergeScenes();

void addScene(csNode *scene);
csNode *done();

void setGoalMin(int n) ;
void setGoalMax(int n) ;
void setInsertLODFunc(LODCallback f) ;

int getGoalMin() ;
int getGoalMax() ;
LODCallback getInsertLODFunc() ;