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>
monroegm-disable-blank-issue-2
hershey5045 4 years ago committed by GitHub
parent 9477da799b
commit 30da67fe7d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -5,7 +5,7 @@
"ClassData": { "ClassData": {
"PassTemplate": { "PassTemplate": {
"Name": "HDRColorGradingTemplate", "Name": "HDRColorGradingTemplate",
"PassClass": "FullScreenTriangle", "PassClass": "HDRColorGradingPass",
"Slots": [ "Slots": [
{ {
"Name": "Input", "Name": "Input",
@ -85,7 +85,7 @@
}, },
{ {
"Name": "m_whiteBalanceKelvin", "Name": "m_whiteBalanceKelvin",
"Value": 6500.0 // 1000.0f ... 40000.0f kelvin "Value": 6600.0 // 1000.0f ... 40000.0f kelvin
}, },
{ {
"Name": "m_whiteBalanceTint", "Name": "m_whiteBalanceTint",
@ -96,7 +96,7 @@
"Value": 0.0 // -1 ... 1 "Value": 0.0 // -1 ... 1
}, },
{ {
"Name": "m_splitToneMix", "Name": "m_splitToneWeight",
"Value": 0.0 // 0 ... 1 "Value": 0.0 // 0 ... 1
}, },
{ {
@ -120,7 +120,7 @@
"Value": 1.0 // 0 ... 1 "Value": 1.0 // 0 ... 1
}, },
{ {
"Name": "m_smhMix", "Name": "m_smhWeight",
"Value": 0.0 // 0 ... 1 "Value": 0.0 // 0 ... 1
} }
], ],

@ -92,8 +92,8 @@
] ]
}, },
{ {
"Name": "LookModificationTransformPass", "Name": "HDRColorGradingPass",
"TemplateName": "LookModificationTransformTemplate", "TemplateName": "HDRColorGradingTemplate",
"Enabled": true, "Enabled": true,
"Connections": [ "Connections": [
{ {
@ -102,6 +102,20 @@
"Pass": "Parent", "Pass": "Parent",
"Attachment": "LightingInput" "Attachment": "LightingInput"
} }
}
]
},
{
"Name": "LookModificationTransformPass",
"TemplateName": "LookModificationTransformTemplate",
"Enabled": true,
"Connections": [
{
"LocalSlot": "Input",
"AttachmentRef": {
"Pass": "HDRColorGradingPass",
"Attachment": "Output"
}
}, },
{ {
"LocalSlot": "EyeAdaptationDataInput", "LocalSlot": "EyeAdaptationDataInput",

@ -50,13 +50,13 @@ ShaderResourceGroup PassSrg : SRG_PerPass_WithFallback
float m_whiteBalanceKelvin; float m_whiteBalanceKelvin;
float m_whiteBalanceTint; float m_whiteBalanceTint;
float m_splitToneBalance; float m_splitToneBalance;
float m_splitToneMix; float m_splitToneWeight;
float m_colorGradingPostSaturation; float m_colorGradingPostSaturation;
float m_smhShadowsStart; float m_smhShadowsStart;
float m_smhShadowsEnd; float m_smhShadowsEnd;
float m_smhHighlightsStart; float m_smhHighlightsStart;
float m_smhHighlightsEnd; float m_smhHighlightsEnd;
float m_smhMix; float m_smhWeight;
float3 m_channelMixingRed; float3 m_channelMixingRed;
float3 m_channelMixingGreen; float3 m_channelMixingGreen;
@ -69,9 +69,6 @@ ShaderResourceGroup PassSrg : SRG_PerPass_WithFallback
float4 m_smhShadowsColor; float4 m_smhShadowsColor;
float4 m_smhMidtonesColor; float4 m_smhMidtonesColor;
float4 m_smhHighlightsColor; float4 m_smhHighlightsColor;
// my color grading output
float4 m_color;
} }
float SaturateWithEpsilon(float value) float SaturateWithEpsilon(float value)
@ -133,7 +130,7 @@ float3 NoNanPow(float3 base, float3 power)
return pow(max(abs(base), float3(FloatEpsilon, FloatEpsilon, FloatEpsilon)), 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); float3 frameSplitTone = NoNanPow(frameColor, 1.0 / 2.2);
const float t = SaturateWithEpsilon(CalculateLuminance(SaturateWithEpsilon(frameSplitTone), ColorSpaceId::ACEScg) + balance); 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, shadows);
frameSplitTone = BlendMode_SoftLight(frameSplitTone, highlights); frameSplitTone = BlendMode_SoftLight(frameSplitTone, highlights);
frameSplitTone = NoNanPow(frameSplitTone, 2.2); frameSplitTone = NoNanPow(frameSplitTone, 2.2);
return lerp(frameColor.rgb, frameSplitTone.rgb, mix); return lerp(frameColor.rgb, frameSplitTone.rgb, weight);
} }
float3 ColorGradeChannelMixer (float3 frameColor) float3 ColorGradeChannelMixer (float3 frameColor)
@ -154,7 +151,7 @@ float3 ColorGradeChannelMixer (float3 frameColor)
} }
float3 ColorGradeShadowsMidtonesHighlights (float3 frameColor, float shadowsStart, float shadowsEnd, 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) float4 shadowsColor, float4 midtonesColor, float4 highlightsColor)
{ {
const float3 shadowsColorACEScg = TransformColor(shadowsColor.rgb, ColorSpaceId::LinearSRGB, ColorSpaceId::ACEScg); 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 + const float3 frameSmh = frameColor * shadowsColorACEScg * shadowsWeight +
frameColor * midtonesColorACEScg * midtonesWeight + frameColor * midtonesColorACEScg * midtonesWeight +
frameColor * highlightsColorACEScg * highlightsWeight; frameColor * highlightsColorACEScg * highlightsWeight;
return lerp(frameColor.rgb, frameSmh.rgb, mix); return lerp(frameColor.rgb, frameSmh.rgb, weight);
} }
float3 ColorGrade (float3 frameColor) float3 ColorGrade (float3 frameColor)
@ -181,11 +178,11 @@ float3 ColorGrade (float3 frameColor)
PassSrg::m_colorFilterMultiply); PassSrg::m_colorFilterMultiply);
frameColor = max(frameColor, 0.0); frameColor = max(frameColor, 0.0);
frameColor = ColorGradeSaturation(frameColor, PassSrg::m_colorGradingPreSaturation); 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 = ColorGradeChannelMixer(frameColor);
frameColor = max(frameColor, 0.0); frameColor = max(frameColor, 0.0);
frameColor = ColorGradeShadowsMidtonesHighlights(frameColor, PassSrg::m_smhShadowsStart, PassSrg::m_smhShadowsEnd, 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); PassSrg::m_smhShadowsColor, PassSrg::m_smhMidtonesColor, PassSrg::m_smhHighlightsColor);
frameColor = ColorGradeHueShift(frameColor, PassSrg::m_colorGradingHueShift); frameColor = ColorGradeHueShift(frameColor, PassSrg::m_colorGradingHueShift);
frameColor = ColorGradeSaturation(frameColor, PassSrg::m_colorGradingPostSaturation); 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(SsaoSettings, m_ssaoSettings)
POST_PROCESS_MEMBER(LookModificationSettings, m_lookModificationSettings) POST_PROCESS_MEMBER(LookModificationSettings, m_lookModificationSettings)
POST_PROCESS_MEMBER(DeferredFogSettings, m_deferredFogSettings) 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/ExposureControl/ExposureControlSettingsInterface.h>
#include <Atom/Feature/PostProcess/Ssao/SsaoSettingsInterface.h> #include <Atom/Feature/PostProcess/Ssao/SsaoSettingsInterface.h>
#include <Atom/Feature/PostProcess/LookModification/LookModificationSettingsInterface.h> #include <Atom/Feature/PostProcess/LookModification/LookModificationSettingsInterface.h>
#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingSettingsInterface.h>
#include <Atom/Feature/ScreenSpace/DeferredFogSettingsInterface.h> #include <Atom/Feature/ScreenSpace/DeferredFogSettingsInterface.h>
#include <Atom/RPI.Public/View.h> #include <Atom/RPI.Public/View.h>

@ -42,6 +42,7 @@
#include <PostProcess/PostProcessFeatureProcessor.h> #include <PostProcess/PostProcessFeatureProcessor.h>
#include <PostProcessing/BlendColorGradingLutsPass.h> #include <PostProcessing/BlendColorGradingLutsPass.h>
#include <PostProcessing/BloomParentPass.h> #include <PostProcessing/BloomParentPass.h>
#include <PostProcessing/HDRColorGradingPass.h>
#include <PostProcessing/DepthUpsamplePass.h> #include <PostProcessing/DepthUpsamplePass.h>
#include <PostProcessing/DepthOfFieldCompositePass.h> #include <PostProcessing/DepthOfFieldCompositePass.h>
#include <PostProcessing/DepthOfFieldBokehBlurPass.h> #include <PostProcessing/DepthOfFieldBokehBlurPass.h>
@ -222,6 +223,7 @@ namespace AZ
passSystem->AddPassCreator(Name("LightCullingRemapPass"), &LightCullingRemap::Create); passSystem->AddPassCreator(Name("LightCullingRemapPass"), &LightCullingRemap::Create);
passSystem->AddPassCreator(Name("LightCullingTilePreparePass"), &LightCullingTilePreparePass::Create); passSystem->AddPassCreator(Name("LightCullingTilePreparePass"), &LightCullingTilePreparePass::Create);
passSystem->AddPassCreator(Name("BlendColorGradingLutsPass"), &BlendColorGradingLutsPass::Create); passSystem->AddPassCreator(Name("BlendColorGradingLutsPass"), &BlendColorGradingLutsPass::Create);
passSystem->AddPassCreator(Name("HDRColorGradingPass"), &HDRColorGradingPass::Create);
passSystem->AddPassCreator(Name("LookModificationCompositePass"), &LookModificationCompositePass::Create); passSystem->AddPassCreator(Name("LookModificationCompositePass"), &LookModificationCompositePass::Create);
passSystem->AddPassCreator(Name("LookModificationTransformPass"), &LookModificationPass::Create); passSystem->AddPassCreator(Name("LookModificationTransformPass"), &LookModificationPass::Create);
passSystem->AddPassCreator(Name("SMAAEdgeDetectionPass"), &SMAAEdgeDetectionPass::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/ExposureControl/ExposureControlSettings.h>
#include <PostProcess/Ssao/SsaoSettings.h> #include <PostProcess/Ssao/SsaoSettings.h>
#include <PostProcess/LookModification/LookModificationSettings.h> #include <PostProcess/LookModification/LookModificationSettings.h>
#include <PostProcess/ColorGrading/HDRColorGradingSettings.h>
#include <ScreenSpace/DeferredFogSettings.h> #include <ScreenSpace/DeferredFogSettings.h>
namespace AZ 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/PostProcessFeatureProcessor.h
Source/PostProcess/PostProcessSettings.cpp Source/PostProcess/PostProcessSettings.cpp
Source/PostProcess/PostProcessSettings.h Source/PostProcess/PostProcessSettings.h
Source/PostProcess/ColorGrading/HDRColorGradingSettings.h
Source/PostProcess/ColorGrading/HDRColorGradingSettings.cpp
Source/PostProcess/Bloom/BloomSettings.cpp Source/PostProcess/Bloom/BloomSettings.cpp
Source/PostProcess/Bloom/BloomSettings.h Source/PostProcess/Bloom/BloomSettings.h
Source/PostProcess/DepthOfField/DepthOfFieldSettings.cpp Source/PostProcess/DepthOfField/DepthOfFieldSettings.cpp
@ -205,6 +207,8 @@ set(FILES
Source/PostProcessing/BloomCompositePass.cpp Source/PostProcessing/BloomCompositePass.cpp
Source/PostProcessing/BloomParentPass.h Source/PostProcessing/BloomParentPass.h
Source/PostProcessing/BloomParentPass.cpp Source/PostProcessing/BloomParentPass.cpp
Source/PostProcessing/HDRColorGradingPass.cpp
Source/PostProcessing/HDRColorGradingPass.h
Source/PostProcessing/DepthOfFieldCompositePass.h Source/PostProcessing/DepthOfFieldCompositePass.h
Source/PostProcessing/DepthOfFieldCompositePass.cpp Source/PostProcessing/DepthOfFieldCompositePass.cpp
Source/PostProcessing/DepthOfFieldBokehBlurPass.h Source/PostProcessing/DepthOfFieldBokehBlurPass.h

@ -51,6 +51,8 @@ set(FILES
Include/Atom/Feature/PostProcess/Bloom/BloomConstants.h Include/Atom/Feature/PostProcess/Bloom/BloomConstants.h
Include/Atom/Feature/PostProcess/Bloom/BloomParams.inl Include/Atom/Feature/PostProcess/Bloom/BloomParams.inl
Include/Atom/Feature/PostProcess/Bloom/BloomSettingsInterface.h 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/DepthOfFieldConstants.h
Include/Atom/Feature/PostProcess/DepthOfField/DepthOfFieldParams.inl Include/Atom/Feature/PostProcess/DepthOfField/DepthOfFieldParams.inl
Include/Atom/Feature/PostProcess/DepthOfField/DepthOfFieldSettingsInterface.h Include/Atom/Feature/PostProcess/DepthOfField/DepthOfFieldSettingsInterface.h

@ -0,0 +1,34 @@
/*
* 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>
namespace AZ
{
namespace Render
{
class HDRColorGradingRequests
: public ComponentBus
{
public:
AZ_RTTI(AZ::Render::HDRColorGradingRequests, "{E414A96B-0AA7-4574-ABC0-968B1F5CEE56}");
/// Overrides the default AZ::EBusTraits handler policy to allow one listener only.
static const EBusHandlerPolicy HandlerPolicy = EBusHandlerPolicy::Single;
virtual ~HDRColorGradingRequests() {}
// Auto-gen virtual getters/setters...
#include <Atom/Feature/ParamMacros/StartParamFunctionsVirtual.inl>
#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingParams.inl>
#include <Atom/Feature/ParamMacros/EndParams.inl>
};
typedef AZ::EBus<HDRColorGradingRequests> HDRColorGradingRequestBus;
} // namespace Render
} // namespace AZ

@ -0,0 +1,39 @@
/*
* 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 <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingSettingsInterface.h>
namespace AZ
{
namespace Render
{
class HDRColorGradingComponentConfig final
: public ComponentConfig
{
public:
AZ_RTTI(AZ::Render::HDRColorGradingComponentConfig, "{8613EA4A-6E1C-49AD-87F3-9FECCB7EA36D}", AZ::ComponentConfig);
static void Reflect(ReflectContext* context);
// Generate members...
#include <Atom/Feature/ParamMacros/StartParamMembers.inl>
#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingParams.inl>
#include <Atom/Feature/ParamMacros/EndParams.inl>
// Generate Getters/Setters...
#include <Atom/Feature/ParamMacros/StartParamFunctions.inl>
#include <Atom/Feature/PostProcess/ColorGrading/HDRColorGradingParams.inl>
#include <Atom/Feature/ParamMacros/EndParams.inl>
void CopySettingsTo(HDRColorGradingSettingsInterface* settings);
};
} // namespace Render
} // namespace AZ

@ -24,6 +24,7 @@
#include <OcclusionCullingPlane/OcclusionCullingPlaneComponent.h> #include <OcclusionCullingPlane/OcclusionCullingPlaneComponent.h>
#include <PostProcess/PostFxLayerComponent.h> #include <PostProcess/PostFxLayerComponent.h>
#include <PostProcess/Bloom/BloomComponent.h> #include <PostProcess/Bloom/BloomComponent.h>
#include <PostProcess/ColorGrading/HDRColorGradingComponent.h>
#include <PostProcess/DepthOfField/DepthOfFieldComponent.h> #include <PostProcess/DepthOfField/DepthOfFieldComponent.h>
#include <PostProcess/DisplayMapper/DisplayMapperComponent.h> #include <PostProcess/DisplayMapper/DisplayMapperComponent.h>
#include <PostProcess/ExposureControl/ExposureControlComponent.h> #include <PostProcess/ExposureControl/ExposureControlComponent.h>
@ -57,6 +58,7 @@
#include <OcclusionCullingPlane/EditorOcclusionCullingPlaneComponent.h> #include <OcclusionCullingPlane/EditorOcclusionCullingPlaneComponent.h>
#include <PostProcess/EditorPostFxLayerComponent.h> #include <PostProcess/EditorPostFxLayerComponent.h>
#include <PostProcess/Bloom/EditorBloomComponent.h> #include <PostProcess/Bloom/EditorBloomComponent.h>
#include <PostProcess/ColorGrading/EditorHDRColorGradingComponent.h>
#include <PostProcess/DepthOfField/EditorDepthOfFieldComponent.h> #include <PostProcess/DepthOfField/EditorDepthOfFieldComponent.h>
#include <PostProcess/DisplayMapper/EditorDisplayMapperComponent.h> #include <PostProcess/DisplayMapper/EditorDisplayMapperComponent.h>
#include <PostProcess/ExposureControl/EditorExposureControlComponent.h> #include <PostProcess/ExposureControl/EditorExposureControlComponent.h>
@ -93,6 +95,7 @@ namespace AZ
DecalComponent::CreateDescriptor(), DecalComponent::CreateDescriptor(),
DirectionalLightComponent::CreateDescriptor(), DirectionalLightComponent::CreateDescriptor(),
BloomComponent::CreateDescriptor(), BloomComponent::CreateDescriptor(),
HDRColorGradingComponent::CreateDescriptor(),
DisplayMapperComponent::CreateDescriptor(), DisplayMapperComponent::CreateDescriptor(),
DepthOfFieldComponent::CreateDescriptor(), DepthOfFieldComponent::CreateDescriptor(),
ExposureControlComponent::CreateDescriptor(), ExposureControlComponent::CreateDescriptor(),
@ -124,6 +127,7 @@ namespace AZ
EditorDecalComponent::CreateDescriptor(), EditorDecalComponent::CreateDescriptor(),
EditorDirectionalLightComponent::CreateDescriptor(), EditorDirectionalLightComponent::CreateDescriptor(),
EditorBloomComponent::CreateDescriptor(), EditorBloomComponent::CreateDescriptor(),
EditorHDRColorGradingComponent::CreateDescriptor(),
EditorDepthOfFieldComponent::CreateDescriptor(), EditorDepthOfFieldComponent::CreateDescriptor(),
EditorDisplayMapperComponent::CreateDescriptor(), EditorDisplayMapperComponent::CreateDescriptor(),
EditorExposureControlComponent::CreateDescriptor(), EditorExposureControlComponent::CreateDescriptor(),

@ -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

@ -63,6 +63,8 @@ set(FILES
Source/PostProcess/EditorPostFxLayerComponent.h Source/PostProcess/EditorPostFxLayerComponent.h
Source/PostProcess/Bloom/EditorBloomComponent.cpp Source/PostProcess/Bloom/EditorBloomComponent.cpp
Source/PostProcess/Bloom/EditorBloomComponent.h Source/PostProcess/Bloom/EditorBloomComponent.h
Source/PostProcess/ColorGrading/EditorHDRColorGradingComponent.cpp
Source/PostProcess/ColorGrading/EditorHDRColorGradingComponent.h
Source/PostProcess/DepthOfField/EditorDepthOfFieldComponent.cpp Source/PostProcess/DepthOfField/EditorDepthOfFieldComponent.cpp
Source/PostProcess/DepthOfField/EditorDepthOfFieldComponent.h Source/PostProcess/DepthOfField/EditorDepthOfFieldComponent.h
Source/PostProcess/DisplayMapper/EditorDisplayMapperComponent.cpp Source/PostProcess/DisplayMapper/EditorDisplayMapperComponent.cpp

@ -83,6 +83,11 @@ set(FILES
Source/PostProcess/Bloom/BloomComponentConfig.cpp Source/PostProcess/Bloom/BloomComponentConfig.cpp
Source/PostProcess/Bloom/BloomComponentController.cpp Source/PostProcess/Bloom/BloomComponentController.cpp
Source/PostProcess/Bloom/BloomComponentController.h Source/PostProcess/Bloom/BloomComponentController.h
Source/PostProcess/ColorGrading/HDRColorGradingComponent.cpp
Source/PostProcess/ColorGrading/HDRColorGradingComponent.h
Source/PostProcess/ColorGrading/HDRColorGradingComponentConfig.cpp
Source/PostProcess/ColorGrading/HDRColorGradingComponentController.cpp
Source/PostProcess/ColorGrading/HDRColorGradingComponentController.h
Source/PostProcess/DepthOfField/DepthOfFieldComponent.cpp Source/PostProcess/DepthOfField/DepthOfFieldComponent.cpp
Source/PostProcess/DepthOfField/DepthOfFieldComponent.h Source/PostProcess/DepthOfField/DepthOfFieldComponent.h
Source/PostProcess/DepthOfField/DepthOfFieldComponentConfig.cpp Source/PostProcess/DepthOfField/DepthOfFieldComponentConfig.cpp

@ -39,6 +39,8 @@ set(FILES
Include/AtomLyIntegration/CommonFeatures/PostProcess/ExposureControl/ExposureControlBus.h Include/AtomLyIntegration/CommonFeatures/PostProcess/ExposureControl/ExposureControlBus.h
Include/AtomLyIntegration/CommonFeatures/PostProcess/ExposureControl/ExposureControlComponentConfig.h Include/AtomLyIntegration/CommonFeatures/PostProcess/ExposureControl/ExposureControlComponentConfig.h
Include/AtomLyIntegration/CommonFeatures/PostProcess/ExposureControl/ExposureControlComponentConstants.h Include/AtomLyIntegration/CommonFeatures/PostProcess/ExposureControl/ExposureControlComponentConstants.h
Include/AtomLyIntegration/CommonFeatures/PostProcess/ColorGrading/HDRColorGradingBus.h
Include/AtomLyIntegration/CommonFeatures/PostProcess/ColorGrading/HDRColorGradingComponentConfig.h
Include/AtomLyIntegration/CommonFeatures/PostProcess/Ssao/SsaoBus.h Include/AtomLyIntegration/CommonFeatures/PostProcess/Ssao/SsaoBus.h
Include/AtomLyIntegration/CommonFeatures/PostProcess/Ssao/SsaoComponentConfiguration.h Include/AtomLyIntegration/CommonFeatures/PostProcess/Ssao/SsaoComponentConfiguration.h
Include/AtomLyIntegration/CommonFeatures/PostProcess/LookModification/LookModificationBus.h Include/AtomLyIntegration/CommonFeatures/PostProcess/LookModification/LookModificationBus.h

Loading…
Cancel
Save