UniformBufferObject.hpp

Go to the documentation of this file.

 
#ifndef CSCI441_UNIFORM_BUFFER_OBJECT_HPP
#define CSCI441_UNIFORM_BUFFER_OBJECT_HPP
 
#include "constants.h"
#include "LogUtils.hpp"
#include "ShaderProgram.hpp"
 
#ifdef CSCI441_USE_GLEW
    #include <GL/glew.h>
#else
    #include <glad/gl.h>
#endif
 
#include <cstdio>
#include <vector>
 
//******************************************************************************
 
namespace CSCI441 {
 
    class [[maybe_unused]] UniformBufferObject final {
    public:
        UniformBufferObject() = delete;
 
        UniformBufferObject(UniformBufferObject& unused) = delete;
        UniformBufferObject& operator=(UniformBufferObject& unused) = delete;
 
        UniformBufferObject(UniformBufferObject&&) noexcept;
        UniformBufferObject& operator=(UniformBufferObject&&) noexcept;
 
        [[maybe_unused]] UniformBufferObject(const char* UNIFORM_BLOCK_NAME, const std::initializer_list<const char*> uniformNamesList);
        ~UniformBufferObject();
 
        UniformBufferObject(const UniformBufferObject&) = delete;
        UniformBufferObject& operator=(const UniformBufferObject&) = delete;
 
        [[maybe_unused]] void setupWithShaderProgram( ShaderProgram *shaderProgram, GLuint bindingPoint );
 
        [[maybe_unused]] void bindToShaderProgram( ShaderProgram *shaderProgram );
 
        [[maybe_unused]] void copyToOffset( unsigned int offset, const void * src, size_t len );
 
        [[maybe_unused]] void copyToBuffer( const char* UNIFORM_NAME, const void * src, size_t len );
 
        [[maybe_unused]] void setUniform( const char* UNIFORM_NAME, GLboolean value );
        [[maybe_unused]] void setUniform( const char* UNIFORM_NAME, GLint value );
        [[maybe_unused]] void setUniform( const char* UNIFORM_NAME, GLfloat value );
        [[maybe_unused]] void setUniform( const char* UNIFORM_NAME, glm::vec3 vec );
        [[maybe_unused]] void setUniform( const char* UNIFORM_NAME, glm::vec4 vec );
        [[maybe_unused]] void setUniform( const char* UNIFORM_NAME, glm::mat4 mtx );
        [[maybe_unused]] void setUniform( const char* UNIFORM_NAME, const GLint* pArray, GLint count );
        [[maybe_unused]] void setUniform( const char* UNIFORM_NAME, const glm::ivec4* pArray, GLint count );
 
        void bindBuffer() const;
 
        [[maybe_unused]] void bufferSubData() const;
 
    private:
        char* _blockName;
        std::vector<char*> _uniformNames;
        GLint _blockSize;
        GLubyte* _buffer;
        GLuint _numUniforms;
        GLuint* _uniformIndices;
        GLint* _uniformOffsets;
        GLuint _ubod;
        GLuint _bindingPoint;
 
        void _cleanupSelf();
        void _moveFromSource(UniformBufferObject&);
    };
}
 
//******************************************************************************
 
[[maybe_unused]]
inline CSCI441::UniformBufferObject::UniformBufferObject(const char* UNIFORM_BLOCK_NAME, const std::initializer_list<const char*> uniformNamesList) {
    _blockName = new char[strlen(UNIFORM_BLOCK_NAME) + 1];
    strncpy(_blockName, UNIFORM_BLOCK_NAME, strlen(UNIFORM_BLOCK_NAME));
    _blockName[ strlen(UNIFORM_BLOCK_NAME) ] = '\0';
 
    _numUniforms = uniformNamesList.size();
 
    for(const auto &uniformName : uniformNamesList ) {
        const auto un = new char[ strlen(uniformName) + 1];
        strncpy(un, uniformName, strlen(uniformName));
        un[strlen(uniformName)] = '\0';
        _uniformNames.push_back(un);
    }
 
    _uniformIndices = new GLuint[_numUniforms];
    _uniformOffsets = new GLint[_numUniforms];
 
    _blockSize = 0;
    _buffer = nullptr;
    _bindingPoint = 0;
    _ubod = 0;
}
 
inline CSCI441::UniformBufferObject::UniformBufferObject(UniformBufferObject&& src) noexcept {
    _moveFromSource(src);
}
 
inline CSCI441::UniformBufferObject& CSCI441::UniformBufferObject::operator=(UniformBufferObject&& src) noexcept {
    if (this != &src) {             // guard against self movement
        _cleanupSelf();             // cleanup existing UBO
        _moveFromSource(src);   // move source UBO
    }
    return *this;                   // return ourselves
}
 
inline CSCI441::UniformBufferObject::~UniformBufferObject() {
    _cleanupSelf();
}
 
[[maybe_unused]]
inline void CSCI441::UniformBufferObject::setupWithShaderProgram( ShaderProgram * shaderProgram, const GLuint bindingPoint ) {
    _blockSize = shaderProgram->getUniformBlockSize( _blockName );
    _buffer = new GLubyte[ _blockSize ];
 
    glGetUniformIndices(shaderProgram->getShaderProgramHandle(), _numUniforms, &_uniformNames[0], _uniformIndices);
    glGetActiveUniformsiv(shaderProgram->getShaderProgramHandle(), _numUniforms, _uniformIndices, GL_UNIFORM_OFFSET, _uniformOffsets);
 
    glGenBuffers(1, &_ubod);
    bindBuffer();
    glBufferData(GL_UNIFORM_BUFFER, _blockSize, nullptr, GL_DYNAMIC_DRAW);
 
    _bindingPoint = bindingPoint;
    glBindBufferBase(GL_UNIFORM_BUFFER, _bindingPoint, _ubod);
    shaderProgram->setUniformBlockBinding(_blockName, _bindingPoint);
}
 
[[maybe_unused]]
inline void CSCI441::UniformBufferObject::bindToShaderProgram( ShaderProgram *shaderProgram ) {
    shaderProgram->setUniformBlockBinding(_blockName, _bindingPoint);
}
 
[[maybe_unused]]
inline void CSCI441::UniformBufferObject::copyToOffset( const unsigned int offset, const void * src, const size_t len ) {
    if(offset < _numUniforms) {
        memcpy(_buffer + _uniformOffsets[offset], src, len);
    } else {
        CSCI441::LogUtils::logError("[ERROR]: Offset %d exceeds size of Uniform Block %s which is %d\n", offset, _blockName, _numUniforms);
    }
}
 
[[maybe_unused]]
inline void CSCI441::UniformBufferObject::copyToBuffer( const char* UNIFORM_NAME, const void * src, const size_t len ) {
    bool found = false;
    for(GLuint i = 0; i < _numUniforms; i++) {
        if( strcmp(_uniformNames[i], UNIFORM_NAME) == 0 ) {
            memcpy( _buffer + _uniformOffsets[i], src, len );
            found = true;
            break;
        }
    }
    if(!found) {
        CSCI441::LogUtils::logError("[ERROR]: Uniform Name \"%s\" not found within Uniform Block \"%s\"\n", UNIFORM_NAME, _blockName);
    }
}
 
[[maybe_unused]]
inline void CSCI441::UniformBufferObject::setUniform( const char* UNIFORM_NAME, const GLboolean value ) {
    copyToBuffer(UNIFORM_NAME, &value, sizeof(GLboolean));
}
 
[[maybe_unused]]
inline void CSCI441::UniformBufferObject::setUniform( const char* UNIFORM_NAME, const GLint value ) {
    copyToBuffer(UNIFORM_NAME, &value, sizeof(GLint));
}
 
[[maybe_unused]]
inline void CSCI441::UniformBufferObject::setUniform( const char* UNIFORM_NAME, const GLfloat value ) {
    copyToBuffer(UNIFORM_NAME, &value, sizeof(GLfloat));
}
 
[[maybe_unused]]
inline void CSCI441::UniformBufferObject::setUniform( const char* UNIFORM_NAME, const glm::vec3 vec ) {
    copyToBuffer(UNIFORM_NAME, glm::value_ptr(vec), sizeof(glm::vec3));
}
 
[[maybe_unused]]
inline void CSCI441::UniformBufferObject::setUniform( const char* UNIFORM_NAME, const glm::vec4 vec ) {
    copyToBuffer(UNIFORM_NAME, glm::value_ptr(vec), sizeof(glm::vec4));
}
 
[[maybe_unused]]
inline void CSCI441::UniformBufferObject::setUniform( const char* UNIFORM_NAME, const glm::mat4 mtx ) {
    copyToBuffer(UNIFORM_NAME, glm::value_ptr(mtx), sizeof(glm::mat4));
}
 
[[maybe_unused]]
inline void CSCI441::UniformBufferObject::setUniform( const char* UNIFORM_NAME, const GLint * const pArray, const GLint count ) {
    copyToBuffer(UNIFORM_NAME, pArray, sizeof(GLint) * count);
}
 
[[maybe_unused]]
inline void CSCI441::UniformBufferObject::setUniform( const char* UNIFORM_NAME, const glm::ivec4 * const pArray, const GLint count ) {
    copyToBuffer(UNIFORM_NAME, pArray, sizeof(glm::ivec4) * count);
}
 
inline void CSCI441::UniformBufferObject::bindBuffer() const {
    glBindBuffer(GL_UNIFORM_BUFFER, _ubod);
}
 
[[maybe_unused]]
inline void CSCI441::UniformBufferObject::bufferSubData() const {
    glBufferSubData(GL_UNIFORM_BUFFER, 0, _blockSize, _buffer);
}
 
inline void CSCI441::UniformBufferObject::_cleanupSelf() {
    glDeleteBuffers(1, &_ubod);
    _ubod = 0;
 
    for(GLuint i = 0; i < _numUniforms; i++) {
        delete[] _uniformNames[i];
    }
    _uniformNames.clear();
 
    delete[] _uniformIndices;
    _uniformIndices = nullptr;
 
    delete[] _uniformOffsets;
    _uniformOffsets = nullptr;
 
    delete[] _buffer;
    _buffer = nullptr;
 
    delete[] _blockName;
    _blockName = nullptr;
 
    _numUniforms = 0;
    _blockSize = 0;
    _bindingPoint = 0;
}
 
 
inline void CSCI441::UniformBufferObject::_moveFromSource(UniformBufferObject &src) {
    _blockName = src._blockName;
    src._blockName = nullptr;
 
    _numUniforms = src._numUniforms;
    src._numUniforms = 0;
 
    _uniformNames = std::move(src._uniformNames);
    src._uniformNames.clear();
 
    _uniformIndices = src._uniformIndices;
    src._uniformIndices = nullptr;
 
    _uniformOffsets = src._uniformOffsets;
    src._uniformOffsets = nullptr;
 
    _blockSize = src._blockSize;
    src._blockSize = 0;
 
    _buffer = src._buffer;
    src._buffer = nullptr;
 
    _bindingPoint = src._bindingPoint;
    src._bindingPoint = 0;
 
    _ubod = src._ubod;
    src._ubod = 0;
}
 
#endif //CSCI441_UNIFORM_BUFFER_OBJECT_HPP