Integrating latest from github/staging

Integrating up through commit 5e1bdae
2021-03-26 14:31:50 -07:00
parent 9c54341af8
commit 36c4e827bd
764 changed files with 11453 additions and 20251 deletions
@@ -15,7 +15,6 @@
 #include <AzCore/Asset/AssetManagerBus.h>
 #include <AzCore/Asset/AssetManagerComponent.h>
 #include <AzCore/IO/FileIO.h>
-#include <AzCore/Jobs/Algorithms.h>
 #include <AzCore/Jobs/JobManagerComponent.h>
 #include <AzCore/Memory/MemoryComponent.h>
 #include <AzCore/Module/DynamicModuleHandle.h>
@@ -23,6 +22,7 @@
 #include <AzCore/Slice/SliceSystemComponent.h>
 #include <AzCore/std/string/conversions.h>
 #include <AzCore/UserSettings/UserSettingsComponent.h>
+#include <AzCore/Utils/Utils.h>

 #include <AzFramework/Asset/AssetCatalogComponent.h>
 #include <AzFramework/Driller/RemoteDrillerInterface.h>
@@ -38,18 +38,12 @@
 #include <AzToolsFramework/Asset/AssetUtils.h>
 #include <AzToolsFramework/AssetBundle/AssetBundleComponent.h>
 #include <AzToolsFramework/AssetCatalog/PlatformAddressedAssetCatalogBus.h>
+#include <AzCore/Jobs/Algorithms.h>

 namespace AssetBundler
 {
    const char compareVariablePrefix = '$';

-    GemInfo::GemInfo(AZStd::string name, AZStd::string relativeFilePath, AZStd::string absoluteFilePath)
-        : m_gemName(name)
-        , m_relativeFilePath(relativeFilePath)
-        , m_absoluteFilePath(absoluteFilePath)
-    {
-    }
-
    ApplicationManager::ApplicationManager(int* argc, char*** argv)
        : AzToolsFramework::ToolsApplication(argc, argv)
    {
@@ -123,41 +117,21 @@ namespace AssetBundler
        }
        m_showVerboseOutput = ShouldPrintVerbose(parser);

-        ComputeEngineRoot();
+        m_currentProjectName = AZStd::string_view{ AZ::Utils::GetProjectName() };

-        const char* devRoot = nullptr;
-        AzFramework::ApplicationRequests::Bus::BroadcastResult(devRoot, &AzFramework::ApplicationRequests::GetEngineRoot);
-        if (devRoot)
+        if (m_currentProjectName.empty())
        {
-            AZ_TracePrintf(AssetBundler::AppWindowNameVerbose, "Setting devroot alias to ( %s ).\n", devRoot);
-            AZ::IO::FileIOBase::GetInstance()->SetAlias("@devroot@", devRoot);
-        }
-
-        AZStd::string platformName(AzToolsFramework::AssetSystem::GetHostAssetPlatform());
-        AZStd::string assetsAlias;
-        AZStd::string assetCatalogFile;
-
-        AZ::Outcome<void, AZStd::string> result = AssetBundler::ComputeAssetAliasAndGameName(platformName, assetCatalogFile, assetsAlias, m_currentProjectName);
-        if (!result.IsSuccess())
-        {
-            AZ_Error(AppWindowName, false, result.GetError().c_str());
+            AZ_Error(AppWindowName, false, "Unable to retrieve project name from the Settings Registry");
            return false;
        }

-        const char* appRoot = nullptr;
-        AzFramework::ApplicationRequests::Bus::BroadcastResult(appRoot, &AzFramework::ApplicationRequests::GetAppRoot);
-
        // Gems
-        if (!AzToolsFramework::AssetUtils::GetGemsInfo(g_cachedEngineRoot, appRoot, m_currentProjectName.c_str(), m_gemInfoList))
+        if (!AzFramework::GetGemsInfo(m_gemInfoList, *m_settingsRegistry))
        {
            AZ_Error(AppWindowName, false, "Failed to read Gems for project: %s\n", m_currentProjectName.c_str());
            return false;
        }

-        // @assets@ alias
-        AZ_TracePrintf(AssetBundler::AppWindowNameVerbose, "Setting asset alias to ( %s ).\n", assetsAlias.c_str());
-        AZ::IO::FileIOBase::GetInstance()->SetAlias("@assets@", assetsAlias.c_str());
-
        m_platformCatalogManager = AZStd::make_unique<AzToolsFramework::PlatformAddressedAssetCatalogManager>();

        InitArgValidationLists();
@@ -1304,13 +1278,18 @@ namespace AssetBundler

    AZ::Outcome<void, AZStd::string> ApplicationManager::ValidateInputArgs(const AzFramework::CommandLine* parser, const AZStd::vector<const char*>& validArgList)
    {
-        for (const auto& paramInfo : parser->GetSwitchList())
+        for (const auto& paramInfo : *parser)
        {
+            // Skip positional arguments
+            if (paramInfo.m_option.empty())
+            {
+                continue;
+            }
            bool isValidArg = false;

            for (const auto& validArg : validArgList)
            {
-                if (AzFramework::StringFunc::Equal(paramInfo.first.c_str(), validArg))
+                if (AzFramework::StringFunc::Equal(paramInfo.m_option, validArg))
                {
                    isValidArg = true;
                    break;
@@ -1319,7 +1298,7 @@ namespace AssetBundler

            if (!isValidArg)
            {
-                return AZ::Failure(AZStd::string::format("Invalid command: \"--%s\" is not a valid argument for this sub-command.", paramInfo.first.c_str()));
+                return AZ::Failure(AZStd::string::format("Invalid command: \"--%s\" is not a valid argument for this sub-command.", paramInfo.m_option.c_str()));
            }
        }

@@ -1407,7 +1386,7 @@ namespace AssetBundler
        const char* appRoot = nullptr;
        AzFramework::ApplicationRequests::Bus::BroadcastResult(appRoot, &AzFramework::ApplicationRequests::GetAppRoot);

-        AzFramework::PlatformFlags platformFlags = GetEnabledPlatformFlags(g_cachedEngineRoot, appRoot, m_currentProjectName.c_str());
+        AzFramework::PlatformFlags platformFlags = GetEnabledPlatformFlags(GetEngineRoot(), appRoot, AZ::Utils::GetProjectPath().c_str());
        auto platformsString = AzFramework::PlatformHelper::GetCommaSeparatedPlatformList(platformFlags);

        AZ_TracePrintf(AppWindowName, "No platform specified, defaulting to platforms ( %s ).\n", platformsString.c_str());
@@ -1573,7 +1552,8 @@ namespace AssetBundler
        // Add Default Seed List Files
        if (params.m_addDefaultSeedListFiles)
        {
-            AZStd::unordered_map<AZStd::string, AZStd::string> defaultSeedListFiles = GetDefaultSeedListFiles(AssetBundler::g_cachedEngineRoot, m_currentProjectName.c_str(), m_gemInfoList, params.m_platformFlags);
+            AZStd::unordered_map<AZStd::string, AZStd::string> defaultSeedListFiles = GetDefaultSeedListFiles(GetEngineRoot(), AZ::Utils::GetProjectPath(),
+                m_gemInfoList, params.m_platformFlags);
            if (defaultSeedListFiles.empty())
            {
                // Error has already been thrown
@@ -1590,7 +1570,7 @@ namespace AssetBundler
                }
            }

-            AZStd::vector<AZStd::string> defaultSeeds = GetDefaultSeeds(AssetBundler::g_cachedEngineRoot, m_currentProjectName.c_str());
+            AZStd::vector<AZStd::string> defaultSeeds = GetDefaultSeeds(GetEngineRoot(), AZ::Utils::GetProjectPath(), m_currentProjectName);
            if (defaultSeeds.empty())
            {
                // Error has already been thrown
@@ -1830,9 +1810,9 @@ namespace AssetBundler

        bool hasError = false;

-        for (const AZStd::string_view& platformName : AzFramework::PlatformHelper::GetPlatformsInterpreted(paramsOutcome.GetValue().m_platformFlags))
+        for (AZStd::string platformName : AzFramework::PlatformHelper::GetPlatformsInterpreted(paramsOutcome.GetValue().m_platformFlags))
        {
-            AZ_TracePrintf(AssetBundler::AppWindowName, "Running Compare command for the %.*s platform...\n", aznumeric_cast<int>(platformName.size()), platformName.data());
+            AZ_TracePrintf(AssetBundler::AppWindowName, "Running Compare command for the %s platform...\n", platformName.c_str());

            ComparisonParams params = paramsOutcome.GetValue();
            AddPlatformToAllComparisonParams(params, platformName);
@@ -2687,7 +2667,7 @@ namespace AssetBundler
            AZ_Printf(AppWindowName, "          \"path\" - This refers to an Engine-Root-Relative path.\n");
            AZ_Printf(AppWindowName, "                 - Example: \"C:\\Lumberyard\\dev\\SamplesProject\\test.txt\" can be represented as \"SamplesProject\\test.txt\".\n");
            AZ_Printf(AppWindowName, "    \"cache path\" - This refers to a Cache-Relative path.\n");
-            AZ_Printf(AppWindowName, "                 - Example: \"C:\\Lumberyard\\dev\\Cache\\SamplesProject\\pc\\samplesproject\\animations\\skeletonlist.xml\" is represented as \"animations\\skeletonlist.xml\".\n");
+            AZ_Printf(AppWindowName, "                 - Example: \"C:\\Lumberyard\\dev\\SamplesProject\\Cache\\pc\\animations\\skeletonlist.xml\" is represented as \"animations\\skeletonlist.xml\".\n");
            AZ_Printf(AppWindowName, "\n");

            OutputHelpSeeds();
@@ -2718,7 +2698,7 @@ namespace AssetBundler
        AZ_Printf(AppWindowName, "%-31s---Takes in a cache path to a pre-processed asset.\n", "");
        AZ_Printf(AppWindowName, "    --%-25s-Removes the asset from the list of root assets for the specified platform.\n", RemoveSeedArg);
        AZ_Printf(AppWindowName, "%-31s---To completely remove the asset, it must be removed for all platforms.\n", "");
-        AZ_Printf(AppWindowName, "%-31s---Takes in a cache path to a pre-processed asset. A cache path is a path relative to \"...\\dev\\Cache\\ProjectName\\platform\\projectname\\\"\n", "");
+        AZ_Printf(AppWindowName, "%-31s---Takes in a cache path to a pre-processed asset. A cache path is a path relative to \"ProjectPath\\Cache\\platform\\\"\n", "");
        AZ_Printf(AppWindowName, "    --%-25s-Adds the specified platform to every Seed in the Seed List file, if possible.\n", AddPlatformToAllSeedsFlag);
        AZ_Printf(AppWindowName, "    --%-25s-Removes the specified platform from every Seed in the Seed List file, if possible.\n", RemovePlatformFromAllSeedsFlag);
        AZ_Printf(AppWindowName, "    --%-25s-Outputs the contents of the Seed List file after performing any specified operations.\n", PrintFlag);
@@ -2730,7 +2710,7 @@ namespace AssetBundler
        AZ_Printf(AppWindowName, "    --%-25s-Allows input file path to still match if the file path case is different than on disk.\n", IgnoreFileCaseFlag);
        AZ_Printf(AppWindowName, "    --%-25s-[Testing] Specifies the Asset Catalog file referenced by all Seed operations.\n", AssetCatalogFileArg);
        AZ_Printf(AppWindowName, "%-31s---Designed to be used in Unit Tests.\n", "");
-        AZ_Printf(AppWindowName, "    --%-25s-Specifies the game project to use rather than the current default project set in bootsrap.cfg's sys_game_folder.\n", ProjectArg);
+        AZ_Printf(AppWindowName, "    --%-25s-Specifies the game project to use rather than the current default project set in bootstrap.cfg's project_path.\n", ProjectArg);
    }

    void ApplicationManager::OutputHelpAssetLists()
@@ -2740,7 +2720,7 @@ namespace AssetBundler
        AZ_Printf(AppWindowName, "    --%-25s-Specifies the Asset List file to operate on by path. Must include (.%s) file extension.\n", AssetListFileArg, AssetSeedManager::GetAssetListFileExtension());
        AZ_Printf(AppWindowName, "    --%-25s-Specifies the Seed List file(s) that will be used as root(s) when generating this Asset List file.\n", SeedListFileArg);
        AZ_Printf(AppWindowName, "    --%-25s-Specifies the Seed(s) to use as root(s) when generating this Asset List File.\n", AddSeedArg);
-        AZ_Printf(AppWindowName, "%-31s---Takes in a cache path to a pre-processed asset. A cache path is a path relative to \"...\\dev\\Cache\\ProjectName\\platform\\projectname\\\"\n", "");
+        AZ_Printf(AppWindowName, "%-31s---Takes in a cache path to a pre-processed asset. A cache path is a path relative to \"ProjectPath\\Cache\\platform\\\"\n", "");
        AZ_Printf(AppWindowName, "    --%-25s-The specified files and all dependencies will be ignored when generating the Asset List file.\n", SkipArg);
        AZ_Printf(AppWindowName, "%-31s---Takes in a comma-separated list of either: cache paths to pre-processed assets, or wildcard patterns.\n", "");
        AZ_Printf(AppWindowName, "    --%-25s-Automatically include all default Seed List files in generated Asset List File.\n", AddDefaultSeedListFilesFlag);
@@ -2754,7 +2734,7 @@ namespace AssetBundler
        AZ_Printf(AppWindowName, "    --%-25s-Run all input commands, without saving to the specified Asset List file.\n", DryRunFlag);
        AZ_Printf(AppWindowName, "    --%-25s-Generates a human-readable file that maps every entry in the Asset List file to the Seed that generated it.\n", GenerateDebugFileFlag);
        AZ_Printf(AppWindowName, "    --%-25s-Allow destructive overwrites of files. Include this arg in automation.\n", AllowOverwritesFlag);
-        AZ_Printf(AppWindowName, "    --%-25s-Specifies the game project to use rather than the current default project set in bootsrap.cfg's sys_game_folder.\n", ProjectArg);
+        AZ_Printf(AppWindowName, "    --%-25s-Specifies the game project to use rather than the current default project set in bootstrap.cfg's project_path.\n", ProjectArg);
    }

    void ApplicationManager::OutputHelpComparisonRules()
@@ -2781,7 +2761,7 @@ namespace AssetBundler
        AZ_Printf(AppWindowName, "    --%-25s-The Token name of the Comparison Step you wish to use as the second input of this Comparison Step.\n", ComparisonSecondInputArg);
        AZ_Printf(AppWindowName, "%-31s---Comparison Steps of the ( FilePattern ) type only accept one input Token, and cannot be used with this arg.\n", "");
        AZ_Printf(AppWindowName, "    --%-25s-Outputs the contents of the Comparison Rules file after performing any specified operations.\n", PrintFlag);
-        AZ_Printf(AppWindowName, "    --%-25s-Specifies the game project to use rather than the current default project set in bootsrap.cfg's sys_game_folder.\n", ProjectArg);
+        AZ_Printf(AppWindowName, "    --%-25s-Specifies the game project to use rather than the current default project set in bootstrap.cfg's project_path.\n", ProjectArg);
    }

    void ApplicationManager::OutputHelpCompare()
@@ -2813,7 +2793,7 @@ namespace AssetBundler
        AZ_Printf(AppWindowName, "%-31s---All input Asset List files must exist for all specified platforms\n", "");
        AZ_Printf(AppWindowName, "%-31s---Defaults to all enabled platforms. Platforms can be changed by modifying AssetProcessorPlatformConfig.ini.\n", "");
        AZ_Printf(AppWindowName, "    --%-25s-Allow destructive overwrites of files. Include this arg in automation.\n", AllowOverwritesFlag);
-        AZ_Printf(AppWindowName, "    --%-25s-Specifies the game project to use rather than the current default project set in bootsrap.cfg's sys_game_folder.\n", ProjectArg);
+        AZ_Printf(AppWindowName, "    --%-25s-Specifies the game project to use rather than the current default project set in bootstrap.cfg's project_path.\n", ProjectArg);
    }

    void ApplicationManager::OutputHelpBundleSettings()
@@ -2829,7 +2809,7 @@ namespace AssetBundler
        AZ_Printf(AppWindowName, "    --%-25s-Specifies the platform(s) referenced by all Bundle Settings operations.\n", PlatformArg);
        AZ_Printf(AppWindowName, "%-31s---Defaults to all enabled platforms. Platforms can be changed by modifying AssetProcessorPlatformConfig.ini.\n", "");
        AZ_Printf(AppWindowName, "    --%-25s-Outputs the contents of the Bundle Settings file after modifying any specified values.\n", PrintFlag);
-        AZ_Printf(AppWindowName, "    --%-25s-Specifies the game project to use rather than the current default project set in bootsrap.cfg's sys_game_folder.\n", ProjectArg);
+        AZ_Printf(AppWindowName, "    --%-25s-Specifies the game project to use rather than the current default project set in bootstrap.cfg's project_path.\n", ProjectArg);
    }

    void ApplicationManager::OutputHelpBundles()
@@ -2846,7 +2826,7 @@ namespace AssetBundler
        AZ_Printf(AppWindowName, "    --%-25s-Specifies the platform(s) that will be referenced when generating Bundles.\n", PlatformArg);
        AZ_Printf(AppWindowName, "%-31s---If no platforms are specified, Bundles will be generated for all available platforms.\n", "");
        AZ_Printf(AppWindowName, "    --%-25s-Allow destructive overwrites of files. Include this arg in automation.\n", AllowOverwritesFlag);
-        AZ_Printf(AppWindowName, "    --%-25s-Specifies the game project to use rather than the current default project set in bootsrap.cfg's sys_game_folder.\n", ProjectArg);
+        AZ_Printf(AppWindowName, "    --%-25s-Specifies the game project to use rather than the current default project set in bootstrap.cfg's project_path.\n", ProjectArg);
    }

    void ApplicationManager::OutputHelpBundleSeed()
@@ -2854,7 +2834,7 @@ namespace AssetBundler
        using namespace AzToolsFramework;
        AZ_Printf(AppWindowName, "\n%-25s-Subcommand for generating bundles directly from seeds. Must provide either (--%s) or (--%s).\n", BundleSeedCommand, BundleSettingsFileArg, OutputBundlePathArg);
        AZ_Printf(AppWindowName, "    --%-25s-Adds the asset to the list of root assets for the specified platform.\n", AddSeedArg);
-        AZ_Printf(AppWindowName, "%-31s---Takes in a cache path to a pre-processed asset. A cache path is a path relative to \"...\\dev\\Cache\\ProjectName\\platform\\projectname\\\"\n", "");
+        AZ_Printf(AppWindowName, "%-31s---Takes in a cache path to a pre-processed asset. A cache path is a path relative to \"ProjectPath\\Cache\\platform\\\"\n", "");
        AZ_Printf(AppWindowName, "    --%-25s-Specifies the Bundle Settings file to operate on by path. Must include (.%s) file extension.\n", BundleSettingsFileArg, AssetBundleSettings::GetBundleSettingsFileExtension());
        AZ_Printf(AppWindowName, "    --%-25s-Sets the path where generated Bundles will be stored. Must include (.%s) file extension.\n", OutputBundlePathArg, AssetBundleSettings::GetBundleFileExtension());
        AZ_Printf(AppWindowName, "    --%-25s-Determines which version of Lumberyard Bundles to generate. Current version is (%i).\n", BundleVersionArg, AzFramework::AssetBundleManifest::CurrentBundleVersion);
@@ -2865,7 +2845,7 @@ namespace AssetBundler
        AZ_Printf(AppWindowName, "    --%-25s-Allow destructive overwrites of files. Include this arg in automation.\n", AllowOverwritesFlag);
        AZ_Printf(AppWindowName, "    --%-25s-[Testing] Specifies the Asset Catalog file referenced by all Bundle operations.\n", AssetCatalogFileArg);
        AZ_Printf(AppWindowName, "%-31s---Designed to be used in Unit Tests.\n", "");
-        AZ_Printf(AppWindowName, "    --%-25s-Specifies the game project to use rather than the current default project set in bootsrap.cfg's sys_game_folder.\n", ProjectArg);
+        AZ_Printf(AppWindowName, "    --%-25s-Specifies the game project to use rather than the current default project set in bootstrap.cfg's project_path.\n", ProjectArg);
    }

    ////////////////////////////////////////////////////////////////////////////////////////////
@@ -185,7 +185,7 @@ namespace AssetBundler
        ////////////////////////////////////////////////////////////////////////////////////////////

        AZStd::string GetCurrentProjectName() { return m_currentProjectName; }
-        AZStd::vector<AzToolsFramework::AssetUtils::GemInfo> GetGemInfoList() { return m_gemInfoList; }
+        AZStd::vector<AzFramework::GemInfo> GetGemInfoList() { return m_gemInfoList; }

    protected:
        ////////////////////////////////////////////////////////////////////////////////////////////
@@ -288,7 +288,7 @@ namespace AssetBundler

        AZStd::unique_ptr<AzToolsFramework::AssetSeedManager> m_assetSeedManager;
        AZStd::unique_ptr<AzToolsFramework::PlatformAddressedAssetCatalogManager> m_platformCatalogManager;
-        AZStd::vector<AzToolsFramework::AssetUtils::GemInfo> m_gemInfoList;
+        AZStd::vector<AzFramework::GemInfo> m_gemInfoList;
        bool m_showVerboseOutput = false;
        AZStd::string m_currentProjectName;

@@ -24,6 +24,7 @@
 #include <AzCore/Settings/SettingsRegistryMergeUtils.h>
 #include <AzCore/std/algorithm.h>
 #include <AzCore/std/string/regex.h>
+#include <AzCore/Utils/Utils.h>
 #include <cctype>

 AZ_PUSH_DISABLE_WARNING(4244 4251, "-Wunknown-warning-option")
@@ -57,8 +58,8 @@ namespace AssetBundler
    const char* RemovePlatformFromAllSeedsFlag = "removePlatformFromSeeds";
    const char* UpdateSeedPathArg = "updateSeedPath";
    const char* RemoveSeedPathArg = "removeSeedPath";
-    const char* DefaultProjectTemplatePath = "ProjectTemplates/DefaultTemplate/${ProjectName}";
-    const char* ProjectName = "${ProjectName}";
+    const char* DefaultProjectTemplatePath = "Templates/DefaultProject/Template";
+    const char* ProjectName = "${Name}";
    const char* DependenciesFileSuffix = "_Dependencies";
    const char* DependenciesFileExtension = "xml";

@@ -107,8 +108,6 @@ namespace AssetBundler

    const char* AssetCatalogFilename = "assetcatalog.xml";

-    char g_cachedEngineRoot[AZ_MAX_PATH_LEN];
-
    
    const char EngineDirectoryName[] = "Engine";
    const char RestrictedDirectoryName[] = "restricted";
@@ -124,16 +123,15 @@ namespace AssetBundler
        const AZ::u32 PlatformFlags_RESTRICTED = aznumeric_cast<AZ::u32>(AzFramework::PlatformFlags::Platform_JASPER | AzFramework::PlatformFlags::Platform_PROVO | AzFramework::PlatformFlags::Platform_SALEM);

        void AddPlatformSeeds(
-            AZStd::string rootFolder,
+            const AZ::IO::Path& engineDirectory,
            const AZStd::string& rootFolderDisplayName,
            AZStd::unordered_map<AZStd::string, AZStd::string>& defaultSeedLists,
            AzFramework::PlatformFlags platformFlags)
        {
            AZ::IO::FixedMaxPath engineRoot(GetEngineRoot());
-            AZ::IO::FixedMaxPath engineRestrcitedRoot = engineRoot / RestrictedDirectoryName;
+            AZ::IO::FixedMaxPath engineRestrictedRoot = engineRoot / RestrictedDirectoryName;

-            AZ::IO::FixedMaxPath inputPath = AZ::IO::FixedMaxPath(rootFolder);
-            AZ::IO::FixedMaxPath engineLocalPath = inputPath.LexicallyRelative(engineRoot);
+            AZ::IO::FixedMaxPath engineLocalPath = AZ::IO::PathView(engineDirectory.LexicallyRelative(engineRoot));

            AZ::IO::FileIOBase* fileIO = AZ::IO::FileIOBase::GetInstance();
            auto platformsIdxList = AzFramework::PlatformHelper::GetPlatformIndicesInterpreted(platformFlags);
@@ -146,11 +144,11 @@ namespace AssetBundler
                AZ::IO::FixedMaxPath platformDirectory;
                if (aznumeric_cast<AZ::u32>(platformFlag) & PlatformFlags_RESTRICTED)
                {
-                    platformDirectory = engineRestrcitedRoot / platformDirName / engineLocalPath;
+                    platformDirectory = engineRestrictedRoot / platformDirName / engineLocalPath;
                }
                else
                {
-                    platformDirectory = inputPath / PlatformsDirectoryName / platformDirName;
+                    platformDirectory = engineDirectory / PlatformsDirectoryName / platformDirName;
                }

                if (fileIO->Exists(platformDirectory.c_str()))
@@ -174,7 +172,7 @@ namespace AssetBundler
        }

        void AddPlatformsDirectorySeeds(
-            const AZStd::string& rootFolder,
+            const AZ::IO::Path& engineDirectory,
            const AZStd::string& rootFolderDisplayName,
            AZStd::unordered_map<AZStd::string, AZStd::string>& defaultSeedLists,
            AzFramework::PlatformFlags platformFlags)
@@ -185,8 +183,7 @@ namespace AssetBundler
            // Check whether platforms directory exists inside the root, if yes than add
            // * All seed files from the platforms directory
            // * All platform specific seed files based on the platform flags specified. 
-            AZStd::string platformsDirectory;
-            AzFramework::StringFunc::Path::Join(rootFolder.c_str(), PlatformsDirectoryName, platformsDirectory);
+            auto platformsDirectory = engineDirectory / PlatformsDirectoryName;
            if (fileIO->Exists(platformsDirectory.c_str()))
            {
                fileIO->FindFiles(platformsDirectory.c_str(),
@@ -200,119 +197,19 @@ namespace AssetBundler
                    });
            }

-            AddPlatformSeeds(rootFolder, rootFolderDisplayName, defaultSeedLists, platformFlags);
+            AddPlatformSeeds(engineDirectory, rootFolderDisplayName, defaultSeedLists, platformFlags);
        }
    }

-    bool ComputeEngineRoot()
+    AZ::IO::FixedMaxPath GetEngineRoot()
    {
-        if (g_cachedEngineRoot[0])
+        AZ::IO::FixedMaxPath engineRootPath;
+        if (auto settingsRegistry = AZ::SettingsRegistry::Get(); settingsRegistry != nullptr)
        {
-            return true;
+            settingsRegistry->Get(engineRootPath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_EngineRootFolder);
        }

-        const char* engineRoot = nullptr;
-        AzFramework::ApplicationRequests::Bus::BroadcastResult(engineRoot, &AzFramework::ApplicationRequests::GetEngineRoot);
-        if (!engineRoot)
-        {
-            AZ_Error(AssetBundler::AppWindowName, false, "Unable to locate engine root.\n");
-            return false;
-        }
-
-        azstrcpy(g_cachedEngineRoot, AZ_MAX_PATH_LEN, engineRoot);
-        return true;
-    }
-
-    const char* GetEngineRoot()
-    {
-        if (!g_cachedEngineRoot[0])
-        {
-            ComputeEngineRoot();
-        }
-
-        return g_cachedEngineRoot;
-    }
-
-    AZ::Outcome<void, AZStd::string> ComputeAssetAliasAndGameName(const AZStd::string& platformIdentifier, const AZStd::string& assetCatalogFile, AZStd::string& assetAlias, AZStd::string& gameName)
-    {
-        AZStd::string assetPath;
-        AZStd::string gameFolder;
-        if (!ComputeEngineRoot())
-        {
-            return AZ::Failure(AZStd::string("Unable to compute engine root.\n"));
-        }
-        if (assetCatalogFile.empty())
-        {
-            if (gameName.empty())
-            {
-                bool checkPlatform = false;
-                bool result{};
-
-                auto gameFolderKey = AZ::SettingsRegistryInterface::FixedValueString::format("%s/%s",
-                    AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey, AzFramework::AssetSystem::ProjectName);
-                if (auto settingsRegistry = AZ::SettingsRegistry::Get(); settingsRegistry != nullptr)
-                {
-                    result = settingsRegistry->Get(gameFolder, gameFolderKey);
-                }
-
-                if (!result)
-                {
-                    return AZ::Failure(AZStd::string("Unable to locate game name in bootstrap.\n"));
-                }
-
-                gameName = gameFolder;
-            }
-            else
-            {
-                gameFolder = gameName;
-            }
-
-            // Appending Cache/%gamename%/%platform%/%gameName% to the engine root
-            bool success = AzFramework::StringFunc::Path::ConstructFull(g_cachedEngineRoot, "Cache", assetPath) &&
-                AzFramework::StringFunc::Path::ConstructFull(assetPath.c_str(), gameFolder.c_str(), assetPath) &&
-                AzFramework::StringFunc::Path::ConstructFull(assetPath.c_str(), platformIdentifier.c_str(), assetPath);
-            if (success)
-            {
-                AZStd::to_lower(gameFolder.begin(), gameFolder.end());
-                success = AzFramework::StringFunc::Path::ConstructFull(assetPath.c_str(), gameFolder.c_str(), assetPath); // game name is lowercase
-            }
-
-            if (success)
-            {
-                assetAlias = assetPath;
-            }
-        }
-        else if (AzFramework::StringFunc::Path::GetFullPath(assetCatalogFile.c_str(), assetPath))
-        {
-            AzFramework::StringFunc::Strip(assetPath, AZ_CORRECT_FILESYSTEM_SEPARATOR, false, false, true);
-            assetAlias = assetPath;
-
-            // 3rd component from reverse should give us the correct case game name because the assetalias directory 
-            // looks like ./Cache/%GameName%/%platform%/%gameName%/assetcatalog.xml
-            // GetComponent util method returns the component with the separator appended at the end 
-            // therefore we need to strip the separator to get the game name string
-            gameFolder = AZ::IO::PathView(assetPath).ParentPath().ParentPath().Filename().Native();
-            if (gameFolder.empty())
-            {
-                return AZ::Failure(AZStd::string::format("Unable to retrieve game name from assetCatalog file (%s).\n", assetCatalogFile.c_str()));
-            }
-
-            if (!AzFramework::StringFunc::Strip(gameFolder, AZ_CORRECT_FILESYSTEM_SEPARATOR, false, false, true))
-            {
-                return AZ::Failure(AZStd::string::format("Unable to strip separator from game name (%s).\n", gameFolder.c_str()));
-            }
-
-            if (!gameName.empty() && !AzFramework::StringFunc::Equal(gameFolder.c_str(), gameName.c_str()))
-            {
-                return AZ::Failure(AZStd::string::format("Game name retrieved from the assetCatalog file (%s) does not match the inputted game name (%s).\n", gameFolder.c_str(), gameName.c_str()));
-            }
-            else
-            {
-                gameName = gameFolder;
-            }
-        }
-
-        return AZ::Success();
+        return engineRootPath;
    }

    void AddPlatformIdentifier(AZStd::string& filePath, const AZStd::string& platformIdentifier)
@@ -346,7 +243,8 @@ namespace AssetBundler
        return platformFlags;
    }

-    AZStd::unordered_map<AZStd::string, AZStd::string> GetDefaultSeedListFiles(const char* root, const char* projectName, const AZStd::vector<AzToolsFramework::AssetUtils::GemInfo>& gemInfoList, AzFramework::PlatformFlags platformFlag)
+    AZStd::unordered_map<AZStd::string, AZStd::string> GetDefaultSeedListFiles(AZStd::string_view enginePath, AZStd::string_view projectPath,
+        const AZStd::vector<AzFramework::GemInfo>& gemInfoList, AzFramework::PlatformFlags platformFlag)
    {
        AZ::IO::FileIOBase* fileIO = AZ::IO::FileIOBase::GetInstance();
        AZ_Assert(fileIO, "AZ::IO::FileIOBase must be ready for use.\n");
@@ -354,63 +252,65 @@ namespace AssetBundler
        // Add all seed list files of enabled gems for the given project
        AZStd::unordered_map<AZStd::string, AZStd::string> defaultSeedLists = GetGemSeedListFilePathToGemNameMap(gemInfoList, platformFlag);

+
        // Add the engine seed list file
-        AZStd::string engineDirectory;
-        AzFramework::StringFunc::Path::Join(root, EngineDirectoryName, engineDirectory);
-        AZStd::string absoluteEngineSeedFilePath;
-        AzFramework::StringFunc::Path::ConstructFull(engineDirectory.c_str(), EngineSeedFileName, AzToolsFramework::AssetSeedManager::GetSeedFileExtension(), absoluteEngineSeedFilePath, true);
+        AZ::IO::Path engineDirectory = AZ::IO::Path(enginePath) / EngineDirectoryName;
+        auto absoluteEngineSeedFilePath = engineDirectory / EngineSeedFileName;
+        absoluteEngineSeedFilePath.ReplaceExtension(AzToolsFramework::AssetSeedManager::GetSeedFileExtension());
        if (fileIO->Exists(absoluteEngineSeedFilePath.c_str()))
        {
-            defaultSeedLists[absoluteEngineSeedFilePath] = EngineDirectoryName;
+            defaultSeedLists[absoluteEngineSeedFilePath.Native()] = EngineDirectoryName;
        }

        // Add Seed Lists from the Platforms directory
        Internal::AddPlatformsDirectorySeeds(engineDirectory, EngineDirectoryName, defaultSeedLists, platformFlag);

-
-        AZStd::string absoluteProjectDefaultSeedFilePath;
-        AzFramework::StringFunc::Path::ConstructFull(root, projectName, EngineSeedFileName, AzToolsFramework::AssetSeedManager::GetSeedFileExtension(), absoluteProjectDefaultSeedFilePath, true);
+        auto absoluteProjectDefaultSeedFilePath = AZ::IO::Path(projectPath) / EngineSeedFileName;
+        absoluteProjectDefaultSeedFilePath.ReplaceExtension(AzToolsFramework::AssetSeedManager::GetSeedFileExtension());

        if (fileIO->Exists(absoluteProjectDefaultSeedFilePath.c_str()))
        {
-            defaultSeedLists[absoluteProjectDefaultSeedFilePath] = projectName;
+            defaultSeedLists[absoluteProjectDefaultSeedFilePath.Native()] = projectPath;
        }

        return defaultSeedLists;
    }

-    AZStd::vector<AZStd::string> GetDefaultSeeds(const char* root, const char* projectName)
+    AZStd::vector<AZStd::string> GetDefaultSeeds(AZStd::string_view enginePath, AZStd::string_view projectPath, AZStd::string_view projectName)
    {
        AZStd::vector<AZStd::string> defaultSeeds;

-        defaultSeeds.emplace_back(GetProjectDependenciesAssetPath(root, projectName));
+        defaultSeeds.emplace_back(GetProjectDependenciesAssetPath(enginePath, projectPath, projectName));

        return defaultSeeds;
    }

-    AZStd::string GetProjectDependenciesFile(const char* root, const char* projectName)
+    AZ::IO::Path GetProjectDependenciesFile(AZStd::string_view projectPath, AZStd::string_view projectName)
    {
-        AZStd::string projectDependenciesFilePath = AZStd::string::format("%s%s", projectName, DependenciesFileSuffix);
-        AzFramework::StringFunc::Path::ConstructFull(root, projectName, projectDependenciesFilePath.c_str(), DependenciesFileExtension, projectDependenciesFilePath, true);
-        return projectDependenciesFilePath;
+        AZ::IO::Path projectDependenciesFilePath = projectPath;
+        projectDependenciesFilePath /= AZStd::string::format("%.*s%s", aznumeric_cast<int>(projectName.size()), projectName.data(),
+            DependenciesFileSuffix);
+        projectDependenciesFilePath.ReplaceExtension(DependenciesFileExtension);
+        return projectDependenciesFilePath.LexicallyNormal();
    }

-    AZStd::string GetProjectDependenciesFileTemplate(const char* root)
+    AZ::IO::Path GetProjectDependenciesFileTemplate(AZStd::string_view engineRoot)
    {
-        AZStd::string projectDependenciesFileTemplate = ProjectName;
-        projectDependenciesFileTemplate += DependenciesFileSuffix;
-        AzFramework::StringFunc::Path::ConstructFull(root, DefaultProjectTemplatePath, projectDependenciesFileTemplate.c_str(), DependenciesFileExtension, projectDependenciesFileTemplate, true);
-        return projectDependenciesFileTemplate;
+        AZ::IO::Path projectDependenciesFileTemplate = engineRoot;
+        projectDependenciesFileTemplate /= DefaultProjectTemplatePath;
+        projectDependenciesFileTemplate /= AZStd::string::format("%s%s", ProjectName, DependenciesFileSuffix);
+        projectDependenciesFileTemplate.ReplaceExtension(DependenciesFileExtension);
+        return projectDependenciesFileTemplate.LexicallyNormal();
    }

-    AZStd::string GetProjectDependenciesAssetPath(const char* root, const char* projectName)
+    AZ::IO::Path GetProjectDependenciesAssetPath(AZStd::string_view enginePath, AZStd::string_view projectPath, AZStd::string_view projectName)
    {
-        AZStd::string projectDependenciesFile = AZStd::move(GetProjectDependenciesFile(root, projectName));
+        AZ::IO::Path projectDependenciesFile = GetProjectDependenciesFile(projectPath, projectName);
        if (!AZ::IO::FileIOBase::GetInstance()->Exists(projectDependenciesFile.c_str()))
        {
            AZ_TracePrintf(AssetBundler::AppWindowName, "Project dependencies file %s doesn't exist.\n", projectDependenciesFile.c_str());

-            AZStd::string projectDependenciesFileTemplate = AZStd::move(GetProjectDependenciesFileTemplate(root));
+            AZ::IO::Path projectDependenciesFileTemplate = GetProjectDependenciesFileTemplate(enginePath);
            if (AZ::IO::FileIOBase::GetInstance()->Copy(projectDependenciesFileTemplate.c_str(), projectDependenciesFile.c_str()))
            {
                AZ_TracePrintf(AssetBundler::AppWindowName, "Copied project dependencies file template %s to the current project.\n",
@@ -425,37 +325,39 @@ namespace AssetBundler
        }

        // Turn the absolute path into a cache-relative path
-        AZStd::string relativeProductPath;
-        AzFramework::StringFunc::Path::GetFullFileName(projectDependenciesFile.c_str(), relativeProductPath);
-        AZStd::to_lower(relativeProductPath.begin(), relativeProductPath.end());
+        AZ::IO::Path relativeProductPath = projectDependenciesFile.Filename().Native();
+        AZStd::to_lower(relativeProductPath.Native().begin(), relativeProductPath.Native().end());

        return relativeProductPath;
    }

-    AZStd::unordered_map<AZStd::string, AZStd::string> GetGemSeedListFilePathToGemNameMap(const AZStd::vector<AzToolsFramework::AssetUtils::GemInfo>& gemInfoList, AzFramework::PlatformFlags platformFlags)
+    AZStd::unordered_map<AZStd::string, AZStd::string> GetGemSeedListFilePathToGemNameMap(const AZStd::vector<AzFramework::GemInfo>& gemInfoList, AzFramework::PlatformFlags platformFlags)
    {
        AZStd::unordered_map<AZStd::string, AZStd::string> filePathToGemNameMap;
-        for (const AzToolsFramework::AssetUtils::GemInfo& gemInfo : gemInfoList)
+        for (const AzFramework::GemInfo& gemInfo : gemInfoList)
        {
-            AZ::IO::Path gemInfoAssetFilePath = gemInfo.m_absoluteFilePath;
-            gemInfoAssetFilePath /= gemInfo.GetGemAssetFolder();
-            AZ::IO::Path absoluteGemSeedFilePath = gemInfoAssetFilePath / GemsSeedFileName;
-            absoluteGemSeedFilePath.ReplaceExtension(AZ::IO::PathView{ AzToolsFramework::AssetSeedManager::GetSeedFileExtension() });
-            absoluteGemSeedFilePath = absoluteGemSeedFilePath.LexicallyNormal();
-
-            AZStd::string gemName = gemInfo.m_gemName + " Gem";
-            if (AZ::IO::FileIOBase::GetInstance()->Exists(absoluteGemSeedFilePath.c_str()))
+            for (const AZ::IO::Path& gemAbsoluteSourcePath : gemInfo.m_absoluteSourcePaths)
            {
-                filePathToGemNameMap[absoluteGemSeedFilePath.Native()] = gemName;
-            }
+                AZ::IO::Path gemInfoAssetFilePath = gemAbsoluteSourcePath;
+                gemInfoAssetFilePath /= gemInfo.GetGemAssetFolder();
+                AZ::IO::Path absoluteGemSeedFilePath = gemInfoAssetFilePath / GemsSeedFileName;
+                absoluteGemSeedFilePath.ReplaceExtension(AZ::IO::PathView{ AzToolsFramework::AssetSeedManager::GetSeedFileExtension() });
+                absoluteGemSeedFilePath = absoluteGemSeedFilePath.LexicallyNormal();

-            Internal::AddPlatformsDirectorySeeds(gemInfoAssetFilePath.Native(), gemName, filePathToGemNameMap, platformFlags);
+                AZStd::string gemName = gemInfo.m_gemName + " Gem";
+                if (AZ::IO::FileIOBase::GetInstance()->Exists(absoluteGemSeedFilePath.c_str()))
+                {
+                    filePathToGemNameMap[absoluteGemSeedFilePath.Native()] = gemName;
+                }
+
+                Internal::AddPlatformsDirectorySeeds(gemInfoAssetFilePath.Native(), gemName, filePathToGemNameMap, platformFlags);
+            }
        }

        return filePathToGemNameMap;
    }

-    bool IsGemSeedFilePathValid(const char* root, AZStd::string seedAbsoluteFilePath, const AZStd::vector<AzToolsFramework::AssetUtils::GemInfo>& gemInfoList, AzFramework::PlatformFlags platformFlags)
+    bool IsGemSeedFilePathValid(AZStd::string_view engineRoot, AZStd::string seedAbsoluteFilePath, const AZStd::vector<AzFramework::GemInfo>& gemInfoList, AzFramework::PlatformFlags platformFlags)
    {
        AZ::IO::FileIOBase* fileIO = AZ::IO::FileIOBase::GetInstance();
        AZ_Assert(fileIO, "AZ::IO::FileIOBase must be ready for use.\n");
@@ -465,9 +367,8 @@ namespace AssetBundler
            return false;
        }

-        AZ::IO::Path gemsFolder{ root };
+        AZ::IO::Path gemsFolder{ engineRoot };
        gemsFolder /= GemsDirectoryName;
-        gemsFolder /= GemsAssetsDirectoryName;
        gemsFolder = gemsFolder.LexicallyNormal();
        if (!AzFramework::StringFunc::StartsWith(seedAbsoluteFilePath, gemsFolder.Native()))
        {
@@ -476,36 +377,45 @@ namespace AssetBundler
            return true;
        }

-        for (const AzToolsFramework::AssetUtils::GemInfo& gemInfo : gemInfoList)
+        for (const AzFramework::GemInfo& gemInfo : gemInfoList)
        {
-            // We want to check the path before going through the effort of creating the default Seed List file map
-            if (!AzFramework::StringFunc::StartsWith(seedAbsoluteFilePath, gemInfo.m_absoluteFilePath))
+            for (const AZ::IO::Path& gemAbsoluteSourcePath : gemInfo.m_absoluteSourcePaths)
            {
-                continue;
-            }
+                // We want to check the path before going through the effort of creating the default Seed List file map
+                if (!AzFramework::StringFunc::StartsWith(seedAbsoluteFilePath, gemAbsoluteSourcePath.Native()))
+                {
+                    continue;
+                }

-            AZStd::unordered_map<AZStd::string, AZStd::string> seeds = GetGemSeedListFilePathToGemNameMap({gemInfo}, platformFlags);
+                AZStd::unordered_map<AZStd::string, AZStd::string> seeds = GetGemSeedListFilePathToGemNameMap({ gemInfo }, platformFlags);

-            if (seeds.find(seedAbsoluteFilePath) != seeds.end())
-            {
-                return true;
+                if (seeds.find(seedAbsoluteFilePath) != seeds.end())
+                {
+                    return true;
+                }
+                // If we have not validated the input path yet, we need to keep looking, or we will return false negatives
+                //    for Gems that have the same prefix in their name
            }
-            // If we have not validated the input path yet, we need to keep looking, or we will return false negatives
-            //    for Gems that have the same prefix in their name
        }

        return false;
    }

-    AzFramework::PlatformFlags GetEnabledPlatformFlags(const char* root, const char* assetRoot, const char* gameName)
+    AzFramework::PlatformFlags GetEnabledPlatformFlags(AZStd::string_view engineRoot, AZStd::string_view assetRoot, AZStd::string_view projectPath)
    {
-        QStringList configFiles = AzToolsFramework::AssetUtils::GetConfigFiles(root, assetRoot, gameName, true, true);
-
-        QStringList enabaledPlatformList = AzToolsFramework::AssetUtils::GetEnabledPlatforms(configFiles);
-        AzFramework::PlatformFlags platformFlags = AzFramework::PlatformFlags::Platform_NONE;
-        for (const QString& enabledPlatform : enabaledPlatformList)
+        auto settingsRegistry = AZ::SettingsRegistry::Get();
+        if (settingsRegistry == nullptr)
        {
-            AzFramework::PlatformFlags platformFlag = AzFramework::PlatformHelper::GetPlatformFlag(enabledPlatform.toUtf8().data());
+            AZ_Error(AssetBundler::AppWindowName, false, "Settings Registry is not available, enabled platform flags cannot be queried");
+            return AzFramework::PlatformFlags::Platform_NONE;
+        }
+
+        auto configFiles = AzToolsFramework::AssetUtils::GetConfigFiles(engineRoot, assetRoot, projectPath, true, true, settingsRegistry);
+        auto enabledPlatformList = AzToolsFramework::AssetUtils::GetEnabledPlatforms(*settingsRegistry, configFiles);
+        AzFramework::PlatformFlags platformFlags = AzFramework::PlatformFlags::Platform_NONE;
+        for (const auto& enabledPlatform : enabledPlatformList)
+        {
+            AzFramework::PlatformFlags platformFlag = AzFramework::PlatformHelper::GetPlatformFlag(enabledPlatform);

            if (platformFlag != AzFramework::PlatformFlags::Platform_NONE)
            {
@@ -513,7 +423,7 @@ namespace AssetBundler
            }
            else
            {
-                AZ_Warning(AssetBundler::AppWindowName, false, "Platform Helper is not aware of the platform (%s).\n ", enabledPlatform.toUtf8().data());
+                AZ_Warning(AssetBundler::AppWindowName, false, "Platform Helper is not aware of the platform (%s).\n ", enabledPlatform.c_str());
            }
        }

@@ -535,68 +445,60 @@ namespace AssetBundler

    AZ::Outcome<AZStd::string, AZStd::string> GetCurrentProjectName()
    {
-        AZStd::string gameName;
-        bool result{ false };
-        auto gameFolderKey = AZ::SettingsRegistryInterface::FixedValueString::format("%s/%s",
-            AZ::SettingsRegistryMergeUtils::BootstrapSettingsRootKey, AzFramework::AssetSystem::ProjectName);
-        if (auto settingsRegistry = AZ::SettingsRegistry::Get(); settingsRegistry != nullptr)
+        AZStd::string projectName{ AZStd::string_view(AZ::Utils::GetProjectName()) };
+        if (!projectName.empty())
        {
-            result = settingsRegistry->Get(gameName, gameFolderKey);
-        }
-
-        if (result)
-        {
-            return AZ::Success(gameName);
+            return AZ::Success(projectName);
        }
        else
        {
-            return AZ::Failure(AZStd::string("Unable to locate current project name in bootstrap.cfg"));
+            return AZ::Failure(AZStd::string("Unable to obtain current project name from registry"));
        }
    }

-    AZ::Outcome<AZStd::string, AZStd::string> GetProjectFolderPath(const AZStd::string& engineRoot, const AZStd::string& projectName)
+    AZ::Outcome<AZ::IO::Path, AZStd::string> GetProjectFolderPath()
    {
-        AZStd::string projectFolderPath;
-        bool success = AzFramework::StringFunc::Path::ConstructFull(engineRoot.c_str(), projectName.c_str(), projectFolderPath);
-
-        if (success && AZ::IO::FileIOBase::GetInstance()->Exists(projectFolderPath.c_str()))
+        AZ::IO::FixedMaxPath projectPath = AZ::Utils::GetProjectPath();
+        if (!projectPath.empty())
        {
-            return AZ::Success(projectFolderPath);
+            return AZ::Success(AZ::IO::Path{ AZ::IO::PathView(projectPath) });
        }
        else
        {
-            return AZ::Failure(AZStd::string::format( "Unable to locate the current Project folder: %s", projectName.c_str()));
+            return AZ::Failure(AZStd::string::format("Unable to obtain current project path from registry"));
        }
    }

-    AZ::Outcome<AZStd::string, AZStd::string> GetProjectCacheFolderPath(const AZStd::string& engineRoot, const AZStd::string& projectName)
+    AZ::Outcome<AZ::IO::Path, AZStd::string> GetProjectCacheFolderPath()
    {
-        AZStd::string projectCacheFolderPath;
+        AZ::IO::Path projectCacheFolderPath;

-        bool success = AzFramework::StringFunc::Path::ConstructFull(engineRoot.c_str(), "Cache", projectCacheFolderPath);
-        if (!success || !AZ::IO::FileIOBase::GetInstance()->Exists(projectCacheFolderPath.c_str()))
+        auto settingsRegistry = AZ::SettingsRegistry::Get();
+        if (settingsRegistry && settingsRegistry->Get(projectCacheFolderPath.Native(),
+            AZ::SettingsRegistryMergeUtils::FilePathKey_CacheProjectRootFolder))
        {
-            return AZ::Failure(AZStd::string::format(
-                "Unable to locate the Cache in the engine directory: %s. Please run the Lumberyard Asset Processor to generate a Cache and build assets.", 
-                engineRoot.c_str()));
+            if (AZ::IO::FileIOBase::GetInstance()->Exists(projectCacheFolderPath.c_str()))
+            {
+                return AZ::Success(projectCacheFolderPath);
+            }
        }

-        success = AzFramework::StringFunc::Path::ConstructFull(projectCacheFolderPath.c_str(), projectName.c_str(), projectCacheFolderPath);
-        if (success && AZ::IO::FileIOBase::GetInstance()->Exists(projectCacheFolderPath.c_str()))
-        {
-            return AZ::Success(projectCacheFolderPath);
-        }
-        else
-        {
-            return AZ::Failure(AZStd::string::format(
-                "Unable to locate the current Project in the Cache folder: %s. Please run the Lumberyard Asset Processor to generate a Cache and build assets.",
-                projectName.c_str()));
-        }
+        return AZ::Failure(AZStd::string::format(
+            "Unable to locate the Project Cache path from Settings Registry at key %s."
+            " Please run the Lumberyard Asset Processor to generate a Cache and build assets.",
+            AZ::SettingsRegistryMergeUtils::FilePathKey_CacheProjectRootFolder));
    }

-    AZ::Outcome<void, AZStd::string> GetPlatformNamesFromCacheFolder(const AZStd::string& projectCacheFolder, AZStd::vector<AZStd::string>& platformNames)
+    AZ::Outcome<void, AZStd::string> GetPlatformNamesFromCacheFolder(AZStd::vector<AZStd::string>& platformNames)
    {
-        QDir projectCacheDir(QString(projectCacheFolder.c_str()));
+        AZ::Outcome<AZ::IO::Path, AZStd::string> projectCacheRootFolder = GetProjectCacheFolderPath();
+        if (!projectCacheRootFolder)
+        {
+            return AZ::Failure(projectCacheRootFolder.TakeError());
+        }
+
+        const AZStd::string& projectCacheRootPath = projectCacheRootFolder.GetValue().Native();
+        QDir projectCacheDir(QString::fromUtf8(projectCacheRootPath.c_str(), aznumeric_cast<int>(projectCacheRootPath.size())));
        auto tempPlatformList = projectCacheDir.entryList(QDir::Filter::Dirs | QDir::Filter::NoDotAndDotDot);

        if (tempPlatformList.empty())
@@ -612,66 +514,33 @@ namespace AssetBundler
        return AZ::Success();
    }

-    AZ::Outcome<AZStd::string, AZStd::string> GetAssetCatalogFilePath(const char* pathToCacheFolder, const char* platformIdentifier, const char* projectName)
+    AZ::Outcome<AZ::IO::Path, AZStd::string> GetAssetCatalogFilePath()
    {
-        AZStd::string assetCatalogFilePath;
-        bool success = AzFramework::StringFunc::Path::ConstructFull(pathToCacheFolder, platformIdentifier, assetCatalogFilePath, true);
-
-        if (!success)
+        AZ::IO::Path assetCatalogFilePath = GetPlatformSpecificCacheFolderPath();
+        if (assetCatalogFilePath.empty())
        {
            return AZ::Failure(AZStd::string::format(
-                "Unable to find platform folder %s in cache found at: %s. Please run the Lumberyard Asset Processor to generate platform-specific cache folders and build assets.", 
-                platformIdentifier, 
-                pathToCacheFolder));
-        }
-
-        // Project name is lower case in the platform-specific cache folder
-        AZStd::string lowerCaseProjectName = AZStd::string(projectName);
-        AZStd::to_lower(lowerCaseProjectName.begin(), lowerCaseProjectName.end());
-        success = AzFramework::StringFunc::Path::ConstructFull(assetCatalogFilePath.c_str(), lowerCaseProjectName.c_str(), assetCatalogFilePath)
-            && AzFramework::StringFunc::Path::ConstructFull(assetCatalogFilePath.c_str(), AssetCatalogFilename, assetCatalogFilePath);
-
-        if (!success)
-        {
-            return AZ::Failure(AZStd::string("Unable to find the asset catalog. Please run the Lumberyard Asset Processor to generate a Cache and build assets."));
+                "Unable to retrieve cache platform path from Settings Registry at key: %s. Please run the Lumberyard Asset Processor to generate platform-specific cache folders and build assets.",
+                AZ::SettingsRegistryMergeUtils::FilePathKey_CacheProjectRootFolder));
        }

+        assetCatalogFilePath /= AssetCatalogFilename;
        return AZ::Success(assetCatalogFilePath);
    }

-    AZStd::string GetPlatformSpecificCacheFolderPath(const AZStd::string& projectSpecificCacheFolderAbsolutePath, const AZStd::string& platform, const AZStd::string& projectName)
+    AZ::IO::Path GetPlatformSpecificCacheFolderPath()
    {
-        // C:/dev/Cache/ProjectName -> C:/dev/Cache/ProjectName/platform
-        AZStd::string platformSpecificCacheFolderPath;
-        AzFramework::StringFunc::Path::ConstructFull(projectSpecificCacheFolderAbsolutePath.c_str(), platform.c_str(), platformSpecificCacheFolderPath, true);
-
-        // C:/dev/Cache/ProjectName/platform -> C:/dev/Cache/ProjectName/platform/projectname
-        AZStd::string lowerCaseProjectName = AZStd::string(projectName);
-        AZStd::to_lower(lowerCaseProjectName.begin(), lowerCaseProjectName.end());
-        AzFramework::StringFunc::Path::ConstructFull(platformSpecificCacheFolderPath.c_str(), lowerCaseProjectName.c_str(), platformSpecificCacheFolderPath, true);
-
+        AZ::IO::Path platformSpecificCacheFolderPath;
+        if (auto settingsRegistry = AZ::SettingsRegistry::Get(); settingsRegistry != nullptr)
+        {
+            settingsRegistry->Get(platformSpecificCacheFolderPath.Native(), AZ::SettingsRegistryMergeUtils::FilePathKey_CacheProjectRootFolder);
+        }
        return platformSpecificCacheFolderPath;
    }

-    AZStd::string GenerateKeyFromAbsolutePath(const AZStd::string& absoluteFilePath)
+    void ConvertToRelativePath(AZStd::string_view parentFolderPath, AZStd::string& absoluteFilePath)
    {
-        AZStd::string key(absoluteFilePath);
-        AzFramework::StringFunc::Path::Normalize(key);
-        AzFramework::StringFunc::Path::StripDrive(key);
-        return key;
-    }
-
-    void ConvertToRelativePath(const AZStd::string& parentFolderPath, AZStd::string& absoluteFilePath)
-    {
-        // Qt and AZ return different Drive Letter formats, so strip them away before doing a comparison
-        AZStd::string parentFolderPathWithoutDrive(parentFolderPath);
-        AzFramework::StringFunc::Path::StripDrive(parentFolderPathWithoutDrive);
-        AzFramework::StringFunc::Path::Normalize(parentFolderPathWithoutDrive);
-
-        AzFramework::StringFunc::Path::StripDrive(absoluteFilePath);
-        AzFramework::StringFunc::Path::Normalize(absoluteFilePath);
-
-        AzFramework::StringFunc::Replace(absoluteFilePath, parentFolderPathWithoutDrive.c_str(), "");
+        absoluteFilePath = AZ::IO::PathView(absoluteFilePath).LexicallyRelative(parentFolderPath).String();
    }

    AZ::Outcome<void, AZStd::string> MakePath(const AZStd::string& path)
@@ -120,20 +120,8 @@ namespace AssetBundler
    ////////////////////////////////////////////////////////////////////////////////////////////

    extern const char* AssetCatalogFilename;
-    extern char g_cachedEngineRoot[AZ_MAX_PATH_LEN];
    static const size_t MaxErrorMessageLength = 4096;

-    //! This struct stores gem related information
-    struct GemInfo
-    {
-        AZ_CLASS_ALLOCATOR(GemInfo, AZ::SystemAllocator, 0);
-        GemInfo(AZStd::string name, AZStd::string relativeFilePath, AZStd::string absoluteFilePath);
-        GemInfo() = default;
-        AZStd::string m_gemName;
-        AZStd::string m_relativeFilePath;
-        AZStd::string m_absoluteFilePath;
-    };
-

    // The Warning Absorber is used to absorb warnings 
    // One case that this is being used is during loading of the asset catalog.
@@ -149,14 +137,8 @@ namespace AssetBundler
        bool OnPreWarning(const char* window, const char* fileName, int line, const char* func, const char* message) override;
    };

-    // computes the asset alias and game name either through the asset catalog file provided by the user or using the platform and game folder 
-    AZ::Outcome<void, AZStd::string> ComputeAssetAliasAndGameName(const AZStd::string& platformIdentifier, const AZStd::string& assetCatalogFile, AZStd::string& assetAlias, AZStd::string& gameName);
-
-    // Computes the engine root and cache it locally
-    bool ComputeEngineRoot();
-
-    // Retrurns the engine root
-    const char* GetEngineRoot();
+    // Returns the engine root
+    AZ::IO::FixedMaxPath GetEngineRoot();

    /** 
    * Determines the name of the currently enabled game project
@@ -166,58 +148,51 @@ namespace AssetBundler


    /**
-    * Constructs an absolute path to the project folder found at: dev/ProjectName
-    * @param engineRoot The absolute path of the dev/ folder
-    * @param projectName A project present in the dev/ folder
+    * Retrieve the project path from the Settings Registry
    * @return Absolute path of the Project Folder on success, error message on failure
    */
-    AZ::Outcome<AZStd::string, AZStd::string> GetProjectFolderPath(const AZStd::string& engineRoot, const AZStd::string& projectName);
+    AZ::Outcome<AZ::IO::Path, AZStd::string> GetProjectFolderPath();

    /**
-    * Constructs an absolute path to the project-specific cache folder found at: dev/Cache/ProjectName
-    * @param engineRoot The absolute path of the dev/ folder
-    * @param projectName A project present in the dev/ folder
+    * Retrieve the project path from the Settings Registry
    * @return Absolute path of the project-specific cache folder on success, error message on failure
    */
-    AZ::Outcome<AZStd::string, AZStd::string> GetProjectCacheFolderPath(const AZStd::string& engineRoot, const AZStd::string& projectName);
+    AZ::Outcome<AZ::IO::Path, AZStd::string> GetProjectCacheFolderPath();

    /**
    * Calculates the list of enabled platforms for the input project by reading the folder names inside the project-specific cache folder.
-    * If the Asset Processor has not been run yet, or has not been run since the enabled platform list inside AssetProcessorPlatformConfig.ini 
+    * If the Asset Processor has not been run yet, or has not been run since the enabled platform list inside AssetProcessorPlatformConfig.setreg 
    *   was changed, the output of this function will be incorrect.
    *
-    * @param projectCacheFolder The directory of a project-specific cache folder: dev/Cache/ProjectName
+    * @param projectCacheFolder The directory of a project-specific cache folder: /ProjectPath/Cache
    * @param platformNames [out] The list of platforms enabled in the project
    * @return void on success, error message on failure
    */
-    AZ::Outcome<void, AZStd::string> GetPlatformNamesFromCacheFolder(const AZStd::string& projectCacheFolder, AZStd::vector<AZStd::string>& platformNames);
+    AZ::Outcome<void, AZStd::string> GetPlatformNamesFromCacheFolder(AZStd::vector<AZStd::string>& platformNames);

    /**
    * Computes the absolute path to the Asset Catalog file for a specified project and platform.
-    * With platform set as "pc" and project as "ProjectName", the path will resemble: C:/dev/Cache/ProjectName/pc/projectname/assetcatalog.xml
+    * With platform set as "pc" and project as "ProjectName", the path will resemble: C:/ProjectPath/Cache/pc/assetcatalog.xml
    *
-    * @param pathToCacheFolder The absolute path to the Cache folder. ex: C:/dev/Cache
+    * @param pathToCacheFolder The absolute path to the Cache folder. ex: C:/ProjectPath/Cache
    * @param platformIdentifier The platform identifier of the desired Asset Catalog. Valid inputs can be found by reading the folder names 
-    *                             found inside dev/Cache/ProjectName
+    *                             found inside ProjectPath/Cache
    * @param projectName The name of the project you want to search
    * @return Absolute Path to the Asset Catalog file on success, error message on failure
    */
-    AZ::Outcome<AZStd::string, AZStd::string> GetAssetCatalogFilePath(const char* pathToCacheFolder, const char* platformIdentifier, const char* projectName);
+    AZ::Outcome<AZ::IO::Path, AZStd::string> GetAssetCatalogFilePath();

    /**
    * Computes the absolute path to the platform-specific Cache folder where product assets are stored. 
-    * With platform set as "pc" and project as "ProjectName", the path will resemble: C:/dev/Cache/ProjectName/pc/projectname/
+    * With platform set as "pc" the path will resemble: C:/ProjectPath/Cache/pc/projectname/
    * 
-    * @param projectSpecificCacheFolderAbsolutePath The absolute path to the Cache folder. Example: C:/dev/Cache/ProjectName
+    * @param projectSpecificCacheFolderAbsolutePath The absolute path to the Cache folder. Example: C:/ProjectPath/Cache
    * @param platform the platform of the desired cache location
-    * @param projectName The name of the current project
    * @return Absolute path to the platform-specific Cache folder where product assets are stored 
    */
-    AZStd::string GetPlatformSpecificCacheFolderPath(const AZStd::string& projectSpecificCacheFolderAbsolutePath, const AZStd::string& platform, const AZStd::string& projectName);
+    AZ::IO::Path GetPlatformSpecificCacheFolderPath();

-    AZStd::string GenerateKeyFromAbsolutePath(const AZStd::string& absoluteFilePath);
-
-    void ConvertToRelativePath(const AZStd::string& parentFolderPath, AZStd::string& absoluteFilePath);
+    void ConvertToRelativePath(AZStd::string_view parentFolderPath, AZStd::string& absoluteFilePath);

    AZ::Outcome<void, AZStd::string> MakePath(const AZStd::string& path);

@@ -228,30 +203,31 @@ namespace AssetBundler
    AzFramework::PlatformFlags GetPlatformsOnDiskForPlatformSpecificFile(const AZStd::string& platformIndependentAbsolutePath);

    //! Returns a map of <absolute file path, source folder display name> of all default Seed List files for the current game project.
-    AZStd::unordered_map<AZStd::string, AZStd::string> GetDefaultSeedListFiles(const char* root, const char* projectName, const AZStd::vector<AzToolsFramework::AssetUtils::GemInfo>& gemInfoList, AzFramework::PlatformFlags platformFlags);
+    AZStd::unordered_map<AZStd::string, AZStd::string> GetDefaultSeedListFiles(AZStd::string_view enginePath, AZStd::string_view projectPath,
+        const AZStd::vector<AzFramework::GemInfo>& gemInfoList, AzFramework::PlatformFlags platformFlags);

    //! Returns a vector of relative paths to Assets that should be included as default Seeds, but are not already in a Seed List file.
-    AZStd::vector<AZStd::string> GetDefaultSeeds(const char* root, const char* projectName);
+    AZStd::vector<AZStd::string> GetDefaultSeeds(AZStd::string_view enginePath, AZStd::string_view projectPath, AZStd::string_view projectName);

    //! Returns the absolute path of {ProjectName}_Dependencies.xml
-    AZStd::string GetProjectDependenciesFile(const char* root, const char* projectName);
+    AZ::IO::Path GetProjectDependenciesFile(AZStd::string_view productPath, AZStd::string_view projectName);

    //! Returns the absolute path of the project dependencies file in the default project template
-    AZStd::string GetProjectDependenciesFileTemplate(const char* root);
+    AZ::IO::Path GetProjectDependenciesFileTemplate(AZStd::string_view enginePath);

    //! Creates the ProjectName_Dependencies.xml file if it does not exist, and adds returns the relative path to the asset in the Cache.
-    AZStd::string GetProjectDependenciesAssetPath(const char* root, const char* projectName);
+    AZ::IO::Path GetProjectDependenciesAssetPath(AZStd::string_view enginePath, AZStd::string_view projectPath, AZStd::string_view projectName);

    //! Returns the map from gem seed list file path to gem name
-    AZStd::unordered_map<AZStd::string, AZStd::string> GetGemSeedListFilePathToGemNameMap(const AZStd::vector<AzToolsFramework::AssetUtils::GemInfo>& gemInfoList, AzFramework::PlatformFlags platformFlags);
+    AZStd::unordered_map<AZStd::string, AZStd::string> GetGemSeedListFilePathToGemNameMap(const AZStd::vector<AzFramework::GemInfo>& gemInfoList, AzFramework::PlatformFlags platformFlags);

    //! Given an absolute gem seed file path determines whether the file is valid for the current game project.
    //! This method is for validating gem seed list files only.
-    bool IsGemSeedFilePathValid(const char* root, AZStd::string seedAbsoluteFilePath, const AZStd::vector<AzToolsFramework::AssetUtils::GemInfo>& gemInfoList, AzFramework::PlatformFlags platformFlags);
+    bool IsGemSeedFilePathValid(AZStd::string_view enginePath, AZStd::string seedAbsoluteFilePath, const AZStd::vector<AzFramework::GemInfo>& gemInfoList, AzFramework::PlatformFlags platformFlags);

    //! Returns platformFlags of all enabled platforms by parsing all the asset processor config files.
    //! Please note that the game project could be in a different location to the engine therefore we need the assetRoot param.
-    AzFramework::PlatformFlags GetEnabledPlatformFlags(const char* root, const char* assetRoot, const char* gameName);
+    AzFramework::PlatformFlags GetEnabledPlatformFlags(AZStd::string_view enginePath, AZStd::string_view assetRoot, AZStd::string_view projectPath);

    //! Filepath is a helper class that is used to find the absolute path of a file
    //! if the inputted file path is an absolute path than it does nothing