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

Code/Framework/AzCore/AzCore/Component/Entity.cpp

@@ -207,12 +207,6 @@ namespace AZ
             ActivateComponent(**it);
         }
 
-        // Cache the transform interface to the transform interface
-        // Generally this pattern is not recommended unless for component event buses
-        // As we have a guarantee (by design) that components can't change during active state)
-        // Even though technically they can connect disconnect from the bus.
-        m_transform = TransformBus::FindFirstHandler(m_id);
-
         SetState(State::Active);
 
         EBUS_EVENT_ID(m_id, EntityBus, OnEntityActivated, m_id);
@@ -1320,6 +1314,19 @@ namespace AZ
         return *processSignature;
     }
 
+    AZ::TransformInterface* Entity::GetTransform() const
+    {
+        // Lazy evaluation of the cached entity transform.
+        if(!m_transform)
+        {
+            // Generally this pattern is not recommended unless for component event buses
+            // As we have a guarantee (by design) that components can't change during active state)
+            // Even though technically they can connect disconnect from the bus.
+            m_transform = TransformBus::FindFirstHandler(m_id);
+        }
+        return m_transform;
+    }
+
     //=========================================================================
     // MakeId
     // Ids must be unique across a project at authoring time. Runtime doesn't matter

Code/Framework/AzCore/AzCore/Component/Entity.h

@@ -354,10 +354,9 @@ namespace AZ
         //! @return The Process Signature of the local machine.
         static AZ::u32 GetProcessSignature();
 
-        /// @cond EXCLUDE_DOCS 
-        //! @deprecated Use the TransformBus to communicate with the TransformInterface.
-        inline TransformInterface* GetTransform() const { return m_transform; }
-        /// @endcond
+        //! Gets the TransformInterface for the entity.
+        //! @return The TransformInterface for the entity.
+        TransformInterface* GetTransform() const;
 
         //! Sorts an entity's components based on the dependencies between components.
         //! If all dependencies are met, the required services can be activated
@@ -406,7 +405,7 @@ namespace AZ
         //! A cached pointer to the transform interface. 
         //! We recommend using AZ::TransformBus and caching locally instead of accessing
         //! the transform interface directly through this pointer.
-        TransformInterface* m_transform;
+        mutable TransformInterface* m_transform;
 
         //! A user-friendly name for the entity. This makes error messages easier to read.
         AZStd::string m_name;

Code/Framework/AzCore/AzCore/Debug/Profiler.h

@@ -59,6 +59,20 @@ namespace AZStd
 
 namespace AZ::Debug
 {
+    // interface for externally defined profiler systems
+    class Profiler
+    {
+    public:
+        AZ_RTTI(Profiler, "{3E5D6329-72D1-41BA-9158-68A349D1A4D5}");
+
+        Profiler() = default;
+        virtual ~Profiler() = default;
+
+        // support for the extra macro args (e.g. format strings) will come in a later PR
+        virtual void BeginRegion(const Budget* budget, const char* eventName) = 0;
+        virtual void EndRegion(const Budget* budget) = 0;
+    };
+
     class ProfileScope
     {
     public:

Code/Framework/AzCore/AzCore/Debug/Profiler.inl

@@ -6,6 +6,8 @@
  *
  */
 
+#include <AzCore/Interface/Interface.h>
+
 namespace AZ::Debug
 {
     template<typename... T>
@@ -22,9 +24,11 @@ namespace AZ::Debug
         PIXBeginEvent(PIX_COLOR_INDEX(budget->Crc() & 0xff), eventName, args...);
 #endif
         budget->BeginProfileRegion();
-// TODO: injecting instrumentation for other profilers
-// NOTE: external profiler registration won't occur inline in a header necessarily in this manner, but the exact mechanism
-//       will be introduced in a future PR
+
+        if (auto profiler = AZ::Interface<Profiler>::Get(); profiler)
+        {
+            profiler->BeginRegion(budget, eventName);
+        }
 #endif
     }
 
@@ -39,6 +43,10 @@ namespace AZ::Debug
 #if defined(USE_PIX)
         PIXEndEvent();
 #endif
+        if (auto profiler = AZ::Interface<Profiler>::Get(); profiler)
+        {
+            profiler->EndRegion(budget);
+        }
 #endif
     }
 

Code/Framework/AzCore/AzCore/IO/FileReader.cpp

@@ -0,0 +1,200 @@
+/*
+ * 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/IO/FileReader.h>
+#include <AzCore/IO/FileIO.h>
+#include <AzCore/IO/Path/Path.h>
+
+namespace AZ::IO
+{
+    FileReader::FileReader() = default;
+
+    FileReader::FileReader(AZ::IO::FileIOBase* fileIoBase, const char* filePath)
+    {
+        Open(fileIoBase, filePath);
+    }
+
+    FileReader::~FileReader()
+    {
+        Close();
+    }
+
+    FileReader::FileReader(FileReader&& other)
+    {
+        AZStd::swap(m_file, other.m_file);
+        AZStd::swap(m_fileIoBase, other.m_fileIoBase);
+    }
+
+    FileReader& FileReader::operator=(FileReader&& other)
+    {
+        // Close the current file and take over other file
+        Close();
+        m_file = AZStd::move(other.m_file);
+        m_fileIoBase = AZStd::move(other.m_fileIoBase);
+        other.m_file = AZStd::monostate{};
+        other.m_fileIoBase = {};
+
+        return *this;
+    }
+
+    bool FileReader::Open(AZ::IO::FileIOBase* fileIoBase, const char* filePath)
+    {
+        // Close file if the FileReader has an instance open
+        Close();
+
+        if (fileIoBase != nullptr)
+        {
+            AZ::IO::HandleType fileHandle;
+            if (fileIoBase->Open(filePath, IO::OpenMode::ModeRead, fileHandle))
+            {
+                m_file = fileHandle;
+                m_fileIoBase = fileIoBase;
+                return true;
+            }
+        }
+        else
+        {
+            AZ::IO::SystemFile file;
+            if (file.Open(filePath, IO::SystemFile::OpenMode::SF_OPEN_READ_ONLY))
+            {
+                m_file = AZStd::move(file);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    bool FileReader::IsOpen() const
+    {
+        if (auto fileHandle = AZStd::get_if<AZ::IO::HandleType>(&m_file); fileHandle != nullptr)
+        {
+            return *fileHandle != AZ::IO::InvalidHandle;
+        }
+        else if (auto systemFile = AZStd::get_if<AZ::IO::SystemFile>(&m_file); systemFile != nullptr)
+        {
+            return systemFile->IsOpen();
+        }
+
+        return false;
+    }
+
+    void FileReader::Close()
+    {
+        if (auto fileHandle = AZStd::get_if<AZ::IO::HandleType>(&m_file); fileHandle != nullptr)
+        {
+            if (AZ::IO::FileIOBase* fileIo = m_fileIoBase; fileIo != nullptr)
+            {
+                fileIo->Close(*fileHandle);
+            }
+        }
+
+        m_file = AZStd::monostate{};
+        m_fileIoBase = {};
+    }
+
+    auto FileReader::Length() const -> SizeType
+    {
+        if (auto fileHandle = AZStd::get_if<AZ::IO::HandleType>(&m_file); fileHandle != nullptr)
+        {
+            if (SizeType fileSize{}; m_fileIoBase->Size(*fileHandle, fileSize))
+            {
+                return fileSize;
+            }
+        }
+        else if (auto systemFile = AZStd::get_if<AZ::IO::SystemFile>(&m_file); systemFile != nullptr)
+        {
+            return systemFile->Length();
+        }
+
+        return 0;
+    }
+
+    auto FileReader::Read(SizeType byteSize, void* buffer) -> SizeType
+    {
+        if (auto fileHandle = AZStd::get_if<AZ::IO::HandleType>(&m_file); fileHandle != nullptr)
+        {
+            if (SizeType bytesRead{}; m_fileIoBase->Read(*fileHandle, buffer, byteSize, false, &bytesRead))
+            {
+                return bytesRead;
+            }
+        }
+        else if (auto systemFile = AZStd::get_if<AZ::IO::SystemFile>(&m_file); systemFile != nullptr)
+        {
+            return systemFile->Read(byteSize, buffer);
+        }
+
+        return 0;
+    }
+
+    auto FileReader::Tell() const -> SizeType
+    {
+        if (auto fileHandle = AZStd::get_if<AZ::IO::HandleType>(&m_file); fileHandle != nullptr)
+        {
+            if (SizeType fileOffset{}; m_fileIoBase->Tell(*fileHandle, fileOffset))
+            {
+                return fileOffset;
+            }
+        }
+        else if (auto systemFile = AZStd::get_if<AZ::IO::SystemFile>(&m_file); systemFile != nullptr)
+        {
+            return systemFile->Tell();
+        }
+
+        return 0;
+    }
+
+    bool FileReader::Seek(AZ::s64 offset, SeekType type)
+    {
+        if (auto fileHandle = AZStd::get_if<AZ::IO::HandleType>(&m_file); fileHandle != nullptr)
+        {
+            return m_fileIoBase->Seek(*fileHandle, offset, type);
+        }
+        else if (auto systemFile = AZStd::get_if<AZ::IO::SystemFile>(&m_file); systemFile != nullptr)
+        {
+            systemFile->Seek(offset, static_cast<AZ::IO::SystemFile::SeekMode>(type));
+            return true;
+        }
+
+        return false;
+    }
+
+    bool FileReader::Eof() const
+    {
+        if (auto fileHandle = AZStd::get_if<AZ::IO::HandleType>(&m_file); fileHandle != nullptr)
+        {
+            return m_fileIoBase->Eof(*fileHandle);
+        }
+        else if (auto systemFile = AZStd::get_if<AZ::IO::SystemFile>(&m_file); systemFile != nullptr)
+        {
+            return systemFile->Eof();
+        }
+
+        return false;
+    }
+
+    bool FileReader::GetFilePath(AZ::IO::FixedMaxPath& filePath) const
+    {
+        if (auto fileHandle = AZStd::get_if<AZ::IO::HandleType>(&m_file); fileHandle != nullptr)
+        {
+            AZ::IO::FixedMaxPathString& pathStringRef = filePath.Native();
+            if (m_fileIoBase->GetFilename(*fileHandle, pathStringRef.data(), pathStringRef.capacity()))
+            {
+                pathStringRef.resize_no_construct(AZStd::char_traits<char>::length(pathStringRef.data()));
+                return true;
+            }
+        }
+        else if (auto systemFile = AZStd::get_if<AZ::IO::SystemFile>(&m_file); systemFile != nullptr)
+        {
+            filePath = systemFile->Name();
+            return true;
+        }
+
+        return false;
+    }
+}

Code/Framework/AzCore/AzCore/IO/FileReader.h

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+#pragma once
+
+#include <AzCore/IO/Path/Path_fwd.h>
+#include <AzCore/IO/SystemFile.h>
+#include <AzCore/std/containers/variant.h>
+
+namespace AZ::IO
+{
+    class FileIOBase;
+    enum class SeekType : AZ::u32;
+
+    //! Structure which encapsulates delegates File Read operations
+    //! to either the FileIOBase or SystemFile classes based if a FileIOBase* instance has been supplied
+    //! to the FileSystemReader class
+    //! the SettingsRegistry option to use FileIO
+    class FileReader
+    {
+        using HandleType = AZ::u32;
+        using FileHandleType = AZStd::variant<AZStd::monostate, AZ::IO::SystemFile, HandleType>;
+    public:
+        using SizeType = AZ::u64;
+
+        //! Creates FileReader instance in the default state with no file opend
+        FileReader();
+        ~FileReader();
+
+        //! Creates a new FileReader instance and attempts to open the file at the supplied path
+        //! Uses the FileIOBase instance if supplied
+        //! @param fileIOBase pointer to fileIOBase instance
+        //! @param null-terminated filePath to open
+        FileReader(AZ::IO::FileIOBase* fileIoBase, const char* filePath);
+
+        //! Takes ownership of the supplied FileReader handle
+        FileReader(FileReader&& other);
+
+        //! Moves ownership of FileReader handle to this instance
+        FileReader& operator=(FileReader&& other);
+
+        //! Opens a File using the FileIOBase instance if non-nullptr
+        //! Otherwise fall back to use SystemFile
+        //! @param fileIOBase pointer to fileIOBase instance
+        //! @param null-terminated filePath to open
+        //! @return true if the File is opened successfully
+        bool Open(AZ::IO::FileIOBase* fileIoBase, const char* filePath);
+
+        //! Returns true if a file is currently open
+        //! @return true if the file is open
+        bool IsOpen() const;
+
+        //! Closes the File
+        void Close();
+
+        //! Retrieve the length of the OpenFile
+        SizeType Length() const;
+
+        //! Attempts to read up to byte size bytes into the supplied buffer
+        //! @param byteSize - Maximum number of bytes to read
+        //! @param buffer - Buffer to read bytes into
+        //! @returns the number of bytes read if the file is open, otherwise 0
+        SizeType Read(SizeType byteSize, void* buffer);
+
+        //! Returns the current file offset
+        //! @returns file offset if the file is open, otherwise 0
+        SizeType Tell() const;
+
+        //! Seeks within the open file to the offset supplied
+        //! @param offset File offset to seek to
+        //! @param type parameter to indicate the reference point to start the seek from
+        //! @returns true if the file is open and the seek succeeded
+        bool Seek(AZ::s64 offset, SeekType type);
+
+        //! Returns true if the file is open and in the EOF state
+        bool Eof() const;
+
+        //! Store the file path of the open file into the output file path parameter
+        //! The filePath reference is left unmodified, if the path was not stored
+        //! @return true if the filePath was stored
+        bool GetFilePath(AZ::IO::FixedMaxPath& filePath) const;
+
+    private:
+
+        FileHandleType m_file;
+        AZ::IO::FileIOBase* m_fileIoBase{};
+    };
+}

Code/Framework/AzCore/AzCore/IO/SystemFile.cpp

@@ -160,12 +160,12 @@ void SystemFile::Seek(SeekSizeType offset, SeekMode mode)
     Platform::Seek(m_handle, this, offset, mode);
 }
 
-SystemFile::SizeType SystemFile::Tell()
+SystemFile::SizeType SystemFile::Tell() const
 {
     return Platform::Tell(m_handle, this);
 }
 
-bool SystemFile::Eof()
+bool SystemFile::Eof() const
 {
     return Platform::Eof(m_handle, this);
 }

Code/Framework/AzCore/AzCore/IO/SystemFile.h

@@ -72,9 +72,9 @@ namespace AZ
             /// Seek in current file.
             void Seek(SeekSizeType offset, SeekMode mode);
             /// Get the cursor position in the current file.
-            SizeType Tell();
+            SizeType Tell() const;
             /// Is the cursor at the end of the file?
-            bool Eof();
+            bool Eof() const;
             /// Get the time the file was last modified.
             AZ::u64 ModificationTime();
             /// Read data from a file synchronous. Return number of bytes actually read in the buffer.

Code/Framework/AzCore/AzCore/Math/Transform.cpp

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

Code/Framework/AzCore/AzCore/Settings/SettingsRegistryImpl.cpp

@@ -10,6 +10,7 @@
 #include <cerrno>
 #include <AzCore/Casting/numeric_cast.h>
 #include <AzCore/IO/FileIO.h>
+#include <AzCore/IO/FileReader.h>
 #include <AzCore/IO/Path/Path.h>
 #include <AzCore/JSON/error/en.h>
 #include <AzCore/NativeUI//NativeUIRequests.h>
@@ -1116,118 +1117,6 @@ namespace AZ
         }
     }
 
-    //! Structure which encapsulates Commands to either the FileIOBase or SystemFile classes based on
-    //! the SettingsRegistry option to use FileIO
-    struct SettingsRegistryFileReader
-    {
-        using FileHandleType = AZStd::variant<AZStd::monostate, AZ::IO::SystemFile, AZ::IO::HandleType>;
-
-        SettingsRegistryFileReader() = default;
-        SettingsRegistryFileReader(bool useFileIo, const char* filePath)
-        {
-            Open(useFileIo, filePath);
-        }
-
-        ~SettingsRegistryFileReader()
-        {
-            if (auto fileHandle = AZStd::get_if<AZ::IO::HandleType>(&m_file); fileHandle != nullptr)
-            {
-                if (AZ::IO::FileIOBase* fileIo = AZ::IO::FileIOBase::GetInstance(); fileIo != nullptr)
-                {
-                    fileIo->Close(*fileHandle);
-                }
-            }
-        }
-
-        bool Open(bool useFileIo, const char* filePath)
-        {
-            Close();
-            if (AZ::IO::FileIOBase* fileIo = useFileIo ? AZ::IO::FileIOBase::GetInstance() : nullptr; fileIo != nullptr)
-            {
-                AZ::IO::HandleType fileHandle;
-                if (fileIo->Open(filePath, IO::OpenMode::ModeRead, fileHandle))
-                {
-                    m_file = fileHandle;
-                    return true;
-                }
-            }
-            else
-            {
-                AZ::IO::SystemFile file;
-                if (file.Open(filePath, IO::SystemFile::OpenMode::SF_OPEN_READ_ONLY))
-                {
-                    m_file = AZStd::move(file);
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        bool IsOpen() const
-        {
-            if (auto fileHandle = AZStd::get_if<AZ::IO::HandleType>(&m_file); fileHandle != nullptr)
-            {
-                return *fileHandle != AZ::IO::InvalidHandle;
-            }
-            else if (auto systemFile = AZStd::get_if<AZ::IO::SystemFile>(&m_file); systemFile != nullptr)
-            {
-                return systemFile->IsOpen();
-            }
-
-            return false;
-        }
-
-        void Close()
-        {
-            if (auto fileHandle = AZStd::get_if<AZ::IO::HandleType>(&m_file); fileHandle != nullptr)
-            {
-                if (AZ::IO::FileIOBase* fileIo = AZ::IO::FileIOBase::GetInstance(); fileIo != nullptr)
-                {
-                    fileIo->Close(*fileHandle);
-                }
-            }
-
-            m_file = AZStd::monostate{};
-        }
-
-        u64 Length() const
-        {
-            if (auto fileHandle = AZStd::get_if<AZ::IO::HandleType>(&m_file); fileHandle != nullptr)
-            {
-                if (u64 fileSize{}; AZ::IO::FileIOBase::GetInstance()->Size(*fileHandle, fileSize))
-                {
-                    return fileSize;
-                }
-            }
-            else if (auto systemFile = AZStd::get_if<AZ::IO::SystemFile>(&m_file); systemFile != nullptr)
-            {
-                return systemFile->Length();
-            }
-
-            return 0;
-        }
-
-        AZ::IO::SizeType Read(AZ::IO::SizeType byteSize, void* buffer)
-        {
-            if (auto fileHandle = AZStd::get_if<AZ::IO::HandleType>(&m_file); fileHandle != nullptr)
-            {
-                if (AZ::u64 bytesRead{}; AZ::IO::FileIOBase::GetInstance()->Read(*fileHandle, buffer, byteSize, false, &bytesRead))
-                {
-                    return bytesRead;
-                }
-            }
-            else if (auto systemFile = AZStd::get_if<AZ::IO::SystemFile>(&m_file); systemFile != nullptr)
-            {
-                return systemFile->Read(byteSize, buffer);
-            }
-
-            return 0;
-        }
-
-        FileHandleType m_file;
-    };
-
     bool SettingsRegistryImpl::MergeSettingsFileInternal(const char* path, Format format, AZStd::string_view rootKey,
         AZStd::vector<char>& scratchBuffer)
     {
@@ -1236,7 +1125,7 @@ namespace AZ
 
         Pointer pointer(AZ_SETTINGS_REGISTRY_HISTORY_KEY "/-");
 
-        SettingsRegistryFileReader fileReader(m_useFileIo, path);
+        FileReader fileReader(m_useFileIo ? AZ::IO::FileIOBase::GetInstance(): nullptr, path);
         if (!fileReader.IsOpen())
         {
             AZ_Error("Settings Registry", false, R"(Unable to open registry file "%s".)", path);

Code/Framework/AzCore/AzCore/Settings/SettingsRegistryMergeUtils.cpp

@@ -6,6 +6,8 @@
  *
  */
 
+#include <AzCore/IO/FileIO.h>
+#include <AzCore/IO/FileReader.h>
 #include <AzCore/IO/GenericStreams.h>
 #include <AzCore/IO/Path/Path.h>
 #include <AzCore/IO/TextStreamWriters.h>
@@ -388,8 +390,36 @@ namespace AZ::SettingsRegistryMergeUtils
         const ConfigParserSettings& configParserSettings)
     {
         auto configPath = FindEngineRoot(registry) / filePath;
-        IO::SystemFile configFile;
-        if (!configFile.Open(configPath.c_str(), IO::SystemFile::OpenMode::SF_OPEN_READ_ONLY))
+        IO::FileReader configFile;
+        bool configFileOpened{};
+        switch (configParserSettings.m_fileReaderClass)
+        {
+        case ConfigParserSettings::FileReaderClass::UseFileIOIfAvailableFallbackToSystemFile:
+        {
+            auto fileIo = AZ::IO::FileIOBase::GetInstance();
+            configFileOpened = configFile.Open(fileIo, configPath.c_str());
+            break;
+        }
+        case ConfigParserSettings::FileReaderClass::UseSystemFileOnly:
+        {
+            configFileOpened = configFile.Open(nullptr, configPath.c_str());
+            break;
+        }
+        case ConfigParserSettings::FileReaderClass::UseFileIOOnly:
+        {
+            auto fileIo = AZ::IO::FileIOBase::GetInstance();
+            if (fileIo == nullptr)
+            {
+                return false;
+            }
+            configFileOpened = configFile.Open(fileIo, configPath.c_str());
+            break;
+        }
+        default:
+            AZ_Error("SettingsRegistryMergeUtils", false, "An Invalid FileReaderClass enum value has been supplied");
+            return false;
+        }
+        if (!configFileOpened)
         {
             AZ_Warning("SettingsRegistryMergeUtils", false, R"(Unable to open file "%s")", configPath.c_str());
             return false;
@@ -480,7 +510,7 @@ namespace AZ::SettingsRegistryMergeUtils
                 AZ_Error("SettingsRegistryMergeUtils", false,
                     R"(The config file "%s" contains a line which is longer than the max line length of %zu.)" "\n"
                     R"(Parsing will halt. The line content so far is:)" "\n"
-                    R"("%.*s")" "\n", configFile.Name(), configBuffer.max_size(),
+                    R"("%.*s")" "\n", configPath.c_str(), configBuffer.max_size(),
                     aznumeric_cast<int>(configBuffer.size()), configBuffer.data());
                 configFileParsed = false;
                 break;

Code/Framework/AzCore/AzCore/Settings/SettingsRegistryMergeUtils.h

@@ -155,6 +155,15 @@ namespace AZ::SettingsRegistryMergeUtils
         //! structure which is forwarded to the SettingsRegistryInterface MergeCommandLineArgument function
         //! The structure contains a functor which returns true if a character is a valid delimiter
         SettingsRegistryInterface::CommandLineArgumentSettings m_commandLineSettings;
+
+        //! enumeration to indicate if AZ::IO::FileIOBase should be used to open the config file over AZ::IO::SystemFile
+        enum class FileReaderClass
+        {
+            UseFileIOIfAvailableFallbackToSystemFile,
+            UseSystemFileOnly,
+            UseFileIOOnly
+        };
+        FileReaderClass m_fileReaderClass = FileReaderClass::UseFileIOIfAvailableFallbackToSystemFile;
     };
     //! Loads basic configuration files which have structures similar to Windows INI files
     //! It is inspired by the Python configparser module: https://docs.python.org/3.10/library/configparser.html

Code/Framework/AzCore/AzCore/azcore_files.cmake

@@ -166,6 +166,8 @@ set(FILES
     IO/FileIO.cpp
     IO/FileIO.h
     IO/FileIOEventBus.h
+    IO/FileReader.cpp
+    IO/FileReader.h
     IO/IOUtils.h
     IO/IOUtils.cpp
     IO/IStreamer.h

Code/Framework/AzCore/Platform/Common/UnixLike/AzCore/Module/DynamicModuleHandle_UnixLike.cpp

@@ -72,6 +72,7 @@ namespace AZ
             {
                 if (auto settingsRegistry = AZ::SettingsRegistry::Get(); settingsRegistry != nullptr)
                 {
+                    bool fileFound = false;
                     if (AZ::IO::FixedMaxPath projectModulePath;
                         settingsRegistry->Get(projectModulePath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_ProjectConfigurationBinPath))
                     {
@@ -79,6 +80,23 @@ namespace AZ
                         if (AZ::IO::SystemFile::Exists(projectModulePath.c_str()))
                         {
                             m_fileName.assign(projectModulePath.c_str(), projectModulePath.Native().size());
+                            fileFound = true;
+                        }
+                    }
+                    if (!fileFound)
+                    {
+                        if (AZ::IO::FixedMaxPath installedBinariesPath;
+                            settingsRegistry->Get(installedBinariesPath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_InstalledBinaryFolder))
+                        {
+                            if (AZ::IO::FixedMaxPath engineRootFolder;
+                                settingsRegistry->Get(engineRootFolder.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder))
+                            {
+                                installedBinariesPath = engineRootFolder / installedBinariesPath / fullFilePath;
+                                if (AZ::IO::SystemFile::Exists(installedBinariesPath.c_str()))
+                                {
+                                    m_fileName.assign(installedBinariesPath.c_str(), installedBinariesPath.Native().size());
+                                }
+                            }
                         }
                     }
                 }

Code/Framework/AzCore/Platform/Common/UnixLike/AzCore/Utils/Utils_UnixLike.cpp

@@ -9,6 +9,7 @@
 #include <AzCore/Utils/Utils.h>
 
 #include <cstdlib>
+#include <pwd.h>
 
 namespace AZ
 {
@@ -39,6 +40,14 @@ namespace AZ
                 AZ::IO::FixedMaxPath path{homePath};
                 return path.Native();
             }
+
+            struct passwd* pass = getpwuid(getuid());
+            if (pass)
+            {
+                AZ::IO::FixedMaxPath path{pass->pw_dir};
+                return path.Native();
+            }
+            
             return {};
         }
 

Code/Framework/AzCore/Tests/IO/FileReaderTests.cpp

@@ -0,0 +1,72 @@
+/*
+ * 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/IO/FileReader.h>
+#include <FileIOBaseTestTypes.h>
+#include <AzCore/UnitTest/TestTypes.h>
+
+namespace UnitTest
+{
+    template <typename FileIOType>
+    class FileReaderTestFixture
+        : public ScopedAllocatorSetupFixture
+    {
+    public:
+        void SetUp() override
+        {
+            if constexpr (AZStd::is_same_v<FileIOType, TestFileIOBase>)
+            {
+                m_fileIo = AZStd::make_unique<TestFileIOBase>();
+            }
+        }
+
+        void TearDown() override
+        {
+            m_fileIo.reset();
+        }
+
+    protected:
+        AZStd::unique_ptr<AZ::IO::FileIOBase> m_fileIo{};
+    };
+
+    using FileIOTypes = ::testing::Types<void, TestFileIOBase>;
+
+    TYPED_TEST_CASE(FileReaderTestFixture, FileIOTypes);
+
+    TYPED_TEST(FileReaderTestFixture, ConstructorWithFilePath_OpensFileSuccessfully)
+    {
+        AZ::IO::FileReader fileReader(this->m_fileIo.get(), AZ::IO::SystemFile::GetNullFilename());
+        EXPECT_TRUE(fileReader.IsOpen());
+    }
+
+    TYPED_TEST(FileReaderTestFixture, Open_OpensFileSucessfully)
+    {
+        AZ::IO::FileReader fileReader;
+        fileReader.Open(this->m_fileIo.get(), AZ::IO::SystemFile::GetNullFilename());
+        EXPECT_TRUE(fileReader.IsOpen());
+    }
+
+    TYPED_TEST(FileReaderTestFixture, Eof_OnNULDeviceFile_Succeeds)
+    {
+        AZ::IO::FileReader fileReader(this->m_fileIo.get(), AZ::IO::SystemFile::GetNullFilename());
+        EXPECT_TRUE(fileReader.Eof());
+    }
+
+    TYPED_TEST(FileReaderTestFixture, GetFilePath_ReturnsNULDeviceFilename_Succeeds)
+    {
+        AZ::IO::FileReader fileReader(this->m_fileIo.get(), AZ::IO::SystemFile::GetNullFilename());
+        AZ::IO::FixedMaxPath filePath;
+        EXPECT_TRUE(fileReader.GetFilePath(filePath));
+        AZ::IO::FixedMaxPath nulFilename{ AZ::IO::SystemFile::GetNullFilename() };
+        if (this->m_fileIo)
+        {
+            EXPECT_TRUE(this->m_fileIo->ResolvePath(nulFilename, nulFilename));
+        }
+        EXPECT_EQ(nulFilename, filePath);
+    }
+
+}   // namespace UnitTest

Code/Framework/AzCore/Tests/azcoretests_files.cmake

@@ -37,6 +37,7 @@ set(FILES
     FileIOBaseTestTypes.h
     Geometry2DUtils.cpp
     Interface.cpp
+    IO/FileReaderTests.cpp
     IO/Path/PathTests.cpp
     IPC.cpp
     Jobs.cpp

Code/Framework/AzFramework/AzFramework/Archive/ZipDirCache.cpp

@@ -774,7 +774,7 @@ namespace AZ::IO::ZipDir
             return ZD_ERROR_INVALID_CALL;
         }
 
-        if (pFileEntry->nFileDataOffset != pFileEntry->INVALID_DATA_OFFSET)
+        if (pFileEntry->nFileDataOffset != FileEntryBase::INVALID_DATA_OFFSET)
         {
             return ZD_ERROR_SUCCESS; // the data offset has been successfully read..
         }

Code/Framework/AzFramework/AzFramework/Archive/ZipDirCacheFactory.cpp

@@ -553,7 +553,7 @@ namespace AZ::IO::ZipDir
 
     //////////////////////////////////////////////////////////////////////////
     // give the CDR File Header entry, reads the local file header to validate
-    // and determine where the actual file lies
+    // and determine where the actual file resides
     void CacheFactory::AddFileEntry(char* strFilePath, const ZipFile::CDRFileHeader* pFileHeader, const SExtraZipFileData& extra)
     {
         if (pFileHeader->lLocalHeaderOffset > m_CDREnd.lCDROffset)
@@ -600,8 +600,7 @@ namespace AZ::IO::ZipDir
         if (m_encryptedHeaders != ZipFile::HEADERS_NOT_ENCRYPTED)
         {
             // use CDR instead of local header
-            // The pak encryption tool asserts that there is no extra data at the end of the local file header, so don't add any extra data from the CDR header.
-            fileEntry.nFileDataOffset = pFileHeader->lLocalHeaderOffset + sizeof(ZipFile::LocalFileHeader) + pFileHeader->nFileNameLength;
+            fileEntry.nFileDataOffset = pFileHeader->lLocalHeaderOffset + sizeof(ZipFile::LocalFileHeader) + pFileHeader->nFileNameLength + pFileHeader->nExtraFieldLength;
         }
         else
         {

Code/Framework/AzFramework/AzFramework/Archive/ZipDirStructures.cpp

@@ -187,8 +187,7 @@ namespace AZ::IO::ZipDir::ZipDirStructuresInternal
 
         // If src/dst overlap (in place decompress), then inflate in chunks, copying src locally to ensure
         // pointers don't foul each other.
-        bool bIndependantBlocks = ((pInput + nInputLen) <= pOutput) || (pInput >= (pOutput + nOutputLen));
-        if (bIndependantBlocks)
+        if ((pInput + nInputLen) <= pOutput || pInput >= (pOutput + nOutputLen))
         {
             pZStream->next_in = (Bytef*)pInput;
             pZStream->avail_in = aznumeric_cast<uint32_t>(nInputLen);
@@ -260,8 +259,7 @@ namespace AZ::IO::ZipDir::ZipDirStructuresInternal
 
         // If src/dst overlap (in place decompress), then inflate in chunks, copying src locally to ensure
         // pointers don't foul each other.
-        bool bIndependantBlocks = ((pIn + nIn) <= stream.next_out) || (pIn >= (stream.next_out + stream.avail_out));
-        if (bIndependantBlocks)
+        if ((pIn + nIn) <= stream.next_out || pIn >= (stream.next_out + stream.avail_out))
         {
             stream.next_in = pIn;
             stream.avail_in = nIn;
@@ -498,18 +496,18 @@ namespace AZ::IO::ZipDir
     //////////////////////////////////////////////////////////////////////////
     FileEntryBase::FileEntryBase(const ZipFile::CDRFileHeader& header, const SExtraZipFileData& extra)
     {
-        this->desc = header.desc;
-        this->nFileHeaderOffset = header.lLocalHeaderOffset;
-        //this->nFileDataOffset   = INVALID_DATA_OFFSET; // we don't know yet
-        this->nMethod = header.nMethod;
-        this->nNameOffset = 0; // we don't know yet
-        this->nLastModTime = header.nLastModTime;
-        this->nLastModDate = header.nLastModDate;
-        this->nNTFS_LastModifyTime = extra.nLastModifyTime;
+        desc = header.desc;
+        nFileHeaderOffset = header.lLocalHeaderOffset;
+
+        nMethod = header.nMethod;
+        nNameOffset = 0; // we don't know yet
+        nLastModTime = header.nLastModTime;
+        nLastModDate = header.nLastModDate;
+        nNTFS_LastModifyTime = extra.nLastModifyTime;
 
         // make an estimation (at least this offset should be there), but we don't actually know yet
-        this->nFileDataOffset = header.lLocalHeaderOffset + sizeof(ZipFile::LocalFileHeader) + header.nFileNameLength;
-        this->nEOFOffset = header.lLocalHeaderOffset + sizeof(ZipFile::LocalFileHeader) + header.nFileNameLength + header.desc.lSizeCompressed;
+        nFileDataOffset = header.lLocalHeaderOffset + sizeof(ZipFile::LocalFileHeader) + header.nFileNameLength + header.nExtraFieldLength;
+        nEOFOffset = nFileDataOffset + header.desc.lSizeCompressed;
     }
 
     // Uncompresses raw (without wrapping) data that is compressed with method 8 (deflated) in the Zip file
@@ -817,8 +815,6 @@ namespace AZ::IO::ZipDir
         header.nFileNameLength = aznumeric_cast<uint16_t>(nFileNameLength);
         header.nExtraFieldLength = 0;
 
-        pFileEntry->nFileDataOffset = pFileEntry->nFileHeaderOffset + sizeof(header) + header.nFileNameLength;
-        pFileEntry->nEOFOffset = pFileEntry->nFileDataOffset + pFileEntry->desc.lSizeCompressed;
         if (!AZ::IO::FileIOBase::GetDirectInstance()->Write(fileHandle, &header, sizeof(header)))
         {
             return ZD_ERROR_IO_FAILED;

Code/Framework/AzFramework/AzFramework/Archive/ZipDirStructures.h

@@ -169,7 +169,7 @@ namespace AZ::IO::ZipDir
 
         inline static constexpr uint32_t INVALID_DATA_OFFSET = 0xFFFFFFFF;
         ZipFile::DataDescriptor desc{};
-        uint32_t nFileDataOffset{}; // offset of the packed info inside the file; NOTE: this can be INVALID_DATA_OFFSET, if not calculated yet!
+        uint32_t nFileDataOffset{ INVALID_DATA_OFFSET }; // offset of the packed info inside the file; NOTE: this can be INVALID_DATA_OFFSET, if not calculated yet!
         uint32_t nFileHeaderOffset{ INVALID_DATA_OFFSET }; // offset of the local file header
         uint32_t nNameOffset{};       // offset of the file name in the name pool for the directory
 

Code/Framework/AzFramework/AzFramework/Viewport/ClickDetector.cpp

@@ -9,8 +9,19 @@
 #include <AzFramework/Viewport/ClickDetector.h>
 #include <AzFramework/Viewport/ScreenGeometry.h>
 
+#include <AzCore/std/chrono/clocks.h>
+
 namespace AzFramework
 {
+    ClickDetector::ClickDetector()
+    {
+        m_timeNowFn = []
+        {
+            const auto now = AZStd::chrono::high_resolution_clock::now();
+            return AZStd::chrono::time_point_cast<AZStd::chrono::milliseconds>(now).time_since_epoch();
+        };
+    }
+
     ClickDetector::ClickOutcome ClickDetector::DetectClick(const ClickEvent clickEvent, const ScreenVector& cursorDelta)
     {
         const auto previousDetectionState = m_detectionState;
@@ -26,11 +37,13 @@ namespace AzFramework
 
         if (clickEvent == ClickEvent::Down)
         {
-            const auto now = std::chrono::steady_clock::now();
+            const auto now = m_timeNowFn();
             if (m_tryBeginTime)
             {
-                const std::chrono::duration<float> diff = now - m_tryBeginTime.value();
-                if (diff.count() < m_doubleClickInterval)
+                using FloatingPointSeconds = AZStd::chrono::duration<float, AZStd::chrono::seconds::period>;
+
+                const auto diff = now - m_tryBeginTime.value();
+                if (FloatingPointSeconds(diff).count() < m_doubleClickInterval)
                 {
                     return ClickOutcome::Nil;
                 }
@@ -43,7 +56,8 @@ namespace AzFramework
         }
         else if (clickEvent == ClickEvent::Up)
         {
-            const auto clickOutcome = [detectionState = m_detectionState] {
+            const auto clickOutcome = [detectionState = m_detectionState]
+            {
                 if (detectionState == DetectionState::WaitingForMove)
                 {
                     return ClickOutcome::Click;
@@ -66,4 +80,9 @@ namespace AzFramework
 
         return ClickOutcome::Nil;
     }
+
+    void ClickDetector::OverrideTimeNowFn(AZStd::function<AZStd::chrono::milliseconds()> timeNowFn)
+    {
+        m_timeNowFn = AZStd::move(timeNowFn);
+    }
 } // namespace AzFramework

Code/Framework/AzFramework/AzFramework/Viewport/ClickDetector.h

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include <AzCore/std/functional.h>
 #include <AzCore/std/optional.h>
 
 #include <chrono>
@@ -21,10 +22,9 @@ namespace AzFramework
     //! (mouse down with movement and then mouse up).
     class ClickDetector
     {
-        //! Alias for recording time of mouse down events
-        using Time = std::chrono::time_point<std::chrono::steady_clock>;
-
     public:
+        ClickDetector();
+
         //! Internal representation of click event (map from external event for this when
         //! calling DetectClick).
         enum class ClickEvent
@@ -51,6 +51,10 @@ namespace AzFramework
         void SetDoubleClickInterval(float doubleClickInterval);
         //! Override the dead zone before a 'move' outcome will be triggered.
         void SetDeadZone(float deadZone);
+        //! Override how the current time is retrieved.
+        //! This is helpful to override when it comes to simulating different passages of
+        //! time to avoid double click issues in tests for example.
+        void OverrideTimeNowFn(AZStd::function<AZStd::chrono::milliseconds()> timeNowFn);
 
     private:
         //! Internal state of ClickDetector based on incoming events.
@@ -65,7 +69,9 @@ namespace AzFramework
         float m_deadZone = 2.0f; //!< How far to move before a click is cancelled (when Move will fire).
         float m_doubleClickInterval = 0.4f; //!< Default double click interval, can be overridden.
         DetectionState m_detectionState; //!< Internal state of ClickDetector.
-        AZStd::optional<Time> m_tryBeginTime; //!< Mouse down time (happens each mouse down, helps with double click handling).
+        //! Mouse down time (happens each mouse down, helps with double click handling).
+        AZStd::optional<AZStd::chrono::milliseconds> m_tryBeginTime;
+        AZStd::function<AZStd::chrono::milliseconds()> m_timeNowFn; //!< Interface to query the current time.
     };
 
     inline void ClickDetector::SetDoubleClickInterval(const float doubleClickInterval)

Code/Framework/AzFramework/Platform/Linux/AzFramework/Input/Devices/Keyboard/InputDeviceKeyboard_xcb.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 <AzCore/std/typetraits/integral_constant.h>
+#include <AzFramework/API/ApplicationAPI_Linux.h>
+#include <AzFramework/Input/Devices/Keyboard/InputDeviceKeyboard.h>
+
+#define explicit ExplicitIsACXXKeyword
+#include <xcb/xkb.h>
+#undef explicit
+#include <xkbcommon/xkbcommon-keysyms.h>
+#include <xkbcommon/xkbcommon.h>
+#include <xkbcommon/xkbcommon-x11.h>
+
+namespace AzFramework
+{
+    class InputDeviceKeyboardXcb
+        : public InputDeviceKeyboard::Implementation
+        , public LinuxXcbEventHandlerBus::Handler
+    {
+    public:
+        AZ_CLASS_ALLOCATOR(InputDeviceKeyboardXcb, AZ::SystemAllocator, 0);
+
+        using InputDeviceKeyboard::Implementation::Implementation;
+        InputDeviceKeyboardXcb(InputDeviceKeyboard& inputDevice)
+            : InputDeviceKeyboard::Implementation(inputDevice)
+        {
+            LinuxXcbEventHandlerBus::Handler::BusConnect();
+
+            auto* interface = AzFramework::LinuxXcbConnectionManagerInterface::Get();
+            if (!interface)
+            {
+                AZ_Warning("ApplicationLinux", false, "XCB interface not available");
+                return;
+            }
+
+            auto* connection = AzFramework::LinuxXcbConnectionManagerInterface::Get()->GetXcbConnection();
+            if (!connection)
+            {
+                AZ_Warning("ApplicationLinux", false, "XCB connection not available");
+                return;
+            }
+
+            AZStd::unique_ptr<xcb_xkb_use_extension_reply_t, DeleterForFreeFn<::std::free>> xkbUseExtensionReply{
+                xcb_xkb_use_extension_reply(connection, xcb_xkb_use_extension(connection, 1, 0), nullptr)
+            };
+            if (!xkbUseExtensionReply)
+            {
+                AZ_Warning("ApplicationLinux", false, "Failed to initialize the xkb extension");
+                return;
+            }
+            if (!xkbUseExtensionReply->supported)
+            {
+                AZ_Warning("ApplicationLinux", false, "The X server does not support the xkb extension");
+                return;
+            }
+
+            m_coreDeviceId = xkb_x11_get_core_keyboard_device_id(connection);
+
+            m_xkbContext.reset(xkb_context_new(XKB_CONTEXT_NO_FLAGS));
+            m_xkbKeymap.reset(xkb_x11_keymap_new_from_device(m_xkbContext.get(), connection, m_coreDeviceId, XKB_KEYMAP_COMPILE_NO_FLAGS));
+            m_xkbState.reset(xkb_x11_state_new_from_device(m_xkbKeymap.get(), connection, m_coreDeviceId));
+
+            m_initialized = true;
+        }
+
+        bool IsConnected() const override
+        {
+            return m_initialized;
+        }
+
+        bool HasTextEntryStarted() const override
+        {
+            return false;
+        }
+
+        void TextEntryStart(const InputDeviceKeyboard::VirtualKeyboardOptions& options) override
+        {
+        }
+
+        void TextEntryStop() override
+        {
+        }
+
+        void TickInputDevice() override
+        {
+            ProcessRawEventQueues();
+        }
+
+        void HandleXcbEvent(xcb_generic_event_t* event) override
+        {
+            if (!IsConnected())
+            {
+                return;
+            }
+
+            switch (event->response_type & ~0x80)
+            {
+            case XCB_KEY_PRESS:
+            {
+                auto* keyPress = reinterpret_cast<xcb_key_press_event_t*>(event);
+
+                const InputChannelId* key = InputChannelFromKeyEvent(keyPress->detail);
+                if (key)
+                {
+                    QueueRawKeyEvent(*key, true);
+                }
+                break;
+            }
+            case XCB_KEY_RELEASE:
+            {
+                auto* keyRelease = reinterpret_cast<xcb_key_release_event_t*>(event);
+
+                const InputChannelId* key = InputChannelFromKeyEvent(keyRelease->detail);
+                if (key)
+                {
+                    QueueRawKeyEvent(*key, false);
+                }
+                break;
+            }
+            }
+        }
+
+    private:
+        [[nodiscard]] const InputChannelId* InputChannelFromKeyEvent(xcb_keycode_t code) const
+        {
+            const xcb_keysym_t keysym = xkb_state_key_get_one_sym(m_xkbState.get(), code);
+
+            switch(keysym)
+            {
+                case XKB_KEY_0: return &InputDeviceKeyboard::Key::Alphanumeric0;
+                case XKB_KEY_1: return &InputDeviceKeyboard::Key::Alphanumeric1;
+                case XKB_KEY_2: return &InputDeviceKeyboard::Key::Alphanumeric2;
+                case XKB_KEY_3: return &InputDeviceKeyboard::Key::Alphanumeric3;
+                case XKB_KEY_4: return &InputDeviceKeyboard::Key::Alphanumeric4;
+                case XKB_KEY_5: return &InputDeviceKeyboard::Key::Alphanumeric5;
+                case XKB_KEY_6: return &InputDeviceKeyboard::Key::Alphanumeric6;
+                case XKB_KEY_7: return &InputDeviceKeyboard::Key::Alphanumeric7;
+                case XKB_KEY_8: return &InputDeviceKeyboard::Key::Alphanumeric8;
+                case XKB_KEY_9: return &InputDeviceKeyboard::Key::Alphanumeric9;
+                case XKB_KEY_A:
+                case XKB_KEY_a: return &InputDeviceKeyboard::Key::AlphanumericA;
+                case XKB_KEY_B:
+                case XKB_KEY_b: return &InputDeviceKeyboard::Key::AlphanumericB;
+                case XKB_KEY_C:
+                case XKB_KEY_c: return &InputDeviceKeyboard::Key::AlphanumericC;
+                case XKB_KEY_D:
+                case XKB_KEY_d: return &InputDeviceKeyboard::Key::AlphanumericD;
+                case XKB_KEY_E:
+                case XKB_KEY_e: return &InputDeviceKeyboard::Key::AlphanumericE;
+                case XKB_KEY_F:
+                case XKB_KEY_f: return &InputDeviceKeyboard::Key::AlphanumericF;
+                case XKB_KEY_G:
+                case XKB_KEY_g: return &InputDeviceKeyboard::Key::AlphanumericG;
+                case XKB_KEY_H:
+                case XKB_KEY_h: return &InputDeviceKeyboard::Key::AlphanumericH;
+                case XKB_KEY_I:
+                case XKB_KEY_i: return &InputDeviceKeyboard::Key::AlphanumericI;
+                case XKB_KEY_J:
+                case XKB_KEY_j: return &InputDeviceKeyboard::Key::AlphanumericJ;
+                case XKB_KEY_K:
+                case XKB_KEY_k: return &InputDeviceKeyboard::Key::AlphanumericK;
+                case XKB_KEY_L:
+                case XKB_KEY_l: return &InputDeviceKeyboard::Key::AlphanumericL;
+                case XKB_KEY_M:
+                case XKB_KEY_m: return &InputDeviceKeyboard::Key::AlphanumericM;
+                case XKB_KEY_N:
+                case XKB_KEY_n: return &InputDeviceKeyboard::Key::AlphanumericN;
+                case XKB_KEY_O:
+                case XKB_KEY_o: return &InputDeviceKeyboard::Key::AlphanumericO;
+                case XKB_KEY_P:
+                case XKB_KEY_p: return &InputDeviceKeyboard::Key::AlphanumericP;
+                case XKB_KEY_Q:
+                case XKB_KEY_q: return &InputDeviceKeyboard::Key::AlphanumericQ;
+                case XKB_KEY_R:
+                case XKB_KEY_r: return &InputDeviceKeyboard::Key::AlphanumericR;
+                case XKB_KEY_S:
+                case XKB_KEY_s: return &InputDeviceKeyboard::Key::AlphanumericS;
+                case XKB_KEY_T:
+                case XKB_KEY_t: return &InputDeviceKeyboard::Key::AlphanumericT;
+                case XKB_KEY_U:
+                case XKB_KEY_u: return &InputDeviceKeyboard::Key::AlphanumericU;
+                case XKB_KEY_V:
+                case XKB_KEY_v: return &InputDeviceKeyboard::Key::AlphanumericV;
+                case XKB_KEY_W:
+                case XKB_KEY_w: return &InputDeviceKeyboard::Key::AlphanumericW;
+                case XKB_KEY_X:
+                case XKB_KEY_x: return &InputDeviceKeyboard::Key::AlphanumericX;
+                case XKB_KEY_Y:
+                case XKB_KEY_y: return &InputDeviceKeyboard::Key::AlphanumericY;
+                case XKB_KEY_Z:
+                case XKB_KEY_z: return &InputDeviceKeyboard::Key::AlphanumericZ;
+                case XKB_KEY_BackSpace: return &InputDeviceKeyboard::Key::EditBackspace;
+                case XKB_KEY_Caps_Lock: return &InputDeviceKeyboard::Key::EditCapsLock;
+                case XKB_KEY_Return: return &InputDeviceKeyboard::Key::EditEnter;
+                case XKB_KEY_space: return &InputDeviceKeyboard::Key::EditSpace;
+                case XKB_KEY_Tab: return &InputDeviceKeyboard::Key::EditTab;
+                case XKB_KEY_Escape: return &InputDeviceKeyboard::Key::Escape;
+                case XKB_KEY_F1: return &InputDeviceKeyboard::Key::Function01;
+                case XKB_KEY_F2: return &InputDeviceKeyboard::Key::Function02;
+                case XKB_KEY_F3: return &InputDeviceKeyboard::Key::Function03;
+                case XKB_KEY_F4: return &InputDeviceKeyboard::Key::Function04;
+                case XKB_KEY_F5: return &InputDeviceKeyboard::Key::Function05;
+                case XKB_KEY_F6: return &InputDeviceKeyboard::Key::Function06;
+                case XKB_KEY_F7: return &InputDeviceKeyboard::Key::Function07;
+                case XKB_KEY_F8: return &InputDeviceKeyboard::Key::Function08;
+                case XKB_KEY_F9: return &InputDeviceKeyboard::Key::Function09;
+                case XKB_KEY_F10: return &InputDeviceKeyboard::Key::Function10;
+                case XKB_KEY_F11: return &InputDeviceKeyboard::Key::Function11;
+                case XKB_KEY_F12: return &InputDeviceKeyboard::Key::Function12;
+                case XKB_KEY_F13: return &InputDeviceKeyboard::Key::Function13;
+                case XKB_KEY_F14: return &InputDeviceKeyboard::Key::Function14;
+                case XKB_KEY_F15: return &InputDeviceKeyboard::Key::Function15;
+                case XKB_KEY_F16: return &InputDeviceKeyboard::Key::Function16;
+                case XKB_KEY_F17: return &InputDeviceKeyboard::Key::Function17;
+                case XKB_KEY_F18: return &InputDeviceKeyboard::Key::Function18;
+                case XKB_KEY_F19: return &InputDeviceKeyboard::Key::Function19;
+                case XKB_KEY_F20: return &InputDeviceKeyboard::Key::Function20;
+                case XKB_KEY_Alt_L: return &InputDeviceKeyboard::Key::ModifierAltL;
+                case XKB_KEY_Alt_R: return &InputDeviceKeyboard::Key::ModifierAltR;
+                case XKB_KEY_Control_L: return &InputDeviceKeyboard::Key::ModifierCtrlL;
+                case XKB_KEY_Control_R: return &InputDeviceKeyboard::Key::ModifierCtrlR;
+                case XKB_KEY_Shift_L: return &InputDeviceKeyboard::Key::ModifierShiftL;
+                case XKB_KEY_Shift_R: return &InputDeviceKeyboard::Key::ModifierShiftR;
+                case XKB_KEY_Super_L: return &InputDeviceKeyboard::Key::ModifierSuperL;
+                case XKB_KEY_Super_R: return &InputDeviceKeyboard::Key::ModifierSuperR;
+                case XKB_KEY_Down: return &InputDeviceKeyboard::Key::NavigationArrowDown;
+                case XKB_KEY_Left: return &InputDeviceKeyboard::Key::NavigationArrowLeft;
+                case XKB_KEY_Right: return &InputDeviceKeyboard::Key::NavigationArrowRight;
+                case XKB_KEY_Up: return &InputDeviceKeyboard::Key::NavigationArrowUp;
+                case XKB_KEY_Delete: return &InputDeviceKeyboard::Key::NavigationDelete;
+                case XKB_KEY_End: return &InputDeviceKeyboard::Key::NavigationEnd;
+                case XKB_KEY_Home: return &InputDeviceKeyboard::Key::NavigationHome;
+                case XKB_KEY_Insert: return &InputDeviceKeyboard::Key::NavigationInsert;
+                case XKB_KEY_Page_Down: return &InputDeviceKeyboard::Key::NavigationPageDown;
+                case XKB_KEY_Page_Up: return &InputDeviceKeyboard::Key::NavigationPageUp;
+                case XKB_KEY_Num_Lock: return &InputDeviceKeyboard::Key::NumLock;
+                case XKB_KEY_KP_0: return &InputDeviceKeyboard::Key::NumPad0;
+                case XKB_KEY_KP_1: return &InputDeviceKeyboard::Key::NumPad1;
+                case XKB_KEY_KP_2: return &InputDeviceKeyboard::Key::NumPad2;
+                case XKB_KEY_KP_3: return &InputDeviceKeyboard::Key::NumPad3;
+                case XKB_KEY_KP_4: return &InputDeviceKeyboard::Key::NumPad4;
+                case XKB_KEY_KP_5: return &InputDeviceKeyboard::Key::NumPad5;
+                case XKB_KEY_KP_6: return &InputDeviceKeyboard::Key::NumPad6;
+                case XKB_KEY_KP_7: return &InputDeviceKeyboard::Key::NumPad7;
+                case XKB_KEY_KP_8: return &InputDeviceKeyboard::Key::NumPad8;
+                case XKB_KEY_KP_9: return &InputDeviceKeyboard::Key::NumPad9;
+                case XKB_KEY_KP_Add: return &InputDeviceKeyboard::Key::NumPadAdd;
+                case XKB_KEY_KP_Decimal: return &InputDeviceKeyboard::Key::NumPadDecimal;
+                case XKB_KEY_KP_Divide: return &InputDeviceKeyboard::Key::NumPadDivide;
+                case XKB_KEY_KP_Enter: return &InputDeviceKeyboard::Key::NumPadEnter;
+                case XKB_KEY_KP_Multiply: return &InputDeviceKeyboard::Key::NumPadMultiply;
+                case XKB_KEY_KP_Subtract: return &InputDeviceKeyboard::Key::NumPadSubtract;
+                case XKB_KEY_apostrophe: return &InputDeviceKeyboard::Key::PunctuationApostrophe;
+                case XKB_KEY_backslash: return &InputDeviceKeyboard::Key::PunctuationBackslash;
+                case XKB_KEY_bracketleft: return &InputDeviceKeyboard::Key::PunctuationBracketL;
+                case XKB_KEY_bracketright: return &InputDeviceKeyboard::Key::PunctuationBracketR;
+                case XKB_KEY_comma: return &InputDeviceKeyboard::Key::PunctuationComma;
+                case XKB_KEY_equal: return &InputDeviceKeyboard::Key::PunctuationEquals;
+                case XKB_KEY_hyphen: return &InputDeviceKeyboard::Key::PunctuationHyphen;
+                case XKB_KEY_period: return &InputDeviceKeyboard::Key::PunctuationPeriod;
+                case XKB_KEY_semicolon: return &InputDeviceKeyboard::Key::PunctuationSemicolon;
+                case XKB_KEY_slash: return &InputDeviceKeyboard::Key::PunctuationSlash;
+                case XKB_KEY_grave:
+                case XKB_KEY_asciitilde: return &InputDeviceKeyboard::Key::PunctuationTilde;
+                case XKB_KEY_ISO_Group_Shift: return &InputDeviceKeyboard::Key::SupplementaryISO;
+                case XKB_KEY_Pause: return &InputDeviceKeyboard::Key::WindowsSystemPause;
+                case XKB_KEY_Print: return &InputDeviceKeyboard::Key::WindowsSystemPrint;
+                case XKB_KEY_Scroll_Lock: return &InputDeviceKeyboard::Key::WindowsSystemScrollLock;
+                default: return nullptr;
+            }
+        }
+
+        template<auto freeFn>
+        using DeleterForFreeFn = AZStd::integral_constant<decltype(freeFn), freeFn>;
+
+        AZStd::unique_ptr<xkb_context, DeleterForFreeFn<xkb_context_unref>> m_xkbContext;
+        AZStd::unique_ptr<xkb_keymap, DeleterForFreeFn<xkb_keymap_unref>> m_xkbKeymap;
+        AZStd::unique_ptr<xkb_state, DeleterForFreeFn<xkb_state_unref>> m_xkbState;
+        int m_coreDeviceId{-1};
+        bool m_initialized{false};
+    };
+
+    InputDeviceKeyboard::Implementation* InputDeviceKeyboard::Implementation::Create(InputDeviceKeyboard& inputDevice)
+    {
+        return aznew InputDeviceKeyboardXcb(inputDevice);
+    }
+} // namespace AzFramework

Code/Framework/AzFramework/Platform/Linux/AzFramework/Windowing/NativeWindow_Linux_xcb.cpp

@@ -62,8 +62,16 @@ namespace AzFramework
 
         uint32_t eventMask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
         
+        const uint32_t interestedEvents =
+            XCB_EVENT_MASK_STRUCTURE_NOTIFY
+            | XCB_EVENT_MASK_BUTTON_PRESS
+            | XCB_EVENT_MASK_BUTTON_RELEASE
+            | XCB_EVENT_MASK_KEY_PRESS
+            | XCB_EVENT_MASK_KEY_RELEASE
+            | XCB_EVENT_MASK_POINTER_MOTION
+            ;
         uint32_t valueList[] = { xcbRootScreen->black_pixel, 
-                                 XCB_EVENT_MASK_STRUCTURE_NOTIFY };
+                                 interestedEvents };
 
         xcb_void_cookie_t xcbCheckResult;
 

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

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

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

@@ -25,7 +25,7 @@ set(FILES
     AzFramework/Windowing/NativeWindow_Linux_xcb.h
     AzFramework/Windowing/NativeWindow_Linux_xcb.cpp
     ../Common/Unimplemented/AzFramework/Input/Devices/Gamepad/InputDeviceGamepad_Unimplemented.cpp
-    ../Common/Unimplemented/AzFramework/Input/Devices/Keyboard/InputDeviceKeyboard_Unimplemented.cpp
+    AzFramework/Input/Devices/Keyboard/InputDeviceKeyboard_xcb.cpp
     ../Common/Unimplemented/AzFramework/Input/Devices/Motion/InputDeviceMotion_Unimplemented.cpp
     ../Common/Unimplemented/AzFramework/Input/Devices/Mouse/InputDeviceMouse_Unimplemented.cpp
     ../Common/Unimplemented/AzFramework/Input/Devices/Touch/InputDeviceTouch_Unimplemented.cpp

Code/Framework/AzManipulatorTestFramework/Include/AzManipulatorTestFramework/ImmediateModeActionDispatcher.h

@@ -18,6 +18,7 @@ namespace AzManipulatorTestFramework
     class ImmediateModeActionDispatcher
         : public ActionDispatcher<ImmediateModeActionDispatcher>
         , public AzToolsFramework::ViewportInteraction::EditorModifierKeyRequestBus::Handler
+        , public AzToolsFramework::ViewportInteraction::EditorViewportInputTimeNowRequestBus::Handler
     {
         using KeyboardModifier = AzToolsFramework::ViewportInteraction::KeyboardModifier;
         using KeyboardModifiers = AzToolsFramework::ViewportInteraction::KeyboardModifiers;
@@ -50,6 +51,9 @@ namespace AzManipulatorTestFramework
         // EditorModifierKeyRequestBus overrides ...
         KeyboardModifiers QueryKeyboardModifiers() override;
 
+        // EditorViewportInputTimeNowRequestBus overrides ...
+        AZStd::chrono::milliseconds EditorViewportInputTimeNow() override;
+
     protected:
         // ActionDispatcher ...
         void SetSnapToGridImpl(bool enabled) override;
@@ -79,6 +83,9 @@ namespace AzManipulatorTestFramework
 
         mutable AZStd::unique_ptr<MouseInteractionEvent> m_event;
         ManipulatorViewportInteraction& m_viewportManipulatorInteraction;
+
+        //! Current time that ticks up after each call to EditorViewportInputTimeNow.
+        AZStd::chrono::milliseconds m_timeNow = AZStd::chrono::milliseconds(0);
     };
 
     template<typename ActualT, typename ExpectedT>
@@ -106,4 +113,13 @@ namespace AzManipulatorTestFramework
     {
         return GetMouseInteractionEvent()->m_mouseInteraction.m_keyboardModifiers;
     }
+
+    inline AZStd::chrono::milliseconds ImmediateModeActionDispatcher::EditorViewportInputTimeNow()
+    {
+        // step the time for each call to be greater than the minimum time required for a double click to register
+        // note: the time increment is very high to ensure any potential system changes to settings such as double
+        // click interval will not be impacted
+        m_timeNow += AZStd::chrono::milliseconds(10000);
+        return m_timeNow;
+    }
 } // namespace AzManipulatorTestFramework

Code/Framework/AzManipulatorTestFramework/Source/ImmediateModeActionDispatcher.cpp

@@ -33,10 +33,12 @@ namespace AzManipulatorTestFramework
         : m_viewportManipulatorInteraction(viewportManipulatorInteraction)
     {
         AzToolsFramework::ViewportInteraction::EditorModifierKeyRequestBus::Handler::BusConnect();
+        AzToolsFramework::ViewportInteraction::EditorViewportInputTimeNowRequestBus::Handler::BusConnect();
     }
 
     ImmediateModeActionDispatcher::~ImmediateModeActionDispatcher()
     {
+        AzToolsFramework::ViewportInteraction::EditorViewportInputTimeNowRequestBus::Handler::BusDisconnect();
         AzToolsFramework::ViewportInteraction::EditorModifierKeyRequestBus::Handler::BusDisconnect();
     }
 

Code/Framework/AzToolsFramework/AzToolsFramework/API/ViewportEditorModeTrackerInterface.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Interface/Interface.h>
+#include <AzCore/Outcome/Outcome.h>
+#include <AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h>
+
+namespace AzToolsFramework
+{
+    //! The AZ::Interface of the central editor mode tracker for all viewports.
+    class ViewportEditorModeTrackerInterface
+    {
+    public:
+        AZ_RTTI(ViewportEditorModeTrackerInterface, "{7D72A4F7-2147-4ED9-A315-E456A3BE3CF6}");
+
+        virtual ~ViewportEditorModeTrackerInterface() = default;
+
+        //! Activates the specified editor mode for the specified viewport.
+        virtual AZ::Outcome<void, AZStd::string> ActivateMode(
+            const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0;
+       
+        //! Deactivates the specified editor mode for the specified viewport.
+        virtual AZ::Outcome<void, AZStd::string> DeactivateMode(
+            const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) = 0;
+
+        //! Attempts to retrieve the editor mode state for the specified viewport, otherwise returns nullptr.
+        virtual const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0;
+
+        //! Returns the number of viewports currently being tracked.
+        virtual size_t GetTrackedViewportCount() const = 0;
+
+        //! Returns true if the specified viewport is being tracked, otherwise false.
+        virtual bool IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const = 0;
+    };
+} // namespace AzToolsFramework
+

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

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/EBus/Event.h>
+#include <AzFramework/Viewport/ViewportId.h>
+#include <AzToolsFramework/ViewportUi/ViewportUiRequestBus.h>
+
+namespace AzToolsFramework
+{
+    //! Enumeration of each viewport editor mode.
+    enum class ViewportEditorMode : AZ::u8
+    {
+        Default,
+        Component,
+        Focus,
+        Pick
+    };
+
+    //! Viewport identifier and other relevant viewport data.
+    struct ViewportEditorModeInfo
+    {
+        using IdType = AzFramework::ViewportId;
+        IdType m_id = ViewportUi::DefaultViewportId; //!< The unique identifier for a given viewport.
+    };
+
+    //! Interface for the editor modes of a given viewport.
+    class ViewportEditorModesInterface
+    {
+    public:
+        virtual ~ViewportEditorModesInterface() = default;
+
+        //! Returns true if the specified editor mode is active, otherwise false.
+        virtual bool IsModeActive(ViewportEditorMode mode) const = 0;
+    };
+
+    //! Provides a bus to notify when the different editor modes are entered/exit.
+    class ViewportEditorModeNotifications
+        : public AZ::EBusTraits
+    {
+    public:
+        //////////////////////////////////////////////////////////////////////////
+        // EBusTraits overrides
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        using BusIdType = ViewportEditorModeInfo::IdType;
+        //////////////////////////////////////////////////////////////////////////
+
+        //! Notifies subscribers of the a given viewport to the activation of the specified editor mode.
+        virtual void OnEditorModeActivated([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode)
+        {
+        }
+
+        //! Notifies subscribers of the a given viewport to the deactivation of the specified editor mode.
+        virtual void OnEditorModeDeactivated([[maybe_unused]] const ViewportEditorModesInterface& editorModeState, [[maybe_unused]] ViewportEditorMode mode)
+        {
+        }
+    };
+    using ViewportEditorModeNotificationsBus = AZ::EBus<ViewportEditorModeNotifications>;
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Application/ToolsApplication.cpp

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

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

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

Code/Framework/AzToolsFramework/AzToolsFramework/AssetBrowser/Views/AssetBrowserTableView.cpp

@@ -28,16 +28,16 @@ namespace AzToolsFramework
     namespace AssetBrowser
     {
         AssetBrowserTableView::AssetBrowserTableView(QWidget* parent)
-            : QTableView(parent)
+            : AzQtComponents::TableView(parent)
             , m_delegate(new EntryDelegate(this))
         {
             setSortingEnabled(true);
             setItemDelegate(m_delegate);
-            verticalHeader()->hide();
+            setRootIsDecorated(false);
 
             //Styling the header aligning text to the left and using a bold font.
-            horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
-            horizontalHeader()->setStyleSheet("QHeaderView { font-weight: bold; }");
+            header()->setDefaultAlignment(Qt::AlignLeft);
+            header()->setStyleSheet("QHeaderView { font-weight: bold; }");
 
             setContextMenuPolicy(Qt::CustomContextMenu);
 
@@ -45,7 +45,7 @@ namespace AzToolsFramework
             setSortingEnabled(false);
             setSelectionMode(QAbstractItemView::SingleSelection);
 
-            connect(this, &QTableView::customContextMenuRequested, this, &AssetBrowserTableView::OnContextMenu);
+            connect(this, &AzQtComponents::TableView::customContextMenuRequested, this, &AssetBrowserTableView::OnContextMenu);
 
             AssetBrowserViewRequestBus::Handler::BusConnect();
             AssetBrowserComponentNotificationBus::Handler::BusConnect();
@@ -62,11 +62,11 @@ namespace AzToolsFramework
             m_tableModel = qobject_cast<AssetBrowserTableModel*>(model);
             AZ_Assert(m_tableModel, "Expecting AssetBrowserTableModel");
             m_sourceFilterModel = qobject_cast<AssetBrowserFilterModel*>(m_tableModel->sourceModel());
-            QTableView::setModel(model);
+            AzQtComponents::TableView::setModel(model);
             connect(m_tableModel, &AssetBrowserTableModel::layoutChanged, this, &AssetBrowserTableView::layoutChangedSlot);
 
-            horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeMode::Stretch);
-            horizontalHeader()->setSectionResizeMode(1, QHeaderView::ResizeMode::Stretch);
+            header()->setSectionResizeMode(0, QHeaderView::ResizeMode::Stretch);
+            header()->setSectionResizeMode(1, QHeaderView::ResizeMode::Stretch);
         }
 
         void AssetBrowserTableView::SetName(const QString& name)
@@ -98,7 +98,7 @@ namespace AzToolsFramework
 
         void AssetBrowserTableView::selectionChanged(const QItemSelection& selected, const QItemSelection& deselected)
         {
-            QTableView::selectionChanged(selected, deselected);
+            AzQtComponents::TableView::selectionChanged(selected, deselected);
             Q_EMIT selectionChangedSignal(selected, deselected);
         }
 
@@ -115,7 +115,7 @@ namespace AzToolsFramework
                     selectionModel()->clear();
                 }
             }
-            QTableView::rowsAboutToBeRemoved(parent, start, end);
+            AzQtComponents::TableView::rowsAboutToBeRemoved(parent, start, end);
         }
 
         void AssetBrowserTableView::layoutChangedSlot(

Code/Framework/AzToolsFramework/AzToolsFramework/AssetBrowser/Views/AssetBrowserTableView.h

@@ -13,9 +13,10 @@
 #include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
 #include <AzToolsFramework/AssetBrowser/AssetBrowserTableModel.h>
 
+#include <AzQtComponents/Components/Widgets/TableView.h>
+
 #include <QModelIndex>
 #include <QPointer>
-#include <QTableView>
 #endif
 
 namespace AzToolsFramework
@@ -28,7 +29,7 @@ namespace AzToolsFramework
         class EntryDelegate;
 
         class AssetBrowserTableView //! Table view that displays the asset browser entries in a list.
-            : public QTableView
+            : public AzQtComponents::TableView
             , public AssetBrowserViewRequestBus::Handler
             , public AssetBrowserComponentNotificationBus::Handler
         {

Code/Framework/AzToolsFramework/AzToolsFramework/AzToolsFrameworkModule.cpp

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

Code/Framework/AzToolsFramework/AzToolsFramework/FocusMode/FocusModeInterface.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Interface/Interface.h>
+#include <AzCore/Serialization/SerializeContext.h>
+
+namespace AzToolsFramework
+{
+    //! FocusModeInterface
+    //! Interface to handle the Editor Focus Mode.
+    class FocusModeInterface
+    {
+    public:
+        AZ_RTTI(FocusModeInterface, "{437243B0-F86B-422F-B7B8-4A21CC000702}");
+
+        //! Sets the root entity the Editor should focus on.
+        //! The Editor will only allow the user to select entities that are descendants of the EntityId provided.
+        //! @param entityId The entityId that will become the new focus root.
+        virtual void SetFocusRoot(AZ::EntityId entityId) = 0;
+
+        //! Clears the Editor focus, allowing the user to select the whole level again.
+        virtual void ClearFocusRoot() = 0;
+
+        //! Returns the entity id of the root of the current Editor focus.
+        //! @return The entity id of the root of the Editor focus, or an invalid entity id if no focus is set.
+        virtual AZ::EntityId GetFocusRoot() = 0;
+
+        //! Returns whether the entity id provided is part of the focused sub-tree.
+        virtual bool IsInFocusSubTree(AZ::EntityId entityId) = 0;
+    };
+
+} // namespace AzToolsFramework

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

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzCore/Component/TransformBus.h>
+
+#include <AzToolsFramework/API/ViewportEditorModeTrackerInterface.h>
+#include <AzToolsFramework/FocusMode/FocusModeSystemComponent.h>
+
+namespace AzToolsFramework
+{
+    bool IsInFocusSubTree(AZ::EntityId entityId, AZ::EntityId focusRootId)
+    {
+        if (entityId == AZ::EntityId())
+        {
+            return false;
+        }
+
+        if (entityId == focusRootId)
+        {
+            return true;
+        }
+
+        AZ::EntityId parentId;
+        AZ::TransformBus::EventResult(parentId, entityId, &AZ::TransformInterface::GetParentId);
+
+        return IsInFocusSubTree(parentId, focusRootId);
+    }
+
+    void FocusModeSystemComponent::Init()
+    {
+    }
+
+    void FocusModeSystemComponent::Activate()
+    {
+        AZ::Interface<FocusModeInterface>::Register(this);
+    }
+
+    void FocusModeSystemComponent::Deactivate()
+    {
+        AZ::Interface<FocusModeInterface>::Unregister(this);
+    }
+
+    void FocusModeSystemComponent::Reflect([[maybe_unused]] AZ::ReflectContext* context)
+    {
+    }
+
+    void FocusModeSystemComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
+    {
+        provided.push_back(AZ_CRC_CE("EditorFocusMode"));
+    }
+
+    void FocusModeSystemComponent::GetRequiredServices([[maybe_unused]] AZ::ComponentDescriptor::DependencyArrayType& required)
+    {
+    }
+
+    void FocusModeSystemComponent::GetIncompatibleServices([[maybe_unused]] AZ::ComponentDescriptor::DependencyArrayType& incompatible)
+    {
+    }
+
+    void FocusModeSystemComponent::SetFocusRoot(AZ::EntityId entityId)
+    {
+        m_focusRoot = entityId;
+
+        // TODO - If m_focusRoot != AZ::EntityId(), activate focus mode via ViewportEditorModeTrackerInterface; else, deactivate focus mode
+    }
+
+    void FocusModeSystemComponent::ClearFocusRoot()
+    {
+        SetFocusRoot(AZ::EntityId());
+    }
+
+    AZ::EntityId FocusModeSystemComponent::GetFocusRoot()
+    {
+        return m_focusRoot;
+    }
+
+    bool FocusModeSystemComponent::IsInFocusSubTree(AZ::EntityId entityId)
+    {
+        if (m_focusRoot == AZ::EntityId())
+        {
+            return true;
+        }
+
+        return AzToolsFramework::IsInFocusSubTree(entityId, m_focusRoot);
+    }
+
+} // namespace AzToolsFramework

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Component/Component.h>
+#include <AzCore/Memory/SystemAllocator.h>
+
+#include <AzToolsFramework/FocusMode/FocusModeInterface.h>
+
+namespace AzToolsFramework
+{
+    bool IsInFocusSubTree(AZ::EntityId entityId, AZ::EntityId focusRootId);
+
+    //! System Component to handle the Editor Focus Mode system
+    class FocusModeSystemComponent final
+        : public AZ::Component
+        , private FocusModeInterface
+    {
+    public:
+        AZ_COMPONENT(FocusModeSystemComponent, "{6CE522FE-2057-4794-BD05-61E04BD8EA30}");
+
+        FocusModeSystemComponent() = default;
+        virtual ~FocusModeSystemComponent() = default;
+
+        // AZ::Component overrides ...
+        void Init() override;
+        void Activate() override;
+        void Deactivate() override;
+
+        static void Reflect(AZ::ReflectContext* context);
+        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided);
+        static void GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required);
+        static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible);
+
+        // FocusModeInterface overrides ...
+        void SetFocusRoot(AZ::EntityId entityId) override;
+        void ClearFocusRoot() override;
+        AZ::EntityId GetFocusRoot() override;
+        bool IsInFocusSubTree(AZ::EntityId entityId) override;
+
+    private:
+        AZ::EntityId m_focusRoot;
+    };
+
+} // namespace AzToolsFramework

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

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzToolsFramework/Prefab/PrefabFocusHandler.h>
+
+#include <AzToolsFramework/Entity/PrefabEditorEntityOwnershipInterface.h>
+#include <AzToolsFramework/Prefab/Instance/Instance.h>
+#include <AzToolsFramework/Prefab/Instance/InstanceEntityMapperInterface.h>
+
+namespace AzToolsFramework::Prefab
+{
+    PrefabFocusHandler::PrefabFocusHandler()
+    {
+        m_instanceEntityMapperInterface = AZ::Interface<InstanceEntityMapperInterface>::Get();
+        AZ_Assert(
+            m_instanceEntityMapperInterface,
+            "Prefab - PrefabFocusHandler - "
+            "Instance Entity Mapper Interface could not be found. "
+            "Check that it is being correctly initialized.");
+
+        AZ::Interface<PrefabFocusInterface>::Register(this);
+    }
+
+    PrefabFocusHandler::~PrefabFocusHandler()
+    {
+        AZ::Interface<PrefabFocusInterface>::Unregister(this);
+    }
+
+    PrefabFocusOperationResult PrefabFocusHandler::FocusOnOwningPrefab(AZ::EntityId entityId)
+    {
+        InstanceOptionalReference focusedInstance;
+
+        if (entityId == AZ::EntityId())
+        {
+            PrefabEditorEntityOwnershipInterface* prefabEditorEntityOwnershipInterface =
+                AZ::Interface<PrefabEditorEntityOwnershipInterface>::Get();
+
+            if(!prefabEditorEntityOwnershipInterface)
+            {
+                return AZ::Failure(AZStd::string("Could not focus on root prefab instance - internal error "
+                                                 "(PrefabEditorEntityOwnershipInterface unavailable)."));
+            }
+
+            focusedInstance = prefabEditorEntityOwnershipInterface->GetRootPrefabInstance();
+        }
+        else
+        {
+            focusedInstance = m_instanceEntityMapperInterface->FindOwningInstance(entityId);
+        }
+
+        if (!focusedInstance.has_value())
+        {
+            return AZ::Failure(AZStd::string(
+                "Prefab Focus Handler: Couldn't find owning instance of entityId provided."));
+        }
+
+        m_focusedInstance = focusedInstance;
+        m_focusedTemplateId = focusedInstance->get().GetTemplateId();
+
+        FocusModeInterface* focusModeInterface = AZ::Interface<FocusModeInterface>::Get();
+        if (focusModeInterface)
+        {
+            focusModeInterface->SetFocusRoot(focusedInstance->get().GetContainerEntityId());
+        }
+
+        return AZ::Success();
+    }
+    
+    TemplateId PrefabFocusHandler::GetFocusedPrefabTemplateId()
+    {
+        return m_focusedTemplateId;
+    }
+
+    InstanceOptionalReference PrefabFocusHandler::GetFocusedPrefabInstance()
+    {
+        return m_focusedInstance;
+    }
+
+    bool PrefabFocusHandler::IsOwningPrefabBeingFocused(AZ::EntityId entityId)
+    {
+        if (!m_focusedInstance.has_value())
+        {
+            // PrefabFocusHandler has not been initialized yet.
+            return false;
+        }
+
+        if (entityId == AZ::EntityId())
+        {
+            return false;
+        }
+
+        InstanceOptionalReference instance = m_instanceEntityMapperInterface->FindOwningInstance(entityId);
+
+        return instance.has_value() && (&instance->get() == &m_focusedInstance->get());
+    }
+
+} // namespace AzToolsFramework::Prefab

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Memory/SystemAllocator.h>
+
+#include <AzToolsFramework/FocusMode/FocusModeInterface.h>
+#include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
+#include <AzToolsFramework/Prefab/Template/Template.h>
+
+namespace AzToolsFramework::Prefab
+{
+    class InstanceEntityMapperInterface;
+
+    //! Handles Prefab Focus mode, determining which prefab file entity changes will target.
+    class PrefabFocusHandler final
+        : private PrefabFocusInterface
+    {
+    public:
+        AZ_CLASS_ALLOCATOR(PrefabFocusHandler, AZ::SystemAllocator, 0);
+
+        PrefabFocusHandler();
+        ~PrefabFocusHandler();
+
+        // PrefabFocusInterface override ...
+        PrefabFocusOperationResult FocusOnOwningPrefab(AZ::EntityId entityId) override;
+        TemplateId GetFocusedPrefabTemplateId() override;
+        InstanceOptionalReference GetFocusedPrefabInstance() override;
+        bool IsOwningPrefabBeingFocused(AZ::EntityId entityId) override;
+
+    private:
+        InstanceOptionalReference m_focusedInstance;
+        TemplateId m_focusedTemplateId;
+
+        InstanceEntityMapperInterface* m_instanceEntityMapperInterface;
+    };
+
+} // namespace AzToolsFramework::Prefab

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

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Interface/Interface.h>
+#include <AzCore/Serialization/SerializeContext.h>
+
+#include <AzToolsFramework/Prefab/Instance/Instance.h>
+#include <AzToolsFramework/Prefab/Template/Template.h>
+
+namespace AzToolsFramework::Prefab
+{
+    using PrefabFocusOperationResult = AZ::Outcome<void, AZStd::string>;
+
+    //! Interface to handle operations related to the Prefab Focus system.
+    class PrefabFocusInterface
+    {
+    public:
+        AZ_RTTI(PrefabFocusInterface, "{F3CFA37B-5FD8-436A-9C30-60EB54E350E1}");
+
+        //! Set the focused prefab instance to the owning instance of the entityId provided.
+        //! @param entityId The entityId of the entity whose owning instance we want the prefab system to focus on.
+        virtual PrefabFocusOperationResult FocusOnOwningPrefab(AZ::EntityId entityId) = 0;
+
+        //! Returns the template id of the instance the prefab system is focusing on.
+        virtual TemplateId GetFocusedPrefabTemplateId() = 0;
+
+        //! Returns a reference to the instance the prefab system is focusing on.
+        virtual InstanceOptionalReference GetFocusedPrefabInstance() = 0;
+
+        //! Returns whether the entity belongs to the instance that is being focused on, or one of its descendants.
+        //! @param entityId The entityId of the queried entity.
+        //! @return true if the entity belongs to the focused instance or one of its descendants, false otherwise.
+        virtual bool IsOwningPrefabBeingFocused(AZ::EntityId entityId) = 0;
+    };
+
+} // namespace AzToolsFramework::Prefab

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

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

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

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

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

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

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

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

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

@@ -1,43 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#include <AzCore/Interface/Interface.h>
-#include <AzCore/Serialization/SerializeContext.h>
-
-namespace AzToolsFramework
-{
-    namespace Prefab
-    {
-        /*!
-         * PrefabEditInterface
-         * Interface to expose the API to Edit Prefabs in the Editor.
-         */
-        class PrefabEditInterface
-        {
-        public:
-            AZ_RTTI(PrefabEditInterface, "{DABB1D43-3760-420E-9F1E-5104F0AFF167}");
-
-            /**
-             * Sets the prefab for the instance owning the entity provided as the prefab being edited.
-             * @param entityId The entity whose owning prefab should be edited.
-             */
-            virtual void EditOwningPrefab(AZ::EntityId entityId) = 0;
-            
-            /**
-             * Queries the Edit Manager to know if the provided entity is part of the prefab currently being edited.
-             * @param entityId The entity whose prefab editing state we want to query.
-             * @return True if the prefab owning this entity is being edited, false otherwise.
-             */
-            virtual bool IsOwningPrefabBeingEdited(AZ::EntityId entityId) = 0;
-        };
-
-    } // namespace Prefab
-} // namespace AzToolsFramework
-

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

@@ -1,46 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include <AzToolsFramework/UI/Prefab/PrefabEditManager.h>
-
-#include <AzCore/Serialization/SerializeContext.h>
-
-namespace AzToolsFramework
-{
-    namespace Prefab
-    {
-        PrefabEditManager::PrefabEditManager()
-        {
-            m_prefabPublicInterface = AZ::Interface<PrefabPublicInterface>::Get();
-
-            if (m_prefabPublicInterface == nullptr)
-            {
-                AZ_Assert(false, "Prefab - could not get PrefabPublicInterface on PrefabEditManager construction.");
-                return;
-            }
-
-            AZ::Interface<PrefabEditInterface>::Register(this);
-        }
-
-        PrefabEditManager::~PrefabEditManager()
-        {
-            AZ::Interface<PrefabEditInterface>::Unregister(this);
-        }
-
-        void PrefabEditManager::EditOwningPrefab(AZ::EntityId entityId)
-        {
-            m_instanceBeingEdited = m_prefabPublicInterface->GetInstanceContainerEntityId(entityId);
-        }
-
-        bool PrefabEditManager::IsOwningPrefabBeingEdited(AZ::EntityId entityId)
-        {
-            AZ::EntityId containerEntity = m_prefabPublicInterface->GetInstanceContainerEntityId(entityId);
-            return m_instanceBeingEdited == containerEntity;
-        }
-    }
-}

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

@@ -1,40 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#include <AzCore/Component/EntityId.h>
-#include <AzCore/Memory/SystemAllocator.h>
-
-#include <AzToolsFramework/Prefab/PrefabPublicInterface.h>
-#include <AzToolsFramework/UI/Prefab/PrefabEditInterface.h>
-
-namespace AzToolsFramework
-{
-    namespace Prefab
-    {
-        class PrefabEditManager final
-            : private PrefabEditInterface
-        {
-        public:
-            AZ_CLASS_ALLOCATOR(PrefabEditManager, AZ::SystemAllocator, 0);
-
-            PrefabEditManager();
-            ~PrefabEditManager();
-
-        private:
-            // PrefabEditInterface...
-            void EditOwningPrefab(AZ::EntityId entityId) override;
-            bool IsOwningPrefabBeingEdited(AZ::EntityId entityId) override;
-
-            AZ::EntityId m_instanceBeingEdited;
-
-            PrefabPublicInterface* m_prefabPublicInterface;
-        };
-    }
-}

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

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

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

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

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

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

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

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

Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/ViewportMessages.h

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

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

@@ -253,10 +253,10 @@ namespace AzToolsFramework
                  mouseInteraction.m_mouseInteraction.m_keyboardModifiers.Ctrl());
         }
 
-        static bool ManipulatorDitto(const ViewportInteraction::MouseInteractionEvent& mouseInteraction)
+        static bool ManipulatorDitto(
+            const AzFramework::ClickDetector::ClickOutcome clickOutcome, const ViewportInteraction::MouseInteractionEvent& mouseInteraction)
         {
-            return mouseInteraction.m_mouseEvent == ViewportInteraction::MouseEvent::Down &&
-                mouseInteraction.m_mouseInteraction.m_mouseButtons.Left() &&
+            return clickOutcome == AzFramework::ClickDetector::ClickOutcome::Click &&
                 mouseInteraction.m_mouseInteraction.m_keyboardModifiers.Ctrl() &&
                 mouseInteraction.m_mouseInteraction.m_keyboardModifiers.Alt();
         }
@@ -1054,6 +1054,17 @@ namespace AzToolsFramework
         RegisterActions();
         SetupBoxSelect();
         RefreshSelectedEntityIdsAndRegenerateManipulators();
+
+        // ensure the click detector uses the EditorViewportInputTimeNowRequests interface to retrieve elapsed time
+        // note: this is to facilitate overriding this functionality for purposes such as testing
+        m_clickDetector.OverrideTimeNowFn(
+            []
+            {
+                AZStd::chrono::milliseconds timeNow;
+                AzToolsFramework::ViewportInteraction::EditorViewportInputTimeNowRequestBus::BroadcastResult(
+                    timeNow, &AzToolsFramework::ViewportInteraction::EditorViewportInputTimeNowRequestBus::Events::EditorViewportInputTimeNow);
+                return timeNow;
+            });
     }
 
     EditorTransformComponentSelection::~EditorTransformComponentSelection()
@@ -1883,7 +1894,7 @@ namespace AzToolsFramework
             }
 
             // set manipulator pivot override translation or orientation (update manipulators)
-            if (Input::ManipulatorDitto(mouseInteraction))
+            if (Input::ManipulatorDitto(clickOutcome, mouseInteraction))
             {
                 PerformManipulatorDitto(entityIdUnderCursor);
                 return false;
@@ -3631,7 +3642,7 @@ namespace AzToolsFramework
         }
     }
 
-    void EditorTransformComponentSelection::OnViewportViewEntityChanged(const AZ::EntityId& newViewId)
+    void EditorTransformComponentSelection::OnViewportViewEntityChanged(const AZ::EntityId& viewEntityId)
     {
         AZ_PROFILE_FUNCTION(AzToolsFramework);
 
@@ -3639,12 +3650,12 @@ namespace AzToolsFramework
         // match the editor camera translation/orientation), record the entity id if we have
         // a manipulator tracking it (entity id exists in m_entityIdManipulator lookups)
         // and remove it when recreating manipulators (see InitializeManipulators)
-        if (newViewId.IsValid())
+        if (viewEntityId.IsValid())
         {
-            const auto entityIdLookupIt = m_entityIdManipulators.m_lookups.find(newViewId);
+            const auto entityIdLookupIt = m_entityIdManipulators.m_lookups.find(viewEntityId);
             if (entityIdLookupIt != m_entityIdManipulators.m_lookups.end())
             {
-                m_editorCameraComponentEntityId = newViewId;
+                m_editorCameraComponentEntityId = viewEntityId;
                 RegenerateManipulators();
             }
         }

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

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

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.cpp

@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h>
+#include <AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h>
+
+namespace AzToolsFramework
+{
+    AZ::Outcome<void, AZStd::string> ViewportEditorModes::ActivateMode(ViewportEditorMode mode)
+    {
+        if (const AZ::u32 modeIndex = static_cast<AZ::u32>(mode);
+            modeIndex < NumEditorModes)
+        {
+            m_editorModes[modeIndex] = true;
+            return AZ::Success();
+        }
+        else
+        {
+            return AZ::Failure(
+                AZStd::string::format("Cannot activate mode %u, mode is not recognized", modeIndex));
+        }
+    }
+
+    AZ::Outcome<void, AZStd::string> ViewportEditorModes::DeactivateMode(ViewportEditorMode mode)
+    {
+        if (const AZ::u32 modeIndex = static_cast<AZ::u32>(mode); modeIndex < NumEditorModes)
+        {
+            m_editorModes[modeIndex] = false;
+            return AZ::Success();
+        }
+        else
+        {
+            return AZ::Failure(
+                AZStd::string::format("Cannot deactivate mode %u, mode is not recognized", modeIndex));
+        }
+    }
+
+    bool ViewportEditorModes::IsModeActive(ViewportEditorMode mode) const
+    {
+        return m_editorModes[static_cast<AZ::u32>(mode)];
+    }
+
+    void ViewportEditorModeTracker::RegisterInterface()
+    {
+        if (AZ::Interface<ViewportEditorModeTrackerInterface>::Get() == nullptr)
+        {
+            AZ::Interface<ViewportEditorModeTrackerInterface>::Register(this);
+        }
+    }
+
+    void ViewportEditorModeTracker::UnregisterInterface()
+    {
+        if (AZ::Interface<ViewportEditorModeTrackerInterface>::Get() != nullptr)
+        {
+            AZ::Interface<ViewportEditorModeTrackerInterface>::Unregister(this);
+        }
+    }
+
+    AZ::Outcome<void, AZStd::string> ViewportEditorModeTracker::ActivateMode(
+        const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode)
+    {
+        auto& editorModes = m_viewportEditorModesMap[viewportEditorModeInfo.m_id];
+        if (editorModes.IsModeActive(mode))
+        {
+            return AZ::Failure(AZStd::string::format(
+                "Duplicate call to ActivateMode for mode '%u' on id '%i'", static_cast<AZ::u32>(mode), viewportEditorModeInfo.m_id));
+        }
+        
+        if (const auto result = editorModes.ActivateMode(mode);
+            !result.IsSuccess())
+        {
+            return result;
+        }
+
+        ViewportEditorModeNotificationsBus::Event(
+            viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeActivated, editorModes, mode);
+
+        return AZ::Success();
+    }
+
+    AZ::Outcome<void, AZStd::string> ViewportEditorModeTracker::DeactivateMode(
+        const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode)
+    {
+        ViewportEditorModes* editorModes = nullptr;
+        bool modeWasActive = true;
+        if (m_viewportEditorModesMap.count(viewportEditorModeInfo.m_id))
+        {
+            editorModes = &m_viewportEditorModesMap.at(viewportEditorModeInfo.m_id);
+            if (!editorModes->IsModeActive(mode))
+            {
+                return AZ::Failure(AZStd::string::format(
+                    "Duplicate call to DeactivateMode for mode '%u' on id '%i'", static_cast<AZ::u32>(mode), viewportEditorModeInfo.m_id));
+            }
+        }
+        else
+        {
+            modeWasActive = false;
+            editorModes = &m_viewportEditorModesMap[viewportEditorModeInfo.m_id];
+        }
+
+        if(const auto result = editorModes->DeactivateMode(mode);
+            !result.IsSuccess())
+        {
+            return result;
+        }
+
+        ViewportEditorModeNotificationsBus::Event(
+            viewportEditorModeInfo.m_id, &ViewportEditorModeNotificationsBus::Events::OnEditorModeDeactivated, *editorModes, mode);
+
+        if (modeWasActive)
+        {
+            return AZ::Success();
+        }
+        else
+        {
+            return AZ::Failure(AZStd::string::format(
+                "Call to DeactivateMode for mode '%u' on id '%i' without precursor call to ActivateMode", static_cast<AZ::u32>(mode),
+                viewportEditorModeInfo.m_id));
+        }
+    }
+
+    const ViewportEditorModesInterface* ViewportEditorModeTracker::GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const
+    {
+        if (auto editorModes = m_viewportEditorModesMap.find(viewportEditorModeInfo.m_id);
+            editorModes != m_viewportEditorModesMap.end())
+        {
+            return &editorModes->second;
+        }
+        else
+        {
+            return nullptr;
+        }
+    }
+
+    size_t ViewportEditorModeTracker::GetTrackedViewportCount() const
+    {
+        return m_viewportEditorModesMap.size();
+    }
+
+    bool ViewportEditorModeTracker::IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const
+    {
+        return m_viewportEditorModesMap.count(viewportEditorModeInfo.m_id) > 0;
+    }
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/ViewportEditorModeTracker.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/RTTI/RTTI.h>
+#include <AzCore/std/containers/array.h>
+#include <AzCore/std/containers/unordered_map.h>
+#include <AzToolsFramework/API/ViewportEditorModeTrackerNotificationBus.h>
+#include <AzToolsFramework/API/ViewportEditorModeTrackerInterface.h>
+
+namespace AzToolsFramework
+{
+    //! The encapsulation of the editor modes for a given viewport.
+    class ViewportEditorModes
+        : public ViewportEditorModesInterface
+    {
+    public:
+        //! The number of currently supported viewport editor modes.
+        static constexpr AZ::u8 NumEditorModes = 4;
+
+        //! Sets the specified mode as active.
+        AZ::Outcome<void, AZStd::string> ActivateMode(ViewportEditorMode mode);
+
+        // Sets the specified mode as inactive.
+        AZ::Outcome<void, AZStd::string> DeactivateMode(ViewportEditorMode mode);
+
+        // ViewportEditorModesInterface ...
+        bool IsModeActive(ViewportEditorMode mode) const override;
+    private:
+        AZStd::array<bool, NumEditorModes> m_editorModes{}; //!< State flags to track active/inactive status of viewport editor modes.
+    };
+
+    //! The implementation of the central editor mode state tracker for all viewports.
+    class ViewportEditorModeTracker
+        : public ViewportEditorModeTrackerInterface
+    {
+    public:
+        //! Registers this object with the AZ::Interface.
+        void RegisterInterface();
+
+        //! Unregisters this object with the AZ::Interface.
+        void UnregisterInterface();
+
+        // ViewportEditorModeTrackerInterface overrides ...
+        AZ::Outcome<void, AZStd::string> ActivateMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override;
+        AZ::Outcome<void, AZStd::string> DeactivateMode(const ViewportEditorModeInfo& viewportEditorModeInfo, ViewportEditorMode mode) override;
+        const ViewportEditorModesInterface* GetViewportEditorModes(const ViewportEditorModeInfo& viewportEditorModeInfo) const override;
+        size_t GetTrackedViewportCount() const override;
+        bool IsViewportModeTracked(const ViewportEditorModeInfo& viewportEditorModeInfo) const override;
+
+    private:
+        using ViewportEditorModesMap = AZStd::unordered_map<typename ViewportEditorModeInfo::IdType, ViewportEditorModes>;
+        ViewportEditorModesMap m_viewportEditorModesMap; //!< Editor mode state per viewport.
+    };
+} // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake

@@ -34,6 +34,7 @@ set(FILES
     API/EditorAnimationSystemRequestBus.h
     API/EditorEntityAPI.h
     API/EditorLevelNotificationBus.h
+    API/ViewportEditorModeTrackerNotificationBus.h
     API/EditorVegetationRequestsBus.h
     API/EditorPythonConsoleBus.h
     API/EditorPythonRunnerRequestsBus.h
@@ -44,6 +45,7 @@ set(FILES
     API/EntityCompositionNotificationBus.h
     API/EditorViewportIconDisplayInterface.h
     API/ViewPaneOptions.h
+    API/ViewportEditorModeTrackerInterface.h
     Application/Ticker.h
     Application/Ticker.cpp
     Application/EditorEntityManager.cpp
@@ -147,6 +149,9 @@ set(FILES
     Entity/SliceEditorEntityOwnershipServiceBus.h
     Fingerprinting/TypeFingerprinter.h
     Fingerprinting/TypeFingerprinter.cpp
+    FocusMode/FocusModeInterface.h
+    FocusMode/FocusModeSystemComponent.h
+    FocusMode/FocusModeSystemComponent.cpp
     Logger/TraceLogger.cpp
     Logger/TraceLogger.h
     Manipulators/AngularManipulator.cpp
@@ -538,6 +543,8 @@ set(FILES
     ViewportSelection/EditorTransformComponentSelectionRequestBus.cpp
     ViewportSelection/EditorVisibleEntityDataCache.h
     ViewportSelection/EditorVisibleEntityDataCache.cpp
+    ViewportSelection/ViewportEditorModeTracker.cpp
+    ViewportSelection/ViewportEditorModeTracker.h
     ToolsFileUtils/ToolsFileUtils.h
     AssetBrowser/AssetBrowserBus.h
     AssetBrowser/AssetBrowserSourceDropBus.h
@@ -625,6 +632,9 @@ set(FILES
     Prefab/PrefabDomTypes.h
     Prefab/PrefabDomUtils.h
     Prefab/PrefabDomUtils.cpp
+    Prefab/PrefabFocusHandler.h
+    Prefab/PrefabFocusHandler.cpp
+    Prefab/PrefabFocusInterface.h
     Prefab/PrefabIdTypes.h
     Prefab/PrefabLoader.h
     Prefab/PrefabLoader.cpp
@@ -717,9 +727,6 @@ set(FILES
     UI/Layer/LayerUiHandler.cpp
     UI/Prefab/LevelRootUiHandler.h
     UI/Prefab/LevelRootUiHandler.cpp
-    UI/Prefab/PrefabEditInterface.h
-    UI/Prefab/PrefabEditManager.h
-    UI/Prefab/PrefabEditManager.cpp
     UI/Prefab/PrefabIntegrationBus.h
     UI/Prefab/PrefabIntegrationManager.h
     UI/Prefab/PrefabIntegrationManager.cpp

Code/Framework/AzToolsFramework/Tests/EditorTransformComponentSelectionTests.cpp

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

Code/Framework/AzToolsFramework/Tests/Viewport/ViewportEditorModeTests.cpp

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

Code/Framework/AzToolsFramework/Tests/aztoolsframeworktests_files.cmake

@@ -110,6 +110,7 @@ set(FILES
     UI/EntityPropertyEditorTests.cpp
     UndoStack.cpp
     Viewport/ClusterTests.cpp
+    Viewport/ViewportEditorModeTests.cpp
     Viewport/ViewportScreenTests.cpp
     Viewport/ViewportUiClusterTests.cpp
     Viewport/ViewportUiDisplayTests.cpp