Merge branch 'upstream/development' into GitIssue4294_ColorNodeTooltipFix

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

@@ -6,5 +6,6 @@
 #
 #
 
-set(GEM_DEPENDENCIES
+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/AzCore/AzCore/Math/Transform.cpp

@@ -353,6 +353,7 @@ namespace AZ
                 Method("CreateFromMatrix3x3AndTranslation", &Transform::CreateFromMatrix3x3AndTranslation)->
                 Method("CreateUniformScale", &Transform::CreateUniformScale)->
                 Method("CreateTranslation", &Transform::CreateTranslation)->
+                Method("CreateLookAt", &Transform::CreateLookAt)->
                 Method("ConstructFromValuesNumeric", &Internal::ConstructTransformFromValues);
         }
     }

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/Application/ToolsApplication.cpp

@@ -28,6 +28,7 @@
 #include <AzToolsFramework/ToolsComponents/TransformComponent.h>
 #include <AzToolsFramework/Entity/EditorEntityContextComponent.h>
 #include <AzToolsFramework/Entity/EditorEntityInfoBus.h>
+#include <AzToolsFramework/FocusMode/FocusModeSystemComponent.h>
 #include <AzToolsFramework/Slice/SliceMetadataEntityContextComponent.h>
 #include <AzToolsFramework/Prefab/PrefabSystemComponent.h>
 #include <AzToolsFramework/UI/Prefab/PrefabIntegrationManager.h>
@@ -248,6 +249,7 @@ namespace AzToolsFramework
         components.insert(components.end(), {
                 azrtti_typeid<EditorEntityContextComponent>(),
                 azrtti_typeid<Components::EditorEntityUiSystemComponent>(),
+                azrtti_typeid<FocusModeSystemComponent>(),
                 azrtti_typeid<SliceMetadataEntityContextComponent>(),
                 azrtti_typeid<Prefab::PrefabSystemComponent>(),
                 azrtti_typeid<EditorEntityFixupComponent>(),

Code/Framework/AzToolsFramework/AzToolsFramework/AssetBrowser/AssetBrowserTableModel.cpp

@@ -46,7 +46,7 @@ namespace AzToolsFramework
 
         QModelIndex AssetBrowserTableModel::mapToSource(const QModelIndex& proxyIndex) const
         {
-            Q_ASSERT(!proxyIndex.isValid() || proxyIndex.model() != this);
+            Q_ASSERT(!proxyIndex.isValid() || proxyIndex.model() == this);
             if (!proxyIndex.isValid() || !m_indexMap.contains(proxyIndex.row()))
             {
                 return QModelIndex();

Code/Framework/AzToolsFramework/AzToolsFramework/AzToolsFrameworkModule.cpp

@@ -22,6 +22,7 @@
 #include <AzToolsFramework/Entity/EditorEntityModelComponent.h>
 #include <AzToolsFramework/Entity/EditorEntitySearchComponent.h>
 #include <AzToolsFramework/Entity/EditorEntitySortComponent.h>
+#include <AzToolsFramework/FocusMode/FocusModeSystemComponent.h>
 #include <AzToolsFramework/PropertyTreeEditor/PropertyTreeEditorComponent.h>
 #include <AzToolsFramework/Render/EditorIntersectorComponent.h>
 #include <AzToolsFramework/Slice/SliceDependencyBrowserComponent.h>
@@ -69,6 +70,7 @@ namespace AzToolsFramework
             Components::EditorSelectionAccentSystemComponent::CreateDescriptor(),
             EditorEntityContextComponent::CreateDescriptor(),
             EditorEntityFixupComponent::CreateDescriptor(),
+            FocusModeSystemComponent::CreateDescriptor(),
             SliceMetadataEntityContextComponent::CreateDescriptor(),
             SliceRequestComponent::CreateDescriptor(),
             Prefab::PrefabSystemComponent::CreateDescriptor(),

Code/Framework/AzToolsFramework/AzToolsFramework/FocusMode/FocusModeInterface.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/Interface/Interface.h>
+#include <AzCore/Serialization/SerializeContext.h>
+
+namespace AzToolsFramework
+{
+    //! FocusModeInterface
+    //! Interface to handle the Editor Focus Mode.
+    class FocusModeInterface
+    {
+    public:
+        AZ_RTTI(FocusModeInterface, "{437243B0-F86B-422F-B7B8-4A21CC000702}");
+
+        //! Sets the root entity the Editor should focus on.
+        //! The Editor will only allow the user to select entities that are descendants of the EntityId provided.
+        //! @param entityId The entityId that will become the new focus root.
+        virtual void SetFocusRoot(AZ::EntityId entityId) = 0;
+
+        //! Clears the Editor focus, allowing the user to select the whole level again.
+        virtual void ClearFocusRoot() = 0;
+
+        //! Returns the entity id of the root of the current Editor focus.
+        //! @return The entity id of the root of the Editor focus, or an invalid entity id if no focus is set.
+        virtual AZ::EntityId GetFocusRoot() = 0;
+
+        //! Returns whether the entity id provided is part of the focused sub-tree.
+        virtual bool IsInFocusSubTree(AZ::EntityId entityId) = 0;
+    };
+
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/FocusMode/FocusModeSystemComponent.cpp

@@ -0,0 +1,92 @@
+/*
+ * 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/Component/TransformBus.h>
+
+#include <AzToolsFramework/API/ViewportEditorModeTrackerInterface.h>
+#include <AzToolsFramework/FocusMode/FocusModeSystemComponent.h>
+
+namespace AzToolsFramework
+{
+    bool IsInFocusSubTree(AZ::EntityId entityId, AZ::EntityId focusRootId)
+    {
+        if (entityId == AZ::EntityId())
+        {
+            return false;
+        }
+
+        if (entityId == focusRootId)
+        {
+            return true;
+        }
+
+        AZ::EntityId parentId;
+        AZ::TransformBus::EventResult(parentId, entityId, &AZ::TransformInterface::GetParentId);
+
+        return IsInFocusSubTree(parentId, focusRootId);
+    }
+
+    void FocusModeSystemComponent::Init()
+    {
+    }
+
+    void FocusModeSystemComponent::Activate()
+    {
+        AZ::Interface<FocusModeInterface>::Register(this);
+    }
+
+    void FocusModeSystemComponent::Deactivate()
+    {
+        AZ::Interface<FocusModeInterface>::Unregister(this);
+    }
+
+    void FocusModeSystemComponent::Reflect([[maybe_unused]] AZ::ReflectContext* context)
+    {
+    }
+
+    void FocusModeSystemComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
+    {
+        provided.push_back(AZ_CRC_CE("EditorFocusMode"));
+    }
+
+    void FocusModeSystemComponent::GetRequiredServices([[maybe_unused]] AZ::ComponentDescriptor::DependencyArrayType& required)
+    {
+    }
+
+    void FocusModeSystemComponent::GetIncompatibleServices([[maybe_unused]] AZ::ComponentDescriptor::DependencyArrayType& incompatible)
+    {
+    }
+
+    void FocusModeSystemComponent::SetFocusRoot(AZ::EntityId entityId)
+    {
+        m_focusRoot = entityId;
+
+        // TODO - If m_focusRoot != AZ::EntityId(), activate focus mode via ViewportEditorModeTrackerInterface; else, deactivate focus mode
+    }
+
+    void FocusModeSystemComponent::ClearFocusRoot()
+    {
+        SetFocusRoot(AZ::EntityId());
+    }
+
+    AZ::EntityId FocusModeSystemComponent::GetFocusRoot()
+    {
+        return m_focusRoot;
+    }
+
+    bool FocusModeSystemComponent::IsInFocusSubTree(AZ::EntityId entityId)
+    {
+        if (m_focusRoot == AZ::EntityId())
+        {
+            return true;
+        }
+
+        return AzToolsFramework::IsInFocusSubTree(entityId, m_focusRoot);
+    }
+
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/FocusMode/FocusModeSystemComponent.h

@@ -0,0 +1,51 @@
+/*
+ * 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 <AzCore/Memory/SystemAllocator.h>
+
+#include <AzToolsFramework/FocusMode/FocusModeInterface.h>
+
+namespace AzToolsFramework
+{
+    bool IsInFocusSubTree(AZ::EntityId entityId, AZ::EntityId focusRootId);
+
+    //! System Component to handle the Editor Focus Mode system
+    class FocusModeSystemComponent final
+        : public AZ::Component
+        , private FocusModeInterface
+    {
+    public:
+        AZ_COMPONENT(FocusModeSystemComponent, "{6CE522FE-2057-4794-BD05-61E04BD8EA30}");
+
+        FocusModeSystemComponent() = default;
+        virtual ~FocusModeSystemComponent() = default;
+
+        // AZ::Component overrides ...
+        void Init() override;
+        void Activate() override;
+        void Deactivate() override;
+
+        static void Reflect(AZ::ReflectContext* context);
+        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided);
+        static void GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required);
+        static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible);
+
+        // FocusModeInterface overrides ...
+        void SetFocusRoot(AZ::EntityId entityId) override;
+        void ClearFocusRoot() override;
+        AZ::EntityId GetFocusRoot() override;
+        bool IsInFocusSubTree(AZ::EntityId entityId) override;
+
+    private:
+        AZ::EntityId m_focusRoot;
+    };
+
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabFocusHandler.cpp

@@ -0,0 +1,102 @@
+/*
+ * 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 <AzToolsFramework/Prefab/PrefabFocusHandler.h>
+
+#include <AzToolsFramework/Entity/PrefabEditorEntityOwnershipInterface.h>
+#include <AzToolsFramework/Prefab/Instance/Instance.h>
+#include <AzToolsFramework/Prefab/Instance/InstanceEntityMapperInterface.h>
+
+namespace AzToolsFramework::Prefab
+{
+    PrefabFocusHandler::PrefabFocusHandler()
+    {
+        m_instanceEntityMapperInterface = AZ::Interface<InstanceEntityMapperInterface>::Get();
+        AZ_Assert(
+            m_instanceEntityMapperInterface,
+            "Prefab - PrefabFocusHandler - "
+            "Instance Entity Mapper Interface could not be found. "
+            "Check that it is being correctly initialized.");
+
+        AZ::Interface<PrefabFocusInterface>::Register(this);
+    }
+
+    PrefabFocusHandler::~PrefabFocusHandler()
+    {
+        AZ::Interface<PrefabFocusInterface>::Unregister(this);
+    }
+
+    PrefabFocusOperationResult PrefabFocusHandler::FocusOnOwningPrefab(AZ::EntityId entityId)
+    {
+        InstanceOptionalReference focusedInstance;
+
+        if (entityId == AZ::EntityId())
+        {
+            PrefabEditorEntityOwnershipInterface* prefabEditorEntityOwnershipInterface =
+                AZ::Interface<PrefabEditorEntityOwnershipInterface>::Get();
+
+            if(!prefabEditorEntityOwnershipInterface)
+            {
+                return AZ::Failure(AZStd::string("Could not focus on root prefab instance - internal error "
+                                                 "(PrefabEditorEntityOwnershipInterface unavailable)."));
+            }
+
+            focusedInstance = prefabEditorEntityOwnershipInterface->GetRootPrefabInstance();
+        }
+        else
+        {
+            focusedInstance = m_instanceEntityMapperInterface->FindOwningInstance(entityId);
+        }
+
+        if (!focusedInstance.has_value())
+        {
+            return AZ::Failure(AZStd::string(
+                "Prefab Focus Handler: Couldn't find owning instance of entityId provided."));
+        }
+
+        m_focusedInstance = focusedInstance;
+        m_focusedTemplateId = focusedInstance->get().GetTemplateId();
+
+        FocusModeInterface* focusModeInterface = AZ::Interface<FocusModeInterface>::Get();
+        if (focusModeInterface)
+        {
+            focusModeInterface->SetFocusRoot(focusedInstance->get().GetContainerEntityId());
+        }
+
+        return AZ::Success();
+    }
+    
+    TemplateId PrefabFocusHandler::GetFocusedPrefabTemplateId()
+    {
+        return m_focusedTemplateId;
+    }
+
+    InstanceOptionalReference PrefabFocusHandler::GetFocusedPrefabInstance()
+    {
+        return m_focusedInstance;
+    }
+
+    bool PrefabFocusHandler::IsOwningPrefabBeingFocused(AZ::EntityId entityId)
+    {
+        if (!m_focusedInstance.has_value())
+        {
+            // PrefabFocusHandler has not been initialized yet.
+            return false;
+        }
+
+        if (entityId == AZ::EntityId())
+        {
+            return false;
+        }
+
+        InstanceOptionalReference instance = m_instanceEntityMapperInterface->FindOwningInstance(entityId);
+
+        return instance.has_value() && (&instance->get() == &m_focusedInstance->get());
+    }
+
+} // namespace AzToolsFramework::Prefab

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabFocusHandler.h

@@ -0,0 +1,44 @@
+/*
+ * 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/Memory/SystemAllocator.h>
+
+#include <AzToolsFramework/FocusMode/FocusModeInterface.h>
+#include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
+#include <AzToolsFramework/Prefab/Template/Template.h>
+
+namespace AzToolsFramework::Prefab
+{
+    class InstanceEntityMapperInterface;
+
+    //! Handles Prefab Focus mode, determining which prefab file entity changes will target.
+    class PrefabFocusHandler final
+        : private PrefabFocusInterface
+    {
+    public:
+        AZ_CLASS_ALLOCATOR(PrefabFocusHandler, AZ::SystemAllocator, 0);
+
+        PrefabFocusHandler();
+        ~PrefabFocusHandler();
+
+        // PrefabFocusInterface override ...
+        PrefabFocusOperationResult FocusOnOwningPrefab(AZ::EntityId entityId) override;
+        TemplateId GetFocusedPrefabTemplateId() override;
+        InstanceOptionalReference GetFocusedPrefabInstance() override;
+        bool IsOwningPrefabBeingFocused(AZ::EntityId entityId) override;
+
+    private:
+        InstanceOptionalReference m_focusedInstance;
+        TemplateId m_focusedTemplateId;
+
+        InstanceEntityMapperInterface* m_instanceEntityMapperInterface;
+    };
+
+} // namespace AzToolsFramework::Prefab

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabFocusInterface.h

@@ -0,0 +1,43 @@
+/*
+ * 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/Interface/Interface.h>
+#include <AzCore/Serialization/SerializeContext.h>
+
+#include <AzToolsFramework/Prefab/Instance/Instance.h>
+#include <AzToolsFramework/Prefab/Template/Template.h>
+
+namespace AzToolsFramework::Prefab
+{
+    using PrefabFocusOperationResult = AZ::Outcome<void, AZStd::string>;
+
+    //! Interface to handle operations related to the Prefab Focus system.
+    class PrefabFocusInterface
+    {
+    public:
+        AZ_RTTI(PrefabFocusInterface, "{F3CFA37B-5FD8-436A-9C30-60EB54E350E1}");
+
+        //! Set the focused prefab instance to the owning instance of the entityId provided.
+        //! @param entityId The entityId of the entity whose owning instance we want the prefab system to focus on.
+        virtual PrefabFocusOperationResult FocusOnOwningPrefab(AZ::EntityId entityId) = 0;
+
+        //! Returns the template id of the instance the prefab system is focusing on.
+        virtual TemplateId GetFocusedPrefabTemplateId() = 0;
+
+        //! Returns a reference to the instance the prefab system is focusing on.
+        virtual InstanceOptionalReference GetFocusedPrefabInstance() = 0;
+
+        //! Returns whether the entity belongs to the instance that is being focused on, or one of its descendants.
+        //! @param entityId The entityId of the queried entity.
+        //! @return true if the entity belongs to the focused instance or one of its descendants, false otherwise.
+        virtual bool IsOwningPrefabBeingFocused(AZ::EntityId entityId) = 0;
+    };
+
+} // namespace AzToolsFramework::Prefab

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.h

@@ -13,6 +13,7 @@
 #include <AzCore/std/string/string_view.h>
 
 #include <AzToolsFramework/Prefab/Instance/Instance.h>
+#include <AzToolsFramework/Prefab/PrefabFocusHandler.h>
 #include <AzToolsFramework/Prefab/PrefabPublicInterface.h>
 #include <AzToolsFramework/Prefab/PrefabSystemComponentInterface.h>
 #include <AzToolsFramework/Prefab/PrefabUndoCache.h>
@@ -189,6 +190,9 @@ namespace AzToolsFramework
             PrefabLoaderInterface* m_prefabLoaderInterface = nullptr;
             PrefabSystemComponentInterface* m_prefabSystemComponentInterface = nullptr;
 
+            // Handles the Prefab Focus API that determines what prefab is being edited.
+            PrefabFocusHandler m_prefabFocusHandler;
+
             // Caches entity states for undo/redo purposes
             PrefabUndoCache m_prefabUndoCache;
 

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemComponent.h

@@ -369,7 +369,7 @@ namespace AzToolsFramework
             // A counter for generating unique Link Ids.
             AZStd::atomic<LinkId> m_linkIdCounter = 0u;
 
-            // Used for finding the owning instance of an arbitrary entity
+            // Used for finding the owning instance of an arbitrary entity.
             InstanceEntityMapper m_instanceEntityMapper;
 
             // Used for finding the Instances owned by an arbitrary Template.
@@ -378,16 +378,16 @@ namespace AzToolsFramework
             // Used for loading/saving Prefab Template files.
             PrefabLoader m_prefabLoader;
 
-            // Handler the public Prefab API used by UI and scripting
+            // Handles the public Prefab API used by UI and scripting.
             PrefabPublicHandler m_prefabPublicHandler;
 
             // Used for updating Instances of Prefab Template.
             InstanceUpdateExecutor m_instanceUpdateExecutor;
 
-            // Used for updating Templates when Instances are modified
+            // Used for updating Templates when Instances are modified.
             InstanceToTemplatePropagator m_instanceToTemplatePropagator;
 
-            // Handler of the public Prefab requests
+            // Handler of the public Prefab requests.
             PrefabPublicRequestHandler m_prefabPublicRequestHandler;
         };
     } // namespace Prefab

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/LevelRootUiHandler.cpp

@@ -8,7 +8,6 @@
 
 #include <AzToolsFramework/UI/Prefab/LevelRootUiHandler.h>
 
-#include <AzToolsFramework/UI/Prefab/PrefabEditInterface.h>
 #include <AzToolsFramework/Prefab/PrefabPublicInterface.h>
 #include <AzToolsFramework/UI/Outliner/EntityOutlinerListModel.hxx>
 
@@ -24,14 +23,6 @@ namespace AzToolsFramework
 
     LevelRootUiHandler::LevelRootUiHandler()
     {
-        m_prefabEditInterface = AZ::Interface<Prefab::PrefabEditInterface>::Get();
-
-        if (m_prefabEditInterface == nullptr)
-        {
-            AZ_Assert(false, "LevelRootUiHandler - could not get PrefabEditInterface on LevelRootUiHandler construction.");
-            return;
-        }
-
         m_prefabPublicInterface = AZ::Interface<Prefab::PrefabPublicInterface>::Get();
 
         if (m_prefabPublicInterface == nullptr)

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/LevelRootUiHandler.h

@@ -14,7 +14,6 @@ namespace AzToolsFramework
 {
     namespace Prefab
     {
-        class PrefabEditInterface;
         class PrefabPublicInterface;
     };
 
@@ -36,7 +35,6 @@ namespace AzToolsFramework
         void PaintItemBackground(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const override;
 
     private:
-        Prefab::PrefabEditInterface* m_prefabEditInterface = nullptr;
         Prefab::PrefabPublicInterface* m_prefabPublicInterface = nullptr;
 
         static constexpr int m_levelRootBorderThickness = 1;

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabEditInterface.h

@@ -1,43 +0,0 @@
-/*
- * 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/Interface/Interface.h>
-#include <AzCore/Serialization/SerializeContext.h>
-
-namespace AzToolsFramework
-{
-    namespace Prefab
-    {
-        /*!
-         * PrefabEditInterface
-         * Interface to expose the API to Edit Prefabs in the Editor.
-         */
-        class PrefabEditInterface
-        {
-        public:
-            AZ_RTTI(PrefabEditInterface, "{DABB1D43-3760-420E-9F1E-5104F0AFF167}");
-
-            /**
-             * Sets the prefab for the instance owning the entity provided as the prefab being edited.
-             * @param entityId The entity whose owning prefab should be edited.
-             */
-            virtual void EditOwningPrefab(AZ::EntityId entityId) = 0;
-            
-            /**
-             * Queries the Edit Manager to know if the provided entity is part of the prefab currently being edited.
-             * @param entityId The entity whose prefab editing state we want to query.
-             * @return True if the prefab owning this entity is being edited, false otherwise.
-             */
-            virtual bool IsOwningPrefabBeingEdited(AZ::EntityId entityId) = 0;
-        };
-
-    } // namespace Prefab
-} // namespace AzToolsFramework
-

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabEditManager.cpp

@@ -1,46 +0,0 @@
-/*
- * 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 <AzToolsFramework/UI/Prefab/PrefabEditManager.h>
-
-#include <AzCore/Serialization/SerializeContext.h>
-
-namespace AzToolsFramework
-{
-    namespace Prefab
-    {
-        PrefabEditManager::PrefabEditManager()
-        {
-            m_prefabPublicInterface = AZ::Interface<PrefabPublicInterface>::Get();
-
-            if (m_prefabPublicInterface == nullptr)
-            {
-                AZ_Assert(false, "Prefab - could not get PrefabPublicInterface on PrefabEditManager construction.");
-                return;
-            }
-
-            AZ::Interface<PrefabEditInterface>::Register(this);
-        }
-
-        PrefabEditManager::~PrefabEditManager()
-        {
-            AZ::Interface<PrefabEditInterface>::Unregister(this);
-        }
-
-        void PrefabEditManager::EditOwningPrefab(AZ::EntityId entityId)
-        {
-            m_instanceBeingEdited = m_prefabPublicInterface->GetInstanceContainerEntityId(entityId);
-        }
-
-        bool PrefabEditManager::IsOwningPrefabBeingEdited(AZ::EntityId entityId)
-        {
-            AZ::EntityId containerEntity = m_prefabPublicInterface->GetInstanceContainerEntityId(entityId);
-            return m_instanceBeingEdited == containerEntity;
-        }
-    }
-}

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabEditManager.h

@@ -1,40 +0,0 @@
-/*
- * 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/EntityId.h>
-#include <AzCore/Memory/SystemAllocator.h>
-
-#include <AzToolsFramework/Prefab/PrefabPublicInterface.h>
-#include <AzToolsFramework/UI/Prefab/PrefabEditInterface.h>
-
-namespace AzToolsFramework
-{
-    namespace Prefab
-    {
-        class PrefabEditManager final
-            : private PrefabEditInterface
-        {
-        public:
-            AZ_CLASS_ALLOCATOR(PrefabEditManager, AZ::SystemAllocator, 0);
-
-            PrefabEditManager();
-            ~PrefabEditManager();
-
-        private:
-            // PrefabEditInterface...
-            void EditOwningPrefab(AZ::EntityId entityId) override;
-            bool IsOwningPrefabBeingEdited(AZ::EntityId entityId) override;
-
-            AZ::EntityId m_instanceBeingEdited;
-
-            PrefabPublicInterface* m_prefabPublicInterface;
-        };
-    }
-}

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabIntegrationManager.cpp

@@ -22,6 +22,7 @@
 #include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
 #include <AzToolsFramework/AssetBrowser/AssetSelectionModel.h>
 #include <AzToolsFramework/AssetBrowser/Entries/SourceAssetBrowserEntry.h>
+#include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
 #include <AzToolsFramework/Prefab/PrefabLoaderInterface.h>
 #include <AzToolsFramework/ToolsComponents/EditorLayerComponentBus.h>
 #include <AzToolsFramework/UI/EditorEntityUi/EditorEntityUiInterface.h>
@@ -57,9 +58,9 @@ namespace AzToolsFramework
     {
         
         EditorEntityUiInterface* PrefabIntegrationManager::s_editorEntityUiInterface = nullptr;
-        PrefabPublicInterface* PrefabIntegrationManager::s_prefabPublicInterface = nullptr;
-        PrefabEditInterface* PrefabIntegrationManager::s_prefabEditInterface = nullptr;
+        PrefabFocusInterface* PrefabIntegrationManager::s_prefabFocusInterface = nullptr;
         PrefabLoaderInterface* PrefabIntegrationManager::s_prefabLoaderInterface = nullptr;
+        PrefabPublicInterface* PrefabIntegrationManager::s_prefabPublicInterface = nullptr;
         PrefabSystemComponentInterface* PrefabIntegrationManager::s_prefabSystemComponentInterface = nullptr;
 
         const AZStd::string PrefabIntegrationManager::s_prefabFileExtension = ".prefab";
@@ -102,13 +103,6 @@ namespace AzToolsFramework
                 return;
             }
 
-            s_prefabEditInterface = AZ::Interface<PrefabEditInterface>::Get();
-            if (s_prefabEditInterface == nullptr)
-            {
-                AZ_Assert(false, "Prefab - could not get PrefabEditInterface on PrefabIntegrationManager construction.");
-                return;
-            }
-
             s_prefabLoaderInterface = AZ::Interface<PrefabLoaderInterface>::Get();
             if (s_prefabLoaderInterface == nullptr)
             {
@@ -123,6 +117,13 @@ namespace AzToolsFramework
                 return;
             }
 
+            s_prefabFocusInterface = AZ::Interface<PrefabFocusInterface>::Get();
+            if (s_prefabFocusInterface == nullptr)
+            {
+                AZ_Assert(false, "Prefab - could not get PrefabFocusInterface on PrefabIntegrationManager construction.");
+                return;
+            }
+
             EditorContextMenuBus::Handler::BusConnect();
             PrefabInstanceContainerNotificationBus::Handler::BusConnect();
             AZ::Interface<PrefabIntegrationInterface>::Register(this);
@@ -224,7 +225,7 @@ namespace AzToolsFramework
                         // Edit Prefab
                         if (prefabWipFeaturesEnabled)
                         {
-                            bool beingEdited = s_prefabEditInterface->IsOwningPrefabBeingEdited(selectedEntity);
+                            bool beingEdited = s_prefabFocusInterface->IsOwningPrefabBeingFocused(selectedEntity);
 
                             if (!beingEdited)
                             {
@@ -428,7 +429,7 @@ namespace AzToolsFramework
 
         void PrefabIntegrationManager::ContextMenu_EditPrefab(AZ::EntityId containerEntity)
         {
-            s_prefabEditInterface->EditOwningPrefab(containerEntity);
+            s_prefabFocusInterface->FocusOnOwningPrefab(containerEntity);
         }
 
         void PrefabIntegrationManager::ContextMenu_SavePrefab(AZ::EntityId containerEntity)

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabIntegrationManager.h

@@ -17,7 +17,7 @@
 #include <AzToolsFramework/Prefab/PrefabPublicInterface.h>
 #include <AzToolsFramework/Prefab/PrefabSystemComponentInterface.h>
 #include <AzToolsFramework/UI/Prefab/LevelRootUiHandler.h>
-#include <AzToolsFramework/UI/Prefab/PrefabEditManager.h>
+
 #include <AzToolsFramework/UI/Prefab/PrefabIntegrationBus.h>
 #include <AzToolsFramework/UI/Prefab/PrefabIntegrationInterface.h>
 #include <AzToolsFramework/UI/Prefab/PrefabUiHandler.h>
@@ -28,7 +28,7 @@ namespace AzToolsFramework
 {
     namespace Prefab
     {
-
+        class PrefabFocusInterface;
         class PrefabLoaderInterface;
 
         //! Structure for saving/retrieving user settings related to prefab workflows.
@@ -80,9 +80,6 @@ namespace AzToolsFramework
             void ExecuteSavePrefabDialog(TemplateId templateId, bool useSaveAllPrefabsPreference) override;
 
         private:
-            // Manages the Edit Mode UI for prefabs
-            PrefabEditManager m_prefabEditManager;
-
             // Used to handle the UI for the level root
             LevelRootUiHandler m_levelRootUiHandler;
 
@@ -135,13 +132,12 @@ namespace AzToolsFramework
             AZStd::unique_ptr<QDialog> ConstructSavePrefabDialog(TemplateId templateId, bool useSaveAllPrefabsPreference);
             void SavePrefabsInDialog(QDialog* unsavedPrefabsDialog);
 
-
             static const AZStd::string s_prefabFileExtension;
 
             static EditorEntityUiInterface* s_editorEntityUiInterface;
-            static PrefabPublicInterface* s_prefabPublicInterface;
-            static PrefabEditInterface* s_prefabEditInterface;
+            static PrefabFocusInterface* s_prefabFocusInterface;
             static PrefabLoaderInterface* s_prefabLoaderInterface;
+            static PrefabPublicInterface* s_prefabPublicInterface;
             static PrefabSystemComponentInterface* s_prefabSystemComponentInterface;
         };
     }

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabUiHandler.cpp

@@ -8,7 +8,7 @@
 
 #include <AzToolsFramework/UI/Prefab/PrefabUiHandler.h>
 
-#include <AzToolsFramework/UI/Prefab/PrefabEditInterface.h>
+#include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
 #include <AzToolsFramework/Prefab/PrefabPublicInterface.h>
 #include <AzToolsFramework/UI/Outliner/EntityOutlinerListModel.hxx>
 
@@ -26,21 +26,19 @@ namespace AzToolsFramework
 
     PrefabUiHandler::PrefabUiHandler()
     {
-        m_prefabEditInterface = AZ::Interface<Prefab::PrefabEditInterface>::Get();
-
-        if (m_prefabEditInterface == nullptr)
-        {
-            AZ_Assert(false, "PrefabUiHandler - could not get PrefabEditInterface on PrefabUiHandler construction.");
-            return;
-        }
-
         m_prefabPublicInterface = AZ::Interface<Prefab::PrefabPublicInterface>::Get();
-
         if (m_prefabPublicInterface == nullptr)
         {
             AZ_Assert(false, "PrefabUiHandler - could not get PrefabPublicInterface on PrefabUiHandler construction.");
             return;
         }
+
+        m_prefabFocusInterface = AZ::Interface<Prefab::PrefabFocusInterface>::Get();
+        if (m_prefabFocusInterface == nullptr)
+        {
+            AZ_Assert(false, "PrefabUiHandler - could not get PrefabFocusInterface on PrefabUiHandler construction.");
+            return;
+        }
     }
 
     QString PrefabUiHandler::GenerateItemInfoString(AZ::EntityId entityId) const
@@ -83,7 +81,7 @@ namespace AzToolsFramework
 
     QIcon PrefabUiHandler::GenerateItemIcon(AZ::EntityId entityId) const
     {
-        if (m_prefabEditInterface->IsOwningPrefabBeingEdited(entityId))
+        if (m_prefabFocusInterface->IsOwningPrefabBeingFocused(entityId))
         {
             return QIcon(m_prefabEditIconPath);
         }
@@ -105,7 +103,7 @@ namespace AzToolsFramework
         const bool hasVisibleChildren = index.data(EntityOutlinerListModel::ExpandedRole).value<bool>() && index.model()->hasChildren(index);
 
         QColor backgroundColor = m_prefabCapsuleColor;
-        if (m_prefabEditInterface->IsOwningPrefabBeingEdited(entityId))
+        if (m_prefabFocusInterface->IsOwningPrefabBeingFocused(entityId))
         {
             backgroundColor = m_prefabCapsuleEditColor;
         }
@@ -191,7 +189,7 @@ namespace AzToolsFramework
         const bool isLastColumn = descendantIndex.column() == EntityOutlinerListModel::ColumnLockToggle;
 
         QColor borderColor = m_prefabCapsuleColor;
-        if (m_prefabEditInterface->IsOwningPrefabBeingEdited(entityId))
+        if (m_prefabFocusInterface->IsOwningPrefabBeingFocused(entityId))
         {
             borderColor = m_prefabCapsuleEditColor;
         }

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Prefab/PrefabUiHandler.h

@@ -12,9 +12,10 @@
 
 namespace AzToolsFramework
 {
+
     namespace Prefab
     {
-        class PrefabEditInterface;
+        class PrefabFocusInterface;
         class PrefabPublicInterface;
     };
 
@@ -37,7 +38,7 @@ namespace AzToolsFramework
             const QModelIndex& descendantIndex) const override;
 
     private:
-        Prefab::PrefabEditInterface* m_prefabEditInterface = nullptr;
+        Prefab::PrefabFocusInterface* m_prefabFocusInterface = nullptr;
         Prefab::PrefabPublicInterface* m_prefabPublicInterface = nullptr;
 
         static bool IsLastVisibleChild(const QModelIndex& parent, const QModelIndex& child);

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;

Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake

@@ -149,6 +149,9 @@ set(FILES
     Entity/SliceEditorEntityOwnershipServiceBus.h
     Fingerprinting/TypeFingerprinter.h
     Fingerprinting/TypeFingerprinter.cpp
+    FocusMode/FocusModeInterface.h
+    FocusMode/FocusModeSystemComponent.h
+    FocusMode/FocusModeSystemComponent.cpp
     Logger/TraceLogger.cpp
     Logger/TraceLogger.h
     Manipulators/AngularManipulator.cpp
@@ -629,6 +632,9 @@ set(FILES
     Prefab/PrefabDomTypes.h
     Prefab/PrefabDomUtils.h
     Prefab/PrefabDomUtils.cpp
+    Prefab/PrefabFocusHandler.h
+    Prefab/PrefabFocusHandler.cpp
+    Prefab/PrefabFocusInterface.h
     Prefab/PrefabIdTypes.h
     Prefab/PrefabLoader.h
     Prefab/PrefabLoader.cpp
@@ -721,9 +727,6 @@ set(FILES
     UI/Layer/LayerUiHandler.cpp
     UI/Prefab/LevelRootUiHandler.h
     UI/Prefab/LevelRootUiHandler.cpp
-    UI/Prefab/PrefabEditInterface.h
-    UI/Prefab/PrefabEditManager.h
-    UI/Prefab/PrefabEditManager.cpp
     UI/Prefab/PrefabIntegrationBus.h
     UI/Prefab/PrefabIntegrationManager.h
     UI/Prefab/PrefabIntegrationManager.cpp

Code/Tools/ProjectManager/Platform/Linux/ProjectBuilderWorker_linux.cpp

@@ -7,14 +7,69 @@
  */
 
 #include <ProjectBuilderWorker.h>
+#include <ProjectManagerDefs.h>
+#include <ProjectUtils.h>
+
+#include <QDir>
+#include <QString>
 
 namespace O3DE::ProjectManager
 {
-    AZ::Outcome<void, QString> ProjectBuilderWorker::BuildProjectForPlatform()
+    AZ::Outcome<QStringList, QString> ProjectBuilderWorker::ConstructCmakeGenerateProjectArguments(const QString& thirdPartyPath) const
     {
-        QString error = tr("Automatic building on Linux not currently supported!");
-        QStringToAZTracePrint(error);
-        return AZ::Failure(error);
+        // Attempt to use the Ninja build system if it is installed (described in the o3de documentation) if possible,
+        // otherwise default to the the default for Linux (Unix Makefiles)
+        auto    whichNinjaResult = ProjectUtils::ExecuteCommandResult("which", QStringList{"ninja"}, QProcessEnvironment::systemEnvironment());
+        QString cmakeGenerator = (whichNinjaResult.IsSuccess()) ? "Ninja Multi-Config" : "Unix Makefiles";
+        bool    compileProfileOnBuild = (whichNinjaResult.IsSuccess());
+
+        // On Linux the default compiler is gcc. For O3DE, it is clang, so we need to specify the version of clang that is detected
+        // in order to get the compiler option.
+        auto compilerOptionResult = ProjectUtils::FindSupportedCompilerForPlatform();
+        if (!compilerOptionResult.IsSuccess())
+        {
+            return AZ::Failure(compilerOptionResult.GetError());
+        }
+        auto clangCompilers = compilerOptionResult.GetValue().split('|');
+        AZ_Assert(clangCompilers.length()==2, "Invalid clang compiler pair specification");
+
+        QString clangCompilerOption = clangCompilers[0];
+        QString clangPPCompilerOption = clangCompilers[1];
+        QString targetBuildPath = QDir(m_projectInfo.m_path).filePath(ProjectBuildPathPostfix);
+        QStringList generateProjectArgs = QStringList{ProjectCMakeCommand,
+                                                      "-B", ProjectBuildPathPostfix,
+                                                      "-S", ".",
+                                                      QString("-G%1").arg(cmakeGenerator),
+                                                      QString("-DCMAKE_C_COMPILER=").append(clangCompilerOption),
+                                                      QString("-DCMAKE_CXX_COMPILER=").append(clangPPCompilerOption),
+                                                      QString("-DLY_3RDPARTY_PATH=").append(thirdPartyPath)};
+        if (!compileProfileOnBuild)
+        {
+            generateProjectArgs.append("-DCMAKE_BUILD_TYPE=profile");
+        }
+        return AZ::Success(generateProjectArgs);
     }
-    
+
+    AZ::Outcome<QStringList, QString> ProjectBuilderWorker::ConstructCmakeBuildCommandArguments() const
+    {
+        auto    whichNinjaResult = ProjectUtils::ExecuteCommandResult("which", QStringList{"ninja"}, QProcessEnvironment::systemEnvironment());
+        bool    compileProfileOnBuild = (whichNinjaResult.IsSuccess());
+        QString targetBuildPath = QDir(m_projectInfo.m_path).filePath(ProjectBuildPathPostfix);
+        QString launcherTargetName = m_projectInfo.m_projectName + ".GameLauncher";
+
+        QStringList buildProjectArgs = QStringList{ProjectCMakeCommand,
+                                                   "--build", ProjectBuildPathPostfix,
+                                                   "--target", launcherTargetName, ProjectCMakeBuildTargetEditor};
+        if (compileProfileOnBuild)
+        {
+            buildProjectArgs.append(QStringList{"--config","profile"});
+        }
+        return AZ::Success(buildProjectArgs);
+    }
+
+    AZ::Outcome<QStringList, QString> ProjectBuilderWorker::ConstructKillProcessCommandArguments(const QString& pidToKill) const
+    {
+        return AZ::Success(QStringList{"kill", "-9", pidToKill});
+    }
+
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Platform/Linux/ProjectUtils_linux.cpp

@@ -6,15 +6,48 @@
  */
 
 #include <ProjectUtils.h>
+#include <ProjectManagerDefs.h>
+#include <QProcessEnvironment>
 
 namespace O3DE::ProjectManager
 {
     namespace ProjectUtils
     {
-        AZ::Outcome<void, QString> FindSupportedCompilerForPlatform()
+        // The list of clang C/C++ compiler command lines to validate on the host Linux system
+        const QStringList SupportedClangCommands = {"clang-12|clang++-12"};
+
+        AZ::Outcome<QProcessEnvironment, QString> GetCommandLineProcessEnvironment()
         {
-            // Compiler detection not supported on platform
-            return AZ::Success();
+            return AZ::Success(QProcessEnvironment(QProcessEnvironment::systemEnvironment()));
+        }
+
+        AZ::Outcome<QString, QString> FindSupportedCompilerForPlatform()
+        {
+            // Validate that cmake is installed and is in the command line
+            auto whichCMakeResult = ProjectUtils::ExecuteCommandResult("which", QStringList{ProjectCMakeCommand}, QProcessEnvironment::systemEnvironment());
+            if (!whichCMakeResult.IsSuccess())
+            {
+                return AZ::Failure(QObject::tr("CMake not found. \n\n"
+                    "Make sure that the minimum version of CMake is installed and available from the command prompt. "
+                    "Refer to the <a href='https://o3de.org/docs/welcome-guide/setup/requirements/#cmake'>O3DE requirements</a> page for more information."));
+            }
+
+            // Look for the first compatible version of clang. The list below will contain the known clang compilers that have been tested for O3DE.
+            for (const QString& supportClangCommand : SupportedClangCommands)
+            {
+                auto clangCompilers = supportClangCommand.split('|');
+                AZ_Assert(clangCompilers.length()==2, "Invalid clang compiler pair specification");
+
+                auto whichClangResult = ProjectUtils::ExecuteCommandResult("which", QStringList{clangCompilers[0]}, QProcessEnvironment::systemEnvironment());
+                auto whichClangPPResult = ProjectUtils::ExecuteCommandResult("which", QStringList{clangCompilers[1]}, QProcessEnvironment::systemEnvironment());
+                if (whichClangResult.IsSuccess() && whichClangPPResult.IsSuccess())
+                {
+                    return AZ::Success(supportClangCommand);
+                }
+            }
+            return AZ::Failure(QObject::tr("Clang not found. \n\n"
+                "Make sure that the clang is installed and available from the command prompt. "
+                "Refer to the <a href='https://o3de.org/docs/welcome-guide/setup/requirements/#cmake'>O3DE requirements</a> page for more information."));
         }
         
     } // namespace ProjectUtils

Code/Tools/ProjectManager/Platform/Mac/ProjectBuilderWorker_mac.cpp

@@ -7,14 +7,82 @@
  */
 
 #include <ProjectBuilderWorker.h>
+#include <ProjectManagerDefs.h>
+#include <ProjectUtils.h>
+
+#include <QDir>
+#include <QString>
 
 namespace O3DE::ProjectManager
 {
-    AZ::Outcome<void, QString> ProjectBuilderWorker::BuildProjectForPlatform()
+    namespace Internal
     {
-        QString error = tr("Automatic building on MacOS not currently supported!");
-        QStringToAZTracePrint(error);
-        return AZ::Failure(error);
+        AZ::Outcome<QString, QString> QueryInstalledCmakeFullPath()
+        {
+            auto environmentRequest = ProjectUtils::GetCommandLineProcessEnvironment();
+            if (!environmentRequest.IsSuccess())
+            {
+                return AZ::Failure(environmentRequest.GetError());
+            }
+            auto currentEnvironment = environmentRequest.GetValue();
+
+            auto queryCmakeInstalled = ProjectUtils::ExecuteCommandResult("which",
+                                                                          QStringList{ProjectCMakeCommand}, 
+                                                                          currentEnvironment);
+            if (!queryCmakeInstalled.IsSuccess())
+            {
+                return AZ::Failure(QObject::tr("Unable to detect CMake on this host."));
+            }
+            QString cmakeInstalledPath = queryCmakeInstalled.GetValue().split("\n")[0];
+            return AZ::Success(cmakeInstalledPath);
+        }
+    }
+
+    AZ::Outcome<QStringList, QString> ProjectBuilderWorker::ConstructCmakeGenerateProjectArguments(const QString& thirdPartyPath) const
+    {
+        // For Mac, we need to resolve the full path of cmake and use that in the process request. For
+        // some reason, 'which' will resolve the full path, but when you just specify cmake with the same
+        // environment, it is unable to resolve. To work around this, we will use 'which' to resolve the 
+        // full path and then use it as the command argument
+        auto cmakeInstalledPathQuery = Internal::QueryInstalledCmakeFullPath();
+        if (!cmakeInstalledPathQuery.IsSuccess())
+        {
+            return AZ::Failure(cmakeInstalledPathQuery.GetError());
+        }
+        QString cmakeInstalledPath = cmakeInstalledPathQuery.GetValue();
+        QString targetBuildPath = QDir(m_projectInfo.m_path).filePath(ProjectBuildPathPostfix);
+
+        return AZ::Success(QStringList{cmakeInstalledPath,
+                                       "-B", targetBuildPath,
+                                       "-S", m_projectInfo.m_path,
+                                       "-GXcode"});
+    }
+
+    AZ::Outcome<QStringList, QString> ProjectBuilderWorker::ConstructCmakeBuildCommandArguments() const
+    {
+        // For Mac, we need to resolve the full path of cmake and use that in the process request. For
+        // some reason, 'which' will resolve the full path, but when you just specify cmake with the same
+        // environment, it is unable to resolve. To work around this, we will use 'which' to resolve the
+        // full path and then use it as the command argument
+        auto cmakeInstalledPathQuery = Internal::QueryInstalledCmakeFullPath();
+        if (!cmakeInstalledPathQuery.IsSuccess())
+        {
+            return AZ::Failure(cmakeInstalledPathQuery.GetError());
+        }
+
+        QString cmakeInstalledPath = cmakeInstalledPathQuery.GetValue();
+        QString targetBuildPath = QDir(m_projectInfo.m_path).filePath(ProjectBuildPathPostfix);
+        QString launcherTargetName = m_projectInfo.m_projectName + ".GameLauncher";
+
+        return AZ::Success(QStringList{cmakeInstalledPath,
+                                        "--build", targetBuildPath,
+                                        "--config", "profile",
+                                        "--target", launcherTargetName, ProjectCMakeBuildTargetEditor});
+    }
+
+    AZ::Outcome<QStringList, QString> ProjectBuilderWorker::ConstructKillProcessCommandArguments(const QString& pidToKill) const
+    {
+        return AZ::Success(QStringList{"kill", "-9", pidToKill});
     }
     
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Platform/Mac/ProjectUtils_mac.cpp

@@ -7,15 +7,59 @@
 
 #include <ProjectUtils.h>
 
+#include <QProcess>
+
 namespace O3DE::ProjectManager
 {
     namespace ProjectUtils
     {
-        AZ::Outcome<void, QString> FindSupportedCompilerForPlatform()
+        AZ::Outcome<QProcessEnvironment, QString> GetCommandLineProcessEnvironment()
         {
-            // Compiler detection not supported on platform
-            return AZ::Success();
+            // For CMake on Mac, if its installed through home-brew, then it will be installed
+            // under /usr/local/bin, which may not be in the system PATH environment. 
+            // Add that path for the command line process so that it will be able to locate
+            // a home-brew installed version of CMake
+            QProcessEnvironment currentEnvironment(QProcessEnvironment::systemEnvironment());
+            QString pathValue = currentEnvironment.value("PATH");
+            pathValue += ":/usr/local/bin";
+            currentEnvironment.insert("PATH", pathValue);
+            return AZ::Success(currentEnvironment);
         }
-        
+
+        AZ::Outcome<QString, QString> FindSupportedCompilerForPlatform()
+        {
+            QProcessEnvironment currentEnvironment(QProcessEnvironment::systemEnvironment());
+            QString pathValue = currentEnvironment.value("PATH");
+            pathValue += ":/usr/local/bin";
+            currentEnvironment.insert("PATH", pathValue);
+
+            // Validate that we have cmake installed first
+            auto queryCmakeInstalled = ExecuteCommandResult("which", QStringList{ProjectCMakeCommand}, currentEnvironment);
+            if (!queryCmakeInstalled.IsSuccess())
+            {
+                return AZ::Failure(QObject::tr("Unable to detect CMake on this host."));
+            }
+            QString cmakeInstalledPath = queryCmakeInstalled.GetValue().split("\n")[0];
+
+            // Query the version of the installed cmake
+            auto queryCmakeVersionQuery = ExecuteCommandResult(cmakeInstalledPath, QStringList{"-version"}, currentEnvironment);
+            if (!queryCmakeVersionQuery.IsSuccess())
+            {
+                return AZ::Failure(QObject::tr("Unable to determine the version of CMake on this host."));
+            }
+            AZ_TracePrintf("Project Manager", "Cmake version %s detected.", queryCmakeVersionQuery.GetValue().split("\n")[0].toUtf8().constData());
+
+            // Query for the version of xcodebuild (if installed)
+            auto queryXcodeBuildVersion = ExecuteCommandResult("xcodebuild", QStringList{"-version"}, currentEnvironment);
+            if (!queryCmakeInstalled.IsSuccess())
+            {
+                return AZ::Failure(QObject::tr("Unable to detect XCodeBuilder on this host."));
+            }
+            QString xcodeBuilderVersionNumber = queryXcodeBuildVersion.GetValue().split("\n")[0];
+            AZ_TracePrintf("Project Manager", "XcodeBuilder version %s detected.", xcodeBuilderVersionNumber.toUtf8().constData());
+
+
+            return AZ::Success(xcodeBuilderVersionNumber);
+        }       
     } // namespace ProjectUtils
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Platform/Windows/ProjectBuilderWorker_windows.cpp

@@ -8,189 +8,37 @@
 
 #include <ProjectBuilderWorker.h>
 #include <ProjectManagerDefs.h>
-#include <PythonBindingsInterface.h>
 
 #include <QDir>
-#include <QFile>
-#include <QProcess>
-#include <QProcessEnvironment>
-#include <QTextStream>
-#include <QThread>
+#include <QString>
 
 namespace O3DE::ProjectManager
 {
-    AZ::Outcome<void, QString> ProjectBuilderWorker::BuildProjectForPlatform()
+    AZ::Outcome<QStringList, QString> ProjectBuilderWorker::ConstructCmakeGenerateProjectArguments(const QString& thirdPartyPath) const
     {
-        // Check if we are trying to cancel task
-        if (QThread::currentThread()->isInterruptionRequested())
-        {
-            QStringToAZTracePrint(BuildCancelled);
-            return AZ::Failure(BuildCancelled);
-        }
+        QString targetBuildPath = QDir(m_projectInfo.m_path).filePath(ProjectBuildPathPostfix);
 
-        QFile logFile(GetLogFilePath());
-        if (!logFile.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate))
-        {
-            QString error = tr("Failed to open log file.");
-            QStringToAZTracePrint(error);
-            return AZ::Failure(error);
-        }
+        return AZ::Success(QStringList{ ProjectCMakeCommand,
+                                        "-B", targetBuildPath,
+                                        "-S", m_projectInfo.m_path,
+                                        QString("-DLY_3RDPARTY_PATH=").append(thirdPartyPath),
+                                        "-DLY_UNITY_BUILD=ON" } );
+    }
 
-        EngineInfo engineInfo;
+    AZ::Outcome<QStringList, QString> ProjectBuilderWorker::ConstructCmakeBuildCommandArguments() const
+    {
+        QString targetBuildPath = QDir(m_projectInfo.m_path).filePath(ProjectBuildPathPostfix);
+        QString launcherTargetName = m_projectInfo.m_projectName + ".GameLauncher";
 
-        AZ::Outcome<EngineInfo> engineInfoResult = PythonBindingsInterface::Get()->GetEngineInfo();
-        if (engineInfoResult.IsSuccess())
-        {
-            engineInfo = engineInfoResult.GetValue();
-        }
-        else
-        {
-            QString error = tr("Failed to get engine info.");
-            QStringToAZTracePrint(error);
-            return AZ::Failure(error);
-        }
+        return AZ::Success(QStringList{ ProjectCMakeCommand,
+                                        "--build", targetBuildPath,
+                                        "--config", "profile",
+                                        "--target", launcherTargetName, ProjectCMakeBuildTargetEditor });
+    }
 
-        QTextStream logStream(&logFile);
-        if (QThread::currentThread()->isInterruptionRequested())
-        {
-            logFile.close();
-            QStringToAZTracePrint(BuildCancelled);
-            return AZ::Failure(BuildCancelled);
-        }
-
-        // Show some kind of progress with very approximate estimates
-        UpdateProgress(++m_progressEstimate);
-
-        QProcessEnvironment currentEnvironment(QProcessEnvironment::systemEnvironment());
-        // Append cmake path to PATH incase it is missing
-        QDir cmakePath(engineInfo.m_path);
-        cmakePath.cd("cmake/runtime/bin");
-        QString pathValue = currentEnvironment.value("PATH");
-        pathValue += ";" + cmakePath.path();
-        currentEnvironment.insert("PATH", pathValue);
-
-        m_configProjectProcess = new QProcess(this);
-        m_configProjectProcess->setProcessChannelMode(QProcess::MergedChannels);
-        m_configProjectProcess->setWorkingDirectory(m_projectInfo.m_path);
-        m_configProjectProcess->setProcessEnvironment(currentEnvironment);
-
-        m_configProjectProcess->start(
-            "cmake",
-            QStringList
-            {
-                "-B",
-                QDir(m_projectInfo.m_path).filePath(ProjectBuildPathPostfix),
-                "-S",
-                m_projectInfo.m_path,
-                "-G",
-                "Visual Studio 16",
-                "-DLY_3RDPARTY_PATH=" + engineInfo.m_thirdPartyPath,
-                "-DLY_UNITY_BUILD=1"
-            });
-
-        if (!m_configProjectProcess->waitForStarted())
-        {
-            QString error = tr("Configuring project failed to start.");
-            QStringToAZTracePrint(error);
-            return AZ::Failure(error);
-        }
-        bool containsGeneratingDone = false;
-        while (m_configProjectProcess->waitForReadyRead(MaxBuildTimeMSecs))
-        {
-            QString configOutput = m_configProjectProcess->readAllStandardOutput();
-
-            if (configOutput.contains("Generating done"))
-            {
-                containsGeneratingDone = true;
-            }
-
-            logStream << configOutput;
-            logStream.flush();
-
-            UpdateProgress(qMin(++m_progressEstimate, 19));
-
-            if (QThread::currentThread()->isInterruptionRequested())
-            {
-                logFile.close();
-                m_configProjectProcess->close();
-                QStringToAZTracePrint(BuildCancelled);
-                return AZ::Failure(BuildCancelled);
-            }
-        }
-
-        if (m_configProjectProcess->exitStatus() != QProcess::ExitStatus::NormalExit
-            || m_configProjectProcess->exitCode() != 0
-            || !containsGeneratingDone)
-        {
-            QString error = tr("Configuring project failed. See log for details.");
-            QStringToAZTracePrint(error);
-            return AZ::Failure(error);
-        }
-
-        UpdateProgress(++m_progressEstimate);
-
-        m_buildProjectProcess = new QProcess(this);
-        m_buildProjectProcess->setProcessChannelMode(QProcess::MergedChannels);
-        m_buildProjectProcess->setWorkingDirectory(m_projectInfo.m_path);
-        m_buildProjectProcess->setProcessEnvironment(currentEnvironment);
-
-        m_buildProjectProcess->start(
-            "cmake",
-            QStringList
-            {
-                "--build",
-                QDir(m_projectInfo.m_path).filePath(ProjectBuildPathPostfix),
-                "--target",
-                m_projectInfo.m_projectName + ".GameLauncher",
-                "Editor",
-                "--config",
-                "profile"
-            });
-
-        if (!m_buildProjectProcess->waitForStarted())
-        {
-            QString error = tr("Building project failed to start.");
-            QStringToAZTracePrint(error);
-            return AZ::Failure(error);
-        }
-
-        // There are a lot of steps when building so estimate around 800 more steps ((100 - 20) * 10) remaining
-        m_progressEstimate = 200;
-        while (m_buildProjectProcess->waitForReadyRead(MaxBuildTimeMSecs))
-        {
-            logStream << m_buildProjectProcess->readAllStandardOutput();
-            logStream.flush();
-
-            // Show 1% progress for every 10 steps completed
-            UpdateProgress(qMin(++m_progressEstimate / 10, 99));
-
-            if (QThread::currentThread()->isInterruptionRequested())
-            {
-                // QProcess is unable to kill its child processes so we need to ask the operating system to do that for us
-                QProcess killBuildProcess;
-                killBuildProcess.setProcessChannelMode(QProcess::MergedChannels);
-                killBuildProcess.start(
-                    "cmd.exe", QStringList{ "/C", "taskkill", "/pid", QString::number(m_buildProjectProcess->processId()), "/f", "/t" });
-                killBuildProcess.waitForFinished();
-
-                logStream << "Killing Project Build.";
-                logStream << killBuildProcess.readAllStandardOutput();
-                m_buildProjectProcess->kill();
-                logFile.close();
-                QStringToAZTracePrint(BuildCancelled);
-                return AZ::Failure(BuildCancelled);
-            }
-        }
-
-        if (m_configProjectProcess->exitStatus() != QProcess::ExitStatus::NormalExit
-            || m_configProjectProcess->exitCode() != 0)
-        {
-            QString error = tr("Building project failed. See log for details.");
-            QStringToAZTracePrint(error);
-            return AZ::Failure(error);
-        }
-
-        return AZ::Success();
+    AZ::Outcome<QStringList, QString> ProjectBuilderWorker::ConstructKillProcessCommandArguments(const QString& pidToKill) const
+    {
+        return AZ::Success(QStringList { "cmd.exe", "/C", "taskkill", "/pid", pidToKill, "/f", "/t" } );
     }
 
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Platform/Windows/ProjectUtils_windows.cpp

@@ -7,6 +7,8 @@
 
 #include <ProjectUtils.h>
 
+#include <PythonBindingsInterface.h>
+
 #include <QDir>
 #include <QFileInfo>
 #include <QProcess>
@@ -16,8 +18,44 @@ namespace O3DE::ProjectManager
 {
     namespace ProjectUtils
     {
-        AZ::Outcome<void, QString> FindSupportedCompilerForPlatform()
+        AZ::Outcome<QProcessEnvironment, QString> GetCommandLineProcessEnvironment()
         {
+            // Use the engine path to insert a path for cmake
+            auto engineInfoResult = PythonBindingsInterface::Get()->GetEngineInfo();
+            if (!engineInfoResult.IsSuccess())
+            {
+                return AZ::Failure(QObject::tr("Failed to get engine info"));    
+            }
+            auto engineInfo = engineInfoResult.GetValue();
+
+            QProcessEnvironment currentEnvironment(QProcessEnvironment::systemEnvironment());
+
+            // Append cmake path to PATH incase it is missing
+            QDir cmakePath(engineInfo.m_path);
+            cmakePath.cd("cmake/runtime/bin");
+            QString pathValue = currentEnvironment.value("PATH");
+            pathValue += ";" + cmakePath.path();
+            currentEnvironment.insert("PATH", pathValue);
+            return AZ::Success(currentEnvironment);
+        }
+
+        AZ::Outcome<QString, QString> FindSupportedCompilerForPlatform()
+        {
+            // Validate that cmake is installed 
+            auto cmakeProcessEnvResult = GetCommandLineProcessEnvironment();
+            if (!cmakeProcessEnvResult.IsSuccess())
+            {
+                return AZ::Failure(cmakeProcessEnvResult.GetError());
+            }
+            auto cmakeVersionQueryResult = ExecuteCommandResult("cmake", QStringList{"--version"}, cmakeProcessEnvResult.GetValue());
+            if (!cmakeVersionQueryResult.IsSuccess())
+            {
+                return AZ::Failure(QObject::tr("CMake not found. \n\n"
+                    "Make sure that the minimum version of CMake is installed and available from the command prompt. "
+                    "Refer to the <a href='https://o3de.org/docs/welcome-guide/setup/requirements/#cmake'>O3DE requirements</a> for more information."));
+            }
+
+            // Validate that the minimal version of visual studio is installed
             QProcessEnvironment environment = QProcessEnvironment::systemEnvironment();
             QString programFilesPath = environment.value("ProgramFiles(x86)");
             QString vsWherePath = QDir(programFilesPath).filePath("Microsoft Visual Studio/Installer/vswhere.exe");
@@ -25,27 +63,31 @@ namespace O3DE::ProjectManager
             QFileInfo vsWhereFile(vsWherePath);
             if (vsWhereFile.exists() && vsWhereFile.isFile())
             {
-                QProcess vsWhereProcess;
-                vsWhereProcess.setProcessChannelMode(QProcess::MergedChannels);
+                QStringList vsWhereBaseArguments = QStringList{"-version",
+                                                               "16.9.2",
+                                                               "-latest",
+                                                               "-requires",
+                                                               "Microsoft.VisualStudio.Component.VC.Tools.x86.x64"};
 
-                vsWhereProcess.start(
-                    vsWherePath,
-                    QStringList{
-                        "-version",
-                        "16.9.2",
-                        "-latest",
-                        "-requires",
-                        "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
-                        "-property",
-                        "isComplete"
-                    });
+                QProcess vsWhereIsCompleteProcess;
+                vsWhereIsCompleteProcess.setProcessChannelMode(QProcess::MergedChannels);
 
-                if (vsWhereProcess.waitForStarted() && vsWhereProcess.waitForFinished())
+                vsWhereIsCompleteProcess.start(vsWherePath, vsWhereBaseArguments + QStringList{ "-property", "isComplete" });
+
+                if (vsWhereIsCompleteProcess.waitForStarted() && vsWhereIsCompleteProcess.waitForFinished())
                 {
-                    QString vsWhereOutput(vsWhereProcess.readAllStandardOutput());
-                    if (vsWhereOutput.startsWith("1"))
+                    QString vsWhereIsCompleteOutput(vsWhereIsCompleteProcess.readAllStandardOutput());
+                    if (vsWhereIsCompleteOutput.startsWith("1"))
                     {
-                        return AZ::Success();
+                        QProcess vsWhereCompilerVersionProcess;
+                        vsWhereCompilerVersionProcess.setProcessChannelMode(QProcess::MergedChannels);
+                        vsWhereCompilerVersionProcess.start(vsWherePath, vsWhereBaseArguments + QStringList{"-property", "catalog_productDisplayVersion"});
+
+                        if (vsWhereCompilerVersionProcess.waitForStarted() && vsWhereCompilerVersionProcess.waitForFinished())
+                        {
+                            QString vsWhereCompilerVersionOutput(vsWhereCompilerVersionProcess.readAllStandardOutput());
+                            return AZ::Success(vsWhereCompilerVersionOutput);
+                        }
                     }
                 }
             }

Code/Tools/ProjectManager/Source/ProjectBuilderWorker.cpp

@@ -8,8 +8,15 @@
 
 #include <ProjectBuilderWorker.h>
 #include <ProjectManagerDefs.h>
+#include <PythonBindingsInterface.h>
+#include <ProjectUtils.h>
 
 #include <QDir>
+#include <QFile>
+#include <QProcess>
+#include <QProcessEnvironment>
+#include <QTextStream>
+#include <QThread>
 
 //#define MOCK_BUILD_PROJECT true
 
@@ -67,4 +74,176 @@ namespace O3DE::ProjectManager
     {
         AZ_TracePrintf("Project Manager", error.toStdString().c_str());
     }
+
+    AZ::Outcome<void, QString> ProjectBuilderWorker::BuildProjectForPlatform()
+    {
+        // Check if we are trying to cancel task
+        if (QThread::currentThread()->isInterruptionRequested())
+        {
+            QStringToAZTracePrint(BuildCancelled);
+            return AZ::Failure(BuildCancelled);
+        }
+
+        QFile logFile(GetLogFilePath());
+        if (!logFile.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate))
+        {
+            QString error = tr("Failed to open log file.");
+            QStringToAZTracePrint(error);
+            return AZ::Failure(error);
+        }
+
+        EngineInfo engineInfo;
+
+        AZ::Outcome<EngineInfo> engineInfoResult = PythonBindingsInterface::Get()->GetEngineInfo();
+        if (engineInfoResult.IsSuccess())
+        {
+            engineInfo = engineInfoResult.GetValue();
+        }
+        else
+        {
+            QString error = tr("Failed to get engine info.");
+            QStringToAZTracePrint(error);
+            return AZ::Failure(error);
+        }
+
+        QTextStream logStream(&logFile);
+        if (QThread::currentThread()->isInterruptionRequested())
+        {
+            logFile.close();
+            QStringToAZTracePrint(BuildCancelled);
+            return AZ::Failure(BuildCancelled);
+        }
+
+        // Show some kind of progress with very approximate estimates
+        UpdateProgress(++m_progressEstimate);
+
+        auto currentEnvironmentRequest = ProjectUtils::GetCommandLineProcessEnvironment();
+        if (!currentEnvironmentRequest.IsSuccess())
+        {
+            QStringToAZTracePrint(currentEnvironmentRequest.GetError());
+            return AZ::Failure(currentEnvironmentRequest.GetError());
+        }
+        QProcessEnvironment currentEnvironment = currentEnvironmentRequest.GetValue();
+
+        m_configProjectProcess = new QProcess(this);
+        m_configProjectProcess->setProcessChannelMode(QProcess::MergedChannels);
+        m_configProjectProcess->setWorkingDirectory(m_projectInfo.m_path);
+        m_configProjectProcess->setProcessEnvironment(currentEnvironment);
+
+        auto cmakeGenerateArgumentsResult = ConstructCmakeGenerateProjectArguments(engineInfo.m_thirdPartyPath);
+        if (!cmakeGenerateArgumentsResult.IsSuccess())
+        {
+            QStringToAZTracePrint(cmakeGenerateArgumentsResult.GetError());
+            return AZ::Failure(cmakeGenerateArgumentsResult.GetError());
+        }
+        auto cmakeGenerateArguments = cmakeGenerateArgumentsResult.GetValue();
+        m_configProjectProcess->start(cmakeGenerateArguments.front(), cmakeGenerateArguments.mid(1));
+        if (!m_configProjectProcess->waitForStarted())
+        {
+            QString error = tr("Configuring project failed to start.");
+            QStringToAZTracePrint(error);
+            return AZ::Failure(error);
+        }
+        bool containsGeneratingDone = false;
+        while (m_configProjectProcess->waitForReadyRead(MaxBuildTimeMSecs))
+        {
+            QString configOutput = m_configProjectProcess->readAllStandardOutput();
+
+            if (configOutput.contains("Generating done"))
+            {
+                containsGeneratingDone = true;
+            }
+
+            logStream << configOutput;
+            logStream.flush();
+
+            UpdateProgress(qMin(++m_progressEstimate, 19));
+
+            if (QThread::currentThread()->isInterruptionRequested())
+            {
+                logFile.close();
+                m_configProjectProcess->close();
+                QStringToAZTracePrint(BuildCancelled);
+                return AZ::Failure(BuildCancelled);
+            }
+        }
+
+        if (m_configProjectProcess->exitStatus() != QProcess::ExitStatus::NormalExit || m_configProjectProcess->exitCode() != 0 ||
+            !containsGeneratingDone)
+        {
+            QString error = tr("Configuring project failed. See log for details.");
+            QStringToAZTracePrint(error);
+            return AZ::Failure(error);
+        }
+
+        UpdateProgress(++m_progressEstimate);
+
+        m_buildProjectProcess = new QProcess(this);
+        m_buildProjectProcess->setProcessChannelMode(QProcess::MergedChannels);
+        m_buildProjectProcess->setWorkingDirectory(m_projectInfo.m_path);
+        m_buildProjectProcess->setProcessEnvironment(currentEnvironment);
+
+        auto cmakeBuildArgumentsResult = ConstructCmakeBuildCommandArguments();
+        if (!cmakeBuildArgumentsResult.IsSuccess())
+        {
+            QStringToAZTracePrint(cmakeBuildArgumentsResult.GetError());
+            return AZ::Failure(cmakeBuildArgumentsResult.GetError());
+        }
+        auto cmakeBuildArguments = cmakeBuildArgumentsResult.GetValue();
+
+        m_buildProjectProcess->start(cmakeBuildArguments.front(), cmakeBuildArguments.mid(1));
+        if (!m_buildProjectProcess->waitForStarted())
+        {
+            QString error = tr("Building project failed to start.");
+            QStringToAZTracePrint(error);
+            return AZ::Failure(error);
+        }
+
+        // There are a lot of steps when building so estimate around 800 more steps ((100 - 20) * 10) remaining
+        m_progressEstimate = 200;
+        while (m_buildProjectProcess->waitForReadyRead(MaxBuildTimeMSecs))
+        {
+            logStream << m_buildProjectProcess->readAllStandardOutput();
+            logStream.flush();
+
+            // Show 1% progress for every 10 steps completed
+            UpdateProgress(qMin(++m_progressEstimate / 10, 99));
+
+            if (QThread::currentThread()->isInterruptionRequested())
+            {
+                // QProcess is unable to kill its child processes so we need to ask the operating system to do that for us
+                auto killProcessArgumentsResult = ConstructKillProcessCommandArguments(QString::number(m_buildProjectProcess->processId()));
+                if (!killProcessArgumentsResult.IsSuccess())
+                {
+                    return AZ::Failure(killProcessArgumentsResult.GetError());
+                }
+                auto killProcessArguments = killProcessArgumentsResult.GetValue();
+
+
+                QProcess killBuildProcess;
+
+
+                killBuildProcess.setProcessChannelMode(QProcess::MergedChannels);
+                killBuildProcess.start(killProcessArguments.front(), killProcessArguments.mid(1));
+                killBuildProcess.waitForFinished();
+
+                logStream << "Killing Project Build.";
+                logStream << killBuildProcess.readAllStandardOutput();
+                m_buildProjectProcess->kill();
+                logFile.close();
+                QStringToAZTracePrint(BuildCancelled);
+                return AZ::Failure(BuildCancelled);
+            }
+        }
+
+        if (m_buildProjectProcess->exitStatus() != QProcess::ExitStatus::NormalExit || m_buildProjectProcess->exitCode() != 0)
+        {
+            QString error = tr("Building project failed. See log for details.");
+            QStringToAZTracePrint(error);
+            return AZ::Failure(error);
+        }
+
+        return AZ::Success();
+    }
+
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/ProjectBuilderWorker.h

@@ -12,6 +12,7 @@
 #include <AzCore/Outcome/Outcome.h>
 
 #include <QObject>
+#include <QProcessEnvironment>
 #endif
 
 QT_FORWARD_DECLARE_CLASS(QProcess)
@@ -44,6 +45,12 @@ namespace O3DE::ProjectManager
         AZ::Outcome<void, QString> BuildProjectForPlatform();
         void QStringToAZTracePrint(const QString& error);
 
+        // Command line argument builders
+        AZ::Outcome<QStringList, QString> ConstructCmakeGenerateProjectArguments(const QString& thirdPartyPath) const;
+        AZ::Outcome<QStringList, QString> ConstructCmakeBuildCommandArguments() const;
+        AZ::Outcome<QStringList, QString> ConstructKillProcessCommandArguments(const QString& pidToKill) const;
+
+
         QProcess* m_configProjectProcess = nullptr;
         QProcess* m_buildProjectProcess = nullptr;
         ProjectInfo m_projectInfo;

Code/Tools/ProjectManager/Source/ProjectManagerDefs.h

@@ -14,6 +14,7 @@ namespace O3DE::ProjectManager
     inline constexpr static int ProjectPreviewImageWidth = 210;
     inline constexpr static int ProjectPreviewImageHeight = 280;
     inline constexpr static int ProjectTemplateImageWidth = 92;
+    inline constexpr static int ProjectCommandLineTimeoutSeconds = 30;
 
     static const QString ProjectBuildDirectoryName = "build";
     extern const QString ProjectBuildPathPostfix;
@@ -21,4 +22,8 @@ namespace O3DE::ProjectManager
     static const QString ProjectBuildErrorLogName = "CMakeProjectBuildError.log";
     static const QString ProjectCacheDirectoryName = "Cache";
     static const QString ProjectPreviewImagePath = "preview.png";
+    
+    static const QString ProjectCMakeCommand = "cmake";
+    static const QString ProjectCMakeBuildTargetEditor = "Editor";
+
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/ProjectUtils.cpp

@@ -22,6 +22,8 @@
 #include <QSpacerItem>
 #include <QGridLayout>
 
+#include <AzCore/std/chrono/chrono.h>
+
 namespace O3DE::ProjectManager
 {
     namespace ProjectUtils
@@ -507,5 +509,33 @@ namespace O3DE::ProjectManager
 
             return ProjectManagerScreen::Invalid;
         }
+
+        AZ::Outcome<QString, QString> ExecuteCommandResult(
+            const QString& cmd,
+            const QStringList& arguments,
+            const QProcessEnvironment& processEnv,
+            int commandTimeoutSeconds /*= ProjectCommandLineTimeoutSeconds*/)
+        {
+            QProcess execProcess;
+            execProcess.setProcessEnvironment(processEnv);
+            execProcess.setProcessChannelMode(QProcess::MergedChannels);
+            execProcess.start(cmd, arguments);
+            if (!execProcess.waitForStarted())
+            {
+                return AZ::Failure(QObject::tr("Unable to start process for command '%1'").arg(cmd));
+            }
+
+            if (!execProcess.waitForFinished(commandTimeoutSeconds * 1000 /* Milliseconds per second */))
+            {
+                return AZ::Failure(QObject::tr("Process for command '%1' timed out at %2 seconds").arg(cmd).arg(commandTimeoutSeconds));
+            }
+            int resultCode = execProcess.exitCode();
+            if (resultCode != 0)
+            {
+                return AZ::Failure(QObject::tr("Process for command '%1' failed (result code %2").arg(cmd).arg(resultCode));
+            }
+            QString resultOutput = execProcess.readAllStandardOutput();
+            return AZ::Success(resultOutput);
+        }
     } // namespace ProjectUtils
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/ProjectUtils.h

@@ -9,8 +9,11 @@
 
 #include <ScreenDefs.h>
 #include <ProjectInfo.h>
+#include <ProjectManagerDefs.h>
 
 #include <QWidget>
+#include <QProcessEnvironment>
+
 #include <AzCore/Outcome/Outcome.h>
 
 namespace O3DE::ProjectManager
@@ -28,8 +31,17 @@ namespace O3DE::ProjectManager
         bool ReplaceProjectFile(const QString& origFile, const QString& newFile, QWidget* parent = nullptr, bool interactive = true);
 
         bool FindSupportedCompiler(QWidget* parent = nullptr);
-        AZ::Outcome<void, QString> FindSupportedCompilerForPlatform();
+        AZ::Outcome<QString, QString> FindSupportedCompilerForPlatform();
 
         ProjectManagerScreen GetProjectManagerScreen(const QString& screen);
+
+        AZ::Outcome<QString, QString> ExecuteCommandResult(
+            const QString& cmd,
+            const QStringList& arguments,
+            const QProcessEnvironment& processEnv,
+            int commandTimeoutSeconds = ProjectCommandLineTimeoutSeconds);
+
+        AZ::Outcome<QProcessEnvironment, QString> GetCommandLineProcessEnvironment();
+
     } // namespace ProjectUtils
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/PythonBindings.cpp

@@ -339,7 +339,7 @@ namespace O3DE::ProjectManager
             {
                 for (auto engine : allEngines)
                 {
-                    AZ::IO::FixedMaxPath enginePath(Py_To_String(engine["path"]));
+                    AZ::IO::FixedMaxPath enginePath(Py_To_String(engine));
                     if (enginePath.Compare(m_enginePath) == 0)
                     {
                         return;

Gems/AWSClientAuth/gem.json

@@ -5,9 +5,19 @@
     "origin": "Amazon Web Services, Inc.",
     "type": "Code",
     "summary": "AWS Client Auth provides client authentication and AWS authorization solution.",
-    "canonical_tags": ["Gem"],
-    "user_tags": ["AWS", "Network", "SDK"],
+    "canonical_tags": [
+        "Gem"
+    ],
+    "user_tags": [
+        "AWS",
+        "Network",
+        "SDK"
+    ],
     "icon_path": "preview.png",
     "requirements": "",
-    "documentation_url": "https://o3de.org/docs/user-guide/gems/reference/aws/aws-client-auth/"
+    "documentation_url": "https://o3de.org/docs/user-guide/gems/reference/aws/aws-client-auth/",
+    "dependencies": [
+        "AWSCore",
+        "HttpRequestor"
+    ]
 }

Gems/AWSCore/gem.json

@@ -5,9 +5,16 @@
     "origin": "Amazon Web Services, Inc.",
     "type": "Code",
     "summary": "The AWS Core Gem provides basic shared AWS functionality such as AWS SDK initialization and client configuration, and is automatically added when selecting any AWS feature Gem.",
-    "canonical_tags": ["Gem"],
-    "user_tags": ["AWS", "Network", "SDK"],
+    "canonical_tags": [
+        "Gem"
+    ],
+    "user_tags": [
+        "AWS",
+        "Network",
+        "SDK"
+    ],
     "icon_path": "preview.png",
     "requirements": "",
-    "documentation_url": "https://o3de.org/docs/user-guide/gems/reference/aws/aws-core/"
+    "documentation_url": "https://o3de.org/docs/user-guide/gems/reference/aws/aws-core/",
+    "dependencies": []
 }

Gems/AWSGameLift/gem.json

@@ -5,9 +5,18 @@
     "origin": "Amazon Web Services, Inc.",
     "type": "Code",
     "summary": "The AWS GameLift Gem provides a framework to extend O3DE networking layer to work with GameLift resources via GameLift server and client SDK.",
-    "canonical_tags": ["Gem"],
-    "user_tags": ["AWS", "Framework", "Network"],
+    "canonical_tags": [
+        "Gem"
+    ],
+    "user_tags": [
+        "AWS",
+        "Framework",
+        "Network"
+    ],
     "icon_path": "preview.png",
     "requirements": "",
-    "documentation_url": "https://o3de.org/docs/user-guide/gems/reference/aws/aws-gamelift/"
+    "documentation_url": "https://o3de.org/docs/user-guide/gems/reference/aws/aws-gamelift/",
+    "dependencies": [
+        "AWSCore"
+    ]
 }

Gems/AWSMetrics/gem.json

@@ -5,9 +5,18 @@
     "origin": "Amazon Web Services, Inc.",
     "type": "Code",
     "summary": "The AWS Metrics Gem provides a solution for AWS metrics submission and analytics.",
-    "canonical_tags": ["Gem"],
-    "user_tags": ["AWS", "Network", "SDK"],
+    "canonical_tags": [
+        "Gem"
+    ],
+    "user_tags": [
+        "AWS",
+        "Network",
+        "SDK"
+    ],
     "icon_path": "preview.png",
     "requirements": "",
-    "documentation_url": "https://o3de.org/docs/user-guide/gems/reference/aws/aws-metrics/"
+    "documentation_url": "https://o3de.org/docs/user-guide/gems/reference/aws/aws-metrics/",
+    "dependencies": [
+        "AWSCore"
+    ]
 }

Gems/Achievements/gem.json

@@ -5,9 +5,15 @@
     "origin": "Open 3D Engine - o3de.org",
     "type": "Code",
     "summary": "The Achievements Gem provides a target platform agnostic interface for retrieving achievement details and unlocking achievements.",
-    "canonical_tags": ["Gem"],
-    "user_tags": ["Gameplay", "Achievements"],
+    "canonical_tags": [
+        "Gem"
+    ],
+    "user_tags": [
+        "Gameplay",
+        "Achievements"
+    ],
     "icon_path": "preview.png",
     "requirements": "",
-    "documentation_url": "https://o3de.org/docs/user-guide/gems/reference/gameplay/achievements/"
+    "documentation_url": "https://o3de.org/docs/user-guide/gems/reference/gameplay/achievements/",
+    "dependencies": []
 }

Gems/AssetMemoryAnalyzer/gem.json

@@ -5,9 +5,18 @@
     "origin": "Open 3D Engine - o3de.org",
     "type": "Code",
     "summary": "The Asset Memory Analyzer Gem provides tools to profile asset memory usage in Open 3D Engine through ImGUI (Immediate Mode Graphical User Interface).",
-    "canonical_tags": ["Gem"],
-    "user_tags": ["Debug", "Utility", "Tools"],
+    "canonical_tags": [
+        "Gem"
+    ],
+    "user_tags": [
+        "Debug",
+        "Utility",
+        "Tools"
+    ],
     "icon_path": "preview.png",
     "requirements": "",
-    "documentation_url": "https://o3de.org/docs/user-guide/gems/reference/debug/asset-memory-analyzer/"
+    "documentation_url": "https://o3de.org/docs/user-guide/gems/reference/debug/asset-memory-analyzer/",
+    "dependencies": [
+        "ImGui"
+    ]
 }

Gems/AssetValidation/gem.json

@@ -5,9 +5,16 @@
     "origin": "Open 3D Engine - o3de.org",
     "type": "Code",
     "summary": "The Asset Validation Gem provides seed-related commands to ensure assets have valid seeds for asset bundling.",
-    "canonical_tags": ["Gem"],
-    "user_tags": ["Assets", "Utility", "Scripting"],
+    "canonical_tags": [
+        "Gem"
+    ],
+    "user_tags": [
+        "Assets",
+        "Utility",
+        "Scripting"
+    ],
     "icon_path": "preview.png",
     "requirements": "",
-    "documentation_url": "https://o3de.org/docs/user-guide/gems/reference/assets/asset-validation/"
+    "documentation_url": "https://o3de.org/docs/user-guide/gems/reference/assets/asset-validation/",
+    "dependencies": []
 }

Gems/Atom/Asset/ImageProcessingAtom/Code/Source/Converters/PixelOperation.cpp

@@ -248,8 +248,8 @@ namespace ImageProcessingAtom
         {
             const uint8* data = buf;
             r = U8ToF32(data[0]);
-            g = 0.f;
-            b = 0.f;
+            g = r;
+            b = r;
             a = 1.f;
         }
 
@@ -333,8 +333,8 @@ namespace ImageProcessingAtom
         {
             const uint16* data = (uint16*)(buf);
             r = U16ToF32(data[0]);
-            g = 0.f;
-            b = 0.f;
+            g = r;
+            b = r;
             a = 1.f;
         }
 
@@ -418,8 +418,8 @@ namespace ImageProcessingAtom
         {
             const float* data = (float*)(buf);
             r = data[0];
-            g = 0.f;
-            b = 0.f;
+            g = r;
+            b = r;
             a = 1.f;
         }
 
@@ -485,8 +485,8 @@ namespace ImageProcessingAtom
         {
             const SHalf* data = (SHalf*)(buf);
             r = data[0];
-            g = 0.f;
-            b = 0.f;
+            g = r;
+            b = r;
             a = 1.f;
         }
 

Gems/Atom/Asset/ImageProcessingAtom/Config/Albedo.preset

@@ -39,7 +39,7 @@
                     "_bc",
                     "_diffuse"
                 ],
-                "PixelFormat": "ETC2",
+                "PixelFormat": "ASTC_6x6",
                 "DiscardAlpha": true,
                 "IsPowerOf2": true,
                 "MipMapSetting": {

Gems/Atom/Asset/ImageProcessingAtom/Config/AlbedoWithCoverage.preset

@@ -36,7 +36,7 @@
                     "_bc",
                     "_diffuse"
                 ],
-                "PixelFormat": "ETC2a1",
+                "PixelFormat": "ASTC_6x6",
                 "IsPowerOf2": true,
                 "MipMapSetting": {
                     "MipGenType": "Box"