spk_shader_storage_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 <cstddef>
#include <cstring>
#include <optional>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <vector>
 
namespace spk
{
    namespace OpenGL
    {
        class ShaderStorageBufferObject : private BufferObject
        {
        private:
            GLuint _bindingPoint = 0;
            std::size_t _fixedSectionSize = 0;
            std::size_t _paddingBetweenFixedAndDynamicPart = 0;
            BufferLayout _layout;
            std::wstring _dynamicArrayName;
            std::optional<BufferLayout::Element> _dynamicArrayPrototype;
            bool _dynamicArrayPresent = false;
 
            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;

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

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

            void setDynamicElement(const std::wstring &p_name, const BufferLayout::Element &p_elementPrototype);
            void setDynamicPadding(std::size_t p_padding);
            void resizeDynamicArray(std::size_t p_newCount);
 
            template <typename TType>
            TType pullFixed() const
            {
                static_assert(std::is_trivially_copyable_v<TType>, "ShaderStorageBufferObject::pullFixed requires a trivially copyable type");
 
                if (sizeof(TType) > _fixedSectionSize)
                {
                    throw std::runtime_error("ShaderStorageBufferObject::pullFixed: requested type is larger than the fixed section");
                }
 
                const auto rawData = spk::OpenGLUtils::readBuffer(static_cast<GLenum>(_type), static_cast<GLuint>(_id));
                if (rawData.size() < _fixedSectionSize)
                {
                    throw std::runtime_error("ShaderStorageBufferObject::pullFixed: GPU buffer is smaller than the fixed section");
                }
 
                TType value{};
                std::memcpy(&value, rawData.data(), sizeof(TType));
                return value;
            }
 
            template <typename TElement>
            std::vector<TElement> pullDynamic() const
            {
                static_assert(std::is_trivially_copyable_v<TElement>, "ShaderStorageBufferObject::pullDynamic requires a trivially copyable type");
 
                if (_dynamicArrayPrototype.has_value() == false)
                {
                    throw std::runtime_error("ShaderStorageBufferObject::pullDynamic: dynamic array is not configured");
                }
 
                const auto rawData = spk::OpenGLUtils::readBuffer(static_cast<GLenum>(_type), static_cast<GLuint>(_id));
                const std::size_t offset = _fixedSectionSize + _paddingBetweenFixedAndDynamicPart;
 
                if (rawData.size() < offset)
                {
                    throw std::runtime_error("ShaderStorageBufferObject::pullDynamic: GPU buffer is smaller than the dynamic section offset");
                }
 
                const std::size_t dynamicByteSize = rawData.size() - offset;
                if (dynamicByteSize == 0)
                {
                    return {};
                }
 
                if (dynamicByteSize % sizeof(TElement) != 0)
                {
                    throw std::runtime_error("ShaderStorageBufferObject::pullDynamic: dynamic section is not a multiple of the element size");
                }
 
                std::vector<TElement> values(dynamicByteSize / sizeof(TElement));
                std::memcpy(values.data(), rawData.data() + offset, dynamicByteSize);
                return values;
            }
        };
 
        using SSBO = ShaderStorageBufferObject;
    }
}