1 /*************************************************************************/
2 /* variant_call.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 "core_string_names.h"
31 #include "object.h"
32 #include "os/os.h"
33 #include "script_language.h"
34 #include "variant.h"
35
36 typedef void (*VariantFunc)(Variant &r_ret, Variant &p_self, const Variant **p_args);
37 typedef void (*VariantConstructFunc)(Variant &r_ret, const Variant **p_args);
38
39 VARIANT_ENUM_CAST(Image::CompressMode);
40 //VARIANT_ENUM_CAST(Image::Format);
41
42 struct _VariantCall {
43
Vector3_dot_VariantCall44 static void Vector3_dot(Variant &r_ret, Variant &p_self, const Variant **p_args) {
45
46 r_ret = reinterpret_cast<Vector3 *>(p_self._data._mem)->dot(*reinterpret_cast<const Vector3 *>(p_args[0]->_data._mem));
47 }
48
49 struct FuncData {
50
51 int arg_count;
52 Vector<Variant> default_args;
53 Vector<Variant::Type> arg_types;
54
55 #ifdef DEBUG_ENABLED
56 Vector<StringName> arg_names;
57 Variant::Type return_type;
58 bool returns;
59 #endif
60 VariantFunc func;
61
verify_arguments_VariantCall::FuncData62 _FORCE_INLINE_ bool verify_arguments(const Variant **p_args, Variant::CallError &r_error) {
63
64 if (arg_count == 0)
65 return true;
66
67 Variant::Type *tptr = &arg_types[0];
68
69 for (int i = 0; i < arg_count; i++) {
70
71 if (!tptr[i] || tptr[i] == p_args[i]->type)
72 continue; // all good
73 if (!Variant::can_convert(p_args[i]->type, tptr[i])) {
74 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
75 r_error.argument = i;
76 r_error.expected = tptr[i];
77 return false;
78 }
79 }
80 return true;
81 }
82
call_VariantCall::FuncData83 _FORCE_INLINE_ void call(Variant &r_ret, Variant &p_self, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
84 #ifdef DEBUG_ENABLED
85 if (p_argcount > arg_count) {
86 r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
87 r_error.argument = arg_count;
88 return;
89 } else
90 #endif
91 if (p_argcount < arg_count) {
92 int def_argcount = default_args.size();
93 #ifdef DEBUG_ENABLED
94 if (p_argcount < (arg_count - def_argcount)) {
95 r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
96 r_error.argument = arg_count - def_argcount;
97 return;
98 }
99
100 #endif
101 ERR_FAIL_COND(p_argcount > VARIANT_ARG_MAX);
102 const Variant *newargs[VARIANT_ARG_MAX];
103 for (int i = 0; i < p_argcount; i++)
104 newargs[i] = p_args[i];
105 int defargcount = def_argcount;
106 for (int i = p_argcount; i < arg_count; i++)
107 newargs[i] = &default_args[defargcount - (i - p_argcount) - 1]; //default arguments
108 #ifdef DEBUG_ENABLED
109 if (!verify_arguments(newargs, r_error))
110 return;
111 #endif
112 func(r_ret, p_self, newargs);
113 } else {
114 #ifdef DEBUG_ENABLED
115 if (!verify_arguments(p_args, r_error))
116 return;
117 #endif
118 func(r_ret, p_self, p_args);
119 }
120 }
121 };
122
123 struct TypeFunc {
124
125 Map<StringName, FuncData> functions;
126 };
127
128 static TypeFunc *type_funcs;
129
130 struct Arg {
131 StringName name;
132 Variant::Type type;
Arg_VariantCall::Arg133 Arg() { type = Variant::NIL; }
Arg_VariantCall::Arg134 Arg(Variant::Type p_type, const StringName &p_name) {
135 name = p_name;
136 type = p_type;
137 }
138 };
139
140 // void addfunc(Variant::Type p_type, const StringName& p_name,VariantFunc p_func);
addfunc_VariantCall141 static void addfunc(Variant::Type p_type, Variant::Type p_return, const StringName &p_name, VariantFunc p_func, const Vector<Variant> &p_defaultarg, const Arg &p_argtype1 = Arg(), const Arg &p_argtype2 = Arg(), const Arg &p_argtype3 = Arg(), const Arg &p_argtype4 = Arg(), const Arg &p_argtype5 = Arg()) {
142
143 FuncData funcdata;
144 funcdata.func = p_func;
145 funcdata.default_args = p_defaultarg;
146 #ifdef DEBUG_ENABLED
147 funcdata.return_type = p_return;
148 funcdata.returns = p_return != Variant::NIL;
149 #endif
150
151 if (p_argtype1.name) {
152 funcdata.arg_types.push_back(p_argtype1.type);
153 #ifdef DEBUG_ENABLED
154 funcdata.arg_names.push_back(p_argtype1.name);
155 #endif
156
157 } else
158 goto end;
159
160 if (p_argtype2.name) {
161 funcdata.arg_types.push_back(p_argtype2.type);
162 #ifdef DEBUG_ENABLED
163 funcdata.arg_names.push_back(p_argtype2.name);
164 #endif
165
166 } else
167 goto end;
168
169 if (p_argtype3.name) {
170 funcdata.arg_types.push_back(p_argtype3.type);
171 #ifdef DEBUG_ENABLED
172 funcdata.arg_names.push_back(p_argtype3.name);
173 #endif
174
175 } else
176 goto end;
177
178 if (p_argtype4.name) {
179 funcdata.arg_types.push_back(p_argtype4.type);
180 #ifdef DEBUG_ENABLED
181 funcdata.arg_names.push_back(p_argtype4.name);
182 #endif
183 } else
184 goto end;
185
186 if (p_argtype5.name) {
187 funcdata.arg_types.push_back(p_argtype5.type);
188 #ifdef DEBUG_ENABLED
189 funcdata.arg_names.push_back(p_argtype5.name);
190 #endif
191 } else
192 goto end;
193
194 end:
195
196 funcdata.arg_count = funcdata.arg_types.size();
197 type_funcs[p_type].functions[p_name] = funcdata;
198 }
199
200 #define VCALL_LOCALMEM0(m_type, m_method) \
201 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { reinterpret_cast<m_type *>(p_self._data._mem)->m_method(); }
202 #define VCALL_LOCALMEM0R(m_type, m_method) \
203 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { r_ret = reinterpret_cast<m_type *>(p_self._data._mem)->m_method(); }
204 #define VCALL_LOCALMEM1(m_type, m_method) \
205 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { reinterpret_cast<m_type *>(p_self._data._mem)->m_method(*p_args[0]); }
206 #define VCALL_LOCALMEM1R(m_type, m_method) \
207 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { r_ret = reinterpret_cast<m_type *>(p_self._data._mem)->m_method(*p_args[0]); }
208 #define VCALL_LOCALMEM2(m_type, m_method) \
209 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { reinterpret_cast<m_type *>(p_self._data._mem)->m_method(*p_args[0], *p_args[1]); }
210 #define VCALL_LOCALMEM2R(m_type, m_method) \
211 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { r_ret = reinterpret_cast<m_type *>(p_self._data._mem)->m_method(*p_args[0], *p_args[1]); }
212 #define VCALL_LOCALMEM3(m_type, m_method) \
213 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { reinterpret_cast<m_type *>(p_self._data._mem)->m_method(*p_args[0], *p_args[1], *p_args[2]); }
214 #define VCALL_LOCALMEM3R(m_type, m_method) \
215 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { r_ret = reinterpret_cast<m_type *>(p_self._data._mem)->m_method(*p_args[0], *p_args[1], *p_args[2]); }
216 #define VCALL_LOCALMEM4(m_type, m_method) \
217 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { reinterpret_cast<m_type *>(p_self._data._mem)->m_method(*p_args[0], *p_args[1], *p_args[2], *p_args[3]); }
218 #define VCALL_LOCALMEM4R(m_type, m_method) \
219 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { r_ret = reinterpret_cast<m_type *>(p_self._data._mem)->m_method(*p_args[0], *p_args[1], *p_args[2], *p_args[3]); }
220 #define VCALL_LOCALMEM5(m_type, m_method) \
221 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { reinterpret_cast<m_type *>(p_self._data._mem)->m_method(*p_args[0], *p_args[1], *p_args[2], *p_args[3], *p_args[4]); }
222 #define VCALL_LOCALMEM5R(m_type, m_method) \
223 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { r_ret = reinterpret_cast<m_type *>(p_self._data._mem)->m_method(*p_args[0], *p_args[1], *p_args[2], *p_args[3], *p_args[4]); }
224
225 // built-in functions of localmem based types
226
227 VCALL_LOCALMEM1R(String, casecmp_to);
228 VCALL_LOCALMEM1R(String, nocasecmp_to);
229 VCALL_LOCALMEM0R(String, length);
230 VCALL_LOCALMEM2R(String, substr);
231 VCALL_LOCALMEM2R(String, find);
232 VCALL_LOCALMEM1R(String, find_last);
233 VCALL_LOCALMEM2R(String, findn);
234 VCALL_LOCALMEM2R(String, rfind);
235 VCALL_LOCALMEM2R(String, rfindn);
236 VCALL_LOCALMEM1R(String, match);
237 VCALL_LOCALMEM1R(String, matchn);
238 VCALL_LOCALMEM1R(String, begins_with);
239 VCALL_LOCALMEM1R(String, ends_with);
240 VCALL_LOCALMEM1R(String, is_subsequence_of);
241 VCALL_LOCALMEM1R(String, is_subsequence_ofi);
242 VCALL_LOCALMEM0R(String, bigrams);
243 VCALL_LOCALMEM1R(String, similarity);
244 VCALL_LOCALMEM2R(String, format);
245 VCALL_LOCALMEM2R(String, replace);
246 VCALL_LOCALMEM2R(String, replacen);
247 VCALL_LOCALMEM2R(String, insert);
248 VCALL_LOCALMEM0R(String, capitalize);
249 VCALL_LOCALMEM2R(String, split);
250 VCALL_LOCALMEM2R(String, split_floats);
251 VCALL_LOCALMEM0R(String, to_upper);
252 VCALL_LOCALMEM0R(String, to_lower);
253 VCALL_LOCALMEM1R(String, left);
254 VCALL_LOCALMEM1R(String, right);
255 VCALL_LOCALMEM2R(String, strip_edges);
256 VCALL_LOCALMEM0R(String, extension);
257 VCALL_LOCALMEM0R(String, basename);
258 VCALL_LOCALMEM1R(String, plus_file);
259 VCALL_LOCALMEM1R(String, ord_at);
260 VCALL_LOCALMEM2(String, erase);
261 VCALL_LOCALMEM0R(String, hash);
262 VCALL_LOCALMEM0R(String, md5_text);
263 VCALL_LOCALMEM0R(String, sha256_text);
264 VCALL_LOCALMEM1R(String, encrypt_text);
265 VCALL_LOCALMEM1R(String, decrypt_text);
266 VCALL_LOCALMEM0R(String, md5_buffer);
267 VCALL_LOCALMEM0R(String, sha256_buffer);
268 VCALL_LOCALMEM0R(String, empty);
269 VCALL_LOCALMEM0R(String, is_abs_path);
270 VCALL_LOCALMEM0R(String, is_rel_path);
271 VCALL_LOCALMEM0R(String, get_base_dir);
272 VCALL_LOCALMEM0R(String, get_file);
273 VCALL_LOCALMEM0R(String, xml_escape);
274 VCALL_LOCALMEM0R(String, xml_unescape);
275 VCALL_LOCALMEM0R(String, c_escape);
276 VCALL_LOCALMEM0R(String, c_unescape);
277 VCALL_LOCALMEM0R(String, json_escape);
278 VCALL_LOCALMEM0R(String, percent_encode);
279 VCALL_LOCALMEM0R(String, percent_decode);
280 VCALL_LOCALMEM0R(String, is_valid_identifier);
281 VCALL_LOCALMEM0R(String, is_valid_integer);
282 VCALL_LOCALMEM0R(String, is_valid_float);
283 VCALL_LOCALMEM0R(String, is_valid_html_color);
284 VCALL_LOCALMEM0R(String, is_valid_ip_address);
285 VCALL_LOCALMEM0R(String, to_int);
286 VCALL_LOCALMEM0R(String, to_float);
287 VCALL_LOCALMEM0R(String, hex_to_int);
288 VCALL_LOCALMEM1R(String, pad_decimals);
289 VCALL_LOCALMEM1R(String, pad_zeros);
290
_call_String_to_ascii_VariantCall291 static void _call_String_to_ascii(Variant &r_ret, Variant &p_self, const Variant **p_args) {
292
293 String *s = reinterpret_cast<String *>(p_self._data._mem);
294 CharString charstr = s->ascii();
295
296 ByteArray retval;
297 size_t len = charstr.length();
298 retval.resize(len);
299 ByteArray::Write w = retval.write();
300 copymem(w.ptr(), charstr.ptr(), len);
301 w = DVector<uint8_t>::Write();
302
303 r_ret = retval;
304 }
305
_call_String_to_utf8_VariantCall306 static void _call_String_to_utf8(Variant &r_ret, Variant &p_self, const Variant **p_args) {
307
308 String *s = reinterpret_cast<String *>(p_self._data._mem);
309 CharString charstr = s->utf8();
310
311 ByteArray retval;
312 size_t len = charstr.length();
313 retval.resize(len);
314 ByteArray::Write w = retval.write();
315 copymem(w.ptr(), charstr.ptr(), len);
316 w = DVector<uint8_t>::Write();
317
318 r_ret = retval;
319 }
320
321 VCALL_LOCALMEM0R(Vector2, normalized);
322 VCALL_LOCALMEM0R(Vector2, length);
323 VCALL_LOCALMEM0R(Vector2, length_squared);
324 VCALL_LOCALMEM1R(Vector2, distance_to);
325 VCALL_LOCALMEM1R(Vector2, distance_squared_to);
326 VCALL_LOCALMEM1R(Vector2, angle_to);
327 VCALL_LOCALMEM1R(Vector2, angle_to_point);
328 VCALL_LOCALMEM2R(Vector2, linear_interpolate);
329 VCALL_LOCALMEM4R(Vector2, cubic_interpolate);
330 VCALL_LOCALMEM1R(Vector2, rotated);
331 VCALL_LOCALMEM0R(Vector2, tangent);
332 VCALL_LOCALMEM0R(Vector2, floor);
333 VCALL_LOCALMEM1R(Vector2, snapped);
334 VCALL_LOCALMEM0R(Vector2, get_aspect);
335 VCALL_LOCALMEM1R(Vector2, dot);
336 VCALL_LOCALMEM1R(Vector2, slide);
337 VCALL_LOCALMEM1R(Vector2, reflect);
338 VCALL_LOCALMEM0R(Vector2, angle);
339 // VCALL_LOCALMEM1R(Vector2,cross);
340 VCALL_LOCALMEM0R(Vector2, abs);
341 VCALL_LOCALMEM1R(Vector2, clamped);
342
343 VCALL_LOCALMEM0R(Rect2, get_area);
344 VCALL_LOCALMEM1R(Rect2, intersects);
345 VCALL_LOCALMEM1R(Rect2, encloses);
346 VCALL_LOCALMEM0R(Rect2, has_no_area);
347 VCALL_LOCALMEM1R(Rect2, clip);
348 VCALL_LOCALMEM1R(Rect2, merge);
349 VCALL_LOCALMEM1R(Rect2, has_point);
350 VCALL_LOCALMEM1R(Rect2, grow);
351 VCALL_LOCALMEM2R(Rect2, grow_margin);
352 VCALL_LOCALMEM4R(Rect2, grow_individual);
353 VCALL_LOCALMEM1R(Rect2, expand);
354
355 VCALL_LOCALMEM0R(Vector3, min_axis);
356 VCALL_LOCALMEM0R(Vector3, max_axis);
357 VCALL_LOCALMEM0R(Vector3, length);
358 VCALL_LOCALMEM0R(Vector3, length_squared);
359 VCALL_LOCALMEM0R(Vector3, normalized);
360 VCALL_LOCALMEM0R(Vector3, inverse);
361 VCALL_LOCALMEM1R(Vector3, snapped);
362 VCALL_LOCALMEM2R(Vector3, rotated);
363 VCALL_LOCALMEM2R(Vector3, linear_interpolate);
364 VCALL_LOCALMEM4R(Vector3, cubic_interpolate);
365 VCALL_LOCALMEM1R(Vector3, dot);
366 VCALL_LOCALMEM1R(Vector3, cross);
367 VCALL_LOCALMEM0R(Vector3, abs);
368 VCALL_LOCALMEM0R(Vector3, floor);
369 VCALL_LOCALMEM0R(Vector3, ceil);
370 VCALL_LOCALMEM1R(Vector3, distance_to);
371 VCALL_LOCALMEM1R(Vector3, distance_squared_to);
372 VCALL_LOCALMEM1R(Vector3, angle_to);
373 VCALL_LOCALMEM1R(Vector3, slide);
374 VCALL_LOCALMEM1R(Vector3, reflect);
375
376 VCALL_LOCALMEM0R(Plane, normalized);
377 VCALL_LOCALMEM0R(Plane, center);
378 VCALL_LOCALMEM0R(Plane, get_any_point);
379 VCALL_LOCALMEM1R(Plane, is_point_over);
380 VCALL_LOCALMEM1R(Plane, distance_to);
381 VCALL_LOCALMEM2R(Plane, has_point);
382 VCALL_LOCALMEM1R(Plane, project);
383
384 //return vector3 if intersected, nil if not
_call_Plane_intersect_3_VariantCall385 static void _call_Plane_intersect_3(Variant &r_ret, Variant &p_self, const Variant **p_args) {
386 Vector3 result;
387 if (reinterpret_cast<Plane *>(p_self._data._mem)->intersect_3(*p_args[0], *p_args[1], &result))
388 r_ret = result;
389 else
390 r_ret = Variant();
391 }
392
_call_Plane_intersects_ray_VariantCall393 static void _call_Plane_intersects_ray(Variant &r_ret, Variant &p_self, const Variant **p_args) {
394 Vector3 result;
395 if (reinterpret_cast<Plane *>(p_self._data._mem)->intersects_ray(*p_args[0], *p_args[1], &result))
396 r_ret = result;
397 else
398 r_ret = Variant();
399 }
400
_call_Plane_intersects_segment_VariantCall401 static void _call_Plane_intersects_segment(Variant &r_ret, Variant &p_self, const Variant **p_args) {
402 Vector3 result;
403 if (reinterpret_cast<Plane *>(p_self._data._mem)->intersects_segment(*p_args[0], *p_args[1], &result))
404 r_ret = result;
405 else
406 r_ret = Variant();
407 }
408
_call_Vector2_floorf_VariantCall409 static void _call_Vector2_floorf(Variant &r_ret, Variant &p_self, const Variant **p_args) {
410 r_ret = reinterpret_cast<Vector2 *>(p_self._data._mem)->floor();
411 };
412
413 VCALL_LOCALMEM0R(Quat, length);
414 VCALL_LOCALMEM0R(Quat, length_squared);
415 VCALL_LOCALMEM0R(Quat, normalized);
416 VCALL_LOCALMEM0R(Quat, inverse);
417 VCALL_LOCALMEM1R(Quat, dot);
418 VCALL_LOCALMEM1R(Quat, xform);
419 VCALL_LOCALMEM2R(Quat, slerp);
420 VCALL_LOCALMEM2R(Quat, slerpni);
421 VCALL_LOCALMEM4R(Quat, cubic_slerp);
422
423 VCALL_LOCALMEM0R(Color, to_32);
424 VCALL_LOCALMEM0R(Color, to_ARGB32);
425 VCALL_LOCALMEM0R(Color, gray);
426 VCALL_LOCALMEM0R(Color, inverted);
427 VCALL_LOCALMEM0R(Color, contrasted);
428 VCALL_LOCALMEM2R(Color, linear_interpolate);
429 VCALL_LOCALMEM1R(Color, blend);
430 VCALL_LOCALMEM1R(Color, to_html);
431
432 VCALL_LOCALMEM0R(RID, get_id);
433
434 VCALL_LOCALMEM0R(NodePath, is_absolute);
435 VCALL_LOCALMEM0R(NodePath, get_name_count);
436 VCALL_LOCALMEM1R(NodePath, get_name);
437 VCALL_LOCALMEM0R(NodePath, get_subname_count);
438 VCALL_LOCALMEM1R(NodePath, get_subname);
439 VCALL_LOCALMEM0R(NodePath, get_property);
440 VCALL_LOCALMEM0R(NodePath, is_empty);
441
442 VCALL_LOCALMEM0R(Dictionary, size);
443 VCALL_LOCALMEM0R(Dictionary, empty);
444 VCALL_LOCALMEM0(Dictionary, clear);
445 VCALL_LOCALMEM1R(Dictionary, has);
446 VCALL_LOCALMEM1R(Dictionary, has_all);
447 VCALL_LOCALMEM1(Dictionary, erase);
448 VCALL_LOCALMEM0R(Dictionary, hash);
449 VCALL_LOCALMEM0R(Dictionary, keys);
450 VCALL_LOCALMEM0R(Dictionary, values);
451 VCALL_LOCALMEM1R(Dictionary, parse_json);
452 VCALL_LOCALMEM0R(Dictionary, to_json);
453
454 VCALL_LOCALMEM2(Array, set);
455 VCALL_LOCALMEM1R(Array, get);
456 VCALL_LOCALMEM0R(Array, size);
457 VCALL_LOCALMEM0R(Array, empty);
458 VCALL_LOCALMEM0(Array, clear);
459 VCALL_LOCALMEM0R(Array, hash);
460 VCALL_LOCALMEM1(Array, push_back);
461 VCALL_LOCALMEM1(Array, push_front);
462 VCALL_LOCALMEM0(Array, pop_back);
463 VCALL_LOCALMEM0(Array, pop_front);
464 VCALL_LOCALMEM1(Array, append);
465 VCALL_LOCALMEM1(Array, resize);
466 VCALL_LOCALMEM2(Array, insert);
467 VCALL_LOCALMEM1(Array, remove);
468 VCALL_LOCALMEM0R(Array, front);
469 VCALL_LOCALMEM0R(Array, back);
470 VCALL_LOCALMEM2R(Array, find);
471 VCALL_LOCALMEM2R(Array, rfind);
472 VCALL_LOCALMEM1R(Array, find_last);
473 VCALL_LOCALMEM1R(Array, count);
474 VCALL_LOCALMEM1R(Array, has);
475 VCALL_LOCALMEM1(Array, erase);
476 VCALL_LOCALMEM0(Array, sort);
477 VCALL_LOCALMEM2(Array, sort_custom);
478 VCALL_LOCALMEM0(Array, invert);
479 VCALL_LOCALMEM0R(Array, is_shared);
480
_call_ByteArray_get_string_from_ascii_VariantCall481 static void _call_ByteArray_get_string_from_ascii(Variant &r_ret, Variant &p_self, const Variant **p_args) {
482
483 ByteArray *ba = reinterpret_cast<ByteArray *>(p_self._data._mem);
484 String s;
485 if (ba->size() >= 0) {
486 ByteArray::Read r = ba->read();
487 CharString cs;
488 cs.resize(ba->size() + 1);
489 copymem(cs.ptr(), r.ptr(), ba->size());
490 cs[ba->size()] = 0;
491
492 s = cs.get_data();
493 }
494 r_ret = s;
495 }
496
_call_ByteArray_get_string_from_utf8_VariantCall497 static void _call_ByteArray_get_string_from_utf8(Variant &r_ret, Variant &p_self, const Variant **p_args) {
498
499 ByteArray *ba = reinterpret_cast<ByteArray *>(p_self._data._mem);
500 String s;
501 if (ba->size() >= 0) {
502 ByteArray::Read r = ba->read();
503 s.parse_utf8((const char *)r.ptr(), ba->size());
504 }
505 r_ret = s;
506 }
507
508 VCALL_LOCALMEM0R(ByteArray, size);
509 VCALL_LOCALMEM2(ByteArray, set);
510 VCALL_LOCALMEM1R(ByteArray, get);
511 VCALL_LOCALMEM1(ByteArray, push_back);
512 VCALL_LOCALMEM1(ByteArray, resize);
513 VCALL_LOCALMEM2R(ByteArray, insert);
514 VCALL_LOCALMEM1(ByteArray, remove);
515 VCALL_LOCALMEM1(ByteArray, append);
516 VCALL_LOCALMEM1(ByteArray, append_array);
517 VCALL_LOCALMEM0(ByteArray, invert);
518
519 VCALL_LOCALMEM0R(IntArray, size);
520 VCALL_LOCALMEM2(IntArray, set);
521 VCALL_LOCALMEM1R(IntArray, get);
522 VCALL_LOCALMEM1(IntArray, push_back);
523 VCALL_LOCALMEM1(IntArray, resize);
524 VCALL_LOCALMEM2R(IntArray, insert);
525 VCALL_LOCALMEM1(IntArray, remove);
526 VCALL_LOCALMEM1(IntArray, append);
527 VCALL_LOCALMEM1(IntArray, append_array);
528 VCALL_LOCALMEM0(IntArray, invert);
529
530 VCALL_LOCALMEM0R(RealArray, size);
531 VCALL_LOCALMEM2(RealArray, set);
532 VCALL_LOCALMEM1R(RealArray, get);
533 VCALL_LOCALMEM1(RealArray, push_back);
534 VCALL_LOCALMEM1(RealArray, resize);
535 VCALL_LOCALMEM2R(RealArray, insert);
536 VCALL_LOCALMEM1(RealArray, remove);
537 VCALL_LOCALMEM1(RealArray, append);
538 VCALL_LOCALMEM1(RealArray, append_array);
539 VCALL_LOCALMEM0(RealArray, invert);
540
541 VCALL_LOCALMEM0R(StringArray, size);
542 VCALL_LOCALMEM2(StringArray, set);
543 VCALL_LOCALMEM1R(StringArray, get);
544 VCALL_LOCALMEM1(StringArray, push_back);
545 VCALL_LOCALMEM1(StringArray, resize);
546 VCALL_LOCALMEM2R(StringArray, insert);
547 VCALL_LOCALMEM1(StringArray, remove);
548 VCALL_LOCALMEM1(StringArray, append);
549 VCALL_LOCALMEM1(StringArray, append_array);
550 VCALL_LOCALMEM0(StringArray, invert);
551
552 VCALL_LOCALMEM0R(Vector2Array, size);
553 VCALL_LOCALMEM2(Vector2Array, set);
554 VCALL_LOCALMEM1R(Vector2Array, get);
555 VCALL_LOCALMEM1(Vector2Array, push_back);
556 VCALL_LOCALMEM1(Vector2Array, resize);
557 VCALL_LOCALMEM2R(Vector2Array, insert);
558 VCALL_LOCALMEM1(Vector2Array, remove);
559 VCALL_LOCALMEM1(Vector2Array, append);
560 VCALL_LOCALMEM1(Vector2Array, append_array);
561 VCALL_LOCALMEM0(Vector2Array, invert);
562
563 VCALL_LOCALMEM0R(Vector3Array, size);
564 VCALL_LOCALMEM2(Vector3Array, set);
565 VCALL_LOCALMEM1R(Vector3Array, get);
566 VCALL_LOCALMEM1(Vector3Array, push_back);
567 VCALL_LOCALMEM1(Vector3Array, resize);
568 VCALL_LOCALMEM2R(Vector3Array, insert);
569 VCALL_LOCALMEM1(Vector3Array, remove);
570 VCALL_LOCALMEM1(Vector3Array, append);
571 VCALL_LOCALMEM1(Vector3Array, append_array);
572 VCALL_LOCALMEM0(Vector3Array, invert);
573
574 VCALL_LOCALMEM0R(ColorArray, size);
575 VCALL_LOCALMEM2(ColorArray, set);
576 VCALL_LOCALMEM1R(ColorArray, get);
577 VCALL_LOCALMEM1(ColorArray, push_back);
578 VCALL_LOCALMEM1(ColorArray, resize);
579 VCALL_LOCALMEM2R(ColorArray, insert);
580 VCALL_LOCALMEM1(ColorArray, remove);
581 VCALL_LOCALMEM1(ColorArray, append);
582 VCALL_LOCALMEM1(ColorArray, append_array);
583 VCALL_LOCALMEM0(ColorArray, invert);
584
585 #define VCALL_PTR0(m_type, m_method) \
586 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { reinterpret_cast<m_type *>(p_self._data._ptr)->m_method(); }
587 #define VCALL_PTR0R(m_type, m_method) \
588 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { r_ret = reinterpret_cast<m_type *>(p_self._data._ptr)->m_method(); }
589 #define VCALL_PTR1(m_type, m_method) \
590 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { reinterpret_cast<m_type *>(p_self._data._ptr)->m_method(*p_args[0]); }
591 #define VCALL_PTR1R(m_type, m_method) \
592 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { r_ret = reinterpret_cast<m_type *>(p_self._data._ptr)->m_method(*p_args[0]); }
593 #define VCALL_PTR2(m_type, m_method) \
594 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { reinterpret_cast<m_type *>(p_self._data._ptr)->m_method(*p_args[0], *p_args[1]); }
595 #define VCALL_PTR2R(m_type, m_method) \
596 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { r_ret = reinterpret_cast<m_type *>(p_self._data._ptr)->m_method(*p_args[0], *p_args[1]); }
597 #define VCALL_PTR3(m_type, m_method) \
598 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { reinterpret_cast<m_type *>(p_self._data._ptr)->m_method(*p_args[0], *p_args[1], *p_args[2]); }
599 #define VCALL_PTR3R(m_type, m_method) \
600 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { r_ret = reinterpret_cast<m_type *>(p_self._data._ptr)->m_method(*p_args[0], *p_args[1], *p_args[2]); }
601 #define VCALL_PTR4(m_type, m_method) \
602 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { reinterpret_cast<m_type *>(p_self._data._ptr)->m_method(*p_args[0], *p_args[1], *p_args[2], *p_args[3]); }
603 #define VCALL_PTR4R(m_type, m_method) \
604 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { r_ret = reinterpret_cast<m_type *>(p_self._data._ptr)->m_method(*p_args[0], *p_args[1], *p_args[2], *p_args[3]); }
605 #define VCALL_PTR5(m_type, m_method) \
606 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { reinterpret_cast<m_type *>(p_self._data._ptr)->m_method(*p_args[0], *p_args[1], *p_args[2], *p_args[3], *p_args[4]); }
607 #define VCALL_PTR5R(m_type, m_method) \
608 static void _call_##m_type##_##m_method(Variant &r_ret, Variant &p_self, const Variant **p_args) { r_ret = reinterpret_cast<m_type *>(p_self._data._ptr)->m_method(*p_args[0], *p_args[1], *p_args[2], *p_args[3], *p_args[4]); }
609
610 VCALL_PTR0R(Image, get_format);
611 VCALL_PTR0R(Image, get_width);
612 VCALL_PTR0R(Image, get_height);
613 VCALL_PTR0R(Image, empty);
614 VCALL_PTR3R(Image, get_pixel);
615 VCALL_PTR4(Image, put_pixel);
616 VCALL_PTR0R(Image, get_used_rect);
617 VCALL_PTR3R(Image, brushed);
618 VCALL_PTR1R(Image, load);
619 VCALL_PTR1R(Image, save_png);
620 VCALL_PTR3(Image, brush_transfer);
621 VCALL_PTR1R(Image, get_rect);
622 VCALL_PTR1R(Image, compressed);
623 VCALL_PTR0R(Image, decompressed);
624 VCALL_PTR3R(Image, resized);
625 VCALL_PTR0R(Image, get_data);
626 VCALL_PTR3(Image, blit_rect);
627 VCALL_PTR4(Image, blit_rect_mask);
628 VCALL_PTR3(Image, blend_rect);
629 VCALL_PTR4(Image, blend_rect_mask);
630 VCALL_PTR1(Image, fill);
631 VCALL_PTR1R(Image, converted);
632 VCALL_PTR0(Image, fix_alpha_edges);
633
634 VCALL_PTR0R(AABB, get_area);
635 VCALL_PTR0R(AABB, has_no_area);
636 VCALL_PTR0R(AABB, has_no_surface);
637 VCALL_PTR1R(AABB, intersects);
638 VCALL_PTR1R(AABB, encloses);
639 VCALL_PTR1R(AABB, merge);
640 VCALL_PTR1R(AABB, intersection);
641 VCALL_PTR1R(AABB, intersects_plane);
642 VCALL_PTR2R(AABB, intersects_segment);
643 VCALL_PTR1R(AABB, has_point);
644 VCALL_PTR1R(AABB, get_support);
645 VCALL_PTR0R(AABB, get_longest_axis);
646 VCALL_PTR0R(AABB, get_longest_axis_index);
647 VCALL_PTR0R(AABB, get_longest_axis_size);
648 VCALL_PTR0R(AABB, get_shortest_axis);
649 VCALL_PTR0R(AABB, get_shortest_axis_index);
650 VCALL_PTR0R(AABB, get_shortest_axis_size);
651 VCALL_PTR1R(AABB, expand);
652 VCALL_PTR1R(AABB, grow);
653 VCALL_PTR1R(AABB, get_endpoint);
654
655 VCALL_PTR0R(Matrix32, inverse);
656 VCALL_PTR0R(Matrix32, affine_inverse);
657 VCALL_PTR0R(Matrix32, get_rotation);
658 VCALL_PTR0R(Matrix32, get_origin);
659 VCALL_PTR0R(Matrix32, get_scale);
660 VCALL_PTR0R(Matrix32, orthonormalized);
661 VCALL_PTR1R(Matrix32, rotated);
662 VCALL_PTR1R(Matrix32, scaled);
663 VCALL_PTR1R(Matrix32, translated);
664 VCALL_PTR2R(Matrix32, interpolate_with);
665
_call_Matrix32_xform_VariantCall666 static void _call_Matrix32_xform(Variant &r_ret, Variant &p_self, const Variant **p_args) {
667
668 switch (p_args[0]->type) {
669
670 case Variant::VECTOR2: r_ret = reinterpret_cast<Matrix32 *>(p_self._data._ptr)->xform(p_args[0]->operator Vector2()); return;
671 case Variant::RECT2: r_ret = reinterpret_cast<Matrix32 *>(p_self._data._ptr)->xform(p_args[0]->operator Rect2()); return;
672 default: r_ret = Variant();
673 }
674 }
675
_call_Matrix32_xform_inv_VariantCall676 static void _call_Matrix32_xform_inv(Variant &r_ret, Variant &p_self, const Variant **p_args) {
677
678 switch (p_args[0]->type) {
679
680 case Variant::VECTOR2: r_ret = reinterpret_cast<Matrix32 *>(p_self._data._ptr)->xform_inv(p_args[0]->operator Vector2()); return;
681 case Variant::RECT2: r_ret = reinterpret_cast<Matrix32 *>(p_self._data._ptr)->xform_inv(p_args[0]->operator Rect2()); return;
682 default: r_ret = Variant();
683 }
684 }
685
_call_Matrix32_basis_xform_VariantCall686 static void _call_Matrix32_basis_xform(Variant &r_ret, Variant &p_self, const Variant **p_args) {
687
688 switch (p_args[0]->type) {
689
690 case Variant::VECTOR2: r_ret = reinterpret_cast<Matrix32 *>(p_self._data._ptr)->basis_xform(p_args[0]->operator Vector2()); return;
691 default: r_ret = Variant();
692 }
693 }
694
_call_Matrix32_basis_xform_inv_VariantCall695 static void _call_Matrix32_basis_xform_inv(Variant &r_ret, Variant &p_self, const Variant **p_args) {
696
697 switch (p_args[0]->type) {
698
699 case Variant::VECTOR2: r_ret = reinterpret_cast<Matrix32 *>(p_self._data._ptr)->basis_xform_inv(p_args[0]->operator Vector2()); return;
700 default: r_ret = Variant();
701 }
702 }
703
704 VCALL_PTR0R(Matrix3, inverse);
705 VCALL_PTR0R(Matrix3, transposed);
706 VCALL_PTR0R(Matrix3, determinant);
707 VCALL_PTR2R(Matrix3, rotated);
708 VCALL_PTR1R(Matrix3, scaled);
709 VCALL_PTR0R(Matrix3, get_scale);
710 VCALL_PTR0R(Matrix3, get_euler);
711 VCALL_PTR1R(Matrix3, tdotx);
712 VCALL_PTR1R(Matrix3, tdoty);
713 VCALL_PTR1R(Matrix3, tdotz);
714 VCALL_PTR1R(Matrix3, xform);
715 VCALL_PTR1R(Matrix3, xform_inv);
716 VCALL_PTR0R(Matrix3, get_orthogonal_index);
717 VCALL_PTR0R(Matrix3, orthonormalized);
718
719 VCALL_PTR0R(Transform, inverse);
720 VCALL_PTR0R(Transform, affine_inverse);
721 VCALL_PTR2R(Transform, rotated);
722 VCALL_PTR1R(Transform, scaled);
723 VCALL_PTR1R(Transform, translated);
724 VCALL_PTR0R(Transform, orthonormalized);
725 VCALL_PTR2R(Transform, looking_at);
726
_call_Transform_xform_VariantCall727 static void _call_Transform_xform(Variant &r_ret, Variant &p_self, const Variant **p_args) {
728
729 switch (p_args[0]->type) {
730
731 case Variant::VECTOR3: r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform(p_args[0]->operator Vector3()); return;
732 case Variant::PLANE: r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform(p_args[0]->operator Plane()); return;
733 case Variant::_AABB: r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform(p_args[0]->operator AABB()); return;
734 default: r_ret = Variant();
735 }
736 }
737
_call_Transform_xform_inv_VariantCall738 static void _call_Transform_xform_inv(Variant &r_ret, Variant &p_self, const Variant **p_args) {
739
740 switch (p_args[0]->type) {
741
742 case Variant::VECTOR3: r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform_inv(p_args[0]->operator Vector3()); return;
743 case Variant::PLANE: r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform_inv(p_args[0]->operator Plane()); return;
744 case Variant::_AABB: r_ret = reinterpret_cast<Transform *>(p_self._data._ptr)->xform_inv(p_args[0]->operator AABB()); return;
745 default: r_ret = Variant();
746 }
747 }
748
749 /*
750 VCALL_PTR0( Transform, invert );
751 VCALL_PTR0( Transform, affine_invert );
752 VCALL_PTR2( Transform, rotate );
753 VCALL_PTR1( Transform, scale );
754 VCALL_PTR1( Transform, translate );
755 VCALL_PTR0( Transform, orthonormalize ); */
756
757 VCALL_PTR0R(InputEvent, is_pressed);
758 VCALL_PTR1R(InputEvent, is_action);
759 VCALL_PTR1R(InputEvent, is_action_pressed);
760 VCALL_PTR1R(InputEvent, is_action_released);
761 VCALL_PTR0R(InputEvent, is_echo);
762 VCALL_PTR2(InputEvent, set_as_action);
763
764 struct ConstructData {
765
766 int arg_count;
767 Vector<Variant::Type> arg_types;
768 Vector<String> arg_names;
769 VariantConstructFunc func;
770 };
771
772 struct ConstructFunc {
773
774 List<ConstructData> constructors;
775 };
776
777 static ConstructFunc *construct_funcs;
778
Vector2_init1_VariantCall779 static void Vector2_init1(Variant &r_ret, const Variant **p_args) {
780
781 r_ret = Vector2(*p_args[0], *p_args[1]);
782 }
783
Rect2_init1_VariantCall784 static void Rect2_init1(Variant &r_ret, const Variant **p_args) {
785
786 r_ret = Rect2(*p_args[0], *p_args[1]);
787 }
788
Rect2_init2_VariantCall789 static void Rect2_init2(Variant &r_ret, const Variant **p_args) {
790
791 r_ret = Rect2(*p_args[0], *p_args[1], *p_args[2], *p_args[3]);
792 }
793
Matrix32_init2_VariantCall794 static void Matrix32_init2(Variant &r_ret, const Variant **p_args) {
795
796 Matrix32 m(*p_args[0], *p_args[1]);
797 r_ret = m;
798 }
799
Matrix32_init3_VariantCall800 static void Matrix32_init3(Variant &r_ret, const Variant **p_args) {
801
802 Matrix32 m;
803 m[0] = *p_args[0];
804 m[1] = *p_args[1];
805 m[2] = *p_args[2];
806 r_ret = m;
807 }
808
Vector3_init1_VariantCall809 static void Vector3_init1(Variant &r_ret, const Variant **p_args) {
810
811 r_ret = Vector3(*p_args[0], *p_args[1], *p_args[2]);
812 }
813
Plane_init1_VariantCall814 static void Plane_init1(Variant &r_ret, const Variant **p_args) {
815
816 r_ret = Plane(*p_args[0], *p_args[1], *p_args[2], *p_args[3]);
817 }
818
Plane_init2_VariantCall819 static void Plane_init2(Variant &r_ret, const Variant **p_args) {
820
821 r_ret = Plane(*p_args[0], *p_args[1], *p_args[2]);
822 }
823
Plane_init3_VariantCall824 static void Plane_init3(Variant &r_ret, const Variant **p_args) {
825
826 r_ret = Plane(p_args[0]->operator Vector3(), p_args[1]->operator real_t());
827 }
Plane_init4_VariantCall828 static void Plane_init4(Variant &r_ret, const Variant **p_args) {
829
830 r_ret = Plane(p_args[0]->operator Vector3(), p_args[1]->operator Vector3());
831 }
832
Quat_init1_VariantCall833 static void Quat_init1(Variant &r_ret, const Variant **p_args) {
834
835 r_ret = Quat(*p_args[0], *p_args[1], *p_args[2], *p_args[3]);
836 }
837
Quat_init2_VariantCall838 static void Quat_init2(Variant &r_ret, const Variant **p_args) {
839
840 r_ret = Quat(((Vector3)(*p_args[0])), ((float)(*p_args[1])));
841 }
842
Color_init1_VariantCall843 static void Color_init1(Variant &r_ret, const Variant **p_args) {
844
845 r_ret = Color(*p_args[0], *p_args[1], *p_args[2], *p_args[3]);
846 }
847
Color_init2_VariantCall848 static void Color_init2(Variant &r_ret, const Variant **p_args) {
849
850 r_ret = Color(*p_args[0], *p_args[1], *p_args[2]);
851 }
852
Color_init3_VariantCall853 static void Color_init3(Variant &r_ret, const Variant **p_args) {
854
855 r_ret = Color::html(*p_args[0]);
856 }
857
Color_init4_VariantCall858 static void Color_init4(Variant &r_ret, const Variant **p_args) {
859
860 r_ret = Color::hex(*p_args[0]);
861 }
862
AABB_init1_VariantCall863 static void AABB_init1(Variant &r_ret, const Variant **p_args) {
864
865 r_ret = AABB(*p_args[0], *p_args[1]);
866 }
867
Matrix3_init1_VariantCall868 static void Matrix3_init1(Variant &r_ret, const Variant **p_args) {
869
870 Matrix3 m;
871 m.set_axis(0, *p_args[0]);
872 m.set_axis(1, *p_args[1]);
873 m.set_axis(2, *p_args[2]);
874 r_ret = m;
875 }
876
Matrix3_init2_VariantCall877 static void Matrix3_init2(Variant &r_ret, const Variant **p_args) {
878
879 r_ret = Matrix3(p_args[0]->operator Vector3(), p_args[1]->operator real_t());
880 }
881
Transform_init1_VariantCall882 static void Transform_init1(Variant &r_ret, const Variant **p_args) {
883
884 Transform t;
885 t.basis.set_axis(0, *p_args[0]);
886 t.basis.set_axis(1, *p_args[1]);
887 t.basis.set_axis(2, *p_args[2]);
888 t.origin = *p_args[3];
889 r_ret = t;
890 }
891
Transform_init2_VariantCall892 static void Transform_init2(Variant &r_ret, const Variant **p_args) {
893
894 r_ret = Transform(p_args[0]->operator Matrix3(), p_args[1]->operator Vector3());
895 }
896
Image_init1_VariantCall897 static void Image_init1(Variant &r_ret, const Variant **p_args) {
898
899 r_ret = Image(*p_args[0], *p_args[1], *p_args[2], Image::Format(p_args[3]->operator int()));
900 }
901
add_constructor_VariantCall902 static void add_constructor(VariantConstructFunc p_func, const Variant::Type p_type,
903 const String &p_name1 = "", const Variant::Type p_type1 = Variant::NIL,
904 const String &p_name2 = "", const Variant::Type p_type2 = Variant::NIL,
905 const String &p_name3 = "", const Variant::Type p_type3 = Variant::NIL,
906 const String &p_name4 = "", const Variant::Type p_type4 = Variant::NIL) {
907
908 ConstructData cd;
909 cd.func = p_func;
910 cd.arg_count = 0;
911
912 if (p_name1 == "")
913 goto end;
914 cd.arg_count++;
915 cd.arg_names.push_back(p_name1);
916 cd.arg_types.push_back(p_type1);
917
918 if (p_name2 == "")
919 goto end;
920 cd.arg_count++;
921 cd.arg_names.push_back(p_name2);
922 cd.arg_types.push_back(p_type2);
923
924 if (p_name3 == "")
925 goto end;
926 cd.arg_count++;
927 cd.arg_names.push_back(p_name3);
928 cd.arg_types.push_back(p_type3);
929
930 if (p_name4 == "")
931 goto end;
932 cd.arg_count++;
933 cd.arg_names.push_back(p_name4);
934 cd.arg_types.push_back(p_type4);
935
936 end:
937
938 construct_funcs[p_type].constructors.push_back(cd);
939 }
940
941 struct ConstantData {
942
943 Map<StringName, int> value;
944 #ifdef DEBUG_ENABLED
945 List<StringName> value_ordered;
946 #endif
947 };
948
949 static ConstantData *constant_data;
950
add_constant_VariantCall951 static void add_constant(int p_type, StringName p_constant_name, int p_constant_value) {
952
953 constant_data[p_type].value[p_constant_name] = p_constant_value;
954 #ifdef DEBUG_ENABLED
955 constant_data[p_type].value_ordered.push_back(p_constant_name);
956 #endif
957 }
958 };
959
960 _VariantCall::TypeFunc *_VariantCall::type_funcs = NULL;
961 _VariantCall::ConstructFunc *_VariantCall::construct_funcs = NULL;
962 _VariantCall::ConstantData *_VariantCall::constant_data = NULL;
963
call(const StringName & p_method,const Variant ** p_args,int p_argcount,CallError & r_error)964 Variant Variant::call(const StringName &p_method, const Variant **p_args, int p_argcount, CallError &r_error) {
965
966 Variant ret;
967 call_ptr(p_method, p_args, p_argcount, &ret, r_error);
968 return ret;
969 }
970
call_ptr(const StringName & p_method,const Variant ** p_args,int p_argcount,Variant * r_ret,CallError & r_error)971 void Variant::call_ptr(const StringName &p_method, const Variant **p_args, int p_argcount, Variant *r_ret, CallError &r_error) {
972 Variant ret;
973
974 if (type == Variant::OBJECT) {
975 //call object
976 Object *obj = _get_obj().obj;
977 if (!obj) {
978 r_error.error = CallError::CALL_ERROR_INSTANCE_IS_NULL;
979 return;
980 }
981 #ifdef DEBUG_ENABLED
982 if (ScriptDebugger::get_singleton() && _get_obj().ref.is_null()) {
983 //only if debugging!
984 if (!ObjectDB::instance_validate(obj)) {
985 r_error.error = CallError::CALL_ERROR_INSTANCE_IS_NULL;
986 return;
987 }
988 }
989
990 #endif
991 ret = _get_obj().obj->call(p_method, p_args, p_argcount, r_error);
992
993 //else if (type==Variant::METHOD) {
994
995 } else {
996
997 r_error.error = Variant::CallError::CALL_OK;
998
999 Map<StringName, _VariantCall::FuncData>::Element *E = _VariantCall::type_funcs[type].functions.find(p_method);
1000 #ifdef DEBUG_ENABLED
1001 if (!E) {
1002 r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
1003 return;
1004 }
1005 #endif
1006 _VariantCall::FuncData &funcdata = E->get();
1007 funcdata.call(ret, *this, p_args, p_argcount, r_error);
1008 }
1009
1010 if (r_error.error == Variant::CallError::CALL_OK && r_ret)
1011 *r_ret = ret;
1012 }
1013
1014 #define VCALL(m_type, m_method) _VariantCall::_call_##m_type##_##m_method
1015
construct(const Variant::Type p_type,const Variant ** p_args,int p_argcount,CallError & r_error,bool p_strict)1016 Variant Variant::construct(const Variant::Type p_type, const Variant **p_args, int p_argcount, CallError &r_error, bool p_strict) {
1017
1018 r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
1019 ERR_FAIL_INDEX_V(p_type, VARIANT_MAX, Variant());
1020
1021 r_error.error = Variant::CallError::CALL_OK;
1022 if (p_argcount == 0) { //generic construct
1023
1024 switch (p_type) {
1025 case NIL:
1026 return Variant();
1027
1028 // atomic types
1029 case BOOL: return Variant(false);
1030 case INT: return 0;
1031 case REAL: return 0.0f;
1032 case STRING:
1033 return String();
1034
1035 // math types
1036 case VECTOR2:
1037 return Vector2(); // 5
1038 case RECT2: return Rect2();
1039 case VECTOR3: return Vector3();
1040 case MATRIX32: return Matrix32();
1041 case PLANE: return Plane();
1042 case QUAT: return Quat();
1043 case _AABB:
1044 return AABB(); //sorry naming convention fail :( not like it's used often // 10
1045 case MATRIX3: return Matrix3();
1046 case TRANSFORM:
1047 return Transform();
1048
1049 // misc types
1050 case COLOR: return Color();
1051 case IMAGE: return Image();
1052 case NODE_PATH:
1053 return NodePath(); // 15
1054 case _RID: return RID();
1055 case OBJECT: return (Object *)NULL;
1056 case INPUT_EVENT: return InputEvent();
1057 case DICTIONARY: return Dictionary();
1058 case ARRAY:
1059 return Array(); // 20
1060 case RAW_ARRAY: return ByteArray();
1061 case INT_ARRAY: return IntArray();
1062 case REAL_ARRAY: return RealArray();
1063 case STRING_ARRAY: return StringArray();
1064 case VECTOR2_ARRAY:
1065 return Vector2Array(); // 25
1066 case VECTOR3_ARRAY:
1067 return Vector3Array(); // 25
1068 case COLOR_ARRAY: return ColorArray();
1069 default: return Variant();
1070 }
1071
1072 } else if (p_argcount > 1) {
1073
1074 _VariantCall::ConstructFunc &c = _VariantCall::construct_funcs[p_type];
1075
1076 for (List<_VariantCall::ConstructData>::Element *E = c.constructors.front(); E; E = E->next()) {
1077 const _VariantCall::ConstructData &cd = E->get();
1078
1079 if (cd.arg_count != p_argcount)
1080 continue;
1081
1082 //validate parameters
1083 for (int i = 0; i < cd.arg_count; i++) {
1084 if (!Variant::can_convert(p_args[i]->type, cd.arg_types[i])) {
1085 r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; //no such constructor
1086 r_error.argument = i;
1087 r_error.expected = cd.arg_types[i];
1088 return Variant();
1089 }
1090 }
1091
1092 Variant v;
1093 cd.func(v, p_args);
1094 return v;
1095 }
1096
1097 } else if (p_argcount == 1 && p_args[0]->type == p_type) {
1098 return *p_args[0]; //copy construct
1099 } else if (p_argcount == 1 && (!p_strict || Variant::can_convert(p_args[0]->type, p_type))) {
1100 //near match construct
1101
1102 switch (p_type) {
1103 case NIL: {
1104
1105 return Variant();
1106 } break;
1107 case BOOL: {
1108 return Variant(bool(*p_args[0]));
1109 }
1110 case INT: {
1111 return (int(*p_args[0]));
1112 }
1113 case REAL: {
1114 return real_t(*p_args[0]);
1115 }
1116 case STRING: {
1117 return String(*p_args[0]);
1118 }
1119 case VECTOR2: {
1120 return Vector2(*p_args[0]);
1121 }
1122 case RECT2: return (Rect2(*p_args[0]));
1123 case VECTOR3: return (Vector3(*p_args[0]));
1124 case PLANE: return (Plane(*p_args[0]));
1125 case QUAT: return (Quat(*p_args[0]));
1126 case _AABB:
1127 return (AABB(*p_args[0])); //sorry naming convention fail :( not like it's used often // 10
1128 case MATRIX3: return (Matrix3(p_args[0]->operator Matrix3()));
1129 case TRANSFORM:
1130 return (Transform(p_args[0]->operator Transform()));
1131
1132 // misc types
1133 case COLOR: return p_args[0]->type == Variant::STRING ? Color::html(*p_args[0]) : Color::hex(*p_args[0]);
1134 case IMAGE: return (Image(*p_args[0]));
1135 case NODE_PATH:
1136 return (NodePath(p_args[0]->operator NodePath())); // 15
1137 case _RID: return (RID(*p_args[0]));
1138 case OBJECT: return ((Object *)(p_args[0]->operator Object *()));
1139 case INPUT_EVENT: return (InputEvent(*p_args[0]));
1140 case DICTIONARY: return p_args[0]->operator Dictionary();
1141 case ARRAY:
1142 return p_args[0]->operator Array(); // 20
1143
1144 // arrays
1145 case RAW_ARRAY: return (ByteArray(*p_args[0]));
1146 case INT_ARRAY: return (IntArray(*p_args[0]));
1147 case REAL_ARRAY: return (RealArray(*p_args[0]));
1148 case STRING_ARRAY: return (StringArray(*p_args[0]));
1149 case VECTOR2_ARRAY:
1150 return (Vector2Array(*p_args[0])); // 25
1151 case VECTOR3_ARRAY:
1152 return (Vector3Array(*p_args[0])); // 25
1153 case COLOR_ARRAY: return (ColorArray(*p_args[0]));
1154 default: return Variant();
1155 }
1156 }
1157 r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD; //no such constructor
1158 return Variant();
1159 }
1160
has_method(const StringName & p_method) const1161 bool Variant::has_method(const StringName &p_method) const {
1162
1163 if (type == OBJECT) {
1164 Object *obj = operator Object *();
1165 if (!obj)
1166 return false;
1167 #ifdef DEBUG_ENABLED
1168 if (ScriptDebugger::get_singleton()) {
1169 if (ObjectDB::instance_validate(obj)) {
1170 #endif
1171 return obj->has_method(p_method);
1172 #ifdef DEBUG_ENABLED
1173 }
1174 }
1175 #endif
1176 }
1177
1178 const _VariantCall::TypeFunc &fd = _VariantCall::type_funcs[type];
1179 return fd.functions.has(p_method);
1180 }
1181
get_method_list(List<MethodInfo> * p_list) const1182 void Variant::get_method_list(List<MethodInfo> *p_list) const {
1183
1184 const _VariantCall::TypeFunc &fd = _VariantCall::type_funcs[type];
1185
1186 for (const Map<StringName, _VariantCall::FuncData>::Element *E = fd.functions.front(); E; E = E->next()) {
1187
1188 const _VariantCall::FuncData &fd = E->get();
1189
1190 MethodInfo mi;
1191 mi.name = E->key();
1192
1193 for (int i = 0; i < fd.arg_types.size(); i++) {
1194
1195 PropertyInfo pi;
1196 pi.type = fd.arg_types[i];
1197 #ifdef DEBUG_ENABLED
1198 pi.name = fd.arg_names[i];
1199 #endif
1200 mi.arguments.push_back(pi);
1201 }
1202
1203 mi.default_arguments = fd.default_args;
1204 PropertyInfo ret;
1205 #ifdef DEBUG_ENABLED
1206 ret.type = fd.return_type;
1207 if (fd.returns)
1208 ret.name = "ret";
1209 mi.return_val = ret;
1210 #endif
1211
1212 p_list->push_back(mi);
1213 }
1214 }
1215
get_constructor_list(Variant::Type p_type,List<MethodInfo> * p_list)1216 void Variant::get_constructor_list(Variant::Type p_type, List<MethodInfo> *p_list) {
1217
1218 ERR_FAIL_INDEX(p_type, VARIANT_MAX);
1219
1220 //custom constructors
1221 for (const List<_VariantCall::ConstructData>::Element *E = _VariantCall::construct_funcs[p_type].constructors.front(); E; E = E->next()) {
1222
1223 const _VariantCall::ConstructData &cd = E->get();
1224 MethodInfo mi;
1225 mi.name = Variant::get_type_name(p_type);
1226 mi.return_val.type = p_type;
1227 for (int i = 0; i < cd.arg_count; i++) {
1228
1229 PropertyInfo pi;
1230 pi.name = cd.arg_names[i];
1231 pi.type = cd.arg_types[i];
1232 mi.arguments.push_back(pi);
1233 }
1234 p_list->push_back(mi);
1235 }
1236 //default constructors
1237 for (int i = 0; i < VARIANT_MAX; i++) {
1238 if (i == p_type)
1239 continue;
1240 if (!Variant::can_convert(Variant::Type(i), p_type))
1241 continue;
1242
1243 MethodInfo mi;
1244 mi.name = Variant::get_type_name(p_type);
1245 PropertyInfo pi;
1246 pi.name = "from";
1247 pi.type = Variant::Type(i);
1248 mi.arguments.push_back(pi);
1249 mi.return_val.type = p_type;
1250 p_list->push_back(mi);
1251 }
1252 }
1253
get_numeric_constants_for_type(Variant::Type p_type,List<StringName> * p_constants)1254 void Variant::get_numeric_constants_for_type(Variant::Type p_type, List<StringName> *p_constants) {
1255
1256 ERR_FAIL_INDEX(p_type, Variant::VARIANT_MAX);
1257
1258 _VariantCall::ConstantData &cd = _VariantCall::constant_data[p_type];
1259
1260 #ifdef DEBUG_ENABLED
1261 for (List<StringName>::Element *E = cd.value_ordered.front(); E; E = E->next()) {
1262
1263 p_constants->push_back(E->get());
1264 #else
1265 for (Map<StringName, int>::Element *E = cd.value.front(); E; E = E->next()) {
1266
1267 p_constants->push_back(E->key());
1268 #endif
1269 }
1270 }
1271
1272 bool Variant::has_numeric_constant(Variant::Type p_type, const StringName &p_value) {
1273
1274 ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
1275 _VariantCall::ConstantData &cd = _VariantCall::constant_data[p_type];
1276 return cd.value.has(p_value);
1277 }
1278
1279 int Variant::get_numeric_constant_value(Variant::Type p_type, const StringName &p_value) {
1280
1281 ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, 0);
1282 _VariantCall::ConstantData &cd = _VariantCall::constant_data[p_type];
1283
1284 Map<StringName, int>::Element *E = cd.value.find(p_value);
1285 ERR_FAIL_COND_V(!E, 0);
1286 return E->get();
1287 }
1288
1289 void register_variant_methods() {
1290
1291 _VariantCall::type_funcs = memnew_arr(_VariantCall::TypeFunc, Variant::VARIANT_MAX);
1292
1293 _VariantCall::construct_funcs = memnew_arr(_VariantCall::ConstructFunc, Variant::VARIANT_MAX);
1294 _VariantCall::constant_data = memnew_arr(_VariantCall::ConstantData, Variant::VARIANT_MAX);
1295
1296 #define ADDFUNC0(m_vtype, m_ret, m_class, m_method, m_defarg) \
1297 _VariantCall::addfunc(Variant::m_vtype, Variant::m_ret, _SCS(#m_method), VCALL(m_class, m_method), m_defarg);
1298 #define ADDFUNC1(m_vtype, m_ret, m_class, m_method, m_arg1, m_argname1, m_defarg) \
1299 _VariantCall::addfunc(Variant::m_vtype, Variant::m_ret, _SCS(#m_method), VCALL(m_class, m_method), m_defarg, _VariantCall::Arg(Variant::m_arg1, _SCS(m_argname1)));
1300 #define ADDFUNC2(m_vtype, m_ret, m_class, m_method, m_arg1, m_argname1, m_arg2, m_argname2, m_defarg) \
1301 _VariantCall::addfunc(Variant::m_vtype, Variant::m_ret, _SCS(#m_method), VCALL(m_class, m_method), m_defarg, _VariantCall::Arg(Variant::m_arg1, _SCS(m_argname1)), _VariantCall::Arg(Variant::m_arg2, _SCS(m_argname2)));
1302 #define ADDFUNC3(m_vtype, m_ret, m_class, m_method, m_arg1, m_argname1, m_arg2, m_argname2, m_arg3, m_argname3, m_defarg) \
1303 _VariantCall::addfunc(Variant::m_vtype, Variant::m_ret, _SCS(#m_method), VCALL(m_class, m_method), m_defarg, _VariantCall::Arg(Variant::m_arg1, _SCS(m_argname1)), _VariantCall::Arg(Variant::m_arg2, _SCS(m_argname2)), _VariantCall::Arg(Variant::m_arg3, _SCS(m_argname3)));
1304 #define ADDFUNC4(m_vtype, m_ret, m_class, m_method, m_arg1, m_argname1, m_arg2, m_argname2, m_arg3, m_argname3, m_arg4, m_argname4, m_defarg) \
1305 _VariantCall::addfunc(Variant::m_vtype, Variant::m_ret, _SCS(#m_method), VCALL(m_class, m_method), m_defarg, _VariantCall::Arg(Variant::m_arg1, _SCS(m_argname1)), _VariantCall::Arg(Variant::m_arg2, _SCS(m_argname2)), _VariantCall::Arg(Variant::m_arg3, _SCS(m_argname3)), _VariantCall::Arg(Variant::m_arg4, _SCS(m_argname4)));
1306
1307 /* STRING */
1308 ADDFUNC1(STRING, INT, String, casecmp_to, STRING, "to", varray());
1309 ADDFUNC1(STRING, INT, String, nocasecmp_to, STRING, "to", varray());
1310 ADDFUNC0(STRING, INT, String, length, varray());
1311 ADDFUNC2(STRING, STRING, String, substr, INT, "from", INT, "len", varray());
1312
1313 ADDFUNC2(STRING, INT, String, find, STRING, "what", INT, "from", varray(0));
1314
1315 ADDFUNC1(STRING, INT, String, find_last, STRING, "what", varray());
1316 ADDFUNC2(STRING, INT, String, findn, STRING, "what", INT, "from", varray(0));
1317 ADDFUNC2(STRING, INT, String, rfind, STRING, "what", INT, "from", varray(-1));
1318 ADDFUNC2(STRING, INT, String, rfindn, STRING, "what", INT, "from", varray(-1));
1319 ADDFUNC1(STRING, BOOL, String, match, STRING, "expr", varray());
1320 ADDFUNC1(STRING, BOOL, String, matchn, STRING, "expr", varray());
1321 ADDFUNC1(STRING, BOOL, String, begins_with, STRING, "text", varray());
1322 ADDFUNC1(STRING, BOOL, String, ends_with, STRING, "text", varray());
1323 ADDFUNC1(STRING, BOOL, String, is_subsequence_of, STRING, "text", varray());
1324 ADDFUNC1(STRING, BOOL, String, is_subsequence_ofi, STRING, "text", varray());
1325 ADDFUNC0(STRING, STRING_ARRAY, String, bigrams, varray());
1326 ADDFUNC1(STRING, REAL, String, similarity, STRING, "text", varray());
1327
1328 ADDFUNC2(STRING, STRING, String, format, NIL, "values", STRING, "placeholder", varray("{_}"));
1329 ADDFUNC2(STRING, STRING, String, replace, STRING, "what", STRING, "forwhat", varray());
1330 ADDFUNC2(STRING, STRING, String, replacen, STRING, "what", STRING, "forwhat", varray());
1331 ADDFUNC2(STRING, STRING, String, insert, INT, "pos", STRING, "what", varray());
1332 ADDFUNC0(STRING, STRING, String, capitalize, varray());
1333 ADDFUNC2(STRING, STRING_ARRAY, String, split, STRING, "divisor", BOOL, "allow_empty", varray(true));
1334 ADDFUNC2(STRING, REAL_ARRAY, String, split_floats, STRING, "divisor", BOOL, "allow_empty", varray(true));
1335
1336 ADDFUNC0(STRING, STRING, String, to_upper, varray());
1337 ADDFUNC0(STRING, STRING, String, to_lower, varray());
1338
1339 ADDFUNC1(STRING, STRING, String, left, INT, "pos", varray());
1340 ADDFUNC1(STRING, STRING, String, right, INT, "pos", varray());
1341 ADDFUNC2(STRING, STRING, String, strip_edges, BOOL, "left", BOOL, "right", varray(true, true));
1342 ADDFUNC0(STRING, STRING, String, extension, varray());
1343 ADDFUNC0(STRING, STRING, String, basename, varray());
1344 ADDFUNC1(STRING, STRING, String, plus_file, STRING, "file", varray());
1345 ADDFUNC1(STRING, INT, String, ord_at, INT, "at", varray());
1346 ADDFUNC2(STRING, NIL, String, erase, INT, "pos", INT, "chars", varray());
1347 ADDFUNC0(STRING, INT, String, hash, varray());
1348 ADDFUNC0(STRING, STRING, String, md5_text, varray());
1349 ADDFUNC0(STRING, STRING, String, sha256_text, varray());
1350 ADDFUNC1(STRING, STRING, String, encrypt_text, STRING, "key", varray());
1351 ADDFUNC1(STRING, STRING, String, decrypt_text, STRING, "key", varray());
1352 ADDFUNC0(STRING, RAW_ARRAY, String, md5_buffer, varray());
1353 ADDFUNC0(STRING, RAW_ARRAY, String, sha256_buffer, varray());
1354 ADDFUNC0(STRING, BOOL, String, empty, varray());
1355 ADDFUNC0(STRING, BOOL, String, is_abs_path, varray());
1356 ADDFUNC0(STRING, BOOL, String, is_rel_path, varray());
1357 ADDFUNC0(STRING, STRING, String, get_base_dir, varray());
1358 ADDFUNC0(STRING, STRING, String, get_file, varray());
1359 ADDFUNC0(STRING, STRING, String, xml_escape, varray());
1360 ADDFUNC0(STRING, STRING, String, xml_unescape, varray());
1361 ADDFUNC0(STRING, STRING, String, c_escape, varray());
1362 ADDFUNC0(STRING, STRING, String, c_unescape, varray());
1363 ADDFUNC0(STRING, STRING, String, json_escape, varray());
1364 ADDFUNC0(STRING, STRING, String, percent_encode, varray());
1365 ADDFUNC0(STRING, STRING, String, percent_decode, varray());
1366 ADDFUNC0(STRING, BOOL, String, is_valid_identifier, varray());
1367 ADDFUNC0(STRING, BOOL, String, is_valid_integer, varray());
1368 ADDFUNC0(STRING, BOOL, String, is_valid_float, varray());
1369 ADDFUNC0(STRING, BOOL, String, is_valid_html_color, varray());
1370 ADDFUNC0(STRING, BOOL, String, is_valid_ip_address, varray());
1371 ADDFUNC0(STRING, INT, String, to_int, varray());
1372 ADDFUNC0(STRING, REAL, String, to_float, varray());
1373 ADDFUNC0(STRING, INT, String, hex_to_int, varray());
1374 ADDFUNC1(STRING, STRING, String, pad_decimals, INT, "digits", varray());
1375 ADDFUNC1(STRING, STRING, String, pad_zeros, INT, "digits", varray());
1376
1377 ADDFUNC0(STRING, RAW_ARRAY, String, to_ascii, varray());
1378 ADDFUNC0(STRING, RAW_ARRAY, String, to_utf8, varray());
1379
1380 ADDFUNC0(VECTOR2, VECTOR2, Vector2, normalized, varray());
1381 ADDFUNC0(VECTOR2, REAL, Vector2, length, varray());
1382 ADDFUNC0(VECTOR2, REAL, Vector2, angle, varray());
1383 ADDFUNC0(VECTOR2, REAL, Vector2, length_squared, varray());
1384 ADDFUNC1(VECTOR2, REAL, Vector2, distance_to, VECTOR2, "to", varray());
1385 ADDFUNC1(VECTOR2, REAL, Vector2, distance_squared_to, VECTOR2, "to", varray());
1386 ADDFUNC1(VECTOR2, REAL, Vector2, angle_to, VECTOR2, "to", varray());
1387 ADDFUNC1(VECTOR2, REAL, Vector2, angle_to_point, VECTOR2, "to", varray());
1388 ADDFUNC2(VECTOR2, VECTOR2, Vector2, linear_interpolate, VECTOR2, "b", REAL, "t", varray());
1389 ADDFUNC4(VECTOR2, VECTOR2, Vector2, cubic_interpolate, VECTOR2, "b", VECTOR2, "pre_a", VECTOR2, "post_b", REAL, "t", varray());
1390 ADDFUNC1(VECTOR2, VECTOR2, Vector2, rotated, REAL, "phi", varray());
1391 ADDFUNC0(VECTOR2, VECTOR2, Vector2, tangent, varray());
1392 ADDFUNC0(VECTOR2, VECTOR2, Vector2, floor, varray());
1393 ADDFUNC0(VECTOR2, VECTOR2, Vector2, floorf, varray());
1394 ADDFUNC1(VECTOR2, VECTOR2, Vector2, snapped, VECTOR2, "by", varray());
1395 ADDFUNC0(VECTOR2, REAL, Vector2, get_aspect, varray());
1396 ADDFUNC1(VECTOR2, REAL, Vector2, dot, VECTOR2, "with", varray());
1397 ADDFUNC1(VECTOR2, VECTOR2, Vector2, slide, VECTOR2, "vec", varray());
1398 ADDFUNC1(VECTOR2, VECTOR2, Vector2, reflect, VECTOR2, "vec", varray());
1399 //ADDFUNC1(VECTOR2,REAL,Vector2,cross,VECTOR2,"with",varray());
1400 ADDFUNC0(VECTOR2, VECTOR2, Vector2, abs, varray());
1401 ADDFUNC1(VECTOR2, VECTOR2, Vector2, clamped, REAL, "length", varray());
1402
1403 ADDFUNC0(RECT2, REAL, Rect2, get_area, varray());
1404 ADDFUNC1(RECT2, BOOL, Rect2, intersects, RECT2, "b", varray());
1405 ADDFUNC1(RECT2, BOOL, Rect2, encloses, RECT2, "b", varray());
1406 ADDFUNC0(RECT2, BOOL, Rect2, has_no_area, varray());
1407 ADDFUNC1(RECT2, RECT2, Rect2, clip, RECT2, "b", varray());
1408 ADDFUNC1(RECT2, RECT2, Rect2, merge, RECT2, "b", varray());
1409 ADDFUNC1(RECT2, BOOL, Rect2, has_point, VECTOR2, "point", varray());
1410 ADDFUNC1(RECT2, RECT2, Rect2, grow, REAL, "by", varray());
1411 ADDFUNC2(RECT2, RECT2, Rect2, grow_margin, INT, "margin", REAL, "by", varray());
1412 ADDFUNC4(RECT2, RECT2, Rect2, grow_individual, REAL, "left", REAL, "top", REAL, "right", REAL, " bottom", varray());
1413 ADDFUNC1(RECT2, RECT2, Rect2, expand, VECTOR2, "to", varray());
1414
1415 ADDFUNC0(VECTOR3, INT, Vector3, min_axis, varray());
1416 ADDFUNC0(VECTOR3, INT, Vector3, max_axis, varray());
1417 ADDFUNC0(VECTOR3, REAL, Vector3, length, varray());
1418 ADDFUNC0(VECTOR3, REAL, Vector3, length_squared, varray());
1419 ADDFUNC0(VECTOR3, VECTOR3, Vector3, normalized, varray());
1420 ADDFUNC0(VECTOR3, VECTOR3, Vector3, inverse, varray());
1421 ADDFUNC1(VECTOR3, VECTOR3, Vector3, snapped, REAL, "by", varray());
1422 ADDFUNC2(VECTOR3, VECTOR3, Vector3, rotated, VECTOR3, "axis", REAL, "phi", varray());
1423 ADDFUNC2(VECTOR3, VECTOR3, Vector3, linear_interpolate, VECTOR3, "b", REAL, "t", varray());
1424 ADDFUNC4(VECTOR3, VECTOR3, Vector3, cubic_interpolate, VECTOR3, "b", VECTOR3, "pre_a", VECTOR3, "post_b", REAL, "t", varray());
1425 ADDFUNC1(VECTOR3, REAL, Vector3, dot, VECTOR3, "b", varray());
1426 ADDFUNC1(VECTOR3, VECTOR3, Vector3, cross, VECTOR3, "b", varray());
1427 ADDFUNC0(VECTOR3, VECTOR3, Vector3, abs, varray());
1428 ADDFUNC0(VECTOR3, VECTOR3, Vector3, floor, varray());
1429 ADDFUNC0(VECTOR3, VECTOR3, Vector3, ceil, varray());
1430 ADDFUNC1(VECTOR3, REAL, Vector3, distance_to, VECTOR3, "b", varray());
1431 ADDFUNC1(VECTOR3, REAL, Vector3, distance_squared_to, VECTOR3, "b", varray());
1432 ADDFUNC1(VECTOR3, REAL, Vector3, angle_to, VECTOR3, "to", varray());
1433 ADDFUNC1(VECTOR3, VECTOR3, Vector3, slide, VECTOR3, "by", varray());
1434 ADDFUNC1(VECTOR3, VECTOR3, Vector3, reflect, VECTOR3, "by", varray());
1435
1436 ADDFUNC0(PLANE, PLANE, Plane, normalized, varray());
1437 ADDFUNC0(PLANE, VECTOR3, Plane, center, varray());
1438 ADDFUNC0(PLANE, VECTOR3, Plane, get_any_point, varray());
1439 ADDFUNC1(PLANE, BOOL, Plane, is_point_over, VECTOR3, "point", varray());
1440 ADDFUNC1(PLANE, REAL, Plane, distance_to, VECTOR3, "point", varray());
1441 ADDFUNC2(PLANE, BOOL, Plane, has_point, VECTOR3, "point", REAL, "epsilon", varray(CMP_EPSILON));
1442 ADDFUNC1(PLANE, VECTOR3, Plane, project, VECTOR3, "point", varray());
1443 ADDFUNC2(PLANE, VECTOR3, Plane, intersect_3, PLANE, "b", PLANE, "c", varray());
1444 ADDFUNC2(PLANE, VECTOR3, Plane, intersects_ray, VECTOR3, "from", VECTOR3, "dir", varray());
1445 ADDFUNC2(PLANE, VECTOR3, Plane, intersects_segment, VECTOR3, "begin", VECTOR3, "end", varray());
1446
1447 ADDFUNC0(QUAT, REAL, Quat, length, varray());
1448 ADDFUNC0(QUAT, REAL, Quat, length_squared, varray());
1449 ADDFUNC0(QUAT, QUAT, Quat, normalized, varray());
1450 ADDFUNC0(QUAT, QUAT, Quat, inverse, varray());
1451 ADDFUNC1(QUAT, REAL, Quat, dot, QUAT, "b", varray());
1452 ADDFUNC1(QUAT, VECTOR3, Quat, xform, VECTOR3, "v", varray());
1453 ADDFUNC2(QUAT, QUAT, Quat, slerp, QUAT, "b", REAL, "t", varray());
1454 ADDFUNC2(QUAT, QUAT, Quat, slerpni, QUAT, "b", REAL, "t", varray());
1455 ADDFUNC4(QUAT, QUAT, Quat, cubic_slerp, QUAT, "b", QUAT, "pre_a", QUAT, "post_b", REAL, "t", varray());
1456
1457 ADDFUNC0(COLOR, INT, Color, to_32, varray());
1458 ADDFUNC0(COLOR, INT, Color, to_ARGB32, varray());
1459 ADDFUNC0(COLOR, REAL, Color, gray, varray());
1460 ADDFUNC0(COLOR, COLOR, Color, inverted, varray());
1461 ADDFUNC0(COLOR, COLOR, Color, contrasted, varray());
1462 ADDFUNC2(COLOR, COLOR, Color, linear_interpolate, COLOR, "b", REAL, "t", varray());
1463 ADDFUNC1(COLOR, COLOR, Color, blend, COLOR, "over", varray());
1464 ADDFUNC1(COLOR, STRING, Color, to_html, BOOL, "with_alpha", varray(true));
1465
1466 ADDFUNC0(IMAGE, INT, Image, get_format, varray());
1467 ADDFUNC0(IMAGE, INT, Image, get_width, varray());
1468 ADDFUNC0(IMAGE, INT, Image, get_height, varray());
1469 ADDFUNC0(IMAGE, BOOL, Image, empty, varray());
1470 ADDFUNC3(IMAGE, COLOR, Image, get_pixel, INT, "x", INT, "y", INT, "mipmap_level", varray(0));
1471 ADDFUNC4(IMAGE, NIL, Image, put_pixel, INT, "x", INT, "y", COLOR, "color", INT, "mipmap_level", varray(0));
1472 ADDFUNC3(IMAGE, IMAGE, Image, brushed, IMAGE, "src", IMAGE, "brush", VECTOR2, "pos", varray(0));
1473 ADDFUNC1(IMAGE, INT, Image, load, STRING, "path", varray(0));
1474 ADDFUNC1(IMAGE, INT, Image, save_png, STRING, "path", varray(0));
1475 ADDFUNC3(IMAGE, NIL, Image, brush_transfer, IMAGE, "src", IMAGE, "brush", VECTOR2, "pos", varray(0));
1476 ADDFUNC0(IMAGE, RECT2, Image, get_used_rect, varray(0));
1477 ADDFUNC1(IMAGE, IMAGE, Image, get_rect, RECT2, "area", varray(0));
1478 ADDFUNC1(IMAGE, IMAGE, Image, compressed, INT, "format", varray(0));
1479 ADDFUNC0(IMAGE, IMAGE, Image, decompressed, varray(0));
1480 ADDFUNC3(IMAGE, IMAGE, Image, resized, INT, "x", INT, "y", INT, "interpolation", varray(((int)Image::INTERPOLATE_BILINEAR)));
1481 ADDFUNC0(IMAGE, RAW_ARRAY, Image, get_data, varray());
1482 ADDFUNC3(IMAGE, NIL, Image, blit_rect, IMAGE, "src", RECT2, "src_rect", VECTOR2, "dest", varray(0));
1483 ADDFUNC4(IMAGE, NIL, Image, blit_rect_mask, IMAGE, "src", IMAGE, "mask", RECT2, "src_rect", VECTOR2, "dest", varray(0));
1484 ADDFUNC3(IMAGE, NIL, Image, blend_rect, IMAGE, "src", RECT2, "src_rect", VECTOR2, "dest", varray(0));
1485 ADDFUNC4(IMAGE, NIL, Image, blend_rect_mask, IMAGE, "src", IMAGE, "mask", RECT2, "src_rect", VECTOR2, "dest", varray(0));
1486 ADDFUNC1(IMAGE, NIL, Image, fill, COLOR, "color", varray(0));
1487 ADDFUNC1(IMAGE, IMAGE, Image, converted, INT, "format", varray(0));
1488 ADDFUNC0(IMAGE, NIL, Image, fix_alpha_edges, varray());
1489
1490 ADDFUNC0(_RID, INT, RID, get_id, varray());
1491
1492 ADDFUNC0(NODE_PATH, BOOL, NodePath, is_absolute, varray());
1493 ADDFUNC0(NODE_PATH, INT, NodePath, get_name_count, varray());
1494 ADDFUNC1(NODE_PATH, STRING, NodePath, get_name, INT, "idx", varray());
1495 ADDFUNC0(NODE_PATH, INT, NodePath, get_subname_count, varray());
1496 ADDFUNC1(NODE_PATH, STRING, NodePath, get_subname, INT, "idx", varray());
1497 ADDFUNC0(NODE_PATH, STRING, NodePath, get_property, varray());
1498 ADDFUNC0(NODE_PATH, BOOL, NodePath, is_empty, varray());
1499
1500 ADDFUNC0(DICTIONARY, INT, Dictionary, size, varray());
1501 ADDFUNC0(DICTIONARY, BOOL, Dictionary, empty, varray());
1502 ADDFUNC0(DICTIONARY, NIL, Dictionary, clear, varray());
1503 ADDFUNC1(DICTIONARY, BOOL, Dictionary, has, NIL, "key", varray());
1504 ADDFUNC1(DICTIONARY, BOOL, Dictionary, has_all, ARRAY, "keys", varray());
1505 ADDFUNC1(DICTIONARY, NIL, Dictionary, erase, NIL, "key", varray());
1506 ADDFUNC0(DICTIONARY, INT, Dictionary, hash, varray());
1507 ADDFUNC0(DICTIONARY, ARRAY, Dictionary, keys, varray());
1508 ADDFUNC0(DICTIONARY, ARRAY, Dictionary, values, varray());
1509
1510 ADDFUNC1(DICTIONARY, INT, Dictionary, parse_json, STRING, "json", varray());
1511 ADDFUNC0(DICTIONARY, STRING, Dictionary, to_json, varray());
1512
1513 ADDFUNC0(ARRAY, INT, Array, size, varray());
1514 ADDFUNC0(ARRAY, BOOL, Array, empty, varray());
1515 ADDFUNC0(ARRAY, NIL, Array, clear, varray());
1516 ADDFUNC0(ARRAY, INT, Array, hash, varray());
1517 ADDFUNC1(ARRAY, NIL, Array, push_back, NIL, "value", varray());
1518 ADDFUNC1(ARRAY, NIL, Array, push_front, NIL, "value", varray());
1519 ADDFUNC1(ARRAY, NIL, Array, append, NIL, "value", varray());
1520 ADDFUNC1(ARRAY, NIL, Array, resize, INT, "pos", varray());
1521 ADDFUNC2(ARRAY, NIL, Array, insert, INT, "pos", NIL, "value", varray());
1522 ADDFUNC1(ARRAY, NIL, Array, remove, INT, "pos", varray());
1523 ADDFUNC1(ARRAY, NIL, Array, erase, NIL, "value", varray());
1524 ADDFUNC0(ARRAY, NIL, Array, front, varray());
1525 ADDFUNC0(ARRAY, NIL, Array, back, varray());
1526 ADDFUNC2(ARRAY, INT, Array, find, NIL, "what", INT, "from", varray(0));
1527 ADDFUNC2(ARRAY, INT, Array, rfind, NIL, "what", INT, "from", varray(-1));
1528 ADDFUNC1(ARRAY, INT, Array, find_last, NIL, "value", varray());
1529 ADDFUNC1(ARRAY, INT, Array, count, NIL, "value", varray());
1530 ADDFUNC1(ARRAY, BOOL, Array, has, NIL, "value", varray());
1531 ADDFUNC0(ARRAY, NIL, Array, pop_back, varray());
1532 ADDFUNC0(ARRAY, NIL, Array, pop_front, varray());
1533 ADDFUNC0(ARRAY, NIL, Array, sort, varray());
1534 ADDFUNC2(ARRAY, NIL, Array, sort_custom, OBJECT, "obj", STRING, "func", varray());
1535 ADDFUNC0(ARRAY, NIL, Array, invert, varray());
1536 ADDFUNC0(ARRAY, BOOL, Array, is_shared, varray());
1537
1538 ADDFUNC0(RAW_ARRAY, INT, ByteArray, size, varray());
1539 ADDFUNC2(RAW_ARRAY, NIL, ByteArray, set, INT, "idx", INT, "byte", varray());
1540 ADDFUNC1(RAW_ARRAY, NIL, ByteArray, push_back, INT, "byte", varray());
1541 ADDFUNC1(RAW_ARRAY, NIL, ByteArray, append, INT, "byte", varray());
1542 ADDFUNC1(RAW_ARRAY, NIL, ByteArray, append_array, RAW_ARRAY, "array", varray());
1543 ADDFUNC1(RAW_ARRAY, NIL, ByteArray, remove, INT, "idx", varray());
1544 ADDFUNC2(RAW_ARRAY, INT, ByteArray, insert, INT, "idx", INT, "byte", varray());
1545 ADDFUNC1(RAW_ARRAY, NIL, ByteArray, resize, INT, "idx", varray());
1546 ADDFUNC0(RAW_ARRAY, NIL, ByteArray, invert, varray());
1547
1548 ADDFUNC0(RAW_ARRAY, STRING, ByteArray, get_string_from_ascii, varray());
1549 ADDFUNC0(RAW_ARRAY, STRING, ByteArray, get_string_from_utf8, varray());
1550
1551 ADDFUNC0(INT_ARRAY, INT, IntArray, size, varray());
1552 ADDFUNC2(INT_ARRAY, NIL, IntArray, set, INT, "idx", INT, "integer", varray());
1553 ADDFUNC1(INT_ARRAY, NIL, IntArray, push_back, INT, "integer", varray());
1554 ADDFUNC1(INT_ARRAY, NIL, IntArray, append, INT, "integer", varray());
1555 ADDFUNC1(INT_ARRAY, NIL, IntArray, append_array, INT_ARRAY, "array", varray());
1556 ADDFUNC1(INT_ARRAY, NIL, IntArray, remove, INT, "idx", varray());
1557 ADDFUNC2(INT_ARRAY, INT, IntArray, insert, INT, "idx", INT, "integer", varray());
1558 ADDFUNC1(INT_ARRAY, NIL, IntArray, resize, INT, "idx", varray());
1559 ADDFUNC0(INT_ARRAY, NIL, IntArray, invert, varray());
1560
1561 ADDFUNC0(REAL_ARRAY, INT, RealArray, size, varray());
1562 ADDFUNC2(REAL_ARRAY, NIL, RealArray, set, INT, "idx", REAL, "value", varray());
1563 ADDFUNC1(REAL_ARRAY, NIL, RealArray, push_back, REAL, "value", varray());
1564 ADDFUNC1(REAL_ARRAY, NIL, RealArray, append, REAL, "value", varray());
1565 ADDFUNC1(REAL_ARRAY, NIL, RealArray, append_array, REAL_ARRAY, "array", varray());
1566 ADDFUNC1(REAL_ARRAY, NIL, RealArray, remove, INT, "idx", varray());
1567 ADDFUNC2(REAL_ARRAY, INT, RealArray, insert, INT, "idx", REAL, "value", varray());
1568 ADDFUNC1(REAL_ARRAY, NIL, RealArray, resize, INT, "idx", varray());
1569 ADDFUNC0(REAL_ARRAY, NIL, RealArray, invert, varray());
1570
1571 ADDFUNC0(STRING_ARRAY, INT, StringArray, size, varray());
1572 ADDFUNC2(STRING_ARRAY, NIL, StringArray, set, INT, "idx", STRING, "string", varray());
1573 ADDFUNC1(STRING_ARRAY, NIL, StringArray, push_back, STRING, "string", varray());
1574 ADDFUNC1(STRING_ARRAY, NIL, StringArray, append, STRING, "string", varray());
1575 ADDFUNC1(STRING_ARRAY, NIL, StringArray, append_array, STRING_ARRAY, "array", varray());
1576 ADDFUNC1(STRING_ARRAY, NIL, StringArray, remove, INT, "idx", varray());
1577 ADDFUNC2(STRING_ARRAY, INT, StringArray, insert, INT, "idx", STRING, "string", varray());
1578 ADDFUNC1(STRING_ARRAY, NIL, StringArray, resize, INT, "idx", varray());
1579 ADDFUNC0(STRING_ARRAY, NIL, StringArray, invert, varray());
1580
1581 ADDFUNC0(VECTOR2_ARRAY, INT, Vector2Array, size, varray());
1582 ADDFUNC2(VECTOR2_ARRAY, NIL, Vector2Array, set, INT, "idx", VECTOR2, "vector2", varray());
1583 ADDFUNC1(VECTOR2_ARRAY, NIL, Vector2Array, push_back, VECTOR2, "vector2", varray());
1584 ADDFUNC1(VECTOR2_ARRAY, NIL, Vector2Array, append, VECTOR2, "vector2", varray());
1585 ADDFUNC1(VECTOR2_ARRAY, NIL, Vector2Array, append_array, VECTOR2_ARRAY, "array", varray());
1586 ADDFUNC1(VECTOR2_ARRAY, NIL, Vector2Array, remove, INT, "idx", varray());
1587 ADDFUNC2(VECTOR2_ARRAY, INT, Vector2Array, insert, INT, "idx", VECTOR2, "vector2", varray());
1588 ADDFUNC1(VECTOR2_ARRAY, NIL, Vector2Array, resize, INT, "idx", varray());
1589 ADDFUNC0(VECTOR2_ARRAY, NIL, Vector2Array, invert, varray());
1590
1591 ADDFUNC0(VECTOR3_ARRAY, INT, Vector3Array, size, varray());
1592 ADDFUNC2(VECTOR3_ARRAY, NIL, Vector3Array, set, INT, "idx", VECTOR3, "vector3", varray());
1593 ADDFUNC1(VECTOR3_ARRAY, NIL, Vector3Array, push_back, VECTOR3, "vector3", varray());
1594 ADDFUNC1(VECTOR3_ARRAY, NIL, Vector3Array, append, VECTOR3, "vector3", varray());
1595 ADDFUNC1(VECTOR3_ARRAY, NIL, Vector3Array, append_array, VECTOR3_ARRAY, "array", varray());
1596 ADDFUNC1(VECTOR3_ARRAY, NIL, Vector3Array, remove, INT, "idx", varray());
1597 ADDFUNC2(VECTOR3_ARRAY, INT, Vector3Array, insert, INT, "idx", VECTOR3, "vector3", varray());
1598 ADDFUNC1(VECTOR3_ARRAY, NIL, Vector3Array, resize, INT, "idx", varray());
1599 ADDFUNC0(VECTOR3_ARRAY, NIL, Vector3Array, invert, varray());
1600
1601 ADDFUNC0(COLOR_ARRAY, INT, ColorArray, size, varray());
1602 ADDFUNC2(COLOR_ARRAY, NIL, ColorArray, set, INT, "idx", COLOR, "color", varray());
1603 ADDFUNC1(COLOR_ARRAY, NIL, ColorArray, push_back, COLOR, "color", varray());
1604 ADDFUNC1(COLOR_ARRAY, NIL, ColorArray, append, COLOR, "color", varray());
1605 ADDFUNC1(COLOR_ARRAY, NIL, ColorArray, append_array, COLOR_ARRAY, "array", varray());
1606 ADDFUNC1(COLOR_ARRAY, NIL, ColorArray, remove, INT, "idx", varray());
1607 ADDFUNC2(COLOR_ARRAY, INT, ColorArray, insert, INT, "idx", COLOR, "color", varray());
1608 ADDFUNC1(COLOR_ARRAY, NIL, ColorArray, resize, INT, "idx", varray());
1609 ADDFUNC0(COLOR_ARRAY, NIL, ColorArray, invert, varray());
1610
1611 //pointerbased
1612
1613 ADDFUNC0(_AABB, REAL, AABB, get_area, varray());
1614 ADDFUNC0(_AABB, BOOL, AABB, has_no_area, varray());
1615 ADDFUNC0(_AABB, BOOL, AABB, has_no_surface, varray());
1616 ADDFUNC1(_AABB, BOOL, AABB, intersects, _AABB, "with", varray());
1617 ADDFUNC1(_AABB, BOOL, AABB, encloses, _AABB, "with", varray());
1618 ADDFUNC1(_AABB, _AABB, AABB, merge, _AABB, "with", varray());
1619 ADDFUNC1(_AABB, _AABB, AABB, intersection, _AABB, "with", varray());
1620 ADDFUNC1(_AABB, BOOL, AABB, intersects_plane, PLANE, "plane", varray());
1621 ADDFUNC2(_AABB, BOOL, AABB, intersects_segment, VECTOR3, "from", VECTOR3, "to", varray());
1622 ADDFUNC1(_AABB, BOOL, AABB, has_point, VECTOR3, "point", varray());
1623 ADDFUNC1(_AABB, VECTOR3, AABB, get_support, VECTOR3, "dir", varray());
1624 ADDFUNC0(_AABB, VECTOR3, AABB, get_longest_axis, varray());
1625 ADDFUNC0(_AABB, INT, AABB, get_longest_axis_index, varray());
1626 ADDFUNC0(_AABB, REAL, AABB, get_longest_axis_size, varray());
1627 ADDFUNC0(_AABB, VECTOR3, AABB, get_shortest_axis, varray());
1628 ADDFUNC0(_AABB, INT, AABB, get_shortest_axis_index, varray());
1629 ADDFUNC0(_AABB, REAL, AABB, get_shortest_axis_size, varray());
1630 ADDFUNC1(_AABB, _AABB, AABB, expand, VECTOR3, "to_point", varray());
1631 ADDFUNC1(_AABB, _AABB, AABB, grow, REAL, "by", varray());
1632 ADDFUNC1(_AABB, VECTOR3, AABB, get_endpoint, INT, "idx", varray());
1633
1634 ADDFUNC0(MATRIX32, MATRIX32, Matrix32, inverse, varray());
1635 ADDFUNC0(MATRIX32, MATRIX32, Matrix32, affine_inverse, varray());
1636 ADDFUNC0(MATRIX32, REAL, Matrix32, get_rotation, varray());
1637 ADDFUNC0(MATRIX32, VECTOR2, Matrix32, get_origin, varray());
1638 ADDFUNC0(MATRIX32, VECTOR2, Matrix32, get_scale, varray());
1639 ADDFUNC0(MATRIX32, MATRIX32, Matrix32, orthonormalized, varray());
1640 ADDFUNC1(MATRIX32, MATRIX32, Matrix32, rotated, REAL, "phi", varray());
1641 ADDFUNC1(MATRIX32, MATRIX32, Matrix32, scaled, VECTOR2, "scale", varray());
1642 ADDFUNC1(MATRIX32, MATRIX32, Matrix32, translated, VECTOR2, "offset", varray());
1643 ADDFUNC1(MATRIX32, MATRIX32, Matrix32, xform, NIL, "v", varray());
1644 ADDFUNC1(MATRIX32, MATRIX32, Matrix32, xform_inv, NIL, "v", varray());
1645 ADDFUNC1(MATRIX32, MATRIX32, Matrix32, basis_xform, NIL, "v", varray());
1646 ADDFUNC1(MATRIX32, MATRIX32, Matrix32, basis_xform_inv, NIL, "v", varray());
1647 ADDFUNC2(MATRIX32, MATRIX32, Matrix32, interpolate_with, MATRIX32, "m", REAL, "c", varray());
1648
1649 ADDFUNC0(MATRIX3, MATRIX3, Matrix3, inverse, varray());
1650 ADDFUNC0(MATRIX3, MATRIX3, Matrix3, transposed, varray());
1651 ADDFUNC0(MATRIX3, MATRIX3, Matrix3, orthonormalized, varray());
1652 ADDFUNC0(MATRIX3, REAL, Matrix3, determinant, varray());
1653 ADDFUNC2(MATRIX3, MATRIX3, Matrix3, rotated, VECTOR3, "axis", REAL, "phi", varray());
1654 ADDFUNC1(MATRIX3, MATRIX3, Matrix3, scaled, VECTOR3, "scale", varray());
1655 ADDFUNC0(MATRIX3, VECTOR3, Matrix3, get_scale, varray());
1656 ADDFUNC0(MATRIX3, VECTOR3, Matrix3, get_euler, varray());
1657 ADDFUNC1(MATRIX3, REAL, Matrix3, tdotx, VECTOR3, "with", varray());
1658 ADDFUNC1(MATRIX3, REAL, Matrix3, tdoty, VECTOR3, "with", varray());
1659 ADDFUNC1(MATRIX3, REAL, Matrix3, tdotz, VECTOR3, "with", varray());
1660 ADDFUNC1(MATRIX3, VECTOR3, Matrix3, xform, VECTOR3, "v", varray());
1661 ADDFUNC1(MATRIX3, VECTOR3, Matrix3, xform_inv, VECTOR3, "v", varray());
1662 ADDFUNC0(MATRIX3, INT, Matrix3, get_orthogonal_index, varray());
1663
1664 ADDFUNC0(TRANSFORM, TRANSFORM, Transform, inverse, varray());
1665 ADDFUNC0(TRANSFORM, TRANSFORM, Transform, affine_inverse, varray());
1666 ADDFUNC0(TRANSFORM, TRANSFORM, Transform, orthonormalized, varray());
1667 ADDFUNC2(TRANSFORM, TRANSFORM, Transform, rotated, VECTOR3, "axis", REAL, "phi", varray());
1668 ADDFUNC1(TRANSFORM, TRANSFORM, Transform, scaled, VECTOR3, "scale", varray());
1669 ADDFUNC1(TRANSFORM, TRANSFORM, Transform, translated, VECTOR3, "ofs", varray());
1670 ADDFUNC2(TRANSFORM, TRANSFORM, Transform, looking_at, VECTOR3, "target", VECTOR3, "up", varray());
1671 ADDFUNC1(TRANSFORM, NIL, Transform, xform, NIL, "v", varray());
1672 ADDFUNC1(TRANSFORM, NIL, Transform, xform_inv, NIL, "v", varray());
1673
1674 #ifdef DEBUG_ENABLED
1675 _VariantCall::type_funcs[Variant::TRANSFORM].functions["xform"].returns = true;
1676 _VariantCall::type_funcs[Variant::TRANSFORM].functions["xform_inv"].returns = true;
1677 #endif
1678
1679 ADDFUNC0(INPUT_EVENT, BOOL, InputEvent, is_pressed, varray());
1680 ADDFUNC1(INPUT_EVENT, BOOL, InputEvent, is_action, STRING, "action", varray());
1681 ADDFUNC1(INPUT_EVENT, BOOL, InputEvent, is_action_pressed, STRING, "action", varray());
1682 ADDFUNC1(INPUT_EVENT, BOOL, InputEvent, is_action_released, STRING, "action", varray());
1683 ADDFUNC0(INPUT_EVENT, BOOL, InputEvent, is_echo, varray());
1684 ADDFUNC2(INPUT_EVENT, NIL, InputEvent, set_as_action, STRING, "action", BOOL, "pressed", varray());
1685
1686 /* REGISTER CONSTRUCTORS */
1687
1688 _VariantCall::add_constructor(_VariantCall::Vector2_init1, Variant::VECTOR2, "x", Variant::REAL, "y", Variant::REAL);
1689
1690 _VariantCall::add_constructor(_VariantCall::Rect2_init1, Variant::RECT2, "pos", Variant::VECTOR2, "size", Variant::VECTOR2);
1691 _VariantCall::add_constructor(_VariantCall::Rect2_init2, Variant::RECT2, "x", Variant::REAL, "y", Variant::REAL, "width", Variant::REAL, "height", Variant::REAL);
1692
1693 _VariantCall::add_constructor(_VariantCall::Matrix32_init2, Variant::MATRIX32, "rot", Variant::REAL, "pos", Variant::VECTOR2);
1694 _VariantCall::add_constructor(_VariantCall::Matrix32_init3, Variant::MATRIX32, "x_axis", Variant::VECTOR2, "y_axis", Variant::VECTOR2, "origin", Variant::VECTOR2);
1695
1696 _VariantCall::add_constructor(_VariantCall::Vector3_init1, Variant::VECTOR3, "x", Variant::REAL, "y", Variant::REAL, "z", Variant::REAL);
1697
1698 _VariantCall::add_constructor(_VariantCall::Plane_init1, Variant::PLANE, "a", Variant::REAL, "b", Variant::REAL, "c", Variant::REAL, "d", Variant::REAL);
1699 _VariantCall::add_constructor(_VariantCall::Plane_init2, Variant::PLANE, "v1", Variant::VECTOR3, "v2", Variant::VECTOR3, "v3", Variant::VECTOR3);
1700 _VariantCall::add_constructor(_VariantCall::Plane_init3, Variant::PLANE, "normal", Variant::VECTOR3, "d", Variant::REAL);
1701
1702 _VariantCall::add_constructor(_VariantCall::Quat_init1, Variant::QUAT, "x", Variant::REAL, "y", Variant::REAL, "z", Variant::REAL, "w", Variant::REAL);
1703 _VariantCall::add_constructor(_VariantCall::Quat_init2, Variant::QUAT, "axis", Variant::VECTOR3, "angle", Variant::REAL);
1704
1705 _VariantCall::add_constructor(_VariantCall::Color_init1, Variant::COLOR, "r", Variant::REAL, "g", Variant::REAL, "b", Variant::REAL, "a", Variant::REAL);
1706 _VariantCall::add_constructor(_VariantCall::Color_init2, Variant::COLOR, "r", Variant::REAL, "g", Variant::REAL, "b", Variant::REAL);
1707
1708 _VariantCall::add_constructor(_VariantCall::AABB_init1, Variant::_AABB, "pos", Variant::VECTOR3, "size", Variant::VECTOR3);
1709
1710 _VariantCall::add_constructor(_VariantCall::Matrix3_init1, Variant::MATRIX3, "x_axis", Variant::VECTOR3, "y_axis", Variant::VECTOR3, "z_axis", Variant::VECTOR3);
1711 _VariantCall::add_constructor(_VariantCall::Matrix3_init2, Variant::MATRIX3, "axis", Variant::VECTOR3, "phi", Variant::REAL);
1712
1713 _VariantCall::add_constructor(_VariantCall::Transform_init1, Variant::TRANSFORM, "x_axis", Variant::VECTOR3, "y_axis", Variant::VECTOR3, "z_axis", Variant::VECTOR3, "origin", Variant::VECTOR3);
1714 _VariantCall::add_constructor(_VariantCall::Transform_init2, Variant::TRANSFORM, "basis", Variant::MATRIX3, "origin", Variant::VECTOR3);
1715
1716 _VariantCall::add_constructor(_VariantCall::Image_init1, Variant::IMAGE, "width", Variant::INT, "height", Variant::INT, "mipmaps", Variant::BOOL, "format", Variant::INT);
1717
1718 /* REGISTER CONSTANTS */
1719
1720 _VariantCall::add_constant(Variant::VECTOR3, "AXIS_X", Vector3::AXIS_X);
1721 _VariantCall::add_constant(Variant::VECTOR3, "AXIS_Y", Vector3::AXIS_Y);
1722 _VariantCall::add_constant(Variant::VECTOR3, "AXIS_Z", Vector3::AXIS_Z);
1723
1724 _VariantCall::add_constant(Variant::INPUT_EVENT, "NONE", InputEvent::NONE);
1725 _VariantCall::add_constant(Variant::INPUT_EVENT, "KEY", InputEvent::KEY);
1726 _VariantCall::add_constant(Variant::INPUT_EVENT, "MOUSE_MOTION", InputEvent::MOUSE_MOTION);
1727 _VariantCall::add_constant(Variant::INPUT_EVENT, "MOUSE_BUTTON", InputEvent::MOUSE_BUTTON);
1728 _VariantCall::add_constant(Variant::INPUT_EVENT, "JOYSTICK_MOTION", InputEvent::JOYSTICK_MOTION);
1729 _VariantCall::add_constant(Variant::INPUT_EVENT, "JOYSTICK_BUTTON", InputEvent::JOYSTICK_BUTTON);
1730 _VariantCall::add_constant(Variant::INPUT_EVENT, "SCREEN_TOUCH", InputEvent::SCREEN_TOUCH);
1731 _VariantCall::add_constant(Variant::INPUT_EVENT, "SCREEN_DRAG", InputEvent::SCREEN_DRAG);
1732 _VariantCall::add_constant(Variant::INPUT_EVENT, "ACTION", InputEvent::ACTION);
1733
1734 _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_BC", Image::COMPRESS_BC);
1735 _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_PVRTC2", Image::COMPRESS_PVRTC2);
1736 _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_PVRTC4", Image::COMPRESS_PVRTC4);
1737 _VariantCall::add_constant(Variant::IMAGE, "COMPRESS_ETC", Image::COMPRESS_ETC);
1738
1739 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_GRAYSCALE", Image::FORMAT_GRAYSCALE);
1740 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_INTENSITY", Image::FORMAT_INTENSITY);
1741 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_GRAYSCALE_ALPHA", Image::FORMAT_GRAYSCALE_ALPHA);
1742 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGB", Image::FORMAT_RGB);
1743 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_RGBA", Image::FORMAT_RGBA);
1744 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_INDEXED", Image::FORMAT_INDEXED);
1745 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_INDEXED_ALPHA", Image::FORMAT_INDEXED_ALPHA);
1746 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_YUV_422", Image::FORMAT_YUV_422);
1747 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_YUV_444", Image::FORMAT_YUV_444);
1748 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_BC1", Image::FORMAT_BC1);
1749 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_BC2", Image::FORMAT_BC2);
1750 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_BC3", Image::FORMAT_BC3);
1751 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_BC4", Image::FORMAT_BC4);
1752 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_BC5", Image::FORMAT_BC5);
1753 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_PVRTC2", Image::FORMAT_PVRTC2);
1754 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_PVRTC2_ALPHA", Image::FORMAT_PVRTC2_ALPHA);
1755 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_PVRTC4", Image::FORMAT_PVRTC4);
1756 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_PVRTC4_ALPHA", Image::FORMAT_PVRTC4_ALPHA);
1757 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ETC", Image::FORMAT_ETC);
1758 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ATC", Image::FORMAT_ATC);
1759 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ATC_ALPHA_EXPLICIT", Image::FORMAT_ATC_ALPHA_EXPLICIT);
1760 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_ATC_ALPHA_INTERPOLATED", Image::FORMAT_ATC_ALPHA_INTERPOLATED);
1761 _VariantCall::add_constant(Variant::IMAGE, "FORMAT_CUSTOM", Image::FORMAT_CUSTOM);
1762
1763 _VariantCall::add_constant(Variant::IMAGE, "INTERPOLATE_NEAREST", Image::INTERPOLATE_NEAREST);
1764 _VariantCall::add_constant(Variant::IMAGE, "INTERPOLATE_BILINEAR", Image::INTERPOLATE_BILINEAR);
1765 _VariantCall::add_constant(Variant::IMAGE, "INTERPOLATE_CUBIC", Image::INTERPOLATE_CUBIC);
1766 }
1767
1768 void unregister_variant_methods() {
1769
1770 memdelete_arr(_VariantCall::type_funcs);
1771 memdelete_arr(_VariantCall::construct_funcs);
1772 memdelete_arr(_VariantCall::constant_data);
1773 }
1774