From 5bec70dcc52ec92fa2457ed38764d751b49d9482 Mon Sep 17 00:00:00 2001 From: ssdfasd <2156608475@qq.com> Date: Tue, 21 Apr 2026 12:59:52 +0800 Subject: [PATCH] refactor(srp): move urp final color execution into managed feature --- ...anagedOwnershipPlan_完成归档_2026-04-21.md | 57 ++++++++++ .../Rendering/Planning/FullscreenPassDesc.h | 19 +++- .../Planning/FullscreenPassFactory.h | 4 + .../src/Scripting/Mono/MonoScriptRuntime.cpp | 107 ++++++++++++++++-- managed/CMakeLists.txt | 1 + .../ScriptableRenderContextApiSurfaceProbe.cs | 5 + .../BuiltinFinalColorRendererFeature.cs | 107 ++++++++++++++++++ .../Universal/ScriptableRenderPass.cs | 50 ++++++++ .../Universal/UniversalRendererData.cs | 3 +- managed/XCEngine.ScriptCore/InternalCalls.cs | 12 ++ ...ScriptableRenderPipelinePlanningContext.cs | 7 ++ .../Graph/RenderGraphRasterPassBuilder.cs | 26 ++++- 12 files changed, 385 insertions(+), 13 deletions(-) create mode 100644 docs/used/SRP_UniversalFinalColorExecutionManagedOwnershipPlan_完成归档_2026-04-21.md create mode 100644 managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/BuiltinFinalColorRendererFeature.cs diff --git a/docs/used/SRP_UniversalFinalColorExecutionManagedOwnershipPlan_完成归档_2026-04-21.md b/docs/used/SRP_UniversalFinalColorExecutionManagedOwnershipPlan_完成归档_2026-04-21.md new file mode 100644 index 00000000..dedc8954 --- /dev/null +++ b/docs/used/SRP_UniversalFinalColorExecutionManagedOwnershipPlan_完成归档_2026-04-21.md @@ -0,0 +1,57 @@ +# SRP Universal Final Color Execution Managed Ownership Plan 2026-04-21 + +## Goal + +Move first-party final-color final-output execution from native fullscreen pass-sequence construction into managed URP renderer-feature ownership. + +## Why This Stage + +Current state already moved several SRP ownership seams into managed URP: + +1. renderer selection; +2. shadow planning and execution policy selection; +3. render-scene setup policy selection; +4. camera-frame plan policy selection; +5. URP asset-owned final-color default settings. + +But the actual first-party final-color pass is still a native builtin sequence created by the default camera-frame plan policy. + +That means URP still does not own its own final-output pass authoring surface, even though managed render-graph fullscreen recording already exists. + +## Scope + +Included: + +1. add a managed raster-pass execution primitive for final-color fullscreen passes; +2. expose planning-context visibility for whether resolved final color requires processing; +3. add a builtin URP final-color renderer feature and pass; +4. make managed URP explicitly claim the `FinalOutput` stage for final-color processing; +5. rebuild `XCEditor` and run old editor smoke. + +Not included: + +1. deleting native final-color pass implementation; +2. moving raw final-color policy resolution out of native camera-frame planning; +3. custom editor UI for URP final-color authoring; +4. deferred renderer work. + +## Acceptance + +This stage is complete when: + +1. managed URP can record a final-color fullscreen pass through the render-graph builder; +2. builtin URP provides a first-party final-color renderer feature; +3. final-color driven `FinalOutput` stage ownership no longer depends on native fullscreen sequence execution for managed URP; +4. `XCEditor` build and old editor smoke both pass. + +## 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` for about 12 seconds; +3. verified fresh `editor/bin/Debug/editor.log` contains `SceneReady`. + +Observed log line: + +`[2026-04-21 12:58:06] [INFO] [General] [SceneLoadTrace] SceneReady elapsed_ms=4891 first_frame_ms=537 peak_pending_async=9` diff --git a/engine/include/XCEngine/Rendering/Planning/FullscreenPassDesc.h b/engine/include/XCEngine/Rendering/Planning/FullscreenPassDesc.h index 8acb4206..5409cf23 100644 --- a/engine/include/XCEngine/Rendering/Planning/FullscreenPassDesc.h +++ b/engine/include/XCEngine/Rendering/Planning/FullscreenPassDesc.h @@ -2,6 +2,7 @@ #include #include +#include #include #include @@ -11,7 +12,8 @@ namespace Rendering { enum class FullscreenPassType : uint8_t { ColorScale = 0, - ShaderVector = 1 + ShaderVector = 1, + FinalColor = 2 }; struct FullscreenColorScaleDesc { @@ -28,10 +30,15 @@ struct FullscreenShaderVectorDesc { } }; +struct FullscreenFinalColorDesc { + FinalColorSettings settings = {}; +}; + struct FullscreenPassDesc { FullscreenPassType type = FullscreenPassType::ColorScale; FullscreenColorScaleDesc colorScale = {}; FullscreenShaderVectorDesc shaderVector = {}; + FullscreenFinalColorDesc finalColor = {}; static FullscreenPassDesc MakeColorScale(const Math::Vector4& scale) { FullscreenPassDesc desc = {}; @@ -52,12 +59,22 @@ struct FullscreenPassDesc { return desc; } + static FullscreenPassDesc MakeFinalColor( + const FinalColorSettings& settings) { + FullscreenPassDesc desc = {}; + desc.type = FullscreenPassType::FinalColor; + desc.finalColor.settings = settings; + return desc; + } + bool IsValid() const { switch (type) { case FullscreenPassType::ColorScale: return true; case FullscreenPassType::ShaderVector: return shaderVector.IsValid(); + case FullscreenPassType::FinalColor: + return finalColor.settings.RequiresProcessing(); default: return false; } diff --git a/engine/include/XCEngine/Rendering/Planning/FullscreenPassFactory.h b/engine/include/XCEngine/Rendering/Planning/FullscreenPassFactory.h index 8689b91f..5997ec28 100644 --- a/engine/include/XCEngine/Rendering/Planning/FullscreenPassFactory.h +++ b/engine/include/XCEngine/Rendering/Planning/FullscreenPassFactory.h @@ -35,6 +35,10 @@ inline std::unique_ptr BuildFullscreenPassSequence( passDesc.shaderVector.shaderPath, passDesc.shaderVector.passName)); break; + case FullscreenPassType::FinalColor: + sequence->AddPass(std::make_unique( + passDesc.finalColor.settings)); + break; default: break; } diff --git a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp index f3bd9e7e..fc220985 100644 --- a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp +++ b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp @@ -17,6 +17,7 @@ #include "Rendering/Graph/RenderGraphRecordingContext.h" #include "Rendering/GraphicsSettingsState.h" #include "Rendering/Internal/RenderPipelineFactory.h" +#include "Rendering/Passes/BuiltinFinalColorPass.h" #include "Rendering/Passes/BuiltinVectorFullscreenPass.h" #include "Rendering/Planning/FullscreenPassDesc.h" #include "Rendering/Planning/SceneRenderRequestPlanner.h" @@ -1238,6 +1239,25 @@ bool TryUnboxManagedFinalColorSettings( return true; } +Rendering::FinalColorSettings BuildManagedFinalColorSettings( + const ManagedFinalColorSettingsData& managedSettings) { + Rendering::FinalColorSettings settings = {}; + settings.exposureValue = 1.0f; + settings.finalColorScale = XCEngine::Math::Vector4::One(); + settings.outputTransferMode = + ResolveManagedFinalColorOutputTransferMode( + managedSettings.outputTransferMode); + settings.exposureMode = + ResolveManagedFinalColorExposureMode( + managedSettings.exposureMode); + settings.exposureValue = managedSettings.exposureValue; + settings.toneMappingMode = + ResolveManagedFinalColorToneMappingMode( + managedSettings.toneMappingMode); + settings.finalColorScale = managedSettings.finalColorScale; + return settings; +} + bool SupportsManagedRenderPipelineStageGraphRecording( Rendering::CameraFrameStage stage) { return Rendering::SupportsCameraFramePipelineGraphRecording(stage) || @@ -1253,19 +1273,19 @@ Rendering::RenderPass* ConfigureManagedFullscreenPass( } std::unique_ptr& passSlot = passPool[passIndex]; - Rendering::Passes::BuiltinVectorFullscreenPass* fullscreenPass = - dynamic_cast( - passSlot.get()); - if (fullscreenPass == nullptr) { - passSlot = - std::make_unique(); - fullscreenPass = - static_cast( - passSlot.get()); - } switch (passDesc.type) { case Rendering::FullscreenPassType::ColorScale: { + Rendering::Passes::BuiltinVectorFullscreenPass* fullscreenPass = + dynamic_cast( + passSlot.get()); + if (fullscreenPass == nullptr) { + passSlot = + std::make_unique(); + fullscreenPass = + static_cast( + passSlot.get()); + } fullscreenPass->SetShaderPath( Resources::GetBuiltinColorScalePostProcessShaderPath()); fullscreenPass->SetPreferredPassName("ColorScale"); @@ -1273,11 +1293,38 @@ Rendering::RenderPass* ConfigureManagedFullscreenPass( return fullscreenPass; } case Rendering::FullscreenPassType::ShaderVector: { + Rendering::Passes::BuiltinVectorFullscreenPass* fullscreenPass = + dynamic_cast( + passSlot.get()); + if (fullscreenPass == nullptr) { + passSlot = + std::make_unique(); + fullscreenPass = + static_cast( + passSlot.get()); + } fullscreenPass->SetShaderPath(passDesc.shaderVector.shaderPath); fullscreenPass->SetPreferredPassName(passDesc.shaderVector.passName); fullscreenPass->SetVectorPayload(passDesc.shaderVector.vectorPayload); return fullscreenPass; } + case Rendering::FullscreenPassType::FinalColor: { + Rendering::Passes::BuiltinFinalColorPass* finalColorPass = + dynamic_cast( + passSlot.get()); + if (finalColorPass == nullptr) { + passSlot = + std::make_unique(); + finalColorPass = + static_cast( + passSlot.get()); + } + + finalColorPass->SetShaderPath( + Resources::GetBuiltinFinalColorShaderPath()); + finalColorPass->SetSettings(passDesc.finalColor.settings); + return finalColorPass; + } default: return nullptr; } @@ -4909,6 +4956,32 @@ InternalCall_Rendering_ScriptableRenderContext_SetRasterPassShaderVectorFullscre : 0; } +mono_bool +InternalCall_Rendering_ScriptableRenderContext_SetRasterPassFinalColorFullscreenExecution( + uint64_t nativeHandle, + uint64_t rasterPassHandle, + ManagedFinalColorSettingsData* settingsData) { + ManagedScriptableRenderContextState* const state = + FindManagedScriptableRenderContextState(nativeHandle); + ManagedScriptableRenderContextState::RasterPassRecordRequest* + const request = + FindPendingManagedRasterPassRecordRequest( + state, + rasterPassHandle); + if (request == nullptr || + settingsData == nullptr) { + return 0; + } + + request->passDesc = + Rendering::FullscreenPassDesc::MakeFinalColor( + BuildManagedFinalColorSettings( + *settingsData)); + return request->passDesc.IsValid() + ? 1 + : 0; +} + mono_bool InternalCall_Rendering_ScriptableRenderContext_CommitRasterPass( uint64_t nativeHandle, uint64_t rasterPassHandle) { @@ -5805,6 +5878,18 @@ void InternalCall_Rendering_ScriptableRenderPipelinePlanningContext_ClearFullscr state->plan->ClearFullscreenStage(resolvedStage, true); } +mono_bool +InternalCall_Rendering_ScriptableRenderPipelinePlanningContext_GetHasFinalColorProcessing( + uint64_t nativeHandle) { + const ManagedScriptableRenderPipelinePlanningContextState* const state = + FindManagedScriptableRenderPipelinePlanningContextState(nativeHandle); + return state != nullptr && + state->plan != nullptr && + state->plan->finalColorPolicy.RequiresProcessing() + ? 1 + : 0; +} + void RegisterInternalCalls() { if (GetInternalCallRegistrationState()) { return; @@ -5947,6 +6032,7 @@ void RegisterInternalCalls() { mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_SetRasterPassColorAttachment", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderContext_SetRasterPassColorAttachment)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_SetRasterPassColorScaleFullscreenExecution", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderContext_SetRasterPassColorScaleFullscreenExecution)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_SetRasterPassShaderVectorFullscreenExecution", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderContext_SetRasterPassShaderVectorFullscreenExecution)); + mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_SetRasterPassFinalColorFullscreenExecution", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderContext_SetRasterPassFinalColorFullscreenExecution)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_CommitRasterPass", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderContext_CommitRasterPass)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetStageColorSource", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderContext_GetStageColorSource)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetStageUsesGraphManagedOutputColor", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderContext_GetStageUsesGraphManagedOutputColor)); @@ -6008,6 +6094,7 @@ void RegisterInternalCalls() { mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderPipelinePlanningContext_GetStageUsesGraphManagedOutputColor", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderPipelinePlanningContext_GetStageUsesGraphManagedOutputColor)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderPipelinePlanningContext_RequestFullscreenStage", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderPipelinePlanningContext_RequestFullscreenStage)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderPipelinePlanningContext_ClearFullscreenStage", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderPipelinePlanningContext_ClearFullscreenStage)); + mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderPipelinePlanningContext_GetHasFinalColorProcessing", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderPipelinePlanningContext_GetHasFinalColorProcessing)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_GetRenderedBaseCameraCount", reinterpret_cast(&InternalCall_Rendering_CameraRenderRequestContext_GetRenderedBaseCameraCount)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_GetRenderedRequestCount", reinterpret_cast(&InternalCall_Rendering_CameraRenderRequestContext_GetRenderedRequestCount)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_GetCameraGameObjectUUID", reinterpret_cast(&InternalCall_Rendering_CameraRenderRequestContext_GetCameraGameObjectUUID)); diff --git a/managed/CMakeLists.txt b/managed/CMakeLists.txt index e23aca75..41e7fd91 100644 --- a/managed/CMakeLists.txt +++ b/managed/CMakeLists.txt @@ -210,6 +210,7 @@ set(XCENGINE_RENDER_PIPELINES_UNIVERSAL_SOURCES # Universal renderer package ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/CameraData.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/ColorScalePostProcessRendererFeature.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/BuiltinFinalColorRendererFeature.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/BuiltinGaussianSplatRendererFeature.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/BuiltinVolumetricRendererFeature.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/DirectionalLightData.cs diff --git a/managed/GameScripts/ScriptableRenderContextApiSurfaceProbe.cs b/managed/GameScripts/ScriptableRenderContextApiSurfaceProbe.cs index d5953256..a228c848 100644 --- a/managed/GameScripts/ScriptableRenderContextApiSurfaceProbe.cs +++ b/managed/GameScripts/ScriptableRenderContextApiSurfaceProbe.cs @@ -64,6 +64,7 @@ namespace Gameplay public bool HasRenderGraphRasterPassBuilderUseTexture; public bool HasRenderGraphRasterPassBuilderSetColorAttachment; public bool HasRenderGraphRasterPassBuilderSetColorScaleFullscreenExecution; + public bool HasRenderGraphRasterPassBuilderSetFinalColorFullscreenExecution; public bool HasRenderGraphRasterPassBuilderCommit; public bool HasSceneRenderPhaseType; public bool HasSceneRenderInjectionPointType; @@ -366,6 +367,10 @@ namespace Gameplay rasterPassBuilderType.GetMethod( "SetColorScaleFullscreenExecution", PublicInstanceMethodFlags) != null; + HasRenderGraphRasterPassBuilderSetFinalColorFullscreenExecution = + rasterPassBuilderType.GetMethod( + "SetFinalColorFullscreenExecution", + PublicInstanceMethodFlags) != null; HasRenderGraphRasterPassBuilderCommit = rasterPassBuilderType.GetMethod( "Commit", diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/BuiltinFinalColorRendererFeature.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/BuiltinFinalColorRendererFeature.cs new file mode 100644 index 00000000..0d55992f --- /dev/null +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/BuiltinFinalColorRendererFeature.cs @@ -0,0 +1,107 @@ +using XCEngine; +using XCEngine.Rendering; + +namespace XCEngine.Rendering.Universal +{ + internal sealed class BuiltinFinalColorPass + : ScriptableRenderPass + { + public BuiltinFinalColorPass() + { + renderPassEvent = + RenderPassEvent.BeforeRenderingFinalOutput; + } + + protected override bool RecordRenderGraph( + ScriptableRenderContext context, + RenderingData renderingData) + { + return context != null && + renderingData != null && + renderingData.isFinalOutputStage && + (!renderingData.finalColorData.requiresProcessing || + RecordFinalColorFullscreenPass( + context, + renderingData.finalColorData.settings, + "Universal.BuiltinFinalColor")); + } + } + + public sealed class BuiltinFinalColorRendererFeature + : ScriptableRendererFeature + { + private BuiltinFinalColorPass m_pass; + + public override void Create() + { + m_pass = new BuiltinFinalColorPass(); + } + + public override void ConfigureCameraFramePlan( + ScriptableRenderPipelinePlanningContext context) + { + if (context == null || + !context.HasFinalColorProcessing()) + { + return; + } + + CameraFrameColorSource finalOutputSource = + CameraFrameColorSource.MainSceneColor; + if (context.IsStageRequested( + CameraFrameStage.PostProcess)) + { + CameraFrameColorSource postProcessSource = + context.GetStageColorSource( + CameraFrameStage.PostProcess); + if (postProcessSource != + CameraFrameColorSource.ExplicitSurface) + { + if (!context.UsesGraphManagedOutputColor( + CameraFrameStage.PostProcess)) + { + context.ClearFullscreenStage( + CameraFrameStage.PostProcess); + context.RequestFullscreenStage( + CameraFrameStage.PostProcess, + postProcessSource, + true); + } + + finalOutputSource = + CameraFrameColorSource.PostProcessColor; + } + } + + context.ClearFullscreenStage( + CameraFrameStage.FinalOutput); + context.RequestFullscreenStage( + CameraFrameStage.FinalOutput, + finalOutputSource); + } + + public override void AddRenderPasses( + ScriptableRenderer renderer, + RenderingData renderingData) + { + if (renderer == null || + renderingData == null) + { + return; + } + + if (!renderingData.isFinalOutputStage && + !renderingData.finalColorData.requiresProcessing) + { + return; + } + + if (m_pass == null) + { + CreateInstance(); + } + + renderer.EnqueuePass(m_pass); + } + } +} diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRenderPass.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRenderPass.cs index 9d49e79d..6f857f04 100644 --- a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRenderPass.cs +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRenderPass.cs @@ -8,6 +8,8 @@ namespace XCEngine.Rendering.Universal { private const string kColorScaleFullscreenPassName = "Universal.ColorScaleFullscreen"; + private const string kFinalColorFullscreenPassName = + "Universal.FinalColorFullscreen"; private const string kShaderVectorFullscreenPassName = "Universal.ShaderVectorFullscreen"; @@ -156,6 +158,54 @@ namespace XCEngine.Rendering.Universal .Commit(); } + protected bool RecordFinalColorFullscreenPass( + ScriptableRenderContext context, + FinalColorSettings settings, + string passName = null) + { + RenderGraphTextureHandle sourceColor; + RenderGraphTextureHandle outputColor; + return TryResolveDefaultFullscreenTargets( + context, + out sourceColor, + out outputColor) && + RecordFinalColorFullscreenPass( + context, + sourceColor, + outputColor, + settings, + passName); + } + + protected bool RecordFinalColorFullscreenPass( + ScriptableRenderContext context, + RenderGraphTextureHandle sourceColor, + RenderGraphTextureHandle outputColor, + FinalColorSettings settings, + string passName = null) + { + if (context == null || + !outputColor.isValid) + { + return false; + } + + RenderGraphRasterPassBuilder passBuilder = + context.AddRasterPass( + ResolveFullscreenPassName( + passName, + kFinalColorFullscreenPassName)); + if (sourceColor.isValid) + { + passBuilder.UseColorSource(sourceColor); + } + + return passBuilder + .SetColorAttachment(outputColor) + .SetFinalColorFullscreenExecution(settings) + .Commit(); + } + internal static bool TryResolveStage( RenderPassEvent passEvent, out CameraFrameStage stage) diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRendererData.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRendererData.cs index c3e77d88..be090a42 100644 --- a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRendererData.cs +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRendererData.cs @@ -79,7 +79,8 @@ namespace XCEngine.Rendering.Universal return new ScriptableRendererFeature[] { new BuiltinGaussianSplatRendererFeature(), - new BuiltinVolumetricRendererFeature() + new BuiltinVolumetricRendererFeature(), + new BuiltinFinalColorRendererFeature() }; } } diff --git a/managed/XCEngine.ScriptCore/InternalCalls.cs b/managed/XCEngine.ScriptCore/InternalCalls.cs index a1ec2f5a..1a03ce09 100644 --- a/managed/XCEngine.ScriptCore/InternalCalls.cs +++ b/managed/XCEngine.ScriptCore/InternalCalls.cs @@ -472,6 +472,13 @@ namespace XCEngine string shaderPassName, ref Vector4 vectorPayload); + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern bool + Rendering_ScriptableRenderContext_SetRasterPassFinalColorFullscreenExecution( + ulong nativeHandle, + ulong rasterPassHandle, + ref Rendering.FinalColorSettings settings); + [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool Rendering_ScriptableRenderContext_CommitRasterPass( @@ -515,6 +522,11 @@ namespace XCEngine ulong nativeHandle, int stage); + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern bool + Rendering_ScriptableRenderPipelinePlanningContext_GetHasFinalColorProcessing( + ulong nativeHandle); + [MethodImpl(MethodImplOptions.InternalCall)] internal static extern int Rendering_ScriptableRenderContext_GetStageColorSource( diff --git a/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelinePlanningContext.cs b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelinePlanningContext.cs index 5a04d085..5b5bb81c 100644 --- a/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelinePlanningContext.cs +++ b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelinePlanningContext.cs @@ -65,5 +65,12 @@ namespace XCEngine.Rendering m_nativeHandle, (int)stage); } + + public bool HasFinalColorProcessing() + { + return InternalCalls + .Rendering_ScriptableRenderPipelinePlanningContext_GetHasFinalColorProcessing( + m_nativeHandle); + } } } diff --git a/managed/XCEngine.ScriptCore/Rendering/Graph/RenderGraphRasterPassBuilder.cs b/managed/XCEngine.ScriptCore/Rendering/Graph/RenderGraphRasterPassBuilder.cs index 473d3014..6f72bcb5 100644 --- a/managed/XCEngine.ScriptCore/Rendering/Graph/RenderGraphRasterPassBuilder.cs +++ b/managed/XCEngine.ScriptCore/Rendering/Graph/RenderGraphRasterPassBuilder.cs @@ -8,7 +8,8 @@ namespace XCEngine.Rendering { None = 0, ColorScaleFullscreen = 1, - ShaderVectorFullscreen = 2 + ShaderVectorFullscreen = 2, + FinalColorFullscreen = 3 } public sealed class RenderGraphRasterPassBuilder @@ -23,6 +24,7 @@ namespace XCEngine.Rendering private Vector4 m_vectorPayload; private string m_shaderPath = string.Empty; private string m_shaderPassName = string.Empty; + private FinalColorSettings m_finalColorSettings; private RenderGraphRasterPassExecutionKind m_executionKind; private bool m_finalized; @@ -53,6 +55,19 @@ namespace XCEngine.Rendering return this; } + public RenderGraphRasterPassBuilder + SetFinalColorFullscreenExecution( + FinalColorSettings settings) + { + m_executionKind = + RenderGraphRasterPassExecutionKind + .FinalColorFullscreen; + m_finalColorSettings = settings; + m_shaderPath = string.Empty; + m_shaderPassName = string.Empty; + return this; + } + public RenderGraphRasterPassBuilder UseTexture( RenderGraphTextureHandle texture) { @@ -212,6 +227,15 @@ namespace XCEngine.Rendering m_shaderPassName, ref m_vectorPayload); break; + case RenderGraphRasterPassExecutionKind + .FinalColorFullscreen: + configuredExecution = + InternalCalls + .Rendering_ScriptableRenderContext_SetRasterPassFinalColorFullscreenExecution( + m_context.nativeHandle, + nativePassHandle, + ref m_finalColorSettings); + break; default: configuredExecution = false; break;