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/Execution/Internal/CameraFrameGraph/PassRecorder.cpp

@@ -31,7 +31,8 @@ bool TryRecordCameraFrameStageStandaloneRenderGraphPass(
     RenderPass* const standaloneStagePass =
         ResolveCameraFrameStandaloneStagePass(
             stageState.stage,
-            builder.executionState);
+            builder.executionState,
+            context.plan.request.rendererIndex);
     if (standaloneStagePass == nullptr ||
         !standaloneStagePass->SupportsRenderGraph()) {
         handled = false;

engine/src/Rendering/Execution/Internal/CameraFrameGraph/StageContract.cpp

@@ -217,9 +217,12 @@ RenderSceneData BuildCameraFrameStandaloneStageSceneData(
 
 RenderPass* ResolveCameraFrameStandaloneStagePass(
     CameraFrameStage stage,
-    CameraFrameExecutionState& executionState) {
+    CameraFrameExecutionState& executionState,
+    int32_t rendererIndex) {
     return executionState.pipeline != nullptr
-        ? executionState.pipeline->GetCameraFrameStandalonePass(stage)
+        ? executionState.pipeline->GetCameraFrameStandalonePass(
+            stage,
+            rendererIndex)
         : nullptr;
 }
 
@@ -256,7 +259,8 @@ bool ExecuteCameraFrameRecordedStagePass(
         RenderPass* const standaloneStagePass =
             ResolveCameraFrameStandaloneStagePass(
                 stage,
-                executionState);
+                executionState,
+                context.plan.request.rendererIndex);
         return ExecuteCameraFrameStandaloneStagePass(
             standaloneStagePass,
             context.plan.request.context,

engine/src/Rendering/Execution/Internal/CameraFrameGraph/StageContract.h

@@ -47,7 +47,8 @@ RenderSceneData BuildCameraFrameStandaloneStageSceneData(
 
 RenderPass* ResolveCameraFrameStandaloneStagePass(
     CameraFrameStage stage,
-    CameraFrameExecutionState& executionState);
+    CameraFrameExecutionState& executionState,
+    int32_t rendererIndex);
 
 bool InitializeCameraFrameStandaloneStagePass(
     RenderPass* pass,

engine/src/Rendering/Internal/RenderPipelineFactory.cpp

@@ -3,6 +3,9 @@
 #include "Rendering/Pipelines/BuiltinForwardPipeline.h"
 #include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"
 #include "Rendering/Pipelines/ScriptableRenderPipelineHost.h"
+#include "Rendering/Passes/BuiltinDepthOnlyPass.h"
+#include "Rendering/Passes/BuiltinObjectIdPass.h"
+#include "Rendering/Passes/BuiltinShadowCasterPass.h"
 
 #include <mutex>
 #include <unordered_map>
@@ -22,24 +25,53 @@ CreateBuiltinForwardPipelineRendererAsset() {
     return s_builtinForwardPipelineAsset;
 }
 
+std::unique_ptr<RenderPass> CreateBuiltinDepthOnlyStandalonePass() {
+    return std::make_unique<Passes::BuiltinDepthOnlyPass>();
+}
+
+std::unique_ptr<RenderPass> CreateBuiltinObjectIdStandalonePass() {
+    return std::make_unique<Passes::BuiltinObjectIdPass>();
+}
+
+std::unique_ptr<RenderPass> CreateBuiltinShadowCasterStandalonePass() {
+    return std::make_unique<Passes::BuiltinShadowCasterPass>();
+}
+
 using PipelineRendererAssetRegistry =
     std::unordered_map<std::string, PipelineRendererAssetFactory>;
+using CameraFrameStandalonePassRegistry =
+    std::unordered_map<std::string, CameraFrameStandalonePassFactory>;
 
 PipelineRendererAssetRegistry& GetPipelineRendererAssetRegistry() {
     static PipelineRendererAssetRegistry registry = {};
     return registry;
 }
 
+CameraFrameStandalonePassRegistry& GetCameraFrameStandalonePassRegistry() {
+    static CameraFrameStandalonePassRegistry registry = {};
+    return registry;
+}
+
 std::unordered_set<std::string>& GetBuiltinPipelineRendererAssetKeys() {
     static std::unordered_set<std::string> builtinKeys = {};
     return builtinKeys;
 }
 
+std::unordered_set<std::string>& GetBuiltinCameraFrameStandalonePassKeys() {
+    static std::unordered_set<std::string> builtinKeys = {};
+    return builtinKeys;
+}
+
 std::mutex& GetPipelineRendererAssetRegistryMutex() {
     static std::mutex mutex;
     return mutex;
 }
 
+std::mutex& GetCameraFrameStandalonePassRegistryMutex() {
+    static std::mutex mutex;
+    return mutex;
+}
+
 void EnsureBuiltinPipelineRendererAssetRegistryInitialized() {
     static const bool initialized = []() {
         PipelineRendererAssetRegistry& registry =
@@ -53,6 +85,29 @@ void EnsureBuiltinPipelineRendererAssetRegistryInitialized() {
     (void)initialized;
 }
 
+void EnsureBuiltinCameraFrameStandalonePassRegistryInitialized() {
+    static const bool initialized = []() {
+        CameraFrameStandalonePassRegistry& registry =
+            GetCameraFrameStandalonePassRegistry();
+        registry.emplace(
+            "BuiltinDepthOnly",
+            &CreateBuiltinDepthOnlyStandalonePass);
+        registry.emplace(
+            "BuiltinObjectId",
+            &CreateBuiltinObjectIdStandalonePass);
+        registry.emplace(
+            "BuiltinShadowCaster",
+            &CreateBuiltinShadowCasterStandalonePass);
+        std::unordered_set<std::string>& builtinKeys =
+            GetBuiltinCameraFrameStandalonePassKeys();
+        builtinKeys.insert("BuiltinDepthOnly");
+        builtinKeys.insert("BuiltinObjectId");
+        builtinKeys.insert("BuiltinShadowCaster");
+        return true;
+    }();
+    (void)initialized;
+}
+
 std::unique_ptr<NativeSceneRenderer> TryCreateNativeSceneRendererFromAsset(
     const std::shared_ptr<const RenderPipelineAsset>& asset) {
     if (asset == nullptr) {
@@ -144,6 +199,67 @@ std::shared_ptr<const RenderPipelineAsset> CreatePipelineRendererAssetByKey(
     return it->second();
 }
 
+bool RegisterCameraFrameStandalonePassFactory(
+    const std::string& key,
+    CameraFrameStandalonePassFactory factory) {
+    if (key.empty() || !factory) {
+        return false;
+    }
+
+    EnsureBuiltinCameraFrameStandalonePassRegistryInitialized();
+
+    std::lock_guard<std::mutex> lock(
+        GetCameraFrameStandalonePassRegistryMutex());
+    CameraFrameStandalonePassRegistry& registry =
+        GetCameraFrameStandalonePassRegistry();
+    if (registry.find(key) != registry.end()) {
+        return false;
+    }
+
+    registry.emplace(key, std::move(factory));
+    return true;
+}
+
+bool UnregisterCameraFrameStandalonePassFactory(
+    const std::string& key) {
+    if (key.empty()) {
+        return false;
+    }
+
+    EnsureBuiltinCameraFrameStandalonePassRegistryInitialized();
+
+    std::lock_guard<std::mutex> lock(
+        GetCameraFrameStandalonePassRegistryMutex());
+    if (GetBuiltinCameraFrameStandalonePassKeys().find(key) !=
+        GetBuiltinCameraFrameStandalonePassKeys().end()) {
+        return false;
+    }
+
+    CameraFrameStandalonePassRegistry& registry =
+        GetCameraFrameStandalonePassRegistry();
+    return registry.erase(key) != 0u;
+}
+
+std::unique_ptr<RenderPass> CreateCameraFrameStandalonePassByKey(
+    const std::string& key) {
+    if (key.empty()) {
+        return nullptr;
+    }
+
+    EnsureBuiltinCameraFrameStandalonePassRegistryInitialized();
+
+    std::lock_guard<std::mutex> lock(
+        GetCameraFrameStandalonePassRegistryMutex());
+    const CameraFrameStandalonePassRegistry& registry =
+        GetCameraFrameStandalonePassRegistry();
+    const auto it = registry.find(key);
+    if (it == registry.end() || !it->second) {
+        return nullptr;
+    }
+
+    return it->second();
+}
+
 std::shared_ptr<const RenderPipelineAsset> ResolveRenderPipelineAssetOrDefault(
     std::shared_ptr<const RenderPipelineAsset> preferredAsset) {
     if (preferredAsset != nullptr) {

engine/src/Rendering/Internal/RenderPipelineFactory.h

@@ -10,11 +10,14 @@ namespace Rendering {
 class NativeSceneRenderer;
 class RenderPipeline;
 class RenderPipelineAsset;
+class RenderPass;
 
 namespace Internal {
 
 using PipelineRendererAssetFactory =
     std::function<std::shared_ptr<const RenderPipelineAsset>()>;
+using CameraFrameStandalonePassFactory =
+    std::function<std::unique_ptr<RenderPass>()>;
 
 std::shared_ptr<const RenderPipelineAsset> CreateConfiguredRenderPipelineAsset();
 std::shared_ptr<const RenderPipelineAsset> CreateFallbackRenderPipelineAsset();
@@ -24,6 +27,13 @@ bool RegisterPipelineRendererAssetFactory(
 bool UnregisterPipelineRendererAssetFactory(const std::string& key);
 std::shared_ptr<const RenderPipelineAsset> CreatePipelineRendererAssetByKey(
     const std::string& key);
+bool RegisterCameraFrameStandalonePassFactory(
+    const std::string& key,
+    CameraFrameStandalonePassFactory factory);
+bool UnregisterCameraFrameStandalonePassFactory(
+    const std::string& key);
+std::unique_ptr<RenderPass> CreateCameraFrameStandalonePassByKey(
+    const std::string& key);
 
 std::shared_ptr<const RenderPipelineAsset> ResolveRenderPipelineAssetOrDefault(
     std::shared_ptr<const RenderPipelineAsset> preferredAsset);

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 {