Merged dev

Signed-off-by: AMZN-Olex <5432499+AMZN-Olex@users.noreply.github.com>

AutomatedTesting/Gem/PythonTests/Atom/CMakeLists.txt

@@ -13,9 +13,9 @@
 
 if(PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_BUILD_TESTS_SUPPORTED AND AutomatedTesting IN_LIST LY_PROJECTS)
     ly_add_pytest(
-        NAME AutomatedTesting::AtomRenderer_HydraTests_Main
+        NAME AutomatedTesting::Atom_TestSuite_Main
         TEST_SUITE main
-        PATH ${CMAKE_CURRENT_LIST_DIR}/test_Atom_MainSuite.py
+        PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Main.py
         TEST_SERIAL
         TIMEOUT 600
         RUNTIME_DEPENDENCIES
@@ -26,9 +26,9 @@ if(PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_BUILD_TESTS_SUPPORTED AND AutomatedT
             Atom
     )
     ly_add_pytest(
-        NAME AutomatedTesting::AtomRenderer_HydraTests_MainOptimized
+        NAME AutomatedTesting::Atom_TestSuite_Main_Optimized
         TEST_SUITE main
-        PATH ${CMAKE_CURRENT_LIST_DIR}/test_Atom_MainSuite_Optimized.py
+        PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Main_Optimized.py
         TEST_SERIAL
         TIMEOUT 600
         RUNTIME_DEPENDENCIES
@@ -39,9 +39,9 @@ if(PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_BUILD_TESTS_SUPPORTED AND AutomatedT
             Atom
     )
     ly_add_pytest(
-        NAME AutomatedTesting::AtomRenderer_HydraTests_Sandbox
+        NAME AutomatedTesting::Atom_TestSuite_Sandbox
         TEST_SUITE sandbox
-        PATH ${CMAKE_CURRENT_LIST_DIR}/test_Atom_SandboxSuite.py
+        PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Sandbox.py
         TEST_SERIAL
         TIMEOUT 400
         RUNTIME_DEPENDENCIES
@@ -52,12 +52,12 @@ if(PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_BUILD_TESTS_SUPPORTED AND AutomatedT
             Atom
     )
     ly_add_pytest(
-        NAME AutomatedTesting::AtomRenderer_HydraTests_GPUTests
+        NAME AutomatedTesting::Atom_TestSuite_Main_GPU
         TEST_SUITE main
         TEST_REQUIRES gpu
         TEST_SERIAL
         TIMEOUT 1200
-        PATH ${CMAKE_CURRENT_LIST_DIR}/test_Atom_GPUTests.py
+        PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Main_GPU.py
         RUNTIME_DEPENDENCIES
             AssetProcessor
             AutomatedTesting.Assets

AutomatedTesting/Gem/PythonTests/Atom/TestSuite_Main.py

@@ -13,10 +13,10 @@ import pytest
 
 import ly_test_tools.environment.file_system as file_system
 import editor_python_test_tools.hydra_test_utils as hydra
-from atom_renderer.atom_utils.atom_constants import LIGHT_TYPES
+from Atom.atom_utils.atom_constants import LIGHT_TYPES
 
 logger = logging.getLogger(__name__)
-TEST_DIRECTORY = os.path.join(os.path.dirname(__file__), "atom_hydra_scripts")
+TEST_DIRECTORY = os.path.join(os.path.dirname(__file__), "tests")
 
 
 @pytest.mark.parametrize("project", ["AutomatedTesting"])
@@ -38,24 +38,24 @@ class TestAtomEditorComponentsMain(object):
         7. Exposure Control
         8. Directional Light
         9. DepthOfField
-        10. Decal (Atom)
+        10. Decal
         """
         cfg_args = [level]
 
         expected_lines = [
-            # Decal (Atom) Component
-            "Decal (Atom) Entity successfully created",
-            "Decal (Atom)_test: Component added to the entity: True",
-            "Decal (Atom)_test: Component removed after UNDO: True",
-            "Decal (Atom)_test: Component added after REDO: True",
-            "Decal (Atom)_test: Entered game mode: True",
-            "Decal (Atom)_test: Exit game mode: True",
-            "Decal (Atom) Controller|Configuration|Material: SUCCESS",
-            "Decal (Atom)_test: Entity is hidden: True",
-            "Decal (Atom)_test: Entity is shown: True",
-            "Decal (Atom)_test: Entity deleted: True",
-            "Decal (Atom)_test: UNDO entity deletion works: True",
-            "Decal (Atom)_test: REDO entity deletion works: True",
+            # Decal Component
+            "Decal Entity successfully created",
+            "Decal_test: Component added to the entity: True",
+            "Decal_test: Component removed after UNDO: True",
+            "Decal_test: Component added after REDO: True",
+            "Decal_test: Entered game mode: True",
+            "Decal_test: Exit game mode: True",
+            "Decal Controller|Configuration|Material: SUCCESS",
+            "Decal_test: Entity is hidden: True",
+            "Decal_test: Entity is shown: True",
+            "Decal_test: Entity deleted: True",
+            "Decal_test: UNDO entity deletion works: True",
+            "Decal_test: REDO entity deletion works: True",
             # DepthOfField Component
             "DepthOfField Entity successfully created",
             "DepthOfField_test: Component added to the entity: True",

AutomatedTesting/Gem/PythonTests/Atom/TestSuite_Main_GPU.py

@@ -3,8 +3,6 @@ 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
-
-Tests that require a GPU in order to run.
 """
 
 import datetime
@@ -22,7 +20,7 @@ import editor_python_test_tools.hydra_test_utils as hydra
 
 logger = logging.getLogger(__name__)
 DEFAULT_SUBFOLDER_PATH = 'user/PythonTests/Automated/Screenshots'
-TEST_DIRECTORY = os.path.join(os.path.dirname(__file__), "atom_hydra_scripts")
+TEST_DIRECTORY = os.path.join(os.path.dirname(__file__), "tests")
 
 
 def golden_images_directory():

AutomatedTesting/Gem/PythonTests/Atom/TestSuite_Main_Optimized.py

@@ -15,32 +15,32 @@ from ly_test_tools.o3de.editor_test import EditorSharedTest, EditorTestSuite
 class TestAutomation(EditorTestSuite):
 
     class AtomEditorComponents_DecalAdded(EditorSharedTest):
-        from atom_renderer.atom_hydra_scripts import hydra_AtomEditorComponents_DecalAdded as test_module
+        from Atom.tests import hydra_AtomEditorComponents_DecalAdded as test_module
 
     class AtomEditorComponents_DepthOfFieldAdded(EditorSharedTest):
-        from atom_renderer.atom_hydra_scripts import hydra_AtomEditorComponents_DepthOfFieldAdded as test_module
+        from Atom.tests import hydra_AtomEditorComponents_DepthOfFieldAdded as test_module
 
     class AtomEditorComponents_DirectionalLightAdded(EditorSharedTest):
-        from atom_renderer.atom_hydra_scripts import hydra_AtomEditorComponents_DirectionalLightAdded as test_module
+        from Atom.tests import hydra_AtomEditorComponents_DirectionalLightAdded as test_module
 
     class AtomEditorComponents_ExposureControlAdded(EditorSharedTest):
-        from atom_renderer.atom_hydra_scripts import hydra_AtomEditorComponents_ExposureControlAdded as test_module
+        from Atom.tests import hydra_AtomEditorComponents_ExposureControlAdded as test_module
 
     class AtomEditorComponents_GlobalSkylightIBLAdded(EditorSharedTest):
-        from atom_renderer.atom_hydra_scripts import hydra_AtomEditorComponents_GlobalSkylightIBLAdded as test_module
+        from Atom.tests import hydra_AtomEditorComponents_GlobalSkylightIBLAdded as test_module
 
     class AtomEditorComponents_PhysicalSkyAdded(EditorSharedTest):
-        from atom_renderer.atom_hydra_scripts import hydra_AtomEditorComponents_PhysicalSkyAdded as test_module
+        from Atom.tests import hydra_AtomEditorComponents_PhysicalSkyAdded as test_module
 
     class AtomEditorComponents_PostFXRadiusWeightModifierAdded(EditorSharedTest):
-        from atom_renderer.atom_hydra_scripts import (
+        from Atom.tests import (
             hydra_AtomEditorComponents_PostFXRadiusWeightModifierAdded as test_module)
 
     class AtomEditorComponents_LightAdded(EditorSharedTest):
-        from atom_renderer.atom_hydra_scripts import hydra_AtomEditorComponents_LightAdded as test_module
+        from Atom.tests import hydra_AtomEditorComponents_LightAdded as test_module
 
     class AtomEditorComponents_DisplayMapperAdded(EditorSharedTest):
-        from atom_renderer.atom_hydra_scripts import hydra_AtomEditorComponents_DisplayMapperAdded as test_module
+        from Atom.tests import hydra_AtomEditorComponents_DisplayMapperAdded as test_module
 
     class ShaderAssetBuilder_RecompilesShaderAsChainOfDependenciesChanges(EditorSharedTest):
-        from .atom_hydra_scripts import hydra_ShaderAssetBuilder_RecompilesShaderAsChainOfDependenciesChanges as test_module
+        from Atom.tests import hydra_ShaderAssetBuilder_RecompilesShaderAsChainOfDependenciesChanges as test_module

AutomatedTesting/Gem/PythonTests/Atom/tests/TestAssets/ShaderAssetBuilder/DependencyValidation.shader.txt

@@ -2,7 +2,7 @@
 {
     "Source" : "DependencyValidation.azsl",
 
-    "DepthStencilState" : { 
+    "DepthStencilState" : {
         "Depth" : { "Enable" : false, "CompareFunc" : "GreaterEqual" }
     },
 
@@ -22,5 +22,5 @@
         }
       ]
     }
-    
+
 }

AutomatedTesting/Gem/PythonTests/Atom/tests/TestAssets/ShaderAssetBuilder/Test2Color.azsli.txt

@@ -12,5 +12,5 @@
 
 float4 GetTest2Color(float4 color)
 {
-    return color * 0.5; 
+    return color * 0.5;
 }

AutomatedTesting/Gem/PythonTests/Atom/tests/TestAssets/ShaderAssetBuilder/Test3Color.azsli.txt

@@ -12,5 +12,5 @@
 
 float4 GetTest3Color(float4 color)
 {
-    return color * 0.13; 
+    return color * 0.13;
 }

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_AddedToEntity.py

@@ -184,7 +184,7 @@ def run():
     material_asset = asset.AssetCatalogRequestBus(
         bus.Broadcast, "GetAssetIdByPath", material_asset_path, math.Uuid(), False)
     ComponentTests(
-        "Decal (Atom)", lambda entity_obj: verify_set_property(
+        "Decal", lambda entity_obj: verify_set_property(
             entity_obj, "Controller|Configuration|Material", material_asset))
 
     # Directional Light Component

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DecalAdded.py

@@ -73,7 +73,7 @@ def AtomEditorComponents_Decal_AddedToEntity():
 
         # Test steps begin.
         # 1. Create a Decal entity with no components.
-        decal_name = "Decal (Atom)"
+        decal_name = "Decal"
         decal_entity = EditorEntity.create_editor_entity_at(math.Vector3(512.0, 512.0, 34.0), decal_name)
         Report.critical_result(Tests.decal_creation, decal_entity.exists())
 

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_LightComponent.py

@@ -17,7 +17,7 @@ import azlmbr.legacy.general as general
 sys.path.append(os.path.join(azlmbr.paths.devassets, "Gem", "PythonTests"))
 
 import editor_python_test_tools.hydra_editor_utils as hydra
-from atom_renderer.atom_utils.atom_constants import LIGHT_TYPES
+from Atom.atom_utils.atom_constants import LIGHT_TYPES
 
 LIGHT_TYPE_PROPERTY = 'Controller|Configuration|Light type'
 SPHERE_AND_SPOT_DISK_LIGHT_PROPERTIES = [

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomMaterialEditor_BasicTests.py

@@ -18,7 +18,7 @@ import azlmbr.paths
 
 sys.path.append(os.path.join(azlmbr.paths.devassets, "Gem", "PythonTests"))
 
-import atom_renderer.atom_utils.material_editor_utils as material_editor
+import Atom.atom_utils.material_editor_utils as material_editor
 
 NEW_MATERIAL = "test_material.material"
 NEW_MATERIAL_1 = "test_material_1.material"

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_GPUTest_AtomFeatureIntegrationBenchmark.py

@@ -14,7 +14,7 @@ sys.path.append(os.path.join(azlmbr.paths.devroot, "AutomatedTesting", "Gem", "P
 
 import editor_python_test_tools.hydra_editor_utils as hydra
 from editor_python_test_tools.editor_test_helper import EditorTestHelper
-from atom_renderer.atom_utils.benchmark_utils import BenchmarkHelper
+from Atom.atom_utils.benchmark_utils import BenchmarkHelper
 
 SCREEN_WIDTH = 1280
 SCREEN_HEIGHT = 720

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_GPUTest_BasicLevelSetup.py

@@ -21,7 +21,7 @@ sys.path.append(os.path.join(azlmbr.paths.devroot, "AutomatedTesting", "Gem", "P
 
 import editor_python_test_tools.hydra_editor_utils as hydra
 from editor_python_test_tools.editor_test_helper import EditorTestHelper
-from atom_renderer.atom_utils.screenshot_utils import ScreenshotHelper
+from Atom.atom_utils.screenshot_utils import ScreenshotHelper
 
 SCREEN_WIDTH = 1280
 SCREEN_HEIGHT = 720

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_GPUTest_LightComponent.py

@@ -17,7 +17,7 @@ import azlmbr.legacy.general as general
 sys.path.append(os.path.join(azlmbr.paths.devroot, "AutomatedTesting", "Gem", "PythonTests"))
 
 import editor_python_test_tools.hydra_editor_utils as hydra
-from atom_renderer.atom_utils import atom_component_helper, atom_constants, screenshot_utils
+from Atom.atom_utils import atom_component_helper, atom_constants, screenshot_utils
 from editor_python_test_tools.editor_test_helper import EditorTestHelper
 
 helper = EditorTestHelper(log_prefix="Atom_EditorTestHelper")

AutomatedTesting/Gem/PythonTests/CMakeLists.txt

@@ -18,7 +18,7 @@ include(${pal_dir}/PAL_traits_${PAL_PLATFORM_NAME_LOWERCASE}.cmake)
 add_subdirectory(assetpipeline)
 
 ## Atom Renderer ##
-add_subdirectory(atom_renderer)
+add_subdirectory(Atom)
 
 ## Physics ##
 add_subdirectory(Physics)

Code/Editor/CMakeLists.txt

@@ -254,4 +254,35 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED)
     ly_add_googletest(
         NAME Legacy::EditorLib.Tests
     )
+
+    ly_add_target(
+        NAME EditorLib.Camera.Tests ${PAL_TRAIT_TEST_TARGET_TYPE}
+        NAMESPACE Legacy
+        FILES_CMAKE
+            Lib/Tests/Camera/editor_lib_camera_test_files.cmake
+        INCLUDE_DIRECTORIES
+            PRIVATE
+                .
+        BUILD_DEPENDENCIES
+            PRIVATE
+                AZ::AzCore
+                AZ::AzTest
+                AZ::AzToolsFramework
+                AZ::AzTestShared
+                Legacy::EditorLib
+                Gem::Camera.Editor
+                Gem::AtomToolsFramework.Static
+        RUNTIME_DEPENDENCIES
+            Legacy::EditorLib
+    )
+
+    ly_add_source_properties(
+        SOURCES Lib/Tests/Camera/test_EditorCamera.cpp
+        PROPERTY COMPILE_DEFINITIONS 
+        VALUES CAMERA_EDITOR_MODULE="$<TARGET_FILE_BASE_NAME:Camera.Editor>"
+    )
+
+    ly_add_googletest(
+        NAME Legacy::EditorLib.Camera.Tests
+    )
 endif()

Code/Editor/EditorModularViewportCameraComposer.cpp

@@ -9,6 +9,7 @@
 #include <EditorModularViewportCameraComposer.h>
 
 #include <AtomToolsFramework/Viewport/ModularViewportCameraControllerRequestBus.h>
+#include <AzCore/Component/TransformBus.h>
 #include <AzCore/std/smart_ptr/make_shared.h>
 #include <AzFramework/Render/IntersectorInterface.h>
 #include <AzToolsFramework/Viewport/ViewportMessages.h>
@@ -34,10 +35,12 @@ namespace SandboxEditor
         : m_viewportId(viewportId)
     {
         EditorModularViewportCameraComposerNotificationBus::Handler::BusConnect(viewportId);
+        Camera::EditorCameraNotificationBus::Handler::BusConnect();
     }
 
     EditorModularViewportCameraComposer::~EditorModularViewportCameraComposer()
     {
+        Camera::EditorCameraNotificationBus::Handler::BusDisconnect();
         EditorModularViewportCameraComposerNotificationBus::Handler::BusDisconnect();
     }
 
@@ -283,4 +286,22 @@ namespace SandboxEditor
         m_orbitCamera->SetOrbitInputChannelId(SandboxEditor::CameraOrbitChannelId());
         m_orbitDollyMoveCamera->SetDollyInputChannelId(SandboxEditor::CameraOrbitDollyChannelId());
     }
+
+    void EditorModularViewportCameraComposer::OnViewportViewEntityChanged(const AZ::EntityId& viewEntityId)
+    {
+        if (viewEntityId.IsValid())
+        {
+            AZ::Transform worldFromLocal = AZ::Transform::CreateIdentity();
+            AZ::TransformBus::EventResult(worldFromLocal, viewEntityId, &AZ::TransformBus::Events::GetWorldTM);
+
+            AtomToolsFramework::ModularViewportCameraControllerRequestBus::Event(
+                m_viewportId, &AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::SetReferenceFrame,
+                worldFromLocal);
+        }
+        else
+        {
+            AtomToolsFramework::ModularViewportCameraControllerRequestBus::Event(
+                m_viewportId, &AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::ClearReferenceFrame);
+        }
+    }
 } // namespace SandboxEditor

Code/Editor/EditorModularViewportCameraComposer.h

@@ -10,13 +10,16 @@
 
 #include <AtomToolsFramework/Viewport/ModularViewportCameraController.h>
 #include <AzFramework/Viewport/CameraInput.h>
+#include <AzToolsFramework/API/EditorCameraBus.h>
 #include <EditorModularViewportCameraComposerBus.h>
 #include <SandboxAPI.h>
 
 namespace SandboxEditor
 {
     //! Type responsible for building the editor's modular viewport camera controller.
-    class EditorModularViewportCameraComposer : private EditorModularViewportCameraComposerNotificationBus::Handler
+    class EditorModularViewportCameraComposer
+        : private EditorModularViewportCameraComposerNotificationBus::Handler
+        , private Camera::EditorCameraNotificationBus::Handler
     {
     public:
         SANDBOX_API explicit EditorModularViewportCameraComposer(AzFramework::ViewportId viewportId);
@@ -32,6 +35,9 @@ namespace SandboxEditor
         // EditorModularViewportCameraComposerNotificationBus overrides ...
         void OnEditorModularViewportCameraComposerSettingsChanged() override;
 
+        // EditorCameraNotificationBus overrides ...
+        void OnViewportViewEntityChanged(const AZ::EntityId& viewEntityId) override;
+
         AZStd::shared_ptr<AzFramework::RotateCameraInput> m_firstPersonRotateCamera;
         AZStd::shared_ptr<AzFramework::PanCameraInput> m_firstPersonPanCamera;
         AZStd::shared_ptr<AzFramework::TranslateCameraInput> m_firstPersonTranslateCamera;

Code/Editor/Lib/Tests/Camera/editor_lib_camera_test_files.cmake

@@ -0,0 +1,11 @@
+#
+# 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
+#
+#
+
+set(FILES
+    test_EditorCamera.cpp
+)

Code/Editor/Lib/Tests/Camera/test_EditorCamera.cpp

@@ -0,0 +1,225 @@
+/*
+ * 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 <AZTestShared/Math/MathTestHelpers.h>
+#include <AtomToolsFramework/Viewport/ModularViewportCameraController.h>
+#include <AzCore/UnitTest/TestTypes.h>
+#include <AzFramework/Viewport/ViewportControllerList.h>
+#include <AzTest/GemTestEnvironment.h>
+#include <AzToolsFramework/API/EditorCameraBus.h>
+#include <AzToolsFramework/ToolsComponents/TransformComponent.h>
+#include <EditorModularViewportCameraComposer.h>
+
+namespace UnitTest
+{
+    class EditorCameraTestEnvironment : public AZ::Test::GemTestEnvironment
+    {
+        // AZ::Test::GemTestEnvironment overrides ...
+        void AddGemsAndComponents() override;
+    };
+
+    void EditorCameraTestEnvironment::AddGemsAndComponents()
+    {
+        AddDynamicModulePaths({ CAMERA_EDITOR_MODULE });
+        AddComponentDescriptors({ AzToolsFramework::Components::TransformComponent::CreateDescriptor() });
+    }
+
+    class EditorCameraFixture : public ::testing::Test
+    {
+    public:
+        AtomToolsFramework::ModularCameraViewportContext* m_cameraViewportContextView = nullptr;
+        AZStd::unique_ptr<SandboxEditor::EditorModularViewportCameraComposer> m_editorModularViewportCameraComposer;
+        AZStd::unique_ptr<AZ::DynamicModuleHandle> m_editorLibHandle;
+        AzFramework::ViewportControllerListPtr m_controllerList;
+        AZStd::unique_ptr<AZ::Entity> m_entity;
+
+        static const AzFramework::ViewportId TestViewportId;
+
+        void SetUp() override
+        {
+            m_editorLibHandle = AZ::DynamicModuleHandle::Create("EditorLib");
+            [[maybe_unused]] const bool loaded = m_editorLibHandle->Load(true);
+            AZ_Assert(loaded, "EditorLib could not be loaded");
+
+            m_controllerList = AZStd::make_shared<AzFramework::ViewportControllerList>();
+            m_controllerList->RegisterViewportContext(TestViewportId);
+
+            m_entity = AZStd::make_unique<AZ::Entity>();
+            m_entity->Init();
+            m_entity->CreateComponent<AzToolsFramework::Components::TransformComponent>();
+            m_entity->Activate();
+
+            m_editorModularViewportCameraComposer = AZStd::make_unique<SandboxEditor::EditorModularViewportCameraComposer>(TestViewportId);
+
+            auto controller = m_editorModularViewportCameraComposer->CreateModularViewportCameraController();
+            // set some overrides for the test
+            controller->SetCameraViewportContextBuilderCallback(
+                [this](AZStd::unique_ptr<AtomToolsFramework::ModularCameraViewportContext>& cameraViewportContext) mutable
+                {
+                    cameraViewportContext = AZStd::make_unique<AtomToolsFramework::PlaceholderModularCameraViewportContextImpl>();
+                    m_cameraViewportContextView = cameraViewportContext.get();
+                });
+
+            m_controllerList->Add(controller);
+        }
+
+        void TearDown() override
+        {
+            m_editorModularViewportCameraComposer.reset();
+            m_cameraViewportContextView = nullptr;
+            m_entity.reset();
+            m_editorLibHandle = {};
+        }
+    };
+
+    const AzFramework::ViewportId EditorCameraFixture::TestViewportId = AzFramework::ViewportId(1337);
+
+    TEST_F(EditorCameraFixture, ModularViewportCameraControllerReferenceFrameUpdatedWhenViewportEntityisChanged)
+    {
+        // Given
+        const auto entityTransform = AZ::Transform::CreateFromQuaternionAndTranslation(
+            AZ::Quaternion::CreateRotationX(AZ::DegToRad(90.0f)), AZ::Vector3(10.0f, 5.0f, -2.0f));
+        AZ::TransformBus::Event(m_entity->GetId(), &AZ::TransformBus::Events::SetWorldTM, entityTransform);
+
+        // When
+        // imitate viewport entity changing
+        Camera::EditorCameraNotificationBus::Broadcast(
+            &Camera::EditorCameraNotificationBus::Events::OnViewportViewEntityChanged, m_entity->GetId());
+
+        // ensure the viewport updates after the viewport view entity change
+        const float deltaTime = 1.0f / 60.0f;
+        m_controllerList->UpdateViewport({ TestViewportId, AzFramework::FloatSeconds(deltaTime), AZ::ScriptTimePoint() });
+
+        // retrieve updated camera transform
+        const AZ::Transform cameraTransform = m_cameraViewportContextView->GetCameraTransform();
+
+        // Then
+        // camera transform matches that of the entity
+        EXPECT_THAT(cameraTransform, IsClose(entityTransform));
+    }
+
+    TEST_F(EditorCameraFixture, ReferenceFrameRemainsIdentityAfterExternalCameraTransformChangeWhenNotSet)
+    {
+        // Given
+        m_cameraViewportContextView->SetCameraTransform(AZ::Transform::CreateTranslation(AZ::Vector3(10.0f, 20.0f, 30.0f)));
+
+        // When
+        AZ::Transform referenceFrame = AZ::Transform::CreateTranslation(AZ::Vector3(1.0f, 2.0f, 3.0f));
+        AtomToolsFramework::ModularViewportCameraControllerRequestBus::EventResult(
+            referenceFrame, TestViewportId, &AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::GetReferenceFrame);
+
+        // Then
+        // reference frame is still the identity
+        EXPECT_THAT(referenceFrame, IsClose(AZ::Transform::CreateIdentity()));
+    }
+
+    TEST_F(EditorCameraFixture, ExternalCameraTransformChangeWhenReferenceFrameIsSetUpdatesReferenceFrame)
+    {
+        // Given
+        const AZ::Transform referenceFrame = AZ::Transform::CreateFromQuaternionAndTranslation(
+            AZ::Quaternion::CreateRotationX(AZ::DegToRad(90.0f)), AZ::Vector3(1.0f, 2.0f, 3.0f));
+        AtomToolsFramework::ModularViewportCameraControllerRequestBus::Event(
+            TestViewportId, &AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::SetReferenceFrame, referenceFrame);
+
+        const AZ::Transform nextTransform = AZ::Transform::CreateTranslation(AZ::Vector3(10.0f, 20.0f, 30.0f));
+        m_cameraViewportContextView->SetCameraTransform(nextTransform);
+
+        // When
+        AZ::Transform currentReferenceFrame = AZ::Transform::CreateTranslation(AZ::Vector3(1.0f, 2.0f, 3.0f));
+        AtomToolsFramework::ModularViewportCameraControllerRequestBus::EventResult(
+            currentReferenceFrame, TestViewportId,
+            &AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::GetReferenceFrame);
+
+        // Then
+        EXPECT_THAT(currentReferenceFrame, IsClose(nextTransform));
+    }
+
+    TEST_F(EditorCameraFixture, ReferenceFrameReturnedToIdentityAfterClear)
+    {
+        // Given
+        const AZ::Transform referenceFrame = AZ::Transform::CreateFromQuaternionAndTranslation(
+            AZ::Quaternion::CreateRotationX(AZ::DegToRad(90.0f)), AZ::Vector3(1.0f, 2.0f, 3.0f));
+        AtomToolsFramework::ModularViewportCameraControllerRequestBus::Event(
+            TestViewportId, &AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::SetReferenceFrame, referenceFrame);
+
+        // When
+        AtomToolsFramework::ModularViewportCameraControllerRequestBus::Event(
+            TestViewportId, &AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::ClearReferenceFrame);
+
+        AZ::Transform currentReferenceFrame = AZ::Transform::CreateTranslation(AZ::Vector3(1.0f, 2.0f, 3.0f));
+        AtomToolsFramework::ModularViewportCameraControllerRequestBus::EventResult(
+            currentReferenceFrame, TestViewportId,
+            &AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::GetReferenceFrame);
+
+        // Then
+        EXPECT_THAT(currentReferenceFrame, IsClose(AZ::Transform::CreateIdentity()));
+    }
+
+    TEST_F(EditorCameraFixture, InterpolateToTransform)
+    {
+        // When
+        AZ::Transform transformToInterpolateTo = AZ::Transform::CreateFromQuaternionAndTranslation(
+            AZ::Quaternion::CreateRotationZ(AZ::DegToRad(90.0f)), AZ::Vector3(20.0f, 40.0f, 60.0f));
+        AtomToolsFramework::ModularViewportCameraControllerRequestBus::Event(
+            TestViewportId, &AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::InterpolateToTransform,
+            transformToInterpolateTo, 0.0f);
+
+        // simulate interpolation
+        m_controllerList->UpdateViewport({ TestViewportId, AzFramework::FloatSeconds(0.5f), AZ::ScriptTimePoint() });
+        m_controllerList->UpdateViewport({ TestViewportId, AzFramework::FloatSeconds(0.5f), AZ::ScriptTimePoint() });
+
+        const auto finalTransform = m_cameraViewportContextView->GetCameraTransform();
+
+        // Then
+        EXPECT_THAT(finalTransform, IsClose(transformToInterpolateTo));
+    }
+
+    TEST_F(EditorCameraFixture, InterpolateToTransformWithReferenceSpaceSet)
+    {
+        // Given
+        const AZ::Transform referenceFrame = AZ::Transform::CreateFromQuaternionAndTranslation(
+            AZ::Quaternion::CreateRotationX(AZ::DegToRad(90.0f)), AZ::Vector3(1.0f, 2.0f, 3.0f));
+        AtomToolsFramework::ModularViewportCameraControllerRequestBus::Event(
+            TestViewportId, &AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::SetReferenceFrame, referenceFrame);
+
+        AZ::Transform transformToInterpolateTo = AZ::Transform::CreateFromQuaternionAndTranslation(
+            AZ::Quaternion::CreateRotationZ(AZ::DegToRad(90.0f)), AZ::Vector3(20.0f, 40.0f, 60.0f));
+
+        // When
+        AtomToolsFramework::ModularViewportCameraControllerRequestBus::Event(
+            TestViewportId, &AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::InterpolateToTransform,
+            transformToInterpolateTo, 0.0f);
+
+        // simulate interpolation
+        m_controllerList->UpdateViewport({ TestViewportId, AzFramework::FloatSeconds(0.5f), AZ::ScriptTimePoint() });
+        m_controllerList->UpdateViewport({ TestViewportId, AzFramework::FloatSeconds(0.5f), AZ::ScriptTimePoint() });
+
+        AZ::Transform currentReferenceFrame = AZ::Transform::CreateTranslation(AZ::Vector3(1.0f, 2.0f, 3.0f));
+        AtomToolsFramework::ModularViewportCameraControllerRequestBus::EventResult(
+            currentReferenceFrame, TestViewportId,
+            &AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::GetReferenceFrame);
+
+        const auto finalTransform = m_cameraViewportContextView->GetCameraTransform();
+
+        // Then
+        EXPECT_THAT(finalTransform, IsClose(transformToInterpolateTo));
+        EXPECT_THAT(currentReferenceFrame, IsClose(AZ::Transform::CreateIdentity()));
+    }
+} // namespace UnitTest
+
+// required to support running integration tests with the Camera Gem
+AZTEST_EXPORT int AZ_UNIT_TEST_HOOK_NAME(int argc, char** argv)
+{
+    ::testing::InitGoogleMock(&argc, argv);
+    AZ::Test::printUnusedParametersWarning(argc, argv);
+    AZ::Test::addTestEnvironments({ new UnitTest::EditorCameraTestEnvironment() });
+    int result = RUN_ALL_TESTS();
+    return result;
+}
+
+IMPLEMENT_TEST_EXECUTABLE_MAIN();

Code/Editor/Lib/Tests/test_ModularViewportCameraController.cpp

@@ -58,28 +58,6 @@ namespace UnitTest
         return true;
     }
 
-    class TestModularCameraViewportContextImpl : public AtomToolsFramework::ModularCameraViewportContext
-    {
-    public:
-        AZ::Transform GetCameraTransform() const override
-        {
-            return m_cameraTransform;
-        }
-
-        void SetCameraTransform(const AZ::Transform& transform) override
-        {
-            m_cameraTransform = transform;
-        }
-
-        void ConnectViewMatrixChangedHandler(AZ::RPI::ViewportContext::MatrixChangedEvent::Handler&) override
-        {
-            // noop
-        }
-
-    private:
-        AZ::Transform m_cameraTransform = AZ::Transform::CreateIdentity();
-    };
-
     class ModularViewportCameraControllerFixture : public AllocatorsTestFixture
     {
     public:
@@ -146,7 +124,7 @@ namespace UnitTest
             controller->SetCameraViewportContextBuilderCallback(
                 [this](AZStd::unique_ptr<AtomToolsFramework::ModularCameraViewportContext>& cameraViewportContext)
                 {
-                    cameraViewportContext = AZStd::make_unique<TestModularCameraViewportContextImpl>();
+                    cameraViewportContext = AZStd::make_unique<AtomToolsFramework::PlaceholderModularCameraViewportContextImpl>();
                     m_cameraViewportContextView = cameraViewportContext.get();
                 });
 

Code/Framework/AzFramework/Platform/Linux/platform_linux.cmake

@@ -10,17 +10,12 @@
 # Only 'xcb' and 'wayland' are recognized
 if (${PAL_TRAIT_LINUX_WINDOW_MANAGER} STREQUAL "xcb")
 
-    find_library(XCB_LIBRARY xcb)
-    find_library(XCB_XKB_LIBRARY xcb-xkb)
-    find_library(XKBCOMMON_LIBRARY xkbcommon)
-    find_library(XKBCOMMON_X11_LIBRARY xkbcommon-x11)
-
     set(LY_BUILD_DEPENDENCIES
         PRIVATE
-            ${XCB_LIBRARY}
-            ${XKBCOMMON_LIBRARY}
-            ${XKBCOMMON_X11_LIBRARY}
-            ${XCB_XKB_LIBRARY}
+            3rdParty::X11::xcb
+            3rdParty::X11::xcb_xkb
+            3rdParty::X11::xkbcommon
+            3rdParty::X11::xkbcommon_X11
     )
 
     set(LY_COMPILE_DEFINITIONS PUBLIC PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB)

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp

@@ -3642,7 +3642,7 @@ namespace AzToolsFramework
         }
     }
 
-    void EditorTransformComponentSelection::OnViewportViewEntityChanged(const AZ::EntityId& newViewId)
+    void EditorTransformComponentSelection::OnViewportViewEntityChanged(const AZ::EntityId& viewEntityId)
     {
         AZ_PROFILE_FUNCTION(AzToolsFramework);
 
@@ -3650,12 +3650,12 @@ namespace AzToolsFramework
         // match the editor camera translation/orientation), record the entity id if we have
         // a manipulator tracking it (entity id exists in m_entityIdManipulator lookups)
         // and remove it when recreating manipulators (see InitializeManipulators)
-        if (newViewId.IsValid())
+        if (viewEntityId.IsValid())
         {
-            const auto entityIdLookupIt = m_entityIdManipulators.m_lookups.find(newViewId);
+            const auto entityIdLookupIt = m_entityIdManipulators.m_lookups.find(viewEntityId);
             if (entityIdLookupIt != m_entityIdManipulators.m_lookups.end())
             {
-                m_editorCameraComponentEntityId = newViewId;
+                m_editorCameraComponentEntityId = viewEntityId;
                 RegenerateManipulators();
             }
         }

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.h

@@ -270,7 +270,7 @@ namespace AzToolsFramework
         void OnTransformChanged(const AZ::Transform& localTM, const AZ::Transform& worldTM) override;
 
         // Camera::EditorCameraNotificationBus overrides ...
-        void OnViewportViewEntityChanged(const AZ::EntityId& newViewId) override;
+        void OnViewportViewEntityChanged(const AZ::EntityId& viewEntityId) override;
 
         // EditorContextVisibilityNotificationBus overrides ...
         void OnEntityVisibilityChanged(bool visibility) override;

Gems/Atom/Asset/Shader/Code/AZSL/Platform/Android/Vulkan/AzslcHeader.azsli

@@ -16,6 +16,11 @@
 
 static const float4 s_AzslDebugColor = float4(165.0 / 255.0, 30.0 / 255.0, 36.0 / 255.0, 1);
 
-// Uniform limitation need to be taken into consideration for mobile devices
+// Uniform limitation need to be taken into consideration for mobile devices. This would help alleviate device lost errors if the constant buffer
+// size overshoots the device's memory constraints. An example is a large number of constant buffers associated with mesh instances that would result in device lost,
+// but otherwise OK on PC. We can separate out the number of instances for the different platforms with this define.
 // [ATOM-14949]
-#define AZ_TRAIT_CONSTANT_BUFFER_LIMITATIONS 1
+#define AZ_TRAIT_CONSTANT_BUFFER_LIMITATIONS 1
+
+// Different constant buffer alignment on platforms
+#define AZ_TRAIT_CONSTANT_BUFFER_ALIGNMENT      16

Gems/Atom/Asset/Shader/Code/AZSL/Platform/Windows/Vulkan/AzslcHeader.azsli

@@ -12,3 +12,7 @@
 */
 
 static const float4 s_AzslDebugColor = float4(165.0 / 255.0, 30.0 / 255.0, 36.0 / 255.0, 1);
+
+
+// Different constant buffer alignment on platforms
+#define AZ_TRAIT_CONSTANT_BUFFER_ALIGNMENT      128

Gems/Atom/Feature/Common/Assets/Materials/Types/StandardMultilayerPBR_Common.azsli

@@ -104,6 +104,7 @@ option bool o_layer3_enabled;
 enum class DebugDrawMode { None, BlendMask, Displacement, FinalBlendWeights };
 option DebugDrawMode o_debugDrawMode;
 
+// If you modify this enum, you must update the BlendSourceUsesDisplacement function in StandardMultilayerPBR_Displacement.lua
 enum class LayerBlendSource { BlendMaskTexture, BlendMaskVertexColors, Displacement, Displacement_With_BlendMaskTexture, Displacement_With_BlendMaskVertexColors, Fallback };
 option LayerBlendSource o_layerBlendSource;
 

Gems/Atom/Feature/Common/Assets/Materials/Types/StandardMultilayerPBR_Displacement.lua

@@ -88,7 +88,7 @@ end
 -- @return a table with two values {min,max}. Negative values are below the surface and positive values are above the surface.
 function CalcOverallHeightRange(context)
     
-    local heightMinMax = {nil, nil}
+    local heightMinMax = {}
 
     local function GetMergedHeightRange(heightMinMax, offset, factor)
         top = offset
@@ -138,7 +138,8 @@ function CalcOverallHeightRange(context)
         if(enableLayer3) then GetMergedHeightRange(heightMinMax, offsetLayer3, factorLayer3) end
 
     else
-        heightMinMax = {0,0}
+        heightMinMax[0] = 0
+        heightMinMax[1] = 0
     end
 
     return heightMinMax

Gems/Atom/Feature/Common/Assets/Passes/HDRColorGrading.pass

@@ -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
                         }
                     ],

Gems/Atom/Feature/Common/Assets/Passes/LightAdaptationParent.pass

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

Gems/Atom/Feature/Common/Assets/ShaderLib/Atom/Features/PBR/DefaultObjectSrg.azsli

@@ -40,11 +40,10 @@ ShaderResourceGroup ObjectSrg : SRG_PerObject
     //! Reflection Probe (smallest probe volume that overlaps the object position)
     struct ReflectionProbeData
     {
-        float3 m_aabbPos;
-        float3 m_outerAabbMin;
-        float3 m_outerAabbMax;
-        float3 m_innerAabbMin;
-        float3 m_innerAabbMax;
+        row_major float3x4 m_modelToWorld;
+        row_major float3x4 m_modelToWorldInverse; // does not include extents
+        float3 m_outerObbHalfLengths;
+        float3 m_innerObbHalfLengths;
         float m_padding;
         bool m_useReflectionProbe;
         bool m_useParallaxCorrection;
@@ -52,4 +51,32 @@ ShaderResourceGroup ObjectSrg : SRG_PerObject
 
     ReflectionProbeData m_reflectionProbeData;
     TextureCube m_reflectionProbeCubeMap;
+
+    float4x4 GetReflectionProbeWorldMatrix()
+    {
+        float4x4 modelToWorld = float4x4(
+            float4(1, 0, 0, 0),
+            float4(0, 1, 0, 0),
+            float4(0, 0, 1, 0),
+            float4(0, 0, 0, 1));
+
+        modelToWorld[0] = m_reflectionProbeData.m_modelToWorld[0];
+        modelToWorld[1] = m_reflectionProbeData.m_modelToWorld[1];
+        modelToWorld[2] = m_reflectionProbeData.m_modelToWorld[2];
+        return modelToWorld;
+    }
+
+    float4x4 GetReflectionProbeWorldMatrixInverse()
+    {
+        float4x4 modelToWorldInverse = float4x4(
+            float4(1, 0, 0, 0),
+            float4(0, 1, 0, 0),
+            float4(0, 0, 1, 0),
+            float4(0, 0, 0, 1));
+
+        modelToWorldInverse[0] = m_reflectionProbeData.m_modelToWorldInverse[0];
+        modelToWorldInverse[1] = m_reflectionProbeData.m_modelToWorldInverse[1];
+        modelToWorldInverse[2] = m_reflectionProbeData.m_modelToWorldInverse[2];
+        return modelToWorldInverse;
+    }
 }

Gems/Atom/Feature/Common/Assets/ShaderLib/Atom/Features/PBR/LightingUtils.azsli

@@ -50,10 +50,10 @@ float GetRoughnessMip(float roughness)
     return roughness * maxRoughnessMip;
 }
 
-// compute parallax corrected reflection vector
+// compute parallax corrected reflection vector, AABB version
 // we do this by finding the intersection with the volume and adjusting the reflection vector for the surface position 
 // https://seblagarde.wordpress.com/2012/09/29/image-based-lighting-approaches-and-parallax-corrected-cubemap/
-float3 ApplyParallaxCorrection(float3 aabbMin, float3 aabbMax, float3 aabbPos, float3 positionWS, float3 reflectDir)
+float3 ApplyParallaxCorrectionAABB(float3 aabbMin, float3 aabbMax, float3 aabbPos, float3 positionWS, float3 reflectDir)
 {
     float3 rcpReflectDir = 1.0f / reflectDir;
     float3 intersectA = (aabbMax - positionWS) * rcpReflectDir;
@@ -63,3 +63,10 @@ float3 ApplyParallaxCorrection(float3 aabbMin, float3 aabbMax, float3 aabbPos, f
     float3 intersectPos = reflectDir * distance + positionWS;
     return (intersectPos - aabbPos);
 }
+
+// compute parallax corrected reflection vector, OBB version
+float3 ApplyParallaxCorrectionOBB(float4x4 obbTransformInverse, float3 obbHalfExtents, float3 positionWS, float3 reflectDir)
+{
+    float4 p = mul(obbTransformInverse, float4(positionWS, 1.0f));
+    return ApplyParallaxCorrectionAABB(-obbHalfExtents, obbHalfExtents, float3(0.0f, 0.0f, 0.0f), p, reflectDir);
+}

Gems/Atom/Feature/Common/Assets/ShaderLib/Atom/Features/PBR/Lights/Ibl.azsli

@@ -48,10 +48,9 @@ float3 GetIblSpecular(
     {
         if (ObjectSrg::m_reflectionProbeData.m_useParallaxCorrection)
         {
-            reflectDir = ApplyParallaxCorrection(
-                ObjectSrg::m_reflectionProbeData.m_outerAabbMin,
-                ObjectSrg::m_reflectionProbeData.m_outerAabbMax,
-                ObjectSrg::m_reflectionProbeData.m_aabbPos,
+            reflectDir = ApplyParallaxCorrectionOBB(
+                ObjectSrg::GetReflectionProbeWorldMatrixInverse(),
+                ObjectSrg::m_reflectionProbeData.m_outerObbHalfLengths,
                 position,
                 reflectDir);
         }
@@ -60,11 +59,10 @@ float3 GetIblSpecular(
         probeSpecular *= (specularF0 * brdf.x + brdf.y);
     
         // compute blend amount based on world position in the reflection probe volume
-        float blendAmount = ComputeLerpBetweenInnerOuterAABBs(
-            ObjectSrg::m_reflectionProbeData.m_innerAabbMin,
-            ObjectSrg::m_reflectionProbeData.m_innerAabbMax,
-            ObjectSrg::m_reflectionProbeData.m_outerAabbMax,
-            ObjectSrg::m_reflectionProbeData.m_aabbPos,
+        float blendAmount = ComputeLerpBetweenInnerOuterOBBs(
+            ObjectSrg::GetReflectionProbeWorldMatrixInverse(),
+            ObjectSrg::m_reflectionProbeData.m_innerObbHalfLengths,
+            ObjectSrg::m_reflectionProbeData.m_outerObbHalfLengths,
             position);
     
         outSpecular = lerp(outSpecular, probeSpecular, blendAmount);

Gems/Atom/Feature/Common/Assets/Shaders/PostProcessing/HDRColorGrading.azsl

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

Gems/Atom/Feature/Common/Assets/Shaders/Reflections/ReflectionProbeBlendWeight.azsl

@@ -63,7 +63,7 @@ PSOutput MainPS(VSOutput IN, in uint sampleIndex : SV_SampleIndex)
     // make sure the pixel belongs to this probe volume
     // this is necessary since it could have the correct stencil value but actually reside 
     // in another volume that's in between the camera and the volume we're rendering
-    if (!AabbContainsPoint(ObjectSrg::m_outerAabbMin, ObjectSrg::m_outerAabbMax, positionWS))
+    if (!ObbContainsPoint(ObjectSrg::GetWorldMatrixInverse(), ObjectSrg::m_outerObbHalfLengths, positionWS))
     {
         discard;
     }
@@ -71,11 +71,15 @@ PSOutput MainPS(VSOutput IN, in uint sampleIndex : SV_SampleIndex)
     // determine blend based on position with respect to the inner and outer AABBs
     // if it's inside the inner AABB it blends at 100%, otherwise it's the percentage of the distance between the inner/outer AABB
     float blendWeight = 1.0f;
-    if (!AabbContainsPoint(ObjectSrg::m_innerAabbMin, ObjectSrg::m_innerAabbMax, positionWS))
+    if (!ObbContainsPoint(ObjectSrg::GetWorldMatrixInverse(), ObjectSrg::m_innerObbHalfLengths, positionWS))
     {
         // not inside the inner AABB, so it's in between the inner and outer AABBs
         // compute blend amount based on the distance to the outer AABB
-        blendWeight = ComputeLerpBetweenInnerOuterAABBs(ObjectSrg::m_innerAabbMin, ObjectSrg::m_innerAabbMax, ObjectSrg::m_outerAabbMax, ObjectSrg::m_aabbPos, positionWS);
+        blendWeight = ComputeLerpBetweenInnerOuterOBBs(
+            ObjectSrg::GetWorldMatrixInverse(),
+            ObjectSrg::m_innerObbHalfLengths,
+            ObjectSrg::m_outerObbHalfLengths,
+            positionWS);
     }
 
     // write the blend weight (additive) at this position for the probe volume

Gems/Atom/Feature/Common/Assets/Shaders/Reflections/ReflectionProbeRenderCommon.azsli

@@ -12,12 +12,12 @@
 #include <Atom/Features/PBR/Microfacet/Fresnel.azsli>
 
 // compute final probe specular using the probe cubemap and the roughness, normals, and specularF0 for the surface
-bool ComputeProbeSpecular(float2 screenCoords, float3 positionWS, float3 aabbMin, float3 aabbMax, uint sampleIndex, out float3 specular)
+bool ComputeProbeSpecular(float2 screenCoords, float3 positionWS, float4x4 obbTransformInverse, float3 outerObbHalfLengths, uint sampleIndex, out float3 specular)
 {
     // make sure the pixel belongs to this probe volume
     // this is necessary since it could have the correct stencil value but actually reside 
     // in another volume that's in between the camera and the volume we're rendering
-    if (!AabbContainsPoint(aabbMin, aabbMax, positionWS))
+    if (!ObbContainsPoint(obbTransformInverse, outerObbHalfLengths, positionWS))
     {
         return false;
     }
@@ -47,7 +47,11 @@ bool ComputeProbeSpecular(float2 screenCoords, float3 positionWS, float3 aabbMin
     float3 localReflectDir = reflectDir;
     if (ObjectSrg::m_useParallaxCorrection)
     {
-        localReflectDir = ApplyParallaxCorrection(ObjectSrg::m_outerAabbMin, ObjectSrg::m_outerAabbMax, ObjectSrg::m_aabbPos, positionWS, reflectDir);
+        localReflectDir = ApplyParallaxCorrectionOBB(
+            ObjectSrg::GetWorldMatrixInverse(),
+            ObjectSrg::m_outerObbHalfLengths,
+            positionWS,
+            reflectDir);
     }
 
     // sample reflection cubemap with the appropriate roughness mip

Gems/Atom/Feature/Common/Assets/Shaders/Reflections/ReflectionProbeRenderInner.azsl

@@ -75,7 +75,7 @@ PSOutput MainPS(VSOutput IN, in uint sampleIndex : SV_SampleIndex)
 
     // compute specular using the probe cubemap and the roughness, normals, and specularF0 for the surface
     float3 specular = float3(0.0f, 0.0f, 0.0f);
-    if (!ComputeProbeSpecular(IN.m_position.xy, positionWS, ObjectSrg::m_innerAabbMin, ObjectSrg::m_innerAabbMax, sampleIndex, specular))
+    if (!ComputeProbeSpecular(IN.m_position.xy, positionWS, ObjectSrg::GetWorldMatrixInverse(), ObjectSrg::m_innerObbHalfLengths, sampleIndex, specular))
     {
         discard;
     }

Gems/Atom/Feature/Common/Assets/Shaders/Reflections/ReflectionProbeRenderObjectSrg.azsli

@@ -13,12 +13,9 @@
 ShaderResourceGroup ObjectSrg : SRG_PerObject
 {
     row_major float3x4 m_modelToWorld;
-
-    float3 m_aabbPos;
-    float3 m_outerAabbMin;
-    float3 m_outerAabbMax;
-    float3 m_innerAabbMin;
-    float3 m_innerAabbMax;
+    row_major float3x4 m_modelToWorldInverse; // does not include extents
+    float3 m_outerObbHalfLengths;
+    float3 m_innerObbHalfLengths;
     bool m_useParallaxCorrection;
     TextureCube m_reflectionCubeMap;
 
@@ -35,4 +32,18 @@ ShaderResourceGroup ObjectSrg : SRG_PerObject
         modelToWorld[2] = ObjectSrg::m_modelToWorld[2];
         return modelToWorld;
     }
+
+    float4x4 GetWorldMatrixInverse()
+    {
+        float4x4 modelToWorldInverse = float4x4(
+            float4(1, 0, 0, 0),
+            float4(0, 1, 0, 0),
+            float4(0, 0, 1, 0),
+            float4(0, 0, 0, 1));
+
+        modelToWorldInverse[0] = ObjectSrg::m_modelToWorldInverse[0];
+        modelToWorldInverse[1] = ObjectSrg::m_modelToWorldInverse[1];
+        modelToWorldInverse[2] = ObjectSrg::m_modelToWorldInverse[2];
+        return modelToWorldInverse;
+    }
 }

Gems/Atom/Feature/Common/Assets/Shaders/Reflections/ReflectionProbeRenderOuter.azsl

@@ -77,7 +77,7 @@ PSOutput MainPS(VSOutput IN, in uint sampleIndex : SV_SampleIndex)
 
     // compute specular using the probe cubemap and the roughness, normals, and specularF0 for the surface
     float3 specular = float3(0.0f, 0.0f, 0.0f);
-    if (!ComputeProbeSpecular(IN.m_position.xy, positionWS, ObjectSrg::m_outerAabbMin, ObjectSrg::m_outerAabbMax, sampleIndex, specular))
+    if (!ComputeProbeSpecular(IN.m_position.xy, positionWS, ObjectSrg::GetWorldMatrixInverse(), ObjectSrg::m_outerObbHalfLengths, sampleIndex, specular))
     {
         discard;
     }
@@ -85,13 +85,17 @@ PSOutput MainPS(VSOutput IN, in uint sampleIndex : SV_SampleIndex)
     // determine blend based on position with respect to the inner and outer AABBs
     // if it's inside the inner AABB it blends at 100%, otherwise it's the percentage of the distance between the inner/outer AABB
     float blendWeight = 1.0f;
-    if (!AabbContainsPoint(ObjectSrg::m_innerAabbMin, ObjectSrg::m_innerAabbMax, positionWS))
+    if (!ObbContainsPoint(ObjectSrg::GetWorldMatrixInverse(), ObjectSrg::m_innerObbHalfLengths, positionWS))
     {
         // not inside the inner AABB, so it's in between the inner and outer AABBs
         // compute blend amount based on the distance to the outer AABB
-        blendWeight = ComputeLerpBetweenInnerOuterAABBs(ObjectSrg::m_innerAabbMin, ObjectSrg::m_innerAabbMax, ObjectSrg::m_outerAabbMax, ObjectSrg::m_aabbPos, positionWS);
+        blendWeight = ComputeLerpBetweenInnerOuterOBBs(
+            ObjectSrg::GetWorldMatrixInverse(),
+            ObjectSrg::m_innerObbHalfLengths,
+            ObjectSrg::m_outerObbHalfLengths,
+            positionWS);
     }
-        
+
     // retrieve the blend weight of all probes at this location
     float blendWeightAllProbes = PassSrg::m_blendWeight.Load(IN.m_position.xy, sampleIndex).r;
 

Gems/Atom/Feature/Common/Code/Include/Atom/Feature/PostProcess/ColorGrading/HDRColorGradingParams.inl

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

Gems/Atom/Feature/Common/Code/Include/Atom/Feature/PostProcess/ColorGrading/HDRColorGradingSettingsInterface.h

@@ -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;
+        };
+    }
+}

Gems/Atom/Feature/Common/Code/Include/Atom/Feature/PostProcess/PostProcessSettings.inl

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

Gems/Atom/Feature/Common/Code/Include/Atom/Feature/PostProcess/PostProcessSettingsInterface.h

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

Gems/Atom/Feature/Common/Code/Source/CommonSystemComponent.cpp

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

Gems/Atom/Feature/Common/Code/Source/Mesh/MeshFeatureProcessor.cpp

@@ -1111,20 +1111,17 @@ namespace AZ
             if (reflectionProbeFeatureProcessor && (m_descriptor.m_useForwardPassIblSpecular || m_hasForwardPassIblSpecularMaterial))
             {
                 // retrieve probe constant indices
-                AZ::RHI::ShaderInputConstantIndex posConstantIndex = m_shaderResourceGroup->FindShaderInputConstantIndex(Name("m_reflectionProbeData.m_aabbPos"));
-                AZ_Error("MeshDataInstance", posConstantIndex.IsValid(), "Failed to find ReflectionProbe constant index");
+                AZ::RHI::ShaderInputConstantIndex modelToWorldConstantIndex = m_shaderResourceGroup->FindShaderInputConstantIndex(Name("m_reflectionProbeData.m_modelToWorld"));
+                AZ_Error("MeshDataInstance", modelToWorldConstantIndex.IsValid(), "Failed to find ReflectionProbe constant index");
 
-                AZ::RHI::ShaderInputConstantIndex outerAabbMinConstantIndex = m_shaderResourceGroup->FindShaderInputConstantIndex(Name("m_reflectionProbeData.m_outerAabbMin"));
-                AZ_Error("MeshDataInstance", outerAabbMinConstantIndex.IsValid(), "Failed to find ReflectionProbe constant index");
+                AZ::RHI::ShaderInputConstantIndex modelToWorldInverseConstantIndex = m_shaderResourceGroup->FindShaderInputConstantIndex(Name("m_reflectionProbeData.m_modelToWorldInverse"));
+                AZ_Error("MeshDataInstance", modelToWorldInverseConstantIndex.IsValid(), "Failed to find ReflectionProbe constant index");
 
-                AZ::RHI::ShaderInputConstantIndex outerAabbMaxConstantIndex = m_shaderResourceGroup->FindShaderInputConstantIndex(Name("m_reflectionProbeData.m_outerAabbMax"));
-                AZ_Error("MeshDataInstance", outerAabbMaxConstantIndex.IsValid(), "Failed to find ReflectionProbe constant index");
+                AZ::RHI::ShaderInputConstantIndex outerObbHalfLengthsConstantIndex = m_shaderResourceGroup->FindShaderInputConstantIndex(Name("m_reflectionProbeData.m_outerObbHalfLengths"));
+                AZ_Error("MeshDataInstance", outerObbHalfLengthsConstantIndex.IsValid(), "Failed to find ReflectionProbe constant index");
 
-                AZ::RHI::ShaderInputConstantIndex innerAabbMinConstantIndex = m_shaderResourceGroup->FindShaderInputConstantIndex(Name("m_reflectionProbeData.m_innerAabbMin"));
-                AZ_Error("MeshDataInstance", innerAabbMinConstantIndex.IsValid(), "Failed to find ReflectionProbe constant index");
-
-                AZ::RHI::ShaderInputConstantIndex innerAabbMaxConstantIndex = m_shaderResourceGroup->FindShaderInputConstantIndex(Name("m_reflectionProbeData.m_innerAabbMax"));
-                AZ_Error("MeshDataInstance", innerAabbMaxConstantIndex.IsValid(), "Failed to find ReflectionProbe constant index");
+                AZ::RHI::ShaderInputConstantIndex innerObbHalfLengthsConstantIndex = m_shaderResourceGroup->FindShaderInputConstantIndex(Name("m_reflectionProbeData.m_innerObbHalfLengths"));
+                AZ_Error("MeshDataInstance", innerObbHalfLengthsConstantIndex.IsValid(), "Failed to find ReflectionProbe constant index");
 
                 AZ::RHI::ShaderInputConstantIndex useReflectionProbeConstantIndex = m_shaderResourceGroup->FindShaderInputConstantIndex(Name("m_reflectionProbeData.m_useReflectionProbe"));
                 AZ_Error("MeshDataInstance", useReflectionProbeConstantIndex.IsValid(), "Failed to find ReflectionProbe constant index");
@@ -1146,11 +1143,10 @@ namespace AZ
 
                 if (!reflectionProbes.empty() && reflectionProbes[0])
                 {
-                    m_shaderResourceGroup->SetConstant(posConstantIndex, reflectionProbes[0]->GetPosition());
-                    m_shaderResourceGroup->SetConstant(outerAabbMinConstantIndex, reflectionProbes[0]->GetOuterAabbWs().GetMin());
-                    m_shaderResourceGroup->SetConstant(outerAabbMaxConstantIndex, reflectionProbes[0]->GetOuterAabbWs().GetMax());
-                    m_shaderResourceGroup->SetConstant(innerAabbMinConstantIndex, reflectionProbes[0]->GetInnerAabbWs().GetMin());
-                    m_shaderResourceGroup->SetConstant(innerAabbMaxConstantIndex, reflectionProbes[0]->GetInnerAabbWs().GetMax());
+                    m_shaderResourceGroup->SetConstant(modelToWorldConstantIndex, reflectionProbes[0]->GetTransform());
+                    m_shaderResourceGroup->SetConstant(modelToWorldInverseConstantIndex, Matrix3x4::CreateFromTransform(reflectionProbes[0]->GetTransform()).GetInverseFull());
+                    m_shaderResourceGroup->SetConstant(outerObbHalfLengthsConstantIndex, reflectionProbes[0]->GetOuterObbWs().GetHalfLengths());
+                    m_shaderResourceGroup->SetConstant(innerObbHalfLengthsConstantIndex, reflectionProbes[0]->GetInnerObbWs().GetHalfLengths());
                     m_shaderResourceGroup->SetConstant(useReflectionProbeConstantIndex, true);
                     m_shaderResourceGroup->SetConstant(useParallaxCorrectionConstantIndex, reflectionProbes[0]->GetUseParallaxCorrection());
 

Gems/Atom/Feature/Common/Code/Source/PostProcess/ColorGrading/HDRColorGradingSettings.cpp

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

Gems/Atom/Feature/Common/Code/Source/PostProcess/ColorGrading/HDRColorGradingSettings.h

@@ -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;
+        };
+    }
+}

Gems/Atom/Feature/Common/Code/Source/PostProcess/PostProcessSettings.h

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

Gems/Atom/Feature/Common/Code/Source/PostProcessing/HDRColorGradingPass.cpp

@@ -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;
+        }
+    }
+}

Gems/Atom/Feature/Common/Code/Source/PostProcessing/HDRColorGradingPass.h

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

Gems/Atom/Feature/Common/Code/Source/ReflectionProbe/ReflectionProbe.cpp

@@ -138,43 +138,39 @@ namespace AZ
             if (m_updateSrg)
             {
                 // stencil Srg
-                // Note: the stencil pass uses a slightly reduced inner AABB to avoid seams
+                // Note: the stencil pass uses a slightly reduced inner OBB to avoid seams
                 Vector3 innerExtentsReduced = m_innerExtents - Vector3(0.1f, 0.1f, 0.1f);
-                Matrix3x4 modelToWorldStencil = Matrix3x4::CreateFromMatrix3x3AndTranslation(Matrix3x3::CreateIdentity(), m_transform.GetTranslation()) * Matrix3x4::CreateScale(innerExtentsReduced);
+                Matrix3x4 modelToWorldStencil = Matrix3x4::CreateFromQuaternionAndTranslation(m_transform.GetRotation(), m_transform.GetTranslation()) * Matrix3x4::CreateScale(innerExtentsReduced);
                 m_stencilSrg->SetConstant(m_reflectionRenderData->m_modelToWorldStencilConstantIndex, modelToWorldStencil);
                 m_stencilSrg->Compile();
 
+                Matrix3x4 modelToWorldInverse = Matrix3x4::CreateFromTransform(m_transform).GetInverseFull();
+
                 // blend weight Srg
-                Matrix3x4 modelToWorldOuter = Matrix3x4::CreateFromMatrix3x3AndTranslation(Matrix3x3::CreateIdentity(), m_transform.GetTranslation()) * Matrix3x4::CreateScale(m_outerExtents);
+                Matrix3x4 modelToWorldOuter = Matrix3x4::CreateFromQuaternionAndTranslation(m_transform.GetRotation(), m_transform.GetTranslation()) * Matrix3x4::CreateScale(m_outerExtents);
                 m_blendWeightSrg->SetConstant(m_reflectionRenderData->m_modelToWorldRenderConstantIndex, modelToWorldOuter);
-                m_blendWeightSrg->SetConstant(m_reflectionRenderData->m_aabbPosRenderConstantIndex, m_outerAabbWs.GetCenter());
-                m_blendWeightSrg->SetConstant(m_reflectionRenderData->m_outerAabbMinRenderConstantIndex, m_outerAabbWs.GetMin());
-                m_blendWeightSrg->SetConstant(m_reflectionRenderData->m_outerAabbMaxRenderConstantIndex, m_outerAabbWs.GetMax());
-                m_blendWeightSrg->SetConstant(m_reflectionRenderData->m_innerAabbMinRenderConstantIndex, m_innerAabbWs.GetMin());
-                m_blendWeightSrg->SetConstant(m_reflectionRenderData->m_innerAabbMaxRenderConstantIndex, m_innerAabbWs.GetMax());
+                m_blendWeightSrg->SetConstant(m_reflectionRenderData->m_modelToWorldInverseRenderConstantIndex, modelToWorldInverse);
+                m_blendWeightSrg->SetConstant(m_reflectionRenderData->m_outerObbHalfLengthsRenderConstantIndex, m_outerObbWs.GetHalfLengths());
+                m_blendWeightSrg->SetConstant(m_reflectionRenderData->m_innerObbHalfLengthsRenderConstantIndex, m_innerObbWs.GetHalfLengths());
                 m_blendWeightSrg->SetConstant(m_reflectionRenderData->m_useParallaxCorrectionRenderConstantIndex, m_useParallaxCorrection);
                 m_blendWeightSrg->SetImage(m_reflectionRenderData->m_reflectionCubeMapRenderImageIndex, m_cubeMapImage);
                 m_blendWeightSrg->Compile();
 
                 // render outer Srg
                 m_renderOuterSrg->SetConstant(m_reflectionRenderData->m_modelToWorldRenderConstantIndex, modelToWorldOuter);
-                m_renderOuterSrg->SetConstant(m_reflectionRenderData->m_aabbPosRenderConstantIndex, m_outerAabbWs.GetCenter());
-                m_renderOuterSrg->SetConstant(m_reflectionRenderData->m_outerAabbMinRenderConstantIndex, m_outerAabbWs.GetMin());
-                m_renderOuterSrg->SetConstant(m_reflectionRenderData->m_outerAabbMaxRenderConstantIndex, m_outerAabbWs.GetMax());
-                m_renderOuterSrg->SetConstant(m_reflectionRenderData->m_innerAabbMinRenderConstantIndex, m_innerAabbWs.GetMin());
-                m_renderOuterSrg->SetConstant(m_reflectionRenderData->m_innerAabbMaxRenderConstantIndex, m_innerAabbWs.GetMax());
+                m_renderOuterSrg->SetConstant(m_reflectionRenderData->m_modelToWorldInverseRenderConstantIndex, modelToWorldInverse);
+                m_renderOuterSrg->SetConstant(m_reflectionRenderData->m_outerObbHalfLengthsRenderConstantIndex, m_outerObbWs.GetHalfLengths());
+                m_renderOuterSrg->SetConstant(m_reflectionRenderData->m_innerObbHalfLengthsRenderConstantIndex, m_innerObbWs.GetHalfLengths());
                 m_renderOuterSrg->SetConstant(m_reflectionRenderData->m_useParallaxCorrectionRenderConstantIndex, m_useParallaxCorrection);
                 m_renderOuterSrg->SetImage(m_reflectionRenderData->m_reflectionCubeMapRenderImageIndex, m_cubeMapImage);
                 m_renderOuterSrg->Compile();
 
                 // render inner Srg
-                Matrix3x4 modelToWorldInner = Matrix3x4::CreateFromMatrix3x3AndTranslation(Matrix3x3::CreateIdentity(), m_transform.GetTranslation()) * Matrix3x4::CreateScale(m_innerExtents);
+                Matrix3x4 modelToWorldInner = Matrix3x4::CreateFromQuaternionAndTranslation(m_transform.GetRotation(), m_transform.GetTranslation()) * Matrix3x4::CreateScale(m_innerExtents);
                 m_renderInnerSrg->SetConstant(m_reflectionRenderData->m_modelToWorldRenderConstantIndex, modelToWorldInner);
-                m_renderInnerSrg->SetConstant(m_reflectionRenderData->m_aabbPosRenderConstantIndex, m_outerAabbWs.GetCenter());
-                m_renderInnerSrg->SetConstant(m_reflectionRenderData->m_outerAabbMinRenderConstantIndex, m_outerAabbWs.GetMin());
-                m_renderInnerSrg->SetConstant(m_reflectionRenderData->m_outerAabbMaxRenderConstantIndex, m_outerAabbWs.GetMax());
-                m_renderInnerSrg->SetConstant(m_reflectionRenderData->m_innerAabbMinRenderConstantIndex, m_innerAabbWs.GetMin());
-                m_renderInnerSrg->SetConstant(m_reflectionRenderData->m_innerAabbMaxRenderConstantIndex, m_innerAabbWs.GetMax());
+                m_renderInnerSrg->SetConstant(m_reflectionRenderData->m_modelToWorldInverseRenderConstantIndex, modelToWorldInverse);
+                m_renderInnerSrg->SetConstant(m_reflectionRenderData->m_outerObbHalfLengthsRenderConstantIndex, m_outerObbWs.GetHalfLengths());
+                m_renderInnerSrg->SetConstant(m_reflectionRenderData->m_innerObbHalfLengthsRenderConstantIndex, m_innerObbWs.GetHalfLengths());
                 m_renderInnerSrg->SetConstant(m_reflectionRenderData->m_useParallaxCorrectionRenderConstantIndex, m_useParallaxCorrection);
                 m_renderInnerSrg->SetImage(m_reflectionRenderData->m_reflectionCubeMapRenderImageIndex, m_cubeMapImage);
                 m_renderInnerSrg->Compile();
@@ -244,22 +240,22 @@ namespace AZ
             m_outerExtents *= m_transform.GetUniformScale();
             m_innerExtents *= m_transform.GetUniformScale();
 
-            m_outerAabbWs = Aabb::CreateCenterHalfExtents(m_transform.GetTranslation(), m_outerExtents / 2.0f);
-            m_innerAabbWs = Aabb::CreateCenterHalfExtents(m_transform.GetTranslation(), m_innerExtents / 2.0f);
+            m_outerObbWs = Obb::CreateFromPositionRotationAndHalfLengths(m_transform.GetTranslation(), m_transform.GetRotation(), m_outerExtents / 2.0f);
+            m_innerObbWs = Obb::CreateFromPositionRotationAndHalfLengths(m_transform.GetTranslation(), m_transform.GetRotation(), m_innerExtents / 2.0f);
             m_updateSrg = true;
         }
 
         void ReflectionProbe::SetOuterExtents(const AZ::Vector3& outerExtents)
         {
             m_outerExtents = outerExtents * m_transform.GetUniformScale();
-            m_outerAabbWs = Aabb::CreateCenterHalfExtents(m_transform.GetTranslation(), m_outerExtents / 2.0f);
+            m_outerObbWs = Obb::CreateFromPositionRotationAndHalfLengths(m_transform.GetTranslation(), m_transform.GetRotation(), m_outerExtents / 2.0f);
             m_updateSrg = true;
         }
 
         void ReflectionProbe::SetInnerExtents(const AZ::Vector3& innerExtents)
         {
             m_innerExtents = innerExtents * m_transform.GetUniformScale();
-            m_innerAabbWs = Aabb::CreateCenterHalfExtents(m_transform.GetTranslation(), m_innerExtents / 2.0f);
+            m_innerObbWs = Obb::CreateFromPositionRotationAndHalfLengths(m_transform.GetTranslation(), m_transform.GetRotation(), m_innerExtents / 2.0f);
             m_updateSrg = true;
         }
 
@@ -410,13 +406,14 @@ namespace AZ
             lod.m_screenCoverageMax = 1.0f;
 
             // update cullable bounds
+            Aabb outerAabb = Aabb::CreateFromObb(m_outerObbWs);
             Vector3 center;
             float radius;
-            m_outerAabbWs.GetAsSphere(center, radius);
+            outerAabb.GetAsSphere(center, radius);
 
             m_cullable.m_cullData.m_boundingSphere = Sphere(center, radius);
-            m_cullable.m_cullData.m_boundingObb = m_outerAabbWs.GetTransformedObb(AZ::Transform::CreateIdentity());
-            m_cullable.m_cullData.m_visibilityEntry.m_boundingVolume = m_outerAabbWs;
+            m_cullable.m_cullData.m_boundingObb = m_outerObbWs;
+            m_cullable.m_cullData.m_visibilityEntry.m_boundingVolume = outerAabb;
             m_cullable.m_cullData.m_visibilityEntry.m_userData = &m_cullable;
             m_cullable.m_cullData.m_visibilityEntry.m_typeFlags = AzFramework::VisibilityEntry::TYPE_RPI_Cullable;
 

Gems/Atom/Feature/Common/Code/Source/ReflectionProbe/ReflectionProbe.h

@@ -55,15 +55,13 @@ namespace AZ
             RHI::DrawListTag m_renderOuterDrawListTag;
             RHI::DrawListTag m_renderInnerDrawListTag;
 
-            RHI::ShaderInputConstantIndex m_modelToWorldStencilConstantIndex;
-            RHI::ShaderInputConstantIndex m_modelToWorldRenderConstantIndex;
-            RHI::ShaderInputConstantIndex m_aabbPosRenderConstantIndex;
-            RHI::ShaderInputConstantIndex m_outerAabbMinRenderConstantIndex;
-            RHI::ShaderInputConstantIndex m_outerAabbMaxRenderConstantIndex;
-            RHI::ShaderInputConstantIndex m_innerAabbMinRenderConstantIndex;
-            RHI::ShaderInputConstantIndex m_innerAabbMaxRenderConstantIndex;
-            RHI::ShaderInputConstantIndex m_useParallaxCorrectionRenderConstantIndex;
-            RHI::ShaderInputImageIndex m_reflectionCubeMapRenderImageIndex;
+            RHI::ShaderInputNameIndex m_modelToWorldStencilConstantIndex = "m_modelToWorld";
+            RHI::ShaderInputNameIndex m_modelToWorldRenderConstantIndex = "m_modelToWorld";
+            RHI::ShaderInputNameIndex m_modelToWorldInverseRenderConstantIndex = "m_modelToWorldInverse";
+            RHI::ShaderInputNameIndex m_outerObbHalfLengthsRenderConstantIndex = "m_outerObbHalfLengths";
+            RHI::ShaderInputNameIndex m_innerObbHalfLengthsRenderConstantIndex = "m_innerObbHalfLengths";
+            RHI::ShaderInputNameIndex m_useParallaxCorrectionRenderConstantIndex = "m_useParallaxCorrection";
+            RHI::ShaderInputNameIndex m_reflectionCubeMapRenderImageIndex = "m_reflectionCubeMap";
         };
 
         // ReflectionProbe manages all aspects of a single probe, including rendering, visualization, and cubemap generation
@@ -78,6 +76,7 @@ namespace AZ
             void Simulate(uint32_t probeIndex);
 
             const Vector3& GetPosition() const { return m_transform.GetTranslation(); }
+            const AZ::Transform& GetTransform() const { return m_transform; }
             void SetTransform(const AZ::Transform& transform);
 
             const AZ::Vector3& GetOuterExtents() const { return m_outerExtents; }
@@ -86,8 +85,8 @@ namespace AZ
             const AZ::Vector3& GetInnerExtents() const { return m_innerExtents; }
             void SetInnerExtents(const AZ::Vector3& innerExtents);
 
-            const Aabb& GetOuterAabbWs() const { return m_outerAabbWs; }
-            const Aabb& GetInnerAabbWs() const { return m_innerAabbWs; }
+            const Obb& GetOuterObbWs() const { return m_outerObbWs; }
+            const Obb& GetInnerObbWs() const { return m_innerObbWs; }
 
             const Data::Instance<RPI::Image>& GetCubeMapImage() const { return m_cubeMapImage; }
             void SetCubeMapImage(const Data::Instance<RPI::Image>& cubeMapImage, const AZStd::string& relativePath);
@@ -133,9 +132,9 @@ namespace AZ
             AZ::Vector3 m_outerExtents = AZ::Vector3(0.0f, 0.0f, 0.0f);
             AZ::Vector3 m_innerExtents = AZ::Vector3(0.0f, 0.0f, 0.0f);
 
-            // probe volume AABBs (world space), built from position and extents
-            Aabb m_outerAabbWs;
-            Aabb m_innerAabbWs;
+            // probe volume OBBs (world space), built from position and extents
+            Obb m_outerObbWs;
+            Obb m_innerObbWs;
 
             // cubemap
             Data::Instance<RPI::Image> m_cubeMapImage;

Gems/Atom/Feature/Common/Code/Source/ReflectionProbe/ReflectionProbeFeatureProcessor.cpp

@@ -77,61 +77,6 @@ namespace AZ
                 m_reflectionRenderData.m_renderInnerSrgLayout,
                 m_reflectionRenderData.m_renderInnerDrawListTag);
 
-            // create ShaderResourceGroups here so we can get the layout and cache the indices
-            // Note: the SRGs are not needed beyond this method since each probe creates its own SRGs, we are just interested in the indices
-
-            // cache probe stencil shader indices 
-            Data::Instance<RPI::ShaderResourceGroup> stencilSrg = RPI::ShaderResourceGroup::Create(
-                m_reflectionRenderData.m_stencilShader->GetAsset(),
-                m_reflectionRenderData.m_stencilShader->GetSupervariantIndex(),
-                m_reflectionRenderData.m_stencilSrgLayout->GetName());
-            AZ_Error("ReflectionProbeFeatureProcessor", stencilSrg.get(), "Failed to create stencil back face shader resource group");
-
-            const RHI::ShaderResourceGroupLayout* stencilSrgLayout = stencilSrg->GetLayout();
-            Name modelToWorldConstantName = Name("m_modelToWorld");
-            m_reflectionRenderData.m_modelToWorldStencilConstantIndex = stencilSrgLayout->FindShaderInputConstantIndex(modelToWorldConstantName);
-            AZ_Error("ReflectionProbeFeatureProcessor", m_reflectionRenderData.m_modelToWorldStencilConstantIndex.IsValid(), "Failed to find stencil shader input constant [%s]", modelToWorldConstantName.GetCStr());
-
-            // cache probe render shader indices
-            // Note: the outer and inner render shaders use the same Srg
-            Data::Instance<RPI::ShaderResourceGroup> renderReflectionSrg = RPI::ShaderResourceGroup::Create(
-                m_reflectionRenderData.m_renderOuterShader->GetAsset(),
-                m_reflectionRenderData.m_renderOuterShader->GetSupervariantIndex(),
-                m_reflectionRenderData.m_renderOuterSrgLayout->GetName());
-            AZ_Error("ReflectionProbeFeatureProcessor", renderReflectionSrg.get(), "Failed to create render reflection shader resource group");
-
-            const RHI::ShaderResourceGroupLayout* renderReflectionSrgLayout = renderReflectionSrg->GetLayout();
-            m_reflectionRenderData.m_modelToWorldRenderConstantIndex = renderReflectionSrgLayout->FindShaderInputConstantIndex(modelToWorldConstantName);
-            AZ_Error("ReflectionProbeFeatureProcessor", m_reflectionRenderData.m_modelToWorldRenderConstantIndex.IsValid(), "Failed to find render shader input constant [%s]", modelToWorldConstantName.GetCStr());
-
-            Name aabbPosConstantName = Name("m_aabbPos");
-            m_reflectionRenderData.m_aabbPosRenderConstantIndex = renderReflectionSrgLayout->FindShaderInputConstantIndex(aabbPosConstantName);
-            AZ_Error("ReflectionProbeFeatureProcessor", m_reflectionRenderData.m_aabbPosRenderConstantIndex.IsValid(), "Failed to find render shader input constant [%s]", aabbPosConstantName.GetCStr());
-
-            Name outerAabbMinConstantName = Name("m_outerAabbMin");
-            m_reflectionRenderData.m_outerAabbMinRenderConstantIndex = renderReflectionSrgLayout->FindShaderInputConstantIndex(outerAabbMinConstantName);
-            AZ_Error("ReflectionProbeFeatureProcessor", m_reflectionRenderData.m_outerAabbMinRenderConstantIndex.IsValid(), "Failed to find render shader input constant [%s]", outerAabbMinConstantName.GetCStr());
-
-            Name outerAabbMaxConstantName = Name("m_outerAabbMax");
-            m_reflectionRenderData.m_outerAabbMaxRenderConstantIndex = renderReflectionSrgLayout->FindShaderInputConstantIndex(outerAabbMaxConstantName);
-            AZ_Error("ReflectionProbeFeatureProcessor", m_reflectionRenderData.m_outerAabbMaxRenderConstantIndex.IsValid(), "Failed to find render shader input constant [%s]", outerAabbMaxConstantName.GetCStr());
-
-            Name innerAabbMinConstantName = Name("m_innerAabbMin");
-            m_reflectionRenderData.m_innerAabbMinRenderConstantIndex = renderReflectionSrgLayout->FindShaderInputConstantIndex(innerAabbMinConstantName);
-            AZ_Error("ReflectionProbeFeatureProcessor", m_reflectionRenderData.m_innerAabbMinRenderConstantIndex.IsValid(), "Failed to find render shader input constant [%s]", innerAabbMinConstantName.GetCStr());
-
-            Name innerAabbMaxConstantName = Name("m_innerAabbMax");
-            m_reflectionRenderData.m_innerAabbMaxRenderConstantIndex = renderReflectionSrgLayout->FindShaderInputConstantIndex(innerAabbMaxConstantName);
-            AZ_Error("ReflectionProbeFeatureProcessor", m_reflectionRenderData.m_innerAabbMaxRenderConstantIndex.IsValid(), "Failed to find render shader input constant [%s]", innerAabbMaxConstantName.GetCStr());
-
-            Name useParallaxCorrectionConstantName = Name("m_useParallaxCorrection");
-            m_reflectionRenderData.m_useParallaxCorrectionRenderConstantIndex = renderReflectionSrgLayout->FindShaderInputConstantIndex(useParallaxCorrectionConstantName);
-            AZ_Error("ReflectionProbeFeatureProcessor", m_reflectionRenderData.m_useParallaxCorrectionRenderConstantIndex.IsValid(), "Failed to find render shader input constant [%s]", useParallaxCorrectionConstantName.GetCStr());
-
-            Name reflectionCubeMapImageName = Name("m_reflectionCubeMap");
-            m_reflectionRenderData.m_reflectionCubeMapRenderImageIndex = renderReflectionSrgLayout->FindShaderInputImageIndex(reflectionCubeMapImageName);
-            AZ_Error("ReflectionProbeFeatureProcessor", m_reflectionRenderData.m_reflectionCubeMapRenderImageIndex.IsValid(), "Failed to find render shader input image [%s]", reflectionCubeMapImageName.GetCStr());
-
             EnableSceneNotification();
         }
 
@@ -197,10 +142,11 @@ namespace AZ
                 // sort the probes by descending inner volume size, so the smallest volumes are rendered last
                 auto sortFn = [](AZStd::shared_ptr<ReflectionProbe> const& probe1, AZStd::shared_ptr<ReflectionProbe> const& probe2) -> bool
                 {
-                    const Aabb& aabb1 = probe1->GetInnerAabbWs();
-                    const Aabb& aabb2 = probe2->GetInnerAabbWs();
-                    float size1 = aabb1.GetXExtent() * aabb1.GetZExtent() * aabb1.GetYExtent();
-                    float size2 = aabb2.GetXExtent() * aabb2.GetZExtent() * aabb2.GetYExtent();
+                    const Obb& obb1 = probe1->GetInnerObbWs();
+                    const Obb& obb2 = probe2->GetInnerObbWs();
+                    float size1 = obb1.GetHalfLengthX() * obb1.GetHalfLengthZ() * obb1.GetHalfLengthY();
+                    float size2 = obb2.GetHalfLengthX() * obb2.GetHalfLengthZ() * obb2.GetHalfLengthY();
+
                     return (size1 > size2);
                 };
 
@@ -345,7 +291,7 @@ namespace AZ
             // simple AABB check to find the reflection probes that contain the position
             for (auto& reflectionProbe : m_reflectionProbes)
             {
-                if (reflectionProbe->GetOuterAabbWs().Contains(position)
+                if (reflectionProbe->GetOuterObbWs().Contains(position)
                     && reflectionProbe->GetCubeMapImage()
                     && reflectionProbe->GetCubeMapImage()->IsInitialized())
                 {

Gems/Atom/Feature/Common/Code/atom_feature_common_files.cmake

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

Gems/Atom/Feature/Common/Code/atom_feature_common_public_files.cmake

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

Gems/Atom/RHI/Code/Include/Atom/RHI/SwapChain.h

@@ -81,15 +81,6 @@ namespace AZ
 
             AZ_RTTI(SwapChain, "{888B64A5-D956-406F-9C33-CF6A54FC41B0}", Object);
 
-#if defined(PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB)
-            // On Linux platforms that uses XCB, a resize may occur in the swap chain but the command queue may still
-            // reference the original surface. This flag is a temporary fix to make sure the swap chain is ready to present
-            // We need to remove this work around with
-
-            // [GFX TODO][GHI - 2678]
-            AZStd::atomic_bool m_readyToPresent { false };
-#endif // PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
-
         protected:
             SwapChain();
 

Gems/Atom/RHI/Code/Source/RHI/SwapChain.cpp

@@ -164,12 +164,6 @@ namespace AZ
                 m_currentImageIndex = 0;
             }
 
-#if defined(PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB)
-            // If we are presenting through the editor, the resize is triggered through the editor's window, which
-            // won't happen until after the surface is ready to present
-            m_readyToPresent.store(true);
-#endif // PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
-
             return resultCode;
         }
 

Gems/Atom/RHI/Vulkan/Code/Source/RHI/CommandQueue.cpp

@@ -42,15 +42,6 @@ namespace AZ
 
         void CommandQueue::ExecuteWork(const RHI::ExecuteWorkRequest& rhiRequest)
         {
-#if defined(PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB)
-            for (RHI::SwapChain* swapChain : rhiRequest.m_swapChainsToPresent)
-            {
-                if (!swapChain->m_readyToPresent)
-                {
-                    return;
-                }
-            }
-#endif // PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
             const ExecuteWorkRequest& request = static_cast<const ExecuteWorkRequest&>(rhiRequest);
             QueueCommand([=](void* queue) 
             {

Gems/Atom/RHI/Vulkan/Code/Source/RHI/SwapChain.cpp

@@ -128,17 +128,6 @@ namespace AZ
                 nativeDimensions->m_imageFormat = ConvertFormat(m_surfaceFormat.format);
             }
 
-#if defined(PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB)
-            // When launching in game mode, the surface will be ready at this point, meaning that after
-            // intialization, this swap chain is ready to present
-            AZ::ApplicationTypeQuery appType;
-            ComponentApplicationBus::Broadcast(&AZ::ComponentApplicationBus::Events::QueryApplicationType, appType);
-            if (appType.IsGame())
-            {
-                m_readyToPresent.store(true);
-            }
-#endif // PAL_TRAIT_LINUX_WINDOW_MANAGER_XCB
-
             SetName(GetName());
             return result;
         }

Gems/Atom/RPI/Assets/ShaderLib/Atom/RPI/Math.azsli

@@ -116,6 +116,22 @@ float ComputeLerpBetweenInnerOuterAABBs(float3 innerAabbMin, float3 innerAabbMax
     return totalDistance > 0.0f ? saturate(shortestDistance / totalDistance) : 1.0f;
 }
 
+// returns true if the Obb contains the specified point
+bool ObbContainsPoint(float4x4 obbTransformInverse, float3 obbHalfExtents, float3 testPoint)
+{
+    // get the position in Obb local space, force to positive quadrant with abs()
+    float4 p = abs(mul(obbTransformInverse, float4(testPoint, 1.0f)));
+    return AabbContainsPoint(-obbHalfExtents, obbHalfExtents, p);
+}
+
+// computes [0..1] percentage of a point that's in between the inner and outer OBBs
+float ComputeLerpBetweenInnerOuterOBBs(float3x4 obbTransformInverse, float3 innerObbHalfExtents, float3 outerObbHalfExtents, float3 position)
+{
+    // get the position in Obb local space, force to positive quadrant with abs()
+    float3 p = abs(mul(obbTransformInverse, float4(position, 1.0f)));
+    return ComputeLerpBetweenInnerOuterAABBs(-innerObbHalfExtents, innerObbHalfExtents, outerObbHalfExtents, float3(0.0f, 0.0f, 0.0f), p);
+}
+
 // ---------- Normal Encoding -----------
 
 // Encode/Decode functions for Signed Octahedron normals

Gems/Atom/RPI/Code/Source/RPI.Public/Culling.cpp

@@ -730,12 +730,22 @@ namespace AZ
 
             m_debugCtx.ResetCullStats();
             m_debugCtx.m_numCullablesInScene = GetNumCullables();
+            AZ::JobCompletion beginCullingCompletion;
 
             for (auto& view : views)
             {
-                view->BeginCulling();
+                const auto cullingLambda = [&view]()
+                {
+                    view->BeginCulling();
+                };
+
+                AZ::Job* cullingJob = AZ::CreateJobFunction(AZStd::move(cullingLambda), true, nullptr);
+                cullingJob->SetDependent(&beginCullingCompletion);
+                cullingJob->Start();
             }
 
+            beginCullingCompletion.StartAndWaitForCompletion();
+
             AuxGeomDrawPtr auxGeom;
             if (m_debugCtx.m_debugDraw)
             {

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ModularViewportCameraController.h

@@ -116,11 +116,18 @@ namespace AtomToolsFramework
         // ModularViewportCameraControllerRequestBus overrides ...
         void InterpolateToTransform(const AZ::Transform& worldFromLocal, float lookAtDistance) override;
         AZStd::optional<AZ::Vector3> LookAtAfterInterpolation() const override;
+        AZ::Transform GetReferenceFrame() const override;
+        void SetReferenceFrame(const AZ::Transform& worldFromLocal) override;
+        void ClearReferenceFrame() override;
 
     private:
         // AzFramework::ViewportDebugDisplayEventBus overrides ...
         void DisplayViewport(const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay) override;
 
+        //! Update the reference frame after a change has been made to the camera
+        //! view without updating the internal camera via user input.
+        void RefreshReferenceFrame();
+
         //! The current mode the camera controller is in.
         enum class CameraMode
         {
@@ -139,6 +146,8 @@ namespace AtomToolsFramework
 
         AzFramework::Camera m_camera; //!< The current camera state (pitch/yaw/position/look-distance).
         AzFramework::Camera m_targetCamera; //!< The target (next) camera state that m_camera is catching up to.
+        AzFramework::Camera m_previousCamera; //!< The state of the camera from the previous frame.
+        AZStd::optional<AzFramework::Camera> m_storedCamera; //!< A potentially stored camera for when a custom reference frame is set.
         AzFramework::CameraSystem m_cameraSystem; //!< The camera system responsible for managing all CameraInputs.
         AzFramework::CameraProps m_cameraProps; //!< Camera properties to control rotate and translate smoothness.
         CameraControllerPriorityFn m_priorityFn; //!< Controls at what priority the camera controller should respond to events.
@@ -147,6 +156,7 @@ namespace AtomToolsFramework
         CameraMode m_cameraMode = CameraMode::Control; //!< The current mode the camera is operating in.
         AZStd::optional<AZ::Vector3> m_lookAtAfterInterpolation; //!< The look at point after an interpolation has finished.
                                                                  //!< Will be cleared when the view changes (camera looks away).
+        AZ::Transform m_referenceFrameOverride = AZ::Transform::CreateIdentity(); //!<
         //! Flag to prevent circular updates of the camera transform (while the viewport transform is being updated internally).
         bool m_updatingTransformInternally = false;
         //! Listen for camera view changes outside of the camera controller.
@@ -154,4 +164,17 @@ namespace AtomToolsFramework
         //! The current instance of the modular camera viewport context.
         AZStd::unique_ptr<ModularCameraViewportContext> m_modularCameraViewportContext;
     };
+
+    //! Placeholder implementation for ModularCameraViewportContext (useful for verifying the interface).
+    class PlaceholderModularCameraViewportContextImpl : public AtomToolsFramework::ModularCameraViewportContext
+    {
+    public:
+        AZ::Transform GetCameraTransform() const override;
+        void SetCameraTransform(const AZ::Transform& transform) override;
+        void ConnectViewMatrixChangedHandler(AZ::RPI::ViewportContext::MatrixChangedEvent::Handler& handler) override;
+
+    private:
+        AZ::Transform m_cameraTransform = AZ::Transform::CreateIdentity();
+        AZ::RPI::ViewportContext::MatrixChangedEvent m_viewMatrixChangedEvent;
+    };
 } // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ModularViewportCameraControllerRequestBus.h

@@ -35,6 +35,16 @@ namespace AtomToolsFramework
         //! Look at point after an interpolation has finished and no translation has occurred.
         virtual AZStd::optional<AZ::Vector3> LookAtAfterInterpolation() const = 0;
 
+        //! Return the current reference frame.
+        //! @note If a reference frame has not been set or a frame has been cleared, this is just the identity.
+        virtual AZ::Transform GetReferenceFrame() const = 0;
+
+        //! Set a new reference frame other than the identity for the camera controller.
+        virtual void SetReferenceFrame(const AZ::Transform& worldFromLocal) = 0;
+
+        //! Clear the current reference frame to restore the identity.
+        virtual void ClearReferenceFrame() = 0;
+
     protected:
         ~ModularViewportCameraControllerRequests() = default;
     };

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/RenderViewportWidget.h

@@ -159,8 +159,6 @@ namespace AtomToolsFramework
         AZ::RPI::ViewPtr m_defaultCamera;
         // Our viewport-local aux geom pipeline for supplemental rendering.
         AZ::RPI::AuxGeomDrawPtr m_auxGeom;
-        // Used to keep track of a pending resize event to avoid initialization before window activate.
-        bool m_windowResizedEvent = false;
         // Tracks whether the cursor is currently over our viewport, used for mouse input event book-keeping.
         bool m_mouseOver = false;
         // The last recorded mouse position, in local viewport screen coordinates.

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/ModularViewportCameraController.cpp

@@ -30,6 +30,18 @@ namespace AtomToolsFramework
         "");
     AZ_CVAR(float, ed_cameraSystemOrbitPointSize, 0.1f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
 
+    AZ::Transform TransformFromMatrix4x4(const AZ::Matrix4x4& matrix)
+    {
+        const auto rotation = AZ::Matrix3x3::CreateFromMatrix4x4(matrix);
+        const auto translation = matrix.GetTranslation();
+        return AZ::Transform::CreateFromMatrix3x3AndTranslation(rotation, translation);
+    }
+
+    AZ::Matrix4x4 Matrix4x4FromTransform(const AZ::Transform& transform)
+    {
+        return AZ::Matrix4x4::CreateFromQuaternionAndTranslation(transform.GetRotation(), transform.GetTranslation());
+    }
+
     // debug
     void DrawPreviewAxis(AzFramework::DebugDisplayRequests& display, const AZ::Transform& transform, const float axisLength)
     {
@@ -167,11 +179,19 @@ namespace AtomToolsFramework
         controller->SetupCameraControllerPriority(m_priorityFn);
         controller->SetupCameraControllerViewportContext(m_modularCameraViewportContext);
 
-        auto handleCameraChange = [this](const AZ::Matrix4x4&)
+        auto handleCameraChange = [this]([[maybe_unused]] const AZ::Matrix4x4& cameraView)
         {
             // ignore these updates if the camera is being updated internally
             if (!m_updatingTransformInternally)
             {
+                if (m_storedCamera.has_value())
+                {
+                    // if an external change occurs ensure we update the stored reference frame if one is set
+                    RefreshReferenceFrame();
+                    return;
+                }
+
+                m_previousCamera = m_targetCamera;
                 UpdateCameraFromTransform(m_targetCamera, m_modularCameraViewportContext->GetCameraTransform());
                 m_camera = m_targetCamera;
             }
@@ -231,7 +251,7 @@ namespace AtomToolsFramework
                 }
             }
 
-            m_modularCameraViewportContext->SetCameraTransform(m_camera.Transform());
+            m_modularCameraViewportContext->SetCameraTransform(m_referenceFrameOverride * m_camera.Transform());
         }
         else if (m_cameraMode == CameraMode::Animation)
         {
@@ -240,6 +260,8 @@ namespace AtomToolsFramework
                 return t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f);
             };
 
+            m_cameraAnimation.m_time = AZ::GetClamp(m_cameraAnimation.m_time + event.m_deltaTime.count(), 0.0f, 1.0f);
+
             const auto& [transformStart, transformEnd, animationTime] = m_cameraAnimation;
 
             const float transitionTime = smootherStepFn(animationTime);
@@ -253,14 +275,13 @@ namespace AtomToolsFramework
             m_camera.m_lookAt = current.GetTranslation();
             m_targetCamera = m_camera;
 
+            m_modularCameraViewportContext->SetCameraTransform(current);
+
             if (animationTime >= 1.0f)
             {
                 m_cameraMode = CameraMode::Control;
+                RefreshReferenceFrame();
             }
-
-            m_cameraAnimation.m_time = AZ::GetClamp(animationTime + event.m_deltaTime.count(), 0.0f, 1.0f);
-
-            m_modularCameraViewportContext->SetCameraTransform(current);
         }
 
         m_updatingTransformInternally = false;
@@ -280,7 +301,7 @@ namespace AtomToolsFramework
     void ModularViewportCameraControllerInstance::InterpolateToTransform(const AZ::Transform& worldFromLocal, const float lookAtDistance)
     {
         m_cameraMode = CameraMode::Animation;
-        m_cameraAnimation = CameraAnimation{ m_camera.Transform(), worldFromLocal, 0.0f };
+        m_cameraAnimation = CameraAnimation{ m_referenceFrameOverride * m_camera.Transform(), worldFromLocal, 0.0f };
         m_lookAtAfterInterpolation = worldFromLocal.GetTranslation() + worldFromLocal.GetBasisY() * lookAtDistance;
     }
 
@@ -288,4 +309,59 @@ namespace AtomToolsFramework
     {
         return m_lookAtAfterInterpolation;
     }
+
+    AZ::Transform ModularViewportCameraControllerInstance::GetReferenceFrame() const
+    {
+        return m_referenceFrameOverride;
+    }
+
+    void ModularViewportCameraControllerInstance::SetReferenceFrame(const AZ::Transform& worldFromLocal)
+    {
+        if (!m_storedCamera.has_value())
+        {
+            m_storedCamera = m_previousCamera;
+        }
+
+        m_referenceFrameOverride = worldFromLocal;
+        m_targetCamera.m_pitch = 0.0f;
+        m_targetCamera.m_yaw = 0.0f;
+        m_targetCamera.m_lookAt = AZ::Vector3::CreateZero();
+        m_targetCamera.m_lookDist = 0.0f;
+        m_camera = m_targetCamera;
+    }
+
+    void ModularViewportCameraControllerInstance::ClearReferenceFrame()
+    {
+        m_referenceFrameOverride = AZ::Transform::CreateIdentity();
+
+        if (m_storedCamera.has_value())
+        {
+            m_targetCamera = m_storedCamera.value();
+            m_camera = m_targetCamera;
+        }
+
+        m_storedCamera.reset();
+    }
+
+    void ModularViewportCameraControllerInstance::RefreshReferenceFrame()
+    {
+        m_referenceFrameOverride = m_modularCameraViewportContext->GetCameraTransform() * m_camera.Transform().GetInverse();
+    }
+
+    AZ::Transform PlaceholderModularCameraViewportContextImpl::GetCameraTransform() const
+    {
+        return m_cameraTransform;
+    }
+
+    void PlaceholderModularCameraViewportContextImpl::SetCameraTransform(const AZ::Transform& transform)
+    {
+        m_cameraTransform = transform;
+        m_viewMatrixChangedEvent.Signal(AzFramework::CameraViewFromCameraTransform(Matrix4x4FromTransform(transform)));
+    }
+
+    void PlaceholderModularCameraViewportContextImpl::ConnectViewMatrixChangedHandler(
+        AZ::RPI::ViewportContext::MatrixChangedEvent::Handler& handler)
+    {
+        handler.Connect(m_viewMatrixChangedEvent);
+    }
 } // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/RenderViewportWidget.cpp

@@ -254,28 +254,11 @@ namespace AtomToolsFramework
 
     void RenderViewportWidget::resizeEvent([[maybe_unused]] QResizeEvent* event)
     {
-        // We need to wait until the window is activated, so the underlying surface
-        // has been created and has the correct size.
-        if (windowHandle()->isActive())
-        {
-            SendWindowResizeEvent();
-        }
-        else
-        {
-            m_windowResizedEvent = true;
-        }
+        SendWindowResizeEvent();
     }
 
     bool RenderViewportWidget::event(QEvent* event)
     {
-        // Check if we have a pending resize event.
-        // At this point the surface has been created and has
-        // the proper dimensions.
-        if (event->type() == QEvent::WindowActivate && m_windowResizedEvent)
-        {
-            SendWindowResizeEvent();
-        }
-
         return QWidget::event(event);
     }
 
@@ -372,7 +355,6 @@ namespace AtomToolsFramework
 
         AzFramework::WindowNotificationBus::Event(
             GetNativeWindowHandle(), &AzFramework::WindowNotifications::OnWindowResized, windowSize.width(), windowSize.height());
-        m_windowResizedEvent = false;
     }
 
     void RenderViewportWidget::NotifyUpdateRefreshRate()

Gems/AtomLyIntegration/CommonFeatures/Code/Include/AtomLyIntegration/CommonFeatures/PostProcess/ColorGrading/HDRColorGradingBus.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

Gems/AtomLyIntegration/CommonFeatures/Code/Include/AtomLyIntegration/CommonFeatures/PostProcess/ColorGrading/HDRColorGradingComponentConfig.h

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