Align renderers to pipeline asset selection

engine/src/Rendering/Execution/CameraRenderer.cpp

@@ -36,9 +36,11 @@ void ConfigureTopLevelToolingPasses(RenderPipeline& pipeline) {
 #if XCENGINE_ENABLE_RENDERING_EDITOR_SUPPORT
     // Object-id is a tooling/editor request. It should live on the
     // top-level pipeline used by CameraRenderer, not on a scene backend.
-    pipeline.SetCameraFrameStandalonePass(
-        CameraFrameStage::ObjectId,
-        std::make_unique<Passes::BuiltinObjectIdPass>());
+    if (pipeline.GetCameraFrameStandalonePass(CameraFrameStage::ObjectId) == nullptr) {
+        pipeline.SetCameraFrameStandalonePass(
+            CameraFrameStage::ObjectId,
+            std::make_unique<Passes::BuiltinObjectIdPass>());
+    }
 #else
     (void)pipeline;
 #endif
@@ -60,12 +62,6 @@ CameraRenderer::CameraRenderer()
     SetPipelineAsset(nullptr);
 }
 
-CameraRenderer::CameraRenderer(std::unique_ptr<RenderPipeline> pipeline)
-    : m_pipelineAsset(nullptr)
-    , m_directionalShadowRuntime(std::make_unique<DirectionalShadowRuntime>()) {
-    ResetPipeline(std::move(pipeline));
-}
-
 CameraRenderer::CameraRenderer(std::shared_ptr<const RenderPipelineAsset> pipelineAsset)
     : m_directionalShadowRuntime(std::make_unique<DirectionalShadowRuntime>()) {
     SetPipelineAsset(std::move(pipelineAsset));
@@ -77,13 +73,6 @@ CameraRenderer::~CameraRenderer() {
     }
 }
 
-void CameraRenderer::SetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
-    m_pipelineAsset.reset();
-    m_usesDefaultPipelineAssetSelection = false;
-    m_managedPipelineEnvironmentGeneration = 0u;
-    ResetPipeline(std::move(pipeline));
-}
-
 void CameraRenderer::SetPipelineAsset(std::shared_ptr<const RenderPipelineAsset> pipelineAsset) {
     m_usesDefaultPipelineAssetSelection = pipelineAsset == nullptr;
     ResetPipeline(

engine/src/Rendering/Execution/RenderPipelineHost.cpp

@@ -22,11 +22,6 @@ 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>()) {
@@ -34,10 +29,6 @@ RenderPipelineHost::RenderPipelineHost(std::shared_ptr<const RenderPipelineAsset
 
 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));
 }

engine/src/Rendering/Execution/SceneRenderer.cpp

@@ -9,20 +9,12 @@ namespace Rendering {
 SceneRenderer::SceneRenderer() {
 }
 
-SceneRenderer::SceneRenderer(std::unique_ptr<RenderPipeline> pipeline)
-    : m_pipelineHost(std::move(pipeline)) {
-}
-
 SceneRenderer::SceneRenderer(std::shared_ptr<const RenderPipelineAsset> pipelineAsset)
     : m_pipelineHost(std::move(pipelineAsset)) {
 }
 
 SceneRenderer::~SceneRenderer() = default;
 
-void SceneRenderer::SetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
-    m_pipelineHost.SetPipeline(std::move(pipeline));
-}
-
 void SceneRenderer::SetPipelineAsset(std::shared_ptr<const RenderPipelineAsset> pipelineAsset) {
     m_pipelineHost.SetPipelineAsset(std::move(pipelineAsset));
 }

engine/src/Rendering/Internal/RenderPipelineFactory.cpp

@@ -48,7 +48,12 @@ std::unique_ptr<RenderPipeline> TryCreateRenderPipelineFromAsset(
         return nullptr;
     }
 
-    return asset->CreatePipeline();
+    std::unique_ptr<RenderPipeline> pipeline =
+        asset->CreatePipeline();
+    if (pipeline != nullptr) {
+        asset->ConfigurePipeline(*pipeline);
+    }
+    return pipeline;
 }
 
 std::unique_ptr<RenderPipelineBackend> TryCreatePipelineBackendFromAsset(
@@ -57,7 +62,12 @@ std::unique_ptr<RenderPipelineBackend> TryCreatePipelineBackendFromAsset(
         return nullptr;
     }
 
-    return asset->CreatePipeline();
+    std::unique_ptr<RenderPipeline> pipeline =
+        asset->CreatePipeline();
+    if (pipeline != nullptr) {
+        asset->ConfigurePipeline(*pipeline);
+    }
+    return pipeline;
 }
 
 std::unique_ptr<SceneDrawBackend> TryCreateSceneDrawBackendFromAsset(
@@ -128,10 +138,24 @@ std::unique_ptr<RenderPipeline> CreateRenderPipelineOrDefault(
         return pipeline;
     }
 
+    const std::shared_ptr<const RenderPipelineAsset> defaultAsset =
+        ResolveRenderPipelineAssetOrDefault(nullptr);
+    if (defaultAsset != nullptr &&
+        defaultAsset != resolvedAsset) {
+        if (std::unique_ptr<RenderPipeline> pipeline =
+                TryCreateRenderPipelineFromAsset(defaultAsset)) {
+            if (outResolvedAsset != nullptr) {
+                *outResolvedAsset = defaultAsset;
+            }
+            return pipeline;
+        }
+    }
+
     const std::shared_ptr<const RenderPipelineAsset> fallbackAsset =
         CreateFallbackRenderPipelineAsset();
     if (fallbackAsset != nullptr &&
-        fallbackAsset != resolvedAsset) {
+        fallbackAsset != resolvedAsset &&
+        fallbackAsset != defaultAsset) {
         if (std::unique_ptr<RenderPipeline> pipeline =
                 TryCreateRenderPipelineFromAsset(fallbackAsset)) {
             if (outResolvedAsset != nullptr) {
@@ -142,9 +166,10 @@ std::unique_ptr<RenderPipeline> CreateRenderPipelineOrDefault(
     }
 
     if (outResolvedAsset != nullptr) {
-        *outResolvedAsset =
-            fallbackAsset != nullptr
-                ? fallbackAsset
+        *outResolvedAsset = fallbackAsset != nullptr
+            ? fallbackAsset
+            : defaultAsset != nullptr
+                ? defaultAsset
                 : resolvedAsset;
     }
     return Pipelines::Internal::CreateConfiguredBuiltinForwardPipeline();