Note: both VAO and VBO are used to store vertex information and send it to vertex shader. As for what are vertices and vertices Shaders , I won't say much here. Readers who don't understand CSDN can do it by themselves.

B in VBO means Buffer, which is used to store vertex data; The A of VAO is Array, but I think it is better understood as attribute, which means the attribute of Buffer(VBO).

That is, we use VBO to store data, and VAO to tell the computer what properties and functions these data have respectively.

1, Role of VBO

VBO is the bridge between CPU and GPU to transfer information. We store the data in VBO (this step is executed by CPU), and then VBO will automatically send the data to GPU.

Send GPU In this step, no human operation is required. The user is only responsible for storing data into VBO. As follows:

However, for GPU, VBO is just a pile of numbers. How to explain them? This requires VAO.

2, Role of VAO

VBO is to transfer vertex data to GPU, and VAO is to interpret vertex data to GPU. Some readers will wonder that the vertex data is nothing more than three-dimensional coordinates. Three are a group, and they are transmitted. Why do you need to explain? Let's look at the data in VBO:

float buffer = {
   	//Vertex coordinates (in groups of 3) / / vertex colors (in groups of 3) / / texture coordinates (in groups of 2)
    0.5f,  0.5f, 0.0f,                1.0f, 0.0f, 0.0f,               1.0f, 1.0f,
    0.5f, -0.5f, 0.0f,                0.0f, 1.0f, 0.0f,               1.0f, 0.0f,
   -0.5f, -0.5f, 0.0f,                0.0f, 0.0f, 1.0f,               0.0f, 0.0f,
   -0.5f,  0.5f, 0.0f,                1.0f, 1.0f, 0.0f,               0.0f, 1.0f
};
//The above data is only fabricated by this blog post and has no practical significance

   

It can be seen from the above data that the vertex data is not just three-dimensional coordinates in a group!

If we pass the above information into VBO buffer And VBO sends them to the GPU.

However, vertex shaders don't know how to interpret these numbers, whether to group them in three, first three, then two, or three, two, three?

GPU doesn't know.

This requires the participation of VAO, which is responsible for telling GPU how many information in VBO should be grouped. The following program is to save the description of the data in VBO into a VAO:

	//vertex coord
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);
    // color attribute
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1);
    // texture coord attribute
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
    glEnableVertexAttribArray(2);

   

The above program seems to have three sections (glVertexAttribPointer() + glEnableVertexAttribArray()) as one section), but they all exist in the same VAO. (the functions of glVertexAttribPointer() and glEnableVertexAttribArray() will not be introduced here. Readers who don't understand can check online.)

In some complex OpenGL programs, there may be multiple vbos, but there is only one VAO. So, how to use a VAO to explain multiple vbos?

3, One VAO and multiple vbos

In OpenGL programs, there may be multiple vbos, but there is only one VAO. So, how to use a VAO to explain multiple vbos?

This involves OpenGL Context knowledge: a complete OpenGL program is equivalent to a container. When we use VAO and VBO, we need to Bind (Bind operation) first and then use it. VAO/VBO without binding does not work.

The relationship between one VAO and multiple vbos is roughly as follows:

Then, according to the relationship between one VAO and multiple vbos and the knowledge of OpenGL context (binding), the operation process of using one VAO to explain multiple vbos is as follows:

First, bind VAO，To inform OpenGL The program should use this VAO Right VBO Explain.