refactor: route renderer defaults through pipeline assets

engine/include/XCEngine/Rendering/CameraRenderer.h

@@ -14,20 +14,27 @@ class Scene;
 namespace Rendering {
 
 class RenderSurface;
+class RenderPipelineAsset;
 
 class CameraRenderer {
 public:
     CameraRenderer();
     explicit CameraRenderer(std::unique_ptr<RenderPipeline> pipeline);
+    explicit CameraRenderer(std::shared_ptr<const RenderPipelineAsset> pipelineAsset);
     ~CameraRenderer();
 
     void SetPipeline(std::unique_ptr<RenderPipeline> pipeline);
+    void SetPipelineAsset(std::shared_ptr<const RenderPipelineAsset> pipelineAsset);
     RenderPipeline* GetPipeline() const { return m_pipeline.get(); }
+    const RenderPipelineAsset* GetPipelineAsset() const { return m_pipelineAsset.get(); }
 
     bool Render(const CameraRenderRequest& request);
 
 private:
+    void ResetPipeline(std::unique_ptr<RenderPipeline> pipeline);
+
     RenderSceneExtractor m_sceneExtractor;
+    std::shared_ptr<const RenderPipelineAsset> m_pipelineAsset;
     std::unique_ptr<RenderPipeline> m_pipeline;
 };
 

engine/include/XCEngine/Rendering/Pipelines/BuiltinForwardPipeline.h

@@ -3,6 +3,7 @@
 #include <XCEngine/Rendering/RenderMaterialUtility.h>
 #include <XCEngine/Rendering/RenderPass.h>
 #include <XCEngine/Rendering/RenderPipeline.h>
+#include <XCEngine/Rendering/RenderPipelineAsset.h>
 #include <XCEngine/Rendering/RenderResourceCache.h>
 
 #include <XCEngine/RHI/RHIDescriptorPool.h>
@@ -100,6 +101,11 @@ private:
     RenderPassSequence m_passSequence;
 };
 
+class BuiltinForwardPipelineAsset final : public RenderPipelineAsset {
+public:
+    std::unique_ptr<RenderPipeline> CreatePipeline() const override;
+};
+
 } // namespace Pipelines
 } // namespace Rendering
 } // namespace XCEngine

engine/include/XCEngine/Rendering/SceneRenderer.h

@@ -13,14 +13,19 @@ class Scene;
 
 namespace Rendering {
 
+class RenderPipelineAsset;
+
 class SceneRenderer {
 public:
     SceneRenderer();
     explicit SceneRenderer(std::unique_ptr<RenderPipeline> pipeline);
+    explicit SceneRenderer(std::shared_ptr<const RenderPipelineAsset> pipelineAsset);
     ~SceneRenderer() = default;
 
     void SetPipeline(std::unique_ptr<RenderPipeline> pipeline);
+    void SetPipelineAsset(std::shared_ptr<const RenderPipelineAsset> pipelineAsset);
     RenderPipeline* GetPipeline() const { return m_cameraRenderer.GetPipeline(); }
+    const RenderPipelineAsset* GetPipelineAsset() const { return m_cameraRenderer.GetPipelineAsset(); }
 
     std::vector<CameraRenderRequest> BuildRenderRequests(
         const Components::Scene& scene,

engine/src/Rendering/CameraRenderer.cpp

@@ -1,6 +1,7 @@
 #include "Rendering/CameraRenderer.h"
 
 #include "Rendering/Pipelines/BuiltinForwardPipeline.h"
+#include "Rendering/RenderPipelineAsset.h"
 #include "Rendering/RenderSurface.h"
 #include "Scene/Scene.h"
 
@@ -32,17 +33,38 @@ void ShutdownPassSequence(RenderPassSequence* sequence, bool initialized) {
     }
 }
 
+std::shared_ptr<const RenderPipelineAsset> CreateDefaultPipelineAsset() {
+    static const std::shared_ptr<const RenderPipelineAsset> s_defaultPipelineAsset =
+        std::make_shared<Pipelines::BuiltinForwardPipelineAsset>();
+    return s_defaultPipelineAsset;
+}
+
+std::unique_ptr<RenderPipeline> CreatePipelineFromAsset(
+    const std::shared_ptr<const RenderPipelineAsset>& pipelineAsset) {
+    if (pipelineAsset != nullptr) {
+        std::unique_ptr<RenderPipeline> pipeline = pipelineAsset->CreatePipeline();
+        if (pipeline != nullptr) {
+            return pipeline;
+        }
+    }
+
+    return std::make_unique<Pipelines::BuiltinForwardPipeline>();
+}
+
 } // namespace
 
 CameraRenderer::CameraRenderer()
-    : m_pipeline(std::make_unique<Pipelines::BuiltinForwardPipeline>()) {
+    : CameraRenderer(CreateDefaultPipelineAsset()) {
 }
 
 CameraRenderer::CameraRenderer(std::unique_ptr<RenderPipeline> pipeline)
-    : m_pipeline(std::move(pipeline)) {
+    : m_pipelineAsset(nullptr) {
-    if (!m_pipeline) {
+    ResetPipeline(std::move(pipeline));
-        m_pipeline = std::make_unique<Pipelines::BuiltinForwardPipeline>();
+}
-    }
+
+CameraRenderer::CameraRenderer(std::shared_ptr<const RenderPipelineAsset> pipelineAsset)
+    : m_pipelineAsset(std::move(pipelineAsset)) {
+    SetPipelineAsset(m_pipelineAsset);
 }
 
 CameraRenderer::~CameraRenderer() {
@@ -52,13 +74,24 @@ CameraRenderer::~CameraRenderer() {
 }
 
 void CameraRenderer::SetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
-    if (m_pipeline) {
+    m_pipelineAsset.reset();
+    ResetPipeline(std::move(pipeline));
+}
+
+void CameraRenderer::SetPipelineAsset(std::shared_ptr<const RenderPipelineAsset> pipelineAsset) {
+    m_pipelineAsset = pipelineAsset != nullptr ? std::move(pipelineAsset) : CreateDefaultPipelineAsset();
+    ResetPipeline(CreatePipelineFromAsset(m_pipelineAsset));
+}
+
+void CameraRenderer::ResetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
+    if (m_pipeline != nullptr) {
         m_pipeline->Shutdown();
     }
 
     m_pipeline = std::move(pipeline);
-    if (!m_pipeline) {
+    if (m_pipeline == nullptr) {
-        m_pipeline = std::make_unique<Pipelines::BuiltinForwardPipeline>();
+        m_pipelineAsset = CreateDefaultPipelineAsset();
+        m_pipeline = CreatePipelineFromAsset(m_pipelineAsset);
     }
 }
 

engine/src/Rendering/Pipelines/BuiltinForwardPipeline.cpp

@@ -236,6 +236,10 @@ BuiltinForwardPipeline::~BuiltinForwardPipeline() {
     Shutdown();
 }
 
+std::unique_ptr<RenderPipeline> BuiltinForwardPipelineAsset::CreatePipeline() const {
+    return std::make_unique<BuiltinForwardPipeline>();
+}
+
 RHI::InputLayoutDesc BuiltinForwardPipeline::BuildInputLayout() {
     RHI::InputLayoutDesc inputLayout = {};
 

engine/src/Rendering/SceneRenderer.cpp

@@ -25,10 +25,18 @@ SceneRenderer::SceneRenderer(std::unique_ptr<RenderPipeline> pipeline)
     : m_cameraRenderer(std::move(pipeline)) {
 }
 
+SceneRenderer::SceneRenderer(std::shared_ptr<const RenderPipelineAsset> pipelineAsset)
+    : m_cameraRenderer(std::move(pipelineAsset)) {
+}
+
 void SceneRenderer::SetPipeline(std::unique_ptr<RenderPipeline> pipeline) {
     m_cameraRenderer.SetPipeline(std::move(pipeline));
 }
 
+void SceneRenderer::SetPipelineAsset(std::shared_ptr<const RenderPipelineAsset> pipelineAsset) {
+    m_cameraRenderer.SetPipelineAsset(std::move(pipelineAsset));
+}
+
 std::vector<CameraRenderRequest> SceneRenderer::BuildRenderRequests(
     const Components::Scene& scene,
     Components::CameraComponent* overrideCamera,

tests/Rendering/unit/test_camera_scene_renderer.cpp

@@ -2,6 +2,7 @@
 
 #include <XCEngine/Components/CameraComponent.h>
 #include <XCEngine/Rendering/CameraRenderer.h>
+#include <XCEngine/Rendering/RenderPipelineAsset.h>
 #include <XCEngine/Rendering/RenderSurface.h>
 #include <XCEngine/Rendering/SceneRenderer.h>
 #include <XCEngine/Scene/Scene.h>
@@ -30,6 +31,11 @@ struct MockPipelineState {
     std::vector<std::string> eventLog;
 };
 
+struct MockPipelineAssetState {
+    int createCalls = 0;
+    std::shared_ptr<MockPipelineState> lastCreatedPipelineState;
+};
+
 class MockPipeline final : public RenderPipeline {
 public:
     explicit MockPipeline(std::shared_ptr<MockPipelineState> state)
@@ -65,6 +71,22 @@ private:
     std::shared_ptr<MockPipelineState> m_state;
 };
 
+class MockPipelineAsset final : public RenderPipelineAsset {
+public:
+    explicit MockPipelineAsset(std::shared_ptr<MockPipelineAssetState> state)
+        : m_state(std::move(state)) {
+    }
+
+    std::unique_ptr<RenderPipeline> CreatePipeline() const override {
+        ++m_state->createCalls;
+        m_state->lastCreatedPipelineState = std::make_shared<MockPipelineState>();
+        return std::make_unique<MockPipeline>(m_state->lastCreatedPipelineState);
+    }
+
+private:
+    std::shared_ptr<MockPipelineAssetState> m_state;
+};
+
 class TrackingPass final : public RenderPass {
 public:
     TrackingPass(
@@ -321,6 +343,44 @@ TEST(SceneRenderer_Test, ForwardsPipelineLifetimeAndRenderCallsToCameraRenderer)
     EXPECT_EQ(replacementState->shutdownCalls, 1);
 }
 
+TEST(SceneRenderer_Test, CreatesPipelineInstancesFromPipelineAssetsAndShutsDownReplacedPipelines) {
+    Scene scene("SceneRendererAssetScene");
+
+    GameObject* cameraObject = scene.CreateGameObject("Camera");
+    auto* camera = cameraObject->AddComponent<CameraComponent>();
+    camera->SetPrimary(true);
+    camera->SetDepth(2.0f);
+
+    auto initialAssetState = std::make_shared<MockPipelineAssetState>();
+    auto replacementAssetState = std::make_shared<MockPipelineAssetState>();
+
+    {
+        SceneRenderer renderer(std::make_shared<MockPipelineAsset>(initialAssetState));
+        ASSERT_NE(renderer.GetPipeline(), nullptr);
+        ASSERT_NE(renderer.GetPipelineAsset(), nullptr);
+        EXPECT_EQ(initialAssetState->createCalls, 1);
+
+        const RenderSurface surface(800, 600);
+        ASSERT_TRUE(renderer.Render(scene, nullptr, CreateValidContext(), surface));
+        ASSERT_NE(initialAssetState->lastCreatedPipelineState, nullptr);
+        EXPECT_EQ(initialAssetState->lastCreatedPipelineState->renderCalls, 1);
+        EXPECT_EQ(initialAssetState->lastCreatedPipelineState->lastCamera, camera);
+
+        renderer.SetPipelineAsset(std::make_shared<MockPipelineAsset>(replacementAssetState));
+        ASSERT_NE(initialAssetState->lastCreatedPipelineState, nullptr);
+        EXPECT_EQ(initialAssetState->lastCreatedPipelineState->shutdownCalls, 1);
+        EXPECT_EQ(replacementAssetState->createCalls, 1);
+
+        ASSERT_TRUE(renderer.Render(scene, nullptr, CreateValidContext(), surface));
+        ASSERT_NE(replacementAssetState->lastCreatedPipelineState, nullptr);
+        EXPECT_EQ(replacementAssetState->lastCreatedPipelineState->renderCalls, 1);
+        EXPECT_EQ(replacementAssetState->lastCreatedPipelineState->lastCamera, camera);
+    }
+
+    ASSERT_NE(replacementAssetState->lastCreatedPipelineState, nullptr);
+    EXPECT_EQ(replacementAssetState->lastCreatedPipelineState->shutdownCalls, 1);
+}
+
 TEST(SceneRenderer_Test, SortsManualCameraRequestsByDepthBeforeRendering) {
     Scene scene("SceneRendererManualRequests");