buffer.h

#ifndef __BUFFER_H_
#define __BUFFER_H_
 
#include "app.h"
 
namespace sgltk {

class Buffer {
    GLenum usage;
    GLenum target;
public:
    GLuint buffer;

    unsigned int size;

    unsigned int num_elements;

    Buffer(GLenum target = GL_ARRAY_BUFFER) {
        this->target = target;
        glGenBuffers(1, &buffer);
    }
 
    ~Buffer() {
        glDeleteBuffers(1, &buffer);
    }

    void bind() {
        glBindBuffer(target, buffer);
    }

    void bind(GLenum target) {
        this->target = target;
        glBindBuffer(target, buffer);
    }

    void bind(GLenum target, unsigned int index) {
        this->target = target;
        switch(target) {
            case GL_ATOMIC_COUNTER_BUFFER:
            case GL_TRANSFORM_FEEDBACK_BUFFER:
            case GL_UNIFORM_BUFFER:
            case GL_SHADER_STORAGE_BUFFER:
                glBindBufferBase(target, index, buffer);
                break;
            default:
                glBindBuffer(target, buffer);
                break;
        }
    }

    void unbind() {
        glBindBuffer(target, 0);
    }

    template <typename T>
    void create_empty(unsigned int num_elements, GLenum usage) {
        this->usage = usage;
        this->size = num_elements * sizeof(T);
        bind();
        glBufferData(target, size, nullptr, usage);
        unbind();
    }

    template <typename T>
    void load(const std::vector<T> &data, GLenum usage) {
        this->usage = usage;
        bind();
        size = data.size() * sizeof(T);
        num_elements = data.size();
 
        glBufferData(target, size, data.data(), usage);
        unbind();
    }

    template <typename T>
    void load(unsigned int num_elements, const T *data, GLenum usage) {
        this->usage = usage;
        bind();
        size = num_elements * sizeof(T);
 
        glBufferData(target, size, data, usage);
        unbind();
    }

    bool store(unsigned int offset, unsigned int size, void *storage) {
        if(offset >= this->size)
            return false;
 
        if(size < this->size - offset)
            return false;
 
        if(!storage)
            return false;
 
        bind(GL_COPY_READ_BUFFER);
        glGetBufferSubData(GL_COPY_READ_BUFFER, offset, size, storage);
        unbind();
 
        return true;
     }

    bool copy(Buffer& source, unsigned int read_offset,
          unsigned int write_offset, unsigned int size) {
 
        if(read_offset >= source.size ||
            read_offset + size >= source.size)
                return false;
 
        if(write_offset >= this->size ||
            write_offset + size >= this->size)
                return false;
 
        source.bind(GL_COPY_READ_BUFFER);
        bind(GL_COPY_WRITE_BUFFER);
        glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER,
                        read_offset, write_offset, size);
        source.unbind();
        unbind();
 
        return true;
    }

    bool copy(Buffer *source, unsigned int read_offset,
          unsigned int write_offset, unsigned int size) {
 
        if(!source)
            return false;
 
        if(read_offset >= source->size ||
            read_offset + size >= source->size)
                return false;
 
        if(write_offset >= this->size ||
            write_offset + size >= this->size)
                return false;
 
        source->bind(GL_COPY_READ_BUFFER);
        bind(GL_COPY_WRITE_BUFFER);
        glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER,
                        read_offset, write_offset, size);
        source->unbind();
        unbind();
 
        return true;
    }

    void *map(GLenum access) {
        bind(GL_ARRAY_BUFFER);
        void *ptr = glMapBuffer(target, access);
        unbind();
        return ptr;
     }

    void unmap() {
        bind(GL_ARRAY_BUFFER);
        glUnmapBuffer(target);
        unbind();
     }

    template <typename T>
    void replace_data(const std::vector<T> &data) {
        bind();
 
        unsigned int new_size = data.size() * sizeof(T);
 
        if(size == new_size) {
            //replace the buffer data without reallocation
            glBufferSubData(target, 0, size, data.data());
        } else {
            //replace the buffer data with reallocation
            size = new_size;
            glBufferData(target, new_size, data.data(), usage);
        }
        unbind();
    }

    template <typename T>
    void replace_data(const T *data, unsigned int number_elements) {
        bind();
 
        unsigned int new_size = number_elements * sizeof(T);
 
        if(size == new_size) {
            //replace the buffer data without reallocation
            glBufferSubData(target, 0, size, data);
        } else {
            //replace the buffer data with reallocation
            size = new_size;
            glBufferData(target, new_size, data, usage);
        }
        unbind();
    }

    template <typename T>
    bool replace_partial_data(unsigned int offset, const std::vector<T>& data) {
 
        unsigned int data_size = data.size() * sizeof(T);
 
        if(offset + data_size > size) {
            return false;
        }
 
        bind();
        glBufferSubData(target, offset, data_size, data.data());
        unbind();
        return true;
    }

    template <typename T>
    bool replace_partial_data(unsigned int offset,
                  const T *data,
                  unsigned int number_elements) {
 
        unsigned int data_size = number_elements * sizeof(T);
 
        if(offset + data_size > size) {
            return false;
        }
 
        bind();
        glBufferSubData(target, offset, data_size, data);
        unbind();
        return true;
    }
 
};
 
};
 
#endif