UniformHandler.hpp

#pragma once
 
#include "PixelBullet/Graphics/Buffers/UniformBuffer.hpp"
 
#include <cstring>
 
namespace PixelBullet
{
    class UniformHandler
    {
    public:
        explicit UniformHandler(bool multipipeline = false);
        explicit UniformHandler(const Shader::UniformBlock& uniformBlock, bool multipipeline = false);
 
        template <typename T>
        void Push(const T& object, std::size_t offset, std::size_t size)
        {
            if (!m_UniformBlock || !m_UniformBuffer)
            {
                return;
            }
 
            if (!m_Bound)
            {
                m_UniformBuffer->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), &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 || !m_UniformBuffer)
            {
                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 UniformBuffer* GetUniformBuffer() const
        {
            return m_UniformBuffer.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<UniformBuffer> m_UniformBuffer;
        Buffer::Status m_HandlerStatus;
    };
} // namespace PixelBullet