Add base for IW5 menu parsing based on IW4 menu parser

src/Common/Game/IW5/IW5_Assets.h

@@ -2316,7 +2316,21 @@ namespace IW5
         EXP_FUNC_STATIC_DVAR_FLOAT,
         EXP_FUNC_STATIC_DVAR_STRING,
 
-        EXP_FUNC_DYN_START
+        EXP_FUNC_DYN_START,
+
+        EXP_FUNC_INT = EXP_FUNC_DYN_START,
+        EXP_FUNC_STRING,
+        EXP_FUNC_FLOAT,
+        EXP_FUNC_SIN,
+        EXP_FUNC_COS,
+        EXP_FUNC_MIN,
+        EXP_FUNC_MAX,
+        EXP_FUNC_MILLISECONDS,
+        EXP_FUNC_LOCAL_CLIENT_UI_MILLISECONDS,
+        EXP_FUNC_DVAR_INT,
+        EXP_FUNC_DVAR_BOOL,
+        EXP_FUNC_DVAR_FLOAT,
+        EXP_FUNC_DVAR_STRING
     };
 
     enum expressionEntryType : int
@@ -2560,6 +2574,19 @@ namespace IW5
         WINDOW_FLAG_TEXT_ONLY_FOCUS = 0x80000000,
     };
 
+    // This is data from IW4, could be different for IW5, to be investigated
+    enum WindowDefDynamicFlag : unsigned int
+    {
+        WINDOW_FLAG_HOVERED = 0x1, // guessed
+        WINDOW_FLAG_FOCUSED = 0x2,
+        WINDOW_FLAG_VISIBLE = 0x4,
+        WINDOW_FLAG_FADING_OUT = 0x10,
+        WINDOW_FLAG_FADING_IN = 0x20,
+        WINDOW_FLAG_80 = 0x80,
+        WINDOW_FLAG_NON_DEFAULT_BACKCOLOR = 0x8000,
+        WINDOW_FLAG_NON_DEFAULT_FORECOLOR = 0x10000
+    };
+
     struct windowDef_t
     {
         const char* name;

src/ObjLoading/Game/IW5/AssetLoaders/AssetLoaderMenuDef.cpp

@@ -0,0 +1,17 @@
+#include "AssetLoaderMenuDef.h"
+
+#include <cstring>
+
+#include "ObjLoading.h"
+#include "Game/IW5/IW5.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW5;
+
+void* AssetLoaderMenuDef::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* menu = memory->Create<menuDef_t>();
+    memset(menu, 0, sizeof(menuDef_t));
+    menu->window.name = memory->Dup(assetName.c_str());
+    return menu;
+}

src/ObjLoading/Game/IW5/AssetLoaders/AssetLoaderMenuDef.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Game/IW5/IW5.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW5
+{
+    class AssetLoaderMenuDef final : public BasicAssetLoader<ASSET_TYPE_MENU, menuDef_t>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+    };
+}

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

@@ -0,0 +1,207 @@
+#include "AssetLoaderMenuList.h"
+
+#include <cstring>
+#include <iostream>
+
+#include "ObjLoading.h"
+#include "Game/IW5/IW5.h"
+#include "Game/IW5/Menu/MenuConversionZoneStateIW5.h"
+#include "Game/IW5/Menu/MenuConverterIW5.h"
+#include "Parsing/Menu/MenuFileReader.h"
+#include "Pool/GlobalAssetPool.h"
+
+using namespace IW5;
+
+namespace IW5
+{
+    class MenuLoader
+    {
+    public:
+        static bool ProcessParsedResults(const std::string& fileName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, menu::ParsingResult* parsingResult,
+                                         menu::MenuAssetZoneState* zoneState, MenuConversionZoneState* conversionState, std::vector<menuDef_t*>& menus,
+                                         std::vector<XAssetInfoGeneric*>& menuListDependencies)
+        {
+            const auto menuCount = parsingResult->m_menus.size();
+            const auto functionCount = parsingResult->m_functions.size();
+            const auto menuLoadCount = parsingResult->m_menus_to_load.size();
+            auto totalItemCount = 0u;
+            for (const auto& menu : parsingResult->m_menus)
+                totalItemCount += menu->m_items.size();
+
+            std::cout << "Successfully read menu file \"" << fileName << "\" (" << menuLoadCount << " loads, " << menuCount << " menus, " << functionCount << " functions, " << totalItemCount <<
+                " items)\n";
+
+            // Add all functions to the zone state to make them available for all menus to be converted
+            for (auto& function : parsingResult->m_functions)
+                zoneState->AddFunction(std::move(function));
+
+            // Prepare a list of all menus of this file
+            std::vector<XAssetInfo<menuDef_t>*> allMenusOfFile;
+            allMenusOfFile.reserve(parsingResult->m_menus.size());
+
+            // Convert all menus and add them as assets
+            for (auto& menu : parsingResult->m_menus)
+            {
+                MenuConverter converter(ObjLoading::Configuration.MenuNoOptimization, searchPath, memory, manager);
+                auto* menuAsset = converter.ConvertMenu(*menu);
+                if (menuAsset == nullptr)
+                {
+                    std::cout << "Failed to convert menu file \"" << menu->m_name << "\"\n";
+                    return false;
+                }
+
+                menus.push_back(menuAsset);
+                auto* menuAssetInfo = manager->AddAsset(ASSET_TYPE_MENU, menu->m_name, menuAsset, std::move(converter.GetDependencies()), std::vector<scr_string_t>());
+
+                if (menuAssetInfo)
+                {
+                    allMenusOfFile.push_back(reinterpret_cast<XAssetInfo<menuDef_t>*>(menuAssetInfo));
+                    menuListDependencies.push_back(menuAssetInfo);
+                }
+
+                zoneState->AddMenu(std::move(menu));
+            }
+
+            // Register this file with all loaded menus
+            conversionState->AddLoadedFile(fileName, std::move(allMenusOfFile));
+
+            return true;
+        }
+
+        static MenuList* CreateMenuListAsset(const std::string& assetName, MemoryManager* memory, const std::vector<menuDef_t*>& menus)
+        {
+            auto* menuListAsset = memory->Create<MenuList>();
+            menuListAsset->name = memory->Dup(assetName.c_str());
+            menuListAsset->menuCount = static_cast<int>(menus.size());
+
+            if (menuListAsset->menuCount > 0)
+            {
+                menuListAsset->menus = static_cast<menuDef_t**>(memory->Alloc(sizeof(uintptr_t) * menuListAsset->menuCount));
+                for (auto i = 0; i < menuListAsset->menuCount; i++)
+                    menuListAsset->menus[i] = menus[i];
+            }
+            else
+                menuListAsset->menus = nullptr;
+
+            return menuListAsset;
+        }
+
+        static std::unique_ptr<menu::ParsingResult> ParseMenuFile(const std::string& menuFileName, ISearchPath* searchPath, const menu::MenuAssetZoneState* zoneState)
+        {
+            const auto file = searchPath->Open(menuFileName);
+            if (!file.IsOpen())
+                return nullptr;
+
+            menu::MenuFileReader reader(*file.m_stream, menuFileName, menu::FeatureLevel::IW5, [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;
+
+                return std::move(foundFileToInclude.m_stream);
+            });
+
+            reader.IncludeZoneState(zoneState);
+            reader.SetPermissiveMode(ObjLoading::Configuration.MenuPermissiveParsing);
+
+            return reader.ReadMenuFile();
+        }
+    };
+}
+
+void* AssetLoaderMenuList::CreateEmptyAsset(const std::string& assetName, MemoryManager* memory)
+{
+    auto* menuList = memory->Create<MenuList>();
+    memset(menuList, 0, sizeof(MenuList));
+    menuList->name = memory->Dup(assetName.c_str());
+    return menuList;
+}
+
+bool AssetLoaderMenuList::CanLoadFromRaw() const
+{
+    return true;
+}
+
+bool BuildMenuFileQueue(std::deque<std::string>& menuLoadQueue, const std::string& menuListAssetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, menu::MenuAssetZoneState* zoneState,
+                                           MenuConversionZoneState* conversionState, std::vector<menuDef_t*>& menus, std::vector<XAssetInfoGeneric*>& menuListDependencies)
+{
+    const auto alreadyLoadedMenuListFileMenus = conversionState->m_menus_by_filename.find(menuListAssetName);
+
+    if (alreadyLoadedMenuListFileMenus == conversionState->m_menus_by_filename.end())
+    {
+        const auto menuListResult = MenuLoader::ParseMenuFile(menuListAssetName, searchPath, zoneState);
+        if (menuListResult)
+        {
+            MenuLoader::ProcessParsedResults(menuListAssetName, searchPath, memory, manager, menuListResult.get(), zoneState, conversionState, menus, menuListDependencies);
+
+            for (const auto& menuToLoad : menuListResult->m_menus_to_load)
+                menuLoadQueue.push_back(menuToLoad);
+
+            zoneState->AddMenusToLoad(menuListAssetName, std::move(menuListResult->m_menus_to_load));
+        }
+        else
+            return false;
+    }
+
+    return true;
+}
+
+void LoadMenuFileFromQueue(const std::string& menuFilePath, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, menu::MenuAssetZoneState* zoneState,
+    MenuConversionZoneState* conversionState, std::vector<menuDef_t*>& menus, std::vector<XAssetInfoGeneric*>& menuListDependencies)
+{
+    const auto alreadyLoadedMenuFile = conversionState->m_menus_by_filename.find(menuFilePath);
+    if (alreadyLoadedMenuFile != conversionState->m_menus_by_filename.end())
+    {
+        std::cout << "Already loaded \"" << menuFilePath << "\", skipping\n";
+        for (auto* menu : alreadyLoadedMenuFile->second)
+        {
+            menus.push_back(menu->Asset());
+            menuListDependencies.push_back(menu);
+        }
+        return;
+    }
+
+    const auto menuFileResult = MenuLoader::ParseMenuFile(menuFilePath, searchPath, zoneState);
+    if (menuFileResult)
+    {
+        MenuLoader::ProcessParsedResults(menuFilePath, searchPath, memory, manager, menuFileResult.get(), zoneState, conversionState, menus, menuListDependencies);
+        if (!menuFileResult->m_menus_to_load.empty())
+            std::cout << "WARNING: Menu file has menus to load even though it is not a menu list, ignoring: \"" << menuFilePath << "\"\n";
+    }
+    else
+        std::cerr << "Could not read menu file \"" << menuFilePath << "\"\n";
+}
+
+bool AssetLoaderMenuList::LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const
+{
+    std::vector<menuDef_t*> menus;
+    std::vector<XAssetInfoGeneric*> menuListDependencies;
+
+    auto* zoneState = manager->GetAssetLoadingContext()->GetZoneAssetLoaderState<menu::MenuAssetZoneState>();
+    auto* conversionState = manager->GetAssetLoadingContext()->GetZoneAssetLoaderState<MenuConversionZoneState>();
+
+    std::deque<std::string> menuLoadQueue;
+    if (!BuildMenuFileQueue(menuLoadQueue, assetName, searchPath, memory, manager, zoneState, conversionState, menus, menuListDependencies))
+        return false;
+
+    while(!menuLoadQueue.empty())
+    {
+        const auto& menuFileToLoad = menuLoadQueue.front();
+
+        LoadMenuFileFromQueue(menuFileToLoad, searchPath, memory, manager, zoneState, conversionState, menus, menuListDependencies);
+
+        menuLoadQueue.pop_front();
+    }
+
+    auto* menuListAsset = MenuLoader::CreateMenuListAsset(assetName, memory, menus);
+
+    if (menuListAsset)
+        manager->AddAsset(ASSET_TYPE_MENULIST, assetName, menuListAsset, menuListDependencies, std::vector<scr_string_t>());
+
+    return true;
+}
+
+void AssetLoaderMenuList::FinalizeAssetsForZone(AssetLoadingContext* context) const
+{
+    context->GetZoneAssetLoaderState<MenuConversionZoneState>()->FinalizeSupportingData();
+}

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

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "Game/IW5/IW5.h"
+#include "AssetLoading/BasicAssetLoader.h"
+#include "AssetLoading/IAssetLoadingManager.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW5
+{
+    class AssetLoaderMenuList final : public BasicAssetLoader<ASSET_TYPE_MENULIST, MenuList>
+    {
+    public:
+        _NODISCARD void* CreateEmptyAsset(const std::string& assetName, MemoryManager* memory) override;
+        _NODISCARD bool CanLoadFromRaw() const override;
+        bool LoadFromRaw(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, Zone* zone) const override;
+        void FinalizeAssetsForZone(AssetLoadingContext* context) const override;
+    };
+}

src/ObjLoading/Game/IW5/Menu/MenuConversionZoneStateIW5.cpp

@@ -0,0 +1,121 @@
+#include "MenuConversionZoneStateIW5.h"
+
+#include <cstring>
+
+using namespace IW5;
+
+MenuConversionZoneState::MenuConversionZoneState()
+    : m_zone(nullptr),
+      m_supporting_data(nullptr)
+{
+}
+
+void MenuConversionZoneState::SetZone(Zone* zone)
+{
+    auto* memory = zone->GetMemory();
+
+    m_zone = zone;
+    m_supporting_data = memory->Create<ExpressionSupportingData>();
+    memset(m_supporting_data, 0, sizeof(ExpressionSupportingData));
+}
+
+Statement_s* MenuConversionZoneState::FindFunction(const std::string& functionName)
+{
+    const auto foundFunction = m_function_by_name.find(functionName);
+
+    if (foundFunction != m_function_by_name.end())
+        return foundFunction->second;
+
+    return nullptr;
+}
+
+Statement_s* MenuConversionZoneState::AddFunction(const std::string& functionName, Statement_s* function)
+{
+    m_functions.push_back(function);
+    m_function_by_name.emplace(std::make_pair(functionName, function));
+
+    return function;
+}
+
+size_t MenuConversionZoneState::AddStaticDvar(const std::string& dvarName)
+{
+    const auto foundDvar = m_dvars_by_name.find(dvarName);
+
+    if (foundDvar != m_dvars_by_name.end())
+        return foundDvar->second;
+
+    auto* memory = m_zone->GetMemory();
+    auto* staticDvar = static_cast<StaticDvar*>(memory->Alloc(sizeof(StaticDvar)));
+
+    staticDvar->dvarName = memory->Dup(dvarName.c_str());
+    staticDvar->dvar = nullptr;
+
+    const auto staticDvarIndex = m_static_dvars.size();
+    m_static_dvars.push_back(staticDvar);
+    m_dvars_by_name.emplace(std::make_pair(dvarName, staticDvarIndex));
+
+    return staticDvarIndex;
+}
+
+const char* MenuConversionZoneState::AddString(const std::string& str)
+{
+    const auto foundString = m_strings_by_value.find(str);
+
+    if (foundString != m_strings_by_value.end())
+        return foundString->second;
+
+    auto* memory = m_zone->GetMemory();
+    const auto* strDuped = memory->Dup(str.c_str());
+
+    m_strings.push_back(strDuped);
+    m_strings_by_value.emplace(std::make_pair(str, strDuped));
+
+    return strDuped;
+}
+
+void MenuConversionZoneState::AddLoadedFile(std::string loadedFileName, std::vector<XAssetInfo<menuDef_t>*> menusOfFile)
+{
+    m_menus_by_filename.emplace(std::make_pair(std::move(loadedFileName), std::move(menusOfFile)));
+}
+
+void MenuConversionZoneState::FinalizeSupportingData() const
+{
+    auto* memory = m_zone->GetMemory();
+
+    m_supporting_data->uifunctions.totalFunctions = static_cast<int>(m_functions.size());
+    m_supporting_data->staticDvarList.numStaticDvars = static_cast<int>(m_static_dvars.size());
+    m_supporting_data->uiStrings.totalStrings = static_cast<int>(m_strings.size());
+
+    if (m_supporting_data->uifunctions.functions)
+        memory->Free(m_supporting_data->uifunctions.functions);
+
+    if (m_supporting_data->staticDvarList.staticDvars)
+        memory->Free(m_supporting_data->staticDvarList.staticDvars);
+
+    if (m_supporting_data->uiStrings.strings)
+        memory->Free(m_supporting_data->uiStrings.strings);
+
+    if (!m_functions.empty())
+    {
+        m_supporting_data->uifunctions.functions = static_cast<Statement_s**>(memory->Alloc(sizeof(void*) * m_functions.size()));
+        memcpy(m_supporting_data->uifunctions.functions, &m_functions[0], sizeof(void*) * m_functions.size());
+    }
+    else
+        m_supporting_data->uifunctions.functions = nullptr;
+
+    if (!m_static_dvars.empty())
+    {
+        m_supporting_data->staticDvarList.staticDvars = static_cast<StaticDvar**>(memory->Alloc(sizeof(void*) * m_static_dvars.size()));
+        memcpy(m_supporting_data->staticDvarList.staticDvars, &m_static_dvars[0], sizeof(void*) * m_static_dvars.size());
+    }
+    else
+        m_supporting_data->staticDvarList.staticDvars = nullptr;
+
+    if (!m_strings.empty())
+    {
+        m_supporting_data->uiStrings.strings = static_cast<const char**>(memory->Alloc(sizeof(void*) * m_strings.size()));
+        memcpy(m_supporting_data->uiStrings.strings, &m_strings[0], sizeof(void*) * m_strings.size());
+    }
+    else
+        m_supporting_data->uiStrings.strings = nullptr;
+}

src/ObjLoading/Game/IW5/Menu/MenuConversionZoneStateIW5.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <map>
+
+#include "AssetLoading/IZoneAssetLoaderState.h"
+#include "Game/IW5/IW5.h"
+
+namespace IW5
+{
+    class MenuConversionZoneState final : public IZoneAssetLoaderState
+    {
+        Zone* m_zone;
+        std::vector<Statement_s*> m_functions;
+        std::map<std::string, Statement_s*> m_function_by_name;
+
+        std::vector<StaticDvar*> m_static_dvars;
+        std::map<std::string, size_t> m_dvars_by_name;
+
+        std::vector<const char*> m_strings;
+        std::map<std::string, const char*> m_strings_by_value;
+
+    public:
+        std::map<std::string, std::vector<XAssetInfo<menuDef_t>*>> m_menus_by_filename;
+        ExpressionSupportingData* m_supporting_data;
+
+        MenuConversionZoneState();
+        void SetZone(Zone* zone) override;
+
+        Statement_s* FindFunction(const std::string& functionName);
+
+        Statement_s* AddFunction(const std::string& functionName, Statement_s* function);
+        size_t AddStaticDvar(const std::string& dvarName);
+        const char* AddString(const std::string& str);
+
+        void AddLoadedFile(std::string loadedFileName, std::vector<XAssetInfo<menuDef_t>*> menusOfFile);
+
+        void FinalizeSupportingData() const;
+    };
+}

src/ObjLoading/Game/IW5/Menu/MenuConverterIW5.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "Utils/ClassUtils.h"
+#include "AssetLoading/IAssetLoadingManager.h"
+#include "Game/IW5/IW5.h"
+#include "Parsing/Menu/Domain/CommonMenuDef.h"
+#include "Utils/MemoryManager.h"
+#include "SearchPath/ISearchPath.h"
+
+namespace IW5
+{
+    class MenuConverter
+    {
+        bool m_disable_optimizations;
+        ISearchPath* m_search_path;
+        MemoryManager* m_memory;
+        IAssetLoadingManager* m_manager;
+        std::vector<XAssetInfoGeneric*> m_dependencies;
+
+    public:
+        MenuConverter(bool disableOptimizations, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager);
+
+        std::vector<XAssetInfoGeneric*>& GetDependencies();
+        _NODISCARD menuDef_t* ConvertMenu(const menu::CommonMenuDef& commonMenu);
+    };
+}

src/ObjLoading/Game/IW5/ObjLoaderIW5.cpp

@@ -5,6 +5,8 @@
 #include "ObjContainer/IPak/IPak.h"
 #include "ObjLoading.h"
 #include "AssetLoaders/AssetLoaderLocalizeEntry.h"
+#include "AssetLoaders/AssetLoaderMenuDef.h"
+#include "AssetLoaders/AssetLoaderMenuList.h"
 #include "AssetLoaders/AssetLoaderRawFile.h"
 #include "AssetLoaders/AssetLoaderStringTable.h"
 #include "AssetLoading/AssetLoadingManager.h"
@@ -44,8 +46,8 @@ ObjLoader::ObjLoader()
     REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_GFXWORLD, GfxWorld))
     REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_LIGHT_DEF, GfxLightDef))
     REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_FONT, Font_s))
-    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_MENULIST, MenuList))
-    REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_MENU, menuDef_t))
+    REGISTER_ASSET_LOADER(AssetLoaderMenuList)
+    REGISTER_ASSET_LOADER(AssetLoaderMenuDef)
     REGISTER_ASSET_LOADER(AssetLoaderLocalizeEntry)
     REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_ATTACHMENT, WeaponAttachment))
     REGISTER_ASSET_LOADER(BASIC_LOADER(ASSET_TYPE_WEAPON, WeaponCompleteDef))