Question

I’m using a GLUtesselator to fill some nonconvex polygons.

It worked quite well but with some polygons it complained that it needed a combine function so I’ve provided a very simple GLU_TESS_COMBINE callback, which allocates a new vertex and just copies the coords (it’s 2D with solid colors, so I don’t need to interpolate RGB values or anything):

void CALLBACK tessCombine( GLdouble coords[3], GLdouble * vertex_data[4], GLfloat weight[4], GLdouble **outData )
{
    GLdouble *vertex = new GLdouble[3];
    vertex[0] = coords[0];
    vertex[1] = coords[1];
    vertex[2] = coords[2];
    *outData = vertex;
}

Now everything is rendered as expected, but it obviously leaks memory. The docs say:

Allocate another vertex, […] Free the memory sometime after
calling gluTessEndPolygon.

But in all the examples I’ve found, they don’t show how to handle the memory. The callbacks are free functions and there’s no way to free the memory allocated there, is there?

The only way I can think of is to store them somewhere and then delete them myself. Is this the correct way?

Answer 1

Take a look into this OpenGL Tessellation tutorial.

The point is not to allocate any memory in the callback (otherwise you are going to get a memory leak). Instead, you should copy vertex data to the memory location in the callback (as it is done in the example). From where you copy vertex data, it is up to you.

This is how the callback function looks in their example :

void CALLBACK tessCombineCB(const GLdouble newVertex[3], const GLdouble *neighborVertex[4],
                            const GLfloat neighborWeight[4], GLdouble **outData)
{
    // copy new intersect vertex to local array
    // Because newVertex is temporal and cannot be hold by tessellator until next
    // vertex callback called, it must be copied to the safe place in the app.
    // Once gluTessEndPolygon() called, then you can safly deallocate the array.
    vertices[vertexIndex][0] = newVertex[0];
    vertices[vertexIndex][1] = newVertex[1];
    vertices[vertexIndex][2] = newVertex[2];

    // compute vertex color with given weights and colors of 4 neighbors
    // the neighborVertex[4] must hold required info, in this case, color.
    // neighborVertex was actually the third param of gluTessVertex() and is
    // passed into here to compute the color of the intersect vertex.
    vertices[vertexIndex][3] = neighborWeight[0] * neighborVertex[0][3] +   // red
                               neighborWeight[1] * neighborVertex[1][3] +
                               neighborWeight[2] * neighborVertex[2][3] +
                               neighborWeight[3] * neighborVertex[3][3];
    vertices[vertexIndex][4] = neighborWeight[0] * neighborVertex[0][4] +   // green
                               neighborWeight[1] * neighborVertex[1][4] +
                               neighborWeight[2] * neighborVertex[2][4] +
                               neighborWeight[3] * neighborVertex[3][4];
    vertices[vertexIndex][5] = neighborWeight[0] * neighborVertex[0][5] +   // blue
                               neighborWeight[1] * neighborVertex[1][5] +
                               neighborWeight[2] * neighborVertex[2][5] +
                               neighborWeight[3] * neighborVertex[3][5];


    // return output data (vertex coords and others)
    *outData = vertices[vertexIndex];   // assign the address of new intersect vertex

    ++vertexIndex;  // increase index for next vertex
}