refactor(srp): move render scene setup into managed urp

engine/src/Rendering/Internal/RenderPipelineFactory.cpp

@@ -1,6 +1,7 @@
 #include "Rendering/Internal/RenderPipelineFactory.h"
 
 #include <XCEngine/Rendering/RenderPipelineAsset.h>
+#include <XCEngine/Rendering/RenderPipeline.h>
 
 #include "Rendering/Execution/DirectionalShadowExecutionState.h"
 #include "Rendering/Pipelines/BuiltinForwardPipeline.h"
@@ -46,6 +47,8 @@ using CameraFrameStandalonePassRegistry =
     std::unordered_map<std::string, CameraFrameStandalonePassFactory>;
 using DirectionalShadowPlanningPolicyRegistry =
     std::unordered_map<std::string, DirectionalShadowPlanningPolicy>;
+using RenderSceneSetupPolicyRegistry =
+    std::unordered_map<std::string, RenderSceneSetupPolicy>;
 using DirectionalShadowExecutionPolicyRegistry =
     std::unordered_map<std::string, DirectionalShadowExecutionPolicy>;
 
@@ -65,6 +68,12 @@ GetDirectionalShadowPlanningPolicyRegistry() {
     return registry;
 }
 
+RenderSceneSetupPolicyRegistry&
+GetRenderSceneSetupPolicyRegistry() {
+    static RenderSceneSetupPolicyRegistry registry = {};
+    return registry;
+}
+
 DirectionalShadowExecutionPolicyRegistry&
 GetDirectionalShadowExecutionPolicyRegistry() {
     static DirectionalShadowExecutionPolicyRegistry registry = {};
@@ -86,6 +95,11 @@ std::unordered_set<std::string>& GetBuiltinDirectionalShadowPlanningPolicyKeys()
     return builtinKeys;
 }
 
+std::unordered_set<std::string>& GetBuiltinRenderSceneSetupPolicyKeys() {
+    static std::unordered_set<std::string> builtinKeys = {};
+    return builtinKeys;
+}
+
 std::unordered_set<std::string>&
 GetBuiltinDirectionalShadowExecutionPolicyKeys() {
     static std::unordered_set<std::string> builtinKeys = {};
@@ -107,6 +121,11 @@ std::mutex& GetDirectionalShadowPlanningPolicyRegistryMutex() {
     return mutex;
 }
 
+std::mutex& GetRenderSceneSetupPolicyRegistryMutex() {
+    static std::mutex mutex;
+    return mutex;
+}
+
 std::mutex& GetDirectionalShadowExecutionPolicyRegistryMutex() {
     static std::mutex mutex;
     return mutex;
@@ -171,6 +190,25 @@ void EnsureBuiltinDirectionalShadowPlanningPolicyRegistryInitialized() {
     (void)initialized;
 }
 
+void EnsureBuiltinRenderSceneSetupPolicyRegistryInitialized() {
+    static const bool initialized = []() {
+        RenderSceneSetupPolicyRegistry& registry =
+            GetRenderSceneSetupPolicyRegistry();
+        registry.emplace(
+            "BuiltinDefaultSceneSetup",
+            [](const CameraFramePlan& plan,
+               RenderSceneData& sceneData) {
+                ApplyDefaultRenderPipelineSceneSetupPolicy(
+                    plan,
+                    sceneData);
+            });
+        GetBuiltinRenderSceneSetupPolicyKeys().insert(
+            "BuiltinDefaultSceneSetup");
+        return true;
+    }();
+    (void)initialized;
+}
+
 void EnsureBuiltinDirectionalShadowExecutionPolicyRegistryInitialized() {
     static const bool initialized = []() {
         DirectionalShadowExecutionPolicyRegistry& registry =
@@ -416,6 +454,72 @@ bool ApplyDirectionalShadowPlanningPolicyByKey(
     return true;
 }
 
+bool RegisterRenderSceneSetupPolicy(
+    const std::string& key,
+    RenderSceneSetupPolicy policy) {
+    if (key.empty() || !policy) {
+        return false;
+    }
+
+    EnsureBuiltinRenderSceneSetupPolicyRegistryInitialized();
+
+    std::lock_guard<std::mutex> lock(
+        GetRenderSceneSetupPolicyRegistryMutex());
+    RenderSceneSetupPolicyRegistry& registry =
+        GetRenderSceneSetupPolicyRegistry();
+    if (registry.find(key) != registry.end()) {
+        return false;
+    }
+
+    registry.emplace(key, std::move(policy));
+    return true;
+}
+
+bool UnregisterRenderSceneSetupPolicy(
+    const std::string& key) {
+    if (key.empty()) {
+        return false;
+    }
+
+    EnsureBuiltinRenderSceneSetupPolicyRegistryInitialized();
+
+    std::lock_guard<std::mutex> lock(
+        GetRenderSceneSetupPolicyRegistryMutex());
+    if (GetBuiltinRenderSceneSetupPolicyKeys().find(key) !=
+        GetBuiltinRenderSceneSetupPolicyKeys().end()) {
+        return false;
+    }
+
+    RenderSceneSetupPolicyRegistry& registry =
+        GetRenderSceneSetupPolicyRegistry();
+    return registry.erase(key) != 0u;
+}
+
+bool ApplyRenderSceneSetupPolicyByKey(
+    const std::string& key,
+    const CameraFramePlan& plan,
+    RenderSceneData& sceneData) {
+    if (key.empty()) {
+        return false;
+    }
+
+    EnsureBuiltinRenderSceneSetupPolicyRegistryInitialized();
+
+    std::lock_guard<std::mutex> lock(
+        GetRenderSceneSetupPolicyRegistryMutex());
+    const RenderSceneSetupPolicyRegistry& registry =
+        GetRenderSceneSetupPolicyRegistry();
+    const auto it = registry.find(key);
+    if (it == registry.end() || !it->second) {
+        return false;
+    }
+
+    it->second(
+        plan,
+        sceneData);
+    return true;
+}
+
 bool RegisterDirectionalShadowExecutionPolicy(
     const std::string& key,
     DirectionalShadowExecutionPolicy policy) {