Implemented the PrefabViewportFocusPathHandler class, added a breadcrumb widget to the viewport toolbar to display the currently focused prefab path.

Signed-off-by: Danilo Aimini <82231674+AMZN-daimini@users.noreply.github.com>

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

@@ -11,6 +11,7 @@
 #include <AzToolsFramework/Entity/PrefabEditorEntityOwnershipInterface.h>
 #include <AzToolsFramework/Prefab/Instance/Instance.h>
 #include <AzToolsFramework/Prefab/Instance/InstanceEntityMapperInterface.h>
+#include <AzToolsFramework/Prefab/PrefabFocusNotificationBus.h>
 
 namespace AzToolsFramework::Prefab
 {
@@ -23,12 +24,14 @@ namespace AzToolsFramework::Prefab
             "Instance Entity Mapper Interface could not be found. "
             "Check that it is being correctly initialized.");
 
+        EditorEntityContextNotificationBus::Handler::BusConnect();
         AZ::Interface<PrefabFocusInterface>::Register(this);
     }
 
     PrefabFocusHandler::~PrefabFocusHandler()
     {
         AZ::Interface<PrefabFocusInterface>::Unregister(this);
+        EditorEntityContextNotificationBus::Handler::BusDisconnect();
     }
 
     PrefabFocusOperationResult PrefabFocusHandler::FocusOnOwningPrefab(AZ::EntityId entityId)
@@ -55,8 +58,28 @@ namespace AzToolsFramework::Prefab
 
         if (!focusedInstance.has_value())
         {
-            return AZ::Failure(AZStd::string(
-                "Prefab Focus Handler: Couldn't find owning instance of entityId provided."));
+            return AZ::Failure(AZStd::string("Prefab Focus Handler: Couldn't find owning instance of entityId provided."));
+        }
+
+        if (&m_focusedInstance->get() != &focusedInstance->get())
+        {
+            m_focusedInstance = focusedInstance;
+            m_focusedTemplateId = focusedInstance->get().GetTemplateId();
+            s_focusModeInterface->SetFocusRoot(focusedInstance->get().GetContainerEntityId());
+
+            RefreshInstanceFocusList();
+
+            PrefabFocusNotificationBus::Broadcast(&PrefabFocusNotifications::OnPrefabFocusChanged);
+        }
+
+        return AZ::Success();
+    }
+
+    PrefabFocusOperationResult PrefabFocusHandler::FocusOnPathIndex(int index)
+    {
+        if (index < 0 || index >= m_instanceFocusVector.size())
+        {
+            return AZ::Failure(AZStd::string("Prefab Focus Handler: Invalid index on FocusOnPathIndex."));
         }
 
         m_focusedInstance = focusedInstance;
@@ -68,7 +91,13 @@ namespace AzToolsFramework::Prefab
             focusModeInterface->SetFocusRoot(focusedInstance->get().GetContainerEntityId());
         }
 
+            RefreshInstanceFocusList();
+
+            PrefabFocusNotificationBus::Broadcast(&PrefabFocusNotifications::OnPrefabFocusChanged);
+        }
+
         return AZ::Success();
+
     }
     
     TemplateId PrefabFocusHandler::GetFocusedPrefabTemplateId()
@@ -93,4 +122,39 @@ namespace AzToolsFramework::Prefab
         return instance.has_value() && (&instance->get() == &m_focusedInstance->get());
     }
 
+    const AZ::IO::Path& PrefabFocusHandler::GetPrefabFocusPath()
+    {
+        return m_instanceFocusPath;
+    }
+
+    void PrefabFocusHandler::OnEntityStreamLoadSuccess()
+    {
+        // Focus on the root prefab (AZ::EntityId() will default to it)
+        FocusOnOwningPrefab(AZ::EntityId());
+    }
+
+    void PrefabFocusHandler::RefreshInstanceFocusList()
+    {
+        m_instanceFocusVector.clear();
+        m_instanceFocusPath.clear();
+
+        AZStd::list<InstanceOptionalReference> instanceFocusList;
+
+        // Use a support list to easily push front while traversing the prefab hierarchy
+        InstanceOptionalReference currentInstance = m_focusedInstance;
+        while (currentInstance.has_value())
+        {
+            instanceFocusList.push_front(currentInstance);
+
+            currentInstance = currentInstance->get().GetParentInstance();
+        }
+
+        // Populate internals using the support list
+        for (auto& instance : instanceFocusList)
+        {
+            m_instanceFocusPath.Append(instance->get().GetContainerEntity()->get().GetName());
+            m_instanceFocusVector.emplace_back(instance);
+        }
+    }
+
 } // namespace AzToolsFramework::Prefab

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

@@ -10,6 +10,7 @@
 
 #include <AzCore/Memory/SystemAllocator.h>
 
+#include <AzToolsFramework/Entity/EditorEntityContextBus.h>
 #include <AzToolsFramework/FocusMode/FocusModeInterface.h>
 #include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
 #include <AzToolsFramework/Prefab/Template/Template.h>
@@ -21,6 +22,7 @@ namespace AzToolsFramework::Prefab
     //! Handles Prefab Focus mode, determining which prefab file entity changes will target.
     class PrefabFocusHandler final
         : private PrefabFocusInterface
+        , private EditorEntityContextNotificationBus::Handler
     {
     public:
         AZ_CLASS_ALLOCATOR(PrefabFocusHandler, AZ::SystemAllocator, 0);
@@ -30,13 +32,22 @@ namespace AzToolsFramework::Prefab
 
         // PrefabFocusInterface override ...
         PrefabFocusOperationResult FocusOnOwningPrefab(AZ::EntityId entityId) override;
+        PrefabFocusOperationResult FocusOnPathIndex(int index) override;
         TemplateId GetFocusedPrefabTemplateId() override;
         InstanceOptionalReference GetFocusedPrefabInstance() override;
         bool IsOwningPrefabBeingFocused(AZ::EntityId entityId) override;
+        const AZ::IO::Path& GetPrefabFocusPath() override;
+
+        // EditorEntityContextNotificationBus...
+        void OnEntityStreamLoadSuccess() override;
 
     private:
+        void RefreshInstanceFocusList();
+
         InstanceOptionalReference m_focusedInstance;
         TemplateId m_focusedTemplateId;
+        AZStd::vector<InstanceOptionalReference> m_instanceFocusVector;
+        AZ::IO::Path m_instanceFocusPath;
 
         InstanceEntityMapperInterface* m_instanceEntityMapperInterface;
     };

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

@@ -28,6 +28,10 @@ namespace AzToolsFramework::Prefab
         //! @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(int index) = 0;
+
         //! Returns the template id of the instance the prefab system is focusing on.
         virtual TemplateId GetFocusedPrefabTemplateId() = 0;
 
@@ -38,6 +42,11 @@ namespace AzToolsFramework::Prefab
         //! @param entityId The entityId of the queried entity.
         //! @return true if the entity belongs to the focused instance or one of its descendants, false otherwise.
         virtual bool IsOwningPrefabBeingFocused(AZ::EntityId entityId) = 0;
+
+        //! 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 const AZ::IO::Path& GetPrefabFocusPath() = 0;
     };
 
 } // namespace AzToolsFramework::Prefab

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabFocusNotificationBus.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/EBus/EBus.h>
+
+namespace AzToolsFramework::Prefab
+{
+    class PrefabFocusNotifications : public AZ::EBusTraits
+    {
+    public:
+        virtual ~PrefabFocusNotifications() = default;
+
+        virtual void OnPrefabFocusChanged() = 0;
+    };
+
+    using PrefabFocusNotificationBus = AZ::EBus<PrefabFocusNotifications>;
+
+} // namespace AzToolsFramework::Prefab