XCEngine/engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp

#include "Rendering/Pipelines/ScriptableRenderPipelineHost.h"

#include "Rendering/Passes/BuiltinDepthOnlyPass.h"
#include "Rendering/Passes/BuiltinObjectIdPass.h"
#include "Rendering/Passes/BuiltinShadowCasterPass.h"
#include "Rendering/Pipelines/BuiltinForwardPipeline.h"

namespace XCEngine {
namespace Rendering {
namespace Pipelines {

namespace {

std::shared_ptr<const RenderPipelineAsset> CreateDefaultPipelineRendererAsset() {
    static const std::shared_ptr<const RenderPipelineAsset> s_defaultRendererAsset =
        std::make_shared<BuiltinForwardPipelineAsset>();
    return s_defaultRendererAsset;
}

std::unique_ptr<RenderPipelineRenderer> CreatePipelineRendererFromAsset(
    const std::shared_ptr<const RenderPipelineAsset>& pipelineRendererAsset) {
    const std::shared_ptr<const RenderPipelineAsset> resolvedAsset =
        pipelineRendererAsset != nullptr
            ? pipelineRendererAsset
            : CreateDefaultPipelineRendererAsset();
    if (resolvedAsset != nullptr) {
        if (std::unique_ptr<RenderPipeline> pipeline = resolvedAsset->CreatePipeline()) {
            return pipeline;
        }
    }

    return std::make_unique<BuiltinForwardPipeline>();
}

void InstallDefaultStandaloneStagePasses(RenderPipeline& pipeline) {
    pipeline.SetCameraFrameStandalonePass(
        CameraFrameStage::ObjectId,
        std::make_unique<Passes::BuiltinObjectIdPass>());
    pipeline.SetCameraFrameStandalonePass(
        CameraFrameStage::DepthOnly,
        std::make_unique<Passes::BuiltinDepthOnlyPass>());
    pipeline.SetCameraFrameStandalonePass(
        CameraFrameStage::ShadowCaster,
        std::make_unique<Passes::BuiltinShadowCasterPass>());
}

} // namespace

ScriptableRenderPipelineHost::ScriptableRenderPipelineHost()
    : ScriptableRenderPipelineHost(CreateDefaultPipelineRendererAsset()) {
}

ScriptableRenderPipelineHost::ScriptableRenderPipelineHost(
    std::unique_ptr<RenderPipelineRenderer> pipelineRenderer) {
    InstallDefaultStandaloneStagePasses(*this);
    ResetPipelineRenderer(std::move(pipelineRenderer));
}

ScriptableRenderPipelineHost::ScriptableRenderPipelineHost(
    std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset)
    : m_pipelineRendererAsset(
        pipelineRendererAsset != nullptr
            ? std::move(pipelineRendererAsset)
            : CreateDefaultPipelineRendererAsset()) {
    InstallDefaultStandaloneStagePasses(*this);
    ResetPipelineRenderer(
        CreatePipelineRendererFromAsset(m_pipelineRendererAsset));
}

ScriptableRenderPipelineHost::~ScriptableRenderPipelineHost() {
    Shutdown();
}

void ScriptableRenderPipelineHost::SetStageRecorder(
    std::unique_ptr<RenderPipelineStageRecorder> stageRecorder) {
    ResetStageRecorder(std::move(stageRecorder));
}

void ScriptableRenderPipelineHost::SetPipelineRenderer(
    std::unique_ptr<RenderPipelineRenderer> pipelineRenderer) {
    m_pipelineRendererAsset.reset();
    ResetPipelineRenderer(std::move(pipelineRenderer));
}

void ScriptableRenderPipelineHost::SetPipelineRendererAsset(
    std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset) {
    m_pipelineRendererAsset =
        pipelineRendererAsset != nullptr
            ? std::move(pipelineRendererAsset)
            : CreateDefaultPipelineRendererAsset();
    ResetPipelineRenderer(
        CreatePipelineRendererFromAsset(m_pipelineRendererAsset));
}

bool ScriptableRenderPipelineHost::Initialize(const RenderContext& context) {
    if (m_pipelineRenderer == nullptr ||
        !m_pipelineRenderer->Initialize(context)) {
        return false;
    }

    if (m_stageRecorder != nullptr &&
        !m_stageRecorder->Initialize(context)) {
        m_stageRecorder->Shutdown();
        m_pipelineRenderer->Shutdown();
        return false;
    }

    return true;
}

void ScriptableRenderPipelineHost::Shutdown() {
    if (m_stageRecorder != nullptr) {
        m_stageRecorder->Shutdown();
    }
    if (m_pipelineRenderer != nullptr) {
        m_pipelineRenderer->Shutdown();
    }
    ShutdownCameraFrameStandalonePasses();
}

bool ScriptableRenderPipelineHost::SupportsStageRenderGraph(
    CameraFrameStage stage) const {
    return (m_stageRecorder != nullptr &&
            m_stageRecorder->SupportsStageRenderGraph(stage)) ||
           (m_pipelineRenderer != nullptr &&
            m_pipelineRenderer->SupportsStageRenderGraph(stage));
}

bool ScriptableRenderPipelineHost::RecordStageRenderGraph(
    const RenderPipelineStageRenderGraphContext& context) {
    if (m_stageRecorder != nullptr &&
        m_stageRecorder->SupportsStageRenderGraph(context.stage)) {
        return m_stageRecorder->RecordStageRenderGraph(context);
    }

    return m_pipelineRenderer != nullptr &&
           m_pipelineRenderer->RecordStageRenderGraph(context);
}

bool ScriptableRenderPipelineHost::Render(
    const FrameExecutionContext& executionContext) {
    return m_pipelineRenderer != nullptr &&
           m_pipelineRenderer->Render(executionContext);
}

bool ScriptableRenderPipelineHost::Render(
    const RenderContext& context,
    const RenderSurface& surface,
    const RenderSceneData& sceneData) {
    return m_pipelineRenderer != nullptr &&
           m_pipelineRenderer->Render(context, surface, sceneData);
}

void ScriptableRenderPipelineHost::ResetStageRecorder(
    std::unique_ptr<RenderPipelineStageRecorder> stageRecorder) {
    if (m_stageRecorder != nullptr) {
        m_stageRecorder->Shutdown();
    }

    m_stageRecorder = std::move(stageRecorder);
}

void ScriptableRenderPipelineHost::ResetPipelineRenderer(
    std::unique_ptr<RenderPipelineRenderer> pipelineRenderer) {
    if (m_pipelineRenderer != nullptr) {
        m_pipelineRenderer->Shutdown();
    }

    m_pipelineRenderer = std::move(pipelineRenderer);
    if (m_pipelineRenderer == nullptr) {
        if (m_pipelineRendererAsset == nullptr) {
            m_pipelineRendererAsset = CreateDefaultPipelineRendererAsset();
        }
        m_pipelineRenderer =
            CreatePipelineRendererFromAsset(m_pipelineRendererAsset);
    }
}

ScriptableRenderPipelineHostAsset::ScriptableRenderPipelineHostAsset()
    : ScriptableRenderPipelineHostAsset(CreateDefaultPipelineRendererAsset()) {
}

ScriptableRenderPipelineHostAsset::ScriptableRenderPipelineHostAsset(
    std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset)
    : m_pipelineRendererAsset(
        pipelineRendererAsset != nullptr
            ? std::move(pipelineRendererAsset)
            : CreateDefaultPipelineRendererAsset()) {
}

std::unique_ptr<RenderPipeline> ScriptableRenderPipelineHostAsset::CreatePipeline() const {
    return std::make_unique<ScriptableRenderPipelineHost>(
        m_pipelineRendererAsset);
}

FinalColorSettings ScriptableRenderPipelineHostAsset::GetDefaultFinalColorSettings() const {
    return m_pipelineRendererAsset != nullptr
        ? m_pipelineRendererAsset->GetDefaultFinalColorSettings()
        : FinalColorSettings{};
}

} // namespace Pipelines
} // namespace Rendering
} // namespace XCEngine