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

#pragma once

#include <XCEngine/Rendering/Execution/CameraFramePlan.h>
#include <XCEngine/Rendering/Execution/CameraRenderer.h>
#include <XCEngine/Rendering/Planning/SceneRenderRequestPlanner.h>

#include <memory>
#include <vector>

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

namespace Rendering {

class CameraFramePlanBuilder;
class RenderPipelineAsset;

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

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

    std::vector<CameraFramePlan> BuildFramePlans(
        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 Components::Scene& scene,
        Components::CameraComponent* overrideCamera,
        const RenderContext& context,
        const RenderSurface& surface);

    SceneRenderRequestPlanner m_requestPlanner;
    CameraRenderer m_cameraRenderer;
    std::unique_ptr<CameraFramePlanBuilder> m_framePlanBuilder;
};

} // namespace Rendering
} // namespace XCEngine