Formalize final color policy resolution

engine/include/XCEngine/Components/CameraComponent.h

@@ -7,6 +7,7 @@
 #include <XCEngine/Core/Math/Rect.h>
 #include <XCEngine/Core/Math/Vector4.h>
 #include <XCEngine/Rendering/Planning/CameraPostProcessDesc.h>
+#include <XCEngine/Rendering/Planning/FinalColorSettings.h>
 #include <XCEngine/Resources/Material/Material.h>
 
 #include <string>
@@ -92,6 +93,10 @@ public:
     const Math::Color& GetSkyboxBottomColor() const { return m_skyboxBottomColor; }
     void SetSkyboxBottomColor(const Math::Color& value) { m_skyboxBottomColor = value; }
 
+    const Rendering::FinalColorOverrideSettings& GetFinalColorOverrides() const { return m_finalColorOverrides; }
+    void SetFinalColorOverrides(const Rendering::FinalColorOverrideSettings& value) { m_finalColorOverrides = value; }
+    void ClearFinalColorOverrides() { m_finalColorOverrides = {}; }
+
     const Rendering::CameraPostProcessStack& GetPostProcessPasses() const { return m_postProcessPasses; }
     void SetPostProcessPasses(const Rendering::CameraPostProcessStack& values);
     void AddPostProcessPass(const Rendering::CameraPostProcessPassDesc& value);
@@ -131,6 +136,7 @@ private:
     Math::Color m_skyboxTopColor = Math::Color(0.18f, 0.36f, 0.74f, 1.0f);
     Math::Color m_skyboxHorizonColor = Math::Color(0.78f, 0.84f, 0.92f, 1.0f);
     Math::Color m_skyboxBottomColor = Math::Color(0.92f, 0.93f, 0.95f, 1.0f);
+    Rendering::FinalColorOverrideSettings m_finalColorOverrides = {};
     Math::Vector4 m_colorScalePostProcessDefaultScale = Math::Vector4::One();
     Rendering::CameraPostProcessStack m_postProcessPasses;
 };

engine/include/XCEngine/Rendering/Execution/SceneRenderer.h

@@ -46,6 +46,8 @@ public:
 
 private:
     void PrepareOwnedCameraPostProcessState(size_t requestCount);
+    void ResolveCameraFinalColorPolicies(
+        std::vector<CameraRenderRequest>& requests) const;
     void AttachCameraPostProcessRequests(
         const RenderContext& context,
         std::vector<CameraRenderRequest>& requests);

engine/include/XCEngine/Rendering/Pipelines/BuiltinForwardPipeline.h

@@ -304,6 +304,7 @@ private:
 class BuiltinForwardPipelineAsset final : public RenderPipelineAsset {
 public:
     std::unique_ptr<RenderPipeline> CreatePipeline() const override;
+    FinalColorSettings GetDefaultFinalColorSettings() const override { return {}; }
 };
 
 } // namespace Pipelines

engine/include/XCEngine/Rendering/Planning/CameraRenderRequest.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <XCEngine/Rendering/FrameData/RenderCameraData.h>
+#include <XCEngine/Rendering/Planning/FinalColorSettings.h>
 #include <XCEngine/Rendering/RenderContext.h>
 #include <XCEngine/Rendering/RenderPass.h>
 #include <XCEngine/Rendering/RenderSurface.h>
@@ -184,6 +185,7 @@ struct CameraRenderRequest {
     DirectionalShadowRenderPlan directionalShadow;
     PostProcessRenderRequest postProcess;
     FinalOutputRenderRequest finalOutput;
+    ResolvedFinalColorPolicy finalColorPolicy = {};
     ObjectIdRenderRequest objectId;
     float cameraDepth = 0.0f;
     uint8_t cameraStackOrder = 0;

engine/include/XCEngine/Rendering/Planning/FinalColorSettings.h

@@ -0,0 +1,122 @@
+#pragma once
+
+#include <XCEngine/Core/Math/Vector4.h>
+
+#include <cstdint>
+
+namespace XCEngine {
+namespace Rendering {
+
+enum class FinalColorOutputTransferMode : uint8_t {
+    Disabled = 0,
+    LinearToSRGB
+};
+
+enum class FinalColorExposureMode : uint8_t {
+    Disabled = 0,
+    Fixed
+};
+
+enum class FinalColorToneMappingMode : uint8_t {
+    Disabled = 0,
+    Neutral,
+    ACES
+};
+
+struct FinalColorSettings {
+    FinalColorOutputTransferMode outputTransferMode = FinalColorOutputTransferMode::Disabled;
+    FinalColorExposureMode exposureMode = FinalColorExposureMode::Disabled;
+    float exposureValue = 1.0f;
+    FinalColorToneMappingMode toneMappingMode = FinalColorToneMappingMode::Disabled;
+    Math::Vector4 finalColorScale = Math::Vector4::One();
+
+    bool RequiresProcessing() const {
+        return outputTransferMode != FinalColorOutputTransferMode::Disabled ||
+               exposureMode != FinalColorExposureMode::Disabled ||
+               toneMappingMode != FinalColorToneMappingMode::Disabled ||
+               finalColorScale != Math::Vector4::One();
+    }
+};
+
+struct FinalColorOverrideSettings {
+    bool overrideOutputTransferMode = false;
+    FinalColorOutputTransferMode outputTransferMode = FinalColorOutputTransferMode::Disabled;
+
+    bool overrideExposureMode = false;
+    FinalColorExposureMode exposureMode = FinalColorExposureMode::Disabled;
+
+    bool overrideExposureValue = false;
+    float exposureValue = 1.0f;
+
+    bool overrideToneMappingMode = false;
+    FinalColorToneMappingMode toneMappingMode = FinalColorToneMappingMode::Disabled;
+
+    bool overrideFinalColorScale = false;
+    Math::Vector4 finalColorScale = Math::Vector4::One();
+
+    bool HasOverrides() const {
+        return overrideOutputTransferMode ||
+               overrideExposureMode ||
+               overrideExposureValue ||
+               overrideToneMappingMode ||
+               overrideFinalColorScale;
+    }
+};
+
+struct ResolvedFinalColorPolicy : FinalColorSettings {
+    bool hasPipelineDefaults = false;
+    bool hasCameraOverrides = false;
+    bool hasVolumeOverrides = false;
+};
+
+inline void ApplyFinalColorOverrides(
+    const FinalColorOverrideSettings& overrides,
+    FinalColorSettings& settings) {
+    if (overrides.overrideOutputTransferMode) {
+        settings.outputTransferMode = overrides.outputTransferMode;
+    }
+
+    if (overrides.overrideExposureMode) {
+        settings.exposureMode = overrides.exposureMode;
+    }
+
+    if (overrides.overrideExposureValue) {
+        settings.exposureValue = overrides.exposureValue;
+    }
+
+    if (overrides.overrideToneMappingMode) {
+        settings.toneMappingMode = overrides.toneMappingMode;
+    }
+
+    if (overrides.overrideFinalColorScale) {
+        settings.finalColorScale = overrides.finalColorScale;
+    }
+}
+
+inline ResolvedFinalColorPolicy ResolveFinalColorPolicy(
+    const FinalColorSettings& pipelineDefaults,
+    const FinalColorOverrideSettings* cameraOverrides = nullptr,
+    const FinalColorOverrideSettings* volumeOverrides = nullptr) {
+    ResolvedFinalColorPolicy resolved = {};
+    resolved.outputTransferMode = pipelineDefaults.outputTransferMode;
+    resolved.exposureMode = pipelineDefaults.exposureMode;
+    resolved.exposureValue = pipelineDefaults.exposureValue;
+    resolved.toneMappingMode = pipelineDefaults.toneMappingMode;
+    resolved.finalColorScale = pipelineDefaults.finalColorScale;
+    resolved.hasPipelineDefaults = true;
+
+    if (cameraOverrides != nullptr && cameraOverrides->HasOverrides()) {
+        ApplyFinalColorOverrides(*cameraOverrides, resolved);
+        resolved.hasCameraOverrides = true;
+    }
+
+    if (volumeOverrides != nullptr && volumeOverrides->HasOverrides()) {
+        ApplyFinalColorOverrides(*volumeOverrides, resolved);
+        resolved.hasVolumeOverrides = true;
+    }
+
+    return resolved;
+}
+
+} // namespace Rendering
+} // namespace XCEngine

engine/include/XCEngine/Rendering/RenderPipelineAsset.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <XCEngine/Rendering/Planning/FinalColorSettings.h>
+
 #include <memory>
 
 namespace XCEngine {
@@ -12,6 +14,7 @@ public:
     virtual ~RenderPipelineAsset() = default;
 
     virtual std::unique_ptr<RenderPipeline> CreatePipeline() const = 0;
+    virtual FinalColorSettings GetDefaultFinalColorSettings() const { return {}; }
 };
 
 } // namespace Rendering

engine/src/Components/CameraComponent.cpp

@@ -276,6 +276,16 @@ void CameraComponent::Serialize(std::ostream& os) const {
     os << "skyboxTopColor=" << m_skyboxTopColor.r << "," << m_skyboxTopColor.g << "," << m_skyboxTopColor.b << "," << m_skyboxTopColor.a << ";";
     os << "skyboxHorizonColor=" << m_skyboxHorizonColor.r << "," << m_skyboxHorizonColor.g << "," << m_skyboxHorizonColor.b << "," << m_skyboxHorizonColor.a << ";";
     os << "skyboxBottomColor=" << m_skyboxBottomColor.r << "," << m_skyboxBottomColor.g << "," << m_skyboxBottomColor.b << "," << m_skyboxBottomColor.a << ";";
+    os << "finalColorOverrideOutputTransferEnabled=" << (m_finalColorOverrides.overrideOutputTransferMode ? 1 : 0) << ";";
+    os << "finalColorOverrideOutputTransferMode=" << static_cast<int>(m_finalColorOverrides.outputTransferMode) << ";";
+    os << "finalColorOverrideExposureModeEnabled=" << (m_finalColorOverrides.overrideExposureMode ? 1 : 0) << ";";
+    os << "finalColorOverrideExposureMode=" << static_cast<int>(m_finalColorOverrides.exposureMode) << ";";
+    os << "finalColorOverrideExposureValueEnabled=" << (m_finalColorOverrides.overrideExposureValue ? 1 : 0) << ";";
+    os << "finalColorOverrideExposureValue=" << m_finalColorOverrides.exposureValue << ";";
+    os << "finalColorOverrideToneMappingModeEnabled=" << (m_finalColorOverrides.overrideToneMappingMode ? 1 : 0) << ";";
+    os << "finalColorOverrideToneMappingMode=" << static_cast<int>(m_finalColorOverrides.toneMappingMode) << ";";
+    os << "finalColorOverrideScaleEnabled=" << (m_finalColorOverrides.overrideFinalColorScale ? 1 : 0) << ";";
+    os << "finalColorOverrideScale=" << EncodeVector4(m_finalColorOverrides.finalColorScale) << ";";
     os << "postProcessPassCount=" << m_postProcessPasses.size() << ";";
     for (size_t index = 0; index < m_postProcessPasses.size(); ++index) {
         const Rendering::CameraPostProcessPassDesc& pass = m_postProcessPasses[index];
@@ -295,6 +305,7 @@ void CameraComponent::Deserialize(std::istream& is) {
     m_skyboxMaterial.Reset();
     m_skyboxMaterialPath.clear();
     m_skyboxMaterialRef.Reset();
+    m_finalColorOverrides = {};
     m_colorScalePostProcessDefaultScale = Math::Vector4::One();
     m_postProcessPasses.clear();
 
@@ -367,6 +378,29 @@ void CameraComponent::Deserialize(std::istream& is) {
             std::replace(value.begin(), value.end(), ',', ' ');
             std::istringstream ss(value);
             ss >> m_skyboxBottomColor.r >> m_skyboxBottomColor.g >> m_skyboxBottomColor.b >> m_skyboxBottomColor.a;
+        } else if (key == "finalColorOverrideOutputTransferEnabled") {
+            m_finalColorOverrides.overrideOutputTransferMode = (std::stoi(value) != 0);
+        } else if (key == "finalColorOverrideOutputTransferMode") {
+            m_finalColorOverrides.outputTransferMode =
+                static_cast<Rendering::FinalColorOutputTransferMode>(std::stoi(value));
+        } else if (key == "finalColorOverrideExposureModeEnabled") {
+            m_finalColorOverrides.overrideExposureMode = (std::stoi(value) != 0);
+        } else if (key == "finalColorOverrideExposureMode") {
+            m_finalColorOverrides.exposureMode =
+                static_cast<Rendering::FinalColorExposureMode>(std::stoi(value));
+        } else if (key == "finalColorOverrideExposureValueEnabled") {
+            m_finalColorOverrides.overrideExposureValue = (std::stoi(value) != 0);
+        } else if (key == "finalColorOverrideExposureValue") {
+            m_finalColorOverrides.exposureValue = std::stof(value);
+        } else if (key == "finalColorOverrideToneMappingModeEnabled") {
+            m_finalColorOverrides.overrideToneMappingMode = (std::stoi(value) != 0);
+        } else if (key == "finalColorOverrideToneMappingMode") {
+            m_finalColorOverrides.toneMappingMode =
+                static_cast<Rendering::FinalColorToneMappingMode>(std::stoi(value));
+        } else if (key == "finalColorOverrideScaleEnabled") {
+            m_finalColorOverrides.overrideFinalColorScale = (std::stoi(value) != 0);
+        } else if (key == "finalColorOverrideScale") {
+            TryParseVector4(value, m_finalColorOverrides.finalColorScale);
         } else if (key == "postProcessPassCount") {
             postProcessPassCount = static_cast<size_t>(std::stoul(value));
             deserializedPostProcessPasses.clear();

engine/src/Rendering/Execution/SceneRenderer.cpp

@@ -4,6 +4,7 @@
 #include "Rendering/Caches/FullscreenPassSurfaceCache.h"
 #include "Rendering/Planning/CameraPostProcessPassFactory.h"
 #include "Rendering/Planning/SceneRenderRequestUtils.h"
+#include "Rendering/RenderPipelineAsset.h"
 
 namespace XCEngine {
 namespace Rendering {
@@ -35,6 +36,7 @@ std::vector<CameraRenderRequest> SceneRenderer::BuildRenderRequests(
     const RenderSurface& surface) {
     std::vector<CameraRenderRequest> requests =
         m_requestPlanner.BuildRequests(scene, overrideCamera, context, surface);
+    ResolveCameraFinalColorPolicies(requests);
     AttachCameraPostProcessRequests(context, requests);
     return requests;
 }
@@ -91,6 +93,24 @@ void SceneRenderer::PrepareOwnedCameraPostProcessState(size_t requestCount) {
     }
 }
 
+void SceneRenderer::ResolveCameraFinalColorPolicies(
+    std::vector<CameraRenderRequest>& requests) const {
+    const RenderPipelineAsset* pipelineAsset = GetPipelineAsset();
+    const FinalColorSettings pipelineDefaults =
+        pipelineAsset != nullptr ? pipelineAsset->GetDefaultFinalColorSettings() : FinalColorSettings();
+
+    for (CameraRenderRequest& request : requests) {
+        if (request.camera == nullptr) {
+            continue;
+        }
+
+        request.finalColorPolicy = ResolveFinalColorPolicy(
+            pipelineDefaults,
+            &request.camera->GetFinalColorOverrides(),
+            nullptr);
+    }
+}
+
 void SceneRenderer::AttachCameraPostProcessRequests(
     const RenderContext& context,
     std::vector<CameraRenderRequest>& requests) {