diff --git a/docs/used/SRP_ManagedCameraFramePolicyKeyRemovalPlan_完成归档_2026-04-21.md b/docs/used/SRP_ManagedCameraFramePolicyKeyRemovalPlan_完成归档_2026-04-21.md new file mode 100644 index 00000000..0d34d142 --- /dev/null +++ b/docs/used/SRP_ManagedCameraFramePolicyKeyRemovalPlan_完成归档_2026-04-21.md @@ -0,0 +1,55 @@ +# SRP Managed Camera Frame Policy Key Removal Plan 2026-04-21 + +## Goal + +Remove the now-redundant managed camera-frame plan policy-key bridge from the generic SRP asset path so managed pipelines only integrate with native planning through explicit capability signals and direct managed frame planning hooks. + +## Why This Stage + +The previous stage already changed renderer-backed managed pipelines to request native camera-frame baseline through `UsesNativeCameraFramePlanBaseline*`. After that change, the old `GetCameraFramePlanPolicyAssetKey*` path became dead architectural baggage: + +1. managed `ScriptableRenderPipelineAsset` still exposes a string-based camera-frame plan policy hook; +2. native Mono runtime still resolves and calls that hook; +3. native managed asset host still keeps a fallback branch for it; +4. current managed URP no longer overrides or needs it. + +Keeping that bridge in the core SRP asset surface weakens ownership boundaries and encourages native policy selection to leak back into managed URP authoring. + +## Scope + +Included: + +1. remove camera-frame policy-key methods from managed `ScriptableRenderPipelineAsset`; +2. remove the corresponding runtime virtuals and Mono bridge resolution/invocation code; +3. simplify `ManagedScriptableRenderPipelineAsset::ConfigureCameraFramePlan` so it only does native baseline application when explicitly requested, then hands control to managed planning; +4. rebuild `XCEditor` and run old editor smoke. + +Not included: + +1. deleting native camera-frame policy-key support used by non-managed pipelines; +2. changing standalone pass / render-scene / shadow policy-key surfaces; +3. SRP renderer selection redesign; +4. deferred renderer work. + +## Acceptance + +This stage is complete when: + +1. generic managed SRP asset API no longer exposes `GetCameraFramePlanPolicyAssetKey*`; +2. native managed runtime bridge no longer resolves or invokes camera-frame policy-key methods; +3. managed camera-frame planning host path only keeps native baseline capability plus managed `ConfigureCameraFramePlan(...)`; +4. `XCEditor` builds successfully; +5. old editor smoke passes and `editor.log` contains a fresh `SceneReady`. + +## Validation + +Validated on 2026-04-21: + +1. built old editor target with `cmake --build . --config Debug --target XCEditor` from `build/`; +2. launched `editor/bin/Debug/XCEngine.exe`; +3. let it run for about 12 seconds; +4. verified a fresh `SceneReady` entry in `editor/bin/Debug/editor.log`. + +Observed log line: + +`[2026-04-21 13:54:49] [INFO] [General] [SceneLoadTrace] SceneReady elapsed_ms=5610 first_frame_ms=607 peak_pending_async=9` diff --git a/engine/include/XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h b/engine/include/XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h index 1917aaad..fcc10543 100644 --- a/engine/include/XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h +++ b/engine/include/XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h @@ -96,14 +96,6 @@ public: (void)rendererIndex; return GetPipelineRendererAsset(); } - virtual std::string GetCameraFramePlanPolicyAssetKey() const { - return {}; - } - virtual std::string GetCameraFramePlanPolicyAssetKey( - int32_t rendererIndex) const { - (void)rendererIndex; - return GetCameraFramePlanPolicyAssetKey(); - } virtual bool UsesNativeCameraFramePlanBaseline() const { return false; } diff --git a/engine/src/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.cpp b/engine/src/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.cpp index 5ae756f9..033814c0 100644 --- a/engine/src/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.cpp +++ b/engine/src/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.cpp @@ -41,32 +41,6 @@ void ApplyManagedDirectionalShadowPlanningPolicyOrDefault( } } -void ApplyManagedCameraFramePlanPolicyOrDefault( - const std::string& assetKey, - CameraFramePlan& plan, - const FinalColorSettings& defaultFinalColorSettings) { - if (assetKey.empty()) { - ApplyDefaultRenderPipelineAssetCameraFramePlanPolicy( - plan, - defaultFinalColorSettings); - return; - } - - if (!Rendering::Internal::ApplyCameraFramePlanPolicyByKey( - assetKey, - plan, - defaultFinalColorSettings)) { - Debug::Logger::Get().Error( - Debug::LogCategory::Rendering, - Containers::String( - "ManagedScriptableRenderPipelineAsset failed to resolve camera frame plan policy asset key: ") + - assetKey.c_str()); - ApplyDefaultRenderPipelineAssetCameraFramePlanPolicy( - plan, - defaultFinalColorSettings); - } -} - } // namespace ManagedScriptableRenderPipelineAsset::ManagedScriptableRenderPipelineAsset( @@ -179,19 +153,11 @@ void ManagedScriptableRenderPipelineAsset::ConfigureCameraFramePlan( if (const std::shared_ptr runtime = ResolveManagedAssetRuntime(); runtime != nullptr) { - const FinalColorSettings defaultFinalColorSettings = - GetDefaultFinalColorSettings(); if (runtime->UsesNativeCameraFramePlanBaseline( plan.request.rendererIndex)) { ApplyDefaultRenderPipelineAssetCameraFramePlanBaselinePolicy( plan, - defaultFinalColorSettings); - } else { - ApplyManagedCameraFramePlanPolicyOrDefault( - runtime->GetCameraFramePlanPolicyAssetKey( - plan.request.rendererIndex), - plan, - defaultFinalColorSettings); + GetDefaultFinalColorSettings()); } runtime->ConfigureCameraFramePlan(plan); return; diff --git a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp index 476ea594..cb5fba4c 100644 --- a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp +++ b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp @@ -1366,10 +1366,6 @@ public: GetPipelineRendererAsset() const override; std::shared_ptr GetPipelineRendererAsset(int32_t rendererIndex) const override; - std::string GetCameraFramePlanPolicyAssetKey() const - override; - std::string GetCameraFramePlanPolicyAssetKey( - int32_t rendererIndex) const override; bool UsesNativeCameraFramePlanBaseline() const override; bool UsesNativeCameraFramePlanBaseline( int32_t rendererIndex) const override; @@ -1422,10 +1418,6 @@ private: MonoObject* assetObject) const; MonoMethod* ResolveGetPipelineRendererAssetKeyContextualMethod( MonoObject* assetObject) const; - MonoMethod* ResolveGetCameraFramePlanPolicyAssetKeyMethod( - MonoObject* assetObject) const; - MonoMethod* ResolveGetCameraFramePlanPolicyAssetKeyContextualMethod( - MonoObject* assetObject) const; MonoMethod* ResolveUsesNativeCameraFramePlanBaselineMethod( MonoObject* assetObject) const; MonoMethod* ResolveUsesNativeCameraFramePlanBaselineContextualMethod( @@ -1462,11 +1454,6 @@ private: mutable MonoMethod* m_getPipelineRendererAssetKeyMethod = nullptr; mutable MonoMethod* m_getPipelineRendererAssetKeyContextualMethod = nullptr; - mutable MonoMethod* m_getCameraFramePlanPolicyAssetKeyMethod = - nullptr; - mutable MonoMethod* - m_getCameraFramePlanPolicyAssetKeyContextualMethod = - nullptr; mutable MonoMethod* m_usesNativeCameraFramePlanBaselineMethod = nullptr; mutable MonoMethod* @@ -2135,61 +2122,6 @@ MonoManagedRenderPipelineAssetRuntime::GetPipelineRendererAsset( return m_pipelineRendererAsset; } -std::string MonoManagedRenderPipelineAssetRuntime:: - GetCameraFramePlanPolicyAssetKey() const { - return GetCameraFramePlanPolicyAssetKey(-1); -} - -std::string MonoManagedRenderPipelineAssetRuntime:: - GetCameraFramePlanPolicyAssetKey( - int32_t rendererIndex) const { - if (!SyncManagedAssetRuntimeState()) { - return {}; - } - - MonoObject* const assetObject = GetManagedAssetObject(); - if (assetObject == nullptr) { - return {}; - } - - MonoMethod* const contextualMethod = - ResolveGetCameraFramePlanPolicyAssetKeyContextualMethod( - assetObject); - if (contextualMethod != nullptr) { - void* args[1] = { &rendererIndex }; - MonoObject* managedKeyObject = nullptr; - if (!m_runtime->InvokeManagedMethod( - assetObject, - contextualMethod, - args, - &managedKeyObject)) { - return {}; - } - - return MonoStringToUtf8( - reinterpret_cast(managedKeyObject)); - } - - MonoMethod* const method = - ResolveGetCameraFramePlanPolicyAssetKeyMethod( - assetObject); - if (method == nullptr) { - return {}; - } - - MonoObject* managedKeyObject = nullptr; - if (!m_runtime->InvokeManagedMethod( - assetObject, - method, - nullptr, - &managedKeyObject)) { - return {}; - } - - return MonoStringToUtf8( - reinterpret_cast(managedKeyObject)); -} - bool MonoManagedRenderPipelineAssetRuntime::UsesNativeCameraFramePlanBaseline() const { return UsesNativeCameraFramePlanBaseline(-1); @@ -2664,8 +2596,6 @@ void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedAsset() const { m_getRuntimeResourceVersionMethod = nullptr; m_getPipelineRendererAssetKeyMethod = nullptr; m_getPipelineRendererAssetKeyContextualMethod = nullptr; - m_getCameraFramePlanPolicyAssetKeyMethod = nullptr; - m_getCameraFramePlanPolicyAssetKeyContextualMethod = nullptr; m_usesNativeCameraFramePlanBaselineMethod = nullptr; m_usesNativeCameraFramePlanBaselineContextualMethod = nullptr; m_getRenderSceneSetupPolicyAssetKeyMethod = nullptr; @@ -2824,37 +2754,6 @@ MonoManagedRenderPipelineAssetRuntime::ResolveGetPipelineRendererAssetKeyContext return m_getPipelineRendererAssetKeyContextualMethod; } -MonoMethod* -MonoManagedRenderPipelineAssetRuntime:: - ResolveGetCameraFramePlanPolicyAssetKeyMethod( - MonoObject* assetObject) const { - if (m_getCameraFramePlanPolicyAssetKeyMethod == nullptr) { - m_getCameraFramePlanPolicyAssetKeyMethod = - m_runtime->ResolveManagedMethod( - assetObject, - "GetCameraFramePlanPolicyAssetKey", - 0); - } - - return m_getCameraFramePlanPolicyAssetKeyMethod; -} - -MonoMethod* -MonoManagedRenderPipelineAssetRuntime:: - ResolveGetCameraFramePlanPolicyAssetKeyContextualMethod( - MonoObject* assetObject) const { - if (m_getCameraFramePlanPolicyAssetKeyContextualMethod == - nullptr) { - m_getCameraFramePlanPolicyAssetKeyContextualMethod = - m_runtime->ResolveManagedMethod( - assetObject, - "GetCameraFramePlanPolicyAssetKeyContextual", - 1); - } - - return m_getCameraFramePlanPolicyAssetKeyContextualMethod; -} - MonoMethod* MonoManagedRenderPipelineAssetRuntime:: ResolveUsesNativeCameraFramePlanBaselineMethod( diff --git a/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs index 08439fd8..44f909e6 100644 --- a/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs +++ b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs @@ -58,17 +58,6 @@ namespace XCEngine.Rendering return GetPipelineRendererAssetKey(); } - protected virtual string GetCameraFramePlanPolicyAssetKey() - { - return string.Empty; - } - - protected virtual string GetCameraFramePlanPolicyAssetKeyContextual( - int rendererIndex) - { - return GetCameraFramePlanPolicyAssetKey(); - } - protected virtual bool UsesNativeCameraFramePlanBaseline() { return false;