bufferobject.hpp

Go to the documentation of this file.

#ifndef __BUFFEROBJECT__
#define __BUFFEROBJECT__

#include "tucano/shader.hpp"
#include "tucano/texture.hpp"
#include <Eigen/Dense>
#include <vector>
#include <iostream>
#include <limits>
#include <GL/glew.h>

namespace Tucano
{

template <class T> class BufferObject {

protected:

    virtual void create(void)
    {
        // declare and generate a buffer object name
        glGenBuffers(1, &buffer_id);
        bind();
        // define its initial storage capacity
        glBufferData(buffer_type, sizeof(T) * size, NULL, GL_DYNAMIC_DRAW);
        unbind();
    }

    GLuint buffer_id;

    GLenum buffer_type;

    int size;

    int binding_point;

public:

    BufferObject (int s, GLenum buftype) : buffer_id(0), buffer_type(buftype), size(s)
    {
        create();
        clear();
    }

    virtual ~BufferObject (void)
    {}

    GLuint getBufferID (void) {
        return buffer_id;
    }

    virtual void bind (void)
    {
        glBindBuffer(buffer_type, buffer_id);
    }

    void bindBase (int index)
    {
        binding_point = index;
        glBindBufferBase(buffer_type, binding_point, buffer_id);
    }

    void unbindBase (void) {
        glBindBufferBase(buffer_type, binding_point, 0);
        binding_point = -1;
    }

    virtual void unbind(void)
    {
        glBindBuffer(buffer_type, 0);
    }

    virtual void clear (void)
    {
        // declare a pointer to hold the values in the buffer
        T *buffer_data;
        bind();
        // map the buffer, userCounters will point to the buffers data

        buffer_data = (T*)glMapBufferRange(buffer_type,
                                                 0 ,
                                                 sizeof(T) * size,
                                                 GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT | GL_MAP_UNSYNCHRONIZED_BIT
                                                 );

        // set the memory to zeros, resetting the values in the buffer
        memset(buffer_data, 0, sizeof(T) * size );
        // unmap the buffer
        glUnmapBuffer(buffer_type);
        unbind();

    }

    virtual void readBuffer (T **return_values)
    {
        T *values = new T[size];
        T *buffer_data;
        bind();
        // again we map the buffer to userCounters, but this time for read-only access
        buffer_data = (T*)glMapBufferRange(buffer_type,
                                                 0,
                                                 sizeof(T) * size,
                                                 GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT | GL_MAP_UNSYNCHRONIZED_BIT
                                                );

        // copy the values to other variables because...
        for (int i = 0; i < size; ++i) {
            values[i] = buffer_data[i];
        }
        *return_values = values;

        // ... as soon as we unmap the buffer the pointer buffer becomes invalid.
        glUnmapBuffer(buffer_type);
        unbind();
    }

    void printBuffer (void) {
        T *values;
        readBuffer(&values);
        for (int i = 0; i < size; ++i) {
            cout << i << " : " << values[i] << endl;
        }
        delete [] values;
    }

    int getSize (void)
    {
        return size;
    }



};

class AtomicBuffer : public BufferObject <GLuint>
{

public:
    AtomicBuffer (int s) : BufferObject<GLuint>(s, GL_ATOMIC_COUNTER_BUFFER) {}
};

class ShaderStorageBufferFloat: public BufferObject <GLfloat>
{

public:
    ShaderStorageBufferFloat (int s) : BufferObject<GLfloat>(s, GL_SHADER_STORAGE_BUFFER) {}
};

class ShaderStorageBufferInt: public BufferObject <GLint>
{

public:
    ShaderStorageBufferInt (int s) : BufferObject<GLint>(s, GL_SHADER_STORAGE_BUFFER) {}
};

}

#endif