Buffer.h

Go to the documentation of this file.

#ifndef GlobeEngine_Buffer_h
#define GlobeEngine_Buffer_h

#include "OpenGL_Includes.h"

namespace ge {
    template <int TYPE> class Buffer
    {
    public:
        Buffer() : bufferHandle(0) {
            isImmutable = false;
        }

        ~Buffer() {
            clear();
        }
        
        void clear()
        {
            if (this->bufferHandle != 0) {
                glBindBuffer(TYPE, this->bufferHandle);
                if (!this->isImmutable) {
                    glBufferData(TYPE, 0, nullptr, GL_STATIC_DRAW);
                }
                glDeleteBuffers( 1, &bufferHandle );
                glBindBuffer(TYPE, 0); // should be done automatically after delete
                bufferHandle = 0;
            }
        }

        bool generateHandle(){
            bool res = false;
            if (this->bufferHandle == 0) {
                glGenBuffers(1, &this->bufferHandle);
                res = true;
            }
            this->bindBuffer();
            return res;
        }

        void copyToBufferCustom(GLsizeiptr _size, const GLvoid*  _data, GLenum _access = GL_STATIC_DRAW) {            
            this->generateHandle();
            glBufferData(TYPE, _size, _data, _access);
        }

        template <typename T>
        void copyToBufferByData(GLuint _count, const T*  _data, GLenum _access = GL_STATIC_DRAW) {
            this->generateHandle();
            glBufferData(TYPE, _count * sizeof(T), _data, _access);
        }

        void copyToBufferUInt(GLuint _size, const GLvoid*  _data, GLenum _access = GL_STATIC_DRAW) {
            this->generateHandle();
            glBufferData(TYPE, _size * sizeof(GLuint), _data, _access);
        }

#ifndef GENGINE_GL_ES
        template <typename T>
        T* mapBuffer(GLuint _count,
            GLenum _usage = GL_STATIC_DRAW, GLbitfield _mode = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT) {
            this->generateHandle();
            glBufferData(TYPE, _count * sizeof(T), nullptr, _usage);
            return reinterpret_cast<T*>(glMapBufferRange(TYPE, 0, _count * sizeof(T), _mode));
        }

#ifndef GENGINE_GL_BELOW_410
        template <typename T>
        T* mapBufferStorage(GLuint _count,
            GLbitfield _storageMode = GL_MAP_WRITE_BIT,
            GLbitfield _mode = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT) {
            if (this->generateHandle()){
                // darf nur einmal aufgerufen werden auf ein buffer objekt 
                glBufferStorage(TYPE, _count * sizeof(T), nullptr, _storageMode);
                this->isImmutable = true;
            }
            return reinterpret_cast<T*>(glMapBufferRange(TYPE, 0, _count * sizeof(T), _mode));
        }
#endif

        void unmapBuffer() {
            glUnmapBuffer(TYPE);
        }
#endif

        void bindBuffer() {
            glBindBuffer(TYPE, this->bufferHandle);
        };

        void unbindBuffer(){
            glBindBuffer(TYPE, 0);
        }

        GLuint getBufferHandle(unsigned int _layerid){
            return this->bufferHandle;
        }

    private:
        GLuint bufferHandle;
        /* it this buffer was allocated with a BufferStorage command */
        bool isImmutable;
    };

    typedef Buffer<GL_ARRAY_BUFFER> VertexBuffer;
    typedef Buffer<GL_ELEMENT_ARRAY_BUFFER> IndexBuffer;
#ifndef GENGINE_GL_ES
    typedef Buffer<GL_UNIFORM_BUFFER> UniformBuffer;
    typedef Buffer<GL_PIXEL_UNPACK_BUFFER> PixelUnpackBuffer; // Texture data upload
    typedef Buffer<GL_PIXEL_PACK_BUFFER> PixelPackBuffer; // Texture data download from graphics card
#endif

#ifndef GENGINE_GL_BELOW_410
    typedef Buffer<GL_DRAW_INDIRECT_BUFFER> DrawIndirectBuffer;
    typedef Buffer<GL_SHADER_STORAGE_BUFFER> ShaderStorageBuffer;
#endif
    


}
#endif