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/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) {