我正在创建一个OpenGLManager类,该类的想法是管理对在OpenGL中分配的资源的引用(如“顶点数组对象”和“顶点缓冲区对象”)。
所以我想做的是,每当我分配一个新资源时,便将引用添加到此类中,并且每当使用此资源的对象被破坏(析构函数)时,对该资源的引用都会减少。我意识到的一个问题是,在某些情况下,析构函数被一个对象调用两次,这使我的代码中断。 destructor called twice
我基本上在创建类似shared_ptr
的东西,但是没有指针,而是有处理程序。这是代码:
class OpenGLManager
{
public:
static OpenGLManager& getInstance()
{
static OpenGLManager instance;
return instance;
}
// Increment reference counter
void incrementVBO(GLuint vbo);
void incrementVAO(GLuint vao);
void incrementShaderProgram(GLuint program);
// Decrement reference counter
void decrementVAO(GLuint vao);
void decrementVBO(GLuint vbo);
void decrementShaderProgram(GLuint program);
private:
std::unordered_map<GLuint, int> _vbos;
std::unordered_map<GLuint, int> _vaos;
std::unordered_map<GLuint, int> _programs;
OpenGLManager() {};
OpenGLManager(const OpenGLManager&) = delete;
void operator=(OpenGLManager const&) = delete;
};
---------------------------------------------------------------
#include "opengl_manager.h"
using std::vector;
void lh::OpenGLManager::incrementShaderProgram(GLuint program)
{
if (_programs.find(program) == _programs.end())
_programs[program] = 1;
else
_programs[program]++;
}
void lh::OpenGLManager::incrementVAO(GLuint vao)
{
if (_vaos.find(vao) == _vaos.end())
_vaos[vao] = 1;
else
_vaos[vao]++;
}
void lh::OpenGLManager::incrementVBO(GLuint vbo)
{
if (_vbos.find(vbo) == _vbos.end())
_vbos[vbo] = 1;
else
_vbos[vbo]++;
}
void lh::OpenGLManager::decrementVAO(GLuint vao)
{
if (_vaos.count(vao) == 0)
{
std::cerr << "Trying to decrement VAO: " << vao << ". Fatal Error." << std::endl;
exit(EXIT_FAILURE);
}
_vaos[vao]--;
if (_vaos[vao] == 0) // There are no more references
{
auto iter = _vaos.find(vao);
if (iter == _vaos.end())
{
std::cerr << "Trying to remove inexistent hashmap (vao) key." << std::endl;
exit(EXIT_FAILURE);
}
_vaos.erase(iter);
glDeleteVertexArrays(1, &vao);
}
}
void lh::OpenGLManager::decrementVBO(GLuint vbo)
{
if (_vbos.count(vbo) == 0)
{
std::cerr << "Trying to decrement VBO: " << vbo << ". Fatal Error." << std::endl;
exit(EXIT_FAILURE);
}
_vbos[vbo]--;
if (_vbos[vbo] == 0) // There are no more references
{
auto iter = _vbos.find(vbo);
if (iter == _vbos.end())
{
std::cerr << "Trying to remove inexistent hashmap (vbo) key." << std::endl;
exit(EXIT_FAILURE);
}
_vbos.erase(iter);
glDeleteBuffers(1, &vbo);
}
}
void lh::OpenGLManager::decrementShaderProgram(GLuint program)
{
if (_programs.count(program) == 0)
{
std::cerr << "Trying to decrement Program: " << program << ". Fatal Error." << std::endl;
exit(EXIT_FAILURE);
}
_programs[program]--;
if (_programs[program] == 0) // There are no more references
{
auto iter = _programs.find(program);
if (iter == _programs.end())
{
std::cerr << "Trying to remove inexistent hashmap (program) key." << std::endl;
exit(EXIT_FAILURE);
}
_programs.erase(iter);
glDeleteProgram(program);
}
}
这似乎可行,除了当我用
std::vector
在push_back
上添加对象时,析构函数将被调用两次,从而使引用减少2。如何避免这种情况?还是这只是一个不好的设计?编辑
使用OpenGLManager的类的实现
lh::RawModel::RawModel(vector<GLfloat> vertices, vector<GLint> indices, GLenum usage)
: _vao(-1), _indicesCount(indices.size())
{
std::cout << "CREATING MYSELF" << std::endl;
createAndBindVAO();
storeVerticesDataInVBO(0, vertices, 0, usage);
storeVerticesDataInVBO(1, vertices, VERTEX_SIZE * sizeof(GLfloat), usage);
storeIndicesDataInEBO(indices, usage);
unbindVAO();
}
lh::RawModel::~RawModel()
{
// Decrement reference counters for opengl resources
std::cout << "DESTROYING MYSELF" << std::endl;
lh::OpenGLManager::getInstance().decrementVAO(_vao);
lh::OpenGLManager::getInstance().decrementVBO(_vbo);
lh::OpenGLManager::getInstance().decrementVBO(_ebo);
}
const int lh::RawModel::VERTEX_SIZE = 3;
void lh::RawModel::storeIndicesDataInEBO(vector<GLint> indices, GLenum usage)
{
glGenBuffers(1, &_ebo);
lh::OpenGLManager::getInstance().incrementVBO(_ebo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLint), &indices[0], usage);
}
void lh::RawModel::storeVerticesDataInVBO(int iAttribute, vector<GLfloat> data, int offset, GLenum usage)
{
glGenBuffers(1, &_vbo);
lh::OpenGLManager::getInstance().incrementVBO(_vbo);
glBindBuffer(GL_ARRAY_BUFFER, _vbo);
glBufferData(GL_ARRAY_BUFFER, data.size() * sizeof(GLfloat), &data[0], usage);
glVertexAttribPointer(iAttribute, VERTEX_SIZE, GL_FLOAT, GL_FALSE, 2 * (VERTEX_SIZE * sizeof(float)), (GLvoid*)offset);
glEnableVertexAttribArray(iAttribute);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
void lh::RawModel::createAndBindVAO()
{
glGenVertexArrays(1, &_vao);
glBindVertexArray(_vao);
std::cout << "incrementing vao " << _vao << std::endl;
lh::OpenGLManager::getInstance().incrementVAO(_vao);
}
int lh::RawModel::getNumberOfIndices()
{
return _indicesCount;
}
GLuint lh::RawModel::getVAO()
{
return _vao;
}
void lh::RawModel::unbindVAO()
{
glBindVertexArray(0);
}
通话中断的示例:
models_.push_back(lh::RawModel(vertices, indices, GL_STATIC_DRAW));
最佳答案
这是预期的行为。
不幸的是,您的设计不安全。如果创建作用域变量,将其递增,将其复制到作用域之外的变量中,则该作用域变量将被销毁(称为递减),然后,当您最终销毁另一个变量时,它将再次递减,从而导致程序。像这样:
RawModel rawModel;
{
RawModel temp;
temp.increment() //calls increment methods.
rawModel = temp;
} // destructor called once to clean up temp;
// destroy rawModel. destructor called twice to clean up rawModel;
这正是发生的情况,将实例化RawModel,然后将其传递给vector,vector将变量复制到其中,现在您有两个实例来调用析构函数并中断程序。
选项:
1.(推荐)使用shared_ptr。
2.定义复制构造函数和运算符=,将内容从一个RawModel复制到另一个RawModel并增加计数。
尽管如果您有空闲时间,第二个选项听起来比较容易,但是选择第1个选项,请学习shared_ptr,它将在以后的程序中为您提供很多帮助。
1.
shared_ptr<RawModel> rawModel = make_shared(new RawModel);
rawModel->increment() //increment stuff
vector.push_back(rawModel);
//now it'll work.
2.
//additional RawModel methods:
RawModel(const RawModel& rawModel) {
// copies everything and if it is initialized increment
}
const RawModel& operator =(const RawModel& other) {
//same as copy constructur
}
希望这可以帮助。