Merge remote-tracking branch 'origin/development' into component-doc-links

2021-09-27 00:44:18 -04:00
parent c2a3351676 2ce7bbd945
commit bf58638505
696 changed files with 18658 additions and 9872 deletions
@@ -0,0 +1,145 @@
+/*
+ * 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 <PostProcess/ColorGrading/EditorHDRColorGradingComponent.h>
+
+namespace AZ
+{
+    namespace Render
+    {
+        void EditorHDRColorGradingComponent::Reflect(AZ::ReflectContext* context)
+        {
+            BaseClass::Reflect(context);
+
+            if (AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+            {
+                serializeContext->Class<EditorHDRColorGradingComponent, BaseClass>()->Version(1);
+
+                if (AZ::EditContext* editContext = serializeContext->GetEditContext())
+                {
+                    editContext->Class<EditorHDRColorGradingComponent>(
+                        "HDR Color Grading", "Tune and apply color grading in HDR.")
+                        ->ClassElement(Edit::ClassElements::EditorData, "")
+                        ->Attribute(Edit::Attributes::Category, "Atom")
+                        ->Attribute(AZ::Edit::Attributes::Icon, "Icons/Components/Component_Placeholder.svg") // [GFX TODO ATOM-2672][PostFX] need to create icons for PostProcessing.
+                        ->Attribute(AZ::Edit::Attributes::ViewportIcon, "Icons/Components/Viewport/Component_Placeholder.svg") // [GFX TODO ATOM-2672][PostFX] need to create icons for PostProcessing.
+                        ->Attribute(Edit::Attributes::AppearsInAddComponentMenu, AZ_CRC_CE("Game"))
+                        ->Attribute(Edit::Attributes::AutoExpand, true)
+                        ->Attribute(Edit::Attributes::HelpPageURL, "https://") // [TODO ATOM-2672][PostFX] need to create page for PostProcessing.
+                        ;
+
+                    editContext->Class<HDRColorGradingComponentController>(
+                        "HDRColorGradingComponentControl", "")
+                        ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                        ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                        ->DataElement(AZ::Edit::UIHandlers::Default, &HDRColorGradingComponentController::m_configuration, "Configuration", "")
+                        ->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly)
+                        ;
+
+                    editContext->Class<HDRColorGradingComponentConfig>("HDRColorGradingComponentConfig", "")
+                        ->DataElement(Edit::UIHandlers::CheckBox, &HDRColorGradingComponentConfig::m_enabled,
+                            "Enable HDR color grading",
+                            "Enable HDR color grading.")
+                        ->ClassElement(AZ::Edit::ClassElements::Group, "Color Adjustment")
+                        ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_colorGradingExposure, "Exposure", "Exposure Value")
+                            ->Attribute(Edit::Attributes::Min, AZStd::numeric_limits<float>::lowest())
+                            ->Attribute(Edit::Attributes::Max, AZStd::numeric_limits<float>::max())
+                            ->Attribute(Edit::Attributes::SoftMin, -20.0f)
+                            ->Attribute(Edit::Attributes::SoftMax, 20.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_colorGradingContrast, "Contrast", "Contrast Value")
+                            ->Attribute(Edit::Attributes::Min, -100.0f)
+                            ->Attribute(Edit::Attributes::Max, 100.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_colorGradingPreSaturation, "Pre Saturation", "Pre Saturation Value")
+                            ->Attribute(Edit::Attributes::Min, -100.0f)
+                            ->Attribute(Edit::Attributes::Max, 100.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_colorGradingFilterIntensity, "Filter Intensity", "Filter Intensity Value")
+                            ->Attribute(Edit::Attributes::Min, AZStd::numeric_limits<float>::lowest())
+                            ->Attribute(Edit::Attributes::Max, AZStd::numeric_limits<float>::max())
+                            ->Attribute(Edit::Attributes::SoftMin, -1.0f)
+                            ->Attribute(Edit::Attributes::SoftMax, 1.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_colorGradingFilterMultiply, "Filter Multiply", "Filter Multiply Value")
+                            ->Attribute(Edit::Attributes::Min, 0.0f)
+                            ->Attribute(Edit::Attributes::Max, 1.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Color, &HDRColorGradingComponentConfig::m_colorFilterSwatch, "Color Filter Swatch", "Color Filter Swatch Value")
+
+                        ->ClassElement(AZ::Edit::ClassElements::Group, "White Balance")
+                        ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_whiteBalanceKelvin, "Temperature", "Temperature in Kelvin")
+                            ->Attribute(Edit::Attributes::Min, 1000.0f)
+                            ->Attribute(Edit::Attributes::Max, 40000.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_whiteBalanceTint, "Tint", "Tint Value")
+                            ->Attribute(Edit::Attributes::Min, -100.0f)
+                            ->Attribute(Edit::Attributes::Max, 100.0f)
+
+                        ->ClassElement(AZ::Edit::ClassElements::Group, "Split Toning")
+                        ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_splitToneWeight, "Split Tone Weight", "Modulates the split toning effect.")
+                            ->Attribute(Edit::Attributes::Min, 0.0f)
+                            ->Attribute(Edit::Attributes::Max, 1.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_splitToneBalance, "Split Tone Balance", "Split Tone Balance Value")
+                            ->Attribute(Edit::Attributes::Min, 0.0f)
+                            ->Attribute(Edit::Attributes::Max, 1.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Color, &HDRColorGradingComponentConfig::m_splitToneShadowsColor, "Split Tone Shadows Color", "Split Tone Shadows Color")
+                        ->DataElement(AZ::Edit::UIHandlers::Color, &HDRColorGradingComponentConfig::m_splitToneHighlightsColor, "Split Tone Highlights Color", "Split Tone Highlights Color")
+
+                        ->ClassElement(AZ::Edit::ClassElements::Group, "Channel Mixing")
+                        ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_channelMixingRed, "Channel Mixing Red", "Channel Mixing Red Value")
+                            ->Attribute(Edit::Attributes::Min, 0.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_channelMixingGreen, "Channel Mixing Green", "Channel Mixing Green Value")
+                            ->Attribute(Edit::Attributes::Min, 0.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_channelMixingBlue, "Channel Mixing Blue", "Channel Mixing Blue Value")
+                            ->Attribute(Edit::Attributes::Min, 0.0f)
+
+                        ->ClassElement(AZ::Edit::ClassElements::Group, "Shadow Midtones Highlights")
+                        ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_smhWeight, "SMH Weight", "Modulates the SMH effect.")
+                            ->Attribute(Edit::Attributes::Min, 0.0f)
+                            ->Attribute(Edit::Attributes::Max, 1.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_smhShadowsStart, "SMH Shadows Start", "SMH Shadows Start Value")
+                            ->Attribute(Edit::Attributes::Min, 0.0f)
+                            ->Attribute(Edit::Attributes::Max, 1.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_smhShadowsEnd, "SMH Shadows End", "SMH Shadows End Value")
+                            ->Attribute(Edit::Attributes::Min, 0.0f)
+                            ->Attribute(Edit::Attributes::Max, 1.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_smhHighlightsStart, "SMH Highlights Start", "SMH Highlights Start Value")
+                            ->Attribute(Edit::Attributes::Min, 0.0f)
+                            ->Attribute(Edit::Attributes::Max, 1.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_smhHighlightsEnd, "SMH Highlights End", "SMH Highlights End Value")
+                            ->Attribute(Edit::Attributes::Min, 0.0f)
+                            ->Attribute(Edit::Attributes::Max, 1.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Color, &HDRColorGradingComponentConfig::m_smhShadowsColor, "SMH Shadows Color", "SMH Shadows Color")
+                        ->DataElement(AZ::Edit::UIHandlers::Color, &HDRColorGradingComponentConfig::m_smhMidtonesColor, "SMH Midtones Color", "SMH Midtones Color")
+                        ->DataElement(AZ::Edit::UIHandlers::Color, &HDRColorGradingComponentConfig::m_smhHighlightsColor, "SMH Highlights Color", "SMH Highlights Color")
+
+                        ->ClassElement(AZ::Edit::ClassElements::Group, "Final Adjustment")
+                        ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_colorGradingHueShift, "Hue Shift", "Hue Shift Value")
+                            ->Attribute(Edit::Attributes::Min, 0.0f)
+                            ->Attribute(Edit::Attributes::Max, 1.0f)
+                        ->DataElement(AZ::Edit::UIHandlers::Slider, &HDRColorGradingComponentConfig::m_colorGradingPostSaturation, "Post Saturation", "Post Saturation Value")
+                            ->Attribute(Edit::Attributes::Min, -100.0f)
+                            ->Attribute(Edit::Attributes::Max, 100.0f)
+                        ;
+                }
+            }
+        }
+
+        EditorHDRColorGradingComponent::EditorHDRColorGradingComponent(const HDRColorGradingComponentConfig& config)
+            : BaseClass(config)
+        {
+        }
+
+        u32 EditorHDRColorGradingComponent::OnConfigurationChanged()
+        {
+            m_controller.OnConfigChanged();
+            return Edit::PropertyRefreshLevels::AttributesAndValues;
+        }
+    } // namespace Render
+} // namespace AZ
@@ -0,0 +1,35 @@
+/*
+ * 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 <AzToolsFramework/ToolsComponents/EditorComponentAdapter.h>
+#include <PostProcess/ColorGrading/HDRColorGradingComponent.h>
+
+namespace AZ
+{
+    namespace Render
+    {
+        class EditorHDRColorGradingComponent final
+            : public AzToolsFramework::Components::
+                  EditorComponentAdapter<HDRColorGradingComponentController, HDRColorGradingComponent, HDRColorGradingComponentConfig>
+        {
+        public:
+            using BaseClass = AzToolsFramework::Components::EditorComponentAdapter<HDRColorGradingComponentController, HDRColorGradingComponent, HDRColorGradingComponentConfig>;
+            AZ_EDITOR_COMPONENT(AZ::Render::EditorHDRColorGradingComponent, "{C1FAB0B1-5847-4533-B08E-7314AC807B8E}", BaseClass);
+
+            static void Reflect(AZ::ReflectContext* context);
+
+            EditorHDRColorGradingComponent() = default;
+            EditorHDRColorGradingComponent(const HDRColorGradingComponentConfig& config);
+
+            //! EditorRenderComponentAdapter overrides...
+            AZ::u32 OnConfigurationChanged() override;
+        };
+    } // namespace Render
+} // namespace AZ
@@ -0,0 +1,30 @@
+/*
+ * 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 <PostProcess/ColorGrading/HDRColorGradingComponent.h>
+
+namespace AZ
+{
+    namespace Render
+    {
+        HDRColorGradingComponent::HDRColorGradingComponent(const HDRColorGradingComponentConfig& config)
+            : BaseClass(config)
+        {
+        }
+
+        void HDRColorGradingComponent::Reflect(AZ::ReflectContext* context)
+        {
+            BaseClass::Reflect(context);
+
+            if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+            {
+                serializeContext->Class<HDRColorGradingComponent, BaseClass>();
+            }
+        }
+    } // namespace Render
+} // namespace AZ
@@ -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/Component/Component.h>
+#include <AzFramework/Components/ComponentAdapter.h>
+#include <PostProcess/ColorGrading/HDRColorGradingComponentController.h>
+#include <AtomLyIntegration/CommonFeatures/PostProcess/ColorGrading/HDRColorGradingComponentConfig.h>
+
+namespace AZ
+{
+    namespace Render
+    {
+        class HDRColorGradingComponent final
+            : public AzFramework::Components::ComponentAdapter<HDRColorGradingComponentController, HDRColorGradingComponentConfig>
+        {
+        public:
+            using BaseClass = AzFramework::Components::ComponentAdapter<HDRColorGradingComponentController, HDRColorGradingComponentConfig>;
+            AZ_COMPONENT(AZ::Render::HDRColorGradingComponent, "{51968E0F-4DF0-4851-8405-388CBB15B573}", BaseClass);
+
+            HDRColorGradingComponent() = default;
+            HDRColorGradingComponent(const HDRColorGradingComponentConfig& config);
+
+            static void Reflect(AZ::ReflectContext* context);
+        };
+    } // namespace Render
+} // namespace AZ
@@ -0,0 +1,47 @@
+/*
+ * 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 <AtomLyIntegration/CommonFeatures/PostProcess/ColorGrading/HDRColorGradingComponentConfig.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/Serialization/EditContext.h>
+
+namespace AZ
+{
+    namespace Render
+    {
+        void HDRColorGradingComponentConfig::Reflect(ReflectContext* context)
+        {
+            if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+            {
+                serializeContext->Class<HDRColorGradingComponentConfig, ComponentConfig>()->Version(0)
+
+                // Auto-gen serialize context code...
+#define SERIALIZE_CLASS HDRColorGradingComponentConfig
+#include <Atom/Feature/ParamMacros/StartParamSerializeContext.inl>
+#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingParams.inl>
+#include <Atom/Feature/ParamMacros/EndParams.inl>
+#undef SERIALIZE_CLASS
+                    ;
+            }
+        }
+
+        void HDRColorGradingComponentConfig::CopySettingsTo (HDRColorGradingSettingsInterface* settings)
+        {
+            if (!settings)
+            {
+                return;
+            }
+
+#define COPY_TARGET settings
+#include <Atom/Feature/ParamMacros/StartParamCopySettingsTo.inl>
+#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingParams.inl>
+#include <Atom/Feature/ParamMacros/EndParams.inl>
+#undef COPY_TARGET
+        }
+    } // namespace Render
+} // namespace AZ
@@ -0,0 +1,146 @@
+/*
+ * 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/RTTI/BehaviorContext.h>
+
+#include <Atom/RPI.Public/Scene.h>
+
+#include <PostProcess/ColorGrading/HDRColorGradingComponentController.h>
+
+namespace AZ
+{
+    namespace Render
+    {
+        void HDRColorGradingComponentController::Reflect(ReflectContext* context)
+        {
+            HDRColorGradingComponentConfig::Reflect(context);
+
+            if (auto* serializeContext = azrtti_cast<SerializeContext*>(context))
+            {
+                serializeContext->Class<HDRColorGradingComponentController>()
+                    ->Version(0)
+                    ->Field("Configuration", &HDRColorGradingComponentController::m_configuration);
+            }
+
+            if (auto* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+            {
+                behaviorContext->EBus<HDRColorGradingRequestBus>("HDRColorGradingRequestBus")
+                    ->Attribute(AZ::Script::Attributes::Module, "render")
+                    ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+
+                    // Auto-gen behavior context...
+#define PARAM_EVENT_BUS HDRColorGradingRequestBus::Events
+#include <Atom/Feature/ParamMacros/StartParamBehaviorContext.inl>
+#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingParams.inl>
+#include <Atom/Feature/ParamMacros/EndParams.inl>
+#undef PARAM_EVENT_BUS
+
+                    ;
+            }
+        }
+
+        void HDRColorGradingComponentController::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
+        {
+            provided.push_back(AZ_CRC_CE("HDRColorGradingService"));
+        }
+
+        void HDRColorGradingComponentController::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
+        {
+            incompatible.push_back(AZ_CRC_CE("HDRColorGradingService"));
+        }
+
+        void HDRColorGradingComponentController::GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required)
+        {
+            required.push_back(AZ_CRC_CE("PostFXLayerService"));
+        }
+
+        HDRColorGradingComponentController::HDRColorGradingComponentController(const HDRColorGradingComponentConfig& config)
+            : m_configuration(config)
+        {
+        }
+
+        void HDRColorGradingComponentController::Activate(EntityId entityId)
+        {
+            m_entityId = entityId;
+
+            PostProcessFeatureProcessorInterface* fp =
+                RPI::Scene::GetFeatureProcessorForEntity<PostProcessFeatureProcessorInterface>(m_entityId);
+            if (fp)
+            {
+                m_postProcessInterface = fp->GetOrCreateSettingsInterface(m_entityId);
+                if (m_postProcessInterface)
+                {
+                    m_settingsInterface = m_postProcessInterface->GetOrCreateHDRColorGradingSettingsInterface();
+                    OnConfigChanged();
+                }
+            }
+            HDRColorGradingRequestBus::Handler::BusConnect(m_entityId);
+        }
+
+        void HDRColorGradingComponentController::Deactivate()
+        {
+            HDRColorGradingRequestBus::Handler::BusDisconnect(m_entityId);
+
+            if (m_postProcessInterface)
+            {
+                m_postProcessInterface->RemoveHDRColorGradingSettingsInterface();
+            }
+
+            m_postProcessInterface = nullptr;
+            m_settingsInterface = nullptr;
+            m_entityId.SetInvalid();
+        }
+
+        void HDRColorGradingComponentController::SetConfiguration(const HDRColorGradingComponentConfig& config)
+        {
+            m_configuration = config;
+            OnConfigChanged();
+        }
+
+        const HDRColorGradingComponentConfig& HDRColorGradingComponentController::GetConfiguration() const
+        {
+            return m_configuration;
+        }
+
+        void HDRColorGradingComponentController::OnConfigChanged()
+        {
+            if (m_settingsInterface)
+            {
+                m_configuration.CopySettingsTo(m_settingsInterface);
+                m_settingsInterface->OnConfigChanged();
+            }
+        }
+
+        // Auto-gen getter/setter function definitions...
+        // The setter functions will set the values on the Atom settings class, then get the value back
+        // from the settings class to set the local configuration. This is in case the settings class
+        // applies some custom logic that results in the set value being different from the input
+#define AZ_GFX_COMMON_PARAM(ValueType, Name, MemberName, DefaultValue)                                                                         \
+        ValueType HDRColorGradingComponentController::Get##Name() const                                                                        \
+        {                                                                                                                                      \
+            return m_configuration.MemberName;                                                                                                 \
+        }                                                                                                                                      \
+        void HDRColorGradingComponentController::Set##Name(ValueType val)                                                                      \
+        {                                                                                                                                      \
+            if (m_settingsInterface)                                                                                                           \
+            {                                                                                                                                  \
+                m_settingsInterface->Set##Name(val);                                                                                           \
+                m_settingsInterface->OnConfigChanged();                                                                                        \
+                m_configuration.MemberName = m_settingsInterface->Get##Name();                                                                 \
+            }                                                                                                                                  \
+            else                                                                                                                               \
+            {                                                                                                                                  \
+                m_configuration.MemberName = val;                                                                                              \
+            }                                                                                                                                  \
+        }
+
+#include <Atom/Feature/ParamMacros/MapAllCommon.inl>
+#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingParams.inl>
+#include <Atom/Feature/ParamMacros/EndParams.inl>
+    } // namespace Render
+} // namespace AZ
@@ -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
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Component/Component.h>
+#include <AtomLyIntegration/CommonFeatures/PostProcess/ColorGrading/HDRColorGradingComponentConfig.h>
+#include <AtomLyIntegration/CommonFeatures/PostProcess/ColorGrading/HDRColorGradingBus.h>
+
+#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingSettingsInterface.h>
+#include <Atom/Feature/PostProcess/PostProcessFeatureProcessorInterface.h>
+#include <Atom/Feature/PostProcess/PostProcessSettingsInterface.h>
+
+namespace AZ
+{
+    namespace Render
+    {
+        class HDRColorGradingComponentController final
+            : public HDRColorGradingRequestBus::Handler
+        {
+        public:
+            friend class EditorHDRColorGradingComponent;
+
+            AZ_TYPE_INFO(AZ::Render::HDRColorGradingComponentController, "{CA1D635C-64E9-42C7-A8E0-36C6B825B15D}");
+            static void Reflect(AZ::ReflectContext* context);
+            static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided);
+            static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible);
+            static void GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required);
+
+            HDRColorGradingComponentController() = default;
+            HDRColorGradingComponentController(const HDRColorGradingComponentConfig& config);
+
+            void Activate(EntityId entityId);
+            void Deactivate();
+            void SetConfiguration(const HDRColorGradingComponentConfig& config);
+            const HDRColorGradingComponentConfig& GetConfiguration() const;
+
+            // Auto-gen function override declarations (functions definitions in .cpp)...
+#include <Atom/Feature/ParamMacros/StartParamFunctionsOverride.inl>
+#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingParams.inl>
+#include <Atom/Feature/ParamMacros/EndParams.inl>
+
+        private:
+            AZ_DISABLE_COPY(HDRColorGradingComponentController);
+
+            void OnConfigChanged();
+
+            PostProcessSettingsInterface* m_postProcessInterface = nullptr;
+            HDRColorGradingSettingsInterface* m_settingsInterface = nullptr;
+            HDRColorGradingComponentConfig m_configuration;
+            EntityId m_entityId;
+        };
+    } // namespace Render
+} // namespace AZ