diff --git a/Makefile b/Makefile index 3bcb527dd..d3b6cd62e 100644 --- a/Makefile +++ b/Makefile @@ -634,13 +634,21 @@ SRCS = \ src/tdme/tools/installer/Installer.cpp \ src/tdme/utilities/Base64.cpp \ src/tdme/utilities/Console.cpp \ + src/tdme/utilities/EngineMiniScript.cpp \ src/tdme/utilities/ExceptionBase.cpp \ src/tdme/utilities/Float.cpp \ src/tdme/utilities/Hex.cpp \ src/tdme/utilities/Integer.cpp \ src/tdme/utilities/MiniScript.cpp \ src/tdme/utilities/MiniScriptMath.cpp \ + src/tdme/utilities/MiniScriptTransform.cpp \ src/tdme/utilities/MiniScriptTranspiler.cpp \ + src/tdme/utilities/MiniScriptMatrix3x3.cpp \ + src/tdme/utilities/MiniScriptMatrix4x4.cpp \ + src/tdme/utilities/MiniScriptQuaternion.cpp \ + src/tdme/utilities/MiniScriptVector2.cpp \ + src/tdme/utilities/MiniScriptVector3.cpp \ + src/tdme/utilities/MiniScriptVector4.cpp \ src/tdme/utilities/ModelTools.cpp \ src/tdme/utilities/PathFinding.cpp \ src/tdme/utilities/Primitives.cpp \ diff --git a/Makefile.nmake b/Makefile.nmake index 754d7547b..59d4d6607 100644 --- a/Makefile.nmake +++ b/Makefile.nmake @@ -495,13 +495,21 @@ SRCS = \ src/tdme/tools/installer/Installer.cpp \ src/tdme/utilities/Base64.cpp \ src/tdme/utilities/Console.cpp \ + src/tdme/utilities/EngineMiniScript.cpp \ src/tdme/utilities/ExceptionBase.cpp \ src/tdme/utilities/Float.cpp \ src/tdme/utilities/Hex.cpp \ src/tdme/utilities/Integer.cpp \ src/tdme/utilities/MiniScript.cpp \ src/tdme/utilities/MiniScriptMath.cpp \ + src/tdme/utilities/MiniScriptTransform.cpp \ src/tdme/utilities/MiniScriptTranspiler.cpp \ + src/tdme/utilities/MiniScriptMatrix3x3.cpp \ + src/tdme/utilities/MiniScriptMatrix4x4.cpp \ + src/tdme/utilities/MiniScriptQuaternion.cpp \ + src/tdme/utilities/MiniScriptVector2.cpp \ + src/tdme/utilities/MiniScriptVector3.cpp \ + src/tdme/utilities/MiniScriptVector4.cpp \ src/tdme/utilities/ModelTools.cpp \ src/tdme/utilities/PathFinding.cpp \ src/tdme/utilities/Primitives.cpp \ diff --git a/README-MiniScript.md b/README-MiniScript.md index 4a6456315..0b77a5aba 100644 --- a/README-MiniScript.md +++ b/README-MiniScript.md @@ -7,16 +7,16 @@ This is the documentation of MiniScript language. This document is WIP. Introduction to MiniScript language features: - very small implementation of a scripting language - runs on every CPU, OS, ... due to its simplicity, so its highly portable just like TDME2 is -- can be easily extended by writing state machine machine states and script methods in C++ -- works with the following data types: null, boolean, integer, float, string, vector2, vector3, vector4, quaternion, matrix3x3, matrix4x4, transform, array, map and set +- can be easily extended by writing state machine machine states and script methods in C++ as well as custom data types +- built-in data types: null, boolean, integer, float, string, vector2, vector3, vector4, quaternion, matrix3x3, matrix4x4, transform, array, map and set - when calling script C++ methods or script functions with arguments it does optionally use references or value by copy - supports user script functions and recursion - supports operators by operator to method mapping by a preprocessor run - supports loops and conditions - supports programming with classes style programming - - for string, vector2, vector3, vector4, quaternion, matrix3x3, matrix4x4, transform, array, map and set data types - - via script classes - - custom data types are planned + - for built-in datatypes: null, boolean, integer, float, string, vector2, vector3, vector4, quaternion, matrix3x3, matrix4x4, transform, array, map and set + - for script classes/objects + - for custom data types - supports event like programming - can be transpiled to C++ @@ -116,11 +116,13 @@ end ... ``` -If a argument variable is prefixed with a = operator in function declaration, this variable will be assigned back after the function returns. See =$b and =$c. +If a argument(variable) is prefixed with a & operator in the function declaration, the variable will not be copied into the function arguments, +but a reference will be created, means if this variable changes within the function it will also change in the parent variable scope. +See &$b and &$c. ``` ... # user script function to test assign back in user functions -function: assignTest($a, =$b, =$c) +function: assignTest($a, &$b, &$c) $a = "a" $b = "b" $c = "c" @@ -614,7 +616,7 @@ Please see a example below. " horses in it" ) }, - getProperties: (=$wheelCount, =$color, =$horsePower) -> + getProperties: (&$wheelCount, &$color, &$horsePower) -> { $wheelCount = $this.wheelCount $color = $this.color @@ -651,7 +653,7 @@ If you want to assign a class member function later, see this example. Note that ``` ... -function: setConvertible(=$this, $convertible) +function: setConvertible(&$this, $convertible) $this.convertible = $convertible end @@ -906,7 +908,7 @@ end | Create transform from 4x4 matrix | | static transform.fromMatrix($transformMatrix: Matrix4x4): Transform | | Interpolate rotation | -| static transform.interpolateRotation($currentAngle: Float, $targetAngle: Float, $timePassedSeconds: Float, $degreesPerSeconds: Float, =$interpolatedAngle: Float): Boolean| +| static transform.interpolateRotation($currentAngle: Float, $targetAngle: Float, $timePassedSeconds: Float, $degreesPerSeconds: Float, &$interpolatedAngle: Float): Boolean| |   | | NON STATIC METHODS | | Apply a rotation to transform | @@ -1068,9 +1070,9 @@ end | Logical or | | or($a: Boolean, $b: Boolean): Boolean | | Prefix decrement | -| prefixDecrement(=$variable: Integer): Integer | +| prefixDecrement(&$variable: Integer): Integer | | Prefix increment | -| prefixIncrement(=$variable: Integer): Integer | +| prefixIncrement(&$variable: Integer): Integer | | Return from function with optional return value | | return([$value: Mixed]): Null | | Subtract | @@ -1245,7 +1247,7 @@ The boilerplate template code for a MiniScript logic looks like: [logic_script_t | Get engine height - available in initializeEngine(), updateEngine() | | engine.getHeight(): Integer | | Compute engine screen coordinate by world coordinate - available in initializeEngine(), updateEngine()| -| engine.computeScreenCoordinateByWorldCoordinate($worldCoodinate: Vector3, =$screenCoordinate: Vector2): Boolean| +| engine.computeScreenCoordinateByWorldCoordinate($worldCoodinate: Vector3, &$screenCoordinate: Vector2): Boolean| | Get engine width - available in initializeEngine(), updateEngine() | | engine.getWidth(): Integer | | Compute engine world coordinate by mouse position - available in initializeEngine(), updateEngine()| @@ -1499,7 +1501,7 @@ The boilerplate template code for a MiniScript logic looks like: [logic_script_t | Pathfinding try/lock failed integer code - available in initializeLogic(), updateLogic(), onLogicAdded(), onLogicsProcessed()| | pathfinding.STATE_TRYLOCK_FAILED(): Integer | | Issue pathfinding - available in initializeLogic(), updateLogic(), onLogicAdded(), onLogicsProcessed()| -| pathfinding.findPath($logicId: String, $startPosition: Vector3, $endPosition: Vector3, =$path: Array): Integer| +| pathfinding.findPath($logicId: String, $startPosition: Vector3, $endPosition: Vector3, &$path: Array): Integer| ## 8.12 Scene methods @@ -1526,11 +1528,11 @@ The boilerplate template code for a MiniScript logic looks like: [logic_script_t |                                                                                           Table of methods                                                                                           | |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Determine height at specific position in physics world - available in initializeLogic(), updateLogic(), onLogicAdded(), onLogicsProcessed()| -| world.determineHeight($collisionTypeIds: Integer, $stepUpMax: Float, $point: Vector3, =$heightPoint: Vector3[, =$bodyId: String[, $minHeight: Float[, $maxHeight: Float]]]): Boolean| +| world.determineHeight($collisionTypeIds: Integer, $stepUpMax: Float, $point: Vector3, &$heightPoint: Vector3[, &$bodyId: String[, $minHeight: Float[, $maxHeight: Float]]]): Boolean| | Determine collision of two specific bodies in physics world - available in initializeLogic(), updateLogic(), onLogicAdded(), onLogicsProcessed()| | world.doCollide($bodyId1: String, $bodyId2: String): Boolean | | Compute ray casting in physics world - available in initializeLogic(), updateLogic(), onLogicAdded(), onLogicsProcessed()| -| world.doRayCasting($collisionTypeIds: Integer, $start: Vector3, $end: Vector3, =$hitPoint: Vector3[, =$bodyId: String[, $actorId: String]]): Boolean| +| world.doRayCasting($collisionTypeIds: Integer, $start: Vector3, $end: Vector3, &$hitPoint: Vector3[, &$bodyId: String[, $actorId: String]]): Boolean| | Determine collision of specific body in physics world - available in initializeLogic(), updateLogic(), onLogicAdded(), onLogicsProcessed()| | world.doesCollideWith($collisionTypeIds: Integer, $bodyId: String): Array | @@ -1851,9 +1853,9 @@ The boilerplate template code for a MiniScript GUI logic looks like: [gui_script | && | and($a: Boolean, $b: Boolean): Boolean | | * | mul($a: Mixed, $b: Mixed): Mixed | | + | add($a: Mixed, $b: Mixed): Mixed | -| ++ | prefixIncrement(=$variable: Integer): Integer | +| ++ | prefixIncrement(&$variable: Integer): Integer | | - | sub($a: Mixed, $b: Mixed): Mixed | -| -- | prefixDecrement(=$variable: Integer): Integer | +| -- | prefixDecrement(&$variable: Integer): Integer | | / | div($a: Mixed, $b: Mixed): Mixed | | < | lesser($a: Mixed, $b: Mixed): Boolean | | <= | lesserEquals($a: Mixed, $b: Mixed): Boolean | diff --git a/README.md b/README.md index ea667b3ea..56d826907 100644 --- a/README.md +++ b/README.md @@ -212,16 +212,16 @@ - MiniScript - very small implementation of a scripting language - runs on every CPU, OS, ... due to its simplicity, so its highly portable just like TDME2 is - - can be easily extended by writing state machine machine states and script methods in C++ - - works with the following data types: null, boolean, integer, float, string, vector2, vector3, vector4, quaternion, matrix3x3, matrix4x4, transform, array, map and set + - can be easily extended by writing state machine machine states and script methods in C++ as well as custom data types + - built-in data types: null, boolean, integer, float, string, vector2, vector3, vector4, quaternion, matrix3x3, matrix4x4, transform, array, map and set - when calling script C++ methods or script functions with arguments it does optionally use references or value by copy - supports user script functions and recursion - supports operators by operator to method mapping by a preprocessor run - supports loops and conditions - supports programming with classes style programming - - for string, vector2, vector3, vector4, quaternion, matrix3x3, matrix4x4, transform, array, map and set data types - - via script classes - - custom data types are planned + - for built-in datatypes: null, boolean, integer, float, string, vector2, vector3, vector4, quaternion, matrix3x3, matrix4x4, transform, array, map and set + - for script classes/objects + - for custom data types - supports event like programming - can be transpiled to C++ - how to use: diff --git a/resources/tests/scripts/class-test.tscript b/resources/tests/scripts/class-test.tscript index f4cc17fd2..eb4033098 100644 --- a/resources/tests/scripts/class-test.tscript +++ b/resources/tests/scripts/class-test.tscript @@ -43,7 +43,7 @@ on: nothing " horses in it" ) }, - getProperties: (=$wheelCount, =$color, =$horsePower) -> + getProperties: (&$wheelCount, &$color, &$horsePower) -> { $wheelCount = $this.wheelCount $color = $this.color diff --git a/resources/tests/scripts/functions-test.tscript b/resources/tests/scripts/functions-test.tscript index 0f13876cd..b5a7a208b 100644 --- a/resources/tests/scripts/functions-test.tscript +++ b/resources/tests/scripts/functions-test.tscript @@ -20,7 +20,7 @@ function: helloWorldFunction() end # user script function to test assign back in user functions -function: assignTest($a, =$b, =$c) +function: assignTest($a, &$b, &$c) $a = "a" $b = "b" $c = "c" diff --git a/src/tdme/engine/logics/Logic.h b/src/tdme/engine/logics/Logic.h index 72efcddc3..2f6ae5a27 100644 --- a/src/tdme/engine/logics/Logic.h +++ b/src/tdme/engine/logics/Logic.h @@ -8,7 +8,7 @@ #include #include #include -#include +#include #include using std::vector; @@ -18,7 +18,7 @@ using tdme::engine::physics::World; using tdme::engine::Engine; using tdme::gui::events::GUIKeyboardEvent; using tdme::gui::events::GUIMouseEvent; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tdme::utilities::Time; /** @@ -60,10 +60,10 @@ class tdme::engine::logics::Logic { struct SignalStruct { SignalStruct( const string& signal, - const vector& arguments + const vector& arguments ): signal(signal), arguments(arguments) {} string signal; - vector arguments; + vector arguments; }; vector signals; @@ -211,7 +211,7 @@ class tdme::engine::logics::Logic { * @param signal signal * @param arguments arguments */ - inline void addSignal(const string& signal, const vector& arguments) { + inline void addSignal(const string& signal, const vector& arguments) { signals.emplace_back( signal, arguments @@ -240,9 +240,9 @@ class tdme::engine::logics::Logic { * Get signal argument * @return signal argument at given index */ - inline MiniScript::ScriptVariable getSignalArgument(int idx) { - if (signals.empty() == true) return MiniScript::ScriptVariable(); - if (idx >= signals[0].arguments.size()) return MiniScript::ScriptVariable(); + inline EngineMiniScript::ScriptVariable getSignalArgument(int idx) { + if (signals.empty() == true) return EngineMiniScript::ScriptVariable(); + if (idx >= signals[0].arguments.size()) return EngineMiniScript::ScriptVariable(); return signals[0].arguments[idx]; } diff --git a/src/tdme/engine/logics/LogicMiniScript.cpp b/src/tdme/engine/logics/LogicMiniScript.cpp index 5ee7343a0..571e39966 100644 --- a/src/tdme/engine/logics/LogicMiniScript.cpp +++ b/src/tdme/engine/logics/LogicMiniScript.cpp @@ -37,7 +37,7 @@ #include #include #include -#include +#include #include using std::move; @@ -79,10 +79,10 @@ using tdme::tools::editor::Editor; using tdme::utilities::Character; using tdme::utilities::Console; using tdme::utilities::Exception; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tdme::utilities::UTF8CharacterIterator; -LogicMiniScript::LogicMiniScript(): MiniScript(), prototypesToAddMutex("prototypetoadd-mutex") { +LogicMiniScript::LogicMiniScript(): EngineMiniScript(), prototypesToAddMutex("prototypetoadd-mutex") { } LogicMiniScript::~LogicMiniScript() { @@ -93,7 +93,7 @@ const string LogicMiniScript::getBaseClass() { } const vector LogicMiniScript::getTranspilationUnits() { - auto transpilationUnits = MiniScript::getTranspilationUnits(); + auto transpilationUnits = EngineMiniScript::getTranspilationUnits(); transpilationUnits.push_back("src/tdme/engine/logics/LogicMiniScript.cpp"); return transpilationUnits; } @@ -115,11 +115,11 @@ inline Entity* LogicMiniScript::getEntity(const string& entityId, const string& } void LogicMiniScript::registerStateMachineStates() { - MiniScript::registerStateMachineStates(); + EngineMiniScript::registerStateMachineStates(); } void LogicMiniScript::registerMethods() { - MiniScript::registerMethods(); + EngineMiniScript::registerMethods(); { // class ScriptMethodApplicationRunsInEditor: public ScriptMethod { @@ -133,7 +133,7 @@ void LogicMiniScript::registerMethods() { return "application.runsInEditor"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(miniScript->logic->isRunningInEditor()); + miniScript->setValue(returnValue, miniScript->logic->isRunningInEditor()); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ALL; @@ -154,7 +154,7 @@ void LogicMiniScript::registerMethods() { return "application.isFullScreen"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(Editor::getInstance() != nullptr?Editor::getInstance()->isFullScreen():false); + miniScript->setValue(returnValue, Editor::getInstance() != nullptr?Editor::getInstance()->isFullScreen():false); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ALL; @@ -175,7 +175,7 @@ void LogicMiniScript::registerMethods() { return "logic.getId"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(miniScript->logic->getId()); + miniScript->setValue(returnValue, miniScript->logic->getId()); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ENGINELOGIC; @@ -196,7 +196,7 @@ void LogicMiniScript::registerMethods() { return "logic.getHierarchyId"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(miniScript->logic->getHierarchyId()); + miniScript->setValue(returnValue, miniScript->logic->getHierarchyId()); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ENGINELOGIC; @@ -217,7 +217,7 @@ void LogicMiniScript::registerMethods() { return "logic.getHierarchyParentId"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(miniScript->logic->getHierarchyParentId()); + miniScript->setValue(returnValue, miniScript->logic->getHierarchyParentId()); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ENGINELOGIC; @@ -239,9 +239,9 @@ void LogicMiniScript::registerMethods() { } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { const auto& contextLogics = miniScript->logic->getContext()->getLogics(); - returnValue.setType(MiniScript::TYPE_ARRAY); + returnValue.setType(EngineMiniScript::TYPE_ARRAY); for (auto contextLogic: contextLogics) { - returnValue.pushArrayEntry(MiniScript::ScriptVariable(contextLogic->getId())); + returnValue.pushArrayEntry(EngineMiniScript::ScriptVariable(contextLogic->getId())); } } const vector& getContextFunctions() { @@ -259,14 +259,14 @@ void LogicMiniScript::registerMethods() { ScriptMethodAudioGetListenerPosition(LogicMiniScript* miniScript): ScriptMethod( {}, - ScriptVariableType::TYPE_VECTOR3 + TYPE_VECTOR3 ), miniScript(miniScript) {} const string getMethodName() override { return "audio.getListenerPosition"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(miniScript->logic->getContext()->getAudio()->getListenerPosition()); + miniScript->setValue(returnValue, miniScript->logic->getContext()->getAudio()->getListenerPosition()); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ENGINE; @@ -283,7 +283,7 @@ void LogicMiniScript::registerMethods() { ScriptMethodAudioSetListenerPosition(LogicMiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "position", .optional = false, .reference = false, .nullable = false } + { .type = TYPE_VECTOR3, .name = "position", .optional = false, .reference = false, .nullable = false } }, ScriptVariableType::TYPE_NULL ), @@ -315,14 +315,14 @@ void LogicMiniScript::registerMethods() { ScriptMethodAudioGetListenerOrientationUp(LogicMiniScript* miniScript): ScriptMethod( {}, - ScriptVariableType::TYPE_VECTOR3 + TYPE_VECTOR3 ), miniScript(miniScript) {} const string getMethodName() override { return "audio.getListenerOrientationUp"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(miniScript->logic->getContext()->getAudio()->getListenerOrientationUp()); + miniScript->setValue(returnValue, miniScript->logic->getContext()->getAudio()->getListenerOrientationUp()); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ENGINE; @@ -339,7 +339,7 @@ void LogicMiniScript::registerMethods() { ScriptMethodAudioSetListenerOrientationUp(LogicMiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "orientation", .optional = false, .reference = false, .nullable = false } + { .type = TYPE_VECTOR3, .name = "orientation", .optional = false, .reference = false, .nullable = false } }, ScriptVariableType::TYPE_NULL ), @@ -371,14 +371,14 @@ void LogicMiniScript::registerMethods() { ScriptMethodAudioGetListenerOrientationAt(LogicMiniScript* miniScript): ScriptMethod( {}, - ScriptVariableType::TYPE_VECTOR3 + TYPE_VECTOR3 ), miniScript(miniScript) {} const string getMethodName() override { return "audio.getListenerOrientationAt"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(miniScript->logic->getContext()->getAudio()->getListenerOrientationAt()); + miniScript->setValue(returnValue, miniScript->logic->getContext()->getAudio()->getListenerOrientationAt()); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ENGINE; @@ -395,7 +395,7 @@ void LogicMiniScript::registerMethods() { ScriptMethodAudioSetListenerOrientationAt(LogicMiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "orientation", .optional = false, .reference = false, .nullable = false } + { .type = TYPE_VECTOR3, .name = "orientation", .optional = false, .reference = false, .nullable = false } }, ScriptVariableType::TYPE_NULL ), @@ -472,7 +472,7 @@ void LogicMiniScript::registerMethods() { ScriptMethod( { { .type = ScriptVariableType::TYPE_STRING, .name = "id", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "position", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "position", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_INTEGER, .name = "delay", .optional = true, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_INTEGER, .name = "gain", .optional = true, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_INTEGER, .name = "pitch", .optional = true, .reference = false, .nullable = false }, @@ -573,21 +573,21 @@ void LogicMiniScript::registerMethods() { void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string logicId; string callable; - if (MiniScript::getStringValue(argumentValues, 0, logicId) == false || - MiniScript::getStringValue(argumentValues, 1, callable) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, logicId) == false || + EngineMiniScript::getStringValue(argumentValues, 1, callable) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { auto logic = dynamic_cast(miniScript->context->getLogic(logicId)); if (logic == nullptr || logic->getMiniScript() == nullptr) { - returnValue.setValue(false); + miniScript->setValue(returnValue, false); } else { auto logicMiniScript = logic->getMiniScript(); auto scriptIdx = logicMiniScript->getFunctionScriptIdx(callable); if (scriptIdx == SCRIPTIDX_NONE || logicMiniScript->getScripts()[scriptIdx].callable == false) { - returnValue.setValue(false); + miniScript->setValue(returnValue, false); } else { - returnValue.setValue(true); + miniScript->setValue(returnValue, true); } } } @@ -616,8 +616,8 @@ void LogicMiniScript::registerMethods() { void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string logicId; string callable; - if (MiniScript::getStringValue(argumentValues, 0, logicId) == false || - MiniScript::getStringValue(argumentValues, 1, callable) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, logicId) == false || + EngineMiniScript::getStringValue(argumentValues, 1, callable) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -668,7 +668,7 @@ void LogicMiniScript::registerMethods() { return "logic.signal.has"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(miniScript->logic->hasSignal()); + miniScript->setValue(returnValue, miniScript->logic->hasSignal()); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ALL; @@ -689,7 +689,7 @@ void LogicMiniScript::registerMethods() { return "logic.signal.getName"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(miniScript->logic->getSignalName()); + miniScript->setValue(returnValue, miniScript->logic->getSignalName()); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ALL; @@ -1780,13 +1780,13 @@ void LogicMiniScript::registerMethods() { LogicMiniScript* miniScript { nullptr }; public: ScriptMethodCameraGetLookFrom(LogicMiniScript* miniScript): - ScriptMethod({}, ScriptVariableType::TYPE_VECTOR3), + ScriptMethod({}, TYPE_VECTOR3), miniScript(miniScript) {} const string getMethodName() override { return "engine.camera.getLookFrom"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue = miniScript->context->getEngine()->getCamera()->getLookFrom(); + miniScript->setValue(returnValue, miniScript->context->getEngine()->getCamera()->getLookFrom()); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ENGINE; @@ -1803,7 +1803,7 @@ void LogicMiniScript::registerMethods() { ScriptMethodCameraSetLookFrom(LogicMiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "lookFrom", .optional = false, .reference = false, .nullable = false } + { .type = TYPE_VECTOR3, .name = "lookFrom", .optional = false, .reference = false, .nullable = false } }, ScriptVariableType::TYPE_NULL ), @@ -1833,13 +1833,13 @@ void LogicMiniScript::registerMethods() { LogicMiniScript* miniScript { nullptr }; public: ScriptMethodCameraGetLookAt(LogicMiniScript* miniScript): - ScriptMethod({}, ScriptVariableType::TYPE_VECTOR3), + ScriptMethod({}, TYPE_VECTOR3), miniScript(miniScript) {} const string getMethodName() override { return "engine.camera.getLookAt"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue = miniScript->context->getEngine()->getCamera()->getLookAt(); + miniScript->setValue(returnValue, miniScript->context->getEngine()->getCamera()->getLookAt()); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ENGINE; @@ -1856,7 +1856,7 @@ void LogicMiniScript::registerMethods() { ScriptMethodCameraSetLookAt(LogicMiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "lookAt", .optional = false, .reference = false, .nullable = false } + { .type = TYPE_VECTOR3, .name = "lookAt", .optional = false, .reference = false, .nullable = false } }, ScriptVariableType::TYPE_NULL ), @@ -1886,13 +1886,13 @@ void LogicMiniScript::registerMethods() { LogicMiniScript* miniScript { nullptr }; public: ScriptMethodCameraGetUpVector(LogicMiniScript* miniScript): - ScriptMethod({}, ScriptVariableType::TYPE_VECTOR3), + ScriptMethod({}, TYPE_VECTOR3), miniScript(miniScript) {} const string getMethodName() override { return "engine.camera.getUpVector"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue = miniScript->context->getEngine()->getCamera()->getUpVector(); + miniScript->setValue(returnValue, miniScript->context->getEngine()->getCamera()->getUpVector()); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ENGINE; @@ -1909,7 +1909,7 @@ void LogicMiniScript::registerMethods() { ScriptMethodCameraSetUpVector(LogicMiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "upVector", .optional = false, .reference = false, .nullable = false } + { .type = TYPE_VECTOR3, .name = "upVector", .optional = false, .reference = false, .nullable = false } }, ScriptVariableType::TYPE_NULL ), @@ -1941,10 +1941,10 @@ void LogicMiniScript::registerMethods() { ScriptMethodCameraComputeUpVector(LogicMiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "lookFrom", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "lookAt", .optional = false, .reference = false, .nullable = false } + { .type = TYPE_VECTOR3, .name = "lookFrom", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "lookAt", .optional = false, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_VECTOR3 + TYPE_VECTOR3 ), miniScript(miniScript) {} const string getMethodName() override { @@ -1955,7 +1955,7 @@ void LogicMiniScript::registerMethods() { Vector3 lookAt; if (miniScript->getVector3Value(argumentValues, 0, lookFrom) == true && miniScript->getVector3Value(argumentValues, 1, lookAt) == true) { - returnValue = Camera::computeUpVector(lookFrom, lookAt); + miniScript->setValue(returnValue, Camera::computeUpVector(lookFrom, lookAt)); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); @@ -2098,7 +2098,7 @@ void LogicMiniScript::registerMethods() { return "engine.getAnimationComputationReduction1Distance"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(Engine::getAnimationComputationReduction1Distance()); + miniScript->setValue(returnValue, Engine::getAnimationComputationReduction1Distance()); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ENGINE; @@ -2152,7 +2152,7 @@ void LogicMiniScript::registerMethods() { return "engine.getAnimationComputationReduction2Distance"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(Engine::getAnimationComputationReduction2Distance()); + miniScript->setValue(returnValue, Engine::getAnimationComputationReduction2Distance()); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ENGINE; @@ -2325,7 +2325,7 @@ void LogicMiniScript::registerMethods() { { .type = ScriptVariableType::TYPE_INTEGER, .name = "mouseX", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_INTEGER, .name = "mouseY", .optional = false, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_VECTOR3 + TYPE_VECTOR3 ), miniScript(miniScript) {} const string getMethodName() override { @@ -2336,7 +2336,7 @@ void LogicMiniScript::registerMethods() { int64_t mouseY; if (miniScript->getIntegerValue(argumentValues, 0, mouseX) == true && miniScript->getIntegerValue(argumentValues, 1, mouseY) == true) { - returnValue = miniScript->context->getEngine()->computeWorldCoordinateByMousePosition(mouseX, mouseY); + miniScript->setValue(returnValue, miniScript->context->getEngine()->computeWorldCoordinateByMousePosition(mouseX, mouseY)); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); @@ -2357,8 +2357,8 @@ void LogicMiniScript::registerMethods() { ScriptMethodEngineComputeScreenCoordinateByWorldCoordinate(LogicMiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "worldCoodinate", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR2, .name = "screenCoordinate", .optional = false, .reference = true, .nullable = false } + { .type = TYPE_VECTOR3, .name = "worldCoodinate", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR2, .name = "screenCoordinate", .optional = false, .reference = true, .nullable = false } }, ScriptVariableType::TYPE_BOOLEAN ), @@ -2372,7 +2372,7 @@ void LogicMiniScript::registerMethods() { miniScript->getVector3Value(argumentValues, 0, worldCoodinate) == true) { Vector2 screenCoordinate; if (miniScript->context->getEngine()->computeScreenCoordinateByWorldCoordinate(worldCoodinate, screenCoordinate) == true) { - argumentValues[1].setValue(screenCoordinate); + miniScript->setValue(argumentValues[1], screenCoordinate); returnValue = true; } else { returnValue = false; @@ -2400,7 +2400,7 @@ void LogicMiniScript::registerMethods() { { .type = ScriptVariableType::TYPE_STRING, .name = "entityId", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "childEntityId", .optional = true, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_TRANSFORM + TYPE_TRANSFORM ), miniScript(miniScript) {} const string getMethodName() override { @@ -2413,7 +2413,7 @@ void LogicMiniScript::registerMethods() { miniScript->getStringValue(argumentValues, 1, childEntityId, true) == true) { auto entity = miniScript->getEntity(entityId, childEntityId); if (entity != nullptr) { - returnValue = entity->getTransform(); + miniScript->setValue(returnValue, entity->getTransform()); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": entity not found: " + (childEntityId.empty() == true?entityId:childEntityId + "@" + entityId)); } @@ -2438,7 +2438,7 @@ void LogicMiniScript::registerMethods() { ScriptMethod( { { .type = ScriptVariableType::TYPE_STRING, .name = "entityId", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "childEntityId", .optional = true, .reference = false, .nullable = false } }, ScriptVariableType::TYPE_NULL @@ -2649,7 +2649,7 @@ void LogicMiniScript::registerMethods() { { .type = ScriptVariableType::TYPE_STRING, .name = "entityId", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "childEntityId", .optional = true, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_VECTOR4 + TYPE_VECTOR4 ), miniScript(miniScript) {} const string getMethodName() override { @@ -2663,7 +2663,7 @@ void LogicMiniScript::registerMethods() { auto entity = miniScript->getEntity(entityId, childEntityId); if (entity != nullptr) { auto effectColorMul = entity->getEffectColorMul(); - returnValue.setValue(Vector4(effectColorMul.getRed(), effectColorMul.getGreen(), effectColorMul.getBlue(), effectColorMul.getAlpha())); + miniScript->setValue(returnValue, Vector4(effectColorMul.getRed(), effectColorMul.getGreen(), effectColorMul.getBlue(), effectColorMul.getAlpha())); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": entity not found: " + (childEntityId.empty() == true?entityId:childEntityId + "@" + entityId)); } @@ -2688,7 +2688,7 @@ void LogicMiniScript::registerMethods() { ScriptMethod( { { .type = ScriptVariableType::TYPE_STRING, .name = "entityId", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR4, .name = "effectColorMul", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR4, .name = "effectColorMul", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "childEntityId", .optional = true, .reference = false, .nullable = false } }, ScriptVariableType::TYPE_NULL @@ -2733,7 +2733,7 @@ void LogicMiniScript::registerMethods() { { .type = ScriptVariableType::TYPE_STRING, .name = "entityId", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "childEntityId", .optional = true, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_VECTOR4 + TYPE_VECTOR4 ), miniScript(miniScript) {} const string getMethodName() override { @@ -2747,7 +2747,7 @@ void LogicMiniScript::registerMethods() { auto entity = miniScript->getEntity(entityId, childEntityId); if (entity != nullptr) { auto effectColorAdd = entity->getEffectColorAdd(); - returnValue.setValue(Vector4(effectColorAdd.getRed(), effectColorAdd.getGreen(), effectColorAdd.getBlue(), effectColorAdd.getAlpha())); + miniScript->setValue(returnValue, Vector4(effectColorAdd.getRed(), effectColorAdd.getGreen(), effectColorAdd.getBlue(), effectColorAdd.getAlpha())); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": entity not found: " + (childEntityId.empty() == true?entityId:childEntityId + "@" + entityId)); } @@ -2772,7 +2772,7 @@ void LogicMiniScript::registerMethods() { ScriptMethod( { { .type = ScriptVariableType::TYPE_STRING, .name = "entityId", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR4, .name = "effectColorAdd", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR4, .name = "effectColorAdd", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "childEntityId", .optional = true, .reference = false, .nullable = false } }, ScriptVariableType::TYPE_NULL @@ -2830,7 +2830,7 @@ void LogicMiniScript::registerMethods() { miniScript->getStringValue(argumentValues, 1, childEntityId, true) == true) { auto object = dynamic_cast(miniScript->getEntity(entityId, childEntityId)); if (object != nullptr) { - returnValue.setValue(object->getAnimation()); + miniScript->setValue(returnValue, object->getAnimation()); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": object entity not found: " + (childEntityId.empty() == true?entityId:childEntityId + "@" + entityId)); } @@ -2959,7 +2959,7 @@ void LogicMiniScript::registerMethods() { miniScript->getStringValue(argumentValues, 1, childEntityId, true) == true) { auto object = dynamic_cast(miniScript->getEntity(entityId, childEntityId)); if (object != nullptr) { - returnValue.setValue(object->getAnimationTime()); + miniScript->setValue(returnValue, object->getAnimationTime()); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": object entity not found: " + (childEntityId.empty() == true?entityId:childEntityId + "@" + entityId)); } @@ -3211,7 +3211,7 @@ void LogicMiniScript::registerMethods() { miniScript->getStringValue(argumentValues, 2, childEntityId, true) == true) { auto object = dynamic_cast(miniScript->getEntity(entityId, childEntityId)); if (object != nullptr) { - returnValue.setValue(object->getOverlayAnimationTime(animation)); + miniScript->setValue(returnValue, object->getOverlayAnimationTime(animation)); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": object entity not found: " + (childEntityId.empty() == true?entityId:childEntityId + "@" + entityId)); } @@ -3239,7 +3239,7 @@ void LogicMiniScript::registerMethods() { { .type = ScriptVariableType::TYPE_STRING, .name = "nodeId", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "childEntityId", .optional = true, .reference = false, .nullable = false }, }, - ScriptVariableType::TYPE_MATRIX4x4 + TYPE_MATRIX4x4 ), miniScript(miniScript) {} const string getMethodName() override { @@ -3254,7 +3254,7 @@ void LogicMiniScript::registerMethods() { miniScript->getStringValue(argumentValues, 2, childEntityId, true) == true) { auto object = dynamic_cast(miniScript->getEntity(entityId, childEntityId)); if (object != nullptr) { - returnValue.setValue(object->getNodeTransformMatrix(nodeId)); + miniScript->setValue(returnValue, object->getNodeTransformMatrix(nodeId)); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": object entity not found: " + (childEntityId.empty() == true?entityId:childEntityId + "@" + entityId)); } @@ -3282,7 +3282,7 @@ void LogicMiniScript::registerMethods() { { .type = ScriptVariableType::TYPE_STRING, .name = "nodeId", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "childEntityId", .optional = true, .reference = false, .nullable = false }, }, - ScriptVariableType::TYPE_TRANSFORM + TYPE_TRANSFORM ), miniScript(miniScript) {} const string getMethodName() override { @@ -3299,7 +3299,7 @@ void LogicMiniScript::registerMethods() { if (object != nullptr) { Transform transform; transform.fromMatrix(object->getNodeTransformMatrix(nodeId), RotationOrder::ZYX); - returnValue.setValue(transform); + miniScript->setValue(returnValue, transform); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": object entity not found: " + (childEntityId.empty() == true?entityId:childEntityId + "@" + entityId)); } @@ -3325,7 +3325,7 @@ void LogicMiniScript::registerMethods() { { { .type = ScriptVariableType::TYPE_STRING, .name = "entityId", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "nodeId", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_MATRIX4x4, .name = "matrix", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_MATRIX4x4, .name = "matrix", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "childEntityId", .optional = true, .reference = false, .nullable = false }, }, ScriptVariableType::TYPE_NULL @@ -3371,7 +3371,7 @@ void LogicMiniScript::registerMethods() { { { .type = ScriptVariableType::TYPE_STRING, .name = "entityId", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "nodeId", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "childEntityId", .optional = true, .reference = false, .nullable = false }, }, ScriptVariableType::TYPE_NULL @@ -4407,7 +4407,7 @@ void LogicMiniScript::registerMethods() { { { .type = ScriptVariableType::TYPE_STRING, .name = "bodyId", .optional = false, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_VECTOR3 + TYPE_VECTOR3 ), miniScript(miniScript) {} const string getMethodName() override { @@ -4418,7 +4418,7 @@ void LogicMiniScript::registerMethods() { if (miniScript->getStringValue(argumentValues, 0, bodyId) == true) { auto body = miniScript->context->getWorld()->getBody(bodyId); if (body != nullptr) { - returnValue = body->getLinearVelocity(); + miniScript->setValue(returnValue, body->getLinearVelocity()); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": body not found: " + bodyId); } @@ -4443,7 +4443,7 @@ void LogicMiniScript::registerMethods() { ScriptMethod( { { .type = ScriptVariableType::TYPE_STRING, .name = "bodyId", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "linearVelocity", .optional = false, .reference = false, .nullable = false } + { .type = TYPE_VECTOR3, .name = "linearVelocity", .optional = false, .reference = false, .nullable = false } }, ScriptVariableType::TYPE_NULL ), @@ -4484,7 +4484,7 @@ void LogicMiniScript::registerMethods() { { { .type = ScriptVariableType::TYPE_STRING, .name = "bodyId", .optional = false, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_VECTOR3 + TYPE_VECTOR3 ), miniScript(miniScript) {} const string getMethodName() override { @@ -4495,7 +4495,7 @@ void LogicMiniScript::registerMethods() { if (miniScript->getStringValue(argumentValues, 0, bodyId) == true) { auto body = miniScript->context->getWorld()->getBody(bodyId); if (body != nullptr) { - returnValue = body->getAngularVelocity(); + miniScript->setValue(returnValue, body->getAngularVelocity()); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": body not found: " + bodyId); } @@ -4520,7 +4520,7 @@ void LogicMiniScript::registerMethods() { ScriptMethod( { { .type = ScriptVariableType::TYPE_STRING, .name = "bodyId", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "angularVelocity", .optional = false, .reference = false, .nullable = false } + { .type = TYPE_VECTOR3, .name = "angularVelocity", .optional = false, .reference = false, .nullable = false } }, ScriptVariableType::TYPE_NULL ), @@ -4560,8 +4560,8 @@ void LogicMiniScript::registerMethods() { ScriptMethod( { { .type = ScriptVariableType::TYPE_STRING, .name = "bodyId", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "force", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "origin", .optional = true, .reference = false, .nullable = false } + { .type = TYPE_VECTOR3, .name = "force", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "origin", .optional = true, .reference = false, .nullable = false } }, ScriptVariableType::TYPE_NULL ), @@ -4611,7 +4611,7 @@ void LogicMiniScript::registerMethods() { ScriptMethod( { { .type = ScriptVariableType::TYPE_STRING, .name = "bodyId", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "torque", .optional = false, .reference = false, .nullable = false } + { .type = TYPE_VECTOR3, .name = "torque", .optional = false, .reference = false, .nullable = false } }, ScriptVariableType::TYPE_NULL ), @@ -4652,7 +4652,7 @@ void LogicMiniScript::registerMethods() { { { .type = ScriptVariableType::TYPE_STRING, .name = "bodyId", .optional = false, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_TRANSFORM + TYPE_TRANSFORM ), miniScript(miniScript) {} const string getMethodName() override { @@ -4675,7 +4675,7 @@ void LogicMiniScript::registerMethods() { transform.setRotationAngle(1, euler.getY()); transform.setRotationAngle(2, euler.getX()); transform.update(); - returnValue = transform; + miniScript->setValue(returnValue, transform); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": body not found: " + bodyId); } @@ -4700,7 +4700,7 @@ void LogicMiniScript::registerMethods() { ScriptMethod( { { .type = ScriptVariableType::TYPE_STRING, .name = "bodyId", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false } + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false } }, ScriptVariableType::TYPE_NULL ), @@ -4741,8 +4741,8 @@ void LogicMiniScript::registerMethods() { { { .type = ScriptVariableType::TYPE_INTEGER, .name = "collisionTypeIds", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_FLOAT, .name = "stepUpMax", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "point", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "heightPoint", .optional = false, .reference = true, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "point", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "heightPoint", .optional = false, .reference = true, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "bodyId", .optional = true, .reference = true, .nullable = false }, { .type = ScriptVariableType::TYPE_FLOAT, .name = "minHeight", .optional = true, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_FLOAT, .name = "maxHeight", .optional = true, .reference = false, .nullable = false } @@ -4768,7 +4768,7 @@ void LogicMiniScript::registerMethods() { miniScript->getFloatValue(argumentValues, 6, maxHeight, true) == true) { auto body = miniScript->context->getWorld()->determineHeight(collisionTypeIds, stepUpMax, point, heightPoint, minHeight, maxHeight); if (body != nullptr) { - argumentValues[3].setValue(heightPoint); + miniScript->setValue(argumentValues[3], heightPoint); if (argumentValues.size() >= 5) argumentValues[4].setValue(body->getId()); returnValue = true; } else { @@ -4795,9 +4795,9 @@ void LogicMiniScript::registerMethods() { ScriptMethod( { { .type = ScriptVariableType::TYPE_INTEGER, .name = "collisionTypeIds", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "start", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "end", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "hitPoint", .optional = false, .reference = true, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "start", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "end", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "hitPoint", .optional = false, .reference = true, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "bodyId", .optional = true, .reference = true, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "actorId", .optional = true, .reference = false, .nullable = false }, }, @@ -4819,11 +4819,11 @@ void LogicMiniScript::registerMethods() { miniScript->getStringValue(argumentValues, 5, actorId, true) == true) { auto body = miniScript->context->getWorld()->doRayCasting(collisionTypeIds, start, end, hitPoint, actorId); if (body != nullptr) { - argumentValues[3].setValue(hitPoint); + miniScript->setValue(argumentValues[3], hitPoint); if (argumentValues.size() >= 5) argumentValues[4].setValue(body->getId()); - returnValue.setValue(true); + miniScript->setValue(returnValue, true); } else { - returnValue.setValue(false); + miniScript->setValue(returnValue, false); } } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); @@ -4909,7 +4909,7 @@ void LogicMiniScript::registerMethods() { } else { vector collisionBodies; miniScript->context->getWorld()->doesCollideWith(collisionTypeIds, body, collisionBodies); - returnValue.setType(MiniScript::TYPE_ARRAY); + returnValue.setType(EngineMiniScript::TYPE_ARRAY); for (auto collisionBody: collisionBodies) { returnValue.pushArrayEntry(collisionBody->getId()); } @@ -5062,8 +5062,8 @@ void LogicMiniScript::registerMethods() { ScriptMethod( { { .type = ScriptVariableType::TYPE_STRING, .name = "logicId", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "startPosition", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "endPosition", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "startPosition", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "endPosition", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_ARRAY, .name = "path", .optional = false, .reference = true, .nullable = false }, }, ScriptVariableType::TYPE_INTEGER @@ -5080,12 +5080,14 @@ void LogicMiniScript::registerMethods() { miniScript->getStringValue(argumentValues, 0, logicId) == true && miniScript->getVector3Value(argumentValues, 1, startPosition) == true && miniScript->getVector3Value(argumentValues, 2, endPosition) == true) { - argumentValues[3].setType(MiniScript::TYPE_ARRAY); + argumentValues[3].setType(EngineMiniScript::TYPE_ARRAY); vector path; auto pathFindingState = miniScript->context->getPathFinding()->findPath(logicId, logicId, startPosition, endPosition, path); returnValue = static_cast(pathFindingState); for (const auto& position: path) { - argumentValues[3].pushArrayEntry(position); + MiniScript::ScriptVariable positionVariable; + miniScript->setValue(positionVariable, position); + argumentValues[3].pushArrayEntry(positionVariable); }; } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); @@ -5112,7 +5114,7 @@ void LogicMiniScript::registerMethods() { return "scene.getWidth"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue = miniScript->context->getScene()->getBoundingBox()->getDimensions().getX(); + miniScript->setValue(returnValue, miniScript->context->getScene()->getBoundingBox()->getDimensions().getX()); } const vector& getContextFunctions() { return CONTEXTFUNCTIONS_ALL; @@ -5175,7 +5177,7 @@ void LogicMiniScript::registerMethods() { { .type = ScriptVariableType::TYPE_STRING, .name = "pathName", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "fileName", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "id", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "hierarchyId", .optional = true, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "hierarchyParentId", .optional = true, .reference = false, .nullable = false }, }, @@ -5265,7 +5267,7 @@ void LogicMiniScript::registerMethods() { { .type = ScriptVariableType::TYPE_STRING, .name = "fileName", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "id", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "attachNodeId", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, { .type = ScriptVariableType::TYPE_STRING, .name = "parentId", .optional = true, .reference = false, .nullable = false }, }, ScriptVariableType::TYPE_NULL diff --git a/src/tdme/engine/logics/LogicMiniScript.h b/src/tdme/engine/logics/LogicMiniScript.h index 1a9bf755b..5070a6932 100644 --- a/src/tdme/engine/logics/LogicMiniScript.h +++ b/src/tdme/engine/logics/LogicMiniScript.h @@ -14,7 +14,7 @@ #include #include #include -#include +#include using std::array; using std::string; @@ -31,12 +31,12 @@ using tdme::engine::Transform; using tdme::gui::events::GUIKeyboardEvent; using tdme::gui::events::GUIMouseEvent; using tdme::os::threading::Mutex; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; /** * Logic mini script */ -class tdme::engine::logics::LogicMiniScript: public MiniScript { +class tdme::engine::logics::LogicMiniScript: public EngineMiniScript { friend class MiniScriptLogic; protected: diff --git a/src/tdme/engine/logics/MiniScriptLogic.h b/src/tdme/engine/logics/MiniScriptLogic.h index d2ce5a9fa..4d1cd92b6 100644 --- a/src/tdme/engine/logics/MiniScriptLogic.h +++ b/src/tdme/engine/logics/MiniScriptLogic.h @@ -18,7 +18,7 @@ #include #include #include -#include +#include using std::make_unique; using std::span; @@ -38,7 +38,7 @@ using tdme::engine::EntityHierarchy; using tdme::engine::SceneConnector; using tdme::tools::editor::misc::Tools; using tdme::utilities::Console; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; /** * Mini script logic @@ -104,7 +104,7 @@ class tdme::engine::logics::MiniScriptLogic: public Logic { } inline void updateEngine() override { - // add engine entities requested by MiniScript + // add engine entities requested by EngineMiniScript if (miniScript->enginePrototypesToAdd.empty() == false) { miniScript->prototypesToAddMutex.lock(); for (const auto& prototypeToAdd: miniScript->enginePrototypesToAdd) { @@ -177,8 +177,8 @@ class tdme::engine::logics::MiniScriptLogic: public Logic { SceneConnector::addSounds(context->getAudio(), prototypeIt->second, id); } // execute initializeEngine() function - vector argumentValues(0); - MiniScript::ScriptVariable returnValue; + vector argumentValues(0); + EngineMiniScript::ScriptVariable returnValue; span argumentValuesSpan(argumentValues); if (miniScript->call("initializeEngine", argumentValuesSpan, returnValue) == false) { // Console::println("MiniScriptLogic::updateEngine(): Failed to call initializeEngine() function"); @@ -187,8 +187,8 @@ class tdme::engine::logics::MiniScriptLogic: public Logic { engineInitialized = true; } // execute updateEngine() function - vector argumentValues(0); - MiniScript::ScriptVariable returnValue; + vector argumentValues(0); + EngineMiniScript::ScriptVariable returnValue; span argumentValuesSpan(argumentValues); if (miniScript->call("updateEngine", argumentValuesSpan, returnValue) == false) { // Console::println("MiniScriptLogic::updateEngine(): Failed to call updateEngine() function"); @@ -196,7 +196,7 @@ class tdme::engine::logics::MiniScriptLogic: public Logic { } inline void updateLogic() override { - // add physics entities requested by MiniScript and scripts + // add physics entities requested by EngineMiniScript and scripts if (miniScript->physicsPrototypesToAdd.empty() == false) { miniScript->prototypesToAddMutex.lock(); // @@ -288,8 +288,8 @@ class tdme::engine::logics::MiniScriptLogic: public Logic { // if (logicInitialized == false) { // execute initializeLogic() function - vector argumentValues(0); - MiniScript::ScriptVariable returnValue; + vector argumentValues(0); + EngineMiniScript::ScriptVariable returnValue; span argumentValuesSpan(argumentValues); if (miniScript->call("initializeLogic", argumentValuesSpan, returnValue) == false) { // Console::println("MiniScriptLogic::updateLogic(): Failed to call initializeLogic() function"); @@ -300,8 +300,8 @@ class tdme::engine::logics::MiniScriptLogic: public Logic { // execute on: nothing and other event polling and execution miniScript->execute(); // execute updateLogic() function - vector argumentValues(0); - MiniScript::ScriptVariable returnValue; + vector argumentValues(0); + EngineMiniScript::ScriptVariable returnValue; span argumentValuesSpan(argumentValues); if (miniScript->call("updateLogic", argumentValuesSpan, returnValue) == false) { // Console::println("MiniScriptLogic::updateLogic(): Failed to call updateLogic() function"); @@ -310,8 +310,8 @@ class tdme::engine::logics::MiniScriptLogic: public Logic { inline void onLogicAdded() override { // execute onLogicAdded() function - vector argumentValues(0); - MiniScript::ScriptVariable returnValue; + vector argumentValues(0); + EngineMiniScript::ScriptVariable returnValue; span argumentValuesSpan(argumentValues); if (miniScript->call("onLogicAdded", argumentValuesSpan, returnValue) == false) { // Console::println("MiniScriptLogic::onLogicAdded(): Failed to call onLogicAdded() function"); @@ -320,8 +320,8 @@ class tdme::engine::logics::MiniScriptLogic: public Logic { inline void onLogicsProcessed() override { // execute onLogicsProcessed() function - vector argumentValues(0); - MiniScript::ScriptVariable returnValue; + vector argumentValues(0); + EngineMiniScript::ScriptVariable returnValue; span argumentValuesSpan(argumentValues); if (miniScript->call("onLogicsProcessed", argumentValuesSpan, returnValue) == false) { // Console::println("MiniScriptLogic::onLogicsProcessed(): Failed to call onLogicsProcessed() function"); diff --git a/src/tdme/engine/primitives/Capsule.h b/src/tdme/engine/primitives/Capsule.h index f9b9a9b04..fcb656e45 100644 --- a/src/tdme/engine/primitives/Capsule.h +++ b/src/tdme/engine/primitives/Capsule.h @@ -18,7 +18,7 @@ class tdme::engine::primitives::Capsule final : public BoundingVolume { private: - // overriden methods + // overridden methods void destroyCollisionShape() override; void createCollisionShape(World* world) override; diff --git a/src/tdme/engine/primitives/ConvexMesh.h b/src/tdme/engine/primitives/ConvexMesh.h index 50a759dc7..ef620fe4c 100644 --- a/src/tdme/engine/primitives/ConvexMesh.h +++ b/src/tdme/engine/primitives/ConvexMesh.h @@ -107,7 +107,7 @@ class tdme::engine::primitives::ConvexMesh final */ void createConvexMesh(const vector& vertices, const vector& facesVerticesCount, const vector& indices, const Vector3& scale); - // overriden methods + // overridden methods void destroyCollisionShape() override; void createCollisionShape(World* world) override; diff --git a/src/tdme/engine/primitives/HeightMap.h b/src/tdme/engine/primitives/HeightMap.h index 3a8daac63..03d4bc8e0 100644 --- a/src/tdme/engine/primitives/HeightMap.h +++ b/src/tdme/engine/primitives/HeightMap.h @@ -24,7 +24,7 @@ class tdme::engine::primitives::HeightMap final float maxHeight; float* heightValues; - // overriden methods + // overridden methods void destroyCollisionShape() override; void createCollisionShape(World* world) override; diff --git a/src/tdme/engine/primitives/OrientedBoundingBox.h b/src/tdme/engine/primitives/OrientedBoundingBox.h index 94ee065a9..dfe505998 100644 --- a/src/tdme/engine/primitives/OrientedBoundingBox.h +++ b/src/tdme/engine/primitives/OrientedBoundingBox.h @@ -37,7 +37,7 @@ class tdme::engine::primitives::OrientedBoundingBox final STATIC_DLL_IMPEXT static const array FACE11_INDICES; STATIC_DLL_IMPEXT static const array,12> facesVerticesIndexes; - // overriden methods + // overridden methods void destroyCollisionShape() override; void createCollisionShape(World* world) override; diff --git a/src/tdme/engine/primitives/Sphere.h b/src/tdme/engine/primitives/Sphere.h index 4b22869fa..e036ac806 100644 --- a/src/tdme/engine/primitives/Sphere.h +++ b/src/tdme/engine/primitives/Sphere.h @@ -20,7 +20,7 @@ class tdme::engine::primitives::Sphere final private: float radius; - // overriden methods + // overridden methods void destroyCollisionShape() override; void createCollisionShape(World* world) override; diff --git a/src/tdme/engine/primitives/TerrainMesh.h b/src/tdme/engine/primitives/TerrainMesh.h index 27f66a7ea..87c6d4eb7 100644 --- a/src/tdme/engine/primitives/TerrainMesh.h +++ b/src/tdme/engine/primitives/TerrainMesh.h @@ -35,7 +35,7 @@ class tdme::engine::primitives::TerrainMesh final unique_ptr triangleVertexArray; reactphysics3d::TriangleMesh* triangleMesh { nullptr }; - // overriden methods + // overridden methods void destroyCollisionShape() override; void createCollisionShape(World* world) override; diff --git a/src/tdme/gui/GUIParser.h b/src/tdme/gui/GUIParser.h index 0e6199009..8a0bd279f 100644 --- a/src/tdme/gui/GUIParser.h +++ b/src/tdme/gui/GUIParser.h @@ -11,7 +11,7 @@ #include #include #include -#include +#include #include #include @@ -27,7 +27,7 @@ using tdme::gui::nodes::GUIParentNode; using tdme::gui::nodes::GUIScreenNode; using tdme::gui::GUIParserException; using tdme::os::filesystem::FileSystemException; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tdme::utilities::Properties; using tinyxml::TiXmlElement; @@ -89,7 +89,7 @@ class tdme::gui::GUIParser final * @throws tdme::gui::GUIParserException * @throws tdme::os::filesystem::FileSystemException */ - static GUIScreenNode* parse(const string& pathName, const string& fileName, const unordered_map& variables = {}, const MiniScript::ScriptVariable& miniScriptArguments = MiniScript::ScriptVariable(), Context* context = nullptr); + static GUIScreenNode* parse(const string& pathName, const string& fileName, const unordered_map& variables = {}, const EngineMiniScript::ScriptVariable& miniScriptArguments = EngineMiniScript::ScriptVariable(), Context* context = nullptr); /** * Parses a GUI XML content @@ -103,7 +103,7 @@ class tdme::gui::GUIParser final * @throws tdme::gui::GUIParserException * @throws tdme::os::filesystem::FileSystemException */ - static GUIScreenNode* parse(const string& xml, const unordered_map& variables = {}, const string& pathName = string(), const string& fileName = string(), const MiniScript::ScriptVariable& miniScriptArguments = MiniScript::ScriptVariable(), Context* context = nullptr); + static GUIScreenNode* parse(const string& xml, const unordered_map& variables = {}, const string& pathName = string(), const string& fileName = string(), const EngineMiniScript::ScriptVariable& miniScriptArguments = EngineMiniScript::ScriptVariable(), Context* context = nullptr); /** * Parses a GUI XML file into parent node diff --git a/src/tdme/gui/nodes/GUIElementNode.h b/src/tdme/gui/nodes/GUIElementNode.h index 79f930301..7c8b60b9e 100644 --- a/src/tdme/gui/nodes/GUIElementNode.h +++ b/src/tdme/gui/nodes/GUIElementNode.h @@ -136,7 +136,7 @@ class tdme::gui::nodes::GUIElementNode final: public GUILayerNode const string& options ); - // overriden methods + // overridden methods const string getNodeType() override; bool isContentNode() override; diff --git a/src/tdme/gui/nodes/GUIScreenNode.cpp b/src/tdme/gui/nodes/GUIScreenNode.cpp index b4ad1bf48..b97697f14 100644 --- a/src/tdme/gui/nodes/GUIScreenNode.cpp +++ b/src/tdme/gui/nodes/GUIScreenNode.cpp @@ -41,7 +41,7 @@ #include #include #include -#include +#include #include #include @@ -89,7 +89,7 @@ using tdme::os::filesystem::FileSystem; using tdme::os::filesystem::FileSystemException; using tdme::os::filesystem::FileSystemInterface; using tdme::utilities::Integer; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tdme::utilities::MutableString; using tdme::utilities::Properties; @@ -117,7 +117,7 @@ GUIScreenNode::GUIScreenNode( bool scrollable, bool popUp, const string& scriptFileName, - const MiniScript::ScriptVariable& miniScriptArguments, + const EngineMiniScript::ScriptVariable& miniScriptArguments, Context* context ): GUIParentNode(this, nullptr, id, flow, overflowX, overflowY, alignments, requestedConstraints, backgroundColor, backgroundImage, backgroundImageScale9Grid, backgroundImageEffectColorMul, backgroundImageEffectColorAdd, border, padding, showOn, hideOn, tooltip) @@ -216,9 +216,9 @@ GUIScreenNode::~GUIScreenNode() { void GUIScreenNode::initializeMiniScript() { // if (script != nullptr && script->hasFunction("initialize") == true) { - vector argumentValues { miniScriptArguments }; + vector argumentValues { miniScriptArguments }; span argumentValuesSpan(argumentValues); - MiniScript::ScriptVariable returnValue; + EngineMiniScript::ScriptVariable returnValue; script->call("initialize", argumentValuesSpan, returnValue); } } @@ -786,9 +786,9 @@ void GUIScreenNode::tick() { } // if (scriptOnTickAvailable == true) { - vector argumentValues(0); + vector argumentValues(0); span argumentValuesSpan(argumentValues); - MiniScript::ScriptVariable returnValue; + EngineMiniScript::ScriptVariable returnValue; script->call("onTick", argumentValuesSpan, returnValue); } } @@ -915,12 +915,12 @@ void GUIScreenNode::forwardEvents() { } // if (scriptOnActionAvailable == true) { - vector argumentValues { + vector argumentValues { static_cast(event.type), event.nodeId }; span argumentValuesSpan(argumentValues); - MiniScript::ScriptVariable returnValue; + EngineMiniScript::ScriptVariable returnValue; script->call("onAction", argumentValuesSpan, returnValue); } // @@ -935,11 +935,11 @@ void GUIScreenNode::forwardEvents() { } // if (scriptOnChangeAvailable == true) { - vector argumentValues { + vector argumentValues { event.nodeId }; span argumentValuesSpan(argumentValues); - MiniScript::ScriptVariable returnValue; + EngineMiniScript::ScriptVariable returnValue; script->call("onChange", argumentValuesSpan, returnValue); } // @@ -954,11 +954,11 @@ void GUIScreenNode::forwardEvents() { } // if (scriptOnMouseOverAvailable == true) { - vector argumentValues { + vector argumentValues { event.nodeId }; span argumentValuesSpan(argumentValues); - MiniScript::ScriptVariable returnValue; + EngineMiniScript::ScriptVariable returnValue; script->call("onMouseOver", argumentValuesSpan, returnValue); } // @@ -973,13 +973,13 @@ void GUIScreenNode::forwardEvents() { } // if (scriptOnContextMenuRequestAvailable == true) { - vector argumentValues { + vector argumentValues { event.nodeId, static_cast(event.mouseX), static_cast(event.mouseY) }; span argumentValuesSpan(argumentValues); - MiniScript::ScriptVariable returnValue; + EngineMiniScript::ScriptVariable returnValue; script->call("onContextMenuRequest", argumentValuesSpan, returnValue); } // @@ -994,11 +994,11 @@ void GUIScreenNode::forwardEvents() { } // if (scriptOnFocusAvailable == true) { - vector argumentValues { + vector argumentValues { event.nodeId }; span argumentValuesSpan(argumentValues); - MiniScript::ScriptVariable returnValue; + EngineMiniScript::ScriptVariable returnValue; script->call("onFocus", argumentValuesSpan, returnValue); } // @@ -1013,11 +1013,11 @@ void GUIScreenNode::forwardEvents() { } // if (scriptOnUnfocusAvailable == true) { - vector argumentValues { + vector argumentValues { event.nodeId }; span argumentValuesSpan(argumentValues); - MiniScript::ScriptVariable returnValue; + EngineMiniScript::ScriptVariable returnValue; script->call("onUnfocus", argumentValuesSpan, returnValue); } // @@ -1032,11 +1032,11 @@ void GUIScreenNode::forwardEvents() { } // if (scriptOnMoveAvailable == true) { - vector argumentValues { + vector argumentValues { event.nodeId }; span argumentValuesSpan(argumentValues); - MiniScript::ScriptVariable returnValue; + EngineMiniScript::ScriptVariable returnValue; script->call("onMove", argumentValuesSpan, returnValue); } // @@ -1051,13 +1051,13 @@ void GUIScreenNode::forwardEvents() { } // if (scriptOnMoveReleaseAvailable == true) { - vector argumentValues { + vector argumentValues { event.nodeId, static_cast(event.mouseX), static_cast(event.mouseY) }; span argumentValuesSpan(argumentValues); - MiniScript::ScriptVariable returnValue; + EngineMiniScript::ScriptVariable returnValue; script->call("onMoveRelease", argumentValuesSpan, returnValue); } // @@ -1072,13 +1072,13 @@ void GUIScreenNode::forwardEvents() { } // if (scriptOnTooltipShowRequestAvailable == true) { - vector argumentValues { + vector argumentValues { event.nodeId, static_cast(event.mouseX), static_cast(event.mouseY) }; span argumentValuesSpan(argumentValues); - MiniScript::ScriptVariable returnValue; + EngineMiniScript::ScriptVariable returnValue; script->call("onTooltipShowRequest", argumentValuesSpan, returnValue); } // @@ -1091,9 +1091,9 @@ void GUIScreenNode::forwardEvents() { } // if (scriptOnTooltipCloseRequestAvailable == true) { - vector argumentValues(0); + vector argumentValues(0); span argumentValuesSpan(argumentValues); - MiniScript::ScriptVariable returnValue; + EngineMiniScript::ScriptVariable returnValue; script->call("onTooltipCloseRequest", argumentValuesSpan, returnValue); } // @@ -1109,13 +1109,13 @@ void GUIScreenNode::forwardEvents() { } // if (scriptOnDragRequestAvailable == true) { - vector argumentValues { + vector argumentValues { event.nodeId, static_cast(event.mouseX), static_cast(event.mouseY) }; span argumentValuesSpan(argumentValues); - MiniScript::ScriptVariable returnValue; + EngineMiniScript::ScriptVariable returnValue; script->call("onDragRequest", argumentValuesSpan, returnValue); } // diff --git a/src/tdme/gui/nodes/GUIScreenNode.h b/src/tdme/gui/nodes/GUIScreenNode.h index 309e04c83..b58471d68 100644 --- a/src/tdme/gui/nodes/GUIScreenNode.h +++ b/src/tdme/gui/nodes/GUIScreenNode.h @@ -18,7 +18,7 @@ #include #include #include -#include +#include #include using std::string; @@ -60,7 +60,7 @@ using tdme::gui::renderer::GUIFont; using tdme::gui::renderer::GUIRenderer; using tdme::gui::scripting::GUIMiniScript; using tdme::gui::GUI; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tdme::utilities::MutableString; /** @@ -179,7 +179,7 @@ class tdme::gui::nodes::GUIScreenNode final bool scriptOnDragRequestAvailable { false }; bool scriptOnTickAvailable { false }; - MiniScript::ScriptVariable miniScriptArguments; + EngineMiniScript::ScriptVariable miniScriptArguments; Context* context { nullptr }; @@ -356,7 +356,7 @@ class tdme::gui::nodes::GUIScreenNode final * @param tooltip tooltip * @param scrollable scrollable * @param popUp pop up - * @param scriptFileName MiniScript script file name + * @param scriptFileName EngineMiniScript script file name * @param miniScriptArguments mini script arguments * @param context application logic context * @throws tdme::gui::GUIParserException @@ -385,7 +385,7 @@ class tdme::gui::nodes::GUIScreenNode final bool scrollable, bool popUp, const string& scriptFileName, - const MiniScript::ScriptVariable& miniScriptArguments, + const EngineMiniScript::ScriptVariable& miniScriptArguments, Context* context ); diff --git a/src/tdme/gui/scripting/GUIMiniScript.cpp b/src/tdme/gui/scripting/GUIMiniScript.cpp index d73d5d467..4fdcf8b8f 100644 --- a/src/tdme/gui/scripting/GUIMiniScript.cpp +++ b/src/tdme/gui/scripting/GUIMiniScript.cpp @@ -25,7 +25,7 @@ #include #include #include -#include +#include #include using std::make_unique; @@ -56,10 +56,10 @@ using tdme::os::threading::Mutex; using tdme::gui::scripting::GUIMiniScript; using tdme::utilities::Character; using tdme::utilities::Console; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tdme::utilities::MutableString; -GUIMiniScript::GUIMiniScript(GUIScreenNode* screenNode): MiniScript(), screenNode(screenNode) { +GUIMiniScript::GUIMiniScript(GUIScreenNode* screenNode): EngineMiniScript(), screenNode(screenNode) { } GUIMiniScript::~GUIMiniScript() { @@ -70,17 +70,17 @@ const string GUIMiniScript::getBaseClass() { } const vector GUIMiniScript::getTranspilationUnits() { - auto transpilationUnits = MiniScript::getTranspilationUnits(); + auto transpilationUnits = EngineMiniScript::getTranspilationUnits(); transpilationUnits.push_back("src/tdme/gui/scripting/GUIMiniScript.cpp"); return transpilationUnits; } void GUIMiniScript::registerStateMachineStates() { - MiniScript::registerStateMachineStates(); + EngineMiniScript::registerStateMachineStates(); } void GUIMiniScript::registerMethods() { - MiniScript::registerMethods(); + EngineMiniScript::registerMethods(); // input { // @@ -1204,7 +1204,7 @@ void GUIMiniScript::registerMethods() { void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string fileName; if (argumentValues.size() > 3 || - MiniScript::getStringValue(argumentValues, 0, fileName, false) == false) { + EngineMiniScript::getStringValue(argumentValues, 0, fileName, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -1231,7 +1231,7 @@ void GUIMiniScript::registerMethods() { screenPathName, screenFileName, variables, - argumentValues.size() == 3?argumentValues[2]:MiniScript::ScriptVariable(), + argumentValues.size() == 3?argumentValues[2]:EngineMiniScript::ScriptVariable(), miniScript->screenNode->getContext() ) ); @@ -1269,7 +1269,7 @@ void GUIMiniScript::registerMethods() { void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string fileName; if (argumentValues.size() > 3 || - MiniScript::getStringValue(argumentValues, 0, fileName, false) == false) { + EngineMiniScript::getStringValue(argumentValues, 0, fileName, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -1293,7 +1293,7 @@ void GUIMiniScript::registerMethods() { screenPathName, screenFileName, variables, - argumentValues.size() == 3?argumentValues[2]:MiniScript::ScriptVariable(), + argumentValues.size() == 3?argumentValues[2]:EngineMiniScript::ScriptVariable(), miniScript->screenNode->getContext() ); miniScript->screenNode->getGUI()->addScreen(screenNode->getId(), screenNode); @@ -1482,7 +1482,7 @@ void GUIMiniScript::registerMethods() { } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string nodeId; - if (MiniScript::getStringValue(argumentValues, 0, nodeId, false) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, nodeId, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -1523,8 +1523,8 @@ void GUIMiniScript::registerMethods() { void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string nodeId; string value; - if (MiniScript::getStringValue(argumentValues, 0, nodeId, false) == false || - MiniScript::getStringValue(argumentValues, 1, value, false) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, nodeId, false) == false || + EngineMiniScript::getStringValue(argumentValues, 1, value, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -1563,7 +1563,7 @@ void GUIMiniScript::registerMethods() { } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string textNodeId; - if (MiniScript::getStringValue(argumentValues, 0, textNodeId, false) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, textNodeId, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -1607,8 +1607,8 @@ void GUIMiniScript::registerMethods() { void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string textNodeId; string text; - if (MiniScript::getStringValue(argumentValues, 0, textNodeId, false) == false || - MiniScript::getStringValue(argumentValues, 1, text, false) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, textNodeId, false) == false || + EngineMiniScript::getStringValue(argumentValues, 1, text, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -1652,8 +1652,8 @@ void GUIMiniScript::registerMethods() { void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string elementNodeId; string condition; - if (MiniScript::getStringValue(argumentValues, 0, elementNodeId, false) == false || - MiniScript::getStringValue(argumentValues, 1, condition, false) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, elementNodeId, false) == false || + EngineMiniScript::getStringValue(argumentValues, 1, condition, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -1691,7 +1691,7 @@ void GUIMiniScript::registerMethods() { } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string elementNodeId; - if (MiniScript::getStringValue(argumentValues, 0, elementNodeId, false) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, elementNodeId, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -1735,8 +1735,8 @@ void GUIMiniScript::registerMethods() { void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string elementNodeId; string condition; - if (MiniScript::getStringValue(argumentValues, 0, elementNodeId, false) == false || - MiniScript::getStringValue(argumentValues, 1, condition, false) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, elementNodeId, false) == false || + EngineMiniScript::getStringValue(argumentValues, 1, condition, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -1776,8 +1776,8 @@ void GUIMiniScript::registerMethods() { void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string elementNodeId; string condition; - if (MiniScript::getStringValue(argumentValues, 0, elementNodeId, false) == false || - MiniScript::getStringValue(argumentValues, 1, condition, false) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, elementNodeId, false) == false || + EngineMiniScript::getStringValue(argumentValues, 1, condition, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -1816,7 +1816,7 @@ void GUIMiniScript::registerMethods() { } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string elementNodeId; - if (MiniScript::getStringValue(argumentValues, 0, elementNodeId, false) == false || + if (EngineMiniScript::getStringValue(argumentValues, 0, elementNodeId, false) == false || argumentValues.size() <= 1 || argumentValues[1].getType() != ScriptVariableType::TYPE_ARRAY) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); @@ -1866,8 +1866,8 @@ void GUIMiniScript::registerMethods() { void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string elementNodeId; string condition; - if (MiniScript::getStringValue(argumentValues, 0, elementNodeId, false) == false || - MiniScript::getStringValue(argumentValues, 1, condition, false) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, elementNodeId, false) == false || + EngineMiniScript::getStringValue(argumentValues, 1, condition, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -1905,7 +1905,7 @@ void GUIMiniScript::registerMethods() { } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string elementNodeId; - if (MiniScript::getStringValue(argumentValues, 0, elementNodeId, false) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, elementNodeId, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -1943,7 +1943,7 @@ void GUIMiniScript::registerMethods() { } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string imageNodeId; - if (MiniScript::getStringValue(argumentValues, 0, imageNodeId, false) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, imageNodeId, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -1983,8 +1983,8 @@ void GUIMiniScript::registerMethods() { void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string imageNodeId; string source; - if (MiniScript::getStringValue(argumentValues, 0, imageNodeId, false) == false || - MiniScript::getStringValue(argumentValues, 1, source, false) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, imageNodeId, false) == false || + EngineMiniScript::getStringValue(argumentValues, 1, source, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -2022,7 +2022,7 @@ void GUIMiniScript::registerMethods() { } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string videoNodeId; - if (MiniScript::getStringValue(argumentValues, 0, videoNodeId, false) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, videoNodeId, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -2062,8 +2062,8 @@ void GUIMiniScript::registerMethods() { void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string videoNodeId; string source; - if (MiniScript::getStringValue(argumentValues, 0, videoNodeId, false) == false || - MiniScript::getStringValue(argumentValues, 1, source, false) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, videoNodeId, false) == false || + EngineMiniScript::getStringValue(argumentValues, 1, source, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -2101,7 +2101,7 @@ void GUIMiniScript::registerMethods() { } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { string parentNodeId; - if (MiniScript::getStringValue(argumentValues, 0, parentNodeId, false) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, parentNodeId, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -2143,9 +2143,9 @@ void GUIMiniScript::registerMethods() { string parentNodeId; string xml; bool resetScrollOffsets = true; - if (MiniScript::getStringValue(argumentValues, 0, parentNodeId, false) == false || - MiniScript::getStringValue(argumentValues, 1, xml, false) == false || - MiniScript::getBooleanValue(argumentValues, 2, resetScrollOffsets, true) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, parentNodeId, false) == false || + EngineMiniScript::getStringValue(argumentValues, 1, xml, false) == false || + EngineMiniScript::getBooleanValue(argumentValues, 2, resetScrollOffsets, true) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -2187,9 +2187,9 @@ void GUIMiniScript::registerMethods() { string parentNodeId; string xml; bool resetScrollOffsets = true; - if (MiniScript::getStringValue(argumentValues, 0, parentNodeId, false) == false || - MiniScript::getStringValue(argumentValues, 1, xml, false) == false || - MiniScript::getBooleanValue(argumentValues, 2, resetScrollOffsets, true) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, parentNodeId, false) == false || + EngineMiniScript::getStringValue(argumentValues, 1, xml, false) == false || + EngineMiniScript::getBooleanValue(argumentValues, 2, resetScrollOffsets, true) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -2228,8 +2228,8 @@ void GUIMiniScript::registerMethods() { if (context != nullptr) { string logicId; string signal; - if (MiniScript::getStringValue(argumentValues, 0, logicId) == true && - MiniScript::getStringValue(argumentValues, 1, signal) == true) { + if (EngineMiniScript::getStringValue(argumentValues, 0, logicId) == true && + EngineMiniScript::getStringValue(argumentValues, 1, signal) == true) { context->getLogicsMutex()->lock(); auto logic = static_cast(context->getLogic(logicId)); if (logic == nullptr) { @@ -2282,8 +2282,8 @@ void GUIMiniScript::registerMethods() { if (context != nullptr) { string logicId; string callable; - if (MiniScript::getStringValue(argumentValues, 0, logicId) == false || - MiniScript::getStringValue(argumentValues, 1, callable) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, logicId) == false || + EngineMiniScript::getStringValue(argumentValues, 1, callable) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { @@ -2336,8 +2336,8 @@ void GUIMiniScript::registerMethods() { if (context != nullptr) { string logicId; string callable; - if (MiniScript::getStringValue(argumentValues, 0, logicId) == false || - MiniScript::getStringValue(argumentValues, 1, callable) == false) { + if (EngineMiniScript::getStringValue(argumentValues, 0, logicId) == false || + EngineMiniScript::getStringValue(argumentValues, 1, callable) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } else { diff --git a/src/tdme/gui/scripting/GUIMiniScript.h b/src/tdme/gui/scripting/GUIMiniScript.h index e3a3341a4..4474dabc2 100644 --- a/src/tdme/gui/scripting/GUIMiniScript.h +++ b/src/tdme/gui/scripting/GUIMiniScript.h @@ -11,7 +11,7 @@ #include #include #include -#include +#include using std::array; using std::string; @@ -23,12 +23,12 @@ using tdme::gui::GUI; using tdme::gui::events::GUIKeyboardEvent; using tdme::gui::events::GUIMouseEvent; using tdme::gui::nodes::GUIScreenNode; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; /** * GUI mini script */ -class tdme::gui::scripting::GUIMiniScript: public MiniScript { +class tdme::gui::scripting::GUIMiniScript: public EngineMiniScript { public: // forbid class copy FORBID_CLASS_COPY(GUIMiniScript) diff --git a/src/tdme/math/Vector4.h b/src/tdme/math/Vector4.h index 938cfb35b..7f7d6947e 100644 --- a/src/tdme/math/Vector4.h +++ b/src/tdme/math/Vector4.h @@ -4,12 +4,14 @@ #include #include +#include #include #include using std::array; using tdme::math::Math; +using tdme::math::Vector3; using tdme::utilities::Float; /** diff --git a/src/tdme/tests/MiniScriptAdvancedTest.cpp b/src/tdme/tests/MiniScriptAdvancedTest.cpp index 4d18f4423..12b13b8e0 100644 --- a/src/tdme/tests/MiniScriptAdvancedTest.cpp +++ b/src/tdme/tests/MiniScriptAdvancedTest.cpp @@ -5,17 +5,17 @@ #include #include -#include +#include #include using std::array; using std::move; using tdme::utilities::Console; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tdme::utilities::MiniScriptMath; -MiniScriptAdvancedTest::MiniScriptAdvancedTest(): MiniScript() { +MiniScriptAdvancedTest::MiniScriptAdvancedTest(): EngineMiniScript() { initializeNative(); } diff --git a/src/tdme/tests/MiniScriptAdvancedTest.h b/src/tdme/tests/MiniScriptAdvancedTest.h index ec27d799b..bebfc4d43 100644 --- a/src/tdme/tests/MiniScriptAdvancedTest.h +++ b/src/tdme/tests/MiniScriptAdvancedTest.h @@ -3,18 +3,18 @@ #include #include -#include +#include using std::array; using std::move; using tdme::utilities::Console; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; /** * Transpile with './bin/tdme/tools/cli/miniscripttranspiler resources/tests/scripts/advanced-test.tscript src/tdme/tests/MiniScriptAdvancedTest.cpp' */ -class MiniScriptAdvancedTest: public MiniScript { +class MiniScriptAdvancedTest: public EngineMiniScript { public: // forbid class copy FORBID_CLASS_COPY(MiniScriptAdvancedTest) diff --git a/src/tdme/tests/MiniScriptBaseTest.cpp b/src/tdme/tests/MiniScriptBaseTest.cpp index 753cfbd76..342a7dbfc 100644 --- a/src/tdme/tests/MiniScriptBaseTest.cpp +++ b/src/tdme/tests/MiniScriptBaseTest.cpp @@ -2,14 +2,14 @@ #include #include -#include +#include #include using tdme::utilities::Console; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tdme::utilities::MiniScriptMath; -MiniScriptBaseTest::MiniScriptBaseTest(): MiniScript() { +MiniScriptBaseTest::MiniScriptBaseTest(): EngineMiniScript() { initializeNative(); } diff --git a/src/tdme/tests/MiniScriptBaseTest.h b/src/tdme/tests/MiniScriptBaseTest.h index 4f8c91f27..37bfebed5 100644 --- a/src/tdme/tests/MiniScriptBaseTest.h +++ b/src/tdme/tests/MiniScriptBaseTest.h @@ -1,14 +1,14 @@ #include #include -#include +#include using tdme::utilities::Console; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; /** * Transpile with './bin/tdme/tools/cli/miniscripttranspiler resources/tests/scripts/base-test.tscript src/tdme/tests/MiniScriptBaseTest.cpp' */ -class MiniScriptBaseTest: public MiniScript { +class MiniScriptBaseTest: public EngineMiniScript { public: // forbid class copy FORBID_CLASS_COPY(MiniScriptBaseTest) diff --git a/src/tdme/tests/MiniScriptClassTest.cpp b/src/tdme/tests/MiniScriptClassTest.cpp index 86dbcb6b0..e657a48f9 100644 --- a/src/tdme/tests/MiniScriptClassTest.cpp +++ b/src/tdme/tests/MiniScriptClassTest.cpp @@ -2,14 +2,14 @@ #include #include -#include +#include #include using tdme::utilities::Console; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tdme::utilities::MiniScriptMath; -MiniScriptClassTest::MiniScriptClassTest(): MiniScript() { +MiniScriptClassTest::MiniScriptClassTest(): EngineMiniScript() { initializeNative(); } diff --git a/src/tdme/tests/MiniScriptClassTest.h b/src/tdme/tests/MiniScriptClassTest.h index 79e63f276..38573a734 100644 --- a/src/tdme/tests/MiniScriptClassTest.h +++ b/src/tdme/tests/MiniScriptClassTest.h @@ -1,14 +1,14 @@ #include #include -#include +#include using tdme::utilities::Console; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; /** * Transpile with './bin/tdme/tools/cli/miniscripttranspiler resources/tests/scripts/class-test.tscript src/tdme/tests/MiniScriptClassTest.cpp' */ -class MiniScriptClassTest: public MiniScript { +class MiniScriptClassTest: public EngineMiniScript { public: // forbid class copy FORBID_CLASS_COPY(MiniScriptClassTest) diff --git a/src/tdme/tests/MiniScriptEmitTest.cpp b/src/tdme/tests/MiniScriptEmitTest.cpp index d6829d889..68c6572d4 100644 --- a/src/tdme/tests/MiniScriptEmitTest.cpp +++ b/src/tdme/tests/MiniScriptEmitTest.cpp @@ -2,14 +2,14 @@ #include #include -#include +#include #include using tdme::utilities::Console; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tdme::utilities::MiniScriptMath; -MiniScriptEmitTest::MiniScriptEmitTest(): MiniScript() { +MiniScriptEmitTest::MiniScriptEmitTest(): EngineMiniScript() { initializeNative(); } diff --git a/src/tdme/tests/MiniScriptEmitTest.h b/src/tdme/tests/MiniScriptEmitTest.h index 9246cd8a5..8278cdfc6 100644 --- a/src/tdme/tests/MiniScriptEmitTest.h +++ b/src/tdme/tests/MiniScriptEmitTest.h @@ -1,14 +1,14 @@ #include #include -#include +#include using tdme::utilities::Console; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; /** * Transpile with './bin/tdme/tools/cli/miniscripttranspiler resources/tests/scripts/emit-test.tscript src/tdme/tests/MiniScriptEmitTest.cpp' */ -class MiniScriptEmitTest: public MiniScript { +class MiniScriptEmitTest: public EngineMiniScript { public: // forbid class copy FORBID_CLASS_COPY(MiniScriptEmitTest) diff --git a/src/tdme/tests/MiniScriptFunctionsTest.cpp b/src/tdme/tests/MiniScriptFunctionsTest.cpp index c266c2648..a2a3e89aa 100644 --- a/src/tdme/tests/MiniScriptFunctionsTest.cpp +++ b/src/tdme/tests/MiniScriptFunctionsTest.cpp @@ -2,14 +2,14 @@ #include #include -#include +#include #include using tdme::utilities::Console; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tdme::utilities::MiniScriptMath; -MiniScriptFunctionsTest::MiniScriptFunctionsTest(): MiniScript() { +MiniScriptFunctionsTest::MiniScriptFunctionsTest(): EngineMiniScript() { initializeNative(); } diff --git a/src/tdme/tests/MiniScriptFunctionsTest.h b/src/tdme/tests/MiniScriptFunctionsTest.h index fca20a535..f560b6c62 100644 --- a/src/tdme/tests/MiniScriptFunctionsTest.h +++ b/src/tdme/tests/MiniScriptFunctionsTest.h @@ -1,14 +1,14 @@ #include #include -#include +#include using tdme::utilities::Console; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; /** * Transpile with './bin/tdme/tools/cli/miniscripttranspiler resources/tests/scripts/functions-test.tscript src/tdme/tests/MiniScriptFunctionsTest.cpp' */ -class MiniScriptFunctionsTest: public MiniScript { +class MiniScriptFunctionsTest: public EngineMiniScript { public: // forbid class copy FORBID_CLASS_COPY(MiniScriptFunctionsTest) diff --git a/src/tdme/tests/MiniScriptTest-main.cpp b/src/tdme/tests/MiniScriptTest-main.cpp index 28a115685..77cf70c68 100644 --- a/src/tdme/tests/MiniScriptTest-main.cpp +++ b/src/tdme/tests/MiniScriptTest-main.cpp @@ -10,11 +10,15 @@ using std::make_unique; #include #include +#include using tdme::utilities::Console; +using tdme::utilities::EngineMiniScript; int main(int argc, char *argv[]) { Console::println("MiniScriptTest"); + // + EngineMiniScript::registerDataTypes(); // base test { auto script = make_unique(); diff --git a/src/tdme/tools/cli/createminiscriptcodecompletion-main.cpp b/src/tdme/tools/cli/createminiscriptcodecompletion-main.cpp index ab4c3c007..e0156415f 100644 --- a/src/tdme/tools/cli/createminiscriptcodecompletion-main.cpp +++ b/src/tdme/tools/cli/createminiscriptcodecompletion-main.cpp @@ -12,7 +12,7 @@ #include #include #include -#include +#include #include using std::array; @@ -28,7 +28,7 @@ using tdme::gui::GUIParser; using tdme::os::filesystem::FileSystem; using tdme::os::filesystem::FileSystemInterface; using tdme::utilities::Console; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tdme::utilities::Properties; int main(int argc, char** argv) @@ -54,7 +54,9 @@ int main(int argc, char** argv) lines.push_back(""); // - auto baseMiniScript = make_unique(); + EngineMiniScript::registerDataTypes(); + // + auto baseMiniScript = make_unique(); baseMiniScript->registerMethods(); auto logicMiniScript = make_unique(); @@ -64,7 +66,7 @@ int main(int argc, char** argv) guiMiniScript->registerMethods(); // - array miniScriptFlavours = { baseMiniScript.get(), logicMiniScript.get(), guiMiniScript.get() }; + array miniScriptFlavours = { baseMiniScript.get(), logicMiniScript.get(), guiMiniScript.get() }; for (const auto miniScriptFlavour: miniScriptFlavours) { // methods auto scriptMethods = miniScriptFlavour->getMethods(); @@ -82,11 +84,11 @@ int main(int argc, char** argv) if (description.empty() == true) description = methodDescriptions.get("miniscript." + scriptMethod->getMethodName(), string()); Console::println("Adding method: " + scriptMethod->getMethodName()); lines.push_back(" getMethodName() + "\" func=\"yes\">"); - lines.push_back(" getReturnValueType(), scriptMethod->isReturnValueNullable()) + "\" descr=\"" + GUIParser::escape(description) + "\">"); + lines.push_back(" getReturnValueType(), scriptMethod->isReturnValueNullable()) + "\" descr=\"" + GUIParser::escape(description) + "\">"); for (const auto& argumentType: scriptMethod->getArgumentTypes()) { string argumentValueString; if (argumentType.optional == true) argumentValueString+= "["; - argumentValueString+= MiniScript::ScriptVariable::getTypeAsString(miniScriptFlavour, argumentType.type) + " "; + argumentValueString+= EngineMiniScript::ScriptVariable::getTypeAsString(argumentType.type) + " "; argumentValueString+= string() + (argumentType.reference == true?"=":"") + "$" + argumentType.name; if (argumentType.optional == true) argumentValueString+= "]"; lines.push_back(" "); diff --git a/src/tdme/tools/cli/createminiscriptdocumentation-main.cpp b/src/tdme/tools/cli/createminiscriptdocumentation-main.cpp index c5f8337ab..a8b4c8b64 100644 --- a/src/tdme/tools/cli/createminiscriptdocumentation-main.cpp +++ b/src/tdme/tools/cli/createminiscriptdocumentation-main.cpp @@ -13,7 +13,7 @@ #include #include #include -#include +#include #include #include @@ -32,7 +32,7 @@ using tdme::engine::logics::LogicMiniScript; using tdme::engine::Version; using tdme::gui::scripting::GUIMiniScript; using tdme::utilities::Console; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tdme::utilities::Properties; using tdme::utilities::StringTools; @@ -41,7 +41,7 @@ namespace tools { namespace cli { class MiniscriptDocumentation { public: -static void generateMiniScriptMethodsDocumentation(const string& heading, int mainHeadingIdx, MiniScript* miniScript, Properties& descriptions, const string& descriptionPrefix, unordered_set& categories, const set& allClassMethods, MiniScript* omitMiniScript = nullptr) { +static void generateMiniScriptMethodsDocumentation(const string& heading, int mainHeadingIdx, EngineMiniScript* miniScript, Properties& descriptions, const string& descriptionPrefix, unordered_set& categories, const set& allClassMethods, EngineMiniScript* omitMiniScript = nullptr) { auto scriptMethods = miniScript->getMethods(); map>> methodMarkupByCategory; for (auto scriptMethod: scriptMethods) { @@ -68,9 +68,9 @@ static void generateMiniScriptMethodsDocumentation(const string& heading, int ma method+= "| "; method+= scriptMethod->getMethodName(); method+= "("; - method+= scriptMethod->getArgumentsInformation(miniScript); + method+= scriptMethod->getArgumentsInformation(); method+= "): "; - method+= MiniScript::ScriptVariable::getReturnTypeAsString(miniScript, scriptMethod->getReturnValueType(), scriptMethod->isReturnValueNullable()); + method+= EngineMiniScript::ScriptVariable::getReturnTypeAsString(scriptMethod->getReturnValueType(), scriptMethod->isReturnValueNullable()); method+= ""; while (method.size() < 99) method+= " "; method+= "|"; @@ -117,11 +117,11 @@ static void generateMiniScriptMethodsDocumentation(const string& heading, int ma } } -static void generateMiniScriptClassesDocumentation(const string& heading, int mainHeadingIdx, MiniScript* miniScript, Properties& descriptions, const string& descriptionPrefix, set& allClassMethods) { +static void generateMiniScriptClassesDocumentation(const string& heading, int mainHeadingIdx, EngineMiniScript* miniScript, Properties& descriptions, const string& descriptionPrefix, set& allClassMethods) { auto scriptMethods = miniScript->getMethods(); // - for (auto typeIdx = static_cast(MiniScript::TYPE_STRING); typeIdx <= static_cast(MiniScript::TYPE_SET); typeIdx++) { - const auto& className = MiniScript::ScriptVariable::getClassName(miniScript, static_cast(typeIdx)); + for (auto typeIdx = static_cast(EngineMiniScript::TYPE_STRING); typeIdx <= static_cast(EngineMiniScript::TYPE_SET); typeIdx++) { + const auto& className = EngineMiniScript::ScriptVariable::getClassName(static_cast(typeIdx)); allClassMethods.insert(className); } // @@ -131,8 +131,8 @@ static void generateMiniScriptClassesDocumentation(const string& heading, int ma if (className.empty() == true && allClassMethods.find(scriptMethod->getMethodName()) == allClassMethods.end()) continue; // auto _class = false; - for (auto typeIdx = static_cast(MiniScript::TYPE_STRING); typeIdx <= static_cast(MiniScript::TYPE_SET); typeIdx++) { - if (MiniScript::ScriptVariable::getClassName(miniScript, static_cast(typeIdx)) == className) { + for (auto typeIdx = static_cast(EngineMiniScript::TYPE_STRING); typeIdx <= static_cast(EngineMiniScript::TYPE_SET); typeIdx++) { + if (EngineMiniScript::ScriptVariable::getClassName(static_cast(typeIdx)) == className) { _class = true; break; } @@ -148,7 +148,7 @@ static void generateMiniScriptClassesDocumentation(const string& heading, int ma auto _static = scriptMethod->getArgumentTypes().empty() == true || scriptMethod->getArgumentTypes()[0].name != className; - MiniScript::ScriptVariable::getClassName(miniScript, scriptMethod->getArgumentTypes()[0].type) != className; + EngineMiniScript::ScriptVariable::getClassName(scriptMethod->getArgumentTypes()[0].type) != className; // allClassMethods.insert(scriptMethod->getMethodName()); } @@ -164,8 +164,8 @@ static void generateMiniScriptClassesDocumentation(const string& heading, int ma // constructors auto _static = false; if (className.empty() == true) { - for (auto typeIdx = static_cast(MiniScript::TYPE_STRING); typeIdx <= static_cast(MiniScript::TYPE_SET); typeIdx++) { - const auto& possibleClassName = MiniScript::ScriptVariable::getClassName(miniScript, static_cast(typeIdx)); + for (auto typeIdx = static_cast(EngineMiniScript::TYPE_STRING); typeIdx <= static_cast(EngineMiniScript::TYPE_SET); typeIdx++) { + const auto& possibleClassName = EngineMiniScript::ScriptVariable::getClassName(static_cast(typeIdx)); if (scriptMethod->getMethodName() == possibleClassName) { className = possibleClassName; _static = true; @@ -178,7 +178,7 @@ static void generateMiniScriptClassesDocumentation(const string& heading, int ma _static = scriptMethod->getArgumentTypes().empty() == true || scriptMethod->getArgumentTypes()[0].name != className; - MiniScript::ScriptVariable::getClassName(miniScript, scriptMethod->getArgumentTypes()[0].type) != className; + EngineMiniScript::ScriptVariable::getClassName(scriptMethod->getArgumentTypes()[0].type) != className; } // string description; @@ -194,9 +194,9 @@ static void generateMiniScriptClassesDocumentation(const string& heading, int ma } method+= _static == true?scriptMethod->getMethodName():StringTools::substring(scriptMethod->getMethodName(), className.size() + 1, scriptMethod->getMethodName().size()); method+= "("; - method+= scriptMethod->getArgumentsInformation(miniScript, _static == true?0:1); + method+= scriptMethod->getArgumentsInformation(_static == true?0:1); method+= "): "; - method+= MiniScript::ScriptVariable::getReturnTypeAsString(miniScript, scriptMethod->getReturnValueType(), scriptMethod->isReturnValueNullable()); + method+= EngineMiniScript::ScriptVariable::getReturnTypeAsString(scriptMethod->getReturnValueType(), scriptMethod->isReturnValueNullable()); method+= ""; while (method.size() < 99) method+= " "; method+= "|"; @@ -206,8 +206,8 @@ static void generateMiniScriptClassesDocumentation(const string& heading, int ma } // auto classIdx = 1; - for (auto typeIdx = static_cast(MiniScript::TYPE_STRING); typeIdx <= static_cast(MiniScript::TYPE_SET); typeIdx++) { - const auto& className = MiniScript::ScriptVariable::getClassName(miniScript, static_cast(typeIdx)); + for (auto typeIdx = static_cast(EngineMiniScript::TYPE_STRING); typeIdx <= static_cast(EngineMiniScript::TYPE_SET); typeIdx++) { + const auto& className = EngineMiniScript::ScriptVariable::getClassName(static_cast(typeIdx)); auto classNameDescription = descriptions.get("miniscript.baseclass." + (className.empty() == true?"No class":className), "Not documented"); // Console::println(); @@ -250,7 +250,10 @@ int main(int argc, char** argv) descriptions.load("resources/engine/code-completion", "tscript-methods.properties"); // - auto baseMiniScript = make_unique(); + EngineMiniScript::registerDataTypes(); + + // + auto baseMiniScript = make_unique(); baseMiniScript->registerMethods(); // @@ -269,13 +272,13 @@ int main(int argc, char** argv) set allClassMethods; // classes - tdme::tools::cli::MiniscriptDocumentation::generateMiniScriptClassesDocumentation("MiniScript Classes", 6, baseMiniScript.get(), descriptions, "miniscript.basemethod.", allClassMethods); + tdme::tools::cli::MiniscriptDocumentation::generateMiniScriptClassesDocumentation("EngineMiniScript Classes", 6, baseMiniScript.get(), descriptions, "miniscript.basemethod.", allClassMethods); // base methods - tdme::tools::cli::MiniscriptDocumentation::generateMiniScriptMethodsDocumentation("MiniScript Base Methods", 7, baseMiniScript.get(), descriptions, "miniscript.basemethod.", baseMethodCategories, allClassMethods); + tdme::tools::cli::MiniscriptDocumentation::generateMiniScriptMethodsDocumentation("EngineMiniScript Base Methods", 7, baseMiniScript.get(), descriptions, "miniscript.basemethod.", baseMethodCategories, allClassMethods); // logic methods - tdme::tools::cli::MiniscriptDocumentation::generateMiniScriptMethodsDocumentation("MiniScript Logic Methods", 8, logicMiniScript.get(), descriptions, "miniscript.logicmethod.", logicMethodCategories, allClassMethods, baseMiniScript.get()); + tdme::tools::cli::MiniscriptDocumentation::generateMiniScriptMethodsDocumentation("EngineMiniScript Logic Methods", 8, logicMiniScript.get(), descriptions, "miniscript.logicmethod.", logicMethodCategories, allClassMethods, baseMiniScript.get()); // gui methods - tdme::tools::cli::MiniscriptDocumentation::generateMiniScriptMethodsDocumentation("MiniScript GUI Methods", 9, guiMiniScript.get(), descriptions, "miniscript.", guiMethodCategories, allClassMethods, baseMiniScript.get()); + tdme::tools::cli::MiniscriptDocumentation::generateMiniScriptMethodsDocumentation("EngineMiniScript GUI Methods", 9, guiMiniScript.get(), descriptions, "miniscript.", guiMethodCategories, allClassMethods, baseMiniScript.get()); // operators auto scriptOperatorMethods = baseMiniScript->getOperatorMethods(); @@ -283,14 +286,14 @@ int main(int argc, char** argv) for (auto scriptMethod: scriptOperatorMethods) { string operatorString; operatorString = "| "; - operatorString+= StringTools::replace(MiniScript::getOperatorAsString(scriptMethod->getOperator()), "|", "\\|"); + operatorString+= StringTools::replace(EngineMiniScript::getOperatorAsString(scriptMethod->getOperator()), "|", "\\|"); while (operatorString.size() < 5) operatorString+= " "; operatorString+= "| "; operatorString+= scriptMethod->getMethodName(); operatorString+= "("; - operatorString+= scriptMethod->getArgumentsInformation(baseMiniScript.get()); + operatorString+= scriptMethod->getArgumentsInformation(); operatorString+= "): "; - operatorString+= MiniScript::ScriptVariable::getReturnTypeAsString(baseMiniScript.get(), scriptMethod->getReturnValueType(), scriptMethod->isReturnValueNullable()); + operatorString+= EngineMiniScript::ScriptVariable::getReturnTypeAsString(scriptMethod->getReturnValueType(), scriptMethod->isReturnValueNullable()); while (operatorString.size() < 99) operatorString+= " "; operatorString+= "|"; operators.push_back(operatorString); diff --git a/src/tdme/tools/cli/miniscript-main.cpp b/src/tdme/tools/cli/miniscript-main.cpp index 8d9406d7b..005cf6c02 100644 --- a/src/tdme/tools/cli/miniscript-main.cpp +++ b/src/tdme/tools/cli/miniscript-main.cpp @@ -8,7 +8,7 @@ #include #include #include -#include +#include using std::string; using std::unique_ptr; @@ -18,7 +18,7 @@ using tdme::engine::Version; using tdme::os::filesystem::FileSystem; using tdme::os::filesystem::FileSystemInterface; using tdme::utilities::Console; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; static void printInformation() { Console::println(string("miniscript ") + Version::getVersion()); @@ -63,11 +63,12 @@ int main(int argc, char** argv) } // run script - unique_ptr script; + EngineMiniScript::registerDataTypes(); + unique_ptr script; if (pathToScript.empty() == false) { // - script = unique_ptr( - MiniScript::loadScript( + script = unique_ptr( + EngineMiniScript::loadScript( FileSystem::getInstance()->getPathName(pathToScript), FileSystem::getInstance()->getFileName(pathToScript) ) diff --git a/src/tdme/tools/cli/miniscripttranspiler-main.cpp b/src/tdme/tools/cli/miniscripttranspiler-main.cpp index c277b2af7..637cf1b57 100644 --- a/src/tdme/tools/cli/miniscripttranspiler-main.cpp +++ b/src/tdme/tools/cli/miniscripttranspiler-main.cpp @@ -17,7 +17,7 @@ #include #include #include -#include +#include #include #include @@ -39,7 +39,7 @@ using tdme::tools::editor::misc::Tools; using tdme::utilities::Console; using tdme::utilities::Exception; using tdme::utilities::Integer; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tdme::utilities::MiniScriptTranspiler; using tdme::utilities::StringTools; @@ -54,7 +54,7 @@ static void processFile(const string& scriptFileName, const string& miniscriptTr // - auto miniScript = unique_ptr(MiniScript::loadScript(Tools::getPathName(scriptFileName), Tools::getFileName(scriptFileName))); + auto miniScript = unique_ptr(EngineMiniScript::loadScript(Tools::getPathName(scriptFileName), Tools::getFileName(scriptFileName))); if (miniScript == nullptr) { Console::println("No script instance: " + scriptFileName); return; @@ -79,7 +79,7 @@ static void processFile(const string& scriptFileName, const string& miniscriptTr auto bracketCount = 0; string className; if (StringTools::firstIndexOf(StringTools::substring(trimmedLine, 14), "new") == string::npos) { - Console::println("src/tdme/utilities/MiniScript.cpp: registerMethod @ " + to_string(i) + ": '" + trimmedLine + "': unable to determine class name"); + Console::println("src/tdme/utilities/EngineMiniScript.cpp: registerMethod @ " + to_string(i) + ": '" + trimmedLine + "': unable to determine class name"); } else { auto classNameStartIdx = trimmedLine.find("registerMethod") + 14 + 5; for (auto j = classNameStartIdx; j < trimmedLine.size(); j++) { @@ -106,9 +106,9 @@ static void processFile(const string& scriptFileName, const string& miniscriptTr for (const auto& script: scripts) { // method name string methodName = - (script.scriptType == MiniScript::Script::SCRIPTTYPE_FUNCTION? + (script.scriptType == EngineMiniScript::Script::SCRIPTTYPE_FUNCTION? "": - (script.scriptType == MiniScript::Script::SCRIPTTYPE_ON?"on_":"on_enabled_") + (script.scriptType == EngineMiniScript::Script::SCRIPTTYPE_ON?"on_":"on_enabled_") ) + (script.name.empty() == false?script.name:( StringTools::regexMatch(script.condition, "[a-zA-Z0-9_]+") == true? @@ -153,7 +153,7 @@ static void processFile(const string& scriptFileName, const string& miniscriptTr generatedDeclarations+= headerIndent + "void emit(const string& condition) override;" + "\n"; generatedDeclarations+= headerIndent + "inline void startScript() override {" + "\n"; generatedDeclarations+= headerIndent + "\t" + "if (native == false) {" + "\n"; - generatedDeclarations+= headerIndent + "\t" + "\t" + "MiniScript::startScript();" + "\n"; + generatedDeclarations+= headerIndent + "\t" + "\t" + "EngineMiniScript::startScript();" + "\n"; generatedDeclarations+= headerIndent + "\t" + "\t" + "return;" + "\n"; generatedDeclarations+= headerIndent + "\t" + "}" + "\n"; generatedDeclarations+= headerIndent + "\t" + "auto& scriptState = getScriptState();" + "\n"; @@ -165,7 +165,7 @@ static void processFile(const string& scriptFileName, const string& miniscriptTr generatedDeclarations+= headerIndent + "}" + "\n"; generatedDeclarations+= headerIndent + "inline void execute() override {" + "\n"; generatedDeclarations+= headerIndent + "\t" + "if (native == false) {" + "\n"; - generatedDeclarations+= headerIndent + "\t" + "\t" + "MiniScript::execute();" + "\n"; + generatedDeclarations+= headerIndent + "\t" + "\t" + "EngineMiniScript::execute();" + "\n"; generatedDeclarations+= headerIndent + "\t" + "\t" + "return;" + "\n"; generatedDeclarations+= headerIndent + "\t" + "}" + "\n"; generatedDeclarations+= headerIndent + "\t" + "auto& scriptState = getScriptState();" + "\n"; @@ -195,7 +195,7 @@ static void processFile(const string& scriptFileName, const string& miniscriptTr string registerMethodsDefinitions; registerMethodsDefinitions+= "void " + miniScriptClassName + "::registerMethods() {" + "\n"; - registerMethodsDefinitions+= methodCodeIndent+ "MiniScript::registerMethods();" + "\n"; + registerMethodsDefinitions+= methodCodeIndent+ "EngineMiniScript::registerMethods();" + "\n"; registerMethodsDefinitions+= methodCodeIndent + "if (native == false) return;" + "\n"; // for (const auto& memberAccessEvaluationDefintion: memberAccessEvaluationDefinitions) { @@ -207,7 +207,7 @@ static void processFile(const string& scriptFileName, const string& miniscriptTr string emitDefinition; emitDefinition+= "void " + miniScriptClassName + "::emit(const string& condition) {" + "\n"; emitDefinition+= methodCodeIndent + "if (native == false) {" + "\n"; - emitDefinition+= methodCodeIndent + "\t" + "MiniScript::emit(condition);" + "\n"; + emitDefinition+= methodCodeIndent + "\t" + "EngineMiniScript::emit(condition);" + "\n"; emitDefinition+= methodCodeIndent + "\t" + "return;" + "\n"; emitDefinition+= methodCodeIndent + "}" + "\n"; string generatedDefinitions = "\n"; @@ -221,7 +221,7 @@ static void processFile(const string& scriptFileName, const string& miniscriptTr auto scriptIdx = 0; for (const auto& script: scripts) { initializeNativeDefinition+= methodCodeIndent + "\t" + "\t" + "Script(" + "\n"; - initializeNativeDefinition+= methodCodeIndent + "\t" + "\t" + "\t" + (script.scriptType == MiniScript::Script::SCRIPTTYPE_FUNCTION?"Script::SCRIPTTYPE_FUNCTION":(script.scriptType == MiniScript::Script::SCRIPTTYPE_ON?"Script::SCRIPTTYPE_ON":"Script::SCRIPTTYPE_ONENABLED")) + "," + "\n"; + initializeNativeDefinition+= methodCodeIndent + "\t" + "\t" + "\t" + (script.scriptType == EngineMiniScript::Script::SCRIPTTYPE_FUNCTION?"Script::SCRIPTTYPE_FUNCTION":(script.scriptType == EngineMiniScript::Script::SCRIPTTYPE_ON?"Script::SCRIPTTYPE_ON":"Script::SCRIPTTYPE_ONENABLED")) + "," + "\n"; initializeNativeDefinition+= methodCodeIndent + "\t" + "\t" + "\t" + to_string(script.line) + "," + "\n"; initializeNativeDefinition+= methodCodeIndent + "\t" + "\t" + "\t" + "\"" + StringTools::replace(StringTools::replace(script.condition, "\\", "\\\\"), "\"", "\\\"") + "\"," + "\n"; initializeNativeDefinition+= methodCodeIndent + "\t" + "\t" + "\t" + "\"" + StringTools::replace(StringTools::replace(script.executableCondition, "\\", "\\\\"), "\"", "\\\"") + "\"," + "\n"; @@ -236,7 +236,7 @@ static void processFile(const string& scriptFileName, const string& miniscriptTr initializeNativeDefinition+= methodCodeIndent + "\t" + "\t" + "\t" + "\"" + script.name + "\"," + "\n"; initializeNativeDefinition+= methodCodeIndent + "\t" + "\t" + "\t" + (script.emitCondition == true?"true":"false") + "," + "\n"; initializeNativeDefinition+= methodCodeIndent + "\t" + "\t" + "\t" + "{" + "\n"; - auto statementIdx = MiniScript::STATEMENTIDX_FIRST; + auto statementIdx = EngineMiniScript::STATEMENTIDX_FIRST; for (const auto& statement: script.statements) { initializeNativeDefinition+= methodCodeIndent + "\t" + "\t" + "\t" + "\t" + "ScriptStatement(" + "\n"; initializeNativeDefinition+= methodCodeIndent + "\t" + "\t" + "\t" + "\t" + "\t" + to_string(statement.line) + "," + "\n"; @@ -283,11 +283,11 @@ static void processFile(const string& scriptFileName, const string& miniscriptTr // string generatedDetermineScriptIdxToStartDefinition = "\n"; generatedDetermineScriptIdxToStartDefinition+= "int " + miniScriptClassName + "::determineScriptIdxToStart() {" + "\n"; - generatedDetermineScriptIdxToStartDefinition+= string() + "\t" + "if (native == false) return MiniScript::determineScriptIdxToStart();" + "\n"; + generatedDetermineScriptIdxToStartDefinition+= string() + "\t" + "if (native == false) return EngineMiniScript::determineScriptIdxToStart();" + "\n"; generatedDetermineScriptIdxToStartDefinition+= string() + "\t" + "auto miniScript = this;" + "\n"; string generatedDetermineNamedScriptIdxToStartDefinition = "\n"; generatedDetermineNamedScriptIdxToStartDefinition+= "int " + miniScriptClassName + "::determineNamedScriptIdxToStart() {" + "\n"; - generatedDetermineNamedScriptIdxToStartDefinition+= string() + "\t" + "if (native == false) return MiniScript::determineNamedScriptIdxToStart();" + "\n"; + generatedDetermineNamedScriptIdxToStartDefinition+= string() + "\t" + "if (native == false) return EngineMiniScript::determineNamedScriptIdxToStart();" + "\n"; generatedDetermineNamedScriptIdxToStartDefinition+= string() + "\t" + "auto miniScript = this;" + "\n"; generatedDetermineNamedScriptIdxToStartDefinition+= string() + "\t" + "for (const auto& enabledNamedCondition: enabledNamedConditions) {" + "\n"; { @@ -295,9 +295,9 @@ static void processFile(const string& scriptFileName, const string& miniscriptTr for (const auto& script: scripts) { // method name string methodName = - (script.scriptType == MiniScript::Script::SCRIPTTYPE_FUNCTION? + (script.scriptType == EngineMiniScript::Script::SCRIPTTYPE_FUNCTION? "": - (script.scriptType == MiniScript::Script::SCRIPTTYPE_ON?"on_":"on_enabled_") + (script.scriptType == EngineMiniScript::Script::SCRIPTTYPE_ON?"on_":"on_enabled_") ) + (script.name.empty() == false?script.name:( StringTools::regexMatch(script.condition, "[a-zA-Z0-9_]+") == true? @@ -315,7 +315,7 @@ static void processFile(const string& scriptFileName, const string& miniscriptTr ); // emit code - if (script.scriptType == MiniScript::Script::SCRIPTTYPE_ON && StringTools::regexMatch(script.condition, "[a-zA-Z0-9_]+") == true) { + if (script.scriptType == EngineMiniScript::Script::SCRIPTTYPE_ON && StringTools::regexMatch(script.condition, "[a-zA-Z0-9_]+") == true) { string emitDefinitionIndent = "\t"; emitDefinition+= emitDefinitionIndent + "if (condition == \"" + emitName + "\") {" + "\n"; emitDefinition+= emitDefinitionIndent + "\t" + methodName + "(STATEMENTIDX_FIRST);" + "\n"; @@ -324,8 +324,8 @@ static void processFile(const string& scriptFileName, const string& miniscriptTr // declaration generatedDeclarations+= headerIndent + "/**" + "\n"; - generatedDeclarations+= headerIndent + " * Miniscript transpilation of: " + (script.scriptType == MiniScript::Script::SCRIPTTYPE_FUNCTION?"function":(script.scriptType == MiniScript::Script::SCRIPTTYPE_ON?"on":"on-enabled")) + ": " + script.condition + (script.name.empty() == false?" (" + script.name + ")":"") + "\n"; - generatedDeclarations+= headerIndent + " * @param miniScriptGotoStatementIdx MiniScript goto statement index" + "\n"; + generatedDeclarations+= headerIndent + " * Miniscript transpilation of: " + (script.scriptType == EngineMiniScript::Script::SCRIPTTYPE_FUNCTION?"function":(script.scriptType == EngineMiniScript::Script::SCRIPTTYPE_ON?"on":"on-enabled")) + ": " + script.condition + (script.name.empty() == false?" (" + script.name + ")":"") + "\n"; + generatedDeclarations+= headerIndent + " * @param miniScriptGotoStatementIdx EngineMiniScript goto statement index" + "\n"; generatedDeclarations+= headerIndent + " */" + "\n"; generatedDeclarations+= headerIndent + "void " + methodName + "(int miniScriptGotoStatementIdx);" + "\n"; generatedDeclarations+= "\n"; @@ -339,20 +339,20 @@ static void processFile(const string& scriptFileName, const string& miniscriptTr // if (script.emitCondition == false) { - if (script.scriptType == MiniScript::Script::SCRIPTTYPE_ONENABLED) { + if (script.scriptType == EngineMiniScript::Script::SCRIPTTYPE_ONENABLED) { generatedDetermineNamedScriptIdxToStartDefinition+= string() + "\n"; generatedDetermineNamedScriptIdxToStartDefinition+= string() + "\t" + "\t" + "// next statements belong to tested enabled named condition with name \"" + script.name + "\"" + "\n"; generatedDetermineNamedScriptIdxToStartDefinition+= string() + "\t" + "\t" + "if (enabledNamedCondition == \"" + script.name + "\")" + "\n"; } MiniScriptTranspiler::transpileScriptCondition( miniScript.get(), - script.scriptType == MiniScript::Script::SCRIPTTYPE_ON?generatedDetermineScriptIdxToStartDefinition:generatedDetermineNamedScriptIdxToStartDefinition, + script.scriptType == EngineMiniScript::Script::SCRIPTTYPE_ON?generatedDetermineScriptIdxToStartDefinition:generatedDetermineNamedScriptIdxToStartDefinition, scriptIdx, methodCodeMap, allMethods, "-1", "bool returnValueBool; returnValue.getBooleanValue(returnValueBool); if (returnValueBool == true) return " + to_string(scriptIdx) + ";", - script.scriptType == MiniScript::Script::SCRIPTTYPE_ONENABLED?1:0 + script.scriptType == EngineMiniScript::Script::SCRIPTTYPE_ONENABLED?1:0 ); } @@ -394,9 +394,9 @@ static void processFile(const string& scriptFileName, const string& miniscriptTr for (const auto& script: scripts) { // method name string methodName = - (script.scriptType == MiniScript::Script::SCRIPTTYPE_FUNCTION? + (script.scriptType == EngineMiniScript::Script::SCRIPTTYPE_FUNCTION? "": - (script.scriptType == MiniScript::Script::SCRIPTTYPE_ON?"on_":"on_enabled_") + (script.scriptType == EngineMiniScript::Script::SCRIPTTYPE_ON?"on_":"on_enabled_") ) + (script.name.empty() == false?script.name:( StringTools::regexMatch(script.condition, "[a-zA-Z0-9_]+") == true? @@ -584,6 +584,9 @@ int main(int argc, char** argv) vector miniScriptExtensionFileNames; for (auto i = 3; i < argc; i++) miniScriptExtensionFileNames.push_back(argv[i]); + // + EngineMiniScript::registerDataTypes(); + // tdme::tools::cli::MiniScriptTranspilerTool::processFile(argv[1], argv[2], miniScriptExtensionFileNames); diff --git a/src/tdme/tools/editor/Editor.cpp b/src/tdme/tools/editor/Editor.cpp index 1f3fcfb6e..1ec788790 100644 --- a/src/tdme/tools/editor/Editor.cpp +++ b/src/tdme/tools/editor/Editor.cpp @@ -21,6 +21,7 @@ #include #include #include +#include using std::make_unique; using std::string; @@ -44,6 +45,7 @@ using tdme::tools::editor::misc::Tools; using tdme::tools::editor::views::EditorView; using tdme::tools::editor::views::View; using tdme::utilities::Console; +using tdme::utilities::EngineMiniScript; Editor* Editor::instance = nullptr; @@ -69,7 +71,9 @@ int Editor::main(int argc, char** argv) Console::println(string("Editor ") + Version::getVersion()); Console::println(Version::getCopyright()); Console::println(); - + // + EngineMiniScript::registerDataTypes(); + // auto tdmeEditor = new Editor(); return tdmeEditor->run(argc, argv, "Editor", nullptr, Application::WINDOW_HINT_MAXIMIZED); } diff --git a/src/tdme/tools/editor/tabcontrollers/TextEditorTabController.cpp b/src/tdme/tools/editor/tabcontrollers/TextEditorTabController.cpp index 67f74b759..46258cbbd 100644 --- a/src/tdme/tools/editor/tabcontrollers/TextEditorTabController.cpp +++ b/src/tdme/tools/editor/tabcontrollers/TextEditorTabController.cpp @@ -37,7 +37,7 @@ #include #include #include -#include +#include #include #include @@ -80,7 +80,7 @@ using tdme::utilities::Console; using tdme::utilities::Exception; using tdme::utilities::ExceptionBase; using tdme::utilities::Integer; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tdme::utilities::StringTools; using tinyxml::TiXmlAttribute; @@ -409,7 +409,7 @@ void TextEditorTabController::onTooltipCloseRequest() { void TextEditorTabController::setOutlinerContent() { string xml; - xml+= "\n"; + xml+= "\n"; auto scriptIdx = 0; for (const auto& miniScriptSyntaxTree: miniScriptSyntaxTrees) { xml+= "\n"; @@ -426,7 +426,7 @@ void TextEditorTabController::setOutlinerAddDropDownContent() { void TextEditorTabController::updateMiniScriptSyntaxTree(int miniScriptScriptIdx) { auto scriptFileName = view->getFileName(); - // we need to detect MiniScript variant + // we need to detect EngineMiniScript variant vector scriptAsStringArray; try { FileSystem::getInstance()->getContentAsStringArray(Tools::getPathName(scriptFileName), Tools::getFileName(scriptFileName), scriptAsStringArray); @@ -440,8 +440,8 @@ void TextEditorTabController::updateMiniScriptSyntaxTree(int miniScriptScriptIdx return; } - // load specific MiniScript - scriptInstance = unique_ptr(MiniScript::loadScript(Tools::getPathName(scriptFileName), Tools::getFileName(scriptFileName))); + // load specific EngineMiniScript + scriptInstance = unique_ptr(EngineMiniScript::loadScript(Tools::getPathName(scriptFileName), Tools::getFileName(scriptFileName))); // if (scriptInstance->isValid() == false) { @@ -458,7 +458,7 @@ void TextEditorTabController::updateMiniScriptSyntaxTree(int miniScriptScriptIdx // unordered_map methodOperatorMap; for (auto operatorMethod: scriptInstance->getOperatorMethods()) { - methodOperatorMap[operatorMethod->getMethodName()] = MiniScript::getOperatorAsString(operatorMethod->getOperator()); + methodOperatorMap[operatorMethod->getMethodName()] = EngineMiniScript::getOperatorAsString(operatorMethod->getOperator()); } // @@ -469,7 +469,7 @@ void TextEditorTabController::updateMiniScriptSyntaxTree(int miniScriptScriptIdx string name; string argumentsString; switch(script.scriptType) { - case MiniScript::Script::SCRIPTTYPE_FUNCTION: { + case EngineMiniScript::Script::SCRIPTTYPE_FUNCTION: { for (const auto& argument: script.arguments) { if (argumentsString.empty() == false) argumentsString+= ", "; if (argument.reference == true) argumentsString+= "="; @@ -478,8 +478,8 @@ void TextEditorTabController::updateMiniScriptSyntaxTree(int miniScriptScriptIdx argumentsString = "(" + argumentsString + ")"; name+= "function: "; break; } - case MiniScript::Script::SCRIPTTYPE_ON: name+= "on: "; break; - case MiniScript::Script::SCRIPTTYPE_ONENABLED: name+= "on-enabled: "; break; + case EngineMiniScript::Script::SCRIPTTYPE_ON: name+= "on: "; break; + case EngineMiniScript::Script::SCRIPTTYPE_ONENABLED: name+= "on-enabled: "; break; } if (script.name.empty() == false) { name+= script.name; diff --git a/src/tdme/tools/editor/tabcontrollers/TextEditorTabController.h b/src/tdme/tools/editor/tabcontrollers/TextEditorTabController.h index b6bce9d6f..183e65a6d 100644 --- a/src/tdme/tools/editor/tabcontrollers/TextEditorTabController.h +++ b/src/tdme/tools/editor/tabcontrollers/TextEditorTabController.h @@ -16,7 +16,7 @@ #include #include #include -#include +#include #include @@ -38,7 +38,7 @@ using tdme::gui::nodes::GUITextNode; using tdme::tools::editor::misc::PopUps; using tdme::tools::editor::tabcontrollers::TabController; using tdme::tools::editor::tabviews::TextEditorTabView; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; using tinyxml::TiXmlAttribute; using tinyxml::TiXmlDocument; @@ -53,11 +53,11 @@ class tdme::tools::editor::tabcontrollers::TextEditorTabController final { public: struct MiniScriptScriptSyntaxTree { - MiniScript::Script::ScriptType type; + EngineMiniScript::Script::ScriptType type; string condition; string name; - MiniScript::ScriptSyntaxTreeNode conditionSyntaxTree; - vector syntaxTree; + EngineMiniScript::ScriptSyntaxTreeNode conditionSyntaxTree; + vector syntaxTree; }; enum ContextMenuType { CONTEXTMENUTYPE_NONE, CONTEXTMENUTYPE_NODE, CONTEXTMENUTYPE_CANVAS }; @@ -76,7 +76,7 @@ class tdme::tools::editor::tabcontrollers::TextEditorTabController final int addNodeX { -1 }; int addNodeY { -1 }; - unique_ptr scriptInstance; + unique_ptr scriptInstance; public: // forbid class copy @@ -107,9 +107,9 @@ class tdme::tools::editor::tabcontrollers::TextEditorTabController final } /** - * @return MiniScript + * @return EngineMiniScript */ - inline MiniScript* getMiniScript() { + inline EngineMiniScript* getMiniScript() { return scriptInstance.get(); } @@ -196,8 +196,8 @@ class tdme::tools::editor::tabcontrollers::TextEditorTabController final } /** - * Update MiniScript syntax tree - * @param miniScriptScriptIdx MiniScript script index + * Update EngineMiniScript syntax tree + * @param miniScriptScriptIdx EngineMiniScript script index */ void updateMiniScriptSyntaxTree(int miniScriptScriptIdx); diff --git a/src/tdme/tools/editor/tabviews/TextEditorTabView.h b/src/tdme/tools/editor/tabviews/TextEditorTabView.h index e539a88cd..59c7265cc 100644 --- a/src/tdme/tools/editor/tabviews/TextEditorTabView.h +++ b/src/tdme/tools/editor/tabviews/TextEditorTabView.h @@ -15,7 +15,7 @@ #include #include #include -#include +#include using std::string; using std::to_string; @@ -35,7 +35,7 @@ using tdme::tools::editor::tabcontrollers::TabController; using tdme::tools::editor::tabcontrollers::TextEditorTabController; using tdme::tools::editor::tabviews::TabView; using tdme::tools::editor::views::EditorView; -using tdme::utilities::MiniScript; +using tdme::utilities::EngineMiniScript; /** * Text editor tab view @@ -87,7 +87,7 @@ class tdme::tools::editor::tabviews::TextEditorTabView final string id; NodeType type { NODETYPE_NONE }; string value; - MiniScript::ScriptVariableType returnValueType; + EngineMiniScript::ScriptVariableType returnValueType; int left; int top; }; @@ -109,8 +109,8 @@ class tdme::tools::editor::tabviews::TextEditorTabView final struct MiniScriptBranch { string name; - MiniScript::ScriptSyntaxTreeNode* conditionSyntaxTree { nullptr }; - vector syntaxTreeNodes; + EngineMiniScript::ScriptSyntaxTreeNode* conditionSyntaxTree { nullptr }; + vector syntaxTreeNodes; }; unordered_map methodOperatorMap; @@ -295,32 +295,32 @@ class tdme::tools::editor::tabviews::TextEditorTabView final * @param type type * @return string with color property name from theme */ - inline const string getScriptVariableTypePinColor(MiniScript::ScriptVariableType type) { + inline const string getScriptVariableTypePinColor(EngineMiniScript::ScriptVariableType type) { switch (type) { - case MiniScript::ScriptVariableType::TYPE_BOOLEAN: + case EngineMiniScript::ScriptVariableType::TYPE_BOOLEAN: return string("color.pintype_boolean"); - case MiniScript::ScriptVariableType::TYPE_INTEGER: + case EngineMiniScript::ScriptVariableType::TYPE_INTEGER: return string("color.pintype_integer"); - case MiniScript::ScriptVariableType::TYPE_FLOAT: + case EngineMiniScript::ScriptVariableType::TYPE_FLOAT: return string("color.pintype_float"); - case MiniScript::ScriptVariableType::TYPE_STRING: + case EngineMiniScript::ScriptVariableType::TYPE_STRING: return string("color.pintype_string"); - case MiniScript::ScriptVariableType::TYPE_VECTOR2: - case MiniScript::ScriptVariableType::TYPE_VECTOR3: - case MiniScript::ScriptVariableType::TYPE_VECTOR4: + case EngineMiniScript::TYPE_VECTOR2: + case EngineMiniScript::TYPE_VECTOR3: + case EngineMiniScript::TYPE_VECTOR4: return string("color.pintype_vector"); - case MiniScript::ScriptVariableType::TYPE_QUATERNION: - case MiniScript::ScriptVariableType::TYPE_MATRIX3x3: - case MiniScript::ScriptVariableType::TYPE_MATRIX4x4: - case MiniScript::ScriptVariableType::TYPE_TRANSFORM: + case EngineMiniScript::TYPE_QUATERNION: + case EngineMiniScript::TYPE_MATRIX3x3: + case EngineMiniScript::TYPE_MATRIX4x4: + case EngineMiniScript::TYPE_TRANSFORM: return string("color.pintype_transform"); - case MiniScript::ScriptVariableType::TYPE_ARRAY: - case MiniScript::ScriptVariableType::TYPE_MAP: - case MiniScript::ScriptVariableType::TYPE_SET: - case MiniScript::ScriptVariableType::TYPE_PSEUDO_MIXED: - case MiniScript::ScriptVariableType::TYPE_NULL: + case EngineMiniScript::ScriptVariableType::TYPE_ARRAY: + case EngineMiniScript::ScriptVariableType::TYPE_MAP: + case EngineMiniScript::ScriptVariableType::TYPE_SET: + case EngineMiniScript::ScriptVariableType::TYPE_PSEUDO_MIXED: + case EngineMiniScript::ScriptVariableType::TYPE_NULL: return string("color.pintype_undefined"); - case MiniScript::ScriptVariableType::TYPE_PSEUDO_NUMBER: + case EngineMiniScript::ScriptVariableType::TYPE_PSEUDO_NUMBER: return string("color.pintype_float"); } return string("color.pintype_undefined"); @@ -443,7 +443,7 @@ class tdme::tools::editor::tabviews::TextEditorTabView final void setCodeEditor(); /** - * Create MiniScript node + * Create EngineMiniScript node * @param methodName method name * @param id id * @param x x @@ -452,7 +452,7 @@ class tdme::tools::editor::tabviews::TextEditorTabView final void createMiniScriptNode(const string& methodName, int x, int y); /** - * Get MiniScript node flattened id from hierarchical id + * Get EngineMiniScript node flattened id from hierarchical id * @param hierarchicalId hierarchical id * @return flattened id */ @@ -473,10 +473,10 @@ class tdme::tools::editor::tabviews::TextEditorTabView final * @param syntaxTreeNode syntax tree node * @param deltaX delta X */ - void addMiniScriptNodeDeltaX(unordered_map& idMapping, const string& id, const MiniScript::ScriptSyntaxTreeNode& syntaxTreeNode, int deltaX); + void addMiniScriptNodeDeltaX(unordered_map& idMapping, const string& id, const EngineMiniScript::ScriptSyntaxTreeNode& syntaxTreeNode, int deltaX); /** - * Create UI nodes for MiniScript script node syntax tree, which matches a event or function in MiniScript + * Create UI nodes for EngineMiniScript script node syntax tree, which matches a event or function in EngineMiniScript * @param idMapping id mapping * @param id id * @param scriptType script type @@ -489,7 +489,7 @@ class tdme::tools::editor::tabviews::TextEditorTabView final * @param height height * @param createdNodeIds created node ids */ - void createMiniScriptScriptNode(unordered_map& idMapping, const string& id, MiniScript::Script::ScriptType scriptType, const string& condition, const string& readableName, const MiniScript::ScriptSyntaxTreeNode* conditionSyntaxTreeNode, int x, int y, int& width, int& height); + void createMiniScriptScriptNode(unordered_map& idMapping, const string& id, EngineMiniScript::Script::ScriptType scriptType, const string& condition, const string& readableName, const EngineMiniScript::ScriptSyntaxTreeNode* conditionSyntaxTreeNode, int x, int y, int& width, int& height); /** * Create UI nodes for given statement syntax tree, which matches a statement in miniscript @@ -506,7 +506,7 @@ class tdme::tools::editor::tabviews::TextEditorTabView final * @oaram createdNodeIds created node ids * @param depth depth */ - void createMiniScriptNodes(unordered_map& idMapping, const string& id, int syntaxTreeNodeIdx, int syntaxTreeNodeCount, const MiniScript::ScriptSyntaxTreeNode* syntaxTreeNode, Node::NodeType nodeType, int x, int y, int& width, int& height, vector& createdNodeIds, int depth = 0); + void createMiniScriptNodes(unordered_map& idMapping, const string& id, int syntaxTreeNodeIdx, int syntaxTreeNodeCount, const EngineMiniScript::ScriptSyntaxTreeNode* syntaxTreeNode, Node::NodeType nodeType, int x, int y, int& width, int& height, vector& createdNodeIds, int depth = 0); /** * Create UI nodes for branch nodes like if, elseif, else, end; forTime, end; forCondition, end @@ -524,10 +524,10 @@ class tdme::tools::editor::tabviews::TextEditorTabView final * @oaram createdNodeIds created node ids * @param depth depth */ - void createMiniScriptBranchNodes(unordered_map& idMapping, const string& id, int syntaxTreeNodeIdx, int syntaxTreeNodeCount, const MiniScript::ScriptSyntaxTreeNode* syntaxTreeNode, Node::NodeType nodeType, const vector& branches, int x, int y, int& width, int& height, vector& createdNodeIds, int depth = 0); + void createMiniScriptBranchNodes(unordered_map& idMapping, const string& id, int syntaxTreeNodeIdx, int syntaxTreeNodeCount, const EngineMiniScript::ScriptSyntaxTreeNode* syntaxTreeNode, Node::NodeType nodeType, const vector& branches, int x, int y, int& width, int& height, vector& createdNodeIds, int depth = 0); /** - * @return MiniScript script index + * @return EngineMiniScript script index */ inline int getMiniScriptScriptIdx() { return miniScriptScriptIdx; @@ -542,7 +542,7 @@ class tdme::tools::editor::tabviews::TextEditorTabView final } /** - * Handle MiniScript branch + * Handle EngineMiniScript branch * @param idMapping id mapping * @param idPrefix id prefix * @param syntaxTree syntax tree @@ -553,11 +553,11 @@ class tdme::tools::editor::tabviews::TextEditorTabView final * @param height height * @oaram createdNodeIds created node ids */ - bool handleMiniScriptBranch(unordered_map& idMapping, const string& idPrefix, const vector& syntaxTree, int& i, int x, int y, int& width, int& height, vector& createdNodeIds); + bool handleMiniScriptBranch(unordered_map& idMapping, const string& idPrefix, const vector& syntaxTree, int& i, int x, int y, int& width, int& height, vector& createdNodeIds); /** * Update miniscript syntax tree - * @param miniScriptScriptIdx MiniScript script index + * @param miniScriptScriptIdx EngineMiniScript script index */ void updateMiniScriptSyntaxTree(int miniScriptScriptIdx); diff --git a/src/tdme/utilities/EngineMiniScript.cpp b/src/tdme/utilities/EngineMiniScript.cpp new file mode 100644 index 000000000..46d22eb76 --- /dev/null +++ b/src/tdme/utilities/EngineMiniScript.cpp @@ -0,0 +1,144 @@ +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using tdme::utilities::EngineMiniScript; + +using std::make_unique; +using std::string; +using std::unique_ptr; +using std::vector; + +using tdme::engine::logics::LogicMiniScript; +using tdme::gui::scripting::GUIMiniScript; +using tdme::os::filesystem::FileSystem; +using tdme::os::filesystem::FileSystemInterface; +using tdme::utilities::Console; +using tdme::utilities::MiniScript; +using tdme::utilities::MiniScriptMatrix3x3; +using tdme::utilities::MiniScriptMatrix4x4; +using tdme::utilities::MiniScriptMatrix4x4; +using tdme::utilities::MiniScriptQuaternion; +using tdme::utilities::MiniScriptTransform; +using tdme::utilities::MiniScriptVector2; +using tdme::utilities::MiniScriptVector3; +using tdme::utilities::MiniScriptVector4; +using tdme::utilities::StringTools; + +void EngineMiniScript::registerDataTypes() { + // + registerDataType(new MiniScriptTransform()); + registerDataType(new MiniScriptMatrix4x4()); + registerDataType(new MiniScriptMatrix3x3()); + registerDataType(new MiniScriptQuaternion()); + registerDataType(new MiniScriptVector2()); + registerDataType(new MiniScriptVector3()); + registerDataType(new MiniScriptVector4()); +} + +EngineMiniScript* EngineMiniScript::loadScript(const string& pathName, const string& fileName) { + // we need to detect MiniScript variant + vector scriptAsStringArray; + try { + FileSystem::getInstance()->getContentAsStringArray(pathName, fileName, scriptAsStringArray); + } catch (Exception& exception) { + Console::println("MiniScript::loadScript(): An error occurred: " + string(exception.what())); + return nullptr; + } + + // detect MiniScript variant + auto logicMiniScript = false; + auto guiMiniScript = false; + array logicMiniScriptFunctions { + "updateEngine", + "updateLogic" + }; + array guiMiniScriptFunctions { + "onAction", + "onChange", + "onMouseOver", + "onContextMenuRequest", + "onFocus", + "onUnfocus", + "onMove", + "onMoveRelease", + "onTooltipShowRequest", + "onTooltipCloseRequest", + "onDragRequest", + "onTick" + }; + for (const auto& scriptLine: scriptAsStringArray) { + for (const auto& functionName: logicMiniScriptFunctions) { + if (StringTools::regexMatch(scriptLine, "^[\\s]*function:[\\s]*" + functionName + "[\\s]*\\(.*\\).*$") == true) { + logicMiniScript = true; + break; + } + } + if (logicMiniScript == true) break; + for (const auto& functionName: guiMiniScriptFunctions) { + if (StringTools::regexMatch(scriptLine, "^[\\s]*function:[\\s]*" + functionName + "[\\s]*\\(.*\\).*$") == true) { + guiMiniScript = true; + break; + } + } + if (guiMiniScript == true) break; + } + + // load specific MiniScript + unique_ptr scriptInstance; + if (logicMiniScript == true) { + scriptInstance = make_unique(); + scriptInstance->parseScript(pathName, fileName); + } else + if (guiMiniScript == true) { + scriptInstance = make_unique(nullptr); + scriptInstance->parseScript(pathName, fileName); + } else { + scriptInstance = make_unique(); + scriptInstance->parseScript(pathName, fileName); + } + // + return scriptInstance.release(); +} + +EngineMiniScript::EngineMiniScript(): MiniScript() { +} + +const string EngineMiniScript::getBaseClass() { + return "tdme::utilities::EngineMiniScript"; +} + +const vector EngineMiniScript::getTranspilationUnits() { + return { + "src/tdme/utilities/MiniScript.cpp", + "src/tdme/utilities/MiniScriptMath.cpp", + "src/tdme/utilities/MiniScriptMatrix3x3.cpp", + "src/tdme/utilities/MiniScriptMatrix4x4.cpp", + "src/tdme/utilities/MiniScriptQuaternion.cpp", + "src/tdme/utilities/MiniScriptTransform.cpp", + "src/tdme/utilities/MiniScriptTranspiler.cpp", + "src/tdme/utilities/MiniScriptVector2.cpp", + "src/tdme/utilities/MiniScriptVector3.cpp", + "src/tdme/utilities/MiniScriptVector4.cpp" + }; +} + diff --git a/src/tdme/utilities/EngineMiniScript.h b/src/tdme/utilities/EngineMiniScript.h new file mode 100644 index 000000000..57cd3db0b --- /dev/null +++ b/src/tdme/utilities/EngineMiniScript.h @@ -0,0 +1,313 @@ +#pragma once + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using std::span; +using std::string; +using std::unordered_map; +using std::unordered_set; +using std::vector; + +using tdme::utilities::EngineMiniScript; + +using tdme::engine::Transform; +using tdme::math::Matrix3x3; +using tdme::math::Matrix4x4; +using tdme::math::Matrix4x4; +using tdme::math::Quaternion; +using tdme::math::Vector2; +using tdme::math::Vector3; +using tdme::math::Vector4; +using tdme::utilities::MiniScriptMatrix3x3; +using tdme::utilities::MiniScriptMatrix4x4; +using tdme::utilities::MiniScriptMatrix4x4; +using tdme::utilities::MiniScriptQuaternion; +using tdme::utilities::MiniScriptTransform; +using tdme::utilities::MiniScriptVector2; +using tdme::utilities::MiniScriptVector3; +using tdme::utilities::MiniScriptVector4; + +using tdme::utilities::Console; +using tdme::utilities::MiniScript; + +/** + * Engine MiniScript + * @author Andreas Drewke + */ +class EngineMiniScript: public MiniScript { +public: + // forbid class copy + FORBID_CLASS_COPY(EngineMiniScript) + + // custom data types, which needs to be created in this particular order + // we could also read the types dynamically, but this works for now :) + static constexpr ScriptVariableType TYPE_TRANSFORM { static_cast(ScriptVariableType::TYPE_PSEUDO_CUSTOM_DATATYPES) }; + static constexpr ScriptVariableType TYPE_MATRIX4x4 { static_cast(ScriptVariableType::TYPE_PSEUDO_CUSTOM_DATATYPES + 1) }; + static constexpr ScriptVariableType TYPE_MATRIX3x3 { static_cast(ScriptVariableType::TYPE_PSEUDO_CUSTOM_DATATYPES + 2) }; + static constexpr ScriptVariableType TYPE_QUATERNION { static_cast(ScriptVariableType::TYPE_PSEUDO_CUSTOM_DATATYPES + 3) }; + static constexpr ScriptVariableType TYPE_VECTOR2 { static_cast(ScriptVariableType::TYPE_PSEUDO_CUSTOM_DATATYPES + 4) }; + static constexpr ScriptVariableType TYPE_VECTOR3 { static_cast(ScriptVariableType::TYPE_PSEUDO_CUSTOM_DATATYPES + 5) }; + static constexpr ScriptVariableType TYPE_VECTOR4 { static_cast(ScriptVariableType::TYPE_PSEUDO_CUSTOM_DATATYPES + 6) }; + + /** + * Register data types + */ + static void registerDataTypes(); + + /** + * Load script + * @param pathName path name + * @param fileName file name + */ + static EngineMiniScript* loadScript(const string& pathName, const string& fileName); + + /** + * Public constructor + */ + EngineMiniScript(); + + // overridden methods + const string getBaseClass(); + const vector getTranspilationUnits(); + + /** + * Get vector2 value from given variable + * @param arguments arguments + * @param idx argument index + * @param value value + * @param optional optional + * @return success + */ + inline bool getVector2Value(const span& arguments, int idx, Vector2& value, bool optional = false) { + return MiniScriptVector2::getVector2Value(TYPE_VECTOR2, arguments, idx, value, optional); + } + + /** + * Get vector3 value from given variable + * @param arguments arguments + * @param idx argument index + * @param value value + * @param optional optional + * @return success + */ + inline bool getVector3Value(const span& arguments, int idx, Vector3& value, bool optional = false) { + return MiniScriptVector3::getVector3Value(TYPE_VECTOR3, arguments, idx, value, optional); + } + + /** + * Get vector4 value from given variable + * @param arguments arguments + * @param idx argument index + * @param value value + * @param optional optional + * @return success + */ + inline bool getVector4Value(const span& arguments, int idx, Vector4& value, bool optional = false) { + return MiniScriptVector4::getVector4Value(TYPE_VECTOR4, arguments, idx, value, optional); + } + + /** + * Get vector4 value from given variable + * @param arguments arguments + * @param idx argument index + * @param value value + * @param optional optional + * @return success + */ + inline static bool getQuaternionValue(const span& arguments, int idx, Quaternion& value, bool optional = false) { + return MiniScriptQuaternion::getQuaternionValue(TYPE_QUATERNION, arguments, idx, value, optional); + } + + /** + * Get matrix3x3 value from given variable + * @param arguments arguments + * @param idx argument index + * @param value value + * @param optional optional + * @return success + */ + inline static bool getMatrix3x3Value(const span& arguments, int idx, Matrix3x3& value, bool optional = false) { + return MiniScriptMatrix3x3::getMatrix3x3Value(TYPE_MATRIX3x3, arguments, idx, value, optional); + } + + /** + * Get matrix4x4 value from given variable + * @param arguments arguments + * @param idx argument index + * @param value value + * @param optional optional + * @return success + */ + inline static bool getMatrix4x4Value(const span& arguments, int idx, Matrix4x4& value, bool optional = false) { + return MiniScriptMatrix4x4::getMatrix4x4Value(TYPE_MATRIX4x4, arguments, idx, value, optional); + } + + /** + * Get transform value from given variable + * @param arguments arguments + * @param idx argument index + * @param value value + * @param optional optional + * @return success + */ + inline static bool getTransformValue(const span& arguments, int idx, Transform& value, bool optional = false) { + return MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, arguments, idx, value, optional); + } + + /** + * Set boolean value from given value into variable + * @param variable variable + * @param value value + */ + inline void setValue(ScriptVariable& variable, bool value) { + variable.setValue(value); + } + + /** + * Set integer value from given value into variable + * @param variable variable + * @param value value + */ + inline void setValue(ScriptVariable& variable, int64_t value) { + variable.setValue(value); + } + + /** + * Set float value from given value into variable + * @param variable variable + * @param value value + */ + inline void setValue(ScriptVariable& variable, float value) { + variable.setValue(value); + } + + /** + * Set string value from given value into variable + * @param variable variable + * @param value value + */ + inline void setValue(ScriptVariable& variable, const string& value) { + variable.setValue(value); + } + + /** + * Set array value from given value into variable + * @param variable variable + * @param value value + */ + inline void setValue(ScriptVariable& variable, const vector& value) { + variable.setValue(value); + } + + /** + * Set map value from given value into variable + * @param variable variable + * @param value value + */ + inline void setValue(ScriptVariable& variable, const unordered_map& value) { + variable.setValue(value); + } + + /** + * Set set value from given value into variable + * @param variable variable + * @param value value + */ + inline void setValue(ScriptVariable& variable, const unordered_set& value) { + variable.setValue(value); + } + + /** + * Set vector2 value from given value into variable + * @param variable variable + * @param value value + */ + inline void setValue(ScriptVariable& variable, const Vector2& value) { + variable.setType(TYPE_VECTOR2); + variable.setValue(&value); + } + + /** + * Set vector3 value from given value into variable + * @param variable variable + * @param value value + */ + inline void setValue(ScriptVariable& variable, const Vector3& value) { + variable.setType(TYPE_VECTOR3); + variable.setValue(&value); + } + + /** + * Set vector3 value from given value into variable + * @param variable variable + * @param value value + */ + inline void setValue(ScriptVariable& variable, const Vector4& value) { + variable.setType(TYPE_VECTOR4); + variable.setValue(&value); + } + + /** + * Set vector3 value from given value into variable + * @param value value + */ + inline void setValue(ScriptVariable& variable, const Quaternion& value) { + variable.setType(TYPE_QUATERNION); + variable.setValue(&value); + } + + /** + * Set matrix3x3 value from given value into variable + * @param variable variable + * @param value value + */ + inline void setValue(ScriptVariable& variable, const Matrix3x3& value) { + variable.setType(TYPE_MATRIX3x3); + variable.setValue(&value); + } + + /** + * Set matrix4x4 value from given value into variable + * @param variable variable + * @param value value + */ + inline void setValue(ScriptVariable& variable, const Matrix4x4& value) { + variable.setType(TYPE_MATRIX4x4); + variable.setValue(&value); + } + + /** + * Set transform value from given value into variable + * @param variable variable + * @param value value + */ + inline void setValue(ScriptVariable& variable, const Transform& value) { + variable.setType(TYPE_TRANSFORM); + variable.setValue(&value); + } + +}; diff --git a/src/tdme/utilities/MiniScript.cpp b/src/tdme/utilities/MiniScript.cpp index f9fc25f43..7cbc38dc7 100644 --- a/src/tdme/utilities/MiniScript.cpp +++ b/src/tdme/utilities/MiniScript.cpp @@ -14,19 +14,8 @@ #include #include -#include -#include -#include -#include #include -#include #include -#include -#include -#include -#include -#include -#include #include #include #include @@ -58,19 +47,8 @@ using std::unordered_map; using std::unordered_set; using std::vector; -using tdme::engine::logics::LogicMiniScript; -using tdme::engine::model::RotationOrder; -using tdme::engine::Rotation; -using tdme::engine::Transform; using tdme::gui::GUIParser; -using tdme::gui::scripting::GUIMiniScript; using tdme::math::Math; -using tdme::math::Matrix3x3; -using tdme::math::Matrix4x4; -using tdme::math::Quaternion; -using tdme::math::Vector2; -using tdme::math::Vector3; -using tdme::math::Vector4; using tdme::os::filesystem::FileSystem; using tdme::os::filesystem::FileSystemException; using tdme::os::filesystem::FileSystemInterface; @@ -86,19 +64,13 @@ using tdme::utilities::SHA256; using tdme::utilities::Time; const string MiniScript::OPERATOR_CHARS = "+-!~/%<>=&^|"; +vector MiniScript::scriptDataTypes; const string MiniScript::METHOD_SCRIPTCALL = "script.call"; const string MiniScript::METHOD_ENABLENAMEDCONDITION = "script.enableNamedCondition"; const string MiniScript::METHOD_DISABLENAMEDCONDITION = "script.disableNamedCondition"; const string MiniScript::ScriptVariable::CLASSNAME_NONE = ""; const string MiniScript::ScriptVariable::CLASSNAME_STRING = "string"; -const string MiniScript::ScriptVariable::CLASSNAME_VEC2 = "vec2"; -const string MiniScript::ScriptVariable::CLASSNAME_VEC3 = "vec3"; -const string MiniScript::ScriptVariable::CLASSNAME_VEC4 = "vec4"; -const string MiniScript::ScriptVariable::CLASSNAME_QUATERNION = "quaternion"; -const string MiniScript::ScriptVariable::CLASSNAME_MAT3 = "mat3"; -const string MiniScript::ScriptVariable::CLASSNAME_MAT4 = "mat4"; -const string MiniScript::ScriptVariable::CLASSNAME_TRANSFORM = "transform"; const string MiniScript::ScriptVariable::CLASSNAME_ARRAY = "array"; const string MiniScript::ScriptVariable::CLASSNAME_MAP = "map"; const string MiniScript::ScriptVariable::CLASSNAME_SET = "set"; @@ -114,70 +86,6 @@ const vector MiniScript::ScriptMethod::CONTEXTFUNCTIONS_ENGINELOGIC = { }; const vector MiniScript::ScriptMethod::CONTEXTFUNCTION_GUI = {}; -MiniScript* MiniScript::loadScript(const string& pathName, const string& fileName) { - // we need to detect MiniScript variant - vector scriptAsStringArray; - try { - FileSystem::getInstance()->getContentAsStringArray(pathName, fileName, scriptAsStringArray); - } catch (Exception& exception) { - Console::println("MiniScript::loadScript(): An error occurred: " + string(exception.what())); - return nullptr; - } - - // detect MiniScript variant - auto logicMiniScript = false; - auto guiMiniScript = false; - array logicMiniScriptFunctions { - "updateEngine", - "updateLogic" - }; - array guiMiniScriptFunctions { - "onAction", - "onChange", - "onMouseOver", - "onContextMenuRequest", - "onFocus", - "onUnfocus", - "onMove", - "onMoveRelease", - "onTooltipShowRequest", - "onTooltipCloseRequest", - "onDragRequest", - "onTick" - }; - for (const auto& scriptLine: scriptAsStringArray) { - for (const auto& functionName: logicMiniScriptFunctions) { - if (StringTools::regexMatch(scriptLine, "^[\\s]*function:[\\s]*" + functionName + "[\\s]*\\(.*\\).*$") == true) { - logicMiniScript = true; - break; - } - } - if (logicMiniScript == true) break; - for (const auto& functionName: guiMiniScriptFunctions) { - if (StringTools::regexMatch(scriptLine, "^[\\s]*function:[\\s]*" + functionName + "[\\s]*\\(.*\\).*$") == true) { - guiMiniScript = true; - break; - } - } - if (guiMiniScript == true) break; - } - - // load specific MiniScript - unique_ptr scriptInstance; - if (logicMiniScript == true) { - scriptInstance = make_unique(); - scriptInstance->parseScript(pathName, fileName); - } else - if (guiMiniScript == true) { - scriptInstance = make_unique(nullptr); - scriptInstance->parseScript(pathName, fileName); - } else { - scriptInstance = make_unique(); - scriptInstance->parseScript(pathName, fileName); - } - // - return scriptInstance.release(); -} const string MiniScript::getBaseClass() { return "tdme::utilities::MiniScript"; @@ -225,8 +133,6 @@ void MiniScript::registerMethod(ScriptMethod* scriptMethod) { void MiniScript::registerDataType(ScriptDataType* scriptDataType) { scriptDataType->setType(TYPE_PSEUDO_CUSTOM_DATATYPES + scriptDataTypes.size()); scriptDataTypes.push_back(scriptDataType); - scriptDataType->registerMethods(this); - if (scriptDataType->hasMath() == true) miniScriptMath->registerDataType(scriptDataType); } void MiniScript::executeScriptLine() { @@ -600,68 +506,23 @@ MiniScript::ScriptVariable MiniScript::executeScriptStatement(const ScriptSyntax argumentOk = getFloatValue(argumentValues, argumentIdx, floatValue, argumentType.optional); } break; - case TYPE_STRING: - { - string stringValue; - argumentOk = getStringValue(argumentValues, argumentIdx, stringValue, argumentType.optional); - } - break; - case TYPE_VECTOR2: - { - argumentOk = - argumentIdx < 0 || argumentIdx >= argumentValues.size()? - argumentType.optional: - argumentValues[argumentIdx].getType() == TYPE_VECTOR2; - break; - } - case TYPE_VECTOR3: - { - argumentOk = - argumentIdx < 0 || argumentIdx >= argumentValues.size()? - argumentType.optional: - argumentValues[argumentIdx].getType() == TYPE_VECTOR3; - break; - } - case TYPE_VECTOR4: - { - argumentOk = - argumentIdx < 0 || argumentIdx >= argumentValues.size()? - argumentType.optional: - argumentValues[argumentIdx].getType() == TYPE_VECTOR4; - break; - } - case TYPE_QUATERNION: - { - argumentOk = - argumentIdx < 0 || argumentIdx >= argumentValues.size()? - argumentType.optional: - argumentValues[argumentIdx].getType() == TYPE_QUATERNION; - break; - } - case TYPE_MATRIX3x3: + case TYPE_PSEUDO_NUMBER: { - argumentOk = - argumentIdx < 0 || argumentIdx >= argumentValues.size()? - argumentType.optional: - argumentValues[argumentIdx].getType() == TYPE_MATRIX3x3; + float floatValue; + argumentOk = getFloatValue(argumentValues, argumentIdx, floatValue, argumentType.optional); break; } - case TYPE_MATRIX4x4: + case TYPE_PSEUDO_MIXED: { - argumentOk = - argumentIdx < 0 || argumentIdx >= argumentValues.size()? - argumentType.optional: - argumentValues[argumentIdx].getType() == TYPE_MATRIX4x4; + argumentOk = true; break; } - case TYPE_TRANSFORM: + case TYPE_STRING: { - argumentOk = - argumentIdx < 0 || argumentIdx >= argumentValues.size()? - argumentType.optional: - argumentValues[argumentIdx].getType() == TYPE_TRANSFORM; - break; + string stringValue; + argumentOk = getStringValue(argumentValues, argumentIdx, stringValue, argumentType.optional); } + break; case TYPE_ARRAY: { argumentOk = @@ -686,19 +547,23 @@ MiniScript::ScriptVariable MiniScript::executeScriptStatement(const ScriptSyntax argumentValues[argumentIdx].getType() == TYPE_SET; break; } - case TYPE_PSEUDO_NUMBER: + default: { - float floatValue; - argumentOk = getFloatValue(argumentValues, argumentIdx, floatValue, argumentType.optional); + // custom data types + argumentOk = + argumentIdx < 0 || argumentIdx >= argumentValues.size()? + argumentType.optional: + argumentValues[argumentIdx].getType() == argumentType.type; break; } + } } if (argumentOk == false) { Console::println( getStatementInformation(statement) + ": method '" + string(syntaxTree.value.getValueAsString()) + "'" + - ": argument value @ " + to_string(argumentIdx) + ": expected " + ScriptVariable::getTypeAsString(this, argumentType.type) + ", but got: " + (argumentIdx < argumentValues.size()?argumentValues[argumentIdx].getAsString():"nothing")); + ": argument value @ " + to_string(argumentIdx) + ": expected " + ScriptVariable::getTypeAsString(argumentType.type) + ", but got: " + (argumentIdx < argumentValues.size()?argumentValues[argumentIdx].getAsString():"nothing")); } argumentIdx++; } @@ -720,7 +585,7 @@ MiniScript::ScriptVariable MiniScript::executeScriptStatement(const ScriptSyntax Console::println( getStatementInformation(statement) + ": method '" + string(syntaxTree.value.getValueAsString()) + "'" + - ": return value: expected " + ScriptVariable::getReturnTypeAsString(this, scriptMethod->getReturnValueType(), scriptMethod->isReturnValueNullable()) + ", but got: " + ScriptVariable::getReturnTypeAsString(this, returnValue.getType(), false)); + ": return value: expected " + ScriptVariable::getReturnTypeAsString(scriptMethod->getReturnValueType(), scriptMethod->isReturnValueNullable()) + ", but got: " + ScriptVariable::getReturnTypeAsString(returnValue.getType(), false)); } // return returnValue; @@ -1488,7 +1353,7 @@ bool MiniScript::parseScriptInternal(const string& scriptCode) { for (const auto& argumentName: argumentNamesTokenized) { auto argumentNameTrimmed = StringTools::trim(argumentName); auto reference = false; - if (StringTools::startsWith(argumentNameTrimmed, "=") == true) { + if (StringTools::startsWith(argumentNameTrimmed, "&") == true) { reference = true; argumentNameTrimmed = StringTools::trim(StringTools::substring(argumentNameTrimmed, 1)); } @@ -2491,7 +2356,7 @@ const string MiniScript::getScriptInformation(int scriptIdx, bool includeStateme case Script::SCRIPTTYPE_FUNCTION: { for (const auto& argument: script.arguments) { if (argumentsString.empty() == false) argumentsString+= ", "; - if (argument.reference == true) argumentsString+= "="; + if (argument.reference == true) argumentsString+= "&"; argumentsString+= argument.name; } argumentsString = "(" + argumentsString + ")"; @@ -2551,9 +2416,9 @@ const string MiniScript::getInformation() { string method; method+= scriptMethod->getMethodName(); method+= "("; - method+= scriptMethod->getArgumentsInformation(this); + method+= scriptMethod->getArgumentsInformation(); method+= "): "; - method+= ScriptVariable::getReturnTypeAsString(this, scriptMethod->getReturnValueType(), scriptMethod->isReturnValueNullable()); + method+= ScriptVariable::getReturnTypeAsString(scriptMethod->getReturnValueType(), scriptMethod->isReturnValueNullable()); methods.push_back(method); } sort(methods.begin(), methods.end()); @@ -2571,9 +2436,9 @@ const string MiniScript::getInformation() { operatorString+= " --> "; operatorString+= scriptMethod->getMethodName(); operatorString+= "("; - operatorString+= scriptMethod->getArgumentsInformation(this); + operatorString+= scriptMethod->getArgumentsInformation(); operatorString+= "): "; - operatorString+= ScriptVariable::getReturnTypeAsString(this, scriptMethod->getReturnValueType(), scriptMethod->isReturnValueNullable()); + operatorString+= ScriptVariable::getReturnTypeAsString(scriptMethod->getReturnValueType(), scriptMethod->isReturnValueNullable()); operators.push_back(operatorString); } sort(operators.begin(), operators.end()); @@ -3760,2199 +3625,356 @@ void MiniScript::registerMethods() { }; registerMethod(new ScriptMethodLesserEquals(this)); } - // vector2 methods + // bool methods { // - class ScriptMethodVec2: public ScriptMethod { + class ScriptMethodBool: public ScriptMethod { private: MiniScript* miniScript { nullptr }; public: - ScriptMethodVec2(MiniScript* miniScript): + ScriptMethodBool(MiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_FLOAT, .name = "x", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "y", .optional = false, .reference = false, .nullable = false } + { .type = ScriptVariableType::TYPE_BOOLEAN, .name = "bool", .optional = false, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_VECTOR2 + ScriptVariableType::TYPE_BOOLEAN ), miniScript(miniScript) {} const string getMethodName() override { - return "vec2"; + return "bool"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 result; - float xValue; - float yValue; - if (MiniScript::getFloatValue(argumentValues, 0, xValue, false) == true && - MiniScript::getFloatValue(argumentValues, 1, yValue, false) == true) { - returnValue.setValue(Vector2(xValue, yValue)); + bool boolValue; + if (MiniScript::getBooleanValue(argumentValues, 0, boolValue, false) == true) { + returnValue.setValue(boolValue); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); + return; } } }; - registerMethod(new ScriptMethodVec2(this)); + registerMethod(new ScriptMethodBool(this)); } { // - class ScriptMethodVec2ComputeLength: public ScriptMethod { + class ScriptMethodNot: public ScriptMethod { private: MiniScript* miniScript { nullptr }; public: - ScriptMethodVec2ComputeLength(MiniScript* miniScript): + ScriptMethodNot(MiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR2, .name = "vec2", .optional = false, .reference = false, .nullable = false } + { .type = ScriptVariableType::TYPE_BOOLEAN, .name = "bool", .optional = false, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} + ScriptVariableType::TYPE_BOOLEAN), miniScript(miniScript) {} const string getMethodName() override { - return "vec2.computeLength"; + return "not"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector2 vec2; - if (MiniScript::getVector2Value(argumentValues, 0, vec2, false) == true) { - auto length = vec2.computeLength(); - returnValue.setValue(Float::isInfinite(length) == true || Float::isNaN(length) == true?0.0f:length); + bool booleanValue = false; + if (MiniScript::getBooleanValue(argumentValues, 0, booleanValue, false) == true) { + returnValue.setValue(!booleanValue); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); + return; } } + ScriptOperator getOperator() const override { + return OPERATOR_NOT; + } }; - registerMethod(new ScriptMethodVec2ComputeLength(this)); + registerMethod(new ScriptMethodNot(this)); } { // - class ScriptMethodVec2ComputeLengthSquared: public ScriptMethod { + class ScriptMethodAnd: public ScriptMethod { private: MiniScript* miniScript { nullptr }; public: - ScriptMethodVec2ComputeLengthSquared(MiniScript* miniScript): + ScriptMethodAnd(MiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR2, .name = "vec2", .optional = false, .reference = false, .nullable = false } + { .type = ScriptVariableType::TYPE_BOOLEAN, .name = "a", .optional = false, .reference = false, .nullable = false }, + { .type = ScriptVariableType::TYPE_BOOLEAN, .name = "b", .optional = false, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} + ScriptVariableType::TYPE_BOOLEAN + ), + miniScript(miniScript) {} const string getMethodName() override { - return "vec2.computeLengthSquared"; + return "and"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector2 vec2; - if (MiniScript::getVector2Value(argumentValues, 0, vec2, false) == true) { - returnValue.setValue(vec2.computeLengthSquared()); - } else { + if (argumentValues.size() != 2) { + returnValue.setValue(false); Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); + } else { + returnValue.setValue(true); + for (auto i = 0; i < argumentValues.size(); i++) { + bool booleanValue; + if (MiniScript::getBooleanValue(argumentValues, i, booleanValue, false) == false) { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } else + if (booleanValue == false) { + returnValue.setValue(false); + break; + } + } } } + ScriptOperator getOperator() const override { + return OPERATOR_AND; + } }; - registerMethod(new ScriptMethodVec2ComputeLengthSquared(this)); + registerMethod(new ScriptMethodAnd(this)); } { // - class ScriptMethodVec2ComputeDotProduct: public ScriptMethod { + class ScriptMethodOr: public ScriptMethod { private: MiniScript* miniScript { nullptr }; public: - ScriptMethodVec2ComputeDotProduct(MiniScript* miniScript): + ScriptMethodOr(MiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR2, .name = "a", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR2, .name = "b", .optional = false, .reference = false, .nullable = false } + { .type = ScriptVariableType::TYPE_BOOLEAN, .name = "a", .optional = false, .reference = false, .nullable = false }, + { .type = ScriptVariableType::TYPE_BOOLEAN, .name = "b", .optional = false, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} + ScriptVariableType::TYPE_BOOLEAN + ), + miniScript(miniScript) {} const string getMethodName() override { - return "vec2.computeDotProduct"; + return "or"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector2 a; - Vector2 b; - if (MiniScript::getVector2Value(argumentValues, 0, a, false) == true && - MiniScript::getVector2Value(argumentValues, 1, b, false) == true) { - returnValue.setValue(Vector2::computeDotProduct(a, b)); - } else { + if (argumentValues.size() != 2) { + returnValue.setValue(false); Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); + } else { + returnValue.setValue(false); + for (auto i = 0; i < argumentValues.size(); i++) { + bool booleanValue; + if (MiniScript::getBooleanValue(argumentValues, i, booleanValue, false) == false) { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } else + if (booleanValue == true) { + returnValue.setValue(true); + break; + } + } } } + ScriptOperator getOperator() const override { + return OPERATOR_OR; + } }; - registerMethod(new ScriptMethodVec2ComputeDotProduct(this)); + registerMethod(new ScriptMethodOr(this)); } + // string functions { // - class ScriptMethodVec2Normalize: public ScriptMethod { + class ScriptMethodString: public ScriptMethod { private: MiniScript* miniScript { nullptr }; public: - ScriptMethodVec2Normalize(MiniScript* miniScript): + ScriptMethodString(MiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR2, .name = "vec2", .optional = false, .reference = false, .nullable = false }, + { .type = ScriptVariableType::TYPE_STRING, .name = "string", .optional = false, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_VECTOR2), - miniScript(miniScript) {} + ScriptVariableType::TYPE_STRING + ), + miniScript(miniScript) {} const string getMethodName() override { - return "vec2.normalize"; + return "string"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector2 vec2; - if (MiniScript::getVector2Value(argumentValues, 0, vec2, false) == true) { - auto length = vec2.computeLength(); - returnValue.setValue(length < Math::EPSILON || Float::isInfinite(length) == true || Float::isNaN(length) == true?Vector2(0.0f, 0.0f):vec2.normalize()); + string stringValue; + if (MiniScript::getStringValue(argumentValues, 0, stringValue, false) == true) { + returnValue.setValue(stringValue); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } } }; - registerMethod(new ScriptMethodVec2Normalize(this)); + registerMethod(new ScriptMethodString(this)); } { // - class ScriptMethodVec2GetX: public ScriptMethod { + class ScriptMethodStringLength: public ScriptMethod { private: MiniScript* miniScript { nullptr }; public: - ScriptMethodVec2GetX(MiniScript* miniScript): + ScriptMethodStringLength(MiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR2, .name = "vec2", .optional = false, .reference = false, .nullable = false }, + { .type = ScriptVariableType::TYPE_STRING, .name = "string", .optional = false, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} + ScriptVariableType::TYPE_INTEGER + ), + miniScript(miniScript) {} const string getMethodName() override { - return "vec2.getX"; + return "string.length"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector2 vec2; - if (MiniScript::getVector2Value(argumentValues, 0, vec2, false) == true) { - returnValue.setValue(vec2.getX()); + string stringValue; + if (MiniScript::getStringValue(argumentValues, 0, stringValue, false) == true) { + returnValue.setValue(static_cast(stringValue.size())); } else { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); } } }; - registerMethod(new ScriptMethodVec2GetX(this)); + registerMethod(new ScriptMethodStringLength(this)); } { // - class ScriptMethodVec2GetY: public ScriptMethod { + class ScriptMethodStringCharAt: public ScriptMethod { private: MiniScript* miniScript { nullptr }; public: - ScriptMethodVec2GetY(MiniScript* miniScript): + ScriptMethodStringCharAt(MiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR2, .name = "vec2", .optional = false, .reference = false, .nullable = false }, + { .type = ScriptVariableType::TYPE_STRING, .name = "string", .optional = false, .reference = false, .nullable = false }, + { .type = ScriptVariableType::TYPE_INTEGER, .name = "index", .optional = false, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} + ScriptVariableType::TYPE_STRING + ), + miniScript(miniScript) {} const string getMethodName() override { - return "vec2.getY"; + return "string.charAt"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector2 vec2; - if (MiniScript::getVector2Value(argumentValues, 0, vec2, false) == true) { - returnValue.setValue(vec2.getY()); - } else { + string stringValue; + int64_t index; + if (MiniScript::getStringValue(argumentValues, 0, stringValue, false) == false || + MiniScript::getIntegerValue(argumentValues, 1, index, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); + } else { + returnValue.setValue(index >= 0 && index < stringValue.size()?string(&stringValue[index], 1):string()); } } }; - registerMethod(new ScriptMethodVec2GetY(this)); + registerMethod(new ScriptMethodStringCharAt(this)); } - // vector3 methods { // - class ScriptMethodVec3: public ScriptMethod { + class ScriptMethodStringStartsWith: public ScriptMethod { private: MiniScript* miniScript { nullptr }; public: - ScriptMethodVec3(MiniScript* miniScript): + ScriptMethodStringStartsWith(MiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_FLOAT, .name = "x", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "y", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "z", .optional = false, .reference = false, .nullable = false } + { .type = ScriptVariableType::TYPE_STRING, .name = "string", .optional = false, .reference = false, .nullable = false }, + { .type = ScriptVariableType::TYPE_STRING, .name = "prefix", .optional = false, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_VECTOR3 + ScriptVariableType::TYPE_BOOLEAN ), miniScript(miniScript) {} const string getMethodName() override { - return "vec3"; + return "string.startsWith"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 result; - float xValue; - float yValue; - float zValue; - if (MiniScript::getFloatValue(argumentValues, 0, xValue, false) == true && - MiniScript::getFloatValue(argumentValues, 1, yValue, false) == true && - MiniScript::getFloatValue(argumentValues, 2, zValue, false) == true) { - returnValue.setValue(Vector3(xValue, yValue, zValue)); - } else { + string stringValue; + string prefix; + if (MiniScript::getStringValue(argumentValues, 0, stringValue, false) == false || + MiniScript::getStringValue(argumentValues, 1, prefix, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); + } else { + returnValue.setValue(StringTools::startsWith(stringValue, prefix)); } } }; - registerMethod(new ScriptMethodVec3(this)); + registerMethod(new ScriptMethodStringStartsWith(this)); } { // - class ScriptMethodVec3ComputeLength: public ScriptMethod { + class ScriptMethodStringEndsWith: public ScriptMethod { private: MiniScript* miniScript { nullptr }; public: - ScriptMethodVec3ComputeLength(MiniScript* miniScript): + ScriptMethodStringEndsWith(MiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false } + { .type = ScriptVariableType::TYPE_STRING, .name = "string", .optional = false, .reference = false, .nullable = false }, + { .type = ScriptVariableType::TYPE_STRING, .name = "suffix", .optional = false, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} + ScriptVariableType::TYPE_BOOLEAN + ), + miniScript(miniScript) {} const string getMethodName() override { - return "vec3.computeLength"; + return "string.endsWith"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 vec3; - if (MiniScript::getVector3Value(argumentValues, 0, vec3, false) == true) { - auto length = vec3.computeLength(); - returnValue.setValue(Float::isInfinite(length) == true || Float::isNaN(length) == true?0.0f:length); - } else { + string stringValue; + string suffix; + if (MiniScript::getStringValue(argumentValues, 0, stringValue, false) == false || + MiniScript::getStringValue(argumentValues, 1, suffix, false) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); + } else { + returnValue.setValue(StringTools::endsWith(stringValue, suffix)); } } }; - registerMethod(new ScriptMethodVec3ComputeLength(this)); + registerMethod(new ScriptMethodStringEndsWith(this)); } { // - class ScriptMethodVec3ComputeLengthSquared: public ScriptMethod { + class ScriptMethodStringReplace: public ScriptMethod { private: MiniScript* miniScript { nullptr }; public: - ScriptMethodVec3ComputeLengthSquared(MiniScript* miniScript): + ScriptMethodStringReplace(MiniScript* miniScript): ScriptMethod( { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false } + { .type = ScriptVariableType::TYPE_STRING, .name = "string", .optional = false, .reference = false, .nullable = false }, + { .type = ScriptVariableType::TYPE_STRING, .name = "what", .optional = false, .reference = false, .nullable = false }, + { .type = ScriptVariableType::TYPE_STRING, .name = "by", .optional = false, .reference = false, .nullable = false }, + { .type = ScriptVariableType::TYPE_INTEGER, .name = "beginIndex", .optional = true, .reference = false, .nullable = false } }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} + ScriptVariableType::TYPE_STRING + ), + miniScript(miniScript) {} const string getMethodName() override { - return "vec3.computeLengthSquared"; + return "string.replace"; } void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 vec3; - if (MiniScript::getVector3Value(argumentValues, 0, vec3, false) == true) { - returnValue.setValue(vec3.computeLengthSquared()); - } else { + string stringValue; + string what; + string by; + int64_t beginIndex = 0; + if (MiniScript::getStringValue(argumentValues, 0, stringValue, false) == false || + MiniScript::getStringValue(argumentValues, 1, what, false) == false || + MiniScript::getStringValue(argumentValues, 2, by, false) == false || + MiniScript::getIntegerValue(argumentValues, 3, beginIndex, true) == false) { Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); miniScript->startErrorScript(); + } else { + returnValue.setValue(StringTools::replace(stringValue, what, by, beginIndex)); } } }; - registerMethod(new ScriptMethodVec3ComputeLengthSquared(this)); + registerMethod(new ScriptMethodStringReplace(this)); } { // - class ScriptMethodVec3ComputeDotProduct: public ScriptMethod { + class ScriptMethodStringIndexOf: public ScriptMethod { private: MiniScript* miniScript { nullptr }; public: - ScriptMethodVec3ComputeDotProduct(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "a", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "b", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec3.computeDotProduct"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 a; - Vector3 b; - if (MiniScript::getVector3Value(argumentValues, 0, a, false) == true && - MiniScript::getVector3Value(argumentValues, 1, b, false) == true) { - returnValue.setValue(Vector3::computeDotProduct(a, b)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec3ComputeDotProduct(this)); - } - { - // - class ScriptMethodVec3ComputeCrossProduct: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodVec3ComputeCrossProduct(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "a", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "b", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_VECTOR3), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec3.computeCrossProduct"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 a; - Vector3 b; - if (MiniScript::getVector3Value(argumentValues, 0, a, false) == true && - MiniScript::getVector3Value(argumentValues, 1, b, false) == true) { - returnValue.setValue(Vector3::computeCrossProduct(a, b)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec3ComputeCrossProduct(this)); - } - { - // - class ScriptMethodVec3Normalize: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodVec3Normalize(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_VECTOR3), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec3.normalize"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 vec3; - if (MiniScript::getVector3Value(argumentValues, 0, vec3, false) == true) { - auto length = vec3.computeLength(); - returnValue.setValue(length < Math::EPSILON || Float::isInfinite(length) == true || Float::isNaN(length) == true?Vector3(0.0f, 0.0f, 0.0f):vec3.normalize()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec3Normalize(this)); - } - { - // - class ScriptMethodVec3ComputeAngle: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodVec3ComputeAngle(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "a", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "b", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "n", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec3.computeAngle"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 a; - Vector3 b; - Vector3 n; - if (MiniScript::getVector3Value(argumentValues, 0, a, false) == true && - MiniScript::getVector3Value(argumentValues, 1, b, false) == true && - MiniScript::getVector3Value(argumentValues, 2, n, false) == true) { - returnValue.setValue(Vector3::computeAngle(a, b, n)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec3ComputeAngle(this)); - } - { - // - class ScriptMethodVec3GetX: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodVec3GetX(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec3.getX"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 vec3; - if (MiniScript::getVector3Value(argumentValues, 0, vec3, false) == true) { - returnValue.setValue(vec3.getX()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec3GetX(this)); - } - { - // - class ScriptMethodVec3GetY: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodVec3GetY(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec3.getY"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 vec3; - if (MiniScript::getVector3Value(argumentValues, 0, vec3, false) == true) { - returnValue.setValue(vec3.getY()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec3GetY(this)); - } - { - // - class ScriptMethodVec3GetZ: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodVec3GetZ(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec3.getZ"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 vec3; - if (MiniScript::getVector3Value(argumentValues, 0, vec3, false) == true) { - returnValue.setValue(vec3.getZ()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec3GetZ(this)); - } - // vector4 methods - { - // - class ScriptMethodVec4: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodVec4(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_FLOAT, .name = "x", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "y", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "z", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "w", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_VECTOR4 - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec4"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 result; - float xValue; - float yValue; - float zValue; - float wValue; - if (MiniScript::getFloatValue(argumentValues, 0, xValue, false) == true && - MiniScript::getFloatValue(argumentValues, 1, yValue, false) == true && - MiniScript::getFloatValue(argumentValues, 2, zValue, false) == true && - MiniScript::getFloatValue(argumentValues, 3, wValue, false) == true) { - returnValue.setValue(Vector4(xValue, yValue, zValue, wValue)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec4(this)); - } - { - // - class ScriptMethodVec4ComputeLength: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodVec4ComputeLength(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR4, .name = "vec4", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec4.computeLength"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector4 vec4; - if (MiniScript::getVector4Value(argumentValues, 0, vec4, false) == true) { - auto length = vec4.computeLength(); - returnValue.setValue(Float::isInfinite(length) == true || Float::isNaN(length) == true?0.0f:length); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec4ComputeLength(this)); - } - { - // - class ScriptMethodVec4ComputeLengthSquared: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodVec4ComputeLengthSquared(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR4, .name = "vec4", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec4.computeLengthSquared"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector4 vec4; - if (MiniScript::getVector4Value(argumentValues, 0, vec4, false) == true) { - returnValue.setValue(vec4.computeLengthSquared()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec4ComputeLengthSquared(this)); - } - { - // - class ScriptMethodVec4ComputeDotProduct: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodVec4ComputeDotProduct(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR4, .name = "a", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR4, .name = "b", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec4.computeDotProduct"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector4 a; - Vector4 b; - if (MiniScript::getVector4Value(argumentValues, 0, a, false) == true && - MiniScript::getVector4Value(argumentValues, 1, b, false) == true) { - returnValue.setValue(Vector4::computeDotProduct(a, b)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec4ComputeDotProduct(this)); - } - { - // - class ScriptMethodVec4Normalize: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodVec4Normalize(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR4, .name = "vec4", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_VECTOR4), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec4.normalize"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector4 vec4; - if (MiniScript::getVector4Value(argumentValues, 0, vec4, false) == true) { - auto length = vec4.computeLength(); - returnValue.setValue(length < Math::EPSILON || Float::isInfinite(length) == true || Float::isNaN(length) == true?Vector4(0.0f, 0.0f, 0.0f, 0.0f):vec4.normalize()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec4Normalize(this)); - } - { - // - class ScriptMethodVec4GetX: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodVec4GetX(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR4, .name = "vec4", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec4.getX"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector4 vec4; - if (MiniScript::getVector4Value(argumentValues, 0, vec4, false) == true) { - returnValue.setValue(vec4.getX()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec4GetX(this)); - } - { - // - class ScriptMethodVec4GetY: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodVec4GetY(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR4, .name = "vec4", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec4.getY"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector4 vec4; - if (MiniScript::getVector4Value(argumentValues, 0, vec4, false) == true) { - returnValue.setValue(vec4.getY()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec4GetY(this)); - } - { - // - class ScriptMethodVec4GetZ: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodVec4GetZ(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR4, .name = "vec4", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec4.getZ"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector4 vec4; - if (MiniScript::getVector4Value(argumentValues, 0, vec4, false) == true) { - returnValue.setValue(vec4.getZ()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec4GetZ(this)); - } - { - // - class ScriptMethodVec4GetW: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodVec4GetW(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR4, .name = "vec4", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} - const string getMethodName() override { - return "vec4.getW"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector4 vec4; - if (MiniScript::getVector4Value(argumentValues, 0, vec4, false) == true) { - returnValue.setValue(vec4.getW()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodVec4GetW(this)); - } - // quaternion methods - { - // - class ScriptMethodQuaternionIdentity: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodQuaternionIdentity(MiniScript* miniScript): - ScriptMethod({}, ScriptVariableType::TYPE_QUATERNION), - miniScript(miniScript) {} - const string getMethodName() override { - return "quaternion.identity"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(Quaternion().identity()); - } - }; - registerMethod(new ScriptMethodQuaternionIdentity(this)); - } - { - // - class ScriptMethodQuaternionInvert: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodQuaternionInvert(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_QUATERNION, .name = "quaternion", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_QUATERNION - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "quaternion.invert"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Quaternion quaternion; - if (MiniScript::getQuaternionValue(argumentValues, 0, quaternion, false) == true) { - returnValue.setValue(quaternion.invert()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodQuaternionInvert(this)); - } - { - // - class ScriptMethodQuaternionRotate: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodQuaternionRotate(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "axis", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_QUATERNION - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "quaternion.rotate"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 axis; - float angle; - if (MiniScript::getVector3Value(argumentValues, 0, axis, false) == true && - MiniScript::getFloatValue(argumentValues, 1, angle, false) == true) { - returnValue.setValue(Quaternion().rotate(axis, angle)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodQuaternionRotate(this)); - } - { - // - class ScriptMethodQuaternionNormalize: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodQuaternionNormalize(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_QUATERNION, .name = "quaternion", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_QUATERNION - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "quaternion.normalize"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Quaternion quaternion; - if (MiniScript::getQuaternionValue(argumentValues, 0, quaternion, false) == true) { - returnValue.setValue(quaternion.normalize()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodQuaternionNormalize(this)); - } - { - // - class ScriptMethodQuaternionInvert: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodQuaternionInvert(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_QUATERNION, .name = "quaternion", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_VECTOR3 - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "quaternion.computeEulerAngles"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Quaternion quaternion; - if (MiniScript::getQuaternionValue(argumentValues, 0, quaternion, false) == true) { - returnValue.setValue(quaternion.computeEulerAngles()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodQuaternionInvert(this)); - } - { - // - class ScriptMethodQuaternionComputeMatrix: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodQuaternionComputeMatrix(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_QUATERNION, .name = "quaternion", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_MATRIX4x4 - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "quaternion.computeMatrix"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Quaternion quaternion; - if (MiniScript::getQuaternionValue(argumentValues, 0, quaternion, false) == true) { - returnValue.setValue(quaternion.computeMatrix()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodQuaternionComputeMatrix(this)); - } - // matrix3x3 methods - { - // - class ScriptMethodMatrix3x3Identity: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodMatrix3x3Identity(MiniScript* miniScript): - ScriptMethod({}, ScriptVariableType::TYPE_MATRIX3x3), - miniScript(miniScript) {} - const string getMethodName() override { - return "mat3.identity"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(Matrix3x3().identity()); - } - }; - registerMethod(new ScriptMethodMatrix3x3Identity(this)); - } - { - // - class ScriptMethodMatrix3x3Translate: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodMatrix3x3Translate(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR2, .name = "translation", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_MATRIX3x3 - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "mat3.translate"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector2 translation; - if (MiniScript::getVector2Value(argumentValues, 0, translation, false) == true) { - returnValue.setValue(Matrix3x3().identity().setTranslation(translation)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodMatrix3x3Translate(this)); - } - { - // - class ScriptMethodMatrix3x3Rotate: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodMatrix3x3Rotate(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_MATRIX3x3 - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "mat3.rotate"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - float angle; - if (MiniScript::getFloatValue(argumentValues, 0, angle, false) == true) { - returnValue.setValue(Matrix3x3().identity().setAxes(angle)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodMatrix3x3Rotate(this)); - } - { - // - class ScriptMethodMatrix3x3RotateAroundTextureCenter: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodMatrix3x3RotateAroundTextureCenter(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_MATRIX3x3 - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "mat3.rotateAroundTextureCenter"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - float angle; - if (MiniScript::getFloatValue(argumentValues, 0, angle, false) == true) { - returnValue.setValue(Matrix3x3::rotateAroundTextureCenter(angle)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodMatrix3x3RotateAroundTextureCenter(this)); - } - { - // - class ScriptMethodMatrix3x3RotateAroundPoint: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodMatrix3x3RotateAroundPoint(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR2, .name = "point", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_MATRIX3x3 - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "mat3.rotateAroundPoint"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector2 point; - float angle; - if (MiniScript::getVector2Value(argumentValues, 0, point, false) == true && - MiniScript::getFloatValue(argumentValues, 1, angle, false) == true) { - returnValue.setValue(Matrix3x3().rotateAroundPoint(point, angle)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodMatrix3x3RotateAroundPoint(this)); - } - { - // - class ScriptMethodMatrix3x3Scale: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodMatrix3x3Scale(MiniScript* miniScript): - ScriptMethod({}, ScriptVariableType::TYPE_MATRIX3x3), - miniScript(miniScript) {} - const string getMethodName() override { - return "mat3.scale"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector2 vec2Value; - float floatValue; - if (MiniScript::getVector2Value(argumentValues, 0, vec2Value, false) == true) { - returnValue.setValue(Matrix3x3().identity().scale(vec2Value)); - } else - if (MiniScript::getFloatValue(argumentValues, 0, floatValue, false) == true) { - returnValue.setValue(Matrix3x3().identity().scale(floatValue)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - bool isVariadic() const override { - return true; - } - - }; - registerMethod(new ScriptMethodMatrix3x3Scale(this)); - } - // matrix4x4 methods - { - // - class ScriptMethodMatrix4x4Identity: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodMatrix4x4Identity(MiniScript* miniScript): - ScriptMethod({}, ScriptVariableType::TYPE_MATRIX4x4), - miniScript(miniScript) {} - const string getMethodName() override { - return "mat4.identity"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(Matrix4x4().identity()); - } - }; - registerMethod(new ScriptMethodMatrix4x4Identity(this)); - } - { - // - class ScriptMethodMatrix4x4Translate: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodMatrix4x4Translate(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "translation", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_MATRIX4x4 - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "mat4.translate"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 translation; - if (MiniScript::getVector3Value(argumentValues, 0, translation, false) == true) { - returnValue.setValue(Matrix4x4().identity().setTranslation(translation)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodMatrix4x4Translate(this)); - } - { - // - class ScriptMethodMatrix4x4Rotate: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodMatrix4x4Rotate(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "axis", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_MATRIX4x4 - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "mat4.rotate"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 axis; - float angle; - if (MiniScript::getVector3Value(argumentValues, 0, axis, false) == true && - MiniScript::getFloatValue(argumentValues, 1, angle, false) == true) { - returnValue.setValue(Matrix4x4().identity().setAxes(axis, angle)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodMatrix4x4Rotate(this)); - } - { - // - class ScriptMethodMatrix4x4Scale: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodMatrix4x4Scale(MiniScript* miniScript): - ScriptMethod({}, ScriptVariableType::TYPE_MATRIX4x4), - miniScript(miniScript) {} - const string getMethodName() override { - return "mat4.scale"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Vector3 vec3Value; - float floatValue; - if (MiniScript::getVector3Value(argumentValues, 0, vec3Value, false) == true) { - returnValue.setValue(Matrix4x4().identity().scale(vec3Value)); - } else - if (MiniScript::getFloatValue(argumentValues, 0, floatValue, false) == true) { - returnValue.setValue(Matrix4x4().identity().scale(floatValue)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - bool isVariadic() const override { - return true; - } - - }; - registerMethod(new ScriptMethodMatrix4x4Scale(this)); - } - { - // - class ScriptMethodMatrix4x4Invert: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodMatrix4x4Invert(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_MATRIX4x4, .name = "mat4", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_MATRIX4x4 - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "mat4.invert"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Matrix4x4 mat4; - if (MiniScript::getMatrix4x4Value(argumentValues, 0, mat4, false) == true) { - returnValue.setValue(mat4.invert()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodMatrix4x4Invert(this)); - } - { - // - class ScriptMethodMatrix4x4EulerAngles: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodMatrix4x4EulerAngles(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_MATRIX4x4, .name = "mat4", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_VECTOR3 - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "mat4.computeEulerAngles"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Matrix4x4 mat4; - if (MiniScript::getMatrix4x4Value(argumentValues, 0, mat4, false) == true) { - returnValue.setValue(mat4.computeEulerAngles()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodMatrix4x4EulerAngles(this)); - } - // transform - { - // - class ScriptMethodTransformAxisZ: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformAxisZ(MiniScript* miniScript): - ScriptMethod({}, ScriptVariableType::TYPE_VECTOR3), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.AXIS_Z"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(Vector3(0.0f, 0.0f, 1.0f)); - } - }; - registerMethod(new ScriptMethodTransformAxisZ(this)); - } - { - // - class ScriptMethodTransformAxisY: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformAxisY(MiniScript* miniScript): - ScriptMethod({}, ScriptVariableType::TYPE_VECTOR3), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.AXIS_Y"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(Vector3(0.0f, 1.0f, 0.0f)); - } - }; - registerMethod(new ScriptMethodTransformAxisY(this)); - } - { - // - class ScriptMethodTransformAxisX: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformAxisX(MiniScript* miniScript): - ScriptMethod({}, ScriptVariableType::TYPE_VECTOR3), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.AXIS_X"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - returnValue.setValue(Vector3(1.0f, 0.0f, 0.0f)); - } - }; - registerMethod(new ScriptMethodTransformAxisX(this)); - } - { - // - class ScriptMethodTransform: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransform(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "translation", .optional = true, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "scale", .optional = true, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "rotationZ", .optional = true, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "rotationY", .optional = true, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "rotationX", .optional = true, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_TRANSFORM), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Transform transform; - Vector3 vec3Value; - float floatValue; - // translation - if (argumentValues.size() >= 1) { - if (MiniScript::getVector3Value(argumentValues, 0, vec3Value, true) == true) { - transform.setTranslation(vec3Value); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - // scale - if (argumentValues.size() >= 2) { - if (MiniScript::getVector3Value(argumentValues, 1, vec3Value, true) == true) { - transform.setScale(vec3Value); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - // rotations: we always use euler angles here - transform.addRotation(Vector3(0.0f, 0.0f, 1.0f), 0.0f); - transform.addRotation(Vector3(0.0f, 1.0f, 0.0f), 0.0f); - transform.addRotation(Vector3(1.0f, 0.0f, 0.0f), 0.0f); - // - for (auto i = 2; i < argumentValues.size() && i < 5; i++) { - if (MiniScript::getFloatValue(argumentValues, i, floatValue, true) == true) { - transform.setRotationAngle(i - 2, floatValue); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - transform.update(); - returnValue.setValue(transform); - } - }; - registerMethod(new ScriptMethodTransform(this)); - } - { - // - class ScriptMethodTransformGetTranslation: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformGetTranslation(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_VECTOR3), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.getTranslation"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Transform transform; - if (MiniScript::getTransformValue(argumentValues, 0, transform, false) == true) { - returnValue.setValue(transform.getTranslation()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodTransformGetTranslation(this)); - } - { - // - class ScriptMethodTransformSetTranslation: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformSetTranslation(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = true, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "translation", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_NULL), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.setTranslation"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Transform transform; - Vector3 translation; - if (MiniScript::getTransformValue(argumentValues, 0, transform, false) == true && - MiniScript::getVector3Value(argumentValues, 1, translation, false) == true) { - transform.setTranslation(translation); - transform.update(); - argumentValues[0].setValue(transform); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodTransformSetTranslation(this)); - } - { - // - class ScriptMethodTransformGetScale: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformGetScale(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_VECTOR3), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.getScale"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Transform transform; - if (MiniScript::getTransformValue(argumentValues, 0, transform, false) == true) { - returnValue.setValue(transform.getScale()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodTransformGetScale(this)); - } - { - // - class ScriptMethodTransformSetScale: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformSetScale(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = true, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "scale", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_NULL), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.setScale"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Transform transform; - Vector3 scale; - if (MiniScript::getTransformValue(argumentValues, 0, transform, false) == true && - MiniScript::getVector3Value(argumentValues, 1, scale, false) == true) { - transform.setScale(scale); - transform.update(); - argumentValues[0].setValue(transform); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodTransformSetScale(this)); - } - { - // - class ScriptMethodTransformGetRotationAxis: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformGetRotationAxis(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_INTEGER, .name = "idx", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_VECTOR3), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.getRotationAxis"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - int64_t idx; - Transform transform; - if (MiniScript::getTransformValue(argumentValues, 0, transform, false) == true && - MiniScript::getIntegerValue(argumentValues, 1, idx, false) == true) { - if (idx < transform.getRotationCount()) { - returnValue.setValue(transform.getRotationAxis(idx)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": rotation index invalid: " + to_string(idx) + " / " + to_string(transform.getRotationCount())); - miniScript->startErrorScript(); - } - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodTransformGetRotationAxis(this)); - } - { - // - class ScriptMethodTransformGetRotationAngle: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformGetRotationAngle(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_INTEGER, .name = "idx", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_FLOAT), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.getRotationAngle"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - int64_t idx; - Transform transform; - if (MiniScript::getTransformValue(argumentValues, 0, transform, false) == true && - MiniScript::getIntegerValue(argumentValues, 1, idx, false) == true) { - if (idx < transform.getRotationCount()) { - returnValue.setValue(transform.getRotationAngle(idx)); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": rotation index invalid: " + to_string(idx) + " / " + to_string(transform.getRotationCount())); - miniScript->startErrorScript(); - } - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodTransformGetRotationAngle(this)); - } - { - // - class ScriptMethodTransformSetRotationAngle: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformSetRotationAngle(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = true, .nullable = false }, - { .type = ScriptVariableType::TYPE_INTEGER, .name = "idx", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_NULL), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.setRotationAngle"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - int64_t idx; - Transform transform; - float angle; - if (MiniScript::getTransformValue(argumentValues, 0, transform, false) == true && - MiniScript::getIntegerValue(argumentValues, 1, idx, false) == true && - MiniScript::getFloatValue(argumentValues, 2, angle, false) == true) { - if (idx < transform.getRotationCount()) { - transform.setRotationAngle(idx, angle); - transform.update(); - argumentValues[0].setValue(transform); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": rotation index invalid: " + to_string(idx) + " / " + to_string(transform.getRotationCount())); - miniScript->startErrorScript(); - } - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodTransformSetRotationAngle(this)); - } - { - // - class ScriptMethodTransformRotate: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformRotate(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_VECTOR3), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.rotate"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Transform transform; - Vector3 vec3; - if (MiniScript::getTransformValue(argumentValues, 0, transform, false) == true && - MiniScript::getVector3Value(argumentValues, 1, vec3, false) == true) { - returnValue.setValue(transform.getRotationsQuaternion() * vec3); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodTransformRotate(this)); - } - { - // - class ScriptMethodTransformApplyRotation: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformApplyRotation(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = true, .nullable = false }, - { .type = ScriptVariableType::TYPE_VECTOR3, .name = "axis", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_NULL), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.applyRotation"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Transform transform; - Vector3 axis; - float angle; - if (MiniScript::getTransformValue(argumentValues, 0, transform, false) == true && - MiniScript::getVector3Value(argumentValues, 1, axis, false) == true && - MiniScript::getFloatValue(argumentValues, 2, angle, false) == true) { - // - transform.addRotation(axis, angle); - transform.update(); - // get transform and make sure its a euler transform - auto euler = transform.getTransformMatrix().computeEulerAngles(); - while (transform.getRotationCount() > 3) transform.removeRotation(transform.getRotationCount() - 1); - while (transform.getRotationCount() < 3) transform.addRotation(Vector3(), 0.0f); - transform.setRotationAxis(0, Vector3(0.0f, 0.0f, 1.0f)); - transform.setRotationAxis(1, Vector3(0.0f, 1.0f, 0.0f)); - transform.setRotationAxis(2, Vector3(1.0f, 0.0f, 0.0f)); - transform.setRotationAngle(0, euler.getZ()); - transform.setRotationAngle(1, euler.getY()); - transform.setRotationAngle(2, euler.getX()); - transform.update(); - argumentValues[0].setValue(transform); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodTransformApplyRotation(this)); - } - { - // - class ScriptMethodTransformInterpolateRotation: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformInterpolateRotation(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_FLOAT, .name = "currentAngle", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "targetAngle", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "timePassedSeconds", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "degreesPerSeconds", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_FLOAT, .name = "interpolatedAngle", .optional = false, .reference = true, .nullable = false }, - }, - ScriptVariableType::TYPE_BOOLEAN), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.interpolateRotation"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - float currentAngle; - float targetAngle; - float timePassedSeconds; - float degreesPerSeconds; - float interpolatedAngle = 0.0f; - if (argumentValues.size() == 5 && - MiniScript::getFloatValue(argumentValues, 0, currentAngle) == true && - MiniScript::getFloatValue(argumentValues, 1, targetAngle) == true && - MiniScript::getFloatValue(argumentValues, 2, timePassedSeconds) == true && - MiniScript::getFloatValue(argumentValues, 3, degreesPerSeconds) == true) { - returnValue = Rotation::interpolate(currentAngle, targetAngle, timePassedSeconds, degreesPerSeconds, interpolatedAngle); - argumentValues[4].setValue(interpolatedAngle); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodTransformInterpolateRotation(this)); - } - { - // - class ScriptMethodTransformGetTransformMatrix: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformGetTransformMatrix(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_MATRIX4x4), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.getTransformMatrix"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Transform transform; - if (MiniScript::getTransformValue(argumentValues, 0, transform, false) == true) { - returnValue.setValue(transform.getTransformMatrix()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodTransformGetTransformMatrix(this)); - } - { - // - class ScriptMethodTransformGetRotationsQuaternion: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformGetRotationsQuaternion(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_QUATERNION), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.getRotationsQuaternion"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Transform transform; - if (MiniScript::getTransformValue(argumentValues, 0, transform, false) == true) { - returnValue.setValue(transform.getRotationsQuaternion()); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodTransformGetRotationsQuaternion(this)); - } - { - // - class ScriptMethodTransformFromMatrix: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodTransformFromMatrix(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_MATRIX4x4, .name = "transformMatrix", .optional = false, .reference = false, .nullable = false }, - }, - ScriptVariableType::TYPE_TRANSFORM), - miniScript(miniScript) {} - const string getMethodName() override { - return "transform.fromMatrix"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - Matrix4x4 transformMatrix; - if (MiniScript::getMatrix4x4Value(argumentValues, 0, transformMatrix, false) == true) { - Transform transform; - transform.fromMatrix(transformMatrix, RotationOrder::ZYX); - returnValue.setValue(transform); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodTransformFromMatrix(this)); - } - // bool methods - { - // - class ScriptMethodBool: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodBool(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_BOOLEAN, .name = "bool", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_BOOLEAN - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "bool"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - bool boolValue; - if (MiniScript::getBooleanValue(argumentValues, 0, boolValue, false) == true) { - returnValue.setValue(boolValue); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - return; - } - } - }; - registerMethod(new ScriptMethodBool(this)); - } - { - // - class ScriptMethodNot: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodNot(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_BOOLEAN, .name = "bool", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_BOOLEAN), miniScript(miniScript) {} - const string getMethodName() override { - return "not"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - bool booleanValue = false; - if (MiniScript::getBooleanValue(argumentValues, 0, booleanValue, false) == true) { - returnValue.setValue(!booleanValue); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - return; - } - } - ScriptOperator getOperator() const override { - return OPERATOR_NOT; - } - }; - registerMethod(new ScriptMethodNot(this)); - } - { - // - class ScriptMethodAnd: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodAnd(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_BOOLEAN, .name = "a", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_BOOLEAN, .name = "b", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_BOOLEAN - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "and"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - if (argumentValues.size() != 2) { - returnValue.setValue(false); - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } else { - returnValue.setValue(true); - for (auto i = 0; i < argumentValues.size(); i++) { - bool booleanValue; - if (MiniScript::getBooleanValue(argumentValues, i, booleanValue, false) == false) { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } else - if (booleanValue == false) { - returnValue.setValue(false); - break; - } - } - } - } - ScriptOperator getOperator() const override { - return OPERATOR_AND; - } - }; - registerMethod(new ScriptMethodAnd(this)); - } - { - // - class ScriptMethodOr: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodOr(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_BOOLEAN, .name = "a", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_BOOLEAN, .name = "b", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_BOOLEAN - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "or"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - if (argumentValues.size() != 2) { - returnValue.setValue(false); - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } else { - returnValue.setValue(false); - for (auto i = 0; i < argumentValues.size(); i++) { - bool booleanValue; - if (MiniScript::getBooleanValue(argumentValues, i, booleanValue, false) == false) { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } else - if (booleanValue == true) { - returnValue.setValue(true); - break; - } - } - } - } - ScriptOperator getOperator() const override { - return OPERATOR_OR; - } - }; - registerMethod(new ScriptMethodOr(this)); - } - // string functions - { - // - class ScriptMethodString: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodString(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_STRING, .name = "string", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_STRING - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "string"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - string stringValue; - if (MiniScript::getStringValue(argumentValues, 0, stringValue, false) == true) { - returnValue.setValue(stringValue); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodString(this)); - } - { - // - class ScriptMethodStringLength: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodStringLength(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_STRING, .name = "string", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_INTEGER - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "string.length"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - string stringValue; - if (MiniScript::getStringValue(argumentValues, 0, stringValue, false) == true) { - returnValue.setValue(static_cast(stringValue.size())); - } else { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } - } - }; - registerMethod(new ScriptMethodStringLength(this)); - } - { - // - class ScriptMethodStringCharAt: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodStringCharAt(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_STRING, .name = "string", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_INTEGER, .name = "index", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_STRING - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "string.charAt"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - string stringValue; - int64_t index; - if (MiniScript::getStringValue(argumentValues, 0, stringValue, false) == false || - MiniScript::getIntegerValue(argumentValues, 1, index, false) == false) { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } else { - returnValue.setValue(index >= 0 && index < stringValue.size()?string(&stringValue[index], 1):string()); - } - } - }; - registerMethod(new ScriptMethodStringCharAt(this)); - } - { - // - class ScriptMethodStringStartsWith: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodStringStartsWith(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_STRING, .name = "string", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_STRING, .name = "prefix", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_BOOLEAN - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "string.startsWith"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - string stringValue; - string prefix; - if (MiniScript::getStringValue(argumentValues, 0, stringValue, false) == false || - MiniScript::getStringValue(argumentValues, 1, prefix, false) == false) { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } else { - returnValue.setValue(StringTools::startsWith(stringValue, prefix)); - } - } - }; - registerMethod(new ScriptMethodStringStartsWith(this)); - } - { - // - class ScriptMethodStringEndsWith: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodStringEndsWith(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_STRING, .name = "string", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_STRING, .name = "suffix", .optional = false, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_BOOLEAN - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "string.endsWith"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - string stringValue; - string suffix; - if (MiniScript::getStringValue(argumentValues, 0, stringValue, false) == false || - MiniScript::getStringValue(argumentValues, 1, suffix, false) == false) { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } else { - returnValue.setValue(StringTools::endsWith(stringValue, suffix)); - } - } - }; - registerMethod(new ScriptMethodStringEndsWith(this)); - } - { - // - class ScriptMethodStringReplace: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodStringReplace(MiniScript* miniScript): - ScriptMethod( - { - { .type = ScriptVariableType::TYPE_STRING, .name = "string", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_STRING, .name = "what", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_STRING, .name = "by", .optional = false, .reference = false, .nullable = false }, - { .type = ScriptVariableType::TYPE_INTEGER, .name = "beginIndex", .optional = true, .reference = false, .nullable = false } - }, - ScriptVariableType::TYPE_STRING - ), - miniScript(miniScript) {} - const string getMethodName() override { - return "string.replace"; - } - void executeMethod(span& argumentValues, ScriptVariable& returnValue, const ScriptStatement& statement) override { - string stringValue; - string what; - string by; - int64_t beginIndex = 0; - if (MiniScript::getStringValue(argumentValues, 0, stringValue, false) == false || - MiniScript::getStringValue(argumentValues, 1, what, false) == false || - MiniScript::getStringValue(argumentValues, 2, by, false) == false || - MiniScript::getIntegerValue(argumentValues, 3, beginIndex, true) == false) { - Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); - miniScript->startErrorScript(); - } else { - returnValue.setValue(StringTools::replace(stringValue, what, by, beginIndex)); - } - } - }; - registerMethod(new ScriptMethodStringReplace(this)); - } - { - // - class ScriptMethodStringIndexOf: public ScriptMethod { - private: - MiniScript* miniScript { nullptr }; - public: - ScriptMethodStringIndexOf(MiniScript* miniScript): + ScriptMethodStringIndexOf(MiniScript* miniScript): ScriptMethod( { { .type = ScriptVariableType::TYPE_STRING, .name = "string", .optional = false, .reference = false, .nullable = false }, @@ -7764,6 +5786,12 @@ void MiniScript::registerMethods() { miniScriptMath = make_unique(this); miniScriptMath->registerMethods(); + // + for (const auto scriptDataType: scriptDataTypes) { + if (scriptDataType->isMathDataType() == true) miniScriptMath->registerDataType(scriptDataType); + scriptDataType->registerMethods(this); + } + // determine operators for (const auto& [scriptMethodName, scriptMethod]: scriptMethods) { auto methodOperator = scriptMethod->getOperator(); @@ -7779,11 +5807,6 @@ void MiniScript::registerMethods() { } } -void MiniScript::registerDataTypes() { - for (const auto scriptDataType: scriptDataTypes) delete scriptDataType; - scriptDataTypes.clear(); -} - void MiniScript::registerVariables() { for (const auto& [variableName, variable]: getRootScriptState().variables) delete variable; } @@ -8178,7 +6201,7 @@ const MiniScript::ScriptVariable MiniScript::initializeMapSet(const string_view& string functionScriptCode; // function declaration auto functionName = string() + "map_inline_function_" + to_string(miniScript->inlineFunctionIdx++); - functionScriptCode = "function: " + functionName + "(=$this"; + functionScriptCode = "function: " + functionName + "(&$this"; auto argumentIdx = 0; for (const auto& argument: arguments) { functionScriptCode+= ","; diff --git a/src/tdme/utilities/MiniScript.h b/src/tdme/utilities/MiniScript.h index b19ac4ee1..b60c2823f 100644 --- a/src/tdme/utilities/MiniScript.h +++ b/src/tdme/utilities/MiniScript.h @@ -13,13 +13,6 @@ #include #include -#include -#include -#include -#include -#include -#include -#include #include #include #include @@ -45,13 +38,6 @@ using std::unordered_map; using std::unordered_set; using std::vector; -using tdme::engine::Transform; -using tdme::math::Matrix3x3; -using tdme::math::Matrix4x4; -using tdme::math::Quaternion; -using tdme::math::Vector2; -using tdme::math::Vector3; -using tdme::math::Vector4; using tdme::utilities::Character; using tdme::utilities::Console; using tdme::utilities::Exception; @@ -146,25 +132,22 @@ class tdme::utilities::MiniScript { }; enum ScriptVariableType { + // primitives TYPE_NULL, TYPE_BOOLEAN, TYPE_INTEGER, TYPE_FLOAT, - TYPE_STRING, - TYPE_VECTOR2, - TYPE_VECTOR3, - TYPE_VECTOR4, - TYPE_QUATERNION, - TYPE_MATRIX3x3, - TYPE_MATRIX4x4, - TYPE_TRANSFORM, - TYPE_ARRAY, - TYPE_MAP, - TYPE_SET, + // special TYPE_FUNCTION_CALL, TYPE_FUNCTION_ASSIGNMENT, + // pseudo TYPE_PSEUDO_NUMBER, TYPE_PSEUDO_MIXED, + // classes + TYPE_STRING, + TYPE_ARRAY, + TYPE_MAP, + TYPE_SET, TYPE_PSEUDO_CUSTOM_DATATYPES, }; @@ -179,9 +162,9 @@ class tdme::utilities::MiniScript { friend class MiniScript; friend class MiniScriptMath; - private: + protected: + bool mathDataType { false }; int type { TYPE_NULL }; - bool math { false }; /** * Set type @@ -192,10 +175,10 @@ class tdme::utilities::MiniScript { } /** - * @return has math + * @return is math data type */ - inline bool hasMath() { - return math; + inline bool isMathDataType() { + return mathDataType; } /** @@ -215,7 +198,7 @@ class tdme::utilities::MiniScript { * @param variable variable * @param value value */ - virtual void setScriptVariableValue(ScriptVariable& variable, const void* value) = 0; + virtual void setScriptVariableValue(ScriptVariable& variable, const void* value) const = 0; /** * Copy script variable @@ -226,39 +209,43 @@ class tdme::utilities::MiniScript { /** * Multiply + * @param miniScript mini script instance * @param argumentValues argument values * @param returnValue return value * @param statement statement * @return mul was executed */ - virtual bool mul(const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const = 0; + virtual bool mul(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const = 0; /** * Division + * @param miniScript mini script instance * @param argumentValues argument values * @param returnValue return value * @param statement statement * @return div was executed */ - virtual bool div(const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const = 0; + virtual bool div(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const = 0; /** * Addition + * @param miniScript mini script instance * @param argumentValues argument values * @param returnValue return value * @param statement statement * @return add was executed */ - virtual bool add(const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const = 0; + virtual bool add(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const = 0; /** * Subtraction + * @param miniScript mini script instance * @param argumentValues argument values * @param returnValue return value * @param statement statement * @return sub was executed */ - virtual bool sub(const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const = 0; + virtual bool sub(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const = 0; public: // forbid class copy @@ -266,8 +253,9 @@ class tdme::utilities::MiniScript { /** * Script data type + * @param mathDataType is math data type and provides math methods */ - ScriptDataType() { + ScriptDataType(bool mathDataType): mathDataType(mathDataType) { // } @@ -383,12 +371,12 @@ class tdme::utilities::MiniScript { }; // - MiniScript* miniScript { nullptr }; - ScriptVariableType type { TYPE_NULL }; - uint64_t valuePtr { 0LL }; - Initializer* initializer { nullptr }; - ScriptVariable* reference { nullptr }; - int referenceCounter { 1 }; + ScriptVariableType type { TYPE_NULL }; // 4, maybe use a int16_t here + uint64_t valuePtr { 0LL }; // 8 + // TODO: union initializer/reference + Initializer* initializer { nullptr }; // 8 + ScriptVariable* reference { nullptr }; // 8 + int referenceCounter { 1 }; // 4, maybe use a int16_t here /** * Acquire reference @@ -491,104 +479,6 @@ class tdme::utilities::MiniScript { return *static_cast((void*)getValuePtrReference()); } - /** - * @return vector2 value reference - */ - inline Vector2& getVector2ValueReference() { - return *static_cast((void*)getValuePtrReference()); - } - - /** - * @return const vector2 value reference - */ - inline const Vector2& getVector2ValueReference() const { - return *static_cast((void*)getValuePtrReference()); - } - - /** - * @return vector3 value reference - */ - inline Vector3& getVector3ValueReference() { - return *static_cast((void*)getValuePtrReference()); - } - - /** - * @return const vector3 value reference - */ - inline const Vector3& getVector3ValueReference() const { - return *static_cast((void*)getValuePtrReference()); - } - - /** - * @return vector4 value reference - */ - inline Vector4& getVector4ValueReference() { - return *static_cast((void*)getValuePtrReference()); - } - - /** - * @return const vector4 value reference - */ - inline const Vector4& getVector4ValueReference() const { - return *static_cast((void*)getValuePtrReference()); - } - - /** - * @return quaternion value reference - */ - inline Quaternion& getQuaternionValueReference() { - return *static_cast((void*)getValuePtrReference()); - } - - /** - * @return const quaternion value reference - */ - inline const Quaternion& getQuaternionValueReference() const { - return *static_cast((void*)getValuePtrReference()); - } - - /** - * @return matrix3x3 value reference - */ - inline Matrix3x3& getMatrix3x3ValueReference() { - return *static_cast((void*)getValuePtrReference()); - } - - /** - * @return const matrix3x3 value reference - */ - inline const Matrix3x3& getMatrix3x3ValueReference() const { - return *static_cast((void*)getValuePtrReference()); - } - - /** - * @return matrix4x4 value reference - */ - inline Matrix4x4& getMatrix4x4ValueReference() { - return *static_cast((void*)getValuePtrReference()); - } - - /** - * @return const matrix4x4 value reference - */ - inline const Matrix4x4& getMatrix4x4ValueReference() const { - return *static_cast((void*)getValuePtrReference()); - } - - /** - * @return transform value reference - */ - inline Transform& getTransformValueReference() { - return *static_cast((void*)getValuePtrReference()); - } - - /** - * @return const transform value reference - */ - inline const Transform& getTransformValueReference() const { - return *static_cast((void*)getValuePtrReference()); - } - /** * @return array value reference */ @@ -635,13 +525,6 @@ class tdme::utilities::MiniScript { // class names STATIC_DLL_IMPEXT static const string CLASSNAME_NONE; STATIC_DLL_IMPEXT static const string CLASSNAME_STRING; - STATIC_DLL_IMPEXT static const string CLASSNAME_VEC2; - STATIC_DLL_IMPEXT static const string CLASSNAME_VEC3; - STATIC_DLL_IMPEXT static const string CLASSNAME_VEC4; - STATIC_DLL_IMPEXT static const string CLASSNAME_QUATERNION; - STATIC_DLL_IMPEXT static const string CLASSNAME_MAT3; - STATIC_DLL_IMPEXT static const string CLASSNAME_MAT4; - STATIC_DLL_IMPEXT static const string CLASSNAME_TRANSFORM; STATIC_DLL_IMPEXT static const string CLASSNAME_ARRAY; STATIC_DLL_IMPEXT static const string CLASSNAME_MAP; STATIC_DLL_IMPEXT static const string CLASSNAME_SET; @@ -658,7 +541,6 @@ class tdme::utilities::MiniScript { ScriptVariable referenceVariable; referenceVariable.reference = (ScriptVariable*)variable; // TODO: improve me! referenceVariable.reference->acquireReference(); - referenceVariable.miniScript = referenceVariable.reference->miniScript; return referenceVariable; } @@ -674,7 +556,6 @@ class tdme::utilities::MiniScript { ScriptVariable* referenceVariable = new ScriptVariable(); referenceVariable->reference = (ScriptVariable*)variable; // TODO: improve me! referenceVariable->reference->acquireReference(); - referenceVariable->miniScript = referenceVariable->reference->miniScript; return referenceVariable; } @@ -685,7 +566,6 @@ class tdme::utilities::MiniScript { */ inline static void copyScriptVariable(ScriptVariable& to, const ScriptVariable& from) { // initial setup - to.miniScript = from.miniScript; to.setNullValue(); // do the copy switch(from.getType()) { @@ -701,29 +581,20 @@ class tdme::utilities::MiniScript { case TYPE_FLOAT: to.setValue(from.getFloatValueReference()); break; - case TYPE_STRING: - to.setValue(from.getStringValueReference()); - break; - case TYPE_VECTOR2: - to.setValue(from.getVector2ValueReference()); - break; - case TYPE_VECTOR3: - to.setValue(from.getVector3ValueReference()); - break; - case TYPE_VECTOR4: - to.setValue(from.getVector4ValueReference()); - break; - case TYPE_QUATERNION: - to.setValue(from.getQuaternionValueReference()); - break; - case TYPE_MATRIX3x3: - to.setValue(from.getMatrix3x3ValueReference()); + case TYPE_FUNCTION_CALL: + to.setType(TYPE_FUNCTION_CALL); + to.getStringValueReference() = from.getStringValueReference(); + // copy initializer if we have any + to.getInitializer()->copy(from.initializer); + // break; - case TYPE_MATRIX4x4: - to.setValue(from.getMatrix4x4ValueReference()); + case TYPE_FUNCTION_ASSIGNMENT: + to.setFunctionAssignment(from.getStringValueReference()); break; - case TYPE_TRANSFORM: - to.setValue(from.getTransformValueReference()); + case TYPE_PSEUDO_NUMBER: break; + case TYPE_PSEUDO_MIXED: break; + case TYPE_STRING: + to.setValue(from.getStringValueReference()); break; case TYPE_ARRAY: to.setValue(from.getArrayValueReference()); @@ -743,26 +614,14 @@ class tdme::utilities::MiniScript { to.getInitializer()->copy(from.initializer); // break; - case TYPE_FUNCTION_CALL: - to.setType(TYPE_FUNCTION_CALL); - to.getStringValueReference() = from.getStringValueReference(); - // copy initializer if we have any - to.getInitializer()->copy(from.initializer); - // - break; - case TYPE_FUNCTION_ASSIGNMENT: - to.setFunctionAssignment(from.getStringValueReference()); - break; - case TYPE_PSEUDO_NUMBER: break; - case TYPE_PSEUDO_MIXED: break; default: // custom data type auto dataTypeIdx = static_cast(from.getType()) - TYPE_PSEUDO_CUSTOM_DATATYPES; - if (dataTypeIdx < TYPE_PSEUDO_CUSTOM_DATATYPES || dataTypeIdx >= to.miniScript->scriptDataTypes.size()) { + if (dataTypeIdx < 0 || dataTypeIdx >= MiniScript::scriptDataTypes.size()) { Console::println("ScriptVariable::copyScriptVariable(): unknown custom data type with id " + to_string(dataTypeIdx)); return; } - to.miniScript->scriptDataTypes[dataTypeIdx]->copyScriptVariable(to, from); + MiniScript::scriptDataTypes[dataTypeIdx]->copyScriptVariable(to, from); } } @@ -817,7 +676,6 @@ class tdme::utilities::MiniScript { * @param variable variable to move from */ inline ScriptVariable(ScriptVariable&& variable): - miniScript(exchange(variable.miniScript, nullptr)), type(exchange(variable.type, MiniScript::TYPE_NULL)), valuePtr(exchange(variable.valuePtr, 0ll)), initializer(exchange(variable.initializer, nullptr)), @@ -834,7 +692,6 @@ class tdme::utilities::MiniScript { inline ScriptVariable& operator=(const ScriptVariable& variable) { if (variable.reference != nullptr) { reference = variable.reference; - miniScript = variable.miniScript; variable.reference->acquireReference(); } else { copyScriptVariable(*this, variable); @@ -849,7 +706,6 @@ class tdme::utilities::MiniScript { * @return this script variable */ inline ScriptVariable& operator=(ScriptVariable&& variable) { - swap(miniScript, variable.miniScript); swap(type, variable.type); swap(valuePtr, variable.valuePtr); swap(initializer, variable.initializer); @@ -910,62 +766,6 @@ class tdme::utilities::MiniScript { setValue(value); } - /** - * Constructor - * @param value value - */ - inline ScriptVariable(const Vector2& value) { - setValue(value); - } - - /** - * Constructor - * @param value value - */ - inline ScriptVariable(const Vector3& value) { - setValue(value); - } - - /** - * Constructor - * @param value value - */ - inline ScriptVariable(const Vector4& value) { - setValue(value); - } - - /** - * Constructor - * @param value value - */ - inline ScriptVariable(const Quaternion& value) { - setValue(value); - } - - /** - * Constructor - * @param value value - */ - inline ScriptVariable(const Matrix3x3& value) { - setValue(value); - } - - /** - * Constructor - * @param value value - */ - inline ScriptVariable(const Matrix4x4& value) { - setValue(value); - } - - /** - * Constructor - * @param value value - */ - inline ScriptVariable(const Transform& value) { - setValue(value); - } - /** * Constructor * @param value value @@ -1004,31 +804,17 @@ class tdme::utilities::MiniScript { break; case TYPE_FLOAT: break; + case TYPE_FUNCTION_CALL: + delete static_cast((void*)getValuePtrReference()); + delete getInitializerReference(); + getInitializerReference() = nullptr; + break; + case TYPE_PSEUDO_NUMBER: break; + case TYPE_PSEUDO_MIXED: break; case TYPE_STRING: case TYPE_FUNCTION_ASSIGNMENT: delete static_cast((void*)getValuePtrReference()); break; - case TYPE_VECTOR2: - delete static_cast((void*)getValuePtrReference()); - break; - case TYPE_VECTOR3: - delete static_cast((void*)getValuePtrReference()); - break; - case TYPE_VECTOR4: - delete static_cast((void*)getValuePtrReference()); - break; - case TYPE_QUATERNION: - delete static_cast((void*)getValuePtrReference()); - break; - case TYPE_MATRIX3x3: - delete static_cast((void*)getValuePtrReference()); - break; - case TYPE_MATRIX4x4: - delete static_cast((void*)getValuePtrReference()); - break; - case TYPE_TRANSFORM: - delete static_cast((void*)getValuePtrReference()); - break; case TYPE_ARRAY: for (auto arrayValue: getArrayValueReference()) arrayValue->releaseReference(); delete static_cast*>((void*)getValuePtrReference()); @@ -1046,21 +832,14 @@ class tdme::utilities::MiniScript { delete getInitializerReference(); getInitializerReference() = nullptr; break; - case TYPE_FUNCTION_CALL: - delete static_cast((void*)getValuePtrReference()); - delete getInitializerReference(); - getInitializerReference() = nullptr; - break; - case TYPE_PSEUDO_NUMBER: break; - case TYPE_PSEUDO_MIXED: break; default: // custom data type auto dataTypeIdx = static_cast(this->getType()) - TYPE_PSEUDO_CUSTOM_DATATYPES; - if (dataTypeIdx < TYPE_PSEUDO_CUSTOM_DATATYPES || dataTypeIdx >= miniScript->scriptDataTypes.size()) { + if (dataTypeIdx < 0 || dataTypeIdx >= MiniScript::scriptDataTypes.size()) { Console::println("ScriptVariable::setType(): unknown custom data type with id " + to_string(dataTypeIdx)); return; } - miniScript->scriptDataTypes[dataTypeIdx]->unsetScriptVariableValue(*this); + MiniScript::scriptDataTypes[dataTypeIdx]->unsetScriptVariableValue(*this); } this->getValuePtrReference() = 0LL; @@ -1080,31 +859,12 @@ class tdme::utilities::MiniScript { break; case TYPE_FLOAT: break; + case TYPE_PSEUDO_NUMBER: break; + case TYPE_PSEUDO_MIXED: break; case TYPE_STRING: case TYPE_FUNCTION_ASSIGNMENT: getValuePtrReference() = (uint64_t)(new string()); break; - case TYPE_VECTOR2: - getValuePtrReference() = (uint64_t)(new Vector2()); - break; - case TYPE_VECTOR3: - getValuePtrReference() = (uint64_t)(new Vector3()); - break; - case TYPE_VECTOR4: - getValuePtrReference() = (uint64_t)(new Vector4()); - break; - case TYPE_QUATERNION: - getValuePtrReference() = (uint64_t)(new Quaternion()); - break; - case TYPE_MATRIX3x3: - getValuePtrReference() = (uint64_t)(new Matrix3x3()); - break; - case TYPE_MATRIX4x4: - getValuePtrReference() = (uint64_t)(new Matrix4x4()); - break; - case TYPE_TRANSFORM: - getValuePtrReference() = (uint64_t)(new Transform()); - break; case TYPE_ARRAY: getValuePtrReference() = (uint64_t)(new vector()); getInitializerReference() = new Initializer(); @@ -1121,16 +881,14 @@ class tdme::utilities::MiniScript { getValuePtrReference() = (uint64_t)(new string()); getInitializerReference() = new Initializer(); break; - case TYPE_PSEUDO_NUMBER: break; - case TYPE_PSEUDO_MIXED: break; default: // custom data type auto dataTypeIdx = static_cast(this->getType()) - TYPE_PSEUDO_CUSTOM_DATATYPES; - if (dataTypeIdx < TYPE_PSEUDO_CUSTOM_DATATYPES || dataTypeIdx >= miniScript->scriptDataTypes.size()) { + if (dataTypeIdx < 0 || dataTypeIdx >= MiniScript::scriptDataTypes.size()) { Console::println("ScriptVariable::setType(): unknown custom data type with id " + to_string(dataTypeIdx)); return; } - miniScript->scriptDataTypes[dataTypeIdx]->setScriptVariableValue(*this, nullptr); + MiniScript::scriptDataTypes[dataTypeIdx]->setScriptVariableValue(*this, nullptr); } } @@ -1142,6 +900,25 @@ class tdme::utilities::MiniScript { return reference != nullptr?reference->initializer:initializer; } + /** + * @return value pointer + */ + inline const uint64_t getValuePtr() const { + return reference != nullptr?reference->valuePtr:valuePtr; + } + + /** + * Set value pointer + * @param valuePtr value pointer + */ + inline void setValuePtr(uint64_t valuePtr) { + if (reference != nullptr) { + reference->valuePtr = valuePtr; + } else { + this->valuePtr = valuePtr; + } + } + /** * Get boolean value from given variable * @param value value @@ -1272,125 +1049,6 @@ class tdme::utilities::MiniScript { return false; } - /** - * Get vector2 value from given variable - * @param value value - * @param optional optional - * @return success - */ - inline bool getVector2Value(Vector2& value, bool optional = false) const { - switch(getType()) { - case TYPE_VECTOR2: - value = getVector2ValueReference(); - return true; - default: - return optional; - } - return false; - } - - /** - * Get vector3 value from given variable - * @param value value - * @param optional optional - * @return success - */ - inline bool getVector3Value(Vector3& value, bool optional = false) const { - switch(getType()) { - case TYPE_VECTOR3: - value = getVector3ValueReference(); - return true; - default: - return optional; - } - return false; - } - - /** - * Get vector4 value from given variable - * @param value value - * @param optional optional - * @return success - */ - inline bool getVector4Value(Vector4& value, bool optional = false) const { - switch(getType()) { - case TYPE_VECTOR4: - value = getVector4ValueReference(); - return true; - default: - return optional; - } - return false; - } - - /** - * Get quaternion value from given variable - * @param value value - * @param optional optional - * @return success - */ - inline bool getQuaternionValue(Quaternion& value, bool optional = false) const { - switch(getType()) { - case TYPE_QUATERNION: - value = getQuaternionValueReference(); - return true; - default: - return optional; - } - return false; - } - - /** - * Get matrix3x3 value from given variable - * @param value value - * @param optional optional - * @return success - */ - inline bool getMatrix3x3Value(Matrix3x3& value, bool optional = false) const { - switch(getType()) { - case TYPE_MATRIX3x3: - value = getMatrix3x3ValueReference(); - return true; - default: - return optional; - } - return false; - } - - /** - * Get matrix4x4 value from given variable - * @param value value - * @param optional optional - * @return success - */ - inline bool getMatrix4x4Value(Matrix4x4& value, bool optional = false) const { - switch(getType()) { - case TYPE_MATRIX4x4: - value = getMatrix4x4ValueReference(); - return true; - default: - return optional; - } - return false; - } - - /** - * Get transform value from given variable - * @param value value - * @param optional optional - * @return success - */ - inline bool getTransformValue(Transform& value, bool optional = false) const { - switch(getType()) { - case TYPE_TRANSFORM: - value = getTransformValueReference(); - return true; - default: - return optional; - } - return false; - } - /** * Set boolean value from given value into variable * @param value value @@ -1435,69 +1093,6 @@ class tdme::utilities::MiniScript { getStringValueReference() = value; } - /** - * Set vector2 value from given value into variable - * @param value value - */ - inline void setValue(const Vector2& value) { - setType(TYPE_VECTOR2); - getVector2ValueReference() = value; - } - - /** - * Set vector3 value from given value into variable - * @param value value - */ - inline void setValue(const Vector3& value) { - setType(TYPE_VECTOR3); - getVector3ValueReference() = value; - } - - /** - * Set vector3 value from given value into variable - * @param value value - */ - inline void setValue(const Vector4& value) { - setType(TYPE_VECTOR4); - getVector4ValueReference() = value; - } - - /** - * Set vector3 value from given value into variable - * @param value value - */ - inline void setValue(const Quaternion& value) { - setType(TYPE_QUATERNION); - getQuaternionValueReference() = value; - } - - /** - * Set matrix3x3 value from given value into variable - * @param value value - */ - inline void setValue(const Matrix3x3& value) { - setType(TYPE_MATRIX3x3); - getMatrix3x3ValueReference() = value; - } - - /** - * Set matrix4x4 value from given value into variable - * @param value value - */ - inline void setValue(const Matrix4x4& value) { - setType(TYPE_MATRIX4x4); - getMatrix4x4ValueReference() = value; - } - - /** - * Set transform value from given value into variable - * @param value value - */ - inline void setValue(const Transform& value) { - setType(TYPE_TRANSFORM); - getTransformValueReference() = value; - } - /** * Set array value from given value into variable * @param value value @@ -1538,11 +1133,11 @@ class tdme::utilities::MiniScript { inline void setValue(const void* value) { // custom data type auto dataTypeIdx = static_cast(this->getType()) - TYPE_PSEUDO_CUSTOM_DATATYPES; - if (dataTypeIdx < TYPE_PSEUDO_CUSTOM_DATATYPES || dataTypeIdx >= miniScript->scriptDataTypes.size()) { + if (dataTypeIdx < 0 || dataTypeIdx >= MiniScript::scriptDataTypes.size()) { Console::println("ScriptVariable::setValue(): unknown custom data type with id " + to_string(dataTypeIdx)); return; } - miniScript->scriptDataTypes[dataTypeIdx]->setScriptVariableValue(*this, value); + MiniScript::scriptDataTypes[dataTypeIdx]->setScriptVariableValue(*this, value); } /** @@ -1898,82 +1493,66 @@ class tdme::utilities::MiniScript { * @return class name of given script variable type */ inline const string& getClassName() { - return getClassName(miniScript, getType()); + return getClassName(getType()); } /** * Return class name of given script variable type - * @param miniScript mini script instance * @param type type * @return class name of given script variable type */ - inline static const string& getClassName(MiniScript* miniScript, ScriptVariableType type) { + inline static const string& getClassName(ScriptVariableType type) { switch (type) { case TYPE_NULL: return CLASSNAME_NONE; case TYPE_BOOLEAN: return CLASSNAME_NONE; case TYPE_INTEGER: return CLASSNAME_NONE; case TYPE_FLOAT: return CLASSNAME_NONE; - case TYPE_STRING: return CLASSNAME_STRING; - case TYPE_VECTOR2: return CLASSNAME_VEC2; - case TYPE_VECTOR3: return CLASSNAME_VEC3; - case TYPE_VECTOR4: return CLASSNAME_VEC4; - case TYPE_QUATERNION: return CLASSNAME_QUATERNION; - case TYPE_MATRIX3x3: return CLASSNAME_MAT3; - case TYPE_MATRIX4x4: return CLASSNAME_MAT4; - case TYPE_TRANSFORM: return CLASSNAME_TRANSFORM; - case TYPE_ARRAY: return CLASSNAME_ARRAY; - case TYPE_MAP: return CLASSNAME_MAP; - case TYPE_SET: return CLASSNAME_SET; case TYPE_FUNCTION_CALL: return CLASSNAME_NONE; case TYPE_FUNCTION_ASSIGNMENT: return CLASSNAME_NONE; case TYPE_PSEUDO_NUMBER: return CLASSNAME_NONE; case TYPE_PSEUDO_MIXED: return CLASSNAME_NONE; + case TYPE_STRING: return CLASSNAME_STRING; + case TYPE_ARRAY: return CLASSNAME_ARRAY; + case TYPE_MAP: return CLASSNAME_MAP; + case TYPE_SET: return CLASSNAME_SET; default: // custom data types auto dataTypeIdx = static_cast(type) - TYPE_PSEUDO_CUSTOM_DATATYPES; - if (dataTypeIdx < TYPE_PSEUDO_CUSTOM_DATATYPES || dataTypeIdx >= miniScript->scriptDataTypes.size()) { + if (dataTypeIdx < 0 || dataTypeIdx >= MiniScript::scriptDataTypes.size()) { Console::println("ScriptVariable::getClassName(): unknown custom data type with id " + to_string(dataTypeIdx)); return CLASSNAME_NONE; } - return miniScript->scriptDataTypes[dataTypeIdx]->getClassName(); + return MiniScript::scriptDataTypes[dataTypeIdx]->getClassName(); } } /** * Returns given script variable type as string - * @param miniScript mini script instance * @param type type * @return script variable type as string */ - inline static const string getTypeAsString(MiniScript* miniScript, ScriptVariableType type) { + inline static const string getTypeAsString(ScriptVariableType type) { switch(type) { case TYPE_NULL: return "Null"; case TYPE_BOOLEAN: return "Boolean"; case TYPE_INTEGER: return "Integer"; case TYPE_FLOAT: return "Float"; + case TYPE_FUNCTION_CALL: return string(); + case TYPE_FUNCTION_ASSIGNMENT: return string(); + case TYPE_PSEUDO_NUMBER: return "Number"; + case TYPE_PSEUDO_MIXED: return "Mixed"; case TYPE_STRING: return "String"; - case TYPE_VECTOR2: return "Vector2"; - case TYPE_VECTOR3: return "Vector3"; - case TYPE_VECTOR4: return "Vector4"; - case TYPE_QUATERNION: return "Quaternion"; - case TYPE_MATRIX3x3: return "Matrix3x3"; - case TYPE_MATRIX4x4: return "Matrix4x4"; - case TYPE_TRANSFORM: return "Transform"; case TYPE_ARRAY: return "Array"; case TYPE_MAP: return "Map"; case TYPE_SET: return "Set"; - case TYPE_FUNCTION_CALL: return string(); - case TYPE_FUNCTION_ASSIGNMENT: return string(); - case TYPE_PSEUDO_NUMBER: return string(); - case TYPE_PSEUDO_MIXED: return string(); default: // custom data types auto dataTypeIdx = static_cast(type) - TYPE_PSEUDO_CUSTOM_DATATYPES; - if (dataTypeIdx < TYPE_PSEUDO_CUSTOM_DATATYPES || dataTypeIdx >= miniScript->scriptDataTypes.size()) { + if (dataTypeIdx < 0 || dataTypeIdx >= MiniScript::scriptDataTypes.size()) { Console::println("ScriptVariable::getTypeAsString(): unknown custom data type with id " + to_string(dataTypeIdx)); return CLASSNAME_NONE; } - return miniScript->scriptDataTypes[dataTypeIdx]->getTypeAsString(); + return MiniScript::scriptDataTypes[dataTypeIdx]->getTypeAsString(); } return string(); } @@ -1982,30 +1561,30 @@ class tdme::utilities::MiniScript { * @return this script variable type as string */ inline const string getTypeAsString() const { - return getTypeAsString(miniScript, getType()); + return getTypeAsString(getType()); } /** * Returns given return value variable type string representation - * @param miniScript mini script instance * @param type type * @param nullable nullable * @return return value variable type string representation */ - inline static const string getReturnTypeAsString(MiniScript* miniScript, ScriptVariableType type, bool nullable) { + inline static const string getReturnTypeAsString(ScriptVariableType type, bool nullable) { switch(type) { case TYPE_NULL: return "Null"; - default: return string(nullable?"?":"") + getTypeAsString(miniScript, type); + default: return string(nullable?"?":"") + getTypeAsString(type); } return string(); } + /** * Returns given return value variable type string representation * @param nullable nullable * @return return value variable type string representation */ inline const string getReturnTypeAsString(bool nullable) const { - return getReturnTypeAsString(miniScript, getType(), nullable); + return getReturnTypeAsString(getType(), nullable); } /** @@ -2044,110 +1623,20 @@ class tdme::utilities::MiniScript { case TYPE_FLOAT: result+= to_string(getFloatValueReference()); break; - case TYPE_STRING: - result+= getStringValueReference(); - break; - case TYPE_VECTOR2: - { - const auto& vector2Value = getVector2ValueReference(); - result+= - "Vector2(" + - to_string(vector2Value.getX()) + ", " + - to_string(vector2Value.getY()) + ")"; - } - break; - case TYPE_VECTOR3: - { - const auto& vector3Value = getVector3ValueReference(); - result+= - "Vector3(" + - to_string(vector3Value.getX()) + ", " + - to_string(vector3Value.getY()) + ", " + - to_string(vector3Value.getZ()) + ")"; - } - break; - case TYPE_VECTOR4: - { - const auto& vector4Value = getVector4ValueReference(); - result+= - "Vector4(" + - to_string(vector4Value.getX()) + ", " + - to_string(vector4Value.getY()) + ", " + - to_string(vector4Value.getZ()) + ", " + - to_string(vector4Value.getW()) + ")"; - } + case TYPE_FUNCTION_CALL: + result+= "{" + getStringValueReference() + "}"; break; - case TYPE_QUATERNION: - { - const auto& quaternionValue = getQuaternionValueReference(); - result+= - "Quaternion(" + - to_string(quaternionValue.getX()) + ", " + - to_string(quaternionValue.getY()) + ", " + - to_string(quaternionValue.getZ()) + ", " + - to_string(quaternionValue.getW()) + ")"; - } + case TYPE_FUNCTION_ASSIGNMENT: + result+= "() -> " + getStringValueReference(); break; - case TYPE_MATRIX3x3: - { - const auto& matrix3x3Value = getMatrix3x3ValueReference(); - result+= - "Matrix3x3(" + - to_string(matrix3x3Value[0]) + ", " + - to_string(matrix3x3Value[1]) + ", " + - to_string(matrix3x3Value[2]) + ", " + - to_string(matrix3x3Value[3]) + ", " + - to_string(matrix3x3Value[4]) + ", " + - to_string(matrix3x3Value[5]) + ", " + - to_string(matrix3x3Value[6]) + ", " + - to_string(matrix3x3Value[7]) + ", " + - to_string(matrix3x3Value[8]) + ")"; - } + case TYPE_PSEUDO_NUMBER: + result+= "Number"; break; - case TYPE_MATRIX4x4: - { - const auto& matrix4x4Value = getMatrix4x4ValueReference(); - result+= - "Matrix4x4(" + - to_string(matrix4x4Value[0]) + ", " + - to_string(matrix4x4Value[1]) + ", " + - to_string(matrix4x4Value[2]) + ", " + - to_string(matrix4x4Value[3]) + ", " + - to_string(matrix4x4Value[4]) + ", " + - to_string(matrix4x4Value[5]) + ", " + - to_string(matrix4x4Value[6]) + ", " + - to_string(matrix4x4Value[7]) + ", " + - to_string(matrix4x4Value[8]) + ", " + - to_string(matrix4x4Value[9]) + ", " + - to_string(matrix4x4Value[10]) + ", " + - to_string(matrix4x4Value[11]) + ", " + - to_string(matrix4x4Value[12]) + ", " + - to_string(matrix4x4Value[13]) + ", " + - to_string(matrix4x4Value[14]) + ", " + - to_string(matrix4x4Value[15]) + ")"; - } + case TYPE_PSEUDO_MIXED: + result+= "Mixed"; break; - case TYPE_TRANSFORM: - { - const auto& transformValue = getTransformValueReference(); - result+= - "Transform(translation: Vector3(" + - to_string(transformValue.getTranslation().getX()) + ", " + - to_string(transformValue.getTranslation().getY()) + ", " + - to_string(transformValue.getTranslation().getZ()) + "), " + - "scale: (" + - to_string(transformValue.getScale().getX()) + ", " + - to_string(transformValue.getScale().getY()) + ", " + - to_string(transformValue.getScale().getZ()) + ")"; - for (auto i = 0; i < transformValue.getRotationCount(); i++) { - result+= ", rotations: (axis: Vector3(" + - to_string(transformValue.getRotationAxis(i).getX()) + ", " + - to_string(transformValue.getRotationAxis(i).getY()) + ", " + - to_string(transformValue.getRotationAxis(i).getZ()) + "), angle: " + - to_string(transformValue.getRotationAngle(i)) + ")"; - } - result+= ")"; - } + case TYPE_STRING: + result+= getStringValueReference(); break; case TYPE_ARRAY: { @@ -2259,26 +1748,14 @@ class tdme::utilities::MiniScript { } break; } - case TYPE_FUNCTION_CALL: - result+= "{" + getStringValueReference() + "}"; - break; - case TYPE_FUNCTION_ASSIGNMENT: - result+= "() -> " + getStringValueReference(); - break; - case TYPE_PSEUDO_NUMBER: - result+= "Number"; - break; - case TYPE_PSEUDO_MIXED: - result+= "Mixed"; - break; default: // custom data types auto dataTypeIdx = static_cast(type) - TYPE_PSEUDO_CUSTOM_DATATYPES; - if (dataTypeIdx < TYPE_PSEUDO_CUSTOM_DATATYPES || dataTypeIdx >= miniScript->scriptDataTypes.size()) { + if (dataTypeIdx < 0 || dataTypeIdx >= MiniScript::scriptDataTypes.size()) { Console::println("ScriptVariable::getValueAsString(): unknown custom data type with id " + to_string(dataTypeIdx)); - return CLASSNAME_NONE; + return result; } - return miniScript->scriptDataTypes[dataTypeIdx]->getValueAsString(this); + return MiniScript::scriptDataTypes[dataTypeIdx]->getValueAsString(*this); } return result; @@ -2379,11 +1856,10 @@ class tdme::utilities::MiniScript { /** * Get arguments information - * @param miniScript mini script instance * @param beginIdx begin index * @return arguments information */ - inline const string getArgumentsInformation(MiniScript* miniScript, int beginIdx = 0) const { + inline const string getArgumentsInformation(int beginIdx = 0) const { string result; auto optionalArgumentCount = 0; auto argumentIdx = 0; @@ -2396,9 +1872,9 @@ class tdme::utilities::MiniScript { if (argumentIdx > beginIdx) result+= ", "; if (optionalArgumentCount > 0 || argumentIdx >= beginIdx) { if (argumentType.reference == true) { - result+= "="; + result+= "&"; } - result+= "$" + argumentType.name + ": " + (argumentType.nullable == true?"?":"") + ScriptVariable::getTypeAsString(miniScript, argumentType.type); + result+= "$" + argumentType.name + ": " + (argumentType.nullable == true?"?":"") + ScriptVariable::getTypeAsString(argumentType.type); } argumentIdx++; } @@ -2844,6 +2320,7 @@ class tdme::utilities::MiniScript { // STATIC_DLL_IMPEXT static const string OPERATOR_CHARS; + STATIC_DLL_IMPEXT static vector scriptDataTypes; // TODO: maybe we need a better naming for this // script functions defined by script itself @@ -2852,7 +2329,6 @@ class tdme::utilities::MiniScript { unordered_map scriptMethods; unordered_map scriptStateMachineStates; unordered_map scriptOperators; - vector scriptDataTypes; string scriptPathName; string scriptFileName; bool scriptValid { false }; @@ -3238,15 +2714,33 @@ class tdme::utilities::MiniScript { return result; } - // forbid class copy - FORBID_CLASS_COPY(MiniScript) + /** + * @return data types + */ + inline static const vector& getDataTypes() { + return scriptDataTypes; + } /** - * Load script - * @param pathName path name - * @param fileName file name + * Returns data type by class name or nullptr + * @param className class name + * @return script data type + */ + inline static ScriptDataType* getDataTypeByClassName(const string& className) { + for (const auto scriptDataType: scriptDataTypes) { + if (scriptDataType->getClassName() == className) return scriptDataType; + } + return nullptr; + } + + /** + * Register script data type + * @param scriptDataType script data type */ - static MiniScript* loadScript(const string& pathName, const string& fileName); + static void registerDataType(ScriptDataType* scriptDataType); + + // forbid class copy + FORBID_CLASS_COPY(MiniScript) /** * Default constructor @@ -3366,11 +2860,6 @@ class tdme::utilities::MiniScript { */ virtual void registerMethods(); - /** - * Register data types - */ - virtual void registerDataTypes(); - /** * Register variables */ @@ -3396,7 +2885,7 @@ class tdme::utilities::MiniScript { Console::println("MiniScript::getArgumentInformation(): method not found: " + methodName); return "No information available"; } - return scriptMethod->getArgumentsInformation(this); + return scriptMethod->getArgumentsInformation(); } /** @@ -3500,104 +2989,6 @@ class tdme::utilities::MiniScript { return argument.getStringValue(value, optional); } - /** - * Get vector2 value from given variable - * @param arguments arguments - * @param idx argument index - * @param value value - * @param optional optional - * @return success - */ - inline static bool getVector2Value(const span& arguments, int idx, Vector2& value, bool optional = false) { - if (idx >= arguments.size()) return optional; - const auto& argument = arguments[idx]; - return argument.getVector2Value(value, optional); - } - - /** - * Get vector3 value from given variable - * @param arguments arguments - * @param idx argument index - * @param value value - * @param optional optional - * @return success - */ - inline static bool getVector3Value(const span& arguments, int idx, Vector3& value, bool optional = false) { - if (idx >= arguments.size()) return optional; - const auto& argument = arguments[idx]; - return argument.getVector3Value(value, optional); - } - - /** - * Get vector4 value from given variable - * @param arguments arguments - * @param idx argument index - * @param value value - * @param optional optional - * @return success - */ - inline static bool getVector4Value(const span& arguments, int idx, Vector4& value, bool optional = false) { - if (idx >= arguments.size()) return optional; - const auto& argument = arguments[idx]; - return argument.getVector4Value(value, optional); - } - - /** - * Get vector4 value from given variable - * @param arguments arguments - * @param idx argument index - * @param value value - * @param optional optional - * @return success - */ - inline static bool getQuaternionValue(const span& arguments, int idx, Quaternion& value, bool optional = false) { - if (idx >= arguments.size()) return optional; - const auto& argument = arguments[idx]; - return argument.getQuaternionValue(value, optional); - } - - /** - * Get matrix3x3 value from given variable - * @param arguments arguments - * @param idx argument index - * @param value value - * @param optional optional - * @return success - */ - inline static bool getMatrix3x3Value(const span& arguments, int idx, Matrix3x3& value, bool optional = false) { - if (idx >= arguments.size()) return optional; - const auto& argument = arguments[idx]; - return argument.getMatrix3x3Value(value, optional); - } - - /** - * Get matrix4x4 value from given variable - * @param arguments arguments - * @param idx argument index - * @param value value - * @param optional optional - * @return success - */ - inline static bool getMatrix4x4Value(const span& arguments, int idx, Matrix4x4& value, bool optional = false) { - if (idx >= arguments.size()) return optional; - const auto& argument = arguments[idx]; - return argument.getMatrix4x4Value(value, optional); - } - - /** - * Get transform value from given variable - * @param arguments arguments - * @param idx argument index - * @param value value - * @param optional optional - * @return success - */ - inline static bool getTransformValue(const span& arguments, int idx, Transform& value, bool optional = false) { - if (idx >= arguments.size()) return optional; - const auto& argument = arguments[idx]; - return argument.getTransformValue(value, optional); - } - /** * Register script state machine state * @param state state @@ -3610,12 +3001,6 @@ class tdme::utilities::MiniScript { */ void registerMethod(ScriptMethod* scriptMethod); - /** - * Register script data type - * @param scriptDataType script data type - */ - void registerDataType(ScriptDataType* scriptDataType); - /** * Returns if a given string is a variable name * @param candidate candidate diff --git a/src/tdme/utilities/MiniScriptMath.cpp b/src/tdme/utilities/MiniScriptMath.cpp index e17f1e492..8a65f88b2 100644 --- a/src/tdme/utilities/MiniScriptMath.cpp +++ b/src/tdme/utilities/MiniScriptMath.cpp @@ -1,7 +1,10 @@ #include #include +#include #include +#include +#include #include #include #include @@ -10,7 +13,10 @@ using std::span; +using tdme::engine::Transform; using tdme::math::Math; +using tdme::math::Matrix3x3; +using tdme::math::Matrix4x4; using tdme::math::Vector2; using tdme::math::Vector3; using tdme::math::Vector4; @@ -954,279 +960,8 @@ void MiniScriptMath::mul(const span& argumentValues, } // custom data types for (const auto scriptDataType: scriptDataTypes) { - if (scriptDataType->mul(argumentValues, returnValue, statement) == true) return; + if (scriptDataType->mul(miniScript, argumentValues, returnValue, statement) == true) return; } - // transform - if (MiniScript::hasType(argumentValues, MiniScript::TYPE_TRANSFORM) == true) { - // transform * vec3 - if (argumentValues[0].getType() == MiniScript::TYPE_TRANSFORM && - argumentValues[1].getType() == MiniScript::TYPE_VECTOR3) { - Transform a; - Vector3 b; - MiniScript::getTransformValue(argumentValues, 0, a, false); - MiniScript::getVector3Value(argumentValues, 1, b, false); - returnValue.setValue(a * b); - } else - // vec3 * transform - if (argumentValues[0].getType() == MiniScript::TYPE_VECTOR3 && - argumentValues[1].getType() == MiniScript::TYPE_TRANSFORM) { - Vector3 a; - Transform b; - MiniScript::getVector3Value(argumentValues, 0, a, false); - MiniScript::getTransformValue(argumentValues, 1, b, false); - returnValue.setValue(b * a); - } else { - Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); - miniScript->startErrorScript(); - return; - } - } else - // matrix4x4 - if (MiniScript::hasType(argumentValues, MiniScript::TYPE_MATRIX4x4) == true) { - // matrix4x4 * matrix - if (argumentValues[0].getType() == MiniScript::TYPE_MATRIX4x4 && - argumentValues[1].getType() == MiniScript::TYPE_MATRIX4x4) { - Matrix4x4 a; - Matrix4x4 b; - MiniScript::getMatrix4x4Value(argumentValues, 0, a, false); - MiniScript::getMatrix4x4Value(argumentValues, 1, b, false); - returnValue.setValue(a * b); - } else - // matrix4x4 * vec4 - if (argumentValues[0].getType() == MiniScript::TYPE_MATRIX4x4 && - argumentValues[1].getType() == MiniScript::TYPE_VECTOR4) { - Matrix4x4 a; - Vector4 b; - MiniScript::getMatrix4x4Value(argumentValues, 0, a, false); - MiniScript::getVector4Value(argumentValues, 1, b, false); - returnValue.setValue(a * b); - } else - // vec4 * matrix4x4 - if (argumentValues[0].getType() == MiniScript::TYPE_VECTOR4 && - argumentValues[1].getType() == MiniScript::TYPE_MATRIX4x4) { - Vector4 a; - Matrix4x4 b; - MiniScript::getVector4Value(argumentValues, 0, a, false); - MiniScript::getMatrix4x4Value(argumentValues, 1, b, false); - returnValue.setValue(b * a); - } else - // matrix4x4 * vec3 - if (argumentValues[0].getType() == MiniScript::TYPE_MATRIX4x4 && - argumentValues[1].getType() == MiniScript::TYPE_VECTOR3) { - Matrix4x4 a; - Vector3 b; - MiniScript::getMatrix4x4Value(argumentValues, 0, a, false); - MiniScript::getVector3Value(argumentValues, 1, b, false); - returnValue.setValue(a * b); - } else - // vec3 * matrix4x4 - if (argumentValues[0].getType() == MiniScript::TYPE_VECTOR3 && - argumentValues[1].getType() == MiniScript::TYPE_MATRIX4x4) { - Vector3 a; - Matrix4x4 b; - MiniScript::getVector3Value(argumentValues, 0, a, false); - MiniScript::getMatrix4x4Value(argumentValues, 1, b, false); - returnValue.setValue(b * a); - } else - // matrix4x4 * float - if (argumentValues[0].getType() == MiniScript::TYPE_MATRIX4x4 && - MiniScript::ScriptVariable::isExpectedType(argumentValues[1].getType(), MiniScript::TYPE_PSEUDO_NUMBER) == true) { - Matrix4x4 a; - float b; - MiniScript::getMatrix4x4Value(argumentValues, 0, a, false); - MiniScript::getFloatValue(argumentValues, 1, b, false); - returnValue.setValue(a * b); - } else - // float * matrix4x4 - if (MiniScript::ScriptVariable::isExpectedType(argumentValues[0].getType(), MiniScript::TYPE_PSEUDO_NUMBER) == true && - argumentValues[1].getType() == MiniScript::TYPE_MATRIX4x4) { - float a; - Matrix4x4 b; - MiniScript::getFloatValue(argumentValues, 0, a, false); - MiniScript::getMatrix4x4Value(argumentValues, 1, b, false); - returnValue.setValue(b * a); - } else { - Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); - miniScript->startErrorScript(); - return; - } - } else - // matrix3x3 - if (MiniScript::hasType(argumentValues, MiniScript::TYPE_MATRIX3x3) == true) { - // matrix3x3 * matrix - if (argumentValues[0].getType() == MiniScript::TYPE_MATRIX3x3 && - argumentValues[1].getType() == MiniScript::TYPE_MATRIX3x3) { - Matrix3x3 a; - Matrix3x3 b; - MiniScript::getMatrix3x3Value(argumentValues, 0, a, false); - MiniScript::getMatrix3x3Value(argumentValues, 1, b, false); - returnValue.setValue(a * b); - } else - // matrix3x3 * vec2 - if (argumentValues[0].getType() == MiniScript::TYPE_MATRIX3x3 && - argumentValues[1].getType() == MiniScript::TYPE_VECTOR2) { - Matrix3x3 a; - Vector2 b; - MiniScript::getMatrix3x3Value(argumentValues, 0, a, false); - MiniScript::getVector2Value(argumentValues, 1, b, false); - returnValue.setValue(a * b); - } else - // vec2 * matrix3x3 - if (argumentValues[0].getType() == MiniScript::TYPE_VECTOR2 && - argumentValues[1].getType() == MiniScript::TYPE_MATRIX3x3) { - Vector2 a; - Matrix3x3 b; - MiniScript::getVector2Value(argumentValues, 0, a, false); - MiniScript::getMatrix3x3Value(argumentValues, 1, b, false); - returnValue.setValue(b * a); - } else - // matrix3x3 * float - if (argumentValues[0].getType() == MiniScript::TYPE_MATRIX3x3 && - MiniScript::ScriptVariable::isExpectedType(argumentValues[1].getType(), MiniScript::TYPE_PSEUDO_NUMBER) == true) { - Matrix3x3 a; - float b; - MiniScript::getMatrix3x3Value(argumentValues, 0, a, false); - MiniScript::getFloatValue(argumentValues, 1, b, false); - returnValue.setValue(a * b); - } else - // float * matrix3x3 - if (MiniScript::ScriptVariable::isExpectedType(argumentValues[0].getType(), MiniScript::TYPE_PSEUDO_NUMBER) == true && - argumentValues[1].getType() == MiniScript::TYPE_MATRIX3x3) { - float a; - Matrix3x3 b; - MiniScript::getFloatValue(argumentValues, 0, a, false); - MiniScript::getMatrix3x3Value(argumentValues, 1, b, false); - returnValue.setValue(b * a); - } else { - Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); - miniScript->startErrorScript(); - return; - } - } else - // quaternion - if (MiniScript::hasType(argumentValues, MiniScript::TYPE_QUATERNION) == true) { - // quaternion * quaternion - if (argumentValues[0].getType() == MiniScript::TYPE_QUATERNION && - argumentValues[1].getType() == MiniScript::TYPE_QUATERNION) { - Quaternion a; - Quaternion b; - MiniScript::getQuaternionValue(argumentValues, 0, a, false); - MiniScript::getQuaternionValue(argumentValues, 1, b, false); - returnValue.setValue(a * b); - } else - // quaternion * vec3 - if (argumentValues[0].getType() == MiniScript::TYPE_QUATERNION && - argumentValues[1].getType() == MiniScript::TYPE_VECTOR3) { - Quaternion a; - Vector3 b; - MiniScript::getQuaternionValue(argumentValues, 0, a, false); - MiniScript::getVector3Value(argumentValues, 1, b, false); - returnValue.setValue(a * b); - } else - // vec3 * quaternion - if (argumentValues[0].getType() == MiniScript::TYPE_VECTOR3 && - argumentValues[1].getType() == MiniScript::TYPE_QUATERNION) { - Vector3 a; - Quaternion b; - MiniScript::getVector3Value(argumentValues, 0, a, false); - MiniScript::getQuaternionValue(argumentValues, 1, b, false); - returnValue.setValue(b * a); - } else { - Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); - miniScript->startErrorScript(); - return; - } - } else - // vector2 - if (MiniScript::hasType(argumentValues, MiniScript::TYPE_VECTOR2) == true) { - float f; - // a - Vector2 a; - if (argumentValues[0].getType() == MiniScript::TYPE_VECTOR2) { - argumentValues[0].getVector2Value(a, false); - } else - if (MiniScript::getFloatValue(argumentValues, 0, f, false) == true) { - a = Vector2(f, f); - } else { - Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); - miniScript->startErrorScript(); - return; - } - // b - Vector2 b; - if (argumentValues[1].getType() == MiniScript::TYPE_VECTOR2) { - argumentValues[1].getVector2Value(b); - } else - if (MiniScript::getFloatValue(argumentValues, 1, f, false) == true) { - b = Vector2(f, f); - } else { - Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); - miniScript->startErrorScript(); - return; - } - // - returnValue.setValue(a.clone().scale(b)); - } else - // vector3 - if (MiniScript::hasType(argumentValues, MiniScript::TYPE_VECTOR3) == true) { - float f; - // a - Vector3 a; - if (argumentValues[0].getType() == MiniScript::TYPE_VECTOR3) { - argumentValues[0].getVector3Value(a, false); - } else - if (MiniScript::getFloatValue(argumentValues, 0, f, false) == true) { - a = Vector3(f, f, f); - } else { - Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); - miniScript->startErrorScript(); - return; - } - // b - Vector3 b; - if (argumentValues[1].getType() == MiniScript::TYPE_VECTOR3) { - argumentValues[1].getVector3Value(b); - } else - if (MiniScript::getFloatValue(argumentValues, 1, f, false) == true) { - b = Vector3(f, f, f); - } else { - Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); - miniScript->startErrorScript(); - return; - } - // - returnValue.setValue(a.clone().scale(b)); - } else - // vector4 - if (MiniScript::hasType(argumentValues, MiniScript::TYPE_VECTOR4) == true) { - float f; - // a - Vector4 a; - if (argumentValues[0].getType() == MiniScript::TYPE_VECTOR4) { - argumentValues[0].getVector4Value(a, false); - } else - if (MiniScript::getFloatValue(argumentValues, 0, f, false) == true) { - a = Vector4(f, f, f, f); - } else { - Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); - miniScript->startErrorScript(); - return; - } - // b - Vector4 b; - if (argumentValues[1].getType() == MiniScript::TYPE_VECTOR4) { - argumentValues[1].getVector4Value(b); - } else - if (MiniScript::getFloatValue(argumentValues, 1, f, false) == true) { - b = Vector4(f, f, f, f); - } else { - Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); - miniScript->startErrorScript(); - return; - } - // - returnValue.setValue(a.clone().scale(b)); - } else // float if (MiniScript::hasType(argumentValues, MiniScript::TYPE_FLOAT) == true) { float a; @@ -1262,71 +997,8 @@ void MiniScriptMath::div(const span& argumentValues, } // custom data types for (const auto scriptDataType: scriptDataTypes) { - if (scriptDataType->div(argumentValues, returnValue, statement) == true) return; + if (scriptDataType->div(miniScript, argumentValues, returnValue, statement) == true) return; } - // vector2 - if (argumentValues[0].getType() == MiniScript::TYPE_VECTOR2) { - Vector2 a; - Vector2 b; - float f; - // a - MiniScript::getVector2Value(argumentValues, 0, a, false); - // b - if (argumentValues[1].getType() == MiniScript::TYPE_VECTOR2 && - MiniScript::getVector2Value(argumentValues, 1, b, false) == true) { - // nop - } else - if (MiniScript::getFloatValue(argumentValues, 1, f, false) == true) { - b = Vector2(f, f); - } else { - Console::println("div(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("div")); - miniScript->startErrorScript(); - return; - } - returnValue.setValue(a / b); - } else - // vector3 - if (argumentValues[0].getType() == MiniScript::TYPE_VECTOR3) { - Vector3 a; - Vector3 b; - float f; - // a - MiniScript::getVector3Value(argumentValues, 0, a, false); - // b - if (argumentValues[1].getType() == MiniScript::TYPE_VECTOR3 && - MiniScript::getVector3Value(argumentValues, 1, b, false) == true) { - // nop - } else - if (MiniScript::getFloatValue(argumentValues, 1, f, false) == true) { - b = Vector3(f, f, f); - } else { - Console::println("div(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("div")); - miniScript->startErrorScript(); - return; - } - returnValue.setValue(a / b); - } else - // vector4 - if (argumentValues[0].getType() == MiniScript::TYPE_VECTOR4) { - Vector4 a; - Vector4 b; - float f; - // a - MiniScript::getVector4Value(argumentValues, 0, a, false); - // b - if (argumentValues[1].getType() == MiniScript::TYPE_VECTOR4 && - MiniScript::getVector4Value(argumentValues, 1, b, false) == true) { - // nop - } else - if (MiniScript::getFloatValue(argumentValues, 1, f, false) == true) { - b = Vector4(f, f, f, f); - } else { - Console::println("div(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("div")); - miniScript->startErrorScript(); - return; - } - returnValue.setValue(a / b); - } else // float if (MiniScript::hasType(argumentValues, MiniScript::TYPE_FLOAT) == true) { float a; @@ -1362,7 +1034,7 @@ void MiniScriptMath::add(const span& argumentValues, } // custom data types for (const auto scriptDataType: scriptDataTypes) { - if (scriptDataType->add(argumentValues, returnValue, statement) == true) return; + if (scriptDataType->add(miniScript, argumentValues, returnValue, statement) == true) return; } // string concatenation if (MiniScript::hasType(argumentValues, MiniScript::TYPE_STRING) == true) { @@ -1372,58 +1044,6 @@ void MiniScriptMath::add(const span& argumentValues, } returnValue.setValue(result); } else - // vector2 - if (MiniScript::hasType(argumentValues, MiniScript::TYPE_VECTOR2) == true) { - Vector2 a; - Vector2 b; - if (MiniScript::getVector2Value(argumentValues, 0, a, false) == true && - MiniScript::getVector2Value(argumentValues, 1, b, false) == true) { - returnValue.setValue(a.clone().add(b)); - } else { - Console::println("add(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("add")); - miniScript->startErrorScript(); - return; - } - } else - // vector3 - if (MiniScript::hasType(argumentValues, MiniScript::TYPE_VECTOR3) == true) { - Vector3 a; - Vector3 b; - if (MiniScript::getVector3Value(argumentValues, 0, a, false) == true && - MiniScript::getVector3Value(argumentValues, 1, b, false) == true) { - returnValue.setValue(a.clone().add(b)); - } else { - Console::println("add(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("add")); - miniScript->startErrorScript(); - return; - } - } else - // vector4 - if (MiniScript::hasType(argumentValues, MiniScript::TYPE_VECTOR4) == true) { - Vector4 a; - Vector4 b; - if (MiniScript::getVector4Value(argumentValues, 0, a, false) == true && - MiniScript::getVector4Value(argumentValues, 1, b, false) == true) { - returnValue.setValue(a.clone().add(b)); - } else { - Console::println("add(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("add")); - miniScript->startErrorScript(); - return; - } - } else - // quaternion - if (MiniScript::hasType(argumentValues, MiniScript::TYPE_QUATERNION) == true) { - Quaternion a; - Quaternion b; - if (MiniScript::getQuaternionValue(argumentValues, 0, a, false) == true && - MiniScript::getQuaternionValue(argumentValues, 1, b, false) == true) { - returnValue.setValue(a.clone().add(b)); - } else { - Console::println("add(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("add")); - miniScript->startErrorScript(); - return; - } - } else // float if (MiniScript::hasType(argumentValues, MiniScript::TYPE_FLOAT) == true) { float a; @@ -1459,60 +1079,8 @@ void MiniScriptMath::sub(const span& argumentValues, } // custom data types for (const auto scriptDataType: scriptDataTypes) { - if (scriptDataType->sub(argumentValues, returnValue, statement) == true) return; + if (scriptDataType->sub(miniScript, argumentValues, returnValue, statement) == true) return; } - // vector2 - if (MiniScript::hasType(argumentValues, MiniScript::TYPE_VECTOR2) == true) { - Vector2 a; - Vector2 b; - if (MiniScript::getVector2Value(argumentValues, 0, a, false) == true && - MiniScript::getVector2Value(argumentValues, 1, b, false) == true) { - returnValue.setValue(a.clone().sub(b)); - } else { - Console::println("sub(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("sub")); - miniScript->startErrorScript(); - return; - } - } else - // vector3 - if (MiniScript::hasType(argumentValues, MiniScript::TYPE_VECTOR3) == true) { - Vector3 a; - Vector3 b; - if (MiniScript::getVector3Value(argumentValues, 0, a, false) == true && - MiniScript::getVector3Value(argumentValues, 1, b, false) == true) { - returnValue.setValue(a.clone().sub(b)); - } else { - Console::println("sub(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("sub")); - miniScript->startErrorScript(); - return; - } - } else - // vector4 - if (MiniScript::hasType(argumentValues, MiniScript::TYPE_VECTOR4) == true) { - Vector4 a; - Vector4 b; - if (MiniScript::getVector4Value(argumentValues, 0, a, false) == true && - MiniScript::getVector4Value(argumentValues, 1, b, false) == true) { - returnValue.setValue(a.clone().sub(b)); - } else { - Console::println("sub(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("sub")); - miniScript->startErrorScript(); - return; - } - } else - // quaternion - if (MiniScript::hasType(argumentValues, MiniScript::TYPE_QUATERNION) == true) { - Quaternion a; - Quaternion b; - if (MiniScript::getQuaternionValue(argumentValues, 0, a, false) == true && - MiniScript::getQuaternionValue(argumentValues, 1, b, false) == true) { - returnValue.setValue(a.clone().sub(b)); - } else { - Console::println("sub(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("sub")); - miniScript->startErrorScript(); - return; - } - } else // float if (MiniScript::hasType(argumentValues, MiniScript::TYPE_FLOAT) == true) { float a; diff --git a/src/tdme/utilities/MiniScriptMath.h b/src/tdme/utilities/MiniScriptMath.h index 605870a8a..81eda5bac 100644 --- a/src/tdme/utilities/MiniScriptMath.h +++ b/src/tdme/utilities/MiniScriptMath.h @@ -3,19 +3,11 @@ #include #include -#include -#include -#include -#include #include -#include using std::span; using tdme::math::Math; -using tdme::math::Vector2; -using tdme::math::Vector3; -using tdme::math::Vector4; using tdme::utilities::MiniScript; using tdme::utilities::MiniScriptMath; diff --git a/src/tdme/utilities/MiniScriptMatrix3x3.cpp b/src/tdme/utilities/MiniScriptMatrix3x3.cpp new file mode 100644 index 000000000..2abaf0e94 --- /dev/null +++ b/src/tdme/utilities/MiniScriptMatrix3x3.cpp @@ -0,0 +1,404 @@ +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +using std::span; +using std::string; + +using tdme::math::Matrix3x3; +using tdme::math::Vector2; +using tdme::utilities::Float; +using tdme::utilities::MiniScript; +using tdme::utilities::MiniScriptMatrix3x3; +using tdme::utilities::MiniScriptVector2; + +const string MiniScriptMatrix3x3::CLASS_NAME = "mat3"; +const string MiniScriptMatrix3x3::TYPE_NAME = "Matrix3x3"; + +void MiniScriptMatrix3x3::registerMethods(MiniScript* miniScript) const { + const auto TYPE_MATRIX3x3 = static_cast(getType()); + const auto TYPE_VECTOR2 = static_cast(miniScript->getDataTypeByClassName("vec2")->getType()); + // + { + // + class ScriptMethodMatrix3x3Identity: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_MATRIX3x3; + public: + ScriptMethodMatrix3x3Identity( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_MATRIX3x3 + ): + MiniScript::ScriptMethod({}, TYPE_MATRIX3x3), + miniScript(miniScript), TYPE_MATRIX3x3(TYPE_MATRIX3x3) {} + const string getMethodName() override { + return "mat3.identity"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + const auto result = Matrix3x3().identity(); + returnValue.setType(TYPE_MATRIX3x3); + returnValue.setValue(&result); + } + }; + miniScript->registerMethod(new ScriptMethodMatrix3x3Identity(miniScript, TYPE_MATRIX3x3)); + } + { + // + class ScriptMethodMatrix3x3Translate: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_MATRIX3x3; + MiniScript::ScriptVariableType TYPE_VECTOR2; + public: + ScriptMethodMatrix3x3Translate( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_MATRIX3x3, + MiniScript::ScriptVariableType TYPE_VECTOR2 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR2, .name = "translation", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_MATRIX3x3 + ), + miniScript(miniScript), TYPE_MATRIX3x3(TYPE_MATRIX3x3), TYPE_VECTOR2(TYPE_VECTOR2) {} + const string getMethodName() override { + return "mat3.translate"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector2 translation; + if (MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 0, translation, false) == true) { + const auto result = Matrix3x3().identity().setTranslation(translation); + returnValue.setType(TYPE_MATRIX3x3); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodMatrix3x3Translate(miniScript, TYPE_MATRIX3x3, TYPE_VECTOR2)); + } + { + // + class ScriptMethodMatrix3x3Rotate: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_MATRIX3x3; + public: + ScriptMethodMatrix3x3Rotate( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_MATRIX3x3 + ): + MiniScript::ScriptMethod( + { + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_MATRIX3x3 + ), + miniScript(miniScript), TYPE_MATRIX3x3(TYPE_MATRIX3x3) {} + const string getMethodName() override { + return "mat3.rotate"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + float angle; + if (MiniScript::getFloatValue(argumentValues, 0, angle, false) == true) { + const auto result = Matrix3x3().identity().setAxes(angle); + returnValue.setType(TYPE_MATRIX3x3); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodMatrix3x3Rotate(miniScript, TYPE_MATRIX3x3)); + } + { + // + class ScriptMethodMatrix3x3RotateAroundTextureCenter: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_MATRIX3x3; + public: + ScriptMethodMatrix3x3RotateAroundTextureCenter( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_MATRIX3x3 + ): + MiniScript::ScriptMethod( + { + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_MATRIX3x3 + ), + miniScript(miniScript), TYPE_MATRIX3x3(TYPE_MATRIX3x3) {} + const string getMethodName() override { + return "mat3.rotateAroundTextureCenter"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + float angle; + if (MiniScript::getFloatValue(argumentValues, 0, angle, false) == true) { + const auto result = Matrix3x3::rotateAroundTextureCenter(angle); + returnValue.setType(TYPE_MATRIX3x3); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodMatrix3x3RotateAroundTextureCenter(miniScript, TYPE_MATRIX3x3)); + } + { + // + class ScriptMethodMatrix3x3RotateAroundPoint: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_MATRIX3x3; + MiniScript::ScriptVariableType TYPE_VECTOR2; + public: + ScriptMethodMatrix3x3RotateAroundPoint( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_MATRIX3x3, + MiniScript::ScriptVariableType TYPE_VECTOR2 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR2, .name = "point", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_MATRIX3x3 + ), + miniScript(miniScript), TYPE_MATRIX3x3(TYPE_MATRIX3x3), TYPE_VECTOR2(TYPE_VECTOR2) {} + const string getMethodName() override { + return "mat3.rotateAroundPoint"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector2 point; + float angle; + if (MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 0, point, false) == true && + MiniScript::getFloatValue(argumentValues, 1, angle, false) == true) { + const auto result = Matrix3x3().rotateAroundPoint(point, angle); + returnValue.setType(TYPE_MATRIX3x3); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodMatrix3x3RotateAroundPoint(miniScript, TYPE_MATRIX3x3, TYPE_VECTOR2)); + } + { + // + class ScriptMethodMatrix3x3Scale: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_MATRIX3x3; + MiniScript::ScriptVariableType TYPE_VECTOR2; + public: + ScriptMethodMatrix3x3Scale( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_MATRIX3x3, + MiniScript::ScriptVariableType TYPE_VECTOR2 + ): + MiniScript::ScriptMethod({}, TYPE_MATRIX3x3), + miniScript(miniScript), TYPE_MATRIX3x3(TYPE_MATRIX3x3), TYPE_VECTOR2(TYPE_VECTOR2) {} + const string getMethodName() override { + return "mat3.scale"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector2 vec2Value; + float floatValue; + if (MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 0, vec2Value, false) == true) { + const auto result = Matrix3x3().identity().scale(vec2Value); + returnValue.setType(TYPE_MATRIX3x3); + returnValue.setValue(&result); + } else + if (MiniScript::getFloatValue(argumentValues, 0, floatValue, false) == true) { + const auto result = Matrix3x3().identity().scale(floatValue); + returnValue.setType(TYPE_MATRIX3x3); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + bool isVariadic() const override { + return true; + } + + }; + miniScript->registerMethod(new ScriptMethodMatrix3x3Scale(miniScript, TYPE_MATRIX3x3, TYPE_VECTOR2)); + } +} + +void MiniScriptMatrix3x3::unsetScriptVariableValue(MiniScript::ScriptVariable& variable) const { + if (variable.getType() != getType()) return; + if (variable.getValuePtr() == 0ll) return; + // + delete static_cast((void*)variable.getValuePtr()); + variable.setValuePtr(0ll); +} + +void MiniScriptMatrix3x3::setScriptVariableValue(MiniScript::ScriptVariable& variable, const void* value) const { + if (variable.getType() != getType()) return; + // + Matrix3x3 matrix3x3Value; + if (value != 0ll) { + matrix3x3Value = *static_cast(value); + } + // + if (variable.getValuePtr() != 0ll) { + *static_cast((void*)variable.getValuePtr()) = matrix3x3Value; + return; + } + // + variable.setValuePtr((uint64_t)(new Matrix3x3(matrix3x3Value))); +} + +void MiniScriptMatrix3x3::copyScriptVariable(MiniScript::ScriptVariable& to, const MiniScript::ScriptVariable& from) const { + // + Matrix3x3 matrix3x3Value; + if (from.getType() == getType() && from.getValuePtr() != 0ll) { + matrix3x3Value = *static_cast((void*)from.getValuePtr()); + } + // + const auto TYPE_MATRIX3x3 = static_cast(getType()); + to.setType(TYPE_MATRIX3x3); + *static_cast((void*)to.getValuePtr()) = matrix3x3Value; +} + +bool MiniScriptMatrix3x3::mul(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_MATRIX3x3 = static_cast(getType()); + const auto TYPE_VECTOR2 = static_cast(miniScript->getDataTypeByClassName("vec2")->getType()); + // + if (MiniScript::hasType(argumentValues, TYPE_MATRIX3x3) == true) { + // matrix3x3 * matrix + if (argumentValues[0].getType() == TYPE_MATRIX3x3 && + argumentValues[1].getType() == TYPE_MATRIX3x3) { + Matrix3x3 a; + Matrix3x3 b; + MiniScriptMatrix3x3::getMatrix3x3Value(TYPE_MATRIX3x3, argumentValues, 0, a, false); + MiniScriptMatrix3x3::getMatrix3x3Value(TYPE_MATRIX3x3, argumentValues, 1, b, false); + // + const auto result = a * b; + returnValue.setType(TYPE_MATRIX3x3); + returnValue.setValue(&result); + // + return true; + } else + // matrix3x3 * vec2 + if (argumentValues[0].getType() == TYPE_MATRIX3x3 && + argumentValues[1].getType() == TYPE_VECTOR2) { + Matrix3x3 a; + Vector2 b; + MiniScriptMatrix3x3::getMatrix3x3Value(TYPE_MATRIX3x3, argumentValues, 0, a, false); + MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 1, b, false); + // + const auto result = a * b; + returnValue.setType(TYPE_VECTOR2); + returnValue.setValue(&result); + // + return true; + } else + // vec2 * matrix3x3 + if (argumentValues[0].getType() == TYPE_VECTOR2 && + argumentValues[1].getType() == TYPE_MATRIX3x3) { + Vector2 a; + Matrix3x3 b; + MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 0, a, false); + MiniScriptMatrix3x3::getMatrix3x3Value(TYPE_MATRIX3x3, argumentValues, 1, b, false); + // + const auto result = b * a; + returnValue.setType(TYPE_VECTOR2); + returnValue.setValue(&result); + // + return true; + } else + // matrix3x3 * float + if (argumentValues[0].getType() == TYPE_MATRIX3x3 && + MiniScript::ScriptVariable::isExpectedType(argumentValues[1].getType(), MiniScript::TYPE_PSEUDO_NUMBER) == true) { + Matrix3x3 a; + float b; + MiniScriptMatrix3x3::getMatrix3x3Value(TYPE_MATRIX3x3, argumentValues, 0, a, false); + MiniScript::getFloatValue(argumentValues, 1, b, false); + // + const auto result = a * b; + returnValue.setType(TYPE_MATRIX3x3); + returnValue.setValue(&result); + // + return true; + } else + // float * matrix3x3 + if (MiniScript::ScriptVariable::isExpectedType(argumentValues[0].getType(), MiniScript::TYPE_PSEUDO_NUMBER) == true && + argumentValues[1].getType() == TYPE_MATRIX3x3) { + float a; + Matrix3x3 b; + MiniScript::getFloatValue(argumentValues, 0, a, false); + MiniScriptMatrix3x3::getMatrix3x3Value(TYPE_MATRIX3x3, argumentValues, 1, b, false); + // + const auto result = b * a; + returnValue.setType(TYPE_MATRIX3x3); + returnValue.setValue(&result); + // + return true; + } else { + Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); + miniScript->startErrorScript(); + // + return false; + } + } + // + return false; +} + +bool MiniScriptMatrix3x3::div(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + return false; +} + +bool MiniScriptMatrix3x3::add(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + return false; +} + +bool MiniScriptMatrix3x3::sub(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + return false; +} + +const string& MiniScriptMatrix3x3::getClassName() const { + return CLASS_NAME; +} + +const string& MiniScriptMatrix3x3::getTypeAsString() const { + return TYPE_NAME; +} + +const string MiniScriptMatrix3x3::getValueAsString(const MiniScript::ScriptVariable& variable) const { + // + Matrix3x3 matrix3x3Value; + if (variable.getType() == getType() && variable.getValuePtr() != 0ll) { + matrix3x3Value = *static_cast((void*)variable.getValuePtr()); + } + return + "Matrix3x3(" + + to_string(matrix3x3Value[0]) + ", " + + to_string(matrix3x3Value[1]) + ", " + + to_string(matrix3x3Value[2]) + ", " + + to_string(matrix3x3Value[3]) + ", " + + to_string(matrix3x3Value[4]) + ", " + + to_string(matrix3x3Value[5]) + ", " + + to_string(matrix3x3Value[6]) + ", " + + to_string(matrix3x3Value[7]) + ", " + + to_string(matrix3x3Value[8]) + ")"; + +} + diff --git a/src/tdme/utilities/MiniScriptMatrix3x3.h b/src/tdme/utilities/MiniScriptMatrix3x3.h new file mode 100644 index 000000000..0c297cc75 --- /dev/null +++ b/src/tdme/utilities/MiniScriptMatrix3x3.h @@ -0,0 +1,71 @@ +#pragma once + +#include + +#include +#include +#include + +using std::span; + +using tdme::math::Matrix3x3; +using tdme::utilities::MiniScript; + +/** + * MiniScript Matrix3x3 data type + * @author Andreas Drewke + */ +class tdme::utilities::MiniScriptMatrix3x3 final: public MiniScript::ScriptDataType { +private: + // overridden methods + void registerMethods(MiniScript* miniScript) const override; + void unsetScriptVariableValue(MiniScript::ScriptVariable& variable) const override; + void setScriptVariableValue(MiniScript::ScriptVariable& variable, const void* value) const override; + void copyScriptVariable(MiniScript::ScriptVariable& to, const MiniScript::ScriptVariable& from) const override; + bool mul(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool div(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool add(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool sub(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + +public: + static const string CLASS_NAME; + static const string TYPE_NAME; + + /** + * Get matrix3x3 value from given variable + * @param TYPE_MATRIX3x3 custom data type for vector3 + * @param arguments arguments + * @param idx argument index + * @param value value + * @param optional optional + * @return success + */ + static inline bool getMatrix3x3Value(MiniScript::ScriptVariableType TYPE_MATRIX3x3, const span& arguments, int idx, Matrix3x3& value, bool optional = false) { + if (idx >= arguments.size()) return optional; + const auto& argument = arguments[idx]; + if (argument.getType() == TYPE_MATRIX3x3) { + if (argument.getValuePtr() == 0ll) return optional; + value = *static_cast((void*)argument.getValuePtr()); + return true; + } + return optional; + + } + + // forbid class copy + FORBID_CLASS_COPY(MiniScriptMatrix3x3) + + /** + * MiniScript Matrix3x3 data type + * @param miniScript mini script instance + */ + MiniScriptMatrix3x3(): MiniScript::ScriptDataType(true) { + // + } + + // overridden methods + const string& getClassName() const override; + const string& getTypeAsString() const override; + const string getValueAsString(const MiniScript::ScriptVariable& variable) const override; + +}; diff --git a/src/tdme/utilities/MiniScriptMatrix4x4.cpp b/src/tdme/utilities/MiniScriptMatrix4x4.cpp new file mode 100644 index 000000000..7f9d1b8c8 --- /dev/null +++ b/src/tdme/utilities/MiniScriptMatrix4x4.cpp @@ -0,0 +1,444 @@ +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +using std::span; +using std::string; + +using tdme::math::Matrix4x4; +using tdme::utilities::Float; +using tdme::utilities::MiniScript; +using tdme::utilities::MiniScriptMatrix4x4; +using tdme::utilities::MiniScriptVector3; +using tdme::utilities::MiniScriptVector4; + +const string MiniScriptMatrix4x4::CLASS_NAME = "mat4"; +const string MiniScriptMatrix4x4::TYPE_NAME = "Matrix4x4"; + +void MiniScriptMatrix4x4::registerMethods(MiniScript* miniScript) const { + const auto TYPE_MATRIX4x4 = static_cast(getType()); + const auto TYPE_VECTOR3 = static_cast(miniScript->getDataTypeByClassName("vec3")->getType()); + // + { + // + class ScriptMethodMatrix4x4Identity: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_MATRIX4x4; + public: + ScriptMethodMatrix4x4Identity( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_MATRIX4x4 + ): + MiniScript::ScriptMethod({}, TYPE_MATRIX4x4), + miniScript(miniScript), TYPE_MATRIX4x4(TYPE_MATRIX4x4) {} + const string getMethodName() override { + return "mat4.identity"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + const auto result = Matrix4x4().identity(); + returnValue.setType(TYPE_MATRIX4x4); + returnValue.setValue(&result); + } + }; + miniScript->registerMethod(new ScriptMethodMatrix4x4Identity(miniScript, TYPE_MATRIX4x4)); + } + { + // + class ScriptMethodMatrix4x4Translate: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_MATRIX4x4; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodMatrix4x4Translate( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_MATRIX4x4, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR3, .name = "translation", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_MATRIX4x4 + ), + miniScript(miniScript), TYPE_MATRIX4x4(TYPE_MATRIX4x4), TYPE_VECTOR3(TYPE_VECTOR3) {} + const string getMethodName() override { + return "mat4.translate"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector3 translation; + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, translation, false) == true) { + const auto result = Matrix4x4().identity().setTranslation(translation); + returnValue.setType(TYPE_MATRIX4x4); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodMatrix4x4Translate(miniScript, TYPE_MATRIX4x4, TYPE_VECTOR3)); + } + { + // + class ScriptMethodMatrix4x4Rotate: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_MATRIX4x4; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodMatrix4x4Rotate( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_MATRIX4x4, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR3, .name = "axis", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_MATRIX4x4 + ), + miniScript(miniScript), TYPE_MATRIX4x4(TYPE_MATRIX4x4), TYPE_VECTOR3(TYPE_VECTOR3) {} + const string getMethodName() override { + return "mat4.rotate"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector3 axis; + float angle; + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, axis, false) == true && + MiniScript::getFloatValue(argumentValues, 1, angle, false) == true) { + const auto result = Matrix4x4().identity().setAxes(axis, angle); + returnValue.setType(TYPE_MATRIX4x4); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodMatrix4x4Rotate(miniScript, TYPE_MATRIX4x4, TYPE_VECTOR3)); + } + { + // + class ScriptMethodMatrix4x4Scale: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_MATRIX4x4; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodMatrix4x4Scale( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_MATRIX4x4, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod({}, TYPE_MATRIX4x4), + miniScript(miniScript), TYPE_MATRIX4x4(TYPE_MATRIX4x4), TYPE_VECTOR3(TYPE_VECTOR3) {} + const string getMethodName() override { + return "mat4.scale"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector3 vec3Value; + float floatValue; + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, vec3Value, false) == true) { + const auto result = Matrix4x4().identity().scale(vec3Value); + returnValue.setType(TYPE_MATRIX4x4); + returnValue.setValue(&result); + } else + if (MiniScript::getFloatValue(argumentValues, 0, floatValue, false) == true) { + const auto result = Matrix4x4().identity().scale(floatValue); + returnValue.setType(TYPE_MATRIX4x4); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + bool isVariadic() const override { + return true; + } + + }; + miniScript->registerMethod(new ScriptMethodMatrix4x4Scale(miniScript, TYPE_MATRIX4x4, TYPE_VECTOR3)); + } + { + // + class ScriptMethodMatrix4x4Invert: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_MATRIX4x4; + public: + ScriptMethodMatrix4x4Invert( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_MATRIX4x4 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_MATRIX4x4, .name = "mat4", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_MATRIX4x4 + ), + miniScript(miniScript), TYPE_MATRIX4x4(TYPE_MATRIX4x4) {} + const string getMethodName() override { + return "mat4.invert"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Matrix4x4 mat4; + if (MiniScriptMatrix4x4::getMatrix4x4Value(TYPE_MATRIX4x4, argumentValues, 0, mat4, false) == true) { + const auto result = mat4.invert(); + returnValue.setType(TYPE_MATRIX4x4); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodMatrix4x4Invert(miniScript, TYPE_MATRIX4x4)); + } + { + // + class ScriptMethodMatrix4x4EulerAngles: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_MATRIX4x4; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodMatrix4x4EulerAngles( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_MATRIX4x4, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_MATRIX4x4, .name = "mat4", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_VECTOR3 + ), + miniScript(miniScript), TYPE_MATRIX4x4(TYPE_MATRIX4x4), TYPE_VECTOR3(TYPE_VECTOR3) {} + const string getMethodName() override { + return "mat4.computeEulerAngles"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Matrix4x4 mat4; + if (MiniScriptMatrix4x4::getMatrix4x4Value(TYPE_MATRIX4x4, argumentValues, 0, mat4, false) == true) { + const auto result = mat4.computeEulerAngles(); + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodMatrix4x4EulerAngles(miniScript, TYPE_MATRIX4x4, TYPE_VECTOR3)); + } +} + +void MiniScriptMatrix4x4::unsetScriptVariableValue(MiniScript::ScriptVariable& variable) const { + if (variable.getType() != getType()) return; + if (variable.getValuePtr() == 0ll) return; + // + delete static_cast((void*)variable.getValuePtr()); + variable.setValuePtr(0ll); +} + +void MiniScriptMatrix4x4::setScriptVariableValue(MiniScript::ScriptVariable& variable, const void* value) const { + if (variable.getType() != getType()) return; + // + Matrix4x4 matrix4x4Value; + if (value != 0ll) { + matrix4x4Value = *static_cast(value); + } + // + if (variable.getValuePtr() != 0ll) { + *static_cast((void*)variable.getValuePtr()) = matrix4x4Value; + return; + } + // + variable.setValuePtr((uint64_t)(new Matrix4x4(matrix4x4Value))); +} + +void MiniScriptMatrix4x4::copyScriptVariable(MiniScript::ScriptVariable& to, const MiniScript::ScriptVariable& from) const { + // + Matrix4x4 matrix4x4Value; + if (from.getType() == getType() && from.getValuePtr() != 0ll) { + matrix4x4Value = *static_cast((void*)from.getValuePtr()); + } + // + const auto TYPE_MATRIX4x4 = static_cast(getType()); + to.setType(TYPE_MATRIX4x4); + *static_cast((void*)to.getValuePtr()) = matrix4x4Value; +} + +bool MiniScriptMatrix4x4::mul(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_MATRIX4x4 = static_cast(getType()); + const auto TYPE_VECTOR3 = static_cast(miniScript->getDataTypeByClassName("vec3")->getType()); + const auto TYPE_VECTOR4 = static_cast(miniScript->getDataTypeByClassName("vec4")->getType()); + // + if (MiniScript::hasType(argumentValues, TYPE_MATRIX4x4) == true) { + // matrix4x4 * matrix + if (argumentValues[0].getType() == TYPE_MATRIX4x4 && + argumentValues[1].getType() == TYPE_MATRIX4x4) { + Matrix4x4 a; + Matrix4x4 b; + MiniScriptMatrix4x4::getMatrix4x4Value(TYPE_MATRIX4x4, argumentValues, 0, a, false); + MiniScriptMatrix4x4::getMatrix4x4Value(TYPE_MATRIX4x4, argumentValues, 1, b, false); + // + const auto result = a * b; + returnValue.setType(TYPE_MATRIX4x4); + returnValue.setValue(&result); + // + return true; + } else + // matrix4x4 * vec4 + if (argumentValues[0].getType() == TYPE_MATRIX4x4 && + argumentValues[1].getType() == TYPE_VECTOR4) { + Matrix4x4 a; + Vector4 b; + MiniScriptMatrix4x4::getMatrix4x4Value(TYPE_MATRIX4x4, argumentValues, 0, a, false); + MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 1, b, false); + // + const auto result = a * b; + returnValue.setType(TYPE_VECTOR4); + returnValue.setValue(&result); + // + return true; + } else + // vec4 * matrix4x4 + if (argumentValues[0].getType() == TYPE_VECTOR4 && + argumentValues[1].getType() == TYPE_MATRIX4x4) { + Vector4 a; + Matrix4x4 b; + MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 0, a, false); + MiniScriptMatrix4x4::getMatrix4x4Value(TYPE_MATRIX4x4, argumentValues, 1, b, false); + // + const auto result = b * a; + returnValue.setType(TYPE_VECTOR4); + returnValue.setValue(&result); + // + return true; + + } else + // matrix4x4 * vec3 + if (argumentValues[0].getType() == TYPE_MATRIX4x4 && + argumentValues[1].getType() == TYPE_VECTOR3) { + Matrix4x4 a; + Vector3 b; + MiniScriptMatrix4x4::getMatrix4x4Value(TYPE_MATRIX4x4, argumentValues, 0, a, false); + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false); + // + const auto result = a * b; + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + // + return true; + } else + // vec3 * matrix4x4 + if (argumentValues[0].getType() == TYPE_VECTOR3 && + argumentValues[1].getType() == TYPE_MATRIX4x4) { + Vector3 a; + Matrix4x4 b; + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false); + MiniScriptMatrix4x4::getMatrix4x4Value(TYPE_MATRIX4x4, argumentValues, 1, b, false); + // + const auto result = b * a; + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + // + return true; + } else + // matrix4x4 * float + if (argumentValues[0].getType() == TYPE_MATRIX4x4 && + MiniScript::ScriptVariable::isExpectedType(argumentValues[1].getType(), MiniScript::TYPE_PSEUDO_NUMBER) == true) { + Matrix4x4 a; + float b; + MiniScriptMatrix4x4::getMatrix4x4Value(TYPE_MATRIX4x4, argumentValues, 0, a, false); + MiniScript::getFloatValue(argumentValues, 1, b, false); + // + const auto result = a * b; + returnValue.setType(TYPE_MATRIX4x4); + returnValue.setValue(&result); + // + return true; + + } else + // float * matrix4x4 + if (MiniScript::ScriptVariable::isExpectedType(argumentValues[0].getType(), MiniScript::TYPE_PSEUDO_NUMBER) == true && + argumentValues[1].getType() == TYPE_MATRIX4x4) { + float a; + Matrix4x4 b; + MiniScript::getFloatValue(argumentValues, 0, a, false); + MiniScriptMatrix4x4::getMatrix4x4Value(TYPE_MATRIX4x4, argumentValues, 1, b, false); + // + const auto result = b * a; + returnValue.setType(TYPE_MATRIX4x4); + returnValue.setValue(&result); + // + return true; + } else { + Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); + miniScript->startErrorScript(); + // + return false; + } + } + // + return false; +} + +bool MiniScriptMatrix4x4::div(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + return false; +} + +bool MiniScriptMatrix4x4::add(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + return false; +} + +bool MiniScriptMatrix4x4::sub(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + return false; +} + +const string& MiniScriptMatrix4x4::getClassName() const { + return CLASS_NAME; +} + +const string& MiniScriptMatrix4x4::getTypeAsString() const { + return TYPE_NAME; +} + +const string MiniScriptMatrix4x4::getValueAsString(const MiniScript::ScriptVariable& variable) const { + // + Matrix4x4 matrix4x4Value; + if (variable.getType() == getType() && variable.getValuePtr() != 0ll) { + matrix4x4Value = *static_cast((void*)variable.getValuePtr()); + } + return + "Matrix4x4(" + + to_string(matrix4x4Value[0]) + ", " + + to_string(matrix4x4Value[1]) + ", " + + to_string(matrix4x4Value[2]) + ", " + + to_string(matrix4x4Value[3]) + ", " + + to_string(matrix4x4Value[4]) + ", " + + to_string(matrix4x4Value[5]) + ", " + + to_string(matrix4x4Value[6]) + ", " + + to_string(matrix4x4Value[7]) + ", " + + to_string(matrix4x4Value[8]) + ", " + + to_string(matrix4x4Value[9]) + ", " + + to_string(matrix4x4Value[10]) + ", " + + to_string(matrix4x4Value[11]) + ", " + + to_string(matrix4x4Value[12]) + ", " + + to_string(matrix4x4Value[13]) + ", " + + to_string(matrix4x4Value[14]) + ", " + + to_string(matrix4x4Value[15]) + ")"; + +} + diff --git a/src/tdme/utilities/MiniScriptMatrix4x4.h b/src/tdme/utilities/MiniScriptMatrix4x4.h new file mode 100644 index 000000000..1ee00dec9 --- /dev/null +++ b/src/tdme/utilities/MiniScriptMatrix4x4.h @@ -0,0 +1,69 @@ +#pragma once + +#include + +#include +#include +#include + +using std::span; + +using tdme::math::Matrix4x4; +using tdme::utilities::MiniScript; + +/** + * MiniScript Matrix4x4 data type + * @author Andreas Drewke + */ +class tdme::utilities::MiniScriptMatrix4x4 final: public MiniScript::ScriptDataType { +private: + // overridden methods + void registerMethods(MiniScript* miniScript) const override; + void unsetScriptVariableValue(MiniScript::ScriptVariable& variable) const override; + void setScriptVariableValue(MiniScript::ScriptVariable& variable, const void* value) const override; + void copyScriptVariable(MiniScript::ScriptVariable& to, const MiniScript::ScriptVariable& from) const override; + bool mul(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool div(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool add(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool sub(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + +public: + static const string CLASS_NAME; + static const string TYPE_NAME; + + /** + * Get matrix4x4 value from given variable + * @param TYPE_MATRIX4x4 custom data type for vector3 + * @param arguments arguments + * @param idx argument index + * @param value value + * @param optional optional + * @return success + */ + static inline bool getMatrix4x4Value(MiniScript::ScriptVariableType TYPE_MATRIX4x4, const span& arguments, int idx, Matrix4x4& value, bool optional = false) { + if (idx >= arguments.size()) return optional; + const auto& argument = arguments[idx]; + if (argument.getType() == TYPE_MATRIX4x4) { + if (argument.getValuePtr() == 0ll) return optional; + value = *static_cast((void*)argument.getValuePtr()); + return true; + } + return optional; + } + + // forbid class copy + FORBID_CLASS_COPY(MiniScriptMatrix4x4) + + /** + * MiniScript Matrix4x4 data type + */ + MiniScriptMatrix4x4(): MiniScript::ScriptDataType(true) { + // + } + + // overridden methods + const string& getClassName() const override; + const string& getTypeAsString() const override; + const string getValueAsString(const MiniScript::ScriptVariable& variable) const override; + +}; diff --git a/src/tdme/utilities/MiniScriptQuaternion.cpp b/src/tdme/utilities/MiniScriptQuaternion.cpp new file mode 100644 index 000000000..846164633 --- /dev/null +++ b/src/tdme/utilities/MiniScriptQuaternion.cpp @@ -0,0 +1,424 @@ +#include +#include + +#include + +#include +#include +#include +#include +#include +#include + +using std::span; +using std::string; + +using tdme::utilities::MiniScriptQuaternion; + +using tdme::math::Quaternion; +using tdme::utilities::Float; +using tdme::utilities::MiniScript; +using tdme::utilities::MiniScriptMatrix4x4; +using tdme::utilities::MiniScriptVector3; + +const string MiniScriptQuaternion::CLASS_NAME = "quaternion"; +const string MiniScriptQuaternion::TYPE_NAME = "Quaternion"; + +void MiniScriptQuaternion::registerMethods(MiniScript* miniScript) const { + const auto TYPE_QUATERNION = static_cast(getType()); + const auto TYPE_VECTOR3 = static_cast(miniScript->getDataTypeByClassName("vec3")->getType()); + const auto TYPE_MATRIX4x4 = static_cast(miniScript->getDataTypeByClassName("mat4")->getType()); + { + // + class ScriptMethodQuaternionIdentity: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_QUATERNION; + public: + ScriptMethodQuaternionIdentity( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_QUATERNION + ): + MiniScript::ScriptMethod({}, TYPE_QUATERNION), + miniScript(miniScript), TYPE_QUATERNION(TYPE_QUATERNION) { + // + } + const string getMethodName() override { + return "quaternion.identity"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + auto result = Quaternion().identity(); + returnValue.setType(TYPE_QUATERNION); + returnValue.setValue(&result); + } + }; + miniScript->registerMethod(new ScriptMethodQuaternionIdentity(miniScript, TYPE_QUATERNION)); + } + { + // + class ScriptMethodQuaternionInvert: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_QUATERNION; + public: + ScriptMethodQuaternionInvert( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_QUATERNION + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_QUATERNION, .name = "quaternion", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_QUATERNION + ), + miniScript(miniScript), TYPE_QUATERNION(TYPE_QUATERNION) { + // + } + const string getMethodName() override { + return "quaternion.invert"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Quaternion quaternion; + if (MiniScriptQuaternion::getQuaternionValue(TYPE_QUATERNION, argumentValues, 0, quaternion, false) == true) { + auto result = quaternion.invert(); + returnValue.setType(TYPE_QUATERNION); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodQuaternionInvert(miniScript, TYPE_QUATERNION)); + } + { + // + class ScriptMethodQuaternionRotate: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_QUATERNION; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodQuaternionRotate( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_QUATERNION, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR3, .name = "axis", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false } + }, + TYPE_QUATERNION + ), + miniScript(miniScript), + TYPE_QUATERNION(TYPE_QUATERNION), + TYPE_VECTOR3(TYPE_VECTOR3) { + // + } + const string getMethodName() override { + return "quaternion.rotate"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector3 axis; + float angle; + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, axis, false) == true && + MiniScript::getFloatValue(argumentValues, 1, angle, false) == true) { + auto result = Quaternion().rotate(axis, angle); + returnValue.setType(TYPE_QUATERNION); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodQuaternionRotate(miniScript, TYPE_QUATERNION, TYPE_VECTOR3)); + } + { + // + class ScriptMethodQuaternionNormalize: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_QUATERNION; + public: + ScriptMethodQuaternionNormalize( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_QUATERNION + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_QUATERNION, .name = "quaternion", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_QUATERNION + ), + miniScript(miniScript), TYPE_QUATERNION(TYPE_QUATERNION) {} + const string getMethodName() override { + return "quaternion.normalize"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Quaternion quaternion; + if (MiniScriptQuaternion::getQuaternionValue(TYPE_QUATERNION, argumentValues, 0, quaternion, false) == true) { + auto result = quaternion.normalize(); + returnValue.setType(TYPE_QUATERNION); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodQuaternionNormalize(miniScript, TYPE_QUATERNION)); + } + { + // + class ScriptMethodQuaternionInvert: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_QUATERNION; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodQuaternionInvert( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_QUATERNION, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_QUATERNION, .name = "quaternion", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_VECTOR3 + ), + miniScript(miniScript), + TYPE_QUATERNION(TYPE_QUATERNION), + TYPE_VECTOR3(TYPE_VECTOR3) { + // + } + const string getMethodName() override { + return "quaternion.computeEulerAngles"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Quaternion quaternion; + if (MiniScriptQuaternion::getQuaternionValue(TYPE_QUATERNION, argumentValues, 0, quaternion, false) == true) { + auto result = quaternion.computeEulerAngles(); + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodQuaternionInvert(miniScript, TYPE_QUATERNION, TYPE_VECTOR3)); + } + { + // + class ScriptMethodQuaternionComputeMatrix: public MiniScript::ScriptMethod { + private: + MiniScript::ScriptVariableType TYPE_QUATERNION; + MiniScript::ScriptVariableType TYPE_MATRIX4x4; + MiniScript* miniScript { nullptr }; + public: + ScriptMethodQuaternionComputeMatrix( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_QUATERNION, + MiniScript::ScriptVariableType TYPE_MATRIX4x4 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_QUATERNION, .name = "quaternion", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_MATRIX4x4 + ), + miniScript(miniScript), TYPE_QUATERNION(TYPE_QUATERNION), TYPE_MATRIX4x4(TYPE_MATRIX4x4) { + // + } + const string getMethodName() override { + return "quaternion.computeMatrix"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Quaternion quaternion; + if (MiniScriptQuaternion::getQuaternionValue(TYPE_QUATERNION, argumentValues, 0, quaternion, false) == true) { + auto result = quaternion.computeMatrix(); + returnValue.setType(TYPE_MATRIX4x4); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodQuaternionComputeMatrix(miniScript, TYPE_QUATERNION, TYPE_MATRIX4x4)); + } +} + +void MiniScriptQuaternion::unsetScriptVariableValue(MiniScript::ScriptVariable& variable) const { + if (variable.getType() != getType()) return; + if (variable.getValuePtr() == 0ll) return; + // + delete static_cast((void*)variable.getValuePtr()); + variable.setValuePtr(0ll); +} + +void MiniScriptQuaternion::setScriptVariableValue(MiniScript::ScriptVariable& variable, const void* value) const { + if (variable.getType() != getType()) return; + // + Quaternion quaternionValue; + if (value != 0ll) { + quaternionValue = *static_cast(value); + } + // + if (variable.getValuePtr() != 0ll) { + *static_cast((void*)variable.getValuePtr()) = quaternionValue; + return; + } + // + variable.setValuePtr((uint64_t)(new Quaternion(quaternionValue))); +} + +void MiniScriptQuaternion::copyScriptVariable(MiniScript::ScriptVariable& to, const MiniScript::ScriptVariable& from) const { + // + Quaternion quaternionValue; + if (from.getType() == getType() && from.getValuePtr() != 0ll) { + quaternionValue = *static_cast((void*)from.getValuePtr()); + } + // + const auto TYPE_QUATERNION = static_cast(getType()); + to.setType(TYPE_QUATERNION); + *static_cast((void*)to.getValuePtr()) = quaternionValue; +} + +bool MiniScriptQuaternion::mul(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_QUATERNION = static_cast(getType()); + const auto TYPE_VECTOR3 = static_cast(miniScript->getDataTypeByClassName("vec3")->getType()); + // quaternion + if (MiniScript::hasType(argumentValues, TYPE_QUATERNION) == true) { + // quaternion * quaternion + if (argumentValues[0].getType() == TYPE_QUATERNION && + argumentValues[1].getType() == TYPE_QUATERNION) { + Quaternion a; + Quaternion b; + MiniScriptQuaternion::getQuaternionValue(TYPE_QUATERNION, argumentValues, 0, a, false); + MiniScriptQuaternion::getQuaternionValue(TYPE_QUATERNION, argumentValues, 1, b, false); + // + auto result = a * b; + returnValue.setType(TYPE_QUATERNION); + returnValue.setValue(&result); + // + return true; + } else + // quaternion * vec3 + if (argumentValues[0].getType() == TYPE_QUATERNION && + argumentValues[1].getType() == TYPE_VECTOR3) { + Quaternion a; + Vector3 b; + MiniScriptQuaternion::getQuaternionValue(TYPE_QUATERNION, argumentValues, 0, a, false); + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false); + // + auto result = a * b; + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + // + return true; + } else + // vec3 * quaternion + if (argumentValues[0].getType() == TYPE_VECTOR3 && + argumentValues[1].getType() == TYPE_QUATERNION) { + Vector3 a; + Quaternion b; + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false); + MiniScriptQuaternion::getQuaternionValue(TYPE_QUATERNION, argumentValues, 1, b, false); + // + auto result = b * a; + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + // + return true; + } else { + Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); + miniScript->startErrorScript(); + // + return false; + } + } + // + return false; +} + +bool MiniScriptQuaternion::div(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + return false; +} + +bool MiniScriptQuaternion::add(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_QUATERNION = static_cast(getType()); + // + if (MiniScript::hasType(argumentValues, TYPE_QUATERNION) == true) { + Quaternion a; + Quaternion b; + if (MiniScriptQuaternion::getQuaternionValue(TYPE_QUATERNION, argumentValues, 0, a, false) == true && + MiniScriptQuaternion::getQuaternionValue(TYPE_QUATERNION, argumentValues, 1, b, false) == true) { + // + auto result = a.clone().add(b); + returnValue.setType(TYPE_QUATERNION); + returnValue.setValue(&result); + // + return true; + } else { + Console::println("add(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("add")); + miniScript->startErrorScript(); + // + return false; + } + } + // + return false; +} + +bool MiniScriptQuaternion::sub(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_QUATERNION = static_cast(getType()); + // + if (MiniScript::hasType(argumentValues, TYPE_QUATERNION) == true) { + Quaternion a; + Quaternion b; + if (MiniScriptQuaternion::getQuaternionValue(TYPE_QUATERNION, argumentValues, 0, a, false) == true && + MiniScriptQuaternion::getQuaternionValue(TYPE_QUATERNION, argumentValues, 1, b, false) == true) { + // + auto result = a.clone().sub(b); + returnValue.setType(TYPE_QUATERNION); + returnValue.setValue(&result); + // + return true; + } else { + Console::println("sub(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("sub")); + miniScript->startErrorScript(); + // + return false; + } + } + // + return false; +} + +const string& MiniScriptQuaternion::getClassName() const { + return CLASS_NAME; +} + +const string& MiniScriptQuaternion::getTypeAsString() const { + return TYPE_NAME; +} + +const string MiniScriptQuaternion::getValueAsString(const MiniScript::ScriptVariable& variable) const { + // + Quaternion quaternionValue; + if (variable.getType() == getType() && variable.getValuePtr() != 0ll) { + quaternionValue = *static_cast((void*)variable.getValuePtr()); + } + return + "Quaternion(" + + to_string(quaternionValue[0]) + ", " + + to_string(quaternionValue[1]) + ", " + + to_string(quaternionValue[2]) + ", " + + to_string(quaternionValue[3]) + ")"; + +} + diff --git a/src/tdme/utilities/MiniScriptQuaternion.h b/src/tdme/utilities/MiniScriptQuaternion.h new file mode 100644 index 000000000..b00a20d61 --- /dev/null +++ b/src/tdme/utilities/MiniScriptQuaternion.h @@ -0,0 +1,70 @@ +#pragma once + +#include + +#include +#include +#include + +using std::span; + +using tdme::math::Quaternion; +using tdme::utilities::MiniScript; + +/** + * MiniScript Quaternion data type + * @author Andreas Drewke + */ +class tdme::utilities::MiniScriptQuaternion final: public MiniScript::ScriptDataType { +private: + // overridden methods + void registerMethods(MiniScript* miniScript) const override; + void unsetScriptVariableValue(MiniScript::ScriptVariable& variable) const override; + void setScriptVariableValue(MiniScript::ScriptVariable& variable, const void* value) const override; + void copyScriptVariable(MiniScript::ScriptVariable& to, const MiniScript::ScriptVariable& from) const override; + bool mul(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool div(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool add(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool sub(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + +public: + static const string CLASS_NAME; + static const string TYPE_NAME; + + /** + * Get quaternion value from given variable + * @param TYPE_QUATERNION custom data type for vector3 + * @param arguments arguments + * @param idx argument index + * @param value value + * @param optional optional + * @return success + */ + static inline bool getQuaternionValue(MiniScript::ScriptVariableType TYPE_QUATERNION, const span& arguments, int idx, Quaternion& value, bool optional = false) { + if (idx >= arguments.size()) return optional; + const auto& argument = arguments[idx]; + if (argument.getType() == TYPE_QUATERNION) { + if (argument.getValuePtr() == 0ll) return optional; + value = *static_cast((void*)argument.getValuePtr()); + return true; + } + return optional; + + } + + // forbid class copy + FORBID_CLASS_COPY(MiniScriptQuaternion) + + /** + * MiniScript Quaternion data type + */ + MiniScriptQuaternion(): MiniScript::ScriptDataType(true) { + // + } + + // overridden methods + const string& getClassName() const override; + const string& getTypeAsString() const override; + const string getValueAsString(const MiniScript::ScriptVariable& variable) const override; + +}; diff --git a/src/tdme/utilities/MiniScriptTransform.cpp b/src/tdme/utilities/MiniScriptTransform.cpp new file mode 100644 index 000000000..eafe69d1f --- /dev/null +++ b/src/tdme/utilities/MiniScriptTransform.cpp @@ -0,0 +1,856 @@ +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +using std::span; +using std::string; + +using tdme::engine::Transform; +using tdme::utilities::Float; +using tdme::utilities::MiniScript; +using tdme::utilities::MiniScriptMatrix4x4; +using tdme::utilities::MiniScriptQuaternion; +using tdme::utilities::MiniScriptTransform; +using tdme::utilities::MiniScriptVector3; + +const string MiniScriptTransform::CLASS_NAME = "transform"; +const string MiniScriptTransform::TYPE_NAME = "Transform"; + +void MiniScriptTransform::registerMethods(MiniScript* miniScript) const { + const auto TYPE_TRANSFORM = static_cast(getType()); + const auto TYPE_MATRIX4x4 = static_cast(miniScript->getDataTypeByClassName("mat4")->getType()); + const auto TYPE_QUATERNION = static_cast(miniScript->getDataTypeByClassName("quaternion")->getType()); + const auto TYPE_VECTOR3 = static_cast(miniScript->getDataTypeByClassName("vec3")->getType()); + // + { + // + class ScriptMethodTransformAxisZ: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodTransformAxisZ( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod({}, TYPE_VECTOR3), + miniScript(miniScript), TYPE_VECTOR3(TYPE_VECTOR3) {} + const string getMethodName() override { + return "transform.AXIS_Z"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + auto result = Vector3(0.0f, 0.0f, 1.0f); + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + } + }; + miniScript->registerMethod(new ScriptMethodTransformAxisZ(miniScript, TYPE_VECTOR3)); + } + { + // + class ScriptMethodTransformAxisY: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodTransformAxisY( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod({}, TYPE_VECTOR3), + miniScript(miniScript), TYPE_VECTOR3(TYPE_VECTOR3) {} + const string getMethodName() override { + return "transform.AXIS_Y"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + auto result = Vector3(0.0f, 1.0f, 0.0f); + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + } + }; + miniScript->registerMethod(new ScriptMethodTransformAxisY(miniScript, TYPE_VECTOR3)); + } + { + // + class ScriptMethodTransformAxisX: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodTransformAxisX( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod({}, TYPE_VECTOR3), + miniScript(miniScript), TYPE_VECTOR3(TYPE_VECTOR3) {} + const string getMethodName() override { + return "transform.AXIS_X"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + auto result = Vector3(1.0f, 0.0f, 0.0f); + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + } + }; + miniScript->registerMethod(new ScriptMethodTransformAxisX(miniScript, TYPE_VECTOR3)); + } + { + // + class ScriptMethodTransform: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_TRANSFORM; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodTransform( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_TRANSFORM, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR3, .name = "translation", .optional = true, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "scale", .optional = true, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "rotationZ", .optional = true, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "rotationY", .optional = true, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "rotationX", .optional = true, .reference = false, .nullable = false }, + }, + TYPE_TRANSFORM + ), + miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {} + const string getMethodName() override { + return "transform"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Transform result; + Vector3 vec3Value; + float floatValue; + // translation + if (argumentValues.size() >= 1) { + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, vec3Value, true) == true) { + result.setTranslation(vec3Value); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + // scale + if (argumentValues.size() >= 2) { + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, vec3Value, true) == true) { + result.setScale(vec3Value); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + // rotations: we always use euler angles here + result.addRotation(Vector3(0.0f, 0.0f, 1.0f), 0.0f); + result.addRotation(Vector3(0.0f, 1.0f, 0.0f), 0.0f); + result.addRotation(Vector3(1.0f, 0.0f, 0.0f), 0.0f); + // + for (auto i = 2; i < argumentValues.size() && i < 5; i++) { + if (MiniScript::getFloatValue(argumentValues, i, floatValue, true) == true) { + result.setRotationAngle(i - 2, floatValue); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + result.update(); + // + returnValue.setType(TYPE_TRANSFORM); + returnValue.setValue(&result); + + } + }; + miniScript->registerMethod(new ScriptMethodTransform(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3)); + } + { + // + class ScriptMethodTransformGetTranslation: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_TRANSFORM; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodTransformGetTranslation( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_TRANSFORM, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_VECTOR3 + ), + miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {} + const string getMethodName() override { + return "transform.getTranslation"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Transform transform; + if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true) { + const auto& result = transform.getTranslation(); + // + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodTransformGetTranslation(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3)); + } + { + // + class ScriptMethodTransformSetTranslation: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_TRANSFORM; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodTransformSetTranslation( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_TRANSFORM, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = true, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "translation", .optional = false, .reference = false, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_NULL + ), + miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {} + const string getMethodName() override { + return "transform.setTranslation"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Transform transform; + Vector3 translation; + if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true && + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, translation, false) == true) { + transform.setTranslation(translation); + transform.update(); + // + argumentValues[0].setType(TYPE_TRANSFORM); + argumentValues[0].setValue(&transform); + + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodTransformSetTranslation(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3)); + } + { + // + class ScriptMethodTransformGetScale: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_TRANSFORM; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodTransformGetScale( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_TRANSFORM, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_VECTOR3 + ), + miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {} + const string getMethodName() override { + return "transform.getScale"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Transform transform; + if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true) { + const auto& result = transform.getScale(); + // + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodTransformGetScale(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3)); + } + { + // + class ScriptMethodTransformSetScale: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_TRANSFORM; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodTransformSetScale( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_TRANSFORM, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = true, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "scale", .optional = false, .reference = false, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_NULL + ), + miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {} + const string getMethodName() override { + return "transform.setScale"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Transform transform; + Vector3 scale; + if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true && + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, scale, false) == true) { + transform.setScale(scale); + transform.update(); + // + argumentValues[0].setType(TYPE_TRANSFORM); + argumentValues[0].setValue(&transform); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodTransformSetScale(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3)); + } + { + // + class ScriptMethodTransformGetRotationAxis: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_TRANSFORM; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodTransformGetRotationAxis( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_TRANSFORM, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_INTEGER, .name = "idx", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_VECTOR3 + ), + miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {} + const string getMethodName() override { + return "transform.getRotationAxis"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + int64_t idx; + Transform transform; + if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true && + MiniScript::getIntegerValue(argumentValues, 1, idx, false) == true) { + if (idx < transform.getRotationCount()) { + auto result = transform.getRotationAxis(idx); + // + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": rotation index invalid: " + to_string(idx) + " / " + to_string(transform.getRotationCount())); + miniScript->startErrorScript(); + } + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodTransformGetRotationAxis(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3)); + } + { + // + class ScriptMethodTransformGetRotationAngle: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_TRANSFORM; + public: + ScriptMethodTransformGetRotationAngle( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_TRANSFORM + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_INTEGER, .name = "idx", .optional = false, .reference = false, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM) {} + const string getMethodName() override { + return "transform.getRotationAngle"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + int64_t idx; + Transform transform; + if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true && + MiniScript::getIntegerValue(argumentValues, 1, idx, false) == true) { + if (idx < transform.getRotationCount()) { + returnValue.setValue(transform.getRotationAngle(idx)); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": rotation index invalid: " + to_string(idx) + " / " + to_string(transform.getRotationCount())); + miniScript->startErrorScript(); + } + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodTransformGetRotationAngle(miniScript, TYPE_TRANSFORM)); + } + { + // + class ScriptMethodTransformSetRotationAngle: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_TRANSFORM; + public: + ScriptMethodTransformSetRotationAngle( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_TRANSFORM + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = true, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_INTEGER, .name = "idx", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_NULL + ), + miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM) {} + const string getMethodName() override { + return "transform.setRotationAngle"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + int64_t idx; + Transform transform; + float angle; + if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true && + MiniScript::getIntegerValue(argumentValues, 1, idx, false) == true && + MiniScript::getFloatValue(argumentValues, 2, angle, false) == true) { + if (idx < transform.getRotationCount()) { + transform.setRotationAngle(idx, angle); + transform.update(); + // + argumentValues[0].setType(TYPE_TRANSFORM); + argumentValues[0].setValue(&transform); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": rotation index invalid: " + to_string(idx) + " / " + to_string(transform.getRotationCount())); + miniScript->startErrorScript(); + } + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodTransformSetRotationAngle(miniScript, TYPE_TRANSFORM)); + } + { + // + class ScriptMethodTransformRotate: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_TRANSFORM; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodTransformRotate( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_TRANSFORM, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_VECTOR3 + ), + miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {} + const string getMethodName() override { + return "transform.rotate"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Transform transform; + Vector3 vec3; + if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true && + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, vec3, false) == true) { + // + auto result = transform.getRotationsQuaternion() * vec3; + // + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodTransformRotate(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3)); + } + { + // + class ScriptMethodTransformApplyRotation: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_TRANSFORM; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodTransformApplyRotation( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_TRANSFORM, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = true, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "axis", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_NULL + ), + miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {} + const string getMethodName() override { + return "transform.applyRotation"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Transform transform; + Vector3 axis; + float angle; + if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true && + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, axis, false) == true && + MiniScript::getFloatValue(argumentValues, 2, angle, false) == true) { + // + transform.addRotation(axis, angle); + transform.update(); + // get transform and make sure its a euler transform + auto euler = transform.getTransformMatrix().computeEulerAngles(); + while (transform.getRotationCount() > 3) transform.removeRotation(transform.getRotationCount() - 1); + while (transform.getRotationCount() < 3) transform.addRotation(Vector3(), 0.0f); + transform.setRotationAxis(0, Vector3(0.0f, 0.0f, 1.0f)); + transform.setRotationAxis(1, Vector3(0.0f, 1.0f, 0.0f)); + transform.setRotationAxis(2, Vector3(1.0f, 0.0f, 0.0f)); + transform.setRotationAngle(0, euler.getZ()); + transform.setRotationAngle(1, euler.getY()); + transform.setRotationAngle(2, euler.getX()); + transform.update(); + // + argumentValues[0].setType(TYPE_TRANSFORM); + argumentValues[0].setValue(&transform); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodTransformApplyRotation(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3)); + } + { + // + class ScriptMethodTransformInterpolateRotation: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + public: + ScriptMethodTransformInterpolateRotation(MiniScript* miniScript): + MiniScript::ScriptMethod( + { + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "currentAngle", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "targetAngle", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "timePassedSeconds", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "degreesPerSeconds", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "interpolatedAngle", .optional = false, .reference = true, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_BOOLEAN + ), + miniScript(miniScript) {} + const string getMethodName() override { + return "transform.interpolateRotation"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + float currentAngle; + float targetAngle; + float timePassedSeconds; + float degreesPerSeconds; + float interpolatedAngle = 0.0f; + if (argumentValues.size() == 5 && + MiniScript::getFloatValue(argumentValues, 0, currentAngle) == true && + MiniScript::getFloatValue(argumentValues, 1, targetAngle) == true && + MiniScript::getFloatValue(argumentValues, 2, timePassedSeconds) == true && + MiniScript::getFloatValue(argumentValues, 3, degreesPerSeconds) == true) { + returnValue = Rotation::interpolate(currentAngle, targetAngle, timePassedSeconds, degreesPerSeconds, interpolatedAngle); + argumentValues[4].setValue(interpolatedAngle); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodTransformInterpolateRotation(miniScript)); + } + { + // + class ScriptMethodTransformGetTransformMatrix: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_TRANSFORM; + MiniScript::ScriptVariableType TYPE_MATRIX4x4; + public: + ScriptMethodTransformGetTransformMatrix( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_TRANSFORM, + MiniScript::ScriptVariableType TYPE_MATRIX4x4 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_MATRIX4x4 + ), + miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_MATRIX4x4(TYPE_MATRIX4x4) {} + const string getMethodName() override { + return "transform.getTransformMatrix"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Transform transform; + if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true) { + const auto& result = transform.getTransformMatrix(); + // + returnValue.setType(TYPE_MATRIX4x4); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodTransformGetTransformMatrix(miniScript, TYPE_TRANSFORM, TYPE_MATRIX4x4)); + } + { + // + class ScriptMethodTransformGetRotationsQuaternion: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_TRANSFORM; + MiniScript::ScriptVariableType TYPE_QUATERNION; + public: + ScriptMethodTransformGetRotationsQuaternion( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_TRANSFORM, + MiniScript::ScriptVariableType TYPE_QUATERNION + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_QUATERNION + ), + miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_QUATERNION(TYPE_QUATERNION) {} + const string getMethodName() override { + return "transform.getRotationsQuaternion"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Transform transform; + if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true) { + const auto& result = transform.getRotationsQuaternion(); + // + returnValue.setType(TYPE_QUATERNION); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodTransformGetRotationsQuaternion(miniScript, TYPE_TRANSFORM, TYPE_QUATERNION)); + } + { + // + class ScriptMethodTransformFromMatrix: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_TRANSFORM; + MiniScript::ScriptVariableType TYPE_MATRIX4x4; + public: + ScriptMethodTransformFromMatrix( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_TRANSFORM, + MiniScript::ScriptVariableType TYPE_MATRIX4x4 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_MATRIX4x4, .name = "transformMatrix", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_TRANSFORM + ), + miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_MATRIX4x4(TYPE_MATRIX4x4) {} + const string getMethodName() override { + return "transform.fromMatrix"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Matrix4x4 transformMatrix; + if (MiniScriptMatrix4x4::getMatrix4x4Value(TYPE_TRANSFORM, argumentValues, 0, transformMatrix, false) == true) { + Transform result; + result.fromMatrix(transformMatrix, RotationOrder::ZYX); + returnValue.setType(TYPE_TRANSFORM); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodTransformFromMatrix(miniScript, TYPE_TRANSFORM, TYPE_MATRIX4x4)); + } +} + +void MiniScriptTransform::unsetScriptVariableValue(MiniScript::ScriptVariable& variable) const { + if (variable.getType() != getType()) return; + if (variable.getValuePtr() == 0ll) return; + // + delete static_cast((void*)variable.getValuePtr()); + variable.setValuePtr(0ll); +} + +void MiniScriptTransform::setScriptVariableValue(MiniScript::ScriptVariable& variable, const void* value) const { + if (variable.getType() != getType()) return; + // + Transform transformValue; + if (value != 0ll) { + transformValue = *static_cast(value); + } + // + if (variable.getValuePtr() != 0ll) { + *static_cast((void*)variable.getValuePtr()) = transformValue; + return; + } + // + variable.setValuePtr((uint64_t)(new Transform(transformValue))); +} + +void MiniScriptTransform::copyScriptVariable(MiniScript::ScriptVariable& to, const MiniScript::ScriptVariable& from) const { + // + Transform transformValue; + if (from.getType() == getType() && from.getValuePtr() != 0ll) { + transformValue = *static_cast((void*)from.getValuePtr()); + } + // + const auto TYPE_TRANSFORM = static_cast(getType()); + to.setType(TYPE_TRANSFORM); + *static_cast((void*)to.getValuePtr()) = transformValue; +} + +bool MiniScriptTransform::mul(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_TRANSFORM = static_cast(getType()); + const auto TYPE_VECTOR3 = static_cast(miniScript->getDataTypeByClassName("vec3")->getType()); + // transform + if (MiniScript::hasType(argumentValues, TYPE_TRANSFORM) == true) { + // transform * vec3 + if (argumentValues[0].getType() == TYPE_TRANSFORM && + argumentValues[1].getType() == TYPE_VECTOR3) { + Transform a; + Vector3 b; + MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, a, false); + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false); + // + auto result = a * b; + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + // + return true; + } else + // vec3 * transform + if (argumentValues[0].getType() == TYPE_VECTOR3 && + argumentValues[1].getType() == TYPE_TRANSFORM) { + Vector3 a; + Transform b; + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false); + MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 1, b, false); + // + auto result = b * a; + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + // + return true; + } else { + Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); + miniScript->startErrorScript(); + // + return false; + } + } + // + return false; +} + +bool MiniScriptTransform::div(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + return false; +} + +bool MiniScriptTransform::add(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + return false; +} + +bool MiniScriptTransform::sub(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + return false; +} + +const string& MiniScriptTransform::getClassName() const { + return CLASS_NAME; +} + +const string& MiniScriptTransform::getTypeAsString() const { + return TYPE_NAME; +} + +const string MiniScriptTransform::getValueAsString(const MiniScript::ScriptVariable& variable) const { + // + Transform transformValue; + if (variable.getType() == getType() && variable.getValuePtr() != 0ll) { + transformValue = *static_cast((void*)variable.getValuePtr()); + } + // + string result; + result+= + "Transform(translation: Vector3(" + + to_string(transformValue.getTranslation().getX()) + ", " + + to_string(transformValue.getTranslation().getY()) + ", " + + to_string(transformValue.getTranslation().getZ()) + "), " + + "scale: (" + + to_string(transformValue.getScale().getX()) + ", " + + to_string(transformValue.getScale().getY()) + ", " + + to_string(transformValue.getScale().getZ()) + ")"; + for (auto i = 0; i < transformValue.getRotationCount(); i++) { + result+= ", rotations: (axis: Vector3(" + + to_string(transformValue.getRotationAxis(i).getX()) + ", " + + to_string(transformValue.getRotationAxis(i).getY()) + ", " + + to_string(transformValue.getRotationAxis(i).getZ()) + "), angle: " + + to_string(transformValue.getRotationAngle(i)) + ")"; + } + result+= ")"; + // + return result; +} + diff --git a/src/tdme/utilities/MiniScriptTransform.h b/src/tdme/utilities/MiniScriptTransform.h new file mode 100644 index 000000000..d57cc407e --- /dev/null +++ b/src/tdme/utilities/MiniScriptTransform.h @@ -0,0 +1,70 @@ +#pragma once + +#include + +#include +#include +#include + +using std::span; + +using tdme::engine::Transform; +using tdme::utilities::MiniScript; + +/** + * MiniScript Transform data type + * @author Andreas Drewke + */ +class tdme::utilities::MiniScriptTransform final: public MiniScript::ScriptDataType { +private: + // overridden methods + void registerMethods(MiniScript* miniScript) const override; + void unsetScriptVariableValue(MiniScript::ScriptVariable& variable) const override; + void setScriptVariableValue(MiniScript::ScriptVariable& variable, const void* value) const override; + void copyScriptVariable(MiniScript::ScriptVariable& to, const MiniScript::ScriptVariable& from) const override; + bool mul(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool div(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool add(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool sub(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + +public: + static const string CLASS_NAME; + static const string TYPE_NAME; + + /** + * Get quaternion value from given variable + * @param TYPE_TRANSFORM custom data type for vector3 + * @param arguments arguments + * @param idx argument index + * @param value value + * @param optional optional + * @return success + */ + static inline bool getTransformValue(MiniScript::ScriptVariableType TYPE_TRANSFORM, const span& arguments, int idx, Transform& value, bool optional = false) { + if (idx >= arguments.size()) return optional; + const auto& argument = arguments[idx]; + if (argument.getType() == TYPE_TRANSFORM) { + if (argument.getValuePtr() == 0ll) return optional; + value = *static_cast((void*)argument.getValuePtr()); + return true; + } + return optional; + + } + + // forbid class copy + FORBID_CLASS_COPY(MiniScriptTransform) + + /** + * MiniScript Transform data type + */ + MiniScriptTransform(): MiniScript::ScriptDataType(true) { + // + } + + // overridden methods + const string& getClassName() const override; + const string& getTypeAsString() const override; + const string getValueAsString(const MiniScript::ScriptVariable& variable) const override; + +}; diff --git a/src/tdme/utilities/MiniScriptTranspiler.cpp b/src/tdme/utilities/MiniScriptTranspiler.cpp index 2ff06e1fc..c187dd560 100644 --- a/src/tdme/utilities/MiniScriptTranspiler.cpp +++ b/src/tdme/utilities/MiniScriptTranspiler.cpp @@ -27,7 +27,6 @@ using std::unordered_map; using std::unordered_set; using std::vector; -using tdme::engine::Transform; using tdme::math::Math; using tdme::math::Matrix3x3; using tdme::math::Matrix4x4; @@ -52,7 +51,7 @@ const unordered_set MiniScriptTranspiler::getAllMethodNames(MiniScript* if (scriptMethod->getArgumentTypes().empty() == true || scriptMethod->getArgumentTypes()[0].name != className) continue; // first argument of method must be of type of the class - if (className != MiniScript::ScriptVariable::getClassName(miniScript, scriptMethod->getArgumentTypes()[0].type) || + if (className != MiniScript::ScriptVariable::getClassName(scriptMethod->getArgumentTypes()[0].type) || className != scriptMethod->getArgumentTypes()[0].name) continue; // allMethods.insert(method); @@ -85,7 +84,7 @@ const unordered_map> MiniScriptTranspiler::getAllClassesM if (scriptMethod->getArgumentTypes().empty() == true || scriptMethod->getArgumentTypes()[0].name != className) continue; // first argument of method must be of type of the class - if (className != MiniScript::ScriptVariable::getClassName(miniScript, scriptMethod->getArgumentTypes()[0].type) || + if (className != MiniScript::ScriptVariable::getClassName(scriptMethod->getArgumentTypes()[0].type) || className != scriptMethod->getArgumentTypes()[0].name) continue; // methodByClasses[className].push_back(method); @@ -524,13 +523,13 @@ void MiniScriptTranspiler::generateMiniScriptEvaluateMemberAccessArrays( "array, " + - to_string((static_cast(MiniScript::TYPE_SET) - static_cast(MiniScript::TYPE_STRING)) + 1) + + to_string((static_cast(MiniScript::TYPE_PSEUDO_CUSTOM_DATATYPES + MiniScript::getDataTypes().size()) - static_cast(MiniScript::TYPE_STRING))) + "> evaluateMemberAccessArrays {};" ); generatedDeclarations.push_back("// evaluate member access arrays"); generatedDefinitions.push_back("evaluateMemberAccessArrays = {};"); - for (auto typeIdx = static_cast(MiniScript::TYPE_STRING); typeIdx <= static_cast(MiniScript::TYPE_SET); typeIdx++) { - const auto& className = MiniScript::ScriptVariable::getClassName(miniScript, static_cast(typeIdx)); + for (auto typeIdx = static_cast(MiniScript::TYPE_STRING); typeIdx < static_cast(MiniScript::TYPE_PSEUDO_CUSTOM_DATATYPES + MiniScript::getDataTypes().size()); typeIdx++) { + const auto& className = MiniScript::ScriptVariable::getClassName(static_cast(typeIdx)); const auto& methods = methodsByClasses[className]; auto methodIdx = 0; for (const auto& method: allMethods) { @@ -602,6 +601,49 @@ void MiniScriptTranspiler::generateArrayMapSetVariable( generatedDefinitions+= indent + "}" + "\n"; } break; + case MiniScript::TYPE_FUNCTION_CALL: + { + // + const auto& statement = variable.getInitializer()->getStatement(); + string transpiledCode; + auto statementIdx = MiniScript::STATEMENTIDX_FIRST; + auto scriptStateChanged = false; + auto scriptStopped = false; + vectorenabledNamedConditions; + MiniScriptTranspiler::transpileScriptStatement( + miniScript, + transpiledCode, + *variable.getInitializer()->getSyntaxTree(), + statement, + MiniScript::SCRIPTIDX_NONE, + MiniScript::SCRIPTIDX_NONE, + statementIdx, + methodCodeMap, + allMethods, + scriptStateChanged, + scriptStopped, + enabledNamedConditions, + 0, + {}, + "ScriptVariable()", + "const auto& variableD" + to_string(initializerDepth) + " = returnValue; " + postStatement + "\n", 1 + ); + generatedDefinitions+= transpiledCode; + } + break; + case MiniScript::TYPE_FUNCTION_ASSIGNMENT: + { + string value; + variable.getStringValue(value); + value = StringTools::replace(StringTools::replace(value, "\\", "\\\\"), "\"", "\\\""); + // + generatedDefinitions+= indent + "{" + "\n"; + generatedDefinitions+= indent + "\t" + "ScriptVariable variableD" + to_string(initializerDepth) + ";" + "\n"; + generatedDefinitions+= indent + "\t" + "variableD" + to_string(initializerDepth) + ".setFunctionAssignment(\"" + value + "\");" + "\n"; + generatedDefinitions+= indent + "\t" + postStatement + "\n"; + generatedDefinitions+= indent + "}" + "\n"; + } + break; case MiniScript::TYPE_STRING: { string value; @@ -680,49 +722,6 @@ void MiniScriptTranspiler::generateArrayMapSetVariable( generatedDefinitions+= indent + "}" + "\n"; } break; - case MiniScript::TYPE_FUNCTION_CALL: - { - // - const auto& statement = variable.getInitializer()->getStatement(); - string transpiledCode; - auto statementIdx = MiniScript::STATEMENTIDX_FIRST; - auto scriptStateChanged = false; - auto scriptStopped = false; - vectorenabledNamedConditions; - MiniScriptTranspiler::transpileScriptStatement( - miniScript, - transpiledCode, - *variable.getInitializer()->getSyntaxTree(), - statement, - MiniScript::SCRIPTIDX_NONE, - MiniScript::SCRIPTIDX_NONE, - statementIdx, - methodCodeMap, - allMethods, - scriptStateChanged, - scriptStopped, - enabledNamedConditions, - 0, - {}, - "ScriptVariable()", - "const auto& variableD" + to_string(initializerDepth) + " = returnValue; " + postStatement + "\n", 1 - ); - generatedDefinitions+= transpiledCode; - } - break; - case MiniScript::TYPE_FUNCTION_ASSIGNMENT: - { - string value; - variable.getStringValue(value); - value = StringTools::replace(StringTools::replace(value, "\\", "\\\\"), "\"", "\\\""); - // - generatedDefinitions+= indent + "{" + "\n"; - generatedDefinitions+= indent + "\t" + "ScriptVariable variableD" + to_string(initializerDepth) + ";" + "\n"; - generatedDefinitions+= indent + "\t" + "variableD" + to_string(initializerDepth) + ".setFunctionAssignment(\"" + value + "\");" + "\n"; - generatedDefinitions+= indent + "\t" + postStatement + "\n"; - generatedDefinitions+= indent + "}" + "\n"; - } - break; default: break; } } diff --git a/src/tdme/utilities/MiniScriptVector2.cpp b/src/tdme/utilities/MiniScriptVector2.cpp new file mode 100644 index 000000000..4fb91bd2b --- /dev/null +++ b/src/tdme/utilities/MiniScriptVector2.cpp @@ -0,0 +1,471 @@ +#include +#include + +#include +#include +#include +#include +#include + +using std::span; +using std::string; + +using tdme::math::Vector2; +using tdme::utilities::Float; +using tdme::utilities::MiniScript; +using tdme::utilities::MiniScriptVector2; + +const string MiniScriptVector2::CLASS_NAME = "vec2"; +const string MiniScriptVector2::TYPE_NAME = "Vector2"; + +void MiniScriptVector2::registerMethods(MiniScript* miniScript) const { + const auto TYPE_VECTOR2 = static_cast(getType()); + { + // + class ScriptMethodVec2: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR2; + public: + ScriptMethodVec2( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR2 + ): + MiniScript::ScriptMethod( + { + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "x", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "y", .optional = false, .reference = false, .nullable = false } + }, + TYPE_VECTOR2 + ), + miniScript(miniScript), + TYPE_VECTOR2(TYPE_VECTOR2) { + // + } + const string getMethodName() override { + return "vec2"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + float xValue; + float yValue; + if (MiniScript::getFloatValue(argumentValues, 0, xValue, false) == true && + MiniScript::getFloatValue(argumentValues, 1, yValue, false) == true) { + auto result = Vector2(xValue, yValue); + returnValue.setType(TYPE_VECTOR2); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec2(miniScript, TYPE_VECTOR2)); + } + { + // + class ScriptMethodVec2ComputeLength: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR2; + public: + ScriptMethodVec2ComputeLength( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR2 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR2, .name = "vec2", .optional = false, .reference = false, .nullable = false } + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR2(TYPE_VECTOR2) { + // + } + const string getMethodName() override { + return "vec2.computeLength"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector2 vec2; + if (MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 0, vec2, false) == true) { + auto length = vec2.computeLength(); + returnValue.setValue(Float::isInfinite(length) == true || Float::isNaN(length) == true?0.0f:length); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec2ComputeLength(miniScript, TYPE_VECTOR2)); + } + { + // + class ScriptMethodVec2ComputeLengthSquared: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR2; + public: + ScriptMethodVec2ComputeLengthSquared( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR2 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR2, .name = "vec2", .optional = false, .reference = false, .nullable = false } + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR2(TYPE_VECTOR2) { + // + } + const string getMethodName() override { + return "vec2.computeLengthSquared"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector2 vec2; + if (MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 0, vec2, false) == true) { + returnValue.setValue(vec2.computeLengthSquared()); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec2ComputeLengthSquared(miniScript, TYPE_VECTOR2)); + } + { + // + class ScriptMethodVec2ComputeDotProduct: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR2; + public: + ScriptMethodVec2ComputeDotProduct( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR2 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR2, .name = "a", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR2, .name = "b", .optional = false, .reference = false, .nullable = false } + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR2(TYPE_VECTOR2) { + // + } + const string getMethodName() override { + return "vec2.computeDotProduct"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector2 a; + Vector2 b; + if (MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 0, a, false) == true && + MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 1, b, false) == true) { + returnValue.setValue(Vector2::computeDotProduct(a, b)); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec2ComputeDotProduct(miniScript, TYPE_VECTOR2)); + } + { + // + class ScriptMethodVec2Normalize: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR2; + public: + ScriptMethodVec2Normalize( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR2 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR2, .name = "vec2", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_VECTOR2 + ), + miniScript(miniScript), + TYPE_VECTOR2(TYPE_VECTOR2) { + // + } + const string getMethodName() override { + return "vec2.normalize"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector2 vec2; + if (MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 0, vec2, false) == true) { + auto length = vec2.computeLength(); + auto result = length < Math::EPSILON || Float::isInfinite(length) == true || Float::isNaN(length) == true?Vector2(0.0f, 0.0f):vec2.normalize(); + returnValue.setType(TYPE_VECTOR2); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec2Normalize(miniScript, TYPE_VECTOR2)); + } + { + // + class ScriptMethodVec2GetX: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR2; + public: + ScriptMethodVec2GetX( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR2 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR2, .name = "vec2", .optional = false, .reference = false, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR2(TYPE_VECTOR2) { + // + } + const string getMethodName() override { + return "vec2.getX"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector2 vec2; + if (MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 0, vec2, false) == true) { + returnValue.setValue(vec2.getX()); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec2GetX(miniScript, TYPE_VECTOR2)); + } + { + // + class ScriptMethodVec2GetY: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR2; + public: + ScriptMethodVec2GetY( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR2 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR2, .name = "vec2", .optional = false, .reference = false, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR2(TYPE_VECTOR2) { + // + } + const string getMethodName() override { + return "vec2.getY"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector2 vec2; + if (MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 0, vec2, false) == true) { + returnValue.setValue(vec2.getY()); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec2GetY(miniScript, TYPE_VECTOR2)); + } +} + +void MiniScriptVector2::unsetScriptVariableValue(MiniScript::ScriptVariable& variable) const { + if (variable.getType() != getType()) return; + if (variable.getValuePtr() == 0ll) return; + // + delete static_cast((void*)variable.getValuePtr()); + variable.setValuePtr(0ll); +} + +void MiniScriptVector2::setScriptVariableValue(MiniScript::ScriptVariable& variable, const void* value) const { + if (variable.getType() != getType()) return; + // + Vector2 vector2Value; + if (value != 0ll) { + vector2Value = *static_cast(value); + } + // + if (variable.getValuePtr() != 0ll) { + *static_cast((void*)variable.getValuePtr()) = vector2Value; + return; + } + // + variable.setValuePtr((uint64_t)(new Vector2(vector2Value))); +} + +void MiniScriptVector2::copyScriptVariable(MiniScript::ScriptVariable& to, const MiniScript::ScriptVariable& from) const { + // + Vector2 vector2Value; + if (from.getType() == getType() && from.getValuePtr() != 0ll) { + vector2Value = *static_cast((void*)from.getValuePtr()); + } + // + const auto TYPE_VECTOR2 = static_cast(getType()); + to.setType(TYPE_VECTOR2); + *static_cast((void*)to.getValuePtr()) = vector2Value; +} + +bool MiniScriptVector2::mul(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_VECTOR2 = static_cast(getType()); + // + if (MiniScript::hasType(argumentValues, TYPE_VECTOR2) == true) { + float f; + // a + Vector2 a; + if (argumentValues[0].getType() == TYPE_VECTOR2) { + MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 0, a, false); + } else + if (MiniScript::getFloatValue(argumentValues, 0, f, false) == true) { + a = Vector2(f, f); + } else { + Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); + miniScript->startErrorScript(); + // + return false; + } + // b + Vector2 b; + if (argumentValues[1].getType() == TYPE_VECTOR2) { + MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 1, b, false); + } else + if (MiniScript::getFloatValue(argumentValues, 1, f, false) == true) { + b = Vector2(f, f); + } else { + Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); + miniScript->startErrorScript(); + // + return false; + } + // + auto result = a.clone().scale(b); + returnValue.setType(TYPE_VECTOR2); + returnValue.setValue(&result); + // + return true; + } + // + return false; +} + +bool MiniScriptVector2::div(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_VECTOR2 = static_cast(getType()); + // + if (argumentValues[0].getType() == TYPE_VECTOR2) { + Vector2 a; + Vector2 b; + float f; + // a + MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 0, a, false); + // b + if (argumentValues[1].getType() == TYPE_VECTOR2 && + MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 1, b, false) == true) { + // nop + } else + if (MiniScript::getFloatValue(argumentValues, 1, f, false) == true) { + b = Vector2(f, f); + } else { + Console::println("div(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("div")); + miniScript->startErrorScript(); + // + return false; + } + // + auto result = a / b; + returnValue.setType(TYPE_VECTOR2); + returnValue.setValue(&result); + // + return true; + } + // + return false; +} + +bool MiniScriptVector2::add(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_VECTOR2 = static_cast(getType()); + // + if (MiniScript::hasType(argumentValues, TYPE_VECTOR2) == true) { + Vector2 a; + Vector2 b; + if (MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 0, a, false) == true && + MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 1, b, false) == true) { + // + auto result = a.clone().add(b); + returnValue.setType(TYPE_VECTOR2); + returnValue.setValue(&result); + // + return true; + } else { + Console::println("add(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("add")); + miniScript->startErrorScript(); + // + return false; + } + } + // + return false; +} + +bool MiniScriptVector2::sub(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_VECTOR2 = static_cast(getType()); + // + if (MiniScript::hasType(argumentValues, TYPE_VECTOR2) == true) { + Vector2 a; + Vector2 b; + if (MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 0, a, false) == true && + MiniScriptVector2::getVector2Value(TYPE_VECTOR2, argumentValues, 1, b, false) == true) { + // + auto result = a.clone().sub(b); + returnValue.setType(TYPE_VECTOR2); + returnValue.setValue(&result); + // + return true; + } else { + Console::println("sub(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("sub")); + miniScript->startErrorScript(); + // + return false; + } + } + // + return false; +} + +const string& MiniScriptVector2::getClassName() const { + return CLASS_NAME; +} + +const string& MiniScriptVector2::getTypeAsString() const { + return TYPE_NAME; +} + +const string MiniScriptVector2::getValueAsString(const MiniScript::ScriptVariable& variable) const { + // + Vector2 vector2Value; + if (variable.getType() == getType() && variable.getValuePtr() != 0ll) { + vector2Value = *static_cast((void*)variable.getValuePtr()); + } + // + return + "Vector2(" + + to_string(vector2Value.getX()) + ", " + + to_string(vector2Value.getY()) + ")"; + +} + diff --git a/src/tdme/utilities/MiniScriptVector2.h b/src/tdme/utilities/MiniScriptVector2.h new file mode 100644 index 000000000..db995a97c --- /dev/null +++ b/src/tdme/utilities/MiniScriptVector2.h @@ -0,0 +1,69 @@ +#pragma once + +#include + +#include +#include +#include + +using std::span; + +using tdme::math::Vector2; +using tdme::utilities::MiniScript; + +/** + * MiniScript Vector2 data type + * @author Andreas Drewke + */ +class tdme::utilities::MiniScriptVector2 final: public MiniScript::ScriptDataType { +private: + // overridden methods + void registerMethods(MiniScript* miniScript) const override; + void unsetScriptVariableValue(MiniScript::ScriptVariable& variable) const override; + void setScriptVariableValue(MiniScript::ScriptVariable& variable, const void* value) const override; + void copyScriptVariable(MiniScript::ScriptVariable& to, const MiniScript::ScriptVariable& from) const override; + bool mul(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool div(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool add(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool sub(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + +public: + static const string CLASS_NAME; + static const string TYPE_NAME; + + /** + * Get vector2 value from given variable + * @param TYPE_VECTOR2 custom data type for vector3 + * @param arguments arguments + * @param idx argument index + * @param value value + * @param optional optional + * @return success + */ + static inline bool getVector2Value(MiniScript::ScriptVariableType TYPE_VECTOR2, const span& arguments, int idx, Vector2& value, bool optional = false) { + if (idx >= arguments.size()) return optional; + const auto& argument = arguments[idx]; + if (argument.getType() == TYPE_VECTOR2) { + if (argument.getValuePtr() == 0ll) return optional; + value = *static_cast((void*)argument.getValuePtr()); + return true; + } + return optional; + } + + // forbid class copy + FORBID_CLASS_COPY(MiniScriptVector2) + + /** + * MiniScript Vector2 data type + */ + MiniScriptVector2(): MiniScript::ScriptDataType(true) { + // + } + + // overridden methods + const string& getClassName() const override; + const string& getTypeAsString() const override; + const string getValueAsString(const MiniScript::ScriptVariable& variable) const override; + +}; diff --git a/src/tdme/utilities/MiniScriptVector3.cpp b/src/tdme/utilities/MiniScriptVector3.cpp new file mode 100644 index 000000000..e6621cead --- /dev/null +++ b/src/tdme/utilities/MiniScriptVector3.cpp @@ -0,0 +1,590 @@ +#include +#include + +#include +#include +#include +#include +#include + +using std::span; +using std::string; + +using tdme::math::Vector3; +using tdme::utilities::Float; +using tdme::utilities::MiniScript; +using tdme::utilities::MiniScriptVector3; + +const string MiniScriptVector3::CLASS_NAME = "vec3"; +const string MiniScriptVector3::TYPE_NAME = "Vector3"; + +void MiniScriptVector3::registerMethods(MiniScript* miniScript) const { + const auto TYPE_VECTOR3 = static_cast(getType()); + { + // + class ScriptMethodVec3: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodVec3( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "x", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "y", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "z", .optional = false, .reference = false, .nullable = false } + }, + TYPE_VECTOR3 + ), + miniScript(miniScript), + TYPE_VECTOR3(TYPE_VECTOR3) { + // + } + const string getMethodName() override { + return "vec3"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector3 result; + float xValue; + float yValue; + float zValue; + if (MiniScript::getFloatValue(argumentValues, 0, xValue, false) == true && + MiniScript::getFloatValue(argumentValues, 1, yValue, false) == true && + MiniScript::getFloatValue(argumentValues, 2, zValue, false) == true) { + auto result = Vector3(xValue, yValue, zValue); + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec3(miniScript, TYPE_VECTOR3)); + } + { + // + class ScriptMethodVec3ComputeLength: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodVec3ComputeLength( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false } + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR3(TYPE_VECTOR3) { + // + } + const string getMethodName() override { + return "vec3.computeLength"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector3 vec3; + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, vec3, false) == true) { + auto length = vec3.computeLength(); + returnValue.setValue(Float::isInfinite(length) == true || Float::isNaN(length) == true?0.0f:length); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec3ComputeLength(miniScript, TYPE_VECTOR3)); + } + { + // + class ScriptMethodVec3ComputeLengthSquared: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodVec3ComputeLengthSquared( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false } + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR3(TYPE_VECTOR3) { + // + } + const string getMethodName() override { + return "vec3.computeLengthSquared"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector3 vec3; + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, vec3, false) == true) { + returnValue.setValue(vec3.computeLengthSquared()); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec3ComputeLengthSquared(miniScript, TYPE_VECTOR3)); + } + { + // + class ScriptMethodVec3ComputeDotProduct: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodVec3ComputeDotProduct( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR3, .name = "a", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "b", .optional = false, .reference = false, .nullable = false } + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR3(TYPE_VECTOR3) { + // + } + const string getMethodName() override { + return "vec3.computeDotProduct"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector3 a; + Vector3 b; + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false) == true && + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false) == true) { + returnValue.setValue(Vector3::computeDotProduct(a, b)); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec3ComputeDotProduct(miniScript, TYPE_VECTOR3)); + } + { + // + class ScriptMethodVec3ComputeCrossProduct: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodVec3ComputeCrossProduct( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR3, .name = "a", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "b", .optional = false, .reference = false, .nullable = false } + }, + TYPE_VECTOR3 + ), + miniScript(miniScript), + TYPE_VECTOR3(TYPE_VECTOR3) { + // + } + const string getMethodName() override { + return "vec3.computeCrossProduct"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector3 a; + Vector3 b; + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false) == true && + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false) == true) { + auto result = Vector3::computeCrossProduct(a, b); + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec3ComputeCrossProduct(miniScript, TYPE_VECTOR3)); + } + { + // + class ScriptMethodVec3Normalize: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodVec3Normalize( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_VECTOR3 + ), + miniScript(miniScript), + TYPE_VECTOR3(TYPE_VECTOR3) { + // + } + const string getMethodName() override { + return "vec3.normalize"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector3 vec3; + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, vec3, false) == true) { + auto length = vec3.computeLength(); + auto result = length < Math::EPSILON || Float::isInfinite(length) == true || Float::isNaN(length) == true?Vector3(0.0f, 0.0f, 0.0f):vec3.normalize(); + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec3Normalize(miniScript, TYPE_VECTOR3)); + } + { + // + class ScriptMethodVec3ComputeAngle: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodVec3ComputeAngle( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR3, .name = "a", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "b", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR3, .name = "n", .optional = false, .reference = false, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR3(TYPE_VECTOR3) { + // + } + const string getMethodName() override { + return "vec3.computeAngle"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector3 a; + Vector3 b; + Vector3 n; + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false) == true && + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false) == true && + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 2, n, false) == true) { + returnValue.setValue(Vector3::computeAngle(a, b, n)); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec3ComputeAngle(miniScript, TYPE_VECTOR3)); + } + { + // + class ScriptMethodVec3GetX: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodVec3GetX( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR3(TYPE_VECTOR3) { + // + } + const string getMethodName() override { + return "vec3.getX"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector3 vec3; + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, vec3, false) == true) { + returnValue.setValue(vec3.getX()); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec3GetX(miniScript, TYPE_VECTOR3)); + } + { + // + class ScriptMethodVec3GetY: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodVec3GetY( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR3(TYPE_VECTOR3) { + // + } + const string getMethodName() override { + return "vec3.getY"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector3 vec3; + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, vec3, false) == true) { + returnValue.setValue(vec3.getY()); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec3GetY(miniScript, TYPE_VECTOR3)); + } + { + // + class ScriptMethodVec3GetZ: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR3; + public: + ScriptMethodVec3GetZ( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR3 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR3(TYPE_VECTOR3) { + // + } + const string getMethodName() override { + return "vec3.getZ"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector3 vec3; + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, vec3, false) == true) { + returnValue.setValue(vec3.getZ()); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec3GetZ(miniScript, TYPE_VECTOR3)); + } +} + +void MiniScriptVector3::unsetScriptVariableValue(MiniScript::MiniScript::ScriptVariable& variable) const { + if (variable.getType() != getType()) return; + if (variable.getValuePtr() == 0ll) return; + // + delete static_cast((void*)variable.getValuePtr()); + variable.setValuePtr(0ll); +} + +void MiniScriptVector3::setScriptVariableValue(MiniScript::MiniScript::ScriptVariable& variable, const void* value) const { + if (variable.getType() != getType()) return; + // + Vector3 vector3Value; + if (value != 0ll) { + vector3Value = *static_cast(value); + } + // + if (variable.getValuePtr() != 0ll) { + *static_cast((void*)variable.getValuePtr()) = vector3Value; + return; + } + // + variable.setValuePtr((uint64_t)(new Vector3(vector3Value))); +} + +void MiniScriptVector3::copyScriptVariable(MiniScript::MiniScript::ScriptVariable& to, const MiniScript::MiniScript::ScriptVariable& from) const { + // + Vector3 vector3Value; + if (from.getType() == getType() && from.getValuePtr() != 0ll) { + vector3Value = *static_cast((void*)from.getValuePtr()); + } + // + const auto TYPE_VECTOR3 = static_cast(getType()); + to.setType(TYPE_VECTOR3); + *static_cast((void*)to.getValuePtr()) = vector3Value; +} + +bool MiniScriptVector3::mul(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_VECTOR3 = static_cast(getType()); + // vector3 + if (MiniScript::hasType(argumentValues, TYPE_VECTOR3) == true) { + float f; + // a + Vector3 a; + if (argumentValues[0].getType() == TYPE_VECTOR3) { + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false); + } else + if (MiniScript::getFloatValue(argumentValues, 0, f, false) == true) { + a = Vector3(f, f, f); + } else { + Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); + miniScript->startErrorScript(); + return false; + } + // b + Vector3 b; + if (argumentValues[1].getType() == TYPE_VECTOR3) { + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false); + } else + if (MiniScript::getFloatValue(argumentValues, 1, f, false) == true) { + b = Vector3(f, f, f); + } else { + Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); + miniScript->startErrorScript(); + return false; + } + // + auto result = a.clone().scale(b); + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + // + return true; + } + // + return false; +} + +bool MiniScriptVector3::div(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_VECTOR3 = static_cast(getType()); + // vector3 + if (argumentValues[0].getType() == TYPE_VECTOR3) { + Vector3 a; + Vector3 b; + float f; + // a + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false); + // b + if (argumentValues[1].getType() == TYPE_VECTOR3 && + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false) == true) { + // nop + } else + if (MiniScript::getFloatValue(argumentValues, 1, f, false) == true) { + b = Vector3(f, f, f); + } else { + Console::println("div(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("div")); + miniScript->startErrorScript(); + return false; + } + // + auto result = a / b; + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + // + return true; + } + // + return false; +} + +bool MiniScriptVector3::add(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_VECTOR3 = static_cast(getType()); + // vector3 + if (MiniScript::hasType(argumentValues, TYPE_VECTOR3) == true) { + Vector3 a; + Vector3 b; + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false) == true && + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false) == true) { + auto result = a.clone().add(b); + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + // + return true; + } else { + Console::println("add(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("add")); + miniScript->startErrorScript(); + // + return false; + } + } + // + return false; +} + +bool MiniScriptVector3::sub(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_VECTOR3 = static_cast(getType()); + // vector3 + if (MiniScript::hasType(argumentValues, TYPE_VECTOR3) == true) { + Vector3 a; + Vector3 b; + if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false) == true && + MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false) == true) { + auto result = a.clone().sub(b); + returnValue.setType(TYPE_VECTOR3); + returnValue.setValue(&result); + // + return true; + } else { + Console::println("sub(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("sub")); + miniScript->startErrorScript(); + // + return false; + } + } + // + return false; +} + +const string& MiniScriptVector3::getClassName() const { + return CLASS_NAME; +} + +const string& MiniScriptVector3::getTypeAsString() const { + return TYPE_NAME; +} + +const string MiniScriptVector3::getValueAsString(const MiniScript::MiniScript::ScriptVariable& variable) const { + // + Vector3 vector3Value; + if (variable.getType() == getType() && variable.getValuePtr() != 0ll) { + vector3Value = *static_cast((void*)variable.getValuePtr()); + } + // + return + "Vector3(" + + to_string(vector3Value.getX()) + ", " + + to_string(vector3Value.getY()) + ", " + + to_string(vector3Value.getZ()) + ")"; + +} + diff --git a/src/tdme/utilities/MiniScriptVector3.h b/src/tdme/utilities/MiniScriptVector3.h new file mode 100644 index 000000000..16c03f3af --- /dev/null +++ b/src/tdme/utilities/MiniScriptVector3.h @@ -0,0 +1,70 @@ +#pragma once + +#include + +#include +#include +#include + +using std::span; + +using tdme::math::Vector3; +using tdme::utilities::MiniScript; + +/** + * MiniScript Vector3 data type + * @author Andreas Drewke + */ +class tdme::utilities::MiniScriptVector3 final: public MiniScript::ScriptDataType { +private: + // overridden methods + void registerMethods(MiniScript* miniScript) const override; + void unsetScriptVariableValue(MiniScript::ScriptVariable& variable) const override; + void setScriptVariableValue(MiniScript::ScriptVariable& variable, const void* value) const override; + void copyScriptVariable(MiniScript::ScriptVariable& to, const MiniScript::ScriptVariable& from) const override; + bool mul(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool div(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool add(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool sub(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + +public: + static const string CLASS_NAME; + static const string TYPE_NAME; + + /** + * Get vector3 value from given variable + * @param TYPE_VECTOR3 custom data type for vector3 + * @param arguments arguments + * @param idx argument index + * @param value value + * @param optional optional + * @return success + */ + static inline bool getVector3Value(MiniScript::ScriptVariableType TYPE_VECTOR3, const span& arguments, int idx, Vector3& value, bool optional = false) { + if (idx >= arguments.size()) return optional; + const auto& argument = arguments[idx]; + if (argument.getType() == TYPE_VECTOR3) { + if (argument.getValuePtr() == 0ll) return optional; + value = *static_cast((void*)argument.getValuePtr()); + return true; + } + return optional; + + } + + // forbid class copy + FORBID_CLASS_COPY(MiniScriptVector3) + + /** + * MiniScript Vector3 data type + */ + MiniScriptVector3(): MiniScript::ScriptDataType(true) { + // + } + + // overridden methods + const string& getClassName() const override; + const string& getTypeAsString() const override; + const string getValueAsString(const MiniScript::ScriptVariable& variable) const override; + +}; diff --git a/src/tdme/utilities/MiniScriptVector4.cpp b/src/tdme/utilities/MiniScriptVector4.cpp new file mode 100644 index 000000000..490410654 --- /dev/null +++ b/src/tdme/utilities/MiniScriptVector4.cpp @@ -0,0 +1,555 @@ +#include +#include + +#include +#include +#include +#include +#include + +using std::span; +using std::string; + +using tdme::math::Vector4; +using tdme::utilities::Float; +using tdme::utilities::MiniScript; +using tdme::utilities::MiniScriptVector4; + +const string MiniScriptVector4::CLASS_NAME = "vec4"; +const string MiniScriptVector4::TYPE_NAME = "Vector4"; + +void MiniScriptVector4::registerMethods(MiniScript* miniScript) const { + const auto TYPE_VECTOR4 = static_cast(getType()); + { + // + class ScriptMethodVec4: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR4; + public: + ScriptMethodVec4( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR4 + ): + MiniScript::ScriptMethod( + { + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "x", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "y", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "z", .optional = false, .reference = false, .nullable = false }, + { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "w", .optional = false, .reference = false, .nullable = false } + }, + TYPE_VECTOR4 + ), + miniScript(miniScript), + TYPE_VECTOR4(TYPE_VECTOR4) { + // + } + + const string getMethodName() override { + return "vec4"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector3 result; + float xValue; + float yValue; + float zValue; + float wValue; + if (MiniScript::getFloatValue(argumentValues, 0, xValue, false) == true && + MiniScript::getFloatValue(argumentValues, 1, yValue, false) == true && + MiniScript::getFloatValue(argumentValues, 2, zValue, false) == true && + MiniScript::getFloatValue(argumentValues, 3, wValue, false) == true) { + auto result = Vector4(xValue, yValue, zValue, wValue); + returnValue.setType(TYPE_VECTOR4); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec4(miniScript, TYPE_VECTOR4)); + } + { + // + class ScriptMethodVec4ComputeLength: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR4; + public: + ScriptMethodVec4ComputeLength( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR4 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR4, .name = "vec4", .optional = false, .reference = false, .nullable = false } + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR4(TYPE_VECTOR4) { + // + } + const string getMethodName() override { + return "vec4.computeLength"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector4 vec4; + if (MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 0, vec4, false) == true) { + auto length = vec4.computeLength(); + returnValue.setValue(Float::isInfinite(length) == true || Float::isNaN(length) == true?0.0f:length); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec4ComputeLength(miniScript, TYPE_VECTOR4)); + } + { + // + class ScriptMethodVec4ComputeLengthSquared: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR4; + public: + ScriptMethodVec4ComputeLengthSquared( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR4 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR4, .name = "vec4", .optional = false, .reference = false, .nullable = false } + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR4(TYPE_VECTOR4) { + // + } + const string getMethodName() override { + return "vec4.computeLengthSquared"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector4 vec4; + if (MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 0, vec4, false) == true) { + returnValue.setValue(vec4.computeLengthSquared()); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec4ComputeLengthSquared(miniScript, TYPE_VECTOR4)); + } + { + // + class ScriptMethodVec4ComputeDotProduct: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR4; + public: + ScriptMethodVec4ComputeDotProduct( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR4 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR4, .name = "a", .optional = false, .reference = false, .nullable = false }, + { .type = TYPE_VECTOR4, .name = "b", .optional = false, .reference = false, .nullable = false } + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR4(TYPE_VECTOR4) { + // + } + const string getMethodName() override { + return "vec4.computeDotProduct"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector4 a; + Vector4 b; + if (MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 0, a, false) == true && + MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 1, b, false) == true) { + returnValue.setValue(Vector4::computeDotProduct(a, b)); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec4ComputeDotProduct(miniScript, TYPE_VECTOR4)); + } + { + // + class ScriptMethodVec4Normalize: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR4; + public: + ScriptMethodVec4Normalize( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR4 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR4, .name = "vec4", .optional = false, .reference = false, .nullable = false }, + }, + TYPE_VECTOR4 + ), + miniScript(miniScript), + TYPE_VECTOR4(TYPE_VECTOR4) { + // + } + const string getMethodName() override { + return "vec4.normalize"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector4 vec4; + if (MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 0, vec4, false) == true) { + auto length = vec4.computeLength(); + auto result = length < Math::EPSILON || Float::isInfinite(length) == true || Float::isNaN(length) == true?Vector4(0.0f, 0.0f, 0.0f, 0.0f):vec4.normalize(); + returnValue.setType(TYPE_VECTOR4); + returnValue.setValue(&result); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec4Normalize(miniScript, TYPE_VECTOR4)); + } + { + // + class ScriptMethodVec4GetX: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR4; + public: + ScriptMethodVec4GetX( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR4 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR4, .name = "vec4", .optional = false, .reference = false, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR4(TYPE_VECTOR4) { + // + } + const string getMethodName() override { + return "vec4.getX"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector4 vec4; + if (MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 0, vec4, false) == true) { + returnValue.setValue(vec4.getX()); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec4GetX(miniScript, TYPE_VECTOR4)); + } + { + // + class ScriptMethodVec4GetY: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR4; + public: + ScriptMethodVec4GetY( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR4 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR4, .name = "vec4", .optional = false, .reference = false, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR4(TYPE_VECTOR4) { + // + } + const string getMethodName() override { + return "vec4.getY"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector4 vec4; + if (MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 0, vec4, false) == true) { + returnValue.setValue(vec4.getY()); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec4GetY(miniScript, TYPE_VECTOR4)); + } + { + // + class ScriptMethodVec4GetZ: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR4; + public: + ScriptMethodVec4GetZ( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR4 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR4, .name = "vec4", .optional = false, .reference = false, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR4(TYPE_VECTOR4) { + // + } + const string getMethodName() override { + return "vec4.getZ"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector4 vec4; + if (MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 0, vec4, false) == true) { + returnValue.setValue(vec4.getZ()); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec4GetZ(miniScript, TYPE_VECTOR4)); + } + { + // + class ScriptMethodVec4GetW: public MiniScript::ScriptMethod { + private: + MiniScript* miniScript { nullptr }; + MiniScript::ScriptVariableType TYPE_VECTOR4; + public: + ScriptMethodVec4GetW( + MiniScript* miniScript, + MiniScript::ScriptVariableType TYPE_VECTOR4 + ): + MiniScript::ScriptMethod( + { + { .type = TYPE_VECTOR4, .name = "vec4", .optional = false, .reference = false, .nullable = false }, + }, + MiniScript::ScriptVariableType::TYPE_FLOAT + ), + miniScript(miniScript), + TYPE_VECTOR4(TYPE_VECTOR4) { + // + } + const string getMethodName() override { + return "vec4.getW"; + } + void executeMethod(span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override { + Vector4 vec4; + if (MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 0, vec4, false) == true) { + returnValue.setValue(vec4.getW()); + } else { + Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName())); + miniScript->startErrorScript(); + } + } + }; + miniScript->registerMethod(new ScriptMethodVec4GetW(miniScript, TYPE_VECTOR4)); + } +} + +void MiniScriptVector4::unsetScriptVariableValue(MiniScript::ScriptVariable& variable) const { + if (variable.getType() != getType()) return; + if (variable.getValuePtr() == 0ll) return; + // + delete static_cast((void*)variable.getValuePtr()); + variable.setValuePtr(0ll); +} + +void MiniScriptVector4::setScriptVariableValue(MiniScript::ScriptVariable& variable, const void* value) const { + if (variable.getType() != getType()) return; + // + Vector4 vector4Value; + if (value != 0ll) { + vector4Value = *static_cast(value); + } + // + if (variable.getValuePtr() != 0ll) { + *static_cast((void*)variable.getValuePtr()) = vector4Value; + return; + } + // + variable.setValuePtr((uint64_t)(new Vector4(vector4Value))); +} + +void MiniScriptVector4::copyScriptVariable(MiniScript::ScriptVariable& to, const MiniScript::ScriptVariable& from) const { + // + Vector4 vector4Value; + if (from.getType() == getType() && from.getValuePtr() != 0ll) { + vector4Value = *static_cast((void*)from.getValuePtr()); + } + // + to.setType(static_cast(getType())); + *static_cast((void*)to.getValuePtr()) = vector4Value; +} + +bool MiniScriptVector4::mul(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_VECTOR4 = static_cast(getType()); + // + if (MiniScript::hasType(argumentValues, TYPE_VECTOR4) == true) { + float f; + // a + Vector4 a; + if (argumentValues[0].getType() == TYPE_VECTOR4) { + MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 0, a, false); + } else + if (MiniScript::getFloatValue(argumentValues, 0, f, false) == true) { + a = Vector4(f, f, f, f); + } else { + Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); + miniScript->startErrorScript(); + // + return false; + } + // b + Vector4 b; + if (argumentValues[1].getType() == TYPE_VECTOR4) { + MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 1, b, false); + } else + if (MiniScript::getFloatValue(argumentValues, 1, f, false) == true) { + b = Vector4(f, f, f, f); + } else { + Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul")); + miniScript->startErrorScript(); + // + return false; + } + // + auto result = a.clone().scale(b); + returnValue.setType(TYPE_VECTOR4); + returnValue.setValue(&result); + // + return true; + } + // + return false; +} + +bool MiniScriptVector4::div(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_VECTOR4 = static_cast(getType()); + // + if (argumentValues[0].getType() == TYPE_VECTOR4) { + Vector4 a; + Vector4 b; + float f; + // a + MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 0, a, false); + // b + if (argumentValues[1].getType() == TYPE_VECTOR4 && + MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 1, b, false) == true) { + // nop + } else + if (MiniScript::getFloatValue(argumentValues, 1, f, false) == true) { + b = Vector4(f, f, f, f); + } else { + Console::println("div(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("div")); + miniScript->startErrorScript(); + // + return false; + } + // + auto result = a / b; + returnValue.setType(TYPE_VECTOR4); + returnValue.setValue(&result); + // + return true; + + } + // + return false; +} + +bool MiniScriptVector4::add(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_VECTOR4 = static_cast(getType()); + // + // vector4 + if (MiniScript::hasType(argumentValues, TYPE_VECTOR4) == true) { + Vector4 a; + Vector4 b; + if (MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 0, a, false) == true && + MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 1, b, false) == true) { + // + auto result = a.clone().add(b); + returnValue.setType(TYPE_VECTOR4); + returnValue.setValue(&result); + // + return true; + } else { + Console::println("add(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("add")); + miniScript->startErrorScript(); + // + return false; + } + } + // + return false; +} + +bool MiniScriptVector4::sub(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const { + const auto TYPE_VECTOR4 = static_cast(getType()); + // + // vector4 + if (MiniScript::hasType(argumentValues, TYPE_VECTOR4) == true) { + Vector4 a; + Vector4 b; + if (MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 0, a, false) == true && + MiniScriptVector4::getVector4Value(TYPE_VECTOR4, argumentValues, 1, b, false) == true) { + // + auto result = a.clone().sub(b); + returnValue.setType(TYPE_VECTOR4); + returnValue.setValue(&result); + // + return true; + } else { + Console::println("sub(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("sub")); + miniScript->startErrorScript(); + // + return false; + } + } + // + return false; +} + +const string& MiniScriptVector4::getClassName() const { + return CLASS_NAME; +} + +const string& MiniScriptVector4::getTypeAsString() const { + return TYPE_NAME; +} + +const string MiniScriptVector4::getValueAsString(const MiniScript::ScriptVariable& variable) const { + // + Vector4 vector4Value; + if (variable.getType() == getType() && variable.getValuePtr() != 0ll) { + vector4Value = *static_cast((void*)variable.getValuePtr()); + } + // + return + "Vector4(" + + to_string(vector4Value.getX()) + ", " + + to_string(vector4Value.getY()) + ", " + + to_string(vector4Value.getZ()) + ", " + + to_string(vector4Value.getW()) + ")"; + +} + diff --git a/src/tdme/utilities/MiniScriptVector4.h b/src/tdme/utilities/MiniScriptVector4.h new file mode 100644 index 000000000..7f33f4766 --- /dev/null +++ b/src/tdme/utilities/MiniScriptVector4.h @@ -0,0 +1,70 @@ +#pragma once + +#include + +#include +#include +#include + +using std::span; + +using tdme::math::Vector4; +using tdme::utilities::MiniScript; + +/** + * MiniScript Vector4 data type + * @author Andreas Drewke + */ +class tdme::utilities::MiniScriptVector4 final: public MiniScript::ScriptDataType { +private: + // overridden methods + void registerMethods(MiniScript* miniScript) const override; + void unsetScriptVariableValue(MiniScript::ScriptVariable& variable) const override; + void setScriptVariableValue(MiniScript::ScriptVariable& variable, const void* value) const override; + void copyScriptVariable(MiniScript::ScriptVariable& to, const MiniScript::ScriptVariable& from) const override; + bool mul(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool div(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool add(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + bool sub(MiniScript* miniScript, const span& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const override; + +public: + static const string CLASS_NAME; + static const string TYPE_NAME; + + /** + * Get vector4 value from given variable + * @param TYPE_VECTOR4 custom data type for vector3 + * @param arguments arguments + * @param idx argument index + * @param value value + * @param optional optional + * @return success + */ + static inline bool getVector4Value(MiniScript::ScriptVariableType TYPE_VECTOR4, const span& arguments, int idx, Vector4& value, bool optional = false) { + if (idx >= arguments.size()) return optional; + const auto& argument = arguments[idx]; + if (argument.getType() == TYPE_VECTOR4) { + if (argument.getValuePtr() == 0ll) return optional; + value = *static_cast((void*)argument.getValuePtr()); + return true; + } + return optional; + + } + + // forbid class copy + FORBID_CLASS_COPY(MiniScriptVector4) + + /** + * MiniScript Vector4 data type + */ + MiniScriptVector4(): MiniScript::ScriptDataType(true) { + // + } + + // overridden methods + const string& getClassName() const override; + const string& getTypeAsString() const override; + const string getValueAsString(const MiniScript::ScriptVariable& variable) const override; + +}; diff --git a/src/tdme/utilities/fwd-tdme.h b/src/tdme/utilities/fwd-tdme.h index 9914bf5df..f8deb39ff 100644 --- a/src/tdme/utilities/fwd-tdme.h +++ b/src/tdme/utilities/fwd-tdme.h @@ -10,6 +10,7 @@ namespace utilities { class Character; class Console; class ExceptionBase; + class EngineMiniScript; class Enum; class Float; class FloatBuffer; @@ -20,7 +21,14 @@ namespace utilities { class Integer; class MiniScript; class MiniScriptMath; + class MiniScriptTransform; class MiniScriptTranspiler; + class MiniScriptMatrix3x3; + class MiniScriptMatrix4x4; + class MiniScriptQuaternion; + class MiniScriptVector2; + class MiniScriptVector3; + class MiniScriptVector4; class MutableString; class ModelTools; class PathFinding;