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/include/XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h

@@ -96,6 +96,17 @@ public:
         (void)rendererIndex;
         return GetPipelineRendererAsset();
     }
+    virtual std::string GetCameraFrameStandalonePassAssetKey(
+        CameraFrameStage stage) const {
+        (void)stage;
+        return {};
+    }
+    virtual std::string GetCameraFrameStandalonePassAssetKey(
+        CameraFrameStage stage,
+        int32_t rendererIndex) const {
+        (void)rendererIndex;
+        return GetCameraFrameStandalonePassAssetKey(stage);
+    }
 
     virtual bool TryGetDefaultFinalColorSettings(FinalColorSettings&) const {
         return false;

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

@@ -3,12 +3,17 @@
 #include <XCEngine/Rendering/RenderPipeline.h>
 #include <XCEngine/Rendering/RenderPipelineAsset.h>
 
+#include <array>
 #include <memory>
+#include <string>
+#include <unordered_map>
 
 namespace XCEngine {
 namespace Rendering {
 namespace Pipelines {
 
+class ManagedRenderPipelineAssetRuntime;
+
 class ScriptableRenderPipelineHost final : public RenderPipeline {
 public:
     ScriptableRenderPipelineHost();
@@ -16,6 +21,10 @@ public:
         std::unique_ptr<RenderPipelineRenderer> pipelineRenderer);
     explicit ScriptableRenderPipelineHost(
         std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset);
+    ScriptableRenderPipelineHost(
+        std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset,
+        std::shared_ptr<const ManagedRenderPipelineAssetRuntime>
+            managedAssetRuntime);
     ~ScriptableRenderPipelineHost() override;
 
     using RenderPipeline::Render;
@@ -24,6 +33,9 @@ public:
     void SetPipelineRenderer(std::unique_ptr<RenderPipelineRenderer> pipelineRenderer);
     void SetPipelineRendererAsset(
         std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset);
+    void SetManagedAssetRuntime(
+        std::shared_ptr<const ManagedRenderPipelineAssetRuntime>
+            managedAssetRuntime);
     RenderPipelineStageRecorder* GetStageRecorder() const {
         return m_stageRecorder.get();
     }
@@ -46,19 +58,38 @@ public:
         const RenderContext& context,
         const RenderSurface& surface,
         const RenderSceneData& sceneData) override;
+    RenderPass* GetCameraFrameStandalonePass(
+        CameraFrameStage stage,
+        int32_t rendererIndex) const override;
 
 private:
+    struct ContextualCameraFrameStandalonePassEntry {
+        std::string assetKey = {};
+        std::unique_ptr<RenderPass> pass = nullptr;
+    };
+
     bool EnsureInitialized(const RenderContext& context);
     void BindStageRecorderPipelineRenderer();
+    void ShutdownContextualCameraFrameStandalonePasses();
     void ShutdownInitializedComponents();
     void ResetInitializationState();
     void ClearInitializationContextIfNoComponentsAreInitialized();
     void ResetStageRecorder(std::unique_ptr<RenderPipelineStageRecorder> stageRecorder);
     void ResetPipelineRenderer(std::unique_ptr<RenderPipelineRenderer> pipelineRenderer);
+    RenderPass* ResolveContextualCameraFrameStandalonePass(
+        CameraFrameStage stage,
+        int32_t rendererIndex,
+        const std::string& assetKey);
 
     std::unique_ptr<RenderPipelineStageRecorder> m_stageRecorder;
     std::shared_ptr<const RenderPipelineAsset> m_pipelineRendererAsset;
+    std::shared_ptr<const ManagedRenderPipelineAssetRuntime>
+        m_managedAssetRuntime;
     std::unique_ptr<RenderPipelineRenderer> m_pipelineRenderer;
+    std::array<
+        std::unordered_map<int32_t, ContextualCameraFrameStandalonePassEntry>,
+        kCameraFrameStageCount>
+        m_contextualCameraFrameStandalonePasses = {};
     RHI::RHIDevice* m_initializedDevice = nullptr;
     RHI::RHIType m_initializedBackendType = RHI::RHIType::D3D12;
     bool m_pipelineRendererInitialized = false;
@@ -70,6 +101,10 @@ public:
     ScriptableRenderPipelineHostAsset();
     explicit ScriptableRenderPipelineHostAsset(
         std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset);
+    ScriptableRenderPipelineHostAsset(
+        std::shared_ptr<const RenderPipelineAsset> pipelineRendererAsset,
+        std::shared_ptr<const ManagedRenderPipelineAssetRuntime>
+            managedAssetRuntime);
 
     std::unique_ptr<RenderPipeline> CreatePipeline() const override;
     void ConfigurePipeline(RenderPipeline& pipeline) const override;
@@ -77,6 +112,8 @@ public:
 
 private:
     std::shared_ptr<const RenderPipelineAsset> m_pipelineRendererAsset;
+    std::shared_ptr<const ManagedRenderPipelineAssetRuntime>
+        m_managedAssetRuntime;
 };
 
 } // namespace Pipelines

engine/include/XCEngine/Rendering/RenderPipeline.h

@@ -149,6 +149,13 @@ public:
             : nullptr;
     }
 
+    virtual RenderPass* GetCameraFrameStandalonePass(
+        CameraFrameStage stage,
+        int32_t rendererIndex) const {
+        (void)rendererIndex;
+        return GetCameraFrameStandalonePass(stage);
+    }
+
 protected:
     void ShutdownCameraFrameStandalonePasses() {
         for (std::unique_ptr<RenderPass>& pass : m_cameraFrameStandalonePasses) {