使用VAO在OpenGL中更改實例化順序繪制

Question

我試圖使用VAO，VBO和IBO在飛機上繪制一堆球體。 在使用它們之前，一切都按預期繪制。 在我開始使用它們之后，事情變得很奇怪。 我不能在這里發布整個代碼，因為我有5個類（但是如果需要，我可以提供指向我的代碼的鏈接），所以我將嘗試發布我認為有用的內容。

通過本課程，我可以畫一個球體：

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 ），一切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();

並將其從當前位置刪除，以便不再在每次繪制調用之前調用它。