OpenGL Vertex Array Object usage

Question

I have been working to get OpenGL to render multiple different entities on the scene.

According to http://www.opengl.org/wiki/Vertex_Specification,

Vertex Array Object should remember what Vertex Buffer Object was bound to GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER. (Or at least that is how I understood what it was saying)

Yet, even though I call draw after binding any vao, the application will use only the last one bound to GL_ARRAY_BUFFER.

Question - Am I understanding it right? Considering the code below, is all sequence of calling to gl functions is correct?

void OglLayer::InitBuffer()
{
    std::vector<float> out;
    std::vector<unsigned> ibOut;

    glGenVertexArrays(V_COUNT, vaos);
    glGenBuffers(B_COUNT, buffers);

    // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= //
    glBindVertexArray(vaos[V_PLANE]);

    PlaneBuffer(out, ibOut, 0.5f, 0.5f, divCount, divCount);

    OGL_CALL(glBindBuffer(GL_ARRAY_BUFFER, buffers[B_PLANE_VERTEX]));
    OGL_CALL(glBufferData(GL_ARRAY_BUFFER, out.size()*sizeof(float), out.data(), GL_DYNAMIC_DRAW));
    //GLuint vPosition = glGetAttribLocation( programs[P_PLANE], "vPosition" );
    OGL_CALL(glEnableVertexAttribArray(0));
    //OGL_CALL(glVertexAttribPointer( vPosition, 3, GL_FLOAT, GL_FALSE, sizeof(float)*3, BUFFER_OFFSET(0) ));
    OGL_CALL(glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, sizeof(float)*3, BUFFER_OFFSET(0) ));
    bufferData[B_PLANE_VERTEX].cbSize = sizeof(float) * out.size();
    bufferData[B_PLANE_VERTEX].elementCount = out.size()/3;
    OGL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[B_PLANE_INDEX]));
    OGL_CALL(glBufferData(GL_ELEMENT_ARRAY_BUFFER, ibOut.size()*sizeof(unsigned), ibOut.data(), GL_STATIC_DRAW));
    bufferData[B_PLANE_INDEX].cbSize = sizeof(float) * ibOut.size();
    bufferData[B_PLANE_INDEX].elementCount = ibOut.size();

    // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= //
    glBindVertexArray(vaos[V_CUBE]);

    out.clear();
    ibOut.clear();

    GenCubeMesh(out, ibOut);

    glBindBuffer(GL_ARRAY_BUFFER, buffers[B_CUBE_VERTEX]);
    glBufferData(GL_ARRAY_BUFFER, out.size()*sizeof(float), out.data(), GL_STATIC_DRAW);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3*sizeof(float), BUFFER_OFFSET(0));
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[B_CUBE_INDEX]);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned), ibOut.data(), GL_STATIC_DRAW);
}


void RenderPlane::Render( float dt )
{            
    // Putting any vao here always results in using the lastly buffer bound.
    OGL_CALL(glBindVertexArray(g_ogl.vaos[m_pRender->vao]));

    {
        OGL_CALL(glUseProgram(g_ogl.programs[m_pRender->program]));

        // uniform location
        GLint loc = 0;

        // Send Transform Matrix ( Rotate Cube over time )
        loc = glGetUniformLocation(g_ogl.programs[m_pRender->program], "transfMat");
        auto transf = m_pRender->pParent->m_transform->CreateTransformMatrix();
        glUniformMatrix4fv(loc, 1, GL_TRUE, &transf.matrix()(0,0));

        // Send View Matrix
        loc = glGetUniformLocation(g_ogl.programs[m_pRender->program], "viewMat");
        mat4 view = g_ogl.camera.transf().inverse();
        glUniformMatrix4fv(loc, 1, GL_TRUE, &view(0,0));

        // Send Projection Matrix
        loc = glGetUniformLocation(g_ogl.programs[m_pRender->program], "projMat");
        mat4 proj = g_ogl.camera.proj();
        glUniformMatrix4fv(loc, 1, GL_TRUE, &proj(0,0));
    }

    OGL_CALL(glDrawElements(GL_TRIANGLES, g_ogl.bufferData[m_pRender->ib].elementCount, GL_UNSIGNED_INT, 0));
}

Reto Koradi Reto Koradi · Accepted Answer · 2014-09-11T19:00:53

The GL_ARRAY_BUFFER binding is not part of the VAO state. The wiki page you link explains that correctly:

Note: The GL_ARRAY_BUFFER binding is NOT part of the VAO's state! I know that's confusing, but that's the way it is.

The GL_ELEMENT_ARRAY_BUFFER binding on the other hand is part of the VAO state.

While I don't completely disagree with calling this confusing, it actually does make sense if you start thinking about it. The goal of a VAO is to capture all vertex state that you would typically set up before making a draw call. When using indexed rendering, this includes binding the proper index buffer used for the draw call. Therefore, including the GL_ELEMENT_ARRAY_BUFFER binding in the VAO state makes complete sense.

On the other hand, the current GL_ARRAY_BUFFER binding does not influence a draw call at all. It only matters that the correct binding is established before calling glVertexAttribPointer(). And all the state set by glVertexAttribPointer() is part of the VAO state. So the VAO state contains the vertex buffer reference used for each attribute, which is established by the glVertexAttribPointer() call. The current GL_ARRAY_BUFFER on the other hand is not part of the VAO state because the current binding at the time of the draw call does not have any effect on the draw call.

Another way of looking at this: Since attributes used for a draw call can be pulled from different vertex buffers, having a single vertex buffer binding tracked in the VAO state would not be useful. On the other hand, since OpenGL only ever uses a single index buffer for a draw call, and uses the current index buffer binding for the draw call, tracking the index buffer binding in the VAO makes sense.

OpenGL Vertex Array Object usage

1 Answers