c++ - 在 OpenGL 中绘制 VBO 不起作用

Question

我正在编写一个简单的类来解析 OBJ 并在之后呈现 obj。我已经编写了一种从 RAM 中绘制顶点数组的方法，我想对其进行一些优化(我读到使用 VBO 可以使帧速率提高 4 倍!)。

可悲的是，我失败得很厉害，我遵循了一堆教程都无济于事。 这是解析器和在 GPU 上存储顶点和索引缓冲区的调用，我已经彻底调试了解析器本身，没问题。 vertexBuffer 和 vertexIndices 都加载良好(我已经打印它们并根据 obj 文件手动检查它们)。

Mesh::Mesh(string path) {
float* normals;
float* faces;
float* textures;
string fullpath = path + ".obj";
this->mats = loadMtl(path); //Loads a Material list, not used now drawing white
string line;
ifstream objFile(fullpath.c_str());
if (objFile.is_open()) {
    objFile.seekg(0, ios::end);
    long fileSize = long(objFile.tellg());
    objFile.seekg(0, ios::beg);

    // Init buffers and indices
    unsigned int inserted = 0;

    string currentMtl = "";

    float* vertexBuffer = new float[fileSize];
    float* textureBuffer = new float[fileSize];
    float* normalBuffer = new float[fileSize];

    unsigned int* vertexIndices = new unsigned int[fileSize];
    unsigned int* normalIndices = new unsigned int[fileSize];
    unsigned int* textureIndices = new unsigned int[fileSize];

    int connectedVert = 0;
    int textureCoords = 0;
    int normalsCount = 0;

    int vertexIndex = 0;

    string prefix = "usemtl";

    while (!objFile.eof()) {
        getline(objFile, line);
        if (line.c_str()[0] == 'v' && line.c_str()[1] == ' ') {
            line[0] = ' ';
            sscanf_s(line.c_str(), "%f %f %f ",
                &vertexBuffer[connectedVert],
                &vertexBuffer[connectedVert + 1],
                &vertexBuffer[connectedVert + 2]);
            connectedVert += 3;
        }
        else if (line.c_str()[0] == 'v' && line.c_str()[1] == 't') {
            line[0] = ' ';
            line[1] = ' ';
            sscanf_s(line.c_str(), "%f %f ",
                &textureBuffer[textureCoords],
                &textureBuffer[textureCoords + 1]);
            textureCoords += 2;
        }
        else if (line.c_str()[0] == 'v' && line.c_str()[1] == 'n') {
            line[0] = ' ';
            line[1] = ' ';
            sscanf_s(line.c_str(), "%f %f %f ",
                &normalBuffer[normalsCount],
                &normalBuffer[normalsCount + 1],
                &normalBuffer[normalsCount + 2]);
            normalsCount += 3;
        }
        else if (line.c_str()[0] == 'f') {
            line[0] = ' ';

            if (textureCoords > 0) {
                sscanf_s(line.c_str(), "%i/%i/%i %i/%i/%i %i/%i/%i",
                    &vertexIndices[vertexIndex], &textureIndices[vertexIndex], &normalIndices[vertexIndex],
                    &vertexIndices[vertexIndex + 1], &textureIndices[vertexIndex +1], &normalIndices[vertexIndex +1],
                    &vertexIndices[vertexIndex + 2], &textureIndices[vertexIndex +2], &normalIndices[vertexIndex +2]);
            }
            else {
                sscanf_s(line.c_str(), "%i//%i %i//%i %i//%i",
                    &vertexIndices[vertexIndex], &normalIndices[vertexIndex],
                    &vertexIndices[vertexIndex+1], &normalIndices[vertexIndex +1],
                    &vertexIndices[vertexIndex+2], &normalIndices[vertexIndex +2]);
            }

            for (int j = 0; j < 3; j++) {
                vertexIndices[vertexIndex+j] -= 1;
                normalIndices[vertexIndex +j] -= 1;
                textureIndices[vertexIndex +j] -= 1;
            }
            vertexIndex += 3;
        }
        else if (!strncmp(line.c_str(), prefix.c_str(), strlen(prefix.c_str()))) {
            inserted++;
            // No more vertices, normals or texture coords to load, gen arrays on GPU
            if (currentMtl == "") {
                //Copy vertices to GPU
                glGenBuffers(1, &this->verticesID);
                glBindBuffer(GL_ARRAY_BUFFER, this->verticesID);
                glBufferData(GL_ARRAY_BUFFER, sizeof(float) * connectedVert, vertexBuffer, GL_STATIC_DRAW);
                /*
                //Won't be bothered with normals or textures right now...
                //Copy normals to GPU
                glGenBuffers(1, &this->normalsID);
                glBindBuffer(GL_ARRAY_BUFFER, this->normalsID);
                glBufferData(GL_ARRAY_BUFFER, sizeof(float) * normalsCount, &normalBuffer[0], GL_STATIC_DRAW);

                //Copy UV to GPU
                if (textureCoords > 0) {
                    glGenBuffers(1, &this->textID);
                    glBindBuffer(GL_ARRAY_BUFFER, this->textID);
                    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * textureCoords, &textureBuffer[0], GL_STATIC_DRAW);
                }*/
            }
            else {
                // Filled up an index array, copy it.
                this->indices.push_back(0);
                this->faces.push_back(vertexIndex);
                glGenBuffers(1, &this->indices[this->indices.size() - 1]);
                glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->indices[this->indices.size() - 1]);
                glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned int) * vertexIndex, vertexIndices, GL_STATIC_DRAW);
            }
            currentMtl = line.substr(7, line.length());
            vertexIndex = 0;
        }
    }
    // Copy the last indices buffer.
    if (currentMtl != "" && indices.size() < inserted) {
        this->indices.push_back(0);
        this->faces.push_back(vertexIndex);
        glGenBuffers(1, &this->indices[this->indices.size() - 1]);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->indices[this->indices.size() - 1]);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned int) * vertexIndex, vertexIndices, GL_STATIC_DRAW);
    }

    objFile.close();
    delete[] vertexBuffer;
    delete[] textureBuffer;
    delete[] normalBuffer;

    delete[] vertexIndices;
    delete[] normalIndices;
    delete[] textureIndices;
}
else {
    throw runtime_error("Unable to load obj file: " + path + ".obj");
}
}

最后，这是绘制调用。我猜问题就在这里，但我不能完全解决这个问题。我已经使用 glIntercept 来查看是否有问题，但我没有发现任何错误。

void Mesh::draw() {
    //Binding Vertex array
    glBindBuffer(GL_ARRAY_BUFFER, this->verticesID);
    glEnableClientState(GL_VERTEX_ARRAY);
    glVertexPointer(3, GL_FLOAT, 0, (void*)0);
    for (unsigned int i = 0; i < this->indices.size(); i++) {
        glColor3f(1.0f, 1.0f, 1.0f); // Draw it in plain ol' white
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->indices[i]);
        glDrawElements(GL_TRIANGLES,this->faces[i], GL_UNSIGNED_INT,(void*)0);
    }
    glDisableClientState(GL_VERTEX_ARRAY);
}

如果需要，这里是 Mesh 类声明:

class Mesh {
    public:
        GLuint verticesID, textID, normalsID;
        vector<GLuint> indices;
        vector<GLuint> faces;
        vector<Material> mats;
    public:
       Mesh(string path);
       void draw();
        ~Mesh();
};

将 OpenGL 主要版本设置为 2，将次要版本设置为 1。正如我之前提到的，我认为 OpenGL 设置正确，因为我能够在直接模式下和使用 RAM 中的顶点指针绘制三角形。欢迎任何帮助:)

Answer 1

它是 calss Mesh 的构造函数，读取文件并生成对象缓冲区 (glGenBuffers)。在析构函数 Mesh::~Mesh 中，对象缓冲区被销毁 (glDeleteBuffers)。

但是您将 Meshpush_back 到 std::vector。这意味着生成了一个临时的 Mesh 对象，它读取文件并在其构造函数中生成对象缓冲区。此时所有数据都是有效的，并且生成了对象缓冲区(GPU)。当调用 std::vector::push_back 时，会在 std::vector 中生成一个新的 Mesh 对象。该对象由默认的复制构造函数构造，并获取第一个 Mesh 对象的所有成员的拷贝。完成后，临时 Mesh 对象立即被销毁，对象缓冲区被析构函数 Mesh::~Mesh 删除(glDeleteBuffers)的临时对象。此时所有数据都消失了。

参见 std::vector::push_back .在 destrutor Mesh::~Mesh 中放置一个断点，然后您可以简单地跟踪过期时间。

你不应该在类的构造函数和析构函数中生成和删除 GPU 对象，除非你使类不可可复制且不可可复制构造:

class Mesh
{
    Mesh(const Mesh &) = delete;
    Mesh & operator = (const Mesh &) = delete;

    ....
};

出于调试原因，您可以通过替换

来快速修复此行为

test.meshes.push_back(Mesh("tri"));

由

test.meshes.emplace_back("tri");

(参见 std::vector::emplace_back)

但最后你应该做类似的事情:

vector<std::unique_ptr<Mesh>> meshes;

meshes.emplace_back(new Mesh("tri"));