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> CreateDefaultMainSceneRendererAsset() {
    static const std::shared_ptr<const RenderPipelineAsset> s_defaultRendererAsset =
        std::make_shared<BuiltinForwardPipelineAsset>();
    return s_defaultRendererAsset;
}

std::unique_ptr<RenderPipelineRenderer> CreateMainSceneRendererFromAsset(
    const std::shared_ptr<const RenderPipelineAsset>& mainSceneRendererAsset) {
    const std::shared_ptr<const RenderPipelineAsset> resolvedAsset =
        mainSceneRendererAsset != nullptr
            ? mainSceneRendererAsset
            : CreateDefaultMainSceneRendererAsset();
    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(CreateDefaultMainSceneRendererAsset()) {
}

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

ScriptableRenderPipelineHost::ScriptableRenderPipelineHost(
    std::shared_ptr<const RenderPipelineAsset> mainSceneRendererAsset)
    : m_mainSceneRendererAsset(
        mainSceneRendererAsset != nullptr
            ? std::move(mainSceneRendererAsset)
            : CreateDefaultMainSceneRendererAsset()) {
    InstallDefaultStandaloneStagePasses(*this);
    ResetMainSceneRenderer(
        CreateMainSceneRendererFromAsset(m_mainSceneRendererAsset));
}

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

void ScriptableRenderPipelineHost::SetMainSceneRenderer(
    std::unique_ptr<RenderPipelineRenderer> mainSceneRenderer) {
    m_mainSceneRendererAsset.reset();
    ResetMainSceneRenderer(std::move(mainSceneRenderer));
}

void ScriptableRenderPipelineHost::SetMainSceneRendererAsset(
    std::shared_ptr<const RenderPipelineAsset> mainSceneRendererAsset) {
    m_mainSceneRendererAsset =
        mainSceneRendererAsset != nullptr
            ? std::move(mainSceneRendererAsset)
            : CreateDefaultMainSceneRendererAsset();
    ResetMainSceneRenderer(
        CreateMainSceneRendererFromAsset(m_mainSceneRendererAsset));
}

bool ScriptableRenderPipelineHost::Initialize(const RenderContext& context) {
    return m_mainSceneRenderer != nullptr &&
           m_mainSceneRenderer->Initialize(context);
}

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

bool ScriptableRenderPipelineHost::SupportsMainSceneRenderGraph() const {
    return m_mainSceneRenderer != nullptr &&
           m_mainSceneRenderer->SupportsMainSceneRenderGraph();
}

bool ScriptableRenderPipelineHost::RecordMainSceneRenderGraph(
    const RenderPipelineMainSceneRenderGraphContext& context) {
    return m_mainSceneRenderer != nullptr &&
           m_mainSceneRenderer->RecordMainSceneRenderGraph(context);
}

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

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

void ScriptableRenderPipelineHost::ResetMainSceneRenderer(
    std::unique_ptr<RenderPipelineRenderer> mainSceneRenderer) {
    if (m_mainSceneRenderer != nullptr) {
        m_mainSceneRenderer->Shutdown();
    }

    m_mainSceneRenderer = std::move(mainSceneRenderer);
    if (m_mainSceneRenderer == nullptr) {
        if (m_mainSceneRendererAsset == nullptr) {
            m_mainSceneRendererAsset = CreateDefaultMainSceneRendererAsset();
        }
        m_mainSceneRenderer =
            CreateMainSceneRendererFromAsset(m_mainSceneRendererAsset);
    }
}

ScriptableRenderPipelineHostAsset::ScriptableRenderPipelineHostAsset()
    : ScriptableRenderPipelineHostAsset(CreateDefaultMainSceneRendererAsset()) {
}

ScriptableRenderPipelineHostAsset::ScriptableRenderPipelineHostAsset(
    std::shared_ptr<const RenderPipelineAsset> mainSceneRendererAsset)
    : m_mainSceneRendererAsset(
        mainSceneRendererAsset != nullptr
            ? std::move(mainSceneRendererAsset)
            : CreateDefaultMainSceneRendererAsset()) {
}

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

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

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