BufferArray.h

Go to the documentation of this file.

#ifndef GlobeEngine_BufferArray_h
#define GlobeEngine_BufferArray_h

#include "OpenGL_Includes.h"

namespace ge {
    template <int TYPE> class BufferArray
    {
    public:
        BufferArray() {
            this->bufferHandles = NULL;
            this->clearHandles();
        };

        ~BufferArray(){
#ifdef __APPLE__
            for (int i = 0; i < bufferHandleCount; i++){
                this->bindBuffer(i);
                glBufferData(TYPE, 0, NULL, GL_STATIC_DRAW);
            }
#endif
            this->clearHandles();
        };

        void generateHandles(unsigned int _count){
            if (this->bufferHandleCount != _count) {
                this->clearHandles();
                this->bufferHandles = new GLuint[_count];
                this->bufferHandleCount = _count;
                //this->unbindBuffers();
                glGenBuffers(_count, this->bufferHandles);
            }
        }

        void copyToBuffer(unsigned int _layerid, GLsizeiptr _size, const GLvoid*  _data, GLenum _access = GL_STATIC_DRAW) {
            this->bindBuffer(_layerid);
            glBufferData(TYPE, _size, _data, _access);
        }

#ifdef GENGINE_GL_ES
#else
        template <typename T>
        T* mapBuffer(unsigned int  _layerid, GLuint _size,
            GLenum _usage = GL_STATIC_DRAW, GLbitfield _mode = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT) {
            this->bindBuffer(_layerid);
            glBufferData(TYPE, _size * sizeof(T), NULL, _usage);
            return reinterpret_cast<T*>(glMapBufferRange(TYPE, 0, _size * sizeof(T), _mode));
        }

        void unmapBuffer(unsigned int  _layerid){
            this->bindBuffer(_layerid);
            glUnmapBuffer(TYPE);
        }

        void unmapAllBuffers(){
            for (int i = 0; i < bufferHandleCount; i++){
                this->bindBuffer(i);
                glUnmapBuffer(TYPE);
            }
        }

#endif
        void bindBuffer(unsigned int  _layerid) {
            glBindBuffer(TYPE, this->bufferHandles[_layerid]);
        };

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

        GLuint getBufferHandle(unsigned int _layerid){
            if (_layerid < bufferHandleCount){
                return this->bufferHandles[_layerid];
            }
            else{
                return std::numeric_limits< unsigned int >::max();
            }
        }

        // this throws a linker error in case a not supported type 
        // uses this function
        void setAttributeDivisor(GLuint _attributeIndex, GLuint _divisor) {
            glVertexAttribDivisor(_attributeIndex, _divisor);
        }

    private:
        void clearHandles(){
            if (bufferHandles != NULL) {
                glDeleteBuffers(bufferHandleCount, bufferHandles);
                delete[] bufferHandles;
            }
            bufferHandles = NULL;
            bufferHandleCount = 0;
        }
    private:
        GLuint* bufferHandles;
        GLuint bufferHandleCount;
    };

    typedef BufferArray<GL_ARRAY_BUFFER> VertexBufferArray;
#ifndef GENGINE_GL_ES
    typedef BufferArray<GL_UNIFORM_BUFFER> UniformBufferArray;
    typedef BufferArray<GL_PIXEL_UNPACK_BUFFER> PixelUnpackBufferArray; // Texture data upload
    typedef BufferArray<GL_PIXEL_PACK_BUFFER> PixelPackBufferArray; // Texture data download from graphics card
#endif

#ifndef GENGINE_GL_BELOW_410
    typedef BufferArray<GL_SHADER_STORAGE_BUFFER> ShaderStorageBufferArray;
#endif

}
#endif