亚洲欧美国产一区二区,久久综合九九,日韩精品区

本文介紹了使用默認構造函數調用的網格類不起作用 OpenGL C++的處理方法，對大家解決問題具有一定的參考價值，需要的朋友們下面隨著小編來一起學習吧！

問題描述

我為 OpenGL 3.3 創建了一個 Mesh 類，當我使用非默認構造函數創建類時，當我創建對象時創建頂點時，它可以正常工作.
但是，我現在想要通過將它們放入向量中來動態創建多個對象，因此我必須添加一個默認構造函數，我使用與其他構造函數相同的函數來設置緩沖區數據......但是它不起作用.據我所知，不是因為它在向量中，而是與構造函數有關，或者與稍后創建緩沖區數據的事實有關.我真的不太確定.

I created a Mesh class for OpenGL 3.3, it works fine when I create the class with a non-default constructor, when I create the vertices when I create the object.
However, I now want to have multiple objects that I can create dynamically by putting them in a vector, so I had to add in a default constructor I use the same functions for setting up the buffer data as with the other constructor... but it doesn't work. It's as far as I can tell not because of the fact it's in the vector but it's something to do with the constructor or something with the fact the buffer data is created later. I'm really not quite sure.

這是我的課程.(當我創建一個有效的網格時，我調用帶參數的構造函數，當它不起作用時，我構建一個沒有參數的網格并調用changeMes??h"函數)

Here are my classes. ( When I create a mesh that works I call the constructor with parameters and when it doesn't work I construct a mesh with no parameters and call the "changeMesh" function)

mesh.h

#ifndef MESH_H
#define MESH_H

#include <iostream>
#include <vector>
#include <GL/glew.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

class mesh
{
    public:
        mesh();
        mesh(std::vector<GLfloat> vertices, std::vector<GLuint> triangles, GLuint shaderProgram);
        ~mesh();
        void changeMesh(std::vector<GLfloat> vertices, std::vector<GLuint> triangles, GLuint shaderProgram);
        void render();
        void Translate(glm::vec3 addVector);
        void Rotate(glm::vec3 rotVector, GLfloat angle);
    protected:
    private:
        GLuint vertexArrayObject, vertexBuffer, elementBuffer, shaderProgram;
        std::vector<GLfloat> vertices;
        std::vector<GLuint> indices;
        glm::mat4 transform;
        void setUpMesh();
        void bindVertices();
};

#endif // MESH_H

mesh.cpp

    #include "../include/mesh.h"

mesh::mesh(std::vector<GLfloat> vertices, std::vector<GLuint> indices, GLuint shaderProgram)
{
    this->shaderProgram = shaderProgram;
    this->vertices = vertices;
    this->indices = indices;
    setUpMesh();
}

mesh::mesh(){
    glGenVertexArrays(1, &vertexArrayObject);
    glBindVertexArray(vertexArrayObject);

    glGenBuffers(1, &vertexBuffer);
    glGenBuffers(1, &elementBuffer);
}

mesh::~mesh()
{
    glDeleteBuffers(1, &elementBuffer);
    glDeleteBuffers(1, &vertexBuffer);

    glDeleteVertexArrays(1, &vertexArrayObject);
}

void mesh::changeMesh(std::vector<GLfloat> vertices, std::vector<GLuint> triangles, GLuint shaderProgram){
    this->shaderProgram = shaderProgram;
    this->vertices = vertices;
    this->indices = indices;
    bindVertices();

}

void mesh::setUpMesh(){
    glGenVertexArrays(1, &vertexArrayObject);
    glBindVertexArray(vertexArrayObject);

    glGenBuffers(1, &vertexBuffer);
    glGenBuffers(1, &elementBuffer);

    bindVertices();
    glBindVertexArray(0);

}

void mesh::bindVertices(){
    glBindVertexArray(vertexArrayObject);

    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, this->vertices.size() * sizeof(GLfloat), this->vertices.data(), GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, this->indices.size() * sizeof(GLuint), this->indices.data(), GL_STATIC_DRAW);


    GLint amountDataPerVert = 5;

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, amountDataPerVert*sizeof(GLfloat), 0);

    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, amountDataPerVert*sizeof(GLfloat), (void*)(3*sizeof(GLfloat)));


    glBindVertexArray(0);

}
void mesh::render(){
    glBindVertexArray(vertexArrayObject);
    glUniformMatrix4fv(glGetUniformLocation(shaderProgram, "transform"), 1, GL_FALSE, glm::value_ptr(transform));

    glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
    glBindVertexArray(0);
}

void mesh::Translate(glm::vec3 addVector){
    transform = glm::translate(transform, addVector);
}

void mesh::Rotate(glm::vec3 rotVector, GLfloat angle){
    transform = glm::rotate(transform, glm::radians(angle), rotVector);
}

推薦答案

雖然您認為問題與將對象存儲在向量中無關，但我有一種強烈的感覺，它可能會發生.您在 C++ 包裝器中封裝 OpenGL 對象的方式是一種痛苦的方法，您可能會像之前的許多人一樣發現.

While you believe that the problem has nothing to do with storing the objects in a vector, I have a strong feeling that it probably does. The way you are encapsulating OpenGL objects in C++ wrappers is a recipe for pain, and you're probably finding out like many did before you.

典型的問題是由復制和銷毀對象時發生的組合引起的.C++包裝器擁有的OpenGL對象在析構函數中被刪除:

The typical problems are caused by the combination of what happens when objects are copied and destructed. The OpenGL objects owned by the C++ wrapper are deleted in the destructor:

mesh::~mesh()
{
    glDeleteBuffers(1, &elementBuffer);
    glDeleteBuffers(1, &vertexBuffer);

    glDeleteVertexArrays(1, &vertexArrayObject);
}

為了說明這個問題，讓我們看一個典型的序列.假設您有一個網格對象向量，以及一種向該向量添加新網格的方法(注釋點以供以后參考):

To illustrate the problem with this, let's look at a typical sequence. Let's say you have a vector of mesh objects, and a method to add a new mesh to this vector (points annotated for later reference):

std::vector<mesh> m_meshes;

void createMesh(...) {
    mesh newMesh;  // point 1
    newMesh.changeMesh(...);
    m_meshes.push_back(newMesh);  // point 2
}  // point 3

看起來無害?根本不是.這里發生了不好的事情:

Looks harmless? It's not at all. Bad things happened here:

第 1 點:創建了新對象.構造函數創建 OpenGL 對象，并將它們的名稱存儲在成員變量中.
第 2 點:將網格對象的副本添加到向量中，其中使用默認復制構造函數創建副本.這意味著將復制包含 OpenGL 對象名稱的成員變量.
第 3 點:網格對象超出范圍.調用析構函數，刪除 OpenGL 對象.

Point 1: New object is created. The constructor creates the OpenGL objects, and stores their names in member variables.
Point 2: A copy of the mesh object is added to the vector, where the copy is created with the default copy constructor. This means that the member variables, which contain the OpenGL object names, are copied.
Point 3: The mesh object goes out of scope. The destructor is invoked, which deletes the OpenGL objects.

畢竟你擁有的是一個存儲在向量中的網格對象，OpenGL 對象名稱存儲在其成員變量中，而實際的 OpenGL 對象已被刪除.這意味著存儲在此網格對象中的對象名稱現在無效.

What you have after all of this is a mesh object stored in the vector, with OpenGL object names stored in its member variables, while the actual OpenGL objects have been deleted. This means that the object names stored in this mesh object are now invalid.

根本問題是您的類沒有正確的復制構造函數和賦值運算符.不幸的是，在成員變量中存儲 OpenGL 對象名稱，以及在構造函數/析構函數中生成/刪除對象名稱時，實現它們并不容易.

The root problem is that your class does not have proper copy constructors and assignment operators. And unfortunately, it is not easily possible to implement them when storing OpenGL object names in member variables, and generating/deleting the object names in constructor/destructor.

有很多方法可以解決這個問題.它們都不是完美的:

There are a number of ways to handle this. None of them are perfectly pretty:

不要在構造函數/析構函數中生成/刪除 OpenGL 對象.相反，使用您顯式調用的某種形式的 init()/cleanup() 方法.缺點是您必須小心正確地調用這些方法.例如，如果您有一個對象向量，并且想要刪除該向量，則必須手動對向量的所有成員調用 cleanup().

Do not generate/delete the OpenGL objects in constructor/destructor. Instead, use some form of init()/cleanup() methods that you invoke explicitly. The downside is that you have to be careful to invoke these methods correctly. For example, if you have a vector of objects, and want to delete the vector, you have to invoke cleanup() on all members of the vector manually.

總是用指針來引用對象.使用網格對象指針向量代替網格對象向量.這樣，對象就不會被復制.您還必須小心正確地管理對象的生命周期，而不是泄漏它們.如果您使用某種形式的智能指針而不是裸指針，這是最簡單的.

Always reference the objects with pointers. Instead of having a vector of mesh objects, use a vector of mesh object pointers. This way, the objects are not copied. You also have to be careful to manage the lifetime of the objects correctly, and not leak them. This is easiest if you use some form of smart pointer instead of naked pointers.

使用某種形式的混合，您仍然使用實際的 C++ 對象，但它們將底層 OpenGL 對象的名稱存儲在引用計數的嵌套對象中.這樣，他們就可以實現正確的復制/分配語義.

Use some form of hybrid, where you still use actual C++ objects, but they store the names of the underlying OpenGL objects in a nested object that is reference counted. This way, they can implement proper copy/assign semantics.

我認為最簡單、最干凈的方法是使用智能指針的選項 2.較新版本的 C++ 在標準庫中具有智能指針，因此您無需實現任何內容.例如，在 C++11 中，您可以使用類型 std::shared_ptr 來引用您的網格對象.上面的代碼片段將如下所示:

I think the easiest and cleanest approach is option 2 with using smart pointers. Newer versions of C++ have smart pointers in the standard library, so there isn't anything you need to implement. For example in C++11, you can use the type std::shared_ptr<mesh> to reference your mesh objects. The code fragment above would then look like this:

std::vector<std::shared_ptr<mesh> > m_meshes;

void createMesh(...) {
    std::shared_ptr<mesh> newMesh = std::make_shared<mesh>();
    newMesh->changeMesh(...);
    m_meshes.push_back(newMesh);
}

為了確保無論如何都不會意外復制對象，為類聲明未實現的(私有)復制構造函數和賦值運算符也是一個好主意.本主題解釋了如何在 C++11 中做到最好:在 C++11 中使用顯式刪除的成員函數，是否仍然值得從不可復制的基類繼承?.

To be sure that you don't accidentally copy the objects anyway, it's also a good idea to declare unimplemented (private) copy constructors and assignment operators for the class. This topic explains how to do that best in C++11: With explicitly deleted member functions in C++11, is it still worthwhile to inherit from a noncopyable base class?.

這篇關于使用默認構造函數調用的網格類不起作用 OpenGL C++的文章就介紹到這了，希望我們推薦的答案對大家有所幫助，也希望大家多多支持html5模板網！

【網站聲明】本站部分內容來源于互聯網,旨在幫助大家更快的解決問題，如果有圖片或者內容侵犯了您的權益，請聯系我們刪除處理，感謝您的支持！

pbootcms网站模板|日韩1区2区|织梦模板||网站源码|日韩1区2区|jquery建站特效-html5模板网

使用默認構造函數調用的網格類不起作用 OpenGL

問題描述

推薦答案

相關文檔推薦