Some of the terminology is a bit off:
Vertex Arrayis just an array (typically a
float) that contains vertex data. It doesn’t need to be bound to anything. Not to be confused with a
Vertex Array Objector VAO, which I will go over later
Buffer Object, commonly referred to as a
Vertex Buffer Objectwhen storing vertices, or VBO for short, is what you’re calling just a
- Nothing gets saved back to the vertex array,
glVertexAttribPointerworks exactly like
glTexCoordPointerwork, just instead of named attributes, you get to provide a number that specifies your own attribute. You pass this value as
index. All your
glVertexAttribPointercalls get queued up for the next time you call
glDrawElements. If you have a VAO bound, the VAO will store the settings for all your attributes.
The main issue here is that you’re confusing vertex attributes with VAOs. Vertex attributes are just the new way of defining vertices, texcoords, normals, etc. for drawing. VAOs store state. I’m first going to explain how drawing works with vertex attributes, then explain how you can cut down the number of method calls with VAOs:
- You must enable an attribute before you can use it in a shader. For example, if you want to send vertices over to a shader, you’re most likely going to send it as the first attribute, 0. So before you render, you need to enable it with
- Now that an attribute is enabled, you need to define the data it’s going to use. In order to do so you need to bind your VBO –
- And now we can define the attribute –
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);. In order of parameter: 0 is the attribute you’re defining, 3 is the size of each vertex,
GL_FLOATis the type,
GL_FALSEmeans to not normalize each vertex, the last 2 zeros mean that there’s no stride or offset on the vertices.
- Draw something with it –
glDrawArrays(GL_TRIANGLES, 0, 6);
- The next thing you draw may not use attribute 0 (realistically it will, but this is an example), so we can disable it –
Wrap that in
glUseProgram() calls and you have a rendering system that works with shaders properly. But let’s say you have 5 different attributes, vertices, texcoords, normals, color, and lightmap coordinates. First of all, you would be making a single
glVertexAttribPointer call for each of these attributes, and you’d have to enable all the attributes beforehand. Let’s say you define the attributes 0-4 as I have them listed. You would enable all of them like so:
for (int i = 0; i < 5; i++) glEnableVertexAttribArray(i);
And then you would have to bind different VBOs for each attribute (unless you store them all in one VBO and use offsets/stride), then you need to make 5 different
glVertexAttribPointer calls, from
glVertexAttribPointer(4,...); for vertices to lightmap coordinates respectively.
Hopefully that system alone makes sense. Now I’m going to move on to VAOs to explain how to use them to cut down on the number of method calls when doing this type of rendering. Note that using a VAO is not necessary.
Vertex Array Object or VAO is used to store the state of all the
glVertexAttribPointer calls and the VBOs that were targeted when each of the
glVertexAttribPointer calls were made.
You generate one with a call to
glGenVertexArrays. To store everything you need in a VAO, bind it with
, then do a full draw call. All the draw bind calls get intercepted and stored by the VAO. You can unbind the VAO with
Now when you want to draw the object, you don’t need to re-call all the VBO binds or the
glVertexAttribPointer calls, you just need to bind the VAO with
glBindVertexArray then call
glDrawElements and you’ll be drawing the exact same thing as though you were making all those method calls. You probably want to unbind the VAO afterwards too.
Once you unbind the VAO, all the state returns to how it was before you bound the VAO. I’m not sure if any changes you make while the VAO is bound is kept, but that can easily be figured out with a test program. I guess you can think of
glBindVertexArray(0); as binding to the “default” VAO…
Update: Someone brought to my attention the need for the actual draw call. As it turns out, you don’t actually need to do a FULL draw call when setting up the VAO, just all the binding stuff. Don’t know why I thought it was necessary earlier, but it’s fixed now.