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

2021-09-27 00:44:18 -04:00
parent c2a3351676 2ce7bbd945
commit bf58638505
696 changed files with 18658 additions and 9872 deletions
@@ -0,0 +1,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/Outcome/Outcome.h>
+#include <AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h>
+
+namespace AzToolsFramework
+{
+    //! The AZ::Interface of the central editor mode tracker for all viewports.
+    class ViewportEditorModeTrackerInterface
+    {
+    public:
+        AZ_RTTI(ViewportEditorModeTrackerInterface, "{7D72A4F7-2147-4ED9-A315-E456A3BE3CF6}");
+
+        virtual ~ViewportEditorModeTrackerInterface() = default;
+
+        //! Activates the specified editor mode for the specified viewport.
+        virtual AZ::Outcome<void, AZStd::string> ActivateMode(
+            const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0;
+       
+        //! Deactivates the specified editor mode for the specified viewport.
+        virtual AZ::Outcome<void, AZStd::string> DeactivateMode(
+            const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0;
+
+        //! Attempts to retrieve the editor mode state for the specified viewport, otherwise returns nullptr.
+        virtual const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0;
+
+        //! Returns the number of viewports currently being tracked.
+        virtual size_t GetTrackedViewportCount() const = 0;
+
+        //! Returns true if the specified viewport is being tracked, otherwise false.
+        virtual bool IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0;
+    };
+} // namespace AzToolsFramework
+
@@ -0,0 +1,66 @@
+/*
+ * 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/EBus/Event.h>
+#include <AzFramework/Viewport/ViewportId.h>
+#include <AzToolsFramework/ViewportUi/ViewportUiRequestBus.h>
+
+namespace AzToolsFramework
+{
+    //! Enumeration of each viewport editor mode.
+    enum class ViewportEditorMode : AZ::u8
+    {
+        Default,
+        Component,
+        Focus,
+        Pick
+    };
+
+    //! Viewport identifier and other relevant viewport data.
+    struct ViewportEditorModeInfo
+    {
+        using IdType = AzFramework::ViewportId;
+        IdType m_id = ViewportUi::DefaultViewportId; //!< The unique identifier for a given viewport.
+    };
+
+    //! Interface for the editor modes of a given viewport.
+    class ViewportEditorModesInterface
+    {
+    public:
+        virtual ~ViewportEditorModesInterface() = default;
+
+        //! Returns true if the specified editor mode is active, otherwise false.
+        virtual bool IsModeActive(ViewportEditorMode mode) const = 0;
+    };
+
+    //! Provides a bus to notify when the different editor modes are entered/exit.
+    class ViewportEditorModeNotifications
+        : public AZ::EBusTraits
+    {
+    public:
+        //////////////////////////////////////////////////////////////////////////
+        // EBusTraits overrides
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = ViewportEditorModeInfo::IdType;
+        //////////////////////////////////////////////////////////////////////////
+
+        //! Notifies subscribers of the a given viewport to the activation of the specified editor mode.
+        virtual void OnEditorModeActivated([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode)
+        {
+        }
+
+        //! Notifies subscribers of the a given viewport to the deactivation of the specified editor mode.
+        virtual void OnEditorModeDeactivated([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode)
+        {
+        }
+    };
+    using ViewportEditorModeNotificationsBus = AZ::EBus<ViewportEditorModeNotifications>;
+} // namespace AzToolsFramework
@@ -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>(),
@@ -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();
@@ -28,16 +28,16 @@ namespace AzToolsFramework
    namespace AssetBrowser
    {
        AssetBrowserTableView::AssetBrowserTableView(QWidget* parent)
-            : QTableView(parent)
+            : AzQtComponents::TableView(parent)
            , m_delegate(new EntryDelegate(this))
        {
            setSortingEnabled(true);
            setItemDelegate(m_delegate);
-            verticalHeader()->hide();
+            setRootIsDecorated(false);

            //Styling the header aligning text to the left and using a bold font.
-            horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
-            horizontalHeader()->setStyleSheet("QHeaderView { font-weight: bold; }");
+            header()->setDefaultAlignment(Qt::AlignLeft);
+            header()->setStyleSheet("QHeaderView { font-weight: bold; }");

            setContextMenuPolicy(Qt::CustomContextMenu);

@@ -45,7 +45,7 @@ namespace AzToolsFramework
            setSortingEnabled(false);
            setSelectionMode(QAbstractItemView::SingleSelection);

-            connect(this, &QTableView::customContextMenuRequested, this, &AssetBrowserTableView::OnContextMenu);
+            connect(this, &AzQtComponents::TableView::customContextMenuRequested, this, &AssetBrowserTableView::OnContextMenu);

            AssetBrowserViewRequestBus::Handler::BusConnect();
            AssetBrowserComponentNotificationBus::Handler::BusConnect();
@@ -62,11 +62,11 @@ namespace AzToolsFramework
            m_tableModel = qobject_cast<AssetBrowserTableModel*>(model);
            AZ_Assert(m_tableModel, "Expecting AssetBrowserTableModel");
            m_sourceFilterModel = qobject_cast<AssetBrowserFilterModel*>(m_tableModel->sourceModel());
-            QTableView::setModel(model);
+            AzQtComponents::TableView::setModel(model);
            connect(m_tableModel, &AssetBrowserTableModel::layoutChanged, this, &AssetBrowserTableView::layoutChangedSlot);

-            horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeMode::Stretch);
-            horizontalHeader()->setSectionResizeMode(1, QHeaderView::ResizeMode::Stretch);
+            header()->setSectionResizeMode(0, QHeaderView::ResizeMode::Stretch);
+            header()->setSectionResizeMode(1, QHeaderView::ResizeMode::Stretch);
        }

        void AssetBrowserTableView::SetName(const QString& name)
@@ -98,7 +98,7 @@ namespace AzToolsFramework

        void AssetBrowserTableView::selectionChanged(const QItemSelection& selected, const QItemSelection& deselected)
        {
-            QTableView::selectionChanged(selected, deselected);
+            AzQtComponents::TableView::selectionChanged(selected, deselected);
            Q_EMIT selectionChangedSignal(selected, deselected);
        }

@@ -115,7 +115,7 @@ namespace AzToolsFramework
                    selectionModel()->clear();
                }
            }
-            QTableView::rowsAboutToBeRemoved(parent, start, end);
+            AzQtComponents::TableView::rowsAboutToBeRemoved(parent, start, end);
        }

        void AssetBrowserTableView::layoutChangedSlot(
@@ -13,9 +13,10 @@
 #include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
 #include <AzToolsFramework/AssetBrowser/AssetBrowserTableModel.h>

+#include <AzQtComponents/Components/Widgets/TableView.h>
+
 #include <QModelIndex>
 #include <QPointer>
-#include <QTableView>
 #endif

 namespace AzToolsFramework
@@ -28,7 +29,7 @@ namespace AzToolsFramework
        class EntryDelegate;

        class AssetBrowserTableView //! Table view that displays the asset browser entries in a list.
-            : public QTableView
+            : public AzQtComponents::TableView
            , public AssetBrowserViewRequestBus::Handler
            , public AssetBrowserComponentNotificationBus::Handler
        {
@@ -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(),
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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;

@@ -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
@@ -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)
@@ -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;
@@ -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
-
@@ -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;
-        }
-    }
-}
@@ -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;
-        };
-    }
-}
@@ -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)
@@ -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;
        };
    }
@@ -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;
        }
@@ -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);
@@ -282,6 +282,24 @@ namespace AzToolsFramework
            return keyboardModifiers;
        }

+        //! An interface to deal with time requests relating to viewports.
+        //! @note The bus is global and not per viewport.
+        class EditorViewportInputTimeNowRequests : public AZ::EBusTraits
+        {
+        public:
+            static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+            static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
+
+            //! Returns the current time in seconds.
+            //! This interface can be overridden for the purposes of testing to simplify viewport input requests.
+            virtual AZStd::chrono::milliseconds EditorViewportInputTimeNow() = 0;
+
+        protected:
+            ~EditorViewportInputTimeNowRequests() = default;
+        };
+
+        using EditorViewportInputTimeNowRequestBus = AZ::EBus<EditorViewportInputTimeNowRequests>;
+
        //! Viewport requests for managing the viewport cursor state.
        class ViewportMouseCursorRequests
        {
@@ -253,10 +253,10 @@ namespace AzToolsFramework
                 mouseInteraction.m_mouseInteraction.m_keyboardModifiers.Ctrl());
        }

-        static bool ManipulatorDitto(const ViewportInteraction::MouseInteractionEvent& mouseInteraction)
+        static bool ManipulatorDitto(
+            const AzFramework::ClickDetector::ClickOutcome clickOutcome, const ViewportInteraction::MouseInteractionEvent& mouseInteraction)
        {
-            return mouseInteraction.m_mouseEvent == ViewportInteraction::MouseEvent::Down &&
-                mouseInteraction.m_mouseInteraction.m_mouseButtons.Left() &&
+            return clickOutcome == AzFramework::ClickDetector::ClickOutcome::Click &&
                mouseInteraction.m_mouseInteraction.m_keyboardModifiers.Ctrl() &&
                mouseInteraction.m_mouseInteraction.m_keyboardModifiers.Alt();
        }
@@ -1054,6 +1054,17 @@ namespace AzToolsFramework
        RegisterActions();
        SetupBoxSelect();
        RefreshSelectedEntityIdsAndRegenerateManipulators();
+
+        // ensure the click detector uses the EditorViewportInputTimeNowRequests interface to retrieve elapsed time
+        // note: this is to facilitate overriding this functionality for purposes such as testing
+        m_clickDetector.OverrideTimeNowFn(
+            []
+            {
+                AZStd::chrono::milliseconds timeNow;
+                AzToolsFramework::ViewportInteraction::EditorViewportInputTimeNowRequestBus::BroadcastResult(
+                    timeNow, &AzToolsFramework::ViewportInteraction::EditorViewportInputTimeNowRequestBus::Events::EditorViewportInputTimeNow);
+                return timeNow;
+            });
    }

    EditorTransformComponentSelection::~EditorTransformComponentSelection()
@@ -1883,7 +1894,7 @@ namespace AzToolsFramework
            }

            // set manipulator pivot override translation or orientation (update manipulators)
-            if (Input::ManipulatorDitto(mouseInteraction))
+            if (Input::ManipulatorDitto(clickOutcome, mouseInteraction))
            {
                PerformManipulatorDitto(entityIdUnderCursor);
                return false;
@@ -3631,7 +3642,7 @@ namespace AzToolsFramework
        }
    }

-    void EditorTransformComponentSelection::OnViewportViewEntityChanged(const AZ::EntityId& newViewId)
+    void EditorTransformComponentSelection::OnViewportViewEntityChanged(const AZ::EntityId& viewEntityId)
    {
        AZ_PROFILE_FUNCTION(AzToolsFramework);

@@ -3639,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();
            }
        }
@@ -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;
@@ -0,0 +1,149 @@
+/*
+ * 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/API/ViewportEditorModeTrackerNotificationBus.h>
+#include <AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h>
+
+namespace AzToolsFramework
+{
+    AZ::Outcome<void, AZStd::string> ViewportEditorModes::ActivateMode(ViewportEditorMode mode)
+    {
+        if (const AZ::u32 modeIndex = static_cast<AZ::u32>(mode);
+            modeIndex < NumEditorModes)
+        {
+            m_editorModes[modeIndex] = true;
+            return AZ::Success();
+        }
+        else
+        {
+            return AZ::Failure(
+                AZStd::string::format("Cannot activate mode %u, mode is not recognized", modeIndex));
+        }
+    }
+
+    AZ::Outcome<void, AZStd::string> ViewportEditorModes::DeactivateMode(ViewportEditorMode mode)
+    {
+        if (const AZ::u32 modeIndex = static_cast<AZ::u32>(mode); modeIndex < NumEditorModes)
+        {
+            m_editorModes[modeIndex] = false;
+            return AZ::Success();
+        }
+        else
+        {
+            return AZ::Failure(
+                AZStd::string::format("Cannot deactivate mode %u, mode is not recognized", modeIndex));
+        }
+    }
+
+    bool ViewportEditorModes::IsModeActive(ViewportEditorMode mode) const
+    {
+        return m_editorModes[static_cast<AZ::u32>(mode)];
+    }
+
+    void ViewportEditorModeTracker::RegisterInterface()
+    {
+        if (AZ::Interface<ViewportEditorModeTrackerInterface>::Get() == nullptr)
+        {
+            AZ::Interface<ViewportEditorModeTrackerInterface>::Register(this);
+        }
+    }
+
+    void ViewportEditorModeTracker::UnregisterInterface()
+    {
+        if (AZ::Interface<ViewportEditorModeTrackerInterface>::Get() != nullptr)
+        {
+            AZ::Interface<ViewportEditorModeTrackerInterface>::Unregister(this);
+        }
+    }
+
+    AZ::Outcome<void, AZStd::string> ViewportEditorModeTracker::ActivateMode(
+        const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode)
+    {
+        auto& editorModes = m_viewportEditorModesMap[viewportEditorModeInfo.m_id];
+        if (editorModes.IsModeActive(mode))
+        {
+            return AZ::Failure(AZStd::string::format(
+                "Duplicate call to ActivateMode for mode '%u' on id '%i'", static_cast<AZ::u32>(mode), viewportEditorModeInfo.m_id));
+        }
+        
+        if (const auto result = editorModes.ActivateMode(mode);
+            !result.IsSuccess())
+        {
+            return result;
+        }
+
+        ViewportEditorModeNotificationsBus::Event(
+            viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeActivated, editorModes, mode);
+
+        return AZ::Success();
+    }
+
+    AZ::Outcome<void, AZStd::string> ViewportEditorModeTracker::DeactivateMode(
+        const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode)
+    {
+        ViewportEditorModes* editorModes = nullptr;
+        bool modeWasActive = true;
+        if (m_viewportEditorModesMap.count(viewportEditorModeInfo.m_id))
+        {
+            editorModes = &m_viewportEditorModesMap.at(viewportEditorModeInfo.m_id);
+            if (!editorModes->IsModeActive(mode))
+            {
+                return AZ::Failure(AZStd::string::format(
+                    "Duplicate call to DeactivateMode for mode '%u' on id '%i'", static_cast<AZ::u32>(mode), viewportEditorModeInfo.m_id));
+            }
+        }
+        else
+        {
+            modeWasActive = false;
+            editorModes = &m_viewportEditorModesMap[viewportEditorModeInfo.m_id];
+        }
+
+        if(const auto result = editorModes->DeactivateMode(mode);
+            !result.IsSuccess())
+        {
+            return result;
+        }
+
+        ViewportEditorModeNotificationsBus::Event(
+            viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeDeactivated, *editorModes, mode);
+
+        if (modeWasActive)
+        {
+            return AZ::Success();
+        }
+        else
+        {
+            return AZ::Failure(AZStd::string::format(
+                "Call to DeactivateMode for mode '%u' on id '%i' without precursor call to ActivateMode", static_cast<AZ::u32>(mode),
+                viewportEditorModeInfo.m_id));
+        }
+    }
+
+    const ViewportEditorModesInterface* ViewportEditorModeTracker::GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const
+    {
+        if (auto editorModes = m_viewportEditorModesMap.find(viewportEditorModeInfo.m_id);
+            editorModes != m_viewportEditorModesMap.end())
+        {
+            return &editorModes->second;
+        }
+        else
+        {
+            return nullptr;
+        }
+    }
+
+    size_t ViewportEditorModeTracker::GetTrackedViewportCount() const
+    {
+        return m_viewportEditorModesMap.size();
+    }
+
+    bool ViewportEditorModeTracker::IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const
+    {
+        return m_viewportEditorModesMap.count(viewportEditorModeInfo.m_id) > 0;
+    }
+} // namespace AzToolsFramework
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/RTTI/RTTI.h>
+#include <AzCore/std/containers/array.h>
+#include <AzCore/std/containers/unordered_map.h>
+#include <AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h>
+#include <AzToolsFramework/API/ViewportEditorModeTrackerInterface.h>
+
+namespace AzToolsFramework
+{
+    //! The encapsulation of the editor modes for a given viewport.
+    class ViewportEditorModes
+        : public ViewportEditorModesInterface
+    {
+    public:
+        //! The number of currently supported viewport editor modes.
+        static constexpr AZ::u8 NumEditorModes = 4;
+
+        //! Sets the specified mode as active.
+        AZ::Outcome<void, AZStd::string> ActivateMode(ViewportEditorMode mode);
+
+        // Sets the specified mode as inactive.
+        AZ::Outcome<void, AZStd::string> DeactivateMode(ViewportEditorMode mode);
+
+        // ViewportEditorModesInterface ...
+        bool IsModeActive(ViewportEditorMode mode) const override;
+    private:
+        AZStd::array<bool, NumEditorModes> m_editorModes{}; //!< State flags to track active/inactive status of viewport editor modes.
+    };
+
+    //! The implementation of the central editor mode state tracker for all viewports.
+    class ViewportEditorModeTracker
+        : public ViewportEditorModeTrackerInterface
+    {
+    public:
+        //! Registers this object with the AZ::Interface.
+        void RegisterInterface();
+
+        //! Unregisters this object with the AZ::Interface.
+        void UnregisterInterface();
+
+        // ViewportEditorModeTrackerInterface overrides ...
+        AZ::Outcome<void, AZStd::string> ActivateMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override;
+        AZ::Outcome<void, AZStd::string> DeactivateMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override;
+        const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const override;
+        size_t GetTrackedViewportCount() const override;
+        bool IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override;
+
+    private:
+        using ViewportEditorModesMap = AZStd::unordered_map<typename ViewportEditorModeInfo::IdType, ViewportEditorModes>;
+        ViewportEditorModesMap m_viewportEditorModesMap; //!< Editor mode state per viewport.
+    };
+} // namespace AzToolsFramework
@@ -34,6 +34,7 @@ set(FILES
    API/EditorAnimationSystemRequestBus.h
    API/EditorEntityAPI.h
    API/EditorLevelNotificationBus.h
+    API/ViewportEditorModeTrackerNotificationBus.h
    API/EditorVegetationRequestsBus.h
    API/EditorPythonConsoleBus.h
    API/EditorPythonRunnerRequestsBus.h
@@ -44,6 +45,7 @@ set(FILES
    API/EntityCompositionNotificationBus.h
    API/EditorViewportIconDisplayInterface.h
    API/ViewPaneOptions.h
+    API/ViewportEditorModeTrackerInterface.h
    Application/Ticker.h
    Application/Ticker.cpp
    Application/EditorEntityManager.cpp
@@ -147,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
@@ -538,6 +543,8 @@ set(FILES
    ViewportSelection/EditorTransformComponentSelectionRequestBus.cpp
    ViewportSelection/EditorVisibleEntityDataCache.h
    ViewportSelection/EditorVisibleEntityDataCache.cpp
+    ViewportSelection/ViewportEditorModeTracker.cpp
+    ViewportSelection/ViewportEditorModeTracker.h
    ToolsFileUtils/ToolsFileUtils.h
    AssetBrowser/AssetBrowserBus.h
    AssetBrowser/AssetBrowserSourceDropBus.h
@@ -625,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
@@ -717,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
@@ -783,7 +783,8 @@ namespace UnitTest
        const auto entity2ScreenPosition = AzFramework::WorldToScreen(m_entity2WorldTranslation, m_cameraState);

        // click the entity in the viewport
-        m_actionDispatcher->SetStickySelect(true)->CameraState(m_cameraState)
+        m_actionDispatcher->SetStickySelect(true)
+            ->CameraState(m_cameraState)
            ->MousePosition(entity2ScreenPosition)
            ->KeyboardModifierDown(AzToolsFramework::ViewportInteraction::KeyboardModifier::Control)
            ->MouseLButtonDown()
@@ -1018,6 +1019,105 @@ namespace UnitTest
        EXPECT_THAT(selectedEntitiesAfter, UnorderedElementsAre(m_entityId1));
    }

+    class EditorTransformComponentSelectionViewportPickingManipulatorTestFixtureParam
+        : public EditorTransformComponentSelectionViewportPickingManipulatorTestFixture
+        , public ::testing::WithParamInterface<bool>
+    {
+    };
+
+    TEST_P(
+        EditorTransformComponentSelectionViewportPickingManipulatorTestFixtureParam,
+        StickyAndUnstickyDittoManipulatorToOtherEntityChangesManipulatorAndDoesNotChangeSelection)
+    {
+        PositionEntities();
+        PositionCamera(m_cameraState);
+
+        AzToolsFramework::SelectEntity(m_entityId1);
+
+        // calculate the position in screen space of the second entity
+        const auto entity2ScreenPosition = AzFramework::WorldToScreen(m_entity2WorldTranslation, m_cameraState);
+
+        // single click select entity2
+        m_actionDispatcher->SetStickySelect(GetParam())
+            ->CameraState(m_cameraState)
+            ->MousePosition(entity2ScreenPosition)
+            ->KeyboardModifierDown(AzToolsFramework::ViewportInteraction::KeyboardModifier::Control)
+            ->KeyboardModifierDown(AzToolsFramework::ViewportInteraction::KeyboardModifier::Alt)
+            ->MouseLButtonDown()
+            ->MouseLButtonUp();
+
+        // entity1 is still selected
+        using ::testing::UnorderedElementsAre;
+        auto selectedEntitiesAfter = SelectedEntities();
+        EXPECT_THAT(selectedEntitiesAfter, UnorderedElementsAre(m_entityId1));
+
+        AZStd::optional<AZ::Transform> manipulatorTransform;
+        AzToolsFramework::EditorTransformComponentSelectionRequestBus::EventResult(
+            manipulatorTransform, AzToolsFramework::GetEntityContextId(),
+            &AzToolsFramework::EditorTransformComponentSelectionRequestBus::Events::GetManipulatorTransform);
+
+        EXPECT_THAT(manipulatorTransform->GetTranslation(), IsClose(m_entity2WorldTranslation));
+    }
+
+    TEST_P(
+        EditorTransformComponentSelectionViewportPickingManipulatorTestFixtureParam,
+        StickyAndUnstickyDittoManipulatorToOtherEntityChangesManipulatorAndClickOffResetsManipulator)
+    {
+        PositionEntities();
+        PositionCamera(m_cameraState);
+
+        AzToolsFramework::SelectEntity(m_entityId1);
+
+        // calculate the position in screen space of the second entity
+        const auto entity2ScreenPosition = AzFramework::WorldToScreen(m_entity2WorldTranslation, m_cameraState);
+
+        // position in space above the entities
+        const auto clickOffPositionWorld = AZ::Vector3(5.0f, 15.0f, 12.0f);
+        // calculate the screen space position of the click
+        const auto clickOffPositionScreen = AzFramework::WorldToScreen(clickOffPositionWorld, m_cameraState);
+
+        using ::testing::UnorderedElementsAre;
+        // single click select entity2, then click off
+        m_actionDispatcher->SetStickySelect(GetParam())
+            ->CameraState(m_cameraState)
+            ->MousePosition(entity2ScreenPosition)
+            ->KeyboardModifierDown(AzToolsFramework::ViewportInteraction::KeyboardModifier::Control)
+            ->KeyboardModifierDown(AzToolsFramework::ViewportInteraction::KeyboardModifier::Alt)
+            ->MouseLButtonDown()
+            ->MouseLButtonUp()
+            ->ExecuteBlock(
+                [this]()
+                {
+                    auto selectedEntitiesAfter = SelectedEntities();
+                    EXPECT_THAT(selectedEntitiesAfter, UnorderedElementsAre(m_entityId1));
+
+                    AZStd::optional<AZ::Transform> manipulatorTransform;
+                    AzToolsFramework::EditorTransformComponentSelectionRequestBus::EventResult(
+                        manipulatorTransform, AzToolsFramework::GetEntityContextId(),
+                        &AzToolsFramework::EditorTransformComponentSelectionRequestBus::Events::GetManipulatorTransform);
+
+                    EXPECT_THAT(manipulatorTransform->GetTranslation(), IsClose(m_entity2WorldTranslation));
+                })
+            ->MousePosition(clickOffPositionScreen)
+            ->KeyboardModifierDown(AzToolsFramework::ViewportInteraction::KeyboardModifier::Control)
+            ->KeyboardModifierDown(AzToolsFramework::ViewportInteraction::KeyboardModifier::Alt)
+            ->MouseLButtonDown()
+            ->MouseLButtonUp();
+
+        auto selectedEntitiesAfter = SelectedEntities();
+        EXPECT_THAT(selectedEntitiesAfter, UnorderedElementsAre(m_entityId1));
+
+        AZStd::optional<AZ::Transform> manipulatorTransform;
+        AzToolsFramework::EditorTransformComponentSelectionRequestBus::EventResult(
+            manipulatorTransform, AzToolsFramework::GetEntityContextId(),
+            &AzToolsFramework::EditorTransformComponentSelectionRequestBus::Events::GetManipulatorTransform);
+
+        // manipulator transform is reset
+        EXPECT_THAT(manipulatorTransform->GetTranslation(), IsClose(m_entity1WorldTranslation));
+    }
+
+    INSTANTIATE_TEST_CASE_P(All, EditorTransformComponentSelectionViewportPickingManipulatorTestFixtureParam, testing::Values(true, false));
+
    using EditorTransformComponentSelectionManipulatorTestFixture =
        IndirectCallManipulatorViewportInteractionFixtureMixin<EditorTransformComponentSelectionFixture>;

@@ -0,0 +1,498 @@
+/*
+ * 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 <AzTest/AzTest.h>
+#include <AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h>
+#include <AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h>
+
+namespace UnitTest
+{
+    using ViewportEditorMode = AzToolsFramework::ViewportEditorMode;
+    using ViewportEditorModes = AzToolsFramework::ViewportEditorModes;
+    using ViewportEditorModeTracker = AzToolsFramework::ViewportEditorModeTracker;
+    using ViewportEditorModeInfo = AzToolsFramework::ViewportEditorModeInfo;
+    using ViewportId = ViewportEditorModeInfo::IdType;
+    using ViewportEditorModesInterface = AzToolsFramework::ViewportEditorModesInterface;
+
+    void ActivateModeAndExpectSuccess(ViewportEditorModes& editorModeState, ViewportEditorMode mode)
+    {
+        const auto result = editorModeState.ActivateMode(mode);
+        EXPECT_TRUE(result.IsSuccess());
+    }
+
+    void DeactivateModeAndExpectSuccess(ViewportEditorModes& editorModeState, ViewportEditorMode mode)
+    {
+        const auto result = editorModeState.DeactivateMode(mode);
+        EXPECT_TRUE(result.IsSuccess());
+    }
+
+    void SetAllModesActive(ViewportEditorModes& editorModeState)
+    {
+        for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++)
+        {
+            ActivateModeAndExpectSuccess(editorModeState, static_cast<ViewportEditorMode>(mode));
+        }
+    }
+
+    void SetAllModesInactive(ViewportEditorModes& editorModeState)
+    {
+        for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++)
+        {
+            DeactivateModeAndExpectSuccess(editorModeState, static_cast<ViewportEditorMode>(mode));
+        }
+    }
+
+    // Fixture for testing editor mode states
+    class ViewportEditorModesTestsFixture
+        : public ::testing::Test
+    {
+    public:
+        ViewportEditorModes m_editorModes;
+    };
+
+    // Fixture for testing editor mode states with parameterized test arguments
+    class ViewportEditorModesTestsFixtureWithParams
+        : public ViewportEditorModesTestsFixture
+        , public ::testing::WithParamInterface<AzToolsFramework::ViewportEditorMode>
+    {
+    public:
+        void SetUp() override
+        {
+            m_selectedEditorMode = GetParam();
+        }
+
+        ViewportEditorMode m_selectedEditorMode;
+    };
+
+    // Fixture for testing the viewport editor mode state tracker
+    class ViewportEditorModeTrackerTestFixture
+        : public ToolsApplicationFixture
+    {
+    public:
+        ViewportEditorModeTracker m_viewportEditorModeTracker;
+    };
+
+    // Subscriber of viewport editor mode notifications for a single viewport that expects a single mode to be activated/deactivated
+    class ViewportEditorModeNotificationsBusHandler
+        : private AzToolsFramework::ViewportEditorModeNotificationsBus::Handler
+    {
+     public:
+        struct ReceivedEvents
+        {
+            bool m_onEnter = false;
+            bool m_onExit = false;
+        };
+
+        using EditModeTracker = AZStd::unordered_map<ViewportEditorMode, ReceivedEvents>;
+
+        ViewportEditorModeNotificationsBusHandler(ViewportId viewportId)
+             : m_viewportSubscription(viewportId)
+        {
+            AzToolsFramework::ViewportEditorModeNotificationsBus::Handler::BusConnect(m_viewportSubscription);
+        }
+
+        ~ViewportEditorModeNotificationsBusHandler()
+        {
+            AzToolsFramework::ViewportEditorModeNotificationsBus::Handler::BusDisconnect();
+        }
+
+        ViewportId GetViewportSubscription() const
+        {
+            return m_viewportSubscription;
+        }
+
+        const EditModeTracker& GetEditorModes() const
+        {
+            return m_editorModes;
+        }
+
+        void OnEditorModeActivated([[maybe_unused]]const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override
+        {
+            m_editorModes[mode].m_onEnter = true;
+        }
+
+        virtual void OnEditorModeDeactivated([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override
+        {
+            m_editorModes[mode].m_onExit = true;
+        }
+
+     private:
+         ViewportId m_viewportSubscription;
+         EditModeTracker m_editorModes;
+
+    };
+
+    // Fixture for testing viewport editor mode notifications publishing
+    class ViewportEditorModePublisherTestFixture
+        : public ViewportEditorModeTrackerTestFixture
+    {
+    public:
+
+        void SetUpEditorFixtureImpl() override
+        {
+            for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++)
+            {
+                m_editorModeHandlers[mode] = AZStd::make_unique<ViewportEditorModeNotificationsBusHandler>(mode);
+            }
+        }
+
+        void TearDownEditorFixtureImpl() override
+        {
+            for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++)
+            {
+                m_editorModeHandlers[mode].reset();
+            }
+        }
+
+        AZStd::array<AZStd::unique_ptr<ViewportEditorModeNotificationsBusHandler>, ViewportEditorModes::NumEditorModes> m_editorModeHandlers;
+    };
+
+    TEST_F(ViewportEditorModesTestsFixture, NumberOfEditorModesIsEqualTo4)
+    {
+        EXPECT_EQ(ViewportEditorModes::NumEditorModes, 4);
+    }
+
+    TEST_F(ViewportEditorModesTestsFixture, InitialEditorModeStateHasAllInactiveModes)
+    {
+        for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++)
+        {
+            EXPECT_FALSE(m_editorModes.IsModeActive(static_cast<ViewportEditorMode>(mode)));
+        }
+    }
+
+    TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingModeActiveActivatesOnlyThatMode)
+    {
+        ActivateModeAndExpectSuccess(m_editorModes, m_selectedEditorMode);
+
+        for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++)
+        {
+            const auto editorMode = static_cast<ViewportEditorMode>(mode);
+            if (editorMode == m_selectedEditorMode)
+            {
+                EXPECT_TRUE(m_editorModes.IsModeActive(static_cast<ViewportEditorMode>(editorMode)));
+            }
+            else
+            {
+                EXPECT_FALSE(m_editorModes.IsModeActive(static_cast<ViewportEditorMode>(editorMode)));
+            }
+        }
+    }
+
+    TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingModeInactiveInactivatesOnlyThatMode)
+    {
+        SetAllModesActive(m_editorModes);
+        DeactivateModeAndExpectSuccess(m_editorModes, m_selectedEditorMode);
+
+        for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++)
+        {
+            const auto editorMode = static_cast<ViewportEditorMode>(mode);
+            if (editorMode == m_selectedEditorMode)
+            {
+                EXPECT_FALSE(m_editorModes.IsModeActive(editorMode));
+            }
+            else
+            {
+                EXPECT_TRUE(m_editorModes.IsModeActive(editorMode));
+            }
+        }
+    }
+
+    TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingMultipleModesActiveActivatesAllThoseModesNonMutuallyExclusively)
+    {
+        for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes - 1; mode++)
+        {
+            // Given only the selected mode active
+            SetAllModesInactive(m_editorModes);
+            {
+                ActivateModeAndExpectSuccess(m_editorModes, m_selectedEditorMode);
+            }
+
+            const auto editorMode = static_cast<ViewportEditorMode>(mode);
+            if (editorMode == m_selectedEditorMode)
+            {
+                continue;
+            }
+
+            // When other modes are activated
+            ActivateModeAndExpectSuccess(m_editorModes, editorMode);
+
+            for (auto expectedMode = 0; expectedMode < ViewportEditorModes::NumEditorModes; expectedMode++)
+            {
+                const auto expectedEditorMode = static_cast<ViewportEditorMode>(expectedMode);
+                if (expectedEditorMode == editorMode || expectedEditorMode == m_selectedEditorMode)
+                {
+                    // Expect the activated modes to be active
+                    EXPECT_TRUE(m_editorModes.IsModeActive(expectedEditorMode));
+                }
+                else
+                {
+                    // Expect the modes not active to be inactive
+                    EXPECT_FALSE(m_editorModes.IsModeActive(expectedEditorMode));
+                }
+            }
+        }
+    }
+
+    TEST_P(ViewportEditorModesTestsFixtureWithParams, SettingMultipleModesInactiveInactivatesAllThoseModesNonMutuallyExclusively)
+    {
+        for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes - 1; mode++)
+        {
+            // Given only the selected mode inactive
+            SetAllModesActive(m_editorModes);
+            DeactivateModeAndExpectSuccess(m_editorModes, m_selectedEditorMode);
+
+            const auto editorMode = static_cast<ViewportEditorMode>(mode);
+            if (editorMode == m_selectedEditorMode)
+            {
+                continue;
+            }
+
+            // When other modes are deactivated
+            DeactivateModeAndExpectSuccess(m_editorModes, editorMode);
+
+            for (auto expectedMode = 0; expectedMode < ViewportEditorModes::NumEditorModes; expectedMode++)
+            {
+                const auto expectedEditorMode = static_cast<ViewportEditorMode>(expectedMode);
+                if (expectedEditorMode == editorMode || expectedEditorMode == m_selectedEditorMode)
+                {
+                    // Expect the deactivated modes to be inactive
+                    EXPECT_FALSE(m_editorModes.IsModeActive(expectedEditorMode));
+                }
+                else
+                {
+                    // Expects the modes not deactivated to still be active
+                    EXPECT_TRUE(m_editorModes.IsModeActive(expectedEditorMode));
+                }
+            }
+        }
+    }
+
+    INSTANTIATE_TEST_CASE_P(
+        AllEditorModes,
+        ViewportEditorModesTestsFixtureWithParams,
+        ::testing::Values(
+            AzToolsFramework::ViewportEditorMode::Default,
+            AzToolsFramework::ViewportEditorMode::Component,
+            AzToolsFramework::ViewportEditorMode::Focus,
+            AzToolsFramework::ViewportEditorMode::Pick));
+
+    TEST_F(ViewportEditorModesTestsFixture, SettingOutOfBoundsModeActiveReturnsError)
+    {
+        const auto result = m_editorModes.ActivateMode(static_cast<ViewportEditorMode>(ViewportEditorModes::NumEditorModes));
+        EXPECT_FALSE(result.IsSuccess());
+    }
+
+    TEST_F(ViewportEditorModesTestsFixture, SettingOutOfBoundsModeInactiveReturnsError)
+    {
+        const auto result = m_editorModes.DeactivateMode(static_cast<ViewportEditorMode>(ViewportEditorModes::NumEditorModes));
+        EXPECT_FALSE(result.IsSuccess());
+    }
+
+    TEST_F(ViewportEditorModeTrackerTestFixture, InitialCentralStateTrackerHasNoViewportEditorModess)
+    {
+        EXPECT_EQ(m_viewportEditorModeTracker.GetTrackedViewportCount(), 0);
+    }
+
+    TEST_F(ViewportEditorModeTrackerTestFixture, RegisteringViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatId)
+    {
+        // Given a viewport not currently being tracked
+        const ViewportId viewportid = 0;
+        EXPECT_FALSE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid }));
+        EXPECT_EQ(m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }), nullptr);
+
+        // When a mode is activated for that viewport
+        const auto editorMode = ViewportEditorMode::Default;
+        m_viewportEditorModeTracker.ActivateMode({ viewportid }, editorMode);
+        const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid });
+
+        // Expect that viewport to now be tracked
+        EXPECT_TRUE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid }));
+        EXPECT_NE(viewportEditorModeState, nullptr);
+
+        // Expect the mode for that viewport to be active
+        EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode));
+    }
+
+    TEST_F(ViewportEditorModeTrackerTestFixture, UnregisteringViewportEditorModeForNonExistentIdCreatesViewportEditorModesForThatIdButReturnsError)
+    {
+        // Given a viewport not currently being tracked
+        const ViewportId viewportid = 0;
+        EXPECT_FALSE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid }));
+        EXPECT_EQ(m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }), nullptr);
+
+        // When a mode is deactivated for that viewport
+        const auto editorMode = ViewportEditorMode::Default;
+        const auto expectedErrorMsg = AZStd::string::format(
+            "Call to DeactivateMode for mode '%u' on id '%i' without precursor call to ActivateMode", static_cast<AZ::u32>(editorMode), viewportid);
+        const auto result = m_viewportEditorModeTracker.DeactivateMode({ viewportid }, editorMode);
+
+        // Expect an error due to no precursor activation of that mode
+        EXPECT_FALSE(result.IsSuccess());
+        EXPECT_EQ(result.GetError(), expectedErrorMsg);
+
+        // Expect that viewport to now be tracked
+        const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid });
+        EXPECT_TRUE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid }));
+
+        // Expect the mode for that viewport to be inactive
+        EXPECT_NE(viewportEditorModeState, nullptr);
+        EXPECT_FALSE(viewportEditorModeState->IsModeActive(editorMode));
+    }
+
+    TEST_F(ViewportEditorModeTrackerTestFixture, GettingNonExistentViewportEditorModesForIdReturnsNull)
+    {
+        const ViewportId viewportid = 0;
+        EXPECT_FALSE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid }));
+        EXPECT_EQ(m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }), nullptr);
+    }
+
+    TEST_F(ViewportEditorModeTrackerTestFixture, RegisteringViewportEditorModesForExistingIdInThatStateReturnsError)
+    {
+        // Given a viewport not currently tracked
+        const ViewportId viewportid = 0;
+        EXPECT_FALSE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid }));
+        EXPECT_EQ(m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }), nullptr);
+
+        const auto editorMode = ViewportEditorMode::Default;
+        {
+            // When the mode is activated for the viewport
+            const auto result = m_viewportEditorModeTracker.ActivateMode({ viewportid }, editorMode);
+
+            // Expect no error as there is no duplicate activation
+            EXPECT_TRUE(result.IsSuccess());
+
+            // Expect the mode to be active for the viewport
+            const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid });
+            EXPECT_TRUE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid }));
+            EXPECT_NE(viewportEditorModeState, nullptr);
+            EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode));
+        }
+        {
+            // When the mode is activated again for the viewport
+            const auto result = m_viewportEditorModeTracker.ActivateMode({ viewportid }, editorMode);
+
+            // Expect an error for the duplicate activation
+            const auto expectedErrorMsg = AZStd::string::format(
+                "Duplicate call to ActivateMode for mode '%u' on id '%i'", static_cast<AZ::u32>(editorMode), viewportid);
+            EXPECT_FALSE(result.IsSuccess());
+            EXPECT_EQ(result.GetError(), expectedErrorMsg);
+
+            // Expect the mode to still be active for the viewport
+            const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid });
+            EXPECT_TRUE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid }));
+            EXPECT_NE(viewportEditorModeState, nullptr);
+            EXPECT_TRUE(viewportEditorModeState->IsModeActive(editorMode));
+        }
+    }
+
+    TEST_F(ViewportEditorModeTrackerTestFixture, UnregisteringViewportEditorModesForExistingIdNotInThatStateReturnssError)
+    {
+        // Given a viewport not currently tracked
+        const ViewportId viewportid = 0;
+        EXPECT_FALSE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid }));
+        EXPECT_EQ(m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid }), nullptr);
+
+        const auto editorMode = ViewportEditorMode::Default;
+        {
+            // When the mode is activated and then deactivated for the viewport
+            m_viewportEditorModeTracker.ActivateMode({ viewportid }, editorMode);
+            const auto result = m_viewportEditorModeTracker.DeactivateMode({ viewportid }, editorMode);
+
+            // Expect no error as there is no duplicate deactivation
+            EXPECT_TRUE(result.IsSuccess());
+
+            // Expect the mode to be inctive for the viewport
+            const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid });
+            EXPECT_TRUE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid }));
+            EXPECT_NE(viewportEditorModeState, nullptr);
+            EXPECT_FALSE(viewportEditorModeState->IsModeActive(editorMode));
+        }
+        {
+            // When the mode is deactivated again for the viewport
+            const auto result = m_viewportEditorModeTracker.DeactivateMode({ viewportid }, editorMode);
+
+            // Expect an error for the duplicate deactivation
+            const auto expectedErrorMsg = AZStd::string::format(
+                "Duplicate call to DeactivateMode for mode '%u' on id '%i'", static_cast<AZ::u32>(editorMode), viewportid);
+            EXPECT_FALSE(result.IsSuccess());
+            EXPECT_EQ(result.GetError(), expectedErrorMsg);
+
+            // Expect the mode to still be inactive for the viewport
+            const auto* viewportEditorModeState = m_viewportEditorModeTracker.GetViewportEditorModes({ viewportid });
+            EXPECT_TRUE(m_viewportEditorModeTracker.IsViewportModeTracked({ viewportid }));
+            EXPECT_NE(viewportEditorModeState, nullptr);
+            EXPECT_FALSE(viewportEditorModeState->IsModeActive(editorMode));
+        }
+    }
+
+    TEST_F(
+        ViewportEditorModePublisherTestFixture,
+        RegisteringViewportEditorModesForExistingIdPublishesOnViewportEditorModeRegisterEventForAllSubscribers)
+    {
+        // Given a set of subscribers tracking the editor modes for their exclusive viewport
+        for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++)
+        {
+            // Expect each subscriber to have received no editor mode state changes
+            EXPECT_EQ(m_editorModeHandlers[mode]->GetEditorModes().size(), 0);
+        }
+
+        // When each editor mode is activated by the state tracker for a specific viewport
+        for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++)
+        {
+            const ViewportId viewportId = mode;
+            const ViewportEditorMode editorMode = static_cast<ViewportEditorMode>(mode);
+            m_viewportEditorModeTracker.ActivateMode({ viewportId }, editorMode);
+        }
+
+        for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++)
+        {
+            // Expect only the subscribers of each viewport to have received the editor mode activated event
+            const ViewportEditorMode editorMode = static_cast<ViewportEditorMode>(mode);
+            const auto& editorModes = m_editorModeHandlers[mode]->GetEditorModes();
+            EXPECT_EQ(editorModes.size(), 1);
+            EXPECT_EQ(editorModes.count(editorMode), 1);
+            const auto& expectedEditorModeSet = editorModes.find(editorMode);
+            EXPECT_NE(expectedEditorModeSet, editorModes.end());
+            EXPECT_TRUE(expectedEditorModeSet->second.m_onEnter);
+            EXPECT_FALSE(expectedEditorModeSet->second.m_onExit);
+        }
+    }
+
+    TEST_F(
+        ViewportEditorModePublisherTestFixture,
+        UnregisteringViewportEditorModesForExistingIdPublishesOnViewportEditorModeUnregisterEventForAllSubscribers)
+    {
+        // Given a set of subscribers tracking the editor modes for their exclusive viewport
+        for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++)
+        {
+            EXPECT_EQ(m_editorModeHandlers[mode]->GetEditorModes().size(), 0);
+        }
+
+        // When each editor mode is activated deactivated by the state tracker for a specific viewport
+        for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++)
+        {
+            const ViewportId viewportId = mode;
+            const ViewportEditorMode editorMode = static_cast<ViewportEditorMode>(mode);
+            m_viewportEditorModeTracker.ActivateMode({ viewportId }, editorMode);
+            m_viewportEditorModeTracker.DeactivateMode({ viewportId }, editorMode);
+        }
+
+        for (auto mode = 0; mode < ViewportEditorModes::NumEditorModes; mode++)
+        {
+            // Expect only the subscribers of each viewport to have received the editor mode activated and deactivated event
+            const ViewportEditorMode editorMode = static_cast<ViewportEditorMode>(mode);
+            const auto& editorModes = m_editorModeHandlers[mode]->GetEditorModes();
+            EXPECT_EQ(editorModes.size(), 1);
+            EXPECT_EQ(editorModes.count(editorMode), 1);
+            const auto& expectedEditorModeSet = editorModes.find(editorMode);
+            EXPECT_NE(expectedEditorModeSet, editorModes.end());
+            EXPECT_TRUE(expectedEditorModeSet->second.m_onEnter);
+            EXPECT_TRUE(expectedEditorModeSet->second.m_onExit);
+        }
+    }
+} // namespace UnitTest
@@ -110,6 +110,7 @@ set(FILES
    UI/EntityPropertyEditorTests.cpp
    UndoStack.cpp
    Viewport/ClusterTests.cpp
+    Viewport/ViewportEditorModeTests.cpp
    Viewport/ViewportScreenTests.cpp
    Viewport/ViewportUiClusterTests.cpp
    Viewport/ViewportUiDisplayTests.cpp