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