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