From 8cbebc3e5d091f1be07e3b4904751e4f578adff0 Mon Sep 17 00:00:00 2001 From: Karroffel Date: Sat, 4 Mar 2017 03:04:16 +0100 Subject: [PATCH] Finished core types (for now, looking at you, Image) --- include/godot/core/Array.h | 201 ++++++++++++ include/godot/core/Basis.h | 43 ++- include/godot/core/CoreTypes.h | 30 ++ include/godot/core/Defs.h | 10 + include/godot/core/Dictionary.h | 98 ++++++ include/godot/core/InputEvent.h | 1 + include/godot/core/PoolArrays.h | 529 ++++++++++++++++++++++++++++++++ include/godot/core/Quat.h | 7 +- include/godot/core/Variant.h | 526 +++++++++++++++++++++++++++++++ 9 files changed, 1440 insertions(+), 5 deletions(-) create mode 100644 include/godot/core/Array.h create mode 100644 include/godot/core/Dictionary.h create mode 100644 include/godot/core/PoolArrays.h create mode 100644 include/godot/core/Variant.h diff --git a/include/godot/core/Array.h b/include/godot/core/Array.h new file mode 100644 index 0000000..c3a5d62 --- /dev/null +++ b/include/godot/core/Array.h @@ -0,0 +1,201 @@ +#ifndef ARRAY_H +#define ARRAY_H + +#include + +#include "Variant.h" + +namespace godot { + +class Array { + godot_array _godot_array; +public: + Array() + { + godot_array_new(&_godot_array); + } + + Array(const PoolByteArray& a) + { + godot_array_new_pool_byte_array(&_godot_array, (godot_pool_byte_array *) &a); + } + + Array(const PoolIntArray& a) + { + godot_array_new_pool_int_array(&_godot_array, (godot_pool_int_array *) &a); + } + + Array(const PoolRealArray& a) + { + godot_array_new_pool_real_array(&_godot_array, (godot_pool_real_array *) &a); + } + + Array(const PoolStringArray& a) + { + godot_array_new_pool_string_array(&_godot_array, (godot_pool_string_array *) &a); + } + + Array(const PoolVector2Array& a) + { + godot_array_new_pool_vector2_array(&_godot_array, (godot_pool_vector2_array *) &a); + } + + Array(const PoolVector3Array& a) + { + godot_array_new_pool_vector3_array(&_godot_array, (godot_pool_vector3_array *) &a); + } + + Array(const PoolColorArray& a) + { + godot_array_new_pool_color_array(&_godot_array, (godot_pool_color_array *) &a); + } + + Variant& operator [](const int idx) + { + godot_variant *v = godot_array_get(&_godot_array, idx); + return *(Variant *) v; + } + + Variant operator [](const int idx) const + { + // Yes, I'm casting away the const... you can hate me now. + // since the result is + godot_variant *v = godot_array_get((godot_array *) &_godot_array, idx); + return *(Variant *) v; + } + + void append(const Variant& v) + { + godot_array_append(&_godot_array, (godot_variant *) &v); + } + + void clear() + { + godot_array_clear(&_godot_array); + } + + int count(const Variant& v) + { + return godot_array_count(&_godot_array, (godot_variant *) &v); + } + + bool empty() const + { + return godot_array_empty(&_godot_array); + } + + void erase(const Variant& v) + { + godot_array_erase(&_godot_array, (godot_variant *) &v); + } + + Variant front() const + { + godot_variant v = godot_array_front(&_godot_array); + return *(Variant *) &v; + } + + Variant back() const + { + godot_variant v = godot_array_back(&_godot_array); + return *(Variant *) &v; + } + + int find(const Variant& what, const int from = 0) + { + return godot_array_find(&_godot_array, (godot_variant *) &what, from); + } + + int find_last(const Variant& what) + { + return godot_array_find_last(&_godot_array, (godot_variant *) &what); + } + + bool has(const Variant& what) const + { + return godot_array_has(&_godot_array, (godot_variant *) &what); + } + + uint32_t hash() const + { + return godot_array_hash(&_godot_array); + } + + void insert(const int pos, const Variant& value) + { + godot_array_insert(&_godot_array, pos, (godot_variant *) &value); + } + + void invert() + { + godot_array_invert(&_godot_array); + } + + bool is_shared() const + { + return godot_array_is_shared(&_godot_array); + } + + Variant pop_back() + { + godot_variant v = godot_array_pop_back(&_godot_array); + return *(Variant *) &v; + } + + Variant pop_front() + { + godot_variant v = godot_array_pop_front(&_godot_array); + return *(Variant *) &v; + } + + void push_back(const Variant& v) + { + godot_array_push_back(&_godot_array, (godot_variant *) &v); + } + + void push_front(const Variant& v) + { + godot_array_push_front(&_godot_array, (godot_variant *) &v); + } + + void remove(const int idx) + { + godot_array_remove(&_godot_array, idx); + } + + int size() const + { + return godot_array_size(&_godot_array); + } + + void resize(const int size) + { + godot_array_resize(&_godot_array, size); + } + + int rfind(const Variant& what, const int from = -1) + { + return godot_array_rfind(&_godot_array, (godot_variant *) &what, from); + } + + void sort() + { + godot_array_sort(&_godot_array); + } + + void sort_custom(Object *obj, const String& func) + { + godot_array_sort_custom(&_godot_array, (godot_object *) obj, (godot_string *) &func); + } + + ~Array() + { + godot_array_destroy(&_godot_array); + } + + +}; + +} + +#endif // ARRAY_H diff --git a/include/godot/core/Basis.h b/include/godot/core/Basis.h index b8b0c0c..2bffbdd 100644 --- a/include/godot/core/Basis.h +++ b/include/godot/core/Basis.h @@ -1,16 +1,14 @@ #ifndef BASIS_H #define BASIS_H +#include "Defs.h" + #include "Vector3.h" #include typedef float real_t; // @Todo move this to a global Godot.h -#define CMP_EPSILON 0.00001 // @Todo move this somewhere more global -#define CMP_EPSILON2 (CMP_EPSILON*CMP_EPSILON) // @Todo same as above -#define Math_PI 3.14159265358979323846 // I feel like I'm talking to myself - namespace godot { @@ -660,6 +658,43 @@ Basis::Basis(const Vector3& p_axis, real_t p_phi) { } +Basis::operator Quat() const { + ERR_FAIL_COND_V(is_rotation() == false, Quat()); + + real_t trace = elements[0][0] + elements[1][1] + elements[2][2]; + real_t temp[4]; + + if (trace > 0.0) + { + real_t s = ::sqrt(trace + 1.0); + temp[3]=(s * 0.5); + s = 0.5 / s; + + temp[0]=((elements[2][1] - elements[1][2]) * s); + temp[1]=((elements[0][2] - elements[2][0]) * s); + temp[2]=((elements[1][0] - elements[0][1]) * s); + } + else + { + int i = elements[0][0] < elements[1][1] ? + (elements[1][1] < elements[2][2] ? 2 : 1) : + (elements[0][0] < elements[2][2] ? 2 : 0); + int j = (i + 1) % 3; + int k = (i + 2) % 3; + + real_t s = ::sqrt(elements[i][i] - elements[j][j] - elements[k][k] + 1.0); + temp[i] = s * 0.5; + s = 0.5 / s; + + temp[3] = (elements[k][j] - elements[j][k]) * s; + temp[j] = (elements[j][i] + elements[i][j]) * s; + temp[k] = (elements[k][i] + elements[i][k]) * s; + } + + return Quat(temp[0],temp[1],temp[2],temp[3]); + +} + diff --git a/include/godot/core/CoreTypes.h b/include/godot/core/CoreTypes.h index cf5351a..9d5f627 100644 --- a/include/godot/core/CoreTypes.h +++ b/include/godot/core/CoreTypes.h @@ -3,12 +3,15 @@ #include "Defs.h" +#include "Array.h" #include "Basis.h" #include "Color.h" +#include "Dictionary.h" #include "Image.h" #include "InputEvent.h" #include "NodePath.h" #include "Plane.h" +#include "PoolArrays.h" #include "Quat.h" #include "Rect2.h" #include "Rect3.h" @@ -16,8 +19,35 @@ #include "String.h" #include "Transform.h" #include "Transform2D.h" +#include "Variant.h" #include "Vector2.h" #include "Vector3.h" +// This is ugly, sorry +// but those two casts need to be the last thing EVEEEEER +// +// if you can make it prettier feel free to open a Pull Request on +// https://github.com/GodotNativeTools/cpp_bindings +// or message someone on the IRC freenode #godotengine-devel +namespace godot { + + +Variant::operator Dictionary() const +{ + godot_dictionary d = godot_variant_as_dictionary(&_godot_variant); + return *(Dictionary *) &d; +} + + + +Variant::operator Array() const +{ + godot_array s = godot_variant_as_array(&_godot_variant); + return *(Array *) &s; +} + +} + + #endif // CORETYPES_H diff --git a/include/godot/core/Defs.h b/include/godot/core/Defs.h index 1e9e45d..16c1b2d 100644 --- a/include/godot/core/Defs.h +++ b/include/godot/core/Defs.h @@ -64,6 +64,16 @@ enum Error { // @Todo as well as real_t +#define CMP_EPSILON 0.00001 // @Todo move this somewhere more global +#define CMP_EPSILON2 (CMP_EPSILON*CMP_EPSILON) // @Todo same as above +#define Math_PI 3.14159265358979323846 // I feel like I'm talking to myself + + +#ifndef ERR_FAIL_COND_V +#define ERR_FAIL_COND_V(cond, ret) do { if (cond) { return ret; } } while(0) +#endif + + #ifndef ERR_PRINT #define ERR_PRINT(msg) #endif diff --git a/include/godot/core/Dictionary.h b/include/godot/core/Dictionary.h new file mode 100644 index 0000000..1e8d843 --- /dev/null +++ b/include/godot/core/Dictionary.h @@ -0,0 +1,98 @@ +#ifndef DICTIONARY_H +#define DICTIONARY_H + +#include "Variant.h" + +#include "Array.h" + +#include + +namespace godot { + +class Dictionary { + godot_dictionary _godot_dictionary; +public: + Dictionary() + { + godot_dictionary_new(&_godot_dictionary); + } + + void clear() + { + godot_dictionary_clear(&_godot_dictionary); + } + + bool empty() const + { + return godot_dictionary_empty(&_godot_dictionary); + } + + void erase(const Variant& key) + { + godot_dictionary_erase(&_godot_dictionary, (godot_variant *) &key); + } + + bool has(const Variant& key) const + { + return godot_dictionary_has(&_godot_dictionary, (godot_variant *) &key); + } + + bool has_all(const Array& keys) const + { + return godot_dictionary_has_all(&_godot_dictionary, (godot_array *) &keys); + } + + uint32_t hash() const + { + return godot_dictionary_hash(&_godot_dictionary); + } + + Array keys() const + { + godot_array a = godot_dictionary_keys(&_godot_dictionary); + return *(Array *) &a; + } + + int parse_json(const String& json) + { + return godot_dictionary_parse_json(&_godot_dictionary, (godot_string *) &json); + } + + Variant &operator [](const Variant& key) + { + return *(Variant *) godot_dictionary_operator_index(&_godot_dictionary, (godot_variant *) &key); + } + + const Variant &operator [](const Variant& key) const + { + // oops I did it again + return *(Variant *) godot_dictionary_operator_index((godot_dictionary *) &_godot_dictionary, (godot_variant *) &key); + } + + int size() const + { + return godot_dictionary_size(&_godot_dictionary); + } + + String to_json() const + { + godot_string s = godot_dictionary_to_json(&_godot_dictionary); + return *(String *) &s; + } + + Array values() const + { + godot_array a = godot_dictionary_values(&_godot_dictionary); + return *(Array *) &a; + } + + ~Dictionary() + { + godot_dictionary_destroy(&_godot_dictionary); + } + +}; + +} + +#endif // DICTIONARY_H diff --git a/include/godot/core/InputEvent.h b/include/godot/core/InputEvent.h index c78271f..528c01e 100644 --- a/include/godot/core/InputEvent.h +++ b/include/godot/core/InputEvent.h @@ -2,6 +2,7 @@ #define INPUTEVENT_H #include +#include #include "String.h" diff --git a/include/godot/core/PoolArrays.h b/include/godot/core/PoolArrays.h new file mode 100644 index 0000000..7cd1734 --- /dev/null +++ b/include/godot/core/PoolArrays.h @@ -0,0 +1,529 @@ +#ifndef POOLARRAYS_H +#define POOLARRAYS_H + +#include "Defs.h" + +#include "String.h" +#include "Color.h" +#include "Vector2.h" +#include "Vector3.h" + +#include + +namespace godot { + +class Array; + +class PoolByteArray { + godot_pool_byte_array _godot_array; +public: + PoolByteArray() + { + godot_pool_byte_array_new(&_godot_array); + } + + PoolByteArray(const Array& array) + { + godot_pool_byte_array_new_with_array(&_godot_array, (godot_array *) &array); + } + + void append(const uint8_t data) + { + godot_pool_byte_array_append(&_godot_array, data); + } + + void append_array(const PoolByteArray& array) + { + godot_pool_byte_array_append_array(&_godot_array, &array._godot_array); + } + + int insert(const int idx, const uint8_t data) + { + return godot_pool_byte_array_insert(&_godot_array, idx, data); + } + + void invert() + { + godot_pool_byte_array_invert(&_godot_array); + } + + void push_back(const uint8_t data) + { + godot_pool_byte_array_push_back(&_godot_array, data); + } + + void remove(const int idx) + { + godot_pool_byte_array_remove(&_godot_array, idx); + } + + void resize(const int size) + { + godot_pool_byte_array_resize(&_godot_array, size); + } + + void set(const int idx, const uint8_t data) + { + godot_pool_byte_array_set(&_godot_array, idx, data); + } + + uint8_t operator [](const int idx) + { + return godot_pool_byte_array_get(&_godot_array, idx); + } + + int size() + { + return godot_pool_byte_array_size(&_godot_array); + } + + + ~PoolByteArray() + { + godot_pool_byte_array_destroy(&_godot_array); + } +}; + + +class PoolIntArray { + godot_pool_int_array _godot_array; +public: + PoolIntArray() + { + godot_pool_int_array_new(&_godot_array); + } + + PoolIntArray(const Array& array) + { + godot_pool_int_array_new_with_array(&_godot_array, (godot_array *) &array); + } + + void append(const int data) + { + godot_pool_int_array_append(&_godot_array, data); + } + + void append_array(const PoolIntArray& array) + { + godot_pool_int_array_append_array(&_godot_array, &array._godot_array); + } + + int insert(const int idx, const int data) + { + return godot_pool_int_array_insert(&_godot_array, idx, data); + } + + void invert() + { + godot_pool_int_array_invert(&_godot_array); + } + + void push_back(const int data) + { + godot_pool_int_array_push_back(&_godot_array, data); + } + + void remove(const int idx) + { + godot_pool_int_array_remove(&_godot_array, idx); + } + + void resize(const int size) + { + godot_pool_int_array_resize(&_godot_array, size); + } + + void set(const int idx, const int data) + { + godot_pool_int_array_set(&_godot_array, idx, data); + } + + int operator [](const int idx) + { + return godot_pool_int_array_get(&_godot_array, idx); + } + + int size() + { + return godot_pool_int_array_size(&_godot_array); + } + + + ~PoolIntArray() + { + godot_pool_int_array_destroy(&_godot_array); + } +}; + + +class PoolRealArray { + godot_pool_real_array _godot_array; +public: + PoolRealArray() + { + godot_pool_real_array_new(&_godot_array); + } + + PoolRealArray(const Array& array) + { + godot_pool_real_array_new_with_array(&_godot_array, (godot_array *) &array); + } + + void append(const real_t data) + { + godot_pool_real_array_append(&_godot_array, data); + } + + void append_array(const PoolRealArray& array) + { + godot_pool_real_array_append_array(&_godot_array, &array._godot_array); + } + + int insert(const int idx, const real_t data) + { + return godot_pool_real_array_insert(&_godot_array, idx, data); + } + + void invert() + { + godot_pool_real_array_invert(&_godot_array); + } + + void push_back(const real_t data) + { + godot_pool_real_array_push_back(&_godot_array, data); + } + + void remove(const int idx) + { + godot_pool_real_array_remove(&_godot_array, idx); + } + + void resize(const int size) + { + godot_pool_real_array_resize(&_godot_array, size); + } + + void set(const int idx, const real_t data) + { + godot_pool_real_array_set(&_godot_array, idx, data); + } + + real_t operator [](const int idx) + { + return godot_pool_real_array_get(&_godot_array, idx); + } + + int size() + { + return godot_pool_real_array_size(&_godot_array); + } + + + ~PoolRealArray() + { + godot_pool_real_array_destroy(&_godot_array); + } +}; + + +class PoolStringArray { + godot_pool_string_array _godot_array; +public: + PoolStringArray() + { + godot_pool_string_array_new(&_godot_array); + } + + PoolStringArray(const Array& array) + { + godot_pool_string_array_new_with_array(&_godot_array, (godot_array *) &array); + } + + void append(const String& data) + { + godot_pool_string_array_append(&_godot_array, (godot_string *) &data); + } + + void append_array(const PoolStringArray& array) + { + godot_pool_string_array_append_array(&_godot_array, &array._godot_array); + } + + int insert(const int idx, const String& data) + { + return godot_pool_string_array_insert(&_godot_array, idx, (godot_string *) &data); + } + + void invert() + { + godot_pool_string_array_invert(&_godot_array); + } + + void push_back(const String& data) + { + godot_pool_string_array_push_back(&_godot_array, (godot_string *) &data); + } + + void remove(const int idx) + { + godot_pool_string_array_remove(&_godot_array, idx); + } + + void resize(const int size) + { + godot_pool_string_array_resize(&_godot_array, size); + } + + void set(const int idx, const String& data) + { + godot_pool_string_array_set(&_godot_array, idx, (godot_string *) &data); + } + + String operator [](const int idx) + { + String s; + godot_string str = godot_pool_string_array_get(&_godot_array, idx); + godot_string_copy_string((godot_string *) &s, &str); + godot_string_destroy(&str); + return s; + } + + int size() + { + return godot_pool_string_array_size(&_godot_array); + } + + + ~PoolStringArray() + { + godot_pool_string_array_destroy(&_godot_array); + } +}; + + + +class PoolVector2Array { + godot_pool_vector2_array _godot_array; +public: + PoolVector2Array() + { + godot_pool_vector2_array_new(&_godot_array); + } + + PoolVector2Array(const Array& array) + { + godot_pool_vector2_array_new_with_array(&_godot_array, (godot_array *) &array); + } + + void append(const Vector2& data) + { + godot_pool_vector2_array_append(&_godot_array, (godot_vector2 *) &data); + } + + void append_array(const PoolVector2Array& array) + { + godot_pool_vector2_array_append_array(&_godot_array, &array._godot_array); + } + + int insert(const int idx, const Vector2& data) + { + return godot_pool_vector2_array_insert(&_godot_array, idx, (godot_vector2 *) &data); + } + + void invert() + { + godot_pool_vector2_array_invert(&_godot_array); + } + + void push_back(const Vector2& data) + { + godot_pool_vector2_array_push_back(&_godot_array, (godot_vector2 *) &data); + } + + void remove(const int idx) + { + godot_pool_vector2_array_remove(&_godot_array, idx); + } + + void resize(const int size) + { + godot_pool_vector2_array_resize(&_godot_array, size); + } + + void set(const int idx, const Vector2& data) + { + godot_pool_vector2_array_set(&_godot_array, idx, (godot_vector2 *) &data); + } + + Vector2 operator [](const int idx) + { + Vector2 v; + *(godot_vector2 *) &v = godot_pool_vector2_array_get(&_godot_array, idx); + return v; + } + + int size() + { + return godot_pool_vector2_array_size(&_godot_array); + } + + + ~PoolVector2Array() + { + godot_pool_vector2_array_destroy(&_godot_array); + } +}; + + +class PoolVector3Array { + godot_pool_vector3_array _godot_array; +public: + PoolVector3Array() + { + godot_pool_vector3_array_new(&_godot_array); + } + + PoolVector3Array(const Array& array) + { + godot_pool_vector3_array_new_with_array(&_godot_array, (godot_array *) &array); + } + + void append(const Vector3& data) + { + godot_pool_vector3_array_append(&_godot_array, (godot_vector3 *) &data); + } + + void append_array(const PoolVector3Array& array) + { + godot_pool_vector3_array_append_array(&_godot_array, &array._godot_array); + } + + int insert(const int idx, const Vector3& data) + { + return godot_pool_vector3_array_insert(&_godot_array, idx, (godot_vector3 *) &data); + } + + void invert() + { + godot_pool_vector3_array_invert(&_godot_array); + } + + void push_back(const Vector3& data) + { + godot_pool_vector3_array_push_back(&_godot_array, (godot_vector3 *) &data); + } + + void remove(const int idx) + { + godot_pool_vector3_array_remove(&_godot_array, idx); + } + + void resize(const int size) + { + godot_pool_vector3_array_resize(&_godot_array, size); + } + + void set(const int idx, const Vector3& data) + { + godot_pool_vector3_array_set(&_godot_array, idx, (godot_vector3 *) &data); + } + + Vector3 operator [](const int idx) + { + Vector3 v; + *(godot_vector3 *) &v = godot_pool_vector3_array_get(&_godot_array, idx); + return v; + } + + int size() + { + return godot_pool_vector3_array_size(&_godot_array); + } + + + ~PoolVector3Array() + { + godot_pool_vector3_array_destroy(&_godot_array); + } +}; + + +class PoolColorArray { + godot_pool_color_array _godot_array; +public: + PoolColorArray() + { + godot_pool_color_array_new(&_godot_array); + } + + PoolColorArray(const Array& array) + { + godot_pool_color_array_new_with_array(&_godot_array, (godot_array *) &array); + } + + void append(const Color& data) + { + godot_pool_color_array_append(&_godot_array, (godot_color *) &data); + } + + void append_array(const PoolColorArray& array) + { + godot_pool_color_array_append_array(&_godot_array, &array._godot_array); + } + + int insert(const int idx, const Color& data) + { + return godot_pool_color_array_insert(&_godot_array, idx, (godot_color *) &data); + } + + void invert() + { + godot_pool_color_array_invert(&_godot_array); + } + + void push_back(const Color& data) + { + godot_pool_color_array_push_back(&_godot_array, (godot_color *) &data); + } + + void remove(const int idx) + { + godot_pool_color_array_remove(&_godot_array, idx); + } + + void resize(const int size) + { + godot_pool_color_array_resize(&_godot_array, size); + } + + void set(const int idx, const Color& data) + { + godot_pool_color_array_set(&_godot_array, idx, (godot_color *) &data); + } + + Color operator [](const int idx) + { + Color v; + *(godot_color *) &v = godot_pool_color_array_get(&_godot_array, idx); + return v; + } + + int size() + { + return godot_pool_color_array_size(&_godot_array); + } + + + ~PoolColorArray() + { + godot_pool_color_array_destroy(&_godot_array); + } +}; + + + + +} + +#endif // POOLARRAYS_H diff --git a/include/godot/core/Quat.h b/include/godot/core/Quat.h index 958815a..b2c452d 100644 --- a/include/godot/core/Quat.h +++ b/include/godot/core/Quat.h @@ -229,7 +229,7 @@ public: } } - inline Quat() {x=y=z=0; w=1; } + Quat() {x=y=z=0; w=1; } }; @@ -251,6 +251,11 @@ void Quat::operator-=(const Quat& q) { x -= q.x; y -= q.y; z -= q.z; w -= q.w; } +void Quat::operator*=(const Quat& q) { + x *= q.x; y *= q.y; z *= q.z; w *= q.w; +} + + void Quat::operator*=(const real_t& s) { x *= s; y *= s; z *= s; w *= s; } diff --git a/include/godot/core/Variant.h b/include/godot/core/Variant.h new file mode 100644 index 0000000..7d4b103 --- /dev/null +++ b/include/godot/core/Variant.h @@ -0,0 +1,526 @@ +#ifndef VARIANT_H +#define VARIANT_H + +#include + +#include "Defs.h" + +#include "Basis.h" +#include "Color.h" +#include "Image.h" +#include "InputEvent.h" +#include "NodePath.h" +#include "Plane.h" +#include "PoolArrays.h" +#include "Quat.h" +#include "Rect2.h" +#include "Rect3.h" +#include "RID.h" +#include "String.h" +#include "Transform.h" +#include "Transform2D.h" +#include "Vector2.h" +#include "Vector3.h" + +#include + +namespace godot { + +class Dictionary; + +class Array; + +class Variant { + godot_variant _godot_variant; +public: + enum Type { + + NIL, + + // atomic types + BOOL, + INT, + REAL, + STRING, + + // math types + + VECTOR2, // 5 + RECT2, + VECTOR3, + TRANSFORM2D, + PLANE, + QUAT, // 10 + RECT3, //sorry naming convention fail :( not like it's used often + BASIS, + TRANSFORM, + + // misc types + COLOR, + IMAGE, // 15 + NODE_PATH, + _RID, + OBJECT, + INPUT_EVENT, + DICTIONARY, // 20 + ARRAY, + + // arrays + POOL_BYTE_ARRAY, + POOL_INT_ARRAY, + POOL_REAL_ARRAY, + POOL_STRING_ARRAY, // 25 + POOL_VECTOR2_ARRAY, + POOL_VECTOR3_ARRAY, + POOL_COLOR_ARRAY, + + VARIANT_MAX + + }; + + Variant() + { + godot_variant_new_nil(&_godot_variant); + } + + Variant(const Variant& v) + { + godot_variant_copy(&_godot_variant, &v._godot_variant); + } + + Variant(bool p_bool) + { + godot_variant_new_bool(&_godot_variant, p_bool); + } + + Variant(signed int p_int) // real one + { + godot_variant_new_int(&_godot_variant, p_int); + } + + Variant(unsigned int p_int) + { + godot_variant_new_int(&_godot_variant, p_int); + } + + Variant(signed short p_short) // real one + { + godot_variant_new_int(&_godot_variant, (int) p_short); + } + + Variant(unsigned short p_short) : Variant((unsigned int) p_short) {} + + Variant(signed char p_char) : Variant((signed int) p_char) {}// real one + + Variant(unsigned char p_char) : Variant((unsigned int) p_char) {} + Variant(int64_t p_char) // real one + { + godot_variant_new_int(&_godot_variant, p_char); + } + + Variant(uint64_t p_char) + { + godot_variant_new_int(&_godot_variant, p_char); + } + + Variant(float p_float) + { + godot_variant_new_real(&_godot_variant, p_float); + } + + Variant(double p_double) + { + godot_variant_new_real(&_godot_variant, p_double); + } + + Variant(const String& p_string) + { + godot_variant_new_string(&_godot_variant, (godot_string *) &p_string); + } + + Variant(const char * const p_cstring) + { + String s = String(p_cstring); + godot_variant_new_string(&_godot_variant, (godot_string *) &s); + } + + Variant(const wchar_t * p_wstring) + { + String s = p_wstring; + godot_variant_new_string(&_godot_variant, (godot_string *) &s); + } + + Variant(const Vector2& p_vector2) + { + godot_variant_new_vector2(&_godot_variant, (godot_vector2 *) &p_vector2); + } + + Variant(const Rect2& p_rect2) + { + godot_variant_new_rect2(&_godot_variant, (godot_rect2 *) &p_rect2); + } + + Variant(const Vector3& p_vector3) + { + godot_variant_new_vector3(&_godot_variant, (godot_vector3 *) &p_vector3); + } + + Variant(const Plane& p_plane) + { + godot_variant_new_plane(&_godot_variant, (godot_plane *) &p_plane); + } + + + Variant(const Rect3& p_aabb) + { + godot_variant_new_rect3(&_godot_variant, (godot_rect3 *) &p_aabb); + } + + Variant(const Quat& p_quat) + { + godot_variant_new_quat(&_godot_variant, (godot_quat *) &p_quat); + } + + Variant(const Basis& p_transform) + { + godot_variant_new_basis(&_godot_variant, (godot_basis *) &p_transform); + } + + Variant(const Transform2D& p_transform) + { + godot_variant_new_transform2d(&_godot_variant, (godot_transform2d *) &p_transform); + } + + Variant(const Transform& p_transform) + { + godot_variant_new_transform(&_godot_variant, (godot_transform *) &p_transform); + } + + Variant(const Color& p_color) + { + godot_variant_new_color(&_godot_variant, (godot_color *) &p_color); + } + + Variant(const Image& p_image) + { + godot_variant_new_image(&_godot_variant, (godot_image *) &p_image); + } + + Variant(const NodePath& p_path) + { + godot_variant_new_node_path(&_godot_variant, (godot_node_path *) &p_path); + } + + Variant(const RID& p_rid) + { + godot_variant_new_rid(&_godot_variant, (godot_rid *) &p_rid); + } + + Variant(const Object* p_object) + { + godot_variant_new_object(&_godot_variant, (godot_object *) p_object); + } + + Variant(const InputEvent& p_input_event) + { + godot_variant_new_input_event(&_godot_variant, (godot_input_event *) &p_input_event); + } + + Variant(const Dictionary& p_dictionary) + { + godot_variant_new_dictionary(&_godot_variant, (godot_dictionary *) &p_dictionary); + } + + Variant(const Array& p_array) + { + godot_variant_new_array(&_godot_variant, (godot_array *) &p_array); + } + + Variant(const PoolByteArray& p_raw_array) + { + godot_variant_new_pool_byte_array(&_godot_variant, (godot_pool_byte_array *) &p_raw_array); + } + + Variant(const PoolIntArray& p_int_array) + { + godot_variant_new_pool_int_array(&_godot_variant, (godot_pool_int_array *) &p_int_array); + } + + Variant(const PoolRealArray& p_real_array) + { + godot_variant_new_pool_real_array(&_godot_variant, (godot_pool_real_array *) &p_real_array); + } + + Variant(const PoolStringArray& p_string_array) + { + godot_variant_new_pool_string_array(&_godot_variant, (godot_pool_string_array *) &p_string_array); + } + + Variant(const PoolVector2Array& p_vector2_array) + { + godot_variant_new_pool_vector2_array(&_godot_variant, (godot_pool_vector2_array *) &p_vector2_array); + } + + Variant(const PoolVector3Array& p_vector3_array) + { + godot_variant_new_pool_vector3_array(&_godot_variant, (godot_pool_vector3_array *) &p_vector3_array); + } + + Variant(const PoolColorArray& p_color_array) + { + godot_variant_new_pool_color_array(&_godot_variant, (godot_pool_color_array *) &p_color_array); + } + + + Variant &operator =(const Variant& v) + { + godot_variant_copy(&_godot_variant, &v._godot_variant); + return *this; + } + + + operator bool() const + { + bool valid = false; + bool result = booleanize(valid); + return valid && result; + } + operator signed int() const + { + return godot_variant_as_int(&_godot_variant); + } + operator unsigned int() const // this is the real one + { + return godot_variant_as_int(&_godot_variant); + } + operator signed short() const + { + return godot_variant_as_int(&_godot_variant); + } + operator unsigned short() const + { + return godot_variant_as_int(&_godot_variant); + } + operator signed char() const + { + return godot_variant_as_int(&_godot_variant); + } + operator unsigned char() const + { + return godot_variant_as_int(&_godot_variant); + } + operator int64_t() const + { + return godot_variant_as_int(&_godot_variant); + } + operator uint64_t() const + { + return godot_variant_as_int(&_godot_variant); + } + + + operator wchar_t() const + { + return godot_variant_as_int(&_godot_variant); + } + + operator float() const + { + return godot_variant_as_real(&_godot_variant); + } + + operator double() const + { + return godot_variant_as_real(&_godot_variant); + } + operator String() const + { + godot_string s = godot_variant_as_string(&_godot_variant); + return *(String *) &s; + } + operator Vector2() const + { + godot_vector2 s = godot_variant_as_vector2(&_godot_variant); + return *(Vector2 *) &s; + } + operator Rect2() const + { + godot_rect2 s = godot_variant_as_rect2(&_godot_variant); + return *(Rect2 *) &s; + } + operator Vector3() const + { + godot_vector3 s = godot_variant_as_vector3(&_godot_variant); + return *(Vector3 *) &s; + } + operator Plane() const + { + godot_plane s = godot_variant_as_plane(&_godot_variant); + return *(Plane *) &s; + } + operator Rect3() const + { + godot_rect3 s = godot_variant_as_rect3(&_godot_variant); + return *(Rect3 *) &s; + } + operator Quat() const + { + godot_quat s = godot_variant_as_quat(&_godot_variant); + return *(Quat *) &s; + } + operator Basis() const + { + godot_basis s = godot_variant_as_basis(&_godot_variant); + return *(Basis *) &s; + } + operator Transform() const + { + godot_transform s = godot_variant_as_transform(&_godot_variant); + return *(Transform *) &s; + } + operator Transform2D() const + { + godot_transform2d s = godot_variant_as_transform2d(&_godot_variant); + return *(Transform2D *) &s; + } + + operator Color() const + { + godot_color s = godot_variant_as_color(&_godot_variant); + return *(Color *) &s; + } + operator Image() const + { + godot_image s = godot_variant_as_image(&_godot_variant); + return *(Image *) &s; + } + operator NodePath() const + { + godot_node_path s = godot_variant_as_node_path(&_godot_variant); + return *(NodePath *) &s; + } + operator RID() const + { + godot_rid s = godot_variant_as_rid(&_godot_variant); + return *(RID *) &s; + } + operator InputEvent() const + { + godot_input_event s = godot_variant_as_input_event(&_godot_variant); + return *(InputEvent *) &s; + } + operator Object*() const + { + godot_object *s = godot_variant_as_object(&_godot_variant); + return (Object *) s; + } + + operator Dictionary() const; + operator Array() const; + + operator PoolByteArray() const + { + godot_pool_byte_array s = godot_variant_as_pool_byte_array(&_godot_variant); + return *(PoolByteArray *) &s; + } + operator PoolIntArray() const + { + godot_pool_int_array s = godot_variant_as_pool_int_array(&_godot_variant); + return *(PoolIntArray *) &s; + } + operator PoolRealArray() const + { + godot_pool_real_array s = godot_variant_as_pool_real_array(&_godot_variant); + return *(PoolRealArray *) &s; + } + operator PoolStringArray() const + { + godot_pool_string_array s = godot_variant_as_pool_string_array(&_godot_variant); + return *(PoolStringArray *) &s; + } + operator PoolVector2Array() const + { + godot_pool_vector2_array s = godot_variant_as_pool_vector2_array(&_godot_variant); + return *(PoolVector2Array *) &s; + } + operator PoolVector3Array() const + { + godot_pool_vector3_array s = godot_variant_as_pool_vector3_array(&_godot_variant); + return *(PoolVector3Array *) &s; + } + operator PoolColorArray() const + { + godot_pool_color_array s = godot_variant_as_pool_color_array(&_godot_variant); + return *(PoolColorArray *) &s; + } + + Type get_type() const + { + return (Type) godot_variant_get_type(&_godot_variant); + } + + + Variant call(const String& method, const Variant **args, const int arg_count) + { + Variant v; + *(godot_variant *) &v = godot_variant_call(&_godot_variant, (godot_string *) &method, (const godot_variant **)args, arg_count); + return v; + } + + bool has_method(const String& method) + { + return godot_variant_has_method(&_godot_variant, (godot_string *) &method); + } + + bool operator ==(const Variant& b) const + { + return godot_variant_operator_equal(&_godot_variant, &b._godot_variant); + } + + bool operator !=(const Variant& b) const + { + return !(*this == b); + } + + bool operator <(const Variant& b) const + { + return godot_variant_operator_less(&_godot_variant, &b._godot_variant); + } + + bool operator <=(const Variant& b) const + { + return (*this < b) || (*this == b); + } + + bool operator >(const Variant& b) const + { + return !(*this <= b); + } + + bool operator >=(const Variant& b) const + { + return !(*this < b); + } + + bool hash_compare(const Variant& b) const + { + return godot_variant_hash_compare(&_godot_variant, &b._godot_variant); + } + + bool booleanize(bool &valid) const + { + return godot_variant_booleanize(&_godot_variant, &valid); + } + + ~Variant() + { + godot_variant_destroy(&_godot_variant); + } + + + +}; + +} + +#endif // VARIANT_H