Load menu files that are referenced via loadmenu

src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderMenuList.cpp

@@ -22,42 +22,86 @@ bool AssetLoaderMenuList::CanLoadFromRaw() const
     return true;
 }
 
+bool AssetLoaderMenuList::ShouldLoadMenuFile(const std::string& menuFilePath, menu::MenuAssetZoneState* zoneState)
+{
+    const auto alreadyLoadedFile = zoneState->m_loaded_files.find(menuFilePath);
+    if (alreadyLoadedFile == zoneState->m_loaded_files.end())
+    {
+        zoneState->m_loaded_files.emplace(menuFilePath);
+        return true;
+    }
+
+    return false;
+}
+
+void AssetLoaderMenuList::AddMenuFilesToLoadToQueue(std::deque<std::string>& queue, const menu::ParsingResult* parsingResult, menu::MenuAssetZoneState* zoneState)
+{
+    for(const auto& menuFileToLoad : parsingResult->m_menus_to_load)
+    {
+        if(ShouldLoadMenuFile(menuFileToLoad, zoneState))
+        {
+            queue.push_back(menuFileToLoad);
+        }
+    }
+}
+
+void AssetLoaderMenuList::ProcessParsedResults(const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, menu::ParsingResult* parsingResult,
+                                               menu::MenuAssetZoneState* zoneState)
+{
+    std::cout << "Successfully read menu list \"" << assetName << "\":\n";
+
+    std::cout << "  " << parsingResult->m_menus_to_load.size() << " menus to load:\n";
+    for (const auto& menuToLoad : parsingResult->m_menus_to_load)
+        std::cout << "    " << menuToLoad << "\n";
+
+    std::cout << "  " << parsingResult->m_menus.size() << " menus:\n";
+    for (const auto& menu : parsingResult->m_menus)
+        std::cout << "    " << menu->m_name << " (" << menu->m_items.size() << " items)\n";
+
+    std::cout << "  " << parsingResult->m_functions.size() << " functions:\n";
+    for (const auto& function : parsingResult->m_functions)
+        std::cout << "    " << function->m_name << "\n";
+}
+
 bool AssetLoaderMenuList::LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
 {
-    const auto file = searchPath->Open(assetName);
+    std::deque<std::string> menuFileQueue;
-    if (!file.IsOpen())
-        return false;
 
-    menu::MenuFileReader reader(*file.m_stream, assetName, menu::FeatureLevel::IW4, [searchPath](const std::string& filename, const std::string& sourceFile) -> std::unique_ptr<std::istream>
+    auto* zoneState = manager->GetAssetLoadingContext()->GetZoneAssetLoaderState<menu::MenuAssetZoneState>();
+    menuFileQueue.push_back(assetName);
+
+    while (!menuFileQueue.empty())
     {
-        auto foundFileToInclude = searchPath->Open(filename);
+        const auto& nextMenuFile = menuFileQueue.front();
-        if (!foundFileToInclude.IsOpen() || !foundFileToInclude.m_stream)
+        const auto file = searchPath->Open(nextMenuFile);
-            return nullptr;
+        if (!file.IsOpen())
+        {
+            std::cout << "Failed to open menu file \"" << nextMenuFile << "\"\n";
+            return false;
+        }
 
-        return std::move(foundFileToInclude.m_stream);
+        menu::MenuFileReader reader(*file.m_stream, nextMenuFile, menu::FeatureLevel::IW4, [searchPath](const std::string& filename, const std::string& sourceFile) -> std::unique_ptr<std::istream>
-    });
+        {
+            auto foundFileToInclude = searchPath->Open(filename);
+            if (!foundFileToInclude.IsOpen() || !foundFileToInclude.m_stream)
+                return nullptr;
 
-    reader.IncludeZoneState(manager->GetAssetLoadingContext()->GetZoneAssetLoaderState<menu::MenuAssetZoneState>());
+            return std::move(foundFileToInclude.m_stream);
+        });
 
-    const auto menuFileResult = reader.ReadMenuFile();
+        reader.IncludeZoneState(zoneState);
-    if(menuFileResult)
-    {
-        std::cout << "Successfully read menu list \"" << assetName << "\":\n";
 
-        std::cout << "  " << menuFileResult->m_menus_to_load.size() << " menus to load:\n";
+        const auto menuFileResult = reader.ReadMenuFile();
-        for (const auto& menuToLoad : menuFileResult->m_menus_to_load)
+        if (menuFileResult)
-            std::cout << "    " << menuToLoad << "\n";
+        {
+            ProcessParsedResults(nextMenuFile, memory, manager, menuFileResult.get(), zoneState);
+            AddMenuFilesToLoadToQueue(menuFileQueue, menuFileResult.get(), zoneState);
+        }
+        else
+            std::cout << "Could not read menu list \"" << nextMenuFile << "\"\n";
 
-        std::cout << "  " << menuFileResult->m_menus.size() << " menus:\n";
+        menuFileQueue.pop_front();
-        for (const auto& menu : menuFileResult->m_menus)
-            std::cout << "    " << menu->m_name << " (" << menu->m_items.size() << " items)\n";
-
-        std::cout << "  " << menuFileResult->m_functions.size() << " functions:\n";
-        for (const auto& function : menuFileResult->m_functions)
-            std::cout << "    " << function->m_name << "\n";
     }
-    else
-        std::cout << "Could not read menu list \"" << assetName << "\"\n";
 
     return true;
 }

src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderMenuList.h

@@ -1,14 +1,22 @@
 #pragma once
 
+#include <deque>
+
 #include "Game/IW4/IW4.h"
 #include "AssetLoading/BasicAssetLoader.h"
 #include "AssetLoading/IAssetLoadingManager.h"
+#include "Parsing/Menu/MenuAssetZoneState.h"
+#include "Parsing/Menu/Domain/MenuParsingResult.h"
 #include "SearchPath/ISearchPath.h"
 
 namespace IW4
 {
     class AssetLoaderMenuList final : public BasicAssetLoader<ASSET_TYPE_MENULIST, MenuList>
     {
+        static bool ShouldLoadMenuFile(const std::string& menuFilePath, menu::MenuAssetZoneState* zoneState);
+        static void AddMenuFilesToLoadToQueue(std::deque<std::string>& queue, const menu::ParsingResult* parsingResult, menu::MenuAssetZoneState* zoneState);
+        static void ProcessParsedResults(const std::string& assetName, MemoryManager* memory, IAssetLoadingManager* manager, menu::ParsingResult* parsingResult, menu::MenuAssetZoneState* zoneState);
+
     public:
         _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
         _NODISCARD bool CanLoadFromRaw() const override;

src/ObjLoading/Parsing/Menu/MenuAssetZoneState.h

@@ -1,5 +1,8 @@
 #pragma once
 
+#include <set>
+#include <string>
+
 #include "AssetLoading/IZoneAssetLoaderState.h"
 #include "Domain/CommonFunctionDef.h"
 #include "Domain/CommonMenuDef.h"
@@ -9,6 +12,7 @@ namespace menu
     class MenuAssetZoneState final : public IZoneAssetLoaderState
     {
     public:
+        std::set<std::string> m_loaded_files;
         std::vector<std::unique_ptr<CommonFunctionDef>> m_functions;
         std::vector<std::unique_ptr<CommonMenuDef>> m_menus;