Editor HDR Color Grading Component implemented under the PostFx stack (#4159)

* Add HDR color grading pass and shaders. * Remove color grading pass from light adaptation parent pass due to failing ASV tests. This will be added back later on. * Editor HDR Color Grading Component implemented under the PostFx stack (#219) * Add softmin/max for unbounded color grading properties. * Revert channel mixer properties to vector3. Refactor mix to weight. Fix color grading pass to convert any color variable into vec4. Signed-off-by: rbarrand <rbarrand@amazon.com> Co-authored-by: Robin <rbarrand@amazon.com>
2021-09-21 14:19:30 -07:00
parent 9477da799b
commit 30da67fe7d
28 changed files with 1030 additions and 17 deletions
@@ -5,7 +5,7 @@
    "ClassData": {
        "PassTemplate": {
            "Name": "HDRColorGradingTemplate",
-            "PassClass": "FullScreenTriangle",
+            "PassClass": "HDRColorGradingPass",
            "Slots": [
                {
                    "Name": "Input",
@@ -85,7 +85,7 @@
                        },
                        {
                            "Name": "m_whiteBalanceKelvin",
-                            "Value": 6500.0 // 1000.0f ... 40000.0f kelvin
+                            "Value": 6600.0 // 1000.0f ... 40000.0f kelvin
                        },
                        {
                            "Name": "m_whiteBalanceTint",
@@ -96,7 +96,7 @@
                            "Value": 0.0 // -1 ... 1
                        },
                        {
-                            "Name": "m_splitToneMix",
+                            "Name": "m_splitToneWeight",
                            "Value": 0.0 // 0 ... 1
                        },
                        {
@@ -120,7 +120,7 @@
                            "Value": 1.0 // 0 ... 1
                        },
                        {
-                            "Name": "m_smhMix",
+                            "Name": "m_smhWeight",
                            "Value": 0.0 // 0 ... 1
                        }
                    ],
@@ -92,8 +92,8 @@
                    ]
                },
                {
-                    "Name": "LookModificationTransformPass",
-                    "TemplateName": "LookModificationTransformTemplate",
+                    "Name": "HDRColorGradingPass",
+                    "TemplateName": "HDRColorGradingTemplate",
                    "Enabled": true,
                    "Connections": [
                        {
@@ -102,6 +102,20 @@
                                "Pass": "Parent",
                                "Attachment": "LightingInput"
                            }
+                        }
+                    ]
+                },
+                {
+                    "Name": "LookModificationTransformPass",
+                    "TemplateName": "LookModificationTransformTemplate",
+                    "Enabled": true,
+                    "Connections": [
+                        {
+                            "LocalSlot": "Input",
+                            "AttachmentRef": {
+                                "Pass": "HDRColorGradingPass",
+                                "Attachment": "Output"
+                            }
                        },
                        {
                            "LocalSlot": "EyeAdaptationDataInput",
@@ -50,13 +50,13 @@ ShaderResourceGroup PassSrg : SRG_PerPass_WithFallback
    float m_whiteBalanceKelvin;
    float m_whiteBalanceTint;
    float m_splitToneBalance;
-    float m_splitToneMix;
+    float m_splitToneWeight;
    float m_colorGradingPostSaturation;
    float m_smhShadowsStart;
    float m_smhShadowsEnd;
    float m_smhHighlightsStart;
    float m_smhHighlightsEnd;
-    float m_smhMix;
+    float m_smhWeight;

    float3 m_channelMixingRed;
    float3 m_channelMixingGreen;
@@ -69,9 +69,6 @@ ShaderResourceGroup PassSrg : SRG_PerPass_WithFallback
    float4 m_smhShadowsColor;
    float4 m_smhMidtonesColor;
    float4 m_smhHighlightsColor;
-
-    // my color grading output
-    float4 m_color;
 }

 float SaturateWithEpsilon(float value)
@@ -133,7 +130,7 @@ float3 NoNanPow(float3 base, float3 power)
    return pow(max(abs(base), float3(FloatEpsilon, FloatEpsilon, FloatEpsilon)), power);
 }

-float3 ColorGradeSplitTone (float3 frameColor, float balance, float mix) 
+float3 ColorGradeSplitTone (float3 frameColor, float balance, float weight) 
 {
    float3 frameSplitTone = NoNanPow(frameColor, 1.0 / 2.2);
    const float t = SaturateWithEpsilon(CalculateLuminance(SaturateWithEpsilon(frameSplitTone), ColorSpaceId::ACEScg) + balance);
@@ -142,7 +139,7 @@ float3 ColorGradeSplitTone (float3 frameColor, float balance, float mix)
    frameSplitTone = BlendMode_SoftLight(frameSplitTone, shadows);
    frameSplitTone = BlendMode_SoftLight(frameSplitTone, highlights);
    frameSplitTone = NoNanPow(frameSplitTone, 2.2);
-    return lerp(frameColor.rgb, frameSplitTone.rgb, mix);
+    return lerp(frameColor.rgb, frameSplitTone.rgb, weight);
 }

 float3 ColorGradeChannelMixer (float3 frameColor) 
@@ -154,7 +151,7 @@ float3 ColorGradeChannelMixer (float3 frameColor)
 }

 float3 ColorGradeShadowsMidtonesHighlights (float3 frameColor, float shadowsStart, float shadowsEnd, 
-                                            float highlightsStart, float highlightsEnd, float mix,
+                                            float highlightsStart, float highlightsEnd, float weight,
                                            float4 shadowsColor, float4 midtonesColor, float4 highlightsColor) 
 {
    const float3 shadowsColorACEScg = TransformColor(shadowsColor.rgb, ColorSpaceId::LinearSRGB, ColorSpaceId::ACEScg);
@@ -169,7 +166,7 @@ float3 ColorGradeShadowsMidtonesHighlights (float3 frameColor, float shadowsStar
    const float3 frameSmh = frameColor * shadowsColorACEScg * shadowsWeight +
                       frameColor * midtonesColorACEScg * midtonesWeight +
                       frameColor * highlightsColorACEScg * highlightsWeight;
-    return lerp(frameColor.rgb, frameSmh.rgb, mix);
+    return lerp(frameColor.rgb, frameSmh.rgb, weight);
 }

 float3 ColorGrade (float3 frameColor) 
@@ -181,11 +178,11 @@ float3 ColorGrade (float3 frameColor)
                                         PassSrg::m_colorFilterMultiply);
    frameColor = max(frameColor, 0.0);
    frameColor = ColorGradeSaturation(frameColor, PassSrg::m_colorGradingPreSaturation);
-    frameColor = ColorGradeSplitTone(frameColor, PassSrg::m_splitToneBalance, PassSrg::m_splitToneMix);
+    frameColor = ColorGradeSplitTone(frameColor, PassSrg::m_splitToneBalance, PassSrg::m_splitToneWeight);
    frameColor = ColorGradeChannelMixer(frameColor);
    frameColor = max(frameColor, 0.0);
    frameColor = ColorGradeShadowsMidtonesHighlights(frameColor, PassSrg::m_smhShadowsStart, PassSrg::m_smhShadowsEnd,
-                                                    PassSrg::m_smhHighlightsStart, PassSrg::m_smhHighlightsEnd, PassSrg::m_smhMix,
+                                                    PassSrg::m_smhHighlightsStart, PassSrg::m_smhHighlightsEnd, PassSrg::m_smhWeight,
                                                    PassSrg::m_smhShadowsColor, PassSrg::m_smhMidtonesColor, PassSrg::m_smhHighlightsColor);
    frameColor = ColorGradeHueShift(frameColor, PassSrg::m_colorGradingHueShift);
    frameColor = ColorGradeSaturation(frameColor, PassSrg::m_colorGradingPostSaturation);
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+// Macros below are of the form:
+// PARAM(NAME, MEMBER_NAME, DEFAULT_VALUE, ...)
+
+AZ_GFX_BOOL_PARAM(Enabled, m_enabled, false)
+AZ_GFX_FLOAT_PARAM(ColorGradingExposure, m_colorGradingExposure, 0.0)
+AZ_GFX_FLOAT_PARAM(ColorGradingContrast, m_colorGradingContrast, 0.0)
+AZ_GFX_FLOAT_PARAM(ColorGradingHueShift, m_colorGradingHueShift, 0.0)
+AZ_GFX_FLOAT_PARAM(ColorGradingPreSaturation, m_colorGradingPreSaturation, 1.0)
+AZ_GFX_FLOAT_PARAM(ColorGradingFilterIntensity, m_colorGradingFilterIntensity, 1.0)
+AZ_GFX_FLOAT_PARAM(ColorGradingFilterMultiply, m_colorGradingFilterMultiply, 0.0)
+AZ_GFX_FLOAT_PARAM(ColorGradingPostSaturation, m_colorGradingPostSaturation, 1.0)
+AZ_GFX_FLOAT_PARAM(WhiteBalanceKelvin, m_whiteBalanceKelvin, 6600.0)
+AZ_GFX_FLOAT_PARAM(WhiteBalanceTint, m_whiteBalanceTint, 0.0)
+AZ_GFX_FLOAT_PARAM(SplitToneBalance, m_splitToneBalance, 0.0)
+AZ_GFX_FLOAT_PARAM(SplitToneWeight, m_splitToneWeight, 0.0)
+AZ_GFX_FLOAT_PARAM(SmhShadowsStart, m_smhShadowsStart, 0.0)
+AZ_GFX_FLOAT_PARAM(SmhShadowsEnd, m_smhShadowsEnd, 0.3)
+AZ_GFX_FLOAT_PARAM(SmhHighlightsStart, m_smhHighlightsStart, 0.55)
+AZ_GFX_FLOAT_PARAM(SmhHighlightsEnd, m_smhHighlightsEnd, 1.0)
+AZ_GFX_FLOAT_PARAM(SmhWeight, m_smhWeight, 0.0)
+AZ_GFX_VEC3_PARAM(ChannelMixingRed, m_channelMixingRed, AZ::Vector3(1.0f, 0.0f, 0.0f))
+AZ_GFX_VEC3_PARAM(ChannelMixingGreen, m_channelMixingGreen, AZ::Vector3(0.0f, 1.0f, 0.0f))
+AZ_GFX_VEC3_PARAM(ChannelMixingBlue, m_channelMixingBlue, AZ::Vector3(0.0f, 0.f, 1.0f))
+AZ_GFX_VEC3_PARAM(ColorFilterSwatch, m_colorFilterSwatch, AZ::Vector3(1.0f, 0.5f, 0.5f))
+AZ_GFX_VEC3_PARAM(SplitToneShadowsColor, m_splitToneShadowsColor, AZ::Vector3(1.0f, 0.5f, 0.5f))
+AZ_GFX_VEC3_PARAM(SplitToneHighlightsColor, m_splitToneHighlightsColor, AZ::Vector3(0.1f, 1.0f, 0.1f))
+AZ_GFX_VEC3_PARAM(SmhShadowsColor, m_smhShadowsColor, AZ::Vector3(1.0f, 0.25f, 0.25f))
+AZ_GFX_VEC3_PARAM(SmhMidtonesColor, m_smhMidtonesColor, AZ::Vector3(0.1f, 0.1f, 1.0f))
+AZ_GFX_VEC3_PARAM(SmhHighlightsColor, m_smhHighlightsColor, AZ::Vector3(1.0f, 0.0f, 1.0f))
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Math/Vector3.h>
+#include <AzCore/Math/Vector4.h>
+#include <AzCore/RTTI/RTTI.h>
+#include <AzCore/Component/EntityId.h>
+
+namespace AZ
+{
+    namespace Render
+    {
+        class HDRColorGradingSettingsInterface
+        {
+        public:
+            AZ_RTTI(AZ::Render::HDRColorGradingSettingsInterface, "{CB5ADF78-27DE-438C-A991-1E5433046A42}");
+
+            // Auto-gen virtual getter and setter functions...
+#include <Atom/Feature/ParamMacros/StartParamFunctionsVirtual.inl>
+#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingParams.inl>
+#include <Atom/Feature/ParamMacros/EndParams.inl>
+
+            virtual void OnConfigChanged() = 0;
+        };
+    }
+}
@@ -25,3 +25,4 @@ POST_PROCESS_MEMBER(ExposureControlSettings, m_exposureControlSettings)
 POST_PROCESS_MEMBER(SsaoSettings, m_ssaoSettings)
 POST_PROCESS_MEMBER(LookModificationSettings, m_lookModificationSettings)
 POST_PROCESS_MEMBER(DeferredFogSettings, m_deferredFogSettings)
+POST_PROCESS_MEMBER(HDRColorGradingSettings, m_hdrColorGradingSettings)
@@ -14,6 +14,7 @@
 #include <Atom/Feature/PostProcess/ExposureControl/ExposureControlSettingsInterface.h>
 #include <Atom/Feature/PostProcess/Ssao/SsaoSettingsInterface.h>
 #include <Atom/Feature/PostProcess/LookModification/LookModificationSettingsInterface.h>
+#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingSettingsInterface.h>
 #include <Atom/Feature/ScreenSpace/DeferredFogSettingsInterface.h>
 #include <Atom/RPI.Public/View.h>

@@ -42,6 +42,7 @@
 #include <PostProcess/PostProcessFeatureProcessor.h>
 #include <PostProcessing/BlendColorGradingLutsPass.h>
 #include <PostProcessing/BloomParentPass.h>
+#include <PostProcessing/HDRColorGradingPass.h>
 #include <PostProcessing/DepthUpsamplePass.h>
 #include <PostProcessing/DepthOfFieldCompositePass.h>
 #include <PostProcessing/DepthOfFieldBokehBlurPass.h>
@@ -222,6 +223,7 @@ namespace AZ
            passSystem->AddPassCreator(Name("LightCullingRemapPass"), &LightCullingRemap::Create);
            passSystem->AddPassCreator(Name("LightCullingTilePreparePass"), &LightCullingTilePreparePass::Create);
            passSystem->AddPassCreator(Name("BlendColorGradingLutsPass"), &BlendColorGradingLutsPass::Create);
+            passSystem->AddPassCreator(Name("HDRColorGradingPass"), &HDRColorGradingPass::Create);
            passSystem->AddPassCreator(Name("LookModificationCompositePass"), &LookModificationCompositePass::Create);
            passSystem->AddPassCreator(Name("LookModificationTransformPass"), &LookModificationPass::Create);
            passSystem->AddPassCreator(Name("SMAAEdgeDetectionPass"), &SMAAEdgeDetectionPass::Create);
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+#include <AzCore/Serialization/SerializeContext.h>
+
+#include <PostProcess/ColorGrading/HDRColorGradingSettings.h>
+#include <PostProcess/PostProcessFeatureProcessor.h>
+
+namespace AZ
+{
+    namespace Render
+    {
+        HDRColorGradingSettings::HDRColorGradingSettings(PostProcessFeatureProcessor* featureProcessor)
+            : PostProcessBase(featureProcessor)
+        {
+        }
+
+        void HDRColorGradingSettings::OnConfigChanged()
+        {
+            m_parentSettings->OnConfigChanged();
+        }
+
+        void HDRColorGradingSettings::ApplySettingsTo(HDRColorGradingSettings* target, [[maybe_unused]] float alpha) const
+        {
+            AZ_Assert(target != nullptr, "HDRColorGradingSettings::ApplySettingsTo called with nullptr as argument.");
+
+            if (GetEnabled())
+            {
+                target->m_enabled = m_enabled;
+
+#define AZ_GFX_BOOL_PARAM(NAME, MEMBER_NAME, DefaultValue) ;
+#define AZ_GFX_FLOAT_PARAM(NAME, MEMBER_NAME, DefaultValue)                                                  \
+    {                                                                                                        \
+                target->Set##NAME(AZ::Lerp(target->MEMBER_NAME, MEMBER_NAME, alpha));                        \
+    }
+
+#define AZ_GFX_VEC3_PARAM(NAME, MEMBER_NAME, DefaultValue)                                                   \
+    {                                                                                                        \
+                target->MEMBER_NAME.Set(AZ::Lerp(target->MEMBER_NAME.GetX(), MEMBER_NAME.GetX(), alpha),     \
+                    AZ::Lerp(target->MEMBER_NAME.GetY(), MEMBER_NAME.GetY(), alpha),                         \
+                    AZ::Lerp(target->MEMBER_NAME.GetZ(), MEMBER_NAME.GetZ(), alpha));                        \
+    }
+
+#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingParams.inl>
+#include <Atom/Feature/ParamMacros/EndParams.inl>
+            }
+        }
+
+        void HDRColorGradingSettings::Simulate([[maybe_unused]] float deltaTime)
+        {
+        }
+    } // namespace Render
+} // namespace AZ
+
+
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+ 
+#pragma once
+
+#include <AzCore/RTTI/ReflectContext.h>
+
+#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingSettingsInterface.h>
+
+#include <PostProcess/PostProcessBase.h>
+
+namespace AZ
+{
+    namespace Render
+    {
+        class PostProcessSettings;
+        
+        class HDRColorGradingSettings final
+            : public HDRColorGradingSettingsInterface
+            , public PostProcessBase
+        {
+            friend class PostProcessSettings;
+            friend class PostProcessFeatureProcessor;
+
+        public:
+            AZ_RTTI(HDRColorGradingSettings, "{EA8C05D4-66D0-4141-8D4D-68E5D764C2ED}", HDRColorGradingSettingsInterface, PostProcessBase);
+            AZ_CLASS_ALLOCATOR(HDRColorGradingSettings, SystemAllocator, 0);
+
+            HDRColorGradingSettings(PostProcessFeatureProcessor* featureProcessor);
+            ~HDRColorGradingSettings() = default;
+
+            void OnConfigChanged() override;
+
+            void ApplySettingsTo(HDRColorGradingSettings* target, float alpha) const;
+
+            // Generate all getters and override setters.
+            // Declare non-override setters, which will be defined in the .cpp
+#define AZ_GFX_COMMON_PARAM(ValueType, Name, MemberName, DefaultValue)                                  \
+        ValueType Get##Name() const override { return MemberName; }                                     \
+        void Set##Name(ValueType val) override                                                          \
+        {                                                                                               \
+            MemberName = val;                                                                           \
+        }                                                                                               \
+
+#define AZ_GFX_COMMON_OVERRIDE(ValueType, Name, MemberName, OverrideValueType)                          \
+        OverrideValueType Get##Name##Override() const override { return MemberName##Override; }         \
+        void Set##Name##Override(OverrideValueType val) override { MemberName##Override = val; }        \
+
+#include <Atom/Feature/ParamMacros/MapAllCommon.inl>
+#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingParams.inl>
+#include <Atom/Feature/ParamMacros/EndParams.inl>
+
+        private:
+            // Generate members...
+#include <Atom/Feature/ParamMacros/StartParamMembers.inl>
+#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingParams.inl>
+#include <Atom/Feature/ParamMacros/EndParams.inl>
+
+            void Simulate(float deltaTime);
+
+            PostProcessSettings* m_parentSettings = nullptr;
+        };
+    }
+}
@@ -17,6 +17,7 @@
 #include <PostProcess/ExposureControl/ExposureControlSettings.h>
 #include <PostProcess/Ssao/SsaoSettings.h>
 #include <PostProcess/LookModification/LookModificationSettings.h>
+#include <PostProcess/ColorGrading/HDRColorGradingSettings.h>
 #include <ScreenSpace/DeferredFogSettings.h>

 namespace AZ
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+ 
+#include <PostProcessing/HDRColorGradingPass.h>
+#include <PostProcess/PostProcessFeatureProcessor.h>
+
+#include <Atom/RPI.Public/RenderPipeline.h>
+#include <Atom/RPI.Public/Scene.h>
+#include <Atom/RPI.Public/View.h>
+
+ namespace AZ
+{
+    namespace Render
+    {
+        RPI::Ptr<HDRColorGradingPass> HDRColorGradingPass::Create(const RPI::PassDescriptor& descriptor)
+        {
+            RPI::Ptr<HDRColorGradingPass> pass = aznew HDRColorGradingPass(descriptor);
+            return AZStd::move(pass);
+        }
+        
+        HDRColorGradingPass::HDRColorGradingPass(const RPI::PassDescriptor& descriptor)
+            : AZ::RPI::FullscreenTrianglePass(descriptor)
+        {
+        }
+        
+        void HDRColorGradingPass::InitializeInternal()
+        {
+            FullscreenTrianglePass::InitializeInternal();
+
+            m_colorGradingExposureIndex.Reset();
+            m_colorGradingContrastIndex.Reset();
+            m_colorGradingHueShiftIndex.Reset();
+            m_colorGradingPreSaturationIndex.Reset();
+            m_colorFilterIntensityIndex.Reset();
+            m_colorFilterMultiplyIndex.Reset();
+            m_whiteBalanceKelvinIndex.Reset();
+            m_whiteBalanceTintIndex.Reset();
+            m_splitToneBalanceIndex.Reset();
+            m_splitToneWeightIndex.Reset();
+            m_colorGradingPostSaturationIndex.Reset();
+            m_smhShadowsStartIndex.Reset();
+            m_smhShadowsEndIndex.Reset();
+            m_smhHighlightsStartIndex.Reset();
+            m_smhHighlightsEndIndex.Reset();
+            m_smhWeightIndex.Reset();
+
+            m_channelMixingRedIndex.Reset();
+            m_channelMixingGreenIndex.Reset();
+            m_channelMixingBlueIndex.Reset();
+
+            m_colorFilterSwatchIndex.Reset();
+            m_splitToneShadowsColorIndex.Reset();
+            m_splitToneHighlightsColorIndex.Reset();
+            m_smhShadowsColorIndex.Reset();
+            m_smhMidtonesColorIndex.Reset();
+            m_smhHighlightsColorIndex.Reset();
+        }
+        
+        void HDRColorGradingPass::FrameBeginInternal(FramePrepareParams params)
+        {
+            SetSrgConstants();
+
+            FullscreenTrianglePass::FrameBeginInternal(params);
+        }
+
+        bool HDRColorGradingPass::IsEnabled() const
+        {
+            const auto* colorGradingSettings = GetHDRColorGradingSettings();
+            return colorGradingSettings ? colorGradingSettings->GetEnabled() : false;
+        }
+
+        void HDRColorGradingPass::SetSrgConstants()
+        {
+            const HDRColorGradingSettings* settings = GetHDRColorGradingSettings();
+            if (settings)
+            {
+                m_shaderResourceGroup->SetConstant(m_colorGradingExposureIndex, settings->GetColorGradingExposure());
+                m_shaderResourceGroup->SetConstant(m_colorGradingContrastIndex, settings->GetColorGradingContrast());
+                m_shaderResourceGroup->SetConstant(m_colorGradingHueShiftIndex, settings->GetColorGradingHueShift());
+                m_shaderResourceGroup->SetConstant(m_colorGradingPreSaturationIndex, settings->GetColorGradingPreSaturation());
+                m_shaderResourceGroup->SetConstant(m_colorFilterIntensityIndex, settings->GetColorGradingFilterIntensity());
+                m_shaderResourceGroup->SetConstant(m_colorFilterMultiplyIndex, settings->GetColorGradingFilterMultiply());
+                m_shaderResourceGroup->SetConstant(m_whiteBalanceKelvinIndex, settings->GetWhiteBalanceKelvin());
+                m_shaderResourceGroup->SetConstant(m_whiteBalanceTintIndex, settings->GetWhiteBalanceTint());
+                m_shaderResourceGroup->SetConstant(m_splitToneBalanceIndex, settings->GetSplitToneBalance());
+                m_shaderResourceGroup->SetConstant(m_splitToneWeightIndex, settings->GetSplitToneWeight());
+                m_shaderResourceGroup->SetConstant(m_colorGradingPostSaturationIndex, settings->GetColorGradingPostSaturation());
+                m_shaderResourceGroup->SetConstant(m_smhShadowsStartIndex, settings->GetSmhShadowsStart());
+                m_shaderResourceGroup->SetConstant(m_smhShadowsEndIndex, settings->GetSmhShadowsEnd());
+                m_shaderResourceGroup->SetConstant(m_smhHighlightsStartIndex, settings->GetSmhHighlightsStart());
+                m_shaderResourceGroup->SetConstant(m_smhHighlightsEndIndex, settings->GetSmhHighlightsEnd());
+                m_shaderResourceGroup->SetConstant(m_smhWeightIndex, settings->GetSmhWeight());
+
+                m_shaderResourceGroup->SetConstant(m_channelMixingRedIndex, settings->GetChannelMixingRed());
+                m_shaderResourceGroup->SetConstant(m_channelMixingGreenIndex, settings->GetChannelMixingGreen());
+                m_shaderResourceGroup->SetConstant(m_channelMixingBlueIndex, settings->GetChannelMixingBlue());
+
+                m_shaderResourceGroup->SetConstant(m_colorFilterSwatchIndex, AZ::Vector4(settings->GetColorFilterSwatch()));
+                m_shaderResourceGroup->SetConstant(m_splitToneShadowsColorIndex, AZ::Vector4(settings->GetSplitToneShadowsColor()));
+                m_shaderResourceGroup->SetConstant(m_splitToneHighlightsColorIndex, AZ::Vector4(settings->GetSplitToneHighlightsColor()));
+                m_shaderResourceGroup->SetConstant(m_smhShadowsColorIndex, AZ::Vector4(settings->GetSmhShadowsColor()));
+                m_shaderResourceGroup->SetConstant(m_smhMidtonesColorIndex, AZ::Vector4(settings->GetSmhMidtonesColor()));
+                m_shaderResourceGroup->SetConstant(m_smhHighlightsColorIndex, AZ::Vector4(settings->GetSmhHighlightsColor()));
+            }
+        }
+
+        const AZ::Render::HDRColorGradingSettings* HDRColorGradingPass::GetHDRColorGradingSettings() const
+        {
+            RPI::Scene* scene = GetScene();
+            if (scene)
+            {
+                PostProcessFeatureProcessor* fp = scene->GetFeatureProcessor<PostProcessFeatureProcessor>();
+                AZ::RPI::ViewPtr view = scene->GetDefaultRenderPipeline()->GetDefaultView();
+                if (fp)
+                {
+                    PostProcessSettings* postProcessSettings = fp->GetLevelSettingsFromView(view);
+                    if (postProcessSettings)
+                    {
+                        const HDRColorGradingSettings* colorGradingSettings = postProcessSettings->GetHDRColorGradingSettings();
+                        if (colorGradingSettings != nullptr && colorGradingSettings->GetEnabled())
+                        {
+                            return postProcessSettings->GetHDRColorGradingSettings();
+                        }
+                    }
+                }
+            }
+            return nullptr;
+        }
+    }
+}
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+#pragma once
+
+#include <Atom/RPI.Reflect/Shader/ShaderVariantKey.h>
+#include <Atom/RPI.Public/Pass/FullscreenTrianglePass.h>
+#include <Atom/RPI.Public/Shader/Shader.h>
+#include <Atom/RPI.Public/Shader/ShaderResourceGroup.h>
+#include <PostProcess/ColorGrading/HDRColorGradingSettings.h>
+
+namespace AZ
+{
+    namespace Render
+    {
+        /**
+         *  The color grading pass.
+         */
+        class HDRColorGradingPass
+            : public AZ::RPI::FullscreenTrianglePass
+            //TODO: , public PostProcessingShaderOptionBase
+        {
+        public:
+            AZ_RTTI(HDRColorGradingPass, "{E68E31A1-DB24-4AFF-A029-456A8B74C03C}", AZ::RPI::FullscreenTrianglePass);
+            AZ_CLASS_ALLOCATOR(HDRColorGradingPass, SystemAllocator, 0);
+
+            virtual ~HDRColorGradingPass() = default;
+
+            //! Creates a ColorGradingPass
+            static RPI::Ptr<HDRColorGradingPass> Create(const RPI::PassDescriptor& descriptor);
+
+        protected:
+            HDRColorGradingPass(const RPI::PassDescriptor& descriptor);
+            
+            //! Pass behavior overrides
+            void InitializeInternal() override;
+            void FrameBeginInternal(FramePrepareParams params) override;
+            bool IsEnabled() const override;
+
+        private:
+            const HDRColorGradingSettings* GetHDRColorGradingSettings() const;
+            void SetSrgConstants();
+
+            RHI::ShaderInputNameIndex m_colorGradingExposureIndex = "m_colorGradingExposure";
+            RHI::ShaderInputNameIndex m_colorGradingContrastIndex = "m_colorGradingContrast";
+            RHI::ShaderInputNameIndex m_colorGradingHueShiftIndex = "m_colorGradingHueShift";
+            RHI::ShaderInputNameIndex m_colorGradingPreSaturationIndex = "m_colorGradingPreSaturation";
+            RHI::ShaderInputNameIndex m_colorFilterIntensityIndex = "m_colorFilterIntensity";
+            RHI::ShaderInputNameIndex m_colorFilterMultiplyIndex = "m_colorFilterMultiply";
+            RHI::ShaderInputNameIndex m_whiteBalanceKelvinIndex = "m_whiteBalanceKelvin";
+            RHI::ShaderInputNameIndex m_whiteBalanceTintIndex = "m_whiteBalanceTint";
+            RHI::ShaderInputNameIndex m_splitToneBalanceIndex = "m_splitToneBalance";
+            RHI::ShaderInputNameIndex m_splitToneWeightIndex = "m_splitToneWeight";
+            RHI::ShaderInputNameIndex m_colorGradingPostSaturationIndex = "m_colorGradingPostSaturation";
+            RHI::ShaderInputNameIndex m_smhShadowsStartIndex = "m_smhShadowsStart";
+            RHI::ShaderInputNameIndex m_smhShadowsEndIndex = "m_smhShadowsEnd";
+            RHI::ShaderInputNameIndex m_smhHighlightsStartIndex = "m_smhHighlightsStart";
+            RHI::ShaderInputNameIndex m_smhHighlightsEndIndex = "m_smhHighlightsEnd";
+            RHI::ShaderInputNameIndex m_smhWeightIndex = "m_smhWeight";
+
+            RHI::ShaderInputNameIndex m_channelMixingRedIndex = "m_channelMixingRed";
+            RHI::ShaderInputNameIndex m_channelMixingGreenIndex = "m_channelMixingGreen";
+            RHI::ShaderInputNameIndex m_channelMixingBlueIndex = "m_channelMixingBlue";
+
+            RHI::ShaderInputNameIndex m_colorFilterSwatchIndex = "m_colorFilterSwatch";
+            RHI::ShaderInputNameIndex m_splitToneShadowsColorIndex = "m_splitToneShadowsColor";
+            RHI::ShaderInputNameIndex m_splitToneHighlightsColorIndex = "m_splitToneHighlightsColor";
+            RHI::ShaderInputNameIndex m_smhShadowsColorIndex = "m_smhShadowsColor";
+            RHI::ShaderInputNameIndex m_smhMidtonesColorIndex = "m_smhMidtonesColor";
+            RHI::ShaderInputNameIndex m_smhHighlightsColorIndex = "m_smhHighlightsColor";
+        };
+    }   // namespace Render
+}   // namespace AZ
@@ -183,6 +183,8 @@ set(FILES
    Source/PostProcess/PostProcessFeatureProcessor.h
    Source/PostProcess/PostProcessSettings.cpp
    Source/PostProcess/PostProcessSettings.h
+    Source/PostProcess/ColorGrading/HDRColorGradingSettings.h
+    Source/PostProcess/ColorGrading/HDRColorGradingSettings.cpp
    Source/PostProcess/Bloom/BloomSettings.cpp
    Source/PostProcess/Bloom/BloomSettings.h
    Source/PostProcess/DepthOfField/DepthOfFieldSettings.cpp
@@ -205,6 +207,8 @@ set(FILES
    Source/PostProcessing/BloomCompositePass.cpp
    Source/PostProcessing/BloomParentPass.h
    Source/PostProcessing/BloomParentPass.cpp
+    Source/PostProcessing/HDRColorGradingPass.cpp
+    Source/PostProcessing/HDRColorGradingPass.h
    Source/PostProcessing/DepthOfFieldCompositePass.h
    Source/PostProcessing/DepthOfFieldCompositePass.cpp
    Source/PostProcessing/DepthOfFieldBokehBlurPass.h
@@ -51,6 +51,8 @@ set(FILES
    Include/Atom/Feature/PostProcess/Bloom/BloomConstants.h
    Include/Atom/Feature/PostProcess/Bloom/BloomParams.inl
    Include/Atom/Feature/PostProcess/Bloom/BloomSettingsInterface.h
+    Include/Atom/Feature/PostProcess/ColorGrading/HDRColorGradingParams.inl
+    Include/Atom/Feature/PostProcess/ColorGrading/HDRColorGradingSettingsInterface.h
    Include/Atom/Feature/PostProcess/DepthOfField/DepthOfFieldConstants.h
    Include/Atom/Feature/PostProcess/DepthOfField/DepthOfFieldParams.inl
    Include/Atom/Feature/PostProcess/DepthOfField/DepthOfFieldSettingsInterface.h