The main parameters you can use to control spatialization are hints for the largest and smallest sets of triangles in each csGeoSet of the spatialized graph. The spatializing tools attempt to develop a scene graph with the number of triangles in each csGeoSet within the prescribed range.

OpenGL Optimizer provides a high-level tool that allows you to re-structure a scene graph and its csGeoSets to get the desired number of triangles in each leaf node. You can specify the leaf nodes to be trifans or tristrips. More details are provided in the section “Spatialization Tool: opSpatialize”.

You can also use lower-level tools that perform the component procedures of this process, tools that spatialize a set of triangles, reorganize an existing set of nodes, and combine csGeoSets. Combining csGeoSets is useful if the nodes in a scene graph are not appropriate for spatial reorganization because, for example, they contain significantly different numbers of triangles, or the graph simply has too many small csGeoSets. The classes that provide these tools are discussed in the following sections:

The class has the following methods:

class opSpatialize
{
public:
static csNode *convert( 
                   csNode *node,  
                   int goalMin,int goalMax,
                   const csBoxBound& bbox,
                   csType *outType = csTriFanSet::getClassType(),
                   opColorGenerator *c = opColorGenerator::noColors());
};

convert() has the following arguments:

convert() also allows you to provide contrasting colors for the csTriStrips or csTriFans in the new graph by using opColorGenerator in exactly the same way as opTriFanner and opTriStripper. See the section “Specifying Coloring of New csGeoSets: opColorGenerator” in Chapter 13 for more details.

The class opGeoSpatialize reorganizes existing nodes in a scene graph. Given a bounding box and a scene-graph root node, convert()

Figure 6-1 illustrates the effects of opGeoSpatialize on a scene graph of car parts. The csGeoSets for three of the tire-and-rim combinations (necessarily contained in csShape nodes) are placed appropriately with respect to front or rear, and left or right. The csGeoSets for the fourth tire and rim are combined in one csGeoSet, and placed appropriately in the graph. The csGeoSet for the seat is placed in a portion of the graph for triangles in the center.

Figure 6-1. Organizing and Combining csGeoSets With opGeoSpatialize

class opGeoSpatialize : public opDFTravAction
{
public:
opGeoSpatialize(int goalMin,int goalMax, const csBoxBound& bbox);
~opGeoSpatialize();

opTravDisp preNode(csNode *&, const opActionInfo&);
opActionDisp   end(csNode *&, const opActionInfo&);

void addShape(csShape *s);

csNode *done(csType *outType = csTriFanSet::getClassType(),
             opColorGenerator *c = opColorGenerator::noColors());

static csNode *convert( 
                   csNode *node,
                   int goalMin,int goalMax,
                   const csBoxBound& bbox,
                   csType *outType = csTriFanSet::getClassType(),
                   opColorGenerator *c = opColorGenerator::noColors());
};

When you have a scene (sub)graph with too many small csGeosets, you can combine them and develop a graph consisting of a root node with children. Each child contains all the triangles of the original graph that have the same appearance. You can specify whether the output csGeoSets are csTriStripSets or csTriFanSets. You can subsequently use opTriSpatialize on the combined triangles to further develop a scene graph structure and adjust granularity; this is the approach taken by opSpatialize.

The result of combining csGeoSets is faster rendering, because of reduced traversal time and the possibility of larger trifans or tristrips. In one model with too many small csGeoSets, simply combining csGeoSets reduced rendering time by over two thirds.

Figure 6-2 illustrates the effects of combining csGeoSets. Notice that interior nodes of the scene graph are lost: combine nodes before you create LODs or insert transform nodes. Figure 6-2, which represents scene graph changes, shows the csShape nodes that contain the csGeoSets.

Figure 6-2. Combining csGeoSets with opCombineGeoSets

class opCombineGeoSets : public opDFTravAction
{
public:
opCombineGeoSets();
~opCombineGeoSets();
opTravDisp preNode(csNode *&, const opActionInfo&);
opActionDisp end(csNode *&, const opActionInfo&);

void addGeoSet(csGeoSet *gs,csAppearance *app);
csNode *buildGraph(csType *outType=csTriFanSet::getClassType(),
                   opColorGenerator *c = opColorGenerator::noColors());

static csNode *convert(
                csNode *root, float norm_tol,
                csType *outType=csTriFanSet::getClassType(),
                opColorGenerator *c = opColorGenerator::noColors()
                );
};

The most elementary spatialization task successively subdivides a bounding box containing a set of triangles until there are approximately a specified number of triangles in each of the resulting volumes. Thus the loads on the graphics hardware are approximately the same for all of the leaf nodes.

The main method of the class opTriSpatialize is the overloaded convert() function, which redistributes triangles into csGeoSets containing similar numbers of triangles. Except for the arguments that specify the set of triangles on which convert() acts, its arguments are the same as for opSpatialize::convert() and have the same effects. You specify the set of triangles to be manipulated by convert() with a csBoxBound and csShape. Alternatively, you can use a csGeoSet and a csAppearance.

opTriSpatialize uses an opGeoConverter to manage the set of triangles and preserve results for other operations. See “Decomposing csGeoSets Into Constituent Triangles: opGeoConverter”.

Figure 6-3 illustrates the effects of spatializing the set of triangles in one csGeoSet that describes all four wheels of a car. A csGeoSet is created for each wheel and placed in a csShape node corresponding to the spatial position of the wheels.

Figure 6-3. Creating a Spatialized Graph From the csGeoSet in One csShape

class opTriSpatialize
{
public:
opTriSpatialize(int goalMin,int goalMax,
                 const csBoxBound& bbox,
                 opGeoConverter *gc,
                 csAppearance *app);
~opTriSpatialize();

void addTriangle(const opTriangle *t);
csNode *done(csType *outType=csTriFanSet::getClassType(),
             opColorGenerator *c = opColorGenerator::noColors());

static csNode *convert(             
           csGeoSet *gs, csAppearance *app,
           int goalMin,int goalMax,
           const csBoxBound& bbox,
           csType *outType=csTriFanSet::getClassType(),
           opColorGenerator *colors = opColorGenerator::noColors());

static csNode *convert(
           csShape *shape,
           int goalMin,int goalMax,
           const csBoxBound& bbox,
           csType *outType=csTriFanSet::getClassType(),
           opColorGenerator *colors = opColorGenerator::noColors());
};