refactor(srp): move shadow caster stage selection into managed urp

- add standalone pass asset factories for camera frame stages\n- let managed pipeline assets declare stage pass asset keys\n- make universal renderer data explicitly own the builtin shadow caster stage

engine/src/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.cpp

@@ -50,13 +50,19 @@ ManagedScriptableRenderPipelineAsset::ResolvePipelineRendererAsset() const {
 
 ScriptableRenderPipelineHostAsset
 ManagedScriptableRenderPipelineAsset::CreateExecutionHostAsset() const {
+    const std::shared_ptr<const ManagedRenderPipelineAssetRuntime> runtime =
+        ResolveManagedAssetRuntime();
     if (const std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset =
             ResolvePipelineRendererAsset();
         pipelineRendererAsset != nullptr) {
-        return ScriptableRenderPipelineHostAsset(pipelineRendererAsset);
+        return ScriptableRenderPipelineHostAsset(
+            pipelineRendererAsset,
+            runtime);
     }
 
-    return ScriptableRenderPipelineHostAsset();
+    return ScriptableRenderPipelineHostAsset(
+        nullptr,
+        runtime);
 }
 
 std::unique_ptr<RenderPipeline> ManagedScriptableRenderPipelineAsset::CreatePipeline() const {

engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp

@@ -1,6 +1,9 @@
 #include "Rendering/Pipelines/ScriptableRenderPipelineHost.h"
 
+#include "Debug/Logger.h"
+#include "Rendering/Internal/RenderPipelineFactory.h"
 #include "Rendering/Pipelines/BuiltinForwardPipeline.h"
+#include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"
 #include "Rendering/Passes/BuiltinDepthOnlyPass.h"
 #include "Rendering/Passes/BuiltinObjectIdPass.h"
 #include "Rendering/Passes/BuiltinShadowCasterPass.h"
@@ -45,10 +48,20 @@ ScriptableRenderPipelineHost::ScriptableRenderPipelineHost(
 
 ScriptableRenderPipelineHost::ScriptableRenderPipelineHost(
     std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset)
+    : ScriptableRenderPipelineHost(
+        std::move(pipelineRendererAsset),
+        nullptr) {
+}
+
+ScriptableRenderPipelineHost::ScriptableRenderPipelineHost(
+    std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset,
+    std::shared_ptr<const ManagedRenderPipelineAssetRuntime>
+        managedAssetRuntime)
     : m_pipelineRendererAsset(
         pipelineRendererAsset != nullptr
             ? std::move(pipelineRendererAsset)
-            : CreateDefaultPipelineRendererAsset()) {
+            : CreateDefaultPipelineRendererAsset())
+    , m_managedAssetRuntime(std::move(managedAssetRuntime)) {
     ResetPipelineRenderer(
         CreatePipelineRendererFromAsset(m_pipelineRendererAsset));
 }
@@ -78,6 +91,13 @@ void ScriptableRenderPipelineHost::SetPipelineRendererAsset(
         CreatePipelineRendererFromAsset(m_pipelineRendererAsset));
 }
 
+void ScriptableRenderPipelineHost::SetManagedAssetRuntime(
+    std::shared_ptr<const ManagedRenderPipelineAssetRuntime>
+        managedAssetRuntime) {
+    m_managedAssetRuntime = std::move(managedAssetRuntime);
+    ShutdownContextualCameraFrameStandalonePasses();
+}
+
 bool ScriptableRenderPipelineHost::Initialize(const RenderContext& context) {
     return EnsureInitialized(context);
 }
@@ -89,6 +109,7 @@ void ScriptableRenderPipelineHost::Shutdown() {
     if (m_pipelineRenderer != nullptr) {
         m_pipelineRenderer->Shutdown();
     }
+    ShutdownContextualCameraFrameStandalonePasses();
     ShutdownCameraFrameStandalonePasses();
     ResetInitializationState();
 }
@@ -150,6 +171,32 @@ bool ScriptableRenderPipelineHost::Render(
            m_pipelineRenderer->Render(context, surface, sceneData);
 }
 
+RenderPass* ScriptableRenderPipelineHost::GetCameraFrameStandalonePass(
+    CameraFrameStage stage,
+    int32_t rendererIndex) const {
+    RenderPass* const defaultPass =
+        RenderPipeline::GetCameraFrameStandalonePass(stage);
+    if (m_managedAssetRuntime == nullptr ||
+        !SupportsCameraFrameStandalonePass(stage)) {
+        return defaultPass;
+    }
+
+    const std::string assetKey =
+        m_managedAssetRuntime
+            ->GetCameraFrameStandalonePassAssetKey(
+                stage,
+                rendererIndex);
+    if (assetKey.empty()) {
+        return defaultPass;
+    }
+
+    return const_cast<ScriptableRenderPipelineHost*>(this)
+        ->ResolveContextualCameraFrameStandalonePass(
+            stage,
+            rendererIndex,
+            assetKey);
+}
+
 bool ScriptableRenderPipelineHost::EnsureInitialized(const RenderContext& context) {
     if (!context.IsValid() || m_pipelineRenderer == nullptr) {
         return false;
@@ -199,6 +246,18 @@ void ScriptableRenderPipelineHost::BindStageRecorderPipelineRenderer() {
     }
 }
 
+void ScriptableRenderPipelineHost::ShutdownContextualCameraFrameStandalonePasses() {
+    for (auto& stageEntries : m_contextualCameraFrameStandalonePasses) {
+        for (auto& entryIt : stageEntries) {
+            if (entryIt.second.pass != nullptr) {
+                entryIt.second.pass->Shutdown();
+            }
+        }
+
+        stageEntries.clear();
+    }
+}
+
 void ScriptableRenderPipelineHost::ShutdownInitializedComponents() {
     if (m_stageRecorderInitialized &&
         m_stageRecorder != nullptr) {
@@ -256,26 +315,74 @@ void ScriptableRenderPipelineHost::ResetPipelineRenderer(
     }
 
     m_pipelineRendererInitialized = false;
+    ShutdownContextualCameraFrameStandalonePasses();
     BindStageRecorderPipelineRenderer();
     ClearInitializationContextIfNoComponentsAreInitialized();
 }
 
+RenderPass*
+ScriptableRenderPipelineHost::ResolveContextualCameraFrameStandalonePass(
+    CameraFrameStage stage,
+    int32_t rendererIndex,
+    const std::string& assetKey) {
+    auto& stageEntries =
+        m_contextualCameraFrameStandalonePasses[
+            GetCameraFrameStageIndex(stage)];
+    ContextualCameraFrameStandalonePassEntry& entry =
+        stageEntries[rendererIndex];
+    if (entry.assetKey == assetKey) {
+        return entry.pass.get();
+    }
+
+    if (entry.pass != nullptr) {
+        entry.pass->Shutdown();
+    }
+
+    entry = {};
+    entry.assetKey = assetKey;
+    entry.pass =
+        Rendering::Internal::CreateCameraFrameStandalonePassByKey(
+            assetKey);
+    if (entry.pass == nullptr) {
+        Debug::Logger::Get().Error(
+            Debug::LogCategory::Rendering,
+            Containers::String(
+                "ScriptableRenderPipelineHost failed to resolve standalone pass asset key: ") +
+                assetKey.c_str());
+    }
+
+    return entry.pass.get();
+}
+
 ScriptableRenderPipelineHostAsset::ScriptableRenderPipelineHostAsset()
-    : ScriptableRenderPipelineHostAsset(CreateDefaultPipelineRendererAsset()) {
+    : ScriptableRenderPipelineHostAsset(
+        CreateDefaultPipelineRendererAsset(),
+        nullptr) {
 }
 
 ScriptableRenderPipelineHostAsset::ScriptableRenderPipelineHostAsset(
     std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset)
+    : ScriptableRenderPipelineHostAsset(
+        std::move(pipelineRendererAsset),
+        nullptr) {
+}
+
+ScriptableRenderPipelineHostAsset::ScriptableRenderPipelineHostAsset(
+    std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset,
+    std::shared_ptr<const ManagedRenderPipelineAssetRuntime>
+        managedAssetRuntime)
     : m_pipelineRendererAsset(
         pipelineRendererAsset != nullptr
             ? std::move(pipelineRendererAsset)
-            : CreateDefaultPipelineRendererAsset()) {
+            : CreateDefaultPipelineRendererAsset())
+    , m_managedAssetRuntime(std::move(managedAssetRuntime)) {
 }
 
 std::unique_ptr<RenderPipeline> ScriptableRenderPipelineHostAsset::CreatePipeline() const {
     std::unique_ptr<RenderPipeline> pipeline =
         std::make_unique<ScriptableRenderPipelineHost>(
-            m_pipelineRendererAsset);
+            m_pipelineRendererAsset,
+            m_managedAssetRuntime);
     if (pipeline != nullptr) {
         ConfigurePipeline(*pipeline);
     }
@@ -291,9 +398,11 @@ void ScriptableRenderPipelineHostAsset::ConfigurePipeline(
     pipeline.SetCameraFrameStandalonePass(
         CameraFrameStage::DepthOnly,
         std::make_unique<Passes::BuiltinDepthOnlyPass>());
-    pipeline.SetCameraFrameStandalonePass(
-        CameraFrameStage::ShadowCaster,
-        std::make_unique<Passes::BuiltinShadowCasterPass>());
+    if (m_managedAssetRuntime == nullptr) {
+        pipeline.SetCameraFrameStandalonePass(
+            CameraFrameStage::ShadowCaster,
+            std::make_unique<Passes::BuiltinShadowCasterPass>());
+    }
 }
 
 FinalColorSettings ScriptableRenderPipelineHostAsset::GetDefaultFinalColorSettings() const {