XCEngine/engine/include/XCEngine/Rendering/Execution/SceneRenderer.h

#pragma once

#include <XCEngine/Rendering/Execution/CameraStackFramePlan.h>
#include <XCEngine/Rendering/Execution/RenderPipelineHost.h>
#include <XCEngine/Rendering/Planning/SceneRenderRequestPlanner.h>

#include <vector>

namespace XCEngine {
namespace Components {
class CameraComponent;
class Scene;
} // namespace Components

namespace Rendering {

class SceneRenderer {
public:
    SceneRenderer();
    explicit SceneRenderer(std::shared_ptr<const RenderPipelineAsset> pipelineAsset);
    ~SceneRenderer();

    void SetPipelineAsset(std::shared_ptr<const RenderPipelineAsset> pipelineAsset);
    RenderPipeline* GetPipeline() const { return m_pipelineHost.GetPipeline(); }
    const RenderPipelineAsset* GetPipelineAsset() const { return m_pipelineHost.GetPipelineAsset(); }

    std::vector<CameraFramePlan> BuildFramePlans(
        const Components::Scene& scene,
        Components::CameraComponent* overrideCamera,
        const RenderContext& context,
        const RenderSurface& surface);
    std::vector<CameraStackFramePlan> BuildStackFramePlans(
        const Components::Scene& scene,
        Components::CameraComponent* overrideCamera,
        const RenderContext& context,
        const RenderSurface& surface);

    bool Render(const CameraFramePlan& plan);
    bool Render(const std::vector<CameraFramePlan>& plans);
    bool Render(const CameraStackFramePlan& stackPlan);
    bool Render(const std::vector<CameraStackFramePlan>& stackPlans);
    bool Render(
        const Components::Scene& scene,
        Components::CameraComponent* overrideCamera,
        const RenderContext& context,
        const RenderSurface& surface);

    SceneRenderRequestPlanner m_requestPlanner;
    RenderPipelineHost m_pipelineHost;
};

} // namespace Rendering
} // namespace XCEngine