From d75bd95e89df16731658fd80f5b5a9e08780e209 Mon Sep 17 00:00:00 2001 From: ssdfasd <2156608475@qq.com> Date: Tue, 21 Apr 2026 22:34:40 +0800 Subject: [PATCH] refactor(srp): move final color policy into request seam --- ...orRequestPolicyPlan_2026-04-21_完成归档.md | 63 +++++ .../ManagedScriptableRenderPipelineAsset.h | 8 - .../ManagedScriptableRenderPipelineAsset.cpp | 6 - .../src/Scripting/Mono/MonoScriptRuntime.cpp | 238 ++++++++++-------- managed/CMakeLists.txt | 1 + .../RendererBackedRenderPipelineAsset.cs | 6 - .../Universal/RendererCameraRequestContext.cs | 23 ++ .../Universal/UniversalRenderPipelineAsset.cs | 23 ++ managed/XCEngine.ScriptCore/Camera.cs | 20 ++ managed/XCEngine.ScriptCore/InternalCalls.cs | 21 ++ .../Core/CameraRenderRequestContext.cs | 20 ++ .../Core/FinalColorOverrideSettings.cs | 76 ++++++ .../Core/ScriptableRenderPipelineAsset.cs | 11 - 13 files changed, 380 insertions(+), 136 deletions(-) create mode 100644 docs/used/SRP_URP_ManagedFinalColorRequestPolicyPlan_2026-04-21_完成归档.md create mode 100644 managed/XCEngine.ScriptCore/Rendering/Core/FinalColorOverrideSettings.cs diff --git a/docs/used/SRP_URP_ManagedFinalColorRequestPolicyPlan_2026-04-21_完成归档.md b/docs/used/SRP_URP_ManagedFinalColorRequestPolicyPlan_2026-04-21_完成归档.md new file mode 100644 index 00000000..b4c7ed9b --- /dev/null +++ b/docs/used/SRP_URP_ManagedFinalColorRequestPolicyPlan_2026-04-21_完成归档.md @@ -0,0 +1,63 @@ +# SRP / URP Managed Final Color Request Policy Plan + +## Background + +The previous SRP cleanup already moved several policies out of native defaults and into managed URP request/planning seams. +The remaining native baseline dependency was `final color policy`: + +- pipeline default final color settings +- camera final color overrides +- `requiresProcessing` source data + +That policy was still injected from native camera-frame baseline into `CameraFramePlan.finalColorPolicy`, which meant renderer-backed URP was not yet the real owner of final color policy. + +## Goal + +Move final color policy ownership from native camera-frame baseline into the managed request seam. + +After this phase: + +- URP resolves final color policy in `ConfigureRendererCameraRequest(...)` +- `CameraRenderRequest.finalColorPolicy` becomes the source of truth +- `CameraFramePlan` simply inherits the resolved request policy +- the native `UsesNativeCameraFramePlanBaseline*` bridge is removed + +## Design + +### 1. Camera read seam + +Expose managed read access for camera final color overrides: + +- `Camera.hasFinalColorOverrides` +- `Camera.GetFinalColorOverrideSettings()` + +### 2. Request write seam + +Expose managed write access for resolved request policy: + +- `CameraRenderRequestContext.SetResolvedFinalColorPolicy(...)` +- `CameraRenderRequestContext.ClearFinalColorPolicy()` + +### 3. URP policy ownership + +`UniversalRenderPipelineAsset.ConfigureRendererCameraRequest(...)` should: + +- read pipeline default final color settings +- read camera overrides +- resolve the final settings +- write the resolved policy back into request context + +## Completion + +- Status: completed on 2026-04-21 +- Added managed `FinalColorOverrideSettings` +- Added camera final color override read seam +- Added request-context final color policy write seam +- Moved URP final color resolution into managed request configuration +- Removed `UsesNativeCameraFramePlanBaseline*` from managed/native SRP bridge + +## Verification + +- `cmake --build . --config Debug --target XCEditor` +- old editor smoke passed +- `SceneReady elapsed_ms=6129 first_frame_ms=719` diff --git a/engine/include/XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h b/engine/include/XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h index 5227700e..9b1fc4ed 100644 --- a/engine/include/XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h +++ b/engine/include/XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h @@ -104,14 +104,6 @@ public: GetSharedPipelineBackendAsset() const { return nullptr; } - virtual bool UsesNativeCameraFramePlanBaseline() const { - return false; - } - virtual bool UsesNativeCameraFramePlanBaseline( - int32_t rendererIndex) const { - (void)rendererIndex; - return UsesNativeCameraFramePlanBaseline(); - } virtual bool TryGetDefaultFinalColorSettings(FinalColorSettings&) const { return false; } diff --git a/engine/src/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.cpp b/engine/src/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.cpp index e0591d97..a1f24ef6 100644 --- a/engine/src/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.cpp +++ b/engine/src/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.cpp @@ -112,12 +112,6 @@ void ManagedScriptableRenderPipelineAsset::ConfigureCameraFramePlan( if (const std::shared_ptr runtime = ResolveManagedAssetRuntime(); runtime != nullptr) { - if (runtime->UsesNativeCameraFramePlanBaseline( - plan.request.rendererIndex)) { - ApplyDefaultRenderPipelineAssetCameraFramePlanBaselinePolicy( - plan, - GetDefaultFinalColorSettings()); - } runtime->ConfigureCameraFramePlan(plan); return; } diff --git a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp index ab33fb0a..89bdfb18 100644 --- a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp +++ b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp @@ -1042,6 +1042,26 @@ static_assert( sizeof(Rendering::FinalColorSettings), "Managed final color bridge layout must match native FinalColorSettings."); +struct ManagedFinalColorOverrideSettingsData { + uint8_t overrideOutputTransferMode = 0u; + uint8_t outputTransferMode = 0u; + uint8_t overrideExposureMode = 0u; + uint8_t exposureMode = 0u; + uint8_t overrideExposureValue = 0u; + uint8_t exposureValuePadding[3] = {}; + float exposureValue = 1.0f; + uint8_t overrideToneMappingMode = 0u; + uint8_t toneMappingMode = 0u; + uint8_t overrideFinalColorScale = 0u; + uint8_t finalColorScalePadding = 0u; + XCEngine::Math::Vector4 finalColorScale = XCEngine::Math::Vector4::One(); +}; + +static_assert( + sizeof(ManagedFinalColorOverrideSettingsData) == + sizeof(Rendering::FinalColorOverrideSettings), + "Managed final color override bridge layout must match native FinalColorOverrideSettings."); + struct ManagedRenderGraphTextureDescData { uint32_t width = 0u; uint32_t height = 0u; @@ -1377,6 +1397,42 @@ Rendering::FinalColorSettings BuildManagedFinalColorSettings( return settings; } +ManagedFinalColorOverrideSettingsData BuildManagedFinalColorOverrideSettings( + const Rendering::FinalColorOverrideSettings& nativeSettings) { + ManagedFinalColorOverrideSettingsData managedSettings = {}; + managedSettings.overrideOutputTransferMode = + nativeSettings.overrideOutputTransferMode + ? 1u + : 0u; + managedSettings.outputTransferMode = + static_cast(nativeSettings.outputTransferMode); + managedSettings.overrideExposureMode = + nativeSettings.overrideExposureMode + ? 1u + : 0u; + managedSettings.exposureMode = + static_cast(nativeSettings.exposureMode); + managedSettings.overrideExposureValue = + nativeSettings.overrideExposureValue + ? 1u + : 0u; + managedSettings.exposureValue = + nativeSettings.exposureValue; + managedSettings.overrideToneMappingMode = + nativeSettings.overrideToneMappingMode + ? 1u + : 0u; + managedSettings.toneMappingMode = + static_cast(nativeSettings.toneMappingMode); + managedSettings.overrideFinalColorScale = + nativeSettings.overrideFinalColorScale + ? 1u + : 0u; + managedSettings.finalColorScale = + nativeSettings.finalColorScale; + return managedSettings; +} + bool SupportsManagedRenderPipelineStageGraphRecording( Rendering::CameraFrameStage stage) { return Rendering::SupportsCameraFramePipelineGraphRecording(stage) || @@ -1499,9 +1555,6 @@ public: Rendering::FinalColorSettings& settings) const override; std::shared_ptr GetSharedPipelineBackendAsset() const override; - bool UsesNativeCameraFramePlanBaseline() const override; - bool UsesNativeCameraFramePlanBaseline( - int32_t rendererIndex) const override; MonoScriptRuntime* GetRuntime() const { return m_runtime; @@ -1532,10 +1585,6 @@ private: MonoObject* assetObject) const; MonoMethod* ResolveGetRuntimeResourceVersionMethod( MonoObject* assetObject) const; - MonoMethod* ResolveUsesNativeCameraFramePlanBaselineMethod( - MonoObject* assetObject) const; - MonoMethod* ResolveUsesNativeCameraFramePlanBaselineContextualMethod( - MonoObject* assetObject) const; MonoMethod* ResolveConfigureRenderSceneSetupMethod( MonoObject* assetObject) const; MonoMethod* ResolveConfigureDirectionalShadowExecutionStateMethod( @@ -1553,11 +1602,6 @@ private: mutable MonoMethod* m_configureCameraFramePlanMethod = nullptr; mutable MonoMethod* m_getDefaultFinalColorSettingsMethod = nullptr; mutable MonoMethod* m_getRuntimeResourceVersionMethod = nullptr; - mutable MonoMethod* m_usesNativeCameraFramePlanBaselineMethod = - nullptr; - mutable MonoMethod* - m_usesNativeCameraFramePlanBaselineContextualMethod = - nullptr; mutable MonoMethod* m_configureRenderSceneSetupMethod = nullptr; mutable MonoMethod* @@ -2203,66 +2247,6 @@ MonoManagedRenderPipelineAssetRuntime::GetSharedPipelineBackendAsset() const { return m_sharedPipelineBackendAsset; } -bool MonoManagedRenderPipelineAssetRuntime::UsesNativeCameraFramePlanBaseline() - const { - return UsesNativeCameraFramePlanBaseline(-1); -} - -bool MonoManagedRenderPipelineAssetRuntime::UsesNativeCameraFramePlanBaseline( - int32_t rendererIndex) const { - if (!SyncManagedAssetRuntimeState()) { - return false; - } - - MonoObject* const assetObject = GetManagedAssetObject(); - if (assetObject == nullptr) { - return false; - } - - MonoMethod* const contextualMethod = - ResolveUsesNativeCameraFramePlanBaselineContextualMethod( - assetObject); - if (contextualMethod != nullptr) { - void* args[1] = { &rendererIndex }; - MonoObject* managedValueObject = nullptr; - if (!m_runtime->InvokeManagedMethod( - assetObject, - contextualMethod, - args, - &managedValueObject)) { - return false; - } - - bool usesBaseline = false; - return TryUnboxManagedBoolean( - managedValueObject, - usesBaseline) && - usesBaseline; - } - - MonoMethod* const method = - ResolveUsesNativeCameraFramePlanBaselineMethod( - assetObject); - if (method == nullptr) { - return false; - } - - MonoObject* managedValueObject = nullptr; - if (!m_runtime->InvokeManagedMethod( - assetObject, - method, - nullptr, - &managedValueObject)) { - return false; - } - - bool usesBaseline = false; - return TryUnboxManagedBoolean( - managedValueObject, - usesBaseline) && - usesBaseline; -} - bool MonoManagedRenderPipelineAssetRuntime::AcquireManagedPipelineHandle( uint32_t& outPipelineHandle) const { if (!SyncManagedAssetRuntimeState()) { @@ -2467,8 +2451,6 @@ void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedAsset() const { m_configureCameraFramePlanMethod = nullptr; m_getDefaultFinalColorSettingsMethod = nullptr; m_getRuntimeResourceVersionMethod = nullptr; - m_usesNativeCameraFramePlanBaselineMethod = nullptr; - m_usesNativeCameraFramePlanBaselineContextualMethod = nullptr; m_configureRenderSceneSetupMethod = nullptr; m_configureDirectionalShadowExecutionStateMethod = nullptr; m_sharedPipelineBackendAsset.reset(); @@ -2590,37 +2572,6 @@ MonoManagedRenderPipelineAssetRuntime::ResolveGetRuntimeResourceVersionMethod( return m_getRuntimeResourceVersionMethod; } -MonoMethod* -MonoManagedRenderPipelineAssetRuntime:: - ResolveUsesNativeCameraFramePlanBaselineMethod( - MonoObject* assetObject) const { - if (m_usesNativeCameraFramePlanBaselineMethod == nullptr) { - m_usesNativeCameraFramePlanBaselineMethod = - m_runtime->ResolveManagedMethod( - assetObject, - "UsesNativeCameraFramePlanBaseline", - 0); - } - - return m_usesNativeCameraFramePlanBaselineMethod; -} - -MonoMethod* -MonoManagedRenderPipelineAssetRuntime:: - ResolveUsesNativeCameraFramePlanBaselineContextualMethod( - MonoObject* assetObject) const { - if (m_usesNativeCameraFramePlanBaselineContextualMethod == - nullptr) { - m_usesNativeCameraFramePlanBaselineContextualMethod = - m_runtime->ResolveManagedMethod( - assetObject, - "UsesNativeCameraFramePlanBaselineContextual", - 1); - } - - return m_usesNativeCameraFramePlanBaselineContextualMethod; -} - MonoMethod* MonoManagedRenderPipelineAssetRuntime:: ResolveConfigureRenderSceneSetupMethod( @@ -4061,6 +4012,34 @@ mono_bool InternalCall_Camera_GetHasSkyboxMaterial(uint64_t gameObjectUUID) { return (component && component->GetSkyboxMaterial() != nullptr) ? 1 : 0; } +mono_bool InternalCall_Camera_GetHasFinalColorOverrides( + uint64_t gameObjectUUID) { + Components::CameraComponent* component = + FindCameraComponent(gameObjectUUID); + return (component && + component->GetFinalColorOverrides().HasOverrides()) + ? 1 + : 0; +} + +void InternalCall_Camera_GetFinalColorOverrideSettings( + uint64_t gameObjectUUID, + ManagedFinalColorOverrideSettingsData* outSettings) { + if (outSettings == nullptr) { + return; + } + + Components::CameraComponent* component = + FindCameraComponent(gameObjectUUID); + const Rendering::FinalColorOverrideSettings sourceSettings = + component != nullptr + ? component->GetFinalColorOverrides() + : Rendering::FinalColorOverrideSettings{}; + *outSettings = + BuildManagedFinalColorOverrideSettings( + sourceSettings); +} + void InternalCall_Camera_GetSkyboxTopColor( uint64_t gameObjectUUID, XCEngine::Math::Color* outColor) { @@ -5632,6 +5611,51 @@ void InternalCall_Rendering_CameraRenderRequestContext_SetClearFlags( static_cast(clearFlags); } +void InternalCall_Rendering_CameraRenderRequestContext_SetResolvedFinalColorPolicy( + uint64_t nativeHandle, + ManagedFinalColorSettingsData* settings, + mono_bool hasPipelineDefaults, + mono_bool hasCameraOverrides) { + ManagedCameraRenderRequestContextState* const state = + FindManagedCameraRenderRequestContextState(nativeHandle); + if (state == nullptr || + state->request == nullptr || + settings == nullptr) { + return; + } + + const Rendering::FinalColorSettings resolvedSettings = + BuildManagedFinalColorSettings(*settings); + Rendering::ResolvedFinalColorPolicy resolvedPolicy = {}; + resolvedPolicy.outputTransferMode = + resolvedSettings.outputTransferMode; + resolvedPolicy.exposureMode = + resolvedSettings.exposureMode; + resolvedPolicy.exposureValue = + resolvedSettings.exposureValue; + resolvedPolicy.toneMappingMode = + resolvedSettings.toneMappingMode; + resolvedPolicy.finalColorScale = + resolvedSettings.finalColorScale; + resolvedPolicy.hasPipelineDefaults = + hasPipelineDefaults != 0; + resolvedPolicy.hasCameraOverrides = + hasCameraOverrides != 0; + state->request->finalColorPolicy = + resolvedPolicy; +} + +void InternalCall_Rendering_CameraRenderRequestContext_ClearFinalColorPolicy( + uint64_t nativeHandle) { + ManagedCameraRenderRequestContextState* const state = + FindManagedCameraRenderRequestContextState(nativeHandle); + if (state == nullptr || state->request == nullptr) { + return; + } + + state->request->finalColorPolicy = {}; +} + int32_t InternalCall_Rendering_RenderSceneSetupContext_GetRendererIndex( uint64_t nativeHandle) { @@ -6229,6 +6253,8 @@ void RegisterInternalCalls() { mono_add_internal_call("XCEngine.InternalCalls::Camera_GetProjectionType", reinterpret_cast(&InternalCall_Camera_GetProjectionType)); mono_add_internal_call("XCEngine.InternalCalls::Camera_GetSkyboxEnabled", reinterpret_cast(&InternalCall_Camera_GetSkyboxEnabled)); mono_add_internal_call("XCEngine.InternalCalls::Camera_GetHasSkyboxMaterial", reinterpret_cast(&InternalCall_Camera_GetHasSkyboxMaterial)); + mono_add_internal_call("XCEngine.InternalCalls::Camera_GetHasFinalColorOverrides", reinterpret_cast(&InternalCall_Camera_GetHasFinalColorOverrides)); + mono_add_internal_call("XCEngine.InternalCalls::Camera_GetFinalColorOverrideSettings", reinterpret_cast(&InternalCall_Camera_GetFinalColorOverrideSettings)); mono_add_internal_call("XCEngine.InternalCalls::Camera_GetSkyboxTopColor", reinterpret_cast(&InternalCall_Camera_GetSkyboxTopColor)); mono_add_internal_call("XCEngine.InternalCalls::Camera_GetSkyboxHorizonColor", reinterpret_cast(&InternalCall_Camera_GetSkyboxHorizonColor)); mono_add_internal_call("XCEngine.InternalCalls::Camera_GetSkyboxBottomColor", reinterpret_cast(&InternalCall_Camera_GetSkyboxBottomColor)); @@ -6368,6 +6394,8 @@ void RegisterInternalCalls() { mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_ClearDirectionalShadow", reinterpret_cast(&InternalCall_Rendering_CameraRenderRequestContext_ClearDirectionalShadow)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_GetClearFlags", reinterpret_cast(&InternalCall_Rendering_CameraRenderRequestContext_GetClearFlags)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_SetClearFlags", reinterpret_cast(&InternalCall_Rendering_CameraRenderRequestContext_SetClearFlags)); + mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_SetResolvedFinalColorPolicy", reinterpret_cast(&InternalCall_Rendering_CameraRenderRequestContext_SetResolvedFinalColorPolicy)); + mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_ClearFinalColorPolicy", reinterpret_cast(&InternalCall_Rendering_CameraRenderRequestContext_ClearFinalColorPolicy)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_GetRendererIndex", reinterpret_cast(&InternalCall_Rendering_RenderSceneSetupContext_GetRendererIndex)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_GetCameraGameObjectUUID", reinterpret_cast(&InternalCall_Rendering_RenderSceneSetupContext_GetCameraGameObjectUUID)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_GetIsConfigured", reinterpret_cast(&InternalCall_Rendering_RenderSceneSetupContext_GetIsConfigured)); diff --git a/managed/CMakeLists.txt b/managed/CMakeLists.txt index 7d43ef23..e23e4a01 100644 --- a/managed/CMakeLists.txt +++ b/managed/CMakeLists.txt @@ -183,6 +183,7 @@ set(XCENGINE_SCRIPT_CORE_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/DirectionalShadowPlanningSettings.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/DrawingSettings.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/FinalColorExposureMode.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/FinalColorOverrideSettings.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/FinalColorOutputTransferMode.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/FinalColorSettings.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/FinalColorToneMappingMode.cs diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererBackedRenderPipelineAsset.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererBackedRenderPipelineAsset.cs index d0e2be17..ea3e4255 100644 --- a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererBackedRenderPipelineAsset.cs +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererBackedRenderPipelineAsset.cs @@ -150,12 +150,6 @@ namespace XCEngine.Rendering.Universal return true; } - private protected override bool UsesNativeCameraFramePlanBaselineContextual( - int rendererIndex) - { - return UsesExplicitFullscreenStagePlanning(); - } - internal ScriptableRendererData GetDefaultRendererData() { return ResolveSelectedRendererData(); diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererCameraRequestContext.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererCameraRequestContext.cs index a15fa3b7..caa28109 100644 --- a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererCameraRequestContext.cs +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererCameraRequestContext.cs @@ -90,6 +90,29 @@ namespace XCEngine.Rendering.Universal } } + public void SetResolvedFinalColorPolicy( + FinalColorSettings settings, + bool hasPipelineDefaults, + bool hasCameraOverrides) + { + if (m_requestContext != null) + { + m_requestContext + .SetResolvedFinalColorPolicy( + settings, + hasPipelineDefaults, + hasCameraOverrides); + } + } + + public void ClearFinalColorPolicy() + { + if (m_requestContext != null) + { + m_requestContext.ClearFinalColorPolicy(); + } + } + internal CameraRenderRequestContext requestContext => m_requestContext; } diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRenderPipelineAsset.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRenderPipelineAsset.cs index 27f4e706..e0ebef76 100644 --- a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRenderPipelineAsset.cs +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRenderPipelineAsset.cs @@ -37,6 +37,29 @@ namespace XCEngine.Rendering.Universal return; } + FinalColorSettings resolvedFinalColorSettings = + GetFinalColorSettingsInstance().settings; + bool hasCameraFinalColorOverrides = false; + + Camera camera = context.camera; + if (camera != null && + camera.hasFinalColorOverrides) + { + FinalColorOverrideSettings overrideSettings = + camera.GetFinalColorOverrideSettings(); + if (overrideSettings.HasOverrides()) + { + overrideSettings.ApplyTo( + ref resolvedFinalColorSettings); + hasCameraFinalColorOverrides = true; + } + } + + context.SetResolvedFinalColorPolicy( + resolvedFinalColorSettings, + true, + hasCameraFinalColorOverrides); + context.clearFlags = ResolveRequestClearFlags(context); diff --git a/managed/XCEngine.ScriptCore/Camera.cs b/managed/XCEngine.ScriptCore/Camera.cs index 4d2b5c8b..5bd5ca94 100644 --- a/managed/XCEngine.ScriptCore/Camera.cs +++ b/managed/XCEngine.ScriptCore/Camera.cs @@ -1,3 +1,5 @@ +using XCEngine.Rendering; + namespace XCEngine { public sealed class Camera : Component @@ -166,5 +168,23 @@ namespace XCEngine public Color skyboxBottomColor => SkyboxBottomColor; + + public bool HasFinalColorOverrides => + InternalCalls + .Camera_GetHasFinalColorOverrides( + GameObjectUUID); + + public bool hasFinalColorOverrides => + HasFinalColorOverrides; + + public FinalColorOverrideSettings + GetFinalColorOverrideSettings() + { + InternalCalls + .Camera_GetFinalColorOverrideSettings( + GameObjectUUID, + out FinalColorOverrideSettings value); + return value; + } } } diff --git a/managed/XCEngine.ScriptCore/InternalCalls.cs b/managed/XCEngine.ScriptCore/InternalCalls.cs index 4a9e53b9..b5a69838 100644 --- a/managed/XCEngine.ScriptCore/InternalCalls.cs +++ b/managed/XCEngine.ScriptCore/InternalCalls.cs @@ -282,6 +282,14 @@ namespace XCEngine [MethodImpl(MethodImplOptions.InternalCall)] internal static extern void Camera_GetSkyboxBottomColor(ulong gameObjectUUID, out Color value); + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern bool Camera_GetHasFinalColorOverrides(ulong gameObjectUUID); + + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern void Camera_GetFinalColorOverrideSettings( + ulong gameObjectUUID, + out Rendering.FinalColorOverrideSettings settings); + [MethodImpl(MethodImplOptions.InternalCall)] internal static extern float Light_GetIntensity(ulong gameObjectUUID); @@ -944,6 +952,19 @@ namespace XCEngine ulong nativeHandle, int clearFlags); + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern void + Rendering_CameraRenderRequestContext_SetResolvedFinalColorPolicy( + ulong nativeHandle, + ref Rendering.FinalColorSettings settings, + bool hasPipelineDefaults, + bool hasCameraOverrides); + + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern void + Rendering_CameraRenderRequestContext_ClearFinalColorPolicy( + ulong nativeHandle); + [MethodImpl(MethodImplOptions.InternalCall)] internal static extern int Rendering_RenderSceneSetupContext_GetRendererIndex( diff --git a/managed/XCEngine.ScriptCore/Rendering/Core/CameraRenderRequestContext.cs b/managed/XCEngine.ScriptCore/Rendering/Core/CameraRenderRequestContext.cs index 3aa42caf..455a0d67 100644 --- a/managed/XCEngine.ScriptCore/Rendering/Core/CameraRenderRequestContext.cs +++ b/managed/XCEngine.ScriptCore/Rendering/Core/CameraRenderRequestContext.cs @@ -98,6 +98,26 @@ namespace XCEngine.Rendering (int)value); } + public void SetResolvedFinalColorPolicy( + FinalColorSettings settings, + bool hasPipelineDefaults, + bool hasCameraOverrides) + { + InternalCalls + .Rendering_CameraRenderRequestContext_SetResolvedFinalColorPolicy( + m_nativeHandle, + ref settings, + hasPipelineDefaults, + hasCameraOverrides); + } + + public void ClearFinalColorPolicy() + { + InternalCalls + .Rendering_CameraRenderRequestContext_ClearFinalColorPolicy( + m_nativeHandle); + } + internal ulong nativeHandle => m_nativeHandle; } diff --git a/managed/XCEngine.ScriptCore/Rendering/Core/FinalColorOverrideSettings.cs b/managed/XCEngine.ScriptCore/Rendering/Core/FinalColorOverrideSettings.cs new file mode 100644 index 00000000..c423b74c --- /dev/null +++ b/managed/XCEngine.ScriptCore/Rendering/Core/FinalColorOverrideSettings.cs @@ -0,0 +1,76 @@ +using System.Runtime.InteropServices; +using XCEngine; + +namespace XCEngine.Rendering +{ + [StructLayout(LayoutKind.Sequential)] + public struct FinalColorOverrideSettings + { + [MarshalAs(UnmanagedType.I1)] + public bool overrideOutputTransferMode; + + public FinalColorOutputTransferMode outputTransferMode; + + [MarshalAs(UnmanagedType.I1)] + public bool overrideExposureMode; + + public FinalColorExposureMode exposureMode; + + [MarshalAs(UnmanagedType.I1)] + public bool overrideExposureValue; + + public float exposureValue; + + [MarshalAs(UnmanagedType.I1)] + public bool overrideToneMappingMode; + + public FinalColorToneMappingMode toneMappingMode; + + [MarshalAs(UnmanagedType.I1)] + public bool overrideFinalColorScale; + + public Vector4 finalColorScale; + + public bool HasOverrides() + { + return overrideOutputTransferMode || + overrideExposureMode || + overrideExposureValue || + overrideToneMappingMode || + overrideFinalColorScale; + } + + public void ApplyTo(ref FinalColorSettings settings) + { + if (overrideOutputTransferMode) + { + settings.outputTransferMode = + outputTransferMode; + } + + if (overrideExposureMode) + { + settings.exposureMode = + exposureMode; + } + + if (overrideExposureValue) + { + settings.exposureValue = + exposureValue; + } + + if (overrideToneMappingMode) + { + settings.toneMappingMode = + toneMappingMode; + } + + if (overrideFinalColorScale) + { + settings.finalColorScale = + finalColorScale; + } + } + } +} diff --git a/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs index 9bd97294..1e7748fb 100644 --- a/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs +++ b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs @@ -72,17 +72,6 @@ namespace XCEngine.Rendering return FinalColorSettings.CreateDefault(); } - private protected virtual bool UsesNativeCameraFramePlanBaseline() - { - return false; - } - - private protected virtual bool UsesNativeCameraFramePlanBaselineContextual( - int rendererIndex) - { - return UsesNativeCameraFramePlanBaseline(); - } - protected virtual void ReleaseRuntimeResources() { }