refactor(rendering): extract default pipeline resolution from camera renderer

engine/src/Rendering/Execution/CameraRenderer.cpp

@@ -3,8 +3,7 @@
 #include "Components/CameraComponent.h"
 #include "Rendering/Execution/DirectionalShadowExecutionState.h"
 #include "Rendering/Execution/Internal/CameraFrameGraph/Executor.h"
-#include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"
-#include "Rendering/Pipelines/ScriptableRenderPipelineHost.h"
+#include "Rendering/Internal/RenderPipelineFactory.h"
 #include "Rendering/RenderPipelineAsset.h"
 #include "Rendering/RenderSurface.h"
 #include "Rendering/Shadow/DirectionalShadowRuntime.h"
@@ -13,40 +12,8 @@
 namespace XCEngine {
 namespace Rendering {
 
-namespace {
-
-std::shared_ptr<const RenderPipelineAsset> CreateDefaultPipelineAsset() {
-    return Pipelines::CreateManagedOrDefaultScriptableRenderPipelineAsset();
-}
-
-std::unique_ptr<RenderPipeline> CreatePipelineFromAsset(
-    const std::shared_ptr<const RenderPipelineAsset>& pipelineAsset) {
-    const std::shared_ptr<const RenderPipelineAsset> resolvedAsset =
-        pipelineAsset != nullptr ? pipelineAsset : CreateDefaultPipelineAsset();
-    if (resolvedAsset != nullptr) {
-        std::unique_ptr<RenderPipeline> pipeline = resolvedAsset->CreatePipeline();
-        if (pipeline != nullptr) {
-            return pipeline;
-        }
-    }
-
-    const std::shared_ptr<const RenderPipelineAsset> fallbackAsset =
-        CreateDefaultPipelineAsset();
-    if (fallbackAsset != nullptr &&
-        fallbackAsset != resolvedAsset) {
-        std::unique_ptr<RenderPipeline> pipeline = fallbackAsset->CreatePipeline();
-        if (pipeline != nullptr) {
-            return pipeline;
-        }
-    }
-
-    return std::make_unique<Pipelines::ScriptableRenderPipelineHost>();
-}
-
-} // namespace
-
 CameraRenderer::CameraRenderer()
-    : CameraRenderer(CreateDefaultPipelineAsset()) {
+    : CameraRenderer(Internal::CreateDefaultRenderPipelineAsset()) {
 }
 
 CameraRenderer::CameraRenderer(std::unique_ptr<RenderPipeline> pipeline)
@@ -56,9 +23,8 @@ CameraRenderer::CameraRenderer(std::unique_ptr<RenderPipeline> pipeline)
 }
 
 CameraRenderer::CameraRenderer(std::shared_ptr<const RenderPipelineAsset> pipelineAsset)
-    : m_pipelineAsset(std::move(pipelineAsset))
-    , m_directionalShadowRuntime(std::make_unique<DirectionalShadowRuntime>()) {
-    SetPipelineAsset(m_pipelineAsset);
+    : m_directionalShadowRuntime(std::make_unique<DirectionalShadowRuntime>()) {
+    SetPipelineAsset(std::move(pipelineAsset));
 }
 
 CameraRenderer::~CameraRenderer() {
@@ -73,8 +39,10 @@ void CameraRenderer::SetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
 }
 
 void CameraRenderer::SetPipelineAsset(std::shared_ptr<const RenderPipelineAsset> pipelineAsset) {
-    m_pipelineAsset = pipelineAsset != nullptr ? std::move(pipelineAsset) : CreateDefaultPipelineAsset();
-    ResetPipeline(CreatePipelineFromAsset(m_pipelineAsset));
+    ResetPipeline(
+        Internal::CreateRenderPipelineOrDefault(
+            pipelineAsset,
+            &m_pipelineAsset));
 }
 
 void CameraRenderer::ResetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
@@ -84,8 +52,10 @@ void CameraRenderer::ResetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
 
     m_pipeline = std::move(pipeline);
     if (m_pipeline == nullptr) {
-        m_pipelineAsset = CreateDefaultPipelineAsset();
-        m_pipeline = CreatePipelineFromAsset(m_pipelineAsset);
+        m_pipeline =
+            Internal::CreateRenderPipelineOrDefault(
+                nullptr,
+                &m_pipelineAsset);
     }
 }
 

engine/src/Rendering/Internal/RenderPipelineFactory.cpp

@@ -0,0 +1,60 @@
+#include "Rendering/Internal/RenderPipelineFactory.h"
+
+#include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"
+#include "Rendering/Pipelines/ScriptableRenderPipelineHost.h"
+
+namespace XCEngine {
+namespace Rendering {
+namespace Internal {
+
+std::shared_ptr<const RenderPipelineAsset> CreateDefaultRenderPipelineAsset() {
+    return Pipelines::CreateManagedOrDefaultScriptableRenderPipelineAsset();
+}
+
+std::shared_ptr<const RenderPipelineAsset> ResolveRenderPipelineAssetOrDefault(
+    std::shared_ptr<const RenderPipelineAsset> preferredAsset) {
+    return preferredAsset != nullptr
+        ? std::move(preferredAsset)
+        : CreateDefaultRenderPipelineAsset();
+}
+
+std::unique_ptr<RenderPipeline> CreateRenderPipelineOrDefault(
+    const std::shared_ptr<const RenderPipelineAsset>& preferredAsset,
+    std::shared_ptr<const RenderPipelineAsset>* outResolvedAsset) {
+    const std::shared_ptr<const RenderPipelineAsset> resolvedAsset =
+        ResolveRenderPipelineAssetOrDefault(preferredAsset);
+    if (resolvedAsset != nullptr) {
+        if (std::unique_ptr<RenderPipeline> pipeline =
+                resolvedAsset->CreatePipeline()) {
+            if (outResolvedAsset != nullptr) {
+                *outResolvedAsset = resolvedAsset;
+            }
+            return pipeline;
+        }
+    }
+
+    const std::shared_ptr<const RenderPipelineAsset> fallbackAsset =
+        CreateDefaultRenderPipelineAsset();
+    if (fallbackAsset != nullptr &&
+        fallbackAsset != resolvedAsset) {
+        if (std::unique_ptr<RenderPipeline> pipeline =
+                fallbackAsset->CreatePipeline()) {
+            if (outResolvedAsset != nullptr) {
+                *outResolvedAsset = fallbackAsset;
+            }
+            return pipeline;
+        }
+    }
+
+    if (outResolvedAsset != nullptr) {
+        *outResolvedAsset =
+            fallbackAsset != nullptr
+                ? fallbackAsset
+                : resolvedAsset;
+    }
+    return std::make_unique<Pipelines::ScriptableRenderPipelineHost>();
+}
+
+} // namespace Internal
+} // namespace Rendering
+} // namespace XCEngine

engine/src/Rendering/Internal/RenderPipelineFactory.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <memory>
+
+namespace XCEngine {
+namespace Rendering {
+
+class RenderPipeline;
+class RenderPipelineAsset;
+
+namespace Internal {
+
+std::shared_ptr<const RenderPipelineAsset> CreateDefaultRenderPipelineAsset();
+
+std::shared_ptr<const RenderPipelineAsset> ResolveRenderPipelineAssetOrDefault(
+    std::shared_ptr<const RenderPipelineAsset> preferredAsset);
+
+std::unique_ptr<RenderPipeline> CreateRenderPipelineOrDefault(
+    const std::shared_ptr<const RenderPipelineAsset>& preferredAsset,
+    std::shared_ptr<const RenderPipelineAsset>* outResolvedAsset = nullptr);
+
+} // namespace Internal
+} // namespace Rendering
+} // namespace XCEngine