Merge branch 'main' into SpawnablePriorityQueue

Code/Framework/AzCore/AzCore/Component/TransformBus.h

@@ -172,78 +172,10 @@ namespace AZ
 
         //! Rotation modifiers
         //! @{
-        //! @deprecated Use SetLocalRotation()
-        //! Sets the entity's rotation in the world.
-        //! The origin of the axes is the entity's position in world space.
-        //! @param eulerAnglesRadians A three-dimensional vector, containing Euler angles in radians, to rotate the entity by.
-        virtual void SetRotation([[maybe_unused]] const AZ::Vector3& eulerAnglesRadians) {}
-
-        //! @deprecated Use SetLocalRotation()
-        //! Sets the entity's rotation around the world's X axis.
-        //! The origin of the axis is the entity's position in world space.
-        //! @param eulerAngleRadians The X coordinate Euler angle in radians to use for the entity's rotation.
-        virtual void SetRotationX([[maybe_unused]] float eulerAngleRadian) {}
-
-        //! @deprecated Use SetLocalRotation()
-        //! Sets the entity's rotation around the world's Y axis.
-        //! The origin of the axis is the entity's position in world space.
-        //! @param eulerAngleRadians The Y coordinate Euler angle in radians to use for the entity's rotation.
-        virtual void SetRotationY([[maybe_unused]] float eulerAngleRadian) {}
-
-        //! @deprecated Use SetLocalRotation()
-        //! Sets the entity's rotation around the world's Z axis.
-        //! The origin of the axis is the entity's position in world space.
-        //! @param eulerAngleRadians The Z coordinate Euler angle in radians to use for the entity's rotation.
-        virtual void SetRotationZ([[maybe_unused]] float eulerAngleRadian) {}
-
-        //! @deprecated Use SetLocalRotationQuaternion()
         //! Sets the entity's rotation in the world in quaternion notation.
         //! The origin of the axes is the entity's position in world space.
         //! @param quaternion A quaternion that represents the rotation to use for the entity.
-        virtual void SetRotationQuaternion([[maybe_unused]] const AZ::Quaternion& quaternion) {}
-
-        //! @deprecated Use RotateAroundLocalX()
-        //! Rotates the entity around the world's X axis.
-        //! The origin of the axis is the entity's position in world space.
-        //! @param eulerAngleRadians The Euler angle in radians by which to rotate the entity around the X axis.
-        virtual void RotateByX([[maybe_unused]] float eulerAngleRadian) {}
-
-        //! @deprecated Use RotateAroundLocalY()
-        //! Rotates the entity around the world's Y axis.
-        //! The origin of the axis is the entity's position in world space.
-        //! @param eulerAngleRadians The Euler angle in radians by which to rotate the entity around the Y axis.
-        virtual void RotateByY([[maybe_unused]] float eulerAngleRadian) {}
-
-        //! @deprecated Use RotateAroundLocalZ()
-        //! Rotates the entity around the world's Z axis.
-        //! The origin of the axis is the entity's position in world space.
-        //! @param eulerAngleRadians The Euler angle in radians by which to rotate the entity around the Z axis.
-        virtual void RotateByZ([[maybe_unused]] float eulerAngleRadian) {}
-
-        //! @deprecated Use GetLocalRotation()
-        //! Gets the entity's rotation in the world in Euler angles rotation in radians.
-        //! @return A three-dimensional vector, containing Euler angles in radians, that represents the entity's rotation.
-        virtual AZ::Vector3 GetRotationEulerRadians() { return AZ::Vector3(FLT_MAX); }
-
-        //! @deprecated Use GetLocalRotationQuaternion()
-        //! Gets the entity's rotation in the world in quaternion format.
-        //! @return A quaternion that represents the entity's rotation in world space.
-        virtual AZ::Quaternion GetRotationQuaternion() { return AZ::Quaternion::CreateZero(); }
-
-        //! @deprecated Use GetLocalRotation()
-        //! Gets the entity's rotation around the world's X axis.
-        //! @return The Euler angle in radians by which the the entity is rotated around the X axis in world space.
-        virtual float GetRotationX() { return FLT_MAX; }
-
-        //! @deprecated Use GetLocalRotation()
-        //! Gets the entity's rotation around the world's Y axis.
-        //! @return The Euler angle in radians by which the the entity is rotated around the Y axis in world space.
-        virtual float GetRotationY() { return FLT_MAX; }
-
-        //! @deprecated Use GetLocalRotation()
-        //! Gets the entity's rotation around the world's Z axis.
-        //! @return The Euler angle in radians by which the the entity is rotated around the Z axis in world space.
-        virtual float GetRotationZ() { return FLT_MAX; }
+        virtual void SetWorldRotationQuaternion([[maybe_unused]] const AZ::Quaternion& quaternion) {}
 
         //! Get angles in radian for each principle axis around which the world transform is
         //! rotated in the order of z-axis and y-axis and then x-axis.

Code/Framework/AzCore/AzCore/PlatformId/PlatformDefaults.cpp

@@ -19,7 +19,7 @@ namespace AZ
 {
     inline namespace PlatformDefaults
     {
-        static const char* PlatformNames[PlatformId::NumPlatformIds] = { PlatformPC, PlatformES3, PlatformIOS, PlatformOSX, PlatformProvo, PlatformSalem, PlatformJasper, PlatformServer, PlatformAll, PlatformAllClient };
+        static const char* PlatformNames[PlatformId::NumPlatformIds] = { PlatformPC, PlatformAndroid, PlatformIOS, PlatformMac, PlatformProvo, PlatformSalem, PlatformJasper, PlatformServer, PlatformAll, PlatformAllClient };
 
         const char* PlatformIdToPalFolder(AZ::PlatformId platform)
         {
@@ -31,11 +31,11 @@ namespace AZ
             {
             case AZ::PC:
                 return "PC";
-            case AZ::ES3:
+            case AZ::ANDROID_ID:
                 return "Android";
             case AZ::IOS:
                 return "iOS";
-            case AZ::OSX:
+            case AZ::MAC_ID:
                 return "Mac";
             case AZ::PROVO:
                 return "Provo";
@@ -66,11 +66,11 @@ namespace AZ
             }
             else if (osPlatform == PlatformCodeNameMac)
             {
-                return PlatformOSX;
+                return PlatformMac;
             }
             else if (osPlatform == PlatformCodeNameAndroid)
             {
-                return PlatformES3;
+                return PlatformAndroid;
             }
             else if (osPlatform == PlatformCodeNameiOS)
             {
@@ -207,13 +207,13 @@ namespace AZ
                 platformCodes.emplace_back(PlatformCodeNameWindows);
                 platformCodes.emplace_back(PlatformCodeNameLinux);
                 break;
-            case PlatformId::ES3:
+            case PlatformId::ANDROID_ID:
                 platformCodes.emplace_back(PlatformCodeNameAndroid);
                 break;
             case PlatformId::IOS:
                 platformCodes.emplace_back(PlatformCodeNameiOS);
                 break;
-            case PlatformId::OSX:
+            case PlatformId::MAC_ID:
                 platformCodes.emplace_back(PlatformCodeNameMac);
                 break;
             case PlatformId::PROVO:

Code/Framework/AzCore/AzCore/PlatformId/PlatformDefaults.h

@@ -27,9 +27,9 @@ namespace AZ
     inline namespace PlatformDefaults
     {
         constexpr char PlatformPC[] = "pc";
-        constexpr char PlatformES3[] = "es3";
+        constexpr char PlatformAndroid[] = "android";
         constexpr char PlatformIOS[] = "ios";
-        constexpr char PlatformOSX[] = "osx_gl";
+        constexpr char PlatformMac[] = "mac";
         constexpr char PlatformProvo[] = "provo";
         constexpr char PlatformSalem[] = "salem";
         constexpr char PlatformJasper[] = "jasper";
@@ -54,9 +54,9 @@ namespace AZ
         AZ_ENUM_WITH_UNDERLYING_TYPE(PlatformId, int,
             (Invalid, -1),
             PC,
-            ES3,
+            ANDROID_ID,
             IOS,
-            OSX,
+            MAC_ID,
             PROVO,
             SALEM,
             JASPER,
@@ -73,9 +73,9 @@ namespace AZ
         {
             Platform_NONE = 0x00,
             Platform_PC = 1 << PlatformId::PC,
-            Platform_ES3 = 1 << PlatformId::ES3,
+            Platform_ANDROID = 1 << PlatformId::ANDROID_ID,
             Platform_IOS = 1 << PlatformId::IOS,
-            Platform_OSX = 1 << PlatformId::OSX,
+            Platform_MAC = 1 << PlatformId::MAC_ID,
             Platform_PROVO = 1 << PlatformId::PROVO,
             Platform_SALEM = 1 << PlatformId::SALEM,
             Platform_JASPER = 1 << PlatformId::JASPER,
@@ -87,7 +87,7 @@ namespace AZ
             // A special platform that will always correspond to all non-server platforms, even if new ones are added
             Platform_ALL_CLIENT = 1ULL << 31,
 
-            AllNamedPlatforms = Platform_PC | Platform_ES3 | Platform_IOS | Platform_OSX | Platform_PROVO | Platform_SALEM | Platform_JASPER | Platform_SERVER,
+            AllNamedPlatforms = Platform_PC | Platform_ANDROID | Platform_IOS | Platform_MAC | Platform_PROVO | Platform_SALEM | Platform_JASPER | Platform_SERVER,
         };
 
         AZ_DEFINE_ENUM_BITWISE_OPERATORS(PlatformFlags);

Code/Framework/AzCore/AzCore/PlatformId/PlatformId.cpp

@@ -28,8 +28,8 @@ namespace AZ
             return "Android64";
         case PlatformID::PLATFORM_APPLE_IOS:
             return "iOS";
-        case PlatformID::PLATFORM_APPLE_OSX:
-            return "OSX";
+        case PlatformID::PLATFORM_APPLE_MAC:
+            return "Mac";
 #if defined(AZ_EXPAND_FOR_RESTRICTED_PLATFORM) || defined(AZ_TOOLS_EXPAND_FOR_RESTRICTED_PLATFORMS)
 #define AZ_RESTRICTED_PLATFORM_EXPANSION(CodeName, CODENAME, codename, PrivateName, PRIVATENAME, privatename, PublicName, PUBLICNAME, publicname, PublicAuxName1, PublicAuxName2, PublicAuxName3)\
         case PlatformID::PLATFORM_##PUBLICNAME:\

Code/Framework/AzCore/AzCore/PlatformId/PlatformId.h

@@ -23,7 +23,7 @@ namespace AZ
         PLATFORM_WINDOWS_64,
         PLATFORM_LINUX_64,
         PLATFORM_APPLE_IOS,
-        PLATFORM_APPLE_OSX,
+        PLATFORM_APPLE_MAC,
         PLATFORM_ANDROID_64,    // ARMv8 / 64-bit
         #if defined(AZ_EXPAND_FOR_RESTRICTED_PLATFORM) || defined(AZ_TOOLS_EXPAND_FOR_RESTRICTED_PLATFORMS)
 #define AZ_RESTRICTED_PLATFORM_EXPANSION(CodeName, CODENAME, codename, PrivateName, PRIVATENAME, privatename, PublicName, PUBLICNAME, publicname, PublicAuxName1, PublicAuxName2, PublicAuxName3)\

Code/Framework/AzCore/AzCore/Script/ScriptSystemComponent.cpp

@@ -937,7 +937,7 @@ void ScriptSystemComponent::Reflect(ReflectContext* reflection)
             ->Enum<static_cast<int>(PlatformID::PLATFORM_LINUX_64)>("Linux")
             ->Enum<static_cast<int>(PlatformID::PLATFORM_ANDROID_64)>("Android64")
             ->Enum<static_cast<int>(PlatformID::PLATFORM_APPLE_IOS)>("iOS")
-            ->Enum<static_cast<int>(PlatformID::PLATFORM_APPLE_OSX)>("OSX")
+            ->Enum<static_cast<int>(PlatformID::PLATFORM_APPLE_MAC)>("Mac")
 #if defined(AZ_EXPAND_FOR_RESTRICTED_PLATFORM) || defined(AZ_TOOLS_EXPAND_FOR_RESTRICTED_PLATFORMS)
 #define AZ_RESTRICTED_PLATFORM_EXPANSION(CodeName, CODENAME, codename, PrivateName, PRIVATENAME, privatename, PublicName, PUBLICNAME, publicname, PublicAuxName1, PublicAuxName2, PublicAuxName3)\
             ->Enum<static_cast<int>(PlatformID::PLATFORM_##PUBLICNAME)>(#CodeName)

Code/Framework/AzCore/Platform/Mac/AzCore/PlatformId/PlatformId_Mac.h

@@ -13,5 +13,5 @@
 
 namespace AZ
 {
-    static const PlatformID g_currentPlatform = PlatformID::PLATFORM_APPLE_OSX;
+    static const PlatformID g_currentPlatform = PlatformID::PLATFORM_APPLE_MAC;
 }

Code/Framework/AzCore/Tests/SettingsRegistryMergeUtilsTests.cpp

@@ -372,15 +372,15 @@ mac_remote_filesystem=0
 -- We need to know this before we establish VFS because different platform assets
 -- are stored in different root folders in the cache.  These correspond to the names
 -- In the asset processor config file.  This value also controls what config file is read
--- when you read system_xxxx_xxxx.cfg (for example, system_windows_pc.cfg or system_android_es3.cfg)
+-- when you read system_xxxx_xxxx.cfg (for example, system_windows_pc.cfg or system_android_android.cfg)
 -- by default, pc assets (in the 'pc' folder) are used, with RC being fed 'pc' as the platform
 -- by default on console we use the default assets=pc for better iteration times
 -- we should turn on console specific assets only when in release and/or testing assets and/or loading performance
 -- that way most people will not need to have 3 different caches taking up disk space
 assets = pc
-android_assets = es3
+android_assets = android
 ios_assets = ios
-mac_assets = osx_gl
+mac_assets = mac
 
 -- Add the IP address of your console to the white list that will connect to the asset processor here
 -- You can list addresses or CIDR's. CIDR's are helpful if you are using DHCP. A CIDR looks like an ip address with
@@ -438,9 +438,9 @@ mac_wait_for_connect=0
             ConfigFileParams::SettingsKeyValuePair{"/ios_remote_filesystem", AZ::s64{0}},
             ConfigFileParams::SettingsKeyValuePair{"/mac_remote_filesystem", AZ::s64{0}},
             ConfigFileParams::SettingsKeyValuePair{"/assets", AZStd::string_view{"pc"}},
-            ConfigFileParams::SettingsKeyValuePair{"/android_assets", AZStd::string_view{"es3"}},
+            ConfigFileParams::SettingsKeyValuePair{"/android_assets", AZStd::string_view{"android"}},
             ConfigFileParams::SettingsKeyValuePair{"/ios_assets", AZStd::string_view{"ios"}},
-            ConfigFileParams::SettingsKeyValuePair{"/mac_assets", AZStd::string_view{"osx_gl"}},
+            ConfigFileParams::SettingsKeyValuePair{"/mac_assets", AZStd::string_view{"mac"}},
             ConfigFileParams::SettingsKeyValuePair{"/connect_to_remote", AZ::s64{0}},
             ConfigFileParams::SettingsKeyValuePair{"/windows_connect_to_remote", AZ::s64{1}},
             ConfigFileParams::SettingsKeyValuePair{"/android_connect_to_remote", AZ::s64{0}},
@@ -478,20 +478,20 @@ test_asset_processor_tag = test_value
 [Platform pc]
 tags=tools,renderer,dx12,vulkan
 
-[Platform es3]
+[Platform android]
 tags=android,mobile,renderer,vulkan ; With Comments at the end
 
 [Platform ios]
 tags=mobile,renderer,metal
 
-[Platform osx_gl]
+[Platform mac]
 tags=tools,renderer,metal)"
         , AZStd::fixed_vector<ConfigFileParams::SettingsKeyValuePair, 20>{
             ConfigFileParams::SettingsKeyValuePair{"/test_asset_processor_tag", AZStd::string_view{"test_value"}},
             ConfigFileParams::SettingsKeyValuePair{"/Platform pc/tags", AZStd::string_view{"tools,renderer,dx12,vulkan"}},
-            ConfigFileParams::SettingsKeyValuePair{"/Platform es3/tags", AZStd::string_view{"android,mobile,renderer,vulkan"}},
+            ConfigFileParams::SettingsKeyValuePair{"/Platform android/tags", AZStd::string_view{"android,mobile,renderer,vulkan"}},
             ConfigFileParams::SettingsKeyValuePair{"/Platform ios/tags", AZStd::string_view{"mobile,renderer,metal"}},
-            ConfigFileParams::SettingsKeyValuePair{"/Platform osx_gl/tags", AZStd::string_view{"tools,renderer,metal"}},
+            ConfigFileParams::SettingsKeyValuePair{"/Platform mac/tags", AZStd::string_view{"tools,renderer,metal"}},
         }}
         )
     );

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

@@ -2008,13 +2008,12 @@ namespace AZ::IO
         // if no bind root is specified, compute one:
         strBindRoot = !bindRoot.empty() ? bindRoot : szFullPath->ParentPath().Native();
 
-        // Check if archive file disk exist on disk or inside of pak.
-        bool bFileExists = IsFileExist(szFullPath->Native());
-
-        if (!bFileExists && (nFactoryFlags & ZipDir::CacheFactory::FLAGS_READ_ONLY))
+        // Check if archive file disk exist on disk.
+        const bool pakOnDisk = FileIOBase::GetDirectInstance()->Exists(szFullPath->c_str());
+        if (!pakOnDisk && (nFactoryFlags & ZipDir::CacheFactory::FLAGS_READ_ONLY))
         {
             // Archive file not found.
-            AZ_TracePrintf("Archive", "Cannot open Archive file %s\n", szFullPath->c_str());
+            AZ_TracePrintf("Archive", "Archive file %s does not exist\n", szFullPath->c_str());
             return nullptr;
         }
 
@@ -2492,8 +2491,6 @@ namespace AZ::IO
 
     void Archive::FindCompressionInfo(bool& found, AZ::IO::CompressionInfo& info, const AZStd::string_view filename)
     {
-        constexpr uint32_t s_compressionTag = static_cast<uint32_t>('Z') << 24 | static_cast<uint32_t>('C') << 16 | static_cast<uint32_t>('R') << 8 | static_cast<uint32_t>('Y');
-
         if (!found)
         {
             auto correctedFilename = AZ::IO::FileIOBase::GetDirectInstance()->ResolvePath(filename);
@@ -2519,7 +2516,6 @@ namespace AZ::IO
                 found = true;
 
                 info.m_archiveFilename.InitFromRelativePath(archive->GetFilePath());
-                info.m_compressionTag.m_code = s_compressionTag;
                 info.m_offset = pFileData->GetFileDataOffset();
                 info.m_compressedSize = entry->desc.lSizeCompressed;
                 info.m_uncompressedSize = entry->desc.lSizeUncompressed;
@@ -2539,9 +2535,8 @@ namespace AZ::IO
                     break;
                 }
 
-                info.m_decompressor = [&s_compressionTag]([[maybe_unused]] const AZ::IO::CompressionInfo& info, const void* compressed, size_t compressedSize, void* uncompressed, size_t uncompressedBufferSize)->bool
+                info.m_decompressor = []([[maybe_unused]] const AZ::IO::CompressionInfo& info, const void* compressed, size_t compressedSize, void* uncompressed, size_t uncompressedBufferSize)->bool
                 {
-                    AZ_Assert(info.m_compressionTag.m_code == s_compressionTag, "Provided compression info isn't supported by this decompressor.");
                     size_t nSizeUncompressed = uncompressedBufferSize;
                     return ZipDir::ZipRawUncompress(uncompressed, &nSizeUncompressed, compressed, compressedSize) == 0;
                 };

Code/Framework/AzFramework/AzFramework/Archive/ArchiveFindData.cpp

@@ -50,6 +50,7 @@ namespace AZ::IO
         , tWrite{ writeTime }
     {
     }
+
     ArchiveFileIterator::ArchiveFileIterator(FindData* findData, AZStd::string_view filename, const FileDesc& fileDesc)
         : m_findData{ findData }
         , m_filename{ filename }
@@ -108,13 +109,10 @@ namespace AZ::IO
             AZ::StringFunc::Path::GetFullPath(directory.c_str(), searchDirectory);
             AZ::StringFunc::Path::GetFullFileName(directory.c_str(), pattern);
         }
-
         AZ::IO::FileIOBase::GetDirectInstance()->FindFiles(searchDirectory.c_str(), pattern.c_str(), [&](const char* filePath) -> bool
         {
             AZ::IO::FileDesc fileDesc;
-
-            AZStd::string fullFilePath;
-            AZ::StringFunc::Path::GetFullFileName(filePath, fullFilePath);
+            AZStd::string filePathEntry{filePath};
 
             if (AZ::IO::FileIOBase::GetDirectInstance()->IsDirectory(filePath))
             {
@@ -135,9 +133,8 @@ namespace AZ::IO
                 fileDesc.tAccess = fileDesc.tWrite;
                 fileDesc.tCreate = fileDesc.tWrite;
             }
-            [[maybe_unused]] auto result = m_mapFiles.emplace(AZStd::move(fullFilePath), fileDesc);
-            AZ_Assert(result.second, "Failed to insert FindData entry for %s", fullFilePath.c_str());
-
+            [[maybe_unused]] auto result = m_mapFiles.emplace(AZStd::move(filePathEntry), fileDesc);
+            AZ_Assert(result.second, "Failed to insert FindData entry for filePath %s", filePath);
             return true;
         });
     }
@@ -273,7 +270,9 @@ namespace AZ::IO
         }
 
         auto pakFileIter = m_mapFiles.begin();
-        fileIterator.m_filename = pakFileIter->first;
+        AZStd::string fullFilePath;
+        AZ::StringFunc::Path::GetFullFileName(pakFileIter->first.c_str(), fullFilePath);
+        fileIterator.m_filename = AZStd::move(fullFilePath);
         fileIterator.m_fileDesc = pakFileIter->second;
         fileIterator.m_lastFetchValid = true;
 

Code/Framework/AzFramework/AzFramework/Components/ComponentAdapter.h

@@ -1,22 +1,22 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
 #include <AzCore/Component/Component.h>
 #include <AzCore/RTTI/RTTI.h>
-#include <AzCore/Serialization/SerializeContext.h>
 #include <AzCore/Serialization/EditContext.h>
 #include <AzCore/Serialization/EditContextConstants.inl>
+#include <AzCore/Serialization/SerializeContext.h>
 
 namespace AzFramework
 {
@@ -64,15 +64,13 @@ namespace AzFramework
         the EditContext. TController can friend itself to the editor component to make this work if required.
     */
         template<typename TController, typename TConfiguration = AZ::ComponentConfig>
-        class ComponentAdapter
-            : public AZ::Component
+        class ComponentAdapter : public AZ::Component
         {
         public:
-
             AZ_RTTI((ComponentAdapter, "{644A9187-4FDB-42C1-9D59-DD75304B551A}", TController, TConfiguration), AZ::Component);
 
             ComponentAdapter() = default;
-            ComponentAdapter(const TConfiguration& configuration);
+            explicit ComponentAdapter(const TConfiguration& configuration);
 
             static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services);
             static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& services);
@@ -85,7 +83,6 @@ namespace AzFramework
             void Deactivate() override;
 
         protected:
-
             static void Reflect(AZ::ReflectContext* context);
 
             // AZ::Component overrides ...

Code/Framework/AzFramework/AzFramework/Components/ComponentAdapter.inl

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include <AzFramework/Components/ComponentAdapterHelpers.h>
 
@@ -32,10 +32,12 @@ namespace AzFramework
 
             if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
             {
+                // clang-format off
                 serializeContext->Class<ComponentAdapter, Component>()
                     ->Version(1)
                     ->Field("Controller", &ComponentAdapter::m_controller)
                     ;
+                // clang-format on
             }
         }
 
@@ -66,9 +68,6 @@ namespace AzFramework
             GetDependentServicesHelper<TController>(services, typename AZ::HasComponentDependentServices<TController>::type());
         }
 
-        //////////////////////////////////////////////////////////////////////////
-        // AZ::Component interface implementation
-
         template<typename TController, typename TConfiguration>
         void ComponentAdapter<TController, TConfiguration>::Init()
         {
@@ -78,7 +77,7 @@ namespace AzFramework
         template<typename TController, typename TConfiguration>
         void ComponentAdapter<TController, TConfiguration>::Activate()
         {
-            m_controller.Activate(GetEntityId());
+            ComponentActivateHelper<TController>::Activate(m_controller, AZ::EntityComponentIdPair(GetEntityId(), GetId()));
         }
 
         template<typename TController, typename TConfiguration>

Code/Framework/AzFramework/AzFramework/Components/ComponentAdapterHelpers.h

@@ -13,6 +13,7 @@
 #pragma once
 
 #include <AzCore/Component/Component.h>
+#include <AzCore/Component/EntityBus.h>
 
 namespace AzFramework
 {
@@ -27,18 +28,43 @@ namespace AzFramework
         template<typename T, typename = void>
         struct ComponentInitHelper
         {
-            static void Init(T& common)
+            static void Init([[maybe_unused]] T& controller)
             {
-                AZ_UNUSED(common);
             }
         };
 
         template<typename T>
         struct ComponentInitHelper<T, AZStd::void_t<decltype(AZStd::declval<T>().Init())>>
         {
-            static void Init(T& common)
+            static void Init(T& controller)
             {
-                common.Init();
+                controller.Init();
+            }
+        };
+
+        template<typename T, typename = void>
+        struct ComponentActivateHelper
+        {
+            static void Activate([[maybe_unused]] T& controller, [[maybe_unused]] const AZ::EntityComponentIdPair& entityComponentIdPair)
+            {
+            }
+        };
+
+        template<typename T>
+        struct ComponentActivateHelper<T, AZStd::void_t<decltype(AZStd::declval<T>().Activate(AZ::EntityId()))>>
+        {
+            static void Activate(T& controller, const AZ::EntityComponentIdPair& entityComponentIdPair)
+            {
+                controller.Activate(entityComponentIdPair.GetEntityId());
+            }
+        };
+
+        template<typename T>
+        struct ComponentActivateHelper<T, AZStd::void_t<decltype(AZStd::declval<T>().Activate(AZ::EntityComponentIdPair()))>>
+        {
+            static void Activate(T& controller, const AZ::EntityComponentIdPair& entityComponentIdPair)
+            {
+                controller.Activate(entityComponentIdPair);
             }
         };
 

Code/Framework/AzFramework/AzFramework/Components/TransformComponent.cpp

@@ -327,99 +327,13 @@ namespace AzFramework
         return localZ;
     }
 
-    void TransformComponent::SetRotation(const AZ::Vector3& eulerAnglesRadian)
+    void TransformComponent::SetWorldRotationQuaternion(const AZ::Quaternion& quaternion)
     {
-        AZ_Warning("TransformComponent", false, "SetRotation is deprecated, please use SetLocalRotation");
-
-        AZ::Transform newWorldTransform = m_worldTM;
-        newWorldTransform.SetRotation(AZ::ConvertEulerRadiansToQuaternion(eulerAnglesRadian));
-        SetWorldTM(newWorldTransform);
-    }
-
-    void TransformComponent::SetRotationQuaternion(const AZ::Quaternion& quaternion)
-    {
-        AZ_Warning("TransformComponent", false, "SetRotationQuaternion is deprecated, please use SetLocalRotationQuaternion");
-
         AZ::Transform newWorldTransform = m_worldTM;
         newWorldTransform.SetRotation(quaternion);
         SetWorldTM(newWorldTransform);
     }
 
-    void TransformComponent::SetRotationX(float eulerAngleRadian)
-    {
-        AZ_Warning("TransformComponent", false, "SetRotationX is deprecated, please use SetLocalRotation");
-
-        AZ::Transform newWorldTransform = m_worldTM;
-        newWorldTransform.SetRotation(AZ::Quaternion::CreateRotationX(eulerAngleRadian));
-        SetWorldTM(newWorldTransform);
-    }
-
-    void TransformComponent::SetRotationY(float eulerAngleRadian)
-    {
-        AZ_Warning("TransformComponent", false, "SetRotationY is deprecated, please use SetLocalRotation");
-
-        AZ::Transform newWorldTransform = m_worldTM;
-        newWorldTransform.SetRotation(AZ::Quaternion::CreateRotationY(eulerAngleRadian));
-        SetWorldTM(newWorldTransform);
-    }
-
-    void TransformComponent::SetRotationZ(float eulerAngleRadian)
-    {
-        AZ_Warning("TransformComponent", false, "SetRotationZ is deprecated, please use SetLocalRotation");
-
-        AZ::Transform newWorldTransform = m_worldTM;
-        newWorldTransform.SetRotation(AZ::Quaternion::CreateRotationZ(eulerAngleRadian));
-        SetWorldTM(newWorldTransform);
-    }
-
-    void TransformComponent::RotateByX(float eulerAngleRadian)
-    {
-        AZ_Warning("TransformComponent", false, "RotateByX is deprecated, please use RotateAroundLocalX");
-        RotateAroundLocalX(eulerAngleRadian);
-    }
-
-    void TransformComponent::RotateByY(float eulerAngleRadian)
-    {
-        AZ_Warning("TransformComponent", false, "RotateByY is deprecated, please use RotateAroundLocalY");
-        RotateAroundLocalY(eulerAngleRadian);
-    }
-
-    void TransformComponent::RotateByZ(float eulerAngleRadian)
-    {
-        AZ_Warning("TransformComponent", false, "RotateByZ is deprecated, please use RotateAroundLocalZ");
-        RotateAroundLocalZ(eulerAngleRadian);
-    }
-
-    AZ::Vector3 TransformComponent::GetRotationEulerRadians()
-    {
-        AZ_Warning("TransformComponent", false, "GetRotationEulerRadians is deprecated, please use GetWorldRotation");
-        return m_worldTM.GetRotation().GetEulerRadians();
-    }
-
-    AZ::Quaternion TransformComponent::GetRotationQuaternion()
-    {
-        AZ_Warning("TransformComponent", false, "GetRotationQuaternion is deprecated, please use GetWorldRotationQuaternion");
-        return m_worldTM.GetRotation();
-    }
-
-    float TransformComponent::GetRotationX()
-    {
-        AZ_Warning("TransformComponent", false, "GetRotationX is deprecated, please use GetWorldRotation");
-        return GetRotationEulerRadians().GetX();
-    }
-
-    float TransformComponent::GetRotationY()
-    {
-        AZ_Warning("TransformComponent", false, "GetRotationY is deprecated, please use GetWorldRotation");
-        return GetRotationEulerRadians().GetY();
-    }
-
-    float TransformComponent::GetRotationZ()
-    {
-        AZ_Warning("TransformComponent", false, "GetRotationZ is deprecated, please use GetWorldRotation");
-        return GetRotationEulerRadians().GetZ();
-    }
-
     AZ::Vector3 TransformComponent::GetWorldRotation()
     {
         return m_worldTM.GetRotation().GetEulerRadians();
@@ -830,45 +744,7 @@ namespace AzFramework
                 ->Event("GetLocalX", &AZ::TransformBus::Events::GetLocalX)
                 ->Event("GetLocalY", &AZ::TransformBus::Events::GetLocalY)
                 ->Event("GetLocalZ", &AZ::TransformBus::Events::GetLocalZ)
-                ->Event("RotateByX", &AZ::TransformBus::Events::RotateByX)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("RotateByY", &AZ::TransformBus::Events::RotateByY)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("RotateByZ", &AZ::TransformBus::Events::RotateByZ)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("SetEulerRotation", &AZ::TransformBus::Events::SetRotation)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("SetRotationQuaternion", &AZ::TransformBus::Events::SetRotationQuaternion)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("SetRotationX", &AZ::TransformBus::Events::SetRotationX)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("SetRotationY", &AZ::TransformBus::Events::SetRotationY)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("SetRotationZ", &AZ::TransformBus::Events::SetRotationZ)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("GetEulerRotation", &AZ::TransformBus::Events::GetRotationEulerRadians)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("GetRotationQuaternion", &AZ::TransformBus::Events::GetRotationQuaternion)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("GetRotationX", &AZ::TransformBus::Events::GetRotationX)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                   ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("GetRotationY", &AZ::TransformBus::Events::GetRotationY)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
-                ->Event("GetRotationZ", &AZ::TransformBus::Events::GetRotationZ)
-                    ->Attribute(AZ::Script::Attributes::Deprecated, true)
-                    ->Attribute(AZ::Script::Attributes::ExcludeFrom, AZ::Script::Attributes::ExcludeFlags::All)
+                ->Event("SetWorldRotationQuaternion", &AZ::TransformBus::Events::SetWorldRotationQuaternion)
                 ->Event("GetWorldRotation", &AZ::TransformBus::Events::GetWorldRotation)
                 ->Event("GetWorldRotationQuaternion", &AZ::TransformBus::Events::GetWorldRotationQuaternion)
                 ->Event("SetLocalRotation", &AZ::TransformBus::Events::SetLocalRotation)

Code/Framework/AzFramework/AzFramework/Components/TransformComponent.h

@@ -112,22 +112,7 @@ namespace AzFramework
         float GetLocalZ() override;
 
         // Rotation modifiers
-        void SetRotation(const AZ::Vector3& eulerAnglesRadian) override;
-        void SetRotationQuaternion(const AZ::Quaternion& quaternion) override;
-        void SetRotationX(float eulerAngleRadian) override;
-        void SetRotationY(float eulerAngleRadian) override;
-        void SetRotationZ(float eulerAngleRadian) override;
-
-        void RotateByX(float eulerAngleRadian) override;
-        void RotateByY(float eulerAngleRadian) override;
-        void RotateByZ(float eulerAngleRadian) override;
-
-        AZ::Vector3 GetRotationEulerRadians() override;
-        AZ::Quaternion GetRotationQuaternion() override;
-
-        float GetRotationX() override;
-        float GetRotationY() override;
-        float GetRotationZ() override;
+        void SetWorldRotationQuaternion(const AZ::Quaternion& quaternion) override;
 
         AZ::Vector3 GetWorldRotation() override;
         AZ::Quaternion GetWorldRotationQuaternion() override;

Code/Framework/AzFramework/AzFramework/Font/FontInterface.h

@@ -15,6 +15,7 @@
 #include <AzCore/RTTI/RTTI.h>
 #include <AzCore/Math/Vector2.h>
 #include <AzCore/Math/Color.h>
+#include <AzCore/Math/Matrix3x4.h>
 #include <AzCore/std/string/string_view.h>
 #include <AzFramework/Viewport/ViewportId.h>
 
@@ -42,11 +43,15 @@ namespace AzFramework
     {
         ViewportId m_drawViewportId = InvalidViewportId; //!< Viewport to draw into
         AZ::Vector3 m_position; //!< world space position for 3d draws, screen space x,y,depth for 2d.
-        AZ::Color   m_color = AZ::Colors::White; //!< Color to draw the text
+        AZ::Color m_color = AZ::Colors::White; //!< Color to draw the text
+        unsigned int m_effectIndex = 0; //!< effect index to apply
         AZ::Vector2 m_scale = AZ::Vector2(1.0f); //!< font scale
-        float       m_lineSpacing; //!< Spacing between new lines, as a percentage of m_scale.
+        float m_textSizeFactor = 12.0f; //!< font size in pixels
+        float m_lineSpacing = 1.0f; //!< Spacing between new lines, as a percentage of m_scale.
         TextHorizontalAlignment m_hAlign = TextHorizontalAlignment::Left; //!< Horizontal text alignment
         TextVerticalAlignment m_vAlign = TextVerticalAlignment::Top; //!< Vertical text alignment
+        bool m_useTransform = false; //!< Use specified transform
+        AZ::Matrix3x4 m_transform = AZ::Matrix3x4::Identity(); //!< Transform to apply to text quads
         bool m_monospace = false; //!< disable character proportional spacing
         bool m_depthTest = false; //!< Test character against the depth buffer
         bool m_virtual800x600ScreenSize = true; //!< Text placement and size are scaled relative to a virtual 800x600 resolution

Code/Framework/AzFramework/AzFramework/Physics/Ragdoll.h

@@ -102,7 +102,7 @@ namespace Physics
 
         /// Is the ragdoll currently simulated?
         /// @result True in case the ragdoll is simulated, false if not.
-        virtual bool IsSimulated() = 0;
+        virtual bool IsSimulated() const = 0;
 
         /// Writes the state for all of the bodies in the ragdoll to the provided output.
         /// The caller owns the output state and can safely manipulate it without affecting the physics simulation.

Code/Framework/AzToolsFramework/AzToolsFramework/API/EditorAssetSystemAPI.h

@@ -120,14 +120,14 @@ namespace AzToolsFramework
 
             /**
             * Query to see if a specific asset platform is enabled
-            * @param platform the asset platform to check e.g. es3, ios, etc.
+            * @param platform the asset platform to check e.g. android, ios, etc.
             * @return true if enabled, false otherwise
             */
             virtual bool IsAssetPlatformEnabled(const char* platform) = 0;
 
             /**
             * Get the total number of pending assets left to process for a specific asset platform
-            * @param platform the asset platform to check e.g. es3, ios, etc.
+            * @param platform the asset platform to check e.g. android, ios, etc.
             * @return -1 if the process fails, a positive number otherwise
             */
             virtual int GetPendingAssetsForPlatform(const char* platform) = 0;
@@ -312,7 +312,7 @@ namespace AzToolsFramework
         inline const char* GetHostAssetPlatform()
         {
 #if defined(AZ_PLATFORM_MAC)
-            return "osx_gl";
+            return "mac";
 #elif defined(AZ_PLATFORM_WINDOWS)
             return "pc";
 #elif defined(AZ_PLATFORM_LINUX)

Code/Framework/AzToolsFramework/AzToolsFramework/API/EditorViewportIconDisplayInterface.h

@@ -0,0 +1,80 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#pragma once
+
+#include <AzCore/RTTI/RTTI.h>
+#include <AzCore/Interface/Interface.h>
+#include <AzCore/Math/Color.h>
+
+#include <AzFramework/Viewport/ViewportId.h>
+
+namespace AzToolsFramework
+{
+    //! An interface for loading simple icon assets and rendering them to screen on a per-viewport basis.
+    class EditorViewportIconDisplayInterface
+    {
+    public:
+        AZ_RTTI(EditorViewportIconDisplayInterface, "{D5190B58-2561-4F3F-B793-F1E7D454CDF2}");
+
+        using IconId = AZ::s32;
+        static constexpr IconId InvalidIconId = -1;
+
+        enum class CoordinateSpace : AZ::u8
+        {
+            ScreenSpace,
+            WorldSpace
+        };
+
+        //! These draw parameters control rendering for a single icon to a single viewport.
+        struct DrawParameters
+        {
+            //! The ViewportId to render to.
+            AzFramework::ViewportId m_viewport = AzFramework::InvalidViewportId;
+            //! The icon ID, retrieved from GetOrLoadIconForPath, to render to screen.
+            IconId m_icon = InvalidIconId;
+            //! The color, including opacity, to render the icon with. White will render the icon as opaque in its original color.
+            AZ::Color m_color = AZ::Colors::White;
+            //! The position to render the icon to, in world or screen space depending on m_positionSpace.
+            AZ::Vector3 m_position;
+            //! The coordinate system to use for m_position.
+            //! ScreenSpace will accept m_position in the form of [X, Y, Depth], where X & Y are screen coordinates in
+            //! pixels and Depth is a z-ordering depth value from 0.0f to 1.0f.
+            //! WorldSpace will accept a 3D vector in world space coordinates that will be translated back into screen
+            //! space when the icon is rendered.
+            CoordinateSpace m_positionSpace = CoordinateSpace::ScreenSpace;
+            //! The size to render the icon as, in pixels.
+            AZ::Vector2 m_size;
+        };
+
+        //! The current load status of an icon retrieved by GetOrLoadIconForPath.
+        enum class IconLoadStatus : AZ::u8
+        {
+            Unloaded,
+            Loading,
+            Loaded,
+            Error
+        };
+
+        //! Draws an icon to a viewport given a set of draw parameters.
+        //! Requires an IconId retrieved from GetOrLoadIconForPath.
+        virtual void DrawIcon(const DrawParameters& drawParameters) = 0;
+        //! Retrieves a reusable IconId for an icon at a given path.
+        //! This will load the icon, if it has not already been loaded.
+        //! @param path should be a relative asset path to an icon image asset.
+        //! png and svg icons are currently supported.
+        virtual IconId GetOrLoadIconForPath(AZStd::string_view path) = 0;
+        //! Gets the current load status of an icon retrieved via GetOrLoadIconForPath.
+        virtual IconLoadStatus GetIconLoadStatus(IconId icon) = 0;
+    };
+
+    using EditorViewportIconDisplay = AZ::Interface<EditorViewportIconDisplayInterface>;
+} //namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipInterface.h

@@ -56,5 +56,7 @@ namespace AzToolsFramework
         
         virtual void StartPlayInEditor() = 0;
         virtual void StopPlayInEditor() = 0;
+
+        virtual void CreateNewLevelPrefab(AZStd::string_view filename, const AZStd::string& templateFilename) = 0;
     };
 }

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp

@@ -225,50 +225,19 @@ namespace AzToolsFramework
 
         m_rootInstance->SetTemplateSourcePath(relativePath);
 
-        bool newLevelFromTemplate = false;
-
         if (templateId == AzToolsFramework::Prefab::InvalidTemplateId)
         {
-            AZStd::string watchFolder;
-            AZ::Data::AssetInfo assetInfo;
-            bool sourceInfoFound = false;
-            AzToolsFramework::AssetSystemRequestBus::BroadcastResult(
-                sourceInfoFound, &AzToolsFramework::AssetSystemRequestBus::Events::GetSourceInfoBySourcePath, DefaultLevelTemplateName,
-                assetInfo, watchFolder);
+            m_rootInstance->m_containerEntity->AddComponent(aznew Prefab::EditorPrefabComponent());
+            HandleEntitiesAdded({ m_rootInstance->m_containerEntity.get() });
 
-            if (sourceInfoFound)
+            AzToolsFramework::Prefab::PrefabDom dom;
+            bool success = AzToolsFramework::Prefab::PrefabDomUtils::StoreInstanceInPrefabDom(*m_rootInstance, dom);
+            if (!success)
             {
-                AZStd::string fullPath;
-                AZ::StringFunc::Path::Join(watchFolder.c_str(), assetInfo.m_relativePath.c_str(), fullPath);
-
-                // Get the default prefab and copy the Dom over to the new template being saved
-                Prefab::TemplateId defaultId = m_loaderInterface->LoadTemplateFromFile(fullPath.c_str());
-                Prefab::PrefabDom& dom = m_prefabSystemComponent->FindTemplateDom(defaultId);
-
-                Prefab::PrefabDom levelDefaultDom;
-                levelDefaultDom.CopyFrom(dom, levelDefaultDom.GetAllocator());
-
-                Prefab::PrefabDomPath sourcePath("/Source");
-                sourcePath.Set(levelDefaultDom, relativePath.c_str());
-
-                templateId = m_prefabSystemComponent->AddTemplate(relativePath, std::move(levelDefaultDom));
-                newLevelFromTemplate = true;
-            }
-            else
-            {
-                // Create an empty level since we couldn't find the default template
-                m_rootInstance->m_containerEntity->AddComponent(aznew Prefab::EditorPrefabComponent());
-                HandleEntitiesAdded({ m_rootInstance->m_containerEntity.get() });
-
-                AzToolsFramework::Prefab::PrefabDom dom;
-                bool success = AzToolsFramework::Prefab::PrefabDomUtils::StoreInstanceInPrefabDom(*m_rootInstance, dom);
-                if (!success)
-                {
-                    AZ_Error("Prefab", false, "Failed to convert current root instance into a DOM when saving file '%.*s'", AZ_STRING_ARG(filename));
-                    return false;
-                }
-                templateId = m_prefabSystemComponent->AddTemplate(relativePath, std::move(dom));
+                AZ_Error("Prefab", false, "Failed to convert current root instance into a DOM when saving file '%.*s'", AZ_STRING_ARG(filename));
+                return false;
             }
+            templateId = m_prefabSystemComponent->AddTemplate(relativePath, AZStd::move(dom));
 
             if (templateId == AzToolsFramework::Prefab::InvalidTemplateId)
             {
@@ -286,13 +255,6 @@ namespace AzToolsFramework
             m_prefabSystemComponent->RemoveTemplate(prevTemplateId);
         }
 
-        // If we have a new level from a template, we need to make sure to propagate the changes here otherwise
-        // the entities from the new template won't show up
-        if (newLevelFromTemplate)
-        {
-            m_prefabSystemComponent->PropagateTemplateChanges(templateId);
-        }
-
         AZStd::string out;
         if (m_loaderInterface->SaveTemplateToString(m_rootInstance->GetTemplateId(), out))
         {
@@ -303,6 +265,71 @@ namespace AzToolsFramework
         return false;
     }
 
+    void PrefabEditorEntityOwnershipService::CreateNewLevelPrefab(AZStd::string_view filename, const AZStd::string& templateFilename)
+    {
+        AZ::IO::Path relativePath = m_loaderInterface->GetRelativePathToProject(filename);
+        AzToolsFramework::Prefab::TemplateId templateId = m_prefabSystemComponent->GetTemplateIdFromFilePath(relativePath);
+
+        m_rootInstance->SetTemplateSourcePath(relativePath);
+
+        AZStd::string watchFolder;
+        AZ::Data::AssetInfo assetInfo;
+        bool sourceInfoFound = false;
+        AzToolsFramework::AssetSystemRequestBus::BroadcastResult(
+            sourceInfoFound, &AzToolsFramework::AssetSystemRequestBus::Events::GetSourceInfoBySourcePath, templateFilename.c_str(),
+            assetInfo, watchFolder);
+
+        if (sourceInfoFound)
+        {
+            AZStd::string fullPath;
+            AZ::StringFunc::Path::Join(watchFolder.c_str(), assetInfo.m_relativePath.c_str(), fullPath);
+
+            // Get the default prefab and copy the Dom over to the new template being saved
+            Prefab::TemplateId defaultId = m_loaderInterface->LoadTemplateFromFile(fullPath.c_str());
+            Prefab::PrefabDom& dom = m_prefabSystemComponent->FindTemplateDom(defaultId);
+
+            Prefab::PrefabDom levelDefaultDom;
+            levelDefaultDom.CopyFrom(dom, levelDefaultDom.GetAllocator());
+
+            Prefab::PrefabDomPath sourcePath("/Source");
+            sourcePath.Set(levelDefaultDom, relativePath.c_str());
+
+            templateId = m_prefabSystemComponent->AddTemplate(relativePath, AZStd::move(levelDefaultDom));
+        }
+        else
+        {
+            m_rootInstance->m_containerEntity->AddComponent(aznew Prefab::EditorPrefabComponent());
+            HandleEntitiesAdded({ m_rootInstance->m_containerEntity.get() });
+
+            AzToolsFramework::Prefab::PrefabDom dom;
+            bool success = AzToolsFramework::Prefab::PrefabDomUtils::StoreInstanceInPrefabDom(*m_rootInstance, dom);
+            if (!success)
+            {
+                AZ_Error(
+                    "Prefab", false, "Failed to convert current root instance into a DOM when saving file '%.*s'", AZ_STRING_ARG(filename));
+                return;
+            }
+            templateId = m_prefabSystemComponent->AddTemplate(relativePath, std::move(dom));
+        }
+
+        if (templateId == AzToolsFramework::Prefab::InvalidTemplateId)
+        {
+            AZ_Error("Prefab", false, "Couldn't create new template id '%i' when creating new level '%.*s'", templateId, AZ_STRING_ARG(filename));
+            return;
+        }
+
+        Prefab::TemplateId prevTemplateId = m_rootInstance->GetTemplateId();
+        m_rootInstance->SetTemplateId(templateId);
+
+        if (prevTemplateId != Prefab::InvalidTemplateId && templateId != prevTemplateId)
+        {
+            // Make sure we only have one level template loaded at a time
+            m_prefabSystemComponent->RemoveTemplate(prevTemplateId);
+        }
+
+        m_prefabSystemComponent->PropagateTemplateChanges(templateId);
+    }
+
     Prefab::InstanceOptionalReference PrefabEditorEntityOwnershipService::CreatePrefab(
         const AZStd::vector<AZ::Entity*>& entities, AZStd::vector<AZStd::unique_ptr<Prefab::Instance>>&& nestedPrefabInstances,
         AZ::IO::PathView filePath, Prefab::InstanceOptionalReference instanceToParentUnder)

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.h

@@ -170,6 +170,8 @@ namespace AzToolsFramework
         void StartPlayInEditor() override;
         void StopPlayInEditor() override;
 
+        void CreateNewLevelPrefab(AZStd::string_view filename, const AZStd::string& templateFilename) override;
+
     protected:
 
         AZ::SliceComponent::SliceInstanceAddress GetOwningSlice() override;
@@ -216,7 +218,5 @@ namespace AzToolsFramework
         Prefab::PrefabLoaderInterface* m_loaderInterface;
         AzFramework::EntityContextId m_entityContextId;
         AZ::SerializeContext m_serializeContext;
-
-        static inline constexpr const char* DefaultLevelTemplateName = "Prefabs/Default_Level.prefab";
     };
 }

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/SliceEditorEntityOwnershipService.cpp

@@ -614,7 +614,7 @@ namespace AzToolsFramework
 
                                     AZ::Quaternion oldEntityRotation;
                                     AZ::TransformBus::EventResult(oldEntityRotation, id, &AZ::TransformBus::Events::GetWorldRotationQuaternion);
-                                    transformComponent->SetRotationQuaternion(oldEntityRotation);
+                                    transformComponent->SetWorldRotationQuaternion(oldEntityRotation);
 
                                     // Ensure the existing hierarchy is maintained
                                     AZ::EntityId oldParentEntityId;

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/LineSegmentSelectionManipulator.cpp

@@ -31,7 +31,7 @@ namespace AzToolsFramework
             rayProportion, lineSegmentProportion, worldClosestPositionRay, worldClosestPositionLineSegment);
 
         AZ::Transform worldFromLocalNormalized = worldFromLocal;
-        const AZ::Vector3 scale = worldFromLocalNormalized.ExtractScale() * nonUniformScale;
+        const AZ::Vector3 scale = worldFromLocalNormalized.ExtractUniformScale() * nonUniformScale;
         const AZ::Transform localFromWorldNormalized = worldFromLocalNormalized.GetInverse();
 
         return { (localFromWorldNormalized.TransformPoint(worldClosestPositionLineSegment)) / scale };

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/LinearManipulator.cpp

@@ -59,7 +59,7 @@ namespace AzToolsFramework
             ? CalculateSnappedOffset(localTransform.GetTranslation(), axis, gridSize * scaleRecip)
             : AZ::Vector3::CreateZero();
 
-        const AZ::Vector3 localScale = localTransform.GetScale();
+        const AZ::Vector3 localScale = AZ::Vector3(localTransform.GetUniformScale());
         const AZ::Quaternion localRotation = QuaternionFromTransformNoScaling(localTransform);
         // calculate scale amount to snap, to align to round scale value
         const AZ::Vector3 scaleSnapOffset = snapping && !gridSnapAction.m_localSnapping

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorSnapping.h

@@ -113,7 +113,7 @@ namespace AzToolsFramework
     /// noise in the value returned when dealing with values far from the origin.
     inline float ScaleReciprocal(const AZ::Transform& transform)
     {
-        return Round3(transform.GetScale().GetReciprocal().GetMinElement());
+        return Round3(1.0f / transform.GetUniformScale());
     }
 
     /// Find the reciprocal of the non-uniform scale.

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorSpace.cpp

@@ -39,7 +39,7 @@ namespace AzToolsFramework
         AZ::Transform result;
         result.SetRotation(m_space.GetRotation() * localTransform.GetRotation());
         result.SetTranslation(m_space.TransformPoint(m_nonUniformScale * localTransform.GetTranslation()));
-        result.SetScale(m_space.GetScale() * localTransform.GetScale());
+        result.SetScale(m_space.GetScale() * localTransform.GetUniformScale());
         return result;
     }
 

Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/EditorComponentAdapter.h

@@ -1,22 +1,22 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #pragma once
 
-#include <AzToolsFramework/ToolsComponents/EditorComponentBase.h>
-#include <AzToolsFramework/ToolsComponents/EditorVisibilityBus.h>
-#include <AzCore/Serialization/SerializeContext.h>
 #include <AzCore/Serialization/EditContext.h>
 #include <AzCore/Serialization/EditContextConstants.inl>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzToolsFramework/ToolsComponents/EditorComponentBase.h>
+#include <AzToolsFramework/ToolsComponents/EditorVisibilityBus.h>
 
 namespace AzToolsFramework
 {
@@ -31,7 +31,7 @@ namespace AzToolsFramework
         To use the EditorComponentAdapter, 3 classes are required:
          - a class that implements the functions required for TController (see below)
          - a configuration struct/class which extends AZ::ComponentConfig
-         - A runtime component that will be generated by the editor comoinent on export
+         - A runtime component that will be generated by the editor component on export
 
          The concrete component extends the adapter and implements behavior which is unique to the component.
 
@@ -64,15 +64,15 @@ namespace AzToolsFramework
         the EditContext. TController can friend itself to the editor component to make this work if required.
     */
         template<typename TController, typename TRuntimeComponent, typename TConfiguration = AZ::ComponentConfig>
-        class EditorComponentAdapter
-            : public EditorComponentBase
+        class EditorComponentAdapter : public EditorComponentBase
         {
         public:
-
-            AZ_RTTI((EditorComponentAdapter, "{2F5A3669-FFE9-4CD7-B9E2-7FC8100CF1A2}", TController, TRuntimeComponent, TConfiguration), EditorComponentBase);
+            AZ_RTTI(
+                (EditorComponentAdapter, "{2F5A3669-FFE9-4CD7-B9E2-7FC8100CF1A2}", TController, TRuntimeComponent, TConfiguration),
+                EditorComponentBase);
 
             EditorComponentAdapter() = default;
-            EditorComponentAdapter(const TConfiguration& configuration);
+            explicit EditorComponentAdapter(const TConfiguration& configuration);
 
             static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services);
             static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& services);
@@ -86,7 +86,6 @@ namespace AzToolsFramework
             void BuildGameEntity(AZ::Entity* gameEntity) override;
 
         protected:
-
             static void Reflect(AZ::ReflectContext* context);
 
             // AZ::Component overrides ...

Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/EditorComponentAdapter.inl

@@ -1,14 +1,14 @@
 /*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
 
 #include <AzFramework/Components/ComponentAdapterHelpers.h>
 
@@ -28,23 +28,21 @@ namespace AzToolsFramework
         template<typename TController, typename TRuntimeComponent, typename TConfiguration>
         void EditorComponentAdapter<TController, TRuntimeComponent, TConfiguration>::Reflect(AZ::ReflectContext* context)
         {
-            if (AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+            if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
             {
-                serializeContext->Class<EditorComponentAdapter, EditorComponentBase>()
-                    ->Version(1)
-                    ->Field("Controller", &EditorComponentAdapter::m_controller)
-                    ;
+                serializeContext->Class<EditorComponentAdapter, EditorComponentBase>()->Version(1)->Field(
+                    "Controller", &EditorComponentAdapter::m_controller);
 
                 if (AZ::EditContext* editContext = serializeContext->GetEditContext())
                 {
-                    editContext->Class<EditorComponentAdapter>(
-                        "EditorComponentAdapter", "")
+                    // clang-format off
+                    editContext->Class<EditorComponentAdapter>("EditorComponentAdapter", "")
                         ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
                             ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
                         ->DataElement(AZ::Edit::UIHandlers::Default, &EditorComponentAdapter::m_controller, "Controller", "")
                             ->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly)
-                            ->Attribute(AZ::Edit::Attributes::ChangeNotify, &EditorComponentAdapter::OnConfigurationChanged)
-                        ;
+                            ->Attribute(AZ::Edit::Attributes::ChangeNotify, &EditorComponentAdapter::OnConfigurationChanged);
+                    // clang-format on
                 }
             }
         }
@@ -53,27 +51,35 @@ namespace AzToolsFramework
         // Get*Services functions
 
         template<typename TController, typename TRuntimeComponent, typename TConfiguration>
-        void EditorComponentAdapter<TController, TRuntimeComponent, TConfiguration>::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+        void EditorComponentAdapter<TController, TRuntimeComponent, TConfiguration>::GetProvidedServices(
+            AZ::ComponentDescriptor::DependencyArrayType& services)
         {
-            AzFramework::Components::GetProvidedServicesHelper<TController>(services, typename AZ::HasComponentProvidedServices<TController>::type());
+            AzFramework::Components::GetProvidedServicesHelper<TController>(
+                services, typename AZ::HasComponentProvidedServices<TController>::type());
         }
 
         template<typename TController, typename TRuntimeComponent, typename TConfiguration>
-        void EditorComponentAdapter<TController, TRuntimeComponent, TConfiguration>::GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+        void EditorComponentAdapter<TController, TRuntimeComponent, TConfiguration>::GetRequiredServices(
+            AZ::ComponentDescriptor::DependencyArrayType& services)
         {
-            AzFramework::Components::GetRequiredServicesHelper<TController>(services, typename AZ::HasComponentRequiredServices<TController>::type());
+            AzFramework::Components::GetRequiredServicesHelper<TController>(
+                services, typename AZ::HasComponentRequiredServices<TController>::type());
         }
 
         template<typename TController, typename TRuntimeComponent, typename TConfiguration>
-        void EditorComponentAdapter<TController, TRuntimeComponent, TConfiguration>::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+        void EditorComponentAdapter<TController, TRuntimeComponent, TConfiguration>::GetIncompatibleServices(
+            AZ::ComponentDescriptor::DependencyArrayType& services)
         {
-            AzFramework::Components::GetIncompatibleServicesHelper<TController>(services, typename AZ::HasComponentIncompatibleServices<TController>::type());
+            AzFramework::Components::GetIncompatibleServicesHelper<TController>(
+                services, typename AZ::HasComponentIncompatibleServices<TController>::type());
         }
 
         template<typename TController, typename TRuntimeComponent, typename TConfiguration>
-        void EditorComponentAdapter<TController, TRuntimeComponent, TConfiguration>::GetDependentServices(AZ::ComponentDescriptor::DependencyArrayType& services)
+        void EditorComponentAdapter<TController, TRuntimeComponent, TConfiguration>::GetDependentServices(
+            AZ::ComponentDescriptor::DependencyArrayType& services)
         {
-            AzFramework::Components::GetDependentServicesHelper<TController>(services, typename AZ::HasComponentDependentServices<TController>::type());
+            AzFramework::Components::GetDependentServicesHelper<TController>(
+                services, typename AZ::HasComponentDependentServices<TController>::type());
         }
 
         //////////////////////////////////////////////////////////////////////////
@@ -99,7 +105,8 @@ namespace AzToolsFramework
 
             if (ShouldActivateController())
             {
-                m_controller.Activate(GetEntityId());
+                AzFramework::Components::ComponentActivateHelper<TController>::Activate(
+                    m_controller, AZ::EntityComponentIdPair(GetEntityId(), GetId()));
             }
         }
 
@@ -122,7 +129,8 @@ namespace AzToolsFramework
         }
 
         template<typename TController, typename TRuntimeComponent, typename TConfiguration>
-        bool EditorComponentAdapter<TController, TRuntimeComponent, TConfiguration>::WriteOutConfig(AZ::ComponentConfig* outBaseConfig) const
+        bool EditorComponentAdapter<TController, TRuntimeComponent, TConfiguration>::WriteOutConfig(
+            AZ::ComponentConfig* outBaseConfig) const
         {
             if (auto config = azrtti_cast<TConfiguration*>(outBaseConfig))
             {
@@ -139,7 +147,8 @@ namespace AzToolsFramework
 
             if (ShouldActivateController())
             {
-                m_controller.Activate(GetEntityId());
+                AzFramework::Components::ComponentActivateHelper<TController>::Activate(
+                    m_controller, AZ::EntityComponentIdPair(GetEntityId(), GetId()));
             }
 
             return AZ::Edit::PropertyRefreshLevels::None;

Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/EditorEntityIconComponent.cpp

@@ -17,6 +17,7 @@
 #include <AzCore/Asset/AssetManagerBus.h>
 
 #include <AzToolsFramework/API/EditorAssetSystemAPI.h>
+#include <AzToolsFramework/API/EditorViewportIconDisplayInterface.h>
 #include <AzToolsFramework/API/ToolsApplicationAPI.h>
 #include <AzToolsFramework/ToolsComponents/EditorVisibilityBus.h>
 #include <AzToolsFramework/ToolsComponents/GenericComponentWrapper.h>
@@ -313,8 +314,7 @@ namespace AzToolsFramework
             // if we do not yet have a valid texture id, request it using the entity icon path
             if (m_entityIconTextureId == 0)
             {
-                EditorRequestBus::BroadcastResult(
-                    m_entityIconTextureId, &EditorRequests::GetIconTextureIdFromEntityIconPath, m_entityIconPath);
+                m_entityIconTextureId = EditorViewportIconDisplay::Get()->GetOrLoadIconForPath(m_entityIconPath);
             }
 
             return m_entityIconTextureId;

Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.cpp

@@ -520,91 +520,13 @@ namespace AzToolsFramework
             return m_editorTransform.m_translate.GetZ();
         }
 
-        void TransformComponent::SetRotation(const AZ::Vector3& eulerAnglesRadians)
+        void TransformComponent::SetWorldRotationQuaternion(const AZ::Quaternion& quaternion)
         {
-            AZ_Warning("AzToolsFramework::TransformComponent", false, "SetRotation is deprecated, please use SetLocalRotation");
-            AZ::Transform newWorldTransform = GetWorldTM();
-            newWorldTransform.SetRotation(AZ::ConvertEulerRadiansToQuaternion(eulerAnglesRadians));
-            SetWorldTM(newWorldTransform);
-        }
-
-        void TransformComponent::SetRotationQuaternion(const AZ::Quaternion& quaternion)
-        {
-            AZ_Warning("AzToolsFramework::TransformComponent", false, "SetRotationQuaternion is deprecated, please use SetLocalRotation");
             AZ::Transform newWorldTransform = GetWorldTM();
             newWorldTransform.SetRotation(quaternion);
             SetWorldTM(newWorldTransform);
         }
 
-        void TransformComponent::SetRotationX(float eulerAngleRadians)
-        {
-            AZ_Warning("AzToolsFramework::TransformComponent", false, "SetRotationX is deprecated, please use SetLocalRotation");
-            AZ::Transform newWorldTransform = GetWorldTM();
-            newWorldTransform.SetRotation(AZ::Quaternion::CreateRotationX(eulerAngleRadians));
-            SetWorldTM(newWorldTransform);
-        }
-
-        void TransformComponent::SetRotationY(float eulerAngleRadians)
-        {
-            AZ_Warning("AzToolsFramework::TransformComponent", false, "SetRotationY is deprecated, please use SetLocalRotation");
-            AZ::Transform newWorldTransform = GetWorldTM();
-            newWorldTransform.SetRotation(AZ::Quaternion::CreateRotationY(eulerAngleRadians));
-            SetWorldTM(newWorldTransform);
-        }
-
-        void TransformComponent::SetRotationZ(float eulerAngleRadians)
-        {
-            AZ_Warning("AzToolsFramework::TransformComponent", false, "SetRotationZ is deprecated, please use SetLocalRotation");
-            AZ::Transform newWorldTransform = GetWorldTM();
-            newWorldTransform.SetRotation(AZ::Quaternion::CreateRotationZ(eulerAngleRadians));
-            SetWorldTM(newWorldTransform);
-        }
-
-        void TransformComponent::RotateByX(float eulerAngleRadians)
-        {
-            AZ_Warning("AzToolsFramework::TransformComponent", false, "RotateByX is deprecated, please use RotateAroundLocalX");
-            SetWorldTM(GetWorldTM() * AZ::Transform::CreateRotationX(eulerAngleRadians));
-        }
-
-        void TransformComponent::RotateByY(float eulerAngleRadians)
-        {
-            AZ_Warning("AzToolsFramework::TransformComponent", false, "RotateByY is deprecated, please use RotateAroundLocalY");
-            SetWorldTM(GetWorldTM() * AZ::Transform::CreateRotationY(eulerAngleRadians));
-        }
-
-        void TransformComponent::RotateByZ(float eulerAngleRadians)
-        {
-            AZ_Warning("AzToolsFramework::TransformComponent", false, "RotateByZ is deprecated, please use RotateAroundLocalZ");
-            SetWorldTM(GetWorldTM() * AZ::Transform::CreateRotationZ(eulerAngleRadians));
-        }
-
-        AZ::Vector3 TransformComponent::GetRotationEulerRadians()
-        {
-            AZ_Warning("AzToolsFramework::TransformComponent", false, "GetRotationEulerRadians is deprecated, please use GetWorldRotation");
-            return GetWorldTM().GetRotation().GetEulerRadians();
-        }
-
-        AZ::Quaternion TransformComponent::GetRotationQuaternion()
-        {
-            AZ_Warning("AzToolsFramework::TransformComponent", false, "GetRotationQuaternion is deprecated, please use GetWorldRotationQuaternion");
-            return GetWorldTM().GetRotation();
-        }
-
-        float TransformComponent::GetRotationX()
-        {
-            return GetRotationEulerRadians().GetX();
-        }
-
-        float TransformComponent::GetRotationY()
-        {
-            return GetRotationEulerRadians().GetY();
-        }
-
-        float TransformComponent::GetRotationZ()
-        {
-            return GetRotationEulerRadians().GetZ();
-        }
-
         AZ::Vector3 TransformComponent::GetWorldRotation()
         {
             return GetWorldTM().GetRotation().GetEulerRadians();

Code/Framework/AzToolsFramework/AzToolsFramework/ToolsComponents/TransformComponent.h

@@ -99,22 +99,7 @@ namespace AzToolsFramework
             float GetLocalZ() override;
 
             // Rotation modifiers
-            void SetRotation(const AZ::Vector3& eulerAnglesRadians) override;
-            void SetRotationQuaternion(const AZ::Quaternion& quaternion) override;
-            void SetRotationX(float eulerAngleRadians) override;
-            void SetRotationY(float eulerAngleRadians) override;
-            void SetRotationZ(float eulerAngleRadians) override;
-
-            void RotateByX(float eulerAngleRadians) override;
-            void RotateByY(float eulerAngleRadians) override;
-            void RotateByZ(float eulerAngleRadians) override;
-
-            AZ::Vector3 GetRotationEulerRadians() override;
-            AZ::Quaternion GetRotationQuaternion() override;
-
-            float GetRotationX() override;
-            float GetRotationY() override;
-            float GetRotationZ() override;
+            void SetWorldRotationQuaternion(const AZ::Quaternion& quaternion) override;
 
             AZ::Vector3 GetWorldRotation() override;
             AZ::Quaternion GetWorldRotationQuaternion() override;

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

@@ -21,6 +21,7 @@
 #include <AzToolsFramework/Viewport/ViewportTypes.h>
 #include <AzToolsFramework/ViewportSelection/EditorVisibleEntityDataCache.h>
 #include <AzToolsFramework/ViewportSelection/EditorSelectionUtil.h>
+#include <AzToolsFramework/API/EditorViewportIconDisplayInterface.h>
 
 AZ_CVAR(
     bool, ed_visibility_showAggregateEntitySelectionBounds, false, nullptr, AZ::ConsoleFunctorFlags::Null,
@@ -232,10 +233,14 @@ namespace AzToolsFramework
                     return AZ::Color(1.0f, 1.0f, 1.0f, 1.0f);
                 }();
 
-                debugDisplay.SetColor(iconHighlight);
-                // debugDisplay.DrawTextureLabel(
-                //     iconTextureId, entityPosition, iconSize, iconSize,
-                //     /*DisplayContext::ETextureIconFlags::TEXICON_ON_TOP=*/ 0x0008);
+                EditorViewportIconDisplay::Get()->DrawIcon({
+                    viewportInfo.m_viewportId,
+                    iconTextureId,
+                    iconHighlight,
+                    entityPosition,
+                    EditorViewportIconDisplayInterface::CoordinateSpace::WorldSpace,
+                    AZ::Vector2{iconSize, iconSize}
+                });
             }
         }
     }

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

@@ -809,14 +809,12 @@ namespace AzToolsFramework
         EntityIdManipulators& entityIdManipulators,
         OptionalFrame& pivotOverrideFrame,
         ViewportInteraction::KeyboardModifiers& prevModifiers,
-        bool& transformChangedInternally, SpaceCluster spaceCluster)
+        bool& transformChangedInternally, const AZStd::optional<ReferenceFrame> spaceLock)
     {
         AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
 
         entityIdManipulators.m_manipulators->SetLocalPosition(action.LocalPosition());
 
-        const ReferenceFrame referenceFrame = spaceCluster.m_spaceLock ? spaceCluster.m_currentSpace : ReferenceFrameFromModifiers(action.m_modifiers);
-
         if (action.m_modifiers.Ctrl())
         {
             // moving with ctrl - setting override
@@ -826,6 +824,8 @@ namespace AzToolsFramework
         }
         else
         {
+            const ReferenceFrame referenceFrame = spaceLock.value_or(ReferenceFrameFromModifiers(action.m_modifiers));
+
             // note: used for parent and world depending on the current reference frame
             const auto pivotOrientation =
                 ETCS::CalculateSelectionPivotOrientation(
@@ -1298,7 +1298,7 @@ namespace AzToolsFramework
         {
             UpdateTranslationManipulator(
                 action, manipulatorEntityIds->m_entityIds, m_entityIdManipulators, m_pivotOverrideFrame, prevModifiers,
-                    m_transformChangedInternally, m_spaceCluster);
+                    m_transformChangedInternally, m_spaceCluster.m_spaceLock);
         });
 
         translationManipulators->InstallLinearManipulatorMouseUpCallback(
@@ -1329,7 +1329,7 @@ namespace AzToolsFramework
         {
             UpdateTranslationManipulator(
                 action, manipulatorEntityIds->m_entityIds, m_entityIdManipulators, m_pivotOverrideFrame, prevModifiers,
-                    m_transformChangedInternally, m_spaceCluster);
+                    m_transformChangedInternally, m_spaceCluster.m_spaceLock);
         });
 
         translationManipulators->InstallPlanarManipulatorMouseUpCallback(
@@ -1359,7 +1359,7 @@ namespace AzToolsFramework
         {
             UpdateTranslationManipulator(
                 action, manipulatorEntityIds->m_entityIds, m_entityIdManipulators, m_pivotOverrideFrame, prevModifiers,
-                    m_transformChangedInternally, m_spaceCluster);
+                    m_transformChangedInternally, m_spaceCluster.m_spaceLock);
         });
 
         translationManipulators->InstallSurfaceManipulatorMouseUpCallback(
@@ -1437,8 +1437,7 @@ namespace AzToolsFramework
             [this, prevModifiers, sharedRotationState]
             (const AngularManipulator::Action& action) mutable -> void
         {
-            const ReferenceFrame referenceFrame = m_spaceCluster.m_spaceLock ? m_spaceCluster.m_currentSpace : ReferenceFrameFromModifiers(action.m_modifiers);
-
+            const ReferenceFrame referenceFrame = m_spaceCluster.m_spaceLock.value_or(ReferenceFrameFromModifiers(action.m_modifiers));
             const AZ::Quaternion manipulatorOrientation = action.m_start.m_rotation * action.m_current.m_delta;
             // store the pivot override frame when positioning the manipulator manually (ctrl)
             // so we don't lose the orientation when adding/removing entities from the selection
@@ -2605,40 +2604,37 @@ namespace AzToolsFramework
             if (buttonId == m_spaceCluster.m_localButtonId)
             {
                 // Unlock
-                if (m_spaceCluster.m_spaceLock && m_spaceCluster.m_currentSpace == ReferenceFrame::Local)
+                if (m_spaceCluster.m_spaceLock.has_value() && m_spaceCluster.m_spaceLock.value() == ReferenceFrame::Local)
                 {
-                    m_spaceCluster.m_spaceLock = false;
+                    m_spaceCluster.m_spaceLock = AZStd::nullopt;
                 }
                 else
                 {
-                    m_spaceCluster.m_spaceLock = true;
-                    m_spaceCluster.m_currentSpace = ReferenceFrame::Local;
+                    m_spaceCluster.m_spaceLock = ReferenceFrame::Local;
                 }
             }
             else if (buttonId == m_spaceCluster.m_parentButtonId)
             {
                 // Unlock
-                if (m_spaceCluster.m_spaceLock && m_spaceCluster.m_currentSpace == ReferenceFrame::Parent)
+                if (m_spaceCluster.m_spaceLock.has_value() && m_spaceCluster.m_spaceLock.value() == ReferenceFrame::Parent)
                 {
-                    m_spaceCluster.m_spaceLock = false;
+                    m_spaceCluster.m_spaceLock = AZStd::nullopt;
                 }
                 else
                 {
-                    m_spaceCluster.m_spaceLock = true;
-                    m_spaceCluster.m_currentSpace = ReferenceFrame::Parent;
+                    m_spaceCluster.m_spaceLock = ReferenceFrame::Parent;
                 }
             }
             else if (buttonId == m_spaceCluster.m_worldButtonId)
             {
                 // Unlock
-                if (m_spaceCluster.m_spaceLock && m_spaceCluster.m_currentSpace == ReferenceFrame::World)
+                if (m_spaceCluster.m_spaceLock.has_value() && m_spaceCluster.m_spaceLock.value() == ReferenceFrame::World)
                 {
-                    m_spaceCluster.m_spaceLock = false;
+                    m_spaceCluster.m_spaceLock = AZStd::nullopt;
                 }
                 else
                 {
-                    m_spaceCluster.m_spaceLock = true;
-                    m_spaceCluster.m_currentSpace = ReferenceFrame::World;
+                    m_spaceCluster.m_spaceLock = ReferenceFrame::World;
                 }
             }
         };
@@ -3361,8 +3357,7 @@ namespace AzToolsFramework
             ViewportInteraction::BuildMouseButtons(
                 QGuiApplication::mouseButtons()), m_boxSelect.Active());
 
-        const ReferenceFrame referenceFrame =
-            m_spaceCluster.m_spaceLock ? m_spaceCluster.m_currentSpace : ReferenceFrameFromModifiers(modifiers);
+        const ReferenceFrame referenceFrame = m_spaceCluster.m_spaceLock.value_or(ReferenceFrameFromModifiers(modifiers));
 
         UpdateSpaceCluster(referenceFrame);
 

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

@@ -106,15 +106,20 @@ namespace AzToolsFramework
         World, //!< World space (space aligned to world axes - identity).
     };
 
+    //! Grouping of viewport ui related state for controlling the current reference space of the Editor.
     struct SpaceCluster
     {
-        ViewportUi::ClusterId m_spaceClusterId;
-        ViewportUi::ButtonId m_localButtonId;
-        ViewportUi::ButtonId m_parentButtonId;
-        ViewportUi::ButtonId m_worldButtonId;
-        AZ::Event<ViewportUi::ButtonId>::Handler m_spaceSelectionHandler;
-        ReferenceFrame m_currentSpace = ReferenceFrame::Parent;
-        bool m_spaceLock = false;
+        SpaceCluster() = default;
+        // disable copying and moving (implicit)
+        SpaceCluster(const SpaceCluster&) = delete;
+        SpaceCluster& operator=(const SpaceCluster&) = delete;
+
+        ViewportUi::ClusterId m_spaceClusterId; //!< The id identifying the reference space cluster.
+        ViewportUi::ButtonId m_localButtonId; //!< Local reference space button id.
+        ViewportUi::ButtonId m_parentButtonId; //!< Parent reference space button id.
+        ViewportUi::ButtonId m_worldButtonId; //!< World reference space button id.
+        AZ::Event<ViewportUi::ButtonId>::Handler m_spaceSelectionHandler; //!< Callback for when a space cluster button is pressed.
+        AZStd::optional<ReferenceFrame> m_spaceLock; //!< Locked reference frame to use if set.
     };
 
     //! Entity selection/interaction handling.
@@ -265,6 +270,9 @@ namespace AzToolsFramework
         void SetEntityLocalScale(AZ::EntityId entityId, float localScale);
         void SetEntityLocalRotation(AZ::EntityId entityId, const AZ::Vector3& localRotation);
 
+        // Responsible for keeping the space cluster in sync with the current reference frame.
+        void UpdateSpaceCluster(ReferenceFrame referenceFrame);
+
         AZ::EntityId m_hoveredEntityId; //!< What EntityId is the mouse currently hovering over (if any).
         AZ::EntityId m_cachedEntityIdUnderCursor; //!< Store the EntityId on each mouse move for use in Display.
         AZ::EntityId m_editorCameraComponentEntityId; //!< The EditorCameraComponent EntityId if it is set.
@@ -297,9 +305,7 @@ namespace AzToolsFramework
         AZ::Event<ViewportUi::ButtonId>::Handler m_transformModeSelectionHandler; //!< Event handler for the Viewport UI cluster.
         AzFramework::ClickDetector m_clickDetector; //!< Detect different types of mouse click.
         AzFramework::CursorState m_cursorState; //!< Track the mouse position and delta movement each frame.
-
-        SpaceCluster m_spaceCluster;
-        void UpdateSpaceCluster(ReferenceFrame referenceFrame);
+        SpaceCluster m_spaceCluster; //!< Related viewport ui state for controlling the current reference space.
     };
 
     //! The ETCS (EntityTransformComponentSelection) namespace contains functions and data used exclusively by

Code/Framework/AzToolsFramework/AzToolsFramework/aztoolsframework_files.cmake

@@ -46,6 +46,7 @@ set(FILES
     API/EditorWindowRequestBus.h
     API/EntityCompositionRequestBus.h
     API/EntityCompositionNotificationBus.h
+    API/EditorViewportIconDisplayInterface.h
     API/ViewPaneOptions.h
     Application/Ticker.h
     Application/Ticker.cpp

Code/Framework/AzToolsFramework/Tests/AssetSeedManager.cpp

@@ -82,7 +82,7 @@ namespace UnitTest
             }
 
             m_testPlatforms[0] = AzFramework::PlatformId::PC;
-            m_testPlatforms[1] = AzFramework::PlatformId::ES3;
+            m_testPlatforms[1] = AzFramework::PlatformId::ANDROID_ID;
 
             int platformCount = 0;
             for(auto thisPlatform : m_testPlatforms)
@@ -170,20 +170,20 @@ namespace UnitTest
             AzFramework::AssetCatalog assetCatalog(useRequestBus);
 
             AZStd::string pcCatalogFile = AzToolsFramework::PlatformAddressedAssetCatalog::GetCatalogRegistryPathForPlatform(AzFramework::PlatformId::PC);
-            AZStd::string es3CatalogFile = AzToolsFramework::PlatformAddressedAssetCatalog::GetCatalogRegistryPathForPlatform(AzFramework::PlatformId::ES3);
+            AZStd::string androidCatalogFile = AzToolsFramework::PlatformAddressedAssetCatalog::GetCatalogRegistryPathForPlatform(AzFramework::PlatformId::ANDROID_ID);
 
             if (!assetCatalog.SaveCatalog(pcCatalogFile.c_str(), m_assetRegistry))
             {
                 GTEST_FATAL_FAILURE_(AZStd::string::format("Unable to save the asset catalog (PC) file.\n").c_str());
             }
 
-            if (!assetCatalog.SaveCatalog(es3CatalogFile.c_str(), m_assetRegistry))
+            if (!assetCatalog.SaveCatalog(androidCatalogFile.c_str(), m_assetRegistry))
             {
-                GTEST_FATAL_FAILURE_(AZStd::string::format("Unable to save the asset catalog (ES3) file.\n").c_str());
+                GTEST_FATAL_FAILURE_(AZStd::string::format("Unable to save the asset catalog (ANDROID) file.\n").c_str());
             }
 
             m_pcCatalog = new AzToolsFramework::PlatformAddressedAssetCatalog(AzFramework::PlatformId::PC);
-            m_es3Catalog = new AzToolsFramework::PlatformAddressedAssetCatalog(AzFramework::PlatformId::ES3);
+            m_androidCatalog = new AzToolsFramework::PlatformAddressedAssetCatalog(AzFramework::PlatformId::ANDROID_ID);
 
             const AZStd::string engroot = AZ::Test::GetEngineRootPath();
             AZ::IO::FileIOBase::GetInstance()->SetAlias("@engroot@", engroot.c_str());
@@ -227,21 +227,21 @@ namespace UnitTest
             }
 
             auto pcCatalogFile = AzToolsFramework::PlatformAddressedAssetCatalog::GetCatalogRegistryPathForPlatform(AzFramework::PlatformId::PC);
-            auto es3CatalogFile = AzToolsFramework::PlatformAddressedAssetCatalog::GetCatalogRegistryPathForPlatform(AzFramework::PlatformId::ES3);
+            auto androidCatalogFile = AzToolsFramework::PlatformAddressedAssetCatalog::GetCatalogRegistryPathForPlatform(AzFramework::PlatformId::ANDROID_ID);
             if (fileIO->Exists(pcCatalogFile.c_str()))
             {
                 fileIO->Remove(pcCatalogFile.c_str());
             }
 
-            if (fileIO->Exists(es3CatalogFile.c_str()))
+            if (fileIO->Exists(androidCatalogFile.c_str()))
             {
-                fileIO->Remove(es3CatalogFile.c_str());
+                fileIO->Remove(androidCatalogFile.c_str());
             }
 
             delete m_assetSeedManager;
             delete m_assetRegistry;
             delete m_pcCatalog;
-            delete m_es3Catalog;
+            delete m_androidCatalog;
             m_application->Stop();
             delete m_application;
         }
@@ -342,10 +342,10 @@ namespace UnitTest
             m_assetSeedManager->AddSeedAsset(assets[2], AzFramework::PlatformFlags::Platform_PC);
 
             // Step we are testing
-            m_assetSeedManager->AddPlatformToAllSeeds(AzFramework::PlatformId::ES3);
+            m_assetSeedManager->AddPlatformToAllSeeds(AzFramework::PlatformId::ANDROID_ID);
 
             // Verification
-            AzFramework::PlatformFlags expectedPlatformFlags = AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ES3;
+            AzFramework::PlatformFlags expectedPlatformFlags = AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ANDROID;
             for (const auto& seedInfo : m_assetSeedManager->GetAssetSeedList())
             {
                 EXPECT_EQ(seedInfo.m_platformFlags, expectedPlatformFlags);
@@ -358,14 +358,14 @@ namespace UnitTest
             m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
             m_assetSeedManager->AddSeedAsset(assets[1], AzFramework::PlatformFlags::Platform_PC);
 
-            m_es3Catalog->UnregisterAsset(assets[2]);
+            m_androidCatalog->UnregisterAsset(assets[2]);
             m_assetSeedManager->AddSeedAsset(assets[2], AzFramework::PlatformFlags::Platform_PC);
 
             // Step we are testing
-            m_assetSeedManager->AddPlatformToAllSeeds(AzFramework::PlatformId::ES3);
+            m_assetSeedManager->AddPlatformToAllSeeds(AzFramework::PlatformId::ANDROID_ID);
 
             // Verification
-            AzFramework::PlatformFlags expectedPlatformFlags = AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ES3;
+            AzFramework::PlatformFlags expectedPlatformFlags = AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ANDROID;
             for (const auto& seedInfo : m_assetSeedManager->GetAssetSeedList())
             {
                 if (seedInfo.m_assetId == assets[2])
@@ -383,14 +383,14 @@ namespace UnitTest
         {
             // Setup
             m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC);
-            m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_ES3);
+            m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_ANDROID);
             m_assetSeedManager->AddSeedAsset(assets[1], AzFramework::PlatformFlags::Platform_PC);
-            m_assetSeedManager->AddSeedAsset(assets[1], AzFramework::PlatformFlags::Platform_ES3);
+            m_assetSeedManager->AddSeedAsset(assets[1], AzFramework::PlatformFlags::Platform_ANDROID);
             m_assetSeedManager->AddSeedAsset(assets[2], AzFramework::PlatformFlags::Platform_PC);
-            m_assetSeedManager->AddSeedAsset(assets[2], AzFramework::PlatformFlags::Platform_ES3);
+            m_assetSeedManager->AddSeedAsset(assets[2], AzFramework::PlatformFlags::Platform_ANDROID);
 
             // Step we are testing
-            m_assetSeedManager->RemovePlatformFromAllSeeds(AzFramework::PlatformId::ES3);
+            m_assetSeedManager->RemovePlatformFromAllSeeds(AzFramework::PlatformId::ANDROID_ID);
 
             // Verification
             for (const auto& seedInfo : m_assetSeedManager->GetAssetSeedList())
@@ -514,8 +514,8 @@ namespace UnitTest
 
         void DependencyValidation_MultipleAssetSeeds_MultiplePlatformFlags_ListValid()
         {
-            m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ES3);
-            m_assetSeedManager->AddSeedAsset(assets[5], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ES3);
+            m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ANDROID);
+            m_assetSeedManager->AddSeedAsset(assets[5], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ANDROID);
 
             AzToolsFramework::AssetFileInfoList assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
 
@@ -531,7 +531,7 @@ namespace UnitTest
 
             assetList.m_fileInfoList.clear();
 
-            m_assetSeedManager->AddSeedAsset(assets[8], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ES3);
+            m_assetSeedManager->AddSeedAsset(assets[8], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ANDROID);
 
             assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
 
@@ -547,7 +547,7 @@ namespace UnitTest
             EXPECT_TRUE(Search(assetList, assets[8]));
 
             assetList.m_fileInfoList.clear();
-            m_assetSeedManager->RemoveSeedAsset(assets[5], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ES3);
+            m_assetSeedManager->RemoveSeedAsset(assets[5], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ANDROID);
 
             assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
 
@@ -562,7 +562,7 @@ namespace UnitTest
             EXPECT_TRUE(Search(assetList, assets[8]));
 
             // Removing the android flag from the asset should still produce the same result 
-            m_assetSeedManager->RemoveSeedAsset(assets[8], AzFramework::PlatformFlags::Platform_ES3);
+            m_assetSeedManager->RemoveSeedAsset(assets[8], AzFramework::PlatformFlags::Platform_ANDROID);
 
             assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::PC);
 
@@ -576,7 +576,7 @@ namespace UnitTest
             EXPECT_TRUE(Search(assetList, assets[7]));
             EXPECT_TRUE(Search(assetList, assets[8]));
 
-            assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::ES3);
+            assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::ANDROID_ID);
 
             EXPECT_EQ(assetList.m_fileInfoList.size(), 5);
             EXPECT_TRUE(Search(assetList, assets[0]));
@@ -586,8 +586,8 @@ namespace UnitTest
             EXPECT_TRUE(Search(assetList, assets[4]));
 
             // Adding the android flag again to the asset 
-            m_assetSeedManager->AddSeedAsset(assets[8], AzFramework::PlatformFlags::Platform_ES3);
-            assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::ES3);
+            m_assetSeedManager->AddSeedAsset(assets[8], AzFramework::PlatformFlags::Platform_ANDROID);
+            assetList = m_assetSeedManager->GetDependencyList(AzFramework::PlatformId::ANDROID_ID);
 
             EXPECT_EQ(assetList.m_fileInfoList.size(), 8);
             EXPECT_TRUE(Search(assetList, assets[0]));
@@ -773,7 +773,7 @@ namespace UnitTest
         AzFramework::AssetRegistry* m_assetRegistry;
         ToolsTestApplication* m_application;
         AzToolsFramework::PlatformAddressedAssetCatalog* m_pcCatalog;
-        AzToolsFramework::PlatformAddressedAssetCatalog* m_es3Catalog;
+        AzToolsFramework::PlatformAddressedAssetCatalog* m_androidCatalog;
         AZ::IO::FileIOStream m_fileStreams[s_totalTestPlatforms][s_totalAssets];
         AzFramework::PlatformId m_testPlatforms[s_totalTestPlatforms];
         AZStd::string m_assetsPath[s_totalAssets];
@@ -936,7 +936,7 @@ namespace UnitTest
     TEST_F(AssetSeedManagerTest, AddSeedAssetForValidPlatforms_AllPlatformsValid_SeedAddedForEveryInputPlatform)
     {
         using namespace AzFramework;
-        PlatformFlags validPlatforms = PlatformFlags::Platform_PC | PlatformFlags::Platform_ES3;
+        PlatformFlags validPlatforms = PlatformFlags::Platform_PC | PlatformFlags::Platform_ANDROID;
         AZStd::pair<AZ::Data::AssetId, PlatformFlags> result = m_assetSeedManager->AddSeedAssetForValidPlatforms(TestDynamicSliceAssetPath, validPlatforms);
 
         // Verify the function outputs
@@ -953,8 +953,8 @@ namespace UnitTest
     TEST_F(AssetSeedManagerTest, AddSeedAssetForValidPlatforms_SomePlatformsValid_SeedAddedForEveryValidPlatform)
     {
         using namespace AzFramework;
-        PlatformFlags validPlatforms = PlatformFlags::Platform_PC | PlatformFlags::Platform_ES3;
-        PlatformFlags inputPlatforms = validPlatforms | PlatformFlags::Platform_OSX;
+        PlatformFlags validPlatforms = PlatformFlags::Platform_PC | PlatformFlags::Platform_ANDROID;
+        PlatformFlags inputPlatforms = validPlatforms | PlatformFlags::Platform_MAC;
         AZStd::pair<AZ::Data::AssetId, PlatformFlags> result = m_assetSeedManager->AddSeedAssetForValidPlatforms(TestDynamicSliceAssetPath, inputPlatforms);
 
         // Verify the function outputs
@@ -971,7 +971,7 @@ namespace UnitTest
     TEST_F(AssetSeedManagerTest, AddSeedAssetForValidPlatforms_NoPlatformsValid_NoSeedAdded)
     {
         using namespace AzFramework;
-        PlatformFlags inputPlatforms = PlatformFlags::Platform_OSX;
+        PlatformFlags inputPlatforms = PlatformFlags::Platform_MAC;
         AZStd::pair<AZ::Data::AssetId, PlatformFlags> result = m_assetSeedManager->AddSeedAssetForValidPlatforms(TestDynamicSliceAssetPath, inputPlatforms);
 
         // Verify the function outputs
@@ -985,30 +985,30 @@ namespace UnitTest
 
     TEST_F(AssetSeedManagerTest, Valid_Seed_Remove_ForAllPlatform_OK)
     {
-        m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_OSX);
+        m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
 
-        m_assetSeedManager->RemoveSeedAsset(assets[0].ToString<AZStd::string>(), AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_OSX);
+        m_assetSeedManager->RemoveSeedAsset(assets[0].ToString<AZStd::string>(), AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
         const AzFramework::AssetSeedList& seedList = m_assetSeedManager->GetAssetSeedList();
 
         EXPECT_EQ(seedList.size(), 0);
 
-        m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_OSX);
+        m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
 
-        m_assetSeedManager->RemoveSeedAsset("asset0.txt", AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_OSX);
+        m_assetSeedManager->RemoveSeedAsset("asset0.txt", AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
         const AzFramework::AssetSeedList& secondSeedList = m_assetSeedManager->GetAssetSeedList();
         EXPECT_EQ(secondSeedList.size(), 0);
     }
 
     TEST_F(AssetSeedManagerTest, Valid_Seed_Remove_ForSpecificPlatform_OK)
     {
-        m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_OSX);
+        m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
 
-        m_assetSeedManager->RemoveSeedAsset(assets[0].ToString<AZStd::string>(), AzFramework::PlatformFlags::Platform_OSX);
+        m_assetSeedManager->RemoveSeedAsset(assets[0].ToString<AZStd::string>(), AzFramework::PlatformFlags::Platform_MAC);
         const AzFramework::AssetSeedList& seedList = m_assetSeedManager->GetAssetSeedList();
 
         EXPECT_EQ(seedList.size(), 1);
 
-        m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_OSX);
+        m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
 
         m_assetSeedManager->RemoveSeedAsset("asset0.txt", AzFramework::PlatformFlags::Platform_PC);
         const AzFramework::AssetSeedList& secondSeedList = m_assetSeedManager->GetAssetSeedList();
@@ -1017,14 +1017,14 @@ namespace UnitTest
 
     TEST_F(AssetSeedManagerTest, Invalid_NotRemove_SeedForAllPlatform_Ok)
     {
-        m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_OSX);
+        m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
 
-        m_assetSeedManager->RemoveSeedAsset(assets[1].ToString<AZStd::string>(), AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_OSX);
+        m_assetSeedManager->RemoveSeedAsset(assets[1].ToString<AZStd::string>(), AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
         const AzFramework::AssetSeedList& seedList = m_assetSeedManager->GetAssetSeedList();
 
         EXPECT_EQ(seedList.size(), 1);
 
-        m_assetSeedManager->RemoveSeedAsset("asset1.txt", AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_OSX);
+        m_assetSeedManager->RemoveSeedAsset("asset1.txt", AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_MAC);
         const AzFramework::AssetSeedList& secondSeedList = m_assetSeedManager->GetAssetSeedList();
         EXPECT_EQ(secondSeedList.size(), 1);
     }

Code/Framework/AzToolsFramework/Tests/PlatformAddressedAssetCatalogTests.cpp

@@ -184,13 +184,13 @@ namespace UnitTest
     TEST_F(PlatformAddressedAssetCatalogManagerTest, PlatformAddressedAssetCatalogManager_CatalogExistsChecks_Success)
     {
 
-        EXPECT_EQ(AzToolsFramework::PlatformAddressedAssetCatalog::CatalogExists(AzFramework::PlatformId::ES3), true);
-        AZStd::string es3CatalogPath = AzToolsFramework::PlatformAddressedAssetCatalog::GetCatalogRegistryPathForPlatform(AzFramework::PlatformId::ES3);
-        if (AZ::IO::FileIOBase::GetInstance()->Exists(es3CatalogPath.c_str()))
+        EXPECT_EQ(AzToolsFramework::PlatformAddressedAssetCatalog::CatalogExists(AzFramework::PlatformId::ANDROID_ID), true);
+        AZStd::string androidCatalogPath = AzToolsFramework::PlatformAddressedAssetCatalog::GetCatalogRegistryPathForPlatform(AzFramework::PlatformId::ANDROID_ID);
+        if (AZ::IO::FileIOBase::GetInstance()->Exists(androidCatalogPath.c_str()))
         {
-            AZ::IO::FileIOBase::GetInstance()->Remove(es3CatalogPath.c_str());
+            AZ::IO::FileIOBase::GetInstance()->Remove(androidCatalogPath.c_str());
         }
-        EXPECT_EQ(AzToolsFramework::PlatformAddressedAssetCatalog::CatalogExists(AzFramework::PlatformId::ES3), false);
+        EXPECT_EQ(AzToolsFramework::PlatformAddressedAssetCatalog::CatalogExists(AzFramework::PlatformId::ANDROID_ID), false);
     }
 
     class PlatformAddressedAssetCatalogMessageTest : public AzToolsFramework::PlatformAddressedAssetCatalog
@@ -251,7 +251,7 @@ namespace UnitTest
         AzFramework::AssetSystem::NetworkAssetUpdateInterface* notificationInterface = AZ::Interface<AzFramework::AssetSystem::NetworkAssetUpdateInterface>::Get();
         EXPECT_NE(notificationInterface, nullptr);
 
-        auto* mockCatalog = new ::testing::NiceMock<PlatformAddressedAssetCatalogMessageTest>(AzFramework::PlatformId::ES3);
+        auto* mockCatalog = new ::testing::NiceMock<PlatformAddressedAssetCatalogMessageTest>(AzFramework::PlatformId::ANDROID_ID);
         AZStd::unique_ptr< ::testing::NiceMock<PlatformAddressedAssetCatalogMessageTest>> catalogHolder;
         catalogHolder.reset(mockCatalog);
 
@@ -259,7 +259,7 @@ namespace UnitTest
         EXPECT_CALL(*mockCatalog, AssetChanged(testing::_)).Times(0);
         notificationInterface->AssetChanged(testMessage);
 
-        testMessage.m_platform = "es3";
+        testMessage.m_platform = "android";
         EXPECT_CALL(*mockCatalog, AssetChanged(testing::_)).Times(1);
         notificationInterface->AssetChanged(testMessage);
 
@@ -270,7 +270,7 @@ namespace UnitTest
         EXPECT_CALL(*mockCatalog, AssetRemoved(testing::_)).Times(0);
         notificationInterface->AssetRemoved(testMessage);
 
-        testMessage.m_platform = "es3";
+        testMessage.m_platform = "android";
         EXPECT_CALL(*mockCatalog, AssetRemoved(testing::_)).Times(1);
         notificationInterface->AssetRemoved(testMessage);
     }

Code/Framework/Tests/PlatformHelper.cpp

@@ -30,11 +30,11 @@ TEST_F(PlatformHelperTest, SinglePlatformFlags_PlatformId_Valid)
 
 TEST_F(PlatformHelperTest, MultiplePlatformFlags_PlatformId_Valid)
 {
-    AzFramework::PlatformFlags platformFlags = AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ES3;
+    AzFramework::PlatformFlags platformFlags = AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_ANDROID;
     auto platforms = AzFramework::PlatformHelper::GetPlatforms(platformFlags);
     EXPECT_EQ(platforms.size(), 2);
     EXPECT_EQ(platforms[0], "pc");
-    EXPECT_EQ(platforms[1], "es3");
+    EXPECT_EQ(platforms[1], "android");
 }
 
 TEST_F(PlatformHelperTest, SpecialAllFlag_PlatformId_Valid)
@@ -42,7 +42,7 @@ TEST_F(PlatformHelperTest, SpecialAllFlag_PlatformId_Valid)
     AzFramework::PlatformFlags platformFlags = AzFramework::PlatformFlags::Platform_ALL;
     auto platforms = AzFramework::PlatformHelper::GetPlatformsInterpreted(platformFlags);
     EXPECT_EQ(platforms.size(), AzFramework::NumPlatforms);
-    EXPECT_THAT(platforms, testing::UnorderedElementsAre("pc", "es3", "ios", "osx_gl", "provo", "salem", "jasper", "server"));
+    EXPECT_THAT(platforms, testing::UnorderedElementsAre("pc", "android", "ios", "mac", "provo", "salem", "jasper", "server"));
 }
 
 TEST_F(PlatformHelperTest, SpecialAllClientFlag_PlatformId_Valid)
@@ -50,7 +50,7 @@ TEST_F(PlatformHelperTest, SpecialAllClientFlag_PlatformId_Valid)
     AzFramework::PlatformFlags platformFlags = AzFramework::PlatformFlags::Platform_ALL_CLIENT;
     auto platforms = AzFramework::PlatformHelper::GetPlatformsInterpreted(platformFlags);
     EXPECT_EQ(platforms.size(), AzFramework::NumClientPlatforms);
-    EXPECT_THAT(platforms, testing::UnorderedElementsAre("pc", "es3", "ios", "osx_gl", "provo", "salem", "jasper"));
+    EXPECT_THAT(platforms, testing::UnorderedElementsAre("pc", "android", "ios", "mac", "provo", "salem", "jasper"));
 }
 
 TEST_F(PlatformHelperTest, InvalidPlatformFlags_PlatformId_Empty)