From 01b5e0abcd2d48d8f73ad88ed83b157cd2b85db6 Mon Sep 17 00:00:00 2001 From: ssdfasd <2156608475@qq.com> Date: Tue, 21 Apr 2026 18:46:43 +0800 Subject: [PATCH] refactor(srp): remove managed backend key binding detour --- ...RendererBindingPlan_完成归档_2026-04-21.md | 63 +++++++++ .../Internal/RenderPipelineFactory.cpp | 6 + .../Internal/RenderPipelineFactory.h | 1 + .../ScriptableRenderPipelineHost.cpp | 5 +- .../src/Scripting/Mono/MonoScriptRuntime.cpp | 126 +----------------- .../RendererBackedRenderPipelineAsset.cs | 17 --- .../Universal/ScriptableRendererData.cs | 10 -- .../Universal/UniversalRendererData.cs | 5 - 8 files changed, 76 insertions(+), 157 deletions(-) create mode 100644 docs/used/SRP_URP_DefaultNativeRendererBindingPlan_完成归档_2026-04-21.md diff --git a/docs/used/SRP_URP_DefaultNativeRendererBindingPlan_完成归档_2026-04-21.md b/docs/used/SRP_URP_DefaultNativeRendererBindingPlan_完成归档_2026-04-21.md new file mode 100644 index 00000000..4c1e646c --- /dev/null +++ b/docs/used/SRP_URP_DefaultNativeRendererBindingPlan_完成归档_2026-04-21.md @@ -0,0 +1,63 @@ +# SRP URP Default Native Renderer Binding Plan + +Date: 2026-04-21 + +## Goal + +Remove the remaining managed backend-key declaration path from current URP +renderer data and make native scene-renderer binding fall back to an internal +default native renderer asset instead of asking managed C# for a string key. + +This keeps the native renderer substrate in C++, but stops routing current URP +through a Unity-unlike `"BuiltinForward"` key callback. + +## Why This Stage + +After the previous SRP cleanup: + +1. managed standalone-pass asset keys are gone; +2. managed URP owns camera request, frame planning, render-scene setup, + shadow/depth stage composition, and stage recording; +3. the remaining managed/native backend seam is + `GetPipelineRendererAssetKey*()`. + +Current repo state shows: + +1. `UniversalRendererData` still returns `"BuiltinForward"` from managed C#; +2. `MonoManagedRenderPipelineAssetRuntime` still resolves that method name and + converts the string key back into a native asset; +3. the only active builtin backend is still the default forward renderer + substrate. + +So the current C# backend-key hop is not buying real flexibility. It is mostly +an internal detour that keeps Unity-unlike ownership in the current URP path. + +## Scope + +Included: + +1. add an internal helper that resolves the default native pipeline renderer + asset in C++; +2. remove `GetPipelineRendererAssetKey*()` from current managed URP C# types; +3. remove the corresponding Mono method-resolution / invocation bridge; +4. make `MonoManagedRenderPipelineAssetRuntime::GetPipelineRendererAsset(...)` + use the internal default native renderer asset; +5. rebuild `XCEditor` and run old editor smoke. + +Not included: + +1. redesigning `NativeSceneRecorder` itself; +2. introducing deferred native scene renderer backends; +3. changing public SRP authoring APIs; +4. moving scene draw implementation out of C++. + +## Done Criteria + +1. current URP managed code no longer returns native backend keys; +2. Mono runtime no longer resolves `GetPipelineRendererAssetKey*()` from + managed assets; +3. managed SRP host / stage recorder still binds a valid native scene renderer + substrate through internal default binding; +4. `cmake --build . --config Debug --target XCEditor` passes; +5. old editor smoke passes for at least about 10 seconds and a fresh + `SceneReady` appears in `editor/bin/Debug/editor.log`. diff --git a/engine/src/Rendering/Internal/RenderPipelineFactory.cpp b/engine/src/Rendering/Internal/RenderPipelineFactory.cpp index 1227fd74..1f61a2f6 100644 --- a/engine/src/Rendering/Internal/RenderPipelineFactory.cpp +++ b/engine/src/Rendering/Internal/RenderPipelineFactory.cpp @@ -261,6 +261,12 @@ bool UnregisterPipelineRendererAssetFactory(const std::string& key) { return registry.erase(key) != 0u; } +std::shared_ptr CreateDefaultPipelineRendererAsset() { + static const std::shared_ptr s_defaultAsset = + CreateBuiltinForwardPipelineRendererAsset(); + return s_defaultAsset; +} + std::shared_ptr CreatePipelineRendererAssetByKey( const std::string& key) { if (key.empty()) { diff --git a/engine/src/Rendering/Internal/RenderPipelineFactory.h b/engine/src/Rendering/Internal/RenderPipelineFactory.h index e5af377c..ab657fd2 100644 --- a/engine/src/Rendering/Internal/RenderPipelineFactory.h +++ b/engine/src/Rendering/Internal/RenderPipelineFactory.h @@ -38,6 +38,7 @@ bool RegisterPipelineRendererAssetFactory( const std::string& key, PipelineRendererAssetFactory factory); bool UnregisterPipelineRendererAssetFactory(const std::string& key); +std::shared_ptr CreateDefaultPipelineRendererAsset(); std::shared_ptr CreatePipelineRendererAssetByKey( const std::string& key); bool RegisterCameraFrameStandalonePassFactory( diff --git a/engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp b/engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp index cb4b9a40..eff1863f 100644 --- a/engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp +++ b/engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp @@ -1,6 +1,7 @@ #include "Rendering/Pipelines/ScriptableRenderPipelineHost.h" #include "Rendering/Execution/DirectionalShadowExecutionState.h" +#include "Rendering/Internal/RenderPipelineFactory.h" #include "Rendering/Pipelines/BuiltinForwardPipeline.h" #include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h" #include "Rendering/Passes/BuiltinDepthOnlyPass.h" @@ -14,9 +15,7 @@ namespace Pipelines { namespace { std::shared_ptr CreateDefaultPipelineRendererAsset() { - static const std::shared_ptr s_defaultRendererAsset = - std::make_shared(); - return s_defaultRendererAsset; + return Rendering::Internal::CreateDefaultPipelineRendererAsset(); } std::unique_ptr CreatePipelineRendererFromAsset( diff --git a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp index a604b0a5..5f9281e3 100644 --- a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp +++ b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp @@ -1534,10 +1534,6 @@ private: MonoObject* assetObject) const; MonoMethod* ResolveGetRuntimeResourceVersionMethod( MonoObject* assetObject) const; - MonoMethod* ResolveGetPipelineRendererAssetKeyMethod( - MonoObject* assetObject) const; - MonoMethod* ResolveGetPipelineRendererAssetKeyContextualMethod( - MonoObject* assetObject) const; MonoMethod* ResolveUsesNativeCameraFramePlanBaselineMethod( MonoObject* assetObject) const; MonoMethod* ResolveUsesNativeCameraFramePlanBaselineContextualMethod( @@ -1559,9 +1555,6 @@ private: mutable MonoMethod* m_configureCameraFramePlanMethod = nullptr; mutable MonoMethod* m_getDefaultFinalColorSettingsMethod = nullptr; mutable MonoMethod* m_getRuntimeResourceVersionMethod = nullptr; - mutable MonoMethod* m_getPipelineRendererAssetKeyMethod = nullptr; - mutable MonoMethod* m_getPipelineRendererAssetKeyContextualMethod = - nullptr; mutable MonoMethod* m_usesNativeCameraFramePlanBaselineMethod = nullptr; mutable MonoMethod* @@ -1581,10 +1574,6 @@ private: mutable bool m_pipelineRendererAssetResolved = false; mutable std::shared_ptr m_pipelineRendererAsset = nullptr; - mutable std::unordered_map< - int32_t, - std::shared_ptr> - m_contextualPipelineRendererAssets = {}; }; class MonoManagedRenderPipelineStageRecorder final @@ -2217,92 +2206,17 @@ MonoManagedRenderPipelineAssetRuntime::GetPipelineRendererAsset( return nullptr; } - if (rendererIndex >= 0) { - const auto contextualIt = - m_contextualPipelineRendererAssets.find(rendererIndex); - if (contextualIt != m_contextualPipelineRendererAssets.end()) { - return contextualIt->second; - } - } - if (m_pipelineRendererAssetResolved) { - if (rendererIndex < 0) { - return m_pipelineRendererAsset; - } + return m_pipelineRendererAsset; } - MonoObject* const assetObject = GetManagedAssetObject(); - if (assetObject == nullptr) { + if (GetManagedAssetObject() == nullptr) { return nullptr; } - std::string pipelineRendererAssetKey = {}; - MonoMethod* const contextualMethod = - ResolveGetPipelineRendererAssetKeyContextualMethod(assetObject); - if (contextualMethod != nullptr) { - void* args[1] = { &rendererIndex }; - MonoObject* managedKeyObject = nullptr; - if (!m_runtime->InvokeManagedMethod( - assetObject, - contextualMethod, - args, - &managedKeyObject)) { - return nullptr; - } - - pipelineRendererAssetKey = - MonoStringToUtf8( - reinterpret_cast(managedKeyObject)); - } else { - if (rendererIndex >= 0) { - if (m_pipelineRendererAssetResolved) { - return m_pipelineRendererAsset; - } - } - - MonoMethod* const method = - ResolveGetPipelineRendererAssetKeyMethod(assetObject); - if (method == nullptr) { - return nullptr; - } - - MonoObject* managedKeyObject = nullptr; - if (!m_runtime->InvokeManagedMethod( - assetObject, - method, - nullptr, - &managedKeyObject)) { - return nullptr; - } - - pipelineRendererAssetKey = - MonoStringToUtf8( - reinterpret_cast(managedKeyObject)); - } - - std::shared_ptr - pipelineRendererAsset = nullptr; - if (pipelineRendererAssetKey.empty()) { - if (rendererIndex >= 0) { - m_contextualPipelineRendererAssets[rendererIndex] = nullptr; - } else { - m_pipelineRendererAssetResolved = true; - m_pipelineRendererAsset.reset(); - } - return nullptr; - } - - pipelineRendererAsset = - Rendering::Internal::CreatePipelineRendererAssetByKey( - pipelineRendererAssetKey); - if (rendererIndex >= 0) { - m_contextualPipelineRendererAssets[rendererIndex] = - pipelineRendererAsset; - return pipelineRendererAsset; - } - m_pipelineRendererAssetResolved = true; - m_pipelineRendererAsset = pipelineRendererAsset; + m_pipelineRendererAsset = + Rendering::Internal::CreateDefaultPipelineRendererAsset(); return m_pipelineRendererAsset; } @@ -2505,7 +2419,6 @@ bool MonoManagedRenderPipelineAssetRuntime::SyncManagedAssetRuntimeState() const ReleaseManagedPipeline(); m_pipelineRendererAsset.reset(); m_pipelineRendererAssetResolved = false; - m_contextualPipelineRendererAssets.clear(); m_runtimeResourceVersion = runtimeResourceVersion; return true; } @@ -2571,15 +2484,12 @@ void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedAsset() const { m_configureCameraFramePlanMethod = nullptr; m_getDefaultFinalColorSettingsMethod = nullptr; m_getRuntimeResourceVersionMethod = nullptr; - m_getPipelineRendererAssetKeyMethod = nullptr; - m_getPipelineRendererAssetKeyContextualMethod = nullptr; m_usesNativeCameraFramePlanBaselineMethod = nullptr; m_usesNativeCameraFramePlanBaselineContextualMethod = nullptr; m_configureRenderSceneSetupMethod = nullptr; m_configureDirectionalShadowExecutionStateMethod = nullptr; m_pipelineRendererAsset.reset(); m_pipelineRendererAssetResolved = false; - m_contextualPipelineRendererAssets.clear(); m_runtimeResourceVersionResolved = false; m_runtimeResourceVersion = 0; const bool ownsManagedAssetHandle = m_ownsManagedAssetHandle; @@ -2697,34 +2607,6 @@ MonoManagedRenderPipelineAssetRuntime::ResolveGetRuntimeResourceVersionMethod( return m_getRuntimeResourceVersionMethod; } -MonoMethod* -MonoManagedRenderPipelineAssetRuntime::ResolveGetPipelineRendererAssetKeyMethod( - MonoObject* assetObject) const { - if (m_getPipelineRendererAssetKeyMethod == nullptr) { - m_getPipelineRendererAssetKeyMethod = - m_runtime->ResolveManagedMethod( - assetObject, - "GetPipelineRendererAssetKey", - 0); - } - - return m_getPipelineRendererAssetKeyMethod; -} - -MonoMethod* -MonoManagedRenderPipelineAssetRuntime::ResolveGetPipelineRendererAssetKeyContextualMethod( - MonoObject* assetObject) const { - if (m_getPipelineRendererAssetKeyContextualMethod == nullptr) { - m_getPipelineRendererAssetKeyContextualMethod = - m_runtime->ResolveManagedMethod( - assetObject, - "GetPipelineRendererAssetKeyContextual", - 1); - } - - return m_getPipelineRendererAssetKeyContextualMethod; -} - MonoMethod* MonoManagedRenderPipelineAssetRuntime:: ResolveUsesNativeCameraFramePlanBaselineMethod( diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererBackedRenderPipelineAsset.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererBackedRenderPipelineAsset.cs index 030c3b1f..e041e365 100644 --- a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererBackedRenderPipelineAsset.cs +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererBackedRenderPipelineAsset.cs @@ -93,23 +93,6 @@ namespace XCEngine.Rendering.Universal context); } - private protected string GetPipelineRendererAssetKey() - { - return GetPipelineRendererAssetKeyContextual( - -1); - } - - private protected string GetPipelineRendererAssetKeyContextual( - int rendererIndex) - { - ScriptableRendererData resolvedRendererData = - GetRendererData(rendererIndex); - return resolvedRendererData != null - ? resolvedRendererData - .GetPipelineRendererAssetKeyInstance() - : string.Empty; - } - protected override void ReleaseRuntimeResources() { ReleaseRendererDataRuntimeResources(); diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRendererData.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRendererData.cs index 7cf6e99d..5e90774f 100644 --- a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRendererData.cs +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRendererData.cs @@ -59,11 +59,6 @@ namespace XCEngine.Rendering.Universal SetDirty(); } - internal string GetPipelineRendererAssetKeyInstance() - { - return GetPipelineRendererAssetKey(); - } - internal int GetRuntimeStateVersionInstance() { return m_runtimeStateVersion; @@ -236,11 +231,6 @@ namespace XCEngine.Rendering.Universal { } - private protected virtual string GetPipelineRendererAssetKey() - { - return string.Empty; - } - protected virtual ScriptableRendererFeature[] CreateRendererFeatures() { return rendererFeatures ?? diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRendererData.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRendererData.cs index d554a1be..48381a08 100644 --- a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRendererData.cs +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRendererData.cs @@ -33,11 +33,6 @@ namespace XCEngine.Rendering.Universal }; } - private protected override string GetPipelineRendererAssetKey() - { - return "BuiltinForward"; - } - internal UniversalMainSceneData GetMainSceneInstance() { if (mainScene == null)