1 /*************************************************************************/
2 /* variant_op.cpp */
3 /*************************************************************************/
4 /* This file is part of: */
5 /* GODOT ENGINE */
6 /* https://godotengine.org */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
9 /* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
10 /* */
11 /* Permission is hereby granted, free of charge, to any person obtaining */
12 /* a copy of this software and associated documentation files (the */
13 /* "Software"), to deal in the Software without restriction, including */
14 /* without limitation the rights to use, copy, modify, merge, publish, */
15 /* distribute, sublicense, and/or sell copies of the Software, and to */
16 /* permit persons to whom the Software is furnished to do so, subject to */
17 /* the following conditions: */
18 /* */
19 /* The above copyright notice and this permission notice shall be */
20 /* included in all copies or substantial portions of the Software. */
21 /* */
22 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
23 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
24 /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
25 /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
26 /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
27 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
28 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
29 /*************************************************************************/
30
31 #include "variant.h"
32
33 #include "core/core_string_names.h"
34 #include "core/object.h"
35 #include "core/object_rc.h"
36 #include "core/script_language.h"
37
38 #define CASE_TYPE_ALL(PREFIX, OP) \
39 CASE_TYPE(PREFIX, OP, INT) \
40 CASE_TYPE_ALL_BUT_INT(PREFIX, OP)
41
42 #define CASE_TYPE_ALL_BUT_INT(PREFIX, OP) \
43 CASE_TYPE(PREFIX, OP, NIL) \
44 CASE_TYPE(PREFIX, OP, BOOL) \
45 CASE_TYPE(PREFIX, OP, REAL) \
46 CASE_TYPE(PREFIX, OP, STRING) \
47 CASE_TYPE(PREFIX, OP, VECTOR2) \
48 CASE_TYPE(PREFIX, OP, RECT2) \
49 CASE_TYPE(PREFIX, OP, VECTOR3) \
50 CASE_TYPE(PREFIX, OP, TRANSFORM2D) \
51 CASE_TYPE(PREFIX, OP, PLANE) \
52 CASE_TYPE(PREFIX, OP, QUAT) \
53 CASE_TYPE(PREFIX, OP, AABB) \
54 CASE_TYPE(PREFIX, OP, BASIS) \
55 CASE_TYPE(PREFIX, OP, TRANSFORM) \
56 CASE_TYPE(PREFIX, OP, COLOR) \
57 CASE_TYPE(PREFIX, OP, NODE_PATH) \
58 CASE_TYPE(PREFIX, OP, _RID) \
59 CASE_TYPE(PREFIX, OP, OBJECT) \
60 CASE_TYPE(PREFIX, OP, DICTIONARY) \
61 CASE_TYPE(PREFIX, OP, ARRAY) \
62 CASE_TYPE(PREFIX, OP, POOL_BYTE_ARRAY) \
63 CASE_TYPE(PREFIX, OP, POOL_INT_ARRAY) \
64 CASE_TYPE(PREFIX, OP, POOL_REAL_ARRAY) \
65 CASE_TYPE(PREFIX, OP, POOL_STRING_ARRAY) \
66 CASE_TYPE(PREFIX, OP, POOL_VECTOR2_ARRAY) \
67 CASE_TYPE(PREFIX, OP, POOL_VECTOR3_ARRAY) \
68 CASE_TYPE(PREFIX, OP, POOL_COLOR_ARRAY)
69
70 #ifdef __GNUC__
71 #define TYPE(PREFIX, OP, TYPE) &&PREFIX##_##OP##_##TYPE
72
73 /* clang-format off */
74 #define TYPES(PREFIX, OP) { \
75 TYPE(PREFIX, OP, NIL), \
76 TYPE(PREFIX, OP, BOOL), \
77 TYPE(PREFIX, OP, INT), \
78 TYPE(PREFIX, OP, REAL), \
79 TYPE(PREFIX, OP, STRING), \
80 TYPE(PREFIX, OP, VECTOR2), \
81 TYPE(PREFIX, OP, RECT2), \
82 TYPE(PREFIX, OP, VECTOR3), \
83 TYPE(PREFIX, OP, TRANSFORM2D), \
84 TYPE(PREFIX, OP, PLANE), \
85 TYPE(PREFIX, OP, QUAT), \
86 TYPE(PREFIX, OP, AABB), \
87 TYPE(PREFIX, OP, BASIS), \
88 TYPE(PREFIX, OP, TRANSFORM), \
89 TYPE(PREFIX, OP, COLOR), \
90 TYPE(PREFIX, OP, NODE_PATH), \
91 TYPE(PREFIX, OP, _RID), \
92 TYPE(PREFIX, OP, OBJECT), \
93 TYPE(PREFIX, OP, DICTIONARY), \
94 TYPE(PREFIX, OP, ARRAY), \
95 TYPE(PREFIX, OP, POOL_BYTE_ARRAY), \
96 TYPE(PREFIX, OP, POOL_INT_ARRAY), \
97 TYPE(PREFIX, OP, POOL_REAL_ARRAY), \
98 TYPE(PREFIX, OP, POOL_STRING_ARRAY), \
99 TYPE(PREFIX, OP, POOL_VECTOR2_ARRAY), \
100 TYPE(PREFIX, OP, POOL_VECTOR3_ARRAY), \
101 TYPE(PREFIX, OP, POOL_COLOR_ARRAY), \
102 }
103 /* clang-format on */
104
105 #define CASES(PREFIX) static const void *switch_table_##PREFIX[25][27] = { \
106 TYPES(PREFIX, OP_EQUAL), \
107 TYPES(PREFIX, OP_NOT_EQUAL), \
108 TYPES(PREFIX, OP_LESS), \
109 TYPES(PREFIX, OP_LESS_EQUAL), \
110 TYPES(PREFIX, OP_GREATER), \
111 TYPES(PREFIX, OP_GREATER_EQUAL), \
112 TYPES(PREFIX, OP_ADD), \
113 TYPES(PREFIX, OP_SUBTRACT), \
114 TYPES(PREFIX, OP_MULTIPLY), \
115 TYPES(PREFIX, OP_DIVIDE), \
116 TYPES(PREFIX, OP_NEGATE), \
117 TYPES(PREFIX, OP_POSITIVE), \
118 TYPES(PREFIX, OP_MODULE), \
119 TYPES(PREFIX, OP_STRING_CONCAT), \
120 TYPES(PREFIX, OP_SHIFT_LEFT), \
121 TYPES(PREFIX, OP_SHIFT_RIGHT), \
122 TYPES(PREFIX, OP_BIT_AND), \
123 TYPES(PREFIX, OP_BIT_OR), \
124 TYPES(PREFIX, OP_BIT_XOR), \
125 TYPES(PREFIX, OP_BIT_NEGATE), \
126 TYPES(PREFIX, OP_AND), \
127 TYPES(PREFIX, OP_OR), \
128 TYPES(PREFIX, OP_XOR), \
129 TYPES(PREFIX, OP_NOT), \
130 TYPES(PREFIX, OP_IN), \
131 }
132
133 #define SWITCH(PREFIX, op, val) goto *switch_table_##PREFIX[op][val];
134 #define SWITCH_OP(PREFIX, OP, val)
135 #define CASE_TYPE(PREFIX, OP, TYPE) PREFIX##_##OP##_##TYPE:
136
137 #else
138 #define CASES(PREFIX)
139 #define SWITCH(PREFIX, op, val) switch (op)
140 #define SWITCH_OP(PREFIX, OP, val) \
141 case OP: \
142 switch (val)
143 #define CASE_TYPE(PREFIX, OP, TYPE) case TYPE:
144 #endif
145
operator bool() const146 Variant::operator bool() const {
147
148 return booleanize();
149 }
150
151 // We consider all uninitialized or empty types to be false based on the type's
152 // zeroiness.
booleanize() const153 bool Variant::booleanize() const {
154 return !is_zero();
155 }
156
157 #define _RETURN(m_what) \
158 { \
159 r_ret = m_what; \
160 return; \
161 }
162
163 #define _RETURN_FAIL \
164 { \
165 r_valid = false; \
166 return; \
167 }
168
169 #define DEFAULT_OP_NUM(m_prefix, m_op_name, m_name, m_op, m_type) \
170 CASE_TYPE(m_prefix, m_op_name, m_name) { \
171 if (p_b.type == INT) _RETURN(p_a._data.m_type m_op p_b._data._int); \
172 if (p_b.type == REAL) _RETURN(p_a._data.m_type m_op p_b._data._real); \
173 \
174 _RETURN_FAIL \
175 };
176
177 #define DEFAULT_OP_NUM_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \
178 CASE_TYPE(m_prefix, m_op_name, m_name) { \
179 if (p_b.type == INT) _RETURN(p_a._data.m_type m_op p_b._data._int); \
180 if (p_b.type == REAL) _RETURN(p_a._data.m_type m_op p_b._data._real); \
181 if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL)); \
182 \
183 _RETURN_FAIL \
184 };
185
186 #ifdef DEBUG_ENABLED
187 #define DEFAULT_OP_NUM_DIV(m_prefix, m_op_name, m_name, m_type) \
188 CASE_TYPE(m_prefix, m_op_name, m_name) { \
189 if (p_b.type == INT) { \
190 if (p_b._data._int == 0) { \
191 r_valid = false; \
192 _RETURN("Division By Zero"); \
193 } \
194 _RETURN(p_a._data.m_type / p_b._data._int); \
195 } \
196 if (p_b.type == REAL) { \
197 if (p_b._data._real == 0) { \
198 r_valid = false; \
199 _RETURN("Division By Zero"); \
200 } \
201 _RETURN(p_a._data.m_type / p_b._data._real); \
202 } \
203 \
204 _RETURN_FAIL \
205 };
206 #else
207 #define DEFAULT_OP_NUM_DIV(m_prefix, m_op_name, m_name, m_type) \
208 CASE_TYPE(m_prefix, m_op_name, m_name) { \
209 if (p_b.type == INT) _RETURN(p_a._data.m_type / p_b._data._int); \
210 if (p_b.type == REAL) _RETURN(p_a._data.m_type / p_b._data._real); \
211 \
212 _RETURN_FAIL \
213 };
214 #endif
215
216 #define DEFAULT_OP_NUM_NEG(m_prefix, m_op_name, m_name, m_type) \
217 CASE_TYPE(m_prefix, m_op_name, m_name) { \
218 _RETURN(-p_a._data.m_type); \
219 };
220
221 #define DEFAULT_OP_NUM_POS(m_prefix, m_op_name, m_name, m_type) \
222 CASE_TYPE(m_prefix, m_op_name, m_name) { \
223 _RETURN(p_a._data.m_type); \
224 };
225
226 #define DEFAULT_OP_NUM_VEC(m_prefix, m_op_name, m_name, m_op, m_type) \
227 CASE_TYPE(m_prefix, m_op_name, m_name) { \
228 if (p_b.type == INT) _RETURN(p_a._data.m_type m_op p_b._data._int); \
229 if (p_b.type == REAL) _RETURN(p_a._data.m_type m_op p_b._data._real); \
230 if (p_b.type == VECTOR2) _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector2 *>(p_b._data._mem)); \
231 if (p_b.type == VECTOR3) _RETURN(p_a._data.m_type m_op *reinterpret_cast<const Vector3 *>(p_b._data._mem)); \
232 \
233 _RETURN_FAIL \
234 };
235
236 #define DEFAULT_OP_STR_REV(m_prefix, m_op_name, m_name, m_op, m_type) \
237 CASE_TYPE(m_prefix, m_op_name, m_name) { \
238 if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const String *>(p_a._data._mem)); \
239 if (p_b.type == NODE_PATH) _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const NodePath *>(p_a._data._mem)); \
240 \
241 _RETURN_FAIL \
242 };
243
244 #define DEFAULT_OP_STR(m_prefix, m_op_name, m_name, m_op, m_type) \
245 CASE_TYPE(m_prefix, m_op_name, m_name) { \
246 if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem)); \
247 if (p_b.type == NODE_PATH) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem)); \
248 \
249 _RETURN_FAIL \
250 };
251
252 #define DEFAULT_OP_STR_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \
253 CASE_TYPE(m_prefix, m_op_name, m_name) { \
254 if (p_b.type == STRING) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const String *>(p_b._data._mem)); \
255 if (p_b.type == NODE_PATH) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const NodePath *>(p_b._data._mem)); \
256 if (p_b.type == NIL) _RETURN(!(p_b.type m_op NIL)); \
257 \
258 _RETURN_FAIL \
259 };
260
261 #define DEFAULT_OP_LOCALMEM_REV(m_prefix, m_op_name, m_name, m_op, m_type) \
262 CASE_TYPE(m_prefix, m_op_name, m_name) { \
263 if (p_b.type == m_name) \
264 _RETURN(*reinterpret_cast<const m_type *>(p_b._data._mem) m_op *reinterpret_cast<const m_type *>(p_a._data._mem)); \
265 \
266 _RETURN_FAIL \
267 };
268
269 #define DEFAULT_OP_LOCALMEM(m_prefix, m_op_name, m_name, m_op, m_type) \
270 CASE_TYPE(m_prefix, m_op_name, m_name) { \
271 if (p_b.type == m_name) \
272 _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const m_type *>(p_b._data._mem)); \
273 \
274 _RETURN_FAIL \
275 };
276
277 #define DEFAULT_OP_LOCALMEM_NULL(m_prefix, m_op_name, m_name, m_op, m_type) \
278 CASE_TYPE(m_prefix, m_op_name, m_name) { \
279 if (p_b.type == m_name) \
280 _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const m_type *>(p_b._data._mem)); \
281 if (p_b.type == NIL) \
282 _RETURN(!(p_b.type m_op NIL)); \
283 \
284 _RETURN_FAIL \
285 };
286
287 #define DEFAULT_OP_LOCALMEM_NEG(m_prefix, m_op_name, m_name, m_type) \
288 CASE_TYPE(m_prefix, m_op_name, m_name) { \
289 _RETURN(-*reinterpret_cast<const m_type *>(p_a._data._mem)); \
290 }
291
292 #define DEFAULT_OP_LOCALMEM_POS(m_prefix, m_op_name, m_name, m_type) \
293 CASE_TYPE(m_prefix, m_op_name, m_name) { \
294 _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem)); \
295 }
296
297 #define DEFAULT_OP_LOCALMEM_NUM(m_prefix, m_op_name, m_name, m_op, m_type) \
298 CASE_TYPE(m_prefix, m_op_name, m_name) { \
299 if (p_b.type == m_name) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op *reinterpret_cast<const m_type *>(p_b._data._mem)); \
300 if (p_b.type == INT) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._int); \
301 if (p_b.type == REAL) _RETURN(*reinterpret_cast<const m_type *>(p_a._data._mem) m_op p_b._data._real); \
302 \
303 _RETURN_FAIL \
304 }
305
306 #define DEFAULT_OP_PTR(m_op, m_name, m_sub) \
307 CASE_TYPE(m_prefix, m_op_name, m_name) { \
308 if (p_b.type == m_name) \
309 _RETURN(p_a._data.m_sub m_op p_b._data.m_sub); \
310 \
311 _RETURN_FAIL \
312 }
313
314 #define DEFAULT_OP_PTRREF(m_prefix, m_op_name, m_name, m_op, m_sub) \
315 CASE_TYPE(m_prefix, m_op_name, m_name) { \
316 if (p_b.type == m_name) \
317 _RETURN(*p_a._data.m_sub m_op *p_b._data.m_sub); \
318 \
319 _RETURN_FAIL \
320 }
321
322 #define DEFAULT_OP_PTRREF_NULL(m_prefix, m_op_name, m_name, m_op, m_sub) \
323 CASE_TYPE(m_prefix, m_op_name, m_name) { \
324 if (p_b.type == m_name) \
325 _RETURN(*p_a._data.m_sub m_op *p_b._data.m_sub); \
326 if (p_b.type == NIL) \
327 _RETURN(!(p_b.type m_op NIL)); \
328 \
329 _RETURN_FAIL \
330 }
331
332 #define DEFAULT_OP_ARRAY_EQ(m_prefix, m_op_name, m_name, m_type) \
333 CASE_TYPE(m_prefix, m_op_name, m_name) { \
334 if (p_b.type == NIL) \
335 _RETURN(false) \
336 DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, !=, !=, true, false, false) \
337 }
338
339 #define DEFAULT_OP_ARRAY_NEQ(m_prefix, m_op_name, m_name, m_type) \
340 CASE_TYPE(m_prefix, m_op_name, m_name) { \
341 if (p_b.type == NIL) \
342 _RETURN(true) \
343 DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, !=, !=, false, true, true) \
344 }
345
346 #define DEFAULT_OP_ARRAY_LT(m_prefix, m_op_name, m_name, m_type) \
347 DEFAULT_OP_ARRAY_OP(m_prefix, m_op_name, m_name, m_type, <, !=, false, a_len < array_b.size(), true)
348
349 #define DEFAULT_OP_ARRAY_GT(m_prefix, m_op_name, m_name, m_type) \
350 DEFAULT_OP_ARRAY_OP(m_prefix, m_op_name, m_name, m_type, >, !=, false, a_len < array_b.size(), true)
351
352 #define DEFAULT_OP_ARRAY_OP(m_prefix, m_op_name, m_name, m_type, m_opa, m_opb, m_ret_def, m_ret_s, m_ret_f) \
353 CASE_TYPE(m_prefix, m_op_name, m_name) { \
354 DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, m_opa, m_opb, m_ret_def, m_ret_s, m_ret_f) \
355 }
356
357 #define DEFAULT_OP_ARRAY_OP_BODY(m_prefix, m_op_name, m_name, m_type, m_opa, m_opb, m_ret_def, m_ret_s, m_ret_f) \
358 if (p_a.type != p_b.type) \
359 _RETURN_FAIL \
360 \
361 const PoolVector<m_type> &array_a = *reinterpret_cast<const PoolVector<m_type> *>(p_a._data._mem); \
362 const PoolVector<m_type> &array_b = *reinterpret_cast<const PoolVector<m_type> *>(p_b._data._mem); \
363 \
364 int a_len = array_a.size(); \
365 if (a_len m_opa array_b.size()) { \
366 _RETURN(m_ret_s); \
367 } else { \
368 \
369 PoolVector<m_type>::Read ra = array_a.read(); \
370 PoolVector<m_type>::Read rb = array_b.read(); \
371 \
372 for (int i = 0; i < a_len; i++) { \
373 if (ra[i] m_opb rb[i]) \
374 _RETURN(m_ret_f); \
375 } \
376 \
377 _RETURN(m_ret_def); \
378 }
379
380 #define DEFAULT_OP_ARRAY_ADD(m_prefix, m_op_name, m_name, m_type) \
381 CASE_TYPE(m_prefix, m_op_name, m_name) { \
382 if (p_a.type != p_b.type) \
383 _RETURN_FAIL; \
384 \
385 const PoolVector<m_type> &array_a = *reinterpret_cast<const PoolVector<m_type> *>(p_a._data._mem); \
386 const PoolVector<m_type> &array_b = *reinterpret_cast<const PoolVector<m_type> *>(p_b._data._mem); \
387 PoolVector<m_type> sum = array_a; \
388 sum.append_array(array_b); \
389 _RETURN(sum); \
390 }
391
evaluate(const Operator & p_op,const Variant & p_a,const Variant & p_b,Variant & r_ret,bool & r_valid)392 void Variant::evaluate(const Operator &p_op, const Variant &p_a,
393 const Variant &p_b, Variant &r_ret, bool &r_valid) {
394
395 CASES(math);
396 r_valid = true;
397
398 SWITCH(math, p_op, p_a.type) {
399 SWITCH_OP(math, OP_EQUAL, p_a.type) {
400 CASE_TYPE(math, OP_EQUAL, NIL) {
401 if (p_b.type == NIL) _RETURN(true);
402 if (p_b.type == OBJECT)
403 _RETURN(_OBJ_PTR(p_b) == NULL);
404
405 _RETURN(false);
406 }
407
408 CASE_TYPE(math, OP_EQUAL, BOOL) {
409 if (p_b.type != BOOL) {
410 if (p_b.type == NIL)
411 _RETURN(false);
412 _RETURN_FAIL;
413 }
414
415 _RETURN(p_a._data._bool == p_b._data._bool);
416 }
417
418 CASE_TYPE(math, OP_EQUAL, OBJECT) {
419 if (p_b.type == OBJECT)
420 _RETURN(_OBJ_PTR(p_a) == _OBJ_PTR(p_b));
421 if (p_b.type == NIL)
422 _RETURN(_OBJ_PTR(p_a) == NULL);
423
424 _RETURN_FAIL;
425 }
426
427 CASE_TYPE(math, OP_EQUAL, DICTIONARY) {
428 if (p_b.type != DICTIONARY) {
429 if (p_b.type == NIL)
430 _RETURN(false);
431 _RETURN_FAIL;
432 }
433
434 const Dictionary *arr_a = reinterpret_cast<const Dictionary *>(p_a._data._mem);
435 const Dictionary *arr_b = reinterpret_cast<const Dictionary *>(p_b._data._mem);
436
437 _RETURN(*arr_a == *arr_b);
438 }
439
440 CASE_TYPE(math, OP_EQUAL, ARRAY) {
441 if (p_b.type != ARRAY) {
442 if (p_b.type == NIL)
443 _RETURN(false);
444 _RETURN_FAIL;
445 }
446 const Array *arr_a = reinterpret_cast<const Array *>(p_a._data._mem);
447 const Array *arr_b = reinterpret_cast<const Array *>(p_b._data._mem);
448
449 int l = arr_a->size();
450 if (arr_b->size() != l)
451 _RETURN(false);
452 for (int i = 0; i < l; i++) {
453 if (!((*arr_a)[i] == (*arr_b)[i])) {
454 _RETURN(false);
455 }
456 }
457
458 _RETURN(true);
459 }
460
461 DEFAULT_OP_NUM_NULL(math, OP_EQUAL, INT, ==, _int);
462 DEFAULT_OP_NUM_NULL(math, OP_EQUAL, REAL, ==, _real);
463 DEFAULT_OP_STR_NULL(math, OP_EQUAL, STRING, ==, String);
464 DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, VECTOR2, ==, Vector2);
465 DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, RECT2, ==, Rect2);
466 DEFAULT_OP_PTRREF_NULL(math, OP_EQUAL, TRANSFORM2D, ==, _transform2d);
467 DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, VECTOR3, ==, Vector3);
468 DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, PLANE, ==, Plane);
469 DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, QUAT, ==, Quat);
470 DEFAULT_OP_PTRREF_NULL(math, OP_EQUAL, AABB, ==, _aabb);
471 DEFAULT_OP_PTRREF_NULL(math, OP_EQUAL, BASIS, ==, _basis);
472 DEFAULT_OP_PTRREF_NULL(math, OP_EQUAL, TRANSFORM, ==, _transform);
473 DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, COLOR, ==, Color);
474 DEFAULT_OP_STR_NULL(math, OP_EQUAL, NODE_PATH, ==, NodePath);
475 DEFAULT_OP_LOCALMEM_NULL(math, OP_EQUAL, _RID, ==, RID);
476
477 DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_BYTE_ARRAY, uint8_t);
478 DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_INT_ARRAY, int);
479 DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_REAL_ARRAY, real_t);
480 DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_STRING_ARRAY, String);
481 DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_VECTOR2_ARRAY, Vector2);
482 DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_VECTOR3_ARRAY, Vector3);
483 DEFAULT_OP_ARRAY_EQ(math, OP_EQUAL, POOL_COLOR_ARRAY, Color);
484 }
485
486 SWITCH_OP(math, OP_NOT_EQUAL, p_a.type) {
487 CASE_TYPE(math, OP_NOT_EQUAL, NIL) {
488 if (p_b.type == NIL) _RETURN(false);
489 if (p_b.type == OBJECT)
490 _RETURN(_OBJ_PTR(p_b) != NULL);
491
492 _RETURN(true);
493 }
494
495 CASE_TYPE(math, OP_NOT_EQUAL, BOOL) {
496 if (p_b.type != BOOL) {
497 if (p_b.type == NIL)
498 _RETURN(true);
499
500 _RETURN_FAIL;
501 }
502
503 _RETURN(p_a._data._bool != p_b._data._bool);
504 }
505
506 CASE_TYPE(math, OP_NOT_EQUAL, OBJECT) {
507 if (p_b.type == OBJECT)
508 _RETURN((_OBJ_PTR(p_a) != _OBJ_PTR(p_b)));
509 if (p_b.type == NIL)
510 _RETURN(_OBJ_PTR(p_a) != NULL);
511
512 _RETURN_FAIL;
513 }
514
515 CASE_TYPE(math, OP_NOT_EQUAL, DICTIONARY) {
516 if (p_b.type != DICTIONARY) {
517 if (p_b.type == NIL)
518 _RETURN(true);
519 _RETURN_FAIL;
520 }
521
522 const Dictionary *arr_a = reinterpret_cast<const Dictionary *>(p_a._data._mem);
523 const Dictionary *arr_b = reinterpret_cast<const Dictionary *>(p_b._data._mem);
524
525 _RETURN(*arr_a != *arr_b);
526 }
527
528 CASE_TYPE(math, OP_NOT_EQUAL, ARRAY) {
529 if (p_b.type != ARRAY) {
530 if (p_b.type == NIL)
531 _RETURN(true);
532
533 _RETURN_FAIL;
534 }
535
536 const Array *arr_a = reinterpret_cast<const Array *>(p_a._data._mem);
537 const Array *arr_b = reinterpret_cast<const Array *>(p_b._data._mem);
538
539 int l = arr_a->size();
540 if (arr_b->size() != l)
541 _RETURN(true);
542 for (int i = 0; i < l; i++) {
543 if (((*arr_a)[i] != (*arr_b)[i])) {
544 _RETURN(true);
545 }
546 }
547
548 _RETURN(false);
549 }
550
551 DEFAULT_OP_NUM_NULL(math, OP_NOT_EQUAL, INT, !=, _int);
552 DEFAULT_OP_NUM_NULL(math, OP_NOT_EQUAL, REAL, !=, _real);
553 DEFAULT_OP_STR_NULL(math, OP_NOT_EQUAL, STRING, !=, String);
554 DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, VECTOR2, !=, Vector2);
555 DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, RECT2, !=, Rect2);
556 DEFAULT_OP_PTRREF_NULL(math, OP_NOT_EQUAL, TRANSFORM2D, !=, _transform2d);
557 DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, VECTOR3, !=, Vector3);
558 DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, PLANE, !=, Plane);
559 DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, QUAT, !=, Quat);
560 DEFAULT_OP_PTRREF_NULL(math, OP_NOT_EQUAL, AABB, !=, _aabb);
561 DEFAULT_OP_PTRREF_NULL(math, OP_NOT_EQUAL, BASIS, !=, _basis);
562 DEFAULT_OP_PTRREF_NULL(math, OP_NOT_EQUAL, TRANSFORM, !=, _transform);
563 DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, COLOR, !=, Color);
564 DEFAULT_OP_STR_NULL(math, OP_NOT_EQUAL, NODE_PATH, !=, NodePath);
565 DEFAULT_OP_LOCALMEM_NULL(math, OP_NOT_EQUAL, _RID, !=, RID);
566
567 DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_BYTE_ARRAY, uint8_t);
568 DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_INT_ARRAY, int);
569 DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_REAL_ARRAY, real_t);
570 DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_STRING_ARRAY, String);
571 DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_VECTOR2_ARRAY, Vector2);
572 DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_VECTOR3_ARRAY, Vector3);
573 DEFAULT_OP_ARRAY_NEQ(math, OP_NOT_EQUAL, POOL_COLOR_ARRAY, Color);
574 }
575
576 SWITCH_OP(math, OP_LESS, p_a.type) {
577 CASE_TYPE(math, OP_LESS, BOOL) {
578 if (p_b.type != BOOL)
579 _RETURN_FAIL;
580
581 if (p_a._data._bool == p_b._data._bool)
582 _RETURN(false);
583
584 if (p_a._data._bool && !p_b._data._bool)
585 _RETURN(false);
586
587 _RETURN(true);
588 }
589
590 CASE_TYPE(math, OP_LESS, OBJECT) {
591 if (p_b.type != OBJECT)
592 _RETURN_FAIL;
593 _RETURN(_OBJ_PTR(p_a) < _OBJ_PTR(p_b));
594 }
595
596 CASE_TYPE(math, OP_LESS, ARRAY) {
597 if (p_b.type != ARRAY)
598 _RETURN_FAIL;
599
600 const Array *arr_a = reinterpret_cast<const Array *>(p_a._data._mem);
601 const Array *arr_b = reinterpret_cast<const Array *>(p_b._data._mem);
602
603 int l = arr_a->size();
604 if (arr_b->size() < l)
605 _RETURN(false);
606 for (int i = 0; i < l; i++) {
607 if (!((*arr_a)[i] < (*arr_b)[i])) {
608 _RETURN(true);
609 }
610 }
611
612 _RETURN(false);
613 }
614
615 DEFAULT_OP_NUM(math, OP_LESS, INT, <, _int);
616 DEFAULT_OP_NUM(math, OP_LESS, REAL, <, _real);
617 DEFAULT_OP_STR(math, OP_LESS, STRING, <, String);
618 DEFAULT_OP_LOCALMEM(math, OP_LESS, VECTOR2, <, Vector2);
619 DEFAULT_OP_LOCALMEM(math, OP_LESS, VECTOR3, <, Vector3);
620 DEFAULT_OP_LOCALMEM(math, OP_LESS, _RID, <, RID);
621 DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_BYTE_ARRAY, uint8_t);
622 DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_INT_ARRAY, int);
623 DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_REAL_ARRAY, real_t);
624 DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_STRING_ARRAY, String);
625 DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_VECTOR2_ARRAY, Vector3);
626 DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_VECTOR3_ARRAY, Vector3);
627 DEFAULT_OP_ARRAY_LT(math, OP_LESS, POOL_COLOR_ARRAY, Color);
628
629 CASE_TYPE(math, OP_LESS, NIL)
630 CASE_TYPE(math, OP_LESS, RECT2)
631 CASE_TYPE(math, OP_LESS, TRANSFORM2D)
632 CASE_TYPE(math, OP_LESS, PLANE)
633 CASE_TYPE(math, OP_LESS, QUAT)
634 CASE_TYPE(math, OP_LESS, AABB)
635 CASE_TYPE(math, OP_LESS, BASIS)
636 CASE_TYPE(math, OP_LESS, TRANSFORM)
637 CASE_TYPE(math, OP_LESS, COLOR)
638 CASE_TYPE(math, OP_LESS, NODE_PATH)
639 CASE_TYPE(math, OP_LESS, DICTIONARY)
640 _RETURN_FAIL;
641 }
642
643 SWITCH_OP(math, OP_LESS_EQUAL, p_a.type) {
644 CASE_TYPE(math, OP_LESS_EQUAL, OBJECT) {
645 if (p_b.type != OBJECT)
646 _RETURN_FAIL;
647 _RETURN(_OBJ_PTR(p_a) <= _OBJ_PTR(p_b));
648 }
649
650 DEFAULT_OP_NUM(math, OP_LESS_EQUAL, INT, <=, _int);
651 DEFAULT_OP_NUM(math, OP_LESS_EQUAL, REAL, <=, _real);
652 DEFAULT_OP_STR(math, OP_LESS_EQUAL, STRING, <=, String);
653 DEFAULT_OP_LOCALMEM(math, OP_LESS_EQUAL, VECTOR2, <=, Vector2);
654 DEFAULT_OP_LOCALMEM(math, OP_LESS_EQUAL, VECTOR3, <=, Vector3);
655 DEFAULT_OP_LOCALMEM(math, OP_LESS_EQUAL, _RID, <=, RID);
656
657 CASE_TYPE(math, OP_LESS_EQUAL, NIL)
658 CASE_TYPE(math, OP_LESS_EQUAL, BOOL)
659 CASE_TYPE(math, OP_LESS_EQUAL, RECT2)
660 CASE_TYPE(math, OP_LESS_EQUAL, TRANSFORM2D)
661 CASE_TYPE(math, OP_LESS_EQUAL, PLANE)
662 CASE_TYPE(math, OP_LESS_EQUAL, QUAT)
663 CASE_TYPE(math, OP_LESS_EQUAL, AABB)
664 CASE_TYPE(math, OP_LESS_EQUAL, BASIS)
665 CASE_TYPE(math, OP_LESS_EQUAL, TRANSFORM)
666 CASE_TYPE(math, OP_LESS_EQUAL, COLOR)
667 CASE_TYPE(math, OP_LESS_EQUAL, NODE_PATH)
668 CASE_TYPE(math, OP_LESS_EQUAL, DICTIONARY)
669 CASE_TYPE(math, OP_LESS_EQUAL, ARRAY)
670 CASE_TYPE(math, OP_LESS_EQUAL, POOL_BYTE_ARRAY);
671 CASE_TYPE(math, OP_LESS_EQUAL, POOL_INT_ARRAY);
672 CASE_TYPE(math, OP_LESS_EQUAL, POOL_REAL_ARRAY);
673 CASE_TYPE(math, OP_LESS_EQUAL, POOL_STRING_ARRAY);
674 CASE_TYPE(math, OP_LESS_EQUAL, POOL_VECTOR2_ARRAY);
675 CASE_TYPE(math, OP_LESS_EQUAL, POOL_VECTOR3_ARRAY);
676 CASE_TYPE(math, OP_LESS_EQUAL, POOL_COLOR_ARRAY);
677 _RETURN_FAIL;
678 }
679
680 SWITCH_OP(math, OP_GREATER, p_a.type) {
681 CASE_TYPE(math, OP_GREATER, BOOL) {
682 if (p_b.type != BOOL)
683 _RETURN_FAIL;
684
685 if (p_a._data._bool == p_b._data._bool)
686 _RETURN(false);
687
688 if (!p_a._data._bool && p_b._data._bool)
689 _RETURN(false);
690
691 _RETURN(true);
692 }
693
694 CASE_TYPE(math, OP_GREATER, OBJECT) {
695 if (p_b.type != OBJECT)
696 _RETURN_FAIL;
697 _RETURN(_OBJ_PTR(p_a) > _OBJ_PTR(p_b));
698 }
699
700 CASE_TYPE(math, OP_GREATER, ARRAY) {
701 if (p_b.type != ARRAY)
702 _RETURN_FAIL;
703
704 const Array *arr_a = reinterpret_cast<const Array *>(p_a._data._mem);
705 const Array *arr_b = reinterpret_cast<const Array *>(p_b._data._mem);
706
707 int l = arr_a->size();
708 if (arr_b->size() > l)
709 _RETURN(false);
710 for (int i = 0; i < l; i++) {
711 if (((*arr_a)[i] < (*arr_b)[i])) {
712 _RETURN(false);
713 }
714 }
715
716 _RETURN(true);
717 }
718
719 DEFAULT_OP_NUM(math, OP_GREATER, INT, >, _int);
720 DEFAULT_OP_NUM(math, OP_GREATER, REAL, >, _real);
721 DEFAULT_OP_STR_REV(math, OP_GREATER, STRING, <, String);
722 DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER, VECTOR2, <, Vector2);
723 DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER, VECTOR3, <, Vector3);
724 DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER, _RID, <, RID);
725 DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_BYTE_ARRAY, uint8_t);
726 DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_INT_ARRAY, int);
727 DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_REAL_ARRAY, real_t);
728 DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_STRING_ARRAY, String);
729 DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_VECTOR2_ARRAY, Vector3);
730 DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_VECTOR3_ARRAY, Vector3);
731 DEFAULT_OP_ARRAY_GT(math, OP_GREATER, POOL_COLOR_ARRAY, Color);
732
733 CASE_TYPE(math, OP_GREATER, NIL)
734 CASE_TYPE(math, OP_GREATER, RECT2)
735 CASE_TYPE(math, OP_GREATER, TRANSFORM2D)
736 CASE_TYPE(math, OP_GREATER, PLANE)
737 CASE_TYPE(math, OP_GREATER, QUAT)
738 CASE_TYPE(math, OP_GREATER, AABB)
739 CASE_TYPE(math, OP_GREATER, BASIS)
740 CASE_TYPE(math, OP_GREATER, TRANSFORM)
741 CASE_TYPE(math, OP_GREATER, COLOR)
742 CASE_TYPE(math, OP_GREATER, NODE_PATH)
743 CASE_TYPE(math, OP_GREATER, DICTIONARY)
744 _RETURN_FAIL;
745 }
746
747 SWITCH_OP(math, OP_GREATER_EQUAL, p_a.type) {
748 CASE_TYPE(math, OP_GREATER_EQUAL, OBJECT) {
749 if (p_b.type != OBJECT)
750 _RETURN_FAIL;
751 _RETURN(_OBJ_PTR(p_a) >= _OBJ_PTR(p_b));
752 }
753
754 DEFAULT_OP_NUM(math, OP_GREATER_EQUAL, INT, >=, _int);
755 DEFAULT_OP_NUM(math, OP_GREATER_EQUAL, REAL, >=, _real);
756 DEFAULT_OP_STR_REV(math, OP_GREATER_EQUAL, STRING, <=, String);
757 DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER_EQUAL, VECTOR2, <=, Vector2);
758 DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER_EQUAL, VECTOR3, <=, Vector3);
759 DEFAULT_OP_LOCALMEM_REV(math, OP_GREATER_EQUAL, _RID, <=, RID);
760
761 CASE_TYPE(math, OP_GREATER_EQUAL, NIL)
762 CASE_TYPE(math, OP_GREATER_EQUAL, BOOL)
763 CASE_TYPE(math, OP_GREATER_EQUAL, RECT2)
764 CASE_TYPE(math, OP_GREATER_EQUAL, TRANSFORM2D)
765 CASE_TYPE(math, OP_GREATER_EQUAL, PLANE)
766 CASE_TYPE(math, OP_GREATER_EQUAL, QUAT)
767 CASE_TYPE(math, OP_GREATER_EQUAL, AABB)
768 CASE_TYPE(math, OP_GREATER_EQUAL, BASIS)
769 CASE_TYPE(math, OP_GREATER_EQUAL, TRANSFORM)
770 CASE_TYPE(math, OP_GREATER_EQUAL, COLOR)
771 CASE_TYPE(math, OP_GREATER_EQUAL, NODE_PATH)
772 CASE_TYPE(math, OP_GREATER_EQUAL, DICTIONARY)
773 CASE_TYPE(math, OP_GREATER_EQUAL, ARRAY)
774 CASE_TYPE(math, OP_GREATER_EQUAL, POOL_BYTE_ARRAY);
775 CASE_TYPE(math, OP_GREATER_EQUAL, POOL_INT_ARRAY);
776 CASE_TYPE(math, OP_GREATER_EQUAL, POOL_REAL_ARRAY);
777 CASE_TYPE(math, OP_GREATER_EQUAL, POOL_STRING_ARRAY);
778 CASE_TYPE(math, OP_GREATER_EQUAL, POOL_VECTOR2_ARRAY);
779 CASE_TYPE(math, OP_GREATER_EQUAL, POOL_VECTOR3_ARRAY);
780 CASE_TYPE(math, OP_GREATER_EQUAL, POOL_COLOR_ARRAY);
781 _RETURN_FAIL;
782 }
783
784 SWITCH_OP(math, OP_ADD, p_a.type) {
785 CASE_TYPE(math, OP_ADD, ARRAY) {
786 if (p_a.type != p_b.type)
787 _RETURN_FAIL;
788
789 const Array &array_a = *reinterpret_cast<const Array *>(p_a._data._mem);
790 const Array &array_b = *reinterpret_cast<const Array *>(p_b._data._mem);
791 Array sum;
792 int asize = array_a.size();
793 int bsize = array_b.size();
794 sum.resize(asize + bsize);
795 for (int i = 0; i < asize; i++)
796 sum[i] = array_a[i];
797 for (int i = 0; i < bsize; i++)
798 sum[i + asize] = array_b[i];
799 _RETURN(sum);
800 }
801
802 DEFAULT_OP_NUM(math, OP_ADD, INT, +, _int);
803 DEFAULT_OP_NUM(math, OP_ADD, REAL, +, _real);
804 DEFAULT_OP_STR(math, OP_ADD, STRING, +, String);
805 DEFAULT_OP_LOCALMEM(math, OP_ADD, VECTOR2, +, Vector2);
806 DEFAULT_OP_LOCALMEM(math, OP_ADD, VECTOR3, +, Vector3);
807 DEFAULT_OP_LOCALMEM(math, OP_ADD, QUAT, +, Quat);
808 DEFAULT_OP_LOCALMEM(math, OP_ADD, COLOR, +, Color);
809
810 DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_BYTE_ARRAY, uint8_t);
811 DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_INT_ARRAY, int);
812 DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_REAL_ARRAY, real_t);
813 DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_STRING_ARRAY, String);
814 DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_VECTOR2_ARRAY, Vector2);
815 DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_VECTOR3_ARRAY, Vector3);
816 DEFAULT_OP_ARRAY_ADD(math, OP_ADD, POOL_COLOR_ARRAY, Color);
817
818 CASE_TYPE(math, OP_ADD, NIL)
819 CASE_TYPE(math, OP_ADD, BOOL)
820 CASE_TYPE(math, OP_ADD, RECT2)
821 CASE_TYPE(math, OP_ADD, TRANSFORM2D)
822 CASE_TYPE(math, OP_ADD, PLANE)
823 CASE_TYPE(math, OP_ADD, AABB)
824 CASE_TYPE(math, OP_ADD, BASIS)
825 CASE_TYPE(math, OP_ADD, TRANSFORM)
826 CASE_TYPE(math, OP_ADD, NODE_PATH)
827 CASE_TYPE(math, OP_ADD, _RID)
828 CASE_TYPE(math, OP_ADD, OBJECT)
829 CASE_TYPE(math, OP_ADD, DICTIONARY)
830 _RETURN_FAIL;
831 }
832
833 SWITCH_OP(math, OP_SUBTRACT, p_a.type) {
834 DEFAULT_OP_NUM(math, OP_SUBTRACT, INT, -, _int);
835 DEFAULT_OP_NUM(math, OP_SUBTRACT, REAL, -, _real);
836 DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, VECTOR2, -, Vector2);
837 DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, VECTOR3, -, Vector3);
838 DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, QUAT, -, Quat);
839 DEFAULT_OP_LOCALMEM(math, OP_SUBTRACT, COLOR, -, Color);
840
841 CASE_TYPE(math, OP_SUBTRACT, NIL)
842 CASE_TYPE(math, OP_SUBTRACT, BOOL)
843 CASE_TYPE(math, OP_SUBTRACT, STRING)
844 CASE_TYPE(math, OP_SUBTRACT, RECT2)
845 CASE_TYPE(math, OP_SUBTRACT, TRANSFORM2D)
846 CASE_TYPE(math, OP_SUBTRACT, PLANE)
847 CASE_TYPE(math, OP_SUBTRACT, AABB)
848 CASE_TYPE(math, OP_SUBTRACT, BASIS)
849 CASE_TYPE(math, OP_SUBTRACT, TRANSFORM)
850 CASE_TYPE(math, OP_SUBTRACT, NODE_PATH)
851 CASE_TYPE(math, OP_SUBTRACT, _RID)
852 CASE_TYPE(math, OP_SUBTRACT, OBJECT)
853 CASE_TYPE(math, OP_SUBTRACT, DICTIONARY)
854 CASE_TYPE(math, OP_SUBTRACT, ARRAY)
855 CASE_TYPE(math, OP_SUBTRACT, POOL_BYTE_ARRAY);
856 CASE_TYPE(math, OP_SUBTRACT, POOL_INT_ARRAY);
857 CASE_TYPE(math, OP_SUBTRACT, POOL_REAL_ARRAY);
858 CASE_TYPE(math, OP_SUBTRACT, POOL_STRING_ARRAY);
859 CASE_TYPE(math, OP_SUBTRACT, POOL_VECTOR2_ARRAY);
860 CASE_TYPE(math, OP_SUBTRACT, POOL_VECTOR3_ARRAY);
861 CASE_TYPE(math, OP_SUBTRACT, POOL_COLOR_ARRAY);
862 _RETURN_FAIL;
863 }
864
865 SWITCH_OP(math, OP_MULTIPLY, p_a.type) {
866 CASE_TYPE(math, OP_MULTIPLY, TRANSFORM2D) {
867 switch (p_b.type) {
868 case TRANSFORM2D: {
869 _RETURN(*p_a._data._transform2d * *p_b._data._transform2d);
870 }
871 case VECTOR2: {
872 _RETURN(p_a._data._transform2d->xform(*(const Vector2 *)p_b._data._mem));
873 }
874 default: _RETURN_FAIL;
875 }
876 }
877
878 CASE_TYPE(math, OP_MULTIPLY, QUAT) {
879 switch (p_b.type) {
880 case VECTOR3: {
881 _RETURN(reinterpret_cast<const Quat *>(p_a._data._mem)->xform(*(const Vector3 *)p_b._data._mem));
882 }
883 case QUAT: {
884 _RETURN(*reinterpret_cast<const Quat *>(p_a._data._mem) * *reinterpret_cast<const Quat *>(p_b._data._mem));
885 }
886 case REAL: {
887 _RETURN(*reinterpret_cast<const Quat *>(p_a._data._mem) * p_b._data._real);
888 }
889 default: _RETURN_FAIL;
890 }
891 }
892
893 CASE_TYPE(math, OP_MULTIPLY, BASIS) {
894 switch (p_b.type) {
895 case VECTOR3: {
896 _RETURN(p_a._data._basis->xform(*(const Vector3 *)p_b._data._mem));
897 }
898 case BASIS: {
899 _RETURN(*p_a._data._basis * *p_b._data._basis);
900 }
901 default: _RETURN_FAIL;
902 }
903 }
904
905 CASE_TYPE(math, OP_MULTIPLY, TRANSFORM) {
906 switch (p_b.type) {
907 case VECTOR3: {
908 _RETURN(p_a._data._transform->xform(*(const Vector3 *)p_b._data._mem));
909 }
910 case TRANSFORM: {
911 _RETURN(*p_a._data._transform * *p_b._data._transform);
912 }
913 default: _RETURN_FAIL;
914 }
915 }
916
917 DEFAULT_OP_NUM_VEC(math, OP_MULTIPLY, INT, *, _int);
918 DEFAULT_OP_NUM_VEC(math, OP_MULTIPLY, REAL, *, _real);
919 DEFAULT_OP_LOCALMEM_NUM(math, OP_MULTIPLY, VECTOR2, *, Vector2);
920 DEFAULT_OP_LOCALMEM_NUM(math, OP_MULTIPLY, VECTOR3, *, Vector3);
921 DEFAULT_OP_LOCALMEM_NUM(math, OP_MULTIPLY, COLOR, *, Color);
922
923 CASE_TYPE(math, OP_MULTIPLY, NIL)
924 CASE_TYPE(math, OP_MULTIPLY, BOOL)
925 CASE_TYPE(math, OP_MULTIPLY, STRING)
926 CASE_TYPE(math, OP_MULTIPLY, RECT2)
927 CASE_TYPE(math, OP_MULTIPLY, PLANE)
928 CASE_TYPE(math, OP_MULTIPLY, AABB)
929 CASE_TYPE(math, OP_MULTIPLY, NODE_PATH)
930 CASE_TYPE(math, OP_MULTIPLY, _RID)
931 CASE_TYPE(math, OP_MULTIPLY, OBJECT)
932 CASE_TYPE(math, OP_MULTIPLY, DICTIONARY)
933 CASE_TYPE(math, OP_MULTIPLY, ARRAY)
934 CASE_TYPE(math, OP_MULTIPLY, POOL_BYTE_ARRAY);
935 CASE_TYPE(math, OP_MULTIPLY, POOL_INT_ARRAY);
936 CASE_TYPE(math, OP_MULTIPLY, POOL_REAL_ARRAY);
937 CASE_TYPE(math, OP_MULTIPLY, POOL_STRING_ARRAY);
938 CASE_TYPE(math, OP_MULTIPLY, POOL_VECTOR2_ARRAY);
939 CASE_TYPE(math, OP_MULTIPLY, POOL_VECTOR3_ARRAY);
940 CASE_TYPE(math, OP_MULTIPLY, POOL_COLOR_ARRAY);
941 _RETURN_FAIL;
942 }
943
944 SWITCH_OP(math, OP_DIVIDE, p_a.type) {
945 CASE_TYPE(math, OP_DIVIDE, QUAT) {
946 if (p_b.type != REAL)
947 _RETURN_FAIL;
948 #ifdef DEBUG_ENABLED
949 if (p_b._data._real == 0) {
950 r_valid = false;
951 _RETURN("Division By Zero");
952 }
953 #endif
954 _RETURN(*reinterpret_cast<const Quat *>(p_a._data._mem) / p_b._data._real);
955 }
956
957 DEFAULT_OP_NUM_DIV(math, OP_DIVIDE, INT, _int);
958 DEFAULT_OP_NUM_DIV(math, OP_DIVIDE, REAL, _real);
959 DEFAULT_OP_LOCALMEM_NUM(math, OP_DIVIDE, VECTOR2, /, Vector2);
960 DEFAULT_OP_LOCALMEM_NUM(math, OP_DIVIDE, VECTOR3, /, Vector3);
961 DEFAULT_OP_LOCALMEM_NUM(math, OP_DIVIDE, COLOR, /, Color);
962
963 CASE_TYPE(math, OP_DIVIDE, NIL)
964 CASE_TYPE(math, OP_DIVIDE, BOOL)
965 CASE_TYPE(math, OP_DIVIDE, STRING)
966 CASE_TYPE(math, OP_DIVIDE, RECT2)
967 CASE_TYPE(math, OP_DIVIDE, TRANSFORM2D)
968 CASE_TYPE(math, OP_DIVIDE, PLANE)
969 CASE_TYPE(math, OP_DIVIDE, AABB)
970 CASE_TYPE(math, OP_DIVIDE, BASIS)
971 CASE_TYPE(math, OP_DIVIDE, TRANSFORM)
972 CASE_TYPE(math, OP_DIVIDE, NODE_PATH)
973 CASE_TYPE(math, OP_DIVIDE, _RID)
974 CASE_TYPE(math, OP_DIVIDE, OBJECT)
975 CASE_TYPE(math, OP_DIVIDE, DICTIONARY)
976 CASE_TYPE(math, OP_DIVIDE, ARRAY)
977 CASE_TYPE(math, OP_DIVIDE, POOL_BYTE_ARRAY);
978 CASE_TYPE(math, OP_DIVIDE, POOL_INT_ARRAY);
979 CASE_TYPE(math, OP_DIVIDE, POOL_REAL_ARRAY);
980 CASE_TYPE(math, OP_DIVIDE, POOL_STRING_ARRAY);
981 CASE_TYPE(math, OP_DIVIDE, POOL_VECTOR2_ARRAY);
982 CASE_TYPE(math, OP_DIVIDE, POOL_VECTOR3_ARRAY);
983 CASE_TYPE(math, OP_DIVIDE, POOL_COLOR_ARRAY);
984 _RETURN_FAIL;
985 }
986
987 SWITCH_OP(math, OP_POSITIVE, p_a.type) {
988 DEFAULT_OP_NUM_POS(math, OP_POSITIVE, INT, _int);
989 DEFAULT_OP_NUM_POS(math, OP_POSITIVE, REAL, _real);
990 DEFAULT_OP_LOCALMEM_POS(math, OP_POSITIVE, VECTOR3, Vector3);
991 DEFAULT_OP_LOCALMEM_POS(math, OP_POSITIVE, PLANE, Plane);
992 DEFAULT_OP_LOCALMEM_POS(math, OP_POSITIVE, QUAT, Quat);
993 DEFAULT_OP_LOCALMEM_POS(math, OP_POSITIVE, VECTOR2, Vector2);
994
995 CASE_TYPE(math, OP_POSITIVE, NIL)
996 CASE_TYPE(math, OP_POSITIVE, BOOL)
997 CASE_TYPE(math, OP_POSITIVE, STRING)
998 CASE_TYPE(math, OP_POSITIVE, RECT2)
999 CASE_TYPE(math, OP_POSITIVE, TRANSFORM2D)
1000 CASE_TYPE(math, OP_POSITIVE, AABB)
1001 CASE_TYPE(math, OP_POSITIVE, BASIS)
1002 CASE_TYPE(math, OP_POSITIVE, TRANSFORM)
1003 CASE_TYPE(math, OP_POSITIVE, COLOR)
1004 CASE_TYPE(math, OP_POSITIVE, NODE_PATH)
1005 CASE_TYPE(math, OP_POSITIVE, _RID)
1006 CASE_TYPE(math, OP_POSITIVE, OBJECT)
1007 CASE_TYPE(math, OP_POSITIVE, DICTIONARY)
1008 CASE_TYPE(math, OP_POSITIVE, ARRAY)
1009 CASE_TYPE(math, OP_POSITIVE, POOL_BYTE_ARRAY)
1010 CASE_TYPE(math, OP_POSITIVE, POOL_INT_ARRAY)
1011 CASE_TYPE(math, OP_POSITIVE, POOL_REAL_ARRAY)
1012 CASE_TYPE(math, OP_POSITIVE, POOL_STRING_ARRAY)
1013 CASE_TYPE(math, OP_POSITIVE, POOL_VECTOR2_ARRAY)
1014 CASE_TYPE(math, OP_POSITIVE, POOL_VECTOR3_ARRAY)
1015 CASE_TYPE(math, OP_POSITIVE, POOL_COLOR_ARRAY)
1016 _RETURN_FAIL;
1017 }
1018
1019 SWITCH_OP(math, OP_NEGATE, p_a.type) {
1020 DEFAULT_OP_NUM_NEG(math, OP_NEGATE, INT, _int);
1021 DEFAULT_OP_NUM_NEG(math, OP_NEGATE, REAL, _real);
1022
1023 DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, VECTOR2, Vector2);
1024 DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, VECTOR3, Vector3);
1025 DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, PLANE, Plane);
1026 DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, QUAT, Quat);
1027 DEFAULT_OP_LOCALMEM_NEG(math, OP_NEGATE, COLOR, Color);
1028
1029 CASE_TYPE(math, OP_NEGATE, NIL)
1030 CASE_TYPE(math, OP_NEGATE, BOOL)
1031 CASE_TYPE(math, OP_NEGATE, STRING)
1032 CASE_TYPE(math, OP_NEGATE, RECT2)
1033 CASE_TYPE(math, OP_NEGATE, TRANSFORM2D)
1034 CASE_TYPE(math, OP_NEGATE, AABB)
1035 CASE_TYPE(math, OP_NEGATE, BASIS)
1036 CASE_TYPE(math, OP_NEGATE, TRANSFORM)
1037 CASE_TYPE(math, OP_NEGATE, NODE_PATH)
1038 CASE_TYPE(math, OP_NEGATE, _RID)
1039 CASE_TYPE(math, OP_NEGATE, OBJECT)
1040 CASE_TYPE(math, OP_NEGATE, DICTIONARY)
1041 CASE_TYPE(math, OP_NEGATE, ARRAY)
1042 CASE_TYPE(math, OP_NEGATE, POOL_BYTE_ARRAY)
1043 CASE_TYPE(math, OP_NEGATE, POOL_INT_ARRAY)
1044 CASE_TYPE(math, OP_NEGATE, POOL_REAL_ARRAY)
1045 CASE_TYPE(math, OP_NEGATE, POOL_STRING_ARRAY)
1046 CASE_TYPE(math, OP_NEGATE, POOL_VECTOR2_ARRAY)
1047 CASE_TYPE(math, OP_NEGATE, POOL_VECTOR3_ARRAY)
1048 CASE_TYPE(math, OP_NEGATE, POOL_COLOR_ARRAY)
1049 _RETURN_FAIL;
1050 }
1051
1052 SWITCH_OP(math, OP_MODULE, p_a.type) {
1053 CASE_TYPE(math, OP_MODULE, INT) {
1054 if (p_b.type != INT)
1055 _RETURN_FAIL;
1056 #ifdef DEBUG_ENABLED
1057 if (p_b._data._int == 0) {
1058 r_valid = false;
1059 _RETURN("Division By Zero");
1060 }
1061 #endif
1062 _RETURN(p_a._data._int % p_b._data._int);
1063 }
1064
1065 CASE_TYPE(math, OP_MODULE, STRING) {
1066 const String *format = reinterpret_cast<const String *>(p_a._data._mem);
1067
1068 String result;
1069 bool error;
1070 if (p_b.type == ARRAY) {
1071 // e.g. "frog %s %d" % ["fish", 12]
1072 const Array *args = reinterpret_cast<const Array *>(p_b._data._mem);
1073 result = format->sprintf(*args, &error);
1074 } else {
1075 // e.g. "frog %d" % 12
1076 Array args;
1077 args.push_back(p_b);
1078 result = format->sprintf(args, &error);
1079 }
1080 r_valid = !error;
1081 _RETURN(result);
1082 }
1083
1084 CASE_TYPE(math, OP_MODULE, NIL)
1085 CASE_TYPE(math, OP_MODULE, BOOL)
1086 CASE_TYPE(math, OP_MODULE, REAL)
1087 CASE_TYPE(math, OP_MODULE, VECTOR2)
1088 CASE_TYPE(math, OP_MODULE, RECT2)
1089 CASE_TYPE(math, OP_MODULE, VECTOR3)
1090 CASE_TYPE(math, OP_MODULE, TRANSFORM2D)
1091 CASE_TYPE(math, OP_MODULE, PLANE)
1092 CASE_TYPE(math, OP_MODULE, QUAT)
1093 CASE_TYPE(math, OP_MODULE, AABB)
1094 CASE_TYPE(math, OP_MODULE, BASIS)
1095 CASE_TYPE(math, OP_MODULE, TRANSFORM)
1096 CASE_TYPE(math, OP_MODULE, COLOR)
1097 CASE_TYPE(math, OP_MODULE, NODE_PATH)
1098 CASE_TYPE(math, OP_MODULE, _RID)
1099 CASE_TYPE(math, OP_MODULE, OBJECT)
1100 CASE_TYPE(math, OP_MODULE, DICTIONARY)
1101 CASE_TYPE(math, OP_MODULE, ARRAY)
1102 CASE_TYPE(math, OP_MODULE, POOL_BYTE_ARRAY)
1103 CASE_TYPE(math, OP_MODULE, POOL_INT_ARRAY)
1104 CASE_TYPE(math, OP_MODULE, POOL_REAL_ARRAY)
1105 CASE_TYPE(math, OP_MODULE, POOL_STRING_ARRAY)
1106 CASE_TYPE(math, OP_MODULE, POOL_VECTOR2_ARRAY)
1107 CASE_TYPE(math, OP_MODULE, POOL_VECTOR3_ARRAY)
1108 CASE_TYPE(math, OP_MODULE, POOL_COLOR_ARRAY)
1109 _RETURN_FAIL;
1110 }
1111
1112 SWITCH_OP(math, OP_STRING_CONCAT, p_a.type) {
1113 CASE_TYPE_ALL(math, OP_STRING_CONCAT)
1114
1115 _RETURN(p_a.operator String() + p_b.operator String());
1116 }
1117
1118 SWITCH_OP(math, OP_SHIFT_LEFT, p_a.type) {
1119 CASE_TYPE(math, OP_SHIFT_LEFT, INT) {
1120 if (p_b.type != INT)
1121 _RETURN_FAIL;
1122 if (p_b._data._int < 0 || p_b._data._int >= 64)
1123 _RETURN_FAIL;
1124 _RETURN(p_a._data._int << p_b._data._int);
1125 }
1126
1127 CASE_TYPE_ALL_BUT_INT(math, OP_SHIFT_LEFT)
1128 _RETURN_FAIL;
1129 }
1130
1131 SWITCH_OP(math, OP_SHIFT_RIGHT, p_a.type) {
1132 CASE_TYPE(math, OP_SHIFT_RIGHT, INT) {
1133 if (p_b.type != INT)
1134 _RETURN_FAIL;
1135 if (p_b._data._int < 0 || p_b._data._int >= 64)
1136 _RETURN_FAIL;
1137 _RETURN(p_a._data._int >> p_b._data._int);
1138 }
1139
1140 CASE_TYPE_ALL_BUT_INT(math, OP_SHIFT_RIGHT)
1141 _RETURN_FAIL;
1142 }
1143
1144 SWITCH_OP(math, OP_BIT_AND, p_a.type) {
1145 CASE_TYPE(math, OP_BIT_AND, INT) {
1146 if (p_b.type != INT)
1147 _RETURN_FAIL;
1148 _RETURN(p_a._data._int & p_b._data._int);
1149 }
1150
1151 CASE_TYPE_ALL_BUT_INT(math, OP_BIT_AND)
1152 _RETURN_FAIL;
1153 }
1154
1155 SWITCH_OP(math, OP_BIT_OR, p_a.type) {
1156 CASE_TYPE(math, OP_BIT_OR, INT) {
1157 if (p_b.type != INT)
1158 _RETURN_FAIL;
1159 _RETURN(p_a._data._int | p_b._data._int);
1160 }
1161
1162 CASE_TYPE_ALL_BUT_INT(math, OP_BIT_OR)
1163 _RETURN_FAIL;
1164 }
1165
1166 SWITCH_OP(math, OP_BIT_XOR, p_a.type) {
1167 CASE_TYPE(math, OP_BIT_XOR, INT) {
1168 if (p_b.type != INT)
1169 _RETURN_FAIL;
1170 _RETURN(p_a._data._int ^ p_b._data._int);
1171 }
1172
1173 CASE_TYPE_ALL_BUT_INT(math, OP_BIT_XOR)
1174 _RETURN_FAIL;
1175 }
1176
1177 SWITCH_OP(math, OP_BIT_NEGATE, p_a.type) {
1178 CASE_TYPE(math, OP_BIT_NEGATE, INT) {
1179 _RETURN(~p_a._data._int);
1180 }
1181
1182 CASE_TYPE_ALL_BUT_INT(math, OP_BIT_NEGATE)
1183 _RETURN_FAIL;
1184 }
1185
1186 SWITCH_OP(math, OP_AND, p_a.type) {
1187 CASE_TYPE_ALL(math, OP_AND) {
1188 bool l = p_a.booleanize();
1189 bool r = p_b.booleanize();
1190
1191 _RETURN(l && r);
1192 }
1193 }
1194
1195 SWITCH_OP(math, OP_OR, p_a.type) {
1196 CASE_TYPE_ALL(math, OP_OR) {
1197 bool l = p_a.booleanize();
1198 bool r = p_b.booleanize();
1199
1200 _RETURN(l || r);
1201 }
1202 }
1203
1204 SWITCH_OP(math, OP_XOR, p_a.type) {
1205 CASE_TYPE_ALL(math, OP_XOR) {
1206 bool l = p_a.booleanize();
1207 bool r = p_b.booleanize();
1208
1209 _RETURN((l || r) && !(l && r));
1210 }
1211 }
1212
1213 SWITCH_OP(math, OP_NOT, p_a.type) {
1214 CASE_TYPE_ALL(math, OP_NOT) {
1215 bool l = p_a.booleanize();
1216 _RETURN(!l);
1217 }
1218 }
1219
1220 SWITCH_OP(math, OP_IN, p_a.type) {
1221 CASE_TYPE_ALL(math, OP_IN)
1222 _RETURN(p_b.in(p_a, &r_valid));
1223 }
1224 }
1225 }
1226
set_named(const StringName & p_index,const Variant & p_value,bool * r_valid)1227 void Variant::set_named(const StringName &p_index, const Variant &p_value, bool *r_valid) {
1228
1229 bool valid = false;
1230 switch (type) {
1231 case VECTOR2: {
1232 if (p_value.type == Variant::INT) {
1233 Vector2 *v = reinterpret_cast<Vector2 *>(_data._mem);
1234 if (p_index == CoreStringNames::singleton->x) {
1235 v->x = p_value._data._int;
1236 valid = true;
1237 } else if (p_index == CoreStringNames::singleton->y) {
1238 v->y = p_value._data._int;
1239 valid = true;
1240 }
1241 } else if (p_value.type == Variant::REAL) {
1242 Vector2 *v = reinterpret_cast<Vector2 *>(_data._mem);
1243 if (p_index == CoreStringNames::singleton->x) {
1244 v->x = p_value._data._real;
1245 valid = true;
1246 } else if (p_index == CoreStringNames::singleton->y) {
1247 v->y = p_value._data._real;
1248 valid = true;
1249 }
1250 }
1251
1252 } break;
1253 case RECT2: {
1254
1255 if (p_value.type == Variant::VECTOR2) {
1256 Rect2 *v = reinterpret_cast<Rect2 *>(_data._mem);
1257 //scalar name
1258 if (p_index == CoreStringNames::singleton->position) {
1259 v->position = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
1260 valid = true;
1261 } else if (p_index == CoreStringNames::singleton->size) {
1262 v->size = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
1263 valid = true;
1264 } else if (p_index == CoreStringNames::singleton->end) {
1265 v->size = *reinterpret_cast<const Vector2 *>(p_value._data._mem) - v->position;
1266 valid = true;
1267 }
1268 }
1269 } break;
1270 case TRANSFORM2D: {
1271
1272 if (p_value.type == Variant::VECTOR2) {
1273 Transform2D *v = _data._transform2d;
1274 if (p_index == CoreStringNames::singleton->x) {
1275 v->elements[0] = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
1276 valid = true;
1277 } else if (p_index == CoreStringNames::singleton->y) {
1278 v->elements[1] = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
1279 valid = true;
1280 } else if (p_index == CoreStringNames::singleton->origin) {
1281 v->elements[2] = *reinterpret_cast<const Vector2 *>(p_value._data._mem);
1282 valid = true;
1283 }
1284 }
1285
1286 } break;
1287 case VECTOR3: {
1288
1289 if (p_value.type == Variant::INT) {
1290 Vector3 *v = reinterpret_cast<Vector3 *>(_data._mem);
1291 if (p_index == CoreStringNames::singleton->x) {
1292 v->x = p_value._data._int;
1293 valid = true;
1294 } else if (p_index == CoreStringNames::singleton->y) {
1295 v->y = p_value._data._int;
1296 valid = true;
1297 } else if (p_index == CoreStringNames::singleton->z) {
1298 v->z = p_value._data._int;
1299 valid = true;
1300 }
1301 } else if (p_value.type == Variant::REAL) {
1302 Vector3 *v = reinterpret_cast<Vector3 *>(_data._mem);
1303 if (p_index == CoreStringNames::singleton->x) {
1304 v->x = p_value._data._real;
1305 valid = true;
1306 } else if (p_index == CoreStringNames::singleton->y) {
1307 v->y = p_value._data._real;
1308 valid = true;
1309 } else if (p_index == CoreStringNames::singleton->z) {
1310 v->z = p_value._data._real;
1311 valid = true;
1312 }
1313 }
1314
1315 } break;
1316 case PLANE: {
1317
1318 if (p_value.type == Variant::INT) {
1319 Plane *v = reinterpret_cast<Plane *>(_data._mem);
1320 if (p_index == CoreStringNames::singleton->x) {
1321 v->normal.x = p_value._data._int;
1322 valid = true;
1323 } else if (p_index == CoreStringNames::singleton->y) {
1324 v->normal.y = p_value._data._int;
1325 valid = true;
1326 } else if (p_index == CoreStringNames::singleton->z) {
1327 v->normal.z = p_value._data._int;
1328 valid = true;
1329 } else if (p_index == CoreStringNames::singleton->d) {
1330 v->d = p_value._data._int;
1331 valid = true;
1332 }
1333 } else if (p_value.type == Variant::REAL) {
1334 Plane *v = reinterpret_cast<Plane *>(_data._mem);
1335 if (p_index == CoreStringNames::singleton->x) {
1336 v->normal.x = p_value._data._real;
1337 valid = true;
1338 } else if (p_index == CoreStringNames::singleton->y) {
1339 v->normal.y = p_value._data._real;
1340 valid = true;
1341 } else if (p_index == CoreStringNames::singleton->z) {
1342 v->normal.z = p_value._data._real;
1343 valid = true;
1344 } else if (p_index == CoreStringNames::singleton->d) {
1345 v->d = p_value._data._real;
1346 valid = true;
1347 }
1348
1349 } else if (p_value.type == Variant::VECTOR3) {
1350 Plane *v = reinterpret_cast<Plane *>(_data._mem);
1351 if (p_index == CoreStringNames::singleton->normal) {
1352 v->normal = *reinterpret_cast<const Vector3 *>(p_value._data._mem);
1353 valid = true;
1354 }
1355 }
1356
1357 } break;
1358 case QUAT: {
1359
1360 if (p_value.type == Variant::INT) {
1361 Quat *v = reinterpret_cast<Quat *>(_data._mem);
1362 if (p_index == CoreStringNames::singleton->x) {
1363 v->x = p_value._data._int;
1364 valid = true;
1365 } else if (p_index == CoreStringNames::singleton->y) {
1366 v->y = p_value._data._int;
1367 valid = true;
1368 } else if (p_index == CoreStringNames::singleton->z) {
1369 v->z = p_value._data._int;
1370 valid = true;
1371 } else if (p_index == CoreStringNames::singleton->w) {
1372 v->w = p_value._data._int;
1373 valid = true;
1374 }
1375 } else if (p_value.type == Variant::REAL) {
1376 Quat *v = reinterpret_cast<Quat *>(_data._mem);
1377 if (p_index == CoreStringNames::singleton->x) {
1378 v->x = p_value._data._real;
1379 valid = true;
1380 } else if (p_index == CoreStringNames::singleton->y) {
1381 v->y = p_value._data._real;
1382 valid = true;
1383 } else if (p_index == CoreStringNames::singleton->z) {
1384 v->z = p_value._data._real;
1385 valid = true;
1386 } else if (p_index == CoreStringNames::singleton->w) {
1387 v->w = p_value._data._real;
1388 valid = true;
1389 }
1390 }
1391
1392 } break; // 10
1393 case AABB: {
1394
1395 if (p_value.type == Variant::VECTOR3) {
1396 ::AABB *v = _data._aabb;
1397 //scalar name
1398 if (p_index == CoreStringNames::singleton->position) {
1399 v->position = *reinterpret_cast<const Vector3 *>(p_value._data._mem);
1400 valid = true;
1401 } else if (p_index == CoreStringNames::singleton->size) {
1402 v->size = *reinterpret_cast<const Vector3 *>(p_value._data._mem);
1403 valid = true;
1404 } else if (p_index == CoreStringNames::singleton->end) {
1405 v->size = *reinterpret_cast<const Vector3 *>(p_value._data._mem) - v->position;
1406 valid = true;
1407 }
1408 }
1409 } break;
1410 case BASIS: {
1411
1412 if (p_value.type == Variant::VECTOR3) {
1413 Basis *v = _data._basis;
1414 //scalar name
1415 if (p_index == CoreStringNames::singleton->x) {
1416 v->set_axis(0, *reinterpret_cast<const Vector3 *>(p_value._data._mem));
1417 valid = true;
1418 } else if (p_index == CoreStringNames::singleton->y) {
1419 v->set_axis(1, *reinterpret_cast<const Vector3 *>(p_value._data._mem));
1420 valid = true;
1421 } else if (p_index == CoreStringNames::singleton->z) {
1422 v->set_axis(2, *reinterpret_cast<const Vector3 *>(p_value._data._mem));
1423 valid = true;
1424 }
1425 }
1426 } break;
1427 case TRANSFORM: {
1428
1429 if (p_value.type == Variant::BASIS && p_index == CoreStringNames::singleton->basis) {
1430 _data._transform->basis = *p_value._data._basis;
1431 valid = true;
1432 } else if (p_value.type == Variant::VECTOR3 && p_index == CoreStringNames::singleton->origin) {
1433 _data._transform->origin = *reinterpret_cast<const Vector3 *>(p_value._data._mem);
1434 valid = true;
1435 }
1436
1437 } break;
1438 case COLOR: {
1439
1440 if (p_value.type == Variant::INT) {
1441 Color *v = reinterpret_cast<Color *>(_data._mem);
1442 if (p_index == CoreStringNames::singleton->r) {
1443 v->r = p_value._data._int;
1444 valid = true;
1445 } else if (p_index == CoreStringNames::singleton->g) {
1446 v->g = p_value._data._int;
1447 valid = true;
1448 } else if (p_index == CoreStringNames::singleton->b) {
1449 v->b = p_value._data._int;
1450 valid = true;
1451 } else if (p_index == CoreStringNames::singleton->a) {
1452 v->a = p_value._data._int;
1453 valid = true;
1454 } else if (p_index == CoreStringNames::singleton->r8) {
1455 v->r = p_value._data._int / 255.0;
1456 valid = true;
1457 } else if (p_index == CoreStringNames::singleton->g8) {
1458 v->g = p_value._data._int / 255.0;
1459 valid = true;
1460 } else if (p_index == CoreStringNames::singleton->b8) {
1461 v->b = p_value._data._int / 255.0;
1462 valid = true;
1463 } else if (p_index == CoreStringNames::singleton->a8) {
1464 v->a = p_value._data._int / 255.0;
1465 valid = true;
1466 } else if (p_index == CoreStringNames::singleton->h) {
1467 v->set_hsv(p_value._data._int, v->get_s(), v->get_v(), v->a);
1468 valid = true;
1469 } else if (p_index == CoreStringNames::singleton->s) {
1470 v->set_hsv(v->get_h(), p_value._data._int, v->get_v(), v->a);
1471 valid = true;
1472 } else if (p_index == CoreStringNames::singleton->v) {
1473 v->set_hsv(v->get_h(), v->get_v(), p_value._data._int, v->a);
1474 valid = true;
1475 }
1476 } else if (p_value.type == Variant::REAL) {
1477 Color *v = reinterpret_cast<Color *>(_data._mem);
1478 if (p_index == CoreStringNames::singleton->r) {
1479 v->r = p_value._data._real;
1480 valid = true;
1481 } else if (p_index == CoreStringNames::singleton->g) {
1482 v->g = p_value._data._real;
1483 valid = true;
1484 } else if (p_index == CoreStringNames::singleton->b) {
1485 v->b = p_value._data._real;
1486 valid = true;
1487 } else if (p_index == CoreStringNames::singleton->a) {
1488 v->a = p_value._data._real;
1489 valid = true;
1490 } else if (p_index == CoreStringNames::singleton->r8) {
1491 v->r = p_value._data._real / 255.0;
1492 valid = true;
1493 } else if (p_index == CoreStringNames::singleton->g8) {
1494 v->g = p_value._data._real / 255.0;
1495 valid = true;
1496 } else if (p_index == CoreStringNames::singleton->b8) {
1497 v->b = p_value._data._real / 255.0;
1498 valid = true;
1499 } else if (p_index == CoreStringNames::singleton->a8) {
1500 v->a = p_value._data._real / 255.0;
1501 valid = true;
1502 } else if (p_index == CoreStringNames::singleton->h) {
1503 v->set_hsv(p_value._data._real, v->get_s(), v->get_v(), v->a);
1504 valid = true;
1505 } else if (p_index == CoreStringNames::singleton->s) {
1506 v->set_hsv(v->get_h(), p_value._data._real, v->get_v(), v->a);
1507 valid = true;
1508 } else if (p_index == CoreStringNames::singleton->v) {
1509 v->set_hsv(v->get_h(), v->get_s(), p_value._data._real, v->a);
1510 valid = true;
1511 }
1512 }
1513 } break;
1514 case OBJECT: {
1515
1516 Object *obj = _OBJ_PTR(*this);
1517 #ifdef DEBUG_ENABLED
1518 if (unlikely(!obj)) {
1519 if (ScriptDebugger::get_singleton() && _get_obj().rc && !ObjectDB::get_instance(_get_obj().rc->instance_id)) {
1520 WARN_PRINT("Attempted set on a deleted object.");
1521 }
1522 break;
1523 }
1524 #endif
1525 obj->set(p_index, p_value, &valid);
1526
1527 } break;
1528 default: {
1529 set(p_index.operator String(), p_value, &valid);
1530 } break;
1531 }
1532
1533 if (r_valid) {
1534 *r_valid = valid;
1535 }
1536 }
1537
get_named(const StringName & p_index,bool * r_valid) const1538 Variant Variant::get_named(const StringName &p_index, bool *r_valid) const {
1539
1540 if (r_valid) {
1541 *r_valid = true;
1542 }
1543 switch (type) {
1544 case VECTOR2: {
1545 const Vector2 *v = reinterpret_cast<const Vector2 *>(_data._mem);
1546 if (p_index == CoreStringNames::singleton->x) {
1547 return v->x;
1548 } else if (p_index == CoreStringNames::singleton->y) {
1549 return v->y;
1550 }
1551
1552 } break;
1553 case RECT2: {
1554
1555 const Rect2 *v = reinterpret_cast<const Rect2 *>(_data._mem);
1556 //scalar name
1557 if (p_index == CoreStringNames::singleton->position) {
1558 return v->position;
1559 } else if (p_index == CoreStringNames::singleton->size) {
1560 return v->size;
1561 } else if (p_index == CoreStringNames::singleton->end) {
1562 return v->size + v->position;
1563 }
1564 } break;
1565 case TRANSFORM2D: {
1566
1567 const Transform2D *v = _data._transform2d;
1568 if (p_index == CoreStringNames::singleton->x) {
1569 return v->elements[0];
1570 } else if (p_index == CoreStringNames::singleton->y) {
1571 return v->elements[1];
1572 } else if (p_index == CoreStringNames::singleton->origin) {
1573 return v->elements[2];
1574 }
1575
1576 } break;
1577 case VECTOR3: {
1578
1579 const Vector3 *v = reinterpret_cast<const Vector3 *>(_data._mem);
1580 if (p_index == CoreStringNames::singleton->x) {
1581 return v->x;
1582 } else if (p_index == CoreStringNames::singleton->y) {
1583 return v->y;
1584 } else if (p_index == CoreStringNames::singleton->z) {
1585 return v->z;
1586 }
1587
1588 } break;
1589 case PLANE: {
1590
1591 const Plane *v = reinterpret_cast<const Plane *>(_data._mem);
1592 if (p_index == CoreStringNames::singleton->x) {
1593 return v->normal.x;
1594 } else if (p_index == CoreStringNames::singleton->y) {
1595 return v->normal.y;
1596 } else if (p_index == CoreStringNames::singleton->z) {
1597 return v->normal.z;
1598 } else if (p_index == CoreStringNames::singleton->d) {
1599 return v->d;
1600 } else if (p_index == CoreStringNames::singleton->normal) {
1601 return v->normal;
1602 }
1603
1604 } break;
1605 case QUAT: {
1606
1607 const Quat *v = reinterpret_cast<const Quat *>(_data._mem);
1608 if (p_index == CoreStringNames::singleton->x) {
1609 return v->x;
1610 } else if (p_index == CoreStringNames::singleton->y) {
1611 return v->y;
1612 } else if (p_index == CoreStringNames::singleton->z) {
1613 return v->z;
1614 } else if (p_index == CoreStringNames::singleton->w) {
1615 return v->w;
1616 }
1617
1618 } break; // 10
1619 case AABB: {
1620
1621 const ::AABB *v = _data._aabb;
1622 //scalar name
1623 if (p_index == CoreStringNames::singleton->position) {
1624 return v->position;
1625 } else if (p_index == CoreStringNames::singleton->size) {
1626 return v->size;
1627 } else if (p_index == CoreStringNames::singleton->end) {
1628 return v->size + v->position;
1629 }
1630 } break;
1631 case BASIS: {
1632
1633 const Basis *v = _data._basis;
1634 //scalar name
1635 if (p_index == CoreStringNames::singleton->x) {
1636 return v->get_axis(0);
1637 } else if (p_index == CoreStringNames::singleton->y) {
1638 return v->get_axis(1);
1639 } else if (p_index == CoreStringNames::singleton->z) {
1640 return v->get_axis(2);
1641 }
1642
1643 } break;
1644 case TRANSFORM: {
1645
1646 if (p_index == CoreStringNames::singleton->basis) {
1647 return _data._transform->basis;
1648 } else if (p_index == CoreStringNames::singleton->origin) {
1649 return _data._transform->origin;
1650 }
1651
1652 } break;
1653 case COLOR: {
1654
1655 const Color *v = reinterpret_cast<const Color *>(_data._mem);
1656 if (p_index == CoreStringNames::singleton->r) {
1657 return v->r;
1658 } else if (p_index == CoreStringNames::singleton->g) {
1659 return v->g;
1660 } else if (p_index == CoreStringNames::singleton->b) {
1661 return v->b;
1662 } else if (p_index == CoreStringNames::singleton->a) {
1663 return v->a;
1664 } else if (p_index == CoreStringNames::singleton->r8) {
1665 return int(Math::round(v->r * 255.0));
1666 } else if (p_index == CoreStringNames::singleton->g8) {
1667 return int(Math::round(v->g * 255.0));
1668 } else if (p_index == CoreStringNames::singleton->b8) {
1669 return int(Math::round(v->b * 255.0));
1670 } else if (p_index == CoreStringNames::singleton->a8) {
1671 return int(Math::round(v->a * 255.0));
1672 } else if (p_index == CoreStringNames::singleton->h) {
1673 return v->get_h();
1674 } else if (p_index == CoreStringNames::singleton->s) {
1675 return v->get_s();
1676 } else if (p_index == CoreStringNames::singleton->v) {
1677 return v->get_v();
1678 }
1679 } break;
1680 case OBJECT: {
1681
1682 Object *obj = _OBJ_PTR(*this);
1683 #ifdef DEBUG_ENABLED
1684 if (unlikely(!obj)) {
1685 if (r_valid)
1686 *r_valid = false;
1687 if (ScriptDebugger::get_singleton() && _get_obj().rc && !ObjectDB::get_instance(_get_obj().rc->instance_id)) {
1688 WARN_PRINT("Attempted get on a deleted object.");
1689 }
1690 return Variant();
1691 }
1692 #endif
1693
1694 return obj->get(p_index, r_valid);
1695
1696 } break;
1697 default: {
1698 return get(p_index.operator String(), r_valid);
1699 }
1700 }
1701
1702 if (r_valid) {
1703 *r_valid = false;
1704 }
1705 return Variant();
1706 }
1707
1708 #define DEFAULT_OP_ARRAY_CMD(m_name, m_type, skip_test, cmd) \
1709 case m_name: { \
1710 skip_test; \
1711 \
1712 if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) { \
1713 int index = p_index; \
1714 m_type *arr = reinterpret_cast<m_type *>(_data._mem); \
1715 \
1716 if (index < 0) \
1717 index += arr->size(); \
1718 if (index >= 0 && index < arr->size()) { \
1719 valid = true; \
1720 cmd; \
1721 } \
1722 } \
1723 } break;
1724
1725 #define DEFAULT_OP_DVECTOR_SET(m_name, dv_type, skip_cond) \
1726 DEFAULT_OP_ARRAY_CMD(m_name, PoolVector<dv_type>, if (skip_cond) return;, arr->set(index, p_value); return )
1727
1728 #define DEFAULT_OP_DVECTOR_GET(m_name, dv_type) \
1729 DEFAULT_OP_ARRAY_CMD(m_name, const PoolVector<dv_type>, ;, return arr->get(index))
1730
set(const Variant & p_index,const Variant & p_value,bool * r_valid)1731 void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) {
1732
1733 static bool _dummy = false;
1734
1735 bool &valid = r_valid ? *r_valid : _dummy;
1736 valid = false;
1737
1738 switch (type) {
1739 case NIL: {
1740 return;
1741 } break;
1742 case BOOL: {
1743 return;
1744 } break;
1745 case INT: {
1746 return;
1747 } break;
1748 case REAL: {
1749 return;
1750 } break;
1751 case STRING: {
1752
1753 if (p_index.type != Variant::INT && p_index.type != Variant::REAL)
1754 return;
1755
1756 int idx = p_index;
1757 String *str = reinterpret_cast<String *>(_data._mem);
1758 int len = str->length();
1759 if (idx < 0)
1760 idx += len;
1761 if (idx < 0 || idx >= len)
1762 return;
1763
1764 String chr;
1765 if (p_value.type == Variant::INT || p_value.type == Variant::REAL) {
1766
1767 chr = String::chr(p_value);
1768 } else if (p_value.type == Variant::STRING) {
1769
1770 chr = p_value;
1771 } else {
1772 return;
1773 }
1774
1775 *str = str->substr(0, idx) + chr + str->substr(idx + 1, len);
1776 valid = true;
1777 return;
1778
1779 } break;
1780 case VECTOR2: {
1781
1782 if (p_value.type != Variant::INT && p_value.type != Variant::REAL)
1783 return;
1784
1785 if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
1786 // scalar index
1787 int idx = p_index;
1788
1789 if (idx < 0)
1790 idx += 2;
1791 if (idx >= 0 && idx < 2) {
1792
1793 Vector2 *v = reinterpret_cast<Vector2 *>(_data._mem);
1794 valid = true;
1795 (*v)[idx] = p_value;
1796 return;
1797 }
1798 } else if (p_index.get_type() == Variant::STRING) {
1799 //scalar name
1800
1801 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
1802 Vector2 *v = reinterpret_cast<Vector2 *>(_data._mem);
1803 if (*str == "x") {
1804 valid = true;
1805 v->x = p_value;
1806 return;
1807 } else if (*str == "y") {
1808 valid = true;
1809 v->y = p_value;
1810 return;
1811 }
1812 }
1813
1814 } break; // 5
1815 case RECT2: {
1816
1817 if (p_value.type != Variant::VECTOR2)
1818 return;
1819
1820 if (p_index.get_type() == Variant::STRING) {
1821 //scalar name
1822
1823 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
1824 Rect2 *v = reinterpret_cast<Rect2 *>(_data._mem);
1825 if (*str == "position") {
1826 valid = true;
1827 v->position = p_value;
1828 return;
1829 } else if (*str == "size") {
1830 valid = true;
1831 v->size = p_value;
1832 return;
1833 } else if (*str == "end") {
1834 valid = true;
1835 v->size = Vector2(p_value) - v->position;
1836 return;
1837 }
1838 }
1839 } break;
1840 case TRANSFORM2D: {
1841
1842 if (p_value.type != Variant::VECTOR2)
1843 return;
1844
1845 if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
1846
1847 int index = p_index;
1848
1849 if (index < 0)
1850 index += 3;
1851 if (index >= 0 && index < 3) {
1852 Transform2D *v = _data._transform2d;
1853
1854 valid = true;
1855 v->elements[index] = p_value;
1856 return;
1857 }
1858 } else if (p_index.get_type() == Variant::STRING && p_value.get_type() == Variant::VECTOR2) {
1859
1860 //scalar name
1861 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
1862 Transform2D *v = _data._transform2d;
1863 if (*str == "x") {
1864 valid = true;
1865 v->elements[0] = p_value;
1866 return;
1867 } else if (*str == "y") {
1868 valid = true;
1869 v->elements[1] = p_value;
1870 return;
1871 } else if (*str == "origin") {
1872 valid = true;
1873 v->elements[2] = p_value;
1874 return;
1875 }
1876 }
1877
1878 } break;
1879 case VECTOR3: {
1880
1881 if (p_value.type != Variant::INT && p_value.type != Variant::REAL)
1882 return;
1883
1884 if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
1885 //scalar index
1886 int idx = p_index;
1887 if (idx < 0)
1888 idx += 3;
1889 if (idx >= 0 && idx < 3) {
1890
1891 Vector3 *v = reinterpret_cast<Vector3 *>(_data._mem);
1892 valid = true;
1893 (*v)[idx] = p_value;
1894 return;
1895 }
1896 } else if (p_index.get_type() == Variant::STRING) {
1897
1898 //scalar name
1899 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
1900 Vector3 *v = reinterpret_cast<Vector3 *>(_data._mem);
1901 if (*str == "x") {
1902 valid = true;
1903 v->x = p_value;
1904 return;
1905 } else if (*str == "y") {
1906 valid = true;
1907 v->y = p_value;
1908 return;
1909 } else if (*str == "z") {
1910 valid = true;
1911 v->z = p_value;
1912 return;
1913 }
1914 }
1915
1916 } break;
1917 case PLANE: {
1918
1919 if (p_index.get_type() == Variant::STRING) {
1920 //scalar name
1921 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
1922 Plane *v = reinterpret_cast<Plane *>(_data._mem);
1923 if (*str == "x") {
1924 if (p_value.type != Variant::INT && p_value.type != Variant::REAL)
1925 return;
1926
1927 valid = true;
1928 v->normal.x = p_value;
1929 return;
1930 } else if (*str == "y") {
1931 if (p_value.type != Variant::INT && p_value.type != Variant::REAL)
1932 return;
1933
1934 valid = true;
1935 v->normal.y = p_value;
1936 return;
1937 } else if (*str == "z") {
1938 if (p_value.type != Variant::INT && p_value.type != Variant::REAL)
1939 return;
1940
1941 valid = true;
1942 v->normal.z = p_value;
1943 return;
1944 } else if (*str == "normal") {
1945 if (p_value.type != Variant::VECTOR3)
1946 return;
1947
1948 valid = true;
1949 v->normal = p_value;
1950 return;
1951 } else if (*str == "d") {
1952 valid = true;
1953 v->d = p_value;
1954 return;
1955 }
1956 }
1957
1958 } break;
1959 case QUAT: {
1960
1961 if (p_value.type != Variant::INT && p_value.type != Variant::REAL)
1962 return;
1963
1964 if (p_index.get_type() == Variant::STRING) {
1965
1966 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
1967 Quat *v = reinterpret_cast<Quat *>(_data._mem);
1968 if (*str == "x") {
1969 valid = true;
1970 v->x = p_value;
1971 return;
1972 } else if (*str == "y") {
1973 valid = true;
1974 v->y = p_value;
1975 return;
1976 } else if (*str == "z") {
1977 valid = true;
1978 v->z = p_value;
1979 return;
1980 } else if (*str == "w") {
1981 valid = true;
1982 v->w = p_value;
1983 return;
1984 }
1985 }
1986
1987 } break; // 10
1988 case AABB: {
1989
1990 if (p_value.type != Variant::VECTOR3)
1991 return;
1992
1993 if (p_index.get_type() == Variant::STRING) {
1994 //scalar name
1995
1996 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
1997 ::AABB *v = _data._aabb;
1998 if (*str == "position") {
1999 valid = true;
2000 v->position = p_value;
2001 return;
2002 } else if (*str == "size") {
2003 valid = true;
2004 v->size = p_value;
2005 return;
2006 } else if (*str == "end") {
2007 valid = true;
2008 v->size = Vector3(p_value) - v->position;
2009 return;
2010 }
2011 }
2012 } break;
2013 case BASIS: {
2014
2015 if (p_value.type != Variant::VECTOR3)
2016 return;
2017
2018 if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
2019
2020 int index = p_index;
2021
2022 if (index < 0)
2023 index += 3;
2024 if (index >= 0 && index < 3) {
2025 Basis *v = _data._basis;
2026
2027 valid = true;
2028 v->set_axis(index, p_value);
2029 return;
2030 }
2031 } else if (p_index.get_type() == Variant::STRING) {
2032
2033 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
2034 Basis *v = _data._basis;
2035
2036 if (*str == "x") {
2037 valid = true;
2038 v->set_axis(0, p_value);
2039 return;
2040 } else if (*str == "y") {
2041 valid = true;
2042 v->set_axis(1, p_value);
2043 return;
2044 } else if (*str == "z") {
2045 valid = true;
2046 v->set_axis(2, p_value);
2047 return;
2048 }
2049 }
2050
2051 } break;
2052 case TRANSFORM: {
2053
2054 if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
2055
2056 if (p_value.type != Variant::VECTOR3)
2057 return;
2058
2059 int index = p_index;
2060
2061 if (index < 0)
2062 index += 4;
2063 if (index >= 0 && index < 4) {
2064 Transform *v = _data._transform;
2065 valid = true;
2066 if (index == 3)
2067 v->origin = p_value;
2068 else
2069 v->basis.set_axis(index, p_value);
2070 return;
2071 }
2072 } else if (p_index.get_type() == Variant::STRING) {
2073
2074 Transform *v = _data._transform;
2075 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
2076
2077 if (*str == "basis") {
2078
2079 if (p_value.type != Variant::BASIS)
2080 return;
2081 valid = true;
2082 v->basis = p_value;
2083 return;
2084 }
2085 if (*str == "origin") {
2086 if (p_value.type != Variant::VECTOR3)
2087 return;
2088 valid = true;
2089 v->origin = p_value;
2090 return;
2091 }
2092 }
2093
2094 } break;
2095 case COLOR: {
2096
2097 if (p_value.type != Variant::INT && p_value.type != Variant::REAL)
2098 return;
2099
2100 if (p_index.get_type() == Variant::STRING) {
2101
2102 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
2103 Color *v = reinterpret_cast<Color *>(_data._mem);
2104 if (*str == "r") {
2105 valid = true;
2106 v->r = p_value;
2107 return;
2108 } else if (*str == "g") {
2109 valid = true;
2110 v->g = p_value;
2111 return;
2112 } else if (*str == "b") {
2113 valid = true;
2114 v->b = p_value;
2115 return;
2116 } else if (*str == "a") {
2117 valid = true;
2118 v->a = p_value;
2119 return;
2120 } else if (*str == "h") {
2121 valid = true;
2122 v->set_hsv(p_value, v->get_s(), v->get_v(), v->a);
2123 return;
2124 } else if (*str == "s") {
2125 valid = true;
2126 v->set_hsv(v->get_h(), p_value, v->get_v(), v->a);
2127 return;
2128 } else if (*str == "v") {
2129 valid = true;
2130 v->set_hsv(v->get_h(), v->get_s(), p_value, v->a);
2131 return;
2132 } else if (*str == "r8") {
2133 valid = true;
2134 v->r = float(p_value) / 255.0;
2135 return;
2136 } else if (*str == "g8") {
2137 valid = true;
2138 v->g = float(p_value) / 255.0;
2139 return;
2140 } else if (*str == "b8") {
2141 valid = true;
2142 v->b = float(p_value) / 255.0;
2143 return;
2144 } else if (*str == "a8") {
2145 valid = true;
2146 v->a = float(p_value) / 255.0;
2147 return;
2148 }
2149 } else if (p_index.get_type() == Variant::INT) {
2150
2151 int idx = p_index;
2152 if (idx < 0)
2153 idx += 4;
2154 if (idx >= 0 && idx < 4) {
2155 Color *v = reinterpret_cast<Color *>(_data._mem);
2156 (*v)[idx] = p_value;
2157 valid = true;
2158 }
2159 }
2160
2161 } break;
2162 case NODE_PATH: {
2163 } break; // 15
2164 case _RID: {
2165 } break;
2166 case OBJECT: {
2167
2168 Object *obj = _OBJ_PTR(*this);
2169 if (unlikely(!obj)) {
2170 #ifdef DEBUG_ENABLED
2171 valid = false;
2172 if (ScriptDebugger::get_singleton() && _get_obj().rc && !ObjectDB::get_instance(_get_obj().rc->instance_id)) {
2173 WARN_PRINT("Attempted set on a deleted object.");
2174 }
2175 #endif
2176 return;
2177 }
2178
2179 if (p_index.get_type() != Variant::STRING) {
2180 obj->setvar(p_index, p_value, r_valid);
2181 return;
2182 }
2183
2184 obj->set(p_index, p_value, r_valid);
2185 return;
2186 } break;
2187 case DICTIONARY: {
2188
2189 Dictionary *dic = reinterpret_cast<Dictionary *>(_data._mem);
2190 dic->operator[](p_index) = p_value;
2191 valid = true; //always valid, i guess? should this really be ok?
2192 return;
2193 } break;
2194 DEFAULT_OP_ARRAY_CMD(ARRAY, Array, ;, (*arr)[index] = p_value; return ) // 20
2195 DEFAULT_OP_DVECTOR_SET(POOL_BYTE_ARRAY, uint8_t, p_value.type != Variant::REAL && p_value.type != Variant::INT)
2196 DEFAULT_OP_DVECTOR_SET(POOL_INT_ARRAY, int, p_value.type != Variant::REAL && p_value.type != Variant::INT)
2197 DEFAULT_OP_DVECTOR_SET(POOL_REAL_ARRAY, real_t, p_value.type != Variant::REAL && p_value.type != Variant::INT)
2198 DEFAULT_OP_DVECTOR_SET(POOL_STRING_ARRAY, String, p_value.type != Variant::STRING)
2199 DEFAULT_OP_DVECTOR_SET(POOL_VECTOR2_ARRAY, Vector2, p_value.type != Variant::VECTOR2) // 25
2200 DEFAULT_OP_DVECTOR_SET(POOL_VECTOR3_ARRAY, Vector3, p_value.type != Variant::VECTOR3)
2201 DEFAULT_OP_DVECTOR_SET(POOL_COLOR_ARRAY, Color, p_value.type != Variant::COLOR)
2202 default:
2203 return;
2204 }
2205 }
2206
get(const Variant & p_index,bool * r_valid) const2207 Variant Variant::get(const Variant &p_index, bool *r_valid) const {
2208
2209 static bool _dummy = false;
2210
2211 bool &valid = r_valid ? *r_valid : _dummy;
2212
2213 valid = false;
2214
2215 switch (type) {
2216 case NIL: {
2217 return Variant();
2218 } break;
2219 case BOOL: {
2220 return Variant();
2221 } break;
2222 case INT: {
2223 return Variant();
2224 } break;
2225 case REAL: {
2226 return Variant();
2227 } break;
2228 case STRING: {
2229
2230 if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
2231 //string index
2232
2233 int idx = p_index;
2234 const String *str = reinterpret_cast<const String *>(_data._mem);
2235 if (idx < 0)
2236 idx += str->length();
2237 if (idx >= 0 && idx < str->length()) {
2238
2239 valid = true;
2240 return str->substr(idx, 1);
2241 }
2242 }
2243
2244 } break;
2245 case VECTOR2: {
2246
2247 if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
2248 // scalar index
2249 int idx = p_index;
2250 if (idx < 0)
2251 idx += 2;
2252 if (idx >= 0 && idx < 2) {
2253
2254 const Vector2 *v = reinterpret_cast<const Vector2 *>(_data._mem);
2255 valid = true;
2256 return (*v)[idx];
2257 }
2258 } else if (p_index.get_type() == Variant::STRING) {
2259 //scalar name
2260
2261 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
2262 const Vector2 *v = reinterpret_cast<const Vector2 *>(_data._mem);
2263 if (*str == "x") {
2264 valid = true;
2265 return v->x;
2266 } else if (*str == "y") {
2267 valid = true;
2268 return v->y;
2269 }
2270 }
2271
2272 } break; // 5
2273 case RECT2: {
2274
2275 if (p_index.get_type() == Variant::STRING) {
2276 //scalar name
2277
2278 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
2279 const Rect2 *v = reinterpret_cast<const Rect2 *>(_data._mem);
2280 if (*str == "position") {
2281 valid = true;
2282 return v->position;
2283 } else if (*str == "size") {
2284 valid = true;
2285 return v->size;
2286 } else if (*str == "end") {
2287 valid = true;
2288 return v->size + v->position;
2289 }
2290 }
2291 } break;
2292 case VECTOR3: {
2293
2294 if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
2295 //scalar index
2296 int idx = p_index;
2297 if (idx < 0)
2298 idx += 3;
2299 if (idx >= 0 && idx < 3) {
2300
2301 const Vector3 *v = reinterpret_cast<const Vector3 *>(_data._mem);
2302 valid = true;
2303 return (*v)[idx];
2304 }
2305 } else if (p_index.get_type() == Variant::STRING) {
2306
2307 //scalar name
2308 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
2309 const Vector3 *v = reinterpret_cast<const Vector3 *>(_data._mem);
2310 if (*str == "x") {
2311 valid = true;
2312 return v->x;
2313 } else if (*str == "y") {
2314 valid = true;
2315 return v->y;
2316 } else if (*str == "z") {
2317 valid = true;
2318 return v->z;
2319 }
2320 }
2321
2322 } break;
2323 case TRANSFORM2D: {
2324
2325 if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
2326
2327 int index = p_index;
2328
2329 if (index < 0)
2330 index += 3;
2331 if (index >= 0 && index < 3) {
2332 const Transform2D *v = _data._transform2d;
2333
2334 valid = true;
2335 return v->elements[index];
2336 }
2337 } else if (p_index.get_type() == Variant::STRING) {
2338
2339 //scalar name
2340 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
2341 const Transform2D *v = _data._transform2d;
2342 if (*str == "x") {
2343 valid = true;
2344 return v->elements[0];
2345 } else if (*str == "y") {
2346 valid = true;
2347 return v->elements[1];
2348 } else if (*str == "origin") {
2349 valid = true;
2350 return v->elements[2];
2351 }
2352 }
2353
2354 } break;
2355 case PLANE: {
2356
2357 if (p_index.get_type() == Variant::STRING) {
2358 //scalar name
2359 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
2360 const Plane *v = reinterpret_cast<const Plane *>(_data._mem);
2361 if (*str == "x") {
2362 valid = true;
2363 return v->normal.x;
2364 } else if (*str == "y") {
2365 valid = true;
2366 return v->normal.y;
2367 } else if (*str == "z") {
2368 valid = true;
2369 return v->normal.z;
2370 } else if (*str == "normal") {
2371 valid = true;
2372 return v->normal;
2373 } else if (*str == "d") {
2374 valid = true;
2375 return v->d;
2376 }
2377 }
2378
2379 } break;
2380 case QUAT: {
2381
2382 if (p_index.get_type() == Variant::STRING) {
2383
2384 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
2385 const Quat *v = reinterpret_cast<const Quat *>(_data._mem);
2386 if (*str == "x") {
2387 valid = true;
2388 return v->x;
2389 } else if (*str == "y") {
2390 valid = true;
2391 return v->y;
2392 } else if (*str == "z") {
2393 valid = true;
2394 return v->z;
2395 } else if (*str == "w") {
2396 valid = true;
2397 return v->w;
2398 }
2399 }
2400
2401 } break; // 10
2402 case AABB: {
2403
2404 if (p_index.get_type() == Variant::STRING) {
2405 //scalar name
2406
2407 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
2408 const ::AABB *v = _data._aabb;
2409 if (*str == "position") {
2410 valid = true;
2411 return v->position;
2412 } else if (*str == "size") {
2413 valid = true;
2414 return v->size;
2415 } else if (*str == "end") {
2416 valid = true;
2417 return v->size + v->position;
2418 }
2419 }
2420 } break;
2421 case BASIS: {
2422
2423 if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
2424
2425 int index = p_index;
2426 if (index < 0)
2427 index += 3;
2428 if (index >= 0 && index < 3) {
2429 const Basis *v = _data._basis;
2430
2431 valid = true;
2432 return v->get_axis(index);
2433 }
2434 } else if (p_index.get_type() == Variant::STRING) {
2435
2436 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
2437 const Basis *v = _data._basis;
2438
2439 if (*str == "x") {
2440 valid = true;
2441 return v->get_axis(0);
2442 } else if (*str == "y") {
2443 valid = true;
2444 return v->get_axis(1);
2445 } else if (*str == "z") {
2446 valid = true;
2447 return v->get_axis(2);
2448 }
2449 }
2450
2451 } break;
2452 case TRANSFORM: {
2453
2454 if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
2455
2456 int index = p_index;
2457 if (index < 0)
2458 index += 4;
2459 if (index >= 0 && index < 4) {
2460 const Transform *v = _data._transform;
2461 valid = true;
2462 return index == 3 ? v->origin : v->basis.get_axis(index);
2463 }
2464 } else if (p_index.get_type() == Variant::STRING) {
2465
2466 const Transform *v = _data._transform;
2467 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
2468
2469 if (*str == "basis") {
2470 valid = true;
2471 return v->basis;
2472 }
2473 if (*str == "origin") {
2474 valid = true;
2475 return v->origin;
2476 }
2477 }
2478
2479 } break;
2480 case COLOR: {
2481
2482 if (p_index.get_type() == Variant::STRING) {
2483
2484 const String *str = reinterpret_cast<const String *>(p_index._data._mem);
2485 const Color *v = reinterpret_cast<const Color *>(_data._mem);
2486 if (*str == "r") {
2487 valid = true;
2488 return v->r;
2489 } else if (*str == "g") {
2490 valid = true;
2491 return v->g;
2492 } else if (*str == "b") {
2493 valid = true;
2494 return v->b;
2495 } else if (*str == "a") {
2496 valid = true;
2497 return v->a;
2498 } else if (*str == "h") {
2499 valid = true;
2500 return v->get_h();
2501 } else if (*str == "s") {
2502 valid = true;
2503 return v->get_s();
2504 } else if (*str == "v") {
2505 valid = true;
2506 return v->get_v();
2507 } else if (*str == "r8") {
2508 valid = true;
2509 return (int)Math::round(v->r * 255.0);
2510 } else if (*str == "g8") {
2511 valid = true;
2512 return (int)Math::round(v->g * 255.0);
2513 } else if (*str == "b8") {
2514 valid = true;
2515 return (int)Math::round(v->b * 255.0);
2516 } else if (*str == "a8") {
2517 valid = true;
2518 return (int)Math::round(v->a * 255.0);
2519 }
2520 } else if (p_index.get_type() == Variant::INT) {
2521
2522 int idx = p_index;
2523 if (idx < 0)
2524 idx += 4;
2525 if (idx >= 0 && idx < 4) {
2526 const Color *v = reinterpret_cast<const Color *>(_data._mem);
2527 valid = true;
2528 return (*v)[idx];
2529 }
2530 }
2531
2532 } break;
2533 case NODE_PATH: {
2534 } break; // 15
2535 case _RID: {
2536 } break;
2537 case OBJECT: {
2538 Object *obj = _OBJ_PTR(*this);
2539 if (unlikely(!obj)) {
2540 #ifdef DEBUG_ENABLED
2541 valid = false;
2542 if (ScriptDebugger::get_singleton() && _get_obj().rc && !ObjectDB::get_instance(_get_obj().rc->instance_id)) {
2543 WARN_PRINT("Attempted get on a deleted object.");
2544 }
2545 #endif
2546 return Variant();
2547 }
2548
2549 if (p_index.get_type() != Variant::STRING) {
2550 return obj->getvar(p_index, r_valid);
2551 } else {
2552 return obj->get(p_index, r_valid);
2553 }
2554
2555 } break;
2556 case DICTIONARY: {
2557
2558 const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
2559 const Variant *res = dic->getptr(p_index);
2560 if (res) {
2561 valid = true;
2562 return *res;
2563 }
2564 } break;
2565 DEFAULT_OP_ARRAY_CMD(ARRAY, const Array, ;, return (*arr)[index]) // 20
2566 DEFAULT_OP_DVECTOR_GET(POOL_BYTE_ARRAY, uint8_t)
2567 DEFAULT_OP_DVECTOR_GET(POOL_INT_ARRAY, int)
2568 DEFAULT_OP_DVECTOR_GET(POOL_REAL_ARRAY, real_t)
2569 DEFAULT_OP_DVECTOR_GET(POOL_STRING_ARRAY, String)
2570 DEFAULT_OP_DVECTOR_GET(POOL_VECTOR2_ARRAY, Vector2) // 25
2571 DEFAULT_OP_DVECTOR_GET(POOL_VECTOR3_ARRAY, Vector3)
2572 DEFAULT_OP_DVECTOR_GET(POOL_COLOR_ARRAY, Color)
2573 default:
2574 return Variant();
2575 }
2576
2577 return Variant();
2578 }
2579
in(const Variant & p_index,bool * r_valid) const2580 bool Variant::in(const Variant &p_index, bool *r_valid) const {
2581
2582 if (r_valid)
2583 *r_valid = true;
2584
2585 switch (type) {
2586
2587 case STRING: {
2588
2589 if (p_index.get_type() == Variant::STRING) {
2590 //string index
2591 String idx = p_index;
2592 const String *str = reinterpret_cast<const String *>(_data._mem);
2593
2594 return str->find(idx) != -1;
2595 }
2596
2597 } break;
2598 case OBJECT: {
2599 Object *obj = _OBJ_PTR(*this);
2600 if (unlikely(!obj)) {
2601 #ifdef DEBUG_ENABLED
2602 if (r_valid) {
2603 *r_valid = false;
2604 }
2605 if (ScriptDebugger::get_singleton() && _get_obj().rc && !ObjectDB::get_instance(_get_obj().rc->instance_id)) {
2606 WARN_PRINT("Attempted 'in' on a deleted object.");
2607 }
2608 #endif
2609 return false;
2610 }
2611
2612 bool result;
2613 if (p_index.get_type() != Variant::STRING) {
2614 obj->getvar(p_index, &result);
2615 } else {
2616 obj->get(p_index, &result);
2617 }
2618 return result;
2619 } break;
2620 case DICTIONARY: {
2621
2622 const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
2623 return dic->has(p_index);
2624
2625 } break; // 20
2626 case ARRAY: {
2627
2628 const Array *arr = reinterpret_cast<const Array *>(_data._mem);
2629 int l = arr->size();
2630 if (l) {
2631 for (int i = 0; i < l; i++) {
2632
2633 if (evaluate(OP_EQUAL, (*arr)[i], p_index))
2634 return true;
2635 }
2636 }
2637
2638 return false;
2639
2640 } break;
2641 case POOL_BYTE_ARRAY: {
2642 if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
2643
2644 int index = p_index;
2645 const PoolVector<uint8_t> *arr = reinterpret_cast<const PoolVector<uint8_t> *>(_data._mem);
2646 int l = arr->size();
2647 if (l) {
2648 PoolVector<uint8_t>::Read r = arr->read();
2649 for (int i = 0; i < l; i++) {
2650 if (r[i] == index)
2651 return true;
2652 }
2653 }
2654
2655 return false;
2656 }
2657
2658 } break;
2659 case POOL_INT_ARRAY: {
2660 if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
2661
2662 int index = p_index;
2663 const PoolVector<int> *arr = reinterpret_cast<const PoolVector<int> *>(_data._mem);
2664 int l = arr->size();
2665 if (l) {
2666 PoolVector<int>::Read r = arr->read();
2667 for (int i = 0; i < l; i++) {
2668 if (r[i] == index)
2669 return true;
2670 }
2671 }
2672
2673 return false;
2674 }
2675 } break;
2676 case POOL_REAL_ARRAY: {
2677
2678 if (p_index.get_type() == Variant::INT || p_index.get_type() == Variant::REAL) {
2679
2680 real_t index = p_index;
2681 const PoolVector<real_t> *arr = reinterpret_cast<const PoolVector<real_t> *>(_data._mem);
2682 int l = arr->size();
2683 if (l) {
2684 PoolVector<real_t>::Read r = arr->read();
2685 for (int i = 0; i < l; i++) {
2686 if (r[i] == index)
2687 return true;
2688 }
2689 }
2690
2691 return false;
2692 }
2693
2694 } break;
2695 case POOL_STRING_ARRAY: {
2696 if (p_index.get_type() == Variant::STRING) {
2697
2698 String index = p_index;
2699 const PoolVector<String> *arr = reinterpret_cast<const PoolVector<String> *>(_data._mem);
2700
2701 int l = arr->size();
2702 if (l) {
2703 PoolVector<String>::Read r = arr->read();
2704 for (int i = 0; i < l; i++) {
2705 if (r[i] == index)
2706 return true;
2707 }
2708 }
2709
2710 return false;
2711 }
2712
2713 } break; //25
2714 case POOL_VECTOR2_ARRAY: {
2715 if (p_index.get_type() == Variant::VECTOR2) {
2716
2717 Vector2 index = p_index;
2718 const PoolVector<Vector2> *arr = reinterpret_cast<const PoolVector<Vector2> *>(_data._mem);
2719
2720 int l = arr->size();
2721 if (l) {
2722 PoolVector<Vector2>::Read r = arr->read();
2723 for (int i = 0; i < l; i++) {
2724 if (r[i] == index)
2725 return true;
2726 }
2727 }
2728
2729 return false;
2730 }
2731
2732 } break;
2733 case POOL_VECTOR3_ARRAY: {
2734 if (p_index.get_type() == Variant::VECTOR3) {
2735
2736 Vector3 index = p_index;
2737 const PoolVector<Vector3> *arr = reinterpret_cast<const PoolVector<Vector3> *>(_data._mem);
2738
2739 int l = arr->size();
2740 if (l) {
2741 PoolVector<Vector3>::Read r = arr->read();
2742 for (int i = 0; i < l; i++) {
2743 if (r[i] == index)
2744 return true;
2745 }
2746 }
2747
2748 return false;
2749 }
2750
2751 } break;
2752 case POOL_COLOR_ARRAY: {
2753
2754 if (p_index.get_type() == Variant::COLOR) {
2755
2756 Color index = p_index;
2757 const PoolVector<Color> *arr = reinterpret_cast<const PoolVector<Color> *>(_data._mem);
2758
2759 int l = arr->size();
2760 if (l) {
2761 PoolVector<Color>::Read r = arr->read();
2762 for (int i = 0; i < l; i++) {
2763 if (r[i] == index)
2764 return true;
2765 }
2766 }
2767
2768 return false;
2769 }
2770 } break;
2771 default: {
2772 }
2773 }
2774
2775 if (r_valid)
2776 *r_valid = false;
2777 return false;
2778 }
2779
get_property_list(List<PropertyInfo> * p_list) const2780 void Variant::get_property_list(List<PropertyInfo> *p_list) const {
2781
2782 switch (type) {
2783 case VECTOR2: {
2784
2785 p_list->push_back(PropertyInfo(Variant::REAL, "x"));
2786 p_list->push_back(PropertyInfo(Variant::REAL, "y"));
2787
2788 } break; // 5
2789 case RECT2: {
2790
2791 p_list->push_back(PropertyInfo(Variant::VECTOR2, "position"));
2792 p_list->push_back(PropertyInfo(Variant::VECTOR2, "size"));
2793 p_list->push_back(PropertyInfo(Variant::VECTOR2, "end"));
2794
2795 } break;
2796 case VECTOR3: {
2797
2798 p_list->push_back(PropertyInfo(Variant::REAL, "x"));
2799 p_list->push_back(PropertyInfo(Variant::REAL, "y"));
2800 p_list->push_back(PropertyInfo(Variant::REAL, "z"));
2801
2802 } break;
2803 case TRANSFORM2D: {
2804
2805 p_list->push_back(PropertyInfo(Variant::VECTOR2, "x"));
2806 p_list->push_back(PropertyInfo(Variant::VECTOR2, "y"));
2807 p_list->push_back(PropertyInfo(Variant::VECTOR2, "origin"));
2808
2809 } break;
2810 case PLANE: {
2811
2812 p_list->push_back(PropertyInfo(Variant::VECTOR3, "normal"));
2813 p_list->push_back(PropertyInfo(Variant::REAL, "x"));
2814 p_list->push_back(PropertyInfo(Variant::REAL, "y"));
2815 p_list->push_back(PropertyInfo(Variant::REAL, "z"));
2816 p_list->push_back(PropertyInfo(Variant::REAL, "d"));
2817
2818 } break;
2819 case QUAT: {
2820
2821 p_list->push_back(PropertyInfo(Variant::REAL, "x"));
2822 p_list->push_back(PropertyInfo(Variant::REAL, "y"));
2823 p_list->push_back(PropertyInfo(Variant::REAL, "z"));
2824 p_list->push_back(PropertyInfo(Variant::REAL, "w"));
2825
2826 } break; // 10
2827 case AABB: {
2828 p_list->push_back(PropertyInfo(Variant::VECTOR3, "position"));
2829 p_list->push_back(PropertyInfo(Variant::VECTOR3, "size"));
2830 p_list->push_back(PropertyInfo(Variant::VECTOR3, "end"));
2831 } break;
2832 case BASIS: {
2833
2834 p_list->push_back(PropertyInfo(Variant::VECTOR3, "x"));
2835 p_list->push_back(PropertyInfo(Variant::VECTOR3, "y"));
2836 p_list->push_back(PropertyInfo(Variant::VECTOR3, "z"));
2837
2838 } break;
2839 case TRANSFORM: {
2840
2841 p_list->push_back(PropertyInfo(Variant::BASIS, "basis"));
2842 p_list->push_back(PropertyInfo(Variant::VECTOR3, "origin"));
2843
2844 } break;
2845 case COLOR: {
2846 p_list->push_back(PropertyInfo(Variant::REAL, "r"));
2847 p_list->push_back(PropertyInfo(Variant::REAL, "g"));
2848 p_list->push_back(PropertyInfo(Variant::REAL, "b"));
2849 p_list->push_back(PropertyInfo(Variant::REAL, "a"));
2850 p_list->push_back(PropertyInfo(Variant::REAL, "h"));
2851 p_list->push_back(PropertyInfo(Variant::REAL, "s"));
2852 p_list->push_back(PropertyInfo(Variant::REAL, "v"));
2853 p_list->push_back(PropertyInfo(Variant::INT, "r8"));
2854 p_list->push_back(PropertyInfo(Variant::INT, "g8"));
2855 p_list->push_back(PropertyInfo(Variant::INT, "b8"));
2856 p_list->push_back(PropertyInfo(Variant::INT, "a8"));
2857
2858 } break;
2859 case NODE_PATH: {
2860 } break; // 15
2861 case _RID: {
2862 } break;
2863 case OBJECT: {
2864
2865 Object *obj = _OBJ_PTR(*this);
2866 if (unlikely(!obj)) {
2867 #ifdef DEBUG_ENABLED
2868 if (ScriptDebugger::get_singleton() && _get_obj().rc && !ObjectDB::get_instance(_get_obj().rc->instance_id)) {
2869 WARN_PRINT("Attempted get property list on a deleted object.");
2870 }
2871 #endif
2872 return;
2873 }
2874
2875 obj->get_property_list(p_list);
2876 } break;
2877 case DICTIONARY: {
2878
2879 const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
2880 List<Variant> keys;
2881 dic->get_key_list(&keys);
2882 for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
2883 if (E->get().get_type() == Variant::STRING) {
2884 p_list->push_back(PropertyInfo(Variant::STRING, E->get()));
2885 }
2886 }
2887 } break;
2888 case ARRAY: // 20
2889 case POOL_BYTE_ARRAY:
2890 case POOL_INT_ARRAY:
2891 case POOL_REAL_ARRAY:
2892 case POOL_STRING_ARRAY:
2893 case POOL_VECTOR2_ARRAY: // 25
2894 case POOL_VECTOR3_ARRAY:
2895 case POOL_COLOR_ARRAY: {
2896
2897 //nothing
2898 } break;
2899 default: {
2900 }
2901 }
2902 }
2903
iter_init(Variant & r_iter,bool & valid) const2904 bool Variant::iter_init(Variant &r_iter, bool &valid) const {
2905
2906 valid = true;
2907 switch (type) {
2908 case INT: {
2909 r_iter = 0;
2910 return _data._int > 0;
2911 } break;
2912 case REAL: {
2913 r_iter = 0;
2914 return _data._real > 0.0;
2915 } break;
2916 case VECTOR2: {
2917 int64_t from = reinterpret_cast<const Vector2 *>(_data._mem)->x;
2918 int64_t to = reinterpret_cast<const Vector2 *>(_data._mem)->y;
2919
2920 r_iter = from;
2921
2922 return from < to;
2923 } break;
2924 case VECTOR3: {
2925 int64_t from = reinterpret_cast<const Vector3 *>(_data._mem)->x;
2926 int64_t to = reinterpret_cast<const Vector3 *>(_data._mem)->y;
2927 int64_t step = reinterpret_cast<const Vector3 *>(_data._mem)->z;
2928
2929 r_iter = from;
2930
2931 if (from == to) {
2932 return false;
2933 } else if (from < to) {
2934 return step > 0;
2935 } else {
2936 return step < 0;
2937 }
2938 //return true;
2939 } break;
2940 case OBJECT: {
2941
2942 Object *obj = _OBJ_PTR(*this);
2943 #ifdef DEBUG_ENABLED
2944 if (unlikely(!obj)) {
2945 valid = false;
2946 if (ScriptDebugger::get_singleton() && _get_obj().rc && !ObjectDB::get_instance(_get_obj().rc->instance_id)) {
2947 WARN_PRINT("Attempted iteration start on a deleted object.");
2948 }
2949 return false;
2950 }
2951 #endif
2952 Variant::CallError ce;
2953 ce.error = Variant::CallError::CALL_OK;
2954 Array ref;
2955 ref.push_back(r_iter);
2956 Variant vref = ref;
2957 const Variant *refp[] = { &vref };
2958 Variant ret = obj->call(CoreStringNames::get_singleton()->_iter_init, refp, 1, ce);
2959
2960 if (ref.size() != 1 || ce.error != Variant::CallError::CALL_OK) {
2961 valid = false;
2962 return false;
2963 }
2964
2965 r_iter = ref[0];
2966 return ret;
2967 } break;
2968
2969 case STRING: {
2970
2971 const String *str = reinterpret_cast<const String *>(_data._mem);
2972 if (str->empty())
2973 return false;
2974 r_iter = 0;
2975 return true;
2976 } break;
2977 case DICTIONARY: {
2978
2979 const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
2980 if (dic->empty())
2981 return false;
2982
2983 const Variant *next = dic->next(NULL);
2984 r_iter = *next;
2985 return true;
2986
2987 } break;
2988 case ARRAY: {
2989
2990 const Array *arr = reinterpret_cast<const Array *>(_data._mem);
2991 if (arr->empty())
2992 return false;
2993 r_iter = 0;
2994 return true;
2995 } break;
2996 case POOL_BYTE_ARRAY: {
2997 const PoolVector<uint8_t> *arr = reinterpret_cast<const PoolVector<uint8_t> *>(_data._mem);
2998 if (arr->size() == 0)
2999 return false;
3000 r_iter = 0;
3001 return true;
3002
3003 } break;
3004 case POOL_INT_ARRAY: {
3005 const PoolVector<int> *arr = reinterpret_cast<const PoolVector<int> *>(_data._mem);
3006 if (arr->size() == 0)
3007 return false;
3008 r_iter = 0;
3009 return true;
3010
3011 } break;
3012 case POOL_REAL_ARRAY: {
3013 const PoolVector<real_t> *arr = reinterpret_cast<const PoolVector<real_t> *>(_data._mem);
3014 if (arr->size() == 0)
3015 return false;
3016 r_iter = 0;
3017 return true;
3018
3019 } break;
3020 case POOL_STRING_ARRAY: {
3021 const PoolVector<String> *arr = reinterpret_cast<const PoolVector<String> *>(_data._mem);
3022 if (arr->size() == 0)
3023 return false;
3024 r_iter = 0;
3025 return true;
3026 } break;
3027 case POOL_VECTOR2_ARRAY: {
3028
3029 const PoolVector<Vector2> *arr = reinterpret_cast<const PoolVector<Vector2> *>(_data._mem);
3030 if (arr->size() == 0)
3031 return false;
3032 r_iter = 0;
3033 return true;
3034 } break;
3035 case POOL_VECTOR3_ARRAY: {
3036
3037 const PoolVector<Vector3> *arr = reinterpret_cast<const PoolVector<Vector3> *>(_data._mem);
3038 if (arr->size() == 0)
3039 return false;
3040 r_iter = 0;
3041 return true;
3042 } break;
3043 case POOL_COLOR_ARRAY: {
3044
3045 const PoolVector<Color> *arr = reinterpret_cast<const PoolVector<Color> *>(_data._mem);
3046 if (arr->size() == 0)
3047 return false;
3048 r_iter = 0;
3049 return true;
3050
3051 } break;
3052 default: {
3053 }
3054 }
3055
3056 valid = false;
3057 return false;
3058 }
iter_next(Variant & r_iter,bool & valid) const3059 bool Variant::iter_next(Variant &r_iter, bool &valid) const {
3060
3061 valid = true;
3062 switch (type) {
3063 case INT: {
3064 int64_t idx = r_iter;
3065 idx++;
3066 if (idx >= _data._int)
3067 return false;
3068 r_iter = idx;
3069 return true;
3070 } break;
3071 case REAL: {
3072 int64_t idx = r_iter;
3073 idx++;
3074 if (idx >= _data._real)
3075 return false;
3076 r_iter = idx;
3077 return true;
3078 } break;
3079 case VECTOR2: {
3080 int64_t to = reinterpret_cast<const Vector2 *>(_data._mem)->y;
3081
3082 int64_t idx = r_iter;
3083 idx++;
3084
3085 if (idx >= to)
3086 return false;
3087
3088 r_iter = idx;
3089 return true;
3090 } break;
3091 case VECTOR3: {
3092 int64_t to = reinterpret_cast<const Vector3 *>(_data._mem)->y;
3093 int64_t step = reinterpret_cast<const Vector3 *>(_data._mem)->z;
3094
3095 int64_t idx = r_iter;
3096 idx += step;
3097
3098 if (step < 0 && idx <= to)
3099 return false;
3100
3101 if (step > 0 && idx >= to)
3102 return false;
3103
3104 r_iter = idx;
3105 return true;
3106 } break;
3107 case OBJECT: {
3108
3109 Object *obj = _OBJ_PTR(*this);
3110 #ifdef DEBUG_ENABLED
3111 if (unlikely(!obj)) {
3112 valid = false;
3113 if (ScriptDebugger::get_singleton() && _get_obj().rc && !ObjectDB::get_instance(_get_obj().rc->instance_id)) {
3114 WARN_PRINT("Attempted iteration check next on a deleted object.");
3115 }
3116 return false;
3117 }
3118 #endif
3119 Variant::CallError ce;
3120 ce.error = Variant::CallError::CALL_OK;
3121 Array ref;
3122 ref.push_back(r_iter);
3123 Variant vref = ref;
3124 const Variant *refp[] = { &vref };
3125 Variant ret = obj->call(CoreStringNames::get_singleton()->_iter_next, refp, 1, ce);
3126
3127 if (ref.size() != 1 || ce.error != Variant::CallError::CALL_OK) {
3128 valid = false;
3129 return false;
3130 }
3131
3132 r_iter = ref[0];
3133
3134 return ret;
3135 } break;
3136
3137 case STRING: {
3138
3139 const String *str = reinterpret_cast<const String *>(_data._mem);
3140 int idx = r_iter;
3141 idx++;
3142 if (idx >= str->length())
3143 return false;
3144 r_iter = idx;
3145 return true;
3146 } break;
3147 case DICTIONARY: {
3148
3149 const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem);
3150 const Variant *next = dic->next(&r_iter);
3151 if (!next)
3152 return false;
3153
3154 r_iter = *next;
3155 return true;
3156
3157 } break;
3158 case ARRAY: {
3159
3160 const Array *arr = reinterpret_cast<const Array *>(_data._mem);
3161 int idx = r_iter;
3162 idx++;
3163 if (idx >= arr->size())
3164 return false;
3165 r_iter = idx;
3166 return true;
3167 } break;
3168 case POOL_BYTE_ARRAY: {
3169 const PoolVector<uint8_t> *arr = reinterpret_cast<const PoolVector<uint8_t> *>(_data._mem);
3170 int idx = r_iter;
3171 idx++;
3172 if (idx >= arr->size())
3173 return false;
3174 r_iter = idx;
3175 return true;
3176
3177 } break;
3178 case POOL_INT_ARRAY: {
3179 const PoolVector<int> *arr = reinterpret_cast<const PoolVector<int> *>(_data._mem);
3180 int idx = r_iter;
3181 idx++;
3182 if (idx >= arr->size())
3183 return false;
3184 r_iter = idx;
3185 return true;
3186
3187 } break;
3188 case POOL_REAL_ARRAY: {
3189 const PoolVector<real_t> *arr = reinterpret_cast<const PoolVector<real_t> *>(_data._mem);
3190 int idx = r_iter;
3191 idx++;
3192 if (idx >= arr->size())
3193 return false;
3194 r_iter = idx;
3195 return true;
3196
3197 } break;
3198 case POOL_STRING_ARRAY: {
3199 const PoolVector<String> *arr = reinterpret_cast<const PoolVector<String> *>(_data._mem);
3200 int idx = r_iter;
3201 idx++;
3202 if (idx >= arr->size())
3203 return false;
3204 r_iter = idx;
3205 return true;
3206 } break;
3207 case POOL_VECTOR2_ARRAY: {
3208
3209 const PoolVector<Vector2> *arr = reinterpret_cast<const PoolVector<Vector2> *>(_data._mem);
3210 int idx = r_iter;
3211 idx++;
3212 if (idx >= arr->size())
3213 return false;
3214 r_iter = idx;
3215 return true;
3216 } break;
3217 case POOL_VECTOR3_ARRAY: {
3218
3219 const PoolVector<Vector3> *arr = reinterpret_cast<const PoolVector<Vector3> *>(_data._mem);
3220 int idx = r_iter;
3221 idx++;
3222 if (idx >= arr->size())
3223 return false;
3224 r_iter = idx;
3225 return true;
3226 } break;
3227 case POOL_COLOR_ARRAY: {
3228
3229 const PoolVector<Color> *arr = reinterpret_cast<const PoolVector<Color> *>(_data._mem);
3230 int idx = r_iter;
3231 idx++;
3232 if (idx >= arr->size())
3233 return false;
3234 r_iter = idx;
3235 return true;
3236 } break;
3237 default: {
3238 }
3239 }
3240
3241 valid = false;
3242 return false;
3243 }
3244
iter_get(const Variant & r_iter,bool & r_valid) const3245 Variant Variant::iter_get(const Variant &r_iter, bool &r_valid) const {
3246
3247 r_valid = true;
3248 switch (type) {
3249 case INT: {
3250
3251 return r_iter;
3252 } break;
3253 case REAL: {
3254
3255 return r_iter;
3256 } break;
3257 case VECTOR2: {
3258
3259 return r_iter;
3260 } break;
3261 case VECTOR3: {
3262
3263 return r_iter;
3264 } break;
3265 case OBJECT: {
3266
3267 Object *obj = _OBJ_PTR(*this);
3268 #ifdef DEBUG_ENABLED
3269 if (unlikely(!obj)) {
3270 r_valid = false;
3271 if (ScriptDebugger::get_singleton() && _get_obj().rc && !ObjectDB::get_instance(_get_obj().rc->instance_id)) {
3272 WARN_PRINT("Attempted iteration get next on a deleted object.");
3273 }
3274 return Variant();
3275 }
3276 #endif
3277 Variant::CallError ce;
3278 ce.error = Variant::CallError::CALL_OK;
3279 const Variant *refp[] = { &r_iter };
3280 Variant ret = obj->call(CoreStringNames::get_singleton()->_iter_get, refp, 1, ce);
3281
3282 if (ce.error != Variant::CallError::CALL_OK) {
3283 r_valid = false;
3284 return Variant();
3285 }
3286
3287 //r_iter=ref[0];
3288
3289 return ret;
3290 } break;
3291
3292 case STRING: {
3293
3294 const String *str = reinterpret_cast<const String *>(_data._mem);
3295 return str->substr(r_iter, 1);
3296 } break;
3297 case DICTIONARY: {
3298
3299 return r_iter; //iterator is the same as the key
3300
3301 } break;
3302 case ARRAY: {
3303
3304 const Array *arr = reinterpret_cast<const Array *>(_data._mem);
3305 int idx = r_iter;
3306 #ifdef DEBUG_ENABLED
3307 if (idx < 0 || idx >= arr->size()) {
3308 r_valid = false;
3309 return Variant();
3310 }
3311 #endif
3312 return arr->get(idx);
3313 } break;
3314 case POOL_BYTE_ARRAY: {
3315 const PoolVector<uint8_t> *arr = reinterpret_cast<const PoolVector<uint8_t> *>(_data._mem);
3316 int idx = r_iter;
3317 #ifdef DEBUG_ENABLED
3318 if (idx < 0 || idx >= arr->size()) {
3319 r_valid = false;
3320 return Variant();
3321 }
3322 #endif
3323 return arr->get(idx);
3324 } break;
3325 case POOL_INT_ARRAY: {
3326 const PoolVector<int> *arr = reinterpret_cast<const PoolVector<int> *>(_data._mem);
3327 int idx = r_iter;
3328 #ifdef DEBUG_ENABLED
3329 if (idx < 0 || idx >= arr->size()) {
3330 r_valid = false;
3331 return Variant();
3332 }
3333 #endif
3334 return arr->get(idx);
3335 } break;
3336 case POOL_REAL_ARRAY: {
3337 const PoolVector<real_t> *arr = reinterpret_cast<const PoolVector<real_t> *>(_data._mem);
3338 int idx = r_iter;
3339 #ifdef DEBUG_ENABLED
3340 if (idx < 0 || idx >= arr->size()) {
3341 r_valid = false;
3342 return Variant();
3343 }
3344 #endif
3345 return arr->get(idx);
3346 } break;
3347 case POOL_STRING_ARRAY: {
3348 const PoolVector<String> *arr = reinterpret_cast<const PoolVector<String> *>(_data._mem);
3349 int idx = r_iter;
3350 #ifdef DEBUG_ENABLED
3351 if (idx < 0 || idx >= arr->size()) {
3352 r_valid = false;
3353 return Variant();
3354 }
3355 #endif
3356 return arr->get(idx);
3357 } break;
3358 case POOL_VECTOR2_ARRAY: {
3359
3360 const PoolVector<Vector2> *arr = reinterpret_cast<const PoolVector<Vector2> *>(_data._mem);
3361 int idx = r_iter;
3362 #ifdef DEBUG_ENABLED
3363 if (idx < 0 || idx >= arr->size()) {
3364 r_valid = false;
3365 return Variant();
3366 }
3367 #endif
3368 return arr->get(idx);
3369 } break;
3370 case POOL_VECTOR3_ARRAY: {
3371
3372 const PoolVector<Vector3> *arr = reinterpret_cast<const PoolVector<Vector3> *>(_data._mem);
3373 int idx = r_iter;
3374 #ifdef DEBUG_ENABLED
3375 if (idx < 0 || idx >= arr->size()) {
3376 r_valid = false;
3377 return Variant();
3378 }
3379 #endif
3380 return arr->get(idx);
3381 } break;
3382 case POOL_COLOR_ARRAY: {
3383
3384 const PoolVector<Color> *arr = reinterpret_cast<const PoolVector<Color> *>(_data._mem);
3385 int idx = r_iter;
3386 #ifdef DEBUG_ENABLED
3387 if (idx < 0 || idx >= arr->size()) {
3388 r_valid = false;
3389 return Variant();
3390 }
3391 #endif
3392 return arr->get(idx);
3393 } break;
3394 default: {
3395 }
3396 }
3397
3398 r_valid = false;
3399 return Variant();
3400 }
3401
duplicate(bool deep) const3402 Variant Variant::duplicate(bool deep) const {
3403 switch (type) {
3404 case OBJECT: {
3405 /* breaks stuff :(
3406 if (deep && !_get_obj().ref.is_null()) {
3407 Ref<Resource> resource = _get_obj().ref;
3408 if (resource.is_valid()) {
3409 return resource->duplicate(true);
3410 }
3411 }
3412 */
3413 return *this;
3414 } break;
3415 case DICTIONARY:
3416 return operator Dictionary().duplicate(deep);
3417 case ARRAY:
3418 return operator Array().duplicate(deep);
3419 default:
3420 return *this;
3421 }
3422 }
3423
blend(const Variant & a,const Variant & b,float c,Variant & r_dst)3424 void Variant::blend(const Variant &a, const Variant &b, float c, Variant &r_dst) {
3425 if (a.type != b.type) {
3426 if (a.is_num() && b.is_num()) {
3427 real_t va = a;
3428 real_t vb = b;
3429 r_dst = va + vb * c;
3430 } else {
3431 r_dst = a;
3432 }
3433 return;
3434 }
3435
3436 switch (a.type) {
3437 case NIL: {
3438 r_dst = Variant();
3439 }
3440 return;
3441 case INT: {
3442 int64_t va = a._data._int;
3443 int64_t vb = b._data._int;
3444 r_dst = int(va + vb * c + 0.5);
3445 }
3446 return;
3447 case REAL: {
3448 double ra = a._data._real;
3449 double rb = b._data._real;
3450 r_dst = ra + rb * c;
3451 }
3452 return;
3453 case VECTOR2: {
3454 r_dst = *reinterpret_cast<const Vector2 *>(a._data._mem) + *reinterpret_cast<const Vector2 *>(b._data._mem) * c;
3455 }
3456 return;
3457 case RECT2: {
3458 const Rect2 *ra = reinterpret_cast<const Rect2 *>(a._data._mem);
3459 const Rect2 *rb = reinterpret_cast<const Rect2 *>(b._data._mem);
3460 r_dst = Rect2(ra->position + rb->position * c, ra->size + rb->size * c);
3461 }
3462 return;
3463 case VECTOR3: {
3464 r_dst = *reinterpret_cast<const Vector3 *>(a._data._mem) + *reinterpret_cast<const Vector3 *>(b._data._mem) * c;
3465 }
3466 return;
3467 case AABB: {
3468 const ::AABB *ra = reinterpret_cast<const ::AABB *>(a._data._mem);
3469 const ::AABB *rb = reinterpret_cast<const ::AABB *>(b._data._mem);
3470 r_dst = ::AABB(ra->position + rb->position * c, ra->size + rb->size * c);
3471 }
3472 return;
3473 case QUAT: {
3474 Quat empty_rot;
3475 const Quat *qa = reinterpret_cast<const Quat *>(a._data._mem);
3476 const Quat *qb = reinterpret_cast<const Quat *>(b._data._mem);
3477 r_dst = *qa * empty_rot.slerp(*qb, c);
3478 }
3479 return;
3480 case COLOR: {
3481 const Color *ca = reinterpret_cast<const Color *>(a._data._mem);
3482 const Color *cb = reinterpret_cast<const Color *>(b._data._mem);
3483 float new_r = ca->r + cb->r * c;
3484 float new_g = ca->g + cb->g * c;
3485 float new_b = ca->b + cb->b * c;
3486 float new_a = ca->a + cb->a * c;
3487 new_r = new_r > 1.0 ? 1.0 : new_r;
3488 new_g = new_g > 1.0 ? 1.0 : new_g;
3489 new_b = new_b > 1.0 ? 1.0 : new_b;
3490 new_a = new_a > 1.0 ? 1.0 : new_a;
3491 r_dst = Color(new_r, new_g, new_b, new_a);
3492 }
3493 return;
3494 default: {
3495 r_dst = c < 0.5 ? a : b;
3496 }
3497 return;
3498 }
3499 }
3500
interpolate(const Variant & a,const Variant & b,float c,Variant & r_dst)3501 void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant &r_dst) {
3502
3503 if (a.type != b.type) {
3504 if (a.is_num() && b.is_num()) {
3505 //not as efficient but..
3506 real_t va = a;
3507 real_t vb = b;
3508 r_dst = va + (vb - va) * c;
3509
3510 } else {
3511 r_dst = a;
3512 }
3513 return;
3514 }
3515
3516 switch (a.type) {
3517
3518 case NIL: {
3519 r_dst = Variant();
3520 }
3521 return;
3522 case BOOL: {
3523 r_dst = a;
3524 }
3525 return;
3526 case INT: {
3527 int64_t va = a._data._int;
3528 int64_t vb = b._data._int;
3529 r_dst = int(va + (vb - va) * c);
3530 }
3531 return;
3532 case REAL: {
3533 real_t va = a._data._real;
3534 real_t vb = b._data._real;
3535 r_dst = va + (vb - va) * c;
3536 }
3537 return;
3538 case STRING: {
3539 //this is pretty funny and bizarre, but artists like to use it for typewritter effects
3540 String sa = *reinterpret_cast<const String *>(a._data._mem);
3541 String sb = *reinterpret_cast<const String *>(b._data._mem);
3542 String dst;
3543 int sa_len = sa.length();
3544 int sb_len = sb.length();
3545 int csize = sa_len + (sb_len - sa_len) * c;
3546 if (csize == 0) {
3547 r_dst = "";
3548 return;
3549 }
3550 dst.resize(csize + 1);
3551 dst[csize] = 0;
3552 int split = csize / 2;
3553
3554 for (int i = 0; i < csize; i++) {
3555
3556 CharType chr = ' ';
3557
3558 if (i < split) {
3559
3560 if (i < sa.length())
3561 chr = sa[i];
3562 else if (i < sb.length())
3563 chr = sb[i];
3564
3565 } else {
3566
3567 if (i < sb.length())
3568 chr = sb[i];
3569 else if (i < sa.length())
3570 chr = sa[i];
3571 }
3572
3573 dst[i] = chr;
3574 }
3575
3576 r_dst = dst;
3577 }
3578 return;
3579 case VECTOR2: {
3580 r_dst = reinterpret_cast<const Vector2 *>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Vector2 *>(b._data._mem), c);
3581 }
3582 return;
3583 case RECT2: {
3584 r_dst = Rect2(reinterpret_cast<const Rect2 *>(a._data._mem)->position.linear_interpolate(reinterpret_cast<const Rect2 *>(b._data._mem)->position, c), reinterpret_cast<const Rect2 *>(a._data._mem)->size.linear_interpolate(reinterpret_cast<const Rect2 *>(b._data._mem)->size, c));
3585 }
3586 return;
3587 case VECTOR3: {
3588 r_dst = reinterpret_cast<const Vector3 *>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Vector3 *>(b._data._mem), c);
3589 }
3590 return;
3591 case TRANSFORM2D: {
3592 r_dst = a._data._transform2d->interpolate_with(*b._data._transform2d, c);
3593 }
3594 return;
3595 case PLANE: {
3596 r_dst = a;
3597 }
3598 return;
3599 case QUAT: {
3600 r_dst = reinterpret_cast<const Quat *>(a._data._mem)->slerp(*reinterpret_cast<const Quat *>(b._data._mem), c);
3601 }
3602 return;
3603 case AABB: {
3604 r_dst = ::AABB(a._data._aabb->position.linear_interpolate(b._data._aabb->position, c), a._data._aabb->size.linear_interpolate(b._data._aabb->size, c));
3605 }
3606 return;
3607 case BASIS: {
3608 r_dst = Transform(*a._data._basis).interpolate_with(Transform(*b._data._basis), c).basis;
3609 }
3610 return;
3611 case TRANSFORM: {
3612 r_dst = a._data._transform->interpolate_with(*b._data._transform, c);
3613 }
3614 return;
3615 case COLOR: {
3616 r_dst = reinterpret_cast<const Color *>(a._data._mem)->linear_interpolate(*reinterpret_cast<const Color *>(b._data._mem), c);
3617 }
3618 return;
3619 case NODE_PATH: {
3620 r_dst = a;
3621 }
3622 return;
3623 case _RID: {
3624 r_dst = a;
3625 }
3626 return;
3627 case OBJECT: {
3628 r_dst = a;
3629 }
3630 return;
3631 case DICTIONARY: {
3632 }
3633 return;
3634 case ARRAY: {
3635 r_dst = a;
3636 }
3637 return;
3638 case POOL_BYTE_ARRAY: {
3639 r_dst = a;
3640 }
3641 return;
3642 case POOL_INT_ARRAY: {
3643 const PoolVector<int> *arr_a = reinterpret_cast<const PoolVector<int> *>(a._data._mem);
3644 const PoolVector<int> *arr_b = reinterpret_cast<const PoolVector<int> *>(b._data._mem);
3645 int sz = arr_a->size();
3646 if (sz == 0 || arr_b->size() != sz) {
3647
3648 r_dst = a;
3649 } else {
3650
3651 PoolVector<int> v;
3652 v.resize(sz);
3653 {
3654 PoolVector<int>::Write vw = v.write();
3655 PoolVector<int>::Read ar = arr_a->read();
3656 PoolVector<int>::Read br = arr_b->read();
3657
3658 Variant va;
3659 for (int i = 0; i < sz; i++) {
3660 Variant::interpolate(ar[i], br[i], c, va);
3661 vw[i] = va;
3662 }
3663 }
3664 r_dst = v;
3665 }
3666 }
3667 return;
3668 case POOL_REAL_ARRAY: {
3669 const PoolVector<real_t> *arr_a = reinterpret_cast<const PoolVector<real_t> *>(a._data._mem);
3670 const PoolVector<real_t> *arr_b = reinterpret_cast<const PoolVector<real_t> *>(b._data._mem);
3671 int sz = arr_a->size();
3672 if (sz == 0 || arr_b->size() != sz) {
3673
3674 r_dst = a;
3675 } else {
3676
3677 PoolVector<real_t> v;
3678 v.resize(sz);
3679 {
3680 PoolVector<real_t>::Write vw = v.write();
3681 PoolVector<real_t>::Read ar = arr_a->read();
3682 PoolVector<real_t>::Read br = arr_b->read();
3683
3684 Variant va;
3685 for (int i = 0; i < sz; i++) {
3686 Variant::interpolate(ar[i], br[i], c, va);
3687 vw[i] = va;
3688 }
3689 }
3690 r_dst = v;
3691 }
3692 }
3693 return;
3694 case POOL_STRING_ARRAY: {
3695 r_dst = a;
3696 }
3697 return;
3698 case POOL_VECTOR2_ARRAY: {
3699 const PoolVector<Vector2> *arr_a = reinterpret_cast<const PoolVector<Vector2> *>(a._data._mem);
3700 const PoolVector<Vector2> *arr_b = reinterpret_cast<const PoolVector<Vector2> *>(b._data._mem);
3701 int sz = arr_a->size();
3702 if (sz == 0 || arr_b->size() != sz) {
3703
3704 r_dst = a;
3705 } else {
3706
3707 PoolVector<Vector2> v;
3708 v.resize(sz);
3709 {
3710 PoolVector<Vector2>::Write vw = v.write();
3711 PoolVector<Vector2>::Read ar = arr_a->read();
3712 PoolVector<Vector2>::Read br = arr_b->read();
3713
3714 for (int i = 0; i < sz; i++) {
3715 vw[i] = ar[i].linear_interpolate(br[i], c);
3716 }
3717 }
3718 r_dst = v;
3719 }
3720 }
3721 return;
3722 case POOL_VECTOR3_ARRAY: {
3723
3724 const PoolVector<Vector3> *arr_a = reinterpret_cast<const PoolVector<Vector3> *>(a._data._mem);
3725 const PoolVector<Vector3> *arr_b = reinterpret_cast<const PoolVector<Vector3> *>(b._data._mem);
3726 int sz = arr_a->size();
3727 if (sz == 0 || arr_b->size() != sz) {
3728
3729 r_dst = a;
3730 } else {
3731
3732 PoolVector<Vector3> v;
3733 v.resize(sz);
3734 {
3735 PoolVector<Vector3>::Write vw = v.write();
3736 PoolVector<Vector3>::Read ar = arr_a->read();
3737 PoolVector<Vector3>::Read br = arr_b->read();
3738
3739 for (int i = 0; i < sz; i++) {
3740 vw[i] = ar[i].linear_interpolate(br[i], c);
3741 }
3742 }
3743 r_dst = v;
3744 }
3745 }
3746 return;
3747 case POOL_COLOR_ARRAY: {
3748 const PoolVector<Color> *arr_a = reinterpret_cast<const PoolVector<Color> *>(a._data._mem);
3749 const PoolVector<Color> *arr_b = reinterpret_cast<const PoolVector<Color> *>(b._data._mem);
3750 int sz = arr_a->size();
3751 if (sz == 0 || arr_b->size() != sz) {
3752
3753 r_dst = a;
3754 } else {
3755
3756 PoolVector<Color> v;
3757 v.resize(sz);
3758 {
3759 PoolVector<Color>::Write vw = v.write();
3760 PoolVector<Color>::Read ar = arr_a->read();
3761 PoolVector<Color>::Read br = arr_b->read();
3762
3763 for (int i = 0; i < sz; i++) {
3764 vw[i] = ar[i].linear_interpolate(br[i], c);
3765 }
3766 }
3767 r_dst = v;
3768 }
3769 }
3770 return;
3771 default: {
3772
3773 r_dst = a;
3774 }
3775 }
3776 }
3777
3778 static const char *_op_names[Variant::OP_MAX] = {
3779 "==",
3780 "!=",
3781 "<",
3782 "<=",
3783 ">",
3784 ">=",
3785 "+",
3786 "-",
3787 "*",
3788 "/",
3789 "- (negation)",
3790 "+ (positive)",
3791 "%",
3792 "+ (concatenation)",
3793 "<<",
3794 ">>",
3795 "&",
3796 "|",
3797 "^",
3798 "~",
3799 "and",
3800 "or",
3801 "xor",
3802 "not",
3803 "in"
3804
3805 };
3806
get_operator_name(Operator p_op)3807 String Variant::get_operator_name(Operator p_op) {
3808
3809 ERR_FAIL_INDEX_V(p_op, OP_MAX, "");
3810 return _op_names[p_op];
3811 }
3812