refactor(srp): move scene setup ownership into managed renderer

2026-04-21 18:05:33 +08:00
parent 233cf25965
commit f75164a4fa
19 changed files with 623 additions and 292 deletions
--- a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp
+++ b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp
@@ -137,6 +137,13 @@ struct ManagedCameraRenderRequestContextState {
    bool suppressDirectionalShadow = false;
 };

+struct ManagedRenderSceneSetupContextState {
+    uint64_t handle = 0;
+    const Rendering::CameraFramePlan* plan = nullptr;
+    Rendering::RenderSceneData* sceneData = nullptr;
+    bool explicitlyConfigured = false;
+};
+
 struct ManagedDirectionalShadowExecutionContextState {
    uint64_t handle = 0;
    const Rendering::CameraFramePlan* plan = nullptr;
@@ -529,6 +536,52 @@ void UnregisterManagedCameraRenderRequestContextState(
    GetManagedCameraRenderRequestContextRegistry().erase(handle);
 }

+uint64_t& GetManagedRenderSceneSetupContextNextHandle() {
+    static uint64_t nextHandle = 1;
+    return nextHandle;
+}
+
+std::unordered_map<uint64_t, ManagedRenderSceneSetupContextState*>&
+GetManagedRenderSceneSetupContextRegistry() {
+    static std::unordered_map<uint64_t, ManagedRenderSceneSetupContextState*>
+        registry;
+    return registry;
+}
+
+ManagedRenderSceneSetupContextState*
+FindManagedRenderSceneSetupContextState(
+    uint64_t handle) {
+    const auto it =
+        GetManagedRenderSceneSetupContextRegistry().find(handle);
+    return it != GetManagedRenderSceneSetupContextRegistry().end()
+        ? it->second
+        : nullptr;
+}
+
+uint64_t RegisterManagedRenderSceneSetupContextState(
+    ManagedRenderSceneSetupContextState& state) {
+    uint64_t handle =
+        GetManagedRenderSceneSetupContextNextHandle()++;
+    if (handle == 0) {
+        handle =
+            GetManagedRenderSceneSetupContextNextHandle()++;
+    }
+
+    state.handle = handle;
+    GetManagedRenderSceneSetupContextRegistry()[handle] =
+        &state;
+    return handle;
+}
+
+void UnregisterManagedRenderSceneSetupContextState(
+    uint64_t handle) {
+    if (handle == 0) {
+        return;
+    }
+
+    GetManagedRenderSceneSetupContextRegistry().erase(handle);
+}
+
 uint64_t& GetManagedDirectionalShadowExecutionContextNextHandle() {
    static uint64_t nextHandle = 1;
    return nextHandle;
@@ -1433,6 +1486,9 @@ public:
            directionalShadowSettings) const override;
    void ConfigureCameraFramePlan(
        Rendering::CameraFramePlan& plan) const override;
+    bool ConfigureRenderSceneSetup(
+        const Rendering::CameraFramePlan& plan,
+        Rendering::RenderSceneData& sceneData) const override;
    bool ConfigureDirectionalShadowExecutionState(
        const Rendering::CameraFramePlan& plan,
        const Rendering::DirectionalShadowSurfaceAllocation&
@@ -1449,10 +1505,6 @@ public:
    bool UsesNativeCameraFramePlanBaseline() const override;
    bool UsesNativeCameraFramePlanBaseline(
        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 GetCameraFrameStandalonePassAssetKey(
@@ -1498,9 +1550,7 @@ private:
        MonoObject* assetObject) const;
    MonoMethod* ResolveUsesNativeCameraFramePlanBaselineContextualMethod(
        MonoObject* assetObject) const;
-    MonoMethod* ResolveGetRenderSceneSetupPolicyAssetKeyMethod(
-        MonoObject* assetObject) const;
-    MonoMethod* ResolveGetRenderSceneSetupPolicyAssetKeyContextualMethod(
+    MonoMethod* ResolveConfigureRenderSceneSetupMethod(
        MonoObject* assetObject) const;
    MonoMethod* ResolveConfigureDirectionalShadowExecutionStateMethod(
        MonoObject* assetObject) const;
@@ -1532,11 +1582,8 @@ private:
    mutable MonoMethod*
        m_usesNativeCameraFramePlanBaselineContextualMethod =
            nullptr;
-    mutable MonoMethod* m_getRenderSceneSetupPolicyAssetKeyMethod =
+    mutable MonoMethod* m_configureRenderSceneSetupMethod =
        nullptr;
-    mutable MonoMethod*
-        m_getRenderSceneSetupPolicyAssetKeyContextualMethod =
-            nullptr;
    mutable MonoMethod*
        m_configureDirectionalShadowExecutionStateMethod = nullptr;
    mutable MonoMethod*
@@ -2061,6 +2108,46 @@ void MonoManagedRenderPipelineAssetRuntime::ConfigureCameraFramePlan(
        planningContextHandle);
 }

+bool MonoManagedRenderPipelineAssetRuntime::ConfigureRenderSceneSetup(
+    const Rendering::CameraFramePlan& plan,
+    Rendering::RenderSceneData& sceneData) const {
+    if (!EnsureManagedAsset()) {
+        return false;
+    }
+
+    MonoObject* const assetObject = GetManagedAssetObject();
+    MonoMethod* const method =
+        ResolveConfigureRenderSceneSetupMethod(assetObject);
+    if (assetObject == nullptr || method == nullptr) {
+        return false;
+    }
+
+    ManagedRenderSceneSetupContextState setupContextState = {};
+    setupContextState.plan = &plan;
+    setupContextState.sceneData = &sceneData;
+    const uint64_t setupContextHandle =
+        RegisterManagedRenderSceneSetupContextState(
+            setupContextState);
+    MonoObject* const setupContextObject =
+        m_runtime->CreateManagedRenderSceneSetupContext(
+            setupContextHandle);
+    if (setupContextObject == nullptr) {
+        UnregisterManagedRenderSceneSetupContextState(
+            setupContextHandle);
+        return false;
+    }
+
+    void* args[1] = { setupContextObject };
+    m_runtime->InvokeManagedMethod(
+        assetObject,
+        method,
+        args,
+        nullptr);
+    UnregisterManagedRenderSceneSetupContextState(
+        setupContextHandle);
+    return setupContextState.explicitlyConfigured;
+}
+
 bool MonoManagedRenderPipelineAssetRuntime::
    ConfigureDirectionalShadowExecutionState(
        const Rendering::CameraFramePlan& plan,
@@ -2298,61 +2385,6 @@ bool MonoManagedRenderPipelineAssetRuntime::UsesNativeCameraFramePlanBaseline(
           usesBaseline;
 }

-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()) {
@@ -2659,8 +2691,7 @@ void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedAsset() const {
    m_getPipelineRendererAssetKeyContextualMethod = nullptr;
    m_usesNativeCameraFramePlanBaselineMethod = nullptr;
    m_usesNativeCameraFramePlanBaselineContextualMethod = nullptr;
-    m_getRenderSceneSetupPolicyAssetKeyMethod = nullptr;
-    m_getRenderSceneSetupPolicyAssetKeyContextualMethod = nullptr;
+    m_configureRenderSceneSetupMethod = nullptr;
    m_configureDirectionalShadowExecutionStateMethod = nullptr;
    m_getDirectionalShadowPlanningPolicyAssetKeyMethod = nullptr;
    m_getCameraFrameStandalonePassAssetKeyMethod = nullptr;
@@ -2846,33 +2877,17 @@ MonoManagedRenderPipelineAssetRuntime::

 MonoMethod*
 MonoManagedRenderPipelineAssetRuntime::
-    ResolveGetRenderSceneSetupPolicyAssetKeyMethod(
+    ResolveConfigureRenderSceneSetupMethod(
        MonoObject* assetObject) const {
-    if (m_getRenderSceneSetupPolicyAssetKeyMethod == nullptr) {
-        m_getRenderSceneSetupPolicyAssetKeyMethod =
+    if (m_configureRenderSceneSetupMethod == nullptr) {
+        m_configureRenderSceneSetupMethod =
            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",
+                "ConfigureRenderSceneSetupInstance",
                1);
    }

-    return m_getRenderSceneSetupPolicyAssetKeyContextualMethod;
+    return m_configureRenderSceneSetupMethod;
 }

 MonoMethod*
@@ -5806,6 +5821,119 @@ void InternalCall_Rendering_CameraRenderRequestContext_ClearDirectionalShadow(
    state->suppressDirectionalShadow = true;
 }

+int32_t
+InternalCall_Rendering_RenderSceneSetupContext_GetRendererIndex(
+    uint64_t nativeHandle) {
+    const ManagedRenderSceneSetupContextState* const state =
+        FindManagedRenderSceneSetupContextState(nativeHandle);
+    return state != nullptr &&
+            state->plan != nullptr
+        ? state->plan->request.rendererIndex
+        : -1;
+}
+
+mono_bool
+InternalCall_Rendering_RenderSceneSetupContext_GetIsConfigured(
+    uint64_t nativeHandle) {
+    const ManagedRenderSceneSetupContextState* const state =
+        FindManagedRenderSceneSetupContextState(nativeHandle);
+    return state != nullptr &&
+               state->explicitlyConfigured
+        ? 1
+        : 0;
+}
+
+mono_bool
+InternalCall_Rendering_RenderSceneSetupContext_UseDefaultSceneSetup(
+    uint64_t nativeHandle) {
+    ManagedRenderSceneSetupContextState* const state =
+        FindManagedRenderSceneSetupContextState(nativeHandle);
+    if (state == nullptr ||
+        state->plan == nullptr ||
+        state->sceneData == nullptr) {
+        return 0;
+    }
+
+    Rendering::ApplyDefaultRenderPipelineSceneSetupPolicy(
+        *state->plan,
+        *state->sceneData);
+    state->explicitlyConfigured = true;
+    return 1;
+}
+
+mono_bool
+InternalCall_Rendering_RenderSceneSetupContext_UseDefaultEnvironment(
+    uint64_t nativeHandle) {
+    ManagedRenderSceneSetupContextState* const state =
+        FindManagedRenderSceneSetupContextState(nativeHandle);
+    if (state == nullptr ||
+        state->plan == nullptr ||
+        state->sceneData == nullptr) {
+        return 0;
+    }
+
+    state->sceneData->environment =
+        Rendering::BuildDefaultRenderPipelineEnvironmentData(
+            *state->plan);
+    state->explicitlyConfigured = true;
+    return 1;
+}
+
+mono_bool
+InternalCall_Rendering_RenderSceneSetupContext_UseDefaultGlobalShaderKeywords(
+    uint64_t nativeHandle) {
+    ManagedRenderSceneSetupContextState* const state =
+        FindManagedRenderSceneSetupContextState(nativeHandle);
+    if (state == nullptr || state->sceneData == nullptr) {
+        return 0;
+    }
+
+    state->sceneData->globalShaderKeywords =
+        Rendering::
+            BuildDefaultRenderPipelineSceneGlobalShaderKeywords(
+                *state->sceneData);
+    state->explicitlyConfigured = true;
+    return 1;
+}
+
+void InternalCall_Rendering_RenderSceneSetupContext_ClearEnvironment(
+    uint64_t nativeHandle) {
+    ManagedRenderSceneSetupContextState* const state =
+        FindManagedRenderSceneSetupContextState(nativeHandle);
+    if (state == nullptr || state->sceneData == nullptr) {
+        return;
+    }
+
+    state->sceneData->environment = {};
+    state->explicitlyConfigured = true;
+}
+
+void
+InternalCall_Rendering_RenderSceneSetupContext_ClearGlobalShaderKeywords(
+    uint64_t nativeHandle) {
+    ManagedRenderSceneSetupContextState* const state =
+        FindManagedRenderSceneSetupContextState(nativeHandle);
+    if (state == nullptr || state->sceneData == nullptr) {
+        return;
+    }
+
+    state->sceneData->globalShaderKeywords = {};
+    state->explicitlyConfigured = true;
+}
+
+void InternalCall_Rendering_RenderSceneSetupContext_ClearSceneSetup(
+    uint64_t nativeHandle) {
+    ManagedRenderSceneSetupContextState* const state =
+        FindManagedRenderSceneSetupContextState(nativeHandle);
+    if (state == nullptr || state->sceneData == nullptr) {
+        return;
+    }
+
+    state->sceneData->environment = {};
+    state->sceneData->globalShaderKeywords = {};
+    state->explicitlyConfigured = true;
+}
+
 mono_bool
 InternalCall_Rendering_DirectionalShadowExecutionContext_GetHasPlannedMainDirectionalShadow(
    uint64_t nativeHandle) {
@@ -6332,6 +6460,14 @@ void RegisterInternalCalls() {
    mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_GetDirectionalShadowPlanningSettings", reinterpret_cast<const void*>(&InternalCall_Rendering_CameraRenderRequestContext_GetDirectionalShadowPlanningSettings));
    mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_SetDirectionalShadowPlanningSettings", reinterpret_cast<const void*>(&InternalCall_Rendering_CameraRenderRequestContext_SetDirectionalShadowPlanningSettings));
    mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_ClearDirectionalShadow", reinterpret_cast<const void*>(&InternalCall_Rendering_CameraRenderRequestContext_ClearDirectionalShadow));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_GetRendererIndex", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_GetRendererIndex));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_GetIsConfigured", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_GetIsConfigured));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_UseDefaultSceneSetup", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_UseDefaultSceneSetup));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_UseDefaultEnvironment", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_UseDefaultEnvironment));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_UseDefaultGlobalShaderKeywords", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_UseDefaultGlobalShaderKeywords));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_ClearEnvironment", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_ClearEnvironment));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_ClearGlobalShaderKeywords", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_ClearGlobalShaderKeywords));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_ClearSceneSetup", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_ClearSceneSetup));
    mono_add_internal_call("XCEngine.InternalCalls::Rendering_DirectionalShadowExecutionContext_GetHasPlannedMainDirectionalShadow", reinterpret_cast<const void*>(&InternalCall_Rendering_DirectionalShadowExecutionContext_GetHasPlannedMainDirectionalShadow));
    mono_add_internal_call("XCEngine.InternalCalls::Rendering_DirectionalShadowExecutionContext_GetRendererIndex", reinterpret_cast<const void*>(&InternalCall_Rendering_DirectionalShadowExecutionContext_GetRendererIndex));
    mono_add_internal_call("XCEngine.InternalCalls::Rendering_DirectionalShadowExecutionContext_GetIsConfigured", reinterpret_cast<const void*>(&InternalCall_Rendering_DirectionalShadowExecutionContext_GetIsConfigured));
@@ -6396,6 +6532,10 @@ void MonoScriptRuntime::Shutdown() {
    GetManagedScriptableRenderContextNextHandle() = 1;
    GetManagedCameraRenderRequestContextRegistry().clear();
    GetManagedCameraRenderRequestContextNextHandle() = 1;
+    GetManagedRenderSceneSetupContextRegistry().clear();
+    GetManagedRenderSceneSetupContextNextHandle() = 1;
+    GetManagedDirectionalShadowExecutionContextRegistry().clear();
+    GetManagedDirectionalShadowExecutionContextNextHandle() = 1;
    GetManagedScriptableRenderPipelinePlanningContextRegistry().clear();
    GetManagedScriptableRenderPipelinePlanningContextNextHandle() = 1;
    ClearManagedInstances();
@@ -6415,12 +6555,14 @@ void MonoScriptRuntime::Shutdown() {
    m_scriptableRenderPipelineClass = nullptr;
    m_scriptableRenderContextClass = nullptr;
    m_cameraRenderRequestContextClass = nullptr;
+    m_renderSceneSetupContextClass = nullptr;
    m_directionalShadowExecutionContextClass = nullptr;
    m_scriptableRenderPipelinePlanningContextClass = nullptr;
    m_serializeFieldAttributeClass = nullptr;
    m_gameObjectConstructor = nullptr;
    m_scriptableRenderContextConstructor = nullptr;
    m_cameraRenderRequestContextConstructor = nullptr;
+    m_renderSceneSetupContextConstructor = nullptr;
    m_directionalShadowExecutionContextConstructor = nullptr;
    m_scriptableRenderPipelinePlanningContextConstructor = nullptr;
    m_managedGameObjectUUIDField = nullptr;
@@ -7216,6 +7358,27 @@ bool MonoScriptRuntime::DiscoverScriptClasses() {
        return false;
    }

+    m_renderSceneSetupContextClass = mono_class_from_name(
+        m_coreImage,
+        kManagedRenderingNamespace,
+        "RenderSceneSetupContext");
+    if (!m_renderSceneSetupContextClass) {
+        SetError(
+            "Failed to locate the managed RenderSceneSetupContext type.");
+        return false;
+    }
+
+    m_renderSceneSetupContextConstructor =
+        mono_class_get_method_from_name(
+            m_renderSceneSetupContextClass,
+            ".ctor",
+            1);
+    if (!m_renderSceneSetupContextConstructor) {
+        SetError(
+            "Failed to locate the managed RenderSceneSetupContext constructor.");
+        return false;
+    }
+
    m_directionalShadowExecutionContextClass = mono_class_from_name(
        m_coreImage,
        kManagedRenderingNamespace,
@@ -7853,6 +8016,46 @@ MonoScriptRuntime::CreateManagedCameraRenderRequestContext(
    return contextObject;
 }

+MonoObject*
+MonoScriptRuntime::CreateManagedRenderSceneSetupContext(
+    uint64_t nativeHandle) {
+    if (!m_initialized ||
+        nativeHandle == 0 ||
+        m_renderSceneSetupContextClass == nullptr ||
+        m_renderSceneSetupContextConstructor == nullptr) {
+        return nullptr;
+    }
+
+    SetCurrentDomain();
+
+    MonoObject* const contextObject =
+        mono_object_new(
+            m_appDomain,
+            m_renderSceneSetupContextClass);
+    if (contextObject == nullptr) {
+        SetError(
+            "Mono failed to allocate a managed RenderSceneSetupContext.");
+        return nullptr;
+    }
+
+    void* args[1];
+    uint64_t nativeHandleArgument = nativeHandle;
+    args[0] = &nativeHandleArgument;
+
+    MonoObject* exception = nullptr;
+    mono_runtime_invoke(
+        m_renderSceneSetupContextConstructor,
+        contextObject,
+        args,
+        &exception);
+    if (exception != nullptr) {
+        RecordException(exception);
+        return nullptr;
+    }
+
+    return contextObject;
+}
+
 MonoObject*
 MonoScriptRuntime::CreateManagedDirectionalShadowExecutionContext(
    uint64_t nativeHandle) {