spk_uniform_buffer_object.hpp

#pragma once
 
#include "structure/container/spk_buffer_layout.hpp"
#include "structure/opengl/spk_buffer_object.hpp"
#include "structure/opengl/spk_opengl_includes.hpp"
#include "utils/spk_opengl_utils.hpp"
#include <cstring>
#include <stdexcept>
#include <type_traits>
 
namespace spk
{
    namespace OpenGL
    {
        class UniformBufferObject : private BufferObject
        {
        private:
            GLuint _bindingPoint = 0;
            BufferLayout _layout;
 
            BufferLayout _initializeLayout(size_t p_size);
            void _registerCallbacks();
 
        public:
            using BufferObject::activate;
            using BufferObject::data;
            using BufferObject::deactivate;
            using BufferObject::isActive;
            using BufferObject::needsSynchronization;
            using BufferObject::requestSynchronization;
            using BufferObject::size;

            UniformBufferObject(GLuint p_bindingPoint, BufferObject::Usage p_usage, const size_t &p_size);
            UniformBufferObject(const UniformBufferObject &p_other);
            UniformBufferObject &operator=(const UniformBufferObject &p_other);

            BufferLayout &layout();
            const BufferLayout &layout() const;

            template <typename TType>
            TType pull() const
            {
                static_assert(std::is_trivially_copyable_v<TType>, "UniformBufferObject::pull requires a trivially copyable type");
 
                const auto rawData = spk::OpenGLUtils::readBuffer(static_cast<GLenum>(_type), static_cast<GLuint>(_id));
                if (rawData.size() < sizeof(TType))
                {
                    throw std::runtime_error("UniformBufferObject::pull: GPU buffer is smaller than requested type");
                }
 
                TType value{};
                std::memcpy(&value, rawData.data(), sizeof(TType));
                return value;
            }

            BufferLayout::Element &operator[](const std::wstring &p_name);
            const BufferLayout::Element &operator[](const std::wstring &p_name) const;
        };
 
        using UBO = UniformBufferObject;
    }
}