variant_internal.hpp 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506
  1. /**************************************************************************/
  2. /* variant_internal.hpp */
  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. #pragma once
  31. #include <gdextension_interface.h>
  32. #include <godot_cpp/variant/variant.hpp>
  33. namespace godot {
  34. // For use when you want to access the internal pointer of a Variant directly.
  35. // Use with caution. You need to be sure that the type is correct.
  36. namespace internal {
  37. template <typename T>
  38. struct VariantInternalType {};
  39. template <>
  40. struct VariantInternalType<bool> {
  41. static constexpr Variant::Type type = Variant::BOOL;
  42. };
  43. template <>
  44. struct VariantInternalType<int64_t> {
  45. static constexpr Variant::Type type = Variant::INT;
  46. };
  47. template <>
  48. struct VariantInternalType<double> {
  49. static constexpr Variant::Type type = Variant::FLOAT;
  50. };
  51. template <>
  52. struct VariantInternalType<String> {
  53. static constexpr Variant::Type type = Variant::STRING;
  54. };
  55. template <>
  56. struct VariantInternalType<Vector2> {
  57. static constexpr Variant::Type type = Variant::VECTOR2;
  58. };
  59. template <>
  60. struct VariantInternalType<Vector2i> {
  61. static constexpr Variant::Type type = Variant::VECTOR2I;
  62. };
  63. template <>
  64. struct VariantInternalType<Rect2> {
  65. static constexpr Variant::Type type = Variant::RECT2;
  66. };
  67. template <>
  68. struct VariantInternalType<Rect2i> {
  69. static constexpr Variant::Type type = Variant::RECT2I;
  70. };
  71. template <>
  72. struct VariantInternalType<Vector3> {
  73. static constexpr Variant::Type type = Variant::VECTOR3;
  74. };
  75. template <>
  76. struct VariantInternalType<Vector3i> {
  77. static constexpr Variant::Type type = Variant::VECTOR3I;
  78. };
  79. template <>
  80. struct VariantInternalType<Transform2D> {
  81. static constexpr Variant::Type type = Variant::TRANSFORM2D;
  82. };
  83. template <>
  84. struct VariantInternalType<Vector4> {
  85. static constexpr Variant::Type type = Variant::VECTOR4;
  86. };
  87. template <>
  88. struct VariantInternalType<Vector4i> {
  89. static constexpr Variant::Type type = Variant::VECTOR4I;
  90. };
  91. template <>
  92. struct VariantInternalType<Plane> {
  93. static constexpr Variant::Type type = Variant::PLANE;
  94. };
  95. template <>
  96. struct VariantInternalType<Quaternion> {
  97. static constexpr Variant::Type type = Variant::QUATERNION;
  98. };
  99. template <>
  100. struct VariantInternalType<AABB> {
  101. static constexpr Variant::Type type = Variant::AABB;
  102. };
  103. template <>
  104. struct VariantInternalType<Basis> {
  105. static constexpr Variant::Type type = Variant::BASIS;
  106. };
  107. template <>
  108. struct VariantInternalType<Transform3D> {
  109. static constexpr Variant::Type type = Variant::TRANSFORM3D;
  110. };
  111. template <>
  112. struct VariantInternalType<Projection> {
  113. static constexpr Variant::Type type = Variant::PROJECTION;
  114. };
  115. template <>
  116. struct VariantInternalType<Color> {
  117. static constexpr Variant::Type type = Variant::COLOR;
  118. };
  119. template <>
  120. struct VariantInternalType<StringName> {
  121. static constexpr Variant::Type type = Variant::STRING_NAME;
  122. };
  123. template <>
  124. struct VariantInternalType<NodePath> {
  125. static constexpr Variant::Type type = Variant::NODE_PATH;
  126. };
  127. template <>
  128. struct VariantInternalType<RID> {
  129. static constexpr Variant::Type type = Variant::RID;
  130. };
  131. template <>
  132. struct VariantInternalType<Object *> {
  133. static constexpr Variant::Type type = Variant::OBJECT;
  134. };
  135. template <>
  136. struct VariantInternalType<Callable> {
  137. static constexpr Variant::Type type = Variant::CALLABLE;
  138. };
  139. template <>
  140. struct VariantInternalType<Signal> {
  141. static constexpr Variant::Type type = Variant::SIGNAL;
  142. };
  143. template <>
  144. struct VariantInternalType<Dictionary> {
  145. static constexpr Variant::Type type = Variant::DICTIONARY;
  146. };
  147. template <>
  148. struct VariantInternalType<Array> {
  149. static constexpr Variant::Type type = Variant::ARRAY;
  150. };
  151. template <>
  152. struct VariantInternalType<PackedByteArray> {
  153. static constexpr Variant::Type type = Variant::PACKED_BYTE_ARRAY;
  154. };
  155. template <>
  156. struct VariantInternalType<PackedInt32Array> {
  157. static constexpr Variant::Type type = Variant::PACKED_INT32_ARRAY;
  158. };
  159. template <>
  160. struct VariantInternalType<PackedInt64Array> {
  161. static constexpr Variant::Type type = Variant::PACKED_INT64_ARRAY;
  162. };
  163. template <>
  164. struct VariantInternalType<PackedFloat32Array> {
  165. static constexpr Variant::Type type = Variant::PACKED_FLOAT32_ARRAY;
  166. };
  167. template <>
  168. struct VariantInternalType<PackedFloat64Array> {
  169. static constexpr Variant::Type type = Variant::PACKED_FLOAT64_ARRAY;
  170. };
  171. template <>
  172. struct VariantInternalType<PackedStringArray> {
  173. static constexpr Variant::Type type = Variant::PACKED_STRING_ARRAY;
  174. };
  175. template <>
  176. struct VariantInternalType<PackedVector2Array> {
  177. static constexpr Variant::Type type = Variant::PACKED_VECTOR2_ARRAY;
  178. };
  179. template <>
  180. struct VariantInternalType<PackedVector3Array> {
  181. static constexpr Variant::Type type = Variant::PACKED_VECTOR3_ARRAY;
  182. };
  183. template <>
  184. struct VariantInternalType<PackedColorArray> {
  185. static constexpr Variant::Type type = Variant::PACKED_COLOR_ARRAY;
  186. };
  187. template <>
  188. struct VariantInternalType<PackedVector4Array> {
  189. static constexpr Variant::Type type = Variant::PACKED_VECTOR4_ARRAY;
  190. };
  191. } //namespace internal
  192. class VariantInternal {
  193. friend class Variant;
  194. static GDExtensionVariantGetInternalPtrFunc get_internal_func[Variant::VARIANT_MAX];
  195. static void init_bindings();
  196. public:
  197. template <typename T>
  198. _FORCE_INLINE_ static T *get_internal_value(Variant *v) {
  199. return static_cast<T *>(get_internal_func[internal::VariantInternalType<T>::type](v));
  200. }
  201. template <typename T>
  202. _FORCE_INLINE_ static const T *get_internal_value(const Variant *v) {
  203. return static_cast<const T *>(get_internal_func[internal::VariantInternalType<T>::type](const_cast<Variant *>(v)));
  204. }
  205. // Atomic types.
  206. _FORCE_INLINE_ static bool *get_bool(Variant *v) { return get_internal_value<bool>(v); }
  207. _FORCE_INLINE_ static const bool *get_bool(const Variant *v) { return get_internal_value<bool>(v); }
  208. _FORCE_INLINE_ static int64_t *get_int(Variant *v) { return get_internal_value<int64_t>(v); }
  209. _FORCE_INLINE_ static const int64_t *get_int(const Variant *v) { return get_internal_value<int64_t>(v); }
  210. _FORCE_INLINE_ static double *get_float(Variant *v) { return get_internal_value<double>(v); }
  211. _FORCE_INLINE_ static const double *get_float(const Variant *v) { return get_internal_value<double>(v); }
  212. _FORCE_INLINE_ static String *get_string(Variant *v) { return get_internal_value<String>(v); }
  213. _FORCE_INLINE_ static const String *get_string(const Variant *v) { return get_internal_value<String>(v); }
  214. // Math types.
  215. _FORCE_INLINE_ static Vector2 *get_vector2(Variant *v) { return get_internal_value<Vector2>(v); }
  216. _FORCE_INLINE_ static const Vector2 *get_vector2(const Variant *v) { return get_internal_value<Vector2>(v); }
  217. _FORCE_INLINE_ static Vector2i *get_vector2i(Variant *v) { return get_internal_value<Vector2i>(v); }
  218. _FORCE_INLINE_ static const Vector2i *get_vector2i(const Variant *v) { return get_internal_value<Vector2i>(v); }
  219. _FORCE_INLINE_ static Rect2 *get_rect2(Variant *v) { return get_internal_value<Rect2>(v); }
  220. _FORCE_INLINE_ static const Rect2 *get_rect2(const Variant *v) { return get_internal_value<Rect2>(v); }
  221. _FORCE_INLINE_ static Rect2i *get_rect2i(Variant *v) { return get_internal_value<Rect2i>(v); }
  222. _FORCE_INLINE_ static const Rect2i *get_rect2i(const Variant *v) { return get_internal_value<Rect2i>(v); }
  223. _FORCE_INLINE_ static Vector3 *get_vector3(Variant *v) { return get_internal_value<Vector3>(v); }
  224. _FORCE_INLINE_ static const Vector3 *get_vector3(const Variant *v) { return get_internal_value<Vector3>(v); }
  225. _FORCE_INLINE_ static Vector3i *get_vector3i(Variant *v) { return get_internal_value<Vector3i>(v); }
  226. _FORCE_INLINE_ static const Vector3i *get_vector3i(const Variant *v) { return get_internal_value<Vector3i>(v); }
  227. _FORCE_INLINE_ static Vector4 *get_vector4(Variant *v) { return get_internal_value<Vector4>(v); }
  228. _FORCE_INLINE_ static const Vector4 *get_vector4(const Variant *v) { return get_internal_value<Vector4>(v); }
  229. _FORCE_INLINE_ static Vector4i *get_vector4i(Variant *v) { return get_internal_value<Vector4i>(v); }
  230. _FORCE_INLINE_ static const Vector4i *get_vector4i(const Variant *v) { return get_internal_value<Vector4i>(v); }
  231. _FORCE_INLINE_ static Transform2D *get_transform2d(Variant *v) { return get_internal_value<Transform2D>(v); }
  232. _FORCE_INLINE_ static const Transform2D *get_transform2d(const Variant *v) { return get_internal_value<Transform2D>(v); }
  233. _FORCE_INLINE_ static Plane *get_plane(Variant *v) { return get_internal_value<Plane>(v); }
  234. _FORCE_INLINE_ static const Plane *get_plane(const Variant *v) { return get_internal_value<Plane>(v); }
  235. _FORCE_INLINE_ static Quaternion *get_quaternion(Variant *v) { return get_internal_value<Quaternion>(v); }
  236. _FORCE_INLINE_ static const Quaternion *get_quaternion(const Variant *v) { return get_internal_value<Quaternion>(v); }
  237. _FORCE_INLINE_ static AABB *get_aabb(Variant *v) { return get_internal_value<AABB>(v); }
  238. _FORCE_INLINE_ static const AABB *get_aabb(const Variant *v) { return get_internal_value<AABB>(v); }
  239. _FORCE_INLINE_ static Basis *get_basis(Variant *v) { return get_internal_value<Basis>(v); }
  240. _FORCE_INLINE_ static const Basis *get_basis(const Variant *v) { return get_internal_value<Basis>(v); }
  241. _FORCE_INLINE_ static Transform3D *get_transform(Variant *v) { return get_internal_value<Transform3D>(v); }
  242. _FORCE_INLINE_ static const Transform3D *get_transform(const Variant *v) { return get_internal_value<Transform3D>(v); }
  243. _FORCE_INLINE_ static Projection *get_projection(Variant *v) { return get_internal_value<Projection>(v); }
  244. _FORCE_INLINE_ static const Projection *get_projection(const Variant *v) { return get_internal_value<Projection>(v); }
  245. // Misc types.
  246. _FORCE_INLINE_ static Color *get_color(Variant *v) { return get_internal_value<Color>(v); }
  247. _FORCE_INLINE_ static const Color *get_color(const Variant *v) { return get_internal_value<Color>(v); }
  248. _FORCE_INLINE_ static StringName *get_string_name(Variant *v) { return get_internal_value<StringName>(v); }
  249. _FORCE_INLINE_ static const StringName *get_string_name(const Variant *v) { return get_internal_value<StringName>(v); }
  250. _FORCE_INLINE_ static NodePath *get_node_path(Variant *v) { return get_internal_value<NodePath>(v); }
  251. _FORCE_INLINE_ static const NodePath *get_node_path(const Variant *v) { return get_internal_value<NodePath>(v); }
  252. _FORCE_INLINE_ static RID *get_rid(Variant *v) { return get_internal_value<RID>(v); }
  253. _FORCE_INLINE_ static const RID *get_rid(const Variant *v) { return get_internal_value<RID>(v); }
  254. _FORCE_INLINE_ static Callable *get_callable(Variant *v) { return get_internal_value<Callable>(v); }
  255. _FORCE_INLINE_ static const Callable *get_callable(const Variant *v) { return get_internal_value<Callable>(v); }
  256. _FORCE_INLINE_ static Signal *get_signal(Variant *v) { return get_internal_value<Signal>(v); }
  257. _FORCE_INLINE_ static const Signal *get_signal(const Variant *v) { return get_internal_value<Signal>(v); }
  258. _FORCE_INLINE_ static Dictionary *get_dictionary(Variant *v) { return get_internal_value<Dictionary>(v); }
  259. _FORCE_INLINE_ static const Dictionary *get_dictionary(const Variant *v) { return get_internal_value<Dictionary>(v); }
  260. _FORCE_INLINE_ static Array *get_array(Variant *v) { return get_internal_value<Array>(v); }
  261. _FORCE_INLINE_ static const Array *get_array(const Variant *v) { return get_internal_value<Array>(v); }
  262. // Typed arrays.
  263. _FORCE_INLINE_ static PackedByteArray *get_byte_array(Variant *v) { return get_internal_value<PackedByteArray>(v); }
  264. _FORCE_INLINE_ static const PackedByteArray *get_byte_array(const Variant *v) { return get_internal_value<PackedByteArray>(v); }
  265. _FORCE_INLINE_ static PackedInt32Array *get_int32_array(Variant *v) { return get_internal_value<PackedInt32Array>(v); }
  266. _FORCE_INLINE_ static const PackedInt32Array *get_int32_array(const Variant *v) { return get_internal_value<PackedInt32Array>(v); }
  267. _FORCE_INLINE_ static PackedInt64Array *get_int64_array(Variant *v) { return get_internal_value<PackedInt64Array>(v); }
  268. _FORCE_INLINE_ static const PackedInt64Array *get_int64_array(const Variant *v) { return get_internal_value<PackedInt64Array>(v); }
  269. _FORCE_INLINE_ static PackedFloat32Array *get_float32_array(Variant *v) { return get_internal_value<PackedFloat32Array>(v); }
  270. _FORCE_INLINE_ static const PackedFloat32Array *get_float32_array(const Variant *v) { return get_internal_value<PackedFloat32Array>(v); }
  271. _FORCE_INLINE_ static PackedFloat64Array *get_float64_array(Variant *v) { return get_internal_value<PackedFloat64Array>(v); }
  272. _FORCE_INLINE_ static const PackedFloat64Array *get_float64_array(const Variant *v) { return get_internal_value<PackedFloat64Array>(v); }
  273. _FORCE_INLINE_ static PackedStringArray *get_string_array(Variant *v) { return get_internal_value<PackedStringArray>(v); }
  274. _FORCE_INLINE_ static const PackedStringArray *get_string_array(const Variant *v) { return get_internal_value<PackedStringArray>(v); }
  275. _FORCE_INLINE_ static PackedVector2Array *get_vector2_array(Variant *v) { return get_internal_value<PackedVector2Array>(v); }
  276. _FORCE_INLINE_ static const PackedVector2Array *get_vector2_array(const Variant *v) { return get_internal_value<PackedVector2Array>(v); }
  277. _FORCE_INLINE_ static PackedVector3Array *get_vector3_array(Variant *v) { return get_internal_value<PackedVector3Array>(v); }
  278. _FORCE_INLINE_ static const PackedVector3Array *get_vector3_array(const Variant *v) { return get_internal_value<PackedVector3Array>(v); }
  279. _FORCE_INLINE_ static PackedColorArray *get_color_array(Variant *v) { return get_internal_value<PackedColorArray>(v); }
  280. _FORCE_INLINE_ static const PackedColorArray *get_color_array(const Variant *v) { return get_internal_value<PackedColorArray>(v); }
  281. _FORCE_INLINE_ static PackedVector4Array *get_vector4_array(Variant *v) { return get_internal_value<PackedVector4Array>(v); }
  282. _FORCE_INLINE_ static const PackedVector4Array *get_vector4_array(const Variant *v) { return get_internal_value<PackedVector4Array>(v); }
  283. _FORCE_INLINE_ static Object **get_object(Variant *v) { return get_internal_value<Object *>(v); }
  284. _FORCE_INLINE_ static const Object **get_object(const Variant *v) { return (const Object **)get_internal_value<Object *>(v); }
  285. _FORCE_INLINE_ static void *get_opaque_pointer(Variant *v) {
  286. switch (v->get_type()) {
  287. case Variant::NIL:
  288. return nullptr;
  289. case Variant::BOOL:
  290. return get_bool(v);
  291. case Variant::INT:
  292. return get_int(v);
  293. case Variant::FLOAT:
  294. return get_float(v);
  295. case Variant::STRING:
  296. return get_string(v);
  297. case Variant::VECTOR2:
  298. return get_vector2(v);
  299. case Variant::VECTOR2I:
  300. return get_vector2i(v);
  301. case Variant::VECTOR3:
  302. return get_vector3(v);
  303. case Variant::VECTOR3I:
  304. return get_vector3i(v);
  305. case Variant::VECTOR4:
  306. return get_vector4(v);
  307. case Variant::VECTOR4I:
  308. return get_vector4i(v);
  309. case Variant::RECT2:
  310. return get_rect2(v);
  311. case Variant::RECT2I:
  312. return get_rect2i(v);
  313. case Variant::TRANSFORM3D:
  314. return get_transform(v);
  315. case Variant::PROJECTION:
  316. return get_projection(v);
  317. case Variant::TRANSFORM2D:
  318. return get_transform2d(v);
  319. case Variant::QUATERNION:
  320. return get_quaternion(v);
  321. case Variant::PLANE:
  322. return get_plane(v);
  323. case Variant::BASIS:
  324. return get_basis(v);
  325. case Variant::AABB:
  326. return get_aabb(v);
  327. case Variant::COLOR:
  328. return get_color(v);
  329. case Variant::STRING_NAME:
  330. return get_string_name(v);
  331. case Variant::NODE_PATH:
  332. return get_node_path(v);
  333. case Variant::RID:
  334. return get_rid(v);
  335. case Variant::CALLABLE:
  336. return get_callable(v);
  337. case Variant::SIGNAL:
  338. return get_signal(v);
  339. case Variant::DICTIONARY:
  340. return get_dictionary(v);
  341. case Variant::ARRAY:
  342. return get_array(v);
  343. case Variant::PACKED_BYTE_ARRAY:
  344. return get_byte_array(v);
  345. case Variant::PACKED_INT32_ARRAY:
  346. return get_int32_array(v);
  347. case Variant::PACKED_INT64_ARRAY:
  348. return get_int64_array(v);
  349. case Variant::PACKED_FLOAT32_ARRAY:
  350. return get_float32_array(v);
  351. case Variant::PACKED_FLOAT64_ARRAY:
  352. return get_float64_array(v);
  353. case Variant::PACKED_STRING_ARRAY:
  354. return get_string_array(v);
  355. case Variant::PACKED_VECTOR2_ARRAY:
  356. return get_vector2_array(v);
  357. case Variant::PACKED_VECTOR3_ARRAY:
  358. return get_vector3_array(v);
  359. case Variant::PACKED_COLOR_ARRAY:
  360. return get_color_array(v);
  361. case Variant::PACKED_VECTOR4_ARRAY:
  362. return get_vector4_array(v);
  363. case Variant::OBJECT:
  364. return get_object(v);
  365. case Variant::VARIANT_MAX:
  366. ERR_FAIL_V(nullptr);
  367. }
  368. ERR_FAIL_V(nullptr);
  369. }
  370. _FORCE_INLINE_ static const void *get_opaque_pointer(const Variant *v) {
  371. switch (v->get_type()) {
  372. case Variant::NIL:
  373. return nullptr;
  374. case Variant::BOOL:
  375. return get_bool(v);
  376. case Variant::INT:
  377. return get_int(v);
  378. case Variant::FLOAT:
  379. return get_float(v);
  380. case Variant::STRING:
  381. return get_string(v);
  382. case Variant::VECTOR2:
  383. return get_vector2(v);
  384. case Variant::VECTOR2I:
  385. return get_vector2i(v);
  386. case Variant::VECTOR3:
  387. return get_vector3(v);
  388. case Variant::VECTOR3I:
  389. return get_vector3i(v);
  390. case Variant::VECTOR4:
  391. return get_vector4(v);
  392. case Variant::VECTOR4I:
  393. return get_vector4i(v);
  394. case Variant::RECT2:
  395. return get_rect2(v);
  396. case Variant::RECT2I:
  397. return get_rect2i(v);
  398. case Variant::TRANSFORM3D:
  399. return get_transform(v);
  400. case Variant::PROJECTION:
  401. return get_projection(v);
  402. case Variant::TRANSFORM2D:
  403. return get_transform2d(v);
  404. case Variant::QUATERNION:
  405. return get_quaternion(v);
  406. case Variant::PLANE:
  407. return get_plane(v);
  408. case Variant::BASIS:
  409. return get_basis(v);
  410. case Variant::AABB:
  411. return get_aabb(v);
  412. case Variant::COLOR:
  413. return get_color(v);
  414. case Variant::STRING_NAME:
  415. return get_string_name(v);
  416. case Variant::NODE_PATH:
  417. return get_node_path(v);
  418. case Variant::RID:
  419. return get_rid(v);
  420. case Variant::CALLABLE:
  421. return get_callable(v);
  422. case Variant::SIGNAL:
  423. return get_signal(v);
  424. case Variant::DICTIONARY:
  425. return get_dictionary(v);
  426. case Variant::ARRAY:
  427. return get_array(v);
  428. case Variant::PACKED_BYTE_ARRAY:
  429. return get_byte_array(v);
  430. case Variant::PACKED_INT32_ARRAY:
  431. return get_int32_array(v);
  432. case Variant::PACKED_INT64_ARRAY:
  433. return get_int64_array(v);
  434. case Variant::PACKED_FLOAT32_ARRAY:
  435. return get_float32_array(v);
  436. case Variant::PACKED_FLOAT64_ARRAY:
  437. return get_float64_array(v);
  438. case Variant::PACKED_STRING_ARRAY:
  439. return get_string_array(v);
  440. case Variant::PACKED_VECTOR2_ARRAY:
  441. return get_vector2_array(v);
  442. case Variant::PACKED_VECTOR3_ARRAY:
  443. return get_vector3_array(v);
  444. case Variant::PACKED_COLOR_ARRAY:
  445. return get_color_array(v);
  446. case Variant::PACKED_VECTOR4_ARRAY:
  447. return get_vector4_array(v);
  448. case Variant::OBJECT:
  449. return get_object(v);
  450. case Variant::VARIANT_MAX:
  451. ERR_FAIL_V(nullptr);
  452. }
  453. ERR_FAIL_V(nullptr);
  454. }
  455. };
  456. template <typename T>
  457. struct VariantGetInternalPtr {
  458. static internal::VariantInternalType<T> *get_ptr(Variant *v) { return VariantInternal::get_internal_value<T>(v); }
  459. static const internal::VariantInternalType<T> *get_ptr(const Variant *v) { return VariantInternal::get_internal_value<T>(v); }
  460. };
  461. template <typename T>
  462. struct can_set_variant_internal_value {
  463. static const bool value = true;
  464. };
  465. template <>
  466. struct can_set_variant_internal_value<Object *> {
  467. static const bool value = false;
  468. };
  469. template <typename T>
  470. struct VariantInternalAccessor {
  471. static _FORCE_INLINE_ const T &get(const Variant *v) { return *VariantInternal::get_internal_value<T>(v); }
  472. // Enable set() only for those types where we can set (all but Object *).
  473. template <typename U = T, typename = std::enable_if_t<can_set_variant_internal_value<U>::value>>
  474. static _FORCE_INLINE_ void set(Variant *v, const internal::VariantInternalType<U> &p_value) {
  475. *VariantInternal::get_internal_value<U>(v) = p_value;
  476. }
  477. };
  478. template <typename T, std::enable_if_t<can_set_variant_internal_value<T>::value>>
  479. struct VariantDefaultInitializer {
  480. static _FORCE_INLINE_ void init(Variant *v) { *VariantInternal::get_internal_value<T>(v) = T(); }
  481. };
  482. } // namespace godot