CoCalc -- variant

GitHub Repository: godotengine/godot
Path: blob/master/core/variant/variant_internal.h
⁹⁹⁰² views
1
/**************************************************************************/
2
/*  variant_internal.h                                                    */
3
/**************************************************************************/
4
/*                         This file is part of:                          */
5
/*                             GODOT ENGINE                               */
6
/*                        https://godotengine.org                         */
7
/**************************************************************************/
8
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
9
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
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
#pragma once
32

33
#include "variant.h"
34

35
#include "core/templates/simple_type.h"
36

37
// For use when you want to access the internal pointer of a Variant directly.
38
// Use with caution. You need to be sure that the type is correct.
39

40
class RefCounted;
41

42
class VariantInternal {
43
	friend class Variant;
44

45
public:
46
	// Set type.
47
	_FORCE_INLINE_ static void initialize(Variant *v, Variant::Type p_type) {
48
		v->clear();
49
		v->type = p_type;
50

51
		switch (p_type) {
52
			case Variant::STRING:
53
				init_string(v);
54
				break;
55
			case Variant::TRANSFORM2D:
56
				init_transform2d(v);
57
				break;
58
			case Variant::AABB:
59
				init_aabb(v);
60
				break;
61
			case Variant::BASIS:
62
				init_basis(v);
63
				break;
64
			case Variant::TRANSFORM3D:
65
				init_transform3d(v);
66
				break;
67
			case Variant::PROJECTION:
68
				init_projection(v);
69
				break;
70
			case Variant::COLOR:
71
				init_color(v);
72
				break;
73
			case Variant::STRING_NAME:
74
				init_string_name(v);
75
				break;
76
			case Variant::NODE_PATH:
77
				init_node_path(v);
78
				break;
79
			case Variant::CALLABLE:
80
				init_callable(v);
81
				break;
82
			case Variant::SIGNAL:
83
				init_signal(v);
84
				break;
85
			case Variant::DICTIONARY:
86
				init_dictionary(v);
87
				break;
88
			case Variant::ARRAY:
89
				init_array(v);
90
				break;
91
			case Variant::PACKED_BYTE_ARRAY:
92
				init_byte_array(v);
93
				break;
94
			case Variant::PACKED_INT32_ARRAY:
95
				init_int32_array(v);
96
				break;
97
			case Variant::PACKED_INT64_ARRAY:
98
				init_int64_array(v);
99
				break;
100
			case Variant::PACKED_FLOAT32_ARRAY:
101
				init_float32_array(v);
102
				break;
103
			case Variant::PACKED_FLOAT64_ARRAY:
104
				init_float64_array(v);
105
				break;
106
			case Variant::PACKED_STRING_ARRAY:
107
				init_string_array(v);
108
				break;
109
			case Variant::PACKED_VECTOR2_ARRAY:
110
				init_vector2_array(v);
111
				break;
112
			case Variant::PACKED_VECTOR3_ARRAY:
113
				init_vector3_array(v);
114
				break;
115
			case Variant::PACKED_COLOR_ARRAY:
116
				init_color_array(v);
117
				break;
118
			case Variant::PACKED_VECTOR4_ARRAY:
119
				init_vector4_array(v);
120
				break;
121
			case Variant::OBJECT:
122
				init_object(v);
123
				break;
124
			default:
125
				break;
126
		}
127
	}
128

129
	// Atomic types.
130
	_FORCE_INLINE_ static bool *get_bool(Variant *v) { return &v->_data._bool; }
131
	_FORCE_INLINE_ static const bool *get_bool(const Variant *v) { return &v->_data._bool; }
132
	_FORCE_INLINE_ static int64_t *get_int(Variant *v) { return &v->_data._int; }
133
	_FORCE_INLINE_ static const int64_t *get_int(const Variant *v) { return &v->_data._int; }
134
	_FORCE_INLINE_ static double *get_float(Variant *v) { return &v->_data._float; }
135
	_FORCE_INLINE_ static const double *get_float(const Variant *v) { return &v->_data._float; }
136
	_FORCE_INLINE_ static String *get_string(Variant *v) { return reinterpret_cast<String *>(v->_data._mem); }
137
	_FORCE_INLINE_ static const String *get_string(const Variant *v) { return reinterpret_cast<const String *>(v->_data._mem); }
138

139
	// Math types.
140
	_FORCE_INLINE_ static Vector2 *get_vector2(Variant *v) { return reinterpret_cast<Vector2 *>(v->_data._mem); }
141
	_FORCE_INLINE_ static const Vector2 *get_vector2(const Variant *v) { return reinterpret_cast<const Vector2 *>(v->_data._mem); }
142
	_FORCE_INLINE_ static Vector2i *get_vector2i(Variant *v) { return reinterpret_cast<Vector2i *>(v->_data._mem); }
143
	_FORCE_INLINE_ static const Vector2i *get_vector2i(const Variant *v) { return reinterpret_cast<const Vector2i *>(v->_data._mem); }
144
	_FORCE_INLINE_ static Rect2 *get_rect2(Variant *v) { return reinterpret_cast<Rect2 *>(v->_data._mem); }
145
	_FORCE_INLINE_ static const Rect2 *get_rect2(const Variant *v) { return reinterpret_cast<const Rect2 *>(v->_data._mem); }
146
	_FORCE_INLINE_ static Rect2i *get_rect2i(Variant *v) { return reinterpret_cast<Rect2i *>(v->_data._mem); }
147
	_FORCE_INLINE_ static const Rect2i *get_rect2i(const Variant *v) { return reinterpret_cast<const Rect2i *>(v->_data._mem); }
148
	_FORCE_INLINE_ static Vector3 *get_vector3(Variant *v) { return reinterpret_cast<Vector3 *>(v->_data._mem); }
149
	_FORCE_INLINE_ static const Vector3 *get_vector3(const Variant *v) { return reinterpret_cast<const Vector3 *>(v->_data._mem); }
150
	_FORCE_INLINE_ static Vector3i *get_vector3i(Variant *v) { return reinterpret_cast<Vector3i *>(v->_data._mem); }
151
	_FORCE_INLINE_ static const Vector3i *get_vector3i(const Variant *v) { return reinterpret_cast<const Vector3i *>(v->_data._mem); }
152
	_FORCE_INLINE_ static Vector4 *get_vector4(Variant *v) { return reinterpret_cast<Vector4 *>(v->_data._mem); }
153
	_FORCE_INLINE_ static const Vector4 *get_vector4(const Variant *v) { return reinterpret_cast<const Vector4 *>(v->_data._mem); }
154
	_FORCE_INLINE_ static Vector4i *get_vector4i(Variant *v) { return reinterpret_cast<Vector4i *>(v->_data._mem); }
155
	_FORCE_INLINE_ static const Vector4i *get_vector4i(const Variant *v) { return reinterpret_cast<const Vector4i *>(v->_data._mem); }
156
	_FORCE_INLINE_ static Transform2D *get_transform2d(Variant *v) { return v->_data._transform2d; }
157
	_FORCE_INLINE_ static const Transform2D *get_transform2d(const Variant *v) { return v->_data._transform2d; }
158
	_FORCE_INLINE_ static Plane *get_plane(Variant *v) { return reinterpret_cast<Plane *>(v->_data._mem); }
159
	_FORCE_INLINE_ static const Plane *get_plane(const Variant *v) { return reinterpret_cast<const Plane *>(v->_data._mem); }
160
	_FORCE_INLINE_ static Quaternion *get_quaternion(Variant *v) { return reinterpret_cast<Quaternion *>(v->_data._mem); }
161
	_FORCE_INLINE_ static const Quaternion *get_quaternion(const Variant *v) { return reinterpret_cast<const Quaternion *>(v->_data._mem); }
162
	_FORCE_INLINE_ static ::AABB *get_aabb(Variant *v) { return v->_data._aabb; }
163
	_FORCE_INLINE_ static const ::AABB *get_aabb(const Variant *v) { return v->_data._aabb; }
164
	_FORCE_INLINE_ static Basis *get_basis(Variant *v) { return v->_data._basis; }
165
	_FORCE_INLINE_ static const Basis *get_basis(const Variant *v) { return v->_data._basis; }
166
	_FORCE_INLINE_ static Transform3D *get_transform(Variant *v) { return v->_data._transform3d; }
167
	_FORCE_INLINE_ static const Transform3D *get_transform(const Variant *v) { return v->_data._transform3d; }
168
	_FORCE_INLINE_ static Projection *get_projection(Variant *v) { return v->_data._projection; }
169
	_FORCE_INLINE_ static const Projection *get_projection(const Variant *v) { return v->_data._projection; }
170

171
	// Misc types.
172
	_FORCE_INLINE_ static Color *get_color(Variant *v) { return reinterpret_cast<Color *>(v->_data._mem); }
173
	_FORCE_INLINE_ static const Color *get_color(const Variant *v) { return reinterpret_cast<const Color *>(v->_data._mem); }
174
	_FORCE_INLINE_ static StringName *get_string_name(Variant *v) { return reinterpret_cast<StringName *>(v->_data._mem); }
175
	_FORCE_INLINE_ static const StringName *get_string_name(const Variant *v) { return reinterpret_cast<const StringName *>(v->_data._mem); }
176
	_FORCE_INLINE_ static NodePath *get_node_path(Variant *v) { return reinterpret_cast<NodePath *>(v->_data._mem); }
177
	_FORCE_INLINE_ static const NodePath *get_node_path(const Variant *v) { return reinterpret_cast<const NodePath *>(v->_data._mem); }
178
	_FORCE_INLINE_ static ::RID *get_rid(Variant *v) { return reinterpret_cast<::RID *>(v->_data._mem); }
179
	_FORCE_INLINE_ static const ::RID *get_rid(const Variant *v) { return reinterpret_cast<const ::RID *>(v->_data._mem); }
180
	_FORCE_INLINE_ static Callable *get_callable(Variant *v) { return reinterpret_cast<Callable *>(v->_data._mem); }
181
	_FORCE_INLINE_ static const Callable *get_callable(const Variant *v) { return reinterpret_cast<const Callable *>(v->_data._mem); }
182
	_FORCE_INLINE_ static Signal *get_signal(Variant *v) { return reinterpret_cast<Signal *>(v->_data._mem); }
183
	_FORCE_INLINE_ static const Signal *get_signal(const Variant *v) { return reinterpret_cast<const Signal *>(v->_data._mem); }
184
	_FORCE_INLINE_ static Dictionary *get_dictionary(Variant *v) { return reinterpret_cast<Dictionary *>(v->_data._mem); }
185
	_FORCE_INLINE_ static const Dictionary *get_dictionary(const Variant *v) { return reinterpret_cast<const Dictionary *>(v->_data._mem); }
186
	_FORCE_INLINE_ static Array *get_array(Variant *v) { return reinterpret_cast<Array *>(v->_data._mem); }
187
	_FORCE_INLINE_ static const Array *get_array(const Variant *v) { return reinterpret_cast<const Array *>(v->_data._mem); }
188

189
	// Typed arrays.
190
	_FORCE_INLINE_ static PackedByteArray *get_byte_array(Variant *v) { return &static_cast<Variant::PackedArrayRef<uint8_t> *>(v->_data.packed_array)->array; }
191
	_FORCE_INLINE_ static const PackedByteArray *get_byte_array(const Variant *v) { return &static_cast<const Variant::PackedArrayRef<uint8_t> *>(v->_data.packed_array)->array; }
192
	_FORCE_INLINE_ static PackedInt32Array *get_int32_array(Variant *v) { return &static_cast<Variant::PackedArrayRef<int32_t> *>(v->_data.packed_array)->array; }
193
	_FORCE_INLINE_ static const PackedInt32Array *get_int32_array(const Variant *v) { return &static_cast<const Variant::PackedArrayRef<int32_t> *>(v->_data.packed_array)->array; }
194
	_FORCE_INLINE_ static PackedInt64Array *get_int64_array(Variant *v) { return &static_cast<Variant::PackedArrayRef<int64_t> *>(v->_data.packed_array)->array; }
195
	_FORCE_INLINE_ static const PackedInt64Array *get_int64_array(const Variant *v) { return &static_cast<const Variant::PackedArrayRef<int64_t> *>(v->_data.packed_array)->array; }
196
	_FORCE_INLINE_ static PackedFloat32Array *get_float32_array(Variant *v) { return &static_cast<Variant::PackedArrayRef<float> *>(v->_data.packed_array)->array; }
197
	_FORCE_INLINE_ static const PackedFloat32Array *get_float32_array(const Variant *v) { return &static_cast<const Variant::PackedArrayRef<float> *>(v->_data.packed_array)->array; }
198
	_FORCE_INLINE_ static PackedFloat64Array *get_float64_array(Variant *v) { return &static_cast<Variant::PackedArrayRef<double> *>(v->_data.packed_array)->array; }
199
	_FORCE_INLINE_ static const PackedFloat64Array *get_float64_array(const Variant *v) { return &static_cast<const Variant::PackedArrayRef<double> *>(v->_data.packed_array)->array; }
200
	_FORCE_INLINE_ static PackedStringArray *get_string_array(Variant *v) { return &static_cast<Variant::PackedArrayRef<String> *>(v->_data.packed_array)->array; }
201
	_FORCE_INLINE_ static const PackedStringArray *get_string_array(const Variant *v) { return &static_cast<const Variant::PackedArrayRef<String> *>(v->_data.packed_array)->array; }
202
	_FORCE_INLINE_ static PackedVector2Array *get_vector2_array(Variant *v) { return &static_cast<Variant::PackedArrayRef<Vector2> *>(v->_data.packed_array)->array; }
203
	_FORCE_INLINE_ static const PackedVector2Array *get_vector2_array(const Variant *v) { return &static_cast<const Variant::PackedArrayRef<Vector2> *>(v->_data.packed_array)->array; }
204
	_FORCE_INLINE_ static PackedVector3Array *get_vector3_array(Variant *v) { return &static_cast<Variant::PackedArrayRef<Vector3> *>(v->_data.packed_array)->array; }
205
	_FORCE_INLINE_ static const PackedVector3Array *get_vector3_array(const Variant *v) { return &static_cast<const Variant::PackedArrayRef<Vector3> *>(v->_data.packed_array)->array; }
206
	_FORCE_INLINE_ static PackedColorArray *get_color_array(Variant *v) { return &static_cast<Variant::PackedArrayRef<Color> *>(v->_data.packed_array)->array; }
207
	_FORCE_INLINE_ static const PackedColorArray *get_color_array(const Variant *v) { return &static_cast<const Variant::PackedArrayRef<Color> *>(v->_data.packed_array)->array; }
208
	_FORCE_INLINE_ static PackedVector4Array *get_vector4_array(Variant *v) { return &static_cast<Variant::PackedArrayRef<Vector4> *>(v->_data.packed_array)->array; }
209
	_FORCE_INLINE_ static const PackedVector4Array *get_vector4_array(const Variant *v) { return &static_cast<const Variant::PackedArrayRef<Vector4> *>(v->_data.packed_array)->array; }
210

211
	_FORCE_INLINE_ static Object **get_object(Variant *v) { return (Object **)&v->_get_obj().obj; }
212
	_FORCE_INLINE_ static const Object **get_object(const Variant *v) { return (const Object **)&v->_get_obj().obj; }
213

214
	_FORCE_INLINE_ static const ObjectID get_object_id(const Variant *v) { return v->_get_obj().id; }
215

216
	template <typename T>
217
	_FORCE_INLINE_ static void init_generic(Variant *v) {
218
		v->type = GetTypeInfo<T>::VARIANT_TYPE;
219
	}
220

221
	// Should be in the same order as Variant::Type for consistency.
222
	// Those primitive and vector types don't need an `init_` method:
223
	// Nil, bool, float, Vector2/i, Rect2/i, Vector3/i, Plane, Quat, RID.
224
	// Object is a special case, handled via `object_reset_data`.
225
	_FORCE_INLINE_ static void init_string(Variant *v) {
226
		memnew_placement(v->_data._mem, String);
227
		v->type = Variant::STRING;
228
	}
229
	_FORCE_INLINE_ static void init_transform2d(Variant *v) {
230
		v->_data._transform2d = (Transform2D *)Variant::Pools::_bucket_small.alloc();
231
		memnew_placement(v->_data._transform2d, Transform2D);
232
		v->type = Variant::TRANSFORM2D;
233
	}
234
	_FORCE_INLINE_ static void init_aabb(Variant *v) {
235
		v->_data._aabb = (AABB *)Variant::Pools::_bucket_small.alloc();
236
		memnew_placement(v->_data._aabb, AABB);
237
		v->type = Variant::AABB;
238
	}
239
	_FORCE_INLINE_ static void init_basis(Variant *v) {
240
		v->_data._basis = (Basis *)Variant::Pools::_bucket_medium.alloc();
241
		memnew_placement(v->_data._basis, Basis);
242
		v->type = Variant::BASIS;
243
	}
244
	_FORCE_INLINE_ static void init_transform3d(Variant *v) {
245
		v->_data._transform3d = (Transform3D *)Variant::Pools::_bucket_medium.alloc();
246
		memnew_placement(v->_data._transform3d, Transform3D);
247
		v->type = Variant::TRANSFORM3D;
248
	}
249
	_FORCE_INLINE_ static void init_projection(Variant *v) {
250
		v->_data._projection = (Projection *)Variant::Pools::_bucket_large.alloc();
251
		memnew_placement(v->_data._projection, Projection);
252
		v->type = Variant::PROJECTION;
253
	}
254
	_FORCE_INLINE_ static void init_color(Variant *v) {
255
		memnew_placement(v->_data._mem, Color);
256
		v->type = Variant::COLOR;
257
	}
258
	_FORCE_INLINE_ static void init_string_name(Variant *v) {
259
		memnew_placement(v->_data._mem, StringName);
260
		v->type = Variant::STRING_NAME;
261
	}
262
	_FORCE_INLINE_ static void init_node_path(Variant *v) {
263
		memnew_placement(v->_data._mem, NodePath);
264
		v->type = Variant::NODE_PATH;
265
	}
266
	_FORCE_INLINE_ static void init_callable(Variant *v) {
267
		memnew_placement(v->_data._mem, Callable);
268
		v->type = Variant::CALLABLE;
269
	}
270
	_FORCE_INLINE_ static void init_signal(Variant *v) {
271
		memnew_placement(v->_data._mem, Signal);
272
		v->type = Variant::SIGNAL;
273
	}
274
	_FORCE_INLINE_ static void init_dictionary(Variant *v) {
275
		memnew_placement(v->_data._mem, Dictionary);
276
		v->type = Variant::DICTIONARY;
277
	}
278
	_FORCE_INLINE_ static void init_array(Variant *v) {
279
		memnew_placement(v->_data._mem, Array);
280
		v->type = Variant::ARRAY;
281
	}
282
	_FORCE_INLINE_ static void init_byte_array(Variant *v) {
283
		v->_data.packed_array = Variant::PackedArrayRef<uint8_t>::create(Vector<uint8_t>());
284
		v->type = Variant::PACKED_BYTE_ARRAY;
285
	}
286
	_FORCE_INLINE_ static void init_int32_array(Variant *v) {
287
		v->_data.packed_array = Variant::PackedArrayRef<int32_t>::create(Vector<int32_t>());
288
		v->type = Variant::PACKED_INT32_ARRAY;
289
	}
290
	_FORCE_INLINE_ static void init_int64_array(Variant *v) {
291
		v->_data.packed_array = Variant::PackedArrayRef<int64_t>::create(Vector<int64_t>());
292
		v->type = Variant::PACKED_INT64_ARRAY;
293
	}
294
	_FORCE_INLINE_ static void init_float32_array(Variant *v) {
295
		v->_data.packed_array = Variant::PackedArrayRef<float>::create(Vector<float>());
296
		v->type = Variant::PACKED_FLOAT32_ARRAY;
297
	}
298
	_FORCE_INLINE_ static void init_float64_array(Variant *v) {
299
		v->_data.packed_array = Variant::PackedArrayRef<double>::create(Vector<double>());
300
		v->type = Variant::PACKED_FLOAT64_ARRAY;
301
	}
302
	_FORCE_INLINE_ static void init_string_array(Variant *v) {
303
		v->_data.packed_array = Variant::PackedArrayRef<String>::create(Vector<String>());
304
		v->type = Variant::PACKED_STRING_ARRAY;
305
	}
306
	_FORCE_INLINE_ static void init_vector2_array(Variant *v) {
307
		v->_data.packed_array = Variant::PackedArrayRef<Vector2>::create(Vector<Vector2>());
308
		v->type = Variant::PACKED_VECTOR2_ARRAY;
309
	}
310
	_FORCE_INLINE_ static void init_vector3_array(Variant *v) {
311
		v->_data.packed_array = Variant::PackedArrayRef<Vector3>::create(Vector<Vector3>());
312
		v->type = Variant::PACKED_VECTOR3_ARRAY;
313
	}
314
	_FORCE_INLINE_ static void init_color_array(Variant *v) {
315
		v->_data.packed_array = Variant::PackedArrayRef<Color>::create(Vector<Color>());
316
		v->type = Variant::PACKED_COLOR_ARRAY;
317
	}
318
	_FORCE_INLINE_ static void init_vector4_array(Variant *v) {
319
		v->_data.packed_array = Variant::PackedArrayRef<Vector4>::create(Vector<Vector4>());
320
		v->type = Variant::PACKED_VECTOR4_ARRAY;
321
	}
322
	_FORCE_INLINE_ static void init_object(Variant *v) {
323
		object_reset_data(v);
324
		v->type = Variant::OBJECT;
325
	}
326

327
	_FORCE_INLINE_ static void clear(Variant *v) {
328
		v->clear();
329
	}
330

331
	_FORCE_INLINE_ static void object_assign(Variant *v, const Variant *vo) {
332
		v->_get_obj().ref(vo->_get_obj());
333
	}
334

335
	_FORCE_INLINE_ static void object_assign(Variant *v, Object *o) {
336
		v->_get_obj().ref_pointer(o);
337
	}
338

339
	_FORCE_INLINE_ static void object_assign(Variant *v, const Object *o) {
340
		v->_get_obj().ref_pointer(const_cast<Object *>(o));
341
	}
342

343
	template <typename T>
344
	_FORCE_INLINE_ static void object_assign(Variant *v, const Ref<T> &r) {
345
		v->_get_obj().ref(r);
346
	}
347

348
	_FORCE_INLINE_ static void object_reset_data(Variant *v) {
349
		v->_get_obj() = Variant::ObjData();
350
	}
351

352
	_FORCE_INLINE_ static void update_object_id(Variant *v) {
353
		const Object *o = v->_get_obj().obj;
354
		if (o) {
355
			v->_get_obj().id = o->get_instance_id();
356
		}
357
	}
358

359
	_FORCE_INLINE_ static void *get_opaque_pointer(Variant *v) {
360
		switch (v->type) {
361
			case Variant::NIL:
362
				return nullptr;
363
			case Variant::BOOL:
364
				return get_bool(v);
365
			case Variant::INT:
366
				return get_int(v);
367
			case Variant::FLOAT:
368
				return get_float(v);
369
			case Variant::STRING:
370
				return get_string(v);
371
			case Variant::VECTOR2:
372
				return get_vector2(v);
373
			case Variant::VECTOR2I:
374
				return get_vector2i(v);
375
			case Variant::VECTOR3:
376
				return get_vector3(v);
377
			case Variant::VECTOR3I:
378
				return get_vector3i(v);
379
			case Variant::VECTOR4:
380
				return get_vector4(v);
381
			case Variant::VECTOR4I:
382
				return get_vector4i(v);
383
			case Variant::RECT2:
384
				return get_rect2(v);
385
			case Variant::RECT2I:
386
				return get_rect2i(v);
387
			case Variant::TRANSFORM3D:
388
				return get_transform(v);
389
			case Variant::PROJECTION:
390
				return get_projection(v);
391
			case Variant::TRANSFORM2D:
392
				return get_transform2d(v);
393
			case Variant::QUATERNION:
394
				return get_quaternion(v);
395
			case Variant::PLANE:
396
				return get_plane(v);
397
			case Variant::BASIS:
398
				return get_basis(v);
399
			case Variant::AABB:
400
				return get_aabb(v);
401
			case Variant::COLOR:
402
				return get_color(v);
403
			case Variant::STRING_NAME:
404
				return get_string_name(v);
405
			case Variant::NODE_PATH:
406
				return get_node_path(v);
407
			case Variant::RID:
408
				return get_rid(v);
409
			case Variant::CALLABLE:
410
				return get_callable(v);
411
			case Variant::SIGNAL:
412
				return get_signal(v);
413
			case Variant::DICTIONARY:
414
				return get_dictionary(v);
415
			case Variant::ARRAY:
416
				return get_array(v);
417
			case Variant::PACKED_BYTE_ARRAY:
418
				return get_byte_array(v);
419
			case Variant::PACKED_INT32_ARRAY:
420
				return get_int32_array(v);
421
			case Variant::PACKED_INT64_ARRAY:
422
				return get_int64_array(v);
423
			case Variant::PACKED_FLOAT32_ARRAY:
424
				return get_float32_array(v);
425
			case Variant::PACKED_FLOAT64_ARRAY:
426
				return get_float64_array(v);
427
			case Variant::PACKED_STRING_ARRAY:
428
				return get_string_array(v);
429
			case Variant::PACKED_VECTOR2_ARRAY:
430
				return get_vector2_array(v);
431
			case Variant::PACKED_VECTOR3_ARRAY:
432
				return get_vector3_array(v);
433
			case Variant::PACKED_COLOR_ARRAY:
434
				return get_color_array(v);
435
			case Variant::PACKED_VECTOR4_ARRAY:
436
				return get_vector4_array(v);
437
			case Variant::OBJECT:
438
				return get_object(v);
439
			case Variant::VARIANT_MAX:
440
				ERR_FAIL_V(nullptr);
441
		}
442
		ERR_FAIL_V(nullptr);
443
	}
444

445
	_FORCE_INLINE_ static const void *get_opaque_pointer(const Variant *v) {
446
		switch (v->type) {
447
			case Variant::NIL:
448
				return nullptr;
449
			case Variant::BOOL:
450
				return get_bool(v);
451
			case Variant::INT:
452
				return get_int(v);
453
			case Variant::FLOAT:
454
				return get_float(v);
455
			case Variant::STRING:
456
				return get_string(v);
457
			case Variant::VECTOR2:
458
				return get_vector2(v);
459
			case Variant::VECTOR2I:
460
				return get_vector2i(v);
461
			case Variant::VECTOR3:
462
				return get_vector3(v);
463
			case Variant::VECTOR3I:
464
				return get_vector3i(v);
465
			case Variant::VECTOR4:
466
				return get_vector4(v);
467
			case Variant::VECTOR4I:
468
				return get_vector4i(v);
469
			case Variant::RECT2:
470
				return get_rect2(v);
471
			case Variant::RECT2I:
472
				return get_rect2i(v);
473
			case Variant::TRANSFORM3D:
474
				return get_transform(v);
475
			case Variant::PROJECTION:
476
				return get_projection(v);
477
			case Variant::TRANSFORM2D:
478
				return get_transform2d(v);
479
			case Variant::QUATERNION:
480
				return get_quaternion(v);
481
			case Variant::PLANE:
482
				return get_plane(v);
483
			case Variant::BASIS:
484
				return get_basis(v);
485
			case Variant::AABB:
486
				return get_aabb(v);
487
			case Variant::COLOR:
488
				return get_color(v);
489
			case Variant::STRING_NAME:
490
				return get_string_name(v);
491
			case Variant::NODE_PATH:
492
				return get_node_path(v);
493
			case Variant::RID:
494
				return get_rid(v);
495
			case Variant::CALLABLE:
496
				return get_callable(v);
497
			case Variant::SIGNAL:
498
				return get_signal(v);
499
			case Variant::DICTIONARY:
500
				return get_dictionary(v);
501
			case Variant::ARRAY:
502
				return get_array(v);
503
			case Variant::PACKED_BYTE_ARRAY:
504
				return get_byte_array(v);
505
			case Variant::PACKED_INT32_ARRAY:
506
				return get_int32_array(v);
507
			case Variant::PACKED_INT64_ARRAY:
508
				return get_int64_array(v);
509
			case Variant::PACKED_FLOAT32_ARRAY:
510
				return get_float32_array(v);
511
			case Variant::PACKED_FLOAT64_ARRAY:
512
				return get_float64_array(v);
513
			case Variant::PACKED_STRING_ARRAY:
514
				return get_string_array(v);
515
			case Variant::PACKED_VECTOR2_ARRAY:
516
				return get_vector2_array(v);
517
			case Variant::PACKED_VECTOR3_ARRAY:
518
				return get_vector3_array(v);
519
			case Variant::PACKED_COLOR_ARRAY:
520
				return get_color_array(v);
521
			case Variant::PACKED_VECTOR4_ARRAY:
522
				return get_vector4_array(v);
523
			case Variant::OBJECT:
524
				return get_object(v);
525
			case Variant::VARIANT_MAX:
526
				ERR_FAIL_V(nullptr);
527
		}
528
		ERR_FAIL_V(nullptr);
529
	}
530
};
531

532
template <typename T, typename = void>
533
struct VariantGetInternalPtr;
534

535
template <typename T>
536
struct VariantGetInternalPtr<T, std::enable_if_t<!std::is_same_v<T, GetSimpleTypeT<T>>>> : VariantGetInternalPtr<GetSimpleTypeT<T>> {};
537

538
template <>
539
struct VariantGetInternalPtr<bool> {
540
	static bool *get_ptr(Variant *v) { return VariantInternal::get_bool(v); }
541
	static const bool *get_ptr(const Variant *v) { return VariantInternal::get_bool(v); }
542
};
543

544
template <typename T>
545
struct VariantGetInternalPtr<T, std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>> {
546
	static int64_t *get_ptr(Variant *v) { return VariantInternal::get_int(v); }
547
	static const int64_t *get_ptr(const Variant *v) { return VariantInternal::get_int(v); }
548
};
549

550
template <typename T>
551
struct VariantGetInternalPtr<BitField<T>, std::enable_if_t<std::is_enum_v<T>>> {
552
	static int64_t *get_ptr(Variant *v) { return VariantInternal::get_int(v); }
553
	static const int64_t *get_ptr(const Variant *v) { return VariantInternal::get_int(v); }
554
};
555

556
template <>
557
struct VariantGetInternalPtr<ObjectID> {
558
	static int64_t *get_ptr(Variant *v) { return VariantInternal::get_int(v); }
559
	static const int64_t *get_ptr(const Variant *v) { return VariantInternal::get_int(v); }
560
};
561

562
template <>
563
struct VariantGetInternalPtr<float> {
564
	static double *get_ptr(Variant *v) { return VariantInternal::get_float(v); }
565
	static const double *get_ptr(const Variant *v) { return VariantInternal::get_float(v); }
566
};
567

568
template <>
569
struct VariantGetInternalPtr<double> {
570
	static double *get_ptr(Variant *v) { return VariantInternal::get_float(v); }
571
	static const double *get_ptr(const Variant *v) { return VariantInternal::get_float(v); }
572
};
573

574
template <>
575
struct VariantGetInternalPtr<String> {
576
	static String *get_ptr(Variant *v) { return VariantInternal::get_string(v); }
577
	static const String *get_ptr(const Variant *v) { return VariantInternal::get_string(v); }
578
};
579

580
template <>
581
struct VariantGetInternalPtr<Vector2> {
582
	static Vector2 *get_ptr(Variant *v) { return VariantInternal::get_vector2(v); }
583
	static const Vector2 *get_ptr(const Variant *v) { return VariantInternal::get_vector2(v); }
584
};
585

586
template <>
587
struct VariantGetInternalPtr<Vector2i> {
588
	static Vector2i *get_ptr(Variant *v) { return VariantInternal::get_vector2i(v); }
589
	static const Vector2i *get_ptr(const Variant *v) { return VariantInternal::get_vector2i(v); }
590
};
591

592
template <>
593
struct VariantGetInternalPtr<Rect2> {
594
	static Rect2 *get_ptr(Variant *v) { return VariantInternal::get_rect2(v); }
595
	static const Rect2 *get_ptr(const Variant *v) { return VariantInternal::get_rect2(v); }
596
};
597

598
template <>
599
struct VariantGetInternalPtr<Rect2i> {
600
	static Rect2i *get_ptr(Variant *v) { return VariantInternal::get_rect2i(v); }
601
	static const Rect2i *get_ptr(const Variant *v) { return VariantInternal::get_rect2i(v); }
602
};
603

604
template <>
605
struct VariantGetInternalPtr<Vector3> {
606
	static Vector3 *get_ptr(Variant *v) { return VariantInternal::get_vector3(v); }
607
	static const Vector3 *get_ptr(const Variant *v) { return VariantInternal::get_vector3(v); }
608
};
609

610
template <>
611
struct VariantGetInternalPtr<Vector3i> {
612
	static Vector3i *get_ptr(Variant *v) { return VariantInternal::get_vector3i(v); }
613
	static const Vector3i *get_ptr(const Variant *v) { return VariantInternal::get_vector3i(v); }
614
};
615

616
template <>
617
struct VariantGetInternalPtr<Vector4> {
618
	static Vector4 *get_ptr(Variant *v) { return VariantInternal::get_vector4(v); }
619
	static const Vector4 *get_ptr(const Variant *v) { return VariantInternal::get_vector4(v); }
620
};
621

622
template <>
623
struct VariantGetInternalPtr<Vector4i> {
624
	static Vector4i *get_ptr(Variant *v) { return VariantInternal::get_vector4i(v); }
625
	static const Vector4i *get_ptr(const Variant *v) { return VariantInternal::get_vector4i(v); }
626
};
627
template <>
628
struct VariantGetInternalPtr<Transform2D> {
629
	static Transform2D *get_ptr(Variant *v) { return VariantInternal::get_transform2d(v); }
630
	static const Transform2D *get_ptr(const Variant *v) { return VariantInternal::get_transform2d(v); }
631
};
632

633
template <>
634
struct VariantGetInternalPtr<Transform3D> {
635
	static Transform3D *get_ptr(Variant *v) { return VariantInternal::get_transform(v); }
636
	static const Transform3D *get_ptr(const Variant *v) { return VariantInternal::get_transform(v); }
637
};
638

639
template <>
640
struct VariantGetInternalPtr<Projection> {
641
	static Projection *get_ptr(Variant *v) { return VariantInternal::get_projection(v); }
642
	static const Projection *get_ptr(const Variant *v) { return VariantInternal::get_projection(v); }
643
};
644

645
template <>
646
struct VariantGetInternalPtr<Plane> {
647
	static Plane *get_ptr(Variant *v) { return VariantInternal::get_plane(v); }
648
	static const Plane *get_ptr(const Variant *v) { return VariantInternal::get_plane(v); }
649
};
650

651
template <>
652
struct VariantGetInternalPtr<Quaternion> {
653
	static Quaternion *get_ptr(Variant *v) { return VariantInternal::get_quaternion(v); }
654
	static const Quaternion *get_ptr(const Variant *v) { return VariantInternal::get_quaternion(v); }
655
};
656

657
template <>
658
struct VariantGetInternalPtr<::AABB> {
659
	static ::AABB *get_ptr(Variant *v) { return VariantInternal::get_aabb(v); }
660
	static const ::AABB *get_ptr(const Variant *v) { return VariantInternal::get_aabb(v); }
661
};
662

663
template <>
664
struct VariantGetInternalPtr<Basis> {
665
	static Basis *get_ptr(Variant *v) { return VariantInternal::get_basis(v); }
666
	static const Basis *get_ptr(const Variant *v) { return VariantInternal::get_basis(v); }
667
};
668

669
//
670

671
template <>
672
struct VariantGetInternalPtr<Color> {
673
	static Color *get_ptr(Variant *v) { return VariantInternal::get_color(v); }
674
	static const Color *get_ptr(const Variant *v) { return VariantInternal::get_color(v); }
675
};
676

677
template <>
678
struct VariantGetInternalPtr<StringName> {
679
	static StringName *get_ptr(Variant *v) { return VariantInternal::get_string_name(v); }
680
	static const StringName *get_ptr(const Variant *v) { return VariantInternal::get_string_name(v); }
681
};
682

683
template <>
684
struct VariantGetInternalPtr<NodePath> {
685
	static NodePath *get_ptr(Variant *v) { return VariantInternal::get_node_path(v); }
686
	static const NodePath *get_ptr(const Variant *v) { return VariantInternal::get_node_path(v); }
687
};
688

689
template <>
690
struct VariantGetInternalPtr<::RID> {
691
	static ::RID *get_ptr(Variant *v) { return VariantInternal::get_rid(v); }
692
	static const ::RID *get_ptr(const Variant *v) { return VariantInternal::get_rid(v); }
693
};
694

695
template <>
696
struct VariantGetInternalPtr<Callable> {
697
	static Callable *get_ptr(Variant *v) { return VariantInternal::get_callable(v); }
698
	static const Callable *get_ptr(const Variant *v) { return VariantInternal::get_callable(v); }
699
};
700

701
template <>
702
struct VariantGetInternalPtr<Signal> {
703
	static Signal *get_ptr(Variant *v) { return VariantInternal::get_signal(v); }
704
	static const Signal *get_ptr(const Variant *v) { return VariantInternal::get_signal(v); }
705
};
706

707
template <>
708
struct VariantGetInternalPtr<Dictionary> {
709
	static Dictionary *get_ptr(Variant *v) { return VariantInternal::get_dictionary(v); }
710
	static const Dictionary *get_ptr(const Variant *v) { return VariantInternal::get_dictionary(v); }
711
};
712

713
template <>
714
struct VariantGetInternalPtr<Array> {
715
	static Array *get_ptr(Variant *v) { return VariantInternal::get_array(v); }
716
	static const Array *get_ptr(const Variant *v) { return VariantInternal::get_array(v); }
717
};
718

719
template <>
720
struct VariantGetInternalPtr<PackedByteArray> {
721
	static PackedByteArray *get_ptr(Variant *v) { return VariantInternal::get_byte_array(v); }
722
	static const PackedByteArray *get_ptr(const Variant *v) { return VariantInternal::get_byte_array(v); }
723
};
724

725
template <>
726
struct VariantGetInternalPtr<PackedInt32Array> {
727
	static PackedInt32Array *get_ptr(Variant *v) { return VariantInternal::get_int32_array(v); }
728
	static const PackedInt32Array *get_ptr(const Variant *v) { return VariantInternal::get_int32_array(v); }
729
};
730

731
template <>
732
struct VariantGetInternalPtr<PackedInt64Array> {
733
	static PackedInt64Array *get_ptr(Variant *v) { return VariantInternal::get_int64_array(v); }
734
	static const PackedInt64Array *get_ptr(const Variant *v) { return VariantInternal::get_int64_array(v); }
735
};
736

737
template <>
738
struct VariantGetInternalPtr<PackedFloat32Array> {
739
	static PackedFloat32Array *get_ptr(Variant *v) { return VariantInternal::get_float32_array(v); }
740
	static const PackedFloat32Array *get_ptr(const Variant *v) { return VariantInternal::get_float32_array(v); }
741
};
742

743
template <>
744
struct VariantGetInternalPtr<PackedFloat64Array> {
745
	static PackedFloat64Array *get_ptr(Variant *v) { return VariantInternal::get_float64_array(v); }
746
	static const PackedFloat64Array *get_ptr(const Variant *v) { return VariantInternal::get_float64_array(v); }
747
};
748

749
template <>
750
struct VariantGetInternalPtr<PackedStringArray> {
751
	static PackedStringArray *get_ptr(Variant *v) { return VariantInternal::get_string_array(v); }
752
	static const PackedStringArray *get_ptr(const Variant *v) { return VariantInternal::get_string_array(v); }
753
};
754

755
template <>
756
struct VariantGetInternalPtr<PackedVector2Array> {
757
	static PackedVector2Array *get_ptr(Variant *v) { return VariantInternal::get_vector2_array(v); }
758
	static const PackedVector2Array *get_ptr(const Variant *v) { return VariantInternal::get_vector2_array(v); }
759
};
760

761
template <>
762
struct VariantGetInternalPtr<PackedVector3Array> {
763
	static PackedVector3Array *get_ptr(Variant *v) { return VariantInternal::get_vector3_array(v); }
764
	static const PackedVector3Array *get_ptr(const Variant *v) { return VariantInternal::get_vector3_array(v); }
765
};
766

767
template <>
768
struct VariantGetInternalPtr<PackedColorArray> {
769
	static PackedColorArray *get_ptr(Variant *v) { return VariantInternal::get_color_array(v); }
770
	static const PackedColorArray *get_ptr(const Variant *v) { return VariantInternal::get_color_array(v); }
771
};
772

773
template <>
774
struct VariantGetInternalPtr<PackedVector4Array> {
775
	static PackedVector4Array *get_ptr(Variant *v) { return VariantInternal::get_vector4_array(v); }
776
	static const PackedVector4Array *get_ptr(const Variant *v) { return VariantInternal::get_vector4_array(v); }
777
};
778

779
template <typename T, typename = void>
780
struct VariantInternalAccessor;
781

782
template <typename T>
783
struct VariantInternalAccessor<T, std::enable_if_t<!std::is_same_v<T, GetSimpleTypeT<T>>>> : VariantInternalAccessor<GetSimpleTypeT<T>> {};
784

785
template <>
786
struct VariantInternalAccessor<bool> {
787
	static _FORCE_INLINE_ bool get(const Variant *v) { return *VariantInternal::get_bool(v); }
788
	static _FORCE_INLINE_ void set(Variant *v, bool p_value) { *VariantInternal::get_bool(v) = p_value; }
789
};
790

791
template <typename T>
792
struct VariantInternalAccessor<T, std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>> {
793
	static _FORCE_INLINE_ T get(const Variant *v) { return static_cast<T>(*VariantInternal::get_int(v)); }
794
	static _FORCE_INLINE_ void set(Variant *v, T p_value) { *VariantInternal::get_int(v) = static_cast<int64_t>(p_value); }
795
};
796

797
template <typename T>
798
struct VariantInternalAccessor<BitField<T>, std::enable_if_t<std::is_enum_v<T>>> {
799
	static _FORCE_INLINE_ BitField<T> get(const Variant *v) { return BitField<T>(static_cast<T>(*VariantInternal::get_int(v))); }
800
	static _FORCE_INLINE_ void set(Variant *v, BitField<T> p_value) { *VariantInternal::get_int(v) = static_cast<int64_t>(p_value); }
801
};
802

803
template <>
804
struct VariantInternalAccessor<ObjectID> {
805
	static _FORCE_INLINE_ ObjectID get(const Variant *v) { return ObjectID(*VariantInternal::get_int(v)); }
806
	static _FORCE_INLINE_ void set(Variant *v, ObjectID p_value) { *VariantInternal::get_int(v) = p_value; }
807
};
808

809
template <typename T>
810
struct VariantInternalAccessor<T *> {
811
	static _FORCE_INLINE_ T *get(const Variant *v) { return const_cast<T *>(static_cast<const T *>(*VariantInternal::get_object(v))); }
812
	static _FORCE_INLINE_ void set(Variant *v, const T *p_value) { VariantInternal::object_assign(v, p_value); }
813
};
814

815
template <typename T>
816
struct VariantInternalAccessor<const T *> {
817
	static _FORCE_INLINE_ const T *get(const Variant *v) { return static_cast<const T *>(*VariantInternal::get_object(v)); }
818
	static _FORCE_INLINE_ void set(Variant *v, const T *p_value) { VariantInternal::object_assign(v, p_value); }
819
};
820

821
template <>
822
struct VariantInternalAccessor<IPAddress> {
823
	static _FORCE_INLINE_ IPAddress get(const Variant *v) { return IPAddress(*VariantInternal::get_string(v)); }
824
	static _FORCE_INLINE_ void set(Variant *v, IPAddress p_value) { *VariantInternal::get_string(v) = String(p_value); }
825
};
826

827
template <>
828
struct VariantInternalAccessor<float> {
829
	static _FORCE_INLINE_ float get(const Variant *v) { return *VariantInternal::get_float(v); }
830
	static _FORCE_INLINE_ void set(Variant *v, float p_value) { *VariantInternal::get_float(v) = p_value; }
831
};
832

833
template <>
834
struct VariantInternalAccessor<double> {
835
	static _FORCE_INLINE_ double get(const Variant *v) { return *VariantInternal::get_float(v); }
836
	static _FORCE_INLINE_ void set(Variant *v, double p_value) { *VariantInternal::get_float(v) = p_value; }
837
};
838

839
template <>
840
struct VariantInternalAccessor<String> {
841
	static _FORCE_INLINE_ const String &get(const Variant *v) { return *VariantInternal::get_string(v); }
842
	static _FORCE_INLINE_ void set(Variant *v, const String &p_value) { *VariantInternal::get_string(v) = p_value; }
843
};
844

845
template <>
846
struct VariantInternalAccessor<Vector2> {
847
	static _FORCE_INLINE_ const Vector2 &get(const Variant *v) { return *VariantInternal::get_vector2(v); }
848
	static _FORCE_INLINE_ void set(Variant *v, const Vector2 &p_value) { *VariantInternal::get_vector2(v) = p_value; }
849
};
850

851
template <>
852
struct VariantInternalAccessor<Vector2i> {
853
	static _FORCE_INLINE_ const Vector2i &get(const Variant *v) { return *VariantInternal::get_vector2i(v); }
854
	static _FORCE_INLINE_ void set(Variant *v, const Vector2i &p_value) { *VariantInternal::get_vector2i(v) = p_value; }
855
};
856

857
template <>
858
struct VariantInternalAccessor<Rect2> {
859
	static _FORCE_INLINE_ const Rect2 &get(const Variant *v) { return *VariantInternal::get_rect2(v); }
860
	static _FORCE_INLINE_ void set(Variant *v, const Rect2 &p_value) { *VariantInternal::get_rect2(v) = p_value; }
861
};
862

863
template <>
864
struct VariantInternalAccessor<Rect2i> {
865
	static _FORCE_INLINE_ const Rect2i &get(const Variant *v) { return *VariantInternal::get_rect2i(v); }
866
	static _FORCE_INLINE_ void set(Variant *v, const Rect2i &p_value) { *VariantInternal::get_rect2i(v) = p_value; }
867
};
868

869
template <>
870
struct VariantInternalAccessor<Vector3> {
871
	static _FORCE_INLINE_ const Vector3 &get(const Variant *v) { return *VariantInternal::get_vector3(v); }
872
	static _FORCE_INLINE_ void set(Variant *v, const Vector3 &p_value) { *VariantInternal::get_vector3(v) = p_value; }
873
};
874

875
template <>
876
struct VariantInternalAccessor<Vector3i> {
877
	static _FORCE_INLINE_ const Vector3i &get(const Variant *v) { return *VariantInternal::get_vector3i(v); }
878
	static _FORCE_INLINE_ void set(Variant *v, const Vector3i &p_value) { *VariantInternal::get_vector3i(v) = p_value; }
879
};
880

881
template <>
882
struct VariantInternalAccessor<Vector4> {
883
	static _FORCE_INLINE_ const Vector4 &get(const Variant *v) { return *VariantInternal::get_vector4(v); }
884
	static _FORCE_INLINE_ void set(Variant *v, const Vector4 &p_value) { *VariantInternal::get_vector4(v) = p_value; }
885
};
886

887
template <>
888
struct VariantInternalAccessor<Vector4i> {
889
	static _FORCE_INLINE_ const Vector4i &get(const Variant *v) { return *VariantInternal::get_vector4i(v); }
890
	static _FORCE_INLINE_ void set(Variant *v, const Vector4i &p_value) { *VariantInternal::get_vector4i(v) = p_value; }
891
};
892
template <>
893
struct VariantInternalAccessor<Transform2D> {
894
	static _FORCE_INLINE_ const Transform2D &get(const Variant *v) { return *VariantInternal::get_transform2d(v); }
895
	static _FORCE_INLINE_ void set(Variant *v, const Transform2D &p_value) { *VariantInternal::get_transform2d(v) = p_value; }
896
};
897

898
template <>
899
struct VariantInternalAccessor<Transform3D> {
900
	static _FORCE_INLINE_ const Transform3D &get(const Variant *v) { return *VariantInternal::get_transform(v); }
901
	static _FORCE_INLINE_ void set(Variant *v, const Transform3D &p_value) { *VariantInternal::get_transform(v) = p_value; }
902
};
903

904
template <>
905
struct VariantInternalAccessor<Projection> {
906
	static _FORCE_INLINE_ const Projection &get(const Variant *v) { return *VariantInternal::get_projection(v); }
907
	static _FORCE_INLINE_ void set(Variant *v, const Projection &p_value) { *VariantInternal::get_projection(v) = p_value; }
908
};
909

910
template <>
911
struct VariantInternalAccessor<Plane> {
912
	static _FORCE_INLINE_ const Plane &get(const Variant *v) { return *VariantInternal::get_plane(v); }
913
	static _FORCE_INLINE_ void set(Variant *v, const Plane &p_value) { *VariantInternal::get_plane(v) = p_value; }
914
};
915

916
template <>
917
struct VariantInternalAccessor<Quaternion> {
918
	static _FORCE_INLINE_ const Quaternion &get(const Variant *v) { return *VariantInternal::get_quaternion(v); }
919
	static _FORCE_INLINE_ void set(Variant *v, const Quaternion &p_value) { *VariantInternal::get_quaternion(v) = p_value; }
920
};
921

922
template <>
923
struct VariantInternalAccessor<AABB> {
924
	static _FORCE_INLINE_ const AABB &get(const Variant *v) { return *VariantInternal::get_aabb(v); }
925
	static _FORCE_INLINE_ void set(Variant *v, const AABB &p_value) { *VariantInternal::get_aabb(v) = p_value; }
926
};
927

928
template <>
929
struct VariantInternalAccessor<Basis> {
930
	static _FORCE_INLINE_ const Basis &get(const Variant *v) { return *VariantInternal::get_basis(v); }
931
	static _FORCE_INLINE_ void set(Variant *v, const Basis &p_value) { *VariantInternal::get_basis(v) = p_value; }
932
};
933

934
template <>
935
struct VariantInternalAccessor<Color> {
936
	static _FORCE_INLINE_ const Color &get(const Variant *v) { return *VariantInternal::get_color(v); }
937
	static _FORCE_INLINE_ void set(Variant *v, const Color &p_value) { *VariantInternal::get_color(v) = p_value; }
938
};
939

940
template <>
941
struct VariantInternalAccessor<StringName> {
942
	static _FORCE_INLINE_ const StringName &get(const Variant *v) { return *VariantInternal::get_string_name(v); }
943
	static _FORCE_INLINE_ void set(Variant *v, const StringName &p_value) { *VariantInternal::get_string_name(v) = p_value; }
944
};
945

946
template <>
947
struct VariantInternalAccessor<NodePath> {
948
	static _FORCE_INLINE_ const NodePath &get(const Variant *v) { return *VariantInternal::get_node_path(v); }
949
	static _FORCE_INLINE_ void set(Variant *v, const NodePath &p_value) { *VariantInternal::get_node_path(v) = p_value; }
950
};
951

952
template <>
953
struct VariantInternalAccessor<::RID> {
954
	static _FORCE_INLINE_ const ::RID &get(const Variant *v) { return *VariantInternal::get_rid(v); }
955
	static _FORCE_INLINE_ void set(Variant *v, const ::RID &p_value) { *VariantInternal::get_rid(v) = p_value; }
956
};
957

958
template <>
959
struct VariantInternalAccessor<Callable> {
960
	static _FORCE_INLINE_ const Callable &get(const Variant *v) { return *VariantInternal::get_callable(v); }
961
	static _FORCE_INLINE_ void set(Variant *v, const Callable &p_value) { *VariantInternal::get_callable(v) = p_value; }
962
};
963

964
template <>
965
struct VariantInternalAccessor<Signal> {
966
	static _FORCE_INLINE_ const Signal &get(const Variant *v) { return *VariantInternal::get_signal(v); }
967
	static _FORCE_INLINE_ void set(Variant *v, const Signal &p_value) { *VariantInternal::get_signal(v) = p_value; }
968
};
969

970
template <>
971
struct VariantInternalAccessor<Dictionary> {
972
	static _FORCE_INLINE_ const Dictionary &get(const Variant *v) { return *VariantInternal::get_dictionary(v); }
973
	static _FORCE_INLINE_ void set(Variant *v, const Dictionary &p_value) { *VariantInternal::get_dictionary(v) = p_value; }
974
};
975

976
template <>
977
struct VariantInternalAccessor<Array> {
978
	static _FORCE_INLINE_ const Array &get(const Variant *v) { return *VariantInternal::get_array(v); }
979
	static _FORCE_INLINE_ void set(Variant *v, const Array &p_value) { *VariantInternal::get_array(v) = p_value; }
980
};
981

982
template <>
983
struct VariantInternalAccessor<PackedByteArray> {
984
	static _FORCE_INLINE_ const PackedByteArray &get(const Variant *v) { return *VariantInternal::get_byte_array(v); }
985
	static _FORCE_INLINE_ void set(Variant *v, const PackedByteArray &p_value) { *VariantInternal::get_byte_array(v) = p_value; }
986
};
987

988
template <>
989
struct VariantInternalAccessor<PackedInt32Array> {
990
	static _FORCE_INLINE_ const PackedInt32Array &get(const Variant *v) { return *VariantInternal::get_int32_array(v); }
991
	static _FORCE_INLINE_ void set(Variant *v, const PackedInt32Array &p_value) { *VariantInternal::get_int32_array(v) = p_value; }
992
};
993

994
template <>
995
struct VariantInternalAccessor<PackedInt64Array> {
996
	static _FORCE_INLINE_ const PackedInt64Array &get(const Variant *v) { return *VariantInternal::get_int64_array(v); }
997
	static _FORCE_INLINE_ void set(Variant *v, const PackedInt64Array &p_value) { *VariantInternal::get_int64_array(v) = p_value; }
998
};
999

1000
template <>
1001
struct VariantInternalAccessor<PackedFloat32Array> {
1002
	static _FORCE_INLINE_ const PackedFloat32Array &get(const Variant *v) { return *VariantInternal::get_float32_array(v); }
1003
	static _FORCE_INLINE_ void set(Variant *v, const PackedFloat32Array &p_value) { *VariantInternal::get_float32_array(v) = p_value; }
1004
};
1005

1006
template <>
1007
struct VariantInternalAccessor<PackedFloat64Array> {
1008
	static _FORCE_INLINE_ const PackedFloat64Array &get(const Variant *v) { return *VariantInternal::get_float64_array(v); }
1009
	static _FORCE_INLINE_ void set(Variant *v, const PackedFloat64Array &p_value) { *VariantInternal::get_float64_array(v) = p_value; }
1010
};
1011

1012
template <>
1013
struct VariantInternalAccessor<PackedStringArray> {
1014
	static _FORCE_INLINE_ const PackedStringArray &get(const Variant *v) { return *VariantInternal::get_string_array(v); }
1015
	static _FORCE_INLINE_ void set(Variant *v, const PackedStringArray &p_value) { *VariantInternal::get_string_array(v) = p_value; }
1016
};
1017

1018
template <>
1019
struct VariantInternalAccessor<PackedVector2Array> {
1020
	static _FORCE_INLINE_ const PackedVector2Array &get(const Variant *v) { return *VariantInternal::get_vector2_array(v); }
1021
	static _FORCE_INLINE_ void set(Variant *v, const PackedVector2Array &p_value) { *VariantInternal::get_vector2_array(v) = p_value; }
1022
};
1023

1024
template <>
1025
struct VariantInternalAccessor<PackedVector3Array> {
1026
	static _FORCE_INLINE_ const PackedVector3Array &get(const Variant *v) { return *VariantInternal::get_vector3_array(v); }
1027
	static _FORCE_INLINE_ void set(Variant *v, const PackedVector3Array &p_value) { *VariantInternal::get_vector3_array(v) = p_value; }
1028
};
1029

1030
template <>
1031
struct VariantInternalAccessor<PackedColorArray> {
1032
	static _FORCE_INLINE_ const PackedColorArray &get(const Variant *v) { return *VariantInternal::get_color_array(v); }
1033
	static _FORCE_INLINE_ void set(Variant *v, const PackedColorArray &p_value) { *VariantInternal::get_color_array(v) = p_value; }
1034
};
1035

1036
template <>
1037
struct VariantInternalAccessor<PackedVector4Array> {
1038
	static _FORCE_INLINE_ const PackedVector4Array &get(const Variant *v) { return *VariantInternal::get_vector4_array(v); }
1039
	static _FORCE_INLINE_ void set(Variant *v, const PackedVector4Array &p_value) { *VariantInternal::get_vector4_array(v) = p_value; }
1040
};
1041

1042
template <>
1043
struct VariantInternalAccessor<Object *> {
1044
	static _FORCE_INLINE_ Object *get(const Variant *v) { return const_cast<Object *>(*VariantInternal::get_object(v)); }
1045
	static _FORCE_INLINE_ void set(Variant *v, const Object *p_value) { VariantInternal::object_assign(v, p_value); }
1046
};
1047

1048
template <>
1049
struct VariantInternalAccessor<Variant> {
1050
	static _FORCE_INLINE_ Variant &get(Variant *v) { return *v; }
1051
	static _FORCE_INLINE_ const Variant &get(const Variant *v) { return *v; }
1052
	static _FORCE_INLINE_ void set(Variant *v, const Variant &p_value) { *v = p_value; }
1053
};
1054

1055
template <>
1056
struct VariantInternalAccessor<Vector<Variant>> {
1057
	static _FORCE_INLINE_ Vector<Variant> get(const Variant *v) {
1058
		Vector<Variant> ret;
1059
		int s = VariantInternal::get_array(v)->size();
1060
		ret.resize(s);
1061
		for (int i = 0; i < s; i++) {
1062
			ret.write[i] = VariantInternal::get_array(v)->get(i);
1063
		}
1064

1065
		return ret;
1066
	}
1067
	static _FORCE_INLINE_ void set(Variant *v, const Vector<Variant> &p_value) {
1068
		int s = p_value.size();
1069
		VariantInternal::get_array(v)->resize(s);
1070
		for (int i = 0; i < s; i++) {
1071
			VariantInternal::get_array(v)->set(i, p_value[i]);
1072
		}
1073
	}
1074
};
1075

1076
template <typename T>
1077
struct VariantInitializer {
1078
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_generic<T>(v); }
1079
};
1080

1081
template <>
1082
struct VariantInitializer<String> {
1083
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_string(v); }
1084
};
1085

1086
template <>
1087
struct VariantInitializer<Transform2D> {
1088
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_transform2d(v); }
1089
};
1090

1091
template <>
1092
struct VariantInitializer<AABB> {
1093
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_aabb(v); }
1094
};
1095

1096
template <>
1097
struct VariantInitializer<Basis> {
1098
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_basis(v); }
1099
};
1100

1101
template <>
1102
struct VariantInitializer<Transform3D> {
1103
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_transform3d(v); }
1104
};
1105

1106
template <>
1107
struct VariantInitializer<Projection> {
1108
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_projection(v); }
1109
};
1110

1111
template <>
1112
struct VariantInitializer<StringName> {
1113
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_string_name(v); }
1114
};
1115

1116
template <>
1117
struct VariantInitializer<NodePath> {
1118
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_node_path(v); }
1119
};
1120

1121
template <>
1122
struct VariantInitializer<Callable> {
1123
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_callable(v); }
1124
};
1125

1126
template <>
1127
struct VariantInitializer<Signal> {
1128
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_signal(v); }
1129
};
1130

1131
template <>
1132
struct VariantInitializer<Dictionary> {
1133
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_dictionary(v); }
1134
};
1135

1136
template <>
1137
struct VariantInitializer<Array> {
1138
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_array(v); }
1139
};
1140

1141
template <>
1142
struct VariantInitializer<PackedByteArray> {
1143
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_byte_array(v); }
1144
};
1145

1146
template <>
1147
struct VariantInitializer<PackedInt32Array> {
1148
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_int32_array(v); }
1149
};
1150

1151
template <>
1152
struct VariantInitializer<PackedInt64Array> {
1153
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_int64_array(v); }
1154
};
1155

1156
template <>
1157
struct VariantInitializer<PackedFloat32Array> {
1158
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_float32_array(v); }
1159
};
1160

1161
template <>
1162
struct VariantInitializer<PackedFloat64Array> {
1163
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_float64_array(v); }
1164
};
1165

1166
template <>
1167
struct VariantInitializer<PackedStringArray> {
1168
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_string_array(v); }
1169
};
1170

1171
template <>
1172
struct VariantInitializer<PackedVector2Array> {
1173
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_vector2_array(v); }
1174
};
1175

1176
template <>
1177
struct VariantInitializer<PackedVector3Array> {
1178
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_vector3_array(v); }
1179
};
1180

1181
template <>
1182
struct VariantInitializer<PackedColorArray> {
1183
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_color_array(v); }
1184
};
1185

1186
template <>
1187
struct VariantInitializer<PackedVector4Array> {
1188
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_vector4_array(v); }
1189
};
1190

1191
template <>
1192
struct VariantInitializer<Object *> {
1193
	static _FORCE_INLINE_ void init(Variant *v) { VariantInternal::init_object(v); }
1194
};
1195

1196
template <typename T, typename = void>
1197
struct VariantDefaultInitializer;
1198

1199
template <typename T>
1200
struct VariantDefaultInitializer<T, std::enable_if_t<!std::is_same_v<T, GetSimpleTypeT<T>>>> : VariantDefaultInitializer<GetSimpleTypeT<T>> {};
1201

1202
template <>
1203
struct VariantDefaultInitializer<bool> {
1204
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_bool(v) = false; }
1205
};
1206

1207
template <typename T>
1208
struct VariantDefaultInitializer<T, std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>> {
1209
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_int(v) = 0; }
1210
};
1211

1212
template <typename T>
1213
struct VariantDefaultInitializer<BitField<T>, std::enable_if_t<std::is_enum_v<T>>> {
1214
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_int(v) = 0; }
1215
};
1216

1217
template <>
1218
struct VariantDefaultInitializer<double> {
1219
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_float(v) = 0.0; }
1220
};
1221

1222
template <>
1223
struct VariantDefaultInitializer<float> {
1224
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_float(v) = 0.0; }
1225
};
1226

1227
template <>
1228
struct VariantDefaultInitializer<String> {
1229
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_string(v) = String(); }
1230
};
1231

1232
template <>
1233
struct VariantDefaultInitializer<Vector2> {
1234
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector2(v) = Vector2(); }
1235
};
1236

1237
template <>
1238
struct VariantDefaultInitializer<Vector2i> {
1239
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector2i(v) = Vector2i(); }
1240
};
1241

1242
template <>
1243
struct VariantDefaultInitializer<Rect2> {
1244
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_rect2(v) = Rect2(); }
1245
};
1246

1247
template <>
1248
struct VariantDefaultInitializer<Rect2i> {
1249
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_rect2i(v) = Rect2i(); }
1250
};
1251

1252
template <>
1253
struct VariantDefaultInitializer<Vector3> {
1254
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector3(v) = Vector3(); }
1255
};
1256

1257
template <>
1258
struct VariantDefaultInitializer<Vector3i> {
1259
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector3i(v) = Vector3i(); }
1260
};
1261

1262
template <>
1263
struct VariantDefaultInitializer<Vector4> {
1264
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector4(v) = Vector4(); }
1265
};
1266

1267
template <>
1268
struct VariantDefaultInitializer<Vector4i> {
1269
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector4i(v) = Vector4i(); }
1270
};
1271

1272
template <>
1273
struct VariantDefaultInitializer<Transform2D> {
1274
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_transform2d(v) = Transform2D(); }
1275
};
1276

1277
template <>
1278
struct VariantDefaultInitializer<Plane> {
1279
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_plane(v) = Plane(); }
1280
};
1281

1282
template <>
1283
struct VariantDefaultInitializer<Quaternion> {
1284
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_quaternion(v) = Quaternion(); }
1285
};
1286

1287
template <>
1288
struct VariantDefaultInitializer<AABB> {
1289
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_aabb(v) = AABB(); }
1290
};
1291

1292
template <>
1293
struct VariantDefaultInitializer<Basis> {
1294
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_basis(v) = Basis(); }
1295
};
1296

1297
template <>
1298
struct VariantDefaultInitializer<Transform3D> {
1299
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_transform(v) = Transform3D(); }
1300
};
1301

1302
template <>
1303
struct VariantDefaultInitializer<Projection> {
1304
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_projection(v) = Projection(); }
1305
};
1306

1307
template <>
1308
struct VariantDefaultInitializer<Color> {
1309
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_color(v) = Color(); }
1310
};
1311

1312
template <>
1313
struct VariantDefaultInitializer<StringName> {
1314
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_string_name(v) = StringName(); }
1315
};
1316

1317
template <>
1318
struct VariantDefaultInitializer<NodePath> {
1319
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_node_path(v) = NodePath(); }
1320
};
1321

1322
template <>
1323
struct VariantDefaultInitializer<::RID> {
1324
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_rid(v) = RID(); }
1325
};
1326

1327
template <>
1328
struct VariantDefaultInitializer<Callable> {
1329
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_callable(v) = Callable(); }
1330
};
1331

1332
template <>
1333
struct VariantDefaultInitializer<Signal> {
1334
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_signal(v) = Signal(); }
1335
};
1336

1337
template <>
1338
struct VariantDefaultInitializer<Dictionary> {
1339
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_dictionary(v) = Dictionary(); }
1340
};
1341

1342
template <>
1343
struct VariantDefaultInitializer<Array> {
1344
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_array(v) = Array(); }
1345
};
1346

1347
template <>
1348
struct VariantDefaultInitializer<PackedByteArray> {
1349
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_byte_array(v) = PackedByteArray(); }
1350
};
1351

1352
template <>
1353
struct VariantDefaultInitializer<PackedInt32Array> {
1354
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_int32_array(v) = PackedInt32Array(); }
1355
};
1356

1357
template <>
1358
struct VariantDefaultInitializer<PackedInt64Array> {
1359
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_int64_array(v) = PackedInt64Array(); }
1360
};
1361

1362
template <>
1363
struct VariantDefaultInitializer<PackedFloat32Array> {
1364
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_float32_array(v) = PackedFloat32Array(); }
1365
};
1366

1367
template <>
1368
struct VariantDefaultInitializer<PackedFloat64Array> {
1369
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_float64_array(v) = PackedFloat64Array(); }
1370
};
1371

1372
template <>
1373
struct VariantDefaultInitializer<PackedStringArray> {
1374
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_string_array(v) = PackedStringArray(); }
1375
};
1376

1377
template <>
1378
struct VariantDefaultInitializer<PackedVector2Array> {
1379
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector2_array(v) = PackedVector2Array(); }
1380
};
1381

1382
template <>
1383
struct VariantDefaultInitializer<PackedVector3Array> {
1384
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector3_array(v) = PackedVector3Array(); }
1385
};
1386

1387
template <>
1388
struct VariantDefaultInitializer<PackedColorArray> {
1389
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_color_array(v) = PackedColorArray(); }
1390
};
1391

1392
template <>
1393
struct VariantDefaultInitializer<PackedVector4Array> {
1394
	static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_vector4_array(v) = PackedVector4Array(); }
1395
};
1396

1397
template <typename T>
1398
struct VariantTypeChanger {
1399
	static _FORCE_INLINE_ void change(Variant *v) {
1400
		if (v->get_type() != GetTypeInfo<T>::VARIANT_TYPE || GetTypeInfo<T>::VARIANT_TYPE >= Variant::PACKED_BYTE_ARRAY) { //second condition removed by optimizer
1401
			VariantInternal::clear(v);
1402
			VariantInitializer<T>::init(v);
1403
		}
1404
	}
1405
	static _FORCE_INLINE_ void change_and_reset(Variant *v) {
1406
		if (v->get_type() != GetTypeInfo<T>::VARIANT_TYPE || GetTypeInfo<T>::VARIANT_TYPE >= Variant::PACKED_BYTE_ARRAY) { //second condition removed by optimizer
1407
			VariantInternal::clear(v);
1408
			VariantInitializer<T>::init(v);
1409
		}
1410

1411
		VariantDefaultInitializer<T>::init(v);
1412
	}
1413
};
1414

1415
template <typename T>
1416
struct VariantTypeAdjust {
1417
	_FORCE_INLINE_ static void adjust(Variant *r_ret) {
1418
		VariantTypeChanger<GetSimpleTypeT<T>>::change(r_ret);
1419
	}
1420
};
1421

1422
template <>
1423
struct VariantTypeAdjust<Variant> {
1424
	_FORCE_INLINE_ static void adjust(Variant *r_ret) {
1425
		// Do nothing for variant.
1426
	}
1427
};
1428

1429
template <>
1430
struct VariantTypeAdjust<Object *> {
1431
	_FORCE_INLINE_ static void adjust(Variant *r_ret) {
1432
		VariantInternal::clear(r_ret);
1433
		*r_ret = (Object *)nullptr;
1434
	}
1435
};
1436

1437
// GDExtension helpers.
1438

1439
template <typename T>
1440
struct VariantTypeConstructor {
1441
	_FORCE_INLINE_ static void variant_from_type(void *r_variant, void *p_value) {
1442
		// r_variant is provided by caller as uninitialized memory
1443
		memnew_placement(r_variant, Variant(*((T *)p_value)));
1444
	}
1445

1446
	_FORCE_INLINE_ static void type_from_variant(void *r_value, void *p_variant) {
1447
		// r_value is provided by caller as uninitialized memory
1448
		memnew_placement(r_value, T(*reinterpret_cast<Variant *>(p_variant)));
1449
	}
1450
};
1451

1452
Product

Resources

Company
