TDME2  1.9.200
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
MiniScriptTransform.cpp
Go to the documentation of this file.
1 #include <span>
2 #include <string>
3 
4 #include <tdme/utilities/MiniScriptTransform.h>
5 
6 #include <miniscript/miniscript/MiniScript.h>
7 
8 #include <tdme/tdme.h>
9 #include <tdme/engine/Transform.h>
10 #include <tdme/utilities/Float.h>
11 #include <tdme/utilities/MiniScriptMatrix4x4.h>
12 #include <tdme/utilities/MiniScriptQuaternion.h>
13 #include <tdme/utilities/MiniScriptVector3.h>
14 #include <tdme/utilities/Console.h>
15 
16 using std::span;
17 using std::string;
18 
19 using miniscript::miniscript::MiniScript;
20 
21 using tdme::utilities::MiniScriptTransform;
22 
23 using tdme::engine::Transform;
24 using tdme::utilities::Float;
25 using tdme::utilities::MiniScriptMatrix4x4;
26 using tdme::utilities::MiniScriptQuaternion;
27 using tdme::utilities::MiniScriptVector3;
28 using tdme::utilities::Console;
29 
30 const string MiniScriptTransform::CLASS_NAME = "transform";
31 const string MiniScriptTransform::TYPE_NAME = "Transform";
32 
33 void MiniScriptTransform::registerMethods(MiniScript* miniScript) const {
34  const auto TYPE_TRANSFORM = static_cast<MiniScript::ScriptVariableType>(getType());
35  const auto TYPE_MATRIX4x4 = static_cast<MiniScript::ScriptVariableType>(miniScript->getDataTypeByClassName("mat4")->getType());
36  const auto TYPE_QUATERNION = static_cast<MiniScript::ScriptVariableType>(miniScript->getDataTypeByClassName("quaternion")->getType());
37  const auto TYPE_VECTOR3 = static_cast<MiniScript::ScriptVariableType>(miniScript->getDataTypeByClassName("vec3")->getType());
38  //
39  {
40  //
41  class ScriptMethodTransformAxisZ: public MiniScript::ScriptMethod {
42  private:
43  MiniScript* miniScript { nullptr };
44  MiniScript::ScriptVariableType TYPE_VECTOR3;
45  public:
46  ScriptMethodTransformAxisZ(
47  MiniScript* miniScript,
48  MiniScript::ScriptVariableType TYPE_VECTOR3
49  ):
50  MiniScript::ScriptMethod({}, TYPE_VECTOR3),
51  miniScript(miniScript), TYPE_VECTOR3(TYPE_VECTOR3) {}
52  const string getMethodName() override {
53  return "transform.AXIS_Z";
54  }
55  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
56  auto result = Vector3(0.0f, 0.0f, 1.0f);
57  returnValue.setType(TYPE_VECTOR3);
58  returnValue.setValue(&result);
59  }
60  };
61  miniScript->registerMethod(new ScriptMethodTransformAxisZ(miniScript, TYPE_VECTOR3));
62  }
63  {
64  //
65  class ScriptMethodTransformAxisY: public MiniScript::ScriptMethod {
66  private:
67  MiniScript* miniScript { nullptr };
68  MiniScript::ScriptVariableType TYPE_VECTOR3;
69  public:
70  ScriptMethodTransformAxisY(
71  MiniScript* miniScript,
72  MiniScript::ScriptVariableType TYPE_VECTOR3
73  ):
74  MiniScript::ScriptMethod({}, TYPE_VECTOR3),
75  miniScript(miniScript), TYPE_VECTOR3(TYPE_VECTOR3) {}
76  const string getMethodName() override {
77  return "transform.AXIS_Y";
78  }
79  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
80  auto result = Vector3(0.0f, 1.0f, 0.0f);
81  returnValue.setType(TYPE_VECTOR3);
82  returnValue.setValue(&result);
83  }
84  };
85  miniScript->registerMethod(new ScriptMethodTransformAxisY(miniScript, TYPE_VECTOR3));
86  }
87  {
88  //
89  class ScriptMethodTransformAxisX: public MiniScript::ScriptMethod {
90  private:
91  MiniScript* miniScript { nullptr };
92  MiniScript::ScriptVariableType TYPE_VECTOR3;
93  public:
94  ScriptMethodTransformAxisX(
95  MiniScript* miniScript,
96  MiniScript::ScriptVariableType TYPE_VECTOR3
97  ):
98  MiniScript::ScriptMethod({}, TYPE_VECTOR3),
99  miniScript(miniScript), TYPE_VECTOR3(TYPE_VECTOR3) {}
100  const string getMethodName() override {
101  return "transform.AXIS_X";
102  }
103  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
104  auto result = Vector3(1.0f, 0.0f, 0.0f);
105  returnValue.setType(TYPE_VECTOR3);
106  returnValue.setValue(&result);
107  }
108  };
109  miniScript->registerMethod(new ScriptMethodTransformAxisX(miniScript, TYPE_VECTOR3));
110  }
111  {
112  //
113  class ScriptMethodTransform: public MiniScript::ScriptMethod {
114  private:
115  MiniScript* miniScript { nullptr };
116  MiniScript::ScriptVariableType TYPE_TRANSFORM;
117  MiniScript::ScriptVariableType TYPE_VECTOR3;
118  public:
119  ScriptMethodTransform(
120  MiniScript* miniScript,
121  MiniScript::ScriptVariableType TYPE_TRANSFORM,
122  MiniScript::ScriptVariableType TYPE_VECTOR3
123  ):
124  MiniScript::ScriptMethod(
125  {
126  { .type = TYPE_VECTOR3, .name = "translation", .optional = true, .reference = false, .nullable = false },
127  { .type = TYPE_VECTOR3, .name = "scale", .optional = true, .reference = false, .nullable = false },
128  { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "rotationZ", .optional = true, .reference = false, .nullable = false },
129  { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "rotationY", .optional = true, .reference = false, .nullable = false },
130  { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "rotationX", .optional = true, .reference = false, .nullable = false },
131  },
132  TYPE_TRANSFORM
133  ),
134  miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {}
135  const string getMethodName() override {
136  return "transform";
137  }
138  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
139  Transform result;
140  Vector3 vec3Value;
141  float floatValue;
142  // translation
143  if (argumentValues.size() >= 1) {
144  if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, vec3Value, true) == true) {
145  result.setTranslation(vec3Value);
146  } else {
147  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
148  miniScript->startErrorScript();
149  }
150  }
151  // scale
152  if (argumentValues.size() >= 2) {
153  if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, vec3Value, true) == true) {
154  result.setScale(vec3Value);
155  } else {
156  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
157  miniScript->startErrorScript();
158  }
159  }
160  // rotations: we always use euler angles here
161  result.addRotation(Vector3(0.0f, 0.0f, 1.0f), 0.0f);
162  result.addRotation(Vector3(0.0f, 1.0f, 0.0f), 0.0f);
163  result.addRotation(Vector3(1.0f, 0.0f, 0.0f), 0.0f);
164  //
165  for (auto i = 2; i < argumentValues.size() && i < 5; i++) {
166  if (MiniScript::getFloatValue(argumentValues, i, floatValue, true) == true) {
167  result.setRotationAngle(i - 2, floatValue);
168  } else {
169  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
170  miniScript->startErrorScript();
171  }
172  }
173  result.update();
174  //
175  returnValue.setType(TYPE_TRANSFORM);
176  returnValue.setValue(&result);
177 
178  }
179  };
180  miniScript->registerMethod(new ScriptMethodTransform(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3));
181  }
182  {
183  //
184  class ScriptMethodTransformGetTranslation: public MiniScript::ScriptMethod {
185  private:
186  MiniScript* miniScript { nullptr };
187  MiniScript::ScriptVariableType TYPE_TRANSFORM;
188  MiniScript::ScriptVariableType TYPE_VECTOR3;
189  public:
190  ScriptMethodTransformGetTranslation(
191  MiniScript* miniScript,
192  MiniScript::ScriptVariableType TYPE_TRANSFORM,
193  MiniScript::ScriptVariableType TYPE_VECTOR3
194  ):
195  MiniScript::ScriptMethod(
196  {
197  { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false },
198  },
199  TYPE_VECTOR3
200  ),
201  miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {}
202  const string getMethodName() override {
203  return "transform.getTranslation";
204  }
205  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
206  Transform transform;
207  if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true) {
208  const auto& result = transform.getTranslation();
209  //
210  returnValue.setType(TYPE_VECTOR3);
211  returnValue.setValue(&result);
212  } else {
213  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
214  miniScript->startErrorScript();
215  }
216  }
217  };
218  miniScript->registerMethod(new ScriptMethodTransformGetTranslation(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3));
219  }
220  {
221  //
222  class ScriptMethodTransformSetTranslation: public MiniScript::ScriptMethod {
223  private:
224  MiniScript* miniScript { nullptr };
225  MiniScript::ScriptVariableType TYPE_TRANSFORM;
226  MiniScript::ScriptVariableType TYPE_VECTOR3;
227  public:
228  ScriptMethodTransformSetTranslation(
229  MiniScript* miniScript,
230  MiniScript::ScriptVariableType TYPE_TRANSFORM,
231  MiniScript::ScriptVariableType TYPE_VECTOR3
232  ):
233  MiniScript::ScriptMethod(
234  {
235  { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = true, .nullable = false },
236  { .type = TYPE_VECTOR3, .name = "translation", .optional = false, .reference = false, .nullable = false },
237  },
238  MiniScript::ScriptVariableType::TYPE_NULL
239  ),
240  miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {}
241  const string getMethodName() override {
242  return "transform.setTranslation";
243  }
244  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
245  Transform transform;
246  Vector3 translation;
247  if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true &&
248  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, translation, false) == true) {
249  transform.setTranslation(translation);
250  transform.update();
251  //
252  argumentValues[0].setType(TYPE_TRANSFORM);
253  argumentValues[0].setValue(&transform);
254 
255  } else {
256  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
257  miniScript->startErrorScript();
258  }
259  }
260  };
261  miniScript->registerMethod(new ScriptMethodTransformSetTranslation(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3));
262  }
263  {
264  //
265  class ScriptMethodTransformGetScale: public MiniScript::ScriptMethod {
266  private:
267  MiniScript* miniScript { nullptr };
268  MiniScript::ScriptVariableType TYPE_TRANSFORM;
269  MiniScript::ScriptVariableType TYPE_VECTOR3;
270  public:
271  ScriptMethodTransformGetScale(
272  MiniScript* miniScript,
273  MiniScript::ScriptVariableType TYPE_TRANSFORM,
274  MiniScript::ScriptVariableType TYPE_VECTOR3
275  ):
276  MiniScript::ScriptMethod(
277  {
278  { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false },
279  },
280  TYPE_VECTOR3
281  ),
282  miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {}
283  const string getMethodName() override {
284  return "transform.getScale";
285  }
286  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
287  Transform transform;
288  if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true) {
289  const auto& result = transform.getScale();
290  //
291  returnValue.setType(TYPE_VECTOR3);
292  returnValue.setValue(&result);
293  } else {
294  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
295  miniScript->startErrorScript();
296  }
297  }
298  };
299  miniScript->registerMethod(new ScriptMethodTransformGetScale(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3));
300  }
301  {
302  //
303  class ScriptMethodTransformSetScale: public MiniScript::ScriptMethod {
304  private:
305  MiniScript* miniScript { nullptr };
306  MiniScript::ScriptVariableType TYPE_TRANSFORM;
307  MiniScript::ScriptVariableType TYPE_VECTOR3;
308  public:
309  ScriptMethodTransformSetScale(
310  MiniScript* miniScript,
311  MiniScript::ScriptVariableType TYPE_TRANSFORM,
312  MiniScript::ScriptVariableType TYPE_VECTOR3
313  ):
314  MiniScript::ScriptMethod(
315  {
316  { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = true, .nullable = false },
317  { .type = TYPE_VECTOR3, .name = "scale", .optional = false, .reference = false, .nullable = false },
318  },
319  MiniScript::ScriptVariableType::TYPE_NULL
320  ),
321  miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {}
322  const string getMethodName() override {
323  return "transform.setScale";
324  }
325  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
326  Transform transform;
327  Vector3 scale;
328  if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true &&
329  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, scale, false) == true) {
330  transform.setScale(scale);
331  transform.update();
332  //
333  argumentValues[0].setType(TYPE_TRANSFORM);
334  argumentValues[0].setValue(&transform);
335  } else {
336  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
337  miniScript->startErrorScript();
338  }
339  }
340  };
341  miniScript->registerMethod(new ScriptMethodTransformSetScale(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3));
342  }
343  {
344  //
345  class ScriptMethodTransformGetRotationAxis: public MiniScript::ScriptMethod {
346  private:
347  MiniScript* miniScript { nullptr };
348  MiniScript::ScriptVariableType TYPE_TRANSFORM;
349  MiniScript::ScriptVariableType TYPE_VECTOR3;
350  public:
351  ScriptMethodTransformGetRotationAxis(
352  MiniScript* miniScript,
353  MiniScript::ScriptVariableType TYPE_TRANSFORM,
354  MiniScript::ScriptVariableType TYPE_VECTOR3
355  ):
356  MiniScript::ScriptMethod(
357  {
358  { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false },
359  { .type = MiniScript::ScriptVariableType::TYPE_INTEGER, .name = "idx", .optional = false, .reference = false, .nullable = false },
360  },
361  TYPE_VECTOR3
362  ),
363  miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {}
364  const string getMethodName() override {
365  return "transform.getRotationAxis";
366  }
367  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
368  int64_t idx;
369  Transform transform;
370  if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true &&
371  MiniScript::getIntegerValue(argumentValues, 1, idx, false) == true) {
372  if (idx < transform.getRotationCount()) {
373  auto result = transform.getRotationAxis(idx);
374  //
375  returnValue.setType(TYPE_VECTOR3);
376  returnValue.setValue(&result);
377  } else {
378  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": rotation index invalid: " + to_string(idx) + " / " + to_string(transform.getRotationCount()));
379  miniScript->startErrorScript();
380  }
381  } else {
382  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
383  miniScript->startErrorScript();
384  }
385  }
386  };
387  miniScript->registerMethod(new ScriptMethodTransformGetRotationAxis(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3));
388  }
389  {
390  //
391  class ScriptMethodTransformGetRotationAngle: public MiniScript::ScriptMethod {
392  private:
393  MiniScript* miniScript { nullptr };
394  MiniScript::ScriptVariableType TYPE_TRANSFORM;
395  public:
396  ScriptMethodTransformGetRotationAngle(
397  MiniScript* miniScript,
398  MiniScript::ScriptVariableType TYPE_TRANSFORM
399  ):
400  MiniScript::ScriptMethod(
401  {
402  { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false },
403  { .type = MiniScript::ScriptVariableType::TYPE_INTEGER, .name = "idx", .optional = false, .reference = false, .nullable = false },
404  },
405  MiniScript::ScriptVariableType::TYPE_FLOAT
406  ),
407  miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM) {}
408  const string getMethodName() override {
409  return "transform.getRotationAngle";
410  }
411  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
412  int64_t idx;
413  Transform transform;
414  if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true &&
415  MiniScript::getIntegerValue(argumentValues, 1, idx, false) == true) {
416  if (idx < transform.getRotationCount()) {
417  returnValue.setValue(transform.getRotationAngle(idx));
418  } else {
419  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": rotation index invalid: " + to_string(idx) + " / " + to_string(transform.getRotationCount()));
420  miniScript->startErrorScript();
421  }
422  } else {
423  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
424  miniScript->startErrorScript();
425  }
426  }
427  };
428  miniScript->registerMethod(new ScriptMethodTransformGetRotationAngle(miniScript, TYPE_TRANSFORM));
429  }
430  {
431  //
432  class ScriptMethodTransformSetRotationAngle: public MiniScript::ScriptMethod {
433  private:
434  MiniScript* miniScript { nullptr };
435  MiniScript::ScriptVariableType TYPE_TRANSFORM;
436  public:
437  ScriptMethodTransformSetRotationAngle(
438  MiniScript* miniScript,
439  MiniScript::ScriptVariableType TYPE_TRANSFORM
440  ):
441  MiniScript::ScriptMethod(
442  {
443  { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = true, .nullable = false },
444  { .type = MiniScript::ScriptVariableType::TYPE_INTEGER, .name = "idx", .optional = false, .reference = false, .nullable = false },
445  { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false },
446  },
447  MiniScript::ScriptVariableType::TYPE_NULL
448  ),
449  miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM) {}
450  const string getMethodName() override {
451  return "transform.setRotationAngle";
452  }
453  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
454  int64_t idx;
455  Transform transform;
456  float angle;
457  if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true &&
458  MiniScript::getIntegerValue(argumentValues, 1, idx, false) == true &&
459  MiniScript::getFloatValue(argumentValues, 2, angle, false) == true) {
460  if (idx < transform.getRotationCount()) {
461  transform.setRotationAngle(idx, angle);
462  transform.update();
463  //
464  argumentValues[0].setType(TYPE_TRANSFORM);
465  argumentValues[0].setValue(&transform);
466  } else {
467  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": rotation index invalid: " + to_string(idx) + " / " + to_string(transform.getRotationCount()));
468  miniScript->startErrorScript();
469  }
470  } else {
471  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
472  miniScript->startErrorScript();
473  }
474  }
475  };
476  miniScript->registerMethod(new ScriptMethodTransformSetRotationAngle(miniScript, TYPE_TRANSFORM));
477  }
478  {
479  //
480  class ScriptMethodTransformRotate: public MiniScript::ScriptMethod {
481  private:
482  MiniScript* miniScript { nullptr };
483  MiniScript::ScriptVariableType TYPE_TRANSFORM;
484  MiniScript::ScriptVariableType TYPE_VECTOR3;
485  public:
486  ScriptMethodTransformRotate(
487  MiniScript* miniScript,
488  MiniScript::ScriptVariableType TYPE_TRANSFORM,
489  MiniScript::ScriptVariableType TYPE_VECTOR3
490  ):
491  MiniScript::ScriptMethod(
492  {
493  { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false },
494  { .type = TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false },
495  },
496  TYPE_VECTOR3
497  ),
498  miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {}
499  const string getMethodName() override {
500  return "transform.rotate";
501  }
502  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
503  Transform transform;
504  Vector3 vec3;
505  if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true &&
506  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, vec3, false) == true) {
507  //
508  auto result = transform.getRotationsQuaternion() * vec3;
509  //
510  returnValue.setType(TYPE_VECTOR3);
511  returnValue.setValue(&result);
512  } else {
513  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
514  miniScript->startErrorScript();
515  }
516  }
517  };
518  miniScript->registerMethod(new ScriptMethodTransformRotate(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3));
519  }
520  {
521  //
522  class ScriptMethodTransformApplyRotation: public MiniScript::ScriptMethod {
523  private:
524  MiniScript* miniScript { nullptr };
525  MiniScript::ScriptVariableType TYPE_TRANSFORM;
526  MiniScript::ScriptVariableType TYPE_VECTOR3;
527  public:
528  ScriptMethodTransformApplyRotation(
529  MiniScript* miniScript,
530  MiniScript::ScriptVariableType TYPE_TRANSFORM,
531  MiniScript::ScriptVariableType TYPE_VECTOR3
532  ):
533  MiniScript::ScriptMethod(
534  {
535  { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = true, .nullable = false },
536  { .type = TYPE_VECTOR3, .name = "axis", .optional = false, .reference = false, .nullable = false },
537  { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "angle", .optional = false, .reference = false, .nullable = false },
538  },
539  MiniScript::ScriptVariableType::TYPE_NULL
540  ),
541  miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_VECTOR3(TYPE_VECTOR3) {}
542  const string getMethodName() override {
543  return "transform.applyRotation";
544  }
545  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
546  Transform transform;
547  Vector3 axis;
548  float angle;
549  if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true &&
550  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, axis, false) == true &&
551  MiniScript::getFloatValue(argumentValues, 2, angle, false) == true) {
552  //
553  transform.addRotation(axis, angle);
554  transform.update();
555  // get transform and make sure its a euler transform
556  auto euler = transform.getTransformMatrix().computeEulerAngles();
557  while (transform.getRotationCount() > 3) transform.removeRotation(transform.getRotationCount() - 1);
558  while (transform.getRotationCount() < 3) transform.addRotation(Vector3(), 0.0f);
559  transform.setRotationAxis(0, Vector3(0.0f, 0.0f, 1.0f));
560  transform.setRotationAxis(1, Vector3(0.0f, 1.0f, 0.0f));
561  transform.setRotationAxis(2, Vector3(1.0f, 0.0f, 0.0f));
562  transform.setRotationAngle(0, euler.getZ());
563  transform.setRotationAngle(1, euler.getY());
564  transform.setRotationAngle(2, euler.getX());
565  transform.update();
566  //
567  argumentValues[0].setType(TYPE_TRANSFORM);
568  argumentValues[0].setValue(&transform);
569  } else {
570  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
571  miniScript->startErrorScript();
572  }
573  }
574  };
575  miniScript->registerMethod(new ScriptMethodTransformApplyRotation(miniScript, TYPE_TRANSFORM, TYPE_VECTOR3));
576  }
577  {
578  //
579  class ScriptMethodTransformInterpolateRotation: public MiniScript::ScriptMethod {
580  private:
581  MiniScript* miniScript { nullptr };
582  public:
583  ScriptMethodTransformInterpolateRotation(MiniScript* miniScript):
584  MiniScript::ScriptMethod(
585  {
586  { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "currentAngle", .optional = false, .reference = false, .nullable = false },
587  { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "targetAngle", .optional = false, .reference = false, .nullable = false },
588  { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "timePassedSeconds", .optional = false, .reference = false, .nullable = false },
589  { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "degreesPerSeconds", .optional = false, .reference = false, .nullable = false },
590  { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "interpolatedAngle", .optional = false, .reference = true, .nullable = false },
591  },
592  MiniScript::ScriptVariableType::TYPE_BOOLEAN
593  ),
594  miniScript(miniScript) {}
595  const string getMethodName() override {
596  return "transform.interpolateRotation";
597  }
598  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
599  float currentAngle;
600  float targetAngle;
601  float timePassedSeconds;
602  float degreesPerSeconds;
603  float interpolatedAngle = 0.0f;
604  if (argumentValues.size() == 5 &&
605  MiniScript::getFloatValue(argumentValues, 0, currentAngle) == true &&
606  MiniScript::getFloatValue(argumentValues, 1, targetAngle) == true &&
607  MiniScript::getFloatValue(argumentValues, 2, timePassedSeconds) == true &&
608  MiniScript::getFloatValue(argumentValues, 3, degreesPerSeconds) == true) {
609  returnValue = Rotation::interpolate(currentAngle, targetAngle, timePassedSeconds, degreesPerSeconds, interpolatedAngle);
610  argumentValues[4].setValue(interpolatedAngle);
611  } else {
612  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
613  miniScript->startErrorScript();
614  }
615  }
616  };
617  miniScript->registerMethod(new ScriptMethodTransformInterpolateRotation(miniScript));
618  }
619  {
620  //
621  class ScriptMethodTransformGetTransformMatrix: public MiniScript::ScriptMethod {
622  private:
623  MiniScript* miniScript { nullptr };
624  MiniScript::ScriptVariableType TYPE_TRANSFORM;
625  MiniScript::ScriptVariableType TYPE_MATRIX4x4;
626  public:
627  ScriptMethodTransformGetTransformMatrix(
628  MiniScript* miniScript,
629  MiniScript::ScriptVariableType TYPE_TRANSFORM,
630  MiniScript::ScriptVariableType TYPE_MATRIX4x4
631  ):
632  MiniScript::ScriptMethod(
633  {
634  { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false },
635  },
636  TYPE_MATRIX4x4
637  ),
638  miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_MATRIX4x4(TYPE_MATRIX4x4) {}
639  const string getMethodName() override {
640  return "transform.getTransformMatrix";
641  }
642  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
643  Transform transform;
644  if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true) {
645  const auto& result = transform.getTransformMatrix();
646  //
647  returnValue.setType(TYPE_MATRIX4x4);
648  returnValue.setValue(&result);
649  } else {
650  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
651  miniScript->startErrorScript();
652  }
653  }
654  };
655  miniScript->registerMethod(new ScriptMethodTransformGetTransformMatrix(miniScript, TYPE_TRANSFORM, TYPE_MATRIX4x4));
656  }
657  {
658  //
659  class ScriptMethodTransformGetRotationsQuaternion: public MiniScript::ScriptMethod {
660  private:
661  MiniScript* miniScript { nullptr };
662  MiniScript::ScriptVariableType TYPE_TRANSFORM;
663  MiniScript::ScriptVariableType TYPE_QUATERNION;
664  public:
665  ScriptMethodTransformGetRotationsQuaternion(
666  MiniScript* miniScript,
667  MiniScript::ScriptVariableType TYPE_TRANSFORM,
668  MiniScript::ScriptVariableType TYPE_QUATERNION
669  ):
670  MiniScript::ScriptMethod(
671  {
672  { .type = TYPE_TRANSFORM, .name = "transform", .optional = false, .reference = false, .nullable = false },
673  },
674  TYPE_QUATERNION
675  ),
676  miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_QUATERNION(TYPE_QUATERNION) {}
677  const string getMethodName() override {
678  return "transform.getRotationsQuaternion";
679  }
680  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
681  Transform transform;
682  if (MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, transform, false) == true) {
683  const auto& result = transform.getRotationsQuaternion();
684  //
685  returnValue.setType(TYPE_QUATERNION);
686  returnValue.setValue(&result);
687  } else {
688  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
689  miniScript->startErrorScript();
690  }
691  }
692  };
693  miniScript->registerMethod(new ScriptMethodTransformGetRotationsQuaternion(miniScript, TYPE_TRANSFORM, TYPE_QUATERNION));
694  }
695  {
696  //
697  class ScriptMethodTransformFromMatrix: public MiniScript::ScriptMethod {
698  private:
699  MiniScript* miniScript { nullptr };
700  MiniScript::ScriptVariableType TYPE_TRANSFORM;
701  MiniScript::ScriptVariableType TYPE_MATRIX4x4;
702  public:
703  ScriptMethodTransformFromMatrix(
704  MiniScript* miniScript,
705  MiniScript::ScriptVariableType TYPE_TRANSFORM,
706  MiniScript::ScriptVariableType TYPE_MATRIX4x4
707  ):
708  MiniScript::ScriptMethod(
709  {
710  { .type = TYPE_MATRIX4x4, .name = "transformMatrix", .optional = false, .reference = false, .nullable = false },
711  },
712  TYPE_TRANSFORM
713  ),
714  miniScript(miniScript), TYPE_TRANSFORM(TYPE_TRANSFORM), TYPE_MATRIX4x4(TYPE_MATRIX4x4) {}
715  const string getMethodName() override {
716  return "transform.fromMatrix";
717  }
718  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
719  Matrix4x4 transformMatrix;
720  if (MiniScriptMatrix4x4::getMatrix4x4Value(TYPE_TRANSFORM, argumentValues, 0, transformMatrix, false) == true) {
721  Transform result;
722  result.fromMatrix(transformMatrix, RotationOrder::ZYX);
723  returnValue.setType(TYPE_TRANSFORM);
724  returnValue.setValue(&result);
725  } else {
726  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
727  miniScript->startErrorScript();
728  }
729  }
730  };
731  miniScript->registerMethod(new ScriptMethodTransformFromMatrix(miniScript, TYPE_TRANSFORM, TYPE_MATRIX4x4));
732  }
733 }
734 
735 void MiniScriptTransform::unsetScriptVariableValue(MiniScript::ScriptVariable& variable) const {
736  if (variable.getType() != getType()) return;
737  if (variable.getValuePtr() == 0ll) return;
738  //
739  delete static_cast<Transform*>((void*)variable.getValuePtr());
740  variable.setValuePtr(0ll);
741 }
742 
743 void MiniScriptTransform::setScriptVariableValue(MiniScript::ScriptVariable& variable, const void* value) const {
744  if (variable.getType() != getType()) return;
745  //
746  Transform transformValue;
747  if (value != 0ll) {
748  transformValue = *static_cast<const Transform*>(value);
749  }
750  //
751  if (variable.getValuePtr() != 0ll) {
752  *static_cast<Transform*>((void*)variable.getValuePtr()) = transformValue;
753  return;
754  }
755  //
756  variable.setValuePtr((uint64_t)(new Transform(transformValue)));
757 }
758 
759 void MiniScriptTransform::copyScriptVariable(MiniScript::ScriptVariable& to, const MiniScript::ScriptVariable& from) const {
760  //
761  Transform transformValue;
762  if (from.getType() == getType() && from.getValuePtr() != 0ll) {
763  transformValue = *static_cast<Transform*>((void*)from.getValuePtr());
764  }
765  //
766  const auto TYPE_TRANSFORM = static_cast<MiniScript::ScriptVariableType>(getType());
767  to.setType(TYPE_TRANSFORM);
768  *static_cast<Transform*>((void*)to.getValuePtr()) = transformValue;
769 }
770 
771 bool MiniScriptTransform::mul(MiniScript* miniScript, const span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const {
772  const auto TYPE_TRANSFORM = static_cast<MiniScript::ScriptVariableType>(getType());
773  const auto TYPE_VECTOR3 = static_cast<MiniScript::ScriptVariableType>(miniScript->getDataTypeByClassName("vec3")->getType());
774  // transform
775  if (MiniScript::hasType(argumentValues, TYPE_TRANSFORM) == true) {
776  // transform * vec3
777  if (argumentValues[0].getType() == TYPE_TRANSFORM &&
778  argumentValues[1].getType() == TYPE_VECTOR3) {
779  Transform a;
780  Vector3 b;
781  MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 0, a, false);
782  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false);
783  //
784  auto result = a * b;
785  returnValue.setType(TYPE_VECTOR3);
786  returnValue.setValue(&result);
787  //
788  return true;
789  } else
790  // vec3 * transform
791  if (argumentValues[0].getType() == TYPE_VECTOR3 &&
792  argumentValues[1].getType() == TYPE_TRANSFORM) {
793  Vector3 a;
794  Transform b;
795  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false);
796  MiniScriptTransform::getTransformValue(TYPE_TRANSFORM, argumentValues, 1, b, false);
797  //
798  auto result = b * a;
799  returnValue.setType(TYPE_VECTOR3);
800  returnValue.setValue(&result);
801  //
802  return true;
803  } else {
804  Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul"));
805  miniScript->startErrorScript();
806  //
807  return false;
808  }
809  }
810  //
811  return false;
812 }
813 
814 bool MiniScriptTransform::div(MiniScript* miniScript, const span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const {
815  return false;
816 }
817 
818 bool MiniScriptTransform::add(MiniScript* miniScript, const span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const {
819  return false;
820 }
821 
822 bool MiniScriptTransform::sub(MiniScript* miniScript, const span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const {
823  return false;
824 }
825 
826 const string& MiniScriptTransform::getClassName() const {
827  return CLASS_NAME;
828 }
829 
830 const string& MiniScriptTransform::getTypeAsString() const {
831  return TYPE_NAME;
832 }
833 
834 const string MiniScriptTransform::getValueAsString(const MiniScript::ScriptVariable& variable) const {
835  //
836  Transform transformValue;
837  if (variable.getType() == getType() && variable.getValuePtr() != 0ll) {
838  transformValue = *static_cast<Transform*>((void*)variable.getValuePtr());
839  }
840  //
841  string result;
842  result+=
843  "Transform(translation: Vector3(" +
844  to_string(transformValue.getTranslation().getX()) + ", " +
845  to_string(transformValue.getTranslation().getY()) + ", " +
846  to_string(transformValue.getTranslation().getZ()) + "), " +
847  "scale: (" +
848  to_string(transformValue.getScale().getX()) + ", " +
849  to_string(transformValue.getScale().getY()) + ", " +
850  to_string(transformValue.getScale().getZ()) + ")";
851  for (auto i = 0; i < transformValue.getRotationCount(); i++) {
852  result+= ", rotations: (axis: Vector3(" +
853  to_string(transformValue.getRotationAxis(i).getX()) + ", " +
854  to_string(transformValue.getRotationAxis(i).getY()) + ", " +
855  to_string(transformValue.getRotationAxis(i).getZ()) + "), angle: " +
856  to_string(transformValue.getRotationAngle(i)) + ")";
857  }
858  result+= ")";
859  //
860  return result;
861 }
862 
tdme::engine::Transform
Transform which contain scale, rotations and translation.
Definition: Transform.h:29
tdme::engine::Transform::fromMatrix
virtual void fromMatrix(const Matrix4x4 &matrix, RotationOrder *rotationOrder)
Set up this transform from given matrix and rotation order.
Definition: Transform.cpp:22
tdme::engine::Transform::setRotationAngle
void setRotationAngle(const int idx, const float angle)
Definition: Transform.h:155
tdme::engine::Transform::setRotationAxis
void setRotationAxis(const int idx, const Vector3 &axis)
Set rotation axis.
Definition: Transform.h:138
tdme::engine::Transform::setTranslation
void setTranslation(const Vector3 &translation)
Set translation.
Definition: Transform.h:64
tdme::engine::Transform::removeRotation
void removeRotation(const int idx)
Remove rotation.
Definition: Transform.h:121
tdme::engine::Transform::getScale
const Vector3 & getScale() const
Definition: Transform.h:71
tdme::engine::Transform::setScale
void setScale(const Vector3 &scale)
Set scale.
Definition: Transform.h:79
tdme::engine::Transform::getRotationCount
const int getRotationCount() const
Definition: Transform.h:86
tdme::engine::Transform::getRotationAxis
const Vector3 & getRotationAxis(const int idx) const
Definition: Transform.h:129
tdme::engine::Transform::getRotationsQuaternion
const Quaternion & getRotationsQuaternion() const
Definition: Transform.h:162
tdme::engine::Transform::update
virtual void update()
Computes transform matrix.
Definition: Transform.cpp:33
tdme::engine::Transform::getTranslation
const Vector3 & getTranslation() const
Definition: Transform.h:56
tdme::engine::Transform::addRotation
void addRotation(const Vector3 &axis, const float angle)
Add rotation.
Definition: Transform.h:113
tdme::engine::Transform::getRotationAngle
const float getRotationAngle(const int idx) const
Definition: Transform.h:146
tdme::engine::Transform::getTransformMatrix
const Matrix4x4 & getTransformMatrix() const
Definition: Transform.h:169
tdme::math::Matrix4x4
Matrix4x4 class representing matrix4x4 mathematical structure and operations for 3d space.
Definition: Matrix4x4.h:23
tdme::math::Matrix4x4::computeEulerAngles
Vector3 computeEulerAngles() const
Compute Euler angles (rotation around x, y, z axes)
Definition: Matrix4x4.h:531
tdme::math::Vector3
Vector3 class representing vector3 mathematical structure and operations with x, y,...
Definition: Vector3.h:20
tdme::math::Vector3::getY
float getY() const
Definition: Vector3.h:117
tdme::math::Vector3::getX
float getX() const
Definition: Vector3.h:100
tdme::math::Vector3::getZ
float getZ() const
Definition: Vector3.h:134
tdme::utilities::Console
Console class.
Definition: Console.h:29
tdme::utilities::Console::println
static void println()
Print new line to console.
Definition: Console.cpp:92
tdme::utilities::Float
Float class.
Definition: Float.h:27
tdme::utilities::MiniScriptMatrix4x4
MiniScript Matrix4x4 data type.
Definition: MiniScriptMatrix4x4.h:21
tdme::utilities::MiniScriptMatrix4x4::getMatrix4x4Value
static bool getMatrix4x4Value(MiniScript::ScriptVariableType TYPE_MATRIX4x4, const span< MiniScript::ScriptVariable > &arguments, int idx, Matrix4x4 &value, bool optional=false)
Get matrix4x4 value from given variable.
Definition: MiniScriptMatrix4x4.h:46
tdme::utilities::MiniScriptQuaternion
MiniScript Quaternion data type.
Definition: MiniScriptQuaternion.h:23
tdme::utilities::MiniScriptTransform
MiniScript Transform data type.
Definition: MiniScriptTransform.h:21
tdme::utilities::MiniScriptTransform::getTypeAsString
const string & getTypeAsString() const override
Definition: MiniScriptTransform.cpp:830
tdme::utilities::MiniScriptTransform::add
bool add(MiniScript *miniScript, const span< MiniScript::ScriptVariable > &argumentValues, MiniScript::ScriptVariable &returnValue, const MiniScript::ScriptStatement &statement) const override
Definition: MiniScriptTransform.cpp:818
tdme::utilities::MiniScriptTransform::sub
bool sub(MiniScript *miniScript, const span< MiniScript::ScriptVariable > &argumentValues, MiniScript::ScriptVariable &returnValue, const MiniScript::ScriptStatement &statement) const override
Definition: MiniScriptTransform.cpp:822
tdme::utilities::MiniScriptTransform::getTransformValue
static bool getTransformValue(MiniScript::ScriptVariableType TYPE_TRANSFORM, const span< MiniScript::ScriptVariable > &arguments, int idx, Transform &value, bool optional=false)
Get quaternion value from given variable.
Definition: MiniScriptTransform.h:46
tdme::utilities::MiniScriptTransform::copyScriptVariable
void copyScriptVariable(MiniScript::ScriptVariable &to, const MiniScript::ScriptVariable &from) const override
Definition: MiniScriptTransform.cpp:759
tdme::utilities::MiniScriptTransform::unsetScriptVariableValue
void unsetScriptVariableValue(MiniScript::ScriptVariable &variable) const override
Definition: MiniScriptTransform.cpp:735
tdme::utilities::MiniScriptTransform::div
bool div(MiniScript *miniScript, const span< MiniScript::ScriptVariable > &argumentValues, MiniScript::ScriptVariable &returnValue, const MiniScript::ScriptStatement &statement) const override
Definition: MiniScriptTransform.cpp:814
tdme::utilities::MiniScriptTransform::getClassName
const string & getClassName() const override
Definition: MiniScriptTransform.cpp:826
tdme::utilities::MiniScriptTransform::mul
bool mul(MiniScript *miniScript, const span< MiniScript::ScriptVariable > &argumentValues, MiniScript::ScriptVariable &returnValue, const MiniScript::ScriptStatement &statement) const override
Definition: MiniScriptTransform.cpp:771
tdme::utilities::MiniScriptTransform::getValueAsString
const string getValueAsString(const MiniScript::ScriptVariable &variable) const override
Definition: MiniScriptTransform.cpp:834
tdme::utilities::MiniScriptTransform::setScriptVariableValue
void setScriptVariableValue(MiniScript::ScriptVariable &variable, const void *value) const override
Definition: MiniScriptTransform.cpp:743
tdme::utilities::MiniScriptVector3
MiniScript Vector3 data type.
Definition: MiniScriptVector3.h:21
tdme::utilities::MiniScriptVector3::getVector3Value
static bool getVector3Value(MiniScript::ScriptVariableType TYPE_VECTOR3, const span< MiniScript::ScriptVariable > &arguments, int idx, Vector3 &value, bool optional=false)
Get vector3 value from given variable.
Definition: MiniScriptVector3.h:46
Generated by doxygen 1.9.1