refactor: route renderer defaults through pipeline assets

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);
     }
 }