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

refactor(srp): move final color policy into request seam

Browse Source
This commit is contained in:
ssdfasd
2026-04-21 22:34:40 +08:00
parent 808335126f
commit d75bd95e89
13 changed files with 380 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
engine/src/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.cpp
View File

@@ -112,12 +112,6 @@ void ManagedScriptableRenderPipelineAsset::ConfigureCameraFramePlan(
if (const std::shared_ptr<const ManagedRenderPipelineAssetRuntime> runtime =
ResolveManagedAssetRuntime();
runtime != nullptr) {
if (runtime->UsesNativeCameraFramePlanBaseline(
plan.request.rendererIndex)) {
ApplyDefaultRenderPipelineAssetCameraFramePlanBaselinePolicy(
plan,
GetDefaultFinalColorSettings());
}
runtime->ConfigureCameraFramePlan(plan);
return;
}

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

@@ -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<uint8_t>(nativeSettings.outputTransferMode);
managedSettings.overrideExposureMode =
nativeSettings.overrideExposureMode
? 1u
: 0u;
managedSettings.exposureMode =
static_cast<uint8_t>(nativeSettings.exposureMode);
managedSettings.overrideExposureValue =
nativeSettings.overrideExposureValue
? 1u
: 0u;
managedSettings.exposureValue =
nativeSettings.exposureValue;
managedSettings.overrideToneMappingMode =
nativeSettings.overrideToneMappingMode
? 1u
: 0u;
managedSettings.toneMappingMode =
static_cast<uint8_t>(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<const Rendering::RenderPipelineAsset>
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<Rendering::RenderClearFlags>(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<const void*>(&InternalCall_Camera_GetProjectionType));
mono_add_internal_call("XCEngine.InternalCalls::Camera_GetSkyboxEnabled", reinterpret_cast<const void*>(&InternalCall_Camera_GetSkyboxEnabled));
mono_add_internal_call("XCEngine.InternalCalls::Camera_GetHasSkyboxMaterial", reinterpret_cast<const void*>(&InternalCall_Camera_GetHasSkyboxMaterial));
mono_add_internal_call("XCEngine.InternalCalls::Camera_GetHasFinalColorOverrides", reinterpret_cast<const void*>(&InternalCall_Camera_GetHasFinalColorOverrides));
mono_add_internal_call("XCEngine.InternalCalls::Camera_GetFinalColorOverrideSettings", reinterpret_cast<const void*>(&InternalCall_Camera_GetFinalColorOverrideSettings));
mono_add_internal_call("XCEngine.InternalCalls::Camera_GetSkyboxTopColor", reinterpret_cast<const void*>(&InternalCall_Camera_GetSkyboxTopColor));
mono_add_internal_call("XCEngine.InternalCalls::Camera_GetSkyboxHorizonColor", reinterpret_cast<const void*>(&InternalCall_Camera_GetSkyboxHorizonColor));
mono_add_internal_call("XCEngine.InternalCalls::Camera_GetSkyboxBottomColor", reinterpret_cast<const void*>(&InternalCall_Camera_GetSkyboxBottomColor));
@@ -6368,6 +6394,8 @@ void RegisterInternalCalls() {
mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_ClearDirectionalShadow", reinterpret_cast<const void*>(&InternalCall_Rendering_CameraRenderRequestContext_ClearDirectionalShadow));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_GetClearFlags", reinterpret_cast<const void*>(&InternalCall_Rendering_CameraRenderRequestContext_GetClearFlags));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_SetClearFlags", reinterpret_cast<const void*>(&InternalCall_Rendering_CameraRenderRequestContext_SetClearFlags));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_SetResolvedFinalColorPolicy", reinterpret_cast<const void*>(&InternalCall_Rendering_CameraRenderRequestContext_SetResolvedFinalColorPolicy));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_ClearFinalColorPolicy", reinterpret_cast<const void*>(&InternalCall_Rendering_CameraRenderRequestContext_ClearFinalColorPolicy));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_GetRendererIndex", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_GetRendererIndex));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_GetCameraGameObjectUUID", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_GetCameraGameObjectUUID));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_GetIsConfigured", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_GetIsConfigured));