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/Scripting/Mono/MonoScriptRuntime.cpp

@@ -1319,6 +1319,11 @@ public:
     GetPipelineRendererAsset() const override;
     std::shared_ptr<const Rendering::RenderPipelineAsset>
     GetPipelineRendererAsset(int32_t rendererIndex) const override;
+    std::string GetCameraFrameStandalonePassAssetKey(
+        Rendering::CameraFrameStage stage) const override;
+    std::string GetCameraFrameStandalonePassAssetKey(
+        Rendering::CameraFrameStage stage,
+        int32_t rendererIndex) const override;
 
     MonoScriptRuntime* GetRuntime() const {
         return m_runtime;
@@ -1353,6 +1358,11 @@ private:
         MonoObject* assetObject) const;
     MonoMethod* ResolveGetPipelineRendererAssetKeyContextualMethod(
         MonoObject* assetObject) const;
+    MonoMethod* ResolveGetCameraFrameStandalonePassAssetKeyMethod(
+        MonoObject* assetObject) const;
+    MonoMethod*
+    ResolveGetCameraFrameStandalonePassAssetKeyContextualMethod(
+        MonoObject* assetObject) const;
     MonoMethod* ResolveReleaseRuntimeResourcesMethod(
         MonoObject* assetObject) const;
 
@@ -1369,6 +1379,10 @@ private:
     mutable MonoMethod* m_getPipelineRendererAssetKeyMethod = nullptr;
     mutable MonoMethod* m_getPipelineRendererAssetKeyContextualMethod =
         nullptr;
+    mutable MonoMethod* m_getCameraFrameStandalonePassAssetKeyMethod =
+        nullptr;
+    mutable MonoMethod*
+        m_getCameraFrameStandalonePassAssetKeyContextualMethod = nullptr;
     mutable MonoMethod* m_releaseRuntimeResourcesMethod = nullptr;
     mutable bool m_ownsManagedAssetHandle = false;
     mutable bool m_assetCreationAttempted = false;
@@ -2001,6 +2015,72 @@ MonoManagedRenderPipelineAssetRuntime::GetPipelineRendererAsset(
     return m_pipelineRendererAsset;
 }
 
+std::string MonoManagedRenderPipelineAssetRuntime::
+    GetCameraFrameStandalonePassAssetKey(
+        Rendering::CameraFrameStage stage) const {
+    return GetCameraFrameStandalonePassAssetKey(
+        stage,
+        -1);
+}
+
+std::string MonoManagedRenderPipelineAssetRuntime::
+    GetCameraFrameStandalonePassAssetKey(
+        Rendering::CameraFrameStage stage,
+        int32_t rendererIndex) const {
+    if (!SyncManagedAssetRuntimeState()) {
+        return {};
+    }
+
+    MonoObject* const assetObject = GetManagedAssetObject();
+    if (assetObject == nullptr) {
+        return {};
+    }
+
+    MonoMethod* const contextualMethod =
+        ResolveGetCameraFrameStandalonePassAssetKeyContextualMethod(
+            assetObject);
+    if (contextualMethod != nullptr) {
+        int32_t managedStage =
+            static_cast<int32_t>(stage);
+        void* args[2] = {
+            &managedStage,
+            &rendererIndex };
+        MonoObject* managedKeyObject = nullptr;
+        if (!m_runtime->InvokeManagedMethod(
+                assetObject,
+                contextualMethod,
+                args,
+                &managedKeyObject)) {
+            return {};
+        }
+
+        return MonoStringToUtf8(
+            reinterpret_cast<MonoString*>(managedKeyObject));
+    }
+
+    MonoMethod* const method =
+        ResolveGetCameraFrameStandalonePassAssetKeyMethod(
+            assetObject);
+    if (method == nullptr) {
+        return {};
+    }
+
+    int32_t managedStage =
+        static_cast<int32_t>(stage);
+    void* args[1] = { &managedStage };
+    MonoObject* managedKeyObject = nullptr;
+    if (!m_runtime->InvokeManagedMethod(
+            assetObject,
+            method,
+            args,
+            &managedKeyObject)) {
+        return {};
+    }
+
+    return MonoStringToUtf8(
+        reinterpret_cast<MonoString*>(managedKeyObject));
+}
+
 bool MonoManagedRenderPipelineAssetRuntime::AcquireManagedPipelineHandle(
     uint32_t& outPipelineHandle) const {
     if (!SyncManagedAssetRuntimeState()) {
@@ -2208,6 +2288,8 @@ void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedAsset() const {
     m_getRuntimeResourceVersionMethod = nullptr;
     m_getPipelineRendererAssetKeyMethod = nullptr;
     m_getPipelineRendererAssetKeyContextualMethod = nullptr;
+    m_getCameraFrameStandalonePassAssetKeyMethod = nullptr;
+    m_getCameraFrameStandalonePassAssetKeyContextualMethod = nullptr;
     m_pipelineRendererAsset.reset();
     m_pipelineRendererAssetResolved = false;
     m_contextualPipelineRendererAssets.clear();
@@ -2356,6 +2438,37 @@ MonoManagedRenderPipelineAssetRuntime::ResolveGetPipelineRendererAssetKeyContext
     return m_getPipelineRendererAssetKeyContextualMethod;
 }
 
+MonoMethod*
+MonoManagedRenderPipelineAssetRuntime::
+    ResolveGetCameraFrameStandalonePassAssetKeyMethod(
+        MonoObject* assetObject) const {
+    if (m_getCameraFrameStandalonePassAssetKeyMethod == nullptr) {
+        m_getCameraFrameStandalonePassAssetKeyMethod =
+            m_runtime->ResolveManagedMethod(
+                assetObject,
+                "GetCameraFrameStandalonePassAssetKey",
+                1);
+    }
+
+    return m_getCameraFrameStandalonePassAssetKeyMethod;
+}
+
+MonoMethod*
+MonoManagedRenderPipelineAssetRuntime::
+    ResolveGetCameraFrameStandalonePassAssetKeyContextualMethod(
+        MonoObject* assetObject) const {
+    if (m_getCameraFrameStandalonePassAssetKeyContextualMethod ==
+        nullptr) {
+        m_getCameraFrameStandalonePassAssetKeyContextualMethod =
+            m_runtime->ResolveManagedMethod(
+                assetObject,
+                "GetCameraFrameStandalonePassAssetKeyContextual",
+                2);
+    }
+
+    return m_getCameraFrameStandalonePassAssetKeyContextualMethod;
+}
+
 MonoMethod*
 MonoManagedRenderPipelineAssetRuntime::ResolveReleaseRuntimeResourcesMethod(
     MonoObject* assetObject) const {