subrender_holder.h

#pragma once
 
#include "pixelbullet/graphics/subrender.h"
 
#include <map>
#include <memory>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
 
namespace pixelbullet
{
class RendererRuntimeAccess;
 
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 Subrender::Stage& stage, std::unique_ptr<T>&& subrender)
    {
        const auto type_id = std::type_index(typeid(T));
        stages_.emplace(StageIndex(stage, subrenders_.size()), type_id);
        subrenders_[type_id] = std::move(subrender);
        return static_cast<T*>(subrenders_[type_id].get());
    }
 
    template <typename T, typename = std::enable_if_t<std::is_convertible_v<T*, Subrender*>>>
    void Remove()
    {
        const auto type_id = std::type_index(typeid(T));
        RemoveSubrenderStage(type_id);
        subrenders_.erase(type_id);
    }
 
    void Clear()
    {
        stages_.clear();
        subrenders_.clear();
    }
 
private:
    friend class GraphicsState;
    friend class RendererRuntimeAccess;
 
    using StageIndex = std::pair<Subrender::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 Subrender::Stage& stage, const RenderFrameContext& frame_context)
    {
        for (auto const& [stage_idx, type_id] : stages_)
        {
            if (stage_idx.first != stage)
            {
                continue;
            }
 
            auto& subrender = subrenders_[type_id];
            if (subrender && subrender->IsEnabled())
            {
                subrender->Render(frame_context);
            }
        }
    }
 
    std::unordered_map<std::type_index, std::unique_ptr<Subrender>> subrenders_;
    std::multimap<StageIndex, std::type_index> stages_;
};
} // namespace pixelbullet