Registering Callbacks and Basic Callback Handling

Major Callbacks to Register

All callbacks are registered with the following common method:

void gluTessCallback(GLUtesselator* tObj, GLenum callbackType, void (*cbFcn)());

As indicated in the table, most of the tessellation callbacks take one or more parameters; hence you will need to type-cast actual parameters. Assuming you have executed:

and assuming you have created the following typedef:

do as indicated in the following table:

If you want your callbacks to be methods of a class, they must be class (not instance) methods; i.e., they must be declared as "static" in the class definition. Hence:

class SceneElement
{
    …
    static void tessBeginCB(GLenum mode);
    static void tessVertexCB(void* pva);
    static void tessEndCB();
    static void tessErrorCB(GLenum e);
    …
};

Expectations of the Registered Callback Functions

(Some of this material may make more sense after studying Step 3 of Part 1.)

When you call gluTessEndPolygon, the algorithm to do the tessellation starts, and it will begin calling your callbacks in sequences like:

yourTessBeginCB, yourTessVertexCB, …, yourTessVertexCB, yourTessEndCB

You will need to create two buffers: (i) a coordinate buffer to hold vertex coordinates as they are delivered to your vertex callback, and (ii) a buffer to hold the glDrawArrays data you will be recording as the callbacks are made.

The basic idea is the following:

• When your GLU_TESS_BEGIN callback is called, save the current "mode" along with the index of the next open slot in the coordinate buffer. (The "mode" you save will be one of the standard glDrawArrays modes: GL_TRIANGLE_STRIP, etc.)
• As the series of calls to your GLU_TESS_VERTEX callback get made, append the coordinates to the end of the coordinate buffer, probably converting double to float as you do so.
• When the GLU_TESS_END callback is invoked, record the number of vertices seen since the matching GLU_TESS_BEGIN callback was invoked, and place the triple (mode, startIndex, numVertices) into the "glDrawArrays buffer".

When control returns to your code from the gluEndPolygon call, you need to copy the coordinate buffer data to the GPU in the usual way (i.e., using glGenBuffers-glBindBuffer-glBufferData along with the usual glVertexAttribPointer and glEnableVertexAttribArray calls). The "glDrawArrays buffer" you created will just remain a CPU-side data structure as one of your ModelView subclass instance variables and will be used as described in Part 2. It should look something like:

Because we never make mistakes, there will be no need to worry about the GLU_TESS_ERROR callback.

Yeah, right.

Your error callback will be invoked if the algorithm detects a problem of some sort. The GLenum passed to it is an error code. There is a utility function for obtaining a string representation for any such error code. You can implement your error callback something like:

void tessErrorCB(GLenum e)
{
    std::cerr << static_cast<const unsigned char*>(gluErrorString(e)) << std::endl;

    // On the most recent Mac OS release, "gluErrorString" seems to have disappeared. If you get compilation errors
    // related to this funtion, you will need to do instead:
    // std::cerr << static_cast<int>(e) << std::endl;
}

Note

In your GLU_TESS_VERTEX callback, you will need to cast the void* formal parameter that comes in:

void tessVertexCB(void* pvaAsVoid)
{
    double* xyz = reinterpret_cast<double*> (pvaAsVoid);
    …
}