xuanchi/XCEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(srp): remove managed backend key binding detour

Browse Source
This commit is contained in:
ssdfasd
2026-04-21 18:46:43 +08:00
parent ed738475fe
commit 01b5e0abcd
8 changed files with 76 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
docs/used/SRP_URP_DefaultNativeRendererBindingPlan_完成归档_2026-04-21.md Normal file
View File

@@ -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`.

6
engine/src/Rendering/Internal/RenderPipelineFactory.cpp
View File

@@ -261,6 +261,12 @@ bool UnregisterPipelineRendererAssetFactory(const std::string& key) {
return registry.erase(key) != 0u;
}
std::shared_ptr<const RenderPipelineAsset> CreateDefaultPipelineRendererAsset() {
static const std::shared_ptr<const RenderPipelineAsset> s_defaultAsset =
CreateBuiltinForwardPipelineRendererAsset();
return s_defaultAsset;
}
std::shared_ptr<const RenderPipelineAsset> CreatePipelineRendererAssetByKey(
const std::string& key) {
if (key.empty()) {

1
engine/src/Rendering/Internal/RenderPipelineFactory.h
View File

@@ -38,6 +38,7 @@ bool RegisterPipelineRendererAssetFactory(
const std::string& key,
PipelineRendererAssetFactory factory);
bool UnregisterPipelineRendererAssetFactory(const std::string& key);
std::shared_ptr<const RenderPipelineAsset> CreateDefaultPipelineRendererAsset();
std::shared_ptr<const RenderPipelineAsset> CreatePipelineRendererAssetByKey(
const std::string& key);
bool RegisterCameraFrameStandalonePassFactory(

5
engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp
View File

@@ -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<const RenderPipelineAsset> CreateDefaultPipelineRendererAsset() {
static const std::shared_ptr<const RenderPipelineAsset> s_defaultRendererAsset =
std::make_shared<BuiltinForwardPipelineAsset>();
return s_defaultRendererAsset;
return Rendering::Internal::CreateDefaultPipelineRendererAsset();
}
std::unique_ptr<RenderPipelineRenderer> CreatePipelineRendererFromAsset(

126
engine/src/Scripting/Mono/MonoScriptRuntime.cpp
View File

@@ -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<const Rendering::RenderPipelineAsset>
m_pipelineRendererAsset = nullptr;
mutable std::unordered_map<
int32_t,
std::shared_ptr<const Rendering::RenderPipelineAsset>>
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<MonoString*>(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<MonoString*>(managedKeyObject));
}
std::shared_ptr<const Rendering::RenderPipelineAsset>
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(

17
managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererBackedRenderPipelineAsset.cs
View File

@@ -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();

10
managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRendererData.cs
View File

@@ -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 ??

5
managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRendererData.cs
View File

@@ -33,11 +33,6 @@ namespace XCEngine.Rendering.Universal
};
}
private protected override string GetPipelineRendererAssetKey()
{
return "BuiltinForward";
}
internal UniversalMainSceneData GetMainSceneInstance()
{
if (mainScene == null)