glVertexAttribPointer clarification

by

Some of the terminology is a bit off:

  • A Vertex Array is 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 Object or VAO, which I will go over later
  • A Buffer Object, commonly referred to as a Vertex Buffer Object when storing vertices, or VBO for short, is what you’re calling just a Buffer.
  • Nothing gets saved back to the vertex array, glVertexAttribPointer works exactly like glVertexPointer or glTexCoordPointer work, just instead of named attributes, you get to provide a number that specifies your own attribute. You pass this value as index. All your glVertexAttribPointer calls get queued up for the next time you call glDrawArrays or 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:

  1. 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 glEnableVertexAttribArray(0);.
  2. 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 – glBindBuffer(GL_ARRAY_BUFFER, myBuffer);.
  3. 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_FLOAT is the type, GL_FALSE means to not normalize each vertex, the last 2 zeros mean that there’s no stride or offset on the vertices.
  4. Draw something with it – glDrawArrays(GL_TRIANGLES, 0, 6);
  5. The next thing you draw may not use attribute 0 (realistically it will, but this is an example), so we can disable it – glDisableVertexAttribArray(0);

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(0,...); to 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.

A 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 glBindVertexArray, then do a full draw call. All the draw bind calls get intercepted and stored by the VAO. You can unbind the VAO with glBindVertexArray(0);

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 glDrawArrays or 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.

More Related Contents:

  1. How do I compose a rotation matrix with human readable angles from scratch?
  2. Rendering meshes with multiple indices
  3. Should I ever use a `vec3` inside of a uniform buffer or shader storage buffer object?
  4. About OpenGL texture coordinates
  5. How to render depth linearly in modern OpenGL with gl_FragCoord.z in fragment shader?
  6. how should i handle (morphing) 4D objects in opengl? [closed]
  7. Why transform normals with the transpose of the inverse of the modelview matrix?
  8. How to use GLUT/OpenGL to render to a file?
  9. How does OpenGL work at the lowest level? [closed]
  10. glVertexAttribPointer and glVertexAttribFormat: What’s the difference?
  11. Rotating a Group of Vectors
  12. GLSL fixed function fragment program replacement
  13. What does “immediate mode” mean in OpenGL?
  14. Matrix inverse accuracy
  15. Is OpenGL coordinate system left-handed or right-handed?
  16. The purpose of Model View Projection Matrix
  17. depth buffer got by glReadPixels is always 1
  18. Why does OpenGL not support multiple index buffering?
  19. Using GLEW to use OpenGL extensions under Windows
  20. Using the mouse scrollwheel in GLUT
  21. Opengl pixel perfect 2D drawing
  22. How do I find my mouse point in a scene using SceneKit?
  23. What are Vertex Array Objects?
  24. Initializing OpenGL without GLUT
  25. Multiple textures in GLSL – only one works
  26. Is it possible to rotate an object around its own axis and not around the base coordinate’s axis?
  27. GLSL, semaphores?
  28. How to cast int to const GLvoid*?
  29. Frequency of shader invocations in rendering commands
  30. What are shaders in OpenGL and what do we need them for? [closed]

Leave a Comment