You can accelerate the transform stage by disabling the current-color tests, which are controlled by glColorMaterial(). Naturally this alters the color of objects. See the OpenGL Programming Guide for more details.

The function opRemoveColorBindings() traverses a scene graph and sets the color binding of each csGeoSet to NO_COLOR. This is the declaration of the function, which appears in the file opGFXSpeed.h:

void opRemoveColorBindings(csNode *root)

You can force all csShape nodes in a scene graph to have the same csAppearance, and thus prevent mode switching by the OpenGL machine during rendering. To do so, use the class opCollapseAppearances, which is a csAction that traverses the scene graph and sets all csAppearances to be the same as the first appearance encountered by the traversal. Be aware, however, that existing csAppearances are lost.

Reducing the number of vertices by collecting triangles into strips or fans mainly reduces transform time— fewer vertices means fewer vertex transformations. Secondary benefits of “tristripping” and “trifanning” are reductions in OpenGL function call overhead, bandwidth requirements, memory consumption, and caching. Another benefit is fewer glVertex*() calls and proportionally less bandwidth to the graphics hardware. Because tristrips and trifans encode fewer vertices, they also require less memory than independent triangles. On the host side, this translates into better locality of reference. Fill-limited applications receive no benefit from using tristrips or trifans.

The main feature of the opTriFanner class is an overloaded method, convert(), which generates csTriFanSets from triangle sets. A set of triangles can come from a csGeometry, from a singly linked list of trifans that you create, or from an opGeoConverter, discussed in “Decomposing csGeoSets Into Constituent Triangles: opGeoConverter”. In anticipation of possible derivations, the member function convert() is declared to accept the parent class of csGeoSet, csGeometry.

class opTriFanner : public opTriFanSetBuilder
{
public:
opTriFanner(const opGeoConverter *gc);
~opTriFanner();

static csGeometry *convert( 
                    const opGeoConverter *gc,
                    opColorGenerator *cg=opColorGenerator::noColors());

static csGeometry *convert( 
                    csGeometry *geom,
                    opColorGenerator *cg=opColorGenerator::noColors());
};

The second approach to control redundant vertex information is to organize triangles into strips of adjacent triangles.

class opTriStripper : public opTriStripSetBuilder
{
public:
opTriStripper(const opGeoConverter *gc);
~opTriStripper();

static csGeometry *convert( 
                  const opGeoConverter *gc,
                  opColorGenerator *cg = opColorGenerator::noColors());

static csGeometry *convert( 
                  csGeometry *geom,
                  opColorGenerator *cg = opColorGenerator::noColors());

static csShape    *convert( 
                  csShape *s,
                  opColorGenerator *cg = opColorGenerator::noColors());
};

The effectiveness of triangle strips depends on the length of the strips: many short strips are less efficient than the same number of triangles in one long tristrip.

Typically, models cannot be grouped into long strips using OpenGL Optimizer tristripping algorithms. In general, the more uniform the tessellation, the longer the strips will be. When you see too many vertices per triangle (see “Gathering Triangle Statistics”), check for the following:

The class opTriFanAndStrip is a csAction that uses a hybrid approach to traversing a scene graph and merging the triangles in each csGeoSet into trifans or tristrips.

The merging operation begins by making trifans. If a trifan has fewer than a minimum number of triangles, the fan is not kept and the triangles are passed to the tristripper.

class OP_DLLEXPORT opTriFanAndStrip : public csAction
{
public:
// Input:  csShape
//           csGeometry, csGeoSet0, . . . csGeoSetN
// Output: csShape
//           csGeometry, csTriStripSet, csTriFanSet
opTriFanAndStrip(int minFanSize,
    opColorGenerator *cg=opColorGenerator::noColors());
virtual ~opTriFanAndStrip();

static csShape *convert(
                    csShape *,
                    int minFanSize=5,
                    opColorGenerator *cg=opColorGenerator::noColors());
};

If your application runs on a machine with multiple processors, you can use the OpenGL Optimizer tool opMPTriFanAndStrip to accelerate generation of trifans and tristrips.

The method apply(), which is inherited from csAction, performs the same conversion as opTriFanAndStrip::apply(), but runs the procedure in parallel. The algorithm checks the number of processors and reserves one for the thread manager; the remaining processors manipulate the scene graph. For more information about OpenGL Optimizer multiprocessing tools, see Chapter 14, “Managing Multiple Processors.”

class opMPTriFanAndStrip : public csAction
{
public:
opMPTriFanAndStrip(int minFanSize, opColorGenerator 
                   *cg=opColorGenerator::noColors());
virtual ~opMPTriFanAndStrip();

void             begin(csNode *node); // count shapes, allocate memory

csTravDirective  preVisit(csNode *node); // collect shapes in list

void             end(csNode *node); // convert shapes in parallel, 
                                   // replace in tree
};

The convenience function opColorizeStrips() traverses a scene graph and applies random colors to csTriStripSets, csTriFanSets, and csTriSets, allowing you to visualize the effects of opTriFanner, opTriStripper, opTriFanAndStrip, or opMPTriFanAndStrip algorithms. Notice that the convert() method for each of these classes also allows you to apply random color to the output.

The function, which is declared in opGFXSpeed.h, has the following prototype:

void opColorizeStrips(csNode *root)