#include "Rendering/Execution/SceneRenderer.h"

#include "Components/CameraComponent.h"
#include "Rendering/Execution/RenderPipelineHost.h"

namespace XCEngine {
namespace Rendering {

SceneRenderer::SceneRenderer() {
}

SceneRenderer::SceneRenderer(std::unique_ptr<RenderPipeline> pipeline)
    : m_pipelineHost(std::move(pipeline)) {
}

SceneRenderer::SceneRenderer(std::shared_ptr<const RenderPipelineAsset> pipelineAsset)
    : m_pipelineHost(std::move(pipelineAsset)) {
}

SceneRenderer::~SceneRenderer() = default;

void SceneRenderer::SetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
    m_pipelineHost.SetPipeline(std::move(pipeline));
}

void SceneRenderer::SetPipelineAsset(std::shared_ptr<const RenderPipelineAsset> pipelineAsset) {
    m_pipelineHost.SetPipelineAsset(std::move(pipelineAsset));
}

std::vector<CameraFramePlan> SceneRenderer::BuildFramePlans(
    const Components::Scene& scene,
    Components::CameraComponent* overrideCamera,
    const RenderContext& context,
    const RenderSurface& surface) {
    const std::vector<CameraRenderRequest> requests =
        m_requestPlanner.BuildRequests(scene, overrideCamera, context, surface);
    return m_pipelineHost.BuildFramePlans(requests);
}

bool SceneRenderer::Render(const CameraFramePlan& plan) {
    return m_pipelineHost.Render(plan);
}

bool SceneRenderer::Render(const std::vector<CameraFramePlan>& plans) {
    return m_pipelineHost.Render(plans);
}

bool SceneRenderer::Render(
    const Components::Scene& scene,
    Components::CameraComponent* overrideCamera,
    const RenderContext& context,
    const RenderSurface& surface) {
    return Render(BuildFramePlans(scene, overrideCamera, context, surface));
}

} // namespace Rendering
} // namespace XCEngine