Game Development Stack Exchange is a question and answer site for professional and independent game developers. It only takes a minute to sign up.
Sign up to join this community
I'm trying to learn about vertex arrays and vertex buffer objects, but I don't understand the differences in terms of:
some clarifications?
Here is a decent writeup about VBOs.
Performance
Here is a good overview of the calling semantics.
Here here is another good overview of performance issues; in it we see that VBOs are more performant than arrays.
The reason we prefer VBOs is that the data is loaded onto the card, and so you don't have to transfer it every frame. Depending on the type of VBO created, you can give the graphics driver hints on the usage (write-many, read-many vs. write-many, never-read, etc).
Usage
VBOs are really good for static geometry like terrain that you don't expect to change, or for instanced geometry.
Vertex arrays are good for data that changes frequently but that also is read by the host machine--so, for directly rendering data that is being manipulated (laser rangefinder data buffers, for example, are where I've used them) frequently. If you can get away with never reading the data on the host device (so, just pushing it out onto the card), VBOs in write-only mode are a good option.
Portability
Client Side Vertex Arrays These are available in OpenGL prior to 3.0, deprecated in 3.0, and gone in 3.1+. OpenGL ES supports them (OpenGL ES 2 does not).
VBOs These are available after OpenGL 1.5. These are the only way to store geometry data in OpenGL ES 2 (and so, WebGL).
(I'm adding this here due to the the fact that ChrisE's answer is highly ambiguous, which is unfortunately due to the ambiguity of the original question. However I'm going to assume the OP's question should have been titled "when to use VAOs and when to use VBOs".)
Vertex Buffer Objects (which really aren't dissimilar from other types of Buffer Objects, for example Uniform Buffer Objects) provide a means for uploading vertex data to the graphics hardware.
Vertex Array Objects are used in addition to VBOs in order to improve client-side (CPU-side) performance, by reducing the number of calls needed to rebind individual vertex buffers and re-set vertex attributes every time you want to change to render in a certain way. Instead of doing all that work every frame, you do it once (at initialisation), and then simply rebind the appropriate VAO for each (set of) draw call(s) that use the associated vertex attributes.
In spite of this, using VAOs does not release you from the additional responsibility of having to do glBindBuffer + glBufferData for any data that changes each frame, for instance, game entity positions / rotations / transform matrices. It is only when you have entirely static data that you need only do glBindVertexArray(&vao) -> glDraw*(...) -> glBindVertexArray(0) to render.
In short words VBO is an array of raw data, when VAO is an array of ATTRIBUTES - an instruction for shader program how to use the data.
VBO allows to keep data on GPU side, which saves transfer time, you just need to know VBO's id.
But VBO by itself is not enough. You have to instruct GPU how to use it. You have to define "Vertex Attribute Pointers" (command glVertexAttribPointer) for each attribute (input data variable) of your shader. Before VAO you had to define attributes for each glDrawArrays call (it's a lot), in every frame (like 30+ times per second). VAO allows to attach an entire array of attributes by just VAO's id. So, when VBO is relatively independent, the VAO is VBO+shader-specific.
