SubrenderHolder.hpp

#pragma once
 
#include "PixelBullet/Graphics/Pipelines/Pipeline.hpp"
#include "PixelBullet/Graphics/Subrender.hpp"
 
#include <map>
#include <unordered_map>
 
namespace PixelBullet
{
    class SubrenderHolder
    {
        friend class Graphics;
 
    public:
        SubrenderHolder() = default;
        ~SubrenderHolder() = default;
 
        SubrenderHolder(const SubrenderHolder&) = delete;
        SubrenderHolder& operator=(const SubrenderHolder&) = delete;
        SubrenderHolder(SubrenderHolder&&) noexcept = default;
        SubrenderHolder& operator=(SubrenderHolder&&) noexcept = default;
 
        template <typename T, typename = std::enable_if_t<std::is_convertible_v<T*, Subrender*>>>
        bool Has() const
        {
            return m_Subrenders.count(TypeInfo<Subrender>::Get<T>()) != 0;
        }
 
        template <typename T, typename = std::enable_if_t<std::is_convertible_v<T*, Subrender*>>>
        T* Get() const
        {
            auto it = m_Subrenders.find(TypeInfo<Subrender>::Get<T>());
            return (it != m_Subrenders.end()) ? static_cast<T*>(it->second.get()) : nullptr;
        }
 
        template <typename T, typename = std::enable_if_t<std::is_convertible_v<T*, Subrender*>>>
        T* Add(const Pipeline::Stage& stage, std::unique_ptr<T>&& subrender)
        {
            const auto typeId = TypeInfo<Subrender>::Get<T>();
            m_Stages.emplace(StageIndex(stage, m_Subrenders.size()), typeId);
            m_Subrenders[typeId] = std::move(subrender);
            return static_cast<T*>(m_Subrenders[typeId].get());
        }
 
        template <typename T, typename = std::enable_if_t<std::is_convertible_v<T*, Subrender*>>>
        void Remove()
        {
            const auto typeId = TypeInfo<Subrender>::Get<T>();
            RemoveSubrenderStage(typeId);
            m_Subrenders.erase(typeId);
        }
 
        void Clear()
        {
            m_Stages.clear();
            m_Subrenders.clear();
        }
 
    private:
        using StageIndex = std::pair<Pipeline::Stage, std::size_t>;
 
        void RemoveSubrenderStage(TypeID id)
        {
            for (auto it = m_Stages.begin(); it != m_Stages.end();)
            {
                if (it->second == id)
                {
                    it = m_Stages.erase(it);
                }
                else
                {
                    ++it;
                }
            }
        }
 
        void RenderStage(const Pipeline::Stage& stage, const CommandBuffer& commandBuffer)
        {
            for (auto const& [stageIdx, typeId] : m_Stages)
            {
                if (stageIdx.first != stage)
                {
                    continue;
                }
 
                auto& sr = m_Subrenders[typeId];
                if (sr && sr->IsEnabled())
                {
                    sr->Render(commandBuffer);
                }
            }
        }
 
        std::unordered_map<TypeID, std::unique_ptr<Subrender>> m_Subrenders;
        std::multimap<StageIndex, TypeID> m_Stages;
    };
} // namespace PixelBullet