Renderer.hpp

#pragma once
 
#include "PixelBullet/Graphics/RenderStage.hpp"
#include "PixelBullet/Graphics/SubrenderHolder.hpp"
 
namespace PixelBullet
{
    class Renderer
    {
        friend class Graphics;
 
    public:
        Renderer() = default;
        virtual ~Renderer() = default;
 
        virtual void Start() = 0;
 
        virtual void Update() = 0;
 
        template <typename T>
        bool HasSubrender() const
        {
            return m_SubrenderHolder.Has<T>();
        }
 
        template <typename T>
        T* GetSubrender() const
        {
            return m_SubrenderHolder.Get<T>();
        }
 
        template <typename T, typename... Args>
        T* AddSubrender(const Pipeline::Stage& pipelineStage, Args&&... args)
        {
            return m_SubrenderHolder.Add<T>(pipelineStage,
                                          std::make_unique<T>(pipelineStage, std::forward<Args>(args)...));
        }
 
        template <typename T>
        void RemoveSubrender()
        {
            m_SubrenderHolder.Remove<T>();
        }
 
        void ClearSubrenders()
        {
            m_SubrenderHolder.Clear();
        }
 
        RenderStage* GetRenderStage(uint32_t index) const
        {
            if (m_RenderStages.empty() || m_RenderStages.size() < index)
            {
                return nullptr;
            }
 
            return m_RenderStages.at(index).get();
        }
 
        void AddRenderStage(std::unique_ptr<RenderStage>&& renderStage)
        {
            m_RenderStages.emplace_back(std::move(renderStage));
        }
 
    private:
        bool m_Started = false;
        std::vector<std::unique_ptr<RenderStage>> m_RenderStages;
        SubrenderHolder m_SubrenderHolder;
    };
} // namespace PixelBullet