From 7188b0946d32f2f4b5c01bc383c8ab0996af2a46 Mon Sep 17 00:00:00 2001 From: Jan Date: Tue, 28 Dec 2021 23:52:42 +0100 Subject: [PATCH] Make use of custom functions when converting menus --- src/Common/Game/IW4/IW4_Assets.h | 4 +- src/Common/Game/IW5/IW5_Assets.h | 2 + .../AssetLoading/AssetLoadingContext.h | 1 + .../AssetLoading/IZoneAssetLoaderState.h | 8 +- .../IW4/AssetLoaders/AssetLoaderMenuList.cpp | 6 +- .../IW4/Menu/MenuConversionZoneStateIW4.cpp | 114 ++++++++++++++++++ .../IW4/Menu/MenuConversionZoneStateIW4.h | 36 ++++++ .../Game/IW4/Menu/MenuConverterIW4.cpp | 112 +++++++++-------- .../CommonExpressionBaseFunctionCall.cpp | 43 +++++++ ...l.h => CommonExpressionBaseFunctionCall.h} | 5 +- .../CommonExpressionCustomFunctionCall.cpp | 24 ++++ .../CommonExpressionCustomFunctionCall.h | 18 +++ .../CommonExpressionFunctionCall.cpp | 41 ------- .../Menu/Matcher/MenuExpressionMatchers.cpp | 80 ++++++++++-- .../Menu/Matcher/MenuExpressionMatchers.h | 6 + .../Menu/Matcher/MenuMatcherFactory.cpp | 8 +- .../Parsing/Menu/Matcher/MenuMatcherFactory.h | 5 +- .../Parsing/Menu/MenuAssetZoneState.cpp | 19 +++ .../Parsing/Menu/MenuAssetZoneState.h | 6 + .../EventHandlerSetScopeSequences.cpp | 10 +- .../Generic/GenericColorPropertySequence.cpp | 12 +- .../Generic/GenericColorPropertySequence.h | 2 +- .../GenericExpressionPropertySequence.cpp | 2 +- .../GenericFloatingPointPropertySequence.cpp | 2 +- .../Generic/GenericIntPropertySequence.cpp | 2 +- .../Menu/Sequence/ItemScopeSequences.cpp | 26 ++-- .../Menu/Sequence/MenuScopeSequences.cpp | 8 +- 27 files changed, 459 insertions(+), 143 deletions(-) create mode 100644 src/ObjLoading/Game/IW4/Menu/MenuConversionZoneStateIW4.cpp create mode 100644 src/ObjLoading/Game/IW4/Menu/MenuConversionZoneStateIW4.h create mode 100644 src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionBaseFunctionCall.cpp rename src/ObjLoading/Parsing/Menu/Domain/Expression/{CommonExpressionFunctionCall.h => CommonExpressionBaseFunctionCall.h} (68%) create mode 100644 src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionCustomFunctionCall.cpp create mode 100644 src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionCustomFunctionCall.h delete mode 100644 src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionFunctionCall.cpp create mode 100644 src/ObjLoading/Parsing/Menu/MenuAssetZoneState.cpp diff --git a/src/Common/Game/IW4/IW4_Assets.h b/src/Common/Game/IW4/IW4_Assets.h index 0847dbee..39cb0383 100644 --- a/src/Common/Game/IW4/IW4_Assets.h +++ b/src/Common/Game/IW4/IW4_Assets.h @@ -1105,9 +1105,9 @@ namespace IW4 VAL_INT = 0x0, VAL_FLOAT = 0x1, VAL_STRING = 0x2, - NUM_INTERNAL_DATATYPES = 0x3, VAL_FUNCTION = 0x3, - NUM_DATATYPES = 0x4, + + NUM_DATATYPES, }; struct Operand diff --git a/src/Common/Game/IW5/IW5_Assets.h b/src/Common/Game/IW5/IW5_Assets.h index 7d505e8e..1cdd083f 100644 --- a/src/Common/Game/IW5/IW5_Assets.h +++ b/src/Common/Game/IW5/IW5_Assets.h @@ -2315,6 +2315,8 @@ namespace IW5 EXP_FUNC_STATIC_DVAR_BOOL, EXP_FUNC_STATIC_DVAR_FLOAT, EXP_FUNC_STATIC_DVAR_STRING, + + EXP_FUNC_DYN_START }; enum expressionEntryType : int diff --git a/src/ObjLoading/AssetLoading/AssetLoadingContext.h b/src/ObjLoading/AssetLoading/AssetLoadingContext.h index 7b667e2e..aeb9377d 100644 --- a/src/ObjLoading/AssetLoading/AssetLoadingContext.h +++ b/src/ObjLoading/AssetLoading/AssetLoadingContext.h @@ -37,6 +37,7 @@ public: return dynamic_cast(foundEntry->second.get()); auto newState = std::make_unique(); + newState->SetZone(m_zone); auto* newStatePtr = newState.get(); m_zone_asset_loader_states.emplace(std::make_pair>(typeid(T), std::move(newState))); return newStatePtr; diff --git a/src/ObjLoading/AssetLoading/IZoneAssetLoaderState.h b/src/ObjLoading/AssetLoading/IZoneAssetLoaderState.h index 3e91eba7..a17ccd51 100644 --- a/src/ObjLoading/AssetLoading/IZoneAssetLoaderState.h +++ b/src/ObjLoading/AssetLoading/IZoneAssetLoaderState.h @@ -1,4 +1,5 @@ #pragma once +#include "Zone/Zone.h" class IZoneAssetLoaderState { @@ -11,4 +12,9 @@ public: IZoneAssetLoaderState(IZoneAssetLoaderState&& other) noexcept = default; IZoneAssetLoaderState& operator=(const IZoneAssetLoaderState& other) = default; IZoneAssetLoaderState& operator=(IZoneAssetLoaderState&& other) noexcept = default; -}; \ No newline at end of file + + virtual void SetZone(Zone* zone) + { + // Do nothing by default + } +}; diff --git a/src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderMenuList.cpp b/src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderMenuList.cpp index 3659f3f1..ba63a320 100644 --- a/src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderMenuList.cpp +++ b/src/ObjLoading/Game/IW4/AssetLoaders/AssetLoaderMenuList.cpp @@ -29,7 +29,7 @@ bool AssetLoaderMenuList::ShouldLoadMenuFile(const std::string& menuFilePath, me const auto alreadyLoadedFile = zoneState->m_loaded_files.find(menuFilePath); if (alreadyLoadedFile == zoneState->m_loaded_files.end()) { - zoneState->m_loaded_files.emplace(menuFilePath); + zoneState->AddLoadedFile(menuFilePath); return true; } @@ -50,10 +50,10 @@ void AssetLoaderMenuList::AddMenuFilesToLoadToQueue(std::deque& que void AssetLoaderMenuList::AddResultsToZoneState(menu::ParsingResult* parsingResult, menu::MenuAssetZoneState* zoneState) { for (auto& function : parsingResult->m_functions) - zoneState->m_functions.emplace_back(std::move(function)); + zoneState->AddFunction(std::move(function)); for (auto& menu : parsingResult->m_menus) - zoneState->m_menus.emplace_back(std::move(menu)); + zoneState->AddMenu(std::move(menu)); } bool AssetLoaderMenuList::ProcessParsedResults(const std::string& assetName, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager, menu::ParsingResult* parsingResult, diff --git a/src/ObjLoading/Game/IW4/Menu/MenuConversionZoneStateIW4.cpp b/src/ObjLoading/Game/IW4/Menu/MenuConversionZoneStateIW4.cpp new file mode 100644 index 00000000..88d5ea82 --- /dev/null +++ b/src/ObjLoading/Game/IW4/Menu/MenuConversionZoneStateIW4.cpp @@ -0,0 +1,114 @@ +#include "MenuConversionZoneStateIW4.h" + +using namespace IW4; + +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(); + 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(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::FinalizeSupportingData() const +{ + auto* memory = m_zone->GetMemory(); + + m_supporting_data->uifunctions.totalFunctions = static_cast(m_functions.size()); + m_supporting_data->staticDvarList.numStaticDvars = static_cast(m_static_dvars.size()); + m_supporting_data->uiStrings.totalStrings = static_cast(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(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(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(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; +} diff --git a/src/ObjLoading/Game/IW4/Menu/MenuConversionZoneStateIW4.h b/src/ObjLoading/Game/IW4/Menu/MenuConversionZoneStateIW4.h new file mode 100644 index 00000000..46329251 --- /dev/null +++ b/src/ObjLoading/Game/IW4/Menu/MenuConversionZoneStateIW4.h @@ -0,0 +1,36 @@ +#pragma once + +#include + +#include "AssetLoading/IZoneAssetLoaderState.h" +#include "Game/IW4/IW4.h" + +namespace IW4 +{ + class MenuConversionZoneState final : public IZoneAssetLoaderState + { + Zone* m_zone; + std::vector m_functions; + std::map m_function_by_name; + + std::vector m_static_dvars; + std::map m_dvars_by_name; + + std::vector m_strings; + std::map m_strings_by_value; + + public: + 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 FinalizeSupportingData() const; + }; +} diff --git a/src/ObjLoading/Game/IW4/Menu/MenuConverterIW4.cpp b/src/ObjLoading/Game/IW4/Menu/MenuConverterIW4.cpp index 6b5617e7..c18b1a5b 100644 --- a/src/ObjLoading/Game/IW4/Menu/MenuConverterIW4.cpp +++ b/src/ObjLoading/Game/IW4/Menu/MenuConverterIW4.cpp @@ -3,14 +3,16 @@ #include #include +#include "MenuConversionZoneStateIW4.h" #include "Game/IW4/MenuConstantsIW4.h" -#include "Game/T5/T5_Assets.h" #include "Utils/ClassUtils.h" #include "Menu/AbstractMenuConverter.h" +#include "Parsing/Menu/MenuAssetZoneState.h" #include "Parsing/Menu/Domain/EventHandler/CommonEventHandlerCondition.h" #include "Parsing/Menu/Domain/EventHandler/CommonEventHandlerScript.h" #include "Parsing/Menu/Domain/EventHandler/CommonEventHandlerSetLocalVar.h" -#include "Parsing/Menu/Domain/Expression/CommonExpressionFunctionCall.h" +#include "Parsing/Menu/Domain/Expression/CommonExpressionBaseFunctionCall.h" +#include "Parsing/Menu/Domain/Expression/CommonExpressionCustomFunctionCall.h" #include "Parsing/Simple/Expression/SimpleExpressionBinaryOperation.h" #include "Parsing/Simple/Expression/SimpleExpressionConditionalOperator.h" #include "Parsing/Simple/Expression/SimpleExpressionUnaryOperation.h" @@ -22,6 +24,9 @@ namespace IW4 { class MenuConverterImpl : public AbstractMenuConverter { + MenuConversionZoneState* m_conversion_zone_state; + MenuAssetZoneState* m_parsing_zone_state; + static void ApplyMenuDefaults(menuDef_t* menu) { memset(menu, 0, sizeof(menuDef_t)); @@ -90,39 +95,16 @@ namespace IW4 return static_cast(materialDependency->m_ptr); } - static const std::map& GetFunctionMap() + void ConvertExpressionEntryBaseFunctionCall(Statement_s* gameStatement, std::vector& entries, const CommonExpressionBaseFunctionCall* functionCall, const CommonMenuDef* menu, + const CommonItemDef* item) const { - static std::map mappings; - static bool initialized = false; - - if(!initialized) - { - for(size_t i = EXP_FUNC_DYN_START; i < std::extent_v; i++) - { - mappings[g_expFunctionNames[i]] = static_cast(i); - } - initialized = true; - } - - return mappings; - } - - void ConvertExpressionEntryFunctionCall(std::vector& entries, const CommonExpressionFunctionCall* functionCall, const CommonMenuDef* menu, - const CommonItemDef* item) const - { - const auto& functionMappings = GetFunctionMap(); - - const auto foundMapping = functionMappings.find(functionCall->m_function_name); - if (foundMapping == functionMappings.end()) - throw MenuConversionException("Could not find function \"" + functionCall->m_function_name + "\"", menu, item); - expressionEntry functionEntry{}; functionEntry.type = EET_OPERATOR; - functionEntry.data.op = foundMapping->second; + functionEntry.data.op = static_cast(functionCall->m_function_index); entries.emplace_back(functionEntry); auto firstArg = true; - for(const auto& arg : functionCall->m_args) + for (const auto& arg : functionCall->m_args) { if (!firstArg) { @@ -134,7 +116,7 @@ namespace IW4 else firstArg = false; - ConvertExpressionEntry(entries, arg.get(), menu, item); + ConvertExpressionEntry(gameStatement, entries, arg.get(), menu, item); } expressionEntry parenRight{}; @@ -143,6 +125,33 @@ namespace IW4 entries.emplace_back(parenRight); } + void ConvertExpressionEntryCustomFunctionCall(Statement_s* gameStatement, std::vector& entries, const CommonExpressionCustomFunctionCall* functionCall, const CommonMenuDef* menu, + const CommonItemDef* item) const + { + Statement_s* functionStatement = m_conversion_zone_state->FindFunction(functionCall->m_function_name); + + if (functionStatement == nullptr) + { + // Function was not converted yet: Convert it now + const auto foundCommonFunction = m_parsing_zone_state->m_functions_by_name.find(functionCall->m_function_name); + + if (foundCommonFunction == m_parsing_zone_state->m_functions_by_name.end()) + throw MenuConversionException("Failed to find definition for custom function \"" + functionCall->m_function_name + "\"", menu, item); + + functionStatement = ConvertExpression(foundCommonFunction->second->m_value.get(), menu, item); + functionStatement = m_conversion_zone_state->AddFunction(foundCommonFunction->second->m_name, functionStatement); + } + + expressionEntry functionEntry{}; + functionEntry.type = EET_OPERATOR; + functionEntry.data.operand.dataType = VAL_FUNCTION; + functionEntry.data.operand.internals.function = functionStatement; + entries.emplace_back(functionEntry); + + // Statement uses custom function so it needs supporting data + gameStatement->supportingData = m_conversion_zone_state->m_supporting_data; + } + constexpr static expressionOperatorType_e UNARY_OPERATION_MAPPING[static_cast(SimpleUnaryOperationId::COUNT)] { OP_NOT, @@ -150,7 +159,7 @@ namespace IW4 OP_SUBTRACT }; - void ConvertExpressionEntryUnaryOperation(std::vector& entries, const SimpleExpressionUnaryOperation* unaryOperation, const CommonMenuDef* menu, + void ConvertExpressionEntryUnaryOperation(Statement_s* gameStatement, std::vector& entries, const SimpleExpressionUnaryOperation* unaryOperation, const CommonMenuDef* menu, const CommonItemDef* item) const { assert(static_cast(unaryOperation->m_operation_type->m_id) < static_cast(SimpleUnaryOperationId::COUNT)); @@ -166,7 +175,7 @@ namespace IW4 parenLeft.data.op = OP_LEFTPAREN; entries.emplace_back(parenLeft); - ConvertExpressionEntry(entries, unaryOperation->m_operand.get(), menu, item); + ConvertExpressionEntry(gameStatement, entries, unaryOperation->m_operand.get(), menu, item); expressionEntry parenRight{}; parenRight.type = EET_OPERATOR; @@ -174,7 +183,7 @@ namespace IW4 entries.emplace_back(parenRight); } else - ConvertExpressionEntry(entries, unaryOperation->m_operand.get(), menu, item); + ConvertExpressionEntry(gameStatement, entries, unaryOperation->m_operand.get(), menu, item); } constexpr static expressionOperatorType_e BINARY_OPERATION_MAPPING[static_cast(SimpleBinaryOperationId::COUNT)] @@ -198,7 +207,7 @@ namespace IW4 OP_OR }; - void ConvertExpressionEntryBinaryOperation(std::vector& entries, const SimpleExpressionBinaryOperation* binaryOperation, const CommonMenuDef* menu, + void ConvertExpressionEntryBinaryOperation(Statement_s* gameStatement, std::vector& entries, const SimpleExpressionBinaryOperation* binaryOperation, const CommonMenuDef* menu, const CommonItemDef* item) const { if (binaryOperation->Operand1NeedsParenthesis()) @@ -208,7 +217,7 @@ namespace IW4 parenLeft.data.op = OP_LEFTPAREN; entries.emplace_back(parenLeft); - ConvertExpressionEntry(entries, binaryOperation->m_operand1.get(), menu, item); + ConvertExpressionEntry(gameStatement, entries, binaryOperation->m_operand1.get(), menu, item); expressionEntry parenRight{}; parenRight.type = EET_OPERATOR; @@ -216,7 +225,7 @@ namespace IW4 entries.emplace_back(parenRight); } else - ConvertExpressionEntry(entries, binaryOperation->m_operand1.get(), menu, item); + ConvertExpressionEntry(gameStatement, entries, binaryOperation->m_operand1.get(), menu, item); assert(static_cast(binaryOperation->m_operation_type->m_id) < static_cast(SimpleBinaryOperationId::COUNT)); expressionEntry operation{}; @@ -231,7 +240,7 @@ namespace IW4 parenLeft.data.op = OP_LEFTPAREN; entries.emplace_back(parenLeft); - ConvertExpressionEntry(entries, binaryOperation->m_operand2.get(), menu, item); + ConvertExpressionEntry(gameStatement, entries, binaryOperation->m_operand2.get(), menu, item); expressionEntry parenRight{}; parenRight.type = EET_OPERATOR; @@ -239,7 +248,7 @@ namespace IW4 entries.emplace_back(parenRight); } else - ConvertExpressionEntry(entries, binaryOperation->m_operand2.get(), menu, item); + ConvertExpressionEntry(gameStatement, entries, binaryOperation->m_operand2.get(), menu, item); } void ConvertExpressionEntryExpressionValue(std::vector& entries, const SimpleExpressionValue* expressionValue) const @@ -266,7 +275,7 @@ namespace IW4 entries.emplace_back(entry); } - void ConvertExpressionEntry(std::vector& entries, const ISimpleExpression* expression, const CommonMenuDef* menu, const CommonItemDef* item) const + void ConvertExpressionEntry(Statement_s* gameStatement, std::vector& entries, const ISimpleExpression* expression, const CommonMenuDef* menu, const CommonItemDef* item) const { if (!m_disable_optimizations && expression->IsStatic()) { @@ -279,15 +288,19 @@ namespace IW4 } else if (const auto* binaryOperation = dynamic_cast(expression)) { - ConvertExpressionEntryBinaryOperation(entries, binaryOperation, menu, item); + ConvertExpressionEntryBinaryOperation(gameStatement, entries, binaryOperation, menu, item); } else if (const auto* unaryOperation = dynamic_cast(expression)) { - ConvertExpressionEntryUnaryOperation(entries, unaryOperation, menu, item); + ConvertExpressionEntryUnaryOperation(gameStatement, entries, unaryOperation, menu, item); } - else if (const auto* functionCall = dynamic_cast(expression)) + else if (const auto* baseFunctionCall = dynamic_cast(expression)) { - ConvertExpressionEntryFunctionCall(entries, functionCall, menu, item); + ConvertExpressionEntryBaseFunctionCall(gameStatement, entries, baseFunctionCall, menu, item); + } + else if (const auto* customFunctionCall = dynamic_cast(expression)) + { + ConvertExpressionEntryCustomFunctionCall(gameStatement, entries, customFunctionCall, menu, item); } else if (dynamic_cast(expression)) { @@ -308,10 +321,11 @@ namespace IW4 auto* statement = m_memory->Create(); statement->lastResult = Operand{}; statement->lastExecuteTime = 0; + statement->supportingData = nullptr; // Supporting data is set upon using it std::vector expressionEntries; - ConvertExpressionEntry(expressionEntries, expression, menu, item); + ConvertExpressionEntry(statement, expressionEntries, expression, menu, item); auto* outputExpressionEntries = static_cast(m_memory->Alloc(sizeof(expressionEntry) * expressionEntries.size())); memcpy(outputExpressionEntries, expressionEntries.data(), sizeof(expressionEntry) * expressionEntries.size()); @@ -319,9 +333,6 @@ namespace IW4 statement->entries = outputExpressionEntries; statement->numEntries = static_cast(expressionEntries.size()); - // TODO: Add supporting data - statement->supportingData = nullptr; - return statement; } @@ -646,8 +657,12 @@ namespace IW4 public: MenuConverterImpl(const bool disableOptimizations, ISearchPath* searchPath, MemoryManager* memory, IAssetLoadingManager* manager) - : AbstractMenuConverter(disableOptimizations, searchPath, memory, manager) + : AbstractMenuConverter(disableOptimizations, searchPath, memory, manager), + m_conversion_zone_state(manager->GetAssetLoadingContext()->GetZoneAssetLoaderState()), + m_parsing_zone_state(manager->GetAssetLoadingContext()->GetZoneAssetLoaderState()) { + assert(m_conversion_zone_state); + assert(m_parsing_zone_state); } _NODISCARD menuDef_t* ConvertMenu(const CommonMenuDef& commonMenu) const @@ -697,6 +712,7 @@ namespace IW4 menu->onESC = ConvertEventHandlerSet(commonMenu.m_on_esc.get(), &commonMenu); menu->onKey = ConvertKeyHandler(commonMenu.m_key_handlers, &commonMenu); menu->items = ConvertMenuItems(commonMenu); + menu->expressionData = m_conversion_zone_state->m_supporting_data; return menu; } diff --git a/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionBaseFunctionCall.cpp b/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionBaseFunctionCall.cpp new file mode 100644 index 00000000..487d3688 --- /dev/null +++ b/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionBaseFunctionCall.cpp @@ -0,0 +1,43 @@ +#include "CommonExpressionBaseFunctionCall.h" + +using namespace menu; + +CommonExpressionBaseFunctionCall::CommonExpressionBaseFunctionCall(std::string functionName, size_t functionIndex) + : m_function_name(std::move(functionName)), + m_function_index(functionIndex) +{ +} + +bool CommonExpressionBaseFunctionCall::Equals(const ISimpleExpression* other) const +{ + const auto otherFunctionCall = dynamic_cast(other); + + if (!otherFunctionCall + || m_function_name != otherFunctionCall->m_function_name + || m_function_index != otherFunctionCall->m_function_index + || m_args.size() != otherFunctionCall->m_args.size()) + { + return false; + } + + for (auto i = 0u; i < m_args.size(); i++) + { + const auto* arg = m_args[i].get(); + const auto* otherArg = otherFunctionCall->m_args[i].get(); + + if (!arg->Equals(otherArg)) + return false; + } + + return true; +} + +bool CommonExpressionBaseFunctionCall::IsStatic() const +{ + return false; +} + +SimpleExpressionValue CommonExpressionBaseFunctionCall::Evaluate() const +{ + return SimpleExpressionValue(0); +} diff --git a/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionFunctionCall.h b/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionBaseFunctionCall.h similarity index 68% rename from src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionFunctionCall.h rename to src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionBaseFunctionCall.h index 93b77468..e1626bc2 100644 --- a/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionFunctionCall.h +++ b/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionBaseFunctionCall.h @@ -5,13 +5,14 @@ namespace menu { - class CommonExpressionFunctionCall final : public ISimpleExpression + class CommonExpressionBaseFunctionCall final : public ISimpleExpression { public: std::string m_function_name; + size_t m_function_index; std::vector> m_args; - explicit CommonExpressionFunctionCall(std::string functionName); + CommonExpressionBaseFunctionCall(std::string functionName, size_t functionIndex); _NODISCARD bool Equals(const ISimpleExpression* other) const override; _NODISCARD bool IsStatic() const override; diff --git a/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionCustomFunctionCall.cpp b/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionCustomFunctionCall.cpp new file mode 100644 index 00000000..af702165 --- /dev/null +++ b/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionCustomFunctionCall.cpp @@ -0,0 +1,24 @@ +#include "CommonExpressionCustomFunctionCall.h" + +using namespace menu; + +CommonExpressionCustomFunctionCall::CommonExpressionCustomFunctionCall(std::string functionName) + : m_function_name(std::move(functionName)) +{ +} + +bool CommonExpressionCustomFunctionCall::Equals(const ISimpleExpression* other) const +{ + const auto otherFunctionCall = dynamic_cast(other); + return otherFunctionCall && m_function_name == otherFunctionCall->m_function_name; +} + +bool CommonExpressionCustomFunctionCall::IsStatic() const +{ + return false; +} + +SimpleExpressionValue CommonExpressionCustomFunctionCall::Evaluate() const +{ + return SimpleExpressionValue(0); +} diff --git a/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionCustomFunctionCall.h b/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionCustomFunctionCall.h new file mode 100644 index 00000000..7536d96a --- /dev/null +++ b/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionCustomFunctionCall.h @@ -0,0 +1,18 @@ +#pragma once + +#include "Parsing/Simple/Expression/ISimpleExpression.h" + +namespace menu +{ + class CommonExpressionCustomFunctionCall final : public ISimpleExpression + { + public: + std::string m_function_name; + + explicit CommonExpressionCustomFunctionCall(std::string functionName); + + _NODISCARD bool Equals(const ISimpleExpression* other) const override; + _NODISCARD bool IsStatic() const override; + _NODISCARD SimpleExpressionValue Evaluate() const override; + }; +} diff --git a/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionFunctionCall.cpp b/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionFunctionCall.cpp deleted file mode 100644 index 4842f286..00000000 --- a/src/ObjLoading/Parsing/Menu/Domain/Expression/CommonExpressionFunctionCall.cpp +++ /dev/null @@ -1,41 +0,0 @@ -#include "CommonExpressionFunctionCall.h" - -using namespace menu; - -CommonExpressionFunctionCall::CommonExpressionFunctionCall(std::string functionName) - : m_function_name(std::move(functionName)) -{ -} - -bool CommonExpressionFunctionCall::Equals(const ISimpleExpression* other) const -{ - const auto otherFunctionCall = dynamic_cast(other); - - if (!otherFunctionCall - || m_function_name != otherFunctionCall->m_function_name - || m_args.size() != otherFunctionCall->m_args.size()) - { - return false; - } - - for(auto i = 0u; i < m_args.size(); i++) - { - const auto* arg = m_args[i].get(); - const auto* otherArg = otherFunctionCall->m_args[i].get(); - - if (!arg->Equals(otherArg)) - return false; - } - - return true; -} - -bool CommonExpressionFunctionCall::IsStatic() const -{ - return false; -} - -SimpleExpressionValue CommonExpressionFunctionCall::Evaluate() const -{ - return SimpleExpressionValue(0); -} diff --git a/src/ObjLoading/Parsing/Menu/Matcher/MenuExpressionMatchers.cpp b/src/ObjLoading/Parsing/Menu/Matcher/MenuExpressionMatchers.cpp index 79b094c3..35e7bf05 100644 --- a/src/ObjLoading/Parsing/Menu/Matcher/MenuExpressionMatchers.cpp +++ b/src/ObjLoading/Parsing/Menu/Matcher/MenuExpressionMatchers.cpp @@ -1,7 +1,12 @@ #include "MenuExpressionMatchers.h" #include "MenuMatcherFactory.h" -#include "Parsing/Menu/Domain/Expression/CommonExpressionFunctionCall.h" +#include "Game/IW4/IW4.h" +#include "Game/IW5/IW5.h" +#include "Game/IW4/MenuConstantsIW4.h" +#include "Game/IW5/MenuConstantsIW5.h" +#include "Parsing/Menu/Domain/Expression/CommonExpressionBaseFunctionCall.h" +#include "Parsing/Menu/Domain/Expression/CommonExpressionCustomFunctionCall.h" using namespace menu; @@ -10,9 +15,14 @@ static constexpr int TAG_EXPRESSION_FUNCTION_CALL_END = SimpleExpressionMatchers static constexpr int CAPTURE_FUNCTION_NAME = SimpleExpressionMatchers::CAPTURE_OFFSET_EXPRESSION_EXT + 1; +MenuExpressionMatchers::MenuExpressionMatchers(const MenuFileParserState* state) + : SimpleExpressionMatchers(true, true, true, true, true), + m_state(state) +{ +} MenuExpressionMatchers::MenuExpressionMatchers() - : SimpleExpressionMatchers(true, true, true, true, true) + : MenuExpressionMatchers(nullptr) { } @@ -36,17 +46,73 @@ std::unique_ptr MenuExpressionMatchers::Par }); } +const std::map& MenuExpressionMatchers::GetBaseFunctionMapForFeatureLevel(const FeatureLevel featureLevel) +{ + if(featureLevel == FeatureLevel::IW4) + { + static std::map iw4FunctionMap; + static bool iw4FunctionMapInitialized = false; + + if(!iw4FunctionMapInitialized) + { + for(size_t i = IW4::expressionFunction_e::EXP_FUNC_DYN_START; i < std::extent_v; i++) + iw4FunctionMap.emplace(std::make_pair(IW4::g_expFunctionNames[i], i)); + } + + return iw4FunctionMap; + } + if(featureLevel == FeatureLevel::IW5) + { + static std::map iw5FunctionMap; + static bool iw5FunctionMapInitialized = false; + + if(!iw5FunctionMapInitialized) + { + for(size_t i = IW5::expressionFunction_e::EXP_FUNC_DYN_START; i < std::extent_v; i++) + iw5FunctionMap.emplace(std::make_pair(IW5::g_expFunctionNames[i], i)); + } + + return iw5FunctionMap; + } + + assert(false); + throw ParsingException(TokenPos(), "Feature level has no functions registered!!"); +} + std::unique_ptr MenuExpressionMatchers::ProcessOperandExtension(SequenceResult& result) const { + assert(m_state); + if(m_state == nullptr) + throw ParsingException(TokenPos(), "No state when processing menu operand extension!!"); + if (result.PeekAndRemoveIfTag(TAG_EXPRESSION_FUNCTION_CALL) != TAG_EXPRESSION_FUNCTION_CALL) throw ParsingException(TokenPos(), "Menu Operand Extension must be function call"); - auto functionCall = std::make_unique(result.NextCapture(CAPTURE_FUNCTION_NAME).IdentifierValue()); + const auto& functionCallToken = result.NextCapture(CAPTURE_FUNCTION_NAME); + auto functionCallName = functionCallToken.IdentifierValue(); - while (result.PeekAndRemoveIfTag(TAG_EXPRESSION_FUNCTION_CALL_END) != TAG_EXPRESSION_FUNCTION_CALL_END) + const auto& baseFunctionMap = GetBaseFunctionMapForFeatureLevel(m_state->m_feature_level); + const auto foundBaseFunction = baseFunctionMap.find(functionCallName); + if(foundBaseFunction != baseFunctionMap.end()) { - functionCall->m_args.emplace_back(ProcessExpression(result)); + auto functionCall = std::make_unique(std::move(functionCallName), foundBaseFunction->second); + while (result.PeekAndRemoveIfTag(TAG_EXPRESSION_FUNCTION_CALL_END) != TAG_EXPRESSION_FUNCTION_CALL_END) + { + functionCall->m_args.emplace_back(ProcessExpression(result)); + } + return std::move(functionCall); } - return std::move(functionCall); -} \ No newline at end of file + const auto foundCustomFunction = m_state->m_functions_by_name.find(functionCallName); + if(foundCustomFunction != m_state->m_functions_by_name.end()) + { + auto functionCall = std::make_unique(std::move(functionCallName)); + + if(result.PeekAndRemoveIfTag(TAG_EXPRESSION_FUNCTION_CALL_END) != TAG_EXPRESSION_FUNCTION_CALL_END) + throw ParsingException(functionCallToken.GetPos(), "Custom functions cannot be called with arguments"); + + return std::move(functionCall); + } + + throw ParsingException(functionCallToken.GetPos(), "Unknown function"); +} diff --git a/src/ObjLoading/Parsing/Menu/Matcher/MenuExpressionMatchers.h b/src/ObjLoading/Parsing/Menu/Matcher/MenuExpressionMatchers.h index ab59cfd6..b6821fce 100644 --- a/src/ObjLoading/Parsing/Menu/Matcher/MenuExpressionMatchers.h +++ b/src/ObjLoading/Parsing/Menu/Matcher/MenuExpressionMatchers.h @@ -2,14 +2,20 @@ #include +#include "Parsing/Menu/MenuFileParserState.h" #include "Parsing/Simple/Expression/SimpleExpressionMatchers.h" namespace menu { class MenuExpressionMatchers final : public SimpleExpressionMatchers { + const MenuFileParserState* m_state; + + static const std::map& GetBaseFunctionMapForFeatureLevel(FeatureLevel featureLevel); + public: MenuExpressionMatchers(); + explicit MenuExpressionMatchers(const MenuFileParserState* state); protected: std::unique_ptr ParseOperandExtension(const supplier_t* labelSupplier) const override; diff --git a/src/ObjLoading/Parsing/Menu/Matcher/MenuMatcherFactory.cpp b/src/ObjLoading/Parsing/Menu/Matcher/MenuMatcherFactory.cpp index 07b7189b..6fc242f8 100644 --- a/src/ObjLoading/Parsing/Menu/Matcher/MenuMatcherFactory.cpp +++ b/src/ObjLoading/Parsing/Menu/Matcher/MenuMatcherFactory.cpp @@ -101,7 +101,7 @@ std::string& MenuMatcherFactory::TokenTextValue(const SimpleParserValue& value) return value.StringValue(); } -int MenuMatcherFactory::TokenIntExpressionValue(SequenceResult& result) +int MenuMatcherFactory::TokenIntExpressionValue(MenuFileParserState* state, SequenceResult& result) { const auto nextTag = result.PeekTag(); @@ -115,7 +115,7 @@ int MenuMatcherFactory::TokenIntExpressionValue(SequenceResultIsStatic()) throw ParsingException(result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos(), "Not a valid static expression"); @@ -131,7 +131,7 @@ int MenuMatcherFactory::TokenIntExpressionValue(SequenceResult& result) +double MenuMatcherFactory::TokenNumericExpressionValue(MenuFileParserState* state, SequenceResult& result) { const auto nextTag = result.PeekTag(); @@ -145,7 +145,7 @@ double MenuMatcherFactory::TokenNumericExpressionValue(SequenceResultIsStatic()) throw ParsingException(result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos(), "Not a valid static expression"); diff --git a/src/ObjLoading/Parsing/Menu/Matcher/MenuMatcherFactory.h b/src/ObjLoading/Parsing/Menu/Matcher/MenuMatcherFactory.h index d965c5ec..4762690b 100644 --- a/src/ObjLoading/Parsing/Menu/Matcher/MenuMatcherFactory.h +++ b/src/ObjLoading/Parsing/Menu/Matcher/MenuMatcherFactory.h @@ -2,6 +2,7 @@ #include "Parsing/Sequence/SequenceResult.h" #include "Parsing/Simple/Matcher/SimpleMatcherFactory.h" +#include "Parsing/Menu/MenuFileParserState.h" namespace menu { @@ -30,7 +31,7 @@ namespace menu _NODISCARD static double TokenNumericFloatingPointValue(const SimpleParserValue& value); _NODISCARD static std::string& TokenTextValue(const SimpleParserValue& value); - _NODISCARD static int TokenIntExpressionValue(SequenceResult& result); - _NODISCARD static double TokenNumericExpressionValue(SequenceResult& result); + _NODISCARD static int TokenIntExpressionValue(MenuFileParserState* state, SequenceResult& result); + _NODISCARD static double TokenNumericExpressionValue(MenuFileParserState* state, SequenceResult& result); }; } diff --git a/src/ObjLoading/Parsing/Menu/MenuAssetZoneState.cpp b/src/ObjLoading/Parsing/Menu/MenuAssetZoneState.cpp new file mode 100644 index 00000000..5f2d9387 --- /dev/null +++ b/src/ObjLoading/Parsing/Menu/MenuAssetZoneState.cpp @@ -0,0 +1,19 @@ +#include "MenuAssetZoneState.h" + +using namespace menu; + +void MenuAssetZoneState::AddLoadedFile(std::string loadedFileName) +{ + m_loaded_files.emplace(std::move(loadedFileName)); +} + +void MenuAssetZoneState::AddFunction(std::unique_ptr function) +{ + m_functions_by_name.emplace(std::make_pair(function->m_name, function.get())); + m_functions.emplace_back(std::move(function)); +} + +void MenuAssetZoneState::AddMenu(std::unique_ptr menu) +{ + m_menus.emplace_back(std::move(menu)); +} diff --git a/src/ObjLoading/Parsing/Menu/MenuAssetZoneState.h b/src/ObjLoading/Parsing/Menu/MenuAssetZoneState.h index 79d503ce..2671032a 100644 --- a/src/ObjLoading/Parsing/Menu/MenuAssetZoneState.h +++ b/src/ObjLoading/Parsing/Menu/MenuAssetZoneState.h @@ -16,6 +16,12 @@ namespace menu std::vector> m_functions; std::vector> m_menus; + std::map m_functions_by_name; + MenuAssetZoneState() = default; + + void AddLoadedFile(std::string loadedFileName); + void AddFunction(std::unique_ptr function); + void AddMenu(std::unique_ptr menu); }; } diff --git a/src/ObjLoading/Parsing/Menu/Sequence/EventHandlerSetScopeSequences.cpp b/src/ObjLoading/Parsing/Menu/Sequence/EventHandlerSetScopeSequences.cpp index 184b8bc2..40ceb55a 100644 --- a/src/ObjLoading/Parsing/Menu/Sequence/EventHandlerSetScopeSequences.cpp +++ b/src/ObjLoading/Parsing/Menu/Sequence/EventHandlerSetScopeSequences.cpp @@ -582,7 +582,7 @@ namespace menu::event_handler_set_scope_sequences protected: void ProcessMatch(MenuFileParserState* state, SequenceResult& result) const override { - const MenuExpressionMatchers expressionMatchers; + const MenuExpressionMatchers expressionMatchers(state); const auto typeTag = static_cast(result.NextTag()); const auto& varNameToken = result.NextCapture(CAPTURE_VAR_NAME); @@ -623,7 +623,7 @@ namespace menu::event_handler_set_scope_sequences protected: void ProcessMatch(MenuFileParserState* state, SequenceResult& result) const override { - const MenuExpressionMatchers expressionMatchers; + const MenuExpressionMatchers expressionMatchers(state); auto expression = expressionMatchers.ProcessExpression(result); if (!expression) @@ -668,7 +668,7 @@ namespace menu::event_handler_set_scope_sequences protected: void ProcessMatch(MenuFileParserState* state, SequenceResult& result) const override { - const MenuExpressionMatchers expressionMatchers; + const MenuExpressionMatchers expressionMatchers(state); auto expression = expressionMatchers.ProcessExpression(result); if (!expression) @@ -708,9 +708,7 @@ namespace menu::event_handler_set_scope_sequences { const ScriptMatcherFactory create(this); const MenuExpressionMatchers expressionMatchers; - - AddLabeledMatchers(expressionMatchers.Expression(this), MenuExpressionMatchers::LABEL_EXPRESSION); - + AddMatchers({ create.Char('}'), create.Keyword("else").Capture(CAPTURE_KEYWORD), diff --git a/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericColorPropertySequence.cpp b/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericColorPropertySequence.cpp index 7e052fd0..cec2bfc9 100644 --- a/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericColorPropertySequence.cpp +++ b/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericColorPropertySequence.cpp @@ -22,10 +22,10 @@ GenericColorPropertySequence::GenericColorPropertySequence(std::string keywordNa }); } -double GenericColorPropertySequence::ReadColorValue(SequenceResult& result) +double GenericColorPropertySequence::ReadColorValue(MenuFileParserState* state, SequenceResult& result) { if (result.PeekAndRemoveIfTag(TAG_COLOR) == TAG_COLOR) - return MenuMatcherFactory::TokenNumericExpressionValue(result); + return MenuMatcherFactory::TokenNumericExpressionValue(state, result); return 0.0; } @@ -35,10 +35,10 @@ void GenericColorPropertySequence::ProcessMatch(MenuFileParserState* state, Sequ if (m_set_callback) { CommonColor color{}; - color.r = ReadColorValue(result); - color.g = ReadColorValue(result); - color.b = ReadColorValue(result); - color.a = ReadColorValue(result); + color.r = ReadColorValue(state, result); + color.g = ReadColorValue(state, result); + color.b = ReadColorValue(state, result); + color.a = ReadColorValue(state, result); m_set_callback(state, result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos(), color); } diff --git a/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericColorPropertySequence.h b/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericColorPropertySequence.h index 29c815ab..49a0045a 100644 --- a/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericColorPropertySequence.h +++ b/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericColorPropertySequence.h @@ -20,7 +20,7 @@ namespace menu const callback_t m_set_callback; - static double ReadColorValue(SequenceResult& result); + static double ReadColorValue(MenuFileParserState* state, SequenceResult& result); protected: void ProcessMatch(MenuFileParserState* state, SequenceResult& result) const override; diff --git a/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericExpressionPropertySequence.cpp b/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericExpressionPropertySequence.cpp index f9f70059..bfde58c7 100644 --- a/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericExpressionPropertySequence.cpp +++ b/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericExpressionPropertySequence.cpp @@ -65,7 +65,7 @@ void GenericExpressionPropertySequence::ProcessMatch(MenuFileParserState* state, { if (m_set_callback) { - const MenuExpressionMatchers expressionMatchers; + const MenuExpressionMatchers expressionMatchers(state); auto expression = expressionMatchers.ProcessExpression(result); m_set_callback(state, result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos(), std::move(expression)); } diff --git a/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericFloatingPointPropertySequence.cpp b/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericFloatingPointPropertySequence.cpp index a5de6ad6..14ebd542 100644 --- a/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericFloatingPointPropertySequence.cpp +++ b/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericFloatingPointPropertySequence.cpp @@ -23,7 +23,7 @@ void GenericFloatingPointPropertySequence::ProcessMatch(MenuFileParserState* sta { if (m_set_callback) { - const auto value = MenuMatcherFactory::TokenNumericExpressionValue(result); + const auto value = MenuMatcherFactory::TokenNumericExpressionValue(state, result); m_set_callback(state, result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos(), value); } } diff --git a/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericIntPropertySequence.cpp b/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericIntPropertySequence.cpp index fbf002e4..d2747dd1 100644 --- a/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericIntPropertySequence.cpp +++ b/src/ObjLoading/Parsing/Menu/Sequence/Generic/GenericIntPropertySequence.cpp @@ -23,7 +23,7 @@ void GenericIntPropertySequence::ProcessMatch(MenuFileParserState* state, Sequen { if (m_set_callback) { - const auto value = MenuMatcherFactory::TokenIntExpressionValue(result); + const auto value = MenuMatcherFactory::TokenIntExpressionValue(state, result); m_set_callback(state, result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos(), value); } } diff --git a/src/ObjLoading/Parsing/Menu/Sequence/ItemScopeSequences.cpp b/src/ObjLoading/Parsing/Menu/Sequence/ItemScopeSequences.cpp index 2a7d12f0..7411fb0d 100644 --- a/src/ObjLoading/Parsing/Menu/Sequence/ItemScopeSequences.cpp +++ b/src/ObjLoading/Parsing/Menu/Sequence/ItemScopeSequences.cpp @@ -188,10 +188,10 @@ namespace menu::item_scope_sequences { assert(state->m_current_item); - const auto x = MenuMatcherFactory::TokenNumericExpressionValue(result); - const auto y = MenuMatcherFactory::TokenNumericExpressionValue(result); - const auto w = MenuMatcherFactory::TokenNumericExpressionValue(result); - const auto h = MenuMatcherFactory::TokenNumericExpressionValue(result); + const auto x = MenuMatcherFactory::TokenNumericExpressionValue(state, result); + const auto y = MenuMatcherFactory::TokenNumericExpressionValue(state, result); + const auto w = MenuMatcherFactory::TokenNumericExpressionValue(state, result); + const auto h = MenuMatcherFactory::TokenNumericExpressionValue(state, result); CommonRect rect { x, @@ -231,8 +231,8 @@ namespace menu::item_scope_sequences { assert(state->m_current_item); - state->m_current_item->m_rect.x = MenuMatcherFactory::TokenNumericExpressionValue(result); - state->m_current_item->m_rect.y = MenuMatcherFactory::TokenNumericExpressionValue(result); + state->m_current_item->m_rect.x = MenuMatcherFactory::TokenNumericExpressionValue(state, result); + state->m_current_item->m_rect.y = MenuMatcherFactory::TokenNumericExpressionValue(state, result); } }; @@ -261,9 +261,9 @@ namespace menu::item_scope_sequences { assert(state->m_current_item); - state->m_current_item->m_fx_letter_time = MenuMatcherFactory::TokenIntExpressionValue(result); - state->m_current_item->m_fx_decay_start_time = MenuMatcherFactory::TokenIntExpressionValue(result); - state->m_current_item->m_fx_decay_duration = MenuMatcherFactory::TokenIntExpressionValue(result); + state->m_current_item->m_fx_letter_time = MenuMatcherFactory::TokenIntExpressionValue(state, result); + state->m_current_item->m_fx_decay_start_time = MenuMatcherFactory::TokenIntExpressionValue(state, result); + state->m_current_item->m_fx_decay_duration = MenuMatcherFactory::TokenIntExpressionValue(state, result); } }; @@ -341,9 +341,9 @@ namespace menu::item_scope_sequences ItemScopeOperations::EnsureHasEditFieldFeatures(*state->m_current_item, result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos()); state->m_current_item->m_dvar = MenuMatcherFactory::TokenTextValue(result.NextCapture(CAPTURE_DVAR_NAME)); - state->m_current_item->m_edit_field_features->m_def_val = MenuMatcherFactory::TokenNumericExpressionValue(result); - state->m_current_item->m_edit_field_features->m_min_val = MenuMatcherFactory::TokenNumericExpressionValue(result); - state->m_current_item->m_edit_field_features->m_max_val = MenuMatcherFactory::TokenNumericExpressionValue(result); + state->m_current_item->m_edit_field_features->m_def_val = MenuMatcherFactory::TokenNumericExpressionValue(state, result); + state->m_current_item->m_edit_field_features->m_min_val = MenuMatcherFactory::TokenNumericExpressionValue(state, result); + state->m_current_item->m_edit_field_features->m_max_val = MenuMatcherFactory::TokenNumericExpressionValue(state, result); } }; @@ -422,7 +422,7 @@ namespace menu::item_scope_sequences while (result.HasNextCapture(CAPTURE_STEP_NAME)) { multiValueFeatures->m_step_names.emplace_back(MenuMatcherFactory::TokenTextValue(result.NextCapture(CAPTURE_STEP_NAME))); - multiValueFeatures->m_double_values.emplace_back(MenuMatcherFactory::TokenNumericExpressionValue(result)); + multiValueFeatures->m_double_values.emplace_back(MenuMatcherFactory::TokenNumericExpressionValue(state, result)); } } }; diff --git a/src/ObjLoading/Parsing/Menu/Sequence/MenuScopeSequences.cpp b/src/ObjLoading/Parsing/Menu/Sequence/MenuScopeSequences.cpp index 22f38be8..6dcb8d73 100644 --- a/src/ObjLoading/Parsing/Menu/Sequence/MenuScopeSequences.cpp +++ b/src/ObjLoading/Parsing/Menu/Sequence/MenuScopeSequences.cpp @@ -124,10 +124,10 @@ namespace menu::menu_scope_sequences { assert(state->m_current_menu); - const auto x = MenuMatcherFactory::TokenNumericExpressionValue(result); - const auto y = MenuMatcherFactory::TokenNumericExpressionValue(result); - const auto w = MenuMatcherFactory::TokenNumericExpressionValue(result); - const auto h = MenuMatcherFactory::TokenNumericExpressionValue(result); + const auto x = MenuMatcherFactory::TokenNumericExpressionValue(state, result); + const auto y = MenuMatcherFactory::TokenNumericExpressionValue(state, result); + const auto w = MenuMatcherFactory::TokenNumericExpressionValue(state, result); + const auto h = MenuMatcherFactory::TokenNumericExpressionValue(state, result); CommonRect rect { x,