PushHandler.hpp

#pragma once
 
#include "PixelBullet/Graphics/Pipelines/Pipeline.hpp"
 
#include <cstring>
#include <optional>
 
namespace PixelBullet
{
    class PushHandler
    {
    public:
        explicit PushHandler(bool multipipeline = false);
        explicit PushHandler(const Shader::UniformBlock& uniformBlock, bool multipipeline = false);
 
        template <typename T>
        void Push(const T& object, std::size_t offset, std::size_t size)
        {
            std::memcpy(m_Data.get() + offset, &object, size);
        }
 
        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);
 
        void BindPush(const CommandBuffer& commandBuffer, const Pipeline& pipeline);
 
    private:
        bool m_Multipipeline;
        std::optional<Shader::UniformBlock> m_UniformBlock;
        std::unique_ptr<char[]> m_Data;
    };
} // namespace PixelBullet