feat(rendering): expose managed SRP asset final color defaults

engine/src/Scripting/Mono/MonoScriptRuntime.cpp

@@ -318,6 +318,84 @@ bool TryUnboxManagedBoolean(MonoObject* boxedValue, bool& outValue) {
     return true;
 }
 
+struct ManagedFinalColorSettingsData {
+    uint8_t outputTransferMode = 0;
+    uint8_t exposureMode = 0;
+    uint16_t exposurePadding = 0;
+    float exposureValue = 1.0f;
+    uint8_t toneMappingMode = 0;
+    uint8_t toneMappingPadding[3] = {};
+    XCEngine::Math::Vector4 finalColorScale = XCEngine::Math::Vector4::One();
+};
+
+static_assert(
+    sizeof(ManagedFinalColorSettingsData) ==
+    sizeof(Rendering::FinalColorSettings),
+    "Managed final color bridge layout must match native FinalColorSettings.");
+
+Rendering::FinalColorOutputTransferMode ResolveManagedFinalColorOutputTransferMode(
+    uint8_t value) {
+    switch (value) {
+    case 1:
+        return Rendering::FinalColorOutputTransferMode::LinearToSRGB;
+    default:
+        return Rendering::FinalColorOutputTransferMode::Disabled;
+    }
+}
+
+Rendering::FinalColorExposureMode ResolveManagedFinalColorExposureMode(
+    uint8_t value) {
+    switch (value) {
+    case 1:
+        return Rendering::FinalColorExposureMode::Fixed;
+    default:
+        return Rendering::FinalColorExposureMode::Disabled;
+    }
+}
+
+Rendering::FinalColorToneMappingMode ResolveManagedFinalColorToneMappingMode(
+    uint8_t value) {
+    switch (value) {
+    case 1:
+        return Rendering::FinalColorToneMappingMode::Neutral;
+    case 2:
+        return Rendering::FinalColorToneMappingMode::ACES;
+    default:
+        return Rendering::FinalColorToneMappingMode::Disabled;
+    }
+}
+
+bool TryUnboxManagedFinalColorSettings(
+    MonoObject* boxedValue,
+    Rendering::FinalColorSettings& outSettings) {
+    outSettings = {};
+    outSettings.exposureValue = 1.0f;
+    outSettings.finalColorScale = XCEngine::Math::Vector4::One();
+    if (!boxedValue) {
+        return false;
+    }
+
+    void* const rawValue = mono_object_unbox(boxedValue);
+    if (!rawValue) {
+        return false;
+    }
+
+    const auto* const managedSettings =
+        static_cast<const ManagedFinalColorSettingsData*>(rawValue);
+    outSettings.outputTransferMode =
+        ResolveManagedFinalColorOutputTransferMode(
+            managedSettings->outputTransferMode);
+    outSettings.exposureMode =
+        ResolveManagedFinalColorExposureMode(
+            managedSettings->exposureMode);
+    outSettings.exposureValue = managedSettings->exposureValue;
+    outSettings.toneMappingMode =
+        ResolveManagedFinalColorToneMappingMode(
+            managedSettings->toneMappingMode);
+    outSettings.finalColorScale = managedSettings->finalColorScale;
+    return true;
+}
+
 bool SupportsManagedRenderPipelineStageGraphRecording(
     Rendering::CameraFrameStage stage) {
     return Rendering::SupportsCameraFramePipelineGraphRecording(stage) ||
@@ -394,6 +472,9 @@ public:
     void ConfigureCameraFramePlan(
         Rendering::CameraFramePlan& plan) const override;
 
+    bool TryGetDefaultFinalColorSettings(
+        Rendering::FinalColorSettings& settings) const override;
+
     MonoScriptRuntime* GetRuntime() const {
         return m_runtime;
     }
@@ -415,6 +496,8 @@ private:
         MonoObject* assetObject) const;
     MonoMethod* ResolveConfigureCameraFramePlanMethod(
         MonoObject* assetObject) const;
+    MonoMethod* ResolveGetDefaultFinalColorSettingsMethod(
+        MonoObject* assetObject) const;
 
     MonoScriptRuntime* m_runtime = nullptr;
     std::weak_ptr<void> m_runtimeLifetime;
@@ -423,6 +506,7 @@ private:
     mutable MonoMethod* m_createPipelineMethod = nullptr;
     mutable MonoMethod* m_configureCameraRenderRequestMethod = nullptr;
     mutable MonoMethod* m_configureCameraFramePlanMethod = nullptr;
+    mutable MonoMethod* m_getDefaultFinalColorSettingsMethod = nullptr;
     mutable bool m_assetCreationAttempted = false;
 };
 
@@ -738,6 +822,36 @@ void MonoManagedRenderPipelineAssetRuntime::ConfigureCameraFramePlan(
         planningContextHandle);
 }
 
+bool MonoManagedRenderPipelineAssetRuntime::TryGetDefaultFinalColorSettings(
+    Rendering::FinalColorSettings& settings) const {
+    settings = {};
+    settings.exposureValue = 1.0f;
+    settings.finalColorScale = XCEngine::Math::Vector4::One();
+    if (!EnsureManagedAsset()) {
+        return false;
+    }
+
+    MonoObject* const assetObject = GetManagedAssetObject();
+    MonoMethod* const method =
+        ResolveGetDefaultFinalColorSettingsMethod(assetObject);
+    if (assetObject == nullptr || method == nullptr) {
+        return false;
+    }
+
+    MonoObject* managedSettings = nullptr;
+    if (!m_runtime->InvokeManagedMethod(
+            assetObject,
+            method,
+            nullptr,
+            &managedSettings)) {
+        return false;
+    }
+
+    return TryUnboxManagedFinalColorSettings(
+        managedSettings,
+        settings);
+}
+
 bool MonoManagedRenderPipelineAssetRuntime::CreateManagedPipeline(
     uint32_t& outPipelineHandle) const {
     outPipelineHandle = 0;
@@ -812,6 +926,7 @@ void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedAsset() const {
     m_createPipelineMethod = nullptr;
     m_configureCameraRenderRequestMethod = nullptr;
     m_configureCameraFramePlanMethod = nullptr;
+    m_getDefaultFinalColorSettingsMethod = nullptr;
     m_assetCreationAttempted = false;
 
     if (!IsRuntimeAlive()) {
@@ -872,6 +987,20 @@ MonoManagedRenderPipelineAssetRuntime::ResolveConfigureCameraFramePlanMethod(
     return m_configureCameraFramePlanMethod;
 }
 
+MonoMethod*
+MonoManagedRenderPipelineAssetRuntime::ResolveGetDefaultFinalColorSettingsMethod(
+    MonoObject* assetObject) const {
+    if (m_getDefaultFinalColorSettingsMethod == nullptr) {
+        m_getDefaultFinalColorSettingsMethod =
+            m_runtime->ResolveManagedMethod(
+                assetObject,
+                "GetDefaultFinalColorSettings",
+                0);
+    }
+
+    return m_getDefaultFinalColorSettingsMethod;
+}
+
 class MonoManagedRenderPipelineBridge final
     : public Rendering::Pipelines::ManagedRenderPipelineBridge {
 public: