使用 VAO 在 OpenGL 中实例化顺序更改绘制

Question

我尝试使用 VAO、VBO 和 IBO 在平面上绘制一堆球体。在使用这些之前，一切都按预期绘制。在我开始使用这些之后，事情变得很奇怪。我不能在这里 post 我的整个代码，因为我有 5 个 class es（但如果有必要，我可以为我的代码提供 link），所以我会尝试 post 我认为有用的东西。

有了这个class我可以画一个球体：

SphereShaderProgram::SphereShaderProgram(std::string vertexShaderPath, std::string fragmentShaderPath) : ProgramManager(vertexShaderPath, fragmentShaderPath)
{
    _sphereH = 20;
    _sphereW = 20;
    _vbo = 0;
    _vao = 0;
    _ibo = 0;
    CreateProgram();
    BuildSphere();
    BuildVAO();
}


SphereShaderProgram::~SphereShaderProgram()
{
    glDeleteVertexArrays(1, &_vao);
    glDeleteBuffers(1, &_vbo);
    glDeleteBuffers(1, &_ibo);
}


void SphereShaderProgram::DrawSphere(const glm::mat4 &Projection, const glm::mat4 &ModelView)
{
    _ModelViewProjection = Projection * ModelView;
    _ModelView = ModelView;

    Bind(); //glUseProgram

    glBindVertexArray(_vao);
    LoadVariables();
    glDrawElements(GL_TRIANGLES, _sphereIndexes.size(), GL_UNSIGNED_INT, 0);
    glBindVertexArray(0);

    UnBind();
}


int SphereShaderProgram::Get1DIndex(int line, int column)
{
    return line * (int) _sphereH + column;
}


void SphereShaderProgram::BuildSphere()
{
    for (int l = 0; l < _sphereH - 1; l++)
    {
        for (int c = 0; c < _sphereW - 1; c++)
        {
            int v1_1 = Get1DIndex(l, c);
            int v2_1 = Get1DIndex(l + 1, c + 1);
            int v3_1 = Get1DIndex(l + 1, c);

            int v1_2 = Get1DIndex(l, c);
            int v2_2 = Get1DIndex(l, c + 1);
            int v3_2 = Get1DIndex(l + 1, c + 1);

            _sphereIndexes.push_back(v1_1);
            _sphereIndexes.push_back(v2_1);
            _sphereIndexes.push_back(v3_1);

            _sphereIndexes.push_back(v1_2);
            _sphereIndexes.push_back(v2_2);
            _sphereIndexes.push_back(v3_2);
        }
    }

    for (int l = 0; l < _sphereH; l++)
    {
        for (int c = 0; c < _sphereW; c++)
        {
            float theta = ((float) l / (_sphereH - 1)) * (float) PI;
            float phi = ((float) c / (_sphereW - 1)) * 2 * (float) PI;
            float x = sin(theta) * cos(phi);
            float z = sin(theta) * sin(phi);
            float y = cos(theta);

            _sphereCoordinates.push_back(x);
            _sphereCoordinates.push_back(y);
            _sphereCoordinates.push_back(z);
        }
    }
}


void SphereShaderProgram::BuildVAO()
{
    // Generate and bind the vertex array object
    glGenVertexArrays(1, &_vao);
    glBindVertexArray(_vao);

    // Generate and bind the vertex buffer object
    glGenBuffers(1, &_vbo);
    glBindBuffer(GL_ARRAY_BUFFER, _vbo);
    glBufferData(GL_ARRAY_BUFFER, _sphereCoordinates.size() * sizeof(float), &_sphereCoordinates[0], GL_STATIC_DRAW);

    // Generate and bind the index buffer object
    glGenBuffers(1, &_ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ibo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, _sphereIndexes.size() * sizeof(unsigned int), &_sphereIndexes[0], GL_STATIC_DRAW);

    glBindVertexArray(0);
}


void SphereShaderProgram::LoadUniformVariables()
{
    glm::mat4 MVP = _ModelViewProjection;
    glm::mat4 MV = _ModelView;
    glm::mat3 N = glm::transpose(glm::inverse(glm::mat3(MV)));
    glm::vec4 AC = glm::vec4(0.2, 0.2, 0.2, 1.0);
    glm::vec4 DC = glm::vec4(0.7, 0.0, 0.0, 1.0);
    glm::vec4 SC = glm::vec4(0.1, 0.1, 0.1, 1.0);
    glm::vec3 LP = glm::vec3(1.0, 6.0, 4.0);

    // OpenGL Matrices 
    GLuint ModelViewProjection_location = glGetUniformLocation(GetProgramID(), "mvpMatrix");
    glUniformMatrix4fv(ModelViewProjection_location, 1, GL_FALSE, glm::value_ptr(MVP));

    GLuint ModelView_location = glGetUniformLocation(GetProgramID(), "mvMatrix");
    glUniformMatrix4fv(ModelView_location, 1, GL_FALSE, glm::value_ptr(MV));

    GLuint Normal_location = glGetUniformLocation(GetProgramID(), "normalMatrix");
    glUniformMatrix3fv(Normal_location, 1, GL_FALSE, glm::value_ptr(N));

    // Lighting 
    GLuint AmbientColor_location = glGetUniformLocation(GetProgramID(), "ambientColor");
    glUniform4fv(AmbientColor_location, 1, glm::value_ptr(AC));

    GLuint DiffuseColor_location = glGetUniformLocation(GetProgramID(), "diffuseColor");
    glUniform4fv(DiffuseColor_location, 1, glm::value_ptr(DC));

    GLuint SpecularColor_location = glGetUniformLocation(GetProgramID(), "specularColor");
    glUniform4fv(SpecularColor_location, 1, glm::value_ptr(SC));

    GLuint LightPosition_location = glGetUniformLocation(GetProgramID(), "vLightPosition");
    glUniform3fv(LightPosition_location, 1, glm::value_ptr(LP));
}


void SphereShaderProgram::LoadAtributeVariables()
{
    // Vertex Attributes
    GLuint VertexPosition_location = glGetAttribLocation(GetProgramID(), "vPosition");
    glEnableVertexAttribArray(VertexPosition_location);

    glVertexAttribPointer(VertexPosition_location, 3, GL_FLOAT, GL_FALSE, 0, 0);
}


void SphereShaderProgram::LoadVariables()
{
    LoadUniformVariables();
    LoadAtributeVariables();
}

然后，一架飞机：

PlaneShaderProgram::PlaneShaderProgram(std::string vertexShaderPath, std::string fragmentShaderPath) : ProgramManager(vertexShaderPath, fragmentShaderPath)
{
    CreateProgram();
    _vbo = 0;
    _vao = 0;
    _ibo = 0;
    BuildPlane();
    BuildVAO();
}


PlaneShaderProgram::~PlaneShaderProgram()
{
    glDeleteVertexArrays(1, &_vao);
    glDeleteBuffers(1, &_vbo);
    glDeleteBuffers(1, &_ibo);
}


void PlaneShaderProgram::DrawPlane(const glm::mat4 &Projection, const glm::mat4 &ModelView)
{
    _ModelViewProjection = Projection * ModelView;
    _ModelView = ModelView;

    Bind();

    glBindVertexArray(_vao);
    LoadVariables();
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
    glBindVertexArray(0);

    UnBind();
}


void PlaneShaderProgram::BuildPlane()
{
    _coordinates[0]  = -1.0f;
    _coordinates[1]  =  0.0f;
    _coordinates[2]  = -1.0f;
    _coordinates[3]  = -1.0f;
    _coordinates[4]  =  0.0f;
    _coordinates[5]  =  1.0f;
    _coordinates[6]  =  1.0f;
    _coordinates[7]  =  0.0f;
    _coordinates[8]  =  1.0f;
    _coordinates[9]  =  1.0f;
    _coordinates[10] =  0.0f; 
    _coordinates[11] = -1.0f;

    _indexes[0] = 0;
    _indexes[1] = 1;
    _indexes[2] = 2;
    _indexes[3] = 0;
    _indexes[4] = 2;
    _indexes[5] = 3;
}


void PlaneShaderProgram::BuildVAO()
{
    // Generate and bind the vertex array object
    glGenVertexArrays(1, &_vao);
    glBindVertexArray(_vao);

    // Generate and bind the vertex buffer object
    glGenBuffers(1, &_vbo);
    glBindBuffer(GL_ARRAY_BUFFER, _vbo);
    glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLfloat), _coordinates, GL_STATIC_DRAW);

    // Generate and bind the index buffer object
    glGenBuffers(1, &_ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ibo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * sizeof(GLuint), _indexes, GL_STATIC_DRAW);

    glBindVertexArray(0);
}


void PlaneShaderProgram::LoadUniformVariables()
{
    // OpenGL Matrices
    GLuint ModelViewProjection_location = glGetUniformLocation(GetProgramID(), "mvpMatrix");
    glUniformMatrix4fv(ModelViewProjection_location, 1, GL_FALSE, glm::value_ptr(_ModelViewProjection));
}


void PlaneShaderProgram::LoadAtributeVariables()
{
    // Vertex Attributes
    GLuint VertexPosition_location = glGetAttribLocation(GetProgramID(), "vPosition");
    glEnableVertexAttribArray(VertexPosition_location);

    glVertexAttribPointer(VertexPosition_location, 3, GL_FLOAT, GL_FALSE, 0, 0);
}


void PlaneShaderProgram::LoadVariables()
{
    LoadUniformVariables();
    LoadAtributeVariables();
}

另一方面，这是我的主要内容：

int main(void)
{
    // Set the error callback  
    glfwSetErrorCallback(ErrorCallback);

    // Initialize GLFW  
    if (!glfwInit())
    {
        printf("Error initializing GLFW!\n");
        exit(EXIT_FAILURE);
    }

    // Set the GLFW window creation hints - these are optional  
    glfwWindowHint(GLFW_SAMPLES, 4);

    // Create a window and create its OpenGL context    
    GLFWwindow* window = glfwCreateWindow(width, height, "OpenGL 4 Base", NULL, NULL);

    // If the window couldn't be created  
    if (!window)
    {
        fprintf(stderr, "Failed to open GLFW window.\n");
        glfwTerminate();
        exit(EXIT_FAILURE);
    }

    // Sets the context of the specified window on the calling thread  
    glfwMakeContextCurrent(window);

    // Initialize GLEW
    glewExperimental = true;
    GLenum glewError = glewInit();
    if (glewError != GLEW_OK)
    {
        printf("Error initializing GLEW! %s\n", glewGetErrorString(glewError));
        glfwDestroyWindow(window);
        glfwTerminate();
        exit(EXIT_FAILURE);
    }

    glfwSetKeyCallback(window, KeyCallback);
    glfwSetWindowSizeCallback(window, WindowSizeCallback);
    glfwSetScrollCallback(window, ScrollCallback);

    // Set the view matrix
    glm::mat4 ModelView = glm::lookAt(glm::vec3(0.0f, 7.0f, 15.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));

    // Init matrix stack
    glm_ModelViewMatrix.push(ModelView);

    PlaneShaderProgram PlaneShaderProgram("FloorVertexShader.txt", "FloorFragShader.txt");
    SphereShaderProgram SphereShaderProgram("ADSPerVertexVertexShader.txt", "ADSPerVertexFragShader.txt");
    //SphereShaderProgram SphereShaderProgram = SphereShaderProgram("ADSPerPixelVertexShader.txt", "ADSPerPixelFragShader.txt");

    // Set a background color  
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    // 3D objects
    glEnable(GL_DEPTH_TEST);

    float d = 2.0f;
    float p0 = -10.0f + d / 2;
    // Main Loop  
    while (!glfwWindowShouldClose(window))
    {
        // Clear color buffer  
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // Clone current modelview matrix, which can now be modified 
        glm_ModelViewMatrix.push(glm_ModelViewMatrix.top());
        {
            //------- ModelView Transformations
            // Zoom in/out
            glm_ModelViewMatrix.top() = glm::translate(glm_ModelViewMatrix.top(), glm::vec3(0.0, 0.0, zoom));
            // Rotation
            glm_ModelViewMatrix.top() = glm::rotate(glm_ModelViewMatrix.top(), beta, glm::vec3(1.0, 0.0, 0.0));
            glm_ModelViewMatrix.top() = glm::rotate(glm_ModelViewMatrix.top(), alpha, glm::vec3(0.0, 0.0, 1.0));

            //------- Draw the plane
            glm_ModelViewMatrix.push(glm_ModelViewMatrix.top());
            {
                glm_ModelViewMatrix.top() = glm::scale(glm_ModelViewMatrix.top(), glm::vec3(7.0f, 1.0f, 7.0f));

                PlaneShaderProgram.DrawPlane(Projection, glm_ModelViewMatrix.top());
            }
            glm_ModelViewMatrix.pop();

            //------- Draw spheres
            for (int i = 0; i < 10; i++)
            {
                for (int j = 0; j < 10; j++)
                {
                    glm_ModelViewMatrix.push(glm_ModelViewMatrix.top());
                    {
                        glm_ModelViewMatrix.top() = glm::scale(glm_ModelViewMatrix.top(), glm::vec3(0.5f, 0.5f, 0.5f));
                        glm_ModelViewMatrix.top() = glm::translate(glm_ModelViewMatrix.top(), glm::vec3(p0 + i * d, 1.0f, p0 + j * d));

                        SphereShaderProgram.DrawSphere(Projection, glm_ModelViewMatrix.top());
                    }
                    glm_ModelViewMatrix.pop();
                }
            }
        }
        glm_ModelViewMatrix.pop();

        // Swap buffers  
        glfwSwapBuffers(window);

        // Get and organize events, like keyboard and mouse input, window resizing, etc...  
        glfwPollEvents();
    }

    // Close OpenGL window and terminate GLFW  
    glfwDestroyWindow(window);
    // Finalize and clean up GLFW  
    glfwTerminate();

    exit(EXIT_SUCCESS);
}

先实例化平面再实例化球体程序，结果如下（根本没有平面）：

换个顺序，就是结果：

我正在尝试找到关于我遗漏了什么的线索，因为我不知道哪里出了问题。在使用 VAO 之前（仅使用 glVertexAttribPointer 和 glDrawElements），所有内容都已正确绘制。

提前谢谢你。

Answer 1

问题出在 glVertexAttribPointer() 调用的位置。您在 LoadAtributeVariables() 方法中调用它，而该方法又从 Draw*() 方法中调用。

这确实应该是 VAO 设置的一部分，原因如下：

在每次重绘时调用是低效的。此调用设置属于 VAO 状态一部分的状态。这就是首先使用 VAO 的全部想法。您可以在设置期间设置一次所有这些状态，然后只需要在绘制调用之前再次绑定 VAO，这将通过一次调用再次设置所有状态。
在您的情况下，VBO 在您进行调用时未绑定。 glVertexAttribPointer() 设置属性以从 当前绑定的 VBO 中提取数据，即缓冲区绑定为 GL_ARRAY_BUFFER.

第一个问题只是性能问题。第二个是您的代码不起作用的原因，因为在调用 glVertexAttribPointer() 时您没有正确的 VBO 绑定。

要解决此问题，您只需将 LoadAtributeVariables() 调用移动到 BuildVAO()，位于以下位置：

// Generate and bind the vertex buffer object
glGenBuffers(1, &_vbo);
glBindBuffer(GL_ARRAY_BUFFER, _vbo);
glBufferData(GL_ARRAY_BUFFER, _sphereCoordinates.size() * sizeof(float), &_sphereCoordinates[0], GL_STATIC_DRAW);

LoadAtributeVariables();

并将其从当前位置移除，这样它就不会再在每次绘制调用之前被调用。

使用 VAO 在 OpenGL 中实例化顺序更改绘制

Instantiation order changing draw in OpenGL using VAO

c++

opengl

vbo

vao