Otoczka RAII dla obiektów OpenGL

Question

Chcę napisać proste opakowanie RAII dla obiektów OpenGL (tekstury, bufory ramek itp.) Zauważyłem, że wszystkie funkcje glGen* i glDelete* mają tę samą sygnaturę, więc moja pierwsza próba była taka :

typedef void (__stdcall *GLGenFunction)(GLsizei, GLuint *); 
typedef void (__stdcall *GLDelFunction)(GLsizei, const GLuint *); 

template <GLGenFunction glGenFunction, GLDelFunction glDelFunction> 
class GLObject 
{ 
    GLuint m_name; 
public: 
    GLObject() 
    { 
     glGenFunction(1, &m_name); 
    } 

    ~GLObject() 
    { 
     glDelFunction(1, &m_name); 
    } 

    GLuint getName() {return m_name;} 
}; 

typedef GLObject<glGenTextures, glDeleteTextures> GLTexture; 

To działa dobrze dla tekstur, ale nie dla buforów ramki: glGenFramebuffers i glDeleteFramebuffers adresy funkcyjne nie są znane w czasie kompilacji i nie mogą być używane jako argumenty szablonów. Więc zrobiłem drugą wersję:

class GLObjectBase 
{ 
    GLuint m_name; 
    GLDelFunction m_delFunction; 

public: 
    GLObjectBase(GLGenFunction genFunc, GLDelFunction delFunction) 
     : m_delFunction(delFunction) 
    { 
     genFunc(1, &m_name); 
    } 

    GLuint getName() 
    { 
     return m_name; 
    } 

protected: 
    ~GLObjectBase() 
    { 
     m_delFunction(1, &m_name); 
    } 
}; 

class GLFrameBuffer : public GLObjectBase 
{ 
public: 
    GLFrameBuffer() : GLObjectBase(glGenFramebuffers, glDeleteFramebuffers) {} 
}; 

Ale nie podoba mi się to, ponieważ mam do przechowywania del wskaźnik funkcji w każdym przypadku, że nie ulegnie zmianie w czasie wykonywania.

Jak utworzyć klasę opakowania, w której zapisuje się tylko nazwę obiektu w każdym wystąpieniu bez konieczności tworzenia grupy prawie skopiowanych przez kopiowanie klas?

mógłby zrobić coś takiego:

template <int N> 
class GLObject2 
{ 
    GLuint m_name; 
    static GLDelFunction glDelFunction; 
public: 
    GLObject2(GLGenFunction genFunction, GLDelFunction delFunc) 
    { 
     genFunction(1, &m_name); 
     if (glDelFunction == nullptr) 
      glDelFunction = delFunc; 
     ASSERT(glDelFunction == delFunc); 
    } 

    GLuint getName() {return m_name;} 

protected: 
    ~GLObject2() 
    { 
     glDelFunction(1, &m_name); 
    } 
}; 

template <int N> 
GLDelFunction GLObject2<N>::glDelFunction = nullptr; 

class GLTexture: public GLObject2<1> 
{ 
public: 
    GLTexture(): GLObject2<1>(glGenTextures, glDeleteTextures) {} 
}; 

class GLRenderBuffer: public GLObject2<2> 
{ 
public: 
    GLRenderBuffer(): GLObject2<2>(glGenRenderbuffers, glDeleteRenderbuffers) {} 
}; 

Czy ktoś może sugerować bardziej eleganckie rozwiązanie?

Answer 1

Naprawdę myślisz o tym jak programista C. Używasz C++, więc rozwiąż go tak, jak zrobiłby to programista C++. Z klasą cechy:

struct VertexArrayObjectTraits 
{ 
    typedef GLuint value_type; 
    static value_type Create(); 
    static void Destroy(value_type); 
}; 

jak prawdziwy klasa C++ cechami, mamy każdy obiekt zadeklarować swój własny value_type. Umożliwi to dostosowanie go do obiektów OpenGL, które nie używają GLuint s, jak sync objects (chociaż interfejs Create/Destroy i tak nie byłby dla nich dobry, więc prawdopodobnie nie powinieneś się tym przejmować).

Więc piszesz jedną klasę cech dla każdego typu obiektu OpenGL. Twoje funkcje Create i Destroy będą odpowiednio przekazywać połączenia do API C.

Po robi to, co potrzebne jest RAII-wrapper wokół te interfejsy:

template<typename T> 
class OpenGLObject 
{ 
public: 
    OpenGLObject() : m_obj(T::Create()) {} 
    ~OpenGLObject() {T::Destroy(m_obj);} 

    operator typename T::value_type() {return m_obj;} 

private: 
    typename T::value_type m_obj; 
}; 

OpenGLObject<VertexArrayObjectTraits> będzie posiadać VAO.

Answer 2

Po co odnawiać koło? Jest schludny rozwiązanie wykorzystujące std::unique_ptr, który już zapewnia wymaganą funkcjonalność, więc trzeba tylko napisać cechy (!):

template<void (*func)(GLuint)> 
struct gl_object_deleter { 
    struct pointer { // I wish we could inherit from GLuint... 
     GLuint x; 
     pointer(std::nullptr_t = nullptr) : x(0) {} 
     pointer(GLuint x) : x(x) {} 
     operator GLuint() const { return x; } 
     friend bool operator == (pointer x, pointer y) { return x.x == y.x; } 
     friend bool operator != (pointer x, pointer y) { return x.x != y.x; } 
    }; 
    void operator()(GLuint p) const { func(p); } 
}; 

void delete_texture(GLuint p) { glDeleteTextures(1, &p); } 
void delete_shader(GLuint p) { glDeleteShader(p); } 
// ... 
typedef std::unique_ptr<void, gl_object_deleter<delete_texture>> GLtexture; 
typedef std::unique_ptr<void, gl_object_deleter<delete_shader>> GLshader; 
// ... 

Większość funkcje Create* zwraca tablicę poprzez ich argumentacji, która jest niewygodna, kiedy przydzielaj swoje obiekty jeden po drugim. Możliwe jest określenie zestawu procedur tworzenia pojedynczych przypadkach:

GLuint glCreateTextureSN(GLenum target) { GLuint ret; glCreateTextures(target, 1, &ret); return ret; } 
GLuint glCreateBufferSN() { GLuint ret; glCreateBuffers(1, &ret); return ret; } 
// ... 

Niektóre funkcje OpenGL jak glCreateShader może być stosowany bezpośrednio. Teraz możemy używać go w sposób następujący:

GLtexture tex(glCreateTextureSN(GL_TEXTURE_2D)); 
glTextureParameteri(tex.get(), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 
// ... 
GLtexture tex2 = std::move(tex); // we can move 
tex2.reset(); // delete 
return tex2; // return... 

Jednym minusem jest to, że nie można zdefiniować niejawny oddanych do GLuint, więc musisz zadzwonić get() wyraźnie.Ale, po drugie, zapobieganie przypadkowemu rzutowi na GLuint nie jest takie złe.