Add scriptable render pipeline host

engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp

@@ -0,0 +1,150 @@
+#include "Rendering/Pipelines/ScriptableRenderPipelineHost.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>();
+}
+
+} // namespace
+
+ScriptableRenderPipelineHost::ScriptableRenderPipelineHost()
+    : ScriptableRenderPipelineHost(CreateDefaultMainSceneRendererAsset()) {
+}
+
+ScriptableRenderPipelineHost::ScriptableRenderPipelineHost(
+    std::unique_ptr<RenderPipelineRenderer> mainSceneRenderer) {
+    ResetMainSceneRenderer(std::move(mainSceneRenderer));
+}
+
+ScriptableRenderPipelineHost::ScriptableRenderPipelineHost(
+    std::shared_ptr<const RenderPipelineAsset> mainSceneRendererAsset)
+    : m_mainSceneRendererAsset(
+        mainSceneRendererAsset != nullptr
+            ? std::move(mainSceneRendererAsset)
+            : CreateDefaultMainSceneRendererAsset()) {
+    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();
+    }
+}
+
+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