1 /*************************************************************************/
2 /* variant.h */
3 /*************************************************************************/
4 /* This file is part of: */
5 /* GODOT ENGINE */
6 /* https://godotengine.org */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
9 /* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
10 /* */
11 /* Permission is hereby granted, free of charge, to any person obtaining */
12 /* a copy of this software and associated documentation files (the */
13 /* "Software"), to deal in the Software without restriction, including */
14 /* without limitation the rights to use, copy, modify, merge, publish, */
15 /* distribute, sublicense, and/or sell copies of the Software, and to */
16 /* permit persons to whom the Software is furnished to do so, subject to */
17 /* the following conditions: */
18 /* */
19 /* The above copyright notice and this permission notice shall be */
20 /* included in all copies or substantial portions of the Software. */
21 /* */
22 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
23 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
24 /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
25 /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
26 /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
27 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
28 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
29 /*************************************************************************/
30 #ifndef VARIANT_H
31 #define VARIANT_H
32
33 /**
34 @author Juan Linietsky <reduzio@gmail.com>
35 */
36
37 #include "aabb.h"
38 #include "array.h"
39 #include "color.h"
40 #include "dictionary.h"
41 #include "dvector.h"
42 #include "face3.h"
43 #include "image.h"
44 #include "io/ip_address.h"
45 #include "math_2d.h"
46 #include "matrix3.h"
47 #include "os/input_event.h"
48 #include "path_db.h"
49 #include "plane.h"
50 #include "quat.h"
51 #include "ref_ptr.h"
52 #include "rid.h"
53 #include "simple_type.h"
54 #include "transform.h"
55 #include "ustring.h"
56 #include "vector3.h"
57
58 class RefPtr;
59 class Object;
60 class Node; // helper
61 class Control; // helper
62
63 struct PropertyInfo;
64 struct MethodInfo;
65
66 typedef DVector<uint8_t> ByteArray;
67 typedef DVector<int> IntArray;
68 typedef DVector<real_t> RealArray;
69 typedef DVector<String> StringArray;
70 typedef DVector<Vector2> Vector2Array;
71 typedef DVector<Vector3> Vector3Array;
72 typedef DVector<Color> ColorArray;
73
74 class Variant {
75 public:
76 enum Type {
77
78 NIL,
79
80 // atomic types
81 BOOL,
82 INT,
83 REAL,
84 STRING,
85
86 // math types
87
88 VECTOR2, // 5
89 RECT2,
90 VECTOR3,
91 MATRIX32,
92 PLANE,
93 QUAT, // 10
94 _AABB, //sorry naming convention fail :( not like it's used often
95 MATRIX3,
96 TRANSFORM,
97
98 // misc types
99 COLOR,
100 IMAGE, // 15
101 NODE_PATH,
102 _RID,
103 OBJECT,
104 INPUT_EVENT,
105 DICTIONARY, // 20
106 ARRAY,
107
108 // arrays
109 RAW_ARRAY,
110 INT_ARRAY,
111 REAL_ARRAY,
112 STRING_ARRAY, // 25
113 VECTOR2_ARRAY,
114 VECTOR3_ARRAY,
115 COLOR_ARRAY,
116
117 VARIANT_MAX
118
119 };
120
121 private:
122 friend class _VariantCall;
123 // Variant takes 20 bytes when real_t is float, and 36 if double
124 // it only allocates extra memory for aabb/matrix.
125
126 Type type;
127
128 struct ObjData {
129
130 Object *obj;
131 RefPtr ref;
132 };
133
134 _FORCE_INLINE_ ObjData &_get_obj();
135 _FORCE_INLINE_ const ObjData &_get_obj() const;
136
137 union {
138
139 bool _bool;
140 int _int;
141 double _real;
142 Matrix32 *_matrix32;
143 AABB *_aabb;
144 Matrix3 *_matrix3;
145 Transform *_transform;
146 RefPtr *_resource;
147 InputEvent *_input_event;
148 Image *_image;
149 void *_ptr; //generic pointer
150 uint8_t _mem[sizeof(ObjData) > (sizeof(real_t) * 4) ? sizeof(ObjData) : (sizeof(real_t) * 4)];
151 } _data;
152
153 void reference(const Variant &p_variant);
154 void clear();
155
156 public:
get_type()157 _FORCE_INLINE_ Type get_type() const { return type; }
158 static String get_type_name(Variant::Type p_type);
159 static bool can_convert(Type p_type_from, Type p_type_to);
160 static bool can_convert_strict(Type p_type_from, Type p_type_to);
161
162 template <class T>
get_type_for()163 static Type get_type_for() {
164
165 GetSimpleType<T> t;
166 Variant v(t.type);
167 Type r = v.get_type();
168 return r;
169 }
170
171 bool is_ref() const;
is_num()172 _FORCE_INLINE_ bool is_num() const { return type == INT || type == REAL; };
is_array()173 _FORCE_INLINE_ bool is_array() const { return type >= ARRAY; };
174 bool is_shared() const;
175 bool is_zero() const;
176 bool is_one() const;
177
178 operator bool() const;
179 operator signed int() const;
180 operator unsigned int() const; // this is the real one
181 operator signed short() const;
182 operator unsigned short() const;
183 operator signed char() const;
184 operator unsigned char() const;
185 //operator long unsigned int() const;
186 operator int64_t() const;
187 operator uint64_t() const;
188 #ifdef NEED_LONG_INT
189 operator signed long() const;
190 operator unsigned long() const;
191 #endif
192
193 operator CharType() const;
194 operator float() const;
195 operator double() const;
196 operator String() const;
197 operator StringName() const;
198 operator Vector2() const;
199 operator Rect2() const;
200 operator Vector3() const;
201 operator Plane() const;
202 operator AABB() const;
203 operator Quat() const;
204 operator Matrix3() const;
205 operator Transform() const;
206 operator Matrix32() const;
207
208 operator Color() const;
209 operator Image() const;
210 operator NodePath() const;
211 operator RefPtr() const;
212 operator RID() const;
213 operator InputEvent() const;
214 operator Object *() const;
215 operator Node *() const;
216 operator Control *() const;
217
218 operator Dictionary() const;
219 operator Array() const;
220
221 operator DVector<uint8_t>() const;
222 operator DVector<int>() const;
223 operator DVector<real_t>() const;
224 operator DVector<String>() const;
225 operator DVector<Vector3>() const;
226 operator DVector<Color>() const;
227 operator DVector<Plane>() const;
228 operator DVector<Face3>() const;
229
230 operator Vector<Variant>() const;
231 operator Vector<uint8_t>() const;
232 operator Vector<int>() const;
233 operator Vector<real_t>() const;
234 operator Vector<String>() const;
235 operator Vector<Vector3>() const;
236 operator Vector<Color>() const;
237 operator Vector<RID>() const;
238 operator Vector<Vector2>() const;
239 operator DVector<Vector2>() const;
240 operator Vector<Plane>() const;
241
242 // some core type enums to convert to
243 operator Margin() const;
244 operator Orientation() const;
245
246 operator IP_Address() const;
247
248 Variant(bool p_bool);
249 Variant(signed int p_int); // real one
250 Variant(unsigned int p_int);
251 #ifdef NEED_LONG_INT
252 Variant(signed long p_long); // real one
253 Variant(unsigned long p_long);
254 //Variant(long unsigned int p_long);
255 #endif
256 Variant(signed short p_short); // real one
257 Variant(unsigned short p_short);
258 Variant(signed char p_char); // real one
259 Variant(unsigned char p_char);
260 Variant(int64_t p_char); // real one
261 Variant(uint64_t p_char);
262 Variant(float p_float);
263 Variant(double p_double);
264 Variant(const String &p_string);
265 Variant(const StringName &p_string);
266 Variant(const char *const p_cstring);
267 Variant(const CharType *p_wstring);
268 Variant(const Vector2 &p_vector2);
269 Variant(const Rect2 &p_rect2);
270 Variant(const Vector3 &p_vector3);
271 Variant(const Plane &p_plane);
272 Variant(const AABB &p_aabb);
273 Variant(const Quat &p_quat);
274 Variant(const Matrix3 &p_transform);
275 Variant(const Matrix32 &p_transform);
276 Variant(const Transform &p_transform);
277 Variant(const Color &p_color);
278 Variant(const Image &p_image);
279 Variant(const NodePath &p_path);
280 Variant(const RefPtr &p_resource);
281 Variant(const RID &p_rid);
282 Variant(const Object *p_object);
283 Variant(const InputEvent &p_input_event);
284 Variant(const Dictionary &p_dictionary);
285
286 Variant(const Array &p_array);
287 Variant(const DVector<Plane> &p_array); // helper
288 Variant(const DVector<uint8_t> &p_raw_array);
289 Variant(const DVector<int> &p_int_array);
290 Variant(const DVector<real_t> &p_real_array);
291 Variant(const DVector<String> &p_string_array);
292 Variant(const DVector<Vector3> &p_vector3_array);
293 Variant(const DVector<Color> &p_color_array);
294 Variant(const DVector<Face3> &p_face_array);
295
296 Variant(const Vector<Variant> &p_array);
297 Variant(const Vector<uint8_t> &p_raw_array);
298 Variant(const Vector<int> &p_int_array);
299 Variant(const Vector<real_t> &p_real_array);
300 Variant(const Vector<String> &p_string_array);
301 Variant(const Vector<Vector3> &p_vector3_array);
302 Variant(const Vector<Color> &p_color_array);
303 Variant(const Vector<Plane> &p_array); // helper
304 Variant(const Vector<RID> &p_array); // helper
305 Variant(const Vector<Vector2> &p_array); // helper
306 Variant(const DVector<Vector2> &p_array); // helper
307
308 Variant(const IP_Address &p_address);
309
310 enum Operator {
311
312 //comparation
313 OP_EQUAL,
314 OP_NOT_EQUAL,
315 OP_LESS,
316 OP_LESS_EQUAL,
317 OP_GREATER,
318 OP_GREATER_EQUAL,
319 //mathematic
320 OP_ADD,
321 OP_SUBSTRACT,
322 OP_MULTIPLY,
323 OP_DIVIDE,
324 OP_NEGATE,
325 OP_MODULE,
326 OP_STRING_CONCAT,
327 //bitwise
328 OP_SHIFT_LEFT,
329 OP_SHIFT_RIGHT,
330 OP_BIT_AND,
331 OP_BIT_OR,
332 OP_BIT_XOR,
333 OP_BIT_NEGATE,
334 //logic
335 OP_AND,
336 OP_OR,
337 OP_XOR,
338 OP_NOT,
339 //containment
340 OP_IN,
341 OP_MAX
342
343 };
344
345 static String get_operator_name(Operator p_op);
346 static void evaluate(const Operator &p_op, const Variant &p_a, const Variant &p_b, Variant &r_ret, bool &r_valid);
evaluate(const Operator & p_op,const Variant & p_a,const Variant & p_b)347 static _FORCE_INLINE_ Variant evaluate(const Operator &p_op, const Variant &p_a, const Variant &p_b) {
348
349 bool valid = true;
350 Variant res;
351 evaluate(p_op, p_a, p_b, res, valid);
352 return res;
353 }
354
355 void zero();
356 static void blend(const Variant &a, const Variant &b, float c, Variant &r_dst);
357 static void interpolate(const Variant &a, const Variant &b, float c, Variant &r_dst);
358
359 struct CallError {
360 enum Error {
361 CALL_OK,
362 CALL_ERROR_INVALID_METHOD,
363 CALL_ERROR_INVALID_ARGUMENT,
364 CALL_ERROR_TOO_MANY_ARGUMENTS,
365 CALL_ERROR_TOO_FEW_ARGUMENTS,
366 CALL_ERROR_INSTANCE_IS_NULL,
367 };
368 Error error;
369 int argument;
370 Type expected;
371 };
372
373 void call_ptr(const StringName &p_method, const Variant **p_args, int p_argcount, Variant *r_ret, CallError &r_error);
374 Variant call(const StringName &p_method, const Variant **p_args, int p_argcount, CallError &r_error);
375 Variant call(const StringName &p_method, const Variant &p_arg1 = Variant(), const Variant &p_arg2 = Variant(), const Variant &p_arg3 = Variant(), const Variant &p_arg4 = Variant(), const Variant &p_arg5 = Variant());
376
377 static String get_call_error_text(Object *p_base, const StringName &p_method, const Variant **p_argptrs, int p_argcount, const Variant::CallError &ce);
378
379 static Variant construct(const Variant::Type, const Variant **p_args, int p_argcount, CallError &r_error, bool p_strict = true);
380
381 void get_method_list(List<MethodInfo> *p_list) const;
382 bool has_method(const StringName &p_method) const;
383
384 void set_named(const StringName &p_index, const Variant &p_value, bool *r_valid = NULL);
385 Variant get_named(const StringName &p_index, bool *r_valid = NULL) const;
386
387 void set(const Variant &p_index, const Variant &p_value, bool *r_valid = NULL);
388 Variant get(const Variant &p_index, bool *r_valid = NULL) const;
389 bool in(const Variant &p_index, bool *r_valid = NULL) const;
390
391 bool iter_init(Variant &r_iter, bool &r_valid) const;
392 bool iter_next(Variant &r_iter, bool &r_valid) const;
393 Variant iter_get(const Variant &r_iter, bool &r_valid) const;
394
395 void get_property_list(List<PropertyInfo> *p_list) const;
396
397 //argsVariant call()
398
399 bool operator==(const Variant &p_variant) const;
400 bool operator!=(const Variant &p_variant) const;
401 bool operator<(const Variant &p_variant) const;
402 uint32_t hash() const;
403
404 bool hash_compare(const Variant &p_variant) const;
405 bool booleanize(bool &valid) const;
406
407 void static_assign(const Variant &p_variant);
408 static void get_constructor_list(Variant::Type p_type, List<MethodInfo> *p_list);
409 static void get_numeric_constants_for_type(Variant::Type p_type, List<StringName> *p_constants);
410 static bool has_numeric_constant(Variant::Type p_type, const StringName &p_value);
411 static int get_numeric_constant_value(Variant::Type p_type, const StringName &p_value);
412
413 typedef String (*ObjectDeConstruct)(const Variant &p_object, void *ud);
414 typedef void (*ObjectConstruct)(const String &p_text, void *ud, Variant &r_value);
415
416 String get_construct_string() const;
417 static void construct_from_string(const String &p_string, Variant &r_value, ObjectConstruct p_obj_construct = NULL, void *p_construct_ud = NULL);
418
419 void operator=(const Variant &p_variant); // only this is enough for all the other types
420 Variant(const Variant &p_variant);
Variant()421 _FORCE_INLINE_ Variant() { type = NIL; }
~Variant()422 _FORCE_INLINE_ ~Variant() {
423 if (type != Variant::NIL) clear();
424 }
425 };
426
427 //typedef Dictionary Dictionary; no
428 //typedef Array Array;
429
430 Vector<Variant> varray();
431 Vector<Variant> varray(const Variant &p_arg1);
432 Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2);
433 Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3);
434 Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4);
435 Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4, const Variant &p_arg5);
436
437 struct VariantHasher {
438
hashVariantHasher439 static _FORCE_INLINE_ uint32_t hash(const Variant &p_variant) { return p_variant.hash(); }
440 };
441
442 struct VariantComparator {
443
compareVariantComparator444 static _FORCE_INLINE_ bool compare(const Variant &p_lhs, const Variant &p_rhs) { return p_lhs.hash_compare(p_rhs); }
445 };
446
_get_obj()447 Variant::ObjData &Variant::_get_obj() {
448 return *reinterpret_cast<ObjData *>(&_data._mem[0]);
449 }
450
_get_obj()451 const Variant::ObjData &Variant::_get_obj() const {
452
453 return *reinterpret_cast<const ObjData *>(&_data._mem[0]);
454 }
455
456 String vformat(const String &p_text, const Variant &p1 = Variant(), const Variant &p2 = Variant(), const Variant &p3 = Variant(), const Variant &p4 = Variant(), const Variant &p5 = Variant());
457 #endif
458