10

我遇到了一个非常奇怪的性能问题。到目前为止，我已经将问题简化为：我在网格中渲染 20x20x20 立方体，使用glDrawElementsInstanced，只要我的相机远离原点，它就可以正常工作，但是当它靠近原点时，它开始研磨停下来。

我通过以下方式定义我的模型视图投影矩阵：

float distance=3.8;
Projection = glm::perspective(65.0f, (float)(width)/height, 0.1f, 300.0f);
View  = glm::lookAt(    glm::vec3(0,0,-distance),
                        glm::vec3(0,0,10),
                        glm::vec3(0,1,0));
Model = glm::rotate(glm::mat4(1.0f), 0.0f, glm::vec3(0.25f, 1.0f,0.75f));

距离为 40 时，没有问题，但当距离减小到 3.8 或更低时，一切都停止了。

对渲染的实际调用是通过以下方式执行的：

glBindVertexArray(cubeVAO);
glDrawElementsInstanced(GL_TRIANGLES, indices.size(),GL_UNSIGNED_INT,(GLvoid*)(0),latticePoints.size());

将所有顶点放在一个缓冲区中并通过调用进行渲染：

glBindVertexArray(nonInstancedVAO);
glDrawArrays(GL_TRIANGLES, 0,vertices.size() );

完全消除该行为。任何经历过类似行为的人都可以为我指明解决方案的方向吗？如果失败了，有谁知道如何追踪这样的事情？我希望我能够使用 gDEBugger 确定导致速度下降的原因，但这只是再次确认没有任何其他 opengl 调用，并不能真正帮助找出占用所有处理时间的原因。

另一个注意事项是 glDrawArraysInstanced 也显示出相同的减速，并且将调用分成 4 个单独的调用，每个调用有四分之一的几何图形也可以阻止减速。

更新

这是对问题的最小说明的尝试。

//Minimal reproduction of problem

#include <stdio.h>
#include <string>
#include <fstream>
#include <stdlib.h>
#include <string.h>

#include <GL/glew.h>
#include <GLFW/glfw3.h>

// Include GLM
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#include <vector>
#include <iostream>
#include <stdio.h>

//Set to true to use instanced rendering (glDrawElementsInstanced), false to render a generated grid instead (glDrawElements)
    #define Instanced true

//Translation from origin. Problme is pressent at 0 distance, but disapears at ex. 40.
    const float distanceFromOrigin=0;

// Function to load shaders
GLuint LoadShaders(const char * vertex_file_path,const char * fragment_file_path);


    int main(){

    int     width, height;
    bool    running = true;

    // Initialise GLFW
    glfwInit();

    glfwWindowHint(GLFW_SAMPLES,1);
    glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT,GL_TRUE);
    glfwWindowHint(GLFW_VERSION_MAJOR, 4);

    GLFWwindow* windowRef = glfwCreateWindow( 512, 512, "",0,0);
    glfwMakeContextCurrent(windowRef);

    glewInit();

    //Load Shader
    GLuint programID = LoadShaders( "Simple.vs.c", "Simple.fs.c" );
    GLuint MatrixID = glGetUniformLocation(programID, "MVP");
    glUseProgram(programID);

    glm::mat4 Model,Projection,MVP,View,checkMVP;

    std::vector<GLuint>  sqIndice = {3,2,1,1,0,3,4,5,6,6,7,4,0,4,7,7,3,0,0,1,5,5,4,0,2,3,7,7,6,2,6,5,1,1,2,6,0,4,7,7,3,0};
    std::vector<GLfloat> sqVertex = {-1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, -1, -1};
    std::vector<GLfloat> sqColor = {0.2472,0.24,0.6,0.6,0.24,0.442893,0.6,0.547014,0.24,0.24,0.6,0.33692,0.24,0.353173,0.6,0.6,0.24,0.563266,0.6,0.426641,0.24,0.263452,0.6,0.24};

    const float lattice = 5;
    const int mxn = 10;
    std::vector<GLfloat> v1 = {lattice,-1,0};
    std::vector<GLfloat> v2 = {1,lattice,0};
    std::vector<GLfloat> v3 = {0,0,lattice};
    std::vector<GLfloat> offset = {0,0,-distanceFromOrigin};

    std::vector<GLfloat> latticePoints,sqVertexGrid,sqColorGrid;// = {0,0,0};
    std::vector<GLuint> sqIndiceGrid;
// Looping stuff to generate the full grid of "instances" to render in a single call. 
    int instanceCount=0;
//Generate Lattice vectors, aswell as a vector containing the full grids of indices,vertexes and colors
    for(int x=-mxn;x<mxn;++x){
        for(int y=-mxn;y<mxn;++y){
            for(int z=-mxn;z<mxn;++z){
                for(int n=0;n<3;++n){
                    latticePoints.push_back( x*v1[n]+y*v2[n]+z*v3[n]+offset[n] );
                };
                for(int elm=0;elm<sqVertex.size();elm+=3){
                    for(int n=0;n<3;++n){
                        sqVertexGrid.push_back(sqVertex[elm+n]+x*v1[n]+y*v2[n]+z*v3[n]+offset[n]);
                        sqColorGrid.push_back(sqColor[elm+n]);
                    };
                };
                for(int elm=0;elm<sqIndice.size();++elm){
                    sqIndiceGrid.push_back(sqIndice[elm]+instanceCount*sqVertex.size()/3);
                };
                ++instanceCount;glewInit

            };
        };
    };

#if Instanced==true
//Initialize and fill vertex,color and indice buffers with the relevant data.
GLuint cubeVAO;
    glGenVertexArrays(1, &cubeVAO);
    glBindVertexArray(cubeVAO);
    glEnable(GL_DEPTH_TEST);

//Vertex buffer
    GLuint vertexBuffer;
    glGenBuffers(1, &vertexBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sqVertex.size()*sizeof(GLfloat), &sqVertex[0], GL_STATIC_DRAW);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,0,(void*)0);

//Color buffer
    GLuint colorBuffer;
    glGenBuffers(1, &colorBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, colorBuffer);
    glBufferData(GL_ARRAY_BUFFER, sqColor.size()*sizeof(GLfloat), &sqColor[0], GL_STATIC_DRAW);
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,0,(void*)0);

// Indice buffer
    GLuint indicesBuffer;
    glGenBuffers(1, &indicesBuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indicesBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sqIndice.size()*sizeof(GLuint), &sqIndice[0], GL_STATIC_DRAW);

//Lattice point buffer
    GLuint latticePointBuffer;
    glGenBuffers(1, &latticePointBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, latticePointBuffer);
    glBufferData(GL_ARRAY_BUFFER, latticePoints.size()*sizeof(GLfloat), &latticePoints[0], GL_STATIC_DRAW);
    glEnableVertexAttribArray(2);
    glVertexAttribPointer(2,3,GL_FLOAT,GL_FALSE,0,(void*)0);
    glVertexAttribDivisor(2,1);

glBindVertexArray(0);
#elif Instanced==false
GLuint cubeGridVAO;
    glGenVertexArrays(1, &cubeGridVAO);
    glBindVertexArray(cubeGridVAO);
    glEnable(GL_DEPTH_TEST);

//Vertex buffer
    GLuint vertexBuffer;
    glGenBuffers(1, &vertexBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sqVertexGrid.size()*sizeof(GLfloat), &sqVertexGrid[0], GL_STATIC_DRAW);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,0,(void*)0);

//Color buffer
    GLuint colorBuffer;
    glGenBuffers(1, &colorBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, colorBuffer);
    glBufferData(GL_ARRAY_BUFFER, sqColorGrid.size()*sizeof(GLfloat), &sqColorGrid[0], GL_STATIC_DRAW);
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,0,(void*)0);

// Indice buffer
    GLuint indicesBuffer;
    glGenBuffers(1, &indicesBuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indicesBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sqIndiceGrid.size()*sizeof(GLuint), &sqIndiceGrid[0], GL_STATIC_DRAW);

glBindVertexArray(0);
#endif


while(running)
{
        glfwGetFramebufferSize(windowRef, &width, &height);
        height = height > 0 ? height : 1;

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        Projection = glm::perspective(65.0f, (float)(width)/height, 0.1f, 300.0f);
        View  = glm::lookAt(    glm::vec3(0.0f,0.0f,-(distanceFromOrigin+3.8f)),
                                glm::vec3(0.0f,0.0f,100.0f),
                                glm::vec3(0.0f,1.0f,0.0f));
        Model = glm::rotate(glm::mat4(1.0f), 0.0f, glm::vec3(0.25f, 1.0f,0.75f));

        MVP = Projection*View*Model;
        glUniformMatrix4fv(MatrixID, 1, GL_FALSE,  glm::value_ptr(MVP));

        #if Instanced==true
            glBindVertexArray(cubeVAO);
            glDrawElementsInstanced(GL_TRIANGLES, sqIndice.size(),GL_UNSIGNED_INT,(GLvoid*)(0),latticePoints.size());
        #elif Instanced==false
            glBindVertexArray(cubeGridVAO);
            glDrawElements(GL_TRIANGLES, sqIndiceGrid.size(),GL_UNSIGNED_INT,(GLvoid*)(0));
        #endif

        glfwPollEvents();
        glfwSwapBuffers(windowRef);

        std::cout<<".\n";

    running = !glfwGetKey(windowRef,GLFW_KEY_ESCAPE) && !glfwWindowShouldClose(windowRef);
    }

    glfwDestroyWindow(windowRef);
    glfwTerminate();

    return 0;
};

GLuint LoadShaders(const char * vertex_file_path,const char * fragment_file_path){

        // Create the shaders
        GLuint VertexShaderID   = glCreateShader(GL_VERTEX_SHADER);
        GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);

        // Read the Vertex Shader code from the file
        std::string VertexShaderCode;
        std::ifstream VertexShaderStream(vertex_file_path, std::ios::in);
        if(VertexShaderStream.is_open()){
                std::string Line = "";
                while(getline(VertexShaderStream, Line))
                        VertexShaderCode += "\n" + Line;
                VertexShaderStream.close();
        }else{
                printf("Impossible to open %s. Are you in the right directory?\n", vertex_file_path);
                return 0;
        }

        // Read the Fragment Shader code from the file
        std::string FragmentShaderCode;
        std::ifstream FragmentShaderStream(fragment_file_path, std::ios::in);
        if(FragmentShaderStream.is_open()){
                std::string Line = "";
                while(getline(FragmentShaderStream, Line))
                        FragmentShaderCode += "\n" + Line;
                FragmentShaderStream.close();
        }

        GLint Result = GL_FALSE;
        int InfoLogLength;

        // Compile Vertex Shader
        printf("Compiling shader : %s\n", vertex_file_path);
        char const * VertexSourcePointer = VertexShaderCode.c_str();
        glShaderSource(VertexShaderID, 1, &VertexSourcePointer , NULL);
        glCompileShader(VertexShaderID);

        // Check Vertex Shader
        glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
        glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
        if ( InfoLogLength > 0 ){
                std::vector<char> VertexShaderErrorMessage(InfoLogLength+1);
                glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
                printf("%s\n", &VertexShaderErrorMessage[0]);
        }

        // Compile Fragment Shader
        printf("Compiling shader : %s\n", fragment_file_path);
        char const * FragmentSourcePointer = FragmentShaderCode.c_str();
        glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer , NULL);
        glCompileShader(FragmentShaderID);

        // Check Fragment Shader
        glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
        glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
        if ( InfoLogLength > 0 ){
                std::vector<char> FragmentShaderErrorMessage(InfoLogLength+1);
                glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
                printf("%s\n", &FragmentShaderErrorMessage[0]);
        }


        // Link the program
        printf("Linking program\n");
        GLuint ProgramID = glCreateProgram();
        glAttachShader(ProgramID, VertexShaderID);
        glAttachShader(ProgramID, FragmentShaderID);
        glLinkProgram(ProgramID);

        // Check the program
        glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
        glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
        if ( InfoLogLength > 0 ){
                std::vector<char> ProgramErrorMessage(InfoLogLength+1);
                glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
                printf("%s\n", &ProgramErrorMessage[0]);
        }

        glDeleteShader(VertexShaderID);
        glDeleteShader(FragmentShaderID);

        return ProgramID;
}
4

1 回答 1

7

好吧，深呼吸，坐下：你的问题是显卡显存速度。

但是您可以通过修复此错误使 GPU 更容易：

glDrawElementsInstanced(GL_TRIANGLES, sqIndice.size(),GL_UNSIGNED_INT,(GLvoid*)(0),latticePoints.size());

glDrawElementsInstanced期望绘制的实例数作为最后一个参数。但是你传递了latticePoints. 这是实例数量的 3 倍。这导致着色器内的零基点（因为阻止了越界访问）。所以 16000 个立方体没有被平移，而是被绘制在同一个位置。这导致绘制立方体的正面 16000 次。深度缓冲区不会阻止这种情况，因为面不会相互隐藏，它们在同一个位置。

因此，当您distanceFromOrigin减少 16000 个中心立方体时，它会变得越来越大。OpenGL 必须绘制越来越多的像素。确切地说，还有很多。它必须绘制这么多，以至于它达到了显卡内存的速度限制。

完整阅读诊断 OpenGL 性能问题。

于 2014-01-20T23:41:54.773 回答