Merge branch 'main' into Prefab/CreatePrefab

Code/CryEngine/CryCommon/IMovieSystem.h

@@ -19,6 +19,7 @@
 #include <AzCore/Component/EntityId.h>
 #include <AzCore/Math/Crc.h>
 #include <AzCore/Math/Quaternion.h>
+#include <AzCore/Serialization/SerializeContext.h>
 
 #include <Range.h>
 #include <AnimKey.h>
@@ -914,9 +915,18 @@ struct IAnimStringTable
  */
 struct IAnimSequence
 {
-    AZ_RTTI(IAnimSequence, "{A60F95F5-5A4A-47DB-B3BB-525BBC0BC8DB}")
+    AZ_RTTI(IAnimSequence, "{A60F95F5-5A4A-47DB-B3BB-525BBC0BC8DB}");
+    AZ_CLASS_ALLOCATOR(IAnimSequence, AZ::SystemAllocator, 0);
 
-    static const int kSequenceVersion = 4;
+    static const int kSequenceVersion = 5;
+
+    static void Reflect(AZ::ReflectContext* context)
+    {
+        if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context); serializeContext != nullptr)
+        {
+            serializeContext->Class<IAnimSequence>();
+        }
+    }
 
     //! Flags used for SetFlags(),GetFlags(),SetParentFlags(),GetParentFlags() methods.
     enum EAnimSequenceFlags

Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp

@@ -178,14 +178,16 @@ namespace AZ
     //! on an update to '/Amazon/AzCore/Bootstrap/project_path' key.
     struct UpdateProjectSettingsEventHandler
     {
-        UpdateProjectSettingsEventHandler(AZ::SettingsRegistryInterface& registry)
+        UpdateProjectSettingsEventHandler(AZ::SettingsRegistryInterface& registry, AZ::CommandLine& commandLine)
             : m_registry{ registry }
+            , m_commandLine{ commandLine }
         {
         }
 
         void operator()(AZStd::string_view path, AZ::SettingsRegistryInterface::Type)
         {
             using FixedValueString = AZ::SettingsRegistryInterface::FixedValueString;
+            // #1 Update the project settings when the project path is set
             const auto projectPathKey = FixedValueString(AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey) + "/project_path";
             AZ::IO::FixedMaxPath newProjectPath;
             if (SettingsRegistryMergeUtils::IsPathAncestorDescendantOrEqual(projectPathKey, path)
@@ -194,6 +196,7 @@ namespace AZ
                 UpdateProjectSettingsFromProjectPath(AZ::IO::PathView(newProjectPath));
             }
 
+            // #2 Update the project specialization when the project name is set
             const auto projectNameKey = FixedValueString(AZ::SettingsRegistryMergeUtils::ProjectSettingsRootKey) + "/project_name";
             FixedValueString newProjectName;
             if (SettingsRegistryMergeUtils::IsPathAncestorDescendantOrEqual(projectNameKey, path)
@@ -201,6 +204,12 @@ namespace AZ
             {
                 UpdateProjectSpecializationFromProjectName(newProjectName);
             }
+
+            // #3 Update the ComponentApplication CommandLine instance when the command line settings are merged into the Settings Registry
+            if (path == AZ::SettingsRegistryMergeUtils::CommandLineValueChangedKey)
+            {
+                UpdateCommandLine();
+            }
         }
 
         //! Add the project name as a specialization underneath the /Amazon/AzCore/Settings/Specializations path
@@ -233,10 +242,16 @@ namespace AZ
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(m_registry);
         }
 
+        void UpdateCommandLine()
+        {
+            AZ::SettingsRegistryMergeUtils::GetCommandLineFromRegistry(m_registry, m_commandLine);
+        }
+
     private:
         AZ::IO::FixedMaxPath m_oldProjectPath;
         AZ::SettingsRegistryInterface::FixedValueString m_oldProjectName;
         AZ::SettingsRegistryInterface& m_registry;
+        AZ::CommandLine& m_commandLine;
     };
 
     void ComponentApplication::Descriptor::AllocatorRemapping::Reflect(ReflectContext* context, ComponentApplication* app)
@@ -415,6 +430,12 @@ namespace AZ
         // Add the Command Line arguments into the SettingsRegistry
         SettingsRegistryMergeUtils::StoreCommandLineToRegistry(*m_settingsRegistry, m_commandLine);
 
+        // Add a notifier to update the project_settings when
+        // 1. The 'project_path' key changes
+        // 2. The project specialization when the 'project-name' key changes
+        // 3. The ComponentApplication command line when the command line is stored to the registry
+        m_projectChangedHandler = m_settingsRegistry->RegisterNotifier(UpdateProjectSettingsEventHandler{ *m_settingsRegistry, m_commandLine });
+
         // Merge Command Line arguments
         constexpr bool executeRegDumpCommands = false;
         SettingsRegistryMergeUtils::MergeSettingsToRegistry_CommandLine(*m_settingsRegistry, m_commandLine, executeRegDumpCommands);
@@ -429,10 +450,6 @@ namespace AZ
         // for the application root.
         CalculateAppRoot();
 
-        // Add a notifier to update the /Amazon/AzCore/Settings/Specializations
-        // when the 'project_path' property changes within the SettingsRegistry
-        m_projectChangedHandler = m_settingsRegistry->RegisterNotifier(UpdateProjectSettingsEventHandler{ *m_settingsRegistry });
-
         // Merge the bootstrap.cfg file into the Settings Registry as soon as the OSAllocator has been created.
         SettingsRegistryMergeUtils::MergeSettingsToRegistry_Bootstrap(*m_settingsRegistry);
         SettingsRegistryMergeUtils::MergeSettingsToRegistry_O3deUserRegistry(*m_settingsRegistry, AZ_TRAIT_OS_PLATFORM_CODENAME, {});
@@ -909,6 +926,8 @@ namespace AZ
         SettingsRegistryMergeUtils::MergeSettingsToRegistry_ProjectUserRegistry(registry, AZ_TRAIT_OS_PLATFORM_CODENAME, specializations, &scratchBuffer);
         SettingsRegistryMergeUtils::MergeSettingsToRegistry_CommandLine(registry, m_commandLine, true);
 #endif
+        // Update the Runtime file paths in case the "{BootstrapSettingsRootKey}/assets" key was overriden by a setting registry
+        AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(registry);
     }
 
     void ComponentApplication::SetSettingsRegistrySpecializations(SettingsRegistryInterface::Specializations& specializations)

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

@@ -0,0 +1,340 @@
+/*
+* 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 <AzCore/Casting/numeric_cast.h>
+#include <AzCore/PlatformId/PlatformDefaults.h>
+
+#include <AzCore/StringFunc/StringFunc.h>
+
+namespace AZ
+{
+    inline namespace PlatformDefaults
+    {
+        static const char* PlatformNames[PlatformId::NumPlatformIds] = { PlatformPC, PlatformES3, PlatformIOS, PlatformOSX, PlatformProvo, PlatformSalem, PlatformJasper, PlatformServer, PlatformAll, PlatformAllClient };
+
+        const char* PlatformIdToPalFolder(AZ::PlatformId platform)
+        {
+#ifdef IOS
+#define AZ_REDEFINE_IOS_AT_END IOS
+#undef IOS
+#endif
+            switch (platform)
+            {
+            case AZ::PC:
+                return "PC";
+            case AZ::ES3:
+                return "Android";
+            case AZ::IOS:
+                return "iOS";
+            case AZ::OSX:
+                return "Mac";
+            case AZ::PROVO:
+                return "Provo";
+            case AZ::SALEM:
+                return "Salem";
+            case AZ::JASPER:
+                return "Jasper";
+            case AZ::SERVER:
+                return "Server";
+            case AZ::ALL:
+            case AZ::ALL_CLIENT:
+            case AZ::NumPlatformIds:
+            case AZ::Invalid:
+            default:
+                return "";
+            }
+
+#ifdef AZ_REDEFINE_IOS_AT_END
+#define IOS AZ_REDEFINE_IOS_AT_END
+#endif
+        }
+
+        const char* OSPlatformToDefaultAssetPlatform(AZStd::string_view osPlatform)
+        {
+            if (osPlatform == PlatformCodeNameWindows || osPlatform == PlatformCodeNameLinux)
+            {
+                return PlatformPC;
+            }
+            else if (osPlatform == PlatformCodeNameMac)
+            {
+                return PlatformOSX;
+            }
+            else if (osPlatform == PlatformCodeNameAndroid)
+            {
+                return PlatformES3;
+            }
+            else if (osPlatform == PlatformCodeNameiOS)
+            {
+                return PlatformIOS;
+            }
+            else if (osPlatform == PlatformCodeNameProvo)
+            {
+                return PlatformProvo;
+            }
+            else if (osPlatform == PlatformCodeNameSalem)
+            {
+                return PlatformSalem;
+            }
+            else if (osPlatform == PlatformCodeNameJasper)
+            {
+                return PlatformJasper;
+            }
+
+            AZ_Error("PlatformDefault", false, R"(Supplied OS platform "%.*s" does not have a corresponding default asset platform)",
+                aznumeric_cast<int>(osPlatform.size()), osPlatform.data());
+            return "";
+        }
+
+        PlatformFlags PlatformHelper::GetPlatformFlagFromPlatformIndex(PlatformId platformIndex)
+        {
+            if (platformIndex < 0 || platformIndex > PlatformId::NumPlatformIds)
+            {
+                return PlatformFlags::Platform_NONE;
+            }
+            if (platformIndex == PlatformId::ALL)
+            {
+                return PlatformFlags::Platform_ALL;
+            }
+            if (platformIndex == PlatformId::ALL_CLIENT)
+            {
+                return PlatformFlags::Platform_ALL_CLIENT;
+            }
+            return static_cast<PlatformFlags>(1 << platformIndex);
+        }
+
+        AZStd::fixed_vector<AZStd::string_view, PlatformId::NumPlatformIds> PlatformHelper::GetPlatforms(PlatformFlags platformFlags)
+        {
+            AZStd::fixed_vector<AZStd::string_view, PlatformId::NumPlatformIds> platforms;
+            for (int platformNum = 0; platformNum < PlatformId::NumPlatformIds; ++platformNum)
+            {
+                const bool isAllPlatforms = PlatformId::ALL == static_cast<PlatformId>(platformNum)
+                    && ((platformFlags & PlatformFlags::Platform_ALL) != PlatformFlags::Platform_NONE);
+
+                const bool isAllClientPlatforms = PlatformId::ALL_CLIENT == static_cast<PlatformId>(platformNum)
+                    && ((platformFlags & PlatformFlags::Platform_ALL_CLIENT) != PlatformFlags::Platform_NONE);
+
+                if (isAllPlatforms || isAllClientPlatforms
+                    || (platformFlags & static_cast<PlatformFlags>(1 << platformNum)) != PlatformFlags::Platform_NONE)
+                {
+                    platforms.push_back(PlatformNames[platformNum]);
+                }
+            }
+
+            return platforms;
+        }
+
+        AZStd::fixed_vector<AZStd::string_view, PlatformId::NumPlatformIds> PlatformHelper::GetPlatformsInterpreted(PlatformFlags platformFlags)
+        {
+            return GetPlatforms(GetPlatformFlagsInterpreted(platformFlags));
+        }
+
+        AZStd::fixed_vector<PlatformId, PlatformId::NumPlatformIds> PlatformHelper::GetPlatformIndices(PlatformFlags platformFlags)
+        {
+            AZStd::fixed_vector<PlatformId, PlatformId::NumPlatformIds> platformIndices;
+            for (int i = 0; i < PlatformId::NumPlatformIds; i++)
+            {
+                PlatformId index = static_cast<PlatformId>(i);
+                if ((GetPlatformFlagFromPlatformIndex(index) & platformFlags) != PlatformFlags::Platform_NONE)
+                {
+                    platformIndices.emplace_back(index);
+                }
+            }
+            return platformIndices;
+        }
+
+        AZStd::fixed_vector<PlatformId, PlatformId::NumPlatformIds> PlatformHelper::GetPlatformIndicesInterpreted(PlatformFlags platformFlags)
+        {
+            return GetPlatformIndices(GetPlatformFlagsInterpreted(platformFlags));
+        }
+
+        PlatformFlags PlatformHelper::GetPlatformFlag(AZStd::string_view platform)
+        {
+            int platformIndex = GetPlatformIndexFromName(platform);
+            if (platformIndex == PlatformId::Invalid)
+            {
+                AZ_Error("PlatformDefault", false, "Invalid Platform ( %.*s ).\n", static_cast<int>(platform.length()), platform.data());
+                return PlatformFlags::Platform_NONE;
+            }
+
+            if (platformIndex == PlatformId::ALL)
+            {
+                return PlatformFlags::Platform_ALL;
+            }
+
+            if (platformIndex == PlatformId::ALL_CLIENT)
+            {
+                return PlatformFlags::Platform_ALL_CLIENT;
+            }
+
+            return static_cast<PlatformFlags>(1 << platformIndex);
+        }
+
+        const char* PlatformHelper::GetPlatformName(PlatformId platform)
+        {
+            if (platform < 0 || platform > PlatformId::NumPlatformIds)
+            {
+                return "invalid";
+            }
+            return PlatformNames[platform];
+        }
+
+        void PlatformHelper::AppendPlatformCodeNames(AZStd::fixed_vector<AZStd::string_view, MaxPlatformCodeNames>& platformCodes, AZStd::string_view platformId)
+        {
+            PlatformId platform = GetPlatformIdFromName(platformId);
+            AZ_Assert(platform != PlatformId::Invalid, "Unsupported Platform ID: %.*s", static_cast<int>(platformId.length()), platformId.data());
+            AppendPlatformCodeNames(platformCodes, platform);
+        }
+
+        void PlatformHelper::AppendPlatformCodeNames(AZStd::fixed_vector<AZStd::string_view, MaxPlatformCodeNames>& platformCodes, PlatformId platformId)
+        {
+            // The IOS SDK has a macro that defines IOS as 1 which causes the enum below to be incorrectly converted to "PlatformId::1".
+#pragma push_macro("IOS")
+#undef IOS
+        // To reduce work the Asset Processor groups assets that can be shared between hardware platforms together. For this
+        // reason "PC" can for instance cover both the Windows and Linux platforms and "IOS" can cover AppleTV and iOS.
+            switch (platformId)
+            {
+            case PlatformId::PC:
+                platformCodes.emplace_back(PlatformCodeNameWindows);
+                platformCodes.emplace_back(PlatformCodeNameLinux);
+                break;
+            case PlatformId::ES3:
+                platformCodes.emplace_back(PlatformCodeNameAndroid);
+                break;
+            case PlatformId::IOS:
+                platformCodes.emplace_back(PlatformCodeNameiOS);
+                break;
+            case PlatformId::OSX:
+                platformCodes.emplace_back(PlatformCodeNameMac);
+                break;
+            case PlatformId::PROVO:
+                platformCodes.emplace_back(PlatformCodeNameProvo);
+                break;
+            case PlatformId::SALEM:
+                platformCodes.emplace_back(PlatformCodeNameSalem);
+                break;
+            case PlatformId::JASPER:
+                platformCodes.emplace_back(PlatformCodeNameJasper);
+                break;
+            case PlatformId::SERVER:
+                // Server is not a hardware platform
+                break;
+            default:
+                AZ_Assert(false, "Unsupported Platform ID: %i", platformId);
+                break;
+            }
+#pragma pop_macro("IOS")
+        }
+
+        int PlatformHelper::GetPlatformIndexFromName(AZStd::string_view platformName)
+        {
+            for (int idx = 0; idx < PlatformId::NumPlatformIds; idx++)
+            {
+                if (platformName == PlatformNames[idx])
+                {
+                    return idx;
+                }
+            }
+
+            return PlatformId::Invalid;
+        }
+
+        PlatformId PlatformHelper::GetPlatformIdFromName(AZStd::string_view platformName)
+        {
+            return aznumeric_caster(GetPlatformIndexFromName(platformName));
+        }
+
+        AssetPlatformCombinedString PlatformHelper::GetCommaSeparatedPlatformList(PlatformFlags platformFlags)
+        {
+            AZStd::fixed_vector<AZStd::string_view, PlatformId::NumPlatformIds> platformNames = GetPlatforms(platformFlags);
+            AssetPlatformCombinedString platformsString;
+            AZ::StringFunc::Join(platformsString, platformNames.begin(), platformNames.end(), ", ");
+            return platformsString;
+        }
+
+        PlatformFlags PlatformHelper::GetPlatformFlagsInterpreted(PlatformFlags platformFlags)
+        {
+            PlatformFlags returnFlags = PlatformFlags::Platform_NONE;
+
+            if ((platformFlags & PlatformFlags::Platform_ALL) != PlatformFlags::Platform_NONE)
+            {
+                for (int i = 0; i < NumPlatforms; ++i)
+                {
+                    auto platformId = static_cast<PlatformId>(i);
+
+                    if (platformId != PlatformId::ALL && platformId != PlatformId::ALL_CLIENT)
+                    {
+                        returnFlags |= GetPlatformFlagFromPlatformIndex(platformId);
+                    }
+                }
+            }
+            else if ((platformFlags & PlatformFlags::Platform_ALL_CLIENT) != PlatformFlags::Platform_NONE)
+            {
+                for (int i = 0; i < NumPlatforms; ++i)
+                {
+                    auto platformId = static_cast<PlatformId>(i);
+
+                    if (platformId != PlatformId::ALL && platformId != PlatformId::ALL_CLIENT && platformId != PlatformId::SERVER)
+                    {
+                        returnFlags |= GetPlatformFlagFromPlatformIndex(platformId);
+                    }
+                }
+            }
+            else
+            {
+                returnFlags = platformFlags;
+            }
+
+            return returnFlags;
+        }
+
+        bool PlatformHelper::IsSpecialPlatform(PlatformFlags platformFlags)
+        {
+            return (platformFlags & PlatformFlags::Platform_ALL) != PlatformFlags::Platform_NONE
+                || (platformFlags & PlatformFlags::Platform_ALL_CLIENT) != PlatformFlags::Platform_NONE;
+        }
+
+        bool HasFlagHelper(PlatformFlags flags, PlatformFlags checkPlatform)
+        {
+            return (flags & checkPlatform) == checkPlatform;
+        }
+
+
+        bool PlatformHelper::HasPlatformFlag(PlatformFlags flags, PlatformId checkPlatform)
+        {
+            // If checkPlatform contains any kind of invalid id, just exit out here
+            if (checkPlatform == PlatformId::Invalid || checkPlatform == NumPlatforms)
+            {
+                return false;
+            }
+
+            // ALL_CLIENT + SERVER = ALL
+            if (HasFlagHelper(flags, PlatformFlags::Platform_ALL_CLIENT | PlatformFlags::Platform_SERVER))
+            {
+                flags = PlatformFlags::Platform_ALL;
+            }
+
+            if (HasFlagHelper(flags, PlatformFlags::Platform_ALL))
+            {
+                // It doesn't matter what checkPlatform is set to in this case, just return true
+                return true;
+            }
+
+            if (HasFlagHelper(flags, PlatformFlags::Platform_ALL_CLIENT))
+            {
+                return checkPlatform != PlatformId::SERVER;
+            }
+
+            return HasFlagHelper(flags, GetPlatformFlagFromPlatformIndex(checkPlatform));
+        }
+    }
+}

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

@@ -0,0 +1,157 @@
+/*
+* 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/Preprocessor/Enum.h>
+#include <AzCore/std/containers/fixed_vector.h>
+#include <AzCore/std/containers/unordered_map.h>
+#include <AzCore/std/string/fixed_string.h>
+#include <AzCore/std/string/string_view.h>
+
+// On IOS builds IOS will be defined and interfere with the below enums
+#pragma push_macro("IOS")
+#undef IOS
+
+namespace AZ
+{
+    inline namespace PlatformDefaults
+    {
+        constexpr char PlatformPC[] = "pc";
+        constexpr char PlatformES3[] = "es3";
+        constexpr char PlatformIOS[] = "ios";
+        constexpr char PlatformOSX[] = "osx_gl";
+        constexpr char PlatformProvo[] = "provo";
+        constexpr char PlatformSalem[] = "salem";
+        constexpr char PlatformJasper[] = "jasper";
+        constexpr char PlatformServer[] = "server";
+
+        constexpr char PlatformCodeNameWindows[] = "Windows";
+        constexpr char PlatformCodeNameLinux[] = "Linux";
+        constexpr char PlatformCodeNameAndroid[] = "Android";
+        constexpr char PlatformCodeNameiOS[] = "iOS";
+        constexpr char PlatformCodeNameMac[] = "Mac";
+        constexpr char PlatformCodeNameProvo[] = "Provo";
+        constexpr char PlatformCodeNameSalem[] = "Salem";
+        constexpr char PlatformCodeNameJasper[] = "Jasper";
+        constexpr char PlatformAll[] = "all";
+        constexpr char PlatformAllClient[] = "all_client";
+
+        // Used for the capacity of a fixed vector to store the code names of platforms
+        // The value needs to be higher than the number of unique OS platforms that are supported(at this time 8)
+        constexpr size_t MaxPlatformCodeNames = 16;
+
+        //! This platform enum have platform values in sequence and can also be used to get the platform count.
+        AZ_ENUM_WITH_UNDERLYING_TYPE(PlatformId, int,
+            (Invalid, -1),
+            PC,
+            ES3,
+            IOS,
+            OSX,
+            PROVO,
+            SALEM,
+            JASPER,
+            SERVER, // Corresponds to the customer's flavor of "server" which could be windows, ubuntu, etc
+            ALL,
+            ALL_CLIENT,
+
+            // Add new platforms above this
+            NumPlatformIds
+        );
+        constexpr int NumClientPlatforms = 7;
+        constexpr int NumPlatforms = NumClientPlatforms + 1; // 1 "Server" platform currently
+        enum class PlatformFlags : AZ::u32
+        {
+            Platform_NONE = 0x00,
+            Platform_PC = 1 << PlatformId::PC,
+            Platform_ES3 = 1 << PlatformId::ES3,
+            Platform_IOS = 1 << PlatformId::IOS,
+            Platform_OSX = 1 << PlatformId::OSX,
+            Platform_PROVO = 1 << PlatformId::PROVO,
+            Platform_SALEM = 1 << PlatformId::SALEM,
+            Platform_JASPER = 1 << PlatformId::JASPER,
+            Platform_SERVER = 1 << PlatformId::SERVER,
+
+            // A special platform that will always correspond to all platforms, even if new ones are added
+            Platform_ALL = 1ULL << 30,
+
+            // 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,
+        };
+
+        AZ_DEFINE_ENUM_BITWISE_OPERATORS(PlatformFlags);
+
+        // 32 characters should be more than enough to store a platform name
+        using AssetPlatformFixedString = AZStd::fixed_string<32>;
+        // Fixed string which can store a comma separated list of platforms names
+        // Additional byte is added to take into account the comma
+        using AssetPlatformCombinedString = AZStd::fixed_string < (AssetPlatformFixedString{}.max_size() + 1)* PlatformId::NumPlatformIds > ;
+
+        const char* PlatformIdToPalFolder(PlatformId platform);
+
+        const char* OSPlatformToDefaultAssetPlatform(AZStd::string_view osPlatform);
+
+        //! Platform Helper is an utility class that can be used to retrieve platform related information
+        class PlatformHelper
+        {
+        public:
+
+            //! Given a platformIndex returns the platform name
+            static const char* GetPlatformName(PlatformId platform);
+
+            //! Converts the platform name to the platform code names as defined in AZ_TRAIT_OS_PLATFORM_CODENAME.
+            static void AppendPlatformCodeNames(AZStd::fixed_vector<AZStd::string_view, MaxPlatformCodeNames>& platformCodes, AZStd::string_view platformName);
+
+            //! Converts the platform name to the platform code names as defined in AZ_TRAIT_OS_PLATFORM_CODENAME.
+            static void AppendPlatformCodeNames(AZStd::fixed_vector<AZStd::string_view, MaxPlatformCodeNames>& platformCodes, PlatformId platformId);
+
+            //! Given a platform name returns a platform index. 
+            //! If the platform is not found, the method returns -1. 
+            static int GetPlatformIndexFromName(AZStd::string_view platformName);
+
+            //! Given a platform name returns a platform id. 
+            //! If the platform is not found, the method returns -1. 
+            static PlatformId GetPlatformIdFromName(AZStd::string_view platformName);
+
+            //! Given a platformIndex returns the platformFlags
+            static PlatformFlags GetPlatformFlagFromPlatformIndex(PlatformId platform);
+
+            //! Given a platformFlags returns all the platform identifiers that are set.
+            static AZStd::fixed_vector<AZStd::string_view, PlatformId::NumPlatformIds> GetPlatforms(PlatformFlags platformFlags);
+            //! Given a platformFlags returns all the platform identifiers that are set, with special flags interpreted.  Do not use the result for saving
+            static AZStd::fixed_vector<AZStd::string_view, PlatformId::NumPlatformIds> GetPlatformsInterpreted(PlatformFlags platformFlags);
+
+            //! Given a platformFlags return a list of PlatformId indices
+            static AZStd::fixed_vector<PlatformId, PlatformId::NumPlatformIds> GetPlatformIndices(PlatformFlags platformFlags);
+            //! Given a platformFlags return a list of PlatformId indices, with special flags interpreted.  Do not use the result for saving
+            static AZStd::fixed_vector<PlatformId, PlatformId::NumPlatformIds> GetPlatformIndicesInterpreted(PlatformFlags platformFlags);
+
+            //! Given a platform identifier returns its corresponding platform flag.
+            static PlatformFlags GetPlatformFlag(AZStd::string_view platform);
+
+            //! Given any platformFlags returns a string listing the input platforms
+            static AssetPlatformCombinedString GetCommaSeparatedPlatformList(PlatformFlags platformFlags);
+
+            //! If platformFlags contains any special flags, they are removed and replaced with the normal flags they represent
+            static PlatformFlags GetPlatformFlagsInterpreted(PlatformFlags platformFlags);
+
+            //! Returns true if platformFlags contains any special flags
+            static bool IsSpecialPlatform(PlatformFlags platformFlags);
+
+            //! Returns true if platformFlags has checkPlatform flag set.
+            static bool HasPlatformFlag(PlatformFlags platformFlags, PlatformId checkPlatform);
+        };
+    }
+}
+#pragma pop_macro("IOS")

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

@@ -17,6 +17,7 @@
 #include <AzCore/JSON/pointer.h>
 #include <AzCore/JSON/prettywriter.h>
 #include <AzCore/JSON/writer.h>
+#include <AzCore/PlatformId/PlatformDefaults.h>
 #include <AzCore/Settings/SettingsRegistryMergeUtils.h>
 #include <AzCore/Settings/CommandLine.h>
 #include <AzCore/std/string/conversions.h>
@@ -132,23 +133,14 @@ namespace AZ::Internal
 
     AZ::IO::FixedMaxPath ScanUpRootLocator(AZStd::string_view rootFileToLocate)
     {
-
-        AZStd::fixed_string<AZ::IO::MaxPathLength> executableDir;
-        if (AZ::Utils::GetExecutableDirectory(executableDir.data(), executableDir.capacity()) == Utils::ExecutablePathResult::Success)
-        {
-            // Update the size value of the executable directory fixed string to correctly be the length of the null-terminated string
-            // stored within it
-            executableDir.resize_no_construct(AZStd::char_traits<char>::length(executableDir.data()));
-        }
-
-        AZ::IO::FixedMaxPath engineRootCandidate{ executableDir };
+        AZ::IO::FixedMaxPath rootCandidate{ AZ::Utils::GetExecutableDirectory() };
 
         bool rootPathVisited = false;
         do
         {
-            if (AZ::IO::SystemFile::Exists((engineRootCandidate / rootFileToLocate).c_str()))
+            if (AZ::IO::SystemFile::Exists((rootCandidate / rootFileToLocate).c_str()))
             {
-                return engineRootCandidate;
+                return rootCandidate;
             }
 
             // Note for posix filesystems the parent directory of '/' is '/' and for windows
@@ -156,38 +148,69 @@ namespace AZ::Internal
 
             // Validate that the parent directory isn't itself, that would imply
             // that it is the filesystem root path
-            AZ::IO::PathView parentPath = engineRootCandidate.ParentPath();
-            rootPathVisited = (engineRootCandidate == parentPath);
+            AZ::IO::PathView parentPath = rootCandidate.ParentPath();
+            rootPathVisited = (rootCandidate == parentPath);
             // Recurse upwards one directory
-            engineRootCandidate = AZStd::move(parentPath);
+            rootCandidate = AZStd::move(parentPath);
 
         } while (!rootPathVisited);
 
         return {};
     }
 
+    void InjectSettingToCommandLineFront(AZ::SettingsRegistryInterface& settingsRegistry,
+        AZStd::string_view path, AZStd::string_view value)
+    {
+        AZ::CommandLine commandLine;
+        AZ::SettingsRegistryMergeUtils::GetCommandLineFromRegistry(settingsRegistry, commandLine);
+        AZ::CommandLine::ParamContainer paramContainer;
+        commandLine.Dump(paramContainer);
+
+        auto projectPathOverride = AZStd::string::format(R"(--regset="%.*s=%.*s")",
+            aznumeric_cast<int>(path.size()), path.data(), aznumeric_cast<int>(value.size()), value.data());
+        paramContainer.emplace(paramContainer.begin(), AZStd::move(projectPathOverride));
+        commandLine.Parse(paramContainer);
+        AZ::SettingsRegistryMergeUtils::StoreCommandLineToRegistry(settingsRegistry, commandLine);
+    }
 } // namespace AZ::Internal
 
 namespace AZ::SettingsRegistryMergeUtils
 {
+    constexpr AZStd::string_view InternalScanUpEngineRootKey{ "/O3DE/Settings/Internal/engine_root_scan_up_path" };
+    constexpr AZStd::string_view InternalScanUpProjectRootKey{ "/O3DE/Settings/Internal/project_root_scan_up_path" };
+
     AZ::IO::FixedMaxPath FindEngineRoot(SettingsRegistryInterface& settingsRegistry)
     {
         AZ::IO::FixedMaxPath engineRoot;
-
         // This is the 'external' engine root key, as in passed from command-line or .setreg files.
         auto engineRootKey = SettingsRegistryInterface::FixedValueString::format("%s/engine_path", BootstrapSettingsRootKey);
+
+        // Step 1 Run the scan upwards logic once to find the location of the engine.json if it exist
+        // Once this step is run the {InternalScanUpEngineRootKey} is set in the Settings Registry
+        // to have this scan logic only run once InternalScanUpEngineRootKey the supplied registry
+        if (settingsRegistry.GetType(InternalScanUpEngineRootKey) == SettingsRegistryInterface::Type::NoType)
+        {
+            // We can scan up from exe directory to find engine.json, use that for engine root if it exists.
+            engineRoot = Internal::ScanUpRootLocator("engine.json");
+            // Set the {InternalScanUpEngineRootKey} to make sure this code path isn't called again for this settings registry
+            settingsRegistry.Set(InternalScanUpEngineRootKey, engineRoot.Native());
+            if (!engineRoot.empty())
+            {
+                settingsRegistry.Set(engineRootKey, engineRoot.Native());
+                // Inject the engine root into the front of the command line settings
+                Internal::InjectSettingToCommandLineFront(settingsRegistry, engineRootKey, engineRoot.Native());
+                return engineRoot;
+            }
+        }
+
+        // Step 2 check if the engine_path key has been supplied
         if (settingsRegistry.Get(engineRoot.Native(), engineRootKey); !engineRoot.empty())
         {
             return engineRoot;
         }
 
-        // We can scan up from exe directory to find engine.json, use that for engine root if it exists.
-        if (engineRoot = Internal::ScanUpRootLocator("engine.json"); !engineRoot.empty())
-        {
-            settingsRegistry.Set(engineRootKey, engineRoot.c_str());
-            return engineRoot;
-        }
-
+        // Step 3 locate the project root and attempt to find the engine root using the registered engine
+        // for the project in the project.json file
         AZ::IO::FixedMaxPath projectRoot = FindProjectRoot(settingsRegistry);
         if (projectRoot.empty())
         {
@@ -207,16 +230,30 @@ namespace AZ::SettingsRegistryMergeUtils
     AZ::IO::FixedMaxPath FindProjectRoot(SettingsRegistryInterface& settingsRegistry)
     {
         AZ::IO::FixedMaxPath projectRoot;
-        // This is the 'external' project root key, as in passed from command-line or .setreg files.
-        auto projectRootKey = SettingsRegistryInterface::FixedValueString::format("%s/project_path", BootstrapSettingsRootKey);
-        if (settingsRegistry.Get(projectRoot.Native(), projectRootKey))
+        const auto projectRootKey = SettingsRegistryInterface::FixedValueString::format("%s/project_path", BootstrapSettingsRootKey);
+
+        // Step 1 Run the scan upwards logic once to find the location of the project.json if it exist
+        // Once this step is run the {InternalScanUpProjectRootKey} is set in the Settings Registry
+        // to have this scan logic only run once for the supplied registry
+        // SettingsRegistryInterface::GetType is used to check if a key is set
+        if (settingsRegistry.GetType(InternalScanUpProjectRootKey) == SettingsRegistryInterface::Type::NoType)
         {
-            return projectRoot;
+            projectRoot = Internal::ScanUpRootLocator("project.json");
+            // Set the {InternalScanUpProjectRootKey} to make sure this code path isn't called again for this settings registry
+            settingsRegistry.Set(InternalScanUpProjectRootKey, projectRoot.Native());
+            if (!projectRoot.empty())
+            {
+                settingsRegistry.Set(projectRootKey, projectRoot.c_str());
+                // Inject the project root into the front of the command line settings
+                Internal::InjectSettingToCommandLineFront(settingsRegistry, projectRootKey, projectRoot.Native());
+                return projectRoot;
+            }
         }
 
-        if (projectRoot = Internal::ScanUpRootLocator("project.json"); !projectRoot.empty())
+        // Step 2 Check the project-path key
+        // This is the project path root key, as in passed from command-line or .setreg files.
+        if (settingsRegistry.Get(projectRoot.Native(), projectRootKey))
         {
-            settingsRegistry.Set(projectRootKey, projectRoot.c_str());
             return projectRoot;
         }
 
@@ -463,24 +500,13 @@ namespace AZ::SettingsRegistryMergeUtils
     void MergeSettingsToRegistry_Bootstrap(SettingsRegistryInterface& registry)
     {
         ConfigParserSettings parserSettings;
-        parserSettings.m_commentPrefixFunc = [](AZStd::string_view line) -> AZStd::string_view
-        {
-            constexpr AZStd::string_view commentPrefixes[]{ "--", ";","#" };
-            for (AZStd::string_view commentPrefix : commentPrefixes)
-            {
-                if (size_t commentOffset = line.find(commentPrefix); commentOffset != AZStd::string_view::npos)
-                {
-                    return line.substr(0, commentOffset);
-                }
-            }
-            return line;
-        };
         parserSettings.m_registryRootPointerPath = BootstrapSettingsRootKey;
         MergeSettingsToRegistry_ConfigFile(registry, "bootstrap.cfg", parserSettings);
     }
 
     void MergeSettingsToRegistry_AddRuntimeFilePaths(SettingsRegistryInterface& registry)
     {
+        using FixedValueString = AZ::SettingsRegistryInterface::FixedValueString;
         // Binary folder
         AZ::IO::FixedMaxPath path = AZ::Utils::GetExecutableDirectory();
         registry.Set(FilePathKey_BinaryFolder, path.LexicallyNormal().Native());
@@ -489,27 +515,25 @@ namespace AZ::SettingsRegistryMergeUtils
         AZ::IO::FixedMaxPath engineRoot = FindEngineRoot(registry);
         registry.Set(FilePathKey_EngineRootFolder, engineRoot.LexicallyNormal().Native());
 
-        constexpr size_t bufferSize = 64;
-        auto buffer = AZStd::fixed_string<bufferSize>::format("%s/project_path", BootstrapSettingsRootKey);
-
-        AZ::SettingsRegistryInterface::FixedValueString projectPathKey(buffer);
+        auto projectPathKey = FixedValueString::format("%s/project_path", BootstrapSettingsRootKey);
         SettingsRegistryInterface::FixedValueString projectPathValue;
         if (registry.Get(projectPathValue, projectPathKey))
         {
             // Cache folder
             // Get the name of the asset platform assigned by the bootstrap. First check for platform version such as "windows_assets"
             // and if that's missing just get "assets".
-            constexpr char platformName[] = AZ_TRAIT_OS_PLATFORM_CODENAME_LOWER;
-
-            SettingsRegistryInterface::FixedValueString assetPlatform;
-            buffer = AZStd::fixed_string<bufferSize>::format("%s/%s_assets", BootstrapSettingsRootKey, platformName);
-            AZStd::string_view assetPlatformKey(buffer);
-            if (!registry.Get(assetPlatform, assetPlatformKey))
+            FixedValueString assetPlatform;
+            if (auto assetPlatformKey = FixedValueString::format("%s/%s_assets", BootstrapSettingsRootKey, AZ_TRAIT_OS_PLATFORM_CODENAME_LOWER);
+                !registry.Get(assetPlatform, assetPlatformKey))
             {
-                buffer = AZStd::fixed_string<bufferSize>::format("%s/assets", BootstrapSettingsRootKey);
-                assetPlatformKey = AZStd::string_view(buffer);
+                assetPlatformKey = FixedValueString::format("%s/assets", BootstrapSettingsRootKey);
                 registry.Get(assetPlatform, assetPlatformKey);
             }
+            if (assetPlatform.empty())
+            {
+                // Use the platform codename to retrieve the default asset platform value
+                assetPlatform = AZ::OSPlatformToDefaultAssetPlatform(AZ_TRAIT_OS_PLATFORM_CODENAME);
+            }
 
             // Project path - corresponds to the @devassets@ alias
             // NOTE: Here we append to engineRoot, but if projectPathValue is absolute then engineRoot is discarded.
@@ -549,8 +573,7 @@ namespace AZ::SettingsRegistryMergeUtils
             {
                 // Cache: project root - no corresponding fileIO alias, but this is where the asset database lives.
                 // A registry override is accepted using the "project_cache_path" key.
-                buffer = AZStd::fixed_string<bufferSize>::format("%s/project_cache_path", BootstrapSettingsRootKey);
-                AZStd::string_view projectCacheRootOverrideKey(buffer);
+                auto projectCacheRootOverrideKey = FixedValueString::format("%s/project_cache_path", BootstrapSettingsRootKey);
                 // Clear path to make sure that the `project_cache_path` value isn't concatenated to the project path
                 path.clear();
                 if (registry.Get(path.Native(), projectCacheRootOverrideKey))
@@ -807,6 +830,11 @@ namespace AZ::SettingsRegistryMergeUtils
             ++argumentIndex;
             commandLinePath.resize(commandLineRootSize);
         }
+
+        // This key is used allow Notification Handlers to know when the command line has been updated within the
+        // registry. The value itself is meaningless. The JSON path of {CommandLineValueChangedKey}
+        // being passed to the Notification Event Handler indicates that the command line has be updated
+        registry.Set(CommandLineValueChangedKey, true);
     }
 
     bool GetCommandLineFromRegistry(SettingsRegistryInterface& registry, AZ::CommandLine& commandLine)
@@ -823,10 +851,16 @@ namespace AZ::SettingsRegistryMergeUtils
                 }
                 else if (valueName == "Value" && !value.empty())
                 {
-                    m_arguments.push_back(value);
+                    // Make sure value types are in quotes in case they start with a command option prefix
+                    m_arguments.push_back(QuoteArgument(value));
                 }
             }
 
+            AZStd::string QuoteArgument(AZStd::string_view arg)
+            {
+                return !arg.empty() ? AZStd::string::format(R"("%.*s")", aznumeric_cast<int>(arg.size()), arg.data()) : AZStd::string{ arg };
+            }
+
             // The first parameter is skipped by the ComamndLine::Parse function so initialize
             // the container with one empty element
             AZ::CommandLine::ParamContainer m_arguments{ 1 };

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

@@ -57,6 +57,9 @@ namespace AZ::SettingsRegistryMergeUtils
 
     //! Root key for where command line are stored at within the settings registry
     inline static constexpr char CommandLineRootKey[] = "/Amazon/AzCore/Runtime/CommandLine";
+    //! Key set to trigger a notification that the CommandLine has been stored within the settings registry
+    //! The value of the key has no meaning. Notification Handlers only need to check if the key was supplied
+    inline static constexpr char CommandLineValueChangedKey[] = "/Amazon/AzCore/Runtime/CommandLineChanged";
 
     //! Root key where raw project settings (project.json) file is merged to settings registry
     inline static constexpr char ProjectSettingsRootKey[] = "/Amazon/Project/Settings";
@@ -74,6 +77,20 @@ namespace AZ::SettingsRegistryMergeUtils
     //! If it's still not found, attempt to find the project (by similar means) then reconcile the
     //! engine root by inspecting project.json and the engine manifest file.
     AZ::IO::FixedMaxPath FindEngineRoot(SettingsRegistryInterface& settingsRegistry);
+
+    //! The algorithm that is used to find the project root is as follows
+    //! 1. The first time this function is it performs a upward scan for a project.json file from
+    //! the executable directory and if found stores that path to an internal key.
+    //! In the same step it injects the path into the front of list of command line parameters
+    //! using the --regset="{BootstrapSettingsRootKey}/project_path=<path>" value
+    //! 2. Next the "{BootstrapSettingsRootKey}/project_path" is checked to see if it has a project path set
+    //!
+    //! The order in which the project path settings are overridden proceeds in the following order
+    //! 1. project_path set in the <engine-root>/bootstrap.cfg file
+    //! 2. project_path set in a *.setreg/*.setregpatch file
+    //! 3. project_path found by scanning upwards from the executable directory to the project.json path
+    //! 4. project_path set on the Command line via either --regset="{BootstrapSettingsRootKey}/project_path=<path>"
+    //!    or --project_path=<path>
     AZ::IO::FixedMaxPath FindProjectRoot(SettingsRegistryInterface& settingsRegistry);
 
     //! Query the specializations that will be used when loading the Settings Registry.

Code/Framework/AzCore/AzCore/azcore_files.cmake

@@ -607,6 +607,8 @@ set(FILES
     Utils/Utils.h
     Script/lua/lua.h
     Memory/HeapSchema.cpp
+    PlatformId/PlatformDefaults.h
+    PlatformId/PlatformDefaults.cpp
     PlatformId/PlatformId.h
     PlatformId/PlatformId.cpp
     Socket/AzSocket_fwd.h

Code/Framework/AzFramework/AzFramework/Platform/PlatformDefaults.cpp

@@ -1,338 +0,0 @@
-/*
-* 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 <AzCore/Casting/numeric_cast.h>
-#include <AzFramework/Platform/PlatformDefaults.h>
-
-#include <AzCore/StringFunc/StringFunc.h>
-
-namespace AzFramework
-{
-    static const char* PlatformNames[PlatformId::NumPlatformIds] = { PlatformPC, PlatformES3, PlatformIOS, PlatformOSX, PlatformProvo, PlatformSalem, PlatformJasper, PlatformServer, PlatformAll, PlatformAllClient };
-
-    const char* PlatformIdToPalFolder(AzFramework::PlatformId platform)
-    {
-#ifdef IOS
-#define AZ_REDEFINE_IOS_AT_END IOS
-#undef IOS
-#endif
-        switch (platform)
-        {
-        case AzFramework::PC:
-            return "PC";
-        case AzFramework::ES3:
-            return "Android";
-        case AzFramework::IOS:
-            return "iOS";
-        case AzFramework::OSX:
-            return "Mac";
-        case AzFramework::PROVO:
-            return "Provo";
-        case AzFramework::SALEM:
-            return "Salem";
-        case AzFramework::JASPER:
-            return "Jasper";
-        case AzFramework::SERVER:
-            return "Server";
-        case AzFramework::ALL:
-        case AzFramework::ALL_CLIENT:
-        case AzFramework::NumPlatformIds:
-        case AzFramework::Invalid:
-        default:
-            return "";
-        }
-
-#ifdef AZ_REDEFINE_IOS_AT_END
-#define IOS AZ_REDEFINE_IOS_AT_END
-#endif
-    }
-
-    const char* OSPlatformToDefaultAssetPlatform(AZStd::string_view osPlatform)
-    {
-        if (osPlatform == PlatformCodeNameWindows || osPlatform == PlatformCodeNameLinux)
-        {
-            return PlatformPC;
-        }
-        else if (osPlatform == PlatformCodeNameMac)
-        {
-            return PlatformOSX;
-        }
-        else if (osPlatform == PlatformCodeNameAndroid)
-        {
-            return PlatformES3;
-        }
-        else if (osPlatform == PlatformCodeNameiOS)
-        {
-            return PlatformIOS;
-        }
-        else if (osPlatform == PlatformCodeNameProvo)
-        {
-            return PlatformProvo;
-        }
-        else if (osPlatform == PlatformCodeNameSalem)
-        {
-            return PlatformSalem;
-        }
-        else if (osPlatform == PlatformCodeNameJasper)
-        {
-            return PlatformJasper;
-        }
-
-        AZ_Error("PlatformDefault", false, R"(Supplied OS platform "%.*s" does not have a corresponding default asset platform)",
-            aznumeric_cast<int>(osPlatform.size()), osPlatform.data());
-        return "";
-    }
-
-    PlatformFlags PlatformHelper::GetPlatformFlagFromPlatformIndex(PlatformId platformIndex)
-    {
-        if (platformIndex < 0 || platformIndex > PlatformId::NumPlatformIds)
-        {
-            return PlatformFlags::Platform_NONE;
-        }
-        if (platformIndex == PlatformId::ALL)
-        {
-            return PlatformFlags::Platform_ALL;
-        }
-        if (platformIndex == PlatformId::ALL_CLIENT)
-        {
-            return PlatformFlags::Platform_ALL_CLIENT;
-        }
-        return static_cast<PlatformFlags>(1 << platformIndex);
-    }
-
-    AZStd::fixed_vector<AZStd::string_view, PlatformId::NumPlatformIds> PlatformHelper::GetPlatforms(PlatformFlags platformFlags)
-    {
-        AZStd::fixed_vector<AZStd::string_view, PlatformId::NumPlatformIds> platforms;
-        for (int platformNum = 0; platformNum < PlatformId::NumPlatformIds; ++platformNum)
-        {
-            const bool isAllPlatforms = PlatformId::ALL == static_cast<PlatformId>(platformNum)
-                && ((platformFlags & PlatformFlags::Platform_ALL) != PlatformFlags::Platform_NONE);
-
-            const bool isAllClientPlatforms = PlatformId::ALL_CLIENT == static_cast<PlatformId>(platformNum)
-                && ((platformFlags & PlatformFlags::Platform_ALL_CLIENT) != PlatformFlags::Platform_NONE);
-
-            if (isAllPlatforms || isAllClientPlatforms
-                || (platformFlags & static_cast<PlatformFlags>(1 << platformNum)) != PlatformFlags::Platform_NONE)
-            {
-                platforms.push_back(PlatformNames[platformNum]);
-            }
-        }
-
-        return platforms;
-    }
-
-    AZStd::fixed_vector<AZStd::string_view, PlatformId::NumPlatformIds> PlatformHelper::GetPlatformsInterpreted(PlatformFlags platformFlags)
-    {
-        return GetPlatforms(GetPlatformFlagsInterpreted(platformFlags));
-    }
-
-    AZStd::fixed_vector<PlatformId, PlatformId::NumPlatformIds> PlatformHelper::GetPlatformIndices(PlatformFlags platformFlags)
-    {
-        AZStd::fixed_vector<PlatformId, PlatformId::NumPlatformIds> platformIndices;
-        for (int i = 0; i < PlatformId::NumPlatformIds; i++)
-        {
-            PlatformId index = static_cast<PlatformId>(i);
-            if ((GetPlatformFlagFromPlatformIndex(index) & platformFlags) != PlatformFlags::Platform_NONE)
-            {
-                platformIndices.emplace_back(index);
-            }
-        }
-        return platformIndices;
-    }
-
-    AZStd::fixed_vector<PlatformId, PlatformId::NumPlatformIds> PlatformHelper::GetPlatformIndicesInterpreted(PlatformFlags platformFlags)
-    {
-        return GetPlatformIndices(GetPlatformFlagsInterpreted(platformFlags));
-    }
-
-    PlatformFlags PlatformHelper::GetPlatformFlag(AZStd::string_view platform)
-    {
-        int platformIndex = GetPlatformIndexFromName(platform);
-        if (platformIndex == PlatformId::Invalid)
-        {
-            AZ_Error("PlatformDefault", false, "Invalid Platform ( %.*s ).\n", static_cast<int>(platform.length()), platform.data());
-            return PlatformFlags::Platform_NONE;
-        }
-
-        if(platformIndex == PlatformId::ALL)
-        {
-            return PlatformFlags::Platform_ALL;
-        }
-
-        if (platformIndex == PlatformId::ALL_CLIENT)
-        {
-            return PlatformFlags::Platform_ALL_CLIENT;
-        }
-
-        return static_cast<PlatformFlags>(1 << platformIndex);
-    }
-
-    const char* PlatformHelper::GetPlatformName(PlatformId platform)
-    { 
-        if (platform < 0 || platform > PlatformId::NumPlatformIds)
-        {
-            return "invalid";
-        }
-        return PlatformNames[platform];
-    }
-
-    void PlatformHelper::AppendPlatformCodeNames(AZStd::fixed_vector<AZStd::string_view, MaxPlatformCodeNames>& platformCodes, AZStd::string_view platformId)
-    {
-        PlatformId platform = GetPlatformIdFromName(platformId);
-        AZ_Assert(platform != PlatformId::Invalid, "Unsupported Platform ID: %.*s", static_cast<int>(platformId.length()), platformId.data());
-        AppendPlatformCodeNames(platformCodes, platform);
-    }
-
-    void PlatformHelper::AppendPlatformCodeNames(AZStd::fixed_vector<AZStd::string_view, MaxPlatformCodeNames>& platformCodes, PlatformId platformId)
-    {
-// The IOS SDK has a macro that defines IOS as 1 which causes the enum below to be incorrectly converted to "PlatformId::1".
-#pragma push_macro("IOS")
-#undef IOS
-        // To reduce work the Asset Processor groups assets that can be shared between hardware platforms together. For this
-        // reason "PC" can for instance cover both the Windows and Linux platforms and "IOS" can cover AppleTV and iOS.
-        switch (platformId)
-        {
-        case PlatformId::PC:
-            platformCodes.emplace_back(PlatformCodeNameWindows);
-            platformCodes.emplace_back(PlatformCodeNameLinux);
-            break;
-        case PlatformId::ES3:
-            platformCodes.emplace_back(PlatformCodeNameAndroid);
-            break;
-        case PlatformId::IOS:
-            platformCodes.emplace_back(PlatformCodeNameiOS);
-            break;
-        case PlatformId::OSX:
-            platformCodes.emplace_back(PlatformCodeNameMac);
-            break;
-        case PlatformId::PROVO:
-            platformCodes.emplace_back(PlatformCodeNameProvo);
-            break;
-        case PlatformId::SALEM:
-            platformCodes.emplace_back(PlatformCodeNameSalem);
-            break;
-        case PlatformId::JASPER:
-            platformCodes.emplace_back(PlatformCodeNameJasper);
-            break;
-        case PlatformId::SERVER:
-            // Server is not a hardware platform
-            break;
-        default:
-            AZ_Assert(false, "Unsupported Platform ID: %i", platformId);
-            break;
-        }
-#pragma pop_macro("IOS")
-    }
-
-    int PlatformHelper::GetPlatformIndexFromName(AZStd::string_view platformName)
-    {
-        for (int idx = 0; idx < PlatformId::NumPlatformIds; idx++)
-        {
-            if (platformName == PlatformNames[idx])
-            {
-                return idx;
-            }
-        }
-
-        return PlatformId::Invalid;
-    }
-
-    PlatformId PlatformHelper::GetPlatformIdFromName(AZStd::string_view platformName)
-    {
-        return aznumeric_caster(GetPlatformIndexFromName(platformName));
-    }
-
-    AssetPlatformCombinedString PlatformHelper::GetCommaSeparatedPlatformList(PlatformFlags platformFlags)
-    {
-        AZStd::fixed_vector<AZStd::string_view, PlatformId::NumPlatformIds> platformNames = GetPlatforms(platformFlags);
-        AssetPlatformCombinedString platformsString;
-        AZ::StringFunc::Join(platformsString, platformNames.begin(), platformNames.end(), ", ");
-        return platformsString;
-    }
-
-    PlatformFlags PlatformHelper::GetPlatformFlagsInterpreted(PlatformFlags platformFlags)
-    {
-        PlatformFlags returnFlags = PlatformFlags::Platform_NONE;
-
-        if((platformFlags & PlatformFlags::Platform_ALL) != PlatformFlags::Platform_NONE)
-        {
-            for (int i = 0; i < NumPlatforms; ++i)
-            {
-                auto platformId = static_cast<PlatformId>(i);
-                
-                if (platformId != PlatformId::ALL && platformId != PlatformId::ALL_CLIENT)
-                {
-                    returnFlags |= GetPlatformFlagFromPlatformIndex(platformId);
-                }
-            }
-        }
-        else if((platformFlags & PlatformFlags::Platform_ALL_CLIENT) != PlatformFlags::Platform_NONE)
-        {
-            for (int i = 0; i < NumPlatforms; ++i)
-            {
-                auto platformId = static_cast<PlatformId>(i);
-                
-                if (platformId != PlatformId::ALL && platformId != PlatformId::ALL_CLIENT && platformId != PlatformId::SERVER)
-                {
-                    returnFlags |= GetPlatformFlagFromPlatformIndex(platformId);
-                }
-            }
-        }
-        else
-        {
-            returnFlags = platformFlags;
-        }
-
-        return returnFlags;
-    }
-
-    bool PlatformHelper::IsSpecialPlatform(PlatformFlags platformFlags)
-    {
-        return (platformFlags & PlatformFlags::Platform_ALL) != PlatformFlags::Platform_NONE
-            || (platformFlags & PlatformFlags::Platform_ALL_CLIENT) != PlatformFlags::Platform_NONE;
-    }
-
-    bool HasFlagHelper(PlatformFlags flags, PlatformFlags checkPlatform)
-    {
-        return (flags & checkPlatform) == checkPlatform;
-    }
-
-
-    bool PlatformHelper::HasPlatformFlag(PlatformFlags flags, PlatformId checkPlatform)
-    {
-        // If checkPlatform contains any kind of invalid id, just exit out here
-        if(checkPlatform == PlatformId::Invalid || checkPlatform == NumPlatforms)
-        {
-            return false;
-        }
-
-        // ALL_CLIENT + SERVER = ALL
-        if(HasFlagHelper(flags, PlatformFlags::Platform_ALL_CLIENT | PlatformFlags::Platform_SERVER))
-        {
-            flags = PlatformFlags::Platform_ALL;
-        }
-
-        if(HasFlagHelper(flags, PlatformFlags::Platform_ALL))
-        {
-            // It doesn't matter what checkPlatform is set to in this case, just return true
-            return true;
-        }
-
-        if(HasFlagHelper(flags, PlatformFlags::Platform_ALL_CLIENT))
-        {
-            return checkPlatform != PlatformId::SERVER;
-        }
-
-        return HasFlagHelper(flags, GetPlatformFlagFromPlatformIndex(checkPlatform));
-    }
-
-}

Code/Framework/AzFramework/AzFramework/Platform/PlatformDefaults.h

@@ -12,144 +12,12 @@
 
 #pragma once
 
-#include <AzCore/Preprocessor/Enum.h>
-#include <AzCore/std/containers/fixed_vector.h>
-#include <AzCore/std/containers/unordered_map.h>
-#include <AzCore/std/string/fixed_string.h>
-#include <AzCore/std/string/string_view.h>
-
-// On IOS builds IOS will be defined and interfere with the below enums
-#pragma push_macro("IOS")
-#undef IOS
+#include <AzCore/PlatformId/PlatformDefaults.h>
 
+// As the Platform defaults is needed within AzCore,
+// those structures have been moved to AzCore and brought into
+// The AzFramework namespace for backwards compatibility
 namespace AzFramework
 {
-    constexpr char PlatformPC[] = "pc";
-    constexpr char PlatformES3[] = "es3";
-    constexpr char PlatformIOS[] = "ios";
-    constexpr char PlatformOSX[] = "osx_gl";
-    constexpr char PlatformProvo[] = "provo";
-    constexpr char PlatformSalem[] = "salem";
-    constexpr char PlatformJasper[] = "jasper";
-    constexpr char PlatformServer[] = "server";
-
-    constexpr char PlatformCodeNameWindows[] = "Windows";
-    constexpr char PlatformCodeNameLinux[] = "Linux";
-    constexpr char PlatformCodeNameAndroid[] = "Android";
-    constexpr char PlatformCodeNameiOS[] = "iOS";
-    constexpr char PlatformCodeNameMac[] = "Mac";
-    constexpr char PlatformCodeNameProvo[] = "Provo";
-    constexpr char PlatformCodeNameSalem[] = "Salem";
-    constexpr char PlatformCodeNameJasper[] = "Jasper";
-    constexpr char PlatformAll[] = "all";
-    constexpr char PlatformAllClient[] = "all_client";
-
-    // Used for the capacity of a fixed vector to store the code names of platforms
-    // The value needs to be higher than the number of unique OS platforms that are supported(at this time 8)
-    constexpr size_t MaxPlatformCodeNames = 16;
-
-    //! This platform enum have platform values in sequence and can also be used to get the platform count.
-    AZ_ENUM_WITH_UNDERLYING_TYPE(PlatformId, int,
-        (Invalid, -1),
-        PC,
-        ES3,
-        IOS,
-        OSX,
-        PROVO,
-        SALEM,
-        JASPER,
-        SERVER, // Corresponds to the customer's flavor of "server" which could be windows, ubuntu, etc
-        ALL,
-        ALL_CLIENT,
-
-        // Add new platforms above this
-        NumPlatformIds
-    );
-    constexpr int NumClientPlatforms = 7;
-    constexpr int NumPlatforms = NumClientPlatforms + 1; // 1 "Server" platform currently
-    enum class PlatformFlags : AZ::u32
-    {
-        Platform_NONE = 0x00,
-        Platform_PC = 1 << PlatformId::PC,
-        Platform_ES3 = 1 << PlatformId::ES3,
-        Platform_IOS = 1 << PlatformId::IOS,
-        Platform_OSX = 1 << PlatformId::OSX,
-        Platform_PROVO = 1 << PlatformId::PROVO,
-        Platform_SALEM = 1 << PlatformId::SALEM,
-        Platform_JASPER = 1 << PlatformId::JASPER,
-        Platform_SERVER = 1 << PlatformId::SERVER,
-
-        // A special platform that will always correspond to all platforms, even if new ones are added
-        Platform_ALL = 1ULL << 30,
-
-        // 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,
-    };
-
-    AZ_DEFINE_ENUM_BITWISE_OPERATORS(PlatformFlags);
-
-    // 32 characters should be more than enough to store a platform name
-    using AssetPlatformFixedString = AZStd::fixed_string<32>;
-    // Fixed string which can store a comma separated list of platforms names
-    // Additional byte is added to take into account the comma
-    using AssetPlatformCombinedString = AZStd::fixed_string<(AssetPlatformFixedString{}.max_size() + 1) * PlatformId::NumPlatformIds>;
-
-    const char* PlatformIdToPalFolder(AzFramework::PlatformId platform);
-
-    const char* OSPlatformToDefaultAssetPlatform(AZStd::string_view osPlatform);
-
-    //! Platform Helper is an utility class that can be used to retrieve platform related information
-    class PlatformHelper
-    {
-    public:
-
-        //! Given a platformIndex returns the platform name
-        static const char* GetPlatformName(PlatformId platform);
-
-        //! Converts the platform name to the platform code names as defined in AZ_TRAIT_OS_PLATFORM_CODENAME.
-        static void AppendPlatformCodeNames(AZStd::fixed_vector<AZStd::string_view, MaxPlatformCodeNames>& platformCodes, AZStd::string_view platformName);
-
-        //! Converts the platform name to the platform code names as defined in AZ_TRAIT_OS_PLATFORM_CODENAME.
-        static void AppendPlatformCodeNames(AZStd::fixed_vector<AZStd::string_view, MaxPlatformCodeNames>& platformCodes, PlatformId platformId);
-
-        //! Given a platform name returns a platform index. 
-        //! If the platform is not found, the method returns -1. 
-        static int GetPlatformIndexFromName(AZStd::string_view platformName);
-
-        //! Given a platform name returns a platform id. 
-        //! If the platform is not found, the method returns -1. 
-        static PlatformId GetPlatformIdFromName(AZStd::string_view platformName);
-
-        //! Given a platformIndex returns the platformFlags
-        static PlatformFlags GetPlatformFlagFromPlatformIndex(PlatformId platform);
-
-        //! Given a platformFlags returns all the platform identifiers that are set.
-        static AZStd::fixed_vector<AZStd::string_view, PlatformId::NumPlatformIds> GetPlatforms(PlatformFlags platformFlags);
-        //! Given a platformFlags returns all the platform identifiers that are set, with special flags interpreted.  Do not use the result for saving
-        static AZStd::fixed_vector<AZStd::string_view, PlatformId::NumPlatformIds> GetPlatformsInterpreted(PlatformFlags platformFlags);
-
-        //! Given a platformFlags return a list of PlatformId indices
-        static AZStd::fixed_vector<PlatformId, PlatformId::NumPlatformIds> GetPlatformIndices(PlatformFlags platformFlags);
-        //! Given a platformFlags return a list of PlatformId indices, with special flags interpreted.  Do not use the result for saving
-        static AZStd::fixed_vector<PlatformId, PlatformId::NumPlatformIds> GetPlatformIndicesInterpreted(PlatformFlags platformFlags);
-
-        //! Given a platform identifier returns its corresponding platform flag.
-        static PlatformFlags GetPlatformFlag(AZStd::string_view platform);
-
-        //! Given any platformFlags returns a string listing the input platforms
-        static AssetPlatformCombinedString GetCommaSeparatedPlatformList(PlatformFlags platformFlags);
-
-        //! If platformFlags contains any special flags, they are removed and replaced with the normal flags they represent
-        static PlatformFlags GetPlatformFlagsInterpreted(PlatformFlags platformFlags);
-
-        //! Returns true if platformFlags contains any special flags
-        static bool IsSpecialPlatform(PlatformFlags platformFlags);
-
-        //! Returns true if platformFlags has checkPlatform flag set.
-        static bool HasPlatformFlag(PlatformFlags platformFlags, PlatformId checkPlatform);
-    };
+    using namespace AZ::PlatformDefaults;
 }
-
-#pragma pop_macro("IOS")

Code/Framework/AzFramework/AzFramework/ProjectManager/ProjectManager.cpp

@@ -42,8 +42,14 @@ namespace AzFramework::ProjectManager
             AZ::CommandLine commandLine;
             commandLine.Parse(argc, argv);
             AZ::SettingsRegistryImpl settingsRegistry;
+            // Store the Command line to the Setting Registry
+
+            AZ::SettingsRegistryMergeUtils::StoreCommandLineToRegistry(settingsRegistry, commandLine);
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_Bootstrap(settingsRegistry);
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_O3deUserRegistry(settingsRegistry, AZ_TRAIT_OS_PLATFORM_CODENAME, {});
+            // Retrieve Command Line from Settings Registry, it may have been updated by the call to FindEngineRoot()
+            // in MergeSettingstoRegistry_ConfigFile
+            AZ::SettingsRegistryMergeUtils::GetCommandLineFromRegistry(settingsRegistry, commandLine);
             AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_CommandLine(settingsRegistry, commandLine, false);
             engineRootPath = AZ::SettingsRegistryMergeUtils::FindEngineRoot(settingsRegistry);
             projectRootPath = AZ::SettingsRegistryMergeUtils::FindProjectRoot(settingsRegistry);

Code/Framework/AzFramework/AzFramework/azframework_files.cmake

@@ -317,7 +317,6 @@ set(FILES
     Terrain/TerrainDataRequestBus.h
     Terrain/TerrainDataRequestBus.cpp
     Platform/PlatformDefaults.h
-    Platform/PlatformDefaults.cpp
     Windowing/WindowBus.h
     Windowing/NativeWindow.cpp
     Windowing/NativeWindow.h

Code/Framework/AzGameFramework/AzGameFramework/Application/GameApplication.cpp

@@ -80,6 +80,8 @@ namespace AzGameFramework
         AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_ProjectUserRegistry(registry, AZ_TRAIT_OS_PLATFORM_CODENAME, specializations, &scratchBuffer);
         AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_CommandLine(registry, m_commandLine, true);
 #endif
+        // Update the Runtime file paths in case the "{BootstrapSettingsRootKey}/assets" key was overriden by a setting registry
+        AZ::SettingsRegistryMergeUtils::MergeSettingsToRegistry_AddRuntimeFilePaths(registry);
     }
 
     AZ::ComponentTypeList GameApplication::GetRequiredSystemComponents() const

Code/Framework/AzToolsFramework/AzToolsFramework/API/ToolsApplicationAPI.h

@@ -578,16 +578,6 @@ namespace AzToolsFramework
          */
         virtual bool IsEditorInIsolationMode() = 0;
 
-        /*!
-        * Get the engine root path that the current tool is running under.  
-        */
-        virtual const char* GetEngineRootPath() const = 0;
-
-        /**
-        * Get the version of the engine the current tools application is running under
-        */
-        virtual const char* GetEngineVersion() const = 0;
-
         /**
         * Creates and adds a new entity to the tools application from components which match at least one of the requiredTags
         * The tag matching occurs on AZ::Edit::SystemComponentTags attribute from the reflected class data in the serialization context

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

@@ -224,112 +224,6 @@ namespace AzToolsFramework
 
     } // Internal
 
-#define AZ_MAX_ENGINE_VERSION_LEN   64
-    // Private Implementation class to manage the engine root and version
-    // Note: We are not using any AzCore classes because the ToolsApplication
-    // initialization happens early on, before the Allocators get instantiated,
-    // so we are using Qt privately instead
-    class ToolsApplication::EngineConfigImpl
-    {
-    private:
-        friend class ToolsApplication;
-
-        typedef QMap<QString, QString> EngineJsonMap;
-
-        EngineConfigImpl(const char* logWindow, const char* fileName)
-            : m_logWindow(logWindow)
-            , m_fileName(fileName)
-        {
-            m_engineRoot[0] = '\0';
-            m_engineVersion[0] = '\0';
-        }
-
-        char            m_engineRoot[AZ_MAX_PATH_LEN];
-        char            m_engineVersion[AZ_MAX_ENGINE_VERSION_LEN];
-        EngineJsonMap   m_engineConfigMap;
-        const char*     m_logWindow;
-        const char*     m_fileName;
-
-
-        // Read an engine configuration into a map of key/value pairs
-        bool ReadEngineConfigIntoMap(QString engineJsonPath, EngineJsonMap& engineJsonMap)
-        {
-            QFile engineJsonFile(engineJsonPath);
-            if (!engineJsonFile.open(QIODevice::ReadOnly | QIODevice::Text))
-            {
-                AZ_Warning(m_logWindow, false, "Unable to open file '%s' in the current root directory", engineJsonPath.toUtf8().data());
-                return false;
-            }
-
-            QByteArray engineJsonData = engineJsonFile.readAll();
-            engineJsonFile.close();
-            QJsonDocument engineJsonDoc(QJsonDocument::fromJson(engineJsonData));
-            if (engineJsonDoc.isNull())
-            {
-                AZ_Warning(m_logWindow, false, "Unable to read file '%s' in the current root directory", engineJsonPath.toUtf8().data());
-                return false;
-            }
-
-            QJsonObject engineJsonRoot = engineJsonDoc.object();
-            for (const QString& configKey : engineJsonRoot.keys())
-            {
-                QJsonValue configValue = engineJsonRoot[configKey];
-                if (configValue.isString() || configValue.isDouble())
-                {
-                    // Only map strings and numbers, ignore every other type
-                    engineJsonMap[configKey] = configValue.toString();
-                }
-                else
-                {
-                    AZ_Warning(m_logWindow, false, "Ignoring key '%s' from '%s', unsupported type.", configKey.toUtf8().data(), engineJsonPath.toUtf8().data());
-                }
-            }
-            return true;
-        }
-
-        // Initialize the engine config object based on the current
-        bool Initialize(const char* currentEngineRoot)
-        {
-            // Start with the app root as the engine root (legacy), but check to see if the engine root
-            // is external to the app root
-            azstrncpy(m_engineRoot, AZ_ARRAY_SIZE(m_engineRoot), currentEngineRoot, strlen(currentEngineRoot) + 1);
-
-            // From the appRoot, check and see if we can read any external engine reference in engine.json
-            QString engineJsonFileName = QString(m_fileName);
-            QString engineJsonFilePath = QDir(currentEngineRoot).absoluteFilePath(engineJsonFileName);
-
-            // From the appRoot, check and see if we can read any external engine reference in engine.json
-            if (!QFile::exists(engineJsonFilePath))
-            {
-                AZ_Warning(m_logWindow, false, "Unable to find '%s' in the current app root directory.", m_fileName);
-                return false;
-            }
-            if (!ReadEngineConfigIntoMap(engineJsonFilePath, m_engineConfigMap))
-            {
-                AZ_Warning(m_logWindow, false, "Defaulting root engine path to '%s'", currentEngineRoot);
-                return false;
-            }
-
-            // Read in the local engine version value
-            auto localEngineVersionValue = m_engineConfigMap.find(QString(AzToolsFramework::Internal::s_engineConfigEngineVersionKey));
-            QString localEngineVersion(localEngineVersionValue.value());
-            azstrncpy(m_engineVersion, AZ_ARRAY_SIZE(m_engineVersion), localEngineVersion.toUtf8().data(), localEngineVersion.length() + 1);
-
-            return true;
-        }
-
-        const char* GetEngineRoot() const
-        {
-            return m_engineRoot;
-        }
-
-        const char* GetEngineVersion() const
-        {
-            return m_engineVersion;
-        }
-    };
-
-
     ToolsApplication::ToolsApplication(int* argc, char*** argv)
         : AzFramework::Application(argc, argv)
         , m_selectionBounds(AZ::Aabb())
@@ -339,7 +233,6 @@ namespace AzToolsFramework
         , m_isInIsolationMode(false)
     {
         ToolsApplicationRequests::Bus::Handler::BusConnect();
-        m_engineConfigImpl.reset(new ToolsApplication::EngineConfigImpl(AzToolsFramework::Internal::s_startupLogWindow, AzToolsFramework::Internal::s_engineConfigFileName));
 
         m_undoCache.RegisterToUndoCacheInterface();
     }
@@ -391,7 +284,6 @@ namespace AzToolsFramework
     void ToolsApplication::Start(const Descriptor& descriptor, const StartupParameters& startupParameters/* = StartupParameters()*/)
     {
         Application::Start(descriptor, startupParameters);
-        InitializeEngineConfig();
 
         m_editorEntityManager.Start();
 
@@ -399,14 +291,6 @@ namespace AzToolsFramework
         AZ_Assert(m_editorEntityAPI, "ToolsApplication - Could not retrieve instance of EditorEntityAPI");
     }
 
-    void ToolsApplication::InitializeEngineConfig()
-    {
-        if (!m_engineConfigImpl->Initialize(GetEngineRoot()))
-        {
-            AZ_Warning(AzToolsFramework::Internal::s_startupLogWindow, false, "Defaulting engine root path to '%s'", GetEngineRoot());
-        }
-    }
-
     void ToolsApplication::StartCommon(AZ::Entity* systemEntity)
     {
         Application::StartCommon(systemEntity);
@@ -1832,16 +1716,6 @@ namespace AzToolsFramework
         return m_isInIsolationMode;
     }
 
-    const char* ToolsApplication::GetEngineRootPath() const
-    {
-        return m_engineConfigImpl->GetEngineRoot();
-    }
-
-    const char* ToolsApplication::GetEngineVersion() const
-    {
-        return m_engineConfigImpl->GetEngineVersion();
-    }
-
     void ToolsApplication::CreateAndAddEntityFromComponentTags(const AZStd::vector<AZ::Crc32>& requiredTags, const char* entityName)
     {
         if (!entityName || !entityName[0])

Code/Framework/AzToolsFramework/AzToolsFramework/Application/ToolsApplication.h

@@ -150,8 +150,6 @@ namespace AzToolsFramework
         void EnterEditorIsolationMode() override;
         void ExitEditorIsolationMode() override;
         bool IsEditorInIsolationMode() override;
-        const char* GetEngineRootPath() const override;
-        const char* GetEngineVersion() const override;
 
         void CreateAndAddEntityFromComponentTags(const AZStd::vector<AZ::Crc32>& requiredTags, const char* entityName) override;
 
@@ -174,7 +172,6 @@ namespace AzToolsFramework
 
         void CreateUndosForDirtyEntities();
         void ConsistencyCheckUndoCache();
-        void InitializeEngineConfig();
         AZ::Aabb                            m_selectionBounds;
         EntityIdList                        m_selectedEntities;
         EntityIdList                        m_highlightedEntities;
@@ -186,9 +183,6 @@ namespace AzToolsFramework
         bool                                m_isInIsolationMode;
         EntityIdSet                         m_isolatedEntityIdSet;
 
-        class EngineConfigImpl;
-        AZStd::unique_ptr<EngineConfigImpl> m_engineConfigImpl;
-
         EditorEntityAPI* m_editorEntityAPI = nullptr;
 
         EditorEntityManager m_editorEntityManager;

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

@@ -136,6 +136,48 @@ namespace AzToolsFramework
         return entity->GetName();
     }
 
+    EntityList EntityIdListToEntityList(const EntityIdList& inputEntityIds)
+    {
+        EntityList entities;
+        entities.reserve(inputEntityIds.size());
+
+        for (AZ::EntityId entityId : inputEntityIds)
+        {
+            if (!entityId.IsValid())
+            {
+                continue;
+            }
+
+            if (auto entity = GetEntityById(entityId))
+            {
+                entities.emplace_back(entity);
+            }
+        }
+
+        return entities;
+    }
+
+    EntityList EntityIdSetToEntityList(const EntityIdSet& inputEntityIds)
+    {
+        EntityList entities;
+        entities.reserve(inputEntityIds.size());
+
+        for (AZ::EntityId entityId : inputEntityIds)
+        {
+            if (!entityId.IsValid())
+            {
+                continue;
+            }
+
+            if (auto entity = GetEntityById(entityId))
+            {
+                entities.emplace_back(entity);
+            }
+        }
+
+        return entities;
+    }
+
     void GetAllComponentsForEntity(const AZ::Entity* entity, AZ::Entity::ComponentArrayType& componentsOnEntity)
     {
         if (entity)
@@ -1068,6 +1110,45 @@ namespace AzToolsFramework
         return !allEntityClonesContainer.m_entities.empty();
     }
 
+    EntityIdSet GetCulledEntityHierarchy(const EntityIdList& entities)
+    {
+        EntityIdSet culledEntities;
+
+        for (const AZ::EntityId& entityId : entities)
+        {
+            bool selectionIncludesTransformHeritage = false;
+            AZ::EntityId parentEntityId = entityId;
+            do
+            {
+                AZ::EntityId nextParentId;
+                AZ::TransformBus::EventResult(
+                    /*result*/ nextParentId,
+                    /*address*/ parentEntityId,
+                    &AZ::TransformBus::Events::GetParentId);
+                parentEntityId = nextParentId;
+                if (!parentEntityId.IsValid())
+                {
+                    break;
+                }
+                for (const AZ::EntityId& parentCheck : entities)
+                {
+                    if (parentCheck == parentEntityId)
+                    {
+                        selectionIncludesTransformHeritage = true;
+                        break;
+                    }
+                }
+            } while (parentEntityId.IsValid() && !selectionIncludesTransformHeritage);
+
+            if (!selectionIncludesTransformHeritage)
+            {
+                culledEntities.insert(entityId);
+            }
+        }
+
+        return culledEntities;
+    }
+
     namespace Internal
     {
         void CloneSliceEntitiesAndChildren(

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityHelpers.h

@@ -47,6 +47,9 @@ namespace AzToolsFramework
 
     AZStd::string GetEntityName(const AZ::EntityId& entityId, const AZStd::string_view& nameOverride = {});
 
+    EntityList EntityIdListToEntityList(const EntityIdList& inputEntityIds);
+    EntityList EntityIdSetToEntityList(const EntityIdSet& inputEntityIds);
+
     template <typename... ComponentTypes>
     struct AddComponents
     {
@@ -202,4 +205,8 @@ namespace AzToolsFramework
     /// Wrap EBus SetSelectedEntities call.
     void SelectEntities(const AzToolsFramework::EntityIdList& entities);
 
+    /// Return a set of entities, culling any that have an ancestor in the list.
+    /// e.g. This is useful for getting a concise set of entities that need to be duplicated.
+    EntityIdSet GetCulledEntityHierarchy(const EntityIdList& entities);
+
 }; // namespace AzToolsFramework

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

@@ -153,7 +153,7 @@ namespace AzToolsFramework
             AZ::EntityId& commonRootEntityId, InstanceOptionalReference& commonRootEntityOwningInstance)
         {
             // Retrieve entityList from entityIds
-            EntityIdListToEntityList(entityIds, inputEntityList);
+            inputEntityList = EntityIdListToEntityList(entityIds);
 
             // Find common root and top level entities
             bool entitiesHaveCommonRoot = false;
@@ -485,8 +485,7 @@ namespace AzToolsFramework
             InstanceOptionalReference instance = GetOwnerInstanceByEntityId(entityIds[0]);
 
             // Retrieve entityList from entityIds
-            EntityList inputEntityList;
-            EntityIdListToEntityList(entityIds, inputEntityList);
+            EntityList inputEntityList = EntityIdListToEntityList(entityIds);
 
             AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
 
@@ -833,18 +832,5 @@ namespace AzToolsFramework
 
             return true;
         }
-
-        void PrefabPublicHandler::EntityIdListToEntityList(const EntityIdList& inputEntityIds, EntityList& outEntities)
-        {
-            outEntities.reserve(inputEntityIds.size());
-
-            for (AZ::EntityId entityId : inputEntityIds)
-            {
-                if (entityId.IsValid())
-                {
-                    outEntities.emplace_back(GetEntityById(entityId));
-                }
-            }
-        }
     }
 }

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

@@ -99,7 +99,6 @@ namespace AzToolsFramework
             static Instance* GetParentInstance(Instance* instance);
             static Instance* GetAncestorOfInstanceThatIsChildOfRoot(const Instance* ancestor, Instance* descendant);
             static void GenerateContainerEntityTransform(const EntityList& topLevelEntities, AZ::Vector3& translation, AZ::Quaternion& rotation);
-            static void EntityIdListToEntityList(const EntityIdList& inputEntityIds, EntityList& outEntities);
 
             InstanceEntityMapperInterface* m_instanceEntityMapperInterface = nullptr;
             InstanceToTemplateInterface* m_instanceToTemplateInterface = nullptr;

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

@@ -38,6 +38,7 @@ AZ_POP_DISABLE_WARNING
 #include <AzCore/Asset/AssetManager.h>
 #include <AzCore/Component/ComponentApplicationBus.h>
 #include <AzCore/Asset/AssetTypeInfoBus.h>
+#include <AzCore/Utils/Utils.h>
 #include <AzFramework/StringFunc/StringFunc.h>
 #include <AzFramework/Asset/SimpleAsset.h>
 #include <AzFramework/Asset/AssetCatalogBus.h>
@@ -1212,9 +1213,8 @@ namespace AzToolsFramework
 
                 if (!QFile::exists(path))
                 {
-                    const char* engineRoot = nullptr;
-                    AzToolsFramework::ToolsApplicationRequestBus::BroadcastResult(engineRoot, &AzToolsFramework::ToolsApplicationRequests::GetEngineRootPath);
-                    QDir engineDir = engineRoot ? QDir(engineRoot) : QDir::current();
+                    AZ::IO::FixedMaxPathString engineRoot = AZ::Utils::GetEnginePath();
+                    QDir engineDir = !engineRoot.empty() ? QDir(QString(engineRoot.c_str())) : QDir::current();
 
                     path = engineDir.absoluteFilePath(iconPath.c_str());
                 }

Code/Framework/AzToolsFramework/Tests/AssetSeedManager.cpp

@@ -68,7 +68,7 @@ namespace UnitTest
             {
                 assets[idx] = AssetId(AZ::Uuid::CreateRandom(), 0);
                 AZ::Data::AssetInfo info;
-                info.m_relativePath = AZStd::string::format("Asset%d.txt", idx);
+                info.m_relativePath = AZStd::string::format("asset%d.txt", idx);
                 m_assetsPath[idx] = info.m_relativePath;
                 info.m_assetId = assets[idx];
                 m_assetRegistry->RegisterAsset(assets[idx], info);
@@ -623,7 +623,7 @@ namespace UnitTest
             EXPECT_TRUE(Search(assetList1, assets[fileIndex]));
             if (m_fileStreams[0][fileIndex].Open(m_assetsPathFull[0][fileIndex].c_str(), AZ::IO::OpenMode::ModeWrite | AZ::IO::OpenMode::ModeBinary | AZ::IO::OpenMode::ModeCreatePath))
             {
-                AZStd::string fileContent = AZStd::string::format("Asset%d.txt", fileIndex);
+                AZStd::string fileContent = AZStd::string::format("asset%d.txt", fileIndex);
                 m_fileStreams[0][fileIndex].Write(fileContent.size(), fileContent.c_str());
                 m_fileStreams[0][fileIndex].Close();
             }
@@ -654,7 +654,7 @@ namespace UnitTest
             EXPECT_TRUE(Search(assetList1, assets[fileIndex]));
             if (m_fileStreams[0][fileIndex].Open(m_assetsPathFull[0][fileIndex].c_str(), AZ::IO::OpenMode::ModeWrite | AZ::IO::OpenMode::ModeBinary | AZ::IO::OpenMode::ModeCreatePath))
             {
-                AZStd::string fileContent = AZStd::string::format("Asset%d.txt", fileIndex + 1);// changing file content
+                AZStd::string fileContent = AZStd::string::format("asset%d.txt", fileIndex + 1);// changing file content
                 m_fileStreams[0][fileIndex].Write(fileContent.size(), fileContent.c_str());
                 m_fileStreams[0][fileIndex].Close();
             }
@@ -987,7 +987,7 @@ namespace UnitTest
 
         m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_OSX);
 
-        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_OSX);
         const AzFramework::AssetSeedList& secondSeedList = m_assetSeedManager->GetAssetSeedList();
         EXPECT_EQ(secondSeedList.size(), 0);
     }
@@ -1003,7 +1003,7 @@ namespace UnitTest
 
         m_assetSeedManager->AddSeedAsset(assets[0], AzFramework::PlatformFlags::Platform_PC | AzFramework::PlatformFlags::Platform_OSX);
 
-        m_assetSeedManager->RemoveSeedAsset("Asset0.txt", AzFramework::PlatformFlags::Platform_PC);
+        m_assetSeedManager->RemoveSeedAsset("asset0.txt", AzFramework::PlatformFlags::Platform_PC);
         const AzFramework::AssetSeedList& secondSeedList = m_assetSeedManager->GetAssetSeedList();
         EXPECT_EQ(secondSeedList.size(), 1);
     }
@@ -1017,7 +1017,7 @@ namespace UnitTest
 
         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_OSX);
         const AzFramework::AssetSeedList& secondSeedList = m_assetSeedManager->GetAssetSeedList();
         EXPECT_EQ(secondSeedList.size(), 1);
     }

Code/Framework/AzToolsFramework/Tests/Entity/EditorEntityHelpersTests.cpp

@@ -0,0 +1,57 @@
+/*
+* 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 <AzTest/AzTest.h>
+
+#include <AzToolsFramework/Application/ToolsApplication.h>
+#include <AzToolsFramework/Entity/EditorEntityHelpers.h>
+#include <AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h>
+
+namespace UnitTest
+{
+    class EditorEntityHelpersTest
+        : public ToolsApplicationFixture
+    {
+        void SetUpEditorFixtureImpl() override
+        {
+            m_parent1 = CreateDefaultEditorEntity("Parent1");
+            m_child1 = CreateDefaultEditorEntity("Child1");
+            m_child2 = CreateDefaultEditorEntity("Child2");
+            m_grandChild1 = CreateDefaultEditorEntity("GrandChild1");
+            m_parent2 = CreateDefaultEditorEntity("Parent2");
+
+            AZ::TransformBus::Event(m_child1, &AZ::TransformBus::Events::SetParent, m_parent1);
+            AZ::TransformBus::Event(m_child2, &AZ::TransformBus::Events::SetParent, m_parent1);
+            AZ::TransformBus::Event(m_grandChild1, &AZ::TransformBus::Events::SetParent, m_child1);
+        }
+
+    public:
+        AZ::EntityId m_parent1;
+        AZ::EntityId m_child1;
+        AZ::EntityId m_child2;
+        AZ::EntityId m_grandChild1;
+        AZ::EntityId m_parent2;
+    };
+
+    TEST_F(EditorEntityHelpersTest, EditorEntityHelpersTests_GetCulledEntityHierarchy)
+    {
+        AzToolsFramework::EntityIdList testEntityIds{ m_parent1, m_child1, m_child2, m_grandChild1, m_parent2 };
+
+        AzToolsFramework::EntityIdSet culledSet = AzToolsFramework::GetCulledEntityHierarchy(testEntityIds);
+
+        // There should only be two EntityIds returned (m_parent1, and m_parent2),
+        // since all the others should be culled out since they have a common ancestor
+        // in the list already
+        using ::testing::UnorderedElementsAre;
+        EXPECT_THAT(culledSet, UnorderedElementsAre(m_parent1, m_parent2));
+    }
+}

Code/Framework/AzToolsFramework/Tests/aztoolsframeworktests_files.cmake

@@ -85,7 +85,9 @@ set(FILES
     Prefab/SpawnableSortEntitiesTestFixture.cpp
     Prefab/SpawnableSortEntitiesTestFixture.h
     Entity/EditorEntityContextComponentTests.cpp
+    Entity/EditorEntityHelpersTests.cpp
     Entity/EditorEntitySearchComponentTests.cpp
+    Entity/EditorEntitySelectionTests.cpp
     SliceStabilityTests/SliceStabilityTestFramework.h
     SliceStabilityTests/SliceStabilityTestFramework.cpp
     SliceStabilityTests/SliceStabilityCreateTests.cpp

Code/Sandbox/Editor/AssetEditor/AssetEditorWindow.cpp

@@ -20,6 +20,7 @@
 // AzCore
 #include <AzCore/Asset/AssetManager.h>
 #include <AzCore/UserSettings/UserSettingsComponent.h>
+#include <AzCore/Utils/Utils.h>
 
 // AzToolsFramework
 #include <AzToolsFramework/API/ToolsApplicationAPI.h>
@@ -104,13 +105,9 @@ void AssetEditorWindow::SaveAssetAs(const AZStd::string_view assetPath)
         return;
     }
 
-    const char* engineRoot;
-    AzToolsFramework::ToolsApplicationRequestBus::BroadcastResult(engineRoot, &AzToolsFramework::ToolsApplicationRequests::GetEngineRootPath);
+    auto absoluteAssetPath = AZ::IO::FixedMaxPath(AZ::Utils::GetEnginePath()) / assetPath;
 
-    AZStd::string absoluteAssetPath;
-    AzFramework::StringFunc::Path::Join(engineRoot, assetPath.data(), absoluteAssetPath);
-
-    if (!m_ui->m_assetEditorWidget->SaveAssetToPath(absoluteAssetPath))
+    if (!m_ui->m_assetEditorWidget->SaveAssetToPath(absoluteAssetPath.Native()))
     {
         AZ_Warning("Asset Editor", false, "File was not saved correctly via SaveAssetAs.");
     }

Code/Sandbox/Editor/EditorViewportWidget.cpp

@@ -1617,11 +1617,6 @@ void EditorViewportWidget::keyPressEvent(QKeyEvent* event)
     // because we want the movement to be butter smooth.
     if (!event->isAutoRepeat())
     {
-        if (m_keyDown.isEmpty())
-        {
-            grabKeyboard();
-        }
-
         m_keyDown.insert(event->key());
     }
 

Code/Sandbox/Editor/PythonEditorFuncs.cpp

@@ -19,6 +19,8 @@
 #include <QMessageBox>
 #include <QFileDialog>
 
+#include <AzCore/Utils/Utils.h>
+
 // AzToolsFramework
 #include <AzToolsFramework/API/EditorPythonRunnerRequestsBus.h>
 #include <AzToolsFramework/UI/UICore/WidgetHelpers.h>
@@ -293,9 +295,8 @@ namespace
             // If not found try editor folder
             if (!CFileUtil::FileExists(path))
             {
-                const char* engineRoot = nullptr;
-                AzToolsFramework::ToolsApplicationRequestBus::BroadcastResult(engineRoot, &AzToolsFramework::ToolsApplicationRequests::GetEngineRootPath);
-                QDir engineDir = engineRoot ? QDir(engineRoot) : QDir::current();
+                AZ::IO::FixedMaxPathString engineRoot = AZ::Utils::GetEnginePath();
+                QDir engineDir = !engineRoot.empty() ? QDir(QString(engineRoot.c_str())) : QDir::current();
 
                 QString scriptFolder = engineDir.absoluteFilePath("Editor/Scripts/");
                 Path::ConvertBackSlashToSlash(scriptFolder);

Code/Sandbox/Editor/ToolBox.cpp

@@ -18,6 +18,8 @@
 
 #include "ToolBox.h"
 
+#include <AzCore/Utils/Utils.h>
+
 // AzToolsFramework
 #include <AzToolsFramework/API/EditorPythonRunnerRequestsBus.h>
 #include <AzToolsFramework/API/ToolsApplicationAPI.h>
@@ -419,9 +421,8 @@ void CToolBoxManager::Load(QString xmlpath, AmazonToolbar* pToolbar, bool bToolb
         }
     }
 
-    const char* engineRoot = nullptr;
-    AzToolsFramework::ToolsApplicationRequestBus::BroadcastResult(engineRoot, &AzToolsFramework::ToolsApplicationRequests::GetEngineRootPath);
-    QDir engineDir = engineRoot ? QDir(engineRoot) : QDir::current();
+    AZ::IO::FixedMaxPathString engineRoot = AZ::Utils::GetEnginePath();
+    QDir engineDir = !engineRoot.empty() ? QDir(QString(engineRoot.c_str())) : QDir::current();
 
     string enginePath = PathUtil::AddSlash(engineDir.absolutePath().toUtf8().data());
 

Code/Sandbox/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.cpp

@@ -670,9 +670,13 @@ void SandboxIntegrationManager::PopulateEditorGlobalContextMenu(QMenu* menu, con
         action = menu->addAction(QObject::tr("Create layer"));
         QObject::connect(action, &QAction::triggered, [this] { ContextMenu_NewLayer(); });
 
+        AzToolsFramework::EntityIdList entities;
+        AzToolsFramework::ToolsApplicationRequests::Bus::BroadcastResult(
+            entities,
+            &AzToolsFramework::ToolsApplicationRequests::GetSelectedEntities);
+
         SetupLayerContextMenu(menu);
-        AzToolsFramework::EntityIdSet flattenedSelection;
-        GetSelectedEntitiesSetWithFlattenedHierarchy(flattenedSelection);
+        AzToolsFramework::EntityIdSet flattenedSelection = AzToolsFramework::GetCulledEntityHierarchy(entities);
         AzToolsFramework::SetupAddToLayerMenu(menu, flattenedSelection, [this] { return ContextMenu_NewLayer(); });
 
         SetupSliceContextMenu(menu);
@@ -1220,10 +1224,14 @@ void SandboxIntegrationManager::CloneSelection(bool& handled)
 {
     AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
 
-    AzToolsFramework::EntityIdSet duplicationSet;
-    GetSelectedEntitiesSetWithFlattenedHierarchy(duplicationSet);
+    AzToolsFramework::EntityIdList entities;
+    AzToolsFramework::ToolsApplicationRequests::Bus::BroadcastResult(
+        entities,
+        &AzToolsFramework::ToolsApplicationRequests::GetSelectedEntities);
 
-    if (duplicationSet.size() > 0)
+    AzToolsFramework::EntityIdSet duplicationSet = AzToolsFramework::GetCulledEntityHierarchy(entities);
+
+    if (!duplicationSet.empty())
     {
         AZStd::unordered_set<AZ::EntityId> clonedEntities;
         handled = AzToolsFramework::CloneInstantiatedEntities(duplicationSet, clonedEntities);

Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpAnimationImporter.cpp

@@ -42,7 +42,108 @@ namespace AZ
 
             // Downstream only supports 30 frames per second sample rate. Adjusting to 60 doubles the
             // length of the animations, they still play back at 30 frames per second.
-            const double AssImpAnimationImporter::s_defaultTimeStepSampleRate = 1.0 / 30.0;
+            const double AssImpAnimationImporter::s_defaultTimeStepBetweenFrames = 1.0 / 30.0;
+
+            AZ::u32 GetNumKeyFrames(AZ::u32 keysSize, double duration, double ticksPerSecond)
+            {
+                if (AZ::IsClose(ticksPerSecond, 0))
+                {
+                    AZ_Warning("AnimationImporter", false, "Animation ticks per second should not be zero, defaulting to %d keyframes for animation.", keysSize);
+                    return keysSize;
+                }
+                const double totalTicks = duration / ticksPerSecond;
+                AZ::u32 numKeys = keysSize;
+                // +1 because the animation is from [0, duration] - we have a keyframe at the end of the duration which needs to be included
+                double totalFramesAtDefaultTimeStep = totalTicks / AssImpAnimationImporter::s_defaultTimeStepBetweenFrames + 1;
+                if (!AZ::IsClose(totalFramesAtDefaultTimeStep, numKeys, 1))
+                {
+                    numKeys = AZStd::ceilf(totalFramesAtDefaultTimeStep);
+                }
+                return numKeys;
+            }
+
+            double GetTimeForFrame(AZ::u32 frame, double ticksPerSecond)
+            {
+                return frame * AssImpAnimationImporter::s_defaultTimeStepBetweenFrames * ticksPerSecond;
+            }
+
+            // Helper class to store key data, when translating from AssImp layout to the engine's scene format.
+            struct KeyData
+            {
+                KeyData(float value, float time) :
+                    mValue(value),
+                    mTime(time)
+                {
+
+                }
+
+                bool operator<(const KeyData& other) const
+                {
+                    return mTime < other.mTime;
+                }
+
+                float mValue = 0;
+                float mTime = 0;
+            };
+
+            template<class T>
+            void LerpTemplate(T& start, const T& end, float t)
+            {
+                start = start * (1.0f - t) + end * t;
+            }
+
+            template<>
+            void LerpTemplate(aiQuaternion& start, const aiQuaternion& end, float t)
+            {
+                aiQuaternion::Interpolate(start, start, end, t);
+            }
+
+            template<>
+            void LerpTemplate(float& start, const float& end, float t)
+            {
+                start = AZ::Lerp(start, end, t);
+            }
+
+            template<class KeyContainerType, class FrameValueType>
+            bool SampleKeyFrame(FrameValueType& result, const KeyContainerType& keys, AZ::u32 numKeys, double time, AZ::u32& lastIndex)
+            {
+                if (numKeys == 0)
+                {
+                    AZ_Error("AnimationImporter", numKeys > 0, "Animation key set must have at least 1 key");
+                    return false;
+                }
+                if (numKeys == 1)
+                {
+                    result = keys[0].mValue;
+                    return true;
+                }
+
+                while (lastIndex < numKeys - 1 && time >= keys[lastIndex + 1].mTime)
+                {
+                    ++lastIndex;
+                }
+                result = keys[lastIndex].mValue;
+                if (lastIndex < numKeys - 1)
+                {
+                    auto nextValue = keys[lastIndex + 1].mValue;
+                    float normalizedTimeBetweenFrames = 0;
+                    if (keys[lastIndex + 1].mTime != keys[lastIndex].mTime)
+                    {
+                        normalizedTimeBetweenFrames =
+                            (time - keys[lastIndex].mTime) / (keys[lastIndex + 1].mTime - keys[lastIndex].mTime);
+                    }
+                    else
+                    {
+                        AZ_Warning("AnimationImporter", false,
+                            "Animation has keys with duplicate time %5.5f, at indices %d and %d. The second will be ignored.",
+                            keys[lastIndex].mTime,
+                            lastIndex,
+                            lastIndex + 1);
+                    }
+                    LerpTemplate(result, nextValue, normalizedTimeBetweenFrames);
+                }
+                return true;
+            }
 
             AssImpAnimationImporter::AssImpAnimationImporter()
             {
@@ -199,6 +300,14 @@ namespace AZ
                 for (AZ::u32 animIndex = 0; animIndex < scene->mNumAnimations; ++animIndex)
                 {
                     const aiAnimation* animation = scene->mAnimations[animIndex];
+                    if (animation->mTicksPerSecond == 0)
+                    {
+                        AZ_Error(
+                            "AnimationImporter", false,
+                            "Animation name %s has a sample rate of 0 ticks per second and cannot be processed.",
+                            animation->mName.C_Str());
+                        return Events::ProcessingResult::Failure;
+                    }
                     
                     mapAnimationsFunc(animation->mNumChannels, animation->mChannels, animation, boneAnimations);
 
@@ -410,70 +519,38 @@ namespace AZ
                             anim->mNumPositionKeys, anim->mNumRotationKeys, anim->mNumScalingKeys);
                         return Events::ProcessingResult::Failure;
                     }
-                    
-                    auto sampleKeyFrame = [](const auto& keys, AZ::u32 numKeys, double time, AZ::u32& lastIndex)
-                    {
-                        AZ_Error("AnimationImporter", numKeys > 0, "Animation key set must have at least 1 key");
-
-                        if (numKeys == 1)
-                        {
-                            return keys[0].mValue;
-                        }
-
-                        auto returnValue = keys[0].mValue;
-
-                        for (AZ::u32 keyIndex = lastIndex; keyIndex < numKeys; ++keyIndex)
-                        {
-                            const auto& key = keys[keyIndex];
-                            lastIndex = keyIndex;
-
-                            // We want to return the key that exactly matches the time if possible, otherwise we'll keep track of the previous time
-                            // If we don't find an exact match and end up going past the desired time (or run out of keyframes) then we return the previous key
-                            if (key.mTime < time)
-                            {
-                                returnValue = key.mValue;
-                            }
-                            else if (AZ::IsClose(key.mTime, time))
-                            {
-                                return key.mValue;
-                            }
-                            else
-                            {
-                                return returnValue;
-                            }
-                        }
-                        
-                        return returnValue;
-                    };
 
                     // Resample the animations at a fixed time step. This matches the behaviour of
                     // the previous SDK used. Longer term, this could be data driven, or based on the
                     // smallest time step between key frames.
                     // AssImp has an animation->mTicksPerSecond and animation->mDuration, but those
                     // are less predictable than just using a fixed time step.
-                    const double duration = animation->mDuration / animation->mTicksPerSecond;
+                    // AssImp documentation claims animation->mDuration is the duration of the animation in ticks, but
+                    // not all animations we've tested follow that pattern. Sometimes duration is in seconds.
+                    const AZ::u32 numKeyFrames = GetNumKeyFrames(
+                        AZStd::max(AZStd::max(anim->mNumScalingKeys, anim->mNumPositionKeys), anim->mNumRotationKeys),
+                        animation->mDuration,
+                        animation->mTicksPerSecond);
 
-                    AZ::u32 numKeyFrames = AZStd::max(AZStd::max(anim->mNumScalingKeys, anim->mNumPositionKeys), anim->mNumRotationKeys);
-                    if (!AZ::IsClose(duration / s_defaultTimeStepSampleRate, numKeyFrames, 1))
-                    {
-                        double dT = duration / s_defaultTimeStepSampleRate;
-                        numKeyFrames = AZStd::ceilf(dT) + 1; // +1 because the animation is from [0, duration] - we have a keyframe at the end of the duration which needs to be included
-                    }
-                    
                     AZStd::shared_ptr<SceneData::GraphData::AnimationData> createdAnimationData =
                        AZStd::make_shared<SceneData::GraphData::AnimationData>();
                     createdAnimationData->ReserveKeyFrames(numKeyFrames);
-                    createdAnimationData->SetTimeStepBetweenFrames(s_defaultTimeStepSampleRate);
+                    createdAnimationData->SetTimeStepBetweenFrames(s_defaultTimeStepBetweenFrames);
 
                     AZ::u32 lastScaleIndex = 0;
                     AZ::u32 lastPositionIndex = 0;
                     AZ::u32 lastRotationIndex = 0;
                     for (AZ::u32 frame = 0; frame < numKeyFrames; ++frame)
                     {
-                        double time = frame * s_defaultTimeStepSampleRate * animation->mTicksPerSecond;
-                        aiVector3D scale = sampleKeyFrame(anim->mScalingKeys, anim->mNumScalingKeys, time, lastScaleIndex);
-                        aiVector3D position = sampleKeyFrame(anim->mPositionKeys, anim->mNumPositionKeys, time, lastPositionIndex);
-                        aiQuaternion rotation = sampleKeyFrame(anim->mRotationKeys, anim->mNumRotationKeys, time, lastRotationIndex);
+                        const double time = GetTimeForFrame(frame, animation->mTicksPerSecond);
+                        aiVector3D scale = aiVector3D(1.f, 1.f, 1.f), position = aiVector3D(0.f, 0.f, 0.f);
+                        aiQuaternion rotation(1.f, 0.f, 0.f, 0.f);
+                        if (!SampleKeyFrame(scale, anim->mScalingKeys, anim->mNumScalingKeys, time, lastScaleIndex) ||
+                            !SampleKeyFrame(position, anim->mPositionKeys, anim->mNumPositionKeys, time, lastPositionIndex) ||
+                            !SampleKeyFrame(rotation, anim->mRotationKeys, anim->mNumRotationKeys, time, lastRotationIndex))
+                        {
+                            return Events::ProcessingResult::Failure;
+                        }
                         
                         aiMatrix4x4 transform(scale, rotation, position);
                         
@@ -520,28 +597,6 @@ namespace AZ
                 //      SetTimeStepBetweenFrames set on the animation data
                 //      Keyframes. Weights (Values in FBX SDK) per key time.
                 //      Keyframes generated for every single frame of the animation.
-
-                // Helper class to store key data, when translating from AssImp layout to the engine's scene format.
-                struct KeyData
-                {
-                    KeyData(float weight, float time) :
-                        m_weight(weight),
-                        m_time(time)
-                    {
-
-                    }
-
-                    bool operator<(const KeyData& other) const
-                    {
-                        return m_time < other.m_time;
-                    }
-
-                    // Naming in the previous SDK (FBX SDK) and in the engine's scene format
-                    // doesn't match AssImp's naming convention.
-                    // weight here is the AssImp's name for the data, it was named value in FBX SDK.
-                    float m_weight = 0;
-                    float m_time = 0;
-                };
                 typedef AZStd::map<int, AZStd::vector<KeyData>> ValueToKeyDataMap;
                 ValueToKeyDataMap valueToKeyDataMap;
 
@@ -562,44 +617,27 @@ namespace AZ
                 {
                     AZStd::shared_ptr<SceneData::GraphData::BlendShapeAnimationData> morphAnimNode =
                         AZStd::make_shared<SceneData::GraphData::BlendShapeAnimationData>();
-                    morphAnimNode->ReserveKeyFrames(animation->mDuration + 1);
-                    morphAnimNode->SetTimeStepBetweenFrames(1.0 / animation->mTicksPerSecond);
+
+                    const AZ::u32 numKeyFrames = GetNumKeyFrames(keys.size(), animation->mDuration, animation->mTicksPerSecond);
+                    morphAnimNode->ReserveKeyFrames(numKeyFrames);
+                    morphAnimNode->SetTimeStepBetweenFrames(s_defaultTimeStepBetweenFrames);
 
                     aiAnimMesh* aiAnimMesh = mesh->mAnimMeshes[meshIdx];
                     AZStd::string_view nodeName(aiAnimMesh->mName.C_Str());
 
                     const AZ::u32 maxKeys = keys.size();
                     AZ::u32 keyIdx = 0;
-                    for (AZ::u32 time = 0; time <= animation->mDuration; ++time)
+                    for (AZ::u32 frame = 0; frame <= numKeyFrames; ++frame)
                     {
-                        if (keyIdx < maxKeys - 1 && time >= keys[keyIdx+1].m_time)
-                        {
-                            ++keyIdx;
-                        }
-                        float weight_value = keys[keyIdx].m_weight;
-                        if (keyIdx < maxKeys - 1)
-                        {
-                            float nextWeight = keys[keyIdx+1].m_weight;
-                            float normalizedTimeBetweenFrames = 0;
+                        const double time = GetTimeForFrame(frame, animation->mTicksPerSecond);
 
-                            if (keys[keyIdx + 1].m_time != keys[keyIdx].m_time)
-                            {
-                                normalizedTimeBetweenFrames =
-                                    (time - keys[keyIdx].m_time) / (keys[keyIdx + 1].m_time - keys[keyIdx].m_time);
-                            }
-                            else
-                            {
-                                AZ_Warning("AnimationImporter", false,
-                                    "Morph target mesh %s has keys with duplicate time, at indices %d and %d. The second will be ignored.",
-                                    nodeName.data(),
-                                    keyIdx,
-                                    keyIdx+1);
-                            }
-
-                            // AssImp and FBX both only support linear interpolation for blend shapes.
-                            weight_value = AZ::Lerp(weight_value, nextWeight, normalizedTimeBetweenFrames);
+                        float weight = 0;
+                        if (!SampleKeyFrame(weight, keys, keys.size(), time, keyIdx))
+                        {
+                            return Events::ProcessingResult::Failure;
                         }
-                        morphAnimNode->AddKeyFrame(weight_value);
+
+                        morphAnimNode->AddKeyFrame(weight);
                     }
 
 

Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpAnimationImporter.h

@@ -45,7 +45,7 @@ namespace AZ
                     const aiMeshMorphAnim* meshMorphAnim,
                     const aiMesh* mesh);
 
-                static const double s_defaultTimeStepSampleRate;
+                static const double s_defaultTimeStepBetweenFrames;
 
             protected:
                 static const char* s_animationNodeName;

Code/Tools/SceneAPI/SceneCore/Containers/SceneGraph.cpp

@@ -43,7 +43,7 @@ namespace AZ
                 AZ::BehaviorContext* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context);
                 if (behaviorContext)
                 {
-                    behaviorContext->Class<SceneGraph::NodeIndex>()
+                    behaviorContext->Class<SceneGraph::NodeIndex>("NodeIndex")
                         ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
                         ->Attribute(AZ::Script::Attributes::Module, "scene.graph")
                         ->Constructor<>()
@@ -57,7 +57,7 @@ namespace AZ
                             ->Attribute(AZ::Script::Attributes::Operator, AZ::Script::Attributes::OperatorType::ToString)
                         ;
 
-                    behaviorContext->Class<SceneGraph::Name>()
+                    behaviorContext->Class<SceneGraph::Name>("SceneGraphName")
                         ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
                         ->Attribute(AZ::Script::Attributes::Module, "scene.graph")
                         ->Constructor()