Beatmup::GL::StorageBuffer Class Reference

#include <storage_buffer.h>

Public Member Functions
	StorageBuffer (GL::RecycleBin &recycleBin)
	~StorageBuffer ()
void	allocate (GraphicPipeline &gpu, const size_t sizeBytes, const void *data=nullptr)
void	allocateStatic (GraphicPipeline &gpu, const size_t sizeBytes, const void *data)
void	bind (GraphicPipeline &gpu, int unit) const
void	fetch (GraphicPipeline &gpu, void *data, size_t limit)
void	fetchToBitmap (GraphicPipeline &gpu, size_t offset, size_t stride, AbstractBitmap &bitmap)
	Copies buffer content to a bitmap. More...
size_t	getCurrentCapacity () const

Private Attributes
size_t	sizeBytes
GL::RecycleBin &	recycleBin
handle_t	handle

Friends
class	AbstractProgram

Detailed Description

Definition at line 26 of file storage_buffer.h.

Constructor & Destructor Documentation

StorageBuffer()

StorageBuffer::StorageBuffer

(

GL::RecycleBin &

recycleBin

)

Definition at line 30 of file storage_buffer.cpp.

                                                    :
    sizeBytes(0), recycleBin(recycleBin), handle(0)
{}

~StorageBuffer()

StorageBuffer::~StorageBuffer

(

)

Definition at line 35 of file storage_buffer.cpp.

                              {
    class Deleter : public GL::RecycleBin::Item {
    private:
        const handle_t handle;
    public:
        Deleter(handle_t handle) : handle(handle) {}
        ~Deleter() {
            glDeleteBuffers(1, &handle);
        }
    };
 
    if (handle)
        recycleBin.put(new Deleter(handle));
}

Member Function Documentation

allocate()

void StorageBuffer::allocate	(	GraphicPipeline &	gpu,
		const size_t	sizeBytes,
		const void *	data = nullptr
	)

Definition at line 51 of file storage_buffer.cpp.

                                                                                           {
    if (handle && this->sizeBytes != sizeBytes) {
        glDeleteBuffers(1, &handle);
        handle = 0;
    }
 
    if (!handle && sizeBytes > 0) {
        glGenBuffers(1, &handle);
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, handle);
        glBufferData(GL_SHADER_STORAGE_BUFFER, sizeBytes, data, GL_DYNAMIC_COPY);
    }
 
    this->sizeBytes = sizeBytes;
}

allocateStatic()

void Beatmup::GL::StorageBuffer::allocateStatic	(	GraphicPipeline &	gpu,
		const size_t	sizeBytes,
		const void *	data
	)

Definition at line 66 of file storage_buffer.cpp.

                                                                                                          {
    if (handle && this->sizeBytes != sizeBytes) {
        glDeleteBuffers(1, &handle);
        handle = 0;
    }
 
    if (!handle && sizeBytes > 0) {
        glGenBuffers(1, &handle);
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, handle);
        glBufferData(GL_SHADER_STORAGE_BUFFER, sizeBytes, data, GL_STATIC_DRAW);
    }
 
    this->sizeBytes = sizeBytes;
}

bind()

void StorageBuffer::bind	(	GraphicPipeline &	gpu,
		int	unit
	)		const

Definition at line 82 of file storage_buffer.cpp.

                                                             {
    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, unit, handle);
    GLException::check("binding storage buffer");
}

fetch()

void StorageBuffer::fetch	(	GraphicPipeline &	gpu,
		void *	data,
		size_t	limit
	)

Definition at line 88 of file storage_buffer.cpp.

                                                                        {
    glBindBuffer(GL_SHADER_STORAGE_BUFFER, handle);
    void* buffer = glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, limit, GL_MAP_READ_BIT);
    const bool okay = buffer != nullptr;
    if (okay)
        memcpy(data, buffer, limit);
    glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
    GLException::check("reading storage buffer");
    if (!okay)
        throw RuntimeError("Buffer data not available");
}

fetchToBitmap()

void Beatmup::GL::StorageBuffer::fetchToBitmap	(	GraphicPipeline &	gpu,
		size_t	offset,
		size_t	stride,
		AbstractBitmap &	bitmap
	)

Copies buffer content to a bitmap.

Parameters

[in]	gpu	Graphic pipeline instance
[in]	offset	Offset in the buffer in bytes
[in]	stride	Stride between entries to be copied to the bitmap in the buffer in bytes
[out]	bitmap	The bitmap to fill

Definition at line 101 of file storage_buffer.cpp.

                                                                                                                     {
    Beatmup::RuntimeError::check(!bitmap.isMask(), "Mask bitmaps are not supported");
 
    const size_t limit = offset + stride * (bitmap.getSize().numPixels() - 1) + bitmap.getBitsPerPixel() / 8;
    Beatmup::RuntimeError::check(getCurrentCapacity() >= limit, "Bitmap does not fit the buffer content");
    AbstractBitmap::WriteLock<ProcessingTarget::CPU> lock(bitmap);
 
    glBindBuffer(GL_SHADER_STORAGE_BUFFER, handle);
    const pixbyte* buffer = (const pixbyte*)glMapBufferRange(GL_SHADER_STORAGE_BUFFER, offset, limit - offset, GL_MAP_READ_BIT);
    const bool okay = buffer != nullptr;
    if (okay) {
        pixbyte* ptr = bitmap.getData(0, 0);
        const int
            nPix = bitmap.getSize().numPixels(),
            step = bitmap.getBitsPerPixel() / 8;
        for (int i = 0; i < nPix; ++i, ptr += step, buffer += stride)
            memcpy(ptr, buffer, step);
    }
    glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
}

getCurrentCapacity()

size_t Beatmup::GL::StorageBuffer::getCurrentCapacity ( ) const

inline

Definition at line 49 of file storage_buffer.h.

{ return sizeBytes; }

Friends And Related Function Documentation

AbstractProgram

friend class AbstractProgram

friend

Definition at line 27 of file storage_buffer.h.

Member Data Documentation

sizeBytes

size_t Beatmup::GL::StorageBuffer::sizeBytes

private

Definition at line 29 of file storage_buffer.h.

recycleBin

GL::RecycleBin& Beatmup::GL::StorageBuffer::recycleBin

private

Definition at line 30 of file storage_buffer.h.

handle

handle_t Beatmup::GL::StorageBuffer::handle

private

Definition at line 31 of file storage_buffer.h.

---

The documentation for this class was generated from the following files:

• core/gpu/storage_buffer.h
• core/gpu/storage_buffer.cpp