Merge remote-tracking branch 'upstream/main' into LYN-2726-ProjectRoot

2021-04-16 21:12:55 -05:00
parent 6dadc84581 944dab2ecb
commit 6d3b9e4f51
109 changed files with 3772 additions and 1946 deletions
@@ -926,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)
@@ -167,14 +167,14 @@ namespace AZ
        }
    }

-    AZ_MATH_INLINE Vector2::Vector2(const Vector3& source)
+    Vector2::Vector2(const Vector3& source)
        : m_x(source.GetX())
        , m_y(source.GetY())
    {
    }


-    AZ_MATH_INLINE Vector2::Vector2(const Vector4& source)
+    Vector2::Vector2(const Vector4& source)
        : m_x(source.GetX())
        , m_y(source.GetY())
    {
@@ -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));
+        }
+    }
+}
@@ -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")
@@ -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>
@@ -525,9 +526,10 @@ namespace AZ::SettingsRegistryMergeUtils
            // 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);
+            // Use the platform codename to retrieve the default asset platform value
+            SettingsRegistryInterface::FixedValueString assetPlatform = AZ::OSPlatformToDefaultAssetPlatform(AZ_TRAIT_OS_PLATFORM_CODENAME);
            if (!registry.Get(assetPlatform, assetPlatformKey))
            {
                buffer = AZStd::fixed_string<bufferSize>::format("%s/assets", BootstrapSettingsRootKey);
@@ -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