I was confused about the VBO,
glGenBuffers(1, &positionBufferObject);
glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
Besides GL_ARRAY_BUFFER, there are other target types: GL_ATOMIC_COUNTER_BUFFER, GL_COPY_READ_BUFFER...
However, the Opengl manual doesn't mention what these targets mean. I checked the glew.h:
#define GL_ARRAY_BUFFER 0x8892
Does this mean the targets (like GL_ARRAY_BUFFER) are addresses?
What does the target--GL_ARRAY_BUFFER mean in glBindBuffer?
Most OpenGL objects must be bound to locations in the OpenGL context called "targets" for them to be used. A target is nothing more than a place in the context where objects are bound.
Different object types (buffers, textures, etc) have different sets of targets. Generally speaking, each target has a specific meaning: to bind one object to one target means that you want to use that object in whatever manner that target uses objects bound to it.
Binding an object to one target does not affect whether the object is bound to another target (unless it's a texture object; they treat targets differently).
There are functions that modify objects or query data from bound objects. They take a target to which the object they are modifying/querying has been bound.
The GL_ARRAY_BUFFER target for buffer objects represents the intent to use that buffer object for vertex attribute data. However, binding to this target alone doesn't do anything; it's only the call to glVertexAttribPointer (or equivalent functions) that uses whatever buffer was bound to that target for the attribute data for that attribute.
However, the Opengl manual doesn't mention what these targets mean.
OpenGL 2.1 spec, page 38, section 2.9.1: "Vertex Arrays In Buffer Objects"
Does this mean the targets (like GL_ARRAY_BUFFER) are addresses?
Nope, they're just unsigned ints used like enums.
I will try my best to explain in short.
In OpenGL the target is a specific interface, which can deal with one object of its type at the time. Each target has a set of parameters affecting all its objects, which are stored internally, revealing only their ids. The API never allows the user to directly access those objects, because the wrong pointer can lead to much more damage than the wrong id.
Targets are not connected, so you can use the objects of different types simultaneously. The object id allows you to switch between the objects of the same type while using the same interface. You have to bind the object id to the specific target prior to deal with it, and then unbind it to free its interface, or directly bind another object id to the same target, which automatically unbinds previous object. Note that after binding an id to a target for the first time, the object becomes active, and can no longer be bound to another target. This is the basic concept of the API.
The first line in your code gets the buffer id.
The second line binds the id to GL_ARRAY_BUFFER target, which may by described as setting up internally the Vertex attributes buffer object, or VBO. Now using this id you can refer to a particular internally stored VBO.
Hope that helps!
