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)) {
-    if (!m_pipeline) {
-        m_pipeline = std::make_unique<Pipelines::BuiltinForwardPipeline>();
-    }
+    : m_pipelineAsset(nullptr) {
+    ResetPipeline(std::move(pipeline));
+}
+
+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) {
-        m_pipeline = std::make_unique<Pipelines::BuiltinForwardPipeline>();
+    if (m_pipeline == nullptr) {
+        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,