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

engine/src/Rendering/Internal/RenderPipelineFactory.h

@@ -13,6 +13,7 @@ class RenderPipelineAsset;
 class RenderPass;
 struct CameraRenderRequest;
 struct CameraFramePlan;
+struct RenderSceneData;
 struct DirectionalShadowPlanningSettings;
 struct DirectionalShadowExecutionState;
 struct DirectionalShadowSurfaceAllocation;
@@ -29,6 +30,10 @@ using DirectionalShadowPlanningPolicy =
         size_t,
         size_t,
         const DirectionalShadowPlanningSettings&)>;
+using RenderSceneSetupPolicy =
+    std::function<void(
+        const CameraFramePlan&,
+        RenderSceneData&)>;
 using DirectionalShadowExecutionPolicy =
     std::function<bool(
         const CameraFramePlan&,
@@ -61,6 +66,15 @@ bool ApplyDirectionalShadowPlanningPolicyByKey(
     size_t renderedBaseCameraCount,
     size_t renderedRequestCount,
     const DirectionalShadowPlanningSettings& settings);
+bool RegisterRenderSceneSetupPolicy(
+    const std::string& key,
+    RenderSceneSetupPolicy policy);
+bool UnregisterRenderSceneSetupPolicy(
+    const std::string& key);
+bool ApplyRenderSceneSetupPolicyByKey(
+    const std::string& key,
+    const CameraFramePlan& plan,
+    RenderSceneData& sceneData);
 bool RegisterDirectionalShadowExecutionPolicy(
     const std::string& key,
     DirectionalShadowExecutionPolicy policy);

engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp

@@ -171,6 +171,42 @@ bool ScriptableRenderPipelineHost::Render(
            m_pipelineRenderer->Render(context, surface, sceneData);
 }
 
+void ScriptableRenderPipelineHost::ConfigureRenderSceneData(
+    const CameraFramePlan& plan,
+    RenderSceneData& sceneData) const {
+    if (m_managedAssetRuntime == nullptr) {
+        RenderPipeline::ConfigureRenderSceneData(
+            plan,
+            sceneData);
+        return;
+    }
+
+    const std::string assetKey =
+        m_managedAssetRuntime
+            ->GetRenderSceneSetupPolicyAssetKey(
+                plan.request.rendererIndex);
+    if (assetKey.empty()) {
+        RenderPipeline::ConfigureRenderSceneData(
+            plan,
+            sceneData);
+        return;
+    }
+
+    if (!Rendering::Internal::ApplyRenderSceneSetupPolicyByKey(
+            assetKey,
+            plan,
+            sceneData)) {
+        Debug::Logger::Get().Error(
+            Debug::LogCategory::Rendering,
+            Containers::String(
+                "ScriptableRenderPipelineHost failed to resolve render scene setup policy asset key: ") +
+                assetKey.c_str());
+        RenderPipeline::ConfigureRenderSceneData(
+            plan,
+            sceneData);
+    }
+}
+
 bool ScriptableRenderPipelineHost::ConfigureDirectionalShadowExecutionState(
     const CameraFramePlan& plan,
     const DirectionalShadowSurfaceAllocation& shadowAllocation,

engine/src/Rendering/RenderPipeline.cpp

@@ -52,6 +52,14 @@ RenderEnvironmentData BuildDefaultEnvironmentData(const CameraFramePlan& plan) {
 void RenderPipeline::ConfigureRenderSceneData(
     const CameraFramePlan& plan,
     RenderSceneData& sceneData) const {
+    ApplyDefaultRenderPipelineSceneSetupPolicy(
+        plan,
+        sceneData);
+}
+
+void ApplyDefaultRenderPipelineSceneSetupPolicy(
+    const CameraFramePlan& plan,
+    RenderSceneData& sceneData) {
     sceneData.globalShaderKeywords =
         BuildDefaultSceneGlobalShaderKeywords(sceneData);
     sceneData.environment =

engine/src/Scripting/Mono/MonoScriptRuntime.cpp

@@ -1319,6 +1319,10 @@ public:
     GetPipelineRendererAsset() const override;
     std::shared_ptr<const Rendering::RenderPipelineAsset>
     GetPipelineRendererAsset(int32_t rendererIndex) const override;
+    std::string GetRenderSceneSetupPolicyAssetKey() const
+        override;
+    std::string GetRenderSceneSetupPolicyAssetKey(
+        int32_t rendererIndex) const override;
     std::string GetDirectionalShadowPlanningPolicyAssetKey() const
         override;
     std::string GetDirectionalShadowExecutionPolicyAssetKey() const
@@ -1364,6 +1368,10 @@ private:
         MonoObject* assetObject) const;
     MonoMethod* ResolveGetPipelineRendererAssetKeyContextualMethod(
         MonoObject* assetObject) const;
+    MonoMethod* ResolveGetRenderSceneSetupPolicyAssetKeyMethod(
+        MonoObject* assetObject) const;
+    MonoMethod* ResolveGetRenderSceneSetupPolicyAssetKeyContextualMethod(
+        MonoObject* assetObject) const;
     MonoMethod* ResolveGetDirectionalShadowPlanningPolicyAssetKeyMethod(
         MonoObject* assetObject) const;
     MonoMethod* ResolveGetDirectionalShadowExecutionPolicyAssetKeyMethod(
@@ -1392,6 +1400,11 @@ private:
     mutable MonoMethod* m_getPipelineRendererAssetKeyMethod = nullptr;
     mutable MonoMethod* m_getPipelineRendererAssetKeyContextualMethod =
         nullptr;
+    mutable MonoMethod* m_getRenderSceneSetupPolicyAssetKeyMethod =
+        nullptr;
+    mutable MonoMethod*
+        m_getRenderSceneSetupPolicyAssetKeyContextualMethod =
+            nullptr;
     mutable MonoMethod*
         m_getDirectionalShadowPlanningPolicyAssetKeyMethod = nullptr;
     mutable MonoMethod*
@@ -2050,6 +2063,61 @@ MonoManagedRenderPipelineAssetRuntime::GetPipelineRendererAsset(
     return m_pipelineRendererAsset;
 }
 
+std::string MonoManagedRenderPipelineAssetRuntime::
+    GetRenderSceneSetupPolicyAssetKey() const {
+    return GetRenderSceneSetupPolicyAssetKey(-1);
+}
+
+std::string MonoManagedRenderPipelineAssetRuntime::
+    GetRenderSceneSetupPolicyAssetKey(
+        int32_t rendererIndex) const {
+    if (!SyncManagedAssetRuntimeState()) {
+        return {};
+    }
+
+    MonoObject* const assetObject = GetManagedAssetObject();
+    if (assetObject == nullptr) {
+        return {};
+    }
+
+    MonoMethod* const contextualMethod =
+        ResolveGetRenderSceneSetupPolicyAssetKeyContextualMethod(
+            assetObject);
+    if (contextualMethod != nullptr) {
+        void* args[1] = { &rendererIndex };
+        MonoObject* managedKeyObject = nullptr;
+        if (!m_runtime->InvokeManagedMethod(
+                assetObject,
+                contextualMethod,
+                args,
+                &managedKeyObject)) {
+            return {};
+        }
+
+        return MonoStringToUtf8(
+            reinterpret_cast<MonoString*>(managedKeyObject));
+    }
+
+    MonoMethod* const method =
+        ResolveGetRenderSceneSetupPolicyAssetKeyMethod(
+            assetObject);
+    if (method == nullptr) {
+        return {};
+    }
+
+    MonoObject* managedKeyObject = nullptr;
+    if (!m_runtime->InvokeManagedMethod(
+            assetObject,
+            method,
+            nullptr,
+            &managedKeyObject)) {
+        return {};
+    }
+
+    return MonoStringToUtf8(
+        reinterpret_cast<MonoString*>(managedKeyObject));
+}
+
 std::string MonoManagedRenderPipelineAssetRuntime::
     GetDirectionalShadowPlanningPolicyAssetKey() const {
     if (!SyncManagedAssetRuntimeState()) {
@@ -2409,6 +2477,8 @@ void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedAsset() const {
     m_getRuntimeResourceVersionMethod = nullptr;
     m_getPipelineRendererAssetKeyMethod = nullptr;
     m_getPipelineRendererAssetKeyContextualMethod = nullptr;
+    m_getRenderSceneSetupPolicyAssetKeyMethod = nullptr;
+    m_getRenderSceneSetupPolicyAssetKeyContextualMethod = nullptr;
     m_getDirectionalShadowPlanningPolicyAssetKeyMethod = nullptr;
     m_getDirectionalShadowExecutionPolicyAssetKeyMethod = nullptr;
     m_getDirectionalShadowExecutionPolicyAssetKeyContextualMethod =
@@ -2563,6 +2633,37 @@ MonoManagedRenderPipelineAssetRuntime::ResolveGetPipelineRendererAssetKeyContext
     return m_getPipelineRendererAssetKeyContextualMethod;
 }
 
+MonoMethod*
+MonoManagedRenderPipelineAssetRuntime::
+    ResolveGetRenderSceneSetupPolicyAssetKeyMethod(
+        MonoObject* assetObject) const {
+    if (m_getRenderSceneSetupPolicyAssetKeyMethod == nullptr) {
+        m_getRenderSceneSetupPolicyAssetKeyMethod =
+            m_runtime->ResolveManagedMethod(
+                assetObject,
+                "GetRenderSceneSetupPolicyAssetKey",
+                0);
+    }
+
+    return m_getRenderSceneSetupPolicyAssetKeyMethod;
+}
+
+MonoMethod*
+MonoManagedRenderPipelineAssetRuntime::
+    ResolveGetRenderSceneSetupPolicyAssetKeyContextualMethod(
+        MonoObject* assetObject) const {
+    if (m_getRenderSceneSetupPolicyAssetKeyContextualMethod ==
+        nullptr) {
+        m_getRenderSceneSetupPolicyAssetKeyContextualMethod =
+            m_runtime->ResolveManagedMethod(
+                assetObject,
+                "GetRenderSceneSetupPolicyAssetKeyContextual",
+                1);
+    }
+
+    return m_getRenderSceneSetupPolicyAssetKeyContextualMethod;
+}
+
 MonoMethod*
 MonoManagedRenderPipelineAssetRuntime::
     ResolveGetDirectionalShadowPlanningPolicyAssetKeyMethod(