StorageHandler.hpp

#pragma once
 
#include "PixelBullet/Graphics/Buffers/StorageBuffer.hpp"
 
#include <cstring>
 
namespace PixelBullet
{
    class StorageHandler
    {
    public:
        explicit StorageHandler(bool multipipeline = false);
        explicit StorageHandler(const Shader::UniformBlock& uniformBlock, bool multipipeline = false);
 
        void Push(void* data, std::size_t size)
        {
            if (this->m_Size != size)
            {
                this->m_Size = static_cast<uint32_t>(size);
                m_HandlerStatus = Buffer::Status::Reset;
                return;
            }
 
            if (!m_UniformBlock || !m_StorageBuffer)
            {
                return;
            }
 
            if (!m_Bound)
            {
                m_StorageBuffer->MapMemory(&this->m_Data);
                m_Bound = true;
            }
 
            // If the buffer is already changed we can skip a memory comparison and just copy.
            if (m_HandlerStatus == Buffer::Status::Changed ||
                std::memcmp(static_cast<char*>(this->m_Data), data, size) != 0)
            {
                std::memcpy(static_cast<char*>(this->m_Data), data, size);
                m_HandlerStatus = Buffer::Status::Changed;
            }
        }
 
        template <typename T>
        void Push(const T& object, std::size_t offset, std::size_t size)
        {
            if (!m_UniformBlock || !m_StorageBuffer)
            {
                return;
            }
 
            if (!m_Bound)
            {
                m_StorageBuffer->MapMemory(&this->m_Data);
                m_Bound = true;
            }
 
            // If the buffer is already changed we can skip a memory comparison and just copy.
            if (m_HandlerStatus == Buffer::Status::Changed ||
                std::memcmp(static_cast<char*>(this->m_Data) + offset, &object, size) != 0)
            {
                std::memcpy(static_cast<char*>(this->m_Data) + offset, &object, size);
                m_HandlerStatus = Buffer::Status::Changed;
            }
        }
 
        template <typename T>
        void Push(const std::string& uniformName, const T& object, std::size_t size = 0)
        {
            if (!m_UniformBlock)
            {
                return;
            }
 
            auto uniform = m_UniformBlock->GetUniform(uniformName);
            if (!uniform)
            {
                return;
            }
 
            auto realSize = size;
            if (realSize == 0)
            {
                realSize = std::min(sizeof(object), static_cast<std::size_t>(uniform->GetSize()));
            }
 
            Push(object, static_cast<std::size_t>(uniform->GetOffset()), realSize);
        }
 
        bool Update(const std::optional<Shader::UniformBlock>& uniformBlock);
 
        const StorageBuffer* GetStorageBuffer() const
        {
            return m_StorageBuffer.get();
        }
 
    private:
        bool m_Multipipeline;
        std::optional<Shader::UniformBlock> m_UniformBlock;
        uint32_t m_Size = 0;
        void* m_Data = nullptr;
        bool m_Bound = false;
        std::unique_ptr<StorageBuffer> m_StorageBuffer;
        Buffer::Status m_HandlerStatus;
    };
} // namespace PixelBullet