renderer.h

#pragma once
 
#include "pixelbullet/graphics/render_device.h"
#include "pixelbullet/graphics/render_stage.h"
#include "pixelbullet/graphics/render_target.h"
#include "pixelbullet/graphics/subrender_holder.h"
 
#include <memory>
#include <utility>
#include <vector>
 
namespace pixelbullet
{
class RendererRuntimeAccess;
 
class Renderer
{
    friend class Graphics;
    friend class GraphicsState;
    friend class RendererRuntimeAccess;
 
public:
    Renderer() = default;
    virtual ~Renderer() = default;
 
    virtual void Start(RenderDevice& render_device) = 0;
    virtual void Update(RenderDevice& render_device) = 0;
 
    template <typename T>
    bool HasSubrender() const
    {
        return subrender_holder_.Has<T>();
    }
 
    template <typename T>
    T* GetSubrender() const
    {
        return subrender_holder_.Get<T>();
    }
 
    template <typename T, typename... Args>
    T* AddSubrender(const Subrender::Stage& pipeline_stage, Args&&... args)
    {
        return subrender_holder_.Add<T>(pipeline_stage, std::make_unique<T>(pipeline_stage, std::forward<Args>(args)...));
    }
 
    template <typename T>
    void RemoveSubrender()
    {
        subrender_holder_.Remove<T>();
    }
 
    void ClearSubrenders()
    {
        subrender_holder_.Clear();
    }
 
    RenderStage* GetRenderStage(uint32_t index) const
    {
        if (index >= render_stages_.size())
        {
            return nullptr;
        }
 
        return render_stages_.at(index).get();
    }
 
    void AddRenderStage(std::unique_ptr<RenderStage>&& render_stage)
    {
        render_stages_.emplace_back(std::move(render_stage));
    }
 
    void AddRenderTarget(RenderTargetSpecification specification)
    {
        render_targets_.emplace_back(std::move(specification));
    }
 
private:
    bool started_ = false;
    std::vector<RenderTargetSpecification> render_targets_;
    std::vector<std::unique_ptr<RenderStage>> render_stages_;
    SubrenderHolder subrender_holder_;
};
} // namespace pixelbullet