refactor(srp): move directional shadow planning policy into managed urp

engine/src/Rendering/Internal/RenderPipelineFactory.cpp

@@ -1,5 +1,7 @@
 #include "Rendering/Internal/RenderPipelineFactory.h"
 
+#include <XCEngine/Rendering/RenderPipelineAsset.h>
+
 #include "Rendering/Execution/DirectionalShadowExecutionState.h"
 #include "Rendering/Pipelines/BuiltinForwardPipeline.h"
 #include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"
@@ -42,6 +44,8 @@ using PipelineRendererAssetRegistry =
     std::unordered_map<std::string, PipelineRendererAssetFactory>;
 using CameraFrameStandalonePassRegistry =
     std::unordered_map<std::string, CameraFrameStandalonePassFactory>;
+using DirectionalShadowPlanningPolicyRegistry =
+    std::unordered_map<std::string, DirectionalShadowPlanningPolicy>;
 using DirectionalShadowExecutionPolicyRegistry =
     std::unordered_map<std::string, DirectionalShadowExecutionPolicy>;
 
@@ -55,6 +59,12 @@ CameraFrameStandalonePassRegistry& GetCameraFrameStandalonePassRegistry() {
     return registry;
 }
 
+DirectionalShadowPlanningPolicyRegistry&
+GetDirectionalShadowPlanningPolicyRegistry() {
+    static DirectionalShadowPlanningPolicyRegistry registry = {};
+    return registry;
+}
+
 DirectionalShadowExecutionPolicyRegistry&
 GetDirectionalShadowExecutionPolicyRegistry() {
     static DirectionalShadowExecutionPolicyRegistry registry = {};
@@ -71,6 +81,11 @@ std::unordered_set<std::string>& GetBuiltinCameraFrameStandalonePassKeys() {
     return builtinKeys;
 }
 
+std::unordered_set<std::string>& GetBuiltinDirectionalShadowPlanningPolicyKeys() {
+    static std::unordered_set<std::string> builtinKeys = {};
+    return builtinKeys;
+}
+
 std::unordered_set<std::string>&
 GetBuiltinDirectionalShadowExecutionPolicyKeys() {
     static std::unordered_set<std::string> builtinKeys = {};
@@ -87,6 +102,11 @@ std::mutex& GetCameraFrameStandalonePassRegistryMutex() {
     return mutex;
 }
 
+std::mutex& GetDirectionalShadowPlanningPolicyRegistryMutex() {
+    static std::mutex mutex;
+    return mutex;
+}
+
 std::mutex& GetDirectionalShadowExecutionPolicyRegistryMutex() {
     static std::mutex mutex;
     return mutex;
@@ -128,6 +148,29 @@ void EnsureBuiltinCameraFrameStandalonePassRegistryInitialized() {
     (void)initialized;
 }
 
+void EnsureBuiltinDirectionalShadowPlanningPolicyRegistryInitialized() {
+    static const bool initialized = []() {
+        DirectionalShadowPlanningPolicyRegistry& registry =
+            GetDirectionalShadowPlanningPolicyRegistry();
+        registry.emplace(
+            "BuiltinDirectionalShadowPlanning",
+            [](CameraRenderRequest& request,
+               size_t renderedBaseCameraCount,
+               size_t renderedRequestCount,
+               const DirectionalShadowPlanningSettings& settings) {
+                ApplyDefaultRenderPipelineAssetCameraRenderRequestPolicy(
+                    request,
+                    renderedBaseCameraCount,
+                    renderedRequestCount,
+                    settings);
+            });
+        GetBuiltinDirectionalShadowPlanningPolicyKeys().insert(
+            "BuiltinDirectionalShadowPlanning");
+        return true;
+    }();
+    (void)initialized;
+}
+
 void EnsureBuiltinDirectionalShadowExecutionPolicyRegistryInitialized() {
     static const bool initialized = []() {
         DirectionalShadowExecutionPolicyRegistry& registry =
@@ -303,6 +346,76 @@ std::unique_ptr<RenderPass> CreateCameraFrameStandalonePassByKey(
     return it->second();
 }
 
+bool RegisterDirectionalShadowPlanningPolicy(
+    const std::string& key,
+    DirectionalShadowPlanningPolicy policy) {
+    if (key.empty() || !policy) {
+        return false;
+    }
+
+    EnsureBuiltinDirectionalShadowPlanningPolicyRegistryInitialized();
+
+    std::lock_guard<std::mutex> lock(
+        GetDirectionalShadowPlanningPolicyRegistryMutex());
+    DirectionalShadowPlanningPolicyRegistry& registry =
+        GetDirectionalShadowPlanningPolicyRegistry();
+    if (registry.find(key) != registry.end()) {
+        return false;
+    }
+
+    registry.emplace(key, std::move(policy));
+    return true;
+}
+
+bool UnregisterDirectionalShadowPlanningPolicy(
+    const std::string& key) {
+    if (key.empty()) {
+        return false;
+    }
+
+    EnsureBuiltinDirectionalShadowPlanningPolicyRegistryInitialized();
+
+    std::lock_guard<std::mutex> lock(
+        GetDirectionalShadowPlanningPolicyRegistryMutex());
+    if (GetBuiltinDirectionalShadowPlanningPolicyKeys().find(key) !=
+        GetBuiltinDirectionalShadowPlanningPolicyKeys().end()) {
+        return false;
+    }
+
+    DirectionalShadowPlanningPolicyRegistry& registry =
+        GetDirectionalShadowPlanningPolicyRegistry();
+    return registry.erase(key) != 0u;
+}
+
+bool ApplyDirectionalShadowPlanningPolicyByKey(
+    const std::string& key,
+    CameraRenderRequest& request,
+    size_t renderedBaseCameraCount,
+    size_t renderedRequestCount,
+    const DirectionalShadowPlanningSettings& settings) {
+    if (key.empty()) {
+        return false;
+    }
+
+    EnsureBuiltinDirectionalShadowPlanningPolicyRegistryInitialized();
+
+    std::lock_guard<std::mutex> lock(
+        GetDirectionalShadowPlanningPolicyRegistryMutex());
+    const DirectionalShadowPlanningPolicyRegistry& registry =
+        GetDirectionalShadowPlanningPolicyRegistry();
+    const auto it = registry.find(key);
+    if (it == registry.end() || !it->second) {
+        return false;
+    }
+
+    it->second(
+        request,
+        renderedBaseCameraCount,
+        renderedRequestCount,
+        settings);
+    return true;
+}
+
 bool RegisterDirectionalShadowExecutionPolicy(
     const std::string& key,
     DirectionalShadowExecutionPolicy policy) {