merge develop

Signed-off-by: igarri <igarri@amazon.com>

Code/Framework/AzToolsFramework/AzToolsFramework/API/ComponentModeCollectionInterface.h

@@ -0,0 +1,29 @@
+/*
+ * 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 for component mode collection queries.
+    class ComponentModeCollectionInterface
+    {
+    public:
+        AZ_RTTI(ComponentModeCollectionInterface, "{DFAA4450-BBCD-47C0-9B91-FEA2DBD9B152}");
+
+        virtual ~ComponentModeCollectionInterface() = default;
+
+        //! Retrieves the list of all Component types (usually one).
+        //! @note If called outside of component mode, an empty vector will be returned.
+        virtual AZStd::vector<AZ::Uuid> GetComponentTypes() const = 0;
+    };
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.cpp

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzCore/RTTI/BehaviorContext.h>
+#include <AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h>
+
+namespace AzToolsFramework
+{
+    void ViewportEditorModeNotifications::Reflect(AZ::ReflectContext* context)
+    {
+        if (auto* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->EBus<ViewportEditorModeNotificationsBus>("ViewportEditorModeNotificationsBus")
+                ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Automation)
+                ->Attribute(AZ::Script::Attributes::Category, "Editor")
+                ->Attribute(AZ::Script::Attributes::Module, "editor")
+                ->Event("OnEditorModeActivated", &ViewportEditorModeNotifications::OnEditorModeActivated)
+                ->Event("OnEditorModeDeactivated", &ViewportEditorModeNotifications::OnEditorModeDeactivated)
+                ;
+        }
+    }
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h

@@ -34,6 +34,8 @@ namespace AzToolsFramework
     class ViewportEditorModesInterface
     {
     public:
+        AZ_RTTI(ViewportEditorModesInterface, "{2421496C-4A46-41C9-8AEF-AE2B6E43E6CF}");
+
         virtual ~ViewportEditorModesInterface() = default;
 
         //! Returns true if the specified editor mode is active, otherwise false.
@@ -41,8 +43,7 @@ namespace AzToolsFramework
     };
 
     //! Provides a bus to notify when the different editor modes are entered/exit.
-    class ViewportEditorModeNotifications
-        : public AZ::EBusTraits
+    class ViewportEditorModeNotifications : public AZ::EBusTraits
     {
     public:
         //////////////////////////////////////////////////////////////////////////
@@ -52,15 +53,21 @@ namespace AzToolsFramework
         using BusIdType = ViewportEditorModeTrackerInfo::IdType;
         //////////////////////////////////////////////////////////////////////////
 
+        AZ_RTTI(ViewportEditorModeNotifications, "{9469DE39-6C21-423C-94FA-EF3A9616B14F}", AZ::EBusTraits);
+        static void Reflect(AZ::ReflectContext* context);
+
         //! 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)
+        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)
+        virtual void OnEditorModeDeactivated(
+            [[maybe_unused]] const ViewportEditorModesInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode)
         {
         }
     };
+
     using ViewportEditorModeNotificationsBus = AZ::EBus<ViewportEditorModeNotifications>;
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/AssetBrowser/AssetBrowserTableModel.h

@@ -53,7 +53,7 @@ namespace AzToolsFramework
         private slots:
             void SourceDataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight);
         private:
-            int m_numberOfItemsDisplayed = 50;
+            AZ::u64 m_numberOfItemsDisplayed = 0;
             int m_displayedItemsCounter = 0;
             QPointer<AssetBrowserFilterModel> m_filterModel;
             QMap<int, QModelIndex> m_indexMap;

Code/Framework/AzToolsFramework/AzToolsFramework/AssetEditor/AssetEditorWidget.cpp

@@ -410,7 +410,7 @@ namespace AzToolsFramework
                     filter.append(ext);
                     if (i < n - 1)
                     {
-                        filter.append(", ");
+                        filter.append(" ");
                     }
                 }
                 filter.append(")");

Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.cpp

@@ -137,6 +137,7 @@ namespace AzToolsFramework
             if (componentTypeIt == m_activeComponentTypes.end())
             {
                 m_activeComponentTypes.push_back(componentType);
+                m_viewportUiHandlers.emplace_back(componentType);
             }
 
             // see if we already have a ComponentModeBuilder for the specific component on this entity
@@ -203,6 +204,12 @@ namespace AzToolsFramework
             }
         }
 
+        AZStd::vector<AZ::Uuid> ComponentModeCollection::GetComponentTypes() const
+        {
+            // If in component mode, return the active component types, otherwise return an empty vector
+            return InComponentMode() ? m_activeComponentTypes : AZStd::vector<AZ::Uuid>{};
+        }
+
         void ComponentModeCollection::BeginComponentMode()
         {
             m_selectedComponentModeIndex = 0;
@@ -211,13 +218,6 @@ namespace AzToolsFramework
 
             // notify listeners the editor has entered ComponentMode - listeners may
             // wish to modify state to indicate this (e.g. appearance, functionality etc.)
-            EditorComponentModeNotificationBus::Event(
-                GetEntityContextId(), &EditorComponentModeNotifications::EnteredComponentMode,
-                m_activeComponentTypes);
-
-            // this call to activate the component mode editor state should eventually replace the bus call in
-            // ComponentModeCollection::BeginComponentMode() to EditorComponentModeNotifications::EnteredComponentMode
-            // such that all of the notifications for activating/deactivating the different editor modes are in a central location
             m_viewportEditorModeTracker->ActivateMode({ GetEntityContextId() }, ViewportEditorMode::Component);
 
             // enable actions for the first/primary ComponentMode
@@ -226,6 +226,7 @@ namespace AzToolsFramework
             if (!m_entitiesAndComponentModes.empty())
             {
                 RefreshActions();
+                PopulateViewportUi();
             }
 
             // if entering ComponentMode not as an undo/redo step (an action was
@@ -286,16 +287,12 @@ namespace AzToolsFramework
                 componentModeCommand.release();
             }
 
+            // remove the component mode viewport border
+            ViewportUi::ViewportUiRequestBus::Event(
+                ViewportUi::DefaultViewportId, &ViewportUi::ViewportUiRequestBus::Events::RemoveViewportBorder);
+
             // notify listeners the editor has left ComponentMode - listeners may
             // wish to modify state to indicate this (e.g. appearance, functionality etc.)
-            EditorComponentModeNotificationBus::Event(
-                GetEntityContextId(),
-                &EditorComponentModeNotifications::LeftComponentMode,
-                m_activeComponentTypes);
-
-            // this call to deactivate the component mode editor state should eventually replace the bus call in
-            // ComponentModeCollection::EndComponentMode() to EditorComponentModeNotifications::LeftComponentMode
-            // such that all of the notifications for activating/deactivating the different editor modes are in a central location
             m_viewportEditorModeTracker->DeactivateMode({ GetEntityContextId() }, ViewportEditorMode::Component);
 
             // clear stored modes and builders for this ComponentMode
@@ -310,6 +307,7 @@ namespace AzToolsFramework
             }
             m_entitiesAndComponentModeBuilders.clear();
             m_activeComponentTypes.clear();
+            m_viewportUiHandlers.clear();
 
             m_componentMode = false;
             m_selectedComponentModeIndex = 0;
@@ -394,6 +392,24 @@ namespace AzToolsFramework
             return m_activeComponentTypes.size() > 1;
         }
 
+        static ComponentModeViewportUi* FindViewportUiHandlerForType(
+            AZStd::vector<ComponentModeViewportUi>& viewportUiHandlers, const AZ::Uuid& componentType)
+        {
+            auto handler = AZStd::find_if(
+                viewportUiHandlers.begin(), viewportUiHandlers.end(),
+                [componentType](const ComponentModeViewportUi& handler)
+                {
+                    return handler.GetComponentType() == componentType;
+                });
+
+            if (handler == viewportUiHandlers.end())
+            {
+                return nullptr;
+            }
+
+            return handler;
+        }
+
         bool ComponentModeCollection::ActiveComponentModeChanged(const AZ::Uuid& previousComponentType)
         {
             if (m_activeComponentTypes[m_selectedComponentModeIndex] != previousComponentType)
@@ -419,6 +435,20 @@ namespace AzToolsFramework
                     // replace the current component mode by invoking the builder
                     // for the new 'active' component mode
                     componentMode.m_componentMode = componentModeBuilder->m_componentModeBuilder();
+
+                    // populate the viewport UI with the new component mode
+                    PopulateViewportUi();
+
+                    // set the appropriate viewportUiHandler to active
+                    if (auto viewportUiHandler =
+                            FindViewportUiHandlerForType(m_viewportUiHandlers, m_activeComponentTypes[m_selectedComponentModeIndex]))
+                    {
+                        viewportUiHandler->SetComponentModeViewportUiActive(true);
+                    }
+
+                    ViewportUi::ViewportUiRequestBus::Event(
+                        ViewportUi::DefaultViewportId, &ViewportUi::ViewportUiRequestBus::Events::CreateViewportBorder,
+                        componentMode.m_componentMode->GetComponentModeName().c_str());
                 }
 
                 RefreshActions();
@@ -528,5 +558,18 @@ namespace AzToolsFramework
             }
         }
 
+        void ComponentModeCollection::PopulateViewportUi()
+        {
+            // update viewport UI for new component type
+            if (m_selectedComponentModeIndex < m_activeComponentTypes.size())
+            {
+                // iterate over all entities and their active Component Mode, populate viewport UI for the new mode
+                for (auto& entityAndComponentMode : m_entitiesAndComponentModes)
+                {
+                    // build viewport UI based on current state
+                    entityAndComponentMode.m_componentMode->PopulateViewportUi();
+                }
+            }
+        }
     } // namespace ComponentModeFramework
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeCollection.h

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <AzCore/std/containers/vector.h>
+#include <AzToolsFramework/API/ComponentModeCollectionInterface.h>
 #include <AzToolsFramework/ComponentMode/ComponentModeViewportUi.h>
 #include <AzToolsFramework/ComponentMode/EditorComponentModeBus.h>
 
@@ -21,6 +22,7 @@ namespace AzToolsFramework
     {
         /// Manages all individual ComponentModes for a single instance of Editor wide ComponentMode.
         class ComponentModeCollection
+            : public ComponentModeCollectionInterface
         {
         public:
             AZ_CLASS_ALLOCATOR_DECL
@@ -89,6 +91,9 @@ namespace AzToolsFramework
             /// Called once each time a ComponentMode is added.
             void PopulateViewportUi();
 
+            // ComponentModeCollectionInterface overrides ...
+            AZStd::vector<AZ::Uuid> GetComponentTypes() const override;
+
         private:
             // Internal helper used by Select[|Prev|Next]ActiveComponentMode
             bool ActiveComponentModeChanged(const AZ::Uuid& previousComponentType);

Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/ComponentModeDelegate.cpp

@@ -24,18 +24,8 @@ namespace AzToolsFramework
                 : public EditorComponentModeNotificationBus::Handler
                 , public AZ::BehaviorEBusHandler
             {
-                AZ_EBUS_BEHAVIOR_BINDER(EditorComponentModeNotificationBusHandler, "{AD2F4204-0913-4FC9-9A10-492538F60C70}", AZ::SystemAllocator,
-                    EnteredComponentMode, LeftComponentMode, ActiveComponentModeChanged);
-
-                void EnteredComponentMode(const AZStd::vector<AZ::Uuid>& componentTypes) override
-                {
-                    Call(FN_EnteredComponentMode, componentTypes);
-                }
-
-                void LeftComponentMode(const AZStd::vector<AZ::Uuid>& componentTypes) override
-                {
-                    Call(FN_LeftComponentMode, componentTypes);
-                }
+                AZ_EBUS_BEHAVIOR_BINDER(
+                    EditorComponentModeNotificationBusHandler, "{AD2F4204-0913-4FC9-9A10-492538F60C70}", AZ::SystemAllocator, ActiveComponentModeChanged);
 
                 void ActiveComponentModeChanged(const AZ::Uuid& componentType) override
                 {
@@ -171,8 +161,6 @@ namespace AzToolsFramework
                     ->Attribute(AZ::Script::Attributes::Category, "Editor")
                     ->Attribute(AZ::Script::Attributes::Module, "editor")
                     ->Handler<Internal::EditorComponentModeNotificationBusHandler>()
-                    ->Event("EnteredComponentMode", &EditorComponentModeNotifications::EnteredComponentMode)
-                    ->Event("LeftComponentMode", &EditorComponentModeNotifications::LeftComponentMode)
                     ->Event("ActiveComponentModeChanged", &EditorComponentModeNotifications::ActiveComponentModeChanged)
                     ;
             }

Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/EditorBaseComponentMode.cpp

@@ -55,7 +55,7 @@ namespace AzToolsFramework
                 GetEntityComponentIdPair(), elementIdsToDisplay);
             // create the component mode border with the specific name for this component mode
             ViewportUi::ViewportUiRequestBus::Event(
-                ViewportUi::DefaultViewportId, &ViewportUi::ViewportUiRequestBus::Events::CreateComponentModeBorder,
+                ViewportUi::DefaultViewportId, &ViewportUi::ViewportUiRequestBus::Events::CreateViewportBorder,
                 GetComponentModeName());
             // set the EntityComponentId for this ComponentMode to active in the ComponentModeViewportUi system
             ComponentModeViewportUiRequestBus::Event(

Code/Framework/AzToolsFramework/AzToolsFramework/ComponentMode/EditorComponentModeBus.h

@@ -238,12 +238,6 @@ namespace AzToolsFramework
             using BusIdType = AzFramework::EntityContextId;
             static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
 
-            /// Called when Editor enters ComponentMode - pass the list of all Component types (usually one).
-            virtual void EnteredComponentMode(const AZStd::vector<AZ::Uuid>& componentTypes) = 0;
-
-            /// Called when Editor leaves ComponentMode - pass the list of all Component types (usually one).
-            virtual void LeftComponentMode(const AZStd::vector<AZ::Uuid>& componentTypes) = 0;
-
             /// Called when Tab is pressed to cycle the 'selected' ComponentMode (which shortcuts/actions are active).
             /// Also called when directly selecting a Component in the EntityOutliner.
             virtual void ActiveComponentModeChanged(const AZ::Uuid& /*componentType*/) {}
@@ -255,42 +249,6 @@ namespace AzToolsFramework
         /// Type to inherit to implement EditorComponentModeNotifications.
         using EditorComponentModeNotificationBus = AZ::EBus<EditorComponentModeNotifications>;
 
-        /// Helper for EditorComponentModeNotifications to be used
-        /// as a member instead of inheriting from EBus directly.
-        class EditorComponentModeNotificationBusImpl
-            : public EditorComponentModeNotificationBus::Handler
-        {
-        public:
-            /// Set the function to be called when entering ComponentMode.
-            void SetEnteredComponentModeFunc(
-                const AZStd::function<void(const AZStd::vector<AZ::Uuid>&)>& enteredComponentModeFunc)
-            {
-                m_enteredComponentModeFunc = enteredComponentModeFunc;
-            }
-
-            /// Set the function to be called when leaving ComponentMode.
-            void SetLeftComponentModeFunc(
-                const AZStd::function<void(const AZStd::vector<AZ::Uuid>&)>& leftComponentModeFunc)
-            {
-                m_leftComponentModeFunc = leftComponentModeFunc;
-            }
-
-        private:
-            // EditorComponentModeNotificationBus
-            void EnteredComponentMode(const AZStd::vector<AZ::Uuid>& componentModeTypes) override
-            {
-                m_enteredComponentModeFunc(componentModeTypes);
-            }
-
-            void LeftComponentMode(const AZStd::vector<AZ::Uuid>& componentModeTypes) override
-            {
-                m_leftComponentModeFunc(componentModeTypes);
-            }
-
-            AZStd::function<void(const AZStd::vector<AZ::Uuid>&)> m_enteredComponentModeFunc; ///< Function to call when entering ComponentMode.
-            AZStd::function<void(const AZStd::vector<AZ::Uuid>&)> m_leftComponentModeFunc; ///< Function to call when leaving ComponentMode.
-        };
-
         /// Helper to answer if the Editor is in ComponentMode or not.
         inline bool InComponentMode()
         {

Code/Framework/AzToolsFramework/AzToolsFramework/ContainerEntity/ContainerEntityInterface.h

@@ -11,6 +11,8 @@
 #include <AzCore/Interface/Interface.h>
 #include <AzCore/Serialization/SerializeContext.h>
 
+#include <AzFramework/Entity/EntityContextBus.h>
+
 namespace AzToolsFramework
 {
     //! Outcome object that returns an error message in case of failure to allow caller to handle internal errors.
@@ -43,7 +45,7 @@ namespace AzToolsFramework
         //! @param entityId The entityId whose open state will be set.
         //! @param open True if the container should be opened, false if it should be closed.
         //! @return An error message if the operation was invalid, success otherwise.
-        virtual ContainerEntityOperationResult SetContainerOpenState(AZ::EntityId entityId, bool open) = 0;
+        virtual ContainerEntityOperationResult SetContainerOpen(AZ::EntityId entityId, bool open) = 0;
 
         //! If the entity id provided is registered as a container, it returns whether it's open.
         //! @note the default value for non-containers is true, so this function can be called without
@@ -56,6 +58,16 @@ namespace AzToolsFramework
         //! @return The highest closed entity container id if any, or entityId otherwise.
         virtual AZ::EntityId FindHighestSelectableEntity(AZ::EntityId entityId) const = 0;
 
+        //! Clears all open state information for Container Entities for the EntityContextId provided.
+        //! Used when context is switched, for example in the case of a new root prefab being loaded
+        //! in place of an old one.
+        //! @note Clear is meant to be called when no container is registered for the context provided.
+        //! @return An error message if any container was registered for the context, success otherwise.
+        virtual ContainerEntityOperationResult Clear(AzFramework::EntityContextId entityContextId) = 0;
+
+        //! Returns true if one of the ancestors of entityId is a closed container entity.
+        virtual bool IsUnderClosedContainerEntity(AZ::EntityId entityId) const = 0;
+
     };
 
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/ContainerEntity/ContainerEntitySystemComponent.cpp

@@ -10,16 +10,19 @@
 
 #include <AzCore/Component/TransformBus.h>
 #include <AzToolsFramework/ContainerEntity/ContainerEntityNotificationBus.h>
+#include <AzToolsFramework/API/ToolsApplicationAPI.h>
 
 namespace AzToolsFramework
 {
     void ContainerEntitySystemComponent::Activate()
     {
         AZ::Interface<ContainerEntityInterface>::Register(this);
+        EditorEntityContextNotificationBus::Handler::BusConnect();
     }
 
     void ContainerEntitySystemComponent::Deactivate()
     {
+        EditorEntityContextNotificationBus::Handler::BusDisconnect();
         AZ::Interface<ContainerEntityInterface>::Unregister(this);
     }
 
@@ -63,7 +66,7 @@ namespace AzToolsFramework
         return m_containers.contains(entityId);
     }
 
-    ContainerEntityOperationResult ContainerEntitySystemComponent::SetContainerOpenState(AZ::EntityId entityId, bool open)
+    ContainerEntityOperationResult ContainerEntitySystemComponent::SetContainerOpen(AZ::EntityId entityId, bool open)
     {
         if (!IsContainer(entityId))
         {
@@ -87,7 +90,7 @@ namespace AzToolsFramework
 
     bool ContainerEntitySystemComponent::IsContainerOpen(AZ::EntityId entityId) const
     {
-        // If the entity is not a container, it should behave as open.
+        // Non-container entities behave the same as open containers. This saves the caller an additional check.
         if(!m_containers.contains(entityId))
         {
             return true;
@@ -99,8 +102,17 @@ namespace AzToolsFramework
 
     AZ::EntityId ContainerEntitySystemComponent::FindHighestSelectableEntity(AZ::EntityId entityId) const
     {
+        if (!entityId.IsValid())
+        {
+            return entityId;
+        }
+
+        // Return the highest closed container, or the entity if none is found.
         AZ::EntityId highestSelectableEntityId = entityId;
 
+        // Skip the queried entity, as we only want to check its ancestors.
+        AZ::TransformBus::EventResult(entityId, entityId, &AZ::TransformBus::Events::GetParentId);
+
         // Go up the hierarchy until you hit the root
         while (entityId.IsValid())
         {
@@ -117,4 +129,72 @@ namespace AzToolsFramework
         return highestSelectableEntityId;
     }
 
+    void ContainerEntitySystemComponent::OnEntityStreamLoadSuccess()
+    {
+        // We don't yet support multiple entity contexts, so just use the default.
+        auto editorEntityContextId = AzFramework::EntityContextId::CreateNull();
+        EditorEntityContextRequestBus::BroadcastResult(editorEntityContextId, &EditorEntityContextRequests::GetEditorEntityContextId);
+
+        Clear(editorEntityContextId);
+    }
+
+    ContainerEntityOperationResult ContainerEntitySystemComponent::Clear(AzFramework::EntityContextId entityContextId)
+    {
+        // We don't yet support multiple entity contexts, so only clear the default.
+        auto editorEntityContextId = AzFramework::EntityContextId::CreateNull();
+        EditorEntityContextRequestBus::BroadcastResult(editorEntityContextId, &EditorEntityContextRequests::GetEditorEntityContextId);
+
+        if (entityContextId != editorEntityContextId)
+        {
+            return AZ::Failure(AZStd::string(
+                "Error in ContainerEntitySystemComponent::Clear - cannot clear non-default Entity Context!"));
+        }
+
+        if (!m_containers.empty())
+        {
+            return AZ::Failure(AZStd::string(
+                "Error in ContainerEntitySystemComponent::Clear - cannot clear container states if entities are still registered!"));
+        }
+
+        m_openContainers.clear();
+
+        return AZ::Success();
+    }
+
+    bool ContainerEntitySystemComponent::IsUnderClosedContainerEntity(AZ::EntityId entityId) const
+    {
+        if (!entityId.IsValid())
+        {
+            return false;
+        }
+
+        // Skip the queried entity, as we only want to check its ancestors.
+        AZ::TransformBus::EventResult(entityId, entityId, &AZ::TransformBus::Events::GetParentId);
+
+        // Go up the hierarchy until you hit the root.
+        while (entityId.IsValid())
+        {
+            if (!IsContainerOpen(entityId))
+            {
+                // One of the ancestors is a container and it's closed.
+                return true;
+            }
+
+            AZ::EntityId parentId;
+            AZ::TransformBus::EventResult(parentId, entityId, &AZ::TransformBus::Events::GetParentId);
+
+            if (parentId == entityId)
+            {
+                // In some circumstances, querying a root level entity with GetParentId will return
+                // the entity itself instead of an invalid entityId. 
+                break;
+            }
+
+            entityId = parentId;
+        }
+
+        // All ancestors are either regular entities or open containers.
+        return false;
+    }
+
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/ContainerEntity/ContainerEntitySystemComponent.h

@@ -12,6 +12,7 @@
 #include <AzCore/Memory/SystemAllocator.h>
 
 #include <AzToolsFramework/ContainerEntity/ContainerEntityInterface.h>
+#include <AzToolsFramework/Entity/EditorEntityContextBus.h>
 
 namespace AzToolsFramework
 {
@@ -23,6 +24,7 @@ namespace AzToolsFramework
     class ContainerEntitySystemComponent final
         : public AZ::Component
         , private ContainerEntityInterface
+        , private EditorEntityContextNotificationBus::Handler
     {
     public:
         AZ_COMPONENT(ContainerEntitySystemComponent, "{74349759-B36B-44A6-B89F-F45D7111DD11}");
@@ -42,9 +44,14 @@ namespace AzToolsFramework
         ContainerEntityOperationResult RegisterEntityAsContainer(AZ::EntityId entityId) override;
         ContainerEntityOperationResult UnregisterEntityAsContainer(AZ::EntityId entityId) override;
         bool IsContainer(AZ::EntityId entityId) const override;
-        ContainerEntityOperationResult SetContainerOpenState(AZ::EntityId entityId, bool open) override;
+        ContainerEntityOperationResult SetContainerOpen(AZ::EntityId entityId, bool open) override;
         bool IsContainerOpen(AZ::EntityId entityId) const override;
         AZ::EntityId FindHighestSelectableEntity(AZ::EntityId entityId) const override;
+        ContainerEntityOperationResult Clear(AzFramework::EntityContextId entityContextId) override;
+        bool IsUnderClosedContainerEntity(AZ::EntityId entityId) const override;
+
+        // EditorEntityContextNotificationBus overrides ...
+        void OnEntityStreamLoadSuccess() override;
 
     private:
         AZStd::unordered_set<AZ::EntityId> m_containers;      //!< All entities in this set are containers.

Code/Framework/AzToolsFramework/AzToolsFramework/Editor/EditorSettingsAPIBus.h

@@ -38,7 +38,7 @@ namespace AzToolsFramework
         virtual SettingOutcome GetValue(const AZStd::string_view path) = 0;
         virtual SettingOutcome SetValue(const AZStd::string_view path, const AZStd::any& value) = 0;
         virtual ConsoleColorTheme GetConsoleColorTheme() const = 0;
-        virtual int GetMaxNumberOfItemsShownInSearchView() const = 0;
+        virtual AZ::u64 GetMaxNumberOfItemsShownInSearchView() const = 0;
     };
 
     using EditorSettingsAPIBus = AZ::EBus<EditorSettingsAPIRequests>;

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityHelpers.cpp

@@ -16,9 +16,11 @@
 #include <AzCore/RTTI/AttributeReader.h>
 #include <AzCore/Serialization/SerializeContext.h>
 #include <AzToolsFramework/Commands/EntityStateCommand.h>
+#include <AzToolsFramework/ContainerEntity/ContainerEntityInterface.h>
 #include <AzToolsFramework/Entity/EditorEntityInfoBus.h>
 #include <AzToolsFramework/Entity/EditorEntityContextBus.h>
 #include <AzToolsFramework/Entity/SliceEditorEntityOwnershipServiceBus.h>
+#include <AzToolsFramework/FocusMode/FocusModeInterface.h>
 #include <AzToolsFramework/Slice/SliceMetadataEntityContextBus.h>
 #include <AzToolsFramework/Slice/SliceUtilities.h>
 #include <AzToolsFramework/ToolsComponents/EditorLockComponentBus.h>
@@ -588,15 +590,40 @@ namespace AzToolsFramework
     {
         AZ_PROFILE_FUNCTION(AzToolsFramework);
 
+        // Detect if the Entity is Visible
         bool visible = false;
         EditorEntityInfoRequestBus::EventResult(
             visible, entityId, &EditorEntityInfoRequestBus::Events::IsVisible);
 
-        bool locked = false;
-        EditorEntityInfoRequestBus::EventResult(
-            locked, entityId, &EditorEntityInfoRequestBus::Events::IsLocked);
+        if (!visible)
+        {
+            return false;
+        }
 
-        return visible && !locked;
+        // Detect if the Entity is Locked
+        bool locked = false;
+        EditorEntityInfoRequestBus::EventResult(locked, entityId, &EditorEntityInfoRequestBus::Events::IsLocked);
+
+        if (locked)
+        {
+            return false;
+        }
+
+        // Detect if the Entity is part of the Editor Focus
+        if (auto focusModeInterface = AZ::Interface<FocusModeInterface>::Get();
+            !focusModeInterface->IsInFocusSubTree(entityId))
+        {
+            return false;
+        }
+
+        // Detect if the Entity is a descendant of a closed container
+        if (auto containerEntityInterface = AZ::Interface<ContainerEntityInterface>::Get();
+            containerEntityInterface->IsUnderClosedContainerEntity(entityId))
+        {
+            return false;
+        }
+        
+        return true;
     }
 
     static void SetEntityLockStateRecursively(

Code/Framework/AzToolsFramework/AzToolsFramework/FocusMode/FocusModeNotificationBus.h

@@ -28,8 +28,10 @@ namespace AzToolsFramework
         //////////////////////////////////////////////////////////////////////////
         
         //! Triggered when the editor focus is changed to a different entity.
-        //! @param entityId The entity the focus has been moved to.
-        virtual void OnEditorFocusChanged(AZ::EntityId entityId) = 0;
+        //! @param previousFocusEntityId The entity the focus has been moved from.
+        //! @param newFocusEntityId The entity the focus has been moved to.
+        virtual void OnEditorFocusChanged(
+            [[maybe_unused]] AZ::EntityId previousFocusEntityId, [[maybe_unused]] AZ::EntityId newFocusEntityId) {}
 
     protected:
         ~FocusModeNotifications() = default;

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

@@ -71,11 +71,7 @@ namespace AzToolsFramework
             return;
         }
 
-        m_focusRoot = entityId;
-        FocusModeNotificationBus::Broadcast(&FocusModeNotifications::OnEditorFocusChanged, m_focusRoot);
-
-        if (auto tracker = AZ::Interface<ViewportEditorModeTrackerInterface>::Get();
-            tracker != nullptr)
+        if (auto tracker = AZ::Interface<ViewportEditorModeTrackerInterface>::Get())
         {
             if (!m_focusRoot.IsValid() && entityId.IsValid())
             {
@@ -86,6 +82,10 @@ namespace AzToolsFramework
                 tracker->DeactivateMode({ GetEntityContextId() }, ViewportEditorMode::Focus);
             }
         }
+
+        AZ::EntityId previousFocusEntityId = m_focusRoot;
+        m_focusRoot = entityId;
+        FocusModeNotificationBus::Broadcast(&FocusModeNotifications::OnEditorFocusChanged, previousFocusEntityId, m_focusRoot);
     }
 
     void FocusModeSystemComponent::ClearFocusRoot([[maybe_unused]] AzFramework::EntityContextId entityContextId)

Code/Framework/AzToolsFramework/AzToolsFramework/Input/QtEventToAzInputManager.cpp

@@ -261,10 +261,10 @@ namespace AzToolsFramework
             // ensures cursor positions are refreshed correctly with context menu focus changes)
             if (eventType == QEvent::FocusIn)
             {
-                const auto widgetCursorPosition = m_sourceWidget->mapFromGlobal(QCursor::pos());
-                if (m_sourceWidget->geometry().contains(widgetCursorPosition))
+                const auto globalCursorPosition = QCursor::pos();
+                if (m_sourceWidget->geometry().contains(globalCursorPosition))
                 {
-                    HandleMouseMoveEvent(widgetCursorPosition);
+                    HandleMouseMoveEvent(globalCursorPosition);
                 }
             }
         }
@@ -290,7 +290,7 @@ namespace AzToolsFramework
         else if (eventType == QEvent::Type::MouseMove)
         {
             auto mouseEvent = static_cast<QMouseEvent*>(event);
-            HandleMouseMoveEvent(mouseEvent->pos());
+            HandleMouseMoveEvent(mouseEvent->globalPos());
         }
         // Map wheel events to the mouse Z movement channel.
         else if (eventType == QEvent::Type::Wheel)
@@ -370,11 +370,12 @@ namespace AzToolsFramework
         return QPoint{ denormalizedX, denormalizedY };
     }
 
-    void QtEventToAzInputMapper::HandleMouseMoveEvent(const QPoint& cursorPosition)
+    void QtEventToAzInputMapper::HandleMouseMoveEvent(const QPoint& globalCursorPosition)
     {
-        const QPoint cursorDelta = cursorPosition - m_previousCursorPosition;
+        const QPoint cursorDelta = globalCursorPosition - m_previousGlobalCursorPosition;
 
-        m_mouseDevice->m_cursorPositionData2D->m_normalizedPosition = WidgetPositionToNormalizedPosition(cursorPosition);
+        m_mouseDevice->m_cursorPositionData2D->m_normalizedPosition =
+            WidgetPositionToNormalizedPosition(m_sourceWidget->mapFromGlobal(globalCursorPosition));
         m_mouseDevice->m_cursorPositionData2D->m_normalizedPositionDelta = WidgetPositionToNormalizedPosition(cursorDelta);
 
         ProcessPendingMouseEvents(cursorDelta);
@@ -382,12 +383,11 @@ namespace AzToolsFramework
         if (m_capturingCursor)
         {
             // Reset our cursor position to the previous point
-            const QPoint screenCursorPosition = m_sourceWidget->mapToGlobal(m_previousCursorPosition);
-            AzQtComponents::SetCursorPos(screenCursorPosition);
+            AzQtComponents::SetCursorPos(m_previousGlobalCursorPosition);
         }
         else
         {
-            m_previousCursorPosition = cursorPosition;
+            m_previousGlobalCursorPosition = globalCursorPosition;
         }
     }
 

Code/Framework/AzToolsFramework/AzToolsFramework/Input/QtEventToAzInputManager.h

@@ -129,7 +129,7 @@ namespace AzToolsFramework
         // Handle mouse click events.
         void HandleMouseButtonEvent(QMouseEvent* mouseEvent);
         // Handle mouse move events.
-        void HandleMouseMoveEvent(const QPoint& cursorPosition);
+        void HandleMouseMoveEvent(const QPoint& globalCursorPosition);
         // Handles key press / release events (or ShortcutOverride events for keys listed in m_highPriorityKeys).
         void HandleKeyEvent(QKeyEvent* keyEvent);
         // Handles mouse wheel events.
@@ -156,8 +156,8 @@ namespace AzToolsFramework
         AZStd::unordered_set<Qt::Key> m_highPriorityKeys;
         // A lookup table for AZ input channel ID -> physical input channel on our mouse or keyboard device.
         AZStd::unordered_map<AzFramework::InputChannelId, AzFramework::InputChannel*> m_channels;
-        // Where the position of the mouse cursor was at the last cursor event.
-        QPoint m_previousCursorPosition;
+        // Where the mouse cursor was at the last cursor event.
+        QPoint m_previousGlobalCursorPosition;
         // The source widget to map events from, used to calculate the relative mouse position within the widget bounds.
         QWidget* m_sourceWidget;
         // Flags whether or not Qt events should currently be processed.

Code/Framework/AzToolsFramework/AzToolsFramework/Picking/Manipulators/ManipulatorBounds.cpp

@@ -116,7 +116,7 @@ namespace AzToolsFramework
         {
             return AZ::Intersect::IntersectRayBox(
                        rayOrigin, rayDirection, m_center, m_axis1, m_axis2, m_axis3, m_halfExtents.GetX(), m_halfExtents.GetY(),
-                       m_halfExtents.GetZ(), rayIntersectionDistance) > 0;
+                       m_halfExtents.GetZ(), rayIntersectionDistance);
         }
 
         void ManipulatorBoundBox::SetShapeData(const BoundRequestShapeBase& shapeData)

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.cpp

@@ -262,7 +262,7 @@ namespace AzToolsFramework
 
                         if (assetId.IsValid())
                         {
-                            asset.Create(assetId, true);
+                            asset.Create(assetId, false);
                         }
                     }
                 };

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

@@ -8,12 +8,14 @@
 
 #include <AzToolsFramework/Prefab/PrefabFocusHandler.h>
 
+#include <AzToolsFramework/Commands/SelectionCommand.h>
 #include <AzToolsFramework/ContainerEntity/ContainerEntityInterface.h>
 #include <AzToolsFramework/Entity/EditorEntityHelpers.h>
 #include <AzToolsFramework/Entity/PrefabEditorEntityOwnershipInterface.h>
 #include <AzToolsFramework/Prefab/Instance/Instance.h>
 #include <AzToolsFramework/Prefab/Instance/InstanceEntityMapperInterface.h>
 #include <AzToolsFramework/Prefab/PrefabFocusNotificationBus.h>
+#include <AzToolsFramework/Prefab/PrefabFocusUndo.h>
 
 namespace AzToolsFramework::Prefab
 {
@@ -28,10 +30,12 @@ namespace AzToolsFramework::Prefab
 
         EditorEntityContextNotificationBus::Handler::BusConnect();
         AZ::Interface<PrefabFocusInterface>::Register(this);
+        AZ::Interface<PrefabFocusPublicInterface>::Register(this);
     }
 
     PrefabFocusHandler::~PrefabFocusHandler()
     {
+        AZ::Interface<PrefabFocusPublicInterface>::Unregister(this);
         AZ::Interface<PrefabFocusInterface>::Unregister(this);
         EditorEntityContextNotificationBus::Handler::BusDisconnect();
     }
@@ -61,6 +65,44 @@ namespace AzToolsFramework::Prefab
     }
 
     PrefabFocusOperationResult PrefabFocusHandler::FocusOnOwningPrefab(AZ::EntityId entityId)
+    {
+        // Initialize Undo Batch object
+        ScopedUndoBatch undoBatch("Edit Prefab");
+
+        // Clear selection
+        {
+            const EntityIdList selectedEntities = EntityIdList{};
+            auto selectionUndo = aznew SelectionCommand(selectedEntities, "Clear Selection");
+            selectionUndo->SetParent(undoBatch.GetUndoBatch());
+            ToolsApplicationRequestBus::Broadcast(&ToolsApplicationRequestBus::Events::SetSelectedEntities, selectedEntities);
+        }
+
+        // Edit Prefab
+        {
+            auto editUndo = aznew PrefabFocusUndo("Edit Prefab");
+            editUndo->Capture(entityId);
+            editUndo->SetParent(undoBatch.GetUndoBatch());
+            ToolsApplicationRequestBus::Broadcast(&ToolsApplicationRequestBus::Events::RunRedoSeparately, editUndo);
+        }
+
+        return AZ::Success();
+    }
+
+    PrefabFocusOperationResult PrefabFocusHandler::FocusOnPathIndex([[maybe_unused]] AzFramework::EntityContextId entityContextId, int index)
+    {
+        if (index < 0 || index >= m_instanceFocusVector.size())
+        {
+            return AZ::Failure(AZStd::string("Prefab Focus Handler: Invalid index on FocusOnPathIndex."));
+        }
+
+        InstanceOptionalReference focusedInstance = m_instanceFocusVector[index];
+
+        FocusOnOwningPrefab(focusedInstance->get().GetContainerEntityId());
+
+        return AZ::Success();
+    }
+
+    PrefabFocusOperationResult PrefabFocusHandler::FocusOnPrefabInstanceOwningEntityId(AZ::EntityId entityId)
     {
         InstanceOptionalReference focusedInstance;
 
@@ -85,18 +127,6 @@ namespace AzToolsFramework::Prefab
         return FocusOnPrefabInstance(focusedInstance);
     }
 
-    PrefabFocusOperationResult PrefabFocusHandler::FocusOnPathIndex([[maybe_unused]] AzFramework::EntityContextId entityContextId, int index)
-    {
-        if (index < 0 || index >= m_instanceFocusVector.size())
-        {
-            return AZ::Failure(AZStd::string("Prefab Focus Handler: Invalid index on FocusOnPathIndex."));
-        }
-
-        InstanceOptionalReference focusedInstance = m_instanceFocusVector[index];
-
-        return FocusOnPrefabInstance(focusedInstance);
-    }
-
     PrefabFocusOperationResult PrefabFocusHandler::FocusOnPrefabInstance(InstanceOptionalReference focusedInstance)
     {
         if (!focusedInstance.has_value())
@@ -122,17 +152,10 @@ namespace AzToolsFramework::Prefab
             if (focusedInstance->get().GetParentInstance() != AZStd::nullopt)
             {
                 containerEntityId = focusedInstance->get().GetContainerEntityId();
-
-                // Select the container entity
-                AzToolsFramework::SelectEntity(containerEntityId);
             }
             else
             {
                 containerEntityId = AZ::EntityId();
-
-                // Clear the selection
-                AzToolsFramework::SelectEntities({});
-                
             }
             
             // Focus on the descendants of the container entity
@@ -161,6 +184,17 @@ namespace AzToolsFramework::Prefab
         return m_focusedInstance;
     }
 
+    AZ::EntityId PrefabFocusHandler::GetFocusedPrefabContainerEntityId([[maybe_unused]] AzFramework::EntityContextId entityContextId) const
+    {
+        if (!m_focusedInstance.has_value())
+        {
+            // PrefabFocusHandler has not been initialized yet.
+            return AZ::EntityId();
+        }
+
+        return m_focusedInstance->get().GetContainerEntityId();
+    }
+
     bool PrefabFocusHandler::IsOwningPrefabBeingFocused(AZ::EntityId entityId) const
     {
         if (!m_focusedInstance.has_value())
@@ -196,8 +230,11 @@ namespace AzToolsFramework::Prefab
             Initialize();
         }
 
+        // Clear the old focus vector
+        m_instanceFocusVector.clear();
+
         // Focus on the root prefab (AZ::EntityId() will default to it)
-        FocusOnOwningPrefab(AZ::EntityId());
+        FocusOnPrefabInstanceOwningEntityId(AZ::EntityId());
     }
 
     void PrefabFocusHandler::RefreshInstanceFocusList()
@@ -230,7 +267,7 @@ namespace AzToolsFramework::Prefab
         {
             if (instance.has_value())
             {
-                m_containerEntityInterface->SetContainerOpenState(instance->get().GetContainerEntityId(), true);
+                m_containerEntityInterface->SetContainerOpen(instance->get().GetContainerEntityId(), true);
             }
         }
     }
@@ -241,7 +278,7 @@ namespace AzToolsFramework::Prefab
         {
             if (instance.has_value())
             {
-                m_containerEntityInterface->SetContainerOpenState(instance->get().GetContainerEntityId(), false);
+                m_containerEntityInterface->SetContainerOpen(instance->get().GetContainerEntityId(), false);
             }
         }
     }

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

@@ -13,6 +13,7 @@
 #include <AzToolsFramework/Entity/EditorEntityContextBus.h>
 #include <AzToolsFramework/FocusMode/FocusModeInterface.h>
 #include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
+#include <AzToolsFramework/Prefab/PrefabFocusPublicInterface.h>
 #include <AzToolsFramework/Prefab/Template/Template.h>
 
 namespace AzToolsFramework
@@ -28,6 +29,7 @@ namespace AzToolsFramework::Prefab
     //! Handles Prefab Focus mode, determining which prefab file entity changes will target.
     class PrefabFocusHandler final
         : private PrefabFocusInterface
+        , private PrefabFocusPublicInterface
         , private EditorEntityContextNotificationBus::Handler
     {
     public:
@@ -39,10 +41,14 @@ namespace AzToolsFramework::Prefab
         void Initialize();
 
         // PrefabFocusInterface overrides ...
-        PrefabFocusOperationResult FocusOnOwningPrefab(AZ::EntityId entityId) override;
-        PrefabFocusOperationResult FocusOnPathIndex(AzFramework::EntityContextId entityContextId, int index) override;
+        PrefabFocusOperationResult FocusOnPrefabInstanceOwningEntityId(AZ::EntityId entityId) override;
         TemplateId GetFocusedPrefabTemplateId(AzFramework::EntityContextId entityContextId) const override;
         InstanceOptionalReference GetFocusedPrefabInstance(AzFramework::EntityContextId entityContextId) const override;
+
+        // PrefabFocusPublicInterface overrides ...
+        PrefabFocusOperationResult FocusOnOwningPrefab(AZ::EntityId entityId) override;
+        PrefabFocusOperationResult FocusOnPathIndex(AzFramework::EntityContextId entityContextId, int index) override;
+        AZ::EntityId GetFocusedPrefabContainerEntityId(AzFramework::EntityContextId entityContextId) const override;
         bool IsOwningPrefabBeingFocused(AZ::EntityId entityId) const override;
         const AZ::IO::Path& GetPrefabFocusPath(AzFramework::EntityContextId entityContextId) const override;
         const int GetPrefabFocusPathLength(AzFramework::EntityContextId entityContextId) const override;

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

@@ -20,7 +20,7 @@ namespace AzToolsFramework::Prefab
 {
     using PrefabFocusOperationResult = AZ::Outcome<void, AZStd::string>;
 
-    //! Interface to handle operations related to the Prefab Focus system.
+    //! Interface to handle internal operations related to the Prefab Focus system.
     class PrefabFocusInterface
     {
     public:
@@ -28,29 +28,13 @@ namespace AzToolsFramework::Prefab
 
         //! 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;
-
-        //! Set the focused prefab instance to the instance at position index of the current path.
-        //! @param index The index of the instance in the current path that we want the prefab system to focus on.
-        virtual PrefabFocusOperationResult FocusOnPathIndex(AzFramework::EntityContextId entityContextId, int index) = 0;
+        virtual PrefabFocusOperationResult FocusOnPrefabInstanceOwningEntityId(AZ::EntityId entityId) = 0;
 
         //! Returns the template id of the instance the prefab system is focusing on.
         virtual TemplateId GetFocusedPrefabTemplateId(AzFramework::EntityContextId entityContextId) const = 0;
 
         //! Returns a reference to the instance the prefab system is focusing on.
         virtual InstanceOptionalReference GetFocusedPrefabInstance(AzFramework::EntityContextId entityContextId) const = 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) const = 0;
-
-        //! Returns the path from the root instance to the currently focused instance.
-        //! @return A path composed from the names of the container entities for the instance path.
-        virtual const AZ::IO::Path& GetPrefabFocusPath(AzFramework::EntityContextId entityContextId) const = 0;
-
-        //! Returns the size of the path to the currently focused instance.
-        virtual const int GetPrefabFocusPathLength(AzFramework::EntityContextId entityContextId) const = 0;
     };
 
 } // namespace AzToolsFramework::Prefab

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabFocusPublicInterface.h

@@ -0,0 +1,53 @@
+/*
+ * 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 <AzFramework/Entity/EntityContext.h>
+
+#include <AzToolsFramework/Prefab/Instance/Instance.h>
+#include <AzToolsFramework/Prefab/Template/Template.h>
+
+namespace AzToolsFramework::Prefab
+{
+    using PrefabFocusOperationResult = AZ::Outcome<void, AZStd::string>;
+
+    //! Public Interface for external systems to utilize the Prefab Focus system.
+    class PrefabFocusPublicInterface
+    {
+    public:
+        AZ_RTTI(PrefabFocusPublicInterface, "{53EE1D18-A41F-4DB1-9B73-9448F425722E}");
+
+        //! Set the focused prefab instance to the owning instance of the entityId provided. Supports undo/redo.
+        //! @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;
+
+        //! Set the focused prefab instance to the instance at position index of the current path. Supports undo/redo.
+        //! @param index The index of the instance in the current path that we want the prefab system to focus on.
+        virtual PrefabFocusOperationResult FocusOnPathIndex(AzFramework::EntityContextId entityContextId, int index) = 0;
+
+        //! Returns the entity id of the container entity for the instance the prefab system is focusing on.
+        virtual AZ::EntityId GetFocusedPrefabContainerEntityId(AzFramework::EntityContextId entityContextId) const = 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) const = 0;
+
+        //! Returns the path from the root instance to the currently focused instance.
+        //! @return A path composed from the names of the container entities for the instance path.
+        virtual const AZ::IO::Path& GetPrefabFocusPath(AzFramework::EntityContextId entityContextId) const = 0;
+
+        //! Returns the size of the path to the currently focused instance.
+        virtual const int GetPrefabFocusPathLength(AzFramework::EntityContextId entityContextId) const = 0;
+    };
+
+} // namespace AzToolsFramework::Prefab

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabFocusUndo.cpp

@@ -0,0 +1,52 @@
+/*
+ * 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/PrefabFocusUndo.h>
+
+#include <AzCore/Interface/Interface.h>
+#include <AzToolsFramework/Entity/EditorEntityContextBus.h>
+#include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
+#include <AzToolsFramework/Prefab/PrefabFocusPublicInterface.h>
+
+namespace AzToolsFramework::Prefab
+{
+    PrefabFocusUndo::PrefabFocusUndo(const AZStd::string& undoOperationName)
+        : UndoSystem::URSequencePoint(undoOperationName)
+    {
+        m_prefabFocusInterface = AZ::Interface<PrefabFocusInterface>::Get();
+        AZ_Assert(m_prefabFocusInterface, "PrefabFocusUndo - Failed to grab prefab focus interface");
+
+        m_prefabFocusPublicInterface = AZ::Interface<PrefabFocusPublicInterface>::Get();
+        AZ_Assert(m_prefabFocusPublicInterface, "PrefabFocusUndo - Failed to grab prefab focus public interface");
+    }
+
+    bool PrefabFocusUndo::Changed() const
+    {
+        return true;
+    }
+
+    void PrefabFocusUndo::Capture(AZ::EntityId entityId)
+    {
+        auto entityContextId = AzFramework::EntityContextId::CreateNull();
+        EditorEntityContextRequestBus::BroadcastResult(entityContextId, &EditorEntityContextRequests::GetEditorEntityContextId);
+
+        m_beforeEntityId = m_prefabFocusPublicInterface->GetFocusedPrefabContainerEntityId(entityContextId);
+        m_afterEntityId = entityId;
+    }
+
+    void PrefabFocusUndo::Undo()
+    {
+        m_prefabFocusInterface->FocusOnPrefabInstanceOwningEntityId(m_beforeEntityId);
+    }
+
+    void PrefabFocusUndo::Redo()
+    {
+        m_prefabFocusInterface->FocusOnPrefabInstanceOwningEntityId(m_afterEntityId);
+    }
+
+} // namespace AzToolsFramework::Prefab

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabFocusUndo.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Component/EntityId.h>
+#include <AzToolsFramework/Undo/UndoSystem.h>
+
+namespace AzToolsFramework::Prefab
+{
+    class PrefabFocusInterface;
+    class PrefabFocusPublicInterface;
+
+    //! Undo node for prefab focus change operations.
+    class PrefabFocusUndo
+        : public UndoSystem::URSequencePoint
+    {
+    public:
+        explicit PrefabFocusUndo(const AZStd::string& undoOperationName);
+
+        bool Changed() const override;
+        void Capture(AZ::EntityId entityId);
+
+        void Undo() override;
+        void Redo() override;
+
+    protected:
+        PrefabFocusInterface* m_prefabFocusInterface = nullptr;
+        PrefabFocusPublicInterface* m_prefabFocusPublicInterface = nullptr;
+
+        AZ::EntityId m_beforeEntityId;
+        AZ::EntityId m_afterEntityId;
+    };
+} // namespace AzToolsFramework::Prefab

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp

@@ -43,6 +43,12 @@ namespace AzToolsFramework
             m_instanceToTemplateInterface = AZ::Interface<InstanceToTemplateInterface>::Get();
             AZ_Assert(m_instanceToTemplateInterface, "PrefabPublicHandler - Could not retrieve instance of InstanceToTemplateInterface");
 
+            m_prefabFocusInterface = AZ::Interface<PrefabFocusInterface>::Get();
+            AZ_Assert(m_prefabFocusInterface, "Could not get PrefabFocusInterface on PrefabPublicHandler construction.");
+
+            m_prefabFocusPublicInterface = AZ::Interface<PrefabFocusPublicInterface>::Get();
+            AZ_Assert(m_prefabFocusPublicInterface, "Could not get PrefabFocusPublicInterface on PrefabPublicHandler construction.");
+
             m_prefabLoaderInterface = AZ::Interface<PrefabLoaderInterface>::Get();
             AZ_Assert(m_prefabLoaderInterface, "Could not get PrefabLoaderInterface on PrefabPublicHandler construction.");
 
@@ -257,9 +263,10 @@ namespace AzToolsFramework
 
                 // Select Container Entity
                 {
-                    auto selectionUndo = aznew SelectionCommand({ containerEntityId }, "Select Prefab Container Entity");
+                    const EntityIdList selectedEntities = EntityIdList{ containerEntityId };
+                    auto selectionUndo = aznew SelectionCommand(selectedEntities, "Select Prefab Container Entity");
                     selectionUndo->SetParent(undoBatch.GetUndoBatch());
-                    ToolsApplicationRequestBus::Broadcast(&ToolsApplicationRequestBus::Events::RunRedoSeparately, selectionUndo);
+                    ToolsApplicationRequestBus::Broadcast(&ToolsApplicationRequestBus::Events::SetSelectedEntities, selectedEntities);
                 }
             }
 
@@ -551,6 +558,13 @@ namespace AzToolsFramework
 
         PrefabEntityResult PrefabPublicHandler::CreateEntity(AZ::EntityId parentId, const AZ::Vector3& position)
         {
+            // If the parent is invalid, parent to the container of the currently focused prefab.
+            if (!parentId.IsValid())
+            {
+                AzFramework::EntityContextId editorEntityContextId = AzToolsFramework::GetEntityContextId();
+                parentId = m_prefabFocusPublicInterface->GetFocusedPrefabContainerEntityId(editorEntityContextId);
+            }
+
             InstanceOptionalReference owningInstanceOfParentEntity = GetOwnerInstanceByEntityId(parentId);
             if (!owningInstanceOfParentEntity)
             {
@@ -967,13 +981,13 @@ namespace AzToolsFramework
                 return AZ::Failure(AZStd::string("No entities to duplicate."));
             }
 
-            const EntityIdList entityIdsNoLevelInstance = GenerateEntityIdListWithoutLevelInstance(entityIds);
-            if (entityIdsNoLevelInstance.empty())
+            const EntityIdList entityIdsNoFocusContainer = GenerateEntityIdListWithoutFocusedInstanceContainer(entityIds);
+            if (entityIdsNoFocusContainer.empty())
             {
-                return AZ::Failure(AZStd::string("No entities to duplicate because only instance selected is the level instance."));
+                return AZ::Failure(AZStd::string("No entities to duplicate because only instance selected is the container entity of the focused instance."));
             }
 
-            if (!EntitiesBelongToSameInstance(entityIdsNoLevelInstance))
+            if (!EntitiesBelongToSameInstance(entityIdsNoFocusContainer))
             {
                 return AZ::Failure(AZStd::string("Cannot duplicate multiple entities belonging to different instances with one operation."
                     "Change your selection to contain entities in the same instance."));
@@ -981,7 +995,7 @@ namespace AzToolsFramework
 
             // We've already verified the entities are all owned by the same instance,
             // so we can just retrieve our instance from the first entity in the list.
-            AZ::EntityId firstEntityIdToDuplicate = entityIdsNoLevelInstance[0];
+            AZ::EntityId firstEntityIdToDuplicate = entityIdsNoFocusContainer[0];
             InstanceOptionalReference commonOwningInstance = GetOwnerInstanceByEntityId(firstEntityIdToDuplicate);
             if (!commonOwningInstance.has_value())
             {
@@ -1001,7 +1015,7 @@ namespace AzToolsFramework
 
             // This will cull out any entities that have ancestors in the list, since we will end up duplicating
             // the full nested hierarchy with what is returned from RetrieveAndSortPrefabEntitiesAndInstances
-            AzToolsFramework::EntityIdSet duplicationSet = AzToolsFramework::GetCulledEntityHierarchy(entityIdsNoLevelInstance);
+            AzToolsFramework::EntityIdSet duplicationSet = AzToolsFramework::GetCulledEntityHierarchy(entityIdsNoFocusContainer);
 
             AZ_PROFILE_FUNCTION(AzToolsFramework);
 
@@ -1038,10 +1052,10 @@ namespace AzToolsFramework
                 DuplicateNestedEntitiesInInstance(commonOwningInstance->get(),
                     entities, instanceDomAfter, duplicatedEntityAndInstanceIds, duplicateEntityAliasMap);
 
-                PrefabUndoInstance* command = aznew PrefabUndoInstance("Entity/Instance duplication");
+                PrefabUndoInstance* command = aznew PrefabUndoInstance("Entity/Instance duplication", false);
                 command->SetParent(undoBatch.GetUndoBatch());
                 command->Capture(instanceDomBefore, instanceDomAfter, commonOwningInstance->get().GetTemplateId());
-                command->RedoBatched();
+                command->Redo();
 
                 DuplicateNestedInstancesInInstance(commonOwningInstance->get(),
                     instances, instanceDomAfter, duplicatedEntityAndInstanceIds, newInstanceAliasToOldInstanceMap);
@@ -1097,7 +1111,7 @@ namespace AzToolsFramework
                 // Select the duplicated entities/instances
                 auto selectionUndo = aznew SelectionCommand(duplicatedEntityAndInstanceIds, "Select Duplicated Entities/Instances");
                 selectionUndo->SetParent(undoBatch.GetUndoBatch());
-                ToolsApplicationRequestBus::Broadcast(&ToolsApplicationRequestBus::Events::RunRedoSeparately, selectionUndo);
+                ToolsApplicationRequestBus::Broadcast(&ToolsApplicationRequestBus::Events::SetSelectedEntities, duplicatedEntityAndInstanceIds);
             }
 
             return AZ::Success();
@@ -1105,19 +1119,21 @@ namespace AzToolsFramework
 
         PrefabOperationResult PrefabPublicHandler::DeleteFromInstance(const EntityIdList& entityIds, bool deleteDescendants)
         {
-            const EntityIdList entityIdsNoLevelInstance = GenerateEntityIdListWithoutLevelInstance(entityIds);
+            // Remove the container entity of the focused prefab from the list, if it is included.
+            const EntityIdList entityIdsNoFocusContainer = GenerateEntityIdListWithoutFocusedInstanceContainer(entityIds);
 
-            if (entityIdsNoLevelInstance.empty())
+            if (entityIdsNoFocusContainer.empty())
             {
                 return AZ::Success();
             }
 
-            if (!EntitiesBelongToSameInstance(entityIdsNoLevelInstance))
+            // All entities in this list need to belong to the same prefab instance for the operation to be valid.
+            if (!EntitiesBelongToSameInstance(entityIdsNoFocusContainer))
             {
                 return AZ::Failure(AZStd::string("Cannot delete multiple entities belonging to different instances with one operation."));
             }
 
-            AZ::EntityId firstEntityIdToDelete = entityIdsNoLevelInstance[0];
+            AZ::EntityId firstEntityIdToDelete = entityIdsNoFocusContainer[0];
             InstanceOptionalReference commonOwningInstance = GetOwnerInstanceByEntityId(firstEntityIdToDelete);
 
             // If the first entity id is a container entity id, then we need to mark its parent as the common owning instance because you
@@ -1127,8 +1143,15 @@ namespace AzToolsFramework
                 commonOwningInstance = commonOwningInstance->get().GetParentInstance();
             }
 
+            // We only allow explicit deletions for entities inside the currently focused prefab.
+            AzFramework::EntityContextId editorEntityContextId = AzToolsFramework::GetEntityContextId();
+            if (&m_prefabFocusInterface->GetFocusedPrefabInstance(editorEntityContextId)->get() != &commonOwningInstance->get())
+            {
+                return AZ::Failure(AZStd::string("Cannot delete entities belonging to an instance that is not being edited."));
+            }
+
             // Retrieve entityList from entityIds
-            EntityList inputEntityList = EntityIdListToEntityList(entityIdsNoLevelInstance);
+            EntityList inputEntityList = EntityIdListToEntityList(entityIdsNoFocusContainer);
 
             AZ_PROFILE_FUNCTION(AzToolsFramework);
 
@@ -1185,7 +1208,7 @@ namespace AzToolsFramework
                 }
                 else
                 {
-                    for (AZ::EntityId entityId : entityIdsNoLevelInstance)
+                    for (AZ::EntityId entityId : entityIdsNoFocusContainer)
                     {
                         InstanceOptionalReference owningInstance = m_instanceEntityMapperInterface->FindOwningInstance(entityId);
                         // If this is the container entity, it actually represents the instance so get its owner
@@ -1226,9 +1249,12 @@ namespace AzToolsFramework
                 return AZ::Failure(AZStd::string("Cannot detach Prefab Instance with invalid container entity."));
             }
 
-            if (IsLevelInstanceContainerEntity(containerEntityId))
+            auto editorEntityContextId = AzFramework::EntityContextId::CreateNull();
+            EditorEntityContextRequestBus::BroadcastResult(editorEntityContextId, &EditorEntityContextRequests::GetEditorEntityContextId);
+
+            if (containerEntityId == m_prefabFocusPublicInterface->GetFocusedPrefabContainerEntityId(editorEntityContextId))
             {
-                return AZ::Failure(AZStd::string("Cannot detach level Prefab Instance."));
+                return AZ::Failure(AZStd::string("Cannot detach focused Prefab Instance."));
             }
 
             InstanceOptionalReference owningInstance = GetOwnerInstanceByEntityId(containerEntityId);
@@ -1297,7 +1323,7 @@ namespace AzToolsFramework
                     Prefab::PrefabDom instanceDomAfter;
                     m_instanceToTemplateInterface->GenerateDomForInstance(instanceDomAfter, parentInstance);
 
-                    PrefabUndoInstance* command = aznew PrefabUndoInstance("Instance detachment");
+                    PrefabUndoInstance* command = aznew PrefabUndoInstance("Instance detachment", false);
                     command->Capture(instanceDomBefore, instanceDomAfter, parentTemplateId);
                     command->SetParent(undoBatch.GetUndoBatch());
                     {
@@ -1451,9 +1477,14 @@ namespace AzToolsFramework
 
             AZStd::queue<AZ::Entity*> entityQueue;
 
+            auto editorEntityContextId = AzFramework::EntityContextId::CreateNull();
+            EditorEntityContextRequestBus::BroadcastResult(editorEntityContextId, &EditorEntityContextRequests::GetEditorEntityContextId);
+
+            AZ::EntityId focusedPrefabContainerEntityId =
+                m_prefabFocusPublicInterface->GetFocusedPrefabContainerEntityId(editorEntityContextId);
             for (auto inputEntity : inputEntities)
             {
-                if (inputEntity && !IsLevelInstanceContainerEntity(inputEntity->GetId()))
+                if (inputEntity && inputEntity->GetId() != focusedPrefabContainerEntityId)
                 {
                     entityQueue.push(inputEntity);
                 }
@@ -1547,19 +1578,19 @@ namespace AzToolsFramework
             return AZ::Success();
         }
 
-        EntityIdList PrefabPublicHandler::GenerateEntityIdListWithoutLevelInstance(
+        EntityIdList PrefabPublicHandler::GenerateEntityIdListWithoutFocusedInstanceContainer(
             const EntityIdList& entityIds) const
         {
-            EntityIdList outEntityIds;
-            outEntityIds.reserve(entityIds.size()); // Actual size could be smaller.
+            EntityIdList outEntityIds(entityIds);
 
-            for (const AZ::EntityId& entityId : entityIds)
+            AzFramework::EntityContextId editorEntityContextId = AzToolsFramework::GetEntityContextId();
+            AZ::EntityId focusedInstanceContainerEntityId = m_prefabFocusPublicInterface->GetFocusedPrefabContainerEntityId(editorEntityContextId);
+
+            if (auto iter = AZStd::find(outEntityIds.begin(), outEntityIds.end(), focusedInstanceContainerEntityId); iter != outEntityIds.end())
             {
-                if (!IsLevelInstanceContainerEntity(entityId))
-                {
-                    outEntityIds.emplace_back(entityId);
-                }
+                outEntityIds.erase(iter);
             }
+            
             return outEntityIds;
         }
 

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

@@ -74,7 +74,7 @@ namespace AzToolsFramework
                 Instance& commonRootEntityOwningInstance,
                 EntityList& outEntities,
                 AZStd::vector<Instance*>& outInstances) const;
-            EntityIdList GenerateEntityIdListWithoutLevelInstance(const EntityIdList& entityIds) const;
+            EntityIdList GenerateEntityIdListWithoutFocusedInstanceContainer(const EntityIdList& entityIds) const;
 
             InstanceOptionalReference GetOwnerInstanceByEntityId(AZ::EntityId entityId) const;
             bool EntitiesBelongToSameInstance(const EntityIdList& entityIds) const;
@@ -187,6 +187,8 @@ namespace AzToolsFramework
 
             InstanceEntityMapperInterface* m_instanceEntityMapperInterface = nullptr;
             InstanceToTemplateInterface* m_instanceToTemplateInterface = nullptr;
+            PrefabFocusInterface* m_prefabFocusInterface = nullptr;
+            PrefabFocusPublicInterface* m_prefabFocusPublicInterface = nullptr;
             PrefabLoaderInterface* m_prefabLoaderInterface = nullptr;
             PrefabSystemComponentInterface* m_prefabSystemComponentInterface = nullptr;
 

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabSystemScriptingHandler.cpp

@@ -6,11 +6,14 @@
  *
  */
 
+#include <API/ToolsApplicationAPI.h>
 #include <AzCore/Component/ComponentApplicationBus.h>
 #include <AzCore/RTTI/BehaviorContext.h>
 #include <Prefab/PrefabSystemComponentInterface.h>
 #include <Prefab/PrefabSystemScriptingHandler.h>
 #include <AzCore/Component/Entity.h>
+#include <Prefab/EditorPrefabComponent.h>
+#include <ToolsComponents/TransformComponent.h>
 
 namespace AzToolsFramework::Prefab
 {
@@ -61,9 +64,30 @@ namespace AzToolsFramework::Prefab
                 entities.push_back(entity);
             }
         }
-        
-        auto prefab = m_prefabSystemComponentInterface->CreatePrefab(entities, {}, AZ::IO::PathView(AZStd::string_view(filePath)));
 
+        bool result = false;
+        [[maybe_unused]] AZ::EntityId commonRoot;
+        EntityList topLevelEntities;
+        AzToolsFramework::ToolsApplicationRequestBus::BroadcastResult(result, &AzToolsFramework::ToolsApplicationRequestBus::Events::FindCommonRootInactive,
+            entities, commonRoot, &topLevelEntities);
+
+        auto containerEntity = AZStd::make_unique<AZ::Entity>();
+        containerEntity->CreateComponent<Prefab::EditorPrefabComponent>();
+
+        for (AZ::Entity* entity : topLevelEntities)
+        {
+            AzToolsFramework::Components::TransformComponent* transformComponent =
+                entity->FindComponent<AzToolsFramework::Components::TransformComponent>();
+
+            if (transformComponent)
+            {
+                transformComponent->SetParent(containerEntity->GetId());
+            }
+        }
+
+        auto prefab = m_prefabSystemComponentInterface->CreatePrefab(
+            entities, {}, AZ::IO::PathView(AZStd::string_view(filePath)), AZStd::move(containerEntity));
+        
         if (!prefab)
         {
             AZ_Error("PrefabSystemComponenent", false, "Failed to create prefab %s", filePath.c_str());

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabUndo.cpp

@@ -17,17 +17,16 @@ namespace AzToolsFramework
     {
         PrefabUndoBase::PrefabUndoBase(const AZStd::string& undoOperationName)
             : UndoSystem::URSequencePoint(undoOperationName)
-            , m_changed(true)
-            , m_templateId(InvalidTemplateId)
         {
             m_instanceToTemplateInterface = AZ::Interface<InstanceToTemplateInterface>::Get();
             AZ_Assert(m_instanceToTemplateInterface, "Failed to grab instance to template interface");
         }
 
         //PrefabInstanceUndo
-        PrefabUndoInstance::PrefabUndoInstance(const AZStd::string& undoOperationName)
+        PrefabUndoInstance::PrefabUndoInstance(const AZStd::string& undoOperationName, const bool useImmediatePropagation)
             : PrefabUndoBase(undoOperationName)
         {
+            m_useImmediatePropagation = useImmediatePropagation;
         }
 
         void PrefabUndoInstance::Capture(
@@ -43,17 +42,12 @@ namespace AzToolsFramework
 
         void PrefabUndoInstance::Undo()
         {
-            m_instanceToTemplateInterface->PatchTemplate(m_undoPatch, m_templateId, true);
+            m_instanceToTemplateInterface->PatchTemplate(m_undoPatch, m_templateId, m_useImmediatePropagation);
         }
 
         void PrefabUndoInstance::Redo()
         {
-            m_instanceToTemplateInterface->PatchTemplate(m_redoPatch, m_templateId, true);
-        }
-
-        void PrefabUndoInstance::RedoBatched()
-        {
-            m_instanceToTemplateInterface->PatchTemplate(m_redoPatch, m_templateId);
+            m_instanceToTemplateInterface->PatchTemplate(m_redoPatch, m_templateId, m_useImmediatePropagation);
         }
 
 

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabUndo.h

@@ -29,14 +29,15 @@ namespace AzToolsFramework
             bool Changed() const override { return m_changed; }
 
         protected:
-            TemplateId m_templateId;
+            TemplateId m_templateId = InvalidTemplateId;
 
             PrefabDom m_redoPatch;
             PrefabDom m_undoPatch;
 
             InstanceToTemplateInterface* m_instanceToTemplateInterface = nullptr;
 
-            bool m_changed;
+            bool m_changed = true;
+            bool m_useImmediatePropagation = true;
         };
 
         //! handles the addition and removal of entities from instances
@@ -44,7 +45,7 @@ namespace AzToolsFramework
             : public PrefabUndoBase
         {
         public:
-            explicit PrefabUndoInstance(const AZStd::string& undoOperationName);
+            explicit PrefabUndoInstance(const AZStd::string& undoOperationName, const bool useImmediatePropagation = true);
 
             void Capture(
                 const PrefabDom& initialState,
@@ -53,7 +54,6 @@ namespace AzToolsFramework
 
             void Undo() override;
             void Redo() override;
-            void RedoBatched();
         };
 
         //! handles entity updates, such as when the values on an entity change

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabUndoHelpers.cpp

@@ -23,10 +23,10 @@ namespace AzToolsFramework
                 PrefabDom instanceDomAfterUpdate;
                 PrefabDomUtils::StoreInstanceInPrefabDom(instance, instanceDomAfterUpdate);
 
-                PrefabUndoInstance* state = aznew Prefab::PrefabUndoInstance(undoMessage);
+                PrefabUndoInstance* state = aznew Prefab::PrefabUndoInstance(undoMessage, false);
                 state->Capture(instanceDomBeforeUpdate, instanceDomAfterUpdate, instance.GetTemplateId());
                 state->SetParent(undoBatch);
-                state->RedoBatched();
+                state->Redo();
             }
 
             LinkId CreateLink(

Code/Framework/AzToolsFramework/AzToolsFramework/Thumbnails/ThumbnailerBus.h

@@ -90,7 +90,7 @@ namespace AzToolsFramework
             typedef SharedThumbnailKey BusIdType;
 
             //! notify product thumbnail that the data is ready
-            virtual void ThumbnailRendered(QPixmap& thumbnailImage) = 0;
+            virtual void ThumbnailRendered(const QPixmap& thumbnailImage) = 0;
             //! notify product thumbnail that the thumbnail failed to render
             virtual void ThumbnailFailedToRender() = 0;
         };

Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/ScriptEditorComponent.cpp

@@ -1025,7 +1025,7 @@ namespace AzToolsFramework
                         ->Attribute(AZ::Edit::Attributes::ViewportIcon, "Icons/Components/Viewport/LuaScript.svg")
                         ->Attribute(AZ::Edit::Attributes::PrimaryAssetType, AZ::AzTypeInfo<AZ::ScriptAsset>::Uuid())
                         ->Attribute(AZ::Edit::Attributes::ViewportIcon, "Icons/Components/Viewport/Script.png")
-                        ->Attribute(AZ::Edit::Attributes::HelpPageURL, "https://o3de.org/docs/user-guide/components/reference/lua-script/")
+                        ->Attribute(AZ::Edit::Attributes::HelpPageURL, "https://o3de.org/docs/user-guide/components/reference/scripting/lua-script/")
                         ->DataElement("AssetRef", &ScriptEditorComponent::m_scriptAsset, "Script", "Which script to use")
                             ->Attribute(AZ::Edit::Attributes::ChangeNotify, &ScriptEditorComponent::ScriptHasChanged)
                             ->Attribute("BrowseIcon", ":/stylesheet/img/UI20/browse-edit-select-files.svg")

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Outliner/EntityOutlinerTreeView.cpp

@@ -313,7 +313,8 @@ namespace AzToolsFramework
         StyledTreeView::StartCustomDrag(indexListSorted, supportedActions);
     }
 
-    void EntityOutlinerTreeView::OnEditorFocusChanged([[maybe_unused]] AZ::EntityId entityId)
+    void EntityOutlinerTreeView::OnEditorFocusChanged(
+        [[maybe_unused]] AZ::EntityId previousFocusEntityId, [[maybe_unused]] AZ::EntityId newFocusEntityId)
     {
         viewport()->repaint();
     }

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Outliner/EntityOutlinerTreeView.hxx

@@ -64,7 +64,7 @@ namespace AzToolsFramework
         void leaveEvent(QEvent* event) override;
 
         // FocusModeNotificationBus overrides ...
-        void OnEditorFocusChanged(AZ::EntityId entityId) override;
+        void OnEditorFocusChanged(AZ::EntityId previousFocusEntityId, AZ::EntityId newFocusEntityId) override;
 
         //! Renders the left side of the item: appropriate background, branch lines, icons.
         void drawBranches(QPainter* painter, const QRect& rect, const QModelIndex& index) const override;

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Outliner/EntityOutlinerWidget.cpp

@@ -26,6 +26,7 @@
 #include <AzToolsFramework/Entity/EditorEntityContextBus.h>
 #include <AzToolsFramework/Entity/EditorEntityHelpers.h>
 #include <AzToolsFramework/Entity/EditorEntityInfoBus.h>
+#include <AzToolsFramework/Viewport/ViewportMessages.h>
 #include <AzToolsFramework/UI/ComponentPalette/ComponentPaletteUtil.hxx>
 #include <AzToolsFramework/UI/EditorEntityUi/EditorEntityUiHandlerBase.h>
 #include <AzToolsFramework/UI/Outliner/EntityOutlinerDisplayOptionsMenu.h>
@@ -292,8 +293,7 @@ namespace AzToolsFramework
         EntityOutlinerModelNotificationBus::Handler::BusConnect();
         ToolsApplicationEvents::Bus::Handler::BusConnect();
         EditorEntityContextNotificationBus::Handler::BusConnect();
-        ComponentModeFramework::EditorComponentModeNotificationBus::Handler::BusConnect(
-            GetEntityContextId());
+        ViewportEditorModeNotificationsBus::Handler::BusConnect(GetEntityContextId());
         EditorEntityInfoNotificationBus::Handler::BusConnect();
         Prefab::PrefabPublicNotificationBus::Handler::BusConnect();
         EditorWindowUIRequestBus::Handler::BusConnect();
@@ -303,7 +303,7 @@ namespace AzToolsFramework
     {
         EditorWindowUIRequestBus::Handler::BusDisconnect();
         Prefab::PrefabPublicNotificationBus::Handler::BusDisconnect();
-        ComponentModeFramework::EditorComponentModeNotificationBus::Handler::BusDisconnect();
+        ViewportEditorModeNotificationsBus::Handler::BusDisconnect();
         EditorEntityInfoNotificationBus::Handler::BusDisconnect();
         EditorPickModeNotificationBus::Handler::BusDisconnect();
         EntityHighlightMessages::Bus::Handler::BusDisconnect();
@@ -324,7 +324,8 @@ namespace AzToolsFramework
     //  Currently, the first behavior is implemented.
     void EntityOutlinerWidget::OnSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected)
     {
-        if (m_selectionChangeInProgress || !m_enableSelectionUpdates)
+        if (m_selectionChangeInProgress || !m_enableSelectionUpdates
+            || (selected.empty() && deselected.empty()))
         {
             return;
         }
@@ -552,6 +553,13 @@ namespace AzToolsFramework
             return;
         }
 
+        // Do not display the context menu if the item under the mouse cursor is not selectable.
+        if (const QModelIndex& index = m_gui->m_objectTree->indexAt(pos); index.isValid()
+            && (index.flags() & Qt::ItemIsSelectable) == 0)
+        {
+            return;
+        }
+
         QMenu* contextMenu = new QMenu(this);
 
         // Populate global context menu.
@@ -1128,14 +1136,22 @@ namespace AzToolsFramework
         EnableUi(enable);
     }
 
-    void EntityOutlinerWidget::EnteredComponentMode([[maybe_unused]] const AZStd::vector<AZ::Uuid>& componentModeTypes)
+    void EntityOutlinerWidget::OnEditorModeActivated(
+        [[maybe_unused]] const AzToolsFramework::ViewportEditorModesInterface& editorModeState, AzToolsFramework::ViewportEditorMode mode)
     {
-        EnableUi(false);
+        if (mode == ViewportEditorMode::Component)
+        {
+            EnableUi(false);
+        }
     }
 
-    void EntityOutlinerWidget::LeftComponentMode([[maybe_unused]] const AZStd::vector<AZ::Uuid>& componentModeTypes)
+    void EntityOutlinerWidget::OnEditorModeDeactivated(
+        [[maybe_unused]] const AzToolsFramework::ViewportEditorModesInterface& editorModeState, AzToolsFramework::ViewportEditorMode mode)
     {
-        EnableUi(true);
+        if (mode == ViewportEditorMode::Component)
+        {
+            EnableUi(true);
+        }
     }
 
     void EntityOutlinerWidget::OnPrefabInstancePropagationBegin()

Code/Framework/AzToolsFramework/AzToolsFramework/UI/Outliner/EntityOutlinerWidget.hxx

@@ -14,7 +14,7 @@
 
 #include <AzToolsFramework/API/EditorWindowRequestBus.h>
 #include <AzToolsFramework/API/ToolsApplicationAPI.h>
-#include <AzToolsFramework/ComponentMode/EditorComponentModeBus.h>
+#include <AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h>
 #include <AzToolsFramework/Entity/EditorEntityInfoBus.h>
 #include <AzToolsFramework/Entity/EditorEntityContextBus.h>
 #include <AzToolsFramework/Prefab/PrefabPublicNotificationBus.h>
@@ -59,7 +59,7 @@ namespace AzToolsFramework
         , private ToolsApplicationEvents::Bus::Handler
         , private EditorEntityContextNotificationBus::Handler
         , private EditorEntityInfoNotificationBus::Handler
-        , private ComponentModeFramework::EditorComponentModeNotificationBus::Handler
+        , private ViewportEditorModeNotificationsBus::Handler
         , private Prefab::PrefabPublicNotificationBus::Handler
         , private EditorWindowUIRequestBus::Handler
     {
@@ -101,9 +101,11 @@ namespace AzToolsFramework
         void OnEntityInfoUpdatedAddChildEnd(AZ::EntityId /*parentId*/, AZ::EntityId /*childId*/) override;
         void OnEntityInfoUpdatedName(AZ::EntityId entityId, const AZStd::string& /*name*/) override;
 
-        // EditorComponentModeNotificationBus
-        void EnteredComponentMode(const AZStd::vector<AZ::Uuid>& componentModeTypes) override;
-        void LeftComponentMode(const AZStd::vector<AZ::Uuid>& componentModeTypes) override;
+        // ViewportEditorModeNotificationsBus overrides ...
+        void OnEditorModeActivated(
+            const AzToolsFramework::ViewportEditorModesInterface& editorModeState, AzToolsFramework::ViewportEditorMode mode) override;
+        void OnEditorModeDeactivated(
+            const AzToolsFramework::ViewportEditorModesInterface& editorModeState, AzToolsFramework::ViewportEditorMode mode) override;
 
         // PrefabPublicNotificationBus
         void OnPrefabInstancePropagationBegin() override;

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

@@ -24,11 +24,12 @@
 #include <AzToolsFramework/AssetBrowser/AssetSelectionModel.h>
 #include <AzToolsFramework/AssetBrowser/Entries/SourceAssetBrowserEntry.h>
 #include <AzToolsFramework/ContainerEntity/ContainerEntityInterface.h>
-#include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
+#include <AzToolsFramework/Entity/EditorEntityContextBus.h>
+#include <AzToolsFramework/Prefab/EditorPrefabComponent.h>
+#include <AzToolsFramework/Prefab/Instance/InstanceEntityMapperInterface.h>
+#include <AzToolsFramework/Prefab/PrefabFocusPublicInterface.h>
 #include <AzToolsFramework/Prefab/PrefabLoaderInterface.h>
 #include <AzToolsFramework/Prefab/Procedural/ProceduralPrefabAsset.h>
-#include <AzToolsFramework/Prefab/Instance/InstanceEntityMapperInterface.h>
-#include <AzToolsFramework/Prefab/EditorPrefabComponent.h>
 #include <AzToolsFramework/ToolsComponents/EditorLayerComponentBus.h>
 #include <AzToolsFramework/UI/EditorEntityUi/EditorEntityUiInterface.h>
 #include <AzToolsFramework/UI/Prefab/PrefabIntegrationInterface.h>
@@ -39,7 +40,6 @@
 #include <AzQtComponents/Components/StyleManager.h>
 #include <AzQtComponents/Components/Widgets/CardHeader.h>
 
-
 #include <QApplication>
 #include <QCheckBox>
 #include <QDialog>
@@ -56,14 +56,13 @@
 #include <QVBoxLayout>
 #include <QWidget>
 
-
 namespace AzToolsFramework
 {
     namespace Prefab
     {
         ContainerEntityInterface* PrefabIntegrationManager::s_containerEntityInterface = nullptr;
         EditorEntityUiInterface* PrefabIntegrationManager::s_editorEntityUiInterface = nullptr;
-        PrefabFocusInterface* PrefabIntegrationManager::s_prefabFocusInterface = nullptr;
+        PrefabFocusPublicInterface* PrefabIntegrationManager::s_prefabFocusPublicInterface = nullptr;
         PrefabLoaderInterface* PrefabIntegrationManager::s_prefabLoaderInterface = nullptr;
         PrefabPublicInterface* PrefabIntegrationManager::s_prefabPublicInterface = nullptr;
         PrefabSystemComponentInterface* PrefabIntegrationManager::s_prefabSystemComponentInterface = nullptr;
@@ -129,14 +128,15 @@ namespace AzToolsFramework
                 return;
             }
 
-            s_prefabFocusInterface = AZ::Interface<PrefabFocusInterface>::Get();
-            if (s_prefabFocusInterface == nullptr)
+            s_prefabFocusPublicInterface = AZ::Interface<PrefabFocusPublicInterface>::Get();
+            if (s_prefabFocusPublicInterface == nullptr)
             {
-                AZ_Assert(false, "Prefab - could not get PrefabFocusInterface on PrefabIntegrationManager construction.");
+                AZ_Assert(false, "Prefab - could not get PrefabFocusPublicInterface on PrefabIntegrationManager construction.");
                 return;
             }
 
             EditorContextMenuBus::Handler::BusConnect();
+            EditorEventsBus::Handler::BusConnect();
             PrefabInstanceContainerNotificationBus::Handler::BusConnect();
             AZ::Interface<PrefabIntegrationInterface>::Register(this);
             AssetBrowser::AssetBrowserSourceDropBus::Handler::BusConnect(s_prefabFileExtension);
@@ -147,6 +147,7 @@ namespace AzToolsFramework
             AssetBrowser::AssetBrowserSourceDropBus::Handler::BusDisconnect();
             AZ::Interface<PrefabIntegrationInterface>::Unregister(this);
             PrefabInstanceContainerNotificationBus::Handler::BusDisconnect();
+            EditorEventsBus::Handler::BusDisconnect();
             EditorContextMenuBus::Handler::BusDisconnect();
         }
 
@@ -175,12 +176,16 @@ namespace AzToolsFramework
             AzFramework::ApplicationRequests::Bus::BroadcastResult(
                 prefabWipFeaturesEnabled, &AzFramework::ApplicationRequests::ArePrefabWipFeaturesEnabled);
 
+            auto editorEntityContextId = AzFramework::EntityContextId::CreateNull();
+            EditorEntityContextRequestBus::BroadcastResult(editorEntityContextId, &EditorEntityContextRequests::GetEditorEntityContextId);
+
             // Create Prefab
             {
                 if (!selectedEntities.empty())
                 {
-                    // Hide if the only selected entity is the Level Container
-                    if (selectedEntities.size() > 1 || !s_prefabPublicInterface->IsLevelInstanceContainerEntity(selectedEntities[0]))
+                    // Hide if the only selected entity is the Focused Instance Container
+                    if (selectedEntities.size() > 1 ||
+                        selectedEntities[0]  != s_prefabFocusPublicInterface->GetFocusedPrefabContainerEntityId(editorEntityContextId))
                     {
                         bool layerInSelection = false;
 
@@ -245,21 +250,16 @@ namespace AzToolsFramework
                     if (s_prefabPublicInterface->IsInstanceContainerEntity(selectedEntity))
                     {
                         // Edit Prefab
-                        if (prefabWipFeaturesEnabled)
+                        if (prefabWipFeaturesEnabled && !s_prefabFocusPublicInterface->IsOwningPrefabBeingFocused(selectedEntity))
                         {
-                            bool beingEdited = s_prefabFocusInterface->IsOwningPrefabBeingFocused(selectedEntity);
+                            QAction* editAction = menu->addAction(QObject::tr("Edit Prefab"));
+                            editAction->setToolTip(QObject::tr("Edit the prefab in focus mode."));
 
-                            if (!beingEdited)
-                            {
-                                QAction* editAction = menu->addAction(QObject::tr("Edit Prefab"));
-                                editAction->setToolTip(QObject::tr("Edit the prefab in focus mode."));
+                            QObject::connect(editAction, &QAction::triggered, editAction, [selectedEntity] {
+                                ContextMenu_EditPrefab(selectedEntity);
+                            });
 
-                                QObject::connect(editAction, &QAction::triggered, editAction, [selectedEntity] {
-                                    ContextMenu_EditPrefab(selectedEntity);
-                                });
-
-                                itemWasShown = true;
-                            }
+                            itemWasShown = true;
                         }
 
                         // Save Prefab
@@ -288,8 +288,9 @@ namespace AzToolsFramework
 
             QAction* deleteAction = menu->addAction(QObject::tr("Delete"));
             QObject::connect(deleteAction, &QAction::triggered, deleteAction, [] { ContextMenu_DeleteSelected(); });
-            if (selectedEntities.size() == 0 ||
-                (selectedEntities.size() == 1 && s_prefabPublicInterface->IsLevelInstanceContainerEntity(selectedEntities[0])))
+
+            if (selectedEntities.empty() ||
+                (selectedEntities.size() == 1 && selectedEntities[0] == s_prefabFocusPublicInterface->GetFocusedPrefabContainerEntityId(editorEntityContextId)))
             {
                 deleteAction->setDisabled(true);
             }
@@ -297,22 +298,27 @@ namespace AzToolsFramework
             // Detach Prefab
             if (selectedEntities.size() == 1)
             {
-                AZ::EntityId selectedEntity = selectedEntities[0];
+                AZ::EntityId selectedEntityId = selectedEntities[0];
 
-                if (s_prefabPublicInterface->IsInstanceContainerEntity(selectedEntity) &&
-                    !s_prefabPublicInterface->IsLevelInstanceContainerEntity(selectedEntity))
+                if (s_prefabPublicInterface->IsInstanceContainerEntity(selectedEntityId) &&
+                    selectedEntityId != s_prefabFocusPublicInterface->GetFocusedPrefabContainerEntityId(editorEntityContextId))
                 {
                     QAction* detachPrefabAction = menu->addAction(QObject::tr("Detach Prefab..."));
                     QObject::connect(
                         detachPrefabAction, &QAction::triggered, detachPrefabAction,
-                        [selectedEntity]
+                        [selectedEntityId]
                         {
-                            ContextMenu_DetachPrefab(selectedEntity);
+                            ContextMenu_DetachPrefab(selectedEntityId);
                         });
                 }
             }
         }
 
+        void PrefabIntegrationManager::OnEscape()
+        {
+            s_prefabFocusPublicInterface->FocusOnOwningPrefab(AZ::EntityId());
+        }
+
         void PrefabIntegrationManager::HandleSourceFileType(AZStd::string_view sourceFilePath, AZ::EntityId parentId, AZ::Vector3 position) const
         {
             auto instantiatePrefabOutcome = s_prefabPublicInterface->InstantiatePrefab(sourceFilePath, parentId, position);
@@ -331,13 +337,21 @@ namespace AzToolsFramework
             QWidget* activeWindow = QApplication::activeWindow();
             const AZStd::string prefabFilesPath = "@projectroot@/Prefabs";
 
-            // Remove Level entity if it's part of the list
-            
-            auto levelContainerIter =
-                AZStd::find(selectedEntities.begin(), selectedEntities.end(), s_prefabPublicInterface->GetLevelInstanceContainerEntityId());
-            if (levelContainerIter != selectedEntities.end())
+            // Remove focused instance container entity if it's part of the list
+            auto editorEntityContextId = AzFramework::EntityContextId::CreateNull();
+            EditorEntityContextRequestBus::BroadcastResult(editorEntityContextId, &EditorEntityContextRequests::GetEditorEntityContextId);
+
+            auto focusedContainerIter = AZStd::find(
+                selectedEntities.begin(), selectedEntities.end(),
+                s_prefabFocusPublicInterface->GetFocusedPrefabContainerEntityId(editorEntityContextId));
+            if (focusedContainerIter != selectedEntities.end())
             {
-                selectedEntities.erase(levelContainerIter);
+                selectedEntities.erase(focusedContainerIter);
+            }
+
+            if (selectedEntities.empty())
+            {
+                return;
             }
 
             // Set default folder for prefabs
@@ -483,7 +497,7 @@ namespace AzToolsFramework
 
         void PrefabIntegrationManager::ContextMenu_EditPrefab(AZ::EntityId containerEntity)
         {
-            s_prefabFocusInterface->FocusOnOwningPrefab(containerEntity);
+            s_prefabFocusPublicInterface->FocusOnOwningPrefab(containerEntity);
         }
 
         void PrefabIntegrationManager::ContextMenu_SavePrefab(AZ::EntityId containerEntity)
@@ -1393,7 +1407,7 @@ namespace AzToolsFramework
 
         AZStd::unique_ptr<AzQtComponents::Card> PrefabIntegrationManager::ConstructUnsavedPrefabsCard(TemplateId templateId)
         {
-            FlowLayout* unsavedPrefabsLayout = new FlowLayout(AzToolsFramework::GetActiveWindow());
+            FlowLayout* unsavedPrefabsLayout = new FlowLayout(nullptr);
 
             AZStd::set<AZ::IO::PathView> dirtyTemplatePaths = s_prefabSystemComponentInterface->GetDirtyTemplatePaths(templateId);
 

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

@@ -30,7 +30,7 @@ namespace AzToolsFramework
 
     namespace Prefab
     {
-        class PrefabFocusInterface;
+        class PrefabFocusPublicInterface;
         class PrefabLoaderInterface;
 
         //! Structure for saving/retrieving user settings related to prefab workflows.
@@ -51,6 +51,7 @@ namespace AzToolsFramework
 
         class PrefabIntegrationManager final
             : public EditorContextMenuBus::Handler
+            , public EditorEventsBus::Handler
             , public AssetBrowser::AssetBrowserSourceDropBus::Handler
             , public PrefabInstanceContainerNotificationBus::Handler
             , public PrefabIntegrationInterface
@@ -64,19 +65,22 @@ namespace AzToolsFramework
 
             static void Reflect(AZ::ReflectContext* context);
 
-            // EditorContextMenuBus...
+            // EditorContextMenuBus overrides ...
             int GetMenuPosition() const override;
             AZStd::string GetMenuIdentifier() const override;
             void PopulateEditorGlobalContextMenu(QMenu* menu, const AZ::Vector2& point, int flags) override;
 
-            // EntityOutlinerSourceDropHandlingBus...
+            // EditorEventsBus overrides ...
+            void OnEscape();
+
+            // EntityOutlinerSourceDropHandlingBus overrides ...
             void HandleSourceFileType(AZStd::string_view sourceFilePath, AZ::EntityId parentId, AZ::Vector3 position) const override;
 
-            // PrefabInstanceContainerNotificationBus...
+            // PrefabInstanceContainerNotificationBus overrides ...
             void OnPrefabComponentActivate(AZ::EntityId entityId) override;
             void OnPrefabComponentDeactivate(AZ::EntityId entityId) override;
 
-            // PrefabIntegrationInterface...
+            // PrefabIntegrationInterface overrides ...
             AZ::EntityId CreateNewEntityAtPosition(const AZ::Vector3& position, AZ::EntityId parentId) override;
             int ExecuteClosePrefabDialog(TemplateId templateId) override;
             void ExecuteSavePrefabDialog(TemplateId templateId, bool useSaveAllPrefabsPreference) override;
@@ -140,7 +144,7 @@ namespace AzToolsFramework
 
             static ContainerEntityInterface* s_containerEntityInterface;
             static EditorEntityUiInterface* s_editorEntityUiInterface;
-            static PrefabFocusInterface* s_prefabFocusInterface;
+            static PrefabFocusPublicInterface* s_prefabFocusPublicInterface;
             static PrefabLoaderInterface* s_prefabLoaderInterface;
             static PrefabPublicInterface* s_prefabPublicInterface;
             static PrefabSystemComponentInterface* s_prefabSystemComponentInterface;

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

@@ -10,7 +10,7 @@
 
 #include <AzFramework/API/ApplicationAPI.h>
 
-#include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
+#include <AzToolsFramework/Prefab/PrefabFocusPublicInterface.h>
 #include <AzToolsFramework/Prefab/PrefabPublicInterface.h>
 #include <AzToolsFramework/UI/Outliner/EntityOutlinerListModel.hxx>
 
@@ -35,10 +35,10 @@ namespace AzToolsFramework
             return;
         }
 
-        m_prefabFocusInterface = AZ::Interface<Prefab::PrefabFocusInterface>::Get();
-        if (m_prefabFocusInterface == nullptr)
+        m_prefabFocusPublicInterface = AZ::Interface<Prefab::PrefabFocusPublicInterface>::Get();
+        if (m_prefabFocusPublicInterface == nullptr)
         {
-            AZ_Assert(false, "PrefabUiHandler - could not get PrefabFocusInterface on PrefabUiHandler construction.");
+            AZ_Assert(false, "PrefabUiHandler - could not get PrefabFocusPublicInterface on PrefabUiHandler construction.");
             return;
         }
     }
@@ -83,7 +83,7 @@ namespace AzToolsFramework
 
     QIcon PrefabUiHandler::GenerateItemIcon(AZ::EntityId entityId) const
     {
-        if (m_prefabFocusInterface->IsOwningPrefabBeingFocused(entityId))
+        if (m_prefabFocusPublicInterface->IsOwningPrefabBeingFocused(entityId))
         {
             return QIcon(m_prefabEditIconPath);
         }
@@ -105,7 +105,7 @@ namespace AzToolsFramework
         const bool hasVisibleChildren = index.data(EntityOutlinerListModel::ExpandedRole).value<bool>() && index.model()->hasChildren(index);
 
         QColor backgroundColor = m_prefabCapsuleColor;
-        if (m_prefabFocusInterface->IsOwningPrefabBeingFocused(entityId))
+        if (m_prefabFocusPublicInterface->IsOwningPrefabBeingFocused(entityId))
         {
             backgroundColor = m_prefabCapsuleEditColor;
         }
@@ -178,12 +178,6 @@ namespace AzToolsFramework
 
         AZ::EntityId entityId(index.data(EntityOutlinerListModel::EntityIdRole).value<AZ::u64>());
 
-        // We hide the root instance container entity from the Outliner, so avoid drawing its full container on children
-        if (m_prefabPublicInterface->IsLevelInstanceContainerEntity(entityId))
-        {
-            return;
-        }
-
         const QTreeView* outlinerTreeView(qobject_cast<const QTreeView*>(option.widget));
         const int ancestorLeft = outlinerTreeView->visualRect(index).left() + (m_prefabBorderThickness / 2) - 1;
         const int curveRectSize = m_prefabCapsuleRadius * 2;
@@ -191,7 +185,7 @@ namespace AzToolsFramework
         const bool isLastColumn = descendantIndex.column() == EntityOutlinerListModel::ColumnLockToggle;
 
         QColor borderColor = m_prefabCapsuleColor;
-        if (m_prefabFocusInterface->IsOwningPrefabBeingFocused(entityId))
+        if (m_prefabFocusPublicInterface->IsOwningPrefabBeingFocused(entityId))
         {
             borderColor = m_prefabCapsuleEditColor;
         }
@@ -329,7 +323,7 @@ namespace AzToolsFramework
         if (prefabWipFeaturesEnabled)
         {
             // Focus on this prefab
-            m_prefabFocusInterface->FocusOnOwningPrefab(entityId);
+            m_prefabFocusPublicInterface->FocusOnOwningPrefab(entityId);
         }
     }
 }

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

@@ -15,7 +15,7 @@ namespace AzToolsFramework
 
     namespace Prefab
     {
-        class PrefabFocusInterface;
+        class PrefabFocusPublicInterface;
         class PrefabPublicInterface;
     };
 
@@ -39,7 +39,7 @@ namespace AzToolsFramework
         void OnDoubleClick(AZ::EntityId entityId) const override;
 
     private:
-        Prefab::PrefabFocusInterface* m_prefabFocusInterface = nullptr;
+        Prefab::PrefabFocusPublicInterface* m_prefabFocusPublicInterface = nullptr;
         Prefab::PrefabPublicInterface* m_prefabPublicInterface = nullptr;
 
         static bool IsLastVisibleChild(const QModelIndex& parent, const QModelIndex& child);

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

@@ -8,7 +8,7 @@
 
 #include <AzToolsFramework/UI/Prefab/PrefabViewportFocusPathHandler.h>
 
-#include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
+#include <AzToolsFramework/Prefab/PrefabFocusPublicInterface.h>
 
 namespace AzToolsFramework::Prefab
 {
@@ -31,8 +31,8 @@ namespace AzToolsFramework::Prefab
     void PrefabViewportFocusPathHandler::Initialize(AzQtComponents::BreadCrumbs* breadcrumbsWidget, QToolButton* backButton)
     {
         // Get reference to the PrefabFocusInterface handler
-        m_prefabFocusInterface = AZ::Interface<PrefabFocusInterface>::Get();
-        if (m_prefabFocusInterface == nullptr)
+        m_prefabFocusPublicInterface = AZ::Interface<PrefabFocusPublicInterface>::Get();
+        if (m_prefabFocusPublicInterface == nullptr)
         {
             AZ_Assert(false, "Prefab - could not get PrefabFocusInterface on PrefabViewportFocusPathHandler construction.");
             return;
@@ -46,7 +46,7 @@ namespace AzToolsFramework::Prefab
         connect(m_breadcrumbsWidget, &AzQtComponents::BreadCrumbs::linkClicked, this,
             [&](const QString&, int linkIndex)
             {
-                m_prefabFocusInterface->FocusOnPathIndex(m_editorEntityContextId, linkIndex);
+                m_prefabFocusPublicInterface->FocusOnPathIndex(m_editorEntityContextId, linkIndex);
             }
         );
 
@@ -54,9 +54,9 @@ namespace AzToolsFramework::Prefab
         connect(m_backButton, &QToolButton::clicked, this,
             [&]()
             {
-                if (int length = m_prefabFocusInterface->GetPrefabFocusPathLength(m_editorEntityContextId); length > 1)
+                if (int length = m_prefabFocusPublicInterface->GetPrefabFocusPathLength(m_editorEntityContextId); length > 1)
                 {
-                    m_prefabFocusInterface->FocusOnPathIndex(m_editorEntityContextId, length - 2);
+                    m_prefabFocusPublicInterface->FocusOnPathIndex(m_editorEntityContextId, length - 2);
                 }
             }
         );
@@ -65,7 +65,7 @@ namespace AzToolsFramework::Prefab
     void PrefabViewportFocusPathHandler::OnPrefabFocusChanged()
     {
         // Push new Path
-        m_breadcrumbsWidget->pushPath(m_prefabFocusInterface->GetPrefabFocusPath(m_editorEntityContextId).c_str());
+        m_breadcrumbsWidget->pushPath(m_prefabFocusPublicInterface->GetPrefabFocusPath(m_editorEntityContextId).c_str());
     }
 
 } // namespace AzToolsFramework::Prefab

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

@@ -19,7 +19,7 @@
 
 namespace AzToolsFramework::Prefab
 {
-    class PrefabFocusInterface;
+    class PrefabFocusPublicInterface;
 
     class PrefabViewportFocusPathHandler
         : public PrefabFocusNotificationBus::Handler
@@ -40,6 +40,6 @@ namespace AzToolsFramework::Prefab
 
         AzFramework::EntityContextId m_editorEntityContextId = AzFramework::EntityContextId::CreateNull();
 
-        PrefabFocusInterface* m_prefabFocusInterface = nullptr;
+        PrefabFocusPublicInterface* m_prefabFocusPublicInterface = nullptr;
     };
 } // namespace AzToolsFramework::Prefab

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/ComponentEditor.hxx

@@ -90,7 +90,6 @@ namespace AzToolsFramework
 
         void SetComponentOverridden(const bool overridden);
 
-        // Calls match EditorComponentModeNotificationBus - called from EntityPropertyEditor
         void EnteredComponentMode(const AZStd::vector<AZ::Uuid>& componentModeTypes);
         void LeftComponentMode(const AZStd::vector<AZ::Uuid>& componentModeTypes);
         void ActiveComponentModeChanged(const AZ::Uuid& componentType);

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/EntityPropertyEditor.cpp

@@ -33,6 +33,7 @@ AZ_POP_DISABLE_WARNING
 #include <AzQtComponents/Components/Style.h>
 #include <AzQtComponents/Components/Widgets/DragAndDrop.h>
 #include <AzQtComponents/Components/Widgets/LineEdit.h>
+#include <AzToolsFramework/API/ComponentModeCollectionInterface.h>
 #include <AzToolsFramework/API/EntityCompositionRequestBus.h>
 #include <AzToolsFramework/API/ToolsApplicationAPI.h>
 #include <AzToolsFramework/Entity/EditorEntityInfoBus.h>
@@ -486,8 +487,12 @@ namespace AzToolsFramework
         , m_isSystemEntityEditor(false)
         , m_isLevelEntityEditor(isLevelEntityEditor)
     {
+
         initEntityPropertyEditorResources();
 
+        m_componentModeCollection = AZ::Interface<ComponentModeCollectionInterface>::Get();
+        AZ_Assert(m_componentModeCollection, "Could not retrieve component mode collection.");
+
         m_prefabPublicInterface = AZ::Interface<Prefab::PrefabPublicInterface>::Get();
         AZ_Assert(m_prefabPublicInterface != nullptr, "EntityPropertyEditor requires a PrefabPublicInterface instance on Initialize.");
 
@@ -5698,39 +5703,49 @@ namespace AzToolsFramework
         SaveComponentEditorState();
     }
 
-    void EntityPropertyEditor::EnteredComponentMode(const AZStd::vector<AZ::Uuid>& componentModeTypes)
+    void EntityPropertyEditor::OnEditorModeActivated(
+        [[maybe_unused]] const AzToolsFramework::ViewportEditorModesInterface& editorModeState, AzToolsFramework::ViewportEditorMode mode)
     {
-        DisableComponentActions(this, m_entityComponentActions);
-        SetPropertyEditorState(m_gui, false);
-        m_disabled = true;
-
-        if (!componentModeTypes.empty())
+        if (mode == AzToolsFramework::ViewportEditorMode::Component)
         {
-            m_componentEditorLastSelectedIndex = GetComponentEditorIndexFromType(componentModeTypes.front());
-        }
+            DisableComponentActions(this, m_entityComponentActions);
+            SetPropertyEditorState(m_gui, false);
+            const auto componentModeTypes = m_componentModeCollection->GetComponentTypes();
+            m_disabled = true;
+            
+            if (!componentModeTypes.empty())
+            {
+                m_componentEditorLastSelectedIndex = GetComponentEditorIndexFromType(componentModeTypes.front());
+            }
 
-        for (auto componentEditor : m_componentEditors)
-        {
-            componentEditor->EnteredComponentMode(componentModeTypes);
-        }
+            for (auto componentEditor : m_componentEditors)
+            {
+                componentEditor->EnteredComponentMode(componentModeTypes);
+            }
 
-        // record the selected state after entering component mode
-        SaveComponentEditorState();
+            // record the selected state after entering component mode
+            SaveComponentEditorState();
+        }
     }
 
-    void EntityPropertyEditor::LeftComponentMode(const AZStd::vector<AZ::Uuid>& componentModeTypes)
+    void EntityPropertyEditor::OnEditorModeDeactivated(
+        [[maybe_unused]] const AzToolsFramework::ViewportEditorModesInterface& editorModeState, AzToolsFramework::ViewportEditorMode mode)
     {
-        EnableComponentActions(this, m_entityComponentActions);
-        SetPropertyEditorState(m_gui, true);
-        m_disabled = false;
-
-        for (auto componentEditor : m_componentEditors)
+        if (mode == AzToolsFramework::ViewportEditorMode::Component)
         {
-            componentEditor->LeftComponentMode(componentModeTypes);
-        }
+            EnableComponentActions(this, m_entityComponentActions);
+            SetPropertyEditorState(m_gui, true);
+            const auto componentModeTypes = m_componentModeCollection->GetComponentTypes();
+            m_disabled = false;
 
-        // record the selected state after leaving component mode
-        SaveComponentEditorState();
+            for (auto componentEditor : m_componentEditors)
+            {
+                componentEditor->LeftComponentMode(componentModeTypes);
+            }
+
+            // record the selected state after leaving component mode
+            SaveComponentEditorState();
+        }
     }
 
     void EntityPropertyEditor::ActiveComponentModeChanged(const AZ::Uuid& componentType)

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/EntityPropertyEditor.hxx

@@ -26,6 +26,7 @@
 #include <AzToolsFramework/API/EditorWindowRequestBus.h>
 #include <AzToolsFramework/API/ToolsApplicationAPI.h>
 #include <AzToolsFramework/API/EntityPropertyEditorRequestsBus.h>
+#include <AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h>
 #include <AzToolsFramework/ComponentMode/EditorComponentModeBus.h>
 #include <AzToolsFramework/Entity/EditorEntityContextBus.h>
 #include <AzToolsFramework/ToolsComponents/ComponentMimeData.h>
@@ -59,6 +60,7 @@ namespace AzToolsFramework
 {
     class ComponentEditor;
     class ComponentPaletteWidget;
+    class ComponentModeCollectionInterface;
     struct SourceControlFileInfo;
 
     namespace AssetBrowser
@@ -108,6 +110,7 @@ namespace AzToolsFramework
         , public AzToolsFramework::EditorEntityContextNotificationBus::Handler
         , public AzToolsFramework::EntityPropertyEditorRequestBus::Handler
         , public AzToolsFramework::PropertyEditorEntityChangeNotificationBus::MultiHandler
+        , private AzToolsFramework::ViewportEditorModeNotificationsBus::Handler
         , public EditorInspectorComponentNotificationBus::MultiHandler
         , private AzToolsFramework::ComponentModeFramework::EditorComponentModeNotificationBus::Handler
         , public AZ::EntitySystemBus::Handler
@@ -231,10 +234,14 @@ namespace AzToolsFramework
         //////////////////////////////////////////////////////////////////////////
 
         // EditorComponentModeNotificationBus
-        void EnteredComponentMode(const AZStd::vector<AZ::Uuid>& componentModeTypes) override;
-        void LeftComponentMode(const AZStd::vector<AZ::Uuid>& componentModeTypes) override;
         void ActiveComponentModeChanged(const AZ::Uuid& componentType) override;
 
+        // ViewportEditorModeNotificationsBus overrides ...
+        void OnEditorModeActivated(
+            const AzToolsFramework::ViewportEditorModesInterface& editorModeState, AzToolsFramework::ViewportEditorMode mode) override;
+        void OnEditorModeDeactivated(
+            const AzToolsFramework::ViewportEditorModesInterface& editorModeState, AzToolsFramework::ViewportEditorMode mode) override;
+
         // EntityPropertEditorRequestBus
         void GetSelectedAndPinnedEntities(EntityIdList& selectedEntityIds) override;
         void GetSelectedEntities(EntityIdList& selectedEntityIds) override;
@@ -627,6 +634,8 @@ namespace AzToolsFramework
         float m_moveFadeSecondsRemaining;
         AZStd::vector<int> m_indexMapOfMovedRow;
 
+        AzToolsFramework::ComponentModeCollectionInterface* m_componentModeCollection = nullptr;
+
         // When m_initiatingPropertyChangeNotification is set to true, it means this EntityPropertyEditor is
         // broadcasting a change to all listeners about a property change for a given entity.  This is needed
         // so that we don't update the values twice for this inspector

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyAssetCtrl.cpp

@@ -28,6 +28,9 @@ AZ_PUSH_DISABLE_WARNING(4244 4251, "-Wunknown-warning-option")
 #include <QTableView>
 #include <QHeaderView>
 #include <QPainter>
+#include <QPixmap>
+#include <QByteArray>
+#include <QDataStream>
 AZ_POP_DISABLE_WARNING
 
 #include <AzCore/Asset/AssetManager.h>
@@ -1230,6 +1233,16 @@ namespace AzToolsFramework
         return m_showThumbnailDropDownButton;
     }
 
+    void PropertyAssetCtrl::SetCustomThumbnailEnabled(bool enabled)
+    {
+        m_thumbnail->SetCustomThumbnailEnabled(enabled);
+    }
+
+    void PropertyAssetCtrl::SetCustomThumbnailPixmap(const QPixmap& pixmap)
+    {
+        m_thumbnail->SetCustomThumbnailPixmap(pixmap);
+    }
+
     void PropertyAssetCtrl::SetThumbnailCallback(EditCallbackType* editNotifyCallback)
     {
         m_thumbnailCallback = editNotifyCallback;
@@ -1356,15 +1369,27 @@ namespace AzToolsFramework
                 GUI->SetClearNotifyCallback(nullptr);
             }
         }
-        else if (attrib == AZ_CRC("BrowseIcon", 0x507d7a4f))
+        else if (attrib == AZ_CRC_CE("BrowseIcon"))
         {
             AZStd::string iconPath;
-            attrValue->Read<AZStd::string>(iconPath);
-
-            if (!iconPath.empty())
+            if (attrValue->Read<AZStd::string>(iconPath) && !iconPath.empty())
             {
                 GUI->SetBrowseButtonIcon(QIcon(iconPath.c_str()));
             }
+            else
+            {
+                // A QPixmap object can't be assigned directly via an attribute.
+                // This allows dynamic icon data to be supplied as a buffer containing a serialized QPixmap.
+                AZStd::vector<char> pixmapBuffer;
+                if (attrValue->Read<AZStd::vector<char>>(pixmapBuffer) && !pixmapBuffer.empty())
+                {
+                    QByteArray pixmapBytes(pixmapBuffer.data(), aznumeric_cast<int>(pixmapBuffer.size()));
+                    QDataStream stream(&pixmapBytes, QIODevice::ReadOnly);
+                    QPixmap pixmap;
+                    stream >> pixmap;
+                    GUI->SetBrowseButtonIcon(pixmap);
+                }
+            }
         }
         else if (attrib == AZ_CRC_CE("BrowseButtonEnabled"))
         {
@@ -1390,6 +1415,30 @@ namespace AzToolsFramework
                 GUI->SetShowThumbnail(showThumbnail);
             }
         }
+        else if (attrib == AZ_CRC_CE("ThumbnailIcon"))
+        {
+            AZStd::string iconPath;
+            if (attrValue->Read<AZStd::string>(iconPath) && !iconPath.empty())
+            {
+                GUI->SetCustomThumbnailEnabled(true);
+                GUI->SetCustomThumbnailPixmap(QPixmap::fromImage(QImage(iconPath.c_str())));
+            }
+            else
+            {
+                // A QPixmap object can't be assigned directly via an attribute.
+                // This allows dynamic icon data to be supplied as a buffer containing a serialized QPixmap.
+                AZStd::vector<char> pixmapBuffer;
+                if (attrValue->Read<AZStd::vector<char>>(pixmapBuffer) && !pixmapBuffer.empty())
+                {
+                    QByteArray pixmapBytes(pixmapBuffer.data(), aznumeric_cast<int>(pixmapBuffer.size()));
+                    QDataStream stream(&pixmapBytes, QIODevice::ReadOnly);
+                    QPixmap pixmap;
+                    stream >> pixmap;
+                    GUI->SetCustomThumbnailEnabled(true);
+                    GUI->SetCustomThumbnailPixmap(pixmap);
+                }
+            }
+        }
         else if (attrib == AZ_CRC_CE("ThumbnailCallback"))
         {
             PropertyAssetCtrl::EditCallbackType* func = azdynamic_cast<PropertyAssetCtrl::EditCallbackType*>(attrValue->GetAttribute());

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyAssetCtrl.hxx

@@ -217,12 +217,17 @@ namespace AzToolsFramework
         void SetHideProductFilesInAssetPicker(bool hide);
         bool GetHideProductFilesInAssetPicker() const;
 
+        // Enable and configure a thumbnail widget that displays an asset preview and dropdown arrow for a dropdown menu
         void SetShowThumbnail(bool enable);
         bool GetShowThumbnail() const;
         void SetShowThumbnailDropDownButton(bool enable);
         bool GetShowThumbnailDropDownButton() const;
         void SetThumbnailCallback(EditCallbackType* editNotifyCallback);
 
+        // If enabled, replaces the thumbnail widget content with a custom pixmap
+        void SetCustomThumbnailEnabled(bool enabled);
+        void SetCustomThumbnailPixmap(const QPixmap& pixmap);
+
         void SetSelectedAssetID(const AZ::Data::AssetId& newID);
         void SetCurrentAssetType(const AZ::Data::AssetType& newType);
         void SetSelectedAssetID(const AZ::Data::AssetId& newID, const AZ::Data::AssetType& newType);

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyIntCtrlCommon.h

@@ -38,7 +38,7 @@ namespace AzToolsFramework
         static bool UnsignedToolTip(QWidget* widget, QString& toolTipString);
     };
 
-    //! Base class for integer widget handlers to provide functionality independant
+    //! Base class for integer widget handlers to provide functionality independent
     //! of widget type.
     //! @tparam ValueType The integer primitive type of the handler.
     //! @tparam PropertyControl The widget type of the handler.
@@ -167,8 +167,7 @@ namespace AzToolsFramework
         PropertyControl* newCtrl = aznew PropertyControl(pParent);
         this->connect(newCtrl, &PropertyControl::valueChanged, this, [newCtrl]()
         {
-            EBUS_EVENT(PropertyEditorGUIMessages::Bus, RequestWrite, newCtrl);
-            AzToolsFramework::PropertyEditorGUIMessages::Bus::Broadcast(&PropertyEditorGUIMessages::Bus::Handler::RequestWrite, newCtrl);
+            AzToolsFramework::PropertyEditorGUIMessages::Bus::Broadcast(&PropertyEditorGUIMessages::Bus::Events::RequestWrite, newCtrl);
         });
         // note:  Qt automatically disconnects objects from each other when either end is destroyed, no need to worry about delete.
 

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyIntSpinCtrl.hxx

@@ -98,11 +98,6 @@ namespace AzToolsFramework
     QWidget* IntSpinBoxHandler<ValueType>::CreateGUI(QWidget* parent)
     {
         PropertyIntSpinCtrl* newCtrl = static_cast<PropertyIntSpinCtrl*>(BaseHandler::CreateGUI(parent));
-        this->connect(newCtrl, &PropertyIntSpinCtrl::valueChanged, [newCtrl]()
-        {
-            AzToolsFramework::PropertyEditorGUIMessages::Bus::Broadcast(&PropertyEditorGUIMessages::Bus::Handler::RequestWrite, newCtrl);
-        });
-
         return newCtrl;
     }
 

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/ThumbnailPropertyCtrl.cpp

@@ -7,75 +7,117 @@
  */
 
 #include <AzToolsFramework/Debug/TraceContext.h>
-AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // 4251: 'QRawFont::d': class 'QExplicitlySharedDataPointer<QRawFontPrivate>' needs to have dll-interface to be used by clients of class 'QRawFont'
-                                                               // 4800: 'QTextEngine *const ': forcing value to bool 'true' or 'false' (performance warning)
-#include <QLabel>
-#include <QHBoxLayout>
-#include <QEvent>
-#include <QPainter>
-#include <UI/UICore/AspectRatioAwarePixmapWidget.hxx>
-#include <Thumbnails/ThumbnailWidget.h>
+
+// 4251: 'QRawFont::d': class 'QExplicitlySharedDataPointer<QRawFontPrivate>' needs to have dll-interface to be used by clients of class
+// 'QRawFont' 4800: 'QTextEngine *const ': forcing value to bool 'true' or 'false' (performance warning)
+AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option")
 #include <QApplication>
+#include <QEvent>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QPainter>
+#include <Thumbnails/ThumbnailWidget.h>
+#include <UI/UICore/AspectRatioAwarePixmapWidget.hxx>
 AZ_POP_DISABLE_WARNING
 #include "ThumbnailPropertyCtrl.h"
 
 namespace AzToolsFramework
 {
-
     ThumbnailPropertyCtrl::ThumbnailPropertyCtrl(QWidget* parent)
         : QWidget(parent)
     {
-        QHBoxLayout* pLayout = new QHBoxLayout();
-        pLayout->setContentsMargins(0, 0, 0, 0);
-        pLayout->setSpacing(0);
-
         m_thumbnail = new Thumbnailer::ThumbnailWidget(this);
         m_thumbnail->setFixedSize(QSize(24, 24));
 
+        m_thumbnailEnlarged = new Thumbnailer::ThumbnailWidget(this);
+        m_thumbnailEnlarged->setFixedSize(QSize(180, 180));
+        m_thumbnailEnlarged->setWindowFlags(Qt::Window | Qt::FramelessWindowHint);
+
+        m_customThumbnail = new QLabel(this);
+        m_customThumbnail->setFixedSize(QSize(24, 24));
+        m_customThumbnail->setScaledContents(true);
+
+        m_customThumbnailEnlarged = new QLabel(this);
+        m_customThumbnailEnlarged->setFixedSize(QSize(180, 180));
+        m_customThumbnailEnlarged->setWindowFlags(Qt::Window | Qt::FramelessWindowHint);
+        m_customThumbnailEnlarged->setScaledContents(true);
+
         m_dropDownArrow = new AspectRatioAwarePixmapWidget(this);
         m_dropDownArrow->setPixmap(QPixmap(":/stylesheet/img/triangle0.png"));
         m_dropDownArrow->setFixedSize(QSize(8, 24));
-        ShowDropDownArrow(false);
 
         m_emptyThumbnail = new QLabel(this);
         m_emptyThumbnail->setPixmap(QPixmap(":/stylesheet/img/line.png"));
         m_emptyThumbnail->setFixedSize(QSize(24, 24));
 
-        pLayout->addWidget(m_emptyThumbnail);
+        QHBoxLayout* pLayout = new QHBoxLayout();
+        pLayout->setContentsMargins(0, 0, 0, 0);
+        pLayout->setSpacing(0);
         pLayout->addWidget(m_thumbnail);
+        pLayout->addWidget(m_customThumbnail);
+        pLayout->addWidget(m_emptyThumbnail);
         pLayout->addSpacing(4);
         pLayout->addWidget(m_dropDownArrow);
         pLayout->addSpacing(4);
-
         setLayout(pLayout);
+
+        ShowDropDownArrow(false);
+        UpdateVisibility();
     }
 
     void ThumbnailPropertyCtrl::SetThumbnailKey(Thumbnailer::SharedThumbnailKey key, const char* contextName)
     {
-        m_key = key;
-        m_emptyThumbnail->setVisible(false);
-        m_thumbnail->SetThumbnailKey(key, contextName);
+        if (m_customThumbnailEnabled)
+        {
+            ClearThumbnail();
+        }
+        else
+        {
+            m_key = key;
+            m_thumbnail->SetThumbnailKey(m_key, contextName);
+            m_thumbnailEnlarged->SetThumbnailKey(m_key, contextName);
+        }
+        UpdateVisibility();
     }
 
     void ThumbnailPropertyCtrl::ClearThumbnail()
     {
-        m_emptyThumbnail->setVisible(true);
+        m_key.clear();
         m_thumbnail->ClearThumbnail();
+        m_thumbnailEnlarged->ClearThumbnail();
+        UpdateVisibility();
     }
 
     void ThumbnailPropertyCtrl::ShowDropDownArrow(bool visible)
     {
-        if (visible)
-        {
-            setFixedSize(QSize(40, 24));
-        }
-        else
-        {
-            setFixedSize(QSize(24, 24));
-        }
+        setFixedSize(QSize(visible ? 40 : 24, 24));
         m_dropDownArrow->setVisible(visible);
     }
 
+    void ThumbnailPropertyCtrl::SetCustomThumbnailEnabled(bool enabled)
+    {
+        m_customThumbnailEnabled = enabled;
+        UpdateVisibility();
+    }
+
+    void ThumbnailPropertyCtrl::SetCustomThumbnailPixmap(const QPixmap& pixmap)
+    {
+        m_customThumbnail->setPixmap(pixmap);
+        m_customThumbnailEnlarged->setPixmap(pixmap);
+        UpdateVisibility();
+    }
+
+    void ThumbnailPropertyCtrl::UpdateVisibility()
+    {
+        m_thumbnail->setVisible(m_key && !m_customThumbnailEnabled);
+        m_thumbnailEnlarged->setVisible(false);
+
+        m_customThumbnail->setVisible(m_customThumbnailEnabled);
+        m_customThumbnailEnlarged->setVisible(false);
+
+        m_emptyThumbnail->setVisible(!m_key && !m_customThumbnailEnabled);
+    }
+
     bool ThumbnailPropertyCtrl::event(QEvent* e)
     {
         if (isEnabled())
@@ -83,7 +125,7 @@ namespace AzToolsFramework
             if (e->type() == QEvent::MouseButtonPress)
             {
                 emit clicked();
-                return true; //ignore
+                return true; // ignore
             }
         }
 
@@ -94,37 +136,32 @@ namespace AzToolsFramework
     {
         QPainter p(this);
         QRect targetRect(QPoint(), QSize(40, 24));
-        p.fillRect(targetRect, QColor(17, 17, 17)); // #111111
+        p.fillRect(targetRect, QColor("#111111"));
         QWidget::paintEvent(e);
     }
 
     void ThumbnailPropertyCtrl::enterEvent(QEvent* e)
     {
         m_dropDownArrow->setPixmap(QPixmap(":/stylesheet/img/triangle0_highlighted.png"));
-        if (!m_thumbnailEnlarged && m_key)
-        {
-            QPoint position = mapToGlobal(pos() - QPoint(185, 0));
-            QSize size(180, 180);
-            m_thumbnailEnlarged.reset(new Thumbnailer::ThumbnailWidget());
-            m_thumbnailEnlarged->setFixedSize(size);
-            m_thumbnailEnlarged->move(position);
-            m_thumbnailEnlarged->setWindowFlags(Qt::Window | Qt::FramelessWindowHint);
-            m_thumbnailEnlarged->SetThumbnailKey(m_key);
-            m_thumbnailEnlarged->raise();
-            m_thumbnailEnlarged->show();
-        }
+        const QPoint offset(-m_thumbnailEnlarged->width() - 5, -m_thumbnailEnlarged->height() / 2 + m_thumbnail->height() / 2);
+
+        m_thumbnailEnlarged->move(mapToGlobal(pos()) + offset);
+        m_thumbnailEnlarged->raise();
+        m_thumbnailEnlarged->setVisible(m_key && !m_customThumbnailEnabled);
+
+        m_customThumbnailEnlarged->move(mapToGlobal(pos()) + offset);
+        m_customThumbnailEnlarged->raise();
+        m_customThumbnailEnlarged->setVisible(m_customThumbnailEnabled);
         QWidget::enterEvent(e);
     }
 
     void ThumbnailPropertyCtrl::leaveEvent(QEvent* e)
     {
         m_dropDownArrow->setPixmap(QPixmap(":/stylesheet/img/triangle0.png"));
-        if (m_thumbnailEnlarged)
-        {
-            m_thumbnailEnlarged.reset();
-        }
+        m_thumbnailEnlarged->setVisible(false);
+        m_customThumbnailEnlarged->setVisible(false);
         QWidget::leaveEvent(e);
     }
-}
+} // namespace AzToolsFramework
 
 #include "UI/PropertyEditor/moc_ThumbnailPropertyCtrl.cpp"

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/ThumbnailPropertyCtrl.h

@@ -1,5 +1,3 @@
-#pragma once
-
 /*
  * 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.
@@ -8,6 +6,8 @@
  *
  */
 
+#pragma once
+
 #if !defined(Q_MOC_RUN)
 #include <AzCore/PlatformDef.h>
 #include <AzToolsFramework/Thumbnails/Thumbnail.h>
@@ -35,25 +35,38 @@ namespace AzToolsFramework
 
         //! Call this to set what thumbnail widget will display
         void SetThumbnailKey(Thumbnailer::SharedThumbnailKey key, const char* contextName = "Default");
+
         //! Remove current thumbnail
         void ClearThumbnail();
 
+        //! Display a clickable dropdown arrow next to the thumbnail
         void ShowDropDownArrow(bool visible);
 
-        bool event(QEvent* e) override;
+        //! Override the thumbnail widget with a custom image
+        void SetCustomThumbnailEnabled(bool enabled);
+
+        //! Assign a custom image to display in place of thumbnail
+        void SetCustomThumbnailPixmap(const QPixmap& pixmap);
 
     Q_SIGNALS:
         void clicked();
 
-    protected:
+    private:
+        void UpdateVisibility();
+
+        bool event(QEvent* e) override;
         void paintEvent(QPaintEvent* e) override;
         void enterEvent(QEvent* e) override;
         void leaveEvent(QEvent* e) override;
 
-    private:
         Thumbnailer::SharedThumbnailKey m_key;
         Thumbnailer::ThumbnailWidget* m_thumbnail = nullptr;
-        QScopedPointer<Thumbnailer::ThumbnailWidget> m_thumbnailEnlarged;
+        Thumbnailer::ThumbnailWidget* m_thumbnailEnlarged = nullptr;
+
+        QLabel* m_customThumbnail = nullptr;
+        QLabel* m_customThumbnailEnlarged = nullptr;
+        bool m_customThumbnailEnabled = false;
+
         QLabel* m_emptyThumbnail = nullptr;
         AspectRatioAwarePixmapWidget* m_dropDownArrow = nullptr;
     };

Code/Framework/AzToolsFramework/AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.cpp

@@ -129,7 +129,7 @@ namespace UnitTest
         using AzToolsFramework::ComponentModeFramework::EditorComponentModeNotificationBus;
 
         AzToolsFramework::EditorActionRequestBus::Handler::BusConnect();
-        EditorComponentModeNotificationBus::Handler::BusConnect(GetEntityContextId());
+        ViewportEditorModeNotificationsBus::Handler::BusConnect(GetEntityContextId());
         m_defaultWidget.setFocus();
     }
 
@@ -137,18 +137,26 @@ namespace UnitTest
     {
         using AzToolsFramework::ComponentModeFramework::EditorComponentModeNotificationBus;
 
-        EditorComponentModeNotificationBus::Handler::BusDisconnect();
+        ViewportEditorModeNotificationsBus::Handler::BusDisconnect();
         AzToolsFramework::EditorActionRequestBus::Handler::BusDisconnect();
     }
 
-    void TestEditorActions::EnteredComponentMode([[maybe_unused]] const AZStd::vector<AZ::Uuid>& componentTypes)
+    void TestEditorActions::OnEditorModeActivated(
+        [[maybe_unused]] const AzToolsFramework::ViewportEditorModesInterface& editorModeState, AzToolsFramework::ViewportEditorMode mode)
     {
-        m_componentModeWidget.setFocus();
+        if (mode == ViewportEditorMode::Component)
+        {
+            m_componentModeWidget.setFocus();
+        }
     }
 
-    void TestEditorActions::LeftComponentMode([[maybe_unused]] const AZStd::vector<AZ::Uuid>& componentTypes)
+    void TestEditorActions::OnEditorModeDeactivated(
+        [[maybe_unused]] const AzToolsFramework::ViewportEditorModesInterface& editorModeState, AzToolsFramework::ViewportEditorMode mode)
     {
-        m_defaultWidget.setFocus();
+        if (mode == ViewportEditorMode::Component)
+        {
+            m_defaultWidget.setFocus();
+        }
     }
 
     void TestEditorActions::AddActionViaBus(int id, QAction* action)

Code/Framework/AzToolsFramework/AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h

@@ -23,9 +23,9 @@
 #include <AZTestShared/Utils/Utils.h>
 #include <AzToolsFramework/API/ToolsApplicationAPI.h>
 #include <AzToolsFramework/API/ViewportEditorModeTrackerInterface.h>
+#include <AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h>
 #include <AzToolsFramework/Application/ToolsApplication.h>
 #include <AzToolsFramework/Entity/EditorEntityTransformBus.h>
-#include <AzToolsFramework/ComponentMode/EditorComponentModeBus.h>
 #include <AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI.h>
 #include <AzToolsFramework/Viewport/ActionBus.h>
 #include <AzToolsFramework/Viewport/ViewportMessages.h>
@@ -103,7 +103,7 @@ namespace UnitTest
     /// component mode editing.
     class TestEditorActions
         : private AzToolsFramework::EditorActionRequestBus::Handler
-        , private AzToolsFramework::ComponentModeFramework::EditorComponentModeNotificationBus::Handler
+        , private AzToolsFramework::ViewportEditorModeNotificationsBus::Handler
     {
         // EditorActionRequestBus ...
         void AddActionViaBus(int id, QAction* action) override;
@@ -114,9 +114,11 @@ namespace UnitTest
         void AttachOverride(QWidget* /*object*/) override {}
         void DetachOverride() override {}
 
-        // EditorComponentModeNotificationBus ...
-        void EnteredComponentMode(const AZStd::vector<AZ::Uuid>& componentTypes) override;
-        void LeftComponentMode(const AZStd::vector<AZ::Uuid>& componentTypes) override;
+        // ViewportEditorModeNotificationsBus overrides ...
+        void OnEditorModeActivated(
+            const AzToolsFramework::ViewportEditorModesInterface& editorModeState, AzToolsFramework::ViewportEditorMode mode) override;
+        void OnEditorModeDeactivated(
+            const AzToolsFramework::ViewportEditorModesInterface& editorModeState, AzToolsFramework::ViewportEditorMode mode) override;
 
     public:
         void Connect();

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.cpp

@@ -27,6 +27,10 @@ namespace AzToolsFramework
         , m_viewportEditorModeTracker(viewportEditorModeTracker)
         , m_componentModeCollection(viewportEditorModeTracker)
     {
+        AZ_Assert(
+            AZ::Interface<ComponentModeCollectionInterface>::Get() == nullptr, "Unexpected registration of component mode collection.")
+        AZ::Interface<ComponentModeCollectionInterface>::Register(&m_componentModeCollection);
+
         ActionOverrideRequestBus::Handler::BusConnect(GetEntityContextId());
         ComponentModeFramework::ComponentModeSystemRequestBus::Handler::BusConnect();
 
@@ -40,6 +44,11 @@ namespace AzToolsFramework
         ComponentModeFramework::ComponentModeSystemRequestBus::Handler::BusDisconnect();
         ActionOverrideRequestBus::Handler::BusDisconnect();
         m_viewportEditorModeTracker->DeactivateMode({ GetEntityContextId() }, ViewportEditorMode::Default);
+
+        AZ_Assert(
+            AZ::Interface<ComponentModeCollectionInterface>::Get() != nullptr,
+            "Unexpected unregistration of component mode collection.")
+        AZ::Interface<ComponentModeCollectionInterface>::Unregister(&m_componentModeCollection);
     }
 
     void EditorDefaultSelection::SetOverridePhantomWidget(QWidget* phantomOverrideWidget)

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorHelpers.cpp

@@ -9,6 +9,7 @@
 #include "EditorHelpers.h"
 
 #include <AzCore/Console/Console.h>
+#include <AzCore/Math/VectorConversions.h>
 #include <AzFramework/Entity/EntityDebugDisplayBus.h>
 #include <AzFramework/Viewport/CameraState.h>
 #include <AzFramework/Viewport/ViewportScreen.h>
@@ -114,6 +115,33 @@ namespace AzToolsFramework
         }
     }
 
+    CursorEntityIdQuery::CursorEntityIdQuery(AZ::EntityId entityId, AZ::EntityId rootEntityId)
+        : m_entityId(entityId)
+        , m_containerAncestorEntityId(rootEntityId)
+    {
+    }
+
+    AZ::EntityId CursorEntityIdQuery::EntityIdUnderCursor() const
+    {
+        return m_entityId;
+    }
+
+    AZ::EntityId CursorEntityIdQuery::ContainerAncestorEntityId() const
+    {
+        return m_containerAncestorEntityId;
+    }
+
+    bool CursorEntityIdQuery::HasContainerAncestorEntityId() const
+    {
+        if (m_entityId.IsValid())
+        {
+            return m_entityId != m_containerAncestorEntityId;
+        }
+
+        return false;
+    }
+
+
     EditorHelpers::EditorHelpers(const EditorVisibleEntityDataCache* entityDataCache)
         : m_entityDataCache(entityDataCache)
     {
@@ -123,9 +151,14 @@ namespace AzToolsFramework
             "EditorHelpers - "
             "Focus Mode Interface could not be found. "
             "Check that it is being correctly initialized.");
+
+        AZStd::vector<AZStd::unique_ptr<InvalidClick>> invalidClicks;
+        invalidClicks.push_back(AZStd::make_unique<FadingText>("Not in focus"));
+        invalidClicks.push_back(AZStd::make_unique<ExpandingFadingCircles>());
+        m_invalidClicks = AZStd::make_unique<InvalidClicks>(AZStd::move(invalidClicks));
     }
 
-    AZ::EntityId EditorHelpers::HandleMouseInteraction(
+    CursorEntityIdQuery EditorHelpers::FindEntityIdUnderCursor(
         const AzFramework::CameraState& cameraState, const ViewportInteraction::MouseInteractionEvent& mouseInteraction)
     {
         AZ_PROFILE_FUNCTION(AzToolsFramework);
@@ -186,21 +219,34 @@ namespace AzToolsFramework
             }
         }
 
-        // Verify if the entity Id corresponds to an entity that is focused; if not, halt selection.
-        if (!m_focusModeInterface->IsInFocusSubTree(entityIdUnderCursor))
+        // verify if the entity Id corresponds to an entity that is focused; if not, halt selection.
+        if (entityIdUnderCursor.IsValid() && !IsSelectableAccordingToFocusMode(entityIdUnderCursor))
         {
-            return AZ::EntityId();
+            if (mouseInteraction.m_mouseInteraction.m_mouseButtons.Left() &&
+                    mouseInteraction.m_mouseEvent == ViewportInteraction::MouseEvent::Down ||
+                mouseInteraction.m_mouseEvent == ViewportInteraction::MouseEvent::DoubleClick)
+            {
+                m_invalidClicks->AddInvalidClick(mouseInteraction.m_mouseInteraction.m_mousePick.m_screenCoordinates);
+            }
+
+            return CursorEntityIdQuery(AZ::EntityId(), AZ::EntityId());
         }
 
-        // Container Entity support - if the entity that is being selected is part of a closed container,
+        // container entity support - if the entity that is being selected is part of a closed container,
         // change the selection to the container instead.
-        ContainerEntityInterface* containerEntityInterface = AZ::Interface<ContainerEntityInterface>::Get();
-        if (containerEntityInterface)
+        if (ContainerEntityInterface* containerEntityInterface = AZ::Interface<ContainerEntityInterface>::Get())
         {
-            return containerEntityInterface->FindHighestSelectableEntity(entityIdUnderCursor);
+            const auto highestSelectableEntity = containerEntityInterface->FindHighestSelectableEntity(entityIdUnderCursor);
+            return CursorEntityIdQuery(entityIdUnderCursor, highestSelectableEntity);
         }
 
-        return entityIdUnderCursor;
+        return CursorEntityIdQuery(entityIdUnderCursor, AZ::EntityId());
+    }
+
+    void EditorHelpers::Display2d(
+        [[maybe_unused]] const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay)
+    {
+        m_invalidClicks->Display2d(viewportInfo, debugDisplay);
     }
 
     void EditorHelpers::DisplayHelpers(
@@ -217,7 +263,7 @@ namespace AzToolsFramework
             {
                 const AZ::EntityId entityId = m_entityDataCache->GetVisibleEntityId(entityCacheIndex);
 
-                if (!m_entityDataCache->IsVisibleEntityVisible(entityCacheIndex))
+                if (!m_entityDataCache->IsVisibleEntityVisible(entityCacheIndex) || !IsSelectableInViewport(entityId))
                 {
                     continue;
                 }
@@ -263,4 +309,24 @@ namespace AzToolsFramework
             }
         }
     }
+
+    bool EditorHelpers::IsSelectableInViewport(const AZ::EntityId entityId) const
+    {
+        return IsSelectableAccordingToFocusMode(entityId) && IsSelectableAccordingToContainerEntities(entityId);
+    }
+
+    bool EditorHelpers::IsSelectableAccordingToFocusMode(const AZ::EntityId entityId) const
+    {
+        return m_focusModeInterface->IsInFocusSubTree(entityId);
+    }
+
+    bool EditorHelpers::IsSelectableAccordingToContainerEntities(const AZ::EntityId entityId) const
+    {
+        if (const auto* containerEntityInterface = AZ::Interface<ContainerEntityInterface>::Get())
+        {
+            return !containerEntityInterface->IsUnderClosedContainerEntity(entityId);
+        }
+
+        return true;
+    }
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorHelpers.h

@@ -11,6 +11,9 @@
 #include <AzCore/Component/EntityId.h>
 #include <AzCore/Memory/Memory.h>
 #include <AzCore/std/functional.h>
+#include <AzCore/std/containers/vector.h>
+#include <AzFramework/Viewport/ScreenGeometry.h>
+#include <AzToolsFramework/ViewportSelection/InvalidClicks.h>
 
 namespace AzFramework
 {
@@ -29,6 +32,28 @@ namespace AzToolsFramework
         struct MouseInteractionEvent;
     }
 
+    //!< Represents the result of a query to find the id of the entity under the cursor (if any).
+    class CursorEntityIdQuery
+    {
+    public:
+        CursorEntityIdQuery(AZ::EntityId entityId, AZ::EntityId rootEntityId);
+
+        //! Returns the entity id under the cursor (if any).
+        //! @note In the case of no entity id under the cursor, an invalid entity id is returned.
+        AZ::EntityId EntityIdUnderCursor() const;
+
+        //! Returns the topmost container entity id in the hierarchy if the entity id under the cursor is inside a container entity, otherwise returns the entity id.
+        //! @note In the case of no entity id under the cursor, an invalid entity id is returned.
+        AZ::EntityId ContainerAncestorEntityId() const;
+
+        //! Returns true if the query has a container ancestor entity id, otherwise false.
+        bool HasContainerAncestorEntityId() const;
+
+    private:
+        AZ::EntityId m_entityId; //<! The entity id under the cursor.
+        AZ::EntityId m_containerAncestorEntityId; //<! For entities in container entities, the topmost container entity id in the hierarchy, otherwise the entity id under the cursor.
+    };
+
     //! EditorHelpers are the visualizations that appear for entities
     //! when 'Display Helpers' is toggled on inside the editor.
     //! These include but are not limited to entity icons and shape visualizations.
@@ -44,9 +69,9 @@ namespace AzToolsFramework
         EditorHelpers& operator=(const EditorHelpers&) = delete;
         ~EditorHelpers() = default;
 
-        //! Handle any mouse interaction with the EditorHelpers.
+        //! Finds the id of the entity under the cursor (if any). For entities in container entities, also finds the topmost container entity id in the hierarchy.
         //! Used to check if a particular entity was selected.
-        AZ::EntityId HandleMouseInteraction(
+        CursorEntityIdQuery FindEntityIdUnderCursor(
             const AzFramework::CameraState& cameraState, const ViewportInteraction::MouseInteractionEvent& mouseInteraction);
 
         //! Do the drawing responsible for the EditorHelpers.
@@ -58,8 +83,27 @@ namespace AzToolsFramework
             AzFramework::DebugDisplayRequests& debugDisplay,
             const AZStd::function<bool(AZ::EntityId)>& showIconCheck);
 
+        //! Handle 2d drawing for EditorHelper functionality.
+        void Display2d(
+            const AzFramework::ViewportInfo& viewportInfo,
+            AzFramework::DebugDisplayRequests& debugDisplay);
+
+        //! Returns whether the entityId can be selected in the viewport according
+        //! to the current Editor Focus Mode and Container Entity setup.
+        bool IsSelectableInViewport(AZ::EntityId entityId) const;
+
     private:
+        //! Returns whether the entityId can be selected in the viewport according
+        //! to the current Editor Focus Mode setup.
+        bool IsSelectableAccordingToFocusMode(AZ::EntityId entityId) const;
+
+        //! Returns whether the entityId can be selected in the viewport according
+        //! to the current Container Entity setup.
+        bool IsSelectableAccordingToContainerEntities(AZ::EntityId entityId) const;
+
+        AZStd::unique_ptr<InvalidClicks> m_invalidClicks; //!< Display for invalid click behavior.
+
         const EditorVisibleEntityDataCache* m_entityDataCache = nullptr; //!< Entity Data queried by the EditorHelpers.
-        const FocusModeInterface* m_focusModeInterface = nullptr;
+        const FocusModeInterface* m_focusModeInterface = nullptr; //!< API to interact with focus mode functionality.
     };
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorPickEntitySelection.cpp

@@ -80,7 +80,7 @@ namespace AzToolsFramework
 
         const AzFramework::CameraState cameraState = GetCameraState(viewportId);
 
-        m_cachedEntityIdUnderCursor = m_editorHelpers->HandleMouseInteraction(cameraState, mouseInteraction);
+        m_cachedEntityIdUnderCursor = m_editorHelpers->FindEntityIdUnderCursor(cameraState, mouseInteraction).ContainerAncestorEntityId();
 
         // when left clicking, if we successfully clicked an entity, assign that
         // to the entity field selected in the entity inspector (RPE)

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

@@ -27,6 +27,7 @@
 #include <AzToolsFramework/Manipulators/ScaleManipulators.h>
 #include <AzToolsFramework/Manipulators/TranslationManipulators.h>
 #include <AzToolsFramework/Maths/TransformUtils.h>
+#include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
 #include <AzToolsFramework/ToolsComponents/EditorLockComponentBus.h>
 #include <AzToolsFramework/ToolsComponents/EditorVisibilityBus.h>
 #include <AzToolsFramework/ToolsComponents/TransformComponent.h>
@@ -407,7 +408,7 @@ namespace AzToolsFramework
             const AzFramework::CameraState cameraState = GetCameraState(viewportId);
             for (size_t entityCacheIndex = 0; entityCacheIndex < entityDataCache.VisibleEntityDataCount(); ++entityCacheIndex)
             {
-                if (entityDataCache.IsVisibleEntityLocked(entityCacheIndex) || !entityDataCache.IsVisibleEntityVisible(entityCacheIndex))
+                if (!entityDataCache.IsVisibleEntitySelectableInViewport(entityCacheIndex))
                 {
                     continue;
                 }
@@ -1023,7 +1024,7 @@ namespace AzToolsFramework
         EditorTransformComponentSelectionRequestBus::Handler::BusConnect(entityContextId);
         ToolsApplicationNotificationBus::Handler::BusConnect();
         Camera::EditorCameraNotificationBus::Handler::BusConnect();
-        ComponentModeFramework::EditorComponentModeNotificationBus::Handler::BusConnect(entityContextId);
+        ViewportEditorModeNotificationsBus::Handler::BusConnect(entityContextId);
         EditorEntityContextNotificationBus::Handler::BusConnect();
         EditorEntityVisibilityNotificationBus::Router::BusRouterConnect();
         EditorEntityLockComponentNotificationBus::Router::BusRouterConnect();
@@ -1071,7 +1072,7 @@ namespace AzToolsFramework
         EditorEntityLockComponentNotificationBus::Router::BusRouterDisconnect();
         EditorEntityVisibilityNotificationBus::Router::BusRouterDisconnect();
         EditorEntityContextNotificationBus::Handler::BusDisconnect();
-        ComponentModeFramework::EditorComponentModeNotificationBus::Handler::BusDisconnect();
+        ViewportEditorModeNotificationsBus::Handler::BusDisconnect();
         Camera::EditorCameraNotificationBus::Handler::BusDisconnect();
         ToolsApplicationNotificationBus::Handler::BusDisconnect();
         EditorTransformComponentSelectionRequestBus::Handler::BusDisconnect();
@@ -1113,7 +1114,7 @@ namespace AzToolsFramework
             });
 
         m_boxSelect.InstallLeftMouseUp(
-            [this, entityBoxSelectData]()
+            [this, entityBoxSelectData]
             {
                 entityBoxSelectData->m_boxSelectSelectionCommand->UpdateSelection(EntityIdVectorFromContainer(m_selectedEntityIds));
 
@@ -1799,7 +1800,8 @@ namespace AzToolsFramework
         const AzFramework::ViewportId viewportId = mouseInteraction.m_mouseInteraction.m_interactionId.m_viewportId;
         const AzFramework::CameraState cameraState = GetCameraState(viewportId);
 
-        m_cachedEntityIdUnderCursor = m_editorHelpers->HandleMouseInteraction(cameraState, mouseInteraction);
+        const auto cursorEntityIdQuery = m_editorHelpers->FindEntityIdUnderCursor(cameraState, mouseInteraction);
+        m_cachedEntityIdUnderCursor = cursorEntityIdQuery.ContainerAncestorEntityId();
 
         const auto selectClickEvent = ClickDetectorEventFromViewportInteraction(mouseInteraction);
         m_cursorState.SetCurrentPosition(mouseInteraction.m_mouseInteraction.m_mousePick.m_screenCoordinates);
@@ -1825,8 +1827,6 @@ namespace AzToolsFramework
             }
         }
 
-        const AZ::EntityId entityIdUnderCursor = m_cachedEntityIdUnderCursor;
-
         EditorContextMenuUpdate(m_contextMenu, mouseInteraction);
 
         m_boxSelect.HandleMouseInteraction(mouseInteraction);
@@ -1842,6 +1842,21 @@ namespace AzToolsFramework
             return true;
         }
 
+        const AZ::EntityId entityIdUnderCursor = m_cachedEntityIdUnderCursor;
+
+        if (mouseInteraction.m_mouseEvent == ViewportInteraction::MouseEvent::DoubleClick &&
+            mouseInteraction.m_mouseInteraction.m_mouseButtons.Left())
+        {
+            if (cursorEntityIdQuery.HasContainerAncestorEntityId())
+            {
+                if (auto prefabFocusInterface = AZ::Interface<Prefab::PrefabFocusInterface>::Get())
+                {
+                    prefabFocusInterface->FocusOnPrefabInstanceOwningEntityId(cursorEntityIdQuery.ContainerAncestorEntityId());
+                    return false;
+                }
+            }
+        }
+
         bool stickySelect = false;
         ViewportInteraction::ViewportSettingsRequestBus::EventResult(
             stickySelect, viewportId, &ViewportInteraction::ViewportSettingsRequestBus::Events::StickySelectEnabled);
@@ -2171,7 +2186,7 @@ namespace AzToolsFramework
         // lock selection
         AddAction(
             m_actions, { QKeySequence(Qt::Key_L) }, LockSelection, LockSelectionTitle, LockSelectionDesc,
-            [lockUnlock]()
+            [lockUnlock]
             {
                 lockUnlock(true);
             });
@@ -2179,7 +2194,7 @@ namespace AzToolsFramework
         // unlock selection
         AddAction(
             m_actions, { QKeySequence(Qt::CTRL + Qt::Key_L) }, UnlockSelection, LockSelectionTitle, LockSelectionDesc,
-            [lockUnlock]()
+            [lockUnlock]
             {
                 lockUnlock(false);
             });
@@ -2209,7 +2224,7 @@ namespace AzToolsFramework
         // hide selection
         AddAction(
             m_actions, { QKeySequence(Qt::Key_H) }, HideSelection, HideSelectionTitle, HideSelectionDesc,
-            [showHide]()
+            [showHide]
             {
                 showHide(false);
             });
@@ -2217,7 +2232,7 @@ namespace AzToolsFramework
         // show selection
         AddAction(
             m_actions, { QKeySequence(Qt::CTRL + Qt::Key_H) }, ShowSelection, HideSelectionTitle, HideSelectionDesc,
-            [showHide]()
+            [showHide]
             {
                 showHide(true);
             });
@@ -2225,7 +2240,7 @@ namespace AzToolsFramework
         // unlock all entities in the level/scene
         AddAction(
             m_actions, { QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_L) }, UnlockAll, UnlockAllTitle, UnlockAllDesc,
-            []()
+            []
             {
                 AZ_PROFILE_FUNCTION(AzToolsFramework);
 
@@ -2242,14 +2257,14 @@ namespace AzToolsFramework
         // show all entities in the level/scene
         AddAction(
             m_actions, { QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_H) }, ShowAll, ShowAllTitle, ShowAllDesc,
-            []()
+            []
             {
                 AZ_PROFILE_FUNCTION(AzToolsFramework);
 
                 ScopedUndoBatch undoBatch(ShowAllEntitiesUndoRedoDesc);
 
                 EnumerateEditorEntities(
-                    [](AZ::EntityId entityId)
+                    [](const AZ::EntityId entityId)
                     {
                         ScopedUndoBatch::MarkEntityDirty(entityId);
                         SetEntityVisibility(entityId, true);
@@ -2259,7 +2274,7 @@ namespace AzToolsFramework
         // select all entities in the level/scene
         AddAction(
             m_actions, { QKeySequence(Qt::CTRL + Qt::Key_A) }, SelectAll, SelectAllTitle, SelectAllDesc,
-            [this]()
+            [this]
             {
                 AZ_PROFILE_FUNCTION(AzToolsFramework);
 
@@ -2299,7 +2314,7 @@ namespace AzToolsFramework
         // invert current selection
         AddAction(
             m_actions, { QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_I) }, InvertSelect, InvertSelectionTitle, InvertSelectionDesc,
-            [this]()
+            [this]
             {
                 AZ_PROFILE_FUNCTION(AzToolsFramework);
 
@@ -2346,17 +2361,10 @@ namespace AzToolsFramework
         // duplicate selection
         AddAction(
             m_actions, { QKeySequence(Qt::CTRL + Qt::Key_D) }, DuplicateSelect, DuplicateTitle, DuplicateDesc,
-            []()
+            []
             {
                 AZ_PROFILE_FUNCTION(AzToolsFramework);
 
-                // Clear Widget selection - Prevents issues caused by cloning entities while a property in the Reflected Property Editor
-                // is being edited.
-                if (QApplication::focusWidget())
-                {
-                    QApplication::focusWidget()->clearFocus();
-                }
-
                 ScopedUndoBatch undoBatch(DuplicateUndoRedoDesc);
                 auto selectionCommand = AZStd::make_unique<SelectionCommand>(EntityIdList(), DuplicateUndoRedoDesc);
                 selectionCommand->SetParent(undoBatch.GetUndoBatch());
@@ -2371,7 +2379,7 @@ namespace AzToolsFramework
         // delete selection
         AddAction(
             m_actions, { QKeySequence(Qt::Key_Delete) }, DeleteSelect, DeleteTitle, DeleteDesc,
-            [this]()
+            [this]
             {
                 AZ_PROFILE_FUNCTION(AzToolsFramework);
 
@@ -2388,21 +2396,21 @@ namespace AzToolsFramework
 
         AddAction(
             m_actions, { QKeySequence(Qt::Key_Space) }, EditEscaspe, "", "",
-            [this]()
+            [this]
             {
                 DeselectEntities();
             });
 
         AddAction(
             m_actions, { QKeySequence(Qt::Key_P) }, EditPivot, TogglePivotTitleEditMenu, TogglePivotDesc,
-            [this]()
+            [this]
             {
                 ToggleCenterPivotSelection();
             });
 
         AddAction(
             m_actions, { QKeySequence(Qt::Key_R) }, EditReset, ResetEntityTransformTitle, ResetEntityTransformDesc,
-            [this]()
+            [this]
             {
                 switch (m_mode)
                 {
@@ -2427,7 +2435,7 @@ namespace AzToolsFramework
 
         AddAction(
             m_actions, { QKeySequence(Qt::Key_U) }, ViewportUiVisible, "Toggle Viewport UI", "Hide/Show Viewport UI",
-            [this]()
+            [this]
             {
                 SetAllViewportUiVisible(!m_viewportUiVisible);
             });
@@ -3236,7 +3244,7 @@ namespace AzToolsFramework
         QAction* action = menu->addAction(QObject::tr(TogglePivotTitleRightClick));
         QObject::connect(
             action, &QAction::triggered, action,
-            [this]()
+            [this]
             {
                 ToggleCenterPivotSelection();
             });
@@ -3567,6 +3575,8 @@ namespace AzToolsFramework
         DrawAxisGizmo(viewportInfo, debugDisplay);
 
         m_boxSelect.Display2d(viewportInfo, debugDisplay);
+
+        m_editorHelpers->Display2d(viewportInfo, debugDisplay);
     }
 
     void EditorTransformComponentSelection::RefreshSelectedEntityIds()
@@ -3667,22 +3677,67 @@ namespace AzToolsFramework
         m_selectedEntityIdsAndManipulatorsDirty = true;
     }
 
-    void EditorTransformComponentSelection::EnteredComponentMode([[maybe_unused]] const AZStd::vector<AZ::Uuid>& componentModeTypes)
+    void EditorTransformComponentSelection::OnEditorModeActivated(
+        [[maybe_unused]] const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode)
     {
-        SetAllViewportUiVisible(false);
+        switch (mode)
+        {
+        case ViewportEditorMode::Component:
+            {
+                SetAllViewportUiVisible(false);
 
-        EditorEntityLockComponentNotificationBus::Router::BusRouterDisconnect();
-        EditorEntityVisibilityNotificationBus::Router::BusRouterDisconnect();
-        ToolsApplicationNotificationBus::Handler::BusDisconnect();
+                EditorEntityLockComponentNotificationBus::Router::BusRouterDisconnect();
+                EditorEntityVisibilityNotificationBus::Router::BusRouterDisconnect();
+                ToolsApplicationNotificationBus::Handler::BusDisconnect();
+            }
+            break;
+        case ViewportEditorMode::Focus:
+            {
+                ViewportUi::ViewportUiRequestBus::Event(
+                    ViewportUi::DefaultViewportId, &ViewportUi::ViewportUiRequestBus::Events::CreateViewportBorder, "Focus Mode");
+            }
+            break;
+        case ViewportEditorMode::Default:
+        case ViewportEditorMode::Pick:
+            // noop
+            break;
+        }
     }
 
-    void EditorTransformComponentSelection::LeftComponentMode([[maybe_unused]] const AZStd::vector<AZ::Uuid>& componentModeTypes)
+    void EditorTransformComponentSelection::OnEditorModeDeactivated(
+        const ViewportEditorModesInterface& editorModeState, const ViewportEditorMode mode)
     {
-        SetAllViewportUiVisible(true);
+        switch (mode)
+        {
+        case ViewportEditorMode::Component:
+            {
+                SetAllViewportUiVisible(true);
 
-        ToolsApplicationNotificationBus::Handler::BusConnect();
-        EditorEntityVisibilityNotificationBus::Router::BusRouterConnect();
-        EditorEntityLockComponentNotificationBus::Router::BusRouterConnect();
+                ToolsApplicationNotificationBus::Handler::BusConnect();
+                EditorEntityVisibilityNotificationBus::Router::BusRouterConnect();
+                EditorEntityLockComponentNotificationBus::Router::BusRouterConnect();
+
+                // note: when leaving component mode, we check if we're still in focus mode (i.e. component mode was
+                // started from within focus mode), if we are, ensure we create/update the viewport border (as leaving
+                // component mode will attempt to remove it)
+                if (editorModeState.IsModeActive(ViewportEditorMode::Focus))
+                {
+                    ViewportUi::ViewportUiRequestBus::Event(
+                        ViewportUi::DefaultViewportId, &ViewportUi::ViewportUiRequestBus::Events::CreateViewportBorder, "Focus Mode");
+                }
+            }
+            break;
+        case ViewportEditorMode::Focus:
+            {
+                ViewportUi::ViewportUiRequestBus::Event(
+                    ViewportUi::DefaultViewportId, &ViewportUi::ViewportUiRequestBus::Events::RemoveViewportBorder);
+            }
+            break;
+        case ViewportEditorMode::Default:
+        case ViewportEditorMode::Pick:
+            // noop
+            break;
+        }
     }
 
     void EditorTransformComponentSelection::CreateEntityManipulatorDeselectCommand(ScopedUndoBatch& undoBatch)

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

@@ -18,7 +18,7 @@
 #include <AzFramework/Viewport/CursorState.h>
 #include <AzToolsFramework/API/EditorCameraBus.h>
 #include <AzToolsFramework/Commands/EntityManipulatorCommand.h>
-#include <AzToolsFramework/ComponentMode/EditorComponentModeBus.h>
+#include <AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h>
 #include <AzToolsFramework/Editor/EditorContextMenuBus.h>
 #include <AzToolsFramework/Manipulators/BaseManipulator.h>
 #include <AzToolsFramework/ToolsComponents/EditorLockComponentBus.h>
@@ -153,7 +153,7 @@ namespace AzToolsFramework
         , private EditorTransformComponentSelectionRequestBus::Handler
         , private ToolsApplicationNotificationBus::Handler
         , private Camera::EditorCameraNotificationBus::Handler
-        , private ComponentModeFramework::EditorComponentModeNotificationBus::Handler
+        , private ViewportEditorModeNotificationsBus::Handler
         , private EditorEntityContextNotificationBus::Handler
         , private EditorEntityVisibilityNotificationBus::Router
         , private EditorEntityLockComponentNotificationBus::Router
@@ -286,9 +286,9 @@ namespace AzToolsFramework
         // EditorContextLockComponentNotificationBus overrides ...
         void OnEntityLockChanged(bool locked) override;
 
-        // EditorComponentModeNotificationBus overrides ...
-        void EnteredComponentMode(const AZStd::vector<AZ::Uuid>& componentModeTypes) override;
-        void LeftComponentMode(const AZStd::vector<AZ::Uuid>& componentModeTypes) override;
+        // ViewportEditorModeNotificationsBus overrides ...
+        void OnEditorModeActivated(const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override;
+        void OnEditorModeDeactivated(const ViewportEditorModesInterface& editorModeState, ViewportEditorMode mode) override;
 
         // EditorEntityContextNotificationBus overrides ...
         void OnStartPlayInEditor() override;

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorVisibleEntityDataCache.cpp

@@ -9,7 +9,9 @@
 #include "EditorVisibleEntityDataCache.h"
 
 #include <AzCore/std/sort.h>
+#include <AzToolsFramework/ContainerEntity/ContainerEntityInterface.h>
 #include <AzToolsFramework/Entity/EditorEntityModel.h>
+#include <AzToolsFramework/FocusMode/FocusModeInterface.h>
 #include <AzToolsFramework/Viewport/ViewportMessages.h>
 #include <Entity/EditorEntityHelpers.h>
 
@@ -21,13 +23,23 @@ namespace AzToolsFramework
         using ComponentEntityAccentType = Components::EditorSelectionAccentSystemComponent::ComponentEntityAccentType;
 
         EntityData() = default;
-        EntityData(AZ::EntityId entityId, const AZ::Transform& worldFromLocal, bool locked, bool visible, bool selected, bool iconHidden);
+        EntityData(
+            AZ::EntityId entityId,
+            const AZ::Transform& worldFromLocal,
+            bool locked,
+            bool visible,
+            bool inFocus,
+            bool descendantOfClosedContainer,
+            bool selected,
+            bool iconHidden);
 
         AZ::Transform m_worldFromLocal;
         AZ::EntityId m_entityId;
         ComponentEntityAccentType m_accent = ComponentEntityAccentType::None;
         bool m_locked = false;
         bool m_visible = true;
+        bool m_inFocus = true;
+        bool m_descendantOfClosedContainer = false;
         bool m_selected = false;
         bool m_iconHidden = false;
     };
@@ -57,12 +69,16 @@ namespace AzToolsFramework
         const AZ::Transform& worldFromLocal,
         const bool locked,
         const bool visible,
+        const bool inFocus,
+        const bool descendantOfClosedContainer,
         const bool selected,
         const bool iconHidden)
         : m_worldFromLocal(worldFromLocal)
         , m_entityId(entityId)
         , m_locked(locked)
         , m_visible(visible)
+        , m_inFocus(inFocus)
+        , m_descendantOfClosedContainer(descendantOfClosedContainer)
         , m_selected(selected)
         , m_iconHidden(iconHidden)
     {
@@ -106,6 +122,18 @@ namespace AzToolsFramework
         bool locked = false;
         EditorEntityInfoRequestBus::EventResult(locked, entityId, &EditorEntityInfoRequestBus::Events::IsLocked);
 
+        bool inFocus = false;
+        if (auto focusModeInterface = AZ::Interface<FocusModeInterface>::Get())
+        {
+            inFocus = focusModeInterface->IsInFocusSubTree(entityId);
+        }
+
+        bool descendantOfClosedContainer = false;
+        if (ContainerEntityInterface* containerEntityInterface = AZ::Interface<ContainerEntityInterface>::Get())
+        {
+            descendantOfClosedContainer = containerEntityInterface->IsUnderClosedContainerEntity(entityId);
+        }
+
         bool iconHidden = false;
         EditorEntityIconComponentRequestBus::EventResult(
             iconHidden, entityId, &EditorEntityIconComponentRequests::IsEntityIconHiddenInViewport);
@@ -113,7 +141,7 @@ namespace AzToolsFramework
         AZ::Transform worldFromLocal = AZ::Transform::CreateIdentity();
         AZ::TransformBus::EventResult(worldFromLocal, entityId, &AZ::TransformBus::Events::GetWorldTM);
 
-        return { entityId, worldFromLocal, locked, visible, IsSelected(entityId), iconHidden };
+        return { entityId, worldFromLocal, locked, visible, inFocus, descendantOfClosedContainer, IsSelected(entityId), iconHidden };
     }
 
     EditorVisibleEntityDataCache::EditorVisibleEntityDataCache()
@@ -126,10 +154,17 @@ namespace AzToolsFramework
         EntitySelectionEvents::Bus::Router::BusRouterConnect();
         EditorEntityIconComponentNotificationBus::Router::BusRouterConnect();
         ToolsApplicationNotificationBus::Handler::BusConnect();
+
+        AzFramework::EntityContextId editorEntityContextId = AzToolsFramework::GetEntityContextId();
+
+        ContainerEntityNotificationBus::Handler::BusConnect(editorEntityContextId);
+        FocusModeNotificationBus::Handler::BusConnect(editorEntityContextId);
     }
 
     EditorVisibleEntityDataCache::~EditorVisibleEntityDataCache()
     {
+        FocusModeNotificationBus::Handler::BusDisconnect();
+        ContainerEntityNotificationBus::Handler::BusDisconnect();
         ToolsApplicationNotificationBus::Handler::BusDisconnect();
         EditorEntityIconComponentNotificationBus::Router::BusRouterDisconnect();
         EntitySelectionEvents::Bus::Router::BusRouterDisconnect();
@@ -260,7 +295,10 @@ namespace AzToolsFramework
 
     bool EditorVisibleEntityDataCache::IsVisibleEntitySelectableInViewport(size_t index) const
     {
-        return m_impl->m_visibleEntityDatas[index].m_visible && !m_impl->m_visibleEntityDatas[index].m_locked;
+        return m_impl->m_visibleEntityDatas[index].m_visible
+            && !m_impl->m_visibleEntityDatas[index].m_locked
+            && m_impl->m_visibleEntityDatas[index].m_inFocus
+            && !m_impl->m_visibleEntityDatas[index].m_descendantOfClosedContainer;
     }
 
     AZStd::optional<size_t> EditorVisibleEntityDataCache::GetVisibleEntityIndexFromId(const AZ::EntityId entityId) const
@@ -371,4 +409,72 @@ namespace AzToolsFramework
             m_impl->m_visibleEntityDatas[entityIndex.value()].m_iconHidden = iconHidden;
         }
     }
+
+    void EditorVisibleEntityDataCache::OnContainerEntityStatusChanged(AZ::EntityId entityId, [[maybe_unused]] bool open)
+    {
+        // Get container descendants
+        AzToolsFramework::EntityIdList descendantIds;
+        AZ::TransformBus::EventResult(descendantIds, entityId, &AZ::TransformBus::Events::GetAllDescendants);
+
+        // Update cached values
+        if (auto containerEntityInterface = AZ::Interface<ContainerEntityInterface>::Get())
+        {
+            for (AZ::EntityId descendantId : descendantIds)
+            {
+                if (AZStd::optional<size_t> entityIndex = GetVisibleEntityIndexFromId(descendantId))
+                {
+                    m_impl->m_visibleEntityDatas[entityIndex.value()].m_descendantOfClosedContainer =
+                        containerEntityInterface->IsUnderClosedContainerEntity(descendantId);
+                }
+            }
+        }
+    }
+
+    void EditorVisibleEntityDataCache::OnEditorFocusChanged(AZ::EntityId previousFocusEntityId, AZ::EntityId newFocusEntityId)
+    {
+        if (previousFocusEntityId.IsValid() && newFocusEntityId.IsValid())
+        {
+            // Get previous focus root descendants
+            AzToolsFramework::EntityIdList previousDescendantIds;
+            AZ::TransformBus::EventResult(previousDescendantIds, previousFocusEntityId, &AZ::TransformBus::Events::GetAllDescendants);
+
+            // Get new focus root descendants
+            AzToolsFramework::EntityIdList newDescendantIds;
+            AZ::TransformBus::EventResult(newDescendantIds, newFocusEntityId, &AZ::TransformBus::Events::GetAllDescendants);
+
+            // Merge EntityId Lists to avoid refreshing values twice
+            AzToolsFramework::EntityIdSet descendantsSet;
+            descendantsSet.insert(previousFocusEntityId);
+            descendantsSet.insert(newFocusEntityId);
+            descendantsSet.insert(previousDescendantIds.begin(), previousDescendantIds.end());
+            descendantsSet.insert(newDescendantIds.begin(), newDescendantIds.end());
+
+            // Update cached values
+            if (auto focusModeInterface = AZ::Interface<FocusModeInterface>::Get())
+            {
+                for (const AZ::EntityId& descendantId : descendantsSet)
+                {
+                    if (AZStd::optional<size_t> entityIndex = GetVisibleEntityIndexFromId(descendantId))
+                    {
+                        m_impl->m_visibleEntityDatas[entityIndex.value()].m_inFocus = focusModeInterface->IsInFocusSubTree(descendantId);
+                    }
+                }
+            }
+        }
+        else
+        {
+            // If either focus was the invalid entity, refresh all entities.
+            if (auto focusModeInterface = AZ::Interface<FocusModeInterface>::Get())
+            {
+                for (size_t entityIndex = 0; entityIndex < m_impl->m_visibleEntityDatas.size(); ++entityIndex)
+                {
+                    if (AZ::EntityId descendantId = GetVisibleEntityId(entityIndex); descendantId.IsValid())
+                    {
+                        m_impl->m_visibleEntityDatas[entityIndex].m_inFocus = focusModeInterface->IsInFocusSubTree(descendantId);
+                    }
+                }
+            }
+        }
+    }
+
 } // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorVisibleEntityDataCache.h

@@ -11,6 +11,8 @@
 #include <AzCore/Component/TransformBus.h>
 #include <AzCore/std/optional.h>
 #include <AzToolsFramework/API/ComponentEntitySelectionBus.h>
+#include <AzToolsFramework/ContainerEntity/ContainerEntityNotificationBus.h>
+#include <AzToolsFramework/FocusMode/FocusModeNotificationBus.h>
 #include <AzToolsFramework/ToolsComponents/EditorEntityIconComponentBus.h>
 #include <AzToolsFramework/ToolsComponents/EditorLockComponentBus.h>
 #include <AzToolsFramework/ToolsComponents/EditorSelectionAccentSystemComponent.h>
@@ -28,6 +30,8 @@ namespace AzToolsFramework
         , private EntitySelectionEvents::Bus::Router
         , private EditorEntityIconComponentNotificationBus::Router
         , private ToolsApplicationNotificationBus::Handler
+        , private ContainerEntityNotificationBus::Handler
+        , private FocusModeNotificationBus::Handler
     {
     public:
         EditorVisibleEntityDataCache();
@@ -58,28 +62,34 @@ namespace AzToolsFramework
         void AddEntityIds(const EntityIdList& entityIds);
 
     private:
-        // ToolsApplicationNotificationBus
+        // ToolsApplicationNotificationBus overrides ...
         void AfterUndoRedo() override;
 
-        // EditorEntityVisibilityNotificationBus
+        // EditorEntityVisibilityNotificationBus overrides ...
         void OnEntityVisibilityChanged(bool visibility) override;
 
-        // EditorEntityLockComponentNotificationBus
+        // EditorEntityLockComponentNotificationBus overrides ...
         void OnEntityLockChanged(bool locked) override;
 
-        // TransformNotificationBus
+        // TransformNotificationBus overrides ...
         void OnTransformChanged(const AZ::Transform& local, const AZ::Transform& world) override;
 
-        // EditorComponentSelectionNotificationsBus
+        // EditorComponentSelectionNotificationsBus overrides ...
         void OnAccentTypeChanged(EntityAccentType accent) override;
 
-        // EntitySelectionEvents::Bus
+        // EntitySelectionEvents::Bus overrides ...
         void OnSelected() override;
         void OnDeselected() override;
 
-        // EditorEntityIconComponentNotificationBus
+        // EditorEntityIconComponentNotificationBus overrides ...
         void OnEntityIconChanged(const AZ::Data::AssetId& entityIconAssetId) override;
 
+        // ContainerEntityNotificationBus overrides ...
+        void OnContainerEntityStatusChanged(AZ::EntityId entityId, bool open) override;
+
+        // FocusModeNotificationBus overrides ...
+        void OnEditorFocusChanged(AZ::EntityId previousFocusEntityId, AZ::EntityId newFocusEntityId) override;
+
         class EditorVisibleEntityDataCacheImpl;
         AZStd::unique_ptr<EditorVisibleEntityDataCacheImpl> m_impl; //!< Internal representation of entity data cache.
     };

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/InvalidClicks.cpp

@@ -0,0 +1,142 @@
+/*
+ * 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/Console/Console.h>
+#include <AzFramework/Entity/EntityDebugDisplayBus.h>
+#include <AzToolsFramework/Viewport/ViewportTypes.h>
+#include <AzToolsFramework/ViewportSelection/EditorSelectionUtil.h>
+#include <AzToolsFramework/ViewportSelection/InvalidClicks.h>
+
+AZ_CVAR(float, ed_invalidClickRadius, 10.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "Maximum invalid click radius to expand to");
+AZ_CVAR(float, ed_invalidClickDuration, 1.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "Duration to display the invalid click feedback");
+AZ_CVAR(float, ed_invalidClickMessageSize, 0.8f, nullptr, AZ::ConsoleFunctorFlags::Null, "Size of text for invalid message");
+AZ_CVAR(
+    float,
+    ed_invalidClickMessageVerticalOffset,
+    30.0f,
+    nullptr,
+    AZ::ConsoleFunctorFlags::Null,
+    "Vertical offset from cursor of invalid click message");
+
+namespace AzToolsFramework
+{
+    void ExpandingFadingCircles::Begin(const AzFramework::ScreenPoint& screenPoint)
+    {
+        FadingCircle fadingCircle;
+        fadingCircle.m_position = screenPoint;
+        fadingCircle.m_opacity = 1.0f;
+        fadingCircle.m_radius = 0.0f;
+        m_fadingCircles.push_back(fadingCircle);
+    }
+
+    void ExpandingFadingCircles::Update(const float deltaTime)
+    {
+        for (auto& fadingCircle : m_fadingCircles)
+        {
+            fadingCircle.m_opacity = AZStd::max(fadingCircle.m_opacity - (deltaTime / ed_invalidClickDuration), 0.0f);
+            fadingCircle.m_radius += deltaTime * ed_invalidClickRadius;
+        }
+
+        m_fadingCircles.erase(
+            AZStd::remove_if(
+                m_fadingCircles.begin(), m_fadingCircles.end(),
+                [](const FadingCircle& fadingCircle)
+                {
+                    return fadingCircle.m_opacity <= 0.0f;
+                }),
+            m_fadingCircles.end());
+    }
+
+    bool ExpandingFadingCircles::Updating()
+    {
+        return !m_fadingCircles.empty();
+    }
+
+    void ExpandingFadingCircles::Display(const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay)
+    {
+        const AZ::Vector2 viewportSize = AzToolsFramework::GetCameraState(viewportInfo.m_viewportId).m_viewportSize;
+
+        for (const auto& fadingCircle : m_fadingCircles)
+        {
+            const auto position = AzFramework::Vector2FromScreenPoint(fadingCircle.m_position) / viewportSize;
+            debugDisplay.SetColor(AZ::Color(1.0f, 1.0f, 1.0f, fadingCircle.m_opacity));
+            debugDisplay.DrawWireCircle2d(position, fadingCircle.m_radius * 0.005f, 0.0f);
+        }
+    }
+
+    void FadingText::Begin(const AzFramework::ScreenPoint& screenPoint)
+    {
+        m_opacity = 1.0f;
+        m_invalidClickPosition = screenPoint;
+    }
+
+    void FadingText::Update(const float deltaTime)
+    {
+        m_opacity -= deltaTime / ed_invalidClickDuration;
+    }
+
+    bool FadingText::Updating()
+    {
+        return m_opacity >= 0.0f;
+    }
+
+    void FadingText::Display(
+        [[maybe_unused]] const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay)
+    {
+        if (constexpr float MinOpacity = 0.05f; m_opacity >= MinOpacity)
+        {
+            debugDisplay.SetColor(AZ::Color(1.0f, 1.0f, 1.0f, m_opacity));
+            debugDisplay.Draw2dTextLabel(
+                aznumeric_cast<float>(m_invalidClickPosition.m_x),
+                aznumeric_cast<float>(m_invalidClickPosition.m_y) - ed_invalidClickMessageVerticalOffset, ed_invalidClickMessageSize,
+                m_message.c_str(), true);
+        }
+    }
+
+    void InvalidClicks::AddInvalidClick(const AzFramework::ScreenPoint& screenPoint)
+    {
+        AZ::TickBus::Handler::BusConnect();
+
+        for (auto& invalidClickBehavior : m_invalidClickBehaviors)
+        {
+            invalidClickBehavior->Begin(screenPoint);
+        }
+    }
+
+    void InvalidClicks::OnTick(const float deltaTime, [[maybe_unused]] const AZ::ScriptTimePoint time)
+    {
+        for (auto& invalidClickBehavior : m_invalidClickBehaviors)
+        {
+            invalidClickBehavior->Update(deltaTime);
+        }
+
+        const auto updating = AZStd::any_of(
+            m_invalidClickBehaviors.begin(), m_invalidClickBehaviors.end(),
+            [](const auto& invalidClickBehavior)
+            {
+                return invalidClickBehavior->Updating();
+            });
+
+        if (!updating && AZ::TickBus::Handler::BusIsConnected())
+        {
+            AZ::TickBus::Handler::BusDisconnect();
+        }
+    }
+
+    void InvalidClicks::Display2d(const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay)
+    {
+        debugDisplay.DepthTestOff();
+
+        for (const auto& invalidClickBehavior : m_invalidClickBehaviors)
+        {
+            invalidClickBehavior->Display(viewportInfo, debugDisplay);
+        }
+
+        debugDisplay.DepthTestOn();
+    }
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/InvalidClicks.h

@@ -0,0 +1,108 @@
+/*
+ * 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/TickBus.h>
+#include <AzFramework/Viewport/ScreenGeometry.h>
+
+namespace AzFramework
+{
+    class DebugDisplayRequests;
+    struct ViewportInfo;
+} // namespace AzFramework
+
+namespace AzToolsFramework
+{
+    namespace ViewportInteraction
+    {
+        struct MouseInteractionEvent;
+    }
+
+    //! An interface to provide invalid click feedback in the editor viewport.
+    class InvalidClick
+    {
+    public:
+        virtual ~InvalidClick() = default;
+
+        //! Begin the feedback.
+        //! @param screenPoint The position of the click in screen coordinates.
+        virtual void Begin(const AzFramework::ScreenPoint& screenPoint) = 0;
+        //! Update the invalid click feedback
+        virtual void Update(float deltaTime) = 0;
+        //! Report if the click feedback is running or not (returning false will signal the TickBus can be disconnected from).
+        virtual bool Updating() = 0;
+        //! Display the click feedback in the viewport.
+        virtual void Display(const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay) = 0;
+    };
+
+    //! Display expanding fading circles for every click of the mouse that is invalid.
+    class ExpandingFadingCircles : public InvalidClick
+    {
+    public:
+        void Begin(const AzFramework::ScreenPoint& screenPoint) override;
+        void Update(float deltaTime) override;
+        bool Updating() override;
+        void Display(const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay) override;
+
+    private:
+        //! Stores a circle representation with a lifetime to grow and fade out over time.
+        struct FadingCircle
+        {
+            AzFramework::ScreenPoint m_position;
+            float m_radius;
+            float m_opacity;
+        };
+
+        using FadingCircles = AZStd::vector<FadingCircle>;
+        FadingCircles m_fadingCircles; //!< Collection of fading circles to draw for clicks that have no effect.
+    };
+
+    //! Display fading text where an invalid click happened.
+    //! @note There is only one fading text, each click will update its position.
+    class FadingText : public InvalidClick
+    {
+    public:
+        explicit FadingText(AZStd::string message)
+            : m_message(AZStd::move(message))
+        {
+        }
+
+        void Begin(const AzFramework::ScreenPoint& screenPoint) override;
+        void Update(float deltaTime) override;
+        bool Updating() override;
+        void Display(const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay) override;
+
+    private:
+        AZStd::string m_message; //!< Message to display for fading text.
+        float m_opacity = 1.0f; //!< The opacity of the invalid click message.
+        AzFramework::ScreenPoint m_invalidClickPosition; //!< The position to display the invalid click message.
+    };
+
+    //! Interface to begin invalid click feedback (will run all added InvalidClick behaviors).
+    class InvalidClicks : private AZ::TickBus::Handler
+    {
+    public:
+        explicit InvalidClicks(AZStd::vector<AZStd::unique_ptr<InvalidClick>> invalidClickBehaviors)
+            : m_invalidClickBehaviors(AZStd::move(invalidClickBehaviors))
+        {
+        }
+
+        //! Add an invalid click and activate one or more of the added invalid click behaviors.
+        void AddInvalidClick(const AzFramework::ScreenPoint& screenPoint);
+
+        //! Handle 2d drawing for EditorHelper functionality.
+        void Display2d(const AzFramework::ViewportInfo& viewportInfo, AzFramework::DebugDisplayRequests& debugDisplay);
+
+    private:
+        //! AZ::TickBus overrides ...
+        void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
+
+        AZStd::vector<AZStd::unique_ptr<InvalidClick>> m_invalidClickBehaviors; //!< Invalid click behaviors to run.
+    };
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportUi/ViewportUiDisplay.cpp

@@ -290,9 +290,9 @@ namespace AzToolsFramework::ViewportUi::Internal
         return false;
     }
 
-    void ViewportUiDisplay::CreateComponentModeBorder(const AZStd::string& borderTitle)
+    void ViewportUiDisplay::CreateViewportBorder(const AZStd::string& borderTitle)
     {
-        AZStd::string styleSheet = AZStd::string::format(
+        const AZStd::string styleSheet = AZStd::string::format(
             "border: %dpx solid %s; border-top: %dpx solid %s;", HighlightBorderSize, HighlightBorderColor, TopHighlightBorderSize,
             HighlightBorderColor);
         m_uiOverlay.setStyleSheet(styleSheet.c_str());
@@ -303,7 +303,7 @@ namespace AzToolsFramework::ViewportUi::Internal
         m_componentModeBorderText.setText(borderTitle.c_str());
     }
 
-    void ViewportUiDisplay::RemoveComponentModeBorder()
+    void ViewportUiDisplay::RemoveViewportBorder()
     {
         m_componentModeBorderText.setVisible(false);
         m_uiOverlay.setStyleSheet("border: none;");
@@ -339,7 +339,7 @@ namespace AzToolsFramework::ViewportUi::Internal
     {
         // no background for the widget else each set of buttons/text-fields/etc would have a black box around them
         SetTransparentBackground(mainWindow);
-        mainWindow->setWindowFlags(Qt::Window | Qt::FramelessWindowHint | Qt::WindowDoesNotAcceptFocus);
+        mainWindow->setWindowFlags(Qt::Tool | Qt::FramelessWindowHint | Qt::WindowDoesNotAcceptFocus);
     }
 
     void ViewportUiDisplay::InitializeUiOverlay()
@@ -420,6 +420,7 @@ namespace AzToolsFramework::ViewportUi::Internal
             m_uiMainWindow.setVisible(true);
             m_uiOverlay.setVisible(true);
         }
+
         m_uiMainWindow.setMask(region);
     }
 
@@ -437,6 +438,7 @@ namespace AzToolsFramework::ViewportUi::Internal
         {
             return element->second;
         }
+
         return ViewportUiElementInfo{ nullptr, InvalidViewportUiElementId, false };
     }
 

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportUi/ViewportUiDisplay.h

@@ -89,8 +89,8 @@ namespace AzToolsFramework::ViewportUi::Internal
         AZStd::shared_ptr<QWidget> GetViewportUiElement(ViewportUiElementId elementId);
         bool IsViewportUiElementVisible(ViewportUiElementId elementId);
 
-        void CreateComponentModeBorder(const AZStd::string& borderTitle);
-        void RemoveComponentModeBorder();
+        void CreateViewportBorder(const AZStd::string& borderTitle);
+        void RemoveViewportBorder();
 
     private:
         void PrepareWidgetForViewportUi(QPointer<QWidget> widget);

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportUi/ViewportUiManager.cpp

@@ -240,14 +240,14 @@ namespace AzToolsFramework::ViewportUi
         }
     }
 
-    void ViewportUiManager::CreateComponentModeBorder(const AZStd::string& borderTitle)
+    void ViewportUiManager::CreateViewportBorder(const AZStd::string& borderTitle)
     {
-        m_viewportUi->CreateComponentModeBorder(borderTitle);
+        m_viewportUi->CreateViewportBorder(borderTitle);
     }
 
-    void ViewportUiManager::RemoveComponentModeBorder()
+    void ViewportUiManager::RemoveViewportBorder()
     {
-        m_viewportUi->RemoveComponentModeBorder();
+        m_viewportUi->RemoveViewportBorder();
     }
 
     void ViewportUiManager::PressButton(ClusterId clusterId, ButtonId buttonId)

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportUi/ViewportUiManager.h

@@ -50,8 +50,8 @@ namespace AzToolsFramework::ViewportUi
         void RegisterTextFieldCallback(TextFieldId textFieldId, AZ::Event<AZStd::string>::Handler& handler) override;
         void RemoveTextField(TextFieldId textFieldId) override;
         void SetTextFieldVisible(TextFieldId textFieldId, bool visible) override;
-        void CreateComponentModeBorder(const AZStd::string& borderTitle) override;
-        void RemoveComponentModeBorder() override;
+        void CreateViewportBorder(const AZStd::string& borderTitle) override;
+        void RemoveViewportBorder() override;
         void PressButton(ClusterId clusterId, ButtonId buttonId) override;
         void PressButton(SwitcherId switcherId, ButtonId buttonId) override;
 

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportUi/ViewportUiRequestBus.h

@@ -78,7 +78,7 @@ namespace AzToolsFramework::ViewportUi
         virtual void RegisterSwitcherEventHandler(SwitcherId switcherId, AZ::Event<ButtonId>::Handler& handler) = 0;
         //! Removes a cluster from the Viewport UI system.
         virtual void RemoveCluster(ClusterId clusterId) = 0;
-        //!
+        //! Removes a switcher from the Viewport UI system.
         virtual void RemoveSwitcher(SwitcherId switcherId) = 0;
         //! Sets the visibility of the cluster.
         virtual void SetClusterVisible(ClusterId clusterId, bool visible) = 0;
@@ -96,12 +96,12 @@ namespace AzToolsFramework::ViewportUi
         //! Sets the visibility of the text field.
         virtual void SetTextFieldVisible(TextFieldId textFieldId, bool visible) = 0;
         //! Create the highlight border for Component Mode.
-        virtual void CreateComponentModeBorder(const AZStd::string& borderTitle) = 0;
+        virtual void CreateViewportBorder(const AZStd::string& borderTitle) = 0;
         //! Remove the highlight border for Component Mode.
-        virtual void RemoveComponentModeBorder() = 0;
-        //! Invoke a button press in a cluster.
+        virtual void RemoveViewportBorder() = 0;
+        //! Invoke a button press on a cluster.
         virtual void PressButton(ClusterId clusterId, ButtonId buttonId) = 0;
-        //!
+        //! Invoke a button press on a switcher.
         virtual void PressButton(SwitcherId switcherId, ButtonId buttonId) = 0;
     };
 

Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake

@@ -30,12 +30,14 @@ set(FILES
     API/AssetDatabaseBus.h
     API/ComponentEntityObjectBus.h
     API/ComponentEntitySelectionBus.h
+    API/ComponentModeCollectionInterface.h
     API/EditorCameraBus.h
     API/EditorCameraBus.cpp
     API/EditorAnimationSystemRequestBus.h
     API/EditorEntityAPI.h
     API/EditorLevelNotificationBus.h
     API/ViewportEditorModeTrackerNotificationBus.h
+    API/ViewportEditorModeTrackerNotificationBus.cpp
     API/EditorVegetationRequestsBus.h
     API/EditorPythonConsoleBus.h
     API/EditorPythonRunnerRequestsBus.h
@@ -551,6 +553,8 @@ set(FILES
     ViewportSelection/EditorTransformComponentSelectionRequestBus.cpp
     ViewportSelection/EditorVisibleEntityDataCache.h
     ViewportSelection/EditorVisibleEntityDataCache.cpp
+    ViewportSelection/InvalidClicks.h
+    ViewportSelection/InvalidClicks.cpp
     ViewportSelection/ViewportEditorModeTracker.cpp
     ViewportSelection/ViewportEditorModeTracker.h
     ToolsFileUtils/ToolsFileUtils.h
@@ -644,6 +648,9 @@ set(FILES
     Prefab/PrefabFocusHandler.cpp
     Prefab/PrefabFocusInterface.h
     Prefab/PrefabFocusNotificationBus.h
+    Prefab/PrefabFocusPublicInterface.h
+    Prefab/PrefabFocusUndo.h
+    Prefab/PrefabFocusUndo.cpp
     Prefab/PrefabIdTypes.h
     Prefab/PrefabLoader.h
     Prefab/PrefabLoader.cpp

Code/Framework/AzToolsFramework/Tests/FocusMode/ContainerEntitySelectionTests.cpp

@@ -0,0 +1,99 @@
+/*
+ * 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 <Tests/FocusMode/EditorFocusModeSelectionFixture.h>
+
+namespace AzToolsFramework
+{
+    TEST_F(EditorFocusModeSelectionFixture, ContainerEntitySelectionTests_FindHighestSelectableEntityWithNoContainers)
+    {
+        // When no containers are in the way, the function will just return the entityId of the entity that was clicked.
+        
+        // Click on Car Entity
+        ClickAtWorldPositionOnViewport(WorldCarEntityPosition);
+
+        // Verify the correct entity is selected
+        auto selectedEntitiesAfter = GetSelectedEntities();
+        EXPECT_EQ(selectedEntitiesAfter.size(), 1);
+        EXPECT_EQ(selectedEntitiesAfter.front(), m_entityMap[CarEntityName]);
+    }
+
+    TEST_F(EditorFocusModeSelectionFixture, ContainerEntitySelectionTests_FindHighestSelectableEntityWithClosedContainer)
+    {
+        // If a closed container is an ancestor of the queried entity, the closed container is selected.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[StreetEntityName]); // Containers are closed by default
+
+        // Click on Car Entity
+        ClickAtWorldPositionOnViewport(WorldCarEntityPosition);
+
+        // Verify the correct entity is selected
+        auto selectedEntitiesAfter = GetSelectedEntities();
+        EXPECT_EQ(selectedEntitiesAfter.size(), 1);
+        EXPECT_EQ(selectedEntitiesAfter.front(), m_entityMap[StreetEntityName]);
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[StreetEntityName]);
+    }
+
+    TEST_F(EditorFocusModeSelectionFixture, ContainerEntitySelectionTests_FindHighestSelectableEntityWithOpenContainer)
+    {
+        // If a closed container is an ancestor of the queried entity, the closed container is selected.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[StreetEntityName]);
+        m_containerEntityInterface->SetContainerOpen(m_entityMap[StreetEntityName], true);
+
+        // Click on Car Entity
+        ClickAtWorldPositionOnViewport(WorldCarEntityPosition);
+
+        // Verify the correct entity is selected
+        auto selectedEntitiesAfter = GetSelectedEntities();
+        EXPECT_EQ(selectedEntitiesAfter.size(), 1);
+        EXPECT_EQ(selectedEntitiesAfter.front(), m_entityMap[CarEntityName]);
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[StreetEntityName]);
+    }
+
+    TEST_F(EditorFocusModeSelectionFixture, ContainerEntitySelectionTests_FindHighestSelectableEntityWithMultipleClosedContainers)
+    {
+        // If multiple closed containers are ancestors of the queried entity, the highest closed container is selected.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[StreetEntityName]);
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[CityEntityName]);
+
+        // Click on Car Entity
+        ClickAtWorldPositionOnViewport(WorldCarEntityPosition);
+
+        // Verify the correct entity is selected
+        auto selectedEntitiesAfter = GetSelectedEntities();
+        EXPECT_EQ(selectedEntitiesAfter.size(), 1);
+        EXPECT_EQ(selectedEntitiesAfter.front(), m_entityMap[CityEntityName]);
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[StreetEntityName]);
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[CityEntityName]);
+    }
+
+    TEST_F(EditorFocusModeSelectionFixture, ContainerEntitySelectionTests_FindHighestSelectableEntityWithMultipleContainers)
+    {
+        // If multiple containers are ancestors of the queried entity, the highest closed container is selected.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[StreetEntityName]);
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[CityEntityName]);
+        m_containerEntityInterface->SetContainerOpen(m_entityMap[CityEntityName], true);
+
+        // Click on Car Entity
+        ClickAtWorldPositionOnViewport(WorldCarEntityPosition);
+
+        // Verify the correct entity is selected
+        auto selectedEntitiesAfter = GetSelectedEntities();
+        EXPECT_EQ(selectedEntitiesAfter.size(), 1);
+        EXPECT_EQ(selectedEntitiesAfter.front(), m_entityMap[StreetEntityName]);
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[StreetEntityName]);
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[CityEntityName]);
+    }
+}

Code/Framework/AzToolsFramework/Tests/FocusMode/ContainerEntityTests.cpp

@@ -0,0 +1,293 @@
+/*
+ * 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 <Tests/FocusMode/EditorFocusModeFixture.h>
+
+namespace AzToolsFramework
+{
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_Register)
+    {
+        // Registering an entity is successful.
+        auto outcome = m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[CarEntityName]);
+        EXPECT_TRUE(outcome.IsSuccess());
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[CarEntityName]);
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_RegisterTwice)
+    {
+        // Registering an entity twice fails.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[CarEntityName]);
+        auto outcome = m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[CarEntityName]);
+        EXPECT_FALSE(outcome.IsSuccess());
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[CarEntityName]);
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_Unregister)
+    {
+        // Unregistering a container entity is successful.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[CarEntityName]);
+        auto outcome = m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[CarEntityName]);
+        EXPECT_TRUE(outcome.IsSuccess());
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_UnregisterRegularEntity)
+    {
+        // Unregistering an entity that was not previously registered fails.
+        auto outcome = m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[CarEntityName]);
+        EXPECT_FALSE(outcome.IsSuccess());
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_UnregisterTwice)
+    {
+        // Unregistering a container entity twice fails.
+        auto outcome = m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[CarEntityName]);
+        EXPECT_FALSE(outcome.IsSuccess());
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_IsContainerOnRegularEntity)
+    {
+        // If a regular entity is passed, IsContainer returns false.
+        // Note that we use a different entity than the tests above to validate a completely new EntityId.
+        bool isContainer = m_containerEntityInterface->IsContainer(m_entityMap[SportsCarEntityName]);
+        EXPECT_FALSE(isContainer);
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_IsContainerOnRegisteredContainer)
+    {
+        // If a container entity is passed, IsContainer returns true.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[SportsCarEntityName]);
+        bool isContainer = m_containerEntityInterface->IsContainer(m_entityMap[SportsCarEntityName]);
+        EXPECT_TRUE(isContainer);
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[SportsCarEntityName]);
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_IsContainerOnUnRegisteredContainer)
+    {
+        // If an entity that was previously a container but was then unregistered is passed, IsContainer returns false.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[SportsCarEntityName]);
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[SportsCarEntityName]);
+
+        bool isContainer = m_containerEntityInterface->IsContainer(m_entityMap[SportsCarEntityName]);
+        EXPECT_FALSE(isContainer);
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_SetContainerOpenOnRegularEntity)
+    {
+        // Setting a regular entity to open should return a failure.
+        auto outcome = m_containerEntityInterface->SetContainerOpen(m_entityMap[StreetEntityName], true);
+        EXPECT_FALSE(outcome.IsSuccess());
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_SetContainerOpen)
+    {
+        // Set a container entity to open, and verify the operation was successful.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[StreetEntityName]);
+        auto outcome = m_containerEntityInterface->SetContainerOpen(m_entityMap[StreetEntityName], true);
+        EXPECT_TRUE(outcome.IsSuccess());
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[StreetEntityName]);
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_SetContainerOpenTwice)
+    {
+        // Set a container entity to open twice, and verify that does not cause a failure (as intended).
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[StreetEntityName]);
+        m_containerEntityInterface->SetContainerOpen(m_entityMap[StreetEntityName], true);
+        auto outcome = m_containerEntityInterface->SetContainerOpen(m_entityMap[StreetEntityName], true);
+        EXPECT_TRUE(outcome.IsSuccess());
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[StreetEntityName]);
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_SetContainerClosed)
+    {
+        // Set a container entity to closed, and verify the operation was successful.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[StreetEntityName]);
+        auto outcome = m_containerEntityInterface->SetContainerOpen(m_entityMap[StreetEntityName], true);
+        EXPECT_TRUE(outcome.IsSuccess());
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[StreetEntityName]);
+    }
+    
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_IsContainerOpenOnRegularEntity)
+    {
+        // Query open state on a regular entity, and verify it returns true.
+        // Open containers behave exactly as regular entities, so this is the expected return value.
+        bool isOpen = m_containerEntityInterface->IsContainerOpen(m_entityMap[CityEntityName]);
+        EXPECT_TRUE(isOpen);
+    }
+    
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_IsContainerOpenOnDefaultContainerEntity)
+    {
+        // Query open state on a newly registered container entity, and verify it returns false.
+        // Containers are registered closed by default.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[CityEntityName]);
+        bool isOpen = m_containerEntityInterface->IsContainerOpen(m_entityMap[CityEntityName]);
+        EXPECT_FALSE(isOpen);
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[CityEntityName]);
+    }
+    
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_IsContainerOpenOnOpenContainerEntity)
+    {
+        // Query open state on a container entity that was opened, and verify it returns true.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[CityEntityName]);
+        m_containerEntityInterface->SetContainerOpen(m_entityMap[CityEntityName], true);
+        bool isOpen = m_containerEntityInterface->IsContainerOpen(m_entityMap[CityEntityName]);
+        EXPECT_TRUE(isOpen);
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[CityEntityName]);
+    }
+    
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_IsContainerOpenOnClosedContainerEntity)
+    {
+        // Query open state on a container entity that was opened and then closed, and verify it returns false.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[CityEntityName]);
+        m_containerEntityInterface->SetContainerOpen(m_entityMap[CityEntityName], true);
+        m_containerEntityInterface->SetContainerOpen(m_entityMap[CityEntityName], false);
+        bool isOpen = m_containerEntityInterface->IsContainerOpen(m_entityMap[CityEntityName]);
+        EXPECT_FALSE(isOpen);
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[CityEntityName]);
+    }
+    
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_ContainerOpenStateIsPreserved)
+    {
+        // Register an entity as container, open it, then unregister it.
+        // When the entity is registered again, the open state should be preserved.
+        // This behavior is necessary for the system to work alongside Prefab propagation refreshes.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[CityEntityName]);
+        m_containerEntityInterface->SetContainerOpen(m_entityMap[CityEntityName], true);
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[CityEntityName]);
+
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[CityEntityName]);
+        bool isOpen = m_containerEntityInterface->IsContainerOpen(m_entityMap[CityEntityName]);
+        EXPECT_TRUE(isOpen);
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[CityEntityName]);
+    }
+    
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_ClearSucceeds)
+    {
+        // The Clear function works if no container is registered.
+        auto outcome = m_containerEntityInterface->Clear(m_editorEntityContextId);
+        EXPECT_TRUE(outcome.IsSuccess());
+    }
+    
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_ClearFailsIfContainersAreStillRegistered)
+    {
+        // The Clear function fails if a container is registered.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[Passenger1EntityName]);
+        auto outcome = m_containerEntityInterface->Clear(m_editorEntityContextId);
+        EXPECT_FALSE(outcome.IsSuccess());
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[Passenger1EntityName]);
+    }
+    
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_ClearSucceedsIfContainersAreUnregistered)
+    {
+        // The Clear function fails if a container is registered.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[Passenger1EntityName]);
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[Passenger1EntityName]);
+        auto outcome = m_containerEntityInterface->Clear(m_editorEntityContextId);
+        EXPECT_TRUE(outcome.IsSuccess());
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_ClearDeletesPreservedOpenStates)
+    {
+        // Register an entity as container, open it, unregister it, then call clear.
+        // When the entity is registered again, the open state should not be preserved.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[Passenger1EntityName]);
+        m_containerEntityInterface->SetContainerOpen(m_entityMap[Passenger1EntityName], true);
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[Passenger1EntityName]);
+
+        m_containerEntityInterface->Clear(m_editorEntityContextId);
+
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[Passenger1EntityName]);
+        bool isOpen = m_containerEntityInterface->IsContainerOpen(m_entityMap[Passenger1EntityName]);
+        EXPECT_FALSE(isOpen);
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[Passenger1EntityName]);
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_FindHighestSelectableEntityWithNoContainers)
+    {
+        // When no containers are in the way, the function will just return the entityId that was passed to it.
+        AZ::EntityId selectedEntityId = m_containerEntityInterface->FindHighestSelectableEntity(m_entityMap[Passenger2EntityName]);
+        EXPECT_EQ(selectedEntityId, m_entityMap[Passenger2EntityName]);
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_FindHighestSelectableEntityWithClosedContainer)
+    {
+        // If a closed container is an ancestor of the queried entity, the closed container is selected.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[SportsCarEntityName]); // Containers are closed by default
+        AZ::EntityId selectedEntityId = m_containerEntityInterface->FindHighestSelectableEntity(m_entityMap[Passenger2EntityName]);
+        EXPECT_EQ(selectedEntityId, m_entityMap[SportsCarEntityName]);
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[SportsCarEntityName]);
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_FindHighestSelectableEntityWithOpenContainer)
+    {
+        // If an open container is an ancestor of the queried entity, it is ignored.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[SportsCarEntityName]);
+        m_containerEntityInterface->SetContainerOpen(m_entityMap[SportsCarEntityName], true);
+
+        AZ::EntityId selectedEntityId = m_containerEntityInterface->FindHighestSelectableEntity(m_entityMap[Passenger2EntityName]);
+        EXPECT_EQ(selectedEntityId, m_entityMap[Passenger2EntityName]);
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[SportsCarEntityName]);
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_FindHighestSelectableEntityWithMultipleClosedContainers)
+    {
+        // If multiple closed containers are ancestors of the queried entity, the highest closed container is selected.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[StreetEntityName]);
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[SportsCarEntityName]);
+
+        AZ::EntityId selectedEntityId = m_containerEntityInterface->FindHighestSelectableEntity(m_entityMap[Passenger2EntityName]);
+        EXPECT_EQ(selectedEntityId, m_entityMap[StreetEntityName]);
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[StreetEntityName]);
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[SportsCarEntityName]);
+    }
+
+    TEST_F(EditorFocusModeFixture, ContainerEntityTests_FindHighestSelectableEntityWithMultipleContainers)
+    {
+        // If multiple containers are ancestors of the queried entity, the highest closed container is selected.
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[StreetEntityName]);
+        m_containerEntityInterface->RegisterEntityAsContainer(m_entityMap[SportsCarEntityName]);
+        m_containerEntityInterface->SetContainerOpen(m_entityMap[StreetEntityName], true);
+
+        AZ::EntityId selectedEntityId = m_containerEntityInterface->FindHighestSelectableEntity(m_entityMap[Passenger2EntityName]);
+        EXPECT_EQ(selectedEntityId, m_entityMap[SportsCarEntityName]);
+
+        // Restore default state for other tests.
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[StreetEntityName]);
+        m_containerEntityInterface->UnregisterEntityAsContainer(m_entityMap[SportsCarEntityName]);
+    }
+
+}

Code/Framework/AzToolsFramework/Tests/FocusMode/EditorFocusModeFixture.cpp

@@ -14,6 +14,20 @@
 
 namespace AzToolsFramework
 {
+    void ClearSelectedEntities()
+    {
+        AzToolsFramework::ToolsApplicationRequestBus::Broadcast(
+            &AzToolsFramework::ToolsApplicationRequestBus::Events::SetSelectedEntities, AzToolsFramework::EntityIdList());
+    }
+
+    AzToolsFramework::EntityIdList EditorFocusModeFixture::GetSelectedEntities()
+    {
+        AzToolsFramework::EntityIdList selectedEntities;
+        AzToolsFramework::ToolsApplicationRequestBus::BroadcastResult(
+            selectedEntities, &AzToolsFramework::ToolsApplicationRequestBus::Events::GetSelectedEntities);
+        return selectedEntities;
+    }
+
     void EditorFocusModeFixture::SetUpEditorFixtureImpl()
     {
         // Without this, the user settings component would attempt to save on finalize/shutdown. Since the file is
@@ -21,6 +35,9 @@ namespace AzToolsFramework
         // in the unit tests.
         AZ::UserSettingsComponentRequestBus::Broadcast(&AZ::UserSettingsComponentRequests::DisableSaveOnFinalize);
 
+        m_containerEntityInterface = AZ::Interface<ContainerEntityInterface>::Get();
+        ASSERT_TRUE(m_containerEntityInterface != nullptr);
+
         m_focusModeInterface = AZ::Interface<FocusModeInterface>::Get();
         ASSERT_TRUE(m_focusModeInterface != nullptr);
 
@@ -31,6 +48,24 @@ namespace AzToolsFramework
             m_editorEntityContextId, &AzToolsFramework::EditorEntityContextRequestBus::Events::GetEditorEntityContextId);
 
         GenerateTestHierarchy();
+
+        // Clear the focus, disabling focus mode
+        m_focusModeInterface->ClearFocusRoot(m_editorEntityContextId);
+
+        // Clear selection
+        ClearSelectedEntities();
+    }
+
+    void EditorFocusModeFixture::TearDownEditorFixtureImpl()
+    {
+        // Clear Container Entity preserved open states
+        m_containerEntityInterface->Clear(m_editorEntityContextId);
+
+        // Clear the focus, disabling focus mode
+        m_focusModeInterface->ClearFocusRoot(m_editorEntityContextId);
+
+        // Clear selection
+        ClearSelectedEntities();
     }
 
     void EditorFocusModeFixture::GenerateTestHierarchy() 
@@ -59,7 +94,7 @@ namespace AzToolsFramework
         entity->Activate();
 
         // Move the CarEntity so it's out of the way.
-        AZ::TransformBus::Event(m_entityMap[CarEntityName], &AZ::TransformBus::Events::SetWorldTranslation, CarEntityPosition);
+        AZ::TransformBus::Event(m_entityMap[CarEntityName], &AZ::TransformBus::Events::SetWorldTranslation, WorldCarEntityPosition);
 
         // Setup the camera so the Car entity is in view.
         AzFramework::SetCameraTransform(

Code/Framework/AzToolsFramework/Tests/FocusMode/EditorFocusModeFixture.h

@@ -14,6 +14,7 @@
 
 #include <AzTest/AzTest.h>
 
+#include <AzToolsFramework/ContainerEntity/ContainerEntityInterface.h>
 #include <AzToolsFramework/FocusMode/FocusModeInterface.h>
 #include <AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h>
 
@@ -24,16 +25,20 @@ namespace AzToolsFramework
     {
     protected:
         void SetUpEditorFixtureImpl() override;
+        void TearDownEditorFixtureImpl() override;
 
         void GenerateTestHierarchy();
         AZ::EntityId CreateEditorEntity(const char* name, AZ::EntityId parentId);
 
         AZStd::unordered_map<AZStd::string, AZ::EntityId> m_entityMap;
+
+        ContainerEntityInterface* m_containerEntityInterface = nullptr;
         FocusModeInterface* m_focusModeInterface = nullptr;
 
     public:
-        AzFramework::EntityContextId m_editorEntityContextId = AzFramework::EntityContextId::CreateNull();
+        AzToolsFramework::EntityIdList GetSelectedEntities();
 
+        AzFramework::EntityContextId m_editorEntityContextId = AzFramework::EntityContextId::CreateNull();
         AzFramework::CameraState m_cameraState;
 
         inline static const AZ::Vector3 CameraPosition = AZ::Vector3(10.0f, 15.0f, 10.0f);
@@ -45,6 +50,7 @@ namespace AzToolsFramework
         inline static const char* Passenger1EntityName = "Passenger1";
         inline static const char* Passenger2EntityName = "Passenger2";
 
-        inline static AZ::Vector3 CarEntityPosition = AZ::Vector3(5.0f, 15.0f, 0.0f);
+        inline static AZ::Vector3 WorldCarEntityPosition = AZ::Vector3(5.0f, 15.0f, 0.0f);
     };
+
 }

Code/Framework/AzToolsFramework/Tests/FocusMode/EditorFocusModeSelectionFixture.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 <Tests/FocusMode/EditorFocusModeFixture.h>
+
+#include <AzCore/Component/TransformBus.h>
+#include <AzCore/std/string/string.h>
+
+#include <AzFramework/Viewport/ViewportScreen.h>
+
+#include <AzManipulatorTestFramework/AzManipulatorTestFramework.h>
+#include <AzManipulatorTestFramework/AzManipulatorTestFrameworkTestHelpers.h>
+#include <AzManipulatorTestFramework/DirectManipulatorViewportInteraction.h>
+#include <AzManipulatorTestFramework/ImmediateModeActionDispatcher.h>
+#include <AzManipulatorTestFramework/IndirectManipulatorViewportInteraction.h>
+
+#include <AzToolsFramework/Component/EditorComponentAPIBus.h>
+#include <AzToolsFramework/Manipulators/LinearManipulator.h>
+#include <AzToolsFramework/Manipulators/ManipulatorManager.h>
+#include <AzToolsFramework/ViewportSelection/EditorVisibleEntityDataCache.h>
+
+namespace AzToolsFramework
+{
+    class EditorFocusModeSelectionFixture : public UnitTest::IndirectCallManipulatorViewportInteractionFixtureMixin<EditorFocusModeFixture>
+    {
+    public:
+        void ClickAtWorldPositionOnViewport(const AZ::Vector3& worldPosition)
+        {
+            // Calculate the world position in screen space
+            const auto carScreenPosition = AzFramework::WorldToScreen(worldPosition, m_cameraState);
+
+            // Click the entity in the viewport
+            m_actionDispatcher->CameraState(m_cameraState)->MousePosition(carScreenPosition)->MouseLButtonDown()->MouseLButtonUp();
+        }
+    };
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/Tests/FocusMode/EditorFocusModeSelectionTests.cpp

@@ -6,64 +6,14 @@
  *
  */
 
-#include <Tests/FocusMode/EditorFocusModeFixture.h>
-
-#include <AzCore/Component/TransformBus.h>
-#include <AzCore/std/string/string.h>
-
-#include <AzFramework/Viewport/ViewportScreen.h>
-
-#include <AzManipulatorTestFramework/AzManipulatorTestFramework.h>
-#include <AzManipulatorTestFramework/AzManipulatorTestFrameworkTestHelpers.h>
-#include <AzManipulatorTestFramework/DirectManipulatorViewportInteraction.h>
-#include <AzManipulatorTestFramework/ImmediateModeActionDispatcher.h>
-#include <AzManipulatorTestFramework/IndirectManipulatorViewportInteraction.h>
-
-#include <AzToolsFramework/Component/EditorComponentAPIBus.h>
-#include <AzToolsFramework/Manipulators/LinearManipulator.h>
-#include <AzToolsFramework/Manipulators/ManipulatorManager.h>
-#include <AzToolsFramework/ViewportSelection/EditorVisibleEntityDataCache.h>
-
+#include <Tests/FocusMode/EditorFocusModeSelectionFixture.h>
 
 namespace AzToolsFramework
 {
-    class EditorFocusModeSelectionFixture
-        : public UnitTest::IndirectCallManipulatorViewportInteractionFixtureMixin<EditorFocusModeFixture>
-    {
-    public:
-        void ClickAtWorldPositionOnViewport(const AZ::Vector3& worldPosition)
-        {
-            // Calculate the world position in screen space
-            const auto carScreenPosition = AzFramework::WorldToScreen(worldPosition, m_cameraState);
-
-            // Click the entity in the viewport
-            m_actionDispatcher->CameraState(m_cameraState)->MousePosition(carScreenPosition)->MouseLButtonDown()->MouseLButtonUp();
-        }
-    };
-
-    void ClearSelectedEntities()
-    {
-        AzToolsFramework::ToolsApplicationRequestBus::Broadcast(
-            &AzToolsFramework::ToolsApplicationRequestBus::Events::SetSelectedEntities, AzToolsFramework::EntityIdList());
-    }
-
-    AzToolsFramework::EntityIdList GetSelectedEntities()
-    {
-        AzToolsFramework::EntityIdList selectedEntities;
-        AzToolsFramework::ToolsApplicationRequestBus::BroadcastResult(
-            selectedEntities, &AzToolsFramework::ToolsApplicationRequestBus::Events::GetSelectedEntities);
-        return selectedEntities;
-    }
-
     TEST_F(EditorFocusModeSelectionFixture, EditorFocusModeSelectionTests_SelectEntityWithFocusOnLevel)
     {
-        // Clear the focus, disabling focus mode
-        m_focusModeInterface->ClearFocusRoot(AzFramework::EntityContextId::CreateNull());
-        // Clear selection
-        ClearSelectedEntities();
-
         // Click on Car Entity
-        ClickAtWorldPositionOnViewport(CarEntityPosition);
+        ClickAtWorldPositionOnViewport(WorldCarEntityPosition);
 
         // Verify entity is selected
         auto selectedEntitiesAfter = GetSelectedEntities();
@@ -75,73 +25,53 @@ namespace AzToolsFramework
     {
         // Set the focus on the Street Entity (parent of the test entity)
         m_focusModeInterface->SetFocusRoot(m_entityMap[StreetEntityName]);
-        // Clear selection
-        ClearSelectedEntities();
 
         // Click on Car Entity
-        ClickAtWorldPositionOnViewport(CarEntityPosition);
+        ClickAtWorldPositionOnViewport(WorldCarEntityPosition);
 
         // Verify entity is selected
         auto selectedEntitiesAfter = GetSelectedEntities();
         EXPECT_EQ(selectedEntitiesAfter.size(), 1);
         EXPECT_EQ(selectedEntitiesAfter.front(), m_entityMap[CarEntityName]);
-
-        // Clear the focus, disabling focus mode
-        m_focusModeInterface->ClearFocusRoot(AzFramework::EntityContextId::CreateNull());
     }
 
     TEST_F(EditorFocusModeSelectionFixture, EditorFocusModeSelectionTests_SelectEntityWithFocusOnItself)
     {
         // Set the focus on the Car Entity (test entity)
         m_focusModeInterface->SetFocusRoot(m_entityMap[CarEntityName]);
-        // Clear selection
-        ClearSelectedEntities();
 
         // Click on Car Entity
-        ClickAtWorldPositionOnViewport(CarEntityPosition);
+        ClickAtWorldPositionOnViewport(WorldCarEntityPosition);
 
         // Verify entity is selected
         auto selectedEntitiesAfter = GetSelectedEntities();
         EXPECT_EQ(selectedEntitiesAfter.size(), 1);
         EXPECT_EQ(selectedEntitiesAfter.front(), m_entityMap[CarEntityName]);
-
-        // Clear the focus, disabling focus mode
-        m_focusModeInterface->ClearFocusRoot(AzFramework::EntityContextId::CreateNull());
     }
 
     TEST_F(EditorFocusModeSelectionFixture, EditorFocusModeSelectionTests_SelectEntityWithFocusOnSibling)
     {
         // Set the focus on the SportsCar Entity (sibling of the test entity)
         m_focusModeInterface->SetFocusRoot(m_entityMap[SportsCarEntityName]);
-        // Clear selection
-        ClearSelectedEntities();
 
         // Click on Car Entity
-        ClickAtWorldPositionOnViewport(CarEntityPosition);
+        ClickAtWorldPositionOnViewport(WorldCarEntityPosition);
 
         // Verify entity is selected
         auto selectedEntitiesAfter = GetSelectedEntities();
         EXPECT_EQ(selectedEntitiesAfter.size(), 0);
-
-        // Clear the focus, disabling focus mode
-        m_focusModeInterface->ClearFocusRoot(AzFramework::EntityContextId::CreateNull());
     }
 
     TEST_F(EditorFocusModeSelectionFixture, EditorFocusModeSelectionTests_SelectEntityWithFocusOnDescendant)
     {
         // Set the focus on the Passenger1 Entity (child of the entity)
         m_focusModeInterface->SetFocusRoot(m_entityMap[Passenger1EntityName]);
-        // Clear selection
-        ClearSelectedEntities();
 
         // Click on Car Entity
-        ClickAtWorldPositionOnViewport(CarEntityPosition);
+        ClickAtWorldPositionOnViewport(WorldCarEntityPosition);
 
         // Verify entity is selected
         auto selectedEntitiesAfter = GetSelectedEntities();
         EXPECT_EQ(selectedEntitiesAfter.size(), 0);
-
-        // Clear the focus, disabling focus mode
-        m_focusModeInterface->ClearFocusRoot(AzFramework::EntityContextId::CreateNull());
     }
 }

Code/Framework/AzToolsFramework/Tests/FocusMode/EditorFocusModeTests.cpp

@@ -33,55 +33,40 @@ namespace AzToolsFramework
     TEST_F(EditorFocusModeFixture, EditorFocusModeTests_IsInFocusSubTree_AncestorsDescendants)
     {
         // When the focus is set to an entity, all its descendants are in the focus subtree while the ancestors aren't.
-        {
-            m_focusModeInterface->SetFocusRoot(m_entityMap[StreetEntityName]);
+        m_focusModeInterface->SetFocusRoot(m_entityMap[StreetEntityName]);
 
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CityEntityName]), false);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[StreetEntityName]), true);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CarEntityName]), true);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger1EntityName]), true);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[SportsCarEntityName]), true);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger2EntityName]), true);
-        }
-
-        // Restore default expected focus.
-        m_focusModeInterface->ClearFocusRoot(m_editorEntityContextId);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CityEntityName]), false);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[StreetEntityName]), true);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CarEntityName]), true);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger1EntityName]), true);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[SportsCarEntityName]), true);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger2EntityName]), true);
     }
 
     TEST_F(EditorFocusModeFixture, EditorFocusModeTests_IsInFocusSubTree_Siblings)
     {
         // If the root entity has siblings, they are also outside of the focus subtree.
-        {
-            m_focusModeInterface->SetFocusRoot(m_entityMap[CarEntityName]);
+        m_focusModeInterface->SetFocusRoot(m_entityMap[CarEntityName]);
 
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CityEntityName]), false);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[StreetEntityName]), false);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CarEntityName]), true);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger1EntityName]), true);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[SportsCarEntityName]), false);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger2EntityName]), false);
-        }
-
-        // Restore default expected focus.
-        m_focusModeInterface->ClearFocusRoot(m_editorEntityContextId);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CityEntityName]), false);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[StreetEntityName]), false);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CarEntityName]), true);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger1EntityName]), true);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[SportsCarEntityName]), false);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger2EntityName]), false);
     }
 
     TEST_F(EditorFocusModeFixture, EditorFocusModeTests_IsInFocusSubTree_Leaf)
     {
         // If the root is a leaf, then the focus subtree will consists of just that entity.
-        {
-            m_focusModeInterface->SetFocusRoot(m_entityMap[Passenger2EntityName]);
+        m_focusModeInterface->SetFocusRoot(m_entityMap[Passenger2EntityName]);
 
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CityEntityName]), false);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[StreetEntityName]), false);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CarEntityName]), false);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger1EntityName]), false);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[SportsCarEntityName]), false);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger2EntityName]), true);
-        }
-
-        // Restore default expected focus.
-        m_focusModeInterface->ClearFocusRoot(m_editorEntityContextId);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CityEntityName]), false);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[StreetEntityName]), false);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CarEntityName]), false);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger1EntityName]), false);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[SportsCarEntityName]), false);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger2EntityName]), true);
     }
 
     TEST_F(EditorFocusModeFixture, EditorFocusModeTests_IsInFocusSubTree_Clear)
@@ -90,15 +75,13 @@ namespace AzToolsFramework
         m_focusModeInterface->SetFocusRoot(m_entityMap[StreetEntityName]);
 
         // When the focus is cleared, the whole level is in the focus subtree; so we expect all entities to return true.
-        {
-            m_focusModeInterface->ClearFocusRoot(m_editorEntityContextId);
+        m_focusModeInterface->ClearFocusRoot(m_editorEntityContextId);
 
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CityEntityName]), true);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[StreetEntityName]), true);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CarEntityName]), true);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger1EntityName]), true);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[SportsCarEntityName]), true);
-            EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger2EntityName]), true);
-        }
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CityEntityName]), true);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[StreetEntityName]), true);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[CarEntityName]), true);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger1EntityName]), true);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[SportsCarEntityName]), true);
+        EXPECT_EQ(m_focusModeInterface->IsInFocusSubTree(m_entityMap[Passenger2EntityName]), true);
     }
 }

Code/Framework/AzToolsFramework/Tests/Prefab/PrefabFocus/PrefabFocusTests.cpp

@@ -10,6 +10,7 @@
 #include <AzToolsFramework/Entity/EditorEntityHelpers.h>
 #include <AzToolsFramework/Entity/PrefabEditorEntityOwnershipInterface.h>
 #include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
+#include <AzToolsFramework/Prefab/PrefabFocusPublicInterface.h>
 #include <Prefab/PrefabTestFixture.h>
 
 namespace UnitTest
@@ -72,6 +73,9 @@ namespace UnitTest
             m_prefabFocusInterface = AZ::Interface<PrefabFocusInterface>::Get();
             ASSERT_TRUE(m_prefabFocusInterface != nullptr);
 
+            m_prefabFocusPublicInterface = AZ::Interface<PrefabFocusPublicInterface>::Get();
+            ASSERT_TRUE(m_prefabFocusPublicInterface != nullptr);
+
             AzToolsFramework::EditorEntityContextRequestBus::BroadcastResult(
                 m_editorEntityContextId, &AzToolsFramework::EditorEntityContextRequestBus::Events::GetEditorEntityContextId);
 
@@ -91,6 +95,7 @@ namespace UnitTest
         AZStd::unique_ptr<AzToolsFramework::Prefab::Instance> m_rootInstance;
 
         PrefabFocusInterface* m_prefabFocusInterface = nullptr;
+        PrefabFocusPublicInterface* m_prefabFocusPublicInterface = nullptr;
         AzFramework::EntityContextId m_editorEntityContextId = AzFramework::EntityContextId::CreateNull();
 
         inline static const char* CityEntityName = "City";
@@ -105,7 +110,7 @@ namespace UnitTest
     {
         // Verify FocusOnOwningPrefab works when passing the container entity of the root prefab.
         {
-            m_prefabFocusInterface->FocusOnOwningPrefab(m_instanceMap[CityEntityName]->GetContainerEntityId());
+            m_prefabFocusPublicInterface->FocusOnOwningPrefab(m_instanceMap[CityEntityName]->GetContainerEntityId());
             EXPECT_EQ(
                 m_prefabFocusInterface->GetFocusedPrefabTemplateId(m_editorEntityContextId),
                 m_instanceMap[CityEntityName]->GetTemplateId());
@@ -120,7 +125,7 @@ namespace UnitTest
     {
         // Verify FocusOnOwningPrefab works when passing a nested entity of the root prefab.
         {
-            m_prefabFocusInterface->FocusOnOwningPrefab(m_entityMap[CityEntityName]->GetId());
+            m_prefabFocusPublicInterface->FocusOnOwningPrefab(m_entityMap[CityEntityName]->GetId());
             EXPECT_EQ(
                 m_prefabFocusInterface->GetFocusedPrefabTemplateId(m_editorEntityContextId),
                 m_instanceMap[CityEntityName]->GetTemplateId());
@@ -135,7 +140,7 @@ namespace UnitTest
     {
         // Verify FocusOnOwningPrefab works when passing the container entity of a nested prefab.
         {
-            m_prefabFocusInterface->FocusOnOwningPrefab(m_instanceMap[CarEntityName]->GetContainerEntityId());
+            m_prefabFocusPublicInterface->FocusOnOwningPrefab(m_instanceMap[CarEntityName]->GetContainerEntityId());
             EXPECT_EQ(
                 m_prefabFocusInterface->GetFocusedPrefabTemplateId(m_editorEntityContextId), m_instanceMap[CarEntityName]->GetTemplateId());
 
@@ -149,7 +154,7 @@ namespace UnitTest
     {
         // Verify FocusOnOwningPrefab works when passing a nested entity of the a nested prefab.
         {
-            m_prefabFocusInterface->FocusOnOwningPrefab(m_entityMap[Passenger1EntityName]->GetId());
+            m_prefabFocusPublicInterface->FocusOnOwningPrefab(m_entityMap[Passenger1EntityName]->GetId());
             EXPECT_EQ(
                 m_prefabFocusInterface->GetFocusedPrefabTemplateId(m_editorEntityContextId), m_instanceMap[CarEntityName]->GetTemplateId());
 
@@ -169,7 +174,7 @@ namespace UnitTest
                 prefabEditorEntityOwnershipInterface->GetRootPrefabInstance();
             EXPECT_TRUE(rootPrefabInstance.has_value());
 
-            m_prefabFocusInterface->FocusOnOwningPrefab(AZ::EntityId());
+            m_prefabFocusPublicInterface->FocusOnOwningPrefab(AZ::EntityId());
             EXPECT_EQ(
                 m_prefabFocusInterface->GetFocusedPrefabTemplateId(m_editorEntityContextId), rootPrefabInstance->get().GetTemplateId());
 
@@ -183,10 +188,10 @@ namespace UnitTest
     {
         // Verify IsOwningPrefabBeingFocused returns true for all entities in a focused prefab (container/nested)
         {
-            m_prefabFocusInterface->FocusOnOwningPrefab(m_instanceMap[CityEntityName]->GetContainerEntityId());
+            m_prefabFocusPublicInterface->FocusOnOwningPrefab(m_instanceMap[CityEntityName]->GetContainerEntityId());
 
-            EXPECT_TRUE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap[CityEntityName]->GetContainerEntityId()));
-            EXPECT_TRUE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_entityMap[CityEntityName]->GetId()));
+            EXPECT_TRUE(m_prefabFocusPublicInterface->IsOwningPrefabBeingFocused(m_instanceMap[CityEntityName]->GetContainerEntityId()));
+            EXPECT_TRUE(m_prefabFocusPublicInterface->IsOwningPrefabBeingFocused(m_entityMap[CityEntityName]->GetId()));
         }
     }
 
@@ -194,13 +199,13 @@ namespace UnitTest
     {
         // Verify IsOwningPrefabBeingFocused returns false for all entities not in a focused prefab (ancestors/descendants)
         {
-            m_prefabFocusInterface->FocusOnOwningPrefab(m_instanceMap[StreetEntityName]->GetContainerEntityId());
+            m_prefabFocusPublicInterface->FocusOnOwningPrefab(m_instanceMap[StreetEntityName]->GetContainerEntityId());
 
-            EXPECT_TRUE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap[StreetEntityName]->GetContainerEntityId()));
-            EXPECT_FALSE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap[CityEntityName]->GetContainerEntityId()));
-            EXPECT_FALSE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_entityMap[CityEntityName]->GetId()));
-            EXPECT_FALSE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap[CarEntityName]->GetContainerEntityId()));
-            EXPECT_FALSE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_entityMap[Passenger1EntityName]->GetId()));
+            EXPECT_TRUE(m_prefabFocusPublicInterface->IsOwningPrefabBeingFocused(m_instanceMap[StreetEntityName]->GetContainerEntityId()));
+            EXPECT_FALSE(m_prefabFocusPublicInterface->IsOwningPrefabBeingFocused(m_instanceMap[CityEntityName]->GetContainerEntityId()));
+            EXPECT_FALSE(m_prefabFocusPublicInterface->IsOwningPrefabBeingFocused(m_entityMap[CityEntityName]->GetId()));
+            EXPECT_FALSE(m_prefabFocusPublicInterface->IsOwningPrefabBeingFocused(m_instanceMap[CarEntityName]->GetContainerEntityId()));
+            EXPECT_FALSE(m_prefabFocusPublicInterface->IsOwningPrefabBeingFocused(m_entityMap[Passenger1EntityName]->GetId()));
         }
     }
 
@@ -208,12 +213,12 @@ namespace UnitTest
     {
         // Verify IsOwningPrefabBeingFocused returns false for all entities not in a focused prefab (siblings)
         {
-            m_prefabFocusInterface->FocusOnOwningPrefab(m_instanceMap[SportsCarEntityName]->GetContainerEntityId());
+            m_prefabFocusPublicInterface->FocusOnOwningPrefab(m_instanceMap[SportsCarEntityName]->GetContainerEntityId());
 
-            EXPECT_TRUE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap[SportsCarEntityName]->GetContainerEntityId()));
-            EXPECT_TRUE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_entityMap[Passenger2EntityName]->GetId()));
-            EXPECT_FALSE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_instanceMap[CarEntityName]->GetContainerEntityId()));
-            EXPECT_FALSE(m_prefabFocusInterface->IsOwningPrefabBeingFocused(m_entityMap[Passenger1EntityName]->GetId()));
+            EXPECT_TRUE(m_prefabFocusPublicInterface->IsOwningPrefabBeingFocused(m_instanceMap[SportsCarEntityName]->GetContainerEntityId()));
+            EXPECT_TRUE(m_prefabFocusPublicInterface->IsOwningPrefabBeingFocused(m_entityMap[Passenger2EntityName]->GetId()));
+            EXPECT_FALSE(m_prefabFocusPublicInterface->IsOwningPrefabBeingFocused(m_instanceMap[CarEntityName]->GetContainerEntityId()));
+            EXPECT_FALSE(m_prefabFocusPublicInterface->IsOwningPrefabBeingFocused(m_entityMap[Passenger1EntityName]->GetId()));
         }
     }
 

Code/Framework/AzToolsFramework/Tests/aztoolsframeworktests_files.cmake

@@ -37,8 +37,11 @@ set(FILES
     EntityTestbed.h
     FileFunc.cpp
     FingerprintingTests.cpp
+    FocusMode/ContainerEntitySelectionTests.cpp
+    FocusMode/ContainerEntityTests.cpp
     FocusMode/EditorFocusModeFixture.cpp
     FocusMode/EditorFocusModeFixture.h
+    FocusMode/EditorFocusModeSelectionFixture.h
     FocusMode/EditorFocusModeSelectionTests.cpp
     FocusMode/EditorFocusModeTests.cpp
     GenericComponentWrapperTest.cpp