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

engine/src/Rendering/Internal/RenderPipelineFactory.cpp

@@ -1,5 +1,6 @@
 #include "Rendering/Internal/RenderPipelineFactory.h"
 
+#include "Rendering/Execution/DirectionalShadowExecutionState.h"
 #include "Rendering/Pipelines/BuiltinForwardPipeline.h"
 #include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"
 #include "Rendering/Pipelines/ScriptableRenderPipelineHost.h"
@@ -41,6 +42,8 @@ using PipelineRendererAssetRegistry =
     std::unordered_map<std::string, PipelineRendererAssetFactory>;
 using CameraFrameStandalonePassRegistry =
     std::unordered_map<std::string, CameraFrameStandalonePassFactory>;
+using DirectionalShadowExecutionPolicyRegistry =
+    std::unordered_map<std::string, DirectionalShadowExecutionPolicy>;
 
 PipelineRendererAssetRegistry& GetPipelineRendererAssetRegistry() {
     static PipelineRendererAssetRegistry registry = {};
@@ -52,6 +55,12 @@ CameraFrameStandalonePassRegistry& GetCameraFrameStandalonePassRegistry() {
     return registry;
 }
 
+DirectionalShadowExecutionPolicyRegistry&
+GetDirectionalShadowExecutionPolicyRegistry() {
+    static DirectionalShadowExecutionPolicyRegistry registry = {};
+    return registry;
+}
+
 std::unordered_set<std::string>& GetBuiltinPipelineRendererAssetKeys() {
     static std::unordered_set<std::string> builtinKeys = {};
     return builtinKeys;
@@ -62,6 +71,12 @@ std::unordered_set<std::string>& GetBuiltinCameraFrameStandalonePassKeys() {
     return builtinKeys;
 }
 
+std::unordered_set<std::string>&
+GetBuiltinDirectionalShadowExecutionPolicyKeys() {
+    static std::unordered_set<std::string> builtinKeys = {};
+    return builtinKeys;
+}
+
 std::mutex& GetPipelineRendererAssetRegistryMutex() {
     static std::mutex mutex;
     return mutex;
@@ -72,6 +87,11 @@ std::mutex& GetCameraFrameStandalonePassRegistryMutex() {
     return mutex;
 }
 
+std::mutex& GetDirectionalShadowExecutionPolicyRegistryMutex() {
+    static std::mutex mutex;
+    return mutex;
+}
+
 void EnsureBuiltinPipelineRendererAssetRegistryInitialized() {
     static const bool initialized = []() {
         PipelineRendererAssetRegistry& registry =
@@ -108,6 +128,29 @@ void EnsureBuiltinCameraFrameStandalonePassRegistryInitialized() {
     (void)initialized;
 }
 
+void EnsureBuiltinDirectionalShadowExecutionPolicyRegistryInitialized() {
+    static const bool initialized = []() {
+        DirectionalShadowExecutionPolicyRegistry& registry =
+            GetDirectionalShadowExecutionPolicyRegistry();
+        registry.emplace(
+            "BuiltinDirectionalShadow",
+            [](const CameraFramePlan& plan,
+               const DirectionalShadowSurfaceAllocation& shadowAllocation,
+               DirectionalShadowExecutionState& shadowState) {
+                ApplyDefaultRenderPipelineDirectionalShadowExecutionPolicy(
+                    plan,
+                    shadowAllocation,
+                    shadowState);
+                return shadowState.shadowCasterRequest.IsValid() &&
+                       shadowState.shadowData.IsValid();
+            });
+        GetBuiltinDirectionalShadowExecutionPolicyKeys().insert(
+            "BuiltinDirectionalShadow");
+        return true;
+    }();
+    (void)initialized;
+}
+
 std::unique_ptr<NativeSceneRenderer> TryCreateNativeSceneRendererFromAsset(
     const std::shared_ptr<const RenderPipelineAsset>& asset) {
     if (asset == nullptr) {
@@ -260,6 +303,73 @@ std::unique_ptr<RenderPass> CreateCameraFrameStandalonePassByKey(
     return it->second();
 }
 
+bool RegisterDirectionalShadowExecutionPolicy(
+    const std::string& key,
+    DirectionalShadowExecutionPolicy policy) {
+    if (key.empty() || !policy) {
+        return false;
+    }
+
+    EnsureBuiltinDirectionalShadowExecutionPolicyRegistryInitialized();
+
+    std::lock_guard<std::mutex> lock(
+        GetDirectionalShadowExecutionPolicyRegistryMutex());
+    DirectionalShadowExecutionPolicyRegistry& registry =
+        GetDirectionalShadowExecutionPolicyRegistry();
+    if (registry.find(key) != registry.end()) {
+        return false;
+    }
+
+    registry.emplace(key, std::move(policy));
+    return true;
+}
+
+bool UnregisterDirectionalShadowExecutionPolicy(
+    const std::string& key) {
+    if (key.empty()) {
+        return false;
+    }
+
+    EnsureBuiltinDirectionalShadowExecutionPolicyRegistryInitialized();
+
+    std::lock_guard<std::mutex> lock(
+        GetDirectionalShadowExecutionPolicyRegistryMutex());
+    if (GetBuiltinDirectionalShadowExecutionPolicyKeys().find(key) !=
+        GetBuiltinDirectionalShadowExecutionPolicyKeys().end()) {
+        return false;
+    }
+
+    DirectionalShadowExecutionPolicyRegistry& registry =
+        GetDirectionalShadowExecutionPolicyRegistry();
+    return registry.erase(key) != 0u;
+}
+
+bool ConfigureDirectionalShadowExecutionStateByKey(
+    const std::string& key,
+    const CameraFramePlan& plan,
+    const DirectionalShadowSurfaceAllocation& shadowAllocation,
+    DirectionalShadowExecutionState& shadowState) {
+    if (key.empty()) {
+        return false;
+    }
+
+    EnsureBuiltinDirectionalShadowExecutionPolicyRegistryInitialized();
+
+    std::lock_guard<std::mutex> lock(
+        GetDirectionalShadowExecutionPolicyRegistryMutex());
+    const DirectionalShadowExecutionPolicyRegistry& registry =
+        GetDirectionalShadowExecutionPolicyRegistry();
+    const auto it = registry.find(key);
+    if (it == registry.end() || !it->second) {
+        return false;
+    }
+
+    return it->second(
+        plan,
+        shadowAllocation,
+        shadowState);
+}
+
 std::shared_ptr<const RenderPipelineAsset> ResolveRenderPipelineAssetOrDefault(
     std::shared_ptr<const RenderPipelineAsset> preferredAsset) {
     if (preferredAsset != nullptr) {