Curious "void*" parameter on some GL functions

Question

For some functions in OpenGL, one must specify a byte offset, such as in glVertexAttribPointer(), for stride. At first I would have guessed that it would be a normal number value like an integer. But upon inspection, I realized that it needs to be casted to void* (more specifically GLvoid*). My question is: what is the intended meaning of void* and why must it be used for a byte offset?

Answer 1

glVertexAttribPointer() is an older function from before Vertex Buffer Objects.

Before VBO's your vertex data would be stored in client side arrays and you would need to pass a pointer to the data to OpenGL before you could draw.

When VBO's came along they repurposed this function by allowing the pointer to be used to pass an integer offset.

e.g. void* offset = (void*)offsetof(vertexStructName, vertexMemberName);

Answer 2

Some OpenGL functions, such as glDrawElements take a GLvoid * parameter that is context dependant. On old GL, pre Vertex Buffers, the programmer would pass an array of integer indexes directly to glDrawElements, like this:

const GLuint indexes[] = { ... };
glDrawElements(GL_TRIANGLES, numIndexes, GL_UNSIGNED_INT, indexes);

That was called the immediate mode drawing.

When Vertex and Index Buffers were introduced, the OpenGL architecture board decided that they should reuse the existing interfaces, thus giving a new context dependant meaning to that last void pointer parameter of glDrawElements, glVertexAttribPointer and a few other similar functions.

With Index Buffers, the rendering data is already on the GPU, so the void pointer param is meant to be an offset into the buffer. E.g.: The first index to render. Leading to a new usage of glDrawElements:

size_t firstIndex = ...
size_t indexDataSize = sizeof(GLuint);
glDrawElements(GL_TRIANGLES, numIndexes, GL_UNSIGNED_INT, reinterpret_cast<const GLvoid *>(firstIndex * indexDataSize));

This applies to all the older functions that were repurposed on modern OpenGL, like glDrawElementsInstanced, glDrawElementsBaseVertex, glDrawRangeElements and others.

Now in the specific case of glVertexAttribPointer:

void glVertexAttribPointer(GLuint index​, GLint size​, GLenum type​, GLboolean normalized​, GLsizei stride​, const GLvoid * pointer​);

The const GLvoid * pointer​ parameter is an offset in bytes from the beginning of the vertex to the given element. Again, it was kept like this because the function existed before Vertex/Index Buffers and was repurposed to work with them, whereas in the immediate mode days, you would pass an array of vertexes as the 'pointer' parameter.

So in the old days, glVertexAttribPointer would be used somewhat like:

const vec3 positions[] = { ... };
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, positions);

And in modern GL, you would use:

struct Vert {
    vec3 position;
    vec3 normal;
};

size_t offset;

offset = offsetof(Vert, position);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, reinterpret_cast<const GLvoid *>(offset));

offset = offsetof(Vert, normal);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, reinterpret_cast<const GLvoid *>(offset));

Answer 3

It's called void pointer and it can point at any type, like char* does - but it's slightly different. Firstly you have to remember that the pointer is just a number, an address to right location, nothing more. To use data pointed by void pointer you have to explicitly cast it to correct type, they cannot be dereferenced directly. They allow you to skip type checking and they should be avoided.

Another difference I see is clarity of intentions. When you see char* pointer you can't be sure it'll point at char/char array. It can be something else, it's highly situational: I saw cases when it's confusing, sometimes it's obvious; on the other hand void pointer intentions are clear: it can be really anything and you have to consider the context of application to find the type.

Another thing is pointer arithmetics, AFAIR in case of void pointers it's not defined by standard.

I guess void pointers in OpenGL are used to make API more general, giving more control to drivers (it makes changing types from floats to doubles easier, by settings). But that's only speculation, confirmation is needed.