1 /*************************************************************************/
2 /* gd_functions.cpp */
3 /*************************************************************************/
4 /* This file is part of: */
5 /* GODOT ENGINE */
6 /* https://godotengine.org */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
9 /* Copyright (c) 2014-2019 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 #include "gd_functions.h"
31 #include "func_ref.h"
32 #include "gd_script.h"
33 #include "io/marshalls.h"
34 #include "math_funcs.h"
35 #include "object_type_db.h"
36 #include "os/os.h"
37 #include "reference.h"
38 #include "variant_parser.h"
39
get_func_name(Function p_func)40 const char *GDFunctions::get_func_name(Function p_func) {
41
42 ERR_FAIL_INDEX_V(p_func, FUNC_MAX, "");
43
44 static const char *_names[FUNC_MAX] = {
45 "sin",
46 "cos",
47 "tan",
48 "sinh",
49 "cosh",
50 "tanh",
51 "asin",
52 "acos",
53 "atan",
54 "atan2",
55 "sqrt",
56 "fmod",
57 "fposmod",
58 "floor",
59 "ceil",
60 "round",
61 "abs",
62 "sign",
63 "pow",
64 "log",
65 "exp",
66 "is_nan",
67 "is_inf",
68 "ease",
69 "decimals",
70 "stepify",
71 "lerp",
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 "max",
84 "min",
85 "clamp",
86 "nearest_po2",
87 "weakref",
88 "funcref",
89 "convert",
90 "typeof",
91 "type_exists",
92 "str",
93 "print",
94 "printt",
95 "prints",
96 "printerr",
97 "printraw",
98 "var2str",
99 "str2var",
100 "var2bytes",
101 "bytes2var",
102 "range",
103 "load",
104 "inst2dict",
105 "dict2inst",
106 "hash",
107 "Color8",
108 "ColorN",
109 "print_stack",
110 "instance_from_id",
111 };
112
113 return _names[p_func];
114 }
115
call(Function p_func,const Variant ** p_args,int p_arg_count,Variant & r_ret,Variant::CallError & r_error)116 void GDFunctions::call(Function p_func, const Variant **p_args, int p_arg_count, Variant &r_ret, Variant::CallError &r_error) {
117
118 r_error.error = Variant::CallError::CALL_OK;
119 #ifdef DEBUG_ENABLED
120
121 #define VALIDATE_ARG_COUNT(m_count) \
122 if (p_arg_count < m_count) { \
123 r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS; \
124 r_error.argument = m_count; \
125 r_ret = Variant(); \
126 return; \
127 } \
128 if (p_arg_count > m_count) { \
129 r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS; \
130 r_error.argument = m_count; \
131 r_ret = Variant(); \
132 return; \
133 }
134
135 #define VALIDATE_ARG_NUM(m_arg) \
136 if (!p_args[m_arg]->is_num()) { \
137 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; \
138 r_error.argument = m_arg; \
139 r_error.expected = Variant::REAL; \
140 r_ret = Variant(); \
141 return; \
142 }
143
144 #else
145
146 #define VALIDATE_ARG_COUNT(m_count)
147 #define VALIDATE_ARG_NUM(m_arg)
148 #endif
149
150 //using a switch, so the compiler generates a jumptable
151
152 switch (p_func) {
153
154 case MATH_SIN: {
155 VALIDATE_ARG_COUNT(1);
156 VALIDATE_ARG_NUM(0);
157 r_ret = Math::sin(*p_args[0]);
158 } break;
159 case MATH_COS: {
160 VALIDATE_ARG_COUNT(1);
161 VALIDATE_ARG_NUM(0);
162 r_ret = Math::cos(*p_args[0]);
163 } break;
164 case MATH_TAN: {
165 VALIDATE_ARG_COUNT(1);
166 VALIDATE_ARG_NUM(0);
167 r_ret = Math::tan(*p_args[0]);
168 } break;
169 case MATH_SINH: {
170 VALIDATE_ARG_COUNT(1);
171 VALIDATE_ARG_NUM(0);
172 r_ret = Math::sinh(*p_args[0]);
173 } break;
174 case MATH_COSH: {
175 VALIDATE_ARG_COUNT(1);
176 VALIDATE_ARG_NUM(0);
177 r_ret = Math::cosh(*p_args[0]);
178 } break;
179 case MATH_TANH: {
180 VALIDATE_ARG_COUNT(1);
181 VALIDATE_ARG_NUM(0);
182 r_ret = Math::tanh(*p_args[0]);
183 } break;
184 case MATH_ASIN: {
185 VALIDATE_ARG_COUNT(1);
186 VALIDATE_ARG_NUM(0);
187 r_ret = Math::asin(*p_args[0]);
188 } break;
189 case MATH_ACOS: {
190 VALIDATE_ARG_COUNT(1);
191 VALIDATE_ARG_NUM(0);
192 r_ret = Math::acos(*p_args[0]);
193 } break;
194 case MATH_ATAN: {
195 VALIDATE_ARG_COUNT(1);
196 VALIDATE_ARG_NUM(0);
197 r_ret = Math::atan(*p_args[0]);
198 } break;
199 case MATH_ATAN2: {
200 VALIDATE_ARG_COUNT(2);
201 VALIDATE_ARG_NUM(0);
202 VALIDATE_ARG_NUM(1);
203 r_ret = Math::atan2(*p_args[0], *p_args[1]);
204 } break;
205 case MATH_SQRT: {
206 VALIDATE_ARG_COUNT(1);
207 VALIDATE_ARG_NUM(0);
208 r_ret = Math::sqrt(*p_args[0]);
209 } break;
210 case MATH_FMOD: {
211 VALIDATE_ARG_COUNT(2);
212 VALIDATE_ARG_NUM(0);
213 VALIDATE_ARG_NUM(1);
214 r_ret = Math::fmod(*p_args[0], *p_args[1]);
215 } break;
216 case MATH_FPOSMOD: {
217 VALIDATE_ARG_COUNT(2);
218 VALIDATE_ARG_NUM(0);
219 VALIDATE_ARG_NUM(1);
220 r_ret = Math::fposmod(*p_args[0], *p_args[1]);
221 } break;
222 case MATH_FLOOR: {
223 VALIDATE_ARG_COUNT(1);
224 VALIDATE_ARG_NUM(0);
225 r_ret = Math::floor(*p_args[0]);
226 } break;
227 case MATH_CEIL: {
228 VALIDATE_ARG_COUNT(1);
229 VALIDATE_ARG_NUM(0);
230 r_ret = Math::ceil(*p_args[0]);
231 } break;
232 case MATH_ROUND: {
233 VALIDATE_ARG_COUNT(1);
234 VALIDATE_ARG_NUM(0);
235 r_ret = Math::round(*p_args[0]);
236 } break;
237 case MATH_ABS: {
238 VALIDATE_ARG_COUNT(1);
239 if (p_args[0]->get_type() == Variant::INT) {
240
241 int64_t i = *p_args[0];
242 r_ret = ABS(i);
243 } else if (p_args[0]->get_type() == Variant::REAL) {
244
245 real_t r = *p_args[0];
246 r_ret = Math::abs(r);
247 } else {
248
249 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
250 r_error.argument = 0;
251 r_error.expected = Variant::REAL;
252 r_ret = Variant();
253 }
254 } break;
255 case MATH_SIGN: {
256 VALIDATE_ARG_COUNT(1);
257 if (p_args[0]->get_type() == Variant::INT) {
258
259 int64_t i = *p_args[0];
260 r_ret = i < 0 ? -1 : (i > 0 ? +1 : 0);
261 } else if (p_args[0]->get_type() == Variant::REAL) {
262
263 real_t r = *p_args[0];
264 r_ret = r < 0.0 ? -1.0 : (r > 0.0 ? +1.0 : 0.0);
265 } else {
266
267 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
268 r_error.argument = 0;
269 r_error.expected = Variant::REAL;
270 r_ret = Variant();
271 }
272 } break;
273 case MATH_POW: {
274 VALIDATE_ARG_COUNT(2);
275 VALIDATE_ARG_NUM(0);
276 VALIDATE_ARG_NUM(1);
277 r_ret = Math::pow(*p_args[0], *p_args[1]);
278 } break;
279 case MATH_LOG: {
280 VALIDATE_ARG_COUNT(1);
281 VALIDATE_ARG_NUM(0);
282 r_ret = Math::log(*p_args[0]);
283 } break;
284 case MATH_EXP: {
285 VALIDATE_ARG_COUNT(1);
286 VALIDATE_ARG_NUM(0);
287 r_ret = Math::exp(*p_args[0]);
288 } break;
289 case MATH_ISNAN: {
290 VALIDATE_ARG_COUNT(1);
291 VALIDATE_ARG_NUM(0);
292 r_ret = Math::is_nan(*p_args[0]);
293 } break;
294 case MATH_ISINF: {
295 VALIDATE_ARG_COUNT(1);
296 VALIDATE_ARG_NUM(0);
297 r_ret = Math::is_inf(*p_args[0]);
298 } break;
299 case MATH_EASE: {
300 VALIDATE_ARG_COUNT(2);
301 VALIDATE_ARG_NUM(0);
302 VALIDATE_ARG_NUM(1);
303 r_ret = Math::ease(*p_args[0], *p_args[1]);
304 } break;
305 case MATH_DECIMALS: {
306 VALIDATE_ARG_COUNT(1);
307 VALIDATE_ARG_NUM(0);
308 r_ret = Math::step_decimals(*p_args[0]);
309 } break;
310 case MATH_STEPIFY: {
311 VALIDATE_ARG_COUNT(2);
312 VALIDATE_ARG_NUM(0);
313 VALIDATE_ARG_NUM(1);
314 r_ret = Math::stepify(*p_args[0], *p_args[1]);
315 } break;
316 case MATH_LERP: {
317 VALIDATE_ARG_COUNT(3);
318 VALIDATE_ARG_NUM(0);
319 VALIDATE_ARG_NUM(1);
320 VALIDATE_ARG_NUM(2);
321 r_ret = Math::lerp(*p_args[0], *p_args[1], *p_args[2]);
322 } break;
323 case MATH_DECTIME: {
324 VALIDATE_ARG_COUNT(3);
325 VALIDATE_ARG_NUM(0);
326 VALIDATE_ARG_NUM(1);
327 VALIDATE_ARG_NUM(2);
328 r_ret = Math::dectime(*p_args[0], *p_args[1], *p_args[2]);
329 } break;
330 case MATH_RANDOMIZE: {
331 Math::randomize();
332 r_ret = Variant();
333 } break;
334 case MATH_RAND: {
335 r_ret = Math::rand();
336 } break;
337 case MATH_RANDF: {
338 r_ret = Math::randf();
339 } break;
340 case MATH_RANDOM: {
341 VALIDATE_ARG_COUNT(2);
342 VALIDATE_ARG_NUM(0);
343 VALIDATE_ARG_NUM(1);
344 r_ret = Math::random(*p_args[0], *p_args[1]);
345 } break;
346 case MATH_SEED: {
347 VALIDATE_ARG_COUNT(1);
348 VALIDATE_ARG_NUM(0);
349 uint32_t seed = *p_args[0];
350 Math::seed(seed);
351 r_ret = Variant();
352 } break;
353 case MATH_RANDSEED: {
354 VALIDATE_ARG_COUNT(1);
355 VALIDATE_ARG_NUM(0);
356 uint32_t seed = *p_args[0];
357 int ret = Math::rand_from_seed(&seed);
358 Array reta;
359 reta.push_back(ret);
360 reta.push_back(seed);
361 r_ret = reta;
362
363 } break;
364 case MATH_DEG2RAD: {
365 VALIDATE_ARG_COUNT(1);
366 VALIDATE_ARG_NUM(0);
367 r_ret = Math::deg2rad(*p_args[0]);
368 } break;
369 case MATH_RAD2DEG: {
370 VALIDATE_ARG_COUNT(1);
371 VALIDATE_ARG_NUM(0);
372 r_ret = Math::rad2deg(*p_args[0]);
373 } break;
374 case MATH_LINEAR2DB: {
375 VALIDATE_ARG_COUNT(1);
376 VALIDATE_ARG_NUM(0);
377 r_ret = Math::linear2db(*p_args[0]);
378 } break;
379 case MATH_DB2LINEAR: {
380 VALIDATE_ARG_COUNT(1);
381 VALIDATE_ARG_NUM(0);
382 r_ret = Math::db2linear(*p_args[0]);
383 } break;
384 case LOGIC_MAX: {
385 VALIDATE_ARG_COUNT(2);
386 if (p_args[0]->get_type() == Variant::INT && p_args[1]->get_type() == Variant::INT) {
387
388 int64_t a = *p_args[0];
389 int64_t b = *p_args[1];
390 r_ret = MAX(a, b);
391 } else {
392 VALIDATE_ARG_NUM(0);
393 VALIDATE_ARG_NUM(1);
394
395 real_t a = *p_args[0];
396 real_t b = *p_args[1];
397
398 r_ret = MAX(a, b);
399 }
400
401 } break;
402 case LOGIC_MIN: {
403 VALIDATE_ARG_COUNT(2);
404 if (p_args[0]->get_type() == Variant::INT && p_args[1]->get_type() == Variant::INT) {
405
406 int64_t a = *p_args[0];
407 int64_t b = *p_args[1];
408 r_ret = MIN(a, b);
409 } else {
410 VALIDATE_ARG_NUM(0);
411 VALIDATE_ARG_NUM(1);
412
413 real_t a = *p_args[0];
414 real_t b = *p_args[1];
415
416 r_ret = MIN(a, b);
417 }
418 } break;
419 case LOGIC_CLAMP: {
420 VALIDATE_ARG_COUNT(3);
421 if (p_args[0]->get_type() == Variant::INT && p_args[1]->get_type() == Variant::INT && p_args[2]->get_type() == Variant::INT) {
422
423 int64_t a = *p_args[0];
424 int64_t b = *p_args[1];
425 int64_t c = *p_args[2];
426 r_ret = CLAMP(a, b, c);
427 } else {
428 VALIDATE_ARG_NUM(0);
429 VALIDATE_ARG_NUM(1);
430 VALIDATE_ARG_NUM(2);
431
432 real_t a = *p_args[0];
433 real_t b = *p_args[1];
434 real_t c = *p_args[2];
435
436 r_ret = CLAMP(a, b, c);
437 }
438 } break;
439 case LOGIC_NEAREST_PO2: {
440 VALIDATE_ARG_COUNT(1);
441 VALIDATE_ARG_NUM(0);
442 int64_t num = *p_args[0];
443 r_ret = next_power_of_2(num);
444 } break;
445 case OBJ_WEAKREF: {
446 VALIDATE_ARG_COUNT(1);
447 if (p_args[0]->get_type() != Variant::OBJECT) {
448
449 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
450 r_error.argument = 0;
451 r_error.expected = Variant::OBJECT;
452 r_ret = Variant();
453 return;
454 }
455
456 if (p_args[0]->is_ref()) {
457
458 REF r = *p_args[0];
459 if (!r.is_valid()) {
460 r_ret = Variant();
461 return;
462 }
463
464 Ref<WeakRef> wref = memnew(WeakRef);
465 wref->set_ref(r);
466 r_ret = wref;
467 } else {
468 Object *obj = *p_args[0];
469 if (!obj) {
470 r_ret = Variant();
471 return;
472 }
473 Ref<WeakRef> wref = memnew(WeakRef);
474 wref->set_obj(obj);
475 r_ret = wref;
476 }
477
478 } break;
479 case FUNC_FUNCREF: {
480 VALIDATE_ARG_COUNT(2);
481 if (p_args[0]->get_type() != Variant::OBJECT) {
482
483 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
484 r_error.argument = 0;
485 r_error.expected = Variant::OBJECT;
486 r_ret = Variant();
487 return;
488 }
489 if (p_args[1]->get_type() != Variant::STRING && p_args[1]->get_type() != Variant::NODE_PATH) {
490
491 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
492 r_error.argument = 1;
493 r_error.expected = Variant::STRING;
494 r_ret = Variant();
495 return;
496 }
497
498 Ref<FuncRef> fr = memnew(FuncRef);
499
500 fr->set_instance(*p_args[0]);
501 fr->set_function(*p_args[1]);
502
503 r_ret = fr;
504
505 } break;
506 case TYPE_CONVERT: {
507 VALIDATE_ARG_COUNT(2);
508 VALIDATE_ARG_NUM(1);
509 int type = *p_args[1];
510 if (type < 0 || type >= Variant::VARIANT_MAX) {
511
512 r_ret = RTR("Invalid type argument to convert(), use TYPE_* constants.");
513 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
514 r_error.argument = 0;
515 r_error.expected = Variant::INT;
516 return;
517
518 } else {
519
520 r_ret = Variant::construct(Variant::Type(type), p_args, 1, r_error);
521 }
522 } break;
523 case TYPE_OF: {
524
525 VALIDATE_ARG_COUNT(1);
526 r_ret = p_args[0]->get_type();
527
528 } break;
529 case TYPE_EXISTS: {
530
531 VALIDATE_ARG_COUNT(1);
532 r_ret = ObjectTypeDB::type_exists(*p_args[0]);
533
534 } break;
535 case TEXT_STR: {
536
537 String str;
538 for (int i = 0; i < p_arg_count; i++) {
539
540 String os = p_args[i]->operator String();
541
542 if (i == 0)
543 str = os;
544 else
545 str += os;
546 }
547
548 r_ret = str;
549
550 } break;
551 case TEXT_PRINT: {
552
553 String str;
554 for (int i = 0; i < p_arg_count; i++) {
555
556 str += p_args[i]->operator String();
557 }
558
559 //str+="\n";
560 print_line(str);
561 r_ret = Variant();
562
563 } break;
564 case TEXT_PRINT_TABBED: {
565
566 String str;
567 for (int i = 0; i < p_arg_count; i++) {
568
569 if (i)
570 str += "\t";
571 str += p_args[i]->operator String();
572 }
573
574 //str+="\n";
575 print_line(str);
576 r_ret = Variant();
577
578 } break;
579 case TEXT_PRINT_SPACED: {
580
581 String str;
582 for (int i = 0; i < p_arg_count; i++) {
583
584 if (i)
585 str += " ";
586 str += p_args[i]->operator String();
587 }
588
589 //str+="\n";
590 print_line(str);
591 r_ret = Variant();
592
593 } break;
594
595 case TEXT_PRINTERR: {
596
597 String str;
598 for (int i = 0; i < p_arg_count; i++) {
599
600 str += p_args[i]->operator String();
601 }
602
603 //str+="\n";
604 OS::get_singleton()->printerr("%s\n", str.utf8().get_data());
605 r_ret = Variant();
606
607 } break;
608 case TEXT_PRINTRAW: {
609 String str;
610 for (int i = 0; i < p_arg_count; i++) {
611
612 str += p_args[i]->operator String();
613 }
614
615 //str+="\n";
616 OS::get_singleton()->print("%s", str.utf8().get_data());
617 r_ret = Variant();
618
619 } break;
620 case VAR_TO_STR: {
621 VALIDATE_ARG_COUNT(1);
622 String vars;
623 VariantWriter::write_to_string(*p_args[0], vars);
624 r_ret = vars;
625 } break;
626 case STR_TO_VAR: {
627 VALIDATE_ARG_COUNT(1);
628 if (p_args[0]->get_type() != Variant::STRING) {
629 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
630 r_error.argument = 0;
631 r_error.expected = Variant::STRING;
632 r_ret = Variant();
633 return;
634 }
635
636 VariantParser::StreamString ss;
637 ss.s = *p_args[0];
638
639 String errs;
640 int line;
641 Error err = VariantParser::parse(&ss, r_ret, errs, line);
642
643 if (err != OK) {
644 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
645 r_error.argument = 0;
646 r_error.expected = Variant::STRING;
647 r_ret = "Parse error at line " + itos(line) + ": " + errs;
648 return;
649 }
650
651 } break;
652 case VAR_TO_BYTES: {
653 VALIDATE_ARG_COUNT(1);
654
655 ByteArray barr;
656 int len;
657 Error err = encode_variant(*p_args[0], NULL, len);
658 if (err) {
659 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
660 r_error.argument = 0;
661 r_error.expected = Variant::NIL;
662 r_ret = "Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
663 return;
664 }
665
666 barr.resize(len);
667 {
668 ByteArray::Write w = barr.write();
669 encode_variant(*p_args[0], w.ptr(), len);
670 }
671 r_ret = barr;
672 } break;
673 case BYTES_TO_VAR: {
674 VALIDATE_ARG_COUNT(1);
675 if (p_args[0]->get_type() != Variant::RAW_ARRAY) {
676 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
677 r_error.argument = 0;
678 r_error.expected = Variant::RAW_ARRAY;
679 r_ret = Variant();
680 return;
681 }
682
683 ByteArray varr = *p_args[0];
684 Variant ret;
685 {
686 ByteArray::Read r = varr.read();
687 Error err = decode_variant(ret, r.ptr(), varr.size(), NULL);
688 if (err != OK) {
689 r_ret = RTR("Not enough bytes for decoding bytes, or invalid format.");
690 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
691 r_error.argument = 0;
692 r_error.expected = Variant::RAW_ARRAY;
693 return;
694 }
695 }
696
697 r_ret = ret;
698
699 } break;
700 case GEN_RANGE: {
701
702 switch (p_arg_count) {
703
704 case 0: {
705
706 r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
707 r_error.argument = 1;
708 r_ret = Variant();
709
710 } break;
711 case 1: {
712
713 VALIDATE_ARG_NUM(0);
714 int count = *p_args[0];
715 Array arr(true);
716 if (count <= 0) {
717 r_ret = arr;
718 return;
719 }
720 Error err = arr.resize(count);
721 if (err != OK) {
722 r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
723 r_ret = Variant();
724 return;
725 }
726
727 for (int i = 0; i < count; i++) {
728 arr[i] = i;
729 }
730
731 r_ret = arr;
732 } break;
733 case 2: {
734
735 VALIDATE_ARG_NUM(0);
736 VALIDATE_ARG_NUM(1);
737
738 int from = *p_args[0];
739 int to = *p_args[1];
740
741 Array arr(true);
742 if (from >= to) {
743 r_ret = arr;
744 return;
745 }
746 Error err = arr.resize(to - from);
747 if (err != OK) {
748 r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
749 r_ret = Variant();
750 return;
751 }
752 for (int i = from; i < to; i++)
753 arr[i - from] = i;
754 r_ret = arr;
755 } break;
756 case 3: {
757
758 VALIDATE_ARG_NUM(0);
759 VALIDATE_ARG_NUM(1);
760 VALIDATE_ARG_NUM(2);
761
762 int from = *p_args[0];
763 int to = *p_args[1];
764 int incr = *p_args[2];
765 if (incr == 0) {
766
767 r_ret = RTR("step argument is zero!");
768 r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
769 return;
770 }
771
772 Array arr(true);
773 if (from >= to && incr > 0) {
774 r_ret = arr;
775 return;
776 }
777 if (from <= to && incr < 0) {
778 r_ret = arr;
779 return;
780 }
781
782 //calculate how many
783 int count = 0;
784 if (incr > 0) {
785
786 count = ((to - from - 1) / incr) + 1;
787 } else {
788
789 count = ((from - to - 1) / -incr) + 1;
790 }
791
792 Error err = arr.resize(count);
793
794 if (err != OK) {
795 r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
796 r_ret = Variant();
797 return;
798 }
799
800 if (incr > 0) {
801 int idx = 0;
802 for (int i = from; i < to; i += incr) {
803 arr[idx++] = i;
804 }
805 } else {
806
807 int idx = 0;
808 for (int i = from; i > to; i += incr) {
809 arr[idx++] = i;
810 }
811 }
812
813 r_ret = arr;
814 } break;
815 default: {
816
817 r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
818 r_error.argument = 3;
819 r_ret = Variant();
820
821 } break;
822 }
823
824 } break;
825 case RESOURCE_LOAD: {
826 VALIDATE_ARG_COUNT(1);
827 if (p_args[0]->get_type() != Variant::STRING) {
828 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
829 r_error.argument = 0;
830 r_ret = Variant();
831 } else {
832 r_ret = ResourceLoader::load(*p_args[0]);
833 }
834
835 } break;
836 case INST2DICT: {
837
838 VALIDATE_ARG_COUNT(1);
839
840 if (p_args[0]->get_type() == Variant::NIL) {
841 r_ret = Variant();
842 } else if (p_args[0]->get_type() != Variant::OBJECT) {
843 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
844 r_error.argument = 0;
845 r_ret = Variant();
846 } else {
847
848 Object *obj = *p_args[0];
849 if (!obj) {
850 r_ret = Variant();
851
852 } else if (!obj->get_script_instance() || obj->get_script_instance()->get_language() != GDScriptLanguage::get_singleton()) {
853
854 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
855 r_error.argument = 0;
856 r_error.expected = Variant::DICTIONARY;
857 r_ret = RTR("Not a script with an instance");
858 return;
859 } else {
860
861 GDInstance *ins = static_cast<GDInstance *>(obj->get_script_instance());
862 Ref<GDScript> base = ins->get_script();
863 if (base.is_null()) {
864
865 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
866 r_error.argument = 0;
867 r_error.expected = Variant::DICTIONARY;
868 r_ret = RTR("Not based on a script");
869 return;
870 }
871
872 GDScript *p = base.ptr();
873 Vector<StringName> sname;
874
875 while (p->_owner) {
876
877 sname.push_back(p->name);
878 p = p->_owner;
879 }
880 sname.invert();
881
882 if (!p->path.is_resource_file()) {
883 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
884 r_error.argument = 0;
885 r_error.expected = Variant::DICTIONARY;
886 r_ret = Variant();
887
888 r_ret = RTR("Not based on a resource file");
889
890 return;
891 }
892
893 NodePath cp(sname, Vector<StringName>(), false);
894
895 Dictionary d(true);
896 d["@subpath"] = cp;
897 d["@path"] = p->path;
898
899 p = base.ptr();
900
901 while (p) {
902
903 for (Set<StringName>::Element *E = p->members.front(); E; E = E->next()) {
904
905 Variant value;
906 if (ins->get(E->get(), value)) {
907
908 String k = E->get();
909 if (!d.has(k)) {
910 d[k] = value;
911 }
912 }
913 }
914
915 p = p->_base;
916 }
917
918 r_ret = d;
919 }
920 }
921
922 } break;
923 case DICT2INST: {
924
925 VALIDATE_ARG_COUNT(1);
926
927 if (p_args[0]->get_type() != Variant::DICTIONARY) {
928
929 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
930 r_error.argument = 0;
931 r_error.expected = Variant::DICTIONARY;
932 r_ret = Variant();
933
934 return;
935 }
936
937 Dictionary d = *p_args[0];
938
939 if (!d.has("@path")) {
940
941 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
942 r_error.argument = 0;
943 r_error.expected = Variant::OBJECT;
944 r_ret = RTR("Invalid instance dictionary format (missing @path)");
945
946 return;
947 }
948
949 Ref<Script> scr = ResourceLoader::load(d["@path"]);
950 if (!scr.is_valid()) {
951
952 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
953 r_error.argument = 0;
954 r_error.expected = Variant::OBJECT;
955 r_ret = RTR("Invalid instance dictionary format (can't load script at @path)");
956 return;
957 }
958
959 Ref<GDScript> gdscr = scr;
960
961 if (!gdscr.is_valid()) {
962
963 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
964 r_error.argument = 0;
965 r_error.expected = Variant::OBJECT;
966 r_ret = Variant();
967 r_ret = RTR("Invalid instance dictionary format (invalid script at @path)");
968 return;
969 }
970
971 NodePath sub;
972 if (d.has("@subpath")) {
973 sub = d["@subpath"];
974 }
975
976 for (int i = 0; i < sub.get_name_count(); i++) {
977
978 gdscr = gdscr->subclasses[sub.get_name(i)];
979 if (!gdscr.is_valid()) {
980
981 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
982 r_error.argument = 0;
983 r_error.expected = Variant::OBJECT;
984 r_ret = Variant();
985 r_ret = RTR("Invalid instance dictionary (invalid subclasses)");
986 return;
987 }
988 }
989
990 r_ret = gdscr->_new(NULL, 0, r_error);
991
992 GDInstance *ins = static_cast<GDInstance *>(static_cast<Object *>(r_ret)->get_script_instance());
993 Ref<GDScript> gd_ref = ins->get_script();
994
995 for (Map<StringName, GDScript::MemberInfo>::Element *E = gd_ref->member_indices.front(); E; E = E->next()) {
996 if (d.has(E->key())) {
997 ins->members[E->get().index] = d[E->key()];
998 }
999 }
1000
1001 } break;
1002 case HASH: {
1003
1004 VALIDATE_ARG_COUNT(1);
1005 r_ret = p_args[0]->hash();
1006
1007 } break;
1008 case COLOR8: {
1009
1010 if (p_arg_count < 3) {
1011 r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
1012 r_error.argument = 3;
1013 r_ret = Variant();
1014
1015 return;
1016 }
1017 if (p_arg_count > 4) {
1018 r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
1019 r_error.argument = 4;
1020 r_ret = Variant();
1021
1022 return;
1023 }
1024
1025 VALIDATE_ARG_NUM(0);
1026 VALIDATE_ARG_NUM(1);
1027 VALIDATE_ARG_NUM(2);
1028
1029 Color color((float)*p_args[0] / 255.0f, (float)*p_args[1] / 255.0f, (float)*p_args[2] / 255.0f);
1030
1031 if (p_arg_count == 4) {
1032 VALIDATE_ARG_NUM(3);
1033 color.a = (float)*p_args[3] / 255.0f;
1034 }
1035
1036 r_ret = color;
1037
1038 } break;
1039 case COLORN: {
1040
1041 if (p_arg_count < 1) {
1042 r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
1043 r_error.argument = 1;
1044 r_ret = Variant();
1045 return;
1046 }
1047
1048 if (p_arg_count > 2) {
1049 r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
1050 r_error.argument = 2;
1051 r_ret = Variant();
1052 return;
1053 }
1054
1055 if (p_args[0]->get_type() != Variant::STRING) {
1056 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
1057 r_error.argument = 0;
1058 r_ret = Variant();
1059 } else {
1060 Color color = Color::named(*p_args[0]);
1061 if (p_arg_count == 2) {
1062 VALIDATE_ARG_NUM(1);
1063 color.a = *p_args[1];
1064 }
1065 r_ret = color;
1066 }
1067
1068 } break;
1069
1070 case PRINT_STACK: {
1071
1072 ScriptLanguage *script = GDScriptLanguage::get_singleton();
1073 for (int i = 0; i < script->debug_get_stack_level_count(); i++) {
1074
1075 print_line("Frame " + itos(i) + " - " + script->debug_get_stack_level_source(i) + ":" + itos(script->debug_get_stack_level_line(i)) + " in function '" + script->debug_get_stack_level_function(i) + "'");
1076 };
1077 } break;
1078
1079 case INSTANCE_FROM_ID: {
1080
1081 VALIDATE_ARG_COUNT(1);
1082 if (p_args[0]->get_type() != Variant::INT && p_args[0]->get_type() != Variant::REAL) {
1083 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
1084 r_error.argument = 0;
1085 r_error.expected = Variant::INT;
1086 r_ret = Variant();
1087 break;
1088 }
1089
1090 uint32_t id = *p_args[0];
1091 r_ret = ObjectDB::get_instance(id);
1092
1093 } break;
1094 case FUNC_MAX: {
1095
1096 ERR_FAIL();
1097 } break;
1098 }
1099 }
1100
is_deterministic(Function p_func)1101 bool GDFunctions::is_deterministic(Function p_func) {
1102
1103 //man i couldn't have chosen a worse function name,
1104 //way too controversial..
1105
1106 switch (p_func) {
1107
1108 case MATH_SIN:
1109 case MATH_COS:
1110 case MATH_TAN:
1111 case MATH_SINH:
1112 case MATH_COSH:
1113 case MATH_TANH:
1114 case MATH_ASIN:
1115 case MATH_ACOS:
1116 case MATH_ATAN:
1117 case MATH_ATAN2:
1118 case MATH_SQRT:
1119 case MATH_FMOD:
1120 case MATH_FPOSMOD:
1121 case MATH_FLOOR:
1122 case MATH_CEIL:
1123 case MATH_ROUND:
1124 case MATH_ABS:
1125 case MATH_SIGN:
1126 case MATH_POW:
1127 case MATH_LOG:
1128 case MATH_EXP:
1129 case MATH_ISNAN:
1130 case MATH_ISINF:
1131 case MATH_EASE:
1132 case MATH_DECIMALS:
1133 case MATH_STEPIFY:
1134 case MATH_LERP:
1135 case MATH_DECTIME:
1136 case MATH_DEG2RAD:
1137 case MATH_RAD2DEG:
1138 case MATH_LINEAR2DB:
1139 case MATH_DB2LINEAR:
1140 case LOGIC_MAX:
1141 case LOGIC_MIN:
1142 case LOGIC_CLAMP:
1143 case LOGIC_NEAREST_PO2:
1144 case TYPE_CONVERT:
1145 case TYPE_OF:
1146 case TYPE_EXISTS:
1147 case TEXT_STR:
1148 case COLOR8:
1149 // enable for debug only, otherwise not desirable - case GEN_RANGE:
1150 return true;
1151 default:
1152 return false;
1153 }
1154
1155 return false;
1156 }
1157
get_info(Function p_func)1158 MethodInfo GDFunctions::get_info(Function p_func) {
1159
1160 #ifdef TOOLS_ENABLED
1161 //using a switch, so the compiler generates a jumptable
1162
1163 switch (p_func) {
1164
1165 case MATH_SIN: {
1166 MethodInfo mi("sin", PropertyInfo(Variant::REAL, "s"));
1167 mi.return_val.type = Variant::REAL;
1168 return mi;
1169
1170 } break;
1171 case MATH_COS: {
1172 MethodInfo mi("cos", PropertyInfo(Variant::REAL, "s"));
1173 mi.return_val.type = Variant::REAL;
1174 return mi;
1175 } break;
1176 case MATH_TAN: {
1177 MethodInfo mi("tan", PropertyInfo(Variant::REAL, "s"));
1178 mi.return_val.type = Variant::REAL;
1179 return mi;
1180 } break;
1181 case MATH_SINH: {
1182 MethodInfo mi("sinh", PropertyInfo(Variant::REAL, "s"));
1183 mi.return_val.type = Variant::REAL;
1184 return mi;
1185 } break;
1186 case MATH_COSH: {
1187 MethodInfo mi("cosh", PropertyInfo(Variant::REAL, "s"));
1188 mi.return_val.type = Variant::REAL;
1189 return mi;
1190 } break;
1191 case MATH_TANH: {
1192 MethodInfo mi("tanh", PropertyInfo(Variant::REAL, "s"));
1193 mi.return_val.type = Variant::REAL;
1194 return mi;
1195 } break;
1196 case MATH_ASIN: {
1197 MethodInfo mi("asin", PropertyInfo(Variant::REAL, "s"));
1198 mi.return_val.type = Variant::REAL;
1199 return mi;
1200 } break;
1201 case MATH_ACOS: {
1202 MethodInfo mi("acos", PropertyInfo(Variant::REAL, "s"));
1203 mi.return_val.type = Variant::REAL;
1204 return mi;
1205 } break;
1206 case MATH_ATAN: {
1207 MethodInfo mi("atan", PropertyInfo(Variant::REAL, "s"));
1208 mi.return_val.type = Variant::REAL;
1209 return mi;
1210 } break;
1211 case MATH_ATAN2: {
1212 MethodInfo mi("atan2", PropertyInfo(Variant::REAL, "x"), PropertyInfo(Variant::REAL, "y"));
1213 mi.return_val.type = Variant::REAL;
1214 return mi;
1215 } break;
1216 case MATH_SQRT: {
1217 MethodInfo mi("sqrt", PropertyInfo(Variant::REAL, "s"));
1218 mi.return_val.type = Variant::REAL;
1219 return mi;
1220 } break;
1221 case MATH_FMOD: {
1222 MethodInfo mi("fmod", PropertyInfo(Variant::REAL, "x"), PropertyInfo(Variant::REAL, "y"));
1223 mi.return_val.type = Variant::REAL;
1224 return mi;
1225 } break;
1226 case MATH_FPOSMOD: {
1227 MethodInfo mi("fposmod", PropertyInfo(Variant::REAL, "x"), PropertyInfo(Variant::REAL, "y"));
1228 mi.return_val.type = Variant::REAL;
1229 return mi;
1230 } break;
1231 case MATH_FLOOR: {
1232 MethodInfo mi("floor", PropertyInfo(Variant::REAL, "s"));
1233 mi.return_val.type = Variant::REAL;
1234 return mi;
1235 } break;
1236 case MATH_CEIL: {
1237 MethodInfo mi("ceil", PropertyInfo(Variant::REAL, "s"));
1238 mi.return_val.type = Variant::REAL;
1239 return mi;
1240 } break;
1241 case MATH_ROUND: {
1242 MethodInfo mi("round", PropertyInfo(Variant::REAL, "s"));
1243 mi.return_val.type = Variant::REAL;
1244 return mi;
1245 } break;
1246 case MATH_ABS: {
1247 MethodInfo mi("abs", PropertyInfo(Variant::REAL, "s"));
1248 mi.return_val.type = Variant::REAL;
1249 return mi;
1250 } break;
1251 case MATH_SIGN: {
1252 MethodInfo mi("sign", PropertyInfo(Variant::REAL, "s"));
1253 mi.return_val.type = Variant::REAL;
1254 return mi;
1255 } break;
1256 case MATH_POW: {
1257 MethodInfo mi("pow", PropertyInfo(Variant::REAL, "x"), PropertyInfo(Variant::REAL, "y"));
1258 mi.return_val.type = Variant::REAL;
1259 return mi;
1260 } break;
1261 case MATH_LOG: {
1262 MethodInfo mi("log", PropertyInfo(Variant::REAL, "s"));
1263 mi.return_val.type = Variant::REAL;
1264 return mi;
1265 } break;
1266 case MATH_EXP: {
1267 MethodInfo mi("exp", PropertyInfo(Variant::REAL, "s"));
1268 mi.return_val.type = Variant::REAL;
1269 return mi;
1270 } break;
1271 case MATH_ISNAN: {
1272 MethodInfo mi("is_nan", PropertyInfo(Variant::REAL, "s"));
1273 mi.return_val.type = Variant::REAL;
1274 return mi;
1275 } break;
1276 case MATH_ISINF: {
1277 MethodInfo mi("is_inf", PropertyInfo(Variant::REAL, "s"));
1278 mi.return_val.type = Variant::REAL;
1279 return mi;
1280 } break;
1281 case MATH_EASE: {
1282 MethodInfo mi("ease", PropertyInfo(Variant::REAL, "s"), PropertyInfo(Variant::REAL, "curve"));
1283 mi.return_val.type = Variant::REAL;
1284 return mi;
1285 } break;
1286 case MATH_DECIMALS: {
1287 MethodInfo mi("decimals", PropertyInfo(Variant::REAL, "step"));
1288 mi.return_val.type = Variant::REAL;
1289 return mi;
1290 } break;
1291 case MATH_STEPIFY: {
1292 MethodInfo mi("stepify", PropertyInfo(Variant::REAL, "s"), PropertyInfo(Variant::REAL, "step"));
1293 mi.return_val.type = Variant::REAL;
1294 return mi;
1295 } break;
1296 case MATH_LERP: {
1297 MethodInfo mi("lerp", PropertyInfo(Variant::REAL, "from"), PropertyInfo(Variant::REAL, "to"), PropertyInfo(Variant::REAL, "weight"));
1298 mi.return_val.type = Variant::REAL;
1299 return mi;
1300 } break;
1301 case MATH_DECTIME: {
1302 MethodInfo mi("dectime", PropertyInfo(Variant::REAL, "value"), PropertyInfo(Variant::REAL, "amount"), PropertyInfo(Variant::REAL, "step"));
1303 mi.return_val.type = Variant::REAL;
1304 return mi;
1305 } break;
1306 case MATH_RANDOMIZE: {
1307 MethodInfo mi("randomize");
1308 mi.return_val.type = Variant::NIL;
1309 return mi;
1310 } break;
1311 case MATH_RAND: {
1312 MethodInfo mi("randi");
1313 mi.return_val.type = Variant::INT;
1314 return mi;
1315 } break;
1316 case MATH_RANDF: {
1317 MethodInfo mi("randf");
1318 mi.return_val.type = Variant::REAL;
1319 return mi;
1320 } break;
1321 case MATH_RANDOM: {
1322 MethodInfo mi("rand_range", PropertyInfo(Variant::REAL, "from"), PropertyInfo(Variant::REAL, "to"));
1323 mi.return_val.type = Variant::REAL;
1324 return mi;
1325 } break;
1326 case MATH_SEED: {
1327 MethodInfo mi("seed", PropertyInfo(Variant::INT, "seed"));
1328 mi.return_val.type = Variant::NIL;
1329 return mi;
1330 } break;
1331 case MATH_RANDSEED: {
1332 MethodInfo mi("rand_seed", PropertyInfo(Variant::INT, "seed"));
1333 mi.return_val.type = Variant::ARRAY;
1334 return mi;
1335 } break;
1336 case MATH_DEG2RAD: {
1337 MethodInfo mi("deg2rad", PropertyInfo(Variant::REAL, "deg"));
1338 mi.return_val.type = Variant::REAL;
1339 return mi;
1340 } break;
1341 case MATH_RAD2DEG: {
1342 MethodInfo mi("rad2deg", PropertyInfo(Variant::REAL, "rad"));
1343 mi.return_val.type = Variant::REAL;
1344 return mi;
1345 } break;
1346 case MATH_LINEAR2DB: {
1347 MethodInfo mi("linear2db", PropertyInfo(Variant::REAL, "nrg"));
1348 mi.return_val.type = Variant::REAL;
1349 return mi;
1350 } break;
1351 case MATH_DB2LINEAR: {
1352 MethodInfo mi("db2linear", PropertyInfo(Variant::REAL, "db"));
1353 mi.return_val.type = Variant::REAL;
1354 return mi;
1355 } break;
1356 case LOGIC_MAX: {
1357 MethodInfo mi("max", PropertyInfo(Variant::REAL, "a"), PropertyInfo(Variant::REAL, "b"));
1358 mi.return_val.type = Variant::REAL;
1359 return mi;
1360
1361 } break;
1362 case LOGIC_MIN: {
1363 MethodInfo mi("min", PropertyInfo(Variant::REAL, "a"), PropertyInfo(Variant::REAL, "b"));
1364 mi.return_val.type = Variant::REAL;
1365 return mi;
1366 } break;
1367 case LOGIC_CLAMP: {
1368 MethodInfo mi("clamp", PropertyInfo(Variant::REAL, "val"), PropertyInfo(Variant::REAL, "min"), PropertyInfo(Variant::REAL, "max"));
1369 mi.return_val.type = Variant::REAL;
1370 return mi;
1371 } break;
1372 case LOGIC_NEAREST_PO2: {
1373 MethodInfo mi("nearest_po2", PropertyInfo(Variant::INT, "val"));
1374 mi.return_val.type = Variant::INT;
1375 return mi;
1376 } break;
1377 case OBJ_WEAKREF: {
1378
1379 MethodInfo mi("weakref", PropertyInfo(Variant::OBJECT, "obj"));
1380 mi.return_val.type = Variant::OBJECT;
1381 mi.return_val.name = "WeakRef";
1382
1383 return mi;
1384
1385 } break;
1386 case FUNC_FUNCREF: {
1387
1388 MethodInfo mi("funcref", PropertyInfo(Variant::OBJECT, "instance"), PropertyInfo(Variant::STRING, "funcname"));
1389 mi.return_val.type = Variant::OBJECT;
1390 mi.return_val.name = "FuncRef";
1391 return mi;
1392
1393 } break;
1394 case TYPE_CONVERT: {
1395
1396 MethodInfo mi("convert", PropertyInfo(Variant::NIL, "what"), PropertyInfo(Variant::INT, "type"));
1397 mi.return_val.type = Variant::OBJECT;
1398 return mi;
1399 } break;
1400 case TYPE_OF: {
1401
1402 MethodInfo mi("typeof", PropertyInfo(Variant::NIL, "what"));
1403 mi.return_val.type = Variant::INT;
1404 return mi;
1405
1406 } break;
1407 case TYPE_EXISTS: {
1408
1409 MethodInfo mi("type_exists", PropertyInfo(Variant::STRING, "type"));
1410 mi.return_val.type = Variant::BOOL;
1411 return mi;
1412
1413 } break;
1414 case TEXT_STR: {
1415
1416 MethodInfo mi("str", PropertyInfo(Variant::NIL, "what"), PropertyInfo(Variant::NIL, "..."));
1417 mi.return_val.type = Variant::STRING;
1418 return mi;
1419
1420 } break;
1421 case TEXT_PRINT: {
1422
1423 MethodInfo mi("print", PropertyInfo(Variant::NIL, "what"), PropertyInfo(Variant::NIL, "..."));
1424 mi.return_val.type = Variant::NIL;
1425 return mi;
1426
1427 } break;
1428 case TEXT_PRINT_TABBED: {
1429
1430 MethodInfo mi("printt", PropertyInfo(Variant::NIL, "what"), PropertyInfo(Variant::NIL, "..."));
1431 mi.return_val.type = Variant::NIL;
1432 return mi;
1433
1434 } break;
1435 case TEXT_PRINT_SPACED: {
1436
1437 MethodInfo mi("prints", PropertyInfo(Variant::NIL, "what"), PropertyInfo(Variant::NIL, "..."));
1438 mi.return_val.type = Variant::NIL;
1439 return mi;
1440
1441 } break;
1442 case TEXT_PRINTERR: {
1443
1444 MethodInfo mi("printerr", PropertyInfo(Variant::NIL, "what"), PropertyInfo(Variant::NIL, "..."));
1445 mi.return_val.type = Variant::NIL;
1446 return mi;
1447
1448 } break;
1449 case TEXT_PRINTRAW: {
1450
1451 MethodInfo mi("printraw", PropertyInfo(Variant::NIL, "what"), PropertyInfo(Variant::NIL, "..."));
1452 mi.return_val.type = Variant::NIL;
1453 return mi;
1454
1455 } break;
1456 case VAR_TO_STR: {
1457 MethodInfo mi("var2str", PropertyInfo(Variant::NIL, "var"));
1458 mi.return_val.type = Variant::STRING;
1459 return mi;
1460
1461 } break;
1462 case STR_TO_VAR: {
1463
1464 MethodInfo mi("str2var:Variant", PropertyInfo(Variant::STRING, "string"));
1465 mi.return_val.type = Variant::NIL;
1466 return mi;
1467 } break;
1468 case VAR_TO_BYTES: {
1469 MethodInfo mi("var2bytes", PropertyInfo(Variant::NIL, "var"));
1470 mi.return_val.type = Variant::RAW_ARRAY;
1471 return mi;
1472
1473 } break;
1474 case BYTES_TO_VAR: {
1475
1476 MethodInfo mi("bytes2var:Variant", PropertyInfo(Variant::RAW_ARRAY, "bytes"));
1477 mi.return_val.type = Variant::NIL;
1478 return mi;
1479 } break;
1480 case GEN_RANGE: {
1481
1482 MethodInfo mi("range", PropertyInfo(Variant::NIL, "..."));
1483 mi.return_val.type = Variant::ARRAY;
1484 return mi;
1485 } break;
1486 case RESOURCE_LOAD: {
1487
1488 MethodInfo mi("load", PropertyInfo(Variant::STRING, "path"));
1489 mi.return_val.type = Variant::OBJECT;
1490 mi.return_val.name = "Resource";
1491 return mi;
1492 } break;
1493 case INST2DICT: {
1494
1495 MethodInfo mi("inst2dict", PropertyInfo(Variant::OBJECT, "inst"));
1496 mi.return_val.type = Variant::DICTIONARY;
1497 return mi;
1498 } break;
1499 case DICT2INST: {
1500
1501 MethodInfo mi("dict2inst", PropertyInfo(Variant::DICTIONARY, "dict"));
1502 mi.return_val.type = Variant::OBJECT;
1503 return mi;
1504 } break;
1505 case HASH: {
1506
1507 MethodInfo mi("hash", PropertyInfo(Variant::NIL, "var:Variant"));
1508 mi.return_val.type = Variant::INT;
1509 return mi;
1510 } break;
1511 case COLOR8: {
1512
1513 MethodInfo mi("Color8", PropertyInfo(Variant::INT, "r8"), PropertyInfo(Variant::INT, "g8"), PropertyInfo(Variant::INT, "b8"), PropertyInfo(Variant::INT, "a8"));
1514 mi.return_val.type = Variant::COLOR;
1515 return mi;
1516 } break;
1517 case COLORN: {
1518
1519 MethodInfo mi("ColorN", PropertyInfo(Variant::STRING, "name"), PropertyInfo(Variant::REAL, "alpha"));
1520 mi.return_val.type = Variant::COLOR;
1521 return mi;
1522 } break;
1523
1524 case PRINT_STACK: {
1525 MethodInfo mi("print_stack");
1526 mi.return_val.type = Variant::NIL;
1527 return mi;
1528 } break;
1529
1530 case INSTANCE_FROM_ID: {
1531 MethodInfo mi("instance_from_id", PropertyInfo(Variant::INT, "instance_id"));
1532 mi.return_val.type = Variant::OBJECT;
1533 return mi;
1534 } break;
1535
1536 case FUNC_MAX: {
1537
1538 ERR_FAIL_V(MethodInfo());
1539 } break;
1540 }
1541 #endif
1542
1543 return MethodInfo();
1544 }
1545