subrender_holder.h

#pragma once
 
#include "pixelbullet/graphics/pipelines/pipeline.h"
#include "pixelbullet/graphics/subrender.h"
 
#include <map>
#include <typeindex>
#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 subrenders_.count(std::type_index(typeid(T))) != 0;
    }
 
    template <typename T, typename = std::enable_if_t<std::is_convertible_v<T*, Subrender*>>>
    T* Get() const
    {
        auto it = subrenders_.find(std::type_index(typeid(T)));
        return (it != 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 = std::type_index(typeid(T));
        stages_.emplace(StageIndex(stage, subrenders_.size()), typeId);
        subrenders_[typeId] = std::move(subrender);
        return static_cast<T*>(subrenders_[typeId].get());
    }
 
    template <typename T, typename = std::enable_if_t<std::is_convertible_v<T*, Subrender*>>>
    void Remove()
    {
        const auto typeId = std::type_index(typeid(T));
        RemoveSubrenderStage(typeId);
        subrenders_.erase(typeId);
    }
 
    void Clear()
    {
        stages_.clear();
        subrenders_.clear();
    }
 
private:
    using StageIndex = std::pair<Pipeline::Stage, std::size_t>;
 
    void RemoveSubrenderStage(std::type_index id)
    {
        for (auto it = stages_.begin(); it != stages_.end();)
        {
            if (it->second == id)
            {
                it = stages_.erase(it);
            }
            else
            {
                ++it;
            }
        }
    }
 
    void RenderStage(const Pipeline::Stage& stage, const CommandBuffer& commandBuffer)
    {
        for (auto const& [stageIdx, typeId] : stages_)
        {
            if (stageIdx.first != stage)
            {
                continue;
            }
 
            auto& sr = subrenders_[typeId];
            if (sr && sr->IsEnabled())
            {
                sr->Render(commandBuffer);
            }
        }
    }
 
    std::unordered_map<std::type_index, std::unique_ptr<Subrender>> subrenders_;
    std::multimap<StageIndex, std::type_index> stages_;
};
} // namespace pixelbullet