XCEngine/engine/src/Rendering/Execution/RenderPipelineHost.cpp

#include "Rendering/Execution/RenderPipelineHost.h"

#include "Rendering/Planning/CameraFramePlanBuilder.h"
#include "Rendering/Planning/SceneRenderRequestUtils.h"

namespace XCEngine {
namespace Rendering {

namespace {

bool CompareCameraFramePlans(
    const CameraFramePlan& lhs,
    const CameraFramePlan& rhs) {
    return SceneRenderRequestUtils::CompareCameraRenderRequests(
        lhs.request,
        rhs.request);
}

} // namespace

RenderPipelineHost::RenderPipelineHost()
    : m_framePlanBuilder(std::make_unique<CameraFramePlanBuilder>()) {
}

RenderPipelineHost::RenderPipelineHost(std::unique_ptr<RenderPipeline> pipeline)
    : m_cameraRenderer(std::move(pipeline))
    , m_framePlanBuilder(std::make_unique<CameraFramePlanBuilder>()) {
}

RenderPipelineHost::RenderPipelineHost(std::shared_ptr<const RenderPipelineAsset> pipelineAsset)
    : m_cameraRenderer(std::move(pipelineAsset))
    , m_framePlanBuilder(std::make_unique<CameraFramePlanBuilder>()) {
}

RenderPipelineHost::~RenderPipelineHost() = default;

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

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

std::vector<CameraFramePlan> RenderPipelineHost::BuildFramePlans(
    const std::vector<CameraRenderRequest>& requests) {
    return m_framePlanBuilder != nullptr
        ? m_framePlanBuilder->BuildPlans(requests, GetPipelineAsset())
        : std::vector<CameraFramePlan>();
}

bool RenderPipelineHost::Render(const CameraFramePlan& plan) {
    return m_cameraRenderer.Render(plan);
}

bool RenderPipelineHost::Render(const std::vector<CameraFramePlan>& plans) {
    if (plans.empty()) {
        return false;
    }

    for (const CameraFramePlan& plan : plans) {
        if (!plan.IsValid()) {
            return false;
        }
    }

    std::vector<CameraFramePlan> sortedPlans = plans;
    std::stable_sort(
        sortedPlans.begin(),
        sortedPlans.end(),
        CompareCameraFramePlans);

    bool rendered = false;
    for (const CameraFramePlan& plan : sortedPlans) {
        if (!m_cameraRenderer.Render(plan)) {
            return false;
        }

        rendered = true;
    }

    return rendered;
}

} // namespace Rendering
} // namespace XCEngine