OpenGL RAII शैली की प्रधानता

class buffer_object
{
public:
    buffer_object() noexcept {
        glGenBuffers(1, m_object);
    }
    
    ~buffer_object() noexcept {
        glDeleteBuffers(1, m_object);
    }
    
    uint32_t get_object() const noexcept {
        return m_object;
    }
private:
    uint32_t m_object;
};

• बफर हटाने की निगरानी करने की आवश्यकता नहीं है
• OpenGL हेडर को सक्षम करने से चिपके नहीं रहते हैं (यदि हम फ़ंक्शन की परिभाषा को * .cpp पर स्थानांतरित करते हैं)।

• बाध्यकारी करते समय हम बफर (सरणी, तत्व ...) के प्रकार को निर्दिष्ट नहीं कर सकते
• GlGenBuffers के लिए एक कॉल के साथ कई बफ़र्स नहीं बना सकते
• यदि बफर की प्रतिलिपि बनाई गई थी, तो दूरस्थ ऑब्जेक्ट तक पहुंचने में समस्याएं

struct noncopyable
{
    noncopyable() = default;
            
    noncopyable(noncopyable&&) = default;
    noncopyable& operator = (noncopyable&&) = default;
            
    noncopyable(const noncopyable&) = delete;
    noncopyable& operator = (const noncopyable&) = delete;
};

void bind(buffer_type type) noexcept {
    glBindBuffer(static_cast<GLenum>(type), m_object);
}
    
void unbind() noexcept {
    glBindBuffer(static_cast<GLenum>(type), 0);
}

const uint32_t array_buffer = GL_ARRAY_BUFFER;

#include <GL/glew.h>

• बफर हटाने की निगरानी करने की आवश्यकता नहीं है
• OpenGL हेडर को सक्षम करने से चिपके नहीं रहते हैं (यदि हम फ़ंक्शन की परिभाषा को * .cpp पर स्थानांतरित करते हैं)।
• बंधन करते समय हम बफर के प्रकार (सरणी, तत्व ...) को इंगित कर सकते हैं
• कोई नकल नहीं - कोई नकल की समस्या नहीं

• GlGenBuffers के लिए एक कॉल के साथ कई बफ़र्स नहीं बना सकते

constexpr uint8_t default_object_count = 1;
constexpr size_t  default_index        = 0;

template <type::buffer_type type, uint32_t count = default_object_count>
class buffer_object : noncopyable
{
public:
    buffer_object() noexcept {
        glGenBuffers(count, m_object.data());
    }
    
    ~buffer_object() noexcept {
        glDeleteBuffers(count, m_object.data());
    }
    
    template <size_t index = default_index>
    void bind() noexcept
    {
        static_assert(index < count, "index larger than array size");
        glBindBuffer(static_cast<GLenum>(type), m_object[index]);
    }
    
    void unbind() noexcept {
        glBindBuffer(static_cast<GLenum>(type), 0);
    }
    
    buffer_object(buffer_object&&) = default;
    buffer_object& operator = (buffer_object&&) = default;
    
private:
    std::array<uint32_t, count> m_object;
};

• बफर हटाने की निगरानी करने की आवश्यकता नहीं है
• बंधन करते समय हम बफर के प्रकार (सरणी, तत्व ...) को इंगित कर सकते हैं
• कोई नकल नहीं - कोई नकल की समस्या नहीं
• हम glGenBuffers के लिए एक कॉल के साथ कई बफ़र्स बना सकते हैं

• एक ही वस्तु पर विभिन्न बफ़र्स बाँध नहीं सकते
• OpenGL हैडर स्टिक आउट को सक्षम करना

बक्शीश

constexpr uint32_t default_bind_index = 0;
template <class T>
class binder : utils::noncopyable
{
public:
      template <uint32_t index = default_bind_index>
      binder(T& ref) : m_ref(ref) { m_ref.template bind<index>(); }
    ~binder()                            { m_ref.unbind();}
        
private:
    T& m_ref;
};

m_ref.template bind<index>();

GLuint VAO;
    
primitive::buffer_object<type::buffer_type::array> vbo;
primitive::buffer_object<type::buffer_type::element> ebo;
    
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
    
{
    primitive::binder bind{vbo};
        
    glBufferData(GL_ARRAY_BUFFER, ...);
        
    glVertexAttribPointer(...);
    glEnableVertexAttribArray(...);
        
    glVertexAttribPointer(...);
    glEnableVertexAttribArray(...);
}
    
{
    primitive::binder bind{ebo};
        
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, ...);
        
    glBindVertexArray(0);
}