TDME2  1.9.200
MiniScriptVector3.cpp
Go to the documentation of this file.
1 #include <span>
2 #include <string>
3 
4 #include <miniscript/miniscript/MiniScript.h>
5 
6 #include <tdme/tdme.h>
7 #include <tdme/math/Vector3.h>
8 #include <tdme/utilities/Console.h>
9 #include <tdme/utilities/Float.h>
10 #include <tdme/utilities/MiniScriptVector3.h>
11 
12 using miniscript::miniscript::MiniScript;
13 
14 using std::span;
15 using std::string;
16 
17 using tdme::math::Vector3;
18 using tdme::utilities::Console;
19 using tdme::utilities::Float;
20 using tdme::utilities::MiniScriptVector3;
21 
22 const string MiniScriptVector3::CLASS_NAME = "vec3";
23 const string MiniScriptVector3::TYPE_NAME = "Vector3";
24 
25 void MiniScriptVector3::registerMethods(MiniScript* miniScript) const {
26  const auto TYPE_VECTOR3 = static_cast<MiniScript::ScriptVariableType>(getType());
27  {
28  //
29  class ScriptMethodVec3: public MiniScript::ScriptMethod {
30  private:
31  MiniScript* miniScript { nullptr };
32  MiniScript::ScriptVariableType TYPE_VECTOR3;
33  public:
34  ScriptMethodVec3(
35  MiniScript* miniScript,
36  MiniScript::ScriptVariableType TYPE_VECTOR3
37  ):
38  MiniScript::ScriptMethod(
39  {
40  { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "x", .optional = false, .reference = false, .nullable = false },
41  { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "y", .optional = false, .reference = false, .nullable = false },
42  { .type = MiniScript::ScriptVariableType::TYPE_FLOAT, .name = "z", .optional = false, .reference = false, .nullable = false }
43  },
44  TYPE_VECTOR3
45  ),
46  miniScript(miniScript),
47  TYPE_VECTOR3(TYPE_VECTOR3) {
48  //
49  }
50  const string getMethodName() override {
51  return "vec3";
52  }
53  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
54  Vector3 result;
55  float xValue;
56  float yValue;
57  float zValue;
58  if (MiniScript::getFloatValue(argumentValues, 0, xValue, false) == true &&
59  MiniScript::getFloatValue(argumentValues, 1, yValue, false) == true &&
60  MiniScript::getFloatValue(argumentValues, 2, zValue, false) == true) {
61  auto result = Vector3(xValue, yValue, zValue);
62  returnValue.setType(TYPE_VECTOR3);
63  returnValue.setValue(&result);
64  } else {
65  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
66  miniScript->startErrorScript();
67  }
68  }
69  };
70  miniScript->registerMethod(new ScriptMethodVec3(miniScript, TYPE_VECTOR3));
71  }
72  {
73  //
74  class ScriptMethodVec3ComputeLength: public MiniScript::ScriptMethod {
75  private:
76  MiniScript* miniScript { nullptr };
77  MiniScript::ScriptVariableType TYPE_VECTOR3;
78  public:
79  ScriptMethodVec3ComputeLength(
80  MiniScript* miniScript,
81  MiniScript::ScriptVariableType TYPE_VECTOR3
82  ):
83  MiniScript::ScriptMethod(
84  {
85  { .type = TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false }
86  },
87  MiniScript::ScriptVariableType::TYPE_FLOAT
88  ),
89  miniScript(miniScript),
90  TYPE_VECTOR3(TYPE_VECTOR3) {
91  //
92  }
93  const string getMethodName() override {
94  return "vec3.computeLength";
95  }
96  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
97  Vector3 vec3;
98  if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, vec3, false) == true) {
99  auto length = vec3.computeLength();
100  returnValue.setValue(Float::isInfinite(length) == true || Float::isNaN(length) == true?0.0f:length);
101  } else {
102  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
103  miniScript->startErrorScript();
104  }
105  }
106  };
107  miniScript->registerMethod(new ScriptMethodVec3ComputeLength(miniScript, TYPE_VECTOR3));
108  }
109  {
110  //
111  class ScriptMethodVec3ComputeLengthSquared: public MiniScript::ScriptMethod {
112  private:
113  MiniScript* miniScript { nullptr };
114  MiniScript::ScriptVariableType TYPE_VECTOR3;
115  public:
116  ScriptMethodVec3ComputeLengthSquared(
117  MiniScript* miniScript,
118  MiniScript::ScriptVariableType TYPE_VECTOR3
119  ):
120  MiniScript::ScriptMethod(
121  {
122  { .type = TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false }
123  },
124  MiniScript::ScriptVariableType::TYPE_FLOAT
125  ),
126  miniScript(miniScript),
127  TYPE_VECTOR3(TYPE_VECTOR3) {
128  //
129  }
130  const string getMethodName() override {
131  return "vec3.computeLengthSquared";
132  }
133  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
134  Vector3 vec3;
135  if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, vec3, false) == true) {
136  returnValue.setValue(vec3.computeLengthSquared());
137  } else {
138  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
139  miniScript->startErrorScript();
140  }
141  }
142  };
143  miniScript->registerMethod(new ScriptMethodVec3ComputeLengthSquared(miniScript, TYPE_VECTOR3));
144  }
145  {
146  //
147  class ScriptMethodVec3ComputeDotProduct: public MiniScript::ScriptMethod {
148  private:
149  MiniScript* miniScript { nullptr };
150  MiniScript::ScriptVariableType TYPE_VECTOR3;
151  public:
152  ScriptMethodVec3ComputeDotProduct(
153  MiniScript* miniScript,
154  MiniScript::ScriptVariableType TYPE_VECTOR3
155  ):
156  MiniScript::ScriptMethod(
157  {
158  { .type = TYPE_VECTOR3, .name = "a", .optional = false, .reference = false, .nullable = false },
159  { .type = TYPE_VECTOR3, .name = "b", .optional = false, .reference = false, .nullable = false }
160  },
161  MiniScript::ScriptVariableType::TYPE_FLOAT
162  ),
163  miniScript(miniScript),
164  TYPE_VECTOR3(TYPE_VECTOR3) {
165  //
166  }
167  const string getMethodName() override {
168  return "vec3.computeDotProduct";
169  }
170  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
171  Vector3 a;
172  Vector3 b;
173  if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false) == true &&
174  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false) == true) {
175  returnValue.setValue(Vector3::computeDotProduct(a, b));
176  } else {
177  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
178  miniScript->startErrorScript();
179  }
180  }
181  };
182  miniScript->registerMethod(new ScriptMethodVec3ComputeDotProduct(miniScript, TYPE_VECTOR3));
183  }
184  {
185  //
186  class ScriptMethodVec3ComputeCrossProduct: public MiniScript::ScriptMethod {
187  private:
188  MiniScript* miniScript { nullptr };
189  MiniScript::ScriptVariableType TYPE_VECTOR3;
190  public:
191  ScriptMethodVec3ComputeCrossProduct(
192  MiniScript* miniScript,
193  MiniScript::ScriptVariableType TYPE_VECTOR3
194  ):
195  MiniScript::ScriptMethod(
196  {
197  { .type = TYPE_VECTOR3, .name = "a", .optional = false, .reference = false, .nullable = false },
198  { .type = TYPE_VECTOR3, .name = "b", .optional = false, .reference = false, .nullable = false }
199  },
200  TYPE_VECTOR3
201  ),
202  miniScript(miniScript),
203  TYPE_VECTOR3(TYPE_VECTOR3) {
204  //
205  }
206  const string getMethodName() override {
207  return "vec3.computeCrossProduct";
208  }
209  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
210  Vector3 a;
211  Vector3 b;
212  if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false) == true &&
213  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false) == true) {
214  auto result = Vector3::computeCrossProduct(a, b);
215  returnValue.setType(TYPE_VECTOR3);
216  returnValue.setValue(&result);
217  } else {
218  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
219  miniScript->startErrorScript();
220  }
221  }
222  };
223  miniScript->registerMethod(new ScriptMethodVec3ComputeCrossProduct(miniScript, TYPE_VECTOR3));
224  }
225  {
226  //
227  class ScriptMethodVec3Normalize: public MiniScript::ScriptMethod {
228  private:
229  MiniScript* miniScript { nullptr };
230  MiniScript::ScriptVariableType TYPE_VECTOR3;
231  public:
232  ScriptMethodVec3Normalize(
233  MiniScript* miniScript,
234  MiniScript::ScriptVariableType TYPE_VECTOR3
235  ):
236  MiniScript::ScriptMethod(
237  {
238  { .type = TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false },
239  },
240  TYPE_VECTOR3
241  ),
242  miniScript(miniScript),
243  TYPE_VECTOR3(TYPE_VECTOR3) {
244  //
245  }
246  const string getMethodName() override {
247  return "vec3.normalize";
248  }
249  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
250  Vector3 vec3;
251  if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, vec3, false) == true) {
252  auto length = vec3.computeLength();
253  auto result = length < Math::EPSILON || Float::isInfinite(length) == true || Float::isNaN(length) == true?Vector3(0.0f, 0.0f, 0.0f):vec3.normalize();
254  returnValue.setType(TYPE_VECTOR3);
255  returnValue.setValue(&result);
256  } else {
257  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
258  miniScript->startErrorScript();
259  }
260  }
261  };
262  miniScript->registerMethod(new ScriptMethodVec3Normalize(miniScript, TYPE_VECTOR3));
263  }
264  {
265  //
266  class ScriptMethodVec3ComputeAngle: public MiniScript::ScriptMethod {
267  private:
268  MiniScript* miniScript { nullptr };
269  MiniScript::ScriptVariableType TYPE_VECTOR3;
270  public:
271  ScriptMethodVec3ComputeAngle(
272  MiniScript* miniScript,
273  MiniScript::ScriptVariableType TYPE_VECTOR3
274  ):
275  MiniScript::ScriptMethod(
276  {
277  { .type = TYPE_VECTOR3, .name = "a", .optional = false, .reference = false, .nullable = false },
278  { .type = TYPE_VECTOR3, .name = "b", .optional = false, .reference = false, .nullable = false },
279  { .type = TYPE_VECTOR3, .name = "n", .optional = false, .reference = false, .nullable = false },
280  },
281  MiniScript::ScriptVariableType::TYPE_FLOAT
282  ),
283  miniScript(miniScript),
284  TYPE_VECTOR3(TYPE_VECTOR3) {
285  //
286  }
287  const string getMethodName() override {
288  return "vec3.computeAngle";
289  }
290  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
291  Vector3 a;
292  Vector3 b;
293  Vector3 n;
294  if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false) == true &&
295  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false) == true &&
296  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 2, n, false) == true) {
297  returnValue.setValue(Vector3::computeAngle(a, b, n));
298  } else {
299  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
300  miniScript->startErrorScript();
301  }
302  }
303  };
304  miniScript->registerMethod(new ScriptMethodVec3ComputeAngle(miniScript, TYPE_VECTOR3));
305  }
306  {
307  //
308  class ScriptMethodVec3GetX: public MiniScript::ScriptMethod {
309  private:
310  MiniScript* miniScript { nullptr };
311  MiniScript::ScriptVariableType TYPE_VECTOR3;
312  public:
313  ScriptMethodVec3GetX(
314  MiniScript* miniScript,
315  MiniScript::ScriptVariableType TYPE_VECTOR3
316  ):
317  MiniScript::ScriptMethod(
318  {
319  { .type = TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false },
320  },
321  MiniScript::ScriptVariableType::TYPE_FLOAT
322  ),
323  miniScript(miniScript),
324  TYPE_VECTOR3(TYPE_VECTOR3) {
325  //
326  }
327  const string getMethodName() override {
328  return "vec3.getX";
329  }
330  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
331  Vector3 vec3;
332  if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, vec3, false) == true) {
333  returnValue.setValue(vec3.getX());
334  } else {
335  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
336  miniScript->startErrorScript();
337  }
338  }
339  };
340  miniScript->registerMethod(new ScriptMethodVec3GetX(miniScript, TYPE_VECTOR3));
341  }
342  {
343  //
344  class ScriptMethodVec3GetY: public MiniScript::ScriptMethod {
345  private:
346  MiniScript* miniScript { nullptr };
347  MiniScript::ScriptVariableType TYPE_VECTOR3;
348  public:
349  ScriptMethodVec3GetY(
350  MiniScript* miniScript,
351  MiniScript::ScriptVariableType TYPE_VECTOR3
352  ):
353  MiniScript::ScriptMethod(
354  {
355  { .type = TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false },
356  },
357  MiniScript::ScriptVariableType::TYPE_FLOAT
358  ),
359  miniScript(miniScript),
360  TYPE_VECTOR3(TYPE_VECTOR3) {
361  //
362  }
363  const string getMethodName() override {
364  return "vec3.getY";
365  }
366  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
367  Vector3 vec3;
368  if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, vec3, false) == true) {
369  returnValue.setValue(vec3.getY());
370  } else {
371  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
372  miniScript->startErrorScript();
373  }
374  }
375  };
376  miniScript->registerMethod(new ScriptMethodVec3GetY(miniScript, TYPE_VECTOR3));
377  }
378  {
379  //
380  class ScriptMethodVec3GetZ: public MiniScript::ScriptMethod {
381  private:
382  MiniScript* miniScript { nullptr };
383  MiniScript::ScriptVariableType TYPE_VECTOR3;
384  public:
385  ScriptMethodVec3GetZ(
386  MiniScript* miniScript,
387  MiniScript::ScriptVariableType TYPE_VECTOR3
388  ):
389  MiniScript::ScriptMethod(
390  {
391  { .type = TYPE_VECTOR3, .name = "vec3", .optional = false, .reference = false, .nullable = false },
392  },
393  MiniScript::ScriptVariableType::TYPE_FLOAT
394  ),
395  miniScript(miniScript),
396  TYPE_VECTOR3(TYPE_VECTOR3) {
397  //
398  }
399  const string getMethodName() override {
400  return "vec3.getZ";
401  }
402  void executeMethod(span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) override {
403  Vector3 vec3;
404  if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, vec3, false) == true) {
405  returnValue.setValue(vec3.getZ());
406  } else {
407  Console::println(getMethodName() + "(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation(getMethodName()));
408  miniScript->startErrorScript();
409  }
410  }
411  };
412  miniScript->registerMethod(new ScriptMethodVec3GetZ(miniScript, TYPE_VECTOR3));
413  }
414 }
415 
416 void MiniScriptVector3::unsetScriptVariableValue(MiniScript::MiniScript::ScriptVariable& variable) const {
417  if (variable.getType() != getType()) return;
418  if (variable.getValuePtr() == 0ll) return;
419  //
420  delete static_cast<Vector3*>((void*)variable.getValuePtr());
421  variable.setValuePtr(0ll);
422 }
423 
424 void MiniScriptVector3::setScriptVariableValue(MiniScript::MiniScript::ScriptVariable& variable, const void* value) const {
425  if (variable.getType() != getType()) return;
426  //
427  Vector3 vector3Value;
428  if (value != 0ll) {
429  vector3Value = *static_cast<const Vector3*>(value);
430  }
431  //
432  if (variable.getValuePtr() != 0ll) {
433  *static_cast<Vector3*>((void*)variable.getValuePtr()) = vector3Value;
434  return;
435  }
436  //
437  variable.setValuePtr((uint64_t)(new Vector3(vector3Value)));
438 }
439 
440 void MiniScriptVector3::copyScriptVariable(MiniScript::MiniScript::ScriptVariable& to, const MiniScript::MiniScript::ScriptVariable& from) const {
441  //
442  Vector3 vector3Value;
443  if (from.getType() == getType() && from.getValuePtr() != 0ll) {
444  vector3Value = *static_cast<Vector3*>((void*)from.getValuePtr());
445  }
446  //
447  const auto TYPE_VECTOR3 = static_cast<MiniScript::ScriptVariableType>(getType());
448  to.setType(TYPE_VECTOR3);
449  *static_cast<Vector3*>((void*)to.getValuePtr()) = vector3Value;
450 }
451 
452 bool MiniScriptVector3::mul(MiniScript* miniScript, const span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const {
453  const auto TYPE_VECTOR3 = static_cast<MiniScript::ScriptVariableType>(getType());
454  // vector3
455  if (MiniScript::hasType(argumentValues, TYPE_VECTOR3) == true) {
456  float f;
457  // a
458  Vector3 a;
459  if (argumentValues[0].getType() == TYPE_VECTOR3) {
460  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false);
461  } else
462  if (MiniScript::getFloatValue(argumentValues, 0, f, false) == true) {
463  a = Vector3(f, f, f);
464  } else {
465  Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul"));
466  miniScript->startErrorScript();
467  return false;
468  }
469  // b
470  Vector3 b;
471  if (argumentValues[1].getType() == TYPE_VECTOR3) {
472  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false);
473  } else
474  if (MiniScript::getFloatValue(argumentValues, 1, f, false) == true) {
475  b = Vector3(f, f, f);
476  } else {
477  Console::println("mul(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("mul"));
478  miniScript->startErrorScript();
479  return false;
480  }
481  //
482  auto result = a.clone().scale(b);
483  returnValue.setType(TYPE_VECTOR3);
484  returnValue.setValue(&result);
485  //
486  return true;
487  }
488  //
489  return false;
490 }
491 
492 bool MiniScriptVector3::div(MiniScript* miniScript, const span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const {
493  const auto TYPE_VECTOR3 = static_cast<MiniScript::ScriptVariableType>(getType());
494  // vector3
495  if (argumentValues[0].getType() == TYPE_VECTOR3) {
496  Vector3 a;
497  Vector3 b;
498  float f;
499  // a
500  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false);
501  // b
502  if (argumentValues[1].getType() == TYPE_VECTOR3 &&
503  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false) == true) {
504  // nop
505  } else
506  if (MiniScript::getFloatValue(argumentValues, 1, f, false) == true) {
507  b = Vector3(f, f, f);
508  } else {
509  Console::println("div(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("div"));
510  miniScript->startErrorScript();
511  return false;
512  }
513  //
514  auto result = a / b;
515  returnValue.setType(TYPE_VECTOR3);
516  returnValue.setValue(&result);
517  //
518  return true;
519  }
520  //
521  return false;
522 }
523 
524 bool MiniScriptVector3::add(MiniScript* miniScript, const span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const {
525  const auto TYPE_VECTOR3 = static_cast<MiniScript::ScriptVariableType>(getType());
526  // vector3
527  if (MiniScript::hasType(argumentValues, TYPE_VECTOR3) == true) {
528  Vector3 a;
529  Vector3 b;
530  if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false) == true &&
531  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false) == true) {
532  auto result = a.clone().add(b);
533  returnValue.setType(TYPE_VECTOR3);
534  returnValue.setValue(&result);
535  //
536  return true;
537  } else {
538  Console::println("add(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("add"));
539  miniScript->startErrorScript();
540  //
541  return false;
542  }
543  }
544  //
545  return false;
546 }
547 
548 bool MiniScriptVector3::sub(MiniScript* miniScript, const span<MiniScript::ScriptVariable>& argumentValues, MiniScript::ScriptVariable& returnValue, const MiniScript::ScriptStatement& statement) const {
549  const auto TYPE_VECTOR3 = static_cast<MiniScript::ScriptVariableType>(getType());
550  // vector3
551  if (MiniScript::hasType(argumentValues, TYPE_VECTOR3) == true) {
552  Vector3 a;
553  Vector3 b;
554  if (MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 0, a, false) == true &&
555  MiniScriptVector3::getVector3Value(TYPE_VECTOR3, argumentValues, 1, b, false) == true) {
556  auto result = a.clone().sub(b);
557  returnValue.setType(TYPE_VECTOR3);
558  returnValue.setValue(&result);
559  //
560  return true;
561  } else {
562  Console::println("sub(): " + miniScript->getStatementInformation(statement) + ": argument mismatch: expected arguments: " + miniScript->getArgumentInformation("sub"));
563  miniScript->startErrorScript();
564  //
565  return false;
566  }
567  }
568  //
569  return false;
570 }
571 
572 const string& MiniScriptVector3::getClassName() const {
573  return CLASS_NAME;
574 }
575 
576 const string& MiniScriptVector3::getTypeAsString() const {
577  return TYPE_NAME;
578 }
579 
580 const string MiniScriptVector3::getValueAsString(const MiniScript::MiniScript::ScriptVariable& variable) const {
581  //
582  Vector3 vector3Value;
583  if (variable.getType() == getType() && variable.getValuePtr() != 0ll) {
584  vector3Value = *static_cast<Vector3*>((void*)variable.getValuePtr());
585  }
586  //
587  return
588  "Vector3(" +
589  to_string(vector3Value.getX()) + ", " +
590  to_string(vector3Value.getY()) + ", " +
591  to_string(vector3Value.getZ()) + ")";
592 
593 }
594 
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::computeLength
float computeLength() const
Definition: Vector3.h:274
tdme::math::Vector3::getZ
float getZ() const
Definition: Vector3.h:134
tdme::math::Vector3::add
Vector3 & add(float scalar)
Adds a scalar.
Definition: Vector3.h:153
tdme::math::Vector3::computeLengthSquared
float computeLengthSquared() const
Definition: Vector3.h:281
tdme::math::Vector3::clone
Vector3 clone() const
Clones this vector3.
Definition: Vector3.h:374
tdme::math::Vector3::sub
Vector3 & sub(float scalar)
Subtracts a scalar.
Definition: Vector3.h:177
tdme::math::Vector3::scale
Vector3 & scale(float scalar)
Scales by scalar.
Definition: Vector3.h:201
tdme::math::Vector3::normalize
Vector3 & normalize()
Normalizes this vector3.
Definition: Vector3.h:239
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::Float::isInfinite
static bool isInfinite(float value)
Check if float is infinite.
Definition: Float.h:75
tdme::utilities::Float::isNaN
static bool isNaN(float value)
Check if float is not a number.
Definition: Float.h:66
tdme::utilities::MiniScriptVector3
MiniScript Vector3 data type.
Definition: MiniScriptVector3.h:21
tdme::utilities::MiniScriptVector3::getTypeAsString
const string & getTypeAsString() const override
Definition: MiniScriptVector3.cpp:576
tdme::utilities::MiniScriptVector3::add
bool add(MiniScript *miniScript, const span< MiniScript::ScriptVariable > &argumentValues, MiniScript::ScriptVariable &returnValue, const MiniScript::ScriptStatement &statement) const override
Definition: MiniScriptVector3.cpp:524
tdme::utilities::MiniScriptVector3::sub
bool sub(MiniScript *miniScript, const span< MiniScript::ScriptVariable > &argumentValues, MiniScript::ScriptVariable &returnValue, const MiniScript::ScriptStatement &statement) const override
Definition: MiniScriptVector3.cpp:548
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
tdme::utilities::MiniScriptVector3::copyScriptVariable
void copyScriptVariable(MiniScript::ScriptVariable &to, const MiniScript::ScriptVariable &from) const override
Definition: MiniScriptVector3.cpp:440
tdme::utilities::MiniScriptVector3::unsetScriptVariableValue
void unsetScriptVariableValue(MiniScript::ScriptVariable &variable) const override
Definition: MiniScriptVector3.cpp:416
tdme::utilities::MiniScriptVector3::div
bool div(MiniScript *miniScript, const span< MiniScript::ScriptVariable > &argumentValues, MiniScript::ScriptVariable &returnValue, const MiniScript::ScriptStatement &statement) const override
Definition: MiniScriptVector3.cpp:492
tdme::utilities::MiniScriptVector3::getClassName
const string & getClassName() const override
Definition: MiniScriptVector3.cpp:572
tdme::utilities::MiniScriptVector3::mul
bool mul(MiniScript *miniScript, const span< MiniScript::ScriptVariable > &argumentValues, MiniScript::ScriptVariable &returnValue, const MiniScript::ScriptStatement &statement) const override
Definition: MiniScriptVector3.cpp:452
tdme::utilities::MiniScriptVector3::getValueAsString
const string getValueAsString(const MiniScript::ScriptVariable &variable) const override
Definition: MiniScriptVector3.cpp:580
tdme::utilities::MiniScriptVector3::setScriptVariableValue
void setScriptVariableValue(MiniScript::ScriptVariable &variable, const void *value) const override
Definition: MiniScriptVector3.cpp:424
Generated by doxygen 1.9.1