1 /*************************************************************************/
2 /* visual_script_builtin_funcs.cpp */
3 /*************************************************************************/
4 /* This file is part of: */
5 /* GODOT ENGINE */
6 /* https://godotengine.org */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
9 /* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
10 /* */
11 /* Permission is hereby granted, free of charge, to any person obtaining */
12 /* a copy of this software and associated documentation files (the */
13 /* "Software"), to deal in the Software without restriction, including */
14 /* without limitation the rights to use, copy, modify, merge, publish, */
15 /* distribute, sublicense, and/or sell copies of the Software, and to */
16 /* permit persons to whom the Software is furnished to do so, subject to */
17 /* the following conditions: */
18 /* */
19 /* The above copyright notice and this permission notice shall be */
20 /* included in all copies or substantial portions of the Software. */
21 /* */
22 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
23 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
24 /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
25 /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
26 /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
27 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
28 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
29 /*************************************************************************/
30
31 #include "visual_script_builtin_funcs.h"
32
33 #include "core/class_db.h"
34 #include "core/func_ref.h"
35 #include "core/io/marshalls.h"
36 #include "core/math/math_funcs.h"
37 #include "core/os/os.h"
38 #include "core/reference.h"
39 #include "core/variant_parser.h"
40
41 const char *VisualScriptBuiltinFunc::func_name[VisualScriptBuiltinFunc::FUNC_MAX] = {
42 "sin",
43 "cos",
44 "tan",
45 "sinh",
46 "cosh",
47 "tanh",
48 "asin",
49 "acos",
50 "atan",
51 "atan2",
52 "sqrt",
53 "fmod",
54 "fposmod",
55 "floor",
56 "ceil",
57 "round",
58 "abs",
59 "sign",
60 "pow",
61 "log",
62 "exp",
63 "is_nan",
64 "is_inf",
65 "ease",
66 "decimals",
67 "stepify",
68 "lerp",
69 "inverse_lerp",
70 "range_lerp",
71 "move_toward",
72 "dectime",
73 "randomize",
74 "randi",
75 "randf",
76 "rand_range",
77 "seed",
78 "rand_seed",
79 "deg2rad",
80 "rad2deg",
81 "linear2db",
82 "db2linear",
83 "polar2cartesian",
84 "cartesian2polar",
85 "wrapi",
86 "wrapf",
87 "max",
88 "min",
89 "clamp",
90 "nearest_po2",
91 "weakref",
92 "funcref",
93 "convert",
94 "typeof",
95 "type_exists",
96 "char",
97 "str",
98 "print",
99 "printerr",
100 "printraw",
101 "var2str",
102 "str2var",
103 "var2bytes",
104 "bytes2var",
105 "color_named",
106 "smoothstep",
107 "posmod",
108 "lerp_angle",
109 "ord",
110 };
111
find_function(const String & p_string)112 VisualScriptBuiltinFunc::BuiltinFunc VisualScriptBuiltinFunc::find_function(const String &p_string) {
113
114 for (int i = 0; i < FUNC_MAX; i++) {
115 if (p_string == func_name[i])
116 return BuiltinFunc(i);
117 }
118
119 return FUNC_MAX;
120 }
121
get_func_name(BuiltinFunc p_func)122 String VisualScriptBuiltinFunc::get_func_name(BuiltinFunc p_func) {
123
124 ERR_FAIL_INDEX_V(p_func, FUNC_MAX, String());
125 return func_name[p_func];
126 }
127
get_output_sequence_port_count() const128 int VisualScriptBuiltinFunc::get_output_sequence_port_count() const {
129
130 return has_input_sequence_port() ? 1 : 0;
131 }
132
has_input_sequence_port() const133 bool VisualScriptBuiltinFunc::has_input_sequence_port() const {
134
135 switch (func) {
136
137 case MATH_RANDOMIZE:
138 case TEXT_PRINT:
139 case TEXT_PRINTERR:
140 case TEXT_PRINTRAW:
141 return true;
142 default:
143 return false;
144 }
145 }
146
get_func_argument_count(BuiltinFunc p_func)147 int VisualScriptBuiltinFunc::get_func_argument_count(BuiltinFunc p_func) {
148
149 switch (p_func) {
150
151 case MATH_RANDOMIZE:
152 case MATH_RAND:
153 case MATH_RANDF:
154 return 0;
155 case MATH_SIN:
156 case MATH_COS:
157 case MATH_TAN:
158 case MATH_SINH:
159 case MATH_COSH:
160 case MATH_TANH:
161 case MATH_ASIN:
162 case MATH_ACOS:
163 case MATH_ATAN:
164 case MATH_SQRT:
165 case MATH_FLOOR:
166 case MATH_CEIL:
167 case MATH_ROUND:
168 case MATH_ABS:
169 case MATH_SIGN:
170 case MATH_LOG:
171 case MATH_EXP:
172 case MATH_ISNAN:
173 case MATH_ISINF:
174 case MATH_DECIMALS:
175 case MATH_SEED:
176 case MATH_RANDSEED:
177 case MATH_DEG2RAD:
178 case MATH_RAD2DEG:
179 case MATH_LINEAR2DB:
180 case MATH_DB2LINEAR:
181 case LOGIC_NEAREST_PO2:
182 case OBJ_WEAKREF:
183 case TYPE_OF:
184 case TEXT_CHAR:
185 case TEXT_ORD:
186 case TEXT_STR:
187 case TEXT_PRINT:
188 case TEXT_PRINTERR:
189 case TEXT_PRINTRAW:
190 case VAR_TO_STR:
191 case STR_TO_VAR:
192 case TYPE_EXISTS:
193 return 1;
194 case VAR_TO_BYTES:
195 case BYTES_TO_VAR:
196 case MATH_ATAN2:
197 case MATH_FMOD:
198 case MATH_FPOSMOD:
199 case MATH_POSMOD:
200 case MATH_POW:
201 case MATH_EASE:
202 case MATH_STEPIFY:
203 case MATH_RANDOM:
204 case MATH_POLAR2CARTESIAN:
205 case MATH_CARTESIAN2POLAR:
206 case LOGIC_MAX:
207 case LOGIC_MIN:
208 case FUNC_FUNCREF:
209 case TYPE_CONVERT:
210 case COLORN:
211 return 2;
212 case MATH_LERP:
213 case MATH_LERP_ANGLE:
214 case MATH_INVERSE_LERP:
215 case MATH_SMOOTHSTEP:
216 case MATH_MOVE_TOWARD:
217 case MATH_DECTIME:
218 case MATH_WRAP:
219 case MATH_WRAPF:
220 case LOGIC_CLAMP:
221 return 3;
222 case MATH_RANGE_LERP:
223 return 5;
224 case FUNC_MAX: {
225 }
226 }
227 return 0;
228 }
229
get_input_value_port_count() const230 int VisualScriptBuiltinFunc::get_input_value_port_count() const {
231
232 return get_func_argument_count(func);
233 }
get_output_value_port_count() const234 int VisualScriptBuiltinFunc::get_output_value_port_count() const {
235
236 switch (func) {
237 case MATH_RANDOMIZE:
238 case TEXT_PRINT:
239 case TEXT_PRINTERR:
240 case TEXT_PRINTRAW:
241 case MATH_SEED:
242 return 0;
243 case MATH_RANDSEED:
244 return 2;
245 default:
246 return 1;
247 }
248
249 return 1;
250 }
251
get_output_sequence_port_text(int p_port) const252 String VisualScriptBuiltinFunc::get_output_sequence_port_text(int p_port) const {
253
254 return String();
255 }
256
get_input_value_port_info(int p_idx) const257 PropertyInfo VisualScriptBuiltinFunc::get_input_value_port_info(int p_idx) const {
258
259 switch (func) {
260
261 case MATH_SIN:
262 case MATH_COS:
263 case MATH_TAN:
264 case MATH_SINH:
265 case MATH_COSH:
266 case MATH_TANH:
267 case MATH_ASIN:
268 case MATH_ACOS:
269 case MATH_ATAN:
270 case MATH_SQRT:
271 case MATH_FLOOR:
272 case MATH_CEIL:
273 case MATH_ROUND:
274 case MATH_ABS:
275 case MATH_SIGN:
276 case MATH_LOG:
277 case MATH_EXP:
278 case MATH_ISNAN:
279 case MATH_ISINF: {
280 return PropertyInfo(Variant::REAL, "s");
281 } break;
282 case MATH_ATAN2: {
283 if (p_idx == 0)
284 return PropertyInfo(Variant::REAL, "y");
285 else
286 return PropertyInfo(Variant::REAL, "x");
287 } break;
288 case MATH_FMOD:
289 case MATH_FPOSMOD:
290 case LOGIC_MAX:
291 case LOGIC_MIN: {
292 if (p_idx == 0)
293 return PropertyInfo(Variant::REAL, "a");
294 else
295 return PropertyInfo(Variant::REAL, "b");
296 } break;
297 case MATH_POSMOD: {
298 if (p_idx == 0)
299 return PropertyInfo(Variant::INT, "a");
300 else
301 return PropertyInfo(Variant::INT, "b");
302 } break;
303 case MATH_POW: {
304 if (p_idx == 0)
305 return PropertyInfo(Variant::REAL, "base");
306 else
307 return PropertyInfo(Variant::REAL, "exp");
308 } break;
309 case MATH_EASE: {
310 if (p_idx == 0)
311 return PropertyInfo(Variant::REAL, "s");
312 else
313 return PropertyInfo(Variant::REAL, "curve");
314 } break;
315 case MATH_DECIMALS: {
316 return PropertyInfo(Variant::REAL, "step");
317 } break;
318 case MATH_STEPIFY: {
319 if (p_idx == 0)
320 return PropertyInfo(Variant::REAL, "s");
321 else
322 return PropertyInfo(Variant::REAL, "steps");
323 } break;
324 case MATH_LERP:
325 case MATH_LERP_ANGLE:
326 case MATH_INVERSE_LERP:
327 case MATH_SMOOTHSTEP: {
328 if (p_idx == 0)
329 return PropertyInfo(Variant::REAL, "from");
330 else if (p_idx == 1)
331 return PropertyInfo(Variant::REAL, "to");
332 else
333 return PropertyInfo(Variant::REAL, "weight");
334 } break;
335 case MATH_RANGE_LERP: {
336 if (p_idx == 0)
337 return PropertyInfo(Variant::REAL, "value");
338 else if (p_idx == 1)
339 return PropertyInfo(Variant::REAL, "istart");
340 else if (p_idx == 2)
341 return PropertyInfo(Variant::REAL, "istop");
342 else if (p_idx == 3)
343 return PropertyInfo(Variant::REAL, "ostart");
344 else
345 return PropertyInfo(Variant::REAL, "ostop");
346 } break;
347 case MATH_MOVE_TOWARD: {
348 if (p_idx == 0)
349 return PropertyInfo(Variant::REAL, "from");
350 else if (p_idx == 1)
351 return PropertyInfo(Variant::REAL, "to");
352 else
353 return PropertyInfo(Variant::REAL, "delta");
354 } break;
355 case MATH_DECTIME: {
356 if (p_idx == 0)
357 return PropertyInfo(Variant::REAL, "value");
358 else if (p_idx == 1)
359 return PropertyInfo(Variant::REAL, "amount");
360 else
361 return PropertyInfo(Variant::REAL, "step");
362 } break;
363 case MATH_RANDOMIZE:
364 case MATH_RAND:
365 case MATH_RANDF: {
366
367 } break;
368 case MATH_RANDOM: {
369 if (p_idx == 0)
370 return PropertyInfo(Variant::REAL, "from");
371 else
372 return PropertyInfo(Variant::REAL, "to");
373 } break;
374 case MATH_SEED:
375 case MATH_RANDSEED: {
376 return PropertyInfo(Variant::INT, "seed");
377 } break;
378 case MATH_DEG2RAD: {
379 return PropertyInfo(Variant::REAL, "deg");
380 } break;
381 case MATH_RAD2DEG: {
382 return PropertyInfo(Variant::REAL, "rad");
383 } break;
384 case MATH_LINEAR2DB: {
385 return PropertyInfo(Variant::REAL, "nrg");
386 } break;
387 case MATH_DB2LINEAR: {
388 return PropertyInfo(Variant::REAL, "db");
389 } break;
390 case MATH_POLAR2CARTESIAN: {
391 if (p_idx == 0)
392 return PropertyInfo(Variant::REAL, "r");
393 else
394 return PropertyInfo(Variant::REAL, "th");
395 } break;
396 case MATH_CARTESIAN2POLAR: {
397 if (p_idx == 0)
398 return PropertyInfo(Variant::REAL, "x");
399 else
400 return PropertyInfo(Variant::REAL, "y");
401 } break;
402 case MATH_WRAP: {
403 if (p_idx == 0)
404 return PropertyInfo(Variant::INT, "value");
405 else if (p_idx == 1)
406 return PropertyInfo(Variant::INT, "min");
407 else
408 return PropertyInfo(Variant::INT, "max");
409 } break;
410 case MATH_WRAPF:
411 case LOGIC_CLAMP: {
412 if (p_idx == 0)
413 return PropertyInfo(Variant::REAL, "value");
414 else if (p_idx == 1)
415 return PropertyInfo(Variant::REAL, "min");
416 else
417 return PropertyInfo(Variant::REAL, "max");
418 } break;
419 case LOGIC_NEAREST_PO2: {
420 return PropertyInfo(Variant::INT, "value");
421 } break;
422 case OBJ_WEAKREF: {
423 return PropertyInfo(Variant::OBJECT, "source");
424 } break;
425 case FUNC_FUNCREF: {
426 if (p_idx == 0)
427 return PropertyInfo(Variant::OBJECT, "instance");
428 else
429 return PropertyInfo(Variant::STRING, "funcname");
430 } break;
431 case TYPE_CONVERT: {
432 if (p_idx == 0)
433 return PropertyInfo(Variant::NIL, "what");
434 else
435 return PropertyInfo(Variant::STRING, "type");
436 } break;
437 case TYPE_OF: {
438 return PropertyInfo(Variant::NIL, "what");
439 } break;
440 case TYPE_EXISTS: {
441 return PropertyInfo(Variant::STRING, "type");
442 } break;
443 case TEXT_ORD: {
444 return PropertyInfo(Variant::STRING, "character");
445 } break;
446 case TEXT_CHAR: {
447 return PropertyInfo(Variant::INT, "ascii");
448 } break;
449 case TEXT_STR:
450 case TEXT_PRINT:
451 case TEXT_PRINTERR:
452 case TEXT_PRINTRAW: {
453 return PropertyInfo(Variant::NIL, "value");
454 } break;
455 case STR_TO_VAR: {
456
457 return PropertyInfo(Variant::STRING, "string");
458 } break;
459 case VAR_TO_STR:
460 case VAR_TO_BYTES: {
461 if (p_idx == 0)
462 return PropertyInfo(Variant::NIL, "var");
463 else
464 return PropertyInfo(Variant::BOOL, "full_objects");
465
466 } break;
467 case BYTES_TO_VAR: {
468
469 if (p_idx == 0)
470 return PropertyInfo(Variant::POOL_BYTE_ARRAY, "bytes");
471 else
472 return PropertyInfo(Variant::BOOL, "allow_objects");
473 } break;
474 case COLORN: {
475 if (p_idx == 0)
476 return PropertyInfo(Variant::STRING, "name");
477 else
478 return PropertyInfo(Variant::REAL, "alpha");
479 } break;
480 case FUNC_MAX: {
481 }
482 }
483
484 return PropertyInfo();
485 }
486
get_output_value_port_info(int p_idx) const487 PropertyInfo VisualScriptBuiltinFunc::get_output_value_port_info(int p_idx) const {
488
489 Variant::Type t = Variant::NIL;
490 switch (func) {
491
492 case MATH_SIN:
493 case MATH_COS:
494 case MATH_TAN:
495 case MATH_SINH:
496 case MATH_COSH:
497 case MATH_TANH:
498 case MATH_ASIN:
499 case MATH_ACOS:
500 case MATH_ATAN:
501 case MATH_ATAN2:
502 case MATH_SQRT:
503 case MATH_FMOD:
504 case MATH_FPOSMOD:
505 case MATH_FLOOR:
506 case MATH_CEIL: {
507 t = Variant::REAL;
508 } break;
509 case MATH_POSMOD: {
510 t = Variant::INT;
511 } break;
512 case MATH_ROUND: {
513 t = Variant::REAL;
514 } break;
515 case MATH_ABS: {
516 t = Variant::NIL;
517 } break;
518 case MATH_SIGN: {
519 t = Variant::NIL;
520 } break;
521 case MATH_POW:
522 case MATH_LOG:
523 case MATH_EXP: {
524 t = Variant::REAL;
525 } break;
526 case MATH_ISNAN:
527 case MATH_ISINF: {
528 t = Variant::BOOL;
529 } break;
530 case MATH_EASE: {
531 t = Variant::REAL;
532 } break;
533 case MATH_DECIMALS: {
534 t = Variant::INT;
535 } break;
536 case MATH_STEPIFY:
537 case MATH_LERP:
538 case MATH_LERP_ANGLE:
539 case MATH_INVERSE_LERP:
540 case MATH_RANGE_LERP:
541 case MATH_SMOOTHSTEP:
542 case MATH_MOVE_TOWARD:
543 case MATH_DECTIME: {
544 t = Variant::REAL;
545
546 } break;
547 case MATH_RANDOMIZE: {
548
549 } break;
550 case MATH_RAND: {
551
552 t = Variant::INT;
553 } break;
554 case MATH_RANDF:
555 case MATH_RANDOM: {
556 t = Variant::REAL;
557 } break;
558 case MATH_SEED: {
559
560 } break;
561 case MATH_RANDSEED: {
562
563 if (p_idx == 0)
564 return PropertyInfo(Variant::INT, "rnd");
565 else
566 return PropertyInfo(Variant::INT, "seed");
567 } break;
568 case MATH_DEG2RAD:
569 case MATH_RAD2DEG:
570 case MATH_LINEAR2DB:
571 case MATH_WRAPF:
572 case MATH_DB2LINEAR: {
573 t = Variant::REAL;
574 } break;
575 case MATH_POLAR2CARTESIAN:
576 case MATH_CARTESIAN2POLAR: {
577 t = Variant::VECTOR2;
578 } break;
579 case MATH_WRAP: {
580 t = Variant::INT;
581 } break;
582 case LOGIC_MAX:
583 case LOGIC_MIN:
584 case LOGIC_CLAMP: {
585
586 } break;
587
588 case LOGIC_NEAREST_PO2: {
589 t = Variant::NIL;
590 } break;
591 case OBJ_WEAKREF: {
592
593 t = Variant::OBJECT;
594
595 } break;
596 case FUNC_FUNCREF: {
597
598 t = Variant::OBJECT;
599
600 } break;
601 case TYPE_CONVERT: {
602
603 } break;
604 case TEXT_ORD:
605 case TYPE_OF: {
606 t = Variant::INT;
607
608 } break;
609 case TYPE_EXISTS: {
610
611 t = Variant::BOOL;
612
613 } break;
614 case TEXT_CHAR:
615 case TEXT_STR: {
616
617 t = Variant::STRING;
618
619 } break;
620 case TEXT_PRINT: {
621
622 } break;
623 case TEXT_PRINTERR: {
624
625 } break;
626 case TEXT_PRINTRAW: {
627
628 } break;
629 case VAR_TO_STR: {
630 t = Variant::STRING;
631 } break;
632 case STR_TO_VAR: {
633
634 } break;
635 case VAR_TO_BYTES: {
636 if (p_idx == 0)
637 t = Variant::POOL_BYTE_ARRAY;
638 else
639 t = Variant::BOOL;
640
641 } break;
642 case BYTES_TO_VAR: {
643 if (p_idx == 1)
644 t = Variant::BOOL;
645 } break;
646 case COLORN: {
647 t = Variant::COLOR;
648 } break;
649 case FUNC_MAX: {
650 }
651 }
652
653 return PropertyInfo(t, "");
654 }
655
656 /*
657 String VisualScriptBuiltinFunc::get_caption() const {
658
659 return "BuiltinFunc";
660 }
661 */
662
get_caption() const663 String VisualScriptBuiltinFunc::get_caption() const {
664
665 return func_name[func];
666 }
667
set_func(BuiltinFunc p_which)668 void VisualScriptBuiltinFunc::set_func(BuiltinFunc p_which) {
669
670 ERR_FAIL_INDEX(p_which, FUNC_MAX);
671 func = p_which;
672 _change_notify();
673 ports_changed_notify();
674 }
675
get_func()676 VisualScriptBuiltinFunc::BuiltinFunc VisualScriptBuiltinFunc::get_func() {
677 return func;
678 }
679
680 #define VALIDATE_ARG_NUM(m_arg) \
681 if (!p_inputs[m_arg]->is_num()) { \
682 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; \
683 r_error.argument = m_arg; \
684 r_error.expected = Variant::REAL; \
685 return; \
686 }
687
exec_func(BuiltinFunc p_func,const Variant ** p_inputs,Variant * r_return,Variant::CallError & r_error,String & r_error_str)688 void VisualScriptBuiltinFunc::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant *r_return, Variant::CallError &r_error, String &r_error_str) {
689
690 switch (p_func) {
691 case VisualScriptBuiltinFunc::MATH_SIN: {
692
693 VALIDATE_ARG_NUM(0);
694 *r_return = Math::sin((double)*p_inputs[0]);
695 } break;
696 case VisualScriptBuiltinFunc::MATH_COS: {
697
698 VALIDATE_ARG_NUM(0);
699 *r_return = Math::cos((double)*p_inputs[0]);
700 } break;
701 case VisualScriptBuiltinFunc::MATH_TAN: {
702
703 VALIDATE_ARG_NUM(0);
704 *r_return = Math::tan((double)*p_inputs[0]);
705 } break;
706 case VisualScriptBuiltinFunc::MATH_SINH: {
707
708 VALIDATE_ARG_NUM(0);
709 *r_return = Math::sinh((double)*p_inputs[0]);
710 } break;
711 case VisualScriptBuiltinFunc::MATH_COSH: {
712
713 VALIDATE_ARG_NUM(0);
714 *r_return = Math::cosh((double)*p_inputs[0]);
715 } break;
716 case VisualScriptBuiltinFunc::MATH_TANH: {
717
718 VALIDATE_ARG_NUM(0);
719 *r_return = Math::tanh((double)*p_inputs[0]);
720 } break;
721 case VisualScriptBuiltinFunc::MATH_ASIN: {
722
723 VALIDATE_ARG_NUM(0);
724 *r_return = Math::asin((double)*p_inputs[0]);
725 } break;
726 case VisualScriptBuiltinFunc::MATH_ACOS: {
727
728 VALIDATE_ARG_NUM(0);
729 *r_return = Math::acos((double)*p_inputs[0]);
730 } break;
731 case VisualScriptBuiltinFunc::MATH_ATAN: {
732
733 VALIDATE_ARG_NUM(0);
734 *r_return = Math::atan((double)*p_inputs[0]);
735 } break;
736 case VisualScriptBuiltinFunc::MATH_ATAN2: {
737
738 VALIDATE_ARG_NUM(0);
739 VALIDATE_ARG_NUM(1);
740 *r_return = Math::atan2((double)*p_inputs[0], (double)*p_inputs[1]);
741 } break;
742 case VisualScriptBuiltinFunc::MATH_SQRT: {
743
744 VALIDATE_ARG_NUM(0);
745 *r_return = Math::sqrt((double)*p_inputs[0]);
746 } break;
747 case VisualScriptBuiltinFunc::MATH_FMOD: {
748
749 VALIDATE_ARG_NUM(0);
750 VALIDATE_ARG_NUM(1);
751 *r_return = Math::fmod((double)*p_inputs[0], (double)*p_inputs[1]);
752 } break;
753 case VisualScriptBuiltinFunc::MATH_FPOSMOD: {
754
755 VALIDATE_ARG_NUM(0);
756 VALIDATE_ARG_NUM(1);
757 *r_return = Math::fposmod((double)*p_inputs[0], (double)*p_inputs[1]);
758 } break;
759 case VisualScriptBuiltinFunc::MATH_POSMOD: {
760
761 VALIDATE_ARG_NUM(0);
762 VALIDATE_ARG_NUM(1);
763 *r_return = Math::posmod((int)*p_inputs[0], (int)*p_inputs[1]);
764 } break;
765 case VisualScriptBuiltinFunc::MATH_FLOOR: {
766
767 VALIDATE_ARG_NUM(0);
768 *r_return = Math::floor((double)*p_inputs[0]);
769 } break;
770 case VisualScriptBuiltinFunc::MATH_CEIL: {
771
772 VALIDATE_ARG_NUM(0);
773 *r_return = Math::ceil((double)*p_inputs[0]);
774 } break;
775 case VisualScriptBuiltinFunc::MATH_ROUND: {
776
777 VALIDATE_ARG_NUM(0);
778 *r_return = Math::round((double)*p_inputs[0]);
779 } break;
780 case VisualScriptBuiltinFunc::MATH_ABS: {
781
782 if (p_inputs[0]->get_type() == Variant::INT) {
783
784 int64_t i = *p_inputs[0];
785 *r_return = ABS(i);
786 } else if (p_inputs[0]->get_type() == Variant::REAL) {
787
788 real_t r = *p_inputs[0];
789 *r_return = Math::abs(r);
790 } else {
791
792 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
793 r_error.argument = 0;
794 r_error.expected = Variant::REAL;
795 }
796 } break;
797 case VisualScriptBuiltinFunc::MATH_SIGN: {
798
799 if (p_inputs[0]->get_type() == Variant::INT) {
800
801 int64_t i = *p_inputs[0];
802 *r_return = i < 0 ? -1 : (i > 0 ? +1 : 0);
803 } else if (p_inputs[0]->get_type() == Variant::REAL) {
804
805 real_t r = *p_inputs[0];
806 *r_return = r < 0.0 ? -1.0 : (r > 0.0 ? +1.0 : 0.0);
807 } else {
808
809 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
810 r_error.argument = 0;
811 r_error.expected = Variant::REAL;
812 }
813 } break;
814 case VisualScriptBuiltinFunc::MATH_POW: {
815
816 VALIDATE_ARG_NUM(0);
817 VALIDATE_ARG_NUM(1);
818 *r_return = Math::pow((double)*p_inputs[0], (double)*p_inputs[1]);
819 } break;
820 case VisualScriptBuiltinFunc::MATH_LOG: {
821
822 VALIDATE_ARG_NUM(0);
823 *r_return = Math::log((double)*p_inputs[0]);
824 } break;
825 case VisualScriptBuiltinFunc::MATH_EXP: {
826
827 VALIDATE_ARG_NUM(0);
828 *r_return = Math::exp((double)*p_inputs[0]);
829 } break;
830 case VisualScriptBuiltinFunc::MATH_ISNAN: {
831
832 VALIDATE_ARG_NUM(0);
833 *r_return = Math::is_nan((double)*p_inputs[0]);
834 } break;
835 case VisualScriptBuiltinFunc::MATH_ISINF: {
836
837 VALIDATE_ARG_NUM(0);
838 *r_return = Math::is_inf((double)*p_inputs[0]);
839 } break;
840 case VisualScriptBuiltinFunc::MATH_EASE: {
841
842 VALIDATE_ARG_NUM(0);
843 VALIDATE_ARG_NUM(1);
844 *r_return = Math::ease((double)*p_inputs[0], (double)*p_inputs[1]);
845 } break;
846 case VisualScriptBuiltinFunc::MATH_DECIMALS: {
847
848 VALIDATE_ARG_NUM(0);
849 *r_return = Math::step_decimals((double)*p_inputs[0]);
850 } break;
851 case VisualScriptBuiltinFunc::MATH_STEPIFY: {
852
853 VALIDATE_ARG_NUM(0);
854 VALIDATE_ARG_NUM(1);
855 *r_return = Math::stepify((double)*p_inputs[0], (double)*p_inputs[1]);
856 } break;
857 case VisualScriptBuiltinFunc::MATH_LERP: {
858
859 VALIDATE_ARG_NUM(0);
860 VALIDATE_ARG_NUM(1);
861 VALIDATE_ARG_NUM(2);
862 *r_return = Math::lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
863 } break;
864 case VisualScriptBuiltinFunc::MATH_LERP_ANGLE: {
865
866 VALIDATE_ARG_NUM(0);
867 VALIDATE_ARG_NUM(1);
868 VALIDATE_ARG_NUM(2);
869 *r_return = Math::lerp_angle((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
870 } break;
871 case VisualScriptBuiltinFunc::MATH_INVERSE_LERP: {
872
873 VALIDATE_ARG_NUM(0);
874 VALIDATE_ARG_NUM(1);
875 VALIDATE_ARG_NUM(2);
876 *r_return = Math::inverse_lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
877 } break;
878 case VisualScriptBuiltinFunc::MATH_RANGE_LERP: {
879
880 VALIDATE_ARG_NUM(0);
881 VALIDATE_ARG_NUM(1);
882 VALIDATE_ARG_NUM(2);
883 VALIDATE_ARG_NUM(3);
884 VALIDATE_ARG_NUM(4);
885 *r_return = Math::range_lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2], (double)*p_inputs[3], (double)*p_inputs[4]);
886 } break;
887 case VisualScriptBuiltinFunc::MATH_SMOOTHSTEP: {
888 VALIDATE_ARG_NUM(0);
889 VALIDATE_ARG_NUM(1);
890 VALIDATE_ARG_NUM(2);
891 *r_return = Math::smoothstep((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
892 } break;
893 case VisualScriptBuiltinFunc::MATH_MOVE_TOWARD: {
894
895 VALIDATE_ARG_NUM(0);
896 VALIDATE_ARG_NUM(1);
897 VALIDATE_ARG_NUM(2);
898 *r_return = Math::move_toward((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
899 } break;
900 case VisualScriptBuiltinFunc::MATH_DECTIME: {
901
902 VALIDATE_ARG_NUM(0);
903 VALIDATE_ARG_NUM(1);
904 VALIDATE_ARG_NUM(2);
905 *r_return = Math::dectime((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
906 } break;
907 case VisualScriptBuiltinFunc::MATH_RANDOMIZE: {
908 Math::randomize();
909
910 } break;
911 case VisualScriptBuiltinFunc::MATH_RAND: {
912 *r_return = Math::rand();
913 } break;
914 case VisualScriptBuiltinFunc::MATH_RANDF: {
915 *r_return = Math::randf();
916 } break;
917 case VisualScriptBuiltinFunc::MATH_RANDOM: {
918
919 VALIDATE_ARG_NUM(0);
920 VALIDATE_ARG_NUM(1);
921 *r_return = Math::random((double)*p_inputs[0], (double)*p_inputs[1]);
922 } break;
923 case VisualScriptBuiltinFunc::MATH_SEED: {
924
925 VALIDATE_ARG_NUM(0);
926 uint64_t seed = *p_inputs[0];
927 Math::seed(seed);
928
929 } break;
930 case VisualScriptBuiltinFunc::MATH_RANDSEED: {
931
932 VALIDATE_ARG_NUM(0);
933 uint64_t seed = *p_inputs[0];
934 int ret = Math::rand_from_seed(&seed);
935 Array reta;
936 reta.push_back(ret);
937 reta.push_back(seed);
938 *r_return = reta;
939
940 } break;
941 case VisualScriptBuiltinFunc::MATH_DEG2RAD: {
942
943 VALIDATE_ARG_NUM(0);
944 *r_return = Math::deg2rad((double)*p_inputs[0]);
945 } break;
946 case VisualScriptBuiltinFunc::MATH_RAD2DEG: {
947
948 VALIDATE_ARG_NUM(0);
949 *r_return = Math::rad2deg((double)*p_inputs[0]);
950 } break;
951 case VisualScriptBuiltinFunc::MATH_LINEAR2DB: {
952
953 VALIDATE_ARG_NUM(0);
954 *r_return = Math::linear2db((double)*p_inputs[0]);
955 } break;
956 case VisualScriptBuiltinFunc::MATH_DB2LINEAR: {
957
958 VALIDATE_ARG_NUM(0);
959 *r_return = Math::db2linear((double)*p_inputs[0]);
960 } break;
961 case VisualScriptBuiltinFunc::MATH_POLAR2CARTESIAN: {
962 VALIDATE_ARG_NUM(0);
963 VALIDATE_ARG_NUM(1);
964 double r = *p_inputs[0];
965 double th = *p_inputs[1];
966 *r_return = Vector2(r * Math::cos(th), r * Math::sin(th));
967 } break;
968 case VisualScriptBuiltinFunc::MATH_CARTESIAN2POLAR: {
969 VALIDATE_ARG_NUM(0);
970 VALIDATE_ARG_NUM(1);
971 double x = *p_inputs[0];
972 double y = *p_inputs[1];
973 *r_return = Vector2(Math::sqrt(x * x + y * y), Math::atan2(y, x));
974 } break;
975 case VisualScriptBuiltinFunc::MATH_WRAP: {
976 VALIDATE_ARG_NUM(0);
977 VALIDATE_ARG_NUM(1);
978 VALIDATE_ARG_NUM(2);
979 *r_return = Math::wrapi((int64_t)*p_inputs[0], (int64_t)*p_inputs[1], (int64_t)*p_inputs[2]);
980 } break;
981 case VisualScriptBuiltinFunc::MATH_WRAPF: {
982 VALIDATE_ARG_NUM(0);
983 VALIDATE_ARG_NUM(1);
984 VALIDATE_ARG_NUM(2);
985 *r_return = Math::wrapf((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
986 } break;
987 case VisualScriptBuiltinFunc::LOGIC_MAX: {
988
989 if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT) {
990
991 int64_t a = *p_inputs[0];
992 int64_t b = *p_inputs[1];
993 *r_return = MAX(a, b);
994 } else {
995 VALIDATE_ARG_NUM(0);
996 VALIDATE_ARG_NUM(1);
997
998 real_t a = *p_inputs[0];
999 real_t b = *p_inputs[1];
1000
1001 *r_return = MAX(a, b);
1002 }
1003
1004 } break;
1005 case VisualScriptBuiltinFunc::LOGIC_MIN: {
1006
1007 if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT) {
1008
1009 int64_t a = *p_inputs[0];
1010 int64_t b = *p_inputs[1];
1011 *r_return = MIN(a, b);
1012 } else {
1013 VALIDATE_ARG_NUM(0);
1014 VALIDATE_ARG_NUM(1);
1015
1016 real_t a = *p_inputs[0];
1017 real_t b = *p_inputs[1];
1018
1019 *r_return = MIN(a, b);
1020 }
1021 } break;
1022 case VisualScriptBuiltinFunc::LOGIC_CLAMP: {
1023
1024 if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT && p_inputs[2]->get_type() == Variant::INT) {
1025
1026 int64_t a = *p_inputs[0];
1027 int64_t b = *p_inputs[1];
1028 int64_t c = *p_inputs[2];
1029 *r_return = CLAMP(a, b, c);
1030 } else {
1031 VALIDATE_ARG_NUM(0);
1032 VALIDATE_ARG_NUM(1);
1033 VALIDATE_ARG_NUM(2);
1034
1035 real_t a = *p_inputs[0];
1036 real_t b = *p_inputs[1];
1037 real_t c = *p_inputs[2];
1038
1039 *r_return = CLAMP(a, b, c);
1040 }
1041 } break;
1042 case VisualScriptBuiltinFunc::LOGIC_NEAREST_PO2: {
1043
1044 VALIDATE_ARG_NUM(0);
1045 int64_t num = *p_inputs[0];
1046 *r_return = next_power_of_2(num);
1047 } break;
1048 case VisualScriptBuiltinFunc::OBJ_WEAKREF: {
1049
1050 if (p_inputs[0]->get_type() != Variant::OBJECT) {
1051
1052 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
1053 r_error.argument = 0;
1054 r_error.expected = Variant::OBJECT;
1055
1056 return;
1057 }
1058
1059 if (p_inputs[0]->is_ref()) {
1060
1061 REF r = *p_inputs[0];
1062 if (!r.is_valid()) {
1063
1064 return;
1065 }
1066
1067 Ref<WeakRef> wref = memnew(WeakRef);
1068 wref->set_ref(r);
1069 *r_return = wref;
1070 } else {
1071 Object *obj = *p_inputs[0];
1072 if (!obj) {
1073
1074 return;
1075 }
1076 Ref<WeakRef> wref = memnew(WeakRef);
1077 wref->set_obj(obj);
1078 *r_return = wref;
1079 }
1080
1081 } break;
1082 case VisualScriptBuiltinFunc::FUNC_FUNCREF: {
1083
1084 if (p_inputs[0]->get_type() != Variant::OBJECT) {
1085
1086 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
1087 r_error.argument = 0;
1088 r_error.expected = Variant::OBJECT;
1089
1090 return;
1091 }
1092 if (p_inputs[1]->get_type() != Variant::STRING && p_inputs[1]->get_type() != Variant::NODE_PATH) {
1093
1094 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
1095 r_error.argument = 1;
1096 r_error.expected = Variant::STRING;
1097
1098 return;
1099 }
1100
1101 Ref<FuncRef> fr = memnew(FuncRef);
1102
1103 fr->set_instance(*p_inputs[0]);
1104 fr->set_function(*p_inputs[1]);
1105
1106 *r_return = fr;
1107
1108 } break;
1109 case VisualScriptBuiltinFunc::TYPE_CONVERT: {
1110
1111 VALIDATE_ARG_NUM(1);
1112 int type = *p_inputs[1];
1113 if (type < 0 || type >= Variant::VARIANT_MAX) {
1114
1115 r_error_str = RTR("Invalid type argument to convert(), use TYPE_* constants.");
1116 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
1117 r_error.argument = 0;
1118 r_error.expected = Variant::INT;
1119 return;
1120
1121 } else {
1122
1123 *r_return = Variant::construct(Variant::Type(type), p_inputs, 1, r_error);
1124 }
1125 } break;
1126 case VisualScriptBuiltinFunc::TYPE_OF: {
1127
1128 *r_return = p_inputs[0]->get_type();
1129
1130 } break;
1131 case VisualScriptBuiltinFunc::TYPE_EXISTS: {
1132
1133 *r_return = ClassDB::class_exists(*p_inputs[0]);
1134
1135 } break;
1136 case VisualScriptBuiltinFunc::TEXT_CHAR: {
1137
1138 CharType result[2] = { *p_inputs[0], 0 };
1139
1140 *r_return = String(result);
1141
1142 } break;
1143 case VisualScriptBuiltinFunc::TEXT_ORD: {
1144
1145 if (p_inputs[0]->get_type() != Variant::STRING) {
1146 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
1147 r_error.argument = 0;
1148 r_error.expected = Variant::STRING;
1149
1150 return;
1151 }
1152
1153 String str = p_inputs[0]->operator String();
1154
1155 if (str.length() != 1) {
1156 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
1157 r_error.argument = 0;
1158 r_error.expected = Variant::STRING;
1159 *r_return = "Expected a string of length 1 (a character).";
1160
1161 return;
1162 }
1163
1164 *r_return = str.get(0);
1165
1166 } break;
1167 case VisualScriptBuiltinFunc::TEXT_STR: {
1168
1169 String str = *p_inputs[0];
1170
1171 *r_return = str;
1172
1173 } break;
1174 case VisualScriptBuiltinFunc::TEXT_PRINT: {
1175
1176 String str = *p_inputs[0];
1177 print_line(str);
1178
1179 } break;
1180
1181 case VisualScriptBuiltinFunc::TEXT_PRINTERR: {
1182
1183 String str = *p_inputs[0];
1184 print_error(str);
1185
1186 } break;
1187 case VisualScriptBuiltinFunc::TEXT_PRINTRAW: {
1188
1189 String str = *p_inputs[0];
1190 OS::get_singleton()->print("%s", str.utf8().get_data());
1191
1192 } break;
1193 case VisualScriptBuiltinFunc::VAR_TO_STR: {
1194
1195 String vars;
1196 VariantWriter::write_to_string(*p_inputs[0], vars);
1197 *r_return = vars;
1198 } break;
1199 case VisualScriptBuiltinFunc::STR_TO_VAR: {
1200
1201 if (p_inputs[0]->get_type() != Variant::STRING) {
1202 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
1203 r_error.argument = 0;
1204 r_error.expected = Variant::STRING;
1205
1206 return;
1207 }
1208
1209 VariantParser::StreamString ss;
1210 ss.s = *p_inputs[0];
1211
1212 String errs;
1213 int line;
1214 Error err = VariantParser::parse(&ss, *r_return, errs, line);
1215
1216 if (err != OK) {
1217 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
1218 r_error.argument = 0;
1219 r_error.expected = Variant::STRING;
1220 *r_return = "Parse error at line " + itos(line) + ": " + errs;
1221 return;
1222 }
1223
1224 } break;
1225 case VisualScriptBuiltinFunc::VAR_TO_BYTES: {
1226
1227 if (p_inputs[1]->get_type() != Variant::BOOL) {
1228 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
1229 r_error.argument = 1;
1230 r_error.expected = Variant::BOOL;
1231 return;
1232 }
1233 PoolByteArray barr;
1234 int len;
1235 bool full_objects = *p_inputs[1];
1236 Error err = encode_variant(*p_inputs[0], NULL, len, full_objects);
1237 if (err) {
1238 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
1239 r_error.argument = 0;
1240 r_error.expected = Variant::NIL;
1241 r_error_str = "Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
1242 return;
1243 }
1244
1245 barr.resize(len);
1246 {
1247 PoolByteArray::Write w = barr.write();
1248 encode_variant(*p_inputs[0], w.ptr(), len, full_objects);
1249 }
1250 *r_return = barr;
1251 } break;
1252 case VisualScriptBuiltinFunc::BYTES_TO_VAR: {
1253
1254 if (p_inputs[0]->get_type() != Variant::POOL_BYTE_ARRAY) {
1255 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
1256 r_error.argument = 0;
1257 r_error.expected = Variant::POOL_BYTE_ARRAY;
1258 return;
1259 }
1260 if (p_inputs[1]->get_type() != Variant::BOOL) {
1261 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
1262 r_error.argument = 1;
1263 r_error.expected = Variant::BOOL;
1264 return;
1265 }
1266
1267 PoolByteArray varr = *p_inputs[0];
1268 bool allow_objects = *p_inputs[1];
1269 Variant ret;
1270 {
1271 PoolByteArray::Read r = varr.read();
1272 Error err = decode_variant(ret, r.ptr(), varr.size(), NULL, allow_objects);
1273 if (err != OK) {
1274 r_error_str = RTR("Not enough bytes for decoding bytes, or invalid format.");
1275 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
1276 r_error.argument = 0;
1277 r_error.expected = Variant::POOL_BYTE_ARRAY;
1278 return;
1279 }
1280 }
1281
1282 *r_return = ret;
1283
1284 } break;
1285 case VisualScriptBuiltinFunc::COLORN: {
1286
1287 VALIDATE_ARG_NUM(1);
1288
1289 Color color = Color::named(*p_inputs[0]);
1290 color.a = *p_inputs[1];
1291
1292 *r_return = String(color);
1293
1294 } break;
1295 default: {
1296 }
1297 }
1298 }
1299
1300 class VisualScriptNodeInstanceBuiltinFunc : public VisualScriptNodeInstance {
1301 public:
1302 VisualScriptBuiltinFunc *node;
1303 VisualScriptInstance *instance;
1304
1305 VisualScriptBuiltinFunc::BuiltinFunc func;
1306
1307 //virtual int get_working_memory_size() const { return 0; }
1308 //virtual bool is_output_port_unsequenced(int p_idx) const { return false; }
1309 //virtual bool get_output_port_unsequenced(int p_idx,Variant* r_value,Variant* p_working_mem,String &r_error) const { return true; }
1310
step(const Variant ** p_inputs,Variant ** p_outputs,StartMode p_start_mode,Variant * p_working_mem,Variant::CallError & r_error,String & r_error_str)1311 virtual int step(const Variant **p_inputs, Variant **p_outputs, StartMode p_start_mode, Variant *p_working_mem, Variant::CallError &r_error, String &r_error_str) {
1312
1313 VisualScriptBuiltinFunc::exec_func(func, p_inputs, p_outputs[0], r_error, r_error_str);
1314 return 0;
1315 }
1316 };
1317
instance(VisualScriptInstance * p_instance)1318 VisualScriptNodeInstance *VisualScriptBuiltinFunc::instance(VisualScriptInstance *p_instance) {
1319
1320 VisualScriptNodeInstanceBuiltinFunc *instance = memnew(VisualScriptNodeInstanceBuiltinFunc);
1321 instance->node = this;
1322 instance->instance = p_instance;
1323 instance->func = func;
1324 return instance;
1325 }
1326
_bind_methods()1327 void VisualScriptBuiltinFunc::_bind_methods() {
1328
1329 ClassDB::bind_method(D_METHOD("set_func", "which"), &VisualScriptBuiltinFunc::set_func);
1330 ClassDB::bind_method(D_METHOD("get_func"), &VisualScriptBuiltinFunc::get_func);
1331
1332 String cc;
1333
1334 for (int i = 0; i < FUNC_MAX; i++) {
1335
1336 if (i > 0)
1337 cc += ",";
1338 cc += func_name[i];
1339 }
1340 ADD_PROPERTY(PropertyInfo(Variant::INT, "function", PROPERTY_HINT_ENUM, cc), "set_func", "get_func");
1341
1342 BIND_ENUM_CONSTANT(MATH_SIN);
1343 BIND_ENUM_CONSTANT(MATH_COS);
1344 BIND_ENUM_CONSTANT(MATH_TAN);
1345 BIND_ENUM_CONSTANT(MATH_SINH);
1346 BIND_ENUM_CONSTANT(MATH_COSH);
1347 BIND_ENUM_CONSTANT(MATH_TANH);
1348 BIND_ENUM_CONSTANT(MATH_ASIN);
1349 BIND_ENUM_CONSTANT(MATH_ACOS);
1350 BIND_ENUM_CONSTANT(MATH_ATAN);
1351 BIND_ENUM_CONSTANT(MATH_ATAN2);
1352 BIND_ENUM_CONSTANT(MATH_SQRT);
1353 BIND_ENUM_CONSTANT(MATH_FMOD);
1354 BIND_ENUM_CONSTANT(MATH_FPOSMOD);
1355 BIND_ENUM_CONSTANT(MATH_FLOOR);
1356 BIND_ENUM_CONSTANT(MATH_CEIL);
1357 BIND_ENUM_CONSTANT(MATH_ROUND);
1358 BIND_ENUM_CONSTANT(MATH_ABS);
1359 BIND_ENUM_CONSTANT(MATH_SIGN);
1360 BIND_ENUM_CONSTANT(MATH_POW);
1361 BIND_ENUM_CONSTANT(MATH_LOG);
1362 BIND_ENUM_CONSTANT(MATH_EXP);
1363 BIND_ENUM_CONSTANT(MATH_ISNAN);
1364 BIND_ENUM_CONSTANT(MATH_ISINF);
1365 BIND_ENUM_CONSTANT(MATH_EASE);
1366 BIND_ENUM_CONSTANT(MATH_DECIMALS);
1367 BIND_ENUM_CONSTANT(MATH_STEPIFY);
1368 BIND_ENUM_CONSTANT(MATH_LERP);
1369 BIND_ENUM_CONSTANT(MATH_INVERSE_LERP);
1370 BIND_ENUM_CONSTANT(MATH_RANGE_LERP);
1371 BIND_ENUM_CONSTANT(MATH_MOVE_TOWARD);
1372 BIND_ENUM_CONSTANT(MATH_DECTIME);
1373 BIND_ENUM_CONSTANT(MATH_RANDOMIZE);
1374 BIND_ENUM_CONSTANT(MATH_RAND);
1375 BIND_ENUM_CONSTANT(MATH_RANDF);
1376 BIND_ENUM_CONSTANT(MATH_RANDOM);
1377 BIND_ENUM_CONSTANT(MATH_SEED);
1378 BIND_ENUM_CONSTANT(MATH_RANDSEED);
1379 BIND_ENUM_CONSTANT(MATH_DEG2RAD);
1380 BIND_ENUM_CONSTANT(MATH_RAD2DEG);
1381 BIND_ENUM_CONSTANT(MATH_LINEAR2DB);
1382 BIND_ENUM_CONSTANT(MATH_DB2LINEAR);
1383 BIND_ENUM_CONSTANT(MATH_POLAR2CARTESIAN);
1384 BIND_ENUM_CONSTANT(MATH_CARTESIAN2POLAR);
1385 BIND_ENUM_CONSTANT(MATH_WRAP);
1386 BIND_ENUM_CONSTANT(MATH_WRAPF);
1387 BIND_ENUM_CONSTANT(LOGIC_MAX);
1388 BIND_ENUM_CONSTANT(LOGIC_MIN);
1389 BIND_ENUM_CONSTANT(LOGIC_CLAMP);
1390 BIND_ENUM_CONSTANT(LOGIC_NEAREST_PO2);
1391 BIND_ENUM_CONSTANT(OBJ_WEAKREF);
1392 BIND_ENUM_CONSTANT(FUNC_FUNCREF);
1393 BIND_ENUM_CONSTANT(TYPE_CONVERT);
1394 BIND_ENUM_CONSTANT(TYPE_OF);
1395 BIND_ENUM_CONSTANT(TYPE_EXISTS);
1396 BIND_ENUM_CONSTANT(TEXT_CHAR);
1397 BIND_ENUM_CONSTANT(TEXT_STR);
1398 BIND_ENUM_CONSTANT(TEXT_PRINT);
1399 BIND_ENUM_CONSTANT(TEXT_PRINTERR);
1400 BIND_ENUM_CONSTANT(TEXT_PRINTRAW);
1401 BIND_ENUM_CONSTANT(VAR_TO_STR);
1402 BIND_ENUM_CONSTANT(STR_TO_VAR);
1403 BIND_ENUM_CONSTANT(VAR_TO_BYTES);
1404 BIND_ENUM_CONSTANT(BYTES_TO_VAR);
1405 BIND_ENUM_CONSTANT(COLORN);
1406 BIND_ENUM_CONSTANT(MATH_SMOOTHSTEP);
1407 BIND_ENUM_CONSTANT(MATH_POSMOD);
1408 BIND_ENUM_CONSTANT(MATH_LERP_ANGLE);
1409 BIND_ENUM_CONSTANT(TEXT_ORD);
1410 BIND_ENUM_CONSTANT(FUNC_MAX);
1411 }
1412
VisualScriptBuiltinFunc(VisualScriptBuiltinFunc::BuiltinFunc func)1413 VisualScriptBuiltinFunc::VisualScriptBuiltinFunc(VisualScriptBuiltinFunc::BuiltinFunc func) {
1414
1415 this->func = func;
1416 }
1417
VisualScriptBuiltinFunc()1418 VisualScriptBuiltinFunc::VisualScriptBuiltinFunc() {
1419
1420 func = MATH_SIN;
1421 }
1422
1423 template <VisualScriptBuiltinFunc::BuiltinFunc func>
create_builtin_func_node(const String & p_name)1424 static Ref<VisualScriptNode> create_builtin_func_node(const String &p_name) {
1425
1426 Ref<VisualScriptBuiltinFunc> node = memnew(VisualScriptBuiltinFunc(func));
1427 return node;
1428 }
1429
register_visual_script_builtin_func_node()1430 void register_visual_script_builtin_func_node() {
1431
1432 VisualScriptLanguage::singleton->add_register_func("functions/built_in/sin", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SIN>);
1433 VisualScriptLanguage::singleton->add_register_func("functions/built_in/cos", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_COS>);
1434 VisualScriptLanguage::singleton->add_register_func("functions/built_in/tan", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_TAN>);
1435 VisualScriptLanguage::singleton->add_register_func("functions/built_in/sinh", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SINH>);
1436 VisualScriptLanguage::singleton->add_register_func("functions/built_in/cosh", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_COSH>);
1437 VisualScriptLanguage::singleton->add_register_func("functions/built_in/tanh", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_TANH>);
1438
1439 VisualScriptLanguage::singleton->add_register_func("functions/built_in/asin", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ASIN>);
1440 VisualScriptLanguage::singleton->add_register_func("functions/built_in/acos", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ACOS>);
1441 VisualScriptLanguage::singleton->add_register_func("functions/built_in/atan", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ATAN>);
1442 VisualScriptLanguage::singleton->add_register_func("functions/built_in/atan2", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ATAN2>);
1443
1444 VisualScriptLanguage::singleton->add_register_func("functions/built_in/sqrt", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SQRT>);
1445 VisualScriptLanguage::singleton->add_register_func("functions/built_in/fmod", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_FMOD>);
1446 VisualScriptLanguage::singleton->add_register_func("functions/built_in/fposmod", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_FPOSMOD>);
1447 VisualScriptLanguage::singleton->add_register_func("functions/built_in/posmod", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_POSMOD>);
1448 VisualScriptLanguage::singleton->add_register_func("functions/built_in/floor", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_FLOOR>);
1449 VisualScriptLanguage::singleton->add_register_func("functions/built_in/ceil", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_CEIL>);
1450 VisualScriptLanguage::singleton->add_register_func("functions/built_in/round", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ROUND>);
1451 VisualScriptLanguage::singleton->add_register_func("functions/built_in/abs", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ABS>);
1452 VisualScriptLanguage::singleton->add_register_func("functions/built_in/sign", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SIGN>);
1453 VisualScriptLanguage::singleton->add_register_func("functions/built_in/pow", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_POW>);
1454 VisualScriptLanguage::singleton->add_register_func("functions/built_in/log", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LOG>);
1455 VisualScriptLanguage::singleton->add_register_func("functions/built_in/exp", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_EXP>);
1456 VisualScriptLanguage::singleton->add_register_func("functions/built_in/isnan", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ISNAN>);
1457 VisualScriptLanguage::singleton->add_register_func("functions/built_in/isinf", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_ISINF>);
1458
1459 VisualScriptLanguage::singleton->add_register_func("functions/built_in/ease", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_EASE>);
1460 VisualScriptLanguage::singleton->add_register_func("functions/built_in/decimals", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DECIMALS>);
1461 VisualScriptLanguage::singleton->add_register_func("functions/built_in/stepify", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_STEPIFY>);
1462 VisualScriptLanguage::singleton->add_register_func("functions/built_in/lerp", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LERP>);
1463 VisualScriptLanguage::singleton->add_register_func("functions/built_in/lerp_angle", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LERP_ANGLE>);
1464 VisualScriptLanguage::singleton->add_register_func("functions/built_in/inverse_lerp", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_INVERSE_LERP>);
1465 VisualScriptLanguage::singleton->add_register_func("functions/built_in/range_lerp", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANGE_LERP>);
1466 VisualScriptLanguage::singleton->add_register_func("functions/built_in/smoothstep", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SMOOTHSTEP>);
1467 VisualScriptLanguage::singleton->add_register_func("functions/built_in/move_toward", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_MOVE_TOWARD>);
1468 VisualScriptLanguage::singleton->add_register_func("functions/built_in/dectime", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DECTIME>);
1469 VisualScriptLanguage::singleton->add_register_func("functions/built_in/randomize", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDOMIZE>);
1470 VisualScriptLanguage::singleton->add_register_func("functions/built_in/rand", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RAND>);
1471 VisualScriptLanguage::singleton->add_register_func("functions/built_in/randf", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDF>);
1472 VisualScriptLanguage::singleton->add_register_func("functions/built_in/random", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDOM>);
1473
1474 VisualScriptLanguage::singleton->add_register_func("functions/built_in/seed", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_SEED>);
1475 VisualScriptLanguage::singleton->add_register_func("functions/built_in/randseed", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RANDSEED>);
1476 VisualScriptLanguage::singleton->add_register_func("functions/built_in/deg2rad", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DEG2RAD>);
1477 VisualScriptLanguage::singleton->add_register_func("functions/built_in/rad2deg", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_RAD2DEG>);
1478 VisualScriptLanguage::singleton->add_register_func("functions/built_in/linear2db", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_LINEAR2DB>);
1479 VisualScriptLanguage::singleton->add_register_func("functions/built_in/db2linear", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_DB2LINEAR>);
1480 VisualScriptLanguage::singleton->add_register_func("functions/built_in/polar2cartesian", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_POLAR2CARTESIAN>);
1481 VisualScriptLanguage::singleton->add_register_func("functions/built_in/cartesian2polar", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_CARTESIAN2POLAR>);
1482 VisualScriptLanguage::singleton->add_register_func("functions/built_in/wrapi", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_WRAP>);
1483 VisualScriptLanguage::singleton->add_register_func("functions/built_in/wrapf", create_builtin_func_node<VisualScriptBuiltinFunc::MATH_WRAPF>);
1484
1485 VisualScriptLanguage::singleton->add_register_func("functions/built_in/max", create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_MAX>);
1486 VisualScriptLanguage::singleton->add_register_func("functions/built_in/min", create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_MIN>);
1487 VisualScriptLanguage::singleton->add_register_func("functions/built_in/clamp", create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_CLAMP>);
1488 VisualScriptLanguage::singleton->add_register_func("functions/built_in/nearest_po2", create_builtin_func_node<VisualScriptBuiltinFunc::LOGIC_NEAREST_PO2>);
1489
1490 VisualScriptLanguage::singleton->add_register_func("functions/built_in/weakref", create_builtin_func_node<VisualScriptBuiltinFunc::OBJ_WEAKREF>);
1491 VisualScriptLanguage::singleton->add_register_func("functions/built_in/funcref", create_builtin_func_node<VisualScriptBuiltinFunc::FUNC_FUNCREF>);
1492 VisualScriptLanguage::singleton->add_register_func("functions/built_in/convert", create_builtin_func_node<VisualScriptBuiltinFunc::TYPE_CONVERT>);
1493 VisualScriptLanguage::singleton->add_register_func("functions/built_in/typeof", create_builtin_func_node<VisualScriptBuiltinFunc::TYPE_OF>);
1494 VisualScriptLanguage::singleton->add_register_func("functions/built_in/type_exists", create_builtin_func_node<VisualScriptBuiltinFunc::TYPE_EXISTS>);
1495 VisualScriptLanguage::singleton->add_register_func("functions/built_in/char", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_CHAR>);
1496 VisualScriptLanguage::singleton->add_register_func("functions/built_in/ord", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_ORD>);
1497 VisualScriptLanguage::singleton->add_register_func("functions/built_in/str", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_STR>);
1498 VisualScriptLanguage::singleton->add_register_func("functions/built_in/print", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_PRINT>);
1499 VisualScriptLanguage::singleton->add_register_func("functions/built_in/printerr", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_PRINTERR>);
1500 VisualScriptLanguage::singleton->add_register_func("functions/built_in/printraw", create_builtin_func_node<VisualScriptBuiltinFunc::TEXT_PRINTRAW>);
1501 VisualScriptLanguage::singleton->add_register_func("functions/built_in/var2str", create_builtin_func_node<VisualScriptBuiltinFunc::VAR_TO_STR>);
1502 VisualScriptLanguage::singleton->add_register_func("functions/built_in/str2var", create_builtin_func_node<VisualScriptBuiltinFunc::STR_TO_VAR>);
1503 VisualScriptLanguage::singleton->add_register_func("functions/built_in/var2bytes", create_builtin_func_node<VisualScriptBuiltinFunc::VAR_TO_BYTES>);
1504 VisualScriptLanguage::singleton->add_register_func("functions/built_in/bytes2var", create_builtin_func_node<VisualScriptBuiltinFunc::BYTES_TO_VAR>);
1505 VisualScriptLanguage::singleton->add_register_func("functions/built_in/color_named", create_builtin_func_node<VisualScriptBuiltinFunc::COLORN>);
1506 }
1507