diff options
Diffstat (limited to 'modules')
66 files changed, 2879 insertions, 2885 deletions
diff --git a/modules/dds/texture_loader_dds.cpp b/modules/dds/texture_loader_dds.cpp index d79b7685d1..4448c80387 100644 --- a/modules/dds/texture_loader_dds.cpp +++ b/modules/dds/texture_loader_dds.cpp @@ -441,7 +441,7 @@ RES ResourceFormatDDS::load(const String &p_path, const String &p_original_path, wb = PoolVector<uint8_t>::Write(); } - Image img(width, height, mipmaps - 1, info.format, src_data); + Ref<Image> img = memnew(Image(width, height, mipmaps - 1, info.format, src_data)); Ref<ImageTexture> texture = memnew(ImageTexture); texture->create_from_image(img); diff --git a/modules/etc1/image_etc.cpp b/modules/etc1/image_etc.cpp index 60544594f6..121f50684d 100644 --- a/modules/etc1/image_etc.cpp +++ b/modules/etc1/image_etc.cpp @@ -88,25 +88,26 @@ static void _decompress_etc(Image *p_img) { r = PoolVector<uint8_t>::Read(); //print_line("Re Creating ETC into regular image: w "+itos(p_img->get_width())+" h "+itos(p_img->get_height())+" mm "+itos(p_img->get_mipmaps())); - *p_img = Image(p_img->get_width(), p_img->get_height(), p_img->has_mipmaps(), Image::FORMAT_RGB8, dst); - if (p_img->has_mipmaps()) + bool needs_mipmaps = p_img->has_mipmaps(); + p_img->create(p_img->get_width(), p_img->get_height(), p_img->has_mipmaps(), Image::FORMAT_RGB8, dst); + if (needs_mipmaps) p_img->generate_mipmaps(); } static void _compress_etc(Image *p_img) { - Image img = *p_img; + Ref<Image> img = p_img->duplicate(); - int imgw = img.get_width(), imgh = img.get_height(); + int imgw = img->get_width(), imgh = img->get_height(); ERR_FAIL_COND(nearest_power_of_2(imgw) != imgw || nearest_power_of_2(imgh) != imgh); - if (img.get_format() != Image::FORMAT_RGB8) - img.convert(Image::FORMAT_RGB8); + if (img->get_format() != Image::FORMAT_RGB8) + img->convert(Image::FORMAT_RGB8); PoolVector<uint8_t> res_data; PoolVector<uint8_t> dst_data; - PoolVector<uint8_t>::Read r = img.get_data().read(); + PoolVector<uint8_t>::Read r = img->get_data().read(); int target_size = Image::get_image_data_size(p_img->get_width(), p_img->get_height(), Image::FORMAT_ETC, p_img->has_mipmaps() ? -1 : 0); int mmc = p_img->has_mipmaps() ? Image::get_image_required_mipmaps(p_img->get_width(), p_img->get_height(), Image::FORMAT_ETC) : 0; @@ -122,7 +123,7 @@ static void _compress_etc(Image *p_img) { int bw = MAX(imgw / 4, 1); int bh = MAX(imgh / 4, 1); - const uint8_t *src = &r[img.get_mipmap_offset(i)]; + const uint8_t *src = &r[img->get_mipmap_offset(i)]; int mmsize = MAX(bw, 1) * MAX(bh, 1) * 8; uint8_t *dst = &w[ofs]; @@ -171,7 +172,7 @@ static void _compress_etc(Image *p_img) { mc++; } - *p_img = Image(p_img->get_width(), p_img->get_height(), (mc - 1) ? true : false, Image::FORMAT_ETC, dst_data); + p_img->create(p_img->get_width(), p_img->get_height(), (mc - 1) ? true : false, Image::FORMAT_ETC, dst_data); } void _register_etc1_compress_func() { diff --git a/modules/etc1/texture_loader_pkm.cpp b/modules/etc1/texture_loader_pkm.cpp index 9817de3a0f..c04528d2a0 100644 --- a/modules/etc1/texture_loader_pkm.cpp +++ b/modules/etc1/texture_loader_pkm.cpp @@ -85,7 +85,7 @@ RES ResourceFormatPKM::load(const String &p_path, const String &p_original_path, int width = h.origWidth; int height = h.origHeight; - Image img(width, height, mipmaps, Image::FORMAT_ETC, src_data); + Ref<Image> img = memnew(Image(width, height, mipmaps, Image::FORMAT_ETC, src_data)); Ref<ImageTexture> texture = memnew(ImageTexture); texture->create_from_image(img); diff --git a/modules/gdnative/gdnative.h b/modules/gdnative/gdnative.h index 27e0c3788b..6716b684a0 100644 --- a/modules/gdnative/gdnative.h +++ b/modules/gdnative/gdnative.h @@ -40,7 +40,7 @@ #include "godot.h" -class GDNativeScriptData; +struct GDNativeScriptData; class GDNativeLibrary; struct NativeLibrary { @@ -127,8 +127,6 @@ struct GDNativeScriptData { } }; -class GDNativeLibrary; - class GDNativeScript : public Script { GDCLASS(GDNativeScript, Script); @@ -208,7 +206,7 @@ class GDNativeLibrary : public Resource { protected: friend class GDNativeScript; - friend class NativeLibrary; + friend struct NativeLibrary; friend class GDNativeReloadNode; GDNativeScriptData *get_script_data(const StringName p_name); diff --git a/modules/gdnative/godot.cpp b/modules/gdnative/godot.cpp index bc53eb93f4..4dbb72bba1 100644 --- a/modules/gdnative/godot.cpp +++ b/modules/gdnative/godot.cpp @@ -51,10 +51,8 @@ extern "C" void _basis_api_anchor(); extern "C" void _rect3_api_anchor(); extern "C" void _transform_api_anchor(); extern "C" void _color_api_anchor(); -extern "C" void _image_api_anchor(); extern "C" void _node_path_api_anchor(); extern "C" void _rid_api_anchor(); -extern "C" void _input_event_api_anchor(); extern "C" void _dictionary_api_anchor(); extern "C" void _array_api_anchor(); extern "C" void _pool_arrays_api_anchor(); @@ -73,10 +71,8 @@ void _api_anchor() { _basis_api_anchor(); _transform_api_anchor(); _color_api_anchor(); - _image_api_anchor(); _node_path_api_anchor(); _rid_api_anchor(); - _input_event_api_anchor(); _dictionary_api_anchor(); _array_api_anchor(); _pool_arrays_api_anchor(); diff --git a/modules/gdnative/godot.h b/modules/gdnative/godot.h index 7214ce62df..726bde0b65 100644 --- a/modules/gdnative/godot.h +++ b/modules/gdnative/godot.h @@ -139,6 +139,31 @@ typedef float godot_real; /////// Object (forward declared) typedef void godot_object; +/////// Brute force forward declarations for the rest +typedef struct godot_variant godot_variant; +typedef struct godot_string godot_string; +typedef struct godot_vector2 godot_vector2; +typedef struct godot_rect2 godot_rect2; +typedef struct godot_vector3 godot_vector3; +typedef struct godot_transform2d godot_transform2d; +typedef struct godot_plane godot_plane; +typedef struct godot_quat godot_quat; +typedef struct godot_rect3 godot_rect3; +typedef struct godot_basis godot_basis; +typedef struct godot_transform godot_transform; +typedef struct godot_color godot_color; +typedef struct godot_node_path godot_node_path; +typedef struct godot_rid godot_rid; +typedef struct godot_dictionary godot_dictionary; +typedef struct godot_array godot_array; +typedef struct godot_pool_byte_array godot_pool_byte_array; +typedef struct godot_pool_int_array godot_pool_int_array; +typedef struct godot_pool_real_array godot_pool_real_array; +typedef struct godot_pool_string_array godot_pool_string_array; +typedef struct godot_pool_vector2_array godot_pool_vector2_array; +typedef struct godot_pool_vector3_array godot_pool_vector3_array; +typedef struct godot_pool_color_array godot_pool_color_array; + /////// String #include "godot/godot_string.h" @@ -183,10 +208,6 @@ typedef void godot_object; #include "godot/godot_color.h" -/////// Image - -#include "godot/godot_image.h" - /////// NodePath #include "godot/godot_node_path.h" @@ -195,10 +216,6 @@ typedef void godot_object; #include "godot/godot_rid.h" -/////// InputEvent - -#include "godot/godot_input_event.h" - /////// Dictionary #include "godot/godot_dictionary.h" diff --git a/modules/gdnative/godot/godot_array.cpp b/modules/gdnative/godot/godot_array.cpp index 6c55c5d048..65353c5b0f 100644 --- a/modules/gdnative/godot/godot_array.cpp +++ b/modules/gdnative/godot/godot_array.cpp @@ -139,9 +139,13 @@ void GDAPI godot_array_set(godot_array *p_arr, const godot_int p_idx, const godo a->operator[](p_idx) = *val; } -godot_variant GDAPI *godot_array_get(godot_array *p_arr, const godot_int p_idx) { - Array *a = (Array *)p_arr; - return (godot_variant *)&a->operator[](p_idx); +godot_variant GDAPI godot_array_get(const godot_array *p_arr, const godot_int p_idx) { + godot_variant raw_dest; + Variant *dest = (Variant *)&raw_dest; + memnew_placement(dest, Variant); + const Array *a = (const Array *)p_arr; + *dest = a->operator[](p_idx); + return raw_dest; } void GDAPI godot_array_append(godot_array *p_arr, const godot_variant *p_value) { @@ -155,25 +159,25 @@ void GDAPI godot_array_clear(godot_array *p_arr) { a->clear(); } -godot_int GDAPI godot_array_count(godot_array *p_arr, const godot_variant *p_value) { - Array *a = (Array *)p_arr; - Variant *val = (Variant *)p_value; +godot_int GDAPI godot_array_count(const godot_array *p_arr, const godot_variant *p_value) { + const Array *a = (const Array *)p_arr; + const Variant *val = (const Variant *)p_value; return a->count(*val); } godot_bool GDAPI godot_array_empty(const godot_array *p_arr) { - Array *a = (Array *)p_arr; + const Array *a = (const Array *)p_arr; return a->empty(); } void GDAPI godot_array_erase(godot_array *p_arr, const godot_variant *p_value) { Array *a = (Array *)p_arr; - Variant *val = (Variant *)p_value; + const Variant *val = (const Variant *)p_value; a->erase(*val); } godot_variant GDAPI godot_array_front(const godot_array *p_arr) { - Array *a = (Array *)p_arr; + const Array *a = (const Array *)p_arr; godot_variant v; Variant *val = (Variant *)&v; memnew_placement(val, Variant); @@ -182,7 +186,7 @@ godot_variant GDAPI godot_array_front(const godot_array *p_arr) { } godot_variant GDAPI godot_array_back(const godot_array *p_arr) { - Array *a = (Array *)p_arr; + const Array *a = (const Array *)p_arr; godot_variant v; Variant *val = (Variant *)&v; memnew_placement(val, Variant); @@ -191,31 +195,31 @@ godot_variant GDAPI godot_array_back(const godot_array *p_arr) { } godot_int GDAPI godot_array_find(const godot_array *p_arr, const godot_variant *p_what, const godot_int p_from) { - Array *a = (Array *)p_arr; - Variant *val = (Variant *)p_what; + const Array *a = (const Array *)p_arr; + const Variant *val = (const Variant *)p_what; return a->find(*val, p_from); } godot_int GDAPI godot_array_find_last(const godot_array *p_arr, const godot_variant *p_what) { - Array *a = (Array *)p_arr; - Variant *val = (Variant *)p_what; + const Array *a = (const Array *)p_arr; + const Variant *val = (const Variant *)p_what; return a->find_last(*val); } godot_bool GDAPI godot_array_has(const godot_array *p_arr, const godot_variant *p_value) { - Array *a = (Array *)p_arr; - Variant *val = (Variant *)p_value; + const Array *a = (const Array *)p_arr; + const Variant *val = (const Variant *)p_value; return a->has(*val); } uint32_t GDAPI godot_array_hash(const godot_array *p_arr) { - Array *a = (Array *)p_arr; + const Array *a = (const Array *)p_arr; return a->hash(); } void GDAPI godot_array_insert(godot_array *p_arr, const godot_int p_pos, const godot_variant *p_value) { Array *a = (Array *)p_arr; - Variant *val = (Variant *)p_value; + const Variant *val = (const Variant *)p_value; a->insert(p_pos, *val); } @@ -224,11 +228,6 @@ void GDAPI godot_array_invert(godot_array *p_arr) { a->invert(); } -godot_bool GDAPI godot_array_is_shared(const godot_array *p_arr) { - Array *a = (Array *)p_arr; - return false; // @Todo how do I do it? -} - godot_variant GDAPI godot_array_pop_back(godot_array *p_arr) { Array *a = (Array *)p_arr; godot_variant v; @@ -249,13 +248,13 @@ godot_variant GDAPI godot_array_pop_front(godot_array *p_arr) { void GDAPI godot_array_push_back(godot_array *p_arr, const godot_variant *p_value) { Array *a = (Array *)p_arr; - Variant *val = (Variant *)p_value; + const Variant *val = (const Variant *)p_value; a->push_back(*val); } void GDAPI godot_array_push_front(godot_array *p_arr, const godot_variant *p_value) { Array *a = (Array *)p_arr; - Variant *val = (Variant *)p_value; + const Variant *val = (const Variant *)p_value; a->push_front(*val); } @@ -270,13 +269,13 @@ void GDAPI godot_array_resize(godot_array *p_arr, const godot_int p_size) { } godot_int GDAPI godot_array_rfind(const godot_array *p_arr, const godot_variant *p_what, const godot_int p_from) { - Array *a = (Array *)p_arr; - Variant *val = (Variant *)p_what; + const Array *a = (const Array *)p_arr; + const Variant *val = (const Variant *)p_what; return a->rfind(*val, p_from); } godot_int GDAPI godot_array_size(const godot_array *p_arr) { - Array *a = (Array *)p_arr; + const Array *a = (const Array *)p_arr; return a->size(); } @@ -287,7 +286,7 @@ void GDAPI godot_array_sort(godot_array *p_arr) { void GDAPI godot_array_sort_custom(godot_array *p_arr, godot_object *p_obj, const godot_string *p_func) { Array *a = (Array *)p_arr; - String *func = (String *)p_func; + const String *func = (const String *)p_func; a->sort_custom((Object *)p_obj, *func); } diff --git a/modules/gdnative/godot/godot_array.h b/modules/gdnative/godot/godot_array.h index b92ebb834f..29a76304d0 100644 --- a/modules/gdnative/godot/godot_array.h +++ b/modules/gdnative/godot/godot_array.h @@ -43,11 +43,11 @@ typedef struct godot_array { } godot_array; #endif -#include "../godot.h" - #include "godot_pool_arrays.h" #include "godot_variant.h" +#include "../godot.h" + void GDAPI godot_array_new(godot_array *p_arr); void GDAPI godot_array_new_pool_color_array(godot_array *p_arr, const godot_pool_color_array *p_pca); void GDAPI godot_array_new_pool_vector3_array(godot_array *p_arr, const godot_pool_vector3_array *p_pv3a); @@ -59,13 +59,13 @@ void GDAPI godot_array_new_pool_byte_array(godot_array *p_arr, const godot_pool_ void GDAPI godot_array_set(godot_array *p_arr, const godot_int p_idx, const godot_variant *p_value); -godot_variant GDAPI *godot_array_get(godot_array *p_arr, const godot_int p_idx); +godot_variant GDAPI godot_array_get(const godot_array *p_arr, const godot_int p_idx); void GDAPI godot_array_append(godot_array *p_arr, const godot_variant *p_value); void GDAPI godot_array_clear(godot_array *p_arr); -godot_int GDAPI godot_array_count(godot_array *p_arr, const godot_variant *p_value); +godot_int GDAPI godot_array_count(const godot_array *p_arr, const godot_variant *p_value); godot_bool GDAPI godot_array_empty(const godot_array *p_arr); @@ -87,8 +87,6 @@ void GDAPI godot_array_insert(godot_array *p_arr, const godot_int p_pos, const g void GDAPI godot_array_invert(godot_array *p_arr); -godot_bool GDAPI godot_array_is_shared(const godot_array *p_arr); - godot_variant GDAPI godot_array_pop_back(godot_array *p_arr); godot_variant GDAPI godot_array_pop_front(godot_array *p_arr); diff --git a/modules/gdnative/godot/godot_basis.cpp b/modules/gdnative/godot/godot_basis.cpp index 474cd3d448..46464932c5 100644 --- a/modules/gdnative/godot/godot_basis.cpp +++ b/modules/gdnative/godot/godot_basis.cpp @@ -28,188 +28,245 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "godot_basis.h" +#include "core/variant.h" -#include "math/matrix3.h" +#include "core/math/matrix3.h" #ifdef __cplusplus extern "C" { #endif -void _basis_api_anchor() { +void _basis_api_anchor() {} + +void GDAPI godot_basis_new_with_rows(godot_basis *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis) { + const Vector3 *x_axis = (const Vector3 *)p_x_axis; + const Vector3 *y_axis = (const Vector3 *)p_y_axis; + const Vector3 *z_axis = (const Vector3 *)p_z_axis; + Basis *dest = (Basis *)r_dest; + *dest = Basis(*x_axis, *y_axis, *z_axis); } -void GDAPI godot_basis_new(godot_basis *p_v) { - Basis *v = (Basis *)p_v; - *v = Basis(); +void GDAPI godot_basis_new_with_axis_and_angle(godot_basis *r_dest, const godot_vector3 *p_axis, const godot_real p_phi) { + const Vector3 *axis = (const Vector3 *)p_axis; + Basis *dest = (Basis *)r_dest; + *dest = Basis(*axis, p_phi); } -void GDAPI godot_basis_new_with_euler_quat(godot_basis *p_v, const godot_quat *p_euler) { - Basis *v = (Basis *)p_v; - Quat *euler = (Quat *)p_euler; - *v = Basis(*euler); +void GDAPI godot_basis_new_with_euler(godot_basis *r_dest, const godot_vector3 *p_euler) { + const Vector3 *euler = (const Vector3 *)p_euler; + Basis *dest = (Basis *)r_dest; + *dest = Basis(*euler); } -void GDAPI godot_basis_new_with_euler(godot_basis *p_v, const godot_vector3 p_euler) { - Basis *v = (Basis *)p_v; - Vector3 *euler = (Vector3 *)&p_euler; - *v = Basis(*euler); +godot_string GDAPI godot_basis_as_string(const godot_basis *p_self) { + godot_string ret; + const Basis *self = (const Basis *)p_self; + memnew_placement(&ret, String(*self)); + return ret; } -void GDAPI godot_basis_new_with_axis_and_angle(godot_basis *p_v, const godot_vector3 p_axis, const godot_real p_phi) { - Basis *v = (Basis *)p_v; - const Vector3 *axis = (Vector3 *)&p_axis; - *v = Basis(*axis, p_phi); +godot_basis GDAPI godot_basis_inverse(const godot_basis *p_self) { + godot_basis dest; + const Basis *self = (const Basis *)p_self; + *((Basis *)&dest) = self->inverse(); + return dest; } -void GDAPI godot_basis_new_with_rows(godot_basis *p_v, const godot_vector3 p_row0, const godot_vector3 p_row1, const godot_vector3 p_row2) { - Basis *v = (Basis *)p_v; - const Vector3 *row0 = (Vector3 *)&p_row0; - const Vector3 *row1 = (Vector3 *)&p_row1; - const Vector3 *row2 = (Vector3 *)&p_row2; - *v = Basis(*row0, *row1, *row2); +godot_basis GDAPI godot_basis_transposed(const godot_basis *p_self) { + godot_basis dest; + const Basis *self = (const Basis *)p_self; + *((Basis *)&dest) = self->transposed(); + return dest; } -godot_quat GDAPI godot_basis_as_quat(const godot_basis *p_v) { - const Basis *v = (const Basis *)p_v; - godot_quat quat; - Quat *p_quat = (Quat *)&quat; - *p_quat = v->operator Quat(); - return quat; +godot_basis GDAPI godot_basis_orthonormalized(const godot_basis *p_self) { + godot_basis dest; + const Basis *self = (const Basis *)p_self; + *((Basis *)&dest) = self->orthonormalized(); + return dest; } -/* - * p_elements is a pointer to an array of 3 (!!) vector3 - */ -void GDAPI godot_basis_get_elements(godot_basis *p_v, godot_vector3 *p_elements) { - Basis *v = (Basis *)p_v; - Vector3 *elements = (Vector3 *)p_elements; - elements[0] = v->elements[0]; - elements[1] = v->elements[1]; - elements[2] = v->elements[2]; +godot_real GDAPI godot_basis_determinant(const godot_basis *p_self) { + const Basis *self = (const Basis *)p_self; + return self->determinant(); } -godot_vector3 GDAPI godot_basis_get_axis(const godot_basis *p_v, const godot_int p_axis) { - godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Basis *v = (Basis *)p_v; - *d = v->get_axis(p_axis); +godot_basis GDAPI godot_basis_rotated(const godot_basis *p_self, const godot_vector3 *p_axis, const godot_real p_phi) { + godot_basis dest; + const Basis *self = (const Basis *)p_self; + const Vector3 *axis = (const Vector3 *)p_axis; + *((Basis *)&dest) = self->rotated(*axis, p_phi); return dest; } -void GDAPI godot_basis_set_axis(godot_basis *p_v, const godot_int p_axis, const godot_vector3 p_value) { - Basis *v = (Basis *)p_v; - const Vector3 *value = (Vector3 *)&p_value; - v->set_axis(p_axis, *value); +godot_basis GDAPI godot_basis_scaled(const godot_basis *p_self, const godot_vector3 *p_scale) { + godot_basis dest; + const Basis *self = (const Basis *)p_self; + const Vector3 *scale = (const Vector3 *)p_scale; + *((Basis *)&dest) = self->scaled(*scale); + return dest; } -godot_vector3 GDAPI godot_basis_get_row(const godot_basis *p_v, const godot_int p_row) { - godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Basis *v = (Basis *)p_v; - *d = v->get_row(p_row); - return dest; +void GDAPI godot_basis_set_scale(godot_basis *p_self, const godot_vector3 *p_scale) { + Basis *self = (Basis *)p_self; + const Vector3 *scale = (const Vector3 *)p_scale; + self->set_scale(*scale); } -void GDAPI godot_basis_set_row(godot_basis *p_v, const godot_int p_row, const godot_vector3 p_value) { - Basis *v = (Basis *)p_v; - const Vector3 *value = (Vector3 *)&p_value; - v->set_row(p_row, *value); +void GDAPI godot_basis_set_rotation_euler(godot_basis *p_self, const godot_vector3 *p_euler) { + Basis *self = (Basis *)p_self; + const Vector3 *euler = (const Vector3 *)p_euler; + self->set_rotation_euler(*euler); } -godot_real godot_basis_determinant(const godot_basis *p_v) { - Basis *v = (Basis *)p_v; - return v->determinant(); +void GDAPI godot_basis_set_rotation_axis_angle(godot_basis *p_self, const godot_vector3 *p_axis, const godot_real p_angle) { + Basis *self = (Basis *)p_self; + const Vector3 *axis = (const Vector3 *)p_axis; + self->set_rotation_axis_angle(*axis, p_angle); } -godot_vector3 godot_basis_get_euler(const godot_basis *p_v) { +godot_vector3 GDAPI godot_basis_get_scale(const godot_basis *p_self) { godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Basis *v = (Basis *)p_v; - *d = v->get_euler(); + const Basis *self = (const Basis *)p_self; + *((Vector3 *)&dest) = self->get_scale(); return dest; } -godot_int godot_basis_get_orthogonal_index(const godot_basis *p_v) { - const Basis *v = (Basis *)p_v; - return v->get_orthogonal_index(); -} - -godot_vector3 godot_basis_get_scale(const godot_basis *p_v) { +godot_vector3 GDAPI godot_basis_get_euler(const godot_basis *p_self) { godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Basis *v = (Basis *)p_v; - *d = v->get_scale(); + const Basis *self = (const Basis *)p_self; + *((Vector3 *)&dest) = self->get_euler(); return dest; } -void godot_basis_inverse(godot_basis *p_dest, const godot_basis *p_v) { - Basis *d = (Basis *)p_dest; - const Basis *v = (Basis *)p_v; - *d = v->inverse(); +godot_real GDAPI godot_basis_tdotx(const godot_basis *p_self, const godot_vector3 *p_with) { + const Basis *self = (const Basis *)p_self; + const Vector3 *with = (const Vector3 *)p_with; + return self->tdotx(*with); +} + +godot_real GDAPI godot_basis_tdoty(const godot_basis *p_self, const godot_vector3 *p_with) { + const Basis *self = (const Basis *)p_self; + const Vector3 *with = (const Vector3 *)p_with; + return self->tdoty(*with); } -void godot_basis_orthonormalized(godot_basis *p_dest, const godot_basis *p_v) { - Basis *d = (Basis *)p_dest; - const Basis *v = (Basis *)p_v; - *d = v->orthonormalized(); +godot_real GDAPI godot_basis_tdotz(const godot_basis *p_self, const godot_vector3 *p_with) { + const Basis *self = (const Basis *)p_self; + const Vector3 *with = (const Vector3 *)p_with; + return self->tdotz(*with); } -void godot_basis_rotated(godot_basis *p_dest, const godot_basis *p_v, const godot_vector3 p_axis, const godot_real p_phi) { - Basis *d = (Basis *)p_dest; - const Basis *v = (Basis *)p_v; - const Vector3 *axis = (Vector3 *)&p_axis; - *d = v->rotated(*axis, p_phi); +godot_vector3 GDAPI godot_basis_xform(const godot_basis *p_self, const godot_vector3 *p_v) { + godot_vector3 dest; + const Basis *self = (const Basis *)p_self; + const Vector3 *v = (const Vector3 *)p_v; + *((Vector3 *)&dest) = self->xform(*v); + return dest; } -void godot_basis_scaled(godot_basis *p_dest, const godot_basis *p_v, const godot_vector3 p_scale) { - Basis *d = (Basis *)p_dest; - const Basis *v = (Basis *)p_v; - const Vector3 *scale = (Vector3 *)&p_scale; - *d = v->scaled(*scale); +godot_vector3 GDAPI godot_basis_xform_inv(const godot_basis *p_self, const godot_vector3 *p_v) { + godot_vector3 dest; + const Basis *self = (const Basis *)p_self; + const Vector3 *v = (const Vector3 *)p_v; + *((Vector3 *)&dest) = self->xform_inv(*v); + return dest; } -godot_real godot_basis_tdotx(const godot_basis *p_v, const godot_vector3 p_with) { - const Basis *v = (Basis *)p_v; - const Vector3 *with = (Vector3 *)&p_with; - return v->tdotx(*with); +godot_int GDAPI godot_basis_get_orthogonal_index(const godot_basis *p_self) { + const Basis *self = (const Basis *)p_self; + return self->get_orthogonal_index(); } -godot_real godot_basis_tdoty(const godot_basis *p_v, const godot_vector3 p_with) { - const Basis *v = (Basis *)p_v; - const Vector3 *with = (Vector3 *)&p_with; - return v->tdoty(*with); +void GDAPI godot_basis_new(godot_basis *r_dest) { + Basis *dest = (Basis *)r_dest; + *dest = Basis(); } -godot_real godot_basis_tdotz(const godot_basis *p_v, const godot_vector3 p_with) { - const Basis *v = (Basis *)p_v; - const Vector3 *with = (Vector3 *)&p_with; - return v->tdotz(*with); +void GDAPI godot_basis_new_with_euler_quat(godot_basis *r_dest, const godot_quat *p_euler) { + Basis *dest = (Basis *)r_dest; + const Quat *euler = (const Quat *)p_euler; + *dest = Basis(*euler); } -void godot_basis_transposed(godot_basis *p_dest, const godot_basis *p_v) { - Basis *d = (Basis *)p_dest; - const Basis *v = (Basis *)p_v; - *d = v->transposed(); +// p_elements is a pointer to an array of 3 (!!) vector3 +void GDAPI godot_basis_get_elements(godot_basis *p_self, godot_vector3 *p_elements) { + const Basis *self = (const Basis *)p_self; + Vector3 *elements = (Vector3 *)p_elements; + elements[0] = self->elements[0]; + elements[1] = self->elements[1]; + elements[2] = self->elements[2]; } -godot_vector3 godot_basis_xform(const godot_basis *p_v, const godot_vector3 p_vect) { +godot_vector3 GDAPI godot_basis_get_axis(const godot_basis *p_self, const godot_int p_axis) { godot_vector3 dest; Vector3 *d = (Vector3 *)&dest; - const Basis *v = (Basis *)p_v; - const Vector3 *vect = (Vector3 *)&p_vect; - *d = v->xform(*vect); + const Basis *self = (const Basis *)p_self; + *d = self->get_axis(p_axis); return dest; } -godot_vector3 godot_basis_xform_inv(const godot_basis *p_v, const godot_vector3 p_vect) { +void GDAPI godot_basis_set_axis(godot_basis *p_self, const godot_int p_axis, const godot_vector3 *p_value) { + Basis *self = (Basis *)p_self; + const Vector3 *value = (const Vector3 *)p_value; + self->set_axis(p_axis, *value); +} + +godot_vector3 GDAPI godot_basis_get_row(const godot_basis *p_self, const godot_int p_row) { godot_vector3 dest; Vector3 *d = (Vector3 *)&dest; - const Basis *v = (Basis *)p_v; - const Vector3 *vect = (Vector3 *)&p_vect; - *d = v->xform_inv(*vect); + const Basis *self = (const Basis *)p_self; + *d = self->get_row(p_row); return dest; } +void GDAPI godot_basis_set_row(godot_basis *p_self, const godot_int p_row, const godot_vector3 *p_value) { + Basis *self = (Basis *)p_self; + const Vector3 *value = (const Vector3 *)p_value; + self->set_row(p_row, *value); +} + +godot_bool GDAPI godot_basis_operator_equal(const godot_basis *p_self, const godot_basis *p_b) { + const Basis *self = (const Basis *)p_self; + const Basis *b = (const Basis *)p_b; + return *self == *b; +} + +godot_basis GDAPI godot_basis_operator_add(const godot_basis *p_self, const godot_basis *p_b) { + godot_basis raw_dest; + Basis *dest = (Basis *)&raw_dest; + const Basis *self = (const Basis *)p_self; + const Basis *b = (const Basis *)p_b; + *dest = *self + *b; + return raw_dest; +} + +godot_basis GDAPI godot_basis_operator_substract(const godot_basis *p_self, const godot_basis *p_b) { + godot_basis raw_dest; + Basis *dest = (Basis *)&raw_dest; + const Basis *self = (const Basis *)p_self; + const Basis *b = (const Basis *)p_b; + *dest = *self - *b; + return raw_dest; +} + +godot_basis GDAPI godot_basis_operator_multiply_vector(const godot_basis *p_self, const godot_basis *p_b) { + godot_basis raw_dest; + Basis *dest = (Basis *)&raw_dest; + const Basis *self = (const Basis *)p_self; + const Basis *b = (const Basis *)p_b; + *dest = *self * *b; + return raw_dest; +} + +godot_basis GDAPI godot_basis_operator_multiply_scalar(const godot_basis *p_self, const godot_real p_b) { + godot_basis raw_dest; + Basis *dest = (Basis *)&raw_dest; + const Basis *self = (const Basis *)p_self; + *dest = *self * p_b; + return raw_dest; +} + #ifdef __cplusplus } #endif diff --git a/modules/gdnative/godot/godot_basis.h b/modules/gdnative/godot/godot_basis.h index 2803396997..a096a8cc08 100644 --- a/modules/gdnative/godot/godot_basis.h +++ b/modules/gdnative/godot/godot_basis.h @@ -37,45 +37,79 @@ extern "C" { #include <stdint.h> #ifndef GODOT_CORE_API_GODOT_BASIS_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_BASIS_TYPE_DEFINED typedef struct godot_basis { uint8_t _dont_touch_that[36]; } godot_basis; #endif #include "../godot.h" -#include "godot_quat.h" - -void GDAPI godot_basis_new(godot_basis *p_v); -void GDAPI godot_basis_new_with_euler_quat(godot_basis *p_v, const godot_quat *p_euler); -void GDAPI godot_basis_new_with_euler(godot_basis *p_v, const godot_vector3 p_euler); -void GDAPI godot_basis_new_with_axis_and_angle(godot_basis *p_v, const godot_vector3 p_axis, const godot_real p_phi); -void GDAPI godot_basis_new_with_rows(godot_basis *p_v, const godot_vector3 p_row0, const godot_vector3 p_row1, const godot_vector3 p_row2); - -godot_quat GDAPI godot_basis_as_quat(const godot_basis *p_v); - -/* - * p_elements is a pointer to an array of 3 (!!) vector3 - */ -void GDAPI godot_basis_get_elements(godot_basis *p_v, godot_vector3 *p_elements); -godot_vector3 GDAPI godot_basis_get_axis(const godot_basis *p_v, const godot_int p_axis); -void GDAPI godot_basis_set_axis(godot_basis *p_v, const godot_int p_axis, const godot_vector3 p_value); -godot_vector3 GDAPI godot_basis_get_row(const godot_basis *p_v, const godot_int p_row); -void GDAPI godot_basis_set_row(godot_basis *p_v, const godot_int p_row, const godot_vector3 p_value); - -godot_real godot_basis_determinant(const godot_basis *p_v); -godot_vector3 godot_basis_get_euler(const godot_basis *p_v); -godot_int godot_basis_get_orthogonal_index(const godot_basis *p_v); -godot_vector3 godot_basis_get_scale(const godot_basis *p_v); -void godot_basis_inverse(godot_basis *p_dest, const godot_basis *p_v); -void godot_basis_orthonormalized(godot_basis *p_dest, const godot_basis *p_v); -void godot_basis_rotated(godot_basis *p_dest, const godot_basis *p_v, const godot_vector3 p_axis, const godot_real p_phi); -void godot_basis_scaled(godot_basis *p_dest, const godot_basis *p_v, const godot_vector3 p_scale); -godot_real godot_basis_tdotx(const godot_basis *p_v, const godot_vector3 p_with); -godot_real godot_basis_tdoty(const godot_basis *p_v, const godot_vector3 p_with); -godot_real godot_basis_tdotz(const godot_basis *p_v, const godot_vector3 p_with); -void godot_basis_transposed(godot_basis *p_dest, const godot_basis *p_v); -godot_vector3 godot_basis_xform(const godot_basis *p_v, const godot_vector3 p_vect); -godot_vector3 godot_basis_xform_inv(const godot_basis *p_v, const godot_vector3 p_vect); +#include "godot_vector3.h" + +void GDAPI godot_basis_new_with_rows(godot_basis *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis); +void GDAPI godot_basis_new_with_axis_and_angle(godot_basis *r_dest, const godot_vector3 *p_axis, const godot_real p_phi); +void GDAPI godot_basis_new_with_euler(godot_basis *r_dest, const godot_vector3 *p_euler); + +godot_string GDAPI godot_basis_as_string(const godot_basis *p_self); + +godot_basis GDAPI godot_basis_inverse(const godot_basis *p_self); + +godot_basis GDAPI godot_basis_transposed(const godot_basis *p_self); + +godot_basis GDAPI godot_basis_orthonormalized(const godot_basis *p_self); + +godot_real GDAPI godot_basis_determinant(const godot_basis *p_self); + +godot_basis GDAPI godot_basis_rotated(const godot_basis *p_self, const godot_vector3 *p_axis, const godot_real p_phi); + +godot_basis GDAPI godot_basis_scaled(const godot_basis *p_self, const godot_vector3 *p_scale); + +void GDAPI godot_basis_set_scale(godot_basis *p_self, const godot_vector3 *p_scale); + +void GDAPI godot_basis_set_rotation_euler(godot_basis *p_self, const godot_vector3 *p_euler); + +void GDAPI godot_basis_set_rotation_axis_angle(godot_basis *p_self, const godot_vector3 *p_axis, const godot_real p_angle); + +godot_vector3 GDAPI godot_basis_get_scale(const godot_basis *p_self); + +godot_vector3 GDAPI godot_basis_get_euler(const godot_basis *p_self); + +godot_real GDAPI godot_basis_tdotx(const godot_basis *p_self, const godot_vector3 *p_with); + +godot_real GDAPI godot_basis_tdoty(const godot_basis *p_self, const godot_vector3 *p_with); + +godot_real GDAPI godot_basis_tdotz(const godot_basis *p_self, const godot_vector3 *p_with); + +godot_vector3 GDAPI godot_basis_xform(const godot_basis *p_self, const godot_vector3 *p_v); + +godot_vector3 GDAPI godot_basis_xform_inv(const godot_basis *p_self, const godot_vector3 *p_v); + +godot_int GDAPI godot_basis_get_orthogonal_index(const godot_basis *p_self); + +void GDAPI godot_basis_new(godot_basis *r_dest); + +void GDAPI godot_basis_new_with_euler_quat(godot_basis *r_dest, const godot_quat *p_euler); + +// p_elements is a pointer to an array of 3 (!!) vector3 +void GDAPI godot_basis_get_elements(godot_basis *p_self, godot_vector3 *p_elements); + +godot_vector3 GDAPI godot_basis_get_axis(const godot_basis *p_self, const godot_int p_axis); + +void GDAPI godot_basis_set_axis(godot_basis *p_self, const godot_int p_axis, const godot_vector3 *p_value); + +godot_vector3 GDAPI godot_basis_get_row(const godot_basis *p_self, const godot_int p_row); + +void GDAPI godot_basis_set_row(godot_basis *p_self, const godot_int p_row, const godot_vector3 *p_value); + +godot_bool GDAPI godot_basis_operator_equal(const godot_basis *p_self, const godot_basis *p_b); + +godot_basis GDAPI godot_basis_operator_add(const godot_basis *p_self, const godot_basis *p_b); + +godot_basis GDAPI godot_basis_operator_substract(const godot_basis *p_self, const godot_basis *p_b); + +godot_basis GDAPI godot_basis_operator_multiply_vector(const godot_basis *p_self, const godot_basis *p_b); + +godot_basis GDAPI godot_basis_operator_multiply_scalar(const godot_basis *p_self, const godot_real p_b); #ifdef __cplusplus } diff --git a/modules/gdnative/godot/godot_color.cpp b/modules/gdnative/godot/godot_color.cpp index 203ce672fa..0417a828ab 100644 --- a/modules/gdnative/godot/godot_color.cpp +++ b/modules/gdnative/godot/godot_color.cpp @@ -28,34 +28,98 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "godot_color.h" +#include "core/variant.h" -#include "color.h" +#include "core/color.h" #ifdef __cplusplus extern "C" { #endif -void _color_api_anchor() { +void _color_api_anchor() {} + +void GDAPI godot_color_new_rgba(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b, const godot_real p_a) { + + Color *dest = (Color *)r_dest; + *dest = Color(p_r, p_g, p_b, p_a); +} + +void GDAPI godot_color_new_rgb(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b) { + + Color *dest = (Color *)r_dest; + *dest = Color(p_r, p_g, p_b); +} + +godot_string GDAPI godot_color_as_string(const godot_color *p_self) { + godot_string ret; + const Color *self = (const Color *)p_self; + memnew_placement(&ret, String(*self)); + return ret; +} + +godot_int GDAPI godot_color_to_32(const godot_color *p_self) { + const Color *self = (const Color *)p_self; + return self->to_32(); +} + +godot_int GDAPI godot_color_to_ARGB32(const godot_color *p_self) { + const Color *self = (const Color *)p_self; + return self->to_ARGB32(); +} + +godot_real GDAPI godot_color_gray(const godot_color *p_self) { + const Color *self = (const Color *)p_self; + return self->gray(); +} + +godot_color GDAPI godot_color_inverted(const godot_color *p_self) { + godot_color dest; + const Color *self = (const Color *)p_self; + *((Color *)&dest) = self->inverted(); + return dest; } -void GDAPI godot_color_new(godot_color *p_color) { - Color *color = (Color *)p_color; - *color = Color(); +godot_color GDAPI godot_color_contrasted(const godot_color *p_self) { + godot_color dest; + const Color *self = (const Color *)p_self; + *((Color *)&dest) = self->contrasted(); + return dest; } -void GDAPI godot_color_new_rgba(godot_color *p_color, const godot_real r, const godot_real g, const godot_real b, const godot_real a) { - Color *color = (Color *)p_color; - *color = Color(r, g, b, a); +godot_color GDAPI godot_color_linear_interpolate(const godot_color *p_self, const godot_color *p_b, const godot_real p_t) { + godot_color dest; + const Color *self = (const Color *)p_self; + const Color *b = (const Color *)p_b; + *((Color *)&dest) = self->linear_interpolate(*b, p_t); + return dest; +} + +godot_color GDAPI godot_color_blend(const godot_color *p_self, const godot_color *p_over) { + godot_color dest; + const Color *self = (const Color *)p_self; + const Color *over = (const Color *)p_over; + *((Color *)&dest) = self->blend(*over); + return dest; +} + +godot_string GDAPI godot_color_to_html(const godot_color *p_self, const godot_bool p_with_alpha) { + godot_string dest; + const Color *self = (const Color *)p_self; + + *((String *)&dest) = self->to_html(p_with_alpha); + return dest; } -uint32_t GDAPI godot_color_get_32(const godot_color *p_color) { - const Color *color = (const Color *)p_color; - return color->to_32(); +godot_bool GDAPI godot_color_operator_equal(const godot_color *p_self, const godot_color *p_b) { + const Color *self = (const Color *)p_self; + const Color *b = (const Color *)p_b; + return *self == *b; } -float GDAPI *godot_color_index(godot_color *p_color, const godot_int idx) { - Color *color = (Color *)p_color; - return &color->operator[](idx); +godot_bool GDAPI godot_color_operator_less(const godot_color *p_self, const godot_color *p_b) { + const Color *self = (const Color *)p_self; + const Color *b = (const Color *)p_b; + return *self < *b; } #ifdef __cplusplus diff --git a/modules/gdnative/godot/godot_color.h b/modules/gdnative/godot/godot_color.h index b99a062a66..8588c997ea 100644 --- a/modules/gdnative/godot/godot_color.h +++ b/modules/gdnative/godot/godot_color.h @@ -37,19 +37,39 @@ extern "C" { #include <stdint.h> #ifndef GODOT_CORE_API_GODOT_COLOR_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_COLOR_TYPE_DEFINED typedef struct godot_color { uint8_t _dont_touch_that[16]; } godot_color; #endif #include "../godot.h" +#include "godot_string.h" -void GDAPI godot_color_new(godot_color *p_color); -void GDAPI godot_color_new_rgba(godot_color *p_color, const godot_real r, const godot_real g, const godot_real b, const godot_real a); +void GDAPI godot_color_new_rgba(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b, const godot_real p_a); +void GDAPI godot_color_new_rgb(godot_color *r_dest, const godot_real p_r, const godot_real p_g, const godot_real p_b); -uint32_t GDAPI godot_color_get_32(const godot_color *p_color); +godot_string GDAPI godot_color_as_string(const godot_color *p_self); -float GDAPI *godot_color_index(godot_color *p_color, const godot_int idx); +godot_int GDAPI godot_color_to_32(const godot_color *p_self); + +godot_int GDAPI godot_color_to_ARGB32(const godot_color *p_self); + +godot_real GDAPI godot_color_gray(const godot_color *p_self); + +godot_color GDAPI godot_color_inverted(const godot_color *p_self); + +godot_color GDAPI godot_color_contrasted(const godot_color *p_self); + +godot_color GDAPI godot_color_linear_interpolate(const godot_color *p_self, const godot_color *p_b, const godot_real p_t); + +godot_color GDAPI godot_color_blend(const godot_color *p_self, const godot_color *p_over); + +godot_string GDAPI godot_color_to_html(const godot_color *p_self, const godot_bool p_with_alpha); + +godot_bool GDAPI godot_color_operator_equal(const godot_color *p_self, const godot_color *p_b); + +godot_bool GDAPI godot_color_operator_less(const godot_color *p_self, const godot_color *p_b); #ifdef __cplusplus } diff --git a/modules/gdnative/godot/godot_dictionary.cpp b/modules/gdnative/godot/godot_dictionary.cpp index 16d08e58e2..dda245e59e 100644 --- a/modules/gdnative/godot/godot_dictionary.cpp +++ b/modules/gdnative/godot/godot_dictionary.cpp @@ -28,109 +28,100 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "godot_dictionary.h" +#include "core/variant.h" #include "core/dictionary.h" - -#include "core/os/memory.h" - #include "core/io/json.h" #ifdef __cplusplus extern "C" { #endif -void _dictionary_api_anchor() { +void _dictionary_api_anchor() {} + +void GDAPI godot_dictionary_new(godot_dictionary *r_dest) { + Dictionary *dest = (Dictionary *)r_dest; + memnew_placement(dest, Dictionary); } -void GDAPI godot_dictionary_new(godot_dictionary *p_dict) { - Dictionary *dict = (Dictionary *)p_dict; - memnew_placement(dict, Dictionary); +void GDAPI godot_dictionary_destroy(godot_dictionary *p_self) { + Dictionary *self = (Dictionary *)p_self; + self->~Dictionary(); } -void GDAPI godot_dictionary_clear(godot_dictionary *p_dict) { - Dictionary *dict = (Dictionary *)p_dict; - dict->clear(); +godot_int GDAPI godot_dictionary_size(const godot_dictionary *p_self) { + const Dictionary *self = (const Dictionary *)p_self; + return self->size(); } -godot_bool GDAPI godot_dictionary_empty(const godot_dictionary *p_dict) { - const Dictionary *dict = (const Dictionary *)p_dict; - return dict->empty(); +godot_bool GDAPI godot_dictionary_empty(const godot_dictionary *p_self) { + const Dictionary *self = (const Dictionary *)p_self; + return self->empty(); } -void GDAPI godot_dictionary_erase(godot_dictionary *p_dict, const godot_variant *p_key) { - Dictionary *dict = (Dictionary *)p_dict; - Variant *key = (Variant *)p_key; - dict->erase(*key); +void GDAPI godot_dictionary_clear(godot_dictionary *p_self) { + Dictionary *self = (Dictionary *)p_self; + self->clear(); } -godot_bool GDAPI godot_dictionary_has(const godot_dictionary *p_dict, const godot_variant *p_key) { - const Dictionary *dict = (const Dictionary *)p_dict; +godot_bool GDAPI godot_dictionary_has(const godot_dictionary *p_self, const godot_variant *p_key) { + const Dictionary *self = (const Dictionary *)p_self; const Variant *key = (const Variant *)p_key; - return dict->has(*key); + return self->has(*key); } -godot_bool GDAPI godot_dictionary_has_all(const godot_dictionary *p_dict, const godot_array *p_keys) { - const Dictionary *dict = (const Dictionary *)p_dict; +godot_bool GDAPI godot_dictionary_has_all(const godot_dictionary *p_self, const godot_array *p_keys) { + const Dictionary *self = (const Dictionary *)p_self; const Array *keys = (const Array *)p_keys; - return dict->has_all(*keys); + return self->has_all(*keys); } -uint32_t GDAPI godot_dictionary_hash(const godot_dictionary *p_dict) { - const Dictionary *dict = (const Dictionary *)p_dict; - return dict->hash(); +void GDAPI godot_dictionary_erase(godot_dictionary *p_self, const godot_variant *p_key) { + Dictionary *self = (Dictionary *)p_self; + const Variant *key = (const Variant *)p_key; + self->erase(*key); } -godot_array GDAPI godot_dictionary_keys(const godot_dictionary *p_dict) { - godot_array a; - godot_array_new(&a); - const Dictionary *dict = (const Dictionary *)p_dict; - Array *array = (Array *)&a; - *array = dict->keys(); - return a; +godot_int GDAPI godot_dictionary_hash(const godot_dictionary *p_self) { + const Dictionary *self = (const Dictionary *)p_self; + return self->hash(); } -godot_int GDAPI godot_dictionary_parse_json(godot_dictionary *p_dict, const godot_string *p_json) { - Dictionary *dict = (Dictionary *)p_dict; - const String *json = (const String *)p_json; - Variant ret; - int err_line; - String err_str; - int err = (int)JSON::parse(*json, ret, err_str, err_line); - *dict = ret; - return err; +godot_array GDAPI godot_dictionary_keys(const godot_dictionary *p_self) { + godot_array dest; + const Dictionary *self = (const Dictionary *)p_self; + memnew_placement(&dest, Array(self->keys())); + return dest; } -godot_variant GDAPI *godot_dictionary_operator_index(godot_dictionary *p_dict, const godot_variant *p_key) { - Dictionary *dict = (Dictionary *)p_dict; - Variant *key = (Variant *)p_key; - return (godot_variant *)&dict->operator[](*key); +godot_array GDAPI godot_dictionary_values(const godot_dictionary *p_self) { + godot_array dest; + const Dictionary *self = (const Dictionary *)p_self; + memnew_placement(&dest, Array(self->values())); + return dest; } -godot_int GDAPI godot_dictionary_size(const godot_dictionary *p_dict) { +godot_variant GDAPI godot_dictionary_operator_index(godot_dictionary *p_dict, const godot_variant *p_key) { + godot_variant raw_dest; + Variant *dest = (Variant *)&raw_dest; const Dictionary *dict = (const Dictionary *)p_dict; - return dict->size(); + const Variant *key = (const Variant *)p_key; + *dest = dict->operator[](*key); + return raw_dest; } -godot_string GDAPI godot_dictionary_to_json(const godot_dictionary *p_dict) { - const Dictionary *dict = (const Dictionary *)p_dict; - godot_string str; - godot_string_new(&str); - String *s = (String *)&str; - *s = JSON::print(Variant(*dict)); - return str; +godot_bool GDAPI godot_dictionary_operator_equal(const godot_dictionary *p_self, const godot_dictionary *p_b) { + const Dictionary *self = (const Dictionary *)p_self; + const Dictionary *b = (const Dictionary *)p_b; + return *self == *b; } -godot_array GDAPI godot_dictionary_values(const godot_dictionary *p_dict) { - godot_array a; - godot_array_new(&a); +godot_string GDAPI godot_dictionary_to_json(const godot_dictionary *p_dict) { + godot_string raw_dest; + String *dest = (String *)&raw_dest; const Dictionary *dict = (const Dictionary *)p_dict; - Array *array = (Array *)&a; - *array = dict->values(); - return a; -} - -void GDAPI godot_dictionary_destroy(godot_dictionary *p_dict) { - ((Dictionary *)p_dict)->~Dictionary(); + memnew_placement(dest, String(JSON::print(Variant(*dict)))); + return raw_dest; } #ifdef __cplusplus diff --git a/modules/gdnative/godot/godot_dictionary.h b/modules/gdnative/godot/godot_dictionary.h index 3f7c504880..9f6de77aac 100644 --- a/modules/gdnative/godot/godot_dictionary.h +++ b/modules/gdnative/godot/godot_dictionary.h @@ -36,42 +36,43 @@ extern "C" { #include <stdint.h> -#ifndef GODOT_CORE_API_GODOT_DICITIONARY_TYPE_DEFINED +#ifndef GODOT_CORE_API_GODOT_DICTIONARY_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_DICTIONARY_TYPE_DEFINED typedef struct godot_dictionary { uint8_t _dont_touch_that[8]; } godot_dictionary; #endif +#include "../godot.h" #include "godot_array.h" #include "godot_variant.h" -void GDAPI godot_dictionary_new(godot_dictionary *p_dict); +void GDAPI godot_dictionary_new(godot_dictionary *r_dest); +void GDAPI godot_dictionary_destroy(godot_dictionary *p_self); -void GDAPI godot_dictionary_clear(godot_dictionary *p_dict); +godot_int GDAPI godot_dictionary_size(const godot_dictionary *p_self); -godot_bool GDAPI godot_dictionary_empty(const godot_dictionary *p_dict); +godot_bool GDAPI godot_dictionary_empty(const godot_dictionary *p_self); -void GDAPI godot_dictionary_erase(godot_dictionary *p_dict, const godot_variant *p_key); +void GDAPI godot_dictionary_clear(godot_dictionary *p_self); -godot_bool GDAPI godot_dictionary_has(const godot_dictionary *p_dict, const godot_variant *p_key); +godot_bool GDAPI godot_dictionary_has(const godot_dictionary *p_self, const godot_variant *p_key); -godot_bool GDAPI godot_dictionary_has_all(const godot_dictionary *p_dict, const godot_array *p_keys); +godot_bool GDAPI godot_dictionary_has_all(const godot_dictionary *p_self, const godot_array *p_keys); -uint32_t GDAPI godot_dictionary_hash(const godot_dictionary *p_dict); +void GDAPI godot_dictionary_erase(godot_dictionary *p_self, const godot_variant *p_key); -godot_array GDAPI godot_dictionary_keys(const godot_dictionary *p_dict); +godot_int GDAPI godot_dictionary_hash(const godot_dictionary *p_self); -godot_int GDAPI godot_dictionary_parse_json(godot_dictionary *p_dict, const godot_string *p_json); +godot_array GDAPI godot_dictionary_keys(const godot_dictionary *p_self); -godot_variant GDAPI *godot_dictionary_operator_index(godot_dictionary *p_dict, const godot_variant *p_key); +godot_array GDAPI godot_dictionary_values(const godot_dictionary *p_self); -godot_int GDAPI godot_dictionary_size(const godot_dictionary *p_dict); +godot_variant GDAPI godot_dictionary_operator_index(godot_dictionary *p_dict, const godot_variant *p_key); -godot_string GDAPI godot_dictionary_to_json(const godot_dictionary *p_dict); - -godot_array GDAPI godot_dictionary_values(const godot_dictionary *p_dict); +godot_bool GDAPI godot_dictionary_operator_equal(const godot_dictionary *p_self, const godot_dictionary *p_b); -void GDAPI godot_dictionary_destroy(godot_dictionary *p_dict); +godot_string GDAPI godot_dictionary_to_json(const godot_dictionary *p_dict); #ifdef __cplusplus } diff --git a/modules/gdnative/godot/godot_image.cpp b/modules/gdnative/godot/godot_image.cpp deleted file mode 100644 index ae8290afc2..0000000000 --- a/modules/gdnative/godot/godot_image.cpp +++ /dev/null @@ -1,114 +0,0 @@ -/*************************************************************************/ -/* godot_image.cpp */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#include "godot_image.h" - -#include "image.h" - -#ifdef __cplusplus -extern "C" { -#endif - -void _image_api_anchor() { -} - -#define memnew_placement_custom(m_placement, m_class, m_constr) _post_initialize(new (m_placement, sizeof(m_class), "") m_constr) - -void GDAPI godot_image_new(godot_image *p_img) { - Image *img = (Image *)p_img; - memnew_placement_custom(img, Image, Image()); -} - -void GDAPI godot_image_new_with_png_jpg(godot_image *p_img, const uint8_t *p_mem_png_jpg, int p_len) { - Image *img = (Image *)p_img; - memnew_placement_custom(img, Image, Image(p_mem_png_jpg, p_len)); -} - -void GDAPI godot_image_new_with_xpm(godot_image *p_img, const char **p_xpm) { - Image *img = (Image *)p_img; - memnew_placement_custom(img, Image, Image(p_xpm)); -} - -void GDAPI godot_image_new_with_size_format(godot_image *p_img, int p_width, int p_height, bool p_use_mipmaps, godot_image_format p_format) { - Image *img = (Image *)p_img; - memnew_placement_custom(img, Image, Image(p_width, p_height, p_use_mipmaps, (Image::Format)p_format)); -} - -void GDAPI godot_image_new_with_size_format_data(godot_image *p_img, int p_width, int p_height, bool p_use_mipmaps, godot_image_format p_format, godot_pool_byte_array *p_data) { - Image *img = (Image *)p_img; - PoolVector<uint8_t> *data = (PoolVector<uint8_t> *)p_data; - memnew_placement_custom(img, Image, Image(p_width, p_height, p_use_mipmaps, (Image::Format)p_format, *data)); -} - -godot_pool_byte_array GDAPI godot_image_get_data(godot_image *p_img) { - Image *img = (Image *)p_img; - PoolVector<uint8_t> cpp_data = img->get_data(); - godot_pool_byte_array *data = (godot_pool_byte_array *)&cpp_data; - return *data; -} - -godot_error GDAPI godot_image_load(godot_image *p_img, const godot_string *p_path) { - Image *img = (Image *)p_img; - String *path = (String *)p_path; - return (godot_error)img->load(*path); -} - -godot_error GDAPI godot_image_save_png(godot_image *p_img, const godot_string *p_path) { - Image *img = (Image *)p_img; - String *path = (String *)p_path; - return (godot_error)img->save_png(*path); -} - -int GDAPI godot_image_get_width(const godot_image *p_img) { - Image *img = (Image *)p_img; - return img->get_width(); -} - -int GDAPI godot_image_get_height(const godot_image *p_img) { - Image *img = (Image *)p_img; - return img->get_height(); -} - -godot_bool GDAPI godot_image_has_mipmaps(const godot_image *p_img) { - Image *img = (Image *)p_img; - return img->has_mipmaps(); -} - -int GDAPI godot_image_get_mipmap_count(const godot_image *p_img) { - Image *img = (Image *)p_img; - return img->get_mipmap_count(); -} - -void GDAPI godot_image_destroy(godot_image *p_img) { - ((Image *)p_img)->~Image(); -} - -#ifdef __cplusplus -} -#endif diff --git a/modules/gdnative/godot/godot_image.h b/modules/gdnative/godot/godot_image.h deleted file mode 100644 index c43dd45148..0000000000 --- a/modules/gdnative/godot/godot_image.h +++ /dev/null @@ -1,124 +0,0 @@ -/*************************************************************************/ -/* godot_image.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_IMAGE_H -#define GODOT_IMAGE_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include <stdint.h> - -#ifndef GODOT_CORE_API_GODOT_IMAGE_TYPE_DEFINED -typedef struct godot_image { - uint8_t _dont_touch_that[32]; -} godot_image; -#endif - -#include "godot_pool_arrays.h" - -#include "../godot.h" - -// This is a copypasta of the C++ enum inside the Image class -// There's no neat way of automatically updating the C enum / using the C++ enum directly -// if somebody knows a way feel free to open a PR or open an issue (or ask for Karroffel or bojidar-bg on IRC) - -enum godot_image_format { - - GODOT_IMAGE_FORMAT_L8, //luminance - GODOT_IMAGE_FORMAT_LA8, //luminance-alpha - GODOT_IMAGE_FORMAT_R8, - GODOT_IMAGE_FORMAT_RG8, - GODOT_IMAGE_FORMAT_RGB8, - GODOT_IMAGE_FORMAT_RGBA8, - GODOT_IMAGE_FORMAT_RGB565, //16 bit - GODOT_IMAGE_FORMAT_RGBA4444, - GODOT_IMAGE_FORMAT_RGBA5551, - GODOT_IMAGE_FORMAT_RF, //float - GODOT_IMAGE_FORMAT_RGF, - GODOT_IMAGE_FORMAT_RGBF, - GODOT_IMAGE_FORMAT_RGBAF, - GODOT_IMAGE_FORMAT_RH, //half float - GODOT_IMAGE_FORMAT_RGH, - GODOT_IMAGE_FORMAT_RGBH, - GODOT_IMAGE_FORMAT_RGBAH, - GODOT_IMAGE_FORMAT_DXT1, //s3tc bc1 - GODOT_IMAGE_FORMAT_DXT3, //bc2 - GODOT_IMAGE_FORMAT_DXT5, //bc3 - GODOT_IMAGE_FORMAT_ATI1, //bc4 - GODOT_IMAGE_FORMAT_ATI2, //bc5 - GODOT_IMAGE_FORMAT_BPTC_RGBA, //btpc bc6h - GODOT_IMAGE_FORMAT_BPTC_RGBF, //float / - GODOT_IMAGE_FORMAT_BPTC_RGBFU, //unsigned float - GODOT_IMAGE_FORMAT_PVRTC2, //pvrtc - GODOT_IMAGE_FORMAT_PVRTC2A, - GODOT_IMAGE_FORMAT_PVRTC4, - GODOT_IMAGE_FORMAT_PVRTC4A, - GODOT_IMAGE_FORMAT_ETC, //etc1 - GODOT_IMAGE_FORMAT_ETC2_R11, //etc2 - GODOT_IMAGE_FORMAT_ETC2_R11S, //signed, NOT srgb. - GODOT_IMAGE_FORMAT_ETC2_RG11, - GODOT_IMAGE_FORMAT_ETC2_RG11S, - GODOT_IMAGE_FORMAT_ETC2_RGB8, - GODOT_IMAGE_FORMAT_ETC2_RGBA8, - GODOT_IMAGE_FORMAT_ETC2_RGB8A1, - GODOT_IMAGE_FORMAT_MAX -}; -typedef enum godot_image_format godot_image_format; - -void GDAPI godot_image_new(godot_image *p_img); -// p_len can be -1 -void GDAPI godot_image_new_with_png_jpg(godot_image *p_img, const uint8_t *p_mem_png_jpg, int p_len); -void GDAPI godot_image_new_with_xpm(godot_image *p_img, const char **p_xpm); - -void GDAPI godot_image_new_with_size_format(godot_image *p_img, int p_width, int p_height, bool p_use_mipmaps, godot_image_format p_format); -void GDAPI godot_image_new_with_size_format_data(godot_image *p_img, int p_width, int p_height, bool p_use_mipmaps, godot_image_format p_format, godot_pool_byte_array *p_data); - -godot_pool_byte_array GDAPI godot_image_get_data(godot_image *p_img); - -godot_error GDAPI godot_image_load(godot_image *p_img, const godot_string *p_path); -godot_error GDAPI godot_image_save_png(godot_image *p_img, const godot_string *p_path); - -int GDAPI godot_image_get_width(const godot_image *p_img); -int GDAPI godot_image_get_height(const godot_image *p_img); -godot_bool GDAPI godot_image_has_mipmaps(const godot_image *p_img); -int GDAPI godot_image_get_mipmap_count(const godot_image *p_img); - -// @Incomplete -// I think it's too complex for the binding authors to implement the image class anew, so we should definitely -// export all methods here. That takes a while so it's on my @Todo list - -void GDAPI godot_image_destroy(godot_image *p_img); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_IMAGE_H diff --git a/modules/gdnative/godot/godot_input_event.cpp b/modules/gdnative/godot/godot_input_event.cpp deleted file mode 100644 index 0401c96a88..0000000000 --- a/modules/gdnative/godot/godot_input_event.cpp +++ /dev/null @@ -1,309 +0,0 @@ -/*************************************************************************/ -/* godot_input_event.cpp */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#include "godot_input_event.h" - -#include "os/input_event.h" - -#ifdef __cplusplus -extern "C" { -#endif - -void _input_event_api_anchor() { -} - -void GDAPI godot_input_event_new(godot_input_event *p_ie) { - InputEvent *ie = (InputEvent *)p_ie; - *ie = InputEvent(); -} - -godot_bool GDAPI godot_input_event_is_pressed(const godot_input_event *p_ie) { - const InputEvent *ie = (const InputEvent *)p_ie; - return ie->is_pressed(); -} - -godot_bool GDAPI godot_input_event_is_action(const godot_input_event *p_ie, const godot_string *p_action) { - const InputEvent *ie = (const InputEvent *)p_ie; - const String *action = (const String *)p_action; - return ie->is_action(*action); -} - -godot_bool GDAPI godot_input_event_is_action_pressed(const godot_input_event *p_ie, const godot_string *p_action) { - const InputEvent *ie = (const InputEvent *)p_ie; - const String *action = (const String *)p_action; - return ie->is_action_pressed(*action); -} - -godot_bool GDAPI godot_input_event_is_action_released(const godot_input_event *p_ie, const godot_string *p_action) { - const InputEvent *ie = (const InputEvent *)p_ie; - const String *action = (const String *)p_action; - return ie->is_action_released(*action); -} - -godot_bool GDAPI godot_input_event_is_echo(const godot_input_event *p_ie) { - const InputEvent *ie = (const InputEvent *)p_ie; - return ie->is_echo(); -} - -void GDAPI godot_input_event_set_as_action(godot_input_event *p_ie, const godot_string *p_action, const godot_bool p_pressed) { - InputEvent *ie = (InputEvent *)p_ie; - const String *action = (const String *)p_action; - return ie->set_as_action(*action, p_pressed); -} - -godot_string GDAPI godot_input_event_as_string(const godot_input_event *p_ie) { - const InputEvent *ie = (const InputEvent *)p_ie; - godot_string str; - String *s = (String *)&str; - memnew_placement(s, String); - *s = (String)*ie; - return str; -} - -uint32_t GDAPI *godot_input_event_get_id(godot_input_event *p_ie) { - InputEvent *ie = (InputEvent *)p_ie; - return &ie->ID; -} - -godot_input_event_type GDAPI *godot_input_event_get_type(godot_input_event *p_ie) { - InputEvent *ie = (InputEvent *)p_ie; - return (godot_input_event_type *)&ie->type; -} - -godot_int GDAPI *godot_input_event_get_device(godot_input_event *p_ie) { - InputEvent *ie = (InputEvent *)p_ie; - return &ie->device; -} - -static InputModifierState *_get_mod_for_type(InputEvent *ie) { - switch (ie->type) { - case InputEvent::MOUSE_BUTTON: - return &ie->mouse_button.mod; - case InputEvent::MOUSE_MOTION: - return &ie->mouse_motion.mod; - case InputEvent::KEY: - return &ie->key.mod; - default: - return 0; - } -} - -godot_bool GDAPI *godot_input_event_mod_get_alt(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - InputModifierState *mod = _get_mod_for_type(ie); - return &mod->alt; -} - -godot_bool GDAPI *godot_input_event_mod_get_ctrl(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - InputModifierState *mod = _get_mod_for_type(ie); - return &mod->control; -} - -godot_bool GDAPI *godot_input_event_mod_get_command(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - InputModifierState *mod = _get_mod_for_type(ie); - return &mod->command; -} - -godot_bool GDAPI *godot_input_event_mod_get_shift(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - InputModifierState *mod = _get_mod_for_type(ie); - return &mod->shift; -} - -godot_bool GDAPI *godot_input_event_mod_get_meta(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - InputModifierState *mod = _get_mod_for_type(ie); - return &mod->meta; -} - -uint32_t GDAPI *godot_input_event_key_get_scancode(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->key.scancode; -} - -uint32_t GDAPI *godot_input_event_key_get_unicode(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->key.unicode; -} - -godot_bool GDAPI *godot_input_event_key_get_pressed(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->key.pressed; -} - -godot_bool GDAPI *godot_input_event_key_get_echo(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->key.echo; -} - -float GDAPI *godot_input_event_mouse_get_x(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->mouse_button.x; -} - -float GDAPI *godot_input_event_mouse_get_y(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->mouse_button.y; -} - -float GDAPI *godot_input_event_mouse_get_global_x(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->mouse_button.global_x; -} - -float GDAPI *godot_input_event_mouse_get_global_y(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->mouse_button.global_y; -} - -godot_int GDAPI *godot_input_event_mouse_get_button_mask(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->mouse_button.button_mask; -} - -godot_int GDAPI *godot_input_event_mouse_button_get_button_index(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->mouse_button.button_index; -} - -godot_bool GDAPI *godot_input_event_mouse_button_get_pressed(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->mouse_button.pressed; -} - -godot_bool GDAPI *godot_input_event_mouse_button_get_doubleclick(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->mouse_button.doubleclick; -} - -float GDAPI *godot_input_event_mouse_motion_get_relative_x(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->mouse_motion.relative_x; -} - -float GDAPI *godot_input_event_mouse_motion_get_relative_y(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->mouse_motion.relative_y; -} - -float GDAPI *godot_input_event_mouse_motion_get_speed_x(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->mouse_motion.speed_x; -} - -float GDAPI *godot_input_event_mouse_motion_get_speed_y(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->mouse_motion.speed_y; -} - -godot_int GDAPI *godot_input_event_joypad_motion_get_axis(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->joy_motion.axis; -} - -float GDAPI *godot_input_event_joypad_motion_get_axis_value(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->joy_motion.axis_value; -} - -godot_int GDAPI *godot_input_event_joypad_button_get_button_index(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->joy_button.button_index; -} - -godot_bool GDAPI *godot_input_event_joypad_button_get_pressed(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->joy_button.pressed; -} - -float GDAPI *godot_input_event_joypad_button_get_pressure(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->joy_button.pressure; -} - -godot_int GDAPI *godot_input_event_screen_touch_get_index(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->screen_touch.index; -} - -float GDAPI *godot_input_event_screen_touch_get_x(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->screen_touch.x; -} - -float GDAPI *godot_input_event_screen_touch_get_y(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->screen_touch.y; -} - -godot_bool GDAPI *godot_input_event_screen_touch_get_pressed(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->screen_touch.pressed; -} - -godot_int GDAPI *godot_input_event_screen_drag_get_index(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->screen_drag.index; -} - -float GDAPI *godot_input_event_screen_drag_get_x(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->screen_drag.x; -} - -float GDAPI *godot_input_event_screen_drag_get_y(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->screen_drag.y; -} - -float GDAPI *godot_input_event_screen_drag_get_relative_x(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->screen_drag.relative_x; -} - -float GDAPI *godot_input_event_screen_drag_get_relative_y(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->screen_drag.relative_y; -} - -float GDAPI *godot_input_event_screen_drag_get_speed_x(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->screen_drag.speed_x; -} - -float GDAPI *godot_input_event_screen_drag_get_speed_y(godot_input_event *p_event) { - InputEvent *ie = (InputEvent *)p_event; - return &ie->screen_drag.speed_y; -} - -#ifdef __cplusplus -} -#endif diff --git a/modules/gdnative/godot/godot_input_event.h b/modules/gdnative/godot/godot_input_event.h deleted file mode 100644 index b0a133e3d9..0000000000 --- a/modules/gdnative/godot/godot_input_event.h +++ /dev/null @@ -1,235 +0,0 @@ -/*************************************************************************/ -/* godot_input_event.h */ -/*************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* http://www.godotengine.org */ -/*************************************************************************/ -/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */ -/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/*************************************************************************/ -#ifndef GODOT_INPUT_EVENT_H -#define GODOT_INPUT_EVENT_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include <stdint.h> - -#ifndef GODOT_CORE_API_GODOT_INPUT_EVENT_TYPE_DEFINED -typedef struct godot_input_event { - uint8_t _dont_touch_that[56]; -} godot_input_event; -#endif - -enum godot_input_event_type { - GODOT_INPUT_EVENT_TYPE_NONE, - GODOT_INPUT_EVENT_TYPE_KEY, - GODOT_INPUT_EVENT_TYPE_MOUSE_MOTION, - GODOT_INPUT_EVENT_TYPE_MOUSE_BUTTON, - GODOT_INPUT_EVENT_TYPE_JOYPAD_MOTION, - GODOT_INPUT_EVENT_TYPE_JOYPAD_BUTTON, - GODOT_INPUT_EVENT_TYPE_SCREEN_TOUCH, - GODOT_INPUT_EVENT_TYPE_SCREEN_DRAG, - GODOT_INPUT_EVENT_TYPE_ACTION, - GODOT_INPUT_EVENT_TYPE_TYPE_MAX -}; -typedef enum godot_input_event_type godot_input_event_type; - -enum { - GODOT_BUTTON_LEFT = 1, - GODOT_BUTTON_RIGHT = 2, - GODOT_BUTTON_MIDDLE = 3, - GODOT_BUTTON_WHEEL_UP = 4, - GODOT_BUTTON_WHEEL_DOWN = 5, - GODOT_BUTTON_WHEEL_LEFT = 6, - GODOT_BUTTON_WHEEL_RIGHT = 7, - GODOT_BUTTON_MASK_LEFT = (1 << (GODOT_BUTTON_LEFT - 1)), - GODOT_BUTTON_MASK_RIGHT = (1 << (GODOT_BUTTON_RIGHT - 1)), - GODOT_BUTTON_MASK_MIDDLE = (1 << (GODOT_BUTTON_MIDDLE - 1)), - -}; - -enum { - - GODOT_JOY_BUTTON_0 = 0, - GODOT_JOY_BUTTON_1 = 1, - GODOT_JOY_BUTTON_2 = 2, - GODOT_JOY_BUTTON_3 = 3, - GODOT_JOY_BUTTON_4 = 4, - GODOT_JOY_BUTTON_5 = 5, - GODOT_JOY_BUTTON_6 = 6, - GODOT_JOY_BUTTON_7 = 7, - GODOT_JOY_BUTTON_8 = 8, - GODOT_JOY_BUTTON_9 = 9, - GODOT_JOY_BUTTON_10 = 10, - GODOT_JOY_BUTTON_11 = 11, - GODOT_JOY_BUTTON_12 = 12, - GODOT_JOY_BUTTON_13 = 13, - GODOT_JOY_BUTTON_14 = 14, - GODOT_JOY_BUTTON_15 = 15, - GODOT_JOY_BUTTON_MAX = 16, - - GODOT_JOY_L = GODOT_JOY_BUTTON_4, - GODOT_JOY_R = GODOT_JOY_BUTTON_5, - GODOT_JOY_L2 = GODOT_JOY_BUTTON_6, - GODOT_JOY_R2 = GODOT_JOY_BUTTON_7, - GODOT_JOY_L3 = GODOT_JOY_BUTTON_8, - GODOT_JOY_R3 = GODOT_JOY_BUTTON_9, - GODOT_JOY_SELECT = GODOT_JOY_BUTTON_10, - GODOT_JOY_START = GODOT_JOY_BUTTON_11, - GODOT_JOY_DPAD_UP = GODOT_JOY_BUTTON_12, - GODOT_JOY_DPAD_DOWN = GODOT_JOY_BUTTON_13, - GODOT_JOY_DPAD_LEFT = GODOT_JOY_BUTTON_14, - GODOT_JOY_DPAD_RIGHT = GODOT_JOY_BUTTON_15, - - // a little history about game controllers (who copied who) - - GODOT_JOY_SNES_B = GODOT_JOY_BUTTON_0, - GODOT_JOY_SNES_A = GODOT_JOY_BUTTON_1, - GODOT_JOY_SNES_Y = GODOT_JOY_BUTTON_2, - GODOT_JOY_SNES_X = GODOT_JOY_BUTTON_3, - - GODOT_JOY_SONY_CIRCLE = GODOT_JOY_SNES_A, - GODOT_JOY_SONY_X = GODOT_JOY_SNES_B, - GODOT_JOY_SONY_SQUARE = GODOT_JOY_SNES_Y, - GODOT_JOY_SONY_TRIANGLE = GODOT_JOY_SNES_X, - - GODOT_JOY_SEGA_B = GODOT_JOY_SNES_A, - GODOT_JOY_SEGA_A = GODOT_JOY_SNES_B, - GODOT_JOY_SEGA_X = GODOT_JOY_SNES_Y, - GODOT_JOY_SEGA_Y = GODOT_JOY_SNES_X, - - GODOT_JOY_XBOX_B = GODOT_JOY_SEGA_B, - GODOT_JOY_XBOX_A = GODOT_JOY_SEGA_A, - GODOT_JOY_XBOX_X = GODOT_JOY_SEGA_X, - GODOT_JOY_XBOX_Y = GODOT_JOY_SEGA_Y, - - GODOT_JOY_DS_A = GODOT_JOY_SNES_A, - GODOT_JOY_DS_B = GODOT_JOY_SNES_B, - GODOT_JOY_DS_X = GODOT_JOY_SNES_X, - GODOT_JOY_DS_Y = GODOT_JOY_SNES_Y, - - GODOT_JOY_WII_C = GODOT_JOY_BUTTON_5, - GODOT_JOY_WII_Z = GODOT_JOY_BUTTON_6, - - GODOT_JOY_WII_MINUS = GODOT_JOY_BUTTON_9, - GODOT_JOY_WII_PLUS = GODOT_JOY_BUTTON_10, - - // end of history - - GODOT_JOY_AXIS_0 = 0, - GODOT_JOY_AXIS_1 = 1, - GODOT_JOY_AXIS_2 = 2, - GODOT_JOY_AXIS_3 = 3, - GODOT_JOY_AXIS_4 = 4, - GODOT_JOY_AXIS_5 = 5, - GODOT_JOY_AXIS_6 = 6, - GODOT_JOY_AXIS_7 = 7, - GODOT_JOY_AXIS_MAX = 8, - - GODOT_JOY_ANALOG_0_X = GODOT_JOY_AXIS_0, - GODOT_JOY_ANALOG_0_Y = GODOT_JOY_AXIS_1, - - GODOT_JOY_ANALOG_1_X = GODOT_JOY_AXIS_2, - GODOT_JOY_ANALOG_1_Y = GODOT_JOY_AXIS_3, - - GODOT_JOY_ANALOG_2_X = GODOT_JOY_AXIS_4, - GODOT_JOY_ANALOG_2_Y = GODOT_JOY_AXIS_5, - - GODOT_JOY_ANALOG_L2 = GODOT_JOY_AXIS_6, - GODOT_JOY_ANALOG_R2 = GODOT_JOY_AXIS_7, -}; - -#include "../godot.h" - -void GDAPI godot_input_event_new(godot_input_event *p_ie); - -godot_bool GDAPI godot_input_event_is_pressed(const godot_input_event *p_ie); -godot_bool GDAPI godot_input_event_is_action(const godot_input_event *p_ie, const godot_string *p_action); -godot_bool GDAPI godot_input_event_is_action_pressed(const godot_input_event *p_ie, const godot_string *p_action); -godot_bool GDAPI godot_input_event_is_action_released(const godot_input_event *p_ie, const godot_string *p_action); -godot_bool GDAPI godot_input_event_is_echo(const godot_input_event *p_ie); -void GDAPI godot_input_event_set_as_action(godot_input_event *p_ie, const godot_string *p_action, const godot_bool p_pressed); - -godot_string GDAPI godot_input_event_as_string(const godot_input_event *p_ie); - -// Note: -// We're returning pointers to the fields in the unions. -// This is because I'm too lazy to write setter functions - -uint32_t GDAPI *godot_input_event_get_id(godot_input_event *p_ie); -godot_input_event_type GDAPI *godot_input_event_get_type(godot_input_event *p_ie); -godot_int GDAPI *godot_input_event_get_device(godot_input_event *p_ie); - -godot_bool GDAPI *godot_input_event_mod_get_alt(godot_input_event *p_event); -godot_bool GDAPI *godot_input_event_mod_get_ctrl(godot_input_event *p_event); -godot_bool GDAPI *godot_input_event_mod_get_command(godot_input_event *p_event); -godot_bool GDAPI *godot_input_event_mod_get_shift(godot_input_event *p_event); -godot_bool GDAPI *godot_input_event_mod_get_meta(godot_input_event *p_event); - -uint32_t GDAPI *godot_input_event_key_get_scancode(godot_input_event *p_event); -uint32_t GDAPI *godot_input_event_key_get_unicode(godot_input_event *p_event); -godot_bool GDAPI *godot_input_event_key_get_pressed(godot_input_event *p_event); -godot_bool GDAPI *godot_input_event_key_get_echo(godot_input_event *p_event); - -float GDAPI *godot_input_event_mouse_get_x(godot_input_event *p_event); -float GDAPI *godot_input_event_mouse_get_y(godot_input_event *p_event); -float GDAPI *godot_input_event_mouse_get_global_x(godot_input_event *p_event); -float GDAPI *godot_input_event_mouse_get_global_y(godot_input_event *p_event); -godot_int GDAPI *godot_input_event_mouse_get_button_mask(godot_input_event *p_event); - -godot_int GDAPI *godot_input_event_mouse_button_get_button_index(godot_input_event *p_event); -godot_bool GDAPI *godot_input_event_mouse_button_get_pressed(godot_input_event *p_event); -godot_bool GDAPI *godot_input_event_mouse_button_get_doubleclick(godot_input_event *p_event); - -float GDAPI *godot_input_event_mouse_motion_get_relative_x(godot_input_event *p_event); -float GDAPI *godot_input_event_mouse_motion_get_relative_y(godot_input_event *p_event); -float GDAPI *godot_input_event_mouse_motion_get_speed_x(godot_input_event *p_event); -float GDAPI *godot_input_event_mouse_motion_get_speed_y(godot_input_event *p_event); - -godot_int GDAPI *godot_input_event_joypad_motion_get_axis(godot_input_event *p_event); -float GDAPI *godot_input_event_joypad_motion_get_axis_value(godot_input_event *p_event); - -godot_int GDAPI *godot_input_event_joypad_button_get_button_index(godot_input_event *p_event); -godot_bool GDAPI *godot_input_event_joypad_button_get_pressed(godot_input_event *p_event); -float GDAPI *godot_input_event_joypad_button_get_pressure(godot_input_event *p_event); - -godot_int GDAPI *godot_input_event_screen_touch_get_index(godot_input_event *p_event); -float GDAPI *godot_input_event_screen_touch_get_x(godot_input_event *p_event); -float GDAPI *godot_input_event_screen_touch_get_y(godot_input_event *p_event); -godot_bool GDAPI *godot_input_event_screen_touch_get_pressed(godot_input_event *p_event); - -godot_int GDAPI *godot_input_event_screen_drag_get_index(godot_input_event *p_event); -float GDAPI *godot_input_event_screen_drag_get_x(godot_input_event *p_event); -float GDAPI *godot_input_event_screen_drag_get_y(godot_input_event *p_event); -float GDAPI *godot_input_event_screen_drag_get_relative_x(godot_input_event *p_event); -float GDAPI *godot_input_event_screen_drag_get_relative_y(godot_input_event *p_event); -float GDAPI *godot_input_event_screen_drag_get_speed_x(godot_input_event *p_event); -float GDAPI *godot_input_event_screen_drag_get_speed_y(godot_input_event *p_event); - -#ifdef __cplusplus -} -#endif - -#endif // GODOT_INPUT_EVENT_H diff --git a/modules/gdnative/godot/godot_node_path.cpp b/modules/gdnative/godot/godot_node_path.cpp index a2c9e11699..165688a340 100644 --- a/modules/gdnative/godot/godot_node_path.cpp +++ b/modules/gdnative/godot/godot_node_path.cpp @@ -28,91 +28,81 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "godot_node_path.h" +#include "core/variant.h" -#include "path_db.h" +#include "core/path_db.h" #ifdef __cplusplus extern "C" { #endif -void _node_path_api_anchor() { -} - -#define memnew_placement_custom(m_placement, m_class, m_constr) _post_initialize(new (m_placement, sizeof(m_class), "") m_constr) - -// @Bug ? -// Do I need to memnew_placement when returning strings? +void _node_path_api_anchor() {} -void GDAPI godot_node_path_new(godot_node_path *p_np, const godot_string *p_from) { - NodePath *np = (NodePath *)p_np; - String *from = (String *)p_from; - memnew_placement_custom(np, NodePath, NodePath(*from)); +void GDAPI godot_node_path_new(godot_node_path *r_dest, const godot_string *p_from) { + NodePath *dest = (NodePath *)r_dest; + const String *from = (const String *)p_from; + memnew_placement(dest, NodePath(*from)); } -void GDAPI godot_node_path_copy(godot_node_path *p_np, const godot_node_path *p_from) { - NodePath *np = (NodePath *)p_np; - NodePath *from = (NodePath *)p_from; - *np = *from; +void GDAPI godot_node_path_destroy(godot_node_path *p_self) { + NodePath *self = (NodePath *)p_self; + self->~NodePath(); } -godot_string GDAPI godot_node_path_get_name(const godot_node_path *p_np, const godot_int p_idx) { - const NodePath *np = (const NodePath *)p_np; - godot_string str; - String *s = (String *)&str; - memnew_placement(s, String); - *s = np->get_name(p_idx); - return str; +godot_string GDAPI godot_node_path_as_string(const godot_node_path *p_self) { + godot_string ret; + const NodePath *self = (const NodePath *)p_self; + memnew_placement(&ret, String(*self)); + return ret; } -godot_int GDAPI godot_node_path_get_name_count(const godot_node_path *p_np) { - const NodePath *np = (const NodePath *)p_np; - return np->get_name_count(); +godot_bool GDAPI godot_node_path_is_absolute(const godot_node_path *p_self) { + const NodePath *self = (const NodePath *)p_self; + return self->is_absolute(); } -godot_string GDAPI godot_node_path_get_property(const godot_node_path *p_np) { - const NodePath *np = (const NodePath *)p_np; - godot_string str; - String *s = (String *)&str; - memnew_placement(s, String); - *s = np->get_property(); - return str; +godot_int GDAPI godot_node_path_get_name_count(const godot_node_path *p_self) { + const NodePath *self = (const NodePath *)p_self; + return self->get_name_count(); } -godot_string GDAPI godot_node_path_get_subname(const godot_node_path *p_np, const godot_int p_idx) { - const NodePath *np = (const NodePath *)p_np; - godot_string str; - String *s = (String *)&str; - memnew_placement(s, String); - *s = np->get_subname(p_idx); - return str; +godot_string GDAPI godot_node_path_get_name(const godot_node_path *p_self, const godot_int p_idx) { + godot_string dest; + const NodePath *self = (const NodePath *)p_self; + + memnew_placement(&dest, String(self->get_name(p_idx))); + return dest; } -godot_int GDAPI godot_node_path_get_subname_count(const godot_node_path *p_np) { - const NodePath *np = (const NodePath *)p_np; - return np->get_subname_count(); +godot_int GDAPI godot_node_path_get_subname_count(const godot_node_path *p_self) { + const NodePath *self = (const NodePath *)p_self; + return self->get_subname_count(); } -godot_bool GDAPI godot_node_path_is_absolute(const godot_node_path *p_np) { - const NodePath *np = (const NodePath *)p_np; - return np->is_absolute(); +godot_string GDAPI godot_node_path_get_subname(const godot_node_path *p_self, const godot_int p_idx) { + godot_string dest; + const NodePath *self = (const NodePath *)p_self; + + memnew_placement(&dest, String(self->get_subname(p_idx))); + return dest; } -godot_bool GDAPI godot_node_path_is_empty(const godot_node_path *p_np) { - const NodePath *np = (const NodePath *)p_np; - return np->is_empty(); +godot_string GDAPI godot_node_path_get_property(const godot_node_path *p_self) { + godot_string dest; + const NodePath *self = (const NodePath *)p_self; + memnew_placement(&dest, String(self->get_property())); + return dest; } -godot_string GDAPI godot_node_path_as_string(const godot_node_path *p_np) { - const NodePath *np = (const NodePath *)p_np; - godot_string str; - String *s = (String *)&str; - memnew_placement(s, String); - *s = *np; - return str; +godot_bool GDAPI godot_node_path_is_empty(const godot_node_path *p_self) { + const NodePath *self = (const NodePath *)p_self; + return self->is_empty(); } -void GDAPI godot_node_path_destroy(godot_node_path *p_np) { - ((NodePath *)p_np)->~NodePath(); +godot_bool GDAPI godot_node_path_operator_equal(const godot_node_path *p_self, const godot_node_path *p_b) { + const NodePath *self = (const NodePath *)p_self; + const NodePath *b = (const NodePath *)p_b; + return *self == *b; } #ifdef __cplusplus diff --git a/modules/gdnative/godot/godot_node_path.h b/modules/gdnative/godot/godot_node_path.h index c5f313d190..fb94bd3822 100644 --- a/modules/gdnative/godot/godot_node_path.h +++ b/modules/gdnative/godot/godot_node_path.h @@ -37,29 +37,35 @@ extern "C" { #include <stdint.h> #ifndef GODOT_CORE_API_GODOT_NODE_PATH_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_NODE_PATH_TYPE_DEFINED typedef struct godot_node_path { uint8_t _dont_touch_that[8]; } godot_node_path; #endif #include "../godot.h" +#include "godot_string.h" -void GDAPI godot_node_path_new(godot_node_path *p_np, const godot_string *p_from); -void GDAPI godot_node_path_copy(godot_node_path *p_np, const godot_node_path *p_from); +void GDAPI godot_node_path_new(godot_node_path *r_dest, const godot_string *p_from); +void GDAPI godot_node_path_destroy(godot_node_path *p_self); -godot_string GDAPI godot_node_path_get_name(const godot_node_path *p_np, const godot_int p_idx); -godot_int GDAPI godot_node_path_get_name_count(const godot_node_path *p_np); +godot_string GDAPI godot_node_path_as_string(const godot_node_path *p_self); -godot_string GDAPI godot_node_path_get_property(const godot_node_path *p_np); -godot_string GDAPI godot_node_path_get_subname(const godot_node_path *p_np, const godot_int p_idx); -godot_int GDAPI godot_node_path_get_subname_count(const godot_node_path *p_np); +godot_bool GDAPI godot_node_path_is_absolute(const godot_node_path *p_self); -godot_bool GDAPI godot_node_path_is_absolute(const godot_node_path *p_np); -godot_bool GDAPI godot_node_path_is_empty(const godot_node_path *p_np); +godot_int GDAPI godot_node_path_get_name_count(const godot_node_path *p_self); -godot_string GDAPI godot_node_path_as_string(const godot_node_path *p_np); +godot_string GDAPI godot_node_path_get_name(const godot_node_path *p_self, const godot_int p_idx); -void GDAPI godot_node_path_destroy(godot_node_path *p_np); +godot_int GDAPI godot_node_path_get_subname_count(const godot_node_path *p_self); + +godot_string GDAPI godot_node_path_get_subname(const godot_node_path *p_self, const godot_int p_idx); + +godot_string GDAPI godot_node_path_get_property(const godot_node_path *p_self); + +godot_bool GDAPI godot_node_path_is_empty(const godot_node_path *p_self); + +godot_bool GDAPI godot_node_path_operator_equal(const godot_node_path *p_self, const godot_node_path *p_b); #ifdef __cplusplus } diff --git a/modules/gdnative/godot/godot_plane.cpp b/modules/gdnative/godot/godot_plane.cpp index 38329ef709..68adbd4a98 100644 --- a/modules/gdnative/godot/godot_plane.cpp +++ b/modules/gdnative/godot/godot_plane.cpp @@ -28,48 +28,149 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "godot_plane.h" +#include "core/variant.h" -#include "math/plane.h" +#include "core/math/plane.h" #ifdef __cplusplus extern "C" { #endif -void _plane_api_anchor() { +void _plane_api_anchor() {} + +void GDAPI godot_plane_new_with_reals(godot_plane *r_dest, const godot_real p_a, const godot_real p_b, const godot_real p_c, const godot_real p_d) { + + Plane *dest = (Plane *)r_dest; + *dest = Plane(p_a, p_b, p_c, p_d); } -void GDAPI godot_plane_new(godot_plane *p_pl) { - Plane *pl = (Plane *)p_pl; - *pl = Plane(); +void GDAPI godot_plane_new_with_vectors(godot_plane *r_dest, const godot_vector3 *p_v1, const godot_vector3 *p_v2, const godot_vector3 *p_v3) { + const Vector3 *v1 = (const Vector3 *)p_v1; + const Vector3 *v2 = (const Vector3 *)p_v2; + const Vector3 *v3 = (const Vector3 *)p_v3; + Plane *dest = (Plane *)r_dest; + *dest = Plane(*v1, *v2, *v3); } -void GDAPI godot_plane_new_with_normal(godot_plane *p_pl, const godot_vector3 *p_normal, const godot_real p_d) { - Plane *pl = (Plane *)p_pl; +void GDAPI godot_plane_new_with_normal(godot_plane *r_dest, const godot_vector3 *p_normal, const godot_real p_d) { const Vector3 *normal = (const Vector3 *)p_normal; - *pl = Plane(*normal, p_d); + Plane *dest = (Plane *)r_dest; + *dest = Plane(*normal, p_d); +} + +godot_string GDAPI godot_plane_as_string(const godot_plane *p_self) { + godot_string ret; + const Plane *self = (const Plane *)p_self; + memnew_placement(&ret, String(*self)); + return ret; +} + +godot_plane GDAPI godot_plane_normalized(const godot_plane *p_self) { + godot_plane dest; + const Plane *self = (const Plane *)p_self; + *((Plane *)&dest) = self->normalized(); + return dest; +} + +godot_vector3 GDAPI godot_plane_center(const godot_plane *p_self) { + godot_vector3 dest; + const Plane *self = (const Plane *)p_self; + *((Vector3 *)&dest) = self->center(); + return dest; +} + +godot_vector3 GDAPI godot_plane_get_any_point(const godot_plane *p_self) { + godot_vector3 dest; + const Plane *self = (const Plane *)p_self; + *((Vector3 *)&dest) = self->get_any_point(); + return dest; +} + +godot_bool GDAPI godot_plane_is_point_over(const godot_plane *p_self, const godot_vector3 *p_point) { + const Plane *self = (const Plane *)p_self; + const Vector3 *point = (const Vector3 *)p_point; + return self->is_point_over(*point); +} + +godot_real GDAPI godot_plane_distance_to(const godot_plane *p_self, const godot_vector3 *p_point) { + const Plane *self = (const Plane *)p_self; + const Vector3 *point = (const Vector3 *)p_point; + return self->distance_to(*point); +} + +godot_bool GDAPI godot_plane_has_point(const godot_plane *p_self, const godot_vector3 *p_point, const godot_real p_epsilon) { + const Plane *self = (const Plane *)p_self; + const Vector3 *point = (const Vector3 *)p_point; + return self->has_point(*point, p_epsilon); +} + +godot_vector3 GDAPI godot_plane_project(const godot_plane *p_self, const godot_vector3 *p_point) { + godot_vector3 dest; + const Plane *self = (const Plane *)p_self; + const Vector3 *point = (const Vector3 *)p_point; + *((Vector3 *)&dest) = self->project(*point); + return dest; +} + +godot_bool GDAPI godot_plane_intersect_3(const godot_plane *p_self, godot_vector3 *r_dest, const godot_plane *p_b, const godot_plane *p_c) { + const Plane *self = (const Plane *)p_self; + const Plane *b = (const Plane *)p_b; + const Plane *c = (const Plane *)p_c; + Vector3 *dest = (Vector3 *)r_dest; + return self->intersect_3(*b, *c, dest); +} + +godot_bool GDAPI godot_plane_intersects_ray(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_from, const godot_vector3 *p_dir) { + const Plane *self = (const Plane *)p_self; + const Vector3 *from = (const Vector3 *)p_from; + const Vector3 *dir = (const Vector3 *)p_dir; + Vector3 *dest = (Vector3 *)r_dest; + return self->intersects_ray(*from, *dir, dest); +} + +godot_bool GDAPI godot_plane_intersects_segment(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_begin, const godot_vector3 *p_end) { + const Plane *self = (const Plane *)p_self; + const Vector3 *begin = (const Vector3 *)p_begin; + const Vector3 *end = (const Vector3 *)p_end; + Vector3 *dest = (Vector3 *)r_dest; + return self->intersects_segment(*begin, *end, dest); +} + +godot_plane GDAPI godot_plane_operator_neg(const godot_plane *p_self) { + godot_plane raw_dest; + Plane *dest = (Plane *)&raw_dest; + const Plane *self = (const Plane *)p_self; + *dest = -(*self); + return raw_dest; +} + +godot_bool GDAPI godot_plane_operator_equal(const godot_plane *p_self, const godot_plane *p_b) { + const Plane *self = (const Plane *)p_self; + const Plane *b = (const Plane *)p_b; + return *self == *b; } -void GDAPI godot_plane_set_normal(godot_plane *p_pl, const godot_vector3 *p_normal) { - Plane *pl = (Plane *)p_pl; +void GDAPI godot_plane_set_normal(godot_plane *p_self, const godot_vector3 *p_normal) { + Plane *self = (Plane *)p_self; const Vector3 *normal = (const Vector3 *)p_normal; - pl->set_normal(*normal); + self->set_normal(*normal); } -godot_vector3 godot_plane_get_normal(const godot_plane *p_pl) { - const Plane *pl = (const Plane *)p_pl; - const Vector3 normal = pl->get_normal(); +godot_vector3 GDAPI godot_plane_get_normal(const godot_plane *p_self) { + const Plane *self = (const Plane *)p_self; + const Vector3 normal = self->get_normal(); godot_vector3 *v3 = (godot_vector3 *)&normal; return *v3; } -void GDAPI godot_plane_set_d(godot_plane *p_pl, const godot_real p_d) { - Plane *pl = (Plane *)p_pl; - pl->d = p_d; +godot_real GDAPI godot_plane_get_d(const godot_plane *p_self) { + const Plane *self = (const Plane *)p_self; + return self->d; } -godot_real GDAPI godot_plane_get_d(const godot_plane *p_pl) { - const Plane *pl = (const Plane *)p_pl; - return pl->d; +void GDAPI godot_plane_set_d(godot_plane *p_self, const godot_real p_d) { + Plane *self = (Plane *)p_self; + self->d = p_d; } #ifdef __cplusplus diff --git a/modules/gdnative/godot/godot_plane.h b/modules/gdnative/godot/godot_plane.h index c98e45c9cb..cfc955f277 100644 --- a/modules/gdnative/godot/godot_plane.h +++ b/modules/gdnative/godot/godot_plane.h @@ -37,27 +37,52 @@ extern "C" { #include <stdint.h> #ifndef GODOT_CORE_API_GODOT_PLANE_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_PLANE_TYPE_DEFINED typedef struct godot_plane { uint8_t _dont_touch_that[16]; } godot_plane; #endif +#include "../godot.h" #include "godot_vector3.h" -void GDAPI godot_plane_new(godot_plane *p_pl); -void GDAPI godot_plane_new_with_normal(godot_plane *p_pl, const godot_vector3 *p_normal, const godot_real p_d); +void GDAPI godot_plane_new_with_reals(godot_plane *r_dest, const godot_real p_a, const godot_real p_b, const godot_real p_c, const godot_real p_d); +void GDAPI godot_plane_new_with_vectors(godot_plane *r_dest, const godot_vector3 *p_v1, const godot_vector3 *p_v2, const godot_vector3 *p_v3); +void GDAPI godot_plane_new_with_normal(godot_plane *r_dest, const godot_vector3 *p_normal, const godot_real p_d); -// @Incomplete -// These are additional valid constructors -// _FORCE_INLINE_ Plane(const Vector3 &p_normal, real_t p_d); -// _FORCE_INLINE_ Plane(const Vector3 &p_point, const Vector3& p_normal); -// _FORCE_INLINE_ Plane(const Vector3 &p_point1, const Vector3 &p_point2,const Vector3 &p_point3,ClockDirection p_dir = CLOCKWISE); +godot_string GDAPI godot_plane_as_string(const godot_plane *p_self); -void GDAPI godot_plane_set_normal(godot_plane *p_pl, const godot_vector3 *p_normal); -godot_vector3 GDAPI godot_plane_get_normal(const godot_plane *p_pl); +godot_plane GDAPI godot_plane_normalized(const godot_plane *p_self); -godot_real GDAPI godot_plane_get_d(const godot_plane *p_pl); -void GDAPI godot_plane_set_d(godot_plane *p_pl, const godot_real p_d); +godot_vector3 GDAPI godot_plane_center(const godot_plane *p_self); + +godot_vector3 GDAPI godot_plane_get_any_point(const godot_plane *p_self); + +godot_bool GDAPI godot_plane_is_point_over(const godot_plane *p_self, const godot_vector3 *p_point); + +godot_real GDAPI godot_plane_distance_to(const godot_plane *p_self, const godot_vector3 *p_point); + +godot_bool GDAPI godot_plane_has_point(const godot_plane *p_self, const godot_vector3 *p_point, const godot_real p_epsilon); + +godot_vector3 GDAPI godot_plane_project(const godot_plane *p_self, const godot_vector3 *p_point); + +godot_bool GDAPI godot_plane_intersect_3(const godot_plane *p_self, godot_vector3 *r_dest, const godot_plane *p_b, const godot_plane *p_c); + +godot_bool GDAPI godot_plane_intersects_ray(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_from, const godot_vector3 *p_dir); + +godot_bool GDAPI godot_plane_intersects_segment(const godot_plane *p_self, godot_vector3 *r_dest, const godot_vector3 *p_begin, const godot_vector3 *p_end); + +godot_plane GDAPI godot_plane_operator_neg(const godot_plane *p_self); + +godot_bool GDAPI godot_plane_operator_equal(const godot_plane *p_self, const godot_plane *p_b); + +void GDAPI godot_plane_set_normal(godot_plane *p_self, const godot_vector3 *p_normal); + +godot_vector3 GDAPI godot_plane_get_normal(const godot_plane *p_self); + +godot_real GDAPI godot_plane_get_d(const godot_plane *p_self); + +void GDAPI godot_plane_set_d(godot_plane *p_self, const godot_real p_d); #ifdef __cplusplus } diff --git a/modules/gdnative/godot/godot_pool_arrays.cpp b/modules/gdnative/godot/godot_pool_arrays.cpp index 93e9a9e9dc..10d5d6d939 100644 --- a/modules/gdnative/godot/godot_pool_arrays.cpp +++ b/modules/gdnative/godot/godot_pool_arrays.cpp @@ -101,13 +101,13 @@ void GDAPI godot_pool_byte_array_set(godot_pool_byte_array *p_pba, const godot_i pba->set(p_idx, p_data); } -uint8_t GDAPI godot_pool_byte_array_get(godot_pool_byte_array *p_pba, const godot_int p_idx) { - PoolVector<uint8_t> *pba = (PoolVector<uint8_t> *)p_pba; +uint8_t GDAPI godot_pool_byte_array_get(const godot_pool_byte_array *p_pba, const godot_int p_idx) { + const PoolVector<uint8_t> *pba = (const PoolVector<uint8_t> *)p_pba; return pba->get(p_idx); } -godot_int GDAPI godot_pool_byte_array_size(godot_pool_byte_array *p_pba) { - PoolVector<uint8_t> *pba = (PoolVector<uint8_t> *)p_pba; +godot_int GDAPI godot_pool_byte_array_size(const godot_pool_byte_array *p_pba) { + const PoolVector<uint8_t> *pba = (const PoolVector<uint8_t> *)p_pba; return pba->size(); } @@ -174,13 +174,13 @@ void GDAPI godot_pool_int_array_set(godot_pool_int_array *p_pba, const godot_int pba->set(p_idx, p_data); } -godot_int GDAPI godot_pool_int_array_get(godot_pool_int_array *p_pba, const godot_int p_idx) { - PoolVector<godot_int> *pba = (PoolVector<godot_int> *)p_pba; +godot_int GDAPI godot_pool_int_array_get(const godot_pool_int_array *p_pba, const godot_int p_idx) { + const PoolVector<godot_int> *pba = (const PoolVector<godot_int> *)p_pba; return pba->get(p_idx); } -godot_int GDAPI godot_pool_int_array_size(godot_pool_int_array *p_pba) { - PoolVector<godot_int> *pba = (PoolVector<godot_int> *)p_pba; +godot_int GDAPI godot_pool_int_array_size(const godot_pool_int_array *p_pba) { + const PoolVector<godot_int> *pba = (const PoolVector<godot_int> *)p_pba; return pba->size(); } @@ -247,13 +247,13 @@ void GDAPI godot_pool_real_array_set(godot_pool_real_array *p_pba, const godot_i pba->set(p_idx, p_data); } -godot_real GDAPI godot_pool_real_array_get(godot_pool_real_array *p_pba, const godot_int p_idx) { - PoolVector<godot_real> *pba = (PoolVector<godot_real> *)p_pba; +godot_real GDAPI godot_pool_real_array_get(const godot_pool_real_array *p_pba, const godot_int p_idx) { + const PoolVector<godot_real> *pba = (const PoolVector<godot_real> *)p_pba; return pba->get(p_idx); } -godot_int GDAPI godot_pool_real_array_size(godot_pool_real_array *p_pba) { - PoolVector<godot_real> *pba = (PoolVector<godot_real> *)p_pba; +godot_int GDAPI godot_pool_real_array_size(const godot_pool_real_array *p_pba) { + const PoolVector<godot_real> *pba = (const PoolVector<godot_real> *)p_pba; return pba->size(); } @@ -324,8 +324,8 @@ void GDAPI godot_pool_string_array_set(godot_pool_string_array *p_pba, const god pba->set(p_idx, s); } -godot_string GDAPI godot_pool_string_array_get(godot_pool_string_array *p_pba, const godot_int p_idx) { - PoolVector<String> *pba = (PoolVector<String> *)p_pba; +godot_string GDAPI godot_pool_string_array_get(const godot_pool_string_array *p_pba, const godot_int p_idx) { + const PoolVector<String> *pba = (const PoolVector<String> *)p_pba; godot_string str; String *s = (String *)&str; memnew_placement(s, String); @@ -333,8 +333,8 @@ godot_string GDAPI godot_pool_string_array_get(godot_pool_string_array *p_pba, c return str; } -godot_int GDAPI godot_pool_string_array_size(godot_pool_string_array *p_pba) { - PoolVector<String> *pba = (PoolVector<String> *)p_pba; +godot_int GDAPI godot_pool_string_array_size(const godot_pool_string_array *p_pba) { + const PoolVector<String> *pba = (const PoolVector<String> *)p_pba; return pba->size(); } @@ -405,16 +405,16 @@ void GDAPI godot_pool_vector2_array_set(godot_pool_vector2_array *p_pba, const g pba->set(p_idx, s); } -godot_vector2 GDAPI godot_pool_vector2_array_get(godot_pool_vector2_array *p_pba, const godot_int p_idx) { - PoolVector<Vector2> *pba = (PoolVector<Vector2> *)p_pba; +godot_vector2 GDAPI godot_pool_vector2_array_get(const godot_pool_vector2_array *p_pba, const godot_int p_idx) { + const PoolVector<Vector2> *pba = (const PoolVector<Vector2> *)p_pba; godot_vector2 v; Vector2 *s = (Vector2 *)&v; *s = pba->get(p_idx); return v; } -godot_int GDAPI godot_pool_vector2_array_size(godot_pool_vector2_array *p_pba) { - PoolVector<Vector2> *pba = (PoolVector<Vector2> *)p_pba; +godot_int GDAPI godot_pool_vector2_array_size(const godot_pool_vector2_array *p_pba) { + const PoolVector<Vector2> *pba = (const PoolVector<Vector2> *)p_pba; return pba->size(); } @@ -485,16 +485,16 @@ void GDAPI godot_pool_vector3_array_set(godot_pool_vector3_array *p_pba, const g pba->set(p_idx, s); } -godot_vector3 GDAPI godot_pool_vector3_array_get(godot_pool_vector3_array *p_pba, const godot_int p_idx) { - PoolVector<Vector3> *pba = (PoolVector<Vector3> *)p_pba; +godot_vector3 GDAPI godot_pool_vector3_array_get(const godot_pool_vector3_array *p_pba, const godot_int p_idx) { + const PoolVector<Vector3> *pba = (const PoolVector<Vector3> *)p_pba; godot_vector3 v; Vector3 *s = (Vector3 *)&v; *s = pba->get(p_idx); return v; } -godot_int GDAPI godot_pool_vector3_array_size(godot_pool_vector3_array *p_pba) { - PoolVector<Vector3> *pba = (PoolVector<Vector3> *)p_pba; +godot_int GDAPI godot_pool_vector3_array_size(const godot_pool_vector3_array *p_pba) { + const PoolVector<Vector3> *pba = (const PoolVector<Vector3> *)p_pba; return pba->size(); } @@ -565,16 +565,16 @@ void GDAPI godot_pool_color_array_set(godot_pool_color_array *p_pba, const godot pba->set(p_idx, s); } -godot_color GDAPI godot_pool_color_array_get(godot_pool_color_array *p_pba, const godot_int p_idx) { - PoolVector<Color> *pba = (PoolVector<Color> *)p_pba; +godot_color GDAPI godot_pool_color_array_get(const godot_pool_color_array *p_pba, const godot_int p_idx) { + const PoolVector<Color> *pba = (const PoolVector<Color> *)p_pba; godot_color v; Color *s = (Color *)&v; *s = pba->get(p_idx); return v; } -godot_int GDAPI godot_pool_color_array_size(godot_pool_color_array *p_pba) { - PoolVector<Color> *pba = (PoolVector<Color> *)p_pba; +godot_int GDAPI godot_pool_color_array_size(const godot_pool_color_array *p_pba) { + const PoolVector<Color> *pba = (const PoolVector<Color> *)p_pba; return pba->size(); } diff --git a/modules/gdnative/godot/godot_pool_arrays.h b/modules/gdnative/godot/godot_pool_arrays.h index ec9185f6f3..015be65c3e 100644 --- a/modules/gdnative/godot/godot_pool_arrays.h +++ b/modules/gdnative/godot/godot_pool_arrays.h @@ -92,9 +92,12 @@ typedef struct godot_pool_color_array { } godot_pool_color_array; #endif -#include "../godot.h" - #include "godot_array.h" +#include "godot_color.h" +#include "godot_vector2.h" +#include "godot_vector3.h" + +#include "../godot.h" // byte @@ -116,9 +119,9 @@ void GDAPI godot_pool_byte_array_remove(godot_pool_byte_array *p_pba, const godo void GDAPI godot_pool_byte_array_resize(godot_pool_byte_array *p_pba, const godot_int p_size); void GDAPI godot_pool_byte_array_set(godot_pool_byte_array *p_pba, const godot_int p_idx, const uint8_t p_data); -uint8_t GDAPI godot_pool_byte_array_get(godot_pool_byte_array *p_pba, const godot_int p_idx); +uint8_t GDAPI godot_pool_byte_array_get(const godot_pool_byte_array *p_pba, const godot_int p_idx); -godot_int GDAPI godot_pool_byte_array_size(godot_pool_byte_array *p_pba); +godot_int GDAPI godot_pool_byte_array_size(const godot_pool_byte_array *p_pba); void GDAPI godot_pool_byte_array_destroy(godot_pool_byte_array *p_pba); @@ -142,9 +145,9 @@ void GDAPI godot_pool_int_array_remove(godot_pool_int_array *p_pia, const godot_ void GDAPI godot_pool_int_array_resize(godot_pool_int_array *p_pia, const godot_int p_size); void GDAPI godot_pool_int_array_set(godot_pool_int_array *p_pia, const godot_int p_idx, const godot_int p_data); -godot_int GDAPI godot_pool_int_array_get(godot_pool_int_array *p_pia, const godot_int p_idx); +godot_int GDAPI godot_pool_int_array_get(const godot_pool_int_array *p_pia, const godot_int p_idx); -godot_int GDAPI godot_pool_int_array_size(godot_pool_int_array *p_pia); +godot_int GDAPI godot_pool_int_array_size(const godot_pool_int_array *p_pia); void GDAPI godot_pool_int_array_destroy(godot_pool_int_array *p_pia); @@ -168,9 +171,9 @@ void GDAPI godot_pool_real_array_remove(godot_pool_real_array *p_pra, const godo void GDAPI godot_pool_real_array_resize(godot_pool_real_array *p_pra, const godot_int p_size); void GDAPI godot_pool_real_array_set(godot_pool_real_array *p_pra, const godot_int p_idx, const godot_real p_data); -godot_real GDAPI godot_pool_real_array_get(godot_pool_real_array *p_pra, const godot_int p_idx); +godot_real GDAPI godot_pool_real_array_get(const godot_pool_real_array *p_pra, const godot_int p_idx); -godot_int GDAPI godot_pool_real_array_size(godot_pool_real_array *p_pra); +godot_int GDAPI godot_pool_real_array_size(const godot_pool_real_array *p_pra); void GDAPI godot_pool_real_array_destroy(godot_pool_real_array *p_pra); @@ -194,9 +197,9 @@ void GDAPI godot_pool_string_array_remove(godot_pool_string_array *p_psa, const void GDAPI godot_pool_string_array_resize(godot_pool_string_array *p_psa, const godot_int p_size); void GDAPI godot_pool_string_array_set(godot_pool_string_array *p_psa, const godot_int p_idx, const godot_string *p_data); -godot_string GDAPI godot_pool_string_array_get(godot_pool_string_array *p_psa, const godot_int p_idx); +godot_string GDAPI godot_pool_string_array_get(const godot_pool_string_array *p_psa, const godot_int p_idx); -godot_int GDAPI godot_pool_string_array_size(godot_pool_string_array *p_psa); +godot_int GDAPI godot_pool_string_array_size(const godot_pool_string_array *p_psa); void GDAPI godot_pool_string_array_destroy(godot_pool_string_array *p_psa); @@ -220,9 +223,9 @@ void GDAPI godot_pool_vector2_array_remove(godot_pool_vector2_array *p_pv2a, con void GDAPI godot_pool_vector2_array_resize(godot_pool_vector2_array *p_pv2a, const godot_int p_size); void GDAPI godot_pool_vector2_array_set(godot_pool_vector2_array *p_pv2a, const godot_int p_idx, const godot_vector2 *p_data); -godot_vector2 GDAPI godot_pool_vector2_array_get(godot_pool_vector2_array *p_pv2a, const godot_int p_idx); +godot_vector2 GDAPI godot_pool_vector2_array_get(const godot_pool_vector2_array *p_pv2a, const godot_int p_idx); -godot_int GDAPI godot_pool_vector2_array_size(godot_pool_vector2_array *p_pv2a); +godot_int GDAPI godot_pool_vector2_array_size(const godot_pool_vector2_array *p_pv2a); void GDAPI godot_pool_vector2_array_destroy(godot_pool_vector2_array *p_pv2a); @@ -246,9 +249,9 @@ void GDAPI godot_pool_vector3_array_remove(godot_pool_vector3_array *p_pv3a, con void GDAPI godot_pool_vector3_array_resize(godot_pool_vector3_array *p_pv3a, const godot_int p_size); void GDAPI godot_pool_vector3_array_set(godot_pool_vector3_array *p_pv3a, const godot_int p_idx, const godot_vector3 *p_data); -godot_vector3 GDAPI godot_pool_vector3_array_get(godot_pool_vector3_array *p_pv3a, const godot_int p_idx); +godot_vector3 GDAPI godot_pool_vector3_array_get(const godot_pool_vector3_array *p_pv3a, const godot_int p_idx); -godot_int GDAPI godot_pool_vector3_array_size(godot_pool_vector3_array *p_pv3a); +godot_int GDAPI godot_pool_vector3_array_size(const godot_pool_vector3_array *p_pv3a); void GDAPI godot_pool_vector3_array_destroy(godot_pool_vector3_array *p_pv3a); @@ -272,9 +275,9 @@ void GDAPI godot_pool_color_array_remove(godot_pool_color_array *p_pca, const go void GDAPI godot_pool_color_array_resize(godot_pool_color_array *p_pca, const godot_int p_size); void GDAPI godot_pool_color_array_set(godot_pool_color_array *p_pca, const godot_int p_idx, const godot_color *p_data); -godot_color GDAPI godot_pool_color_array_get(godot_pool_color_array *p_pca, const godot_int p_idx); +godot_color GDAPI godot_pool_color_array_get(const godot_pool_color_array *p_pca, const godot_int p_idx); -godot_int GDAPI godot_pool_color_array_size(godot_pool_color_array *p_pca); +godot_int GDAPI godot_pool_color_array_size(const godot_pool_color_array *p_pca); void GDAPI godot_pool_color_array_destroy(godot_pool_color_array *p_pca); diff --git a/modules/gdnative/godot/godot_quat.cpp b/modules/gdnative/godot/godot_quat.cpp index 7c3a71dfc0..4d38c4987c 100644 --- a/modules/gdnative/godot/godot_quat.cpp +++ b/modules/gdnative/godot/godot_quat.cpp @@ -28,77 +28,150 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "godot_quat.h" +#include "core/variant.h" -#include "math/quat.h" +#include "core/math/quat.h" #ifdef __cplusplus extern "C" { #endif -void _quat_api_anchor() { +void _quat_api_anchor() {} + +void GDAPI godot_quat_new(godot_quat *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z, const godot_real p_w) { + + Quat *dest = (Quat *)r_dest; + *dest = Quat(p_x, p_y, p_z, p_w); } -void GDAPI godot_quat_new(godot_quat *p_quat) { - Quat *quat = (Quat *)p_quat; - *quat = Quat(); +void GDAPI godot_quat_new_with_axis_angle(godot_quat *r_dest, const godot_vector3 *p_axis, const godot_real p_angle) { + const Vector3 *axis = (const Vector3 *)p_axis; + Quat *dest = (Quat *)r_dest; + *dest = Quat(*axis, p_angle); } -void GDAPI godot_quat_new_with_elements(godot_quat *p_quat, const godot_real x, const godot_real y, const godot_real z, const godot_real w) { - Quat *quat = (Quat *)p_quat; - *quat = Quat(x, y, z, w); +godot_string GDAPI godot_quat_as_string(const godot_quat *p_self) { + godot_string ret; + const Quat *self = (const Quat *)p_self; + memnew_placement(&ret, String(*self)); + return ret; } -void GDAPI godot_quat_new_with_rotation(godot_quat *p_quat, const godot_vector3 *p_axis, const godot_real p_angle) { - Quat *quat = (Quat *)p_quat; - const Vector3 *axis = (const Vector3 *)p_axis; - *quat = Quat(*axis, p_angle); -} - -void GDAPI godot_quat_new_with_shortest_arc(godot_quat *p_quat, const godot_vector3 *p_v0, const godot_vector3 *p_v1) { - Quat *quat = (Quat *)p_quat; - const Vector3 *v0 = (const Vector3 *)p_v0; - const Vector3 *v1 = (const Vector3 *)p_v1; - *quat = Quat(*v0, *v1); -} - -godot_vector3 GDAPI godot_quat_get_euler(const godot_quat *p_quat) { - Quat *quat = (Quat *)p_quat; - Vector3 euler = quat->get_euler(); - return *(godot_vector3 *)&euler; -} - -void GDAPI godot_quat_set_euler(godot_quat *p_quat, const godot_vector3 *p_euler) { - Quat *quat = (Quat *)p_quat; - const Vector3 *euler = (const Vector3 *)p_euler; - quat->set_euler(*euler); -} - -godot_real GDAPI *godot_quat_index(godot_quat *p_quat, const godot_int p_idx) { - Quat *quat = (Quat *)p_quat; - switch (p_idx) { - case 0: - return &quat->x; - case 1: - return &quat->y; - case 2: - return &quat->z; - default: - return &quat->y; - } -} - -godot_real GDAPI godot_quat_const_index(const godot_quat *p_quat, const godot_int p_idx) { - const Quat *quat = (const Quat *)p_quat; - switch (p_idx) { - case 0: - return quat->x; - case 1: - return quat->y; - case 2: - return quat->z; - default: - return quat->y; - } +godot_real GDAPI godot_quat_length(const godot_quat *p_self) { + const Quat *self = (const Quat *)p_self; + return self->length(); +} + +godot_real GDAPI godot_quat_length_squared(const godot_quat *p_self) { + const Quat *self = (const Quat *)p_self; + return self->length_squared(); +} + +godot_quat GDAPI godot_quat_normalized(const godot_quat *p_self) { + godot_quat dest; + const Quat *self = (const Quat *)p_self; + *((Quat *)&dest) = self->normalized(); + return dest; +} + +godot_bool GDAPI godot_quat_is_normalized(const godot_quat *p_self) { + const Quat *self = (const Quat *)p_self; + return self->is_normalized(); +} + +godot_quat GDAPI godot_quat_inverse(const godot_quat *p_self) { + godot_quat dest; + const Quat *self = (const Quat *)p_self; + *((Quat *)&dest) = self->inverse(); + return dest; +} + +godot_real GDAPI godot_quat_dot(const godot_quat *p_self, const godot_quat *p_b) { + const Quat *self = (const Quat *)p_self; + const Quat *b = (const Quat *)p_b; + return self->dot(*b); +} + +godot_vector3 GDAPI godot_quat_xform(const godot_quat *p_self, const godot_vector3 *p_v) { + godot_vector3 dest; + const Quat *self = (const Quat *)p_self; + const Vector3 *v = (const Vector3 *)p_v; + *((Vector3 *)&dest) = self->xform(*v); + return dest; +} + +godot_quat GDAPI godot_quat_slerp(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t) { + godot_quat dest; + const Quat *self = (const Quat *)p_self; + const Quat *b = (const Quat *)p_b; + *((Quat *)&dest) = self->slerp(*b, p_t); + return dest; +} + +godot_quat GDAPI godot_quat_slerpni(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t) { + godot_quat dest; + const Quat *self = (const Quat *)p_self; + const Quat *b = (const Quat *)p_b; + *((Quat *)&dest) = self->slerpni(*b, p_t); + return dest; +} + +godot_quat GDAPI godot_quat_cubic_slerp(const godot_quat *p_self, const godot_quat *p_b, const godot_quat *p_pre_a, const godot_quat *p_post_b, const godot_real p_t) { + godot_quat dest; + const Quat *self = (const Quat *)p_self; + const Quat *b = (const Quat *)p_b; + const Quat *pre_a = (const Quat *)p_pre_a; + const Quat *post_b = (const Quat *)p_post_b; + *((Quat *)&dest) = self->cubic_slerp(*b, *pre_a, *post_b, p_t); + return dest; +} + +godot_quat GDAPI godot_quat_operator_multiply(const godot_quat *p_self, const godot_real p_b) { + godot_quat raw_dest; + Quat *dest = (Quat *)&raw_dest; + const Quat *self = (const Quat *)p_self; + *dest = *self * p_b; + return raw_dest; +} + +godot_quat GDAPI godot_quat_operator_add(const godot_quat *p_self, const godot_quat *p_b) { + godot_quat raw_dest; + Quat *dest = (Quat *)&raw_dest; + const Quat *self = (const Quat *)p_self; + const Quat *b = (const Quat *)p_b; + *dest = *self + *b; + return raw_dest; +} + +godot_quat GDAPI godot_quat_operator_substract(const godot_quat *p_self, const godot_quat *p_b) { + godot_quat raw_dest; + Quat *dest = (Quat *)&raw_dest; + const Quat *self = (const Quat *)p_self; + const Quat *b = (const Quat *)p_b; + *dest = *self - *b; + return raw_dest; +} + +godot_quat GDAPI godot_quat_operator_divide(const godot_quat *p_self, const godot_real p_b) { + godot_quat raw_dest; + Quat *dest = (Quat *)&raw_dest; + const Quat *self = (const Quat *)p_self; + *dest = *self / p_b; + return raw_dest; +} + +godot_bool GDAPI godot_quat_operator_equal(const godot_quat *p_self, const godot_quat *p_b) { + const Quat *self = (const Quat *)p_self; + const Quat *b = (const Quat *)p_b; + return *self == *b; +} + +godot_quat GDAPI godot_quat_operator_neg(const godot_quat *p_self) { + godot_quat raw_dest; + Quat *dest = (Quat *)&raw_dest; + const Quat *self = (const Quat *)p_self; + *dest = -(*self); + return raw_dest; } #ifdef __cplusplus diff --git a/modules/gdnative/godot/godot_quat.h b/modules/gdnative/godot/godot_quat.h index 35b1acd3ed..6bdc33accf 100644 --- a/modules/gdnative/godot/godot_quat.h +++ b/modules/gdnative/godot/godot_quat.h @@ -37,23 +37,51 @@ extern "C" { #include <stdint.h> #ifndef GODOT_CORE_API_GODOT_QUAT_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_QUAT_TYPE_DEFINED typedef struct godot_quat { uint8_t _dont_touch_that[16]; } godot_quat; #endif #include "../godot.h" +#include "godot_vector3.h" -void GDAPI godot_quat_new(godot_quat *p_quat); -void GDAPI godot_quat_new_with_elements(godot_quat *p_quat, const godot_real x, const godot_real y, const godot_real z, const godot_real w); -void GDAPI godot_quat_new_with_rotation(godot_quat *p_quat, const godot_vector3 *p_axis, const godot_real p_angle); -void GDAPI godot_quat_new_with_shortest_arc(godot_quat *p_quat, const godot_vector3 *p_v0, const godot_vector3 *p_v1); +void GDAPI godot_quat_new(godot_quat *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z, const godot_real p_w); +void GDAPI godot_quat_new_with_axis_angle(godot_quat *r_dest, const godot_vector3 *p_axis, const godot_real p_angle); -godot_vector3 GDAPI godot_quat_get_euler(const godot_quat *p_quat); -void GDAPI godot_quat_set_euler(godot_quat *p_quat, const godot_vector3 *p_euler); +godot_string GDAPI godot_quat_as_string(const godot_quat *p_self); -godot_real GDAPI *godot_quat_index(godot_quat *p_quat, const godot_int p_idx); -godot_real GDAPI godot_quat_const_index(const godot_quat *p_quat, const godot_int p_idx); +godot_real GDAPI godot_quat_length(const godot_quat *p_self); + +godot_real GDAPI godot_quat_length_squared(const godot_quat *p_self); + +godot_quat GDAPI godot_quat_normalized(const godot_quat *p_self); + +godot_bool GDAPI godot_quat_is_normalized(const godot_quat *p_self); + +godot_quat GDAPI godot_quat_inverse(const godot_quat *p_self); + +godot_real GDAPI godot_quat_dot(const godot_quat *p_self, const godot_quat *p_b); + +godot_vector3 GDAPI godot_quat_xform(const godot_quat *p_self, const godot_vector3 *p_v); + +godot_quat GDAPI godot_quat_slerp(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t); + +godot_quat GDAPI godot_quat_slerpni(const godot_quat *p_self, const godot_quat *p_b, const godot_real p_t); + +godot_quat GDAPI godot_quat_cubic_slerp(const godot_quat *p_self, const godot_quat *p_b, const godot_quat *p_pre_a, const godot_quat *p_post_b, const godot_real p_t); + +godot_quat GDAPI godot_quat_operator_multiply(const godot_quat *p_self, const godot_real p_b); + +godot_quat GDAPI godot_quat_operator_add(const godot_quat *p_self, const godot_quat *p_b); + +godot_quat GDAPI godot_quat_operator_substract(const godot_quat *p_self, const godot_quat *p_b); + +godot_quat GDAPI godot_quat_operator_divide(const godot_quat *p_self, const godot_real p_b); + +godot_bool GDAPI godot_quat_operator_equal(const godot_quat *p_self, const godot_quat *p_b); + +godot_quat GDAPI godot_quat_operator_neg(const godot_quat *p_self); #ifdef __cplusplus } diff --git a/modules/gdnative/godot/godot_rect2.cpp b/modules/gdnative/godot/godot_rect2.cpp index b19096b79e..eea95ca6fe 100644 --- a/modules/gdnative/godot/godot_rect2.cpp +++ b/modules/gdnative/godot/godot_rect2.cpp @@ -28,48 +28,128 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "godot_rect2.h" +#include "core/variant.h" -#include "math/math_2d.h" +#include "core/math/math_2d.h" #ifdef __cplusplus extern "C" { #endif -void _rect2_api_anchor() { +void _rect2_api_anchor() {} + +void GDAPI godot_rect2_new_with_pos_and_size(godot_rect2 *r_dest, const godot_vector2 *p_pos, const godot_vector2 *p_size) { + const Vector2 *pos = (const Vector2 *)p_pos; + const Vector2 *size = (const Vector2 *)p_size; + Rect2 *dest = (Rect2 *)r_dest; + *dest = Rect2(*pos, *size); } -void GDAPI godot_rect2_new(godot_rect2 *p_rect) { - Rect2 *rect = (Rect2 *)p_rect; - *rect = Rect2(); +void GDAPI godot_rect2_new(godot_rect2 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_width, const godot_real p_height) { + + Rect2 *dest = (Rect2 *)r_dest; + *dest = Rect2(p_x, p_y, p_width, p_height); } -void GDAPI godot_rect2_new_with_pos_and_size(godot_rect2 *p_rect, const godot_vector2 *p_pos, const godot_vector2 *p_size) { - Rect2 *rect = (Rect2 *)p_rect; - const Vector2 *pos = (const Vector2 *)p_pos; - const Vector2 *size = (const Vector2 *)p_size; - *rect = Rect2(*pos, *size); +godot_string GDAPI godot_rect2_as_string(const godot_rect2 *p_self) { + godot_string ret; + const Rect2 *self = (const Rect2 *)p_self; + memnew_placement(&ret, String(*self)); + return ret; } -godot_vector2 GDAPI *godot_rect2_get_pos(godot_rect2 *p_rect) { - Rect2 *rect = (Rect2 *)p_rect; - return (godot_vector2 *)&rect->pos; +godot_real GDAPI godot_rect2_get_area(const godot_rect2 *p_self) { + const Rect2 *self = (const Rect2 *)p_self; + return self->get_area(); } -void GDAPI godot_rect2_set_pos(godot_rect2 *p_rect, const godot_vector2 *p_pos) { - Rect2 *rect = (Rect2 *)p_rect; - const Vector2 *pos = (const Vector2 *)p_pos; - rect->pos = *pos; +godot_bool GDAPI godot_rect2_intersects(const godot_rect2 *p_self, const godot_rect2 *p_b) { + const Rect2 *self = (const Rect2 *)p_self; + const Rect2 *b = (const Rect2 *)p_b; + return self->intersects(*b); +} + +godot_bool GDAPI godot_rect2_encloses(const godot_rect2 *p_self, const godot_rect2 *p_b) { + const Rect2 *self = (const Rect2 *)p_self; + const Rect2 *b = (const Rect2 *)p_b; + return self->encloses(*b); +} + +godot_bool GDAPI godot_rect2_has_no_area(const godot_rect2 *p_self) { + const Rect2 *self = (const Rect2 *)p_self; + return self->has_no_area(); +} + +godot_rect2 GDAPI godot_rect2_clip(const godot_rect2 *p_self, const godot_rect2 *p_b) { + godot_rect2 dest; + const Rect2 *self = (const Rect2 *)p_self; + const Rect2 *b = (const Rect2 *)p_b; + *((Rect2 *)&dest) = self->clip(*b); + return dest; +} + +godot_rect2 GDAPI godot_rect2_merge(const godot_rect2 *p_self, const godot_rect2 *p_b) { + godot_rect2 dest; + const Rect2 *self = (const Rect2 *)p_self; + const Rect2 *b = (const Rect2 *)p_b; + *((Rect2 *)&dest) = self->merge(*b); + return dest; } -godot_vector2 GDAPI *godot_rect2_get_size(godot_rect2 *p_rect) { - Rect2 *rect = (Rect2 *)p_rect; - return (godot_vector2 *)&rect->size; +godot_bool GDAPI godot_rect2_has_point(const godot_rect2 *p_self, const godot_vector2 *p_point) { + const Rect2 *self = (const Rect2 *)p_self; + const Vector2 *point = (const Vector2 *)p_point; + return self->has_point(*point); +} + +godot_rect2 GDAPI godot_rect2_grow(const godot_rect2 *p_self, const godot_real p_by) { + godot_rect2 dest; + const Rect2 *self = (const Rect2 *)p_self; + + *((Rect2 *)&dest) = self->grow(p_by); + return dest; +} + +godot_rect2 GDAPI godot_rect2_expand(const godot_rect2 *p_self, const godot_vector2 *p_to) { + godot_rect2 dest; + const Rect2 *self = (const Rect2 *)p_self; + const Vector2 *to = (const Vector2 *)p_to; + *((Rect2 *)&dest) = self->expand(*to); + return dest; +} + +godot_bool GDAPI godot_rect2_operator_equal(const godot_rect2 *p_self, const godot_rect2 *p_b) { + const Rect2 *self = (const Rect2 *)p_self; + const Rect2 *b = (const Rect2 *)p_b; + return *self == *b; +} + +godot_vector2 GDAPI godot_rect2_get_pos(const godot_rect2 *p_self) { + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Rect2 *self = (const Rect2 *)p_self; + *d = self->get_pos(); + return dest; +} + +godot_vector2 GDAPI godot_rect2_get_size(const godot_rect2 *p_self) { + godot_vector2 dest; + Vector2 *d = (Vector2 *)&dest; + const Rect2 *self = (const Rect2 *)p_self; + *d = self->get_size(); + return dest; +} + +void GDAPI godot_rect2_set_pos(godot_rect2 *p_self, const godot_vector2 *p_pos) { + Rect2 *self = (Rect2 *)p_self; + const Vector2 *pos = (const Vector2 *)p_pos; + self->set_pos(*pos); } -void GDAPI godot_rect2_set_size(godot_rect2 *p_rect, const godot_vector2 *p_size) { - Rect2 *rect = (Rect2 *)p_rect; +void GDAPI godot_rect2_set_size(godot_rect2 *p_self, const godot_vector2 *p_size) { + Rect2 *self = (Rect2 *)p_self; const Vector2 *size = (const Vector2 *)p_size; - rect->size = *size; + self->set_size(*size); } #ifdef __cplusplus diff --git a/modules/gdnative/godot/godot_rect2.h b/modules/gdnative/godot/godot_rect2.h index e9e4a26897..9743321a3b 100644 --- a/modules/gdnative/godot/godot_rect2.h +++ b/modules/gdnative/godot/godot_rect2.h @@ -37,24 +37,50 @@ extern "C" { #include <stdint.h> #ifndef GODOT_CORE_API_GODOT_RECT2_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_RECT2_TYPE_DEFINED typedef struct godot_rect2 { uint8_t _dont_touch_that[16]; } godot_rect2; #endif #include "../godot.h" +#include "godot_vector2.h" -void GDAPI godot_rect2_new(godot_rect2 *p_rect); -void GDAPI godot_rect2_new_with_pos_and_size(godot_rect2 *p_rect, const godot_vector2 *p_pos, const godot_vector2 *p_size); +void GDAPI godot_rect2_new_with_pos_and_size(godot_rect2 *r_dest, const godot_vector2 *p_pos, const godot_vector2 *p_size); +void GDAPI godot_rect2_new(godot_rect2 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_width, const godot_real p_height); -godot_vector2 GDAPI *godot_rect2_get_pos(godot_rect2 *p_rect); -void GDAPI godot_rect2_set_pos(godot_rect2 *p_rect, const godot_vector2 *p_pos); +godot_string GDAPI godot_rect2_as_string(const godot_rect2 *p_self); -godot_vector2 GDAPI *godot_rect2_get_size(godot_rect2 *p_rect); -void GDAPI godot_rect2_set_size(godot_rect2 *p_rect, const godot_vector2 *p_size); +godot_real GDAPI godot_rect2_get_area(const godot_rect2 *p_self); + +godot_bool GDAPI godot_rect2_intersects(const godot_rect2 *p_self, const godot_rect2 *p_b); + +godot_bool GDAPI godot_rect2_encloses(const godot_rect2 *p_self, const godot_rect2 *p_b); + +godot_bool GDAPI godot_rect2_has_no_area(const godot_rect2 *p_self); + +godot_rect2 GDAPI godot_rect2_clip(const godot_rect2 *p_self, const godot_rect2 *p_b); + +godot_rect2 GDAPI godot_rect2_merge(const godot_rect2 *p_self, const godot_rect2 *p_b); + +godot_bool GDAPI godot_rect2_has_point(const godot_rect2 *p_self, const godot_vector2 *p_point); + +godot_rect2 GDAPI godot_rect2_grow(const godot_rect2 *p_self, const godot_real p_by); + +godot_rect2 GDAPI godot_rect2_expand(const godot_rect2 *p_self, const godot_vector2 *p_to); + +godot_bool GDAPI godot_rect2_operator_equal(const godot_rect2 *p_self, const godot_rect2 *p_b); + +godot_vector2 GDAPI godot_rect2_get_pos(const godot_rect2 *p_self); + +godot_vector2 GDAPI godot_rect2_get_size(const godot_rect2 *p_self); + +void GDAPI godot_rect2_set_pos(godot_rect2 *p_self, const godot_vector2 *p_pos); + +void GDAPI godot_rect2_set_size(godot_rect2 *p_self, const godot_vector2 *p_size); #ifdef __cplusplus } #endif -#endif // GODOT_RECT3_H +#endif // GODOT_RECT2_H diff --git a/modules/gdnative/godot/godot_rect3.cpp b/modules/gdnative/godot/godot_rect3.cpp index 96c5d17b1a..c4f8a853c2 100644 --- a/modules/gdnative/godot/godot_rect3.cpp +++ b/modules/gdnative/godot/godot_rect3.cpp @@ -28,48 +28,162 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "godot_rect3.h" +#include "core/variant.h" -#include "math/rect3.h" +#include "core/math/rect3.h" #ifdef __cplusplus extern "C" { #endif -void _rect3_api_anchor() { +void _rect3_api_anchor() {} + +void GDAPI godot_rect3_new(godot_rect3 *r_dest, const godot_vector3 *p_pos, const godot_vector3 *p_size) { + const Vector3 *pos = (const Vector3 *)p_pos; + const Vector3 *size = (const Vector3 *)p_size; + Rect3 *dest = (Rect3 *)r_dest; + *dest = Rect3(*pos, *size); } -void GDAPI godot_rect3_new(godot_rect3 *p_rect) { - Rect3 *rect = (Rect3 *)p_rect; - *rect = Rect3(); +godot_string GDAPI godot_rect3_as_string(const godot_rect3 *p_self) { + godot_string ret; + const Rect3 *self = (const Rect3 *)p_self; + memnew_placement(&ret, String(*self)); + return ret; } -void GDAPI godot_rect3_new_with_pos_and_size(godot_rect3 *p_rect, const godot_vector3 *p_pos, const godot_vector3 *p_size) { - Rect3 *rect = (Rect3 *)p_rect; - const Vector3 *pos = (const Vector3 *)p_pos; - const Vector3 *size = (const Vector3 *)p_size; - *rect = Rect3(*pos, *size); +godot_real GDAPI godot_rect3_get_area(const godot_rect3 *p_self) { + const Rect3 *self = (const Rect3 *)p_self; + return self->get_area(); } -godot_vector3 GDAPI *godot_rect3_get_pos(godot_rect3 *p_rect) { - Rect3 *rect = (Rect3 *)p_rect; - return (godot_vector3 *)&rect->pos; +godot_bool GDAPI godot_rect3_has_no_area(const godot_rect3 *p_self) { + const Rect3 *self = (const Rect3 *)p_self; + return self->has_no_area(); } -void GDAPI godot_rect3_set_pos(godot_rect3 *p_rect, const godot_vector3 *p_pos) { - Rect3 *rect = (Rect3 *)p_rect; - const Vector3 *pos = (const Vector3 *)p_pos; - rect->pos = *pos; +godot_bool GDAPI godot_rect3_has_no_surface(const godot_rect3 *p_self) { + const Rect3 *self = (const Rect3 *)p_self; + return self->has_no_surface(); } -godot_vector3 GDAPI *godot_rect3_get_size(godot_rect3 *p_rect) { - Rect3 *rect = (Rect3 *)p_rect; - return (godot_vector3 *)&rect->size; +godot_bool GDAPI godot_rect3_intersects(const godot_rect3 *p_self, const godot_rect3 *p_with) { + const Rect3 *self = (const Rect3 *)p_self; + const Rect3 *with = (const Rect3 *)p_with; + return self->intersects(*with); } -void GDAPI godot_rect3_set_size(godot_rect3 *p_rect, const godot_vector3 *p_size) { - Rect3 *rect = (Rect3 *)p_rect; - const Vector3 *size = (const Vector3 *)p_size; - rect->size = *size; +godot_bool GDAPI godot_rect3_encloses(const godot_rect3 *p_self, const godot_rect3 *p_with) { + const Rect3 *self = (const Rect3 *)p_self; + const Rect3 *with = (const Rect3 *)p_with; + return self->encloses(*with); +} + +godot_rect3 GDAPI godot_rect3_merge(const godot_rect3 *p_self, const godot_rect3 *p_with) { + godot_rect3 dest; + const Rect3 *self = (const Rect3 *)p_self; + const Rect3 *with = (const Rect3 *)p_with; + *((Rect3 *)&dest) = self->merge(*with); + return dest; +} + +godot_rect3 GDAPI godot_rect3_intersection(const godot_rect3 *p_self, const godot_rect3 *p_with) { + godot_rect3 dest; + const Rect3 *self = (const Rect3 *)p_self; + const Rect3 *with = (const Rect3 *)p_with; + *((Rect3 *)&dest) = self->intersection(*with); + return dest; +} + +godot_bool GDAPI godot_rect3_intersects_plane(const godot_rect3 *p_self, const godot_plane *p_plane) { + const Rect3 *self = (const Rect3 *)p_self; + const Plane *plane = (const Plane *)p_plane; + return self->intersects_plane(*plane); +} + +godot_bool GDAPI godot_rect3_intersects_segment(const godot_rect3 *p_self, const godot_vector3 *p_from, const godot_vector3 *p_to) { + const Rect3 *self = (const Rect3 *)p_self; + const Vector3 *from = (const Vector3 *)p_from; + const Vector3 *to = (const Vector3 *)p_to; + return self->intersects_segment(*from, *to); +} + +godot_bool GDAPI godot_rect3_has_point(const godot_rect3 *p_self, const godot_vector3 *p_point) { + const Rect3 *self = (const Rect3 *)p_self; + const Vector3 *point = (const Vector3 *)p_point; + return self->has_point(*point); +} + +godot_vector3 GDAPI godot_rect3_get_support(const godot_rect3 *p_self, const godot_vector3 *p_dir) { + godot_vector3 dest; + const Rect3 *self = (const Rect3 *)p_self; + const Vector3 *dir = (const Vector3 *)p_dir; + *((Vector3 *)&dest) = self->get_support(*dir); + return dest; +} + +godot_vector3 GDAPI godot_rect3_get_longest_axis(const godot_rect3 *p_self) { + godot_vector3 dest; + const Rect3 *self = (const Rect3 *)p_self; + *((Vector3 *)&dest) = self->get_longest_axis(); + return dest; +} + +godot_int GDAPI godot_rect3_get_longest_axis_index(const godot_rect3 *p_self) { + const Rect3 *self = (const Rect3 *)p_self; + return self->get_longest_axis_index(); +} + +godot_real GDAPI godot_rect3_get_longest_axis_size(const godot_rect3 *p_self) { + const Rect3 *self = (const Rect3 *)p_self; + return self->get_longest_axis_size(); +} + +godot_vector3 GDAPI godot_rect3_get_shortest_axis(const godot_rect3 *p_self) { + godot_vector3 dest; + const Rect3 *self = (const Rect3 *)p_self; + *((Vector3 *)&dest) = self->get_shortest_axis(); + return dest; +} + +godot_int GDAPI godot_rect3_get_shortest_axis_index(const godot_rect3 *p_self) { + const Rect3 *self = (const Rect3 *)p_self; + return self->get_shortest_axis_index(); +} + +godot_real GDAPI godot_rect3_get_shortest_axis_size(const godot_rect3 *p_self) { + const Rect3 *self = (const Rect3 *)p_self; + return self->get_shortest_axis_size(); +} + +godot_rect3 GDAPI godot_rect3_expand(const godot_rect3 *p_self, const godot_vector3 *p_to_point) { + godot_rect3 dest; + const Rect3 *self = (const Rect3 *)p_self; + const Vector3 *to_point = (const Vector3 *)p_to_point; + *((Rect3 *)&dest) = self->expand(*to_point); + return dest; +} + +godot_rect3 GDAPI godot_rect3_grow(const godot_rect3 *p_self, const godot_real p_by) { + godot_rect3 dest; + const Rect3 *self = (const Rect3 *)p_self; + + *((Rect3 *)&dest) = self->grow(p_by); + return dest; +} + +godot_vector3 GDAPI godot_rect3_get_endpoint(const godot_rect3 *p_self, const godot_int p_idx) { + godot_vector3 dest; + const Rect3 *self = (const Rect3 *)p_self; + + *((Vector3 *)&dest) = self->get_endpoint(p_idx); + return dest; +} + +godot_bool GDAPI godot_rect3_operator_equal(const godot_rect3 *p_self, const godot_rect3 *p_b) { + const Rect3 *self = (const Rect3 *)p_self; + const Rect3 *b = (const Rect3 *)p_b; + return *self == *b; } #ifdef __cplusplus diff --git a/modules/gdnative/godot/godot_rect3.h b/modules/gdnative/godot/godot_rect3.h index 562ac8379e..95969ab20e 100644 --- a/modules/gdnative/godot/godot_rect3.h +++ b/modules/gdnative/godot/godot_rect3.h @@ -37,21 +37,61 @@ extern "C" { #include <stdint.h> #ifndef GODOT_CORE_API_GODOT_RECT3_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_RECT3_TYPE_DEFINED typedef struct godot_rect3 { uint8_t _dont_touch_that[24]; } godot_rect3; #endif #include "../godot.h" +#include "godot_plane.h" +#include "godot_vector3.h" -void GDAPI godot_rect3_new(godot_rect3 *p_rect); -void GDAPI godot_rect3_new_with_pos_and_size(godot_rect3 *p_rect, const godot_vector3 *p_pos, const godot_vector3 *p_size); +void GDAPI godot_rect3_new(godot_rect3 *r_dest, const godot_vector3 *p_pos, const godot_vector3 *p_size); -godot_vector3 GDAPI *godot_rect3_get_pos(godot_rect3 *p_rect); -void GDAPI godot_rect3_set_pos(godot_rect3 *p_rect, const godot_vector3 *p_pos); +godot_string GDAPI godot_rect3_as_string(const godot_rect3 *p_self); -godot_vector3 GDAPI *godot_rect3_get_size(godot_rect3 *p_rect); -void GDAPI godot_rect3_set_size(godot_rect3 *p_rect, const godot_vector3 *p_size); +godot_real GDAPI godot_rect3_get_area(const godot_rect3 *p_self); + +godot_bool GDAPI godot_rect3_has_no_area(const godot_rect3 *p_self); + +godot_bool GDAPI godot_rect3_has_no_surface(const godot_rect3 *p_self); + +godot_bool GDAPI godot_rect3_intersects(const godot_rect3 *p_self, const godot_rect3 *p_with); + +godot_bool GDAPI godot_rect3_encloses(const godot_rect3 *p_self, const godot_rect3 *p_with); + +godot_rect3 GDAPI godot_rect3_merge(const godot_rect3 *p_self, const godot_rect3 *p_with); + +godot_rect3 GDAPI godot_rect3_intersection(const godot_rect3 *p_self, const godot_rect3 *p_with); + +godot_bool GDAPI godot_rect3_intersects_plane(const godot_rect3 *p_self, const godot_plane *p_plane); + +godot_bool GDAPI godot_rect3_intersects_segment(const godot_rect3 *p_self, const godot_vector3 *p_from, const godot_vector3 *p_to); + +godot_bool GDAPI godot_rect3_has_point(const godot_rect3 *p_self, const godot_vector3 *p_point); + +godot_vector3 GDAPI godot_rect3_get_support(const godot_rect3 *p_self, const godot_vector3 *p_dir); + +godot_vector3 GDAPI godot_rect3_get_longest_axis(const godot_rect3 *p_self); + +godot_int GDAPI godot_rect3_get_longest_axis_index(const godot_rect3 *p_self); + +godot_real GDAPI godot_rect3_get_longest_axis_size(const godot_rect3 *p_self); + +godot_vector3 GDAPI godot_rect3_get_shortest_axis(const godot_rect3 *p_self); + +godot_int GDAPI godot_rect3_get_shortest_axis_index(const godot_rect3 *p_self); + +godot_real GDAPI godot_rect3_get_shortest_axis_size(const godot_rect3 *p_self); + +godot_rect3 GDAPI godot_rect3_expand(const godot_rect3 *p_self, const godot_vector3 *p_to_point); + +godot_rect3 GDAPI godot_rect3_grow(const godot_rect3 *p_self, const godot_real p_by); + +godot_vector3 GDAPI godot_rect3_get_endpoint(const godot_rect3 *p_self, const godot_int p_idx); + +godot_bool GDAPI godot_rect3_operator_equal(const godot_rect3 *p_self, const godot_rect3 *p_b); #ifdef __cplusplus } diff --git a/modules/gdnative/godot/godot_rid.cpp b/modules/gdnative/godot/godot_rid.cpp index fff31e3992..343c004bff 100644 --- a/modules/gdnative/godot/godot_rid.cpp +++ b/modules/gdnative/godot/godot_rid.cpp @@ -28,36 +28,46 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "godot_rid.h" +#include "core/variant.h" -#include "object.h" -#include "resource.h" +#include "core/resource.h" +#include "core/rid.h" #ifdef __cplusplus extern "C" { #endif -void _rid_api_anchor() { -} - -void GDAPI godot_rid_new(godot_rid *p_rid, godot_object *p_from) { +void _rid_api_anchor() {} - Resource *res_from = ((Object *)p_from)->cast_to<Resource>(); +void GDAPI godot_rid_new(godot_rid *r_dest) { + RID *dest = (RID *)r_dest; + memnew_placement(dest, RID); +} - RID *rid = (RID *)p_rid; - memnew_placement(rid, RID); +godot_int GDAPI godot_rid_get_id(const godot_rid *p_self) { + const RID *self = (const RID *)p_self; + return self->get_id(); +} +void GDAPI godot_rid_new_with_resource(godot_rid *r_dest, const godot_object *p_from) { + const Resource *res_from = ((const Object *)p_from)->cast_to<Resource>(); + godot_rid_new(r_dest); if (res_from) { - *rid = RID(res_from->get_rid()); + RID *dest = (RID *)r_dest; + *dest = RID(res_from->get_rid()); } } -uint32_t GDAPI godot_rid_get_rid(const godot_rid *p_rid) { - RID *rid = (RID *)p_rid; - return rid->get_id(); +godot_bool GDAPI godot_rid_operator_equal(const godot_rid *p_self, const godot_rid *p_b) { + const RID *self = (const RID *)p_self; + const RID *b = (const RID *)p_b; + return *self == *b; } -void GDAPI godot_rid_destroy(godot_rid *p_rid) { - ((RID *)p_rid)->~RID(); +godot_bool GDAPI godot_rid_operator_less(const godot_rid *p_self, const godot_rid *p_b) { + const RID *self = (const RID *)p_self; + const RID *b = (const RID *)p_b; + return *self < *b; } #ifdef __cplusplus diff --git a/modules/gdnative/godot/godot_rid.h b/modules/gdnative/godot/godot_rid.h index e00c8f89ad..25dc8d965e 100644 --- a/modules/gdnative/godot/godot_rid.h +++ b/modules/gdnative/godot/godot_rid.h @@ -37,6 +37,7 @@ extern "C" { #include <stdint.h> #ifndef GODOT_CORE_API_GODOT_RID_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_RID_TYPE_DEFINED typedef struct godot_rid { uint8_t _dont_touch_that[8]; } godot_rid; @@ -44,11 +45,15 @@ typedef struct godot_rid { #include "../godot.h" -void GDAPI godot_rid_new(godot_rid *p_rid, godot_object *p_from); +void GDAPI godot_rid_new(godot_rid *r_dest); -uint32_t GDAPI godot_rid_get_rid(const godot_rid *p_rid); +godot_int GDAPI godot_rid_get_id(const godot_rid *p_self); -void GDAPI godot_rid_destroy(godot_rid *p_rid); +void GDAPI godot_rid_new_with_resource(godot_rid *r_dest, const godot_object *p_from); + +godot_bool GDAPI godot_rid_operator_equal(const godot_rid *p_self, const godot_rid *p_b); + +godot_bool GDAPI godot_rid_operator_less(const godot_rid *p_self, const godot_rid *p_b); #ifdef __cplusplus } diff --git a/modules/gdnative/godot/godot_string.cpp b/modules/gdnative/godot/godot_string.cpp index 92c0b04041..59d20c6d23 100644 --- a/modules/gdnative/godot/godot_string.cpp +++ b/modules/gdnative/godot/godot_string.cpp @@ -53,6 +53,12 @@ void GDAPI godot_string_new_data(godot_string *p_str, const char *p_contents, co *p = String::utf8(p_contents, p_size); } +void GDAPI godot_string_new_unicode_data(godot_string *p_str, const wchar_t *p_contents, const int p_size) { + String *p = (String *)p_str; + memnew_placement(p, String); + *p = String(p_contents, p_size); +} + void GDAPI godot_string_get_data(const godot_string *p_str, char *p_dest, int *p_size) { String *p = (String *)p_str; if (p_size != NULL) { diff --git a/modules/gdnative/godot/godot_string.h b/modules/gdnative/godot/godot_string.h index 83ed5d6ec1..e0ba298a9c 100644 --- a/modules/gdnative/godot/godot_string.h +++ b/modules/gdnative/godot/godot_string.h @@ -47,6 +47,7 @@ typedef struct godot_string { void GDAPI godot_string_new(godot_string *p_str); void GDAPI godot_string_new_data(godot_string *p_str, const char *p_contents, const int p_size); +void GDAPI godot_string_new_unicode_data(godot_string *p_str, const wchar_t *p_contents, const int p_size); void GDAPI godot_string_get_data(const godot_string *p_str, char *p_dest, int *p_size); diff --git a/modules/gdnative/godot/godot_transform.cpp b/modules/gdnative/godot/godot_transform.cpp index 681c2b049a..f5a012f59c 100644 --- a/modules/gdnative/godot/godot_transform.cpp +++ b/modules/gdnative/godot/godot_transform.cpp @@ -28,42 +28,168 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "godot_transform.h" +#include "core/variant.h" -#include "math/transform.h" +#include "core/math/transform.h" #ifdef __cplusplus extern "C" { #endif -void _transform_api_anchor() { -} +void _transform_api_anchor() {} -void GDAPI godot_transform_new(godot_transform *p_trans) { - Transform *trans = (Transform *)p_trans; - *trans = Transform(); +void GDAPI godot_transform_new_with_axis_origin(godot_transform *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis, const godot_vector3 *p_origin) { + const Vector3 *x_axis = (const Vector3 *)p_x_axis; + const Vector3 *y_axis = (const Vector3 *)p_y_axis; + const Vector3 *z_axis = (const Vector3 *)p_z_axis; + const Vector3 *origin = (const Vector3 *)p_origin; + Transform *dest = (Transform *)r_dest; + dest->basis.set_axis(0, *x_axis); + dest->basis.set_axis(1, *y_axis); + dest->basis.set_axis(2, *z_axis); + dest->origin = *origin; } -void GDAPI godot_transform_new_with_basis(godot_transform *p_trans, const godot_basis *p_basis) { - Transform *trans = (Transform *)p_trans; +void GDAPI godot_transform_new(godot_transform *r_dest, const godot_basis *p_basis, const godot_vector3 *p_origin) { const Basis *basis = (const Basis *)p_basis; - *trans = Transform(*basis); + const Vector3 *origin = (const Vector3 *)p_origin; + Transform *dest = (Transform *)r_dest; + *dest = Transform(*basis, *origin); } -void GDAPI godot_transform_new_with_basis_origin(godot_transform *p_trans, const godot_basis *p_basis, const godot_vector3 *p_origin) { - Transform *trans = (Transform *)p_trans; - const Basis *basis = (const Basis *)p_basis; - const Vector3 *origin = (const Vector3 *)p_origin; - *trans = Transform(*basis, *origin); +godot_string GDAPI godot_transform_as_string(const godot_transform *p_self) { + godot_string ret; + const Transform *self = (const Transform *)p_self; + memnew_placement(&ret, String(*self)); + return ret; +} + +godot_transform GDAPI godot_transform_inverse(const godot_transform *p_self) { + godot_transform dest; + const Transform *self = (const Transform *)p_self; + *((Transform *)&dest) = self->inverse(); + return dest; +} + +godot_transform GDAPI godot_transform_affine_inverse(const godot_transform *p_self) { + godot_transform dest; + const Transform *self = (const Transform *)p_self; + *((Transform *)&dest) = self->affine_inverse(); + return dest; +} + +godot_transform GDAPI godot_transform_orthonormalized(const godot_transform *p_self) { + godot_transform dest; + const Transform *self = (const Transform *)p_self; + *((Transform *)&dest) = self->orthonormalized(); + return dest; +} + +godot_transform GDAPI godot_transform_rotated(const godot_transform *p_self, const godot_vector3 *p_axis, const godot_real p_phi) { + godot_transform dest; + const Transform *self = (const Transform *)p_self; + const Vector3 *axis = (const Vector3 *)p_axis; + *((Transform *)&dest) = self->rotated(*axis, p_phi); + return dest; +} + +godot_transform GDAPI godot_transform_scaled(const godot_transform *p_self, const godot_vector3 *p_scale) { + godot_transform dest; + const Transform *self = (const Transform *)p_self; + const Vector3 *scale = (const Vector3 *)p_scale; + *((Transform *)&dest) = self->scaled(*scale); + return dest; +} + +godot_transform GDAPI godot_transform_translated(const godot_transform *p_self, const godot_vector3 *p_ofs) { + godot_transform dest; + const Transform *self = (const Transform *)p_self; + const Vector3 *ofs = (const Vector3 *)p_ofs; + *((Transform *)&dest) = self->translated(*ofs); + return dest; +} + +godot_transform GDAPI godot_transform_looking_at(const godot_transform *p_self, const godot_vector3 *p_target, const godot_vector3 *p_up) { + godot_transform dest; + const Transform *self = (const Transform *)p_self; + const Vector3 *target = (const Vector3 *)p_target; + const Vector3 *up = (const Vector3 *)p_up; + *((Transform *)&dest) = self->looking_at(*target, *up); + return dest; +} + +godot_plane GDAPI godot_transform_xform_plane(const godot_transform *p_self, const godot_plane *p_v) { + godot_plane raw_dest; + Plane *dest = (Plane *)&raw_dest; + const Transform *self = (const Transform *)p_self; + const Plane *v = (const Plane *)p_v; + *dest = self->xform(*v); + return raw_dest; +} + +godot_plane GDAPI godot_transform_xform_inv_plane(const godot_transform *p_self, const godot_plane *p_v) { + godot_plane raw_dest; + Plane *dest = (Plane *)&raw_dest; + const Transform *self = (const Transform *)p_self; + const Plane *v = (const Plane *)p_v; + *dest = self->xform_inv(*v); + return raw_dest; +} + +void GDAPI godot_transform_new_identity(godot_transform *r_dest) { + Transform *dest = (Transform *)r_dest; + *dest = Transform(); +} + +godot_bool GDAPI godot_transform_operator_equal(const godot_transform *p_self, const godot_transform *p_b) { + const Transform *self = (const Transform *)p_self; + const Transform *b = (const Transform *)p_b; + return *self == *b; +} + +godot_transform GDAPI godot_transform_operator_multiply(const godot_transform *p_self, const godot_transform *p_b) { + godot_transform raw_dest; + Transform *dest = (Transform *)&raw_dest; + const Transform *self = (const Transform *)p_self; + const Transform *b = (const Transform *)p_b; + *dest = *self * *b; + return raw_dest; +} + +godot_vector3 GDAPI godot_transform_xform_vector3(const godot_transform *p_self, const godot_vector3 *p_v) { + godot_vector3 raw_dest; + Vector3 *dest = (Vector3 *)&raw_dest; + const Transform *self = (const Transform *)p_self; + const Vector3 *v = (const Vector3 *)p_v; + *dest = self->xform(*v); + return raw_dest; +} + +godot_vector3 GDAPI godot_transform_xform_inv_vector3(const godot_transform *p_self, const godot_vector3 *p_v) { + godot_vector3 raw_dest; + Vector3 *dest = (Vector3 *)&raw_dest; + const Transform *self = (const Transform *)p_self; + const Vector3 *v = (const Vector3 *)p_v; + *dest = self->xform_inv(*v); + return raw_dest; } -godot_basis GDAPI *godot_transform_get_basis(godot_transform *p_trans) { - Transform *trans = (Transform *)p_trans; - return (godot_basis *)&trans->basis; +godot_rect3 GDAPI godot_transform_xform_rect3(const godot_transform *p_self, const godot_rect3 *p_v) { + godot_rect3 raw_dest; + Rect3 *dest = (Rect3 *)&raw_dest; + const Transform *self = (const Transform *)p_self; + const Rect3 *v = (const Rect3 *)p_v; + *dest = self->xform(*v); + return raw_dest; } -godot_vector3 GDAPI *godot_transform_get_origin(godot_transform *p_trans) { - Transform *trans = (Transform *)p_trans; - return (godot_vector3 *)&trans->origin; +godot_rect3 GDAPI godot_transform_xform_inv_rect3(const godot_transform *p_self, const godot_rect3 *p_v) { + godot_rect3 raw_dest; + Rect3 *dest = (Rect3 *)&raw_dest; + const Transform *self = (const Transform *)p_self; + const Rect3 *v = (const Rect3 *)p_v; + *dest = self->xform_inv(*v); + return raw_dest; } #ifdef __cplusplus diff --git a/modules/gdnative/godot/godot_transform.h b/modules/gdnative/godot/godot_transform.h index 93817ffbf2..b15efc23b8 100644 --- a/modules/gdnative/godot/godot_transform.h +++ b/modules/gdnative/godot/godot_transform.h @@ -37,19 +37,53 @@ extern "C" { #include <stdint.h> #ifndef GODOT_CORE_API_GODOT_TRANSFORM_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_TRANSFORM_TYPE_DEFINED typedef struct godot_transform { uint8_t _dont_touch_that[48]; } godot_transform; #endif #include "../godot.h" +#include "godot_basis.h" +#include "godot_variant.h" +#include "godot_vector3.h" -void GDAPI godot_transform_new(godot_transform *p_trans); -void GDAPI godot_transform_new_with_basis(godot_transform *p_trans, const godot_basis *p_basis); -void GDAPI godot_transform_new_with_basis_origin(godot_transform *p_trans, const godot_basis *p_basis, const godot_vector3 *p_origin); +void GDAPI godot_transform_new_with_axis_origin(godot_transform *r_dest, const godot_vector3 *p_x_axis, const godot_vector3 *p_y_axis, const godot_vector3 *p_z_axis, const godot_vector3 *p_origin); +void GDAPI godot_transform_new(godot_transform *r_dest, const godot_basis *p_basis, const godot_vector3 *p_origin); -godot_basis GDAPI *godot_transform_get_basis(godot_transform *p_trans); -godot_vector3 GDAPI *godot_transform_get_origin(godot_transform *p_trans); +godot_string GDAPI godot_transform_as_string(const godot_transform *p_self); + +godot_transform GDAPI godot_transform_inverse(const godot_transform *p_self); + +godot_transform GDAPI godot_transform_affine_inverse(const godot_transform *p_self); + +godot_transform GDAPI godot_transform_orthonormalized(const godot_transform *p_self); + +godot_transform GDAPI godot_transform_rotated(const godot_transform *p_self, const godot_vector3 *p_axis, const godot_real p_phi); + +godot_transform GDAPI godot_transform_scaled(const godot_transform *p_self, const godot_vector3 *p_scale); + +godot_transform GDAPI godot_transform_translated(const godot_transform *p_self, const godot_vector3 *p_ofs); + +godot_transform GDAPI godot_transform_looking_at(const godot_transform *p_self, const godot_vector3 *p_target, const godot_vector3 *p_up); + +godot_plane GDAPI godot_transform_xform_plane(const godot_transform *p_self, const godot_plane *p_v); + +godot_plane GDAPI godot_transform_xform_inv_plane(const godot_transform *p_self, const godot_plane *p_v); + +void GDAPI godot_transform_new_identity(godot_transform *r_dest); + +godot_bool GDAPI godot_transform_operator_equal(const godot_transform *p_self, const godot_transform *p_b); + +godot_transform GDAPI godot_transform_operator_multiply(const godot_transform *p_self, const godot_transform *p_b); + +godot_vector3 GDAPI godot_transform_xform_vector3(const godot_transform *p_self, const godot_vector3 *p_v); + +godot_vector3 GDAPI godot_transform_xform_inv_vector3(const godot_transform *p_self, const godot_vector3 *p_v); + +godot_rect3 GDAPI godot_transform_xform_rect3(const godot_transform *p_self, const godot_rect3 *p_v); + +godot_rect3 GDAPI godot_transform_xform_inv_rect3(const godot_transform *p_self, const godot_rect3 *p_v); #ifdef __cplusplus } diff --git a/modules/gdnative/godot/godot_transform2d.cpp b/modules/gdnative/godot/godot_transform2d.cpp index ffc7167559..bdb5476f7d 100644 --- a/modules/gdnative/godot/godot_transform2d.cpp +++ b/modules/gdnative/godot/godot_transform2d.cpp @@ -28,60 +28,182 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "godot_transform2d.h" +#include "core/variant.h" -#include "../godot.h" - -#include "math/math_2d.h" +#include "core/math/math_2d.h" #ifdef __cplusplus extern "C" { #endif -void _transform2d_api_anchor() { +void _transform2d_api_anchor() {} + +void GDAPI godot_transform2d_new(godot_transform2d *r_dest, const godot_real p_rot, const godot_vector2 *p_pos) { + const Vector2 *pos = (const Vector2 *)p_pos; + Transform2D *dest = (Transform2D *)r_dest; + *dest = Transform2D(p_rot, *pos); +} + +void GDAPI godot_transform2d_new_axis_origin(godot_transform2d *r_dest, const godot_vector2 *p_x_axis, const godot_vector2 *p_y_axis, const godot_vector2 *p_origin) { + const Vector2 *x_axis = (const Vector2 *)p_x_axis; + const Vector2 *y_axis = (const Vector2 *)p_y_axis; + const Vector2 *origin = (const Vector2 *)p_origin; + Transform2D *dest = (Transform2D *)r_dest; + *dest = Transform2D(x_axis->x, x_axis->y, y_axis->x, y_axis->y, origin->x, origin->y); +} + +godot_string GDAPI godot_transform2d_as_string(const godot_transform2d *p_self) { + godot_string ret; + const Transform2D *self = (const Transform2D *)p_self; + memnew_placement(&ret, String(*self)); + return ret; +} + +godot_transform2d GDAPI godot_transform2d_inverse(const godot_transform2d *p_self) { + godot_transform2d dest; + const Transform2D *self = (const Transform2D *)p_self; + *((Transform2D *)&dest) = self->inverse(); + return dest; +} + +godot_transform2d GDAPI godot_transform2d_affine_inverse(const godot_transform2d *p_self) { + godot_transform2d dest; + const Transform2D *self = (const Transform2D *)p_self; + *((Transform2D *)&dest) = self->affine_inverse(); + return dest; +} + +godot_real GDAPI godot_transform2d_get_rotation(const godot_transform2d *p_self) { + const Transform2D *self = (const Transform2D *)p_self; + return self->get_rotation(); +} + +godot_vector2 GDAPI godot_transform2d_get_origin(const godot_transform2d *p_self) { + godot_vector2 dest; + const Transform2D *self = (const Transform2D *)p_self; + *((Vector2 *)&dest) = self->get_origin(); + return dest; +} + +godot_vector2 GDAPI godot_transform2d_get_scale(const godot_transform2d *p_self) { + godot_vector2 dest; + const Transform2D *self = (const Transform2D *)p_self; + *((Vector2 *)&dest) = self->get_scale(); + return dest; +} + +godot_transform2d GDAPI godot_transform2d_orthonormalized(const godot_transform2d *p_self) { + godot_transform2d dest; + const Transform2D *self = (const Transform2D *)p_self; + *((Transform2D *)&dest) = self->orthonormalized(); + return dest; +} + +godot_transform2d GDAPI godot_transform2d_rotated(const godot_transform2d *p_self, const godot_real p_phi) { + godot_transform2d dest; + const Transform2D *self = (const Transform2D *)p_self; + + *((Transform2D *)&dest) = self->rotated(p_phi); + return dest; +} + +godot_transform2d GDAPI godot_transform2d_scaled(const godot_transform2d *p_self, const godot_vector2 *p_scale) { + godot_transform2d dest; + const Transform2D *self = (const Transform2D *)p_self; + const Vector2 *scale = (const Vector2 *)p_scale; + *((Transform2D *)&dest) = self->scaled(*scale); + return dest; } -void GDAPI godot_transform2d_new_identity(godot_transform2d *p_t) { - Transform2D *t = (Transform2D *)p_t; - *t = Transform2D(); +godot_transform2d GDAPI godot_transform2d_translated(const godot_transform2d *p_self, const godot_vector2 *p_offset) { + godot_transform2d dest; + const Transform2D *self = (const Transform2D *)p_self; + const Vector2 *offset = (const Vector2 *)p_offset; + *((Transform2D *)&dest) = self->translated(*offset); + return dest; } -void GDAPI godot_transform2d_new_elements(godot_transform2d *p_t, const godot_vector2 *p_a, const godot_vector2 *p_b, const godot_vector2 *p_c) { - Transform2D *t = (Transform2D *)p_t; - Vector2 *a = (Vector2 *)p_a; - Vector2 *b = (Vector2 *)p_b; - Vector2 *c = (Vector2 *)p_c; - *t = Transform2D(a->x, a->y, b->x, b->y, c->x, c->y); +godot_vector2 GDAPI godot_transform2d_xform_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v) { + godot_vector2 raw_dest; + Vector2 *dest = (Vector2 *)&raw_dest; + const Transform2D *self = (const Transform2D *)p_self; + const Vector2 *v = (const Vector2 *)p_v; + *dest = self->xform(*v); + return raw_dest; } -void GDAPI godot_transform2d_new(godot_transform2d *p_t, const godot_real p_rot, const godot_vector2 *p_pos) { - Transform2D *t = (Transform2D *)p_t; - Vector2 *pos = (Vector2 *)p_pos; - *t = Transform2D(p_rot, *pos); +godot_vector2 GDAPI godot_transform2d_xform_inv_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v) { + godot_vector2 raw_dest; + Vector2 *dest = (Vector2 *)&raw_dest; + const Transform2D *self = (const Transform2D *)p_self; + const Vector2 *v = (const Vector2 *)p_v; + *dest = self->xform_inv(*v); + return raw_dest; } -godot_vector2 const GDAPI *godot_transform2d_const_index(const godot_transform2d *p_t, const godot_int p_idx) { - const Transform2D *t = (const Transform2D *)p_t; - const Vector2 *e = &t->operator[](p_idx); - return (godot_vector2 const *)e; +godot_vector2 GDAPI godot_transform2d_basis_xform_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v) { + godot_vector2 raw_dest; + Vector2 *dest = (Vector2 *)&raw_dest; + const Transform2D *self = (const Transform2D *)p_self; + const Vector2 *v = (const Vector2 *)p_v; + *dest = self->basis_xform(*v); + return raw_dest; } -godot_vector2 GDAPI *godot_transform2d_index(godot_transform2d *p_t, const godot_int p_idx) { - Transform2D *t = (Transform2D *)p_t; - Vector2 *e = &t->operator[](p_idx); - return (godot_vector2 *)e; +godot_vector2 GDAPI godot_transform2d_basis_xform_inv_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v) { + godot_vector2 raw_dest; + Vector2 *dest = (Vector2 *)&raw_dest; + const Transform2D *self = (const Transform2D *)p_self; + const Vector2 *v = (const Vector2 *)p_v; + *dest = self->basis_xform_inv(*v); + return raw_dest; } -godot_vector2 GDAPI godot_transform2d_get_axis(const godot_transform2d *p_t, const godot_int p_axis) { - return *godot_transform2d_const_index(p_t, p_axis); +godot_transform2d GDAPI godot_transform2d_interpolate_with(const godot_transform2d *p_self, const godot_transform2d *p_m, const godot_real p_c) { + godot_transform2d dest; + const Transform2D *self = (const Transform2D *)p_self; + const Transform2D *m = (const Transform2D *)p_m; + *((Transform2D *)&dest) = self->interpolate_with(*m, p_c); + return dest; } -void GDAPI godot_transform2d_set_axis(godot_transform2d *p_t, const godot_int p_axis, const godot_vector2 *p_vec) { - godot_vector2 *origin_v = godot_transform2d_index(p_t, p_axis); - *origin_v = *p_vec; +godot_bool GDAPI godot_transform2d_operator_equal(const godot_transform2d *p_self, const godot_transform2d *p_b) { + const Transform2D *self = (const Transform2D *)p_self; + const Transform2D *b = (const Transform2D *)p_b; + return *self == *b; } -// @Incomplete -// See header file +godot_transform2d GDAPI godot_transform2d_operator_multiply(const godot_transform2d *p_self, const godot_transform2d *p_b) { + godot_transform2d raw_dest; + Transform2D *dest = (Transform2D *)&raw_dest; + const Transform2D *self = (const Transform2D *)p_self; + const Transform2D *b = (const Transform2D *)p_b; + *dest = *self * *b; + return raw_dest; +} + +void GDAPI godot_transform2d_new_identity(godot_transform2d *r_dest) { + Transform2D *dest = (Transform2D *)r_dest; + *dest = Transform2D(); +} + +godot_rect2 GDAPI godot_transform2d_xform_rect2(const godot_transform2d *p_self, const godot_rect2 *p_v) { + godot_rect2 raw_dest; + Rect2 *dest = (Rect2 *)&raw_dest; + const Transform2D *self = (const Transform2D *)p_self; + const Rect2 *v = (const Rect2 *)p_v; + *dest = self->xform(*v); + return raw_dest; +} + +godot_rect2 GDAPI godot_transform2d_xform_inv_rect2(const godot_transform2d *p_self, const godot_rect2 *p_v) { + godot_rect2 raw_dest; + Rect2 *dest = (Rect2 *)&raw_dest; + const Transform2D *self = (const Transform2D *)p_self; + const Rect2 *v = (const Rect2 *)p_v; + *dest = self->xform_inv(*v); + return raw_dest; +} #ifdef __cplusplus } diff --git a/modules/gdnative/godot/godot_transform2d.h b/modules/gdnative/godot/godot_transform2d.h index ae0569dbe8..c375e90af7 100644 --- a/modules/gdnative/godot/godot_transform2d.h +++ b/modules/gdnative/godot/godot_transform2d.h @@ -44,31 +44,51 @@ typedef struct godot_transform2d { #endif #include "../godot.h" - +#include "godot_variant.h" #include "godot_vector2.h" -void GDAPI godot_transform2d_new_identity(godot_transform2d *p_t); -void GDAPI godot_transform2d_new_elements(godot_transform2d *p_t, const godot_vector2 *p_a, const godot_vector2 *p_b, const godot_vector2 *p_c); -void GDAPI godot_transform2d_new(godot_transform2d *p_t, const godot_real p_rot, const godot_vector2 *p_pos); +void GDAPI godot_transform2d_new(godot_transform2d *r_dest, const godot_real p_rot, const godot_vector2 *p_pos); +void GDAPI godot_transform2d_new_axis_origin(godot_transform2d *r_dest, const godot_vector2 *p_x_axis, const godot_vector2 *p_y_axis, const godot_vector2 *p_origin); + +godot_string GDAPI godot_transform2d_as_string(const godot_transform2d *p_self); + +godot_transform2d GDAPI godot_transform2d_inverse(const godot_transform2d *p_self); + +godot_transform2d GDAPI godot_transform2d_affine_inverse(const godot_transform2d *p_self); + +godot_real GDAPI godot_transform2d_get_rotation(const godot_transform2d *p_self); + +godot_vector2 GDAPI godot_transform2d_get_origin(const godot_transform2d *p_self); + +godot_vector2 GDAPI godot_transform2d_get_scale(const godot_transform2d *p_self); + +godot_transform2d GDAPI godot_transform2d_orthonormalized(const godot_transform2d *p_self); + +godot_transform2d GDAPI godot_transform2d_rotated(const godot_transform2d *p_self, const godot_real p_phi); + +godot_transform2d GDAPI godot_transform2d_scaled(const godot_transform2d *p_self, const godot_vector2 *p_scale); + +godot_transform2d GDAPI godot_transform2d_translated(const godot_transform2d *p_self, const godot_vector2 *p_offset); + +godot_vector2 GDAPI godot_transform2d_xform_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v); + +godot_vector2 GDAPI godot_transform2d_xform_inv_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v); + +godot_vector2 GDAPI godot_transform2d_basis_xform_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v); + +godot_vector2 GDAPI godot_transform2d_basis_xform_inv_vector2(const godot_transform2d *p_self, const godot_vector2 *p_v); + +godot_transform2d GDAPI godot_transform2d_interpolate_with(const godot_transform2d *p_self, const godot_transform2d *p_m, const godot_real p_c); -/* -godot_real GDAPI godot_transform2d_tdotx(const godot_transform2d *p_t, const godot_vector2 *p_v); -godot_real GDAPI godot_transform2d_tdoty(const godot_transform2d *p_t, const godot_vector2 *p_v); -*/ +godot_bool GDAPI godot_transform2d_operator_equal(const godot_transform2d *p_self, const godot_transform2d *p_b); -godot_vector2 const GDAPI *godot_transform2d_const_index(const godot_transform2d *p_t, const godot_int p_idx); -godot_vector2 GDAPI *godot_transform2d_index(godot_transform2d *p_t, const godot_int p_idx); +godot_transform2d GDAPI godot_transform2d_operator_multiply(const godot_transform2d *p_self, const godot_transform2d *p_b); -godot_vector2 GDAPI godot_transform2d_get_axis(const godot_transform2d *p_t, const godot_int p_axis); -void GDAPI godot_transform2d_set_axis(godot_transform2d *p_t, const godot_int p_axis, const godot_vector2 *p_vec); +void GDAPI godot_transform2d_new_identity(godot_transform2d *r_dest); -/* -void GDAPI godot_transform2d_invert(godot_transform2d *p_t); -godot_transform2d GDAPI godot_transform2d_inverse(const godot_transform2d *p_t); -*/ +godot_rect2 GDAPI godot_transform2d_xform_rect2(const godot_transform2d *p_self, const godot_rect2 *p_v); -// @Incomplete -// I feel like it should be enough to expose get and set, the whole logic can be done in the bindings. +godot_rect2 GDAPI godot_transform2d_xform_inv_rect2(const godot_transform2d *p_self, const godot_rect2 *p_v); #ifdef __cplusplus } diff --git a/modules/gdnative/godot/godot_variant.cpp b/modules/gdnative/godot/godot_variant.cpp index e9fa4eb8c6..9381fb86d3 100644 --- a/modules/gdnative/godot/godot_variant.cpp +++ b/modules/gdnative/godot/godot_variant.cpp @@ -28,23 +28,21 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "godot_variant.h" - -#include "../godot.h" - -#include "variant.h" +#include "core/variant.h" #ifdef __cplusplus extern "C" { #endif -void _variant_api_anchor() { -} +void _variant_api_anchor() {} #define memnew_placement_custom(m_placement, m_class, m_constr) _post_initialize(new (m_placement, sizeof(m_class), "") m_constr) -godot_variant_type GDAPI godot_variant_get_type(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - return (godot_variant_type)v->get_type(); +// Constructors + +godot_variant_type GDAPI godot_variant_get_type(const godot_variant *p_self) { + const Variant *self = (const Variant *)p_self; + return (godot_variant_type)self->get_type(); } void GDAPI godot_variant_copy(godot_variant *p_dest, const godot_variant *p_src) { @@ -53,461 +51,429 @@ void GDAPI godot_variant_copy(godot_variant *p_dest, const godot_variant *p_src) *dest = *src; } -void GDAPI godot_variant_new_nil(godot_variant *p_v) { - Variant *v = (Variant *)p_v; - memnew_placement(v, Variant); +void GDAPI godot_variant_new_nil(godot_variant *r_dest) { + Variant *dest = (Variant *)r_dest; + memnew_placement(dest, Variant); } -void GDAPI godot_variant_new_bool(godot_variant *p_v, const godot_bool p_b) { - Variant *v = (Variant *)p_v; - memnew_placement_custom(v, Variant, Variant(p_b)); +void GDAPI godot_variant_new_bool(godot_variant *r_dest, const godot_bool p_b) { + Variant *dest = (Variant *)r_dest; + memnew_placement_custom(dest, Variant, Variant(p_b)); } -void GDAPI godot_variant_new_uint(godot_variant *p_v, const uint64_t p_i) { - Variant *v = (Variant *)p_v; - memnew_placement_custom(v, Variant, Variant(p_i)); +void GDAPI godot_variant_new_uint(godot_variant *r_dest, const uint64_t p_i) { + Variant *dest = (Variant *)r_dest; + memnew_placement_custom(dest, Variant, Variant(p_i)); } -void GDAPI godot_variant_new_int(godot_variant *p_v, const int64_t p_i) { - Variant *v = (Variant *)p_v; - memnew_placement_custom(v, Variant, Variant(p_i)); +void GDAPI godot_variant_new_int(godot_variant *r_dest, const int64_t p_i) { + Variant *dest = (Variant *)r_dest; + memnew_placement_custom(dest, Variant, Variant(p_i)); } -void GDAPI godot_variant_new_real(godot_variant *p_v, const double p_r) { - Variant *v = (Variant *)p_v; - memnew_placement_custom(v, Variant, Variant(p_r)); +void GDAPI godot_variant_new_real(godot_variant *r_dest, const double p_r) { + Variant *dest = (Variant *)r_dest; + memnew_placement_custom(dest, Variant, Variant(p_r)); } -void GDAPI godot_variant_new_string(godot_variant *p_v, const godot_string *p_s) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_string(godot_variant *r_dest, const godot_string *p_s) { + Variant *dest = (Variant *)r_dest; String *s = (String *)p_s; - memnew_placement_custom(v, Variant, Variant(*s)); + memnew_placement_custom(dest, Variant, Variant(*s)); } -void GDAPI godot_variant_new_vector2(godot_variant *p_v, const godot_vector2 *p_v2) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_vector2(godot_variant *r_dest, const godot_vector2 *p_v2) { + Variant *dest = (Variant *)r_dest; Vector2 *v2 = (Vector2 *)p_v2; - memnew_placement_custom(v, Variant, Variant(*v2)); + memnew_placement_custom(dest, Variant, Variant(*v2)); } -void GDAPI godot_variant_new_rect2(godot_variant *p_v, const godot_rect2 *p_rect2) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_rect2(godot_variant *r_dest, const godot_rect2 *p_rect2) { + Variant *dest = (Variant *)r_dest; Rect2 *rect2 = (Rect2 *)p_rect2; - memnew_placement_custom(v, Variant, Variant(*rect2)); + memnew_placement_custom(dest, Variant, Variant(*rect2)); } -void GDAPI godot_variant_new_vector3(godot_variant *p_v, const godot_vector3 *p_v3) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_vector3(godot_variant *r_dest, const godot_vector3 *p_v3) { + Variant *dest = (Variant *)r_dest; Vector3 *v3 = (Vector3 *)p_v3; - memnew_placement_custom(v, Variant, Variant(*v3)); + memnew_placement_custom(dest, Variant, Variant(*v3)); } -void GDAPI godot_variant_new_transform2d(godot_variant *p_v, const godot_transform2d *p_t2d) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_transform2d(godot_variant *r_dest, const godot_transform2d *p_t2d) { + Variant *dest = (Variant *)r_dest; Transform2D *t2d = (Transform2D *)p_t2d; - memnew_placement_custom(v, Variant, Variant(*t2d)); + memnew_placement_custom(dest, Variant, Variant(*t2d)); } -void GDAPI godot_variant_new_plane(godot_variant *p_v, const godot_plane *p_plane) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_plane(godot_variant *r_dest, const godot_plane *p_plane) { + Variant *dest = (Variant *)r_dest; Plane *plane = (Plane *)p_plane; - memnew_placement_custom(v, Variant, Variant(*plane)); + memnew_placement_custom(dest, Variant, Variant(*plane)); } -void GDAPI godot_variant_new_quat(godot_variant *p_v, const godot_quat *p_quat) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_quat(godot_variant *r_dest, const godot_quat *p_quat) { + Variant *dest = (Variant *)r_dest; Quat *quat = (Quat *)p_quat; - memnew_placement_custom(v, Variant, Variant(*quat)); + memnew_placement_custom(dest, Variant, Variant(*quat)); } -void GDAPI godot_variant_new_rect3(godot_variant *p_v, const godot_rect3 *p_rect3) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_rect3(godot_variant *r_dest, const godot_rect3 *p_rect3) { + Variant *dest = (Variant *)r_dest; Rect3 *rect3 = (Rect3 *)p_rect3; - memnew_placement_custom(v, Variant, Variant(*rect3)); + memnew_placement_custom(dest, Variant, Variant(*rect3)); } -void GDAPI godot_variant_new_basis(godot_variant *p_v, const godot_basis *p_basis) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_basis(godot_variant *r_dest, const godot_basis *p_basis) { + Variant *dest = (Variant *)r_dest; Basis *basis = (Basis *)p_basis; - memnew_placement_custom(v, Variant, Variant(*basis)); + memnew_placement_custom(dest, Variant, Variant(*basis)); } -void GDAPI godot_variant_new_transform(godot_variant *p_v, const godot_transform *p_trans) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_transform(godot_variant *r_dest, const godot_transform *p_trans) { + Variant *dest = (Variant *)r_dest; Transform *trans = (Transform *)p_trans; - memnew_placement_custom(v, Variant, Variant(*trans)); + memnew_placement_custom(dest, Variant, Variant(*trans)); } -void GDAPI godot_variant_new_color(godot_variant *p_v, const godot_color *p_color) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_color(godot_variant *r_dest, const godot_color *p_color) { + Variant *dest = (Variant *)r_dest; Color *color = (Color *)p_color; - memnew_placement_custom(v, Variant, Variant(*color)); + memnew_placement_custom(dest, Variant, Variant(*color)); } -void GDAPI godot_variant_new_image(godot_variant *p_v, const godot_image *p_img) { - Variant *v = (Variant *)p_v; - Image *img = (Image *)p_img; - memnew_placement_custom(v, Variant, Variant(*img)); -} - -void GDAPI godot_variant_new_node_path(godot_variant *p_v, const godot_node_path *p_np) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_node_path(godot_variant *r_dest, const godot_node_path *p_np) { + Variant *dest = (Variant *)r_dest; NodePath *np = (NodePath *)p_np; - memnew_placement_custom(v, Variant, Variant(*np)); + memnew_placement_custom(dest, Variant, Variant(*np)); } -void GDAPI godot_variant_new_rid(godot_variant *p_v, const godot_rid *p_rid) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_rid(godot_variant *r_dest, const godot_rid *p_rid) { + Variant *dest = (Variant *)r_dest; RID *rid = (RID *)p_rid; - memnew_placement_custom(v, Variant, Variant(*rid)); + memnew_placement_custom(dest, Variant, Variant(*rid)); } -void GDAPI godot_variant_new_object(godot_variant *p_v, const godot_object *p_obj) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_object(godot_variant *r_dest, const godot_object *p_obj) { + Variant *dest = (Variant *)r_dest; Object *obj = (Object *)p_obj; - memnew_placement_custom(v, Variant, Variant(obj)); -} - -void GDAPI godot_variant_new_input_event(godot_variant *p_v, const godot_input_event *p_event) { - Variant *v = (Variant *)p_v; - InputEvent *event = (InputEvent *)p_event; - memnew_placement_custom(v, Variant, Variant(*event)); + memnew_placement_custom(dest, Variant, Variant(obj)); } -void GDAPI godot_variant_new_dictionary(godot_variant *p_v, const godot_dictionary *p_dict) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_dictionary(godot_variant *r_dest, const godot_dictionary *p_dict) { + Variant *dest = (Variant *)r_dest; Dictionary *dict = (Dictionary *)p_dict; - memnew_placement_custom(v, Variant, Variant(*dict)); + memnew_placement_custom(dest, Variant, Variant(*dict)); } -void GDAPI godot_variant_new_array(godot_variant *p_v, const godot_array *p_arr) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_array(godot_variant *r_dest, const godot_array *p_arr) { + Variant *dest = (Variant *)r_dest; Array *arr = (Array *)p_arr; - memnew_placement_custom(v, Variant, Variant(*arr)); + memnew_placement_custom(dest, Variant, Variant(*arr)); } -void GDAPI godot_variant_new_pool_byte_array(godot_variant *p_v, const godot_pool_byte_array *p_pba) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_pool_byte_array(godot_variant *r_dest, const godot_pool_byte_array *p_pba) { + Variant *dest = (Variant *)r_dest; PoolByteArray *pba = (PoolByteArray *)p_pba; - memnew_placement_custom(v, Variant, Variant(*pba)); + memnew_placement_custom(dest, Variant, Variant(*pba)); } -void GDAPI godot_variant_new_pool_int_array(godot_variant *p_v, const godot_pool_int_array *p_pia) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_pool_int_array(godot_variant *r_dest, const godot_pool_int_array *p_pia) { + Variant *dest = (Variant *)r_dest; PoolIntArray *pia = (PoolIntArray *)p_pia; - memnew_placement_custom(v, Variant, Variant(*pia)); + memnew_placement_custom(dest, Variant, Variant(*pia)); } -void GDAPI godot_variant_new_pool_real_array(godot_variant *p_v, const godot_pool_real_array *p_pra) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_pool_real_array(godot_variant *r_dest, const godot_pool_real_array *p_pra) { + Variant *dest = (Variant *)r_dest; PoolRealArray *pra = (PoolRealArray *)p_pra; - memnew_placement_custom(v, Variant, Variant(*pra)); + memnew_placement_custom(dest, Variant, Variant(*pra)); } -void GDAPI godot_variant_new_pool_string_array(godot_variant *p_v, const godot_pool_string_array *p_psa) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_pool_string_array(godot_variant *r_dest, const godot_pool_string_array *p_psa) { + Variant *dest = (Variant *)r_dest; PoolStringArray *psa = (PoolStringArray *)p_psa; - memnew_placement_custom(v, Variant, Variant(*psa)); + memnew_placement_custom(dest, Variant, Variant(*psa)); } -void GDAPI godot_variant_new_pool_vector2_array(godot_variant *p_v, const godot_pool_vector2_array *p_pv2a) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_pool_vector2_array(godot_variant *r_dest, const godot_pool_vector2_array *p_pv2a) { + Variant *dest = (Variant *)r_dest; PoolVector2Array *pv2a = (PoolVector2Array *)p_pv2a; - memnew_placement_custom(v, Variant, Variant(*pv2a)); + memnew_placement_custom(dest, Variant, Variant(*pv2a)); } -void GDAPI godot_variant_new_pool_vector3_array(godot_variant *p_v, const godot_pool_vector3_array *p_pv3a) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_pool_vector3_array(godot_variant *r_dest, const godot_pool_vector3_array *p_pv3a) { + Variant *dest = (Variant *)r_dest; PoolVector3Array *pv3a = (PoolVector3Array *)p_pv3a; - memnew_placement_custom(v, Variant, Variant(*pv3a)); + memnew_placement_custom(dest, Variant, Variant(*pv3a)); } -void GDAPI godot_variant_new_pool_color_array(godot_variant *p_v, const godot_pool_color_array *p_pca) { - Variant *v = (Variant *)p_v; +void GDAPI godot_variant_new_pool_color_array(godot_variant *r_dest, const godot_pool_color_array *p_pca) { + Variant *dest = (Variant *)r_dest; PoolColorArray *pca = (PoolColorArray *)p_pca; - memnew_placement_custom(v, Variant, Variant(*pca)); + memnew_placement_custom(dest, Variant, Variant(*pca)); } -godot_bool GDAPI godot_variant_as_bool(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - return v->operator bool(); +godot_bool GDAPI godot_variant_as_bool(const godot_variant *p_self) { + const Variant *self = (const Variant *)p_self; + return self->operator bool(); } -uint64_t GDAPI godot_variant_as_uint(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - return v->operator uint64_t(); +uint64_t GDAPI godot_variant_as_uint(const godot_variant *p_self) { + const Variant *self = (const Variant *)p_self; + return self->operator uint64_t(); } -int64_t GDAPI godot_variant_as_int(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - return v->operator int64_t(); +int64_t GDAPI godot_variant_as_int(const godot_variant *p_self) { + const Variant *self = (const Variant *)p_self; + return self->operator int64_t(); } -double GDAPI godot_variant_as_real(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - return v->operator double(); +double GDAPI godot_variant_as_real(const godot_variant *p_self) { + const Variant *self = (const Variant *)p_self; + return self->operator double(); } -godot_string GDAPI godot_variant_as_string(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_string s; - godot_string_new(&s); - String *str = (String *)&s; - *str = v->operator String(); - return s; +godot_string GDAPI godot_variant_as_string(const godot_variant *p_self) { + godot_string raw_dest; + const Variant *self = (const Variant *)p_self; + String *dest = (String *)&raw_dest; + memnew_placement(dest, String(self->operator String())); // operator = is overloaded by String + return raw_dest; } -godot_vector2 GDAPI godot_variant_as_vector2(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_vector2 v2; - Vector2 *vec2 = (Vector2 *)&v2; - *vec2 = *v; - return v2; +godot_vector2 GDAPI godot_variant_as_vector2(const godot_variant *p_self) { + godot_vector2 raw_dest; + const Variant *self = (const Variant *)p_self; + Vector2 *dest = (Vector2 *)&raw_dest; + *dest = *self; + return raw_dest; } -godot_rect2 GDAPI godot_variant_as_rect2(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_rect2 r2; - Rect2 *rect2 = (Rect2 *)&r2; - *rect2 = *v; - return r2; +godot_rect2 GDAPI godot_variant_as_rect2(const godot_variant *p_self) { + godot_rect2 raw_dest; + const Variant *self = (const Variant *)p_self; + Rect2 *dest = (Rect2 *)&raw_dest; + *dest = *self; + return raw_dest; } -godot_vector3 GDAPI godot_variant_as_vector3(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_vector3 v3; - Vector3 *vec3 = (Vector3 *)&v3; - *vec3 = *v; - return v3; +godot_vector3 GDAPI godot_variant_as_vector3(const godot_variant *p_self) { + godot_vector3 raw_dest; + const Variant *self = (const Variant *)p_self; + Vector3 *dest = (Vector3 *)&raw_dest; + *dest = *self; + return raw_dest; } -godot_transform2d GDAPI godot_variant_as_transform2d(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_transform2d t2; - Transform2D *t = (Transform2D *)&t2; - *t = *v; - return t2; +godot_transform2d GDAPI godot_variant_as_transform2d(const godot_variant *p_self) { + godot_transform2d raw_dest; + const Variant *self = (const Variant *)p_self; + Transform2D *dest = (Transform2D *)&raw_dest; + *dest = *self; + return raw_dest; } -godot_plane GDAPI godot_variant_as_plane(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_plane p; - Plane *pl = (Plane *)&p; - *pl = *v; - return p; +godot_plane GDAPI godot_variant_as_plane(const godot_variant *p_self) { + godot_plane raw_dest; + const Variant *self = (const Variant *)p_self; + Plane *dest = (Plane *)&raw_dest; + *dest = *self; + return raw_dest; } -godot_quat GDAPI godot_variant_as_quat(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_quat q; - Quat *qt = (Quat *)&q; - *qt = *v; - return q; +godot_quat GDAPI godot_variant_as_quat(const godot_variant *p_self) { + godot_quat raw_dest; + const Variant *self = (const Variant *)p_self; + Quat *dest = (Quat *)&raw_dest; + *dest = *self; + return raw_dest; } -godot_rect3 GDAPI godot_variant_as_rect3(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_rect3 r; - Rect3 *r3 = (Rect3 *)&r; - *r3 = *v; - return r; +godot_rect3 GDAPI godot_variant_as_rect3(const godot_variant *p_self) { + godot_rect3 raw_dest; + const Variant *self = (const Variant *)p_self; + Rect3 *dest = (Rect3 *)&raw_dest; + *dest = *self; + return raw_dest; } -godot_basis GDAPI godot_variant_as_basis(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_basis b; - Basis *bs = (Basis *)&b; - *bs = *v; - return b; +godot_basis GDAPI godot_variant_as_basis(const godot_variant *p_self) { + godot_basis raw_dest; + const Variant *self = (const Variant *)p_self; + Basis *dest = (Basis *)&raw_dest; + *dest = *self; + return raw_dest; } -godot_transform GDAPI godot_variant_as_transform(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_transform t; - Transform *tr = (Transform *)&t; - *tr = *v; - return t; +godot_transform GDAPI godot_variant_as_transform(const godot_variant *p_self) { + godot_transform raw_dest; + const Variant *self = (const Variant *)p_self; + Transform *dest = (Transform *)&raw_dest; + *dest = *self; + return raw_dest; } -godot_color GDAPI godot_variant_as_color(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_color c; - Color *col = (Color *)&c; - *col = *v; - return c; +godot_color GDAPI godot_variant_as_color(const godot_variant *p_self) { + godot_color raw_dest; + const Variant *self = (const Variant *)p_self; + Color *dest = (Color *)&raw_dest; + *dest = *self; + return raw_dest; } -godot_image GDAPI godot_variant_as_image(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_image img; - godot_image_new(&img); - Image *i = (Image *)&img; - *i = *v; - return img; -} - -godot_node_path GDAPI godot_variant_as_node_path(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_node_path np; - memnew_placement_custom((NodePath *)&np, NodePath, NodePath((String)*v)); - return np; -} - -godot_rid GDAPI godot_variant_as_rid(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_rid rid; - memnew_placement_custom((RID *)&rid, RID, RID(*v)); - return rid; -} - -godot_object GDAPI *godot_variant_as_object(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_object *p = NULL; - Object **op = (Object **)&p; - *op = *v; - return p; -} - -godot_input_event GDAPI godot_variant_as_input_event(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_input_event ev; - InputEvent *event = (InputEvent *)&ev; - *event = *v; - return ev; -} - -godot_dictionary GDAPI godot_variant_as_dictionary(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_dictionary dict; - godot_dictionary_new(&dict); - Dictionary *d = (Dictionary *)&dict; - *d = *v; - return dict; -} - -godot_array GDAPI godot_variant_as_array(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_array array; - godot_array_new(&array); - Array *a = (Array *)&array; - *a = *v; - return array; -} - -godot_pool_byte_array GDAPI godot_variant_as_pool_byte_array(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_pool_byte_array pba; - godot_pool_byte_array_new(&pba); - PoolByteArray *p = (PoolByteArray *)&pba; - *p = *v; - return pba; -} - -godot_pool_int_array GDAPI godot_variant_as_pool_int_array(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_pool_int_array pba; - godot_pool_int_array_new(&pba); - PoolIntArray *p = (PoolIntArray *)&pba; - *p = *v; - return pba; -} - -godot_pool_real_array GDAPI godot_variant_as_pool_real_array(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_pool_real_array pba; - godot_pool_real_array_new(&pba); - PoolRealArray *p = (PoolRealArray *)&pba; - *p = *v; - return pba; -} - -godot_pool_string_array GDAPI godot_variant_as_pool_string_array(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_pool_string_array pba; - godot_pool_string_array_new(&pba); - PoolStringArray *p = (PoolStringArray *)&pba; - *p = *v; - return pba; -} - -godot_pool_vector2_array GDAPI godot_variant_as_pool_vector2_array(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_pool_vector2_array pba; - godot_pool_vector2_array_new(&pba); - PoolVector2Array *p = (PoolVector2Array *)&pba; - *p = *v; - return pba; -} - -godot_pool_vector3_array GDAPI godot_variant_as_pool_vector3_array(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_pool_vector3_array pba; - godot_pool_vector3_array_new(&pba); - PoolVector3Array *p = (PoolVector3Array *)&pba; - *p = *v; - return pba; -} - -godot_pool_color_array GDAPI godot_variant_as_pool_color_array(const godot_variant *p_v) { - const Variant *v = (const Variant *)p_v; - godot_pool_color_array pba; - godot_pool_color_array_new(&pba); - PoolColorArray *p = (PoolColorArray *)&pba; - *p = *v; - return pba; -} - -godot_variant GDAPI godot_variant_call(godot_variant *p_v, const godot_string *p_method, const godot_variant **p_args, const godot_int p_argcount, godot_variant_call_error *p_error) { - Variant *v = (Variant *)p_v; - String *method = (String *)p_method; - const Variant **args = (const Variant **)p_args; - godot_variant res; - godot_variant_new_nil(&res); +godot_node_path GDAPI godot_variant_as_node_path(const godot_variant *p_self) { + godot_node_path raw_dest; + const Variant *self = (const Variant *)p_self; + NodePath *dest = (NodePath *)&raw_dest; + memnew_placement(dest, NodePath(self->operator NodePath())); // operator = is overloaded by NodePath + return raw_dest; +} + +godot_rid GDAPI godot_variant_as_rid(const godot_variant *p_self) { + godot_rid raw_dest; + const Variant *self = (const Variant *)p_self; + RID *dest = (RID *)&raw_dest; + *dest = *self; + return raw_dest; +} + +godot_object GDAPI *godot_variant_as_object(const godot_variant *p_self) { + const Variant *self = (const Variant *)p_self; + Object *dest; + dest = *self; + return (godot_object *)dest; +} + +godot_dictionary GDAPI godot_variant_as_dictionary(const godot_variant *p_self) { + godot_dictionary raw_dest; + const Variant *self = (const Variant *)p_self; + Dictionary *dest = (Dictionary *)&raw_dest; + memnew_placement(dest, Dictionary(self->operator Dictionary())); // operator = is overloaded by Dictionary + return raw_dest; +} + +godot_array GDAPI godot_variant_as_array(const godot_variant *p_self) { + godot_array raw_dest; + const Variant *self = (const Variant *)p_self; + Array *dest = (Array *)&raw_dest; + memnew_placement(dest, Array(self->operator Array())); // operator = is overloaded by Array + return raw_dest; +} + +godot_pool_byte_array GDAPI godot_variant_as_pool_byte_array(const godot_variant *p_self) { + godot_pool_byte_array raw_dest; + const Variant *self = (const Variant *)p_self; + PoolByteArray *dest = (PoolByteArray *)&raw_dest; + memnew_placement(dest, PoolByteArray(self->operator PoolByteArray())); // operator = is overloaded by PoolByteArray + *dest = *self; + return raw_dest; +} + +godot_pool_int_array GDAPI godot_variant_as_pool_int_array(const godot_variant *p_self) { + godot_pool_int_array raw_dest; + const Variant *self = (const Variant *)p_self; + PoolIntArray *dest = (PoolIntArray *)&raw_dest; + memnew_placement(dest, PoolIntArray(self->operator PoolIntArray())); // operator = is overloaded by PoolIntArray + *dest = *self; + return raw_dest; +} + +godot_pool_real_array GDAPI godot_variant_as_pool_real_array(const godot_variant *p_self) { + godot_pool_real_array raw_dest; + const Variant *self = (const Variant *)p_self; + PoolRealArray *dest = (PoolRealArray *)&raw_dest; + memnew_placement(dest, PoolRealArray(self->operator PoolRealArray())); // operator = is overloaded by PoolRealArray + *dest = *self; + return raw_dest; +} - Variant *ret_val = (Variant *)&res; +godot_pool_string_array GDAPI godot_variant_as_pool_string_array(const godot_variant *p_self) { + godot_pool_string_array raw_dest; + const Variant *self = (const Variant *)p_self; + PoolStringArray *dest = (PoolStringArray *)&raw_dest; + memnew_placement(dest, PoolStringArray(self->operator PoolStringArray())); // operator = is overloaded by PoolStringArray + *dest = *self; + return raw_dest; +} - Variant::CallError r_error; - *ret_val = v->call(StringName(*method), args, p_argcount, r_error); - if (p_error) { - p_error->error = (godot_variant_call_error_error)r_error.error; - p_error->argument = r_error.argument; - p_error->expected = (godot_variant_type)r_error.expected; +godot_pool_vector2_array GDAPI godot_variant_as_pool_vector2_array(const godot_variant *p_self) { + godot_pool_vector2_array raw_dest; + const Variant *self = (const Variant *)p_self; + PoolVector2Array *dest = (PoolVector2Array *)&raw_dest; + memnew_placement(dest, PoolVector2Array(self->operator PoolVector2Array())); // operator = is overloaded by PoolVector2Array + *dest = *self; + return raw_dest; +} + +godot_pool_vector3_array GDAPI godot_variant_as_pool_vector3_array(const godot_variant *p_self) { + godot_pool_vector3_array raw_dest; + const Variant *self = (const Variant *)p_self; + PoolVector3Array *dest = (PoolVector3Array *)&raw_dest; + memnew_placement(dest, PoolVector3Array(self->operator PoolVector3Array())); // operator = is overloaded by PoolVector3Array + *dest = *self; + return raw_dest; +} + +godot_pool_color_array GDAPI godot_variant_as_pool_color_array(const godot_variant *p_self) { + godot_pool_color_array raw_dest; + const Variant *self = (const Variant *)p_self; + PoolColorArray *dest = (PoolColorArray *)&raw_dest; + memnew_placement(dest, PoolColorArray(self->operator PoolColorArray())); // operator = is overloaded by PoolColorArray + *dest = *self; + return raw_dest; +} + +godot_variant GDAPI godot_variant_call(godot_variant *p_self, const godot_string *p_method, const godot_variant **p_args, const godot_int p_argcount, godot_variant_call_error *r_error) { + Variant *self = (Variant *)p_self; + String *method = (String *)p_method; + const Variant **args = (const Variant **)p_args; + godot_variant raw_dest; + Variant *dest = (Variant *)&raw_dest; + Variant::CallError error; + memnew_placement_custom(dest, Variant, Variant(self->call(*method, args, p_argcount, error))); + *dest = self->call(StringName(*method), args, p_argcount, r_error); + if (r_error) { + r_error->error = (godot_variant_call_error_error)error.error; + r_error->argument = error.argument; + r_error->expected = (godot_variant_type)error.expected; } - return res; + return raw_dest; } -godot_bool GDAPI godot_variant_has_method(godot_variant *p_v, const godot_string *p_method) { - Variant *v = (Variant *)p_v; - String *method = (String *)p_method; - return v->has_method(*method); +godot_bool GDAPI godot_variant_has_method(const godot_variant *p_self, const godot_string *p_method) { + const Variant *self = (const Variant *)p_self; + const String *method = (const String *)p_method; + return self->has_method(*method); } -godot_bool GDAPI godot_variant_operator_equal(const godot_variant *p_a, const godot_variant *p_b) { - const Variant *a = (const Variant *)p_a; - const Variant *b = (const Variant *)p_b; - return a->operator==(*b); +godot_bool GDAPI godot_variant_operator_equal(const godot_variant *p_self, const godot_variant *p_other) { + const Variant *self = (const Variant *)p_self; + const Variant *other = (const Variant *)p_other; + return self->operator==(*other); } -godot_bool GDAPI godot_variant_operator_less(const godot_variant *p_a, const godot_variant *p_b) { - const Variant *a = (const Variant *)p_a; - const Variant *b = (const Variant *)p_b; - return a->operator<(*b); +godot_bool GDAPI godot_variant_operator_less(const godot_variant *p_self, const godot_variant *p_other) { + const Variant *self = (const Variant *)p_self; + const Variant *other = (const Variant *)p_other; + return self->operator<(*other); } -godot_bool GDAPI godot_variant_hash_compare(const godot_variant *p_a, const godot_variant *p_b) { - const Variant *a = (const Variant *)p_a; - const Variant *b = (const Variant *)p_b; - return a->hash_compare(*b); +godot_bool GDAPI godot_variant_hash_compare(const godot_variant *p_self, const godot_variant *p_other) { + const Variant *self = (const Variant *)p_self; + const Variant *other = (const Variant *)p_other; + return self->hash_compare(*other); } -godot_bool GDAPI godot_variant_booleanize(const godot_variant *p_v, godot_bool *p_valid) { - const Variant *v = (const Variant *)p_v; - bool &valid = *p_valid; - return v->booleanize(valid); +godot_bool GDAPI godot_variant_booleanize(const godot_variant *p_self, godot_bool *r_valid) { + const Variant *self = (const Variant *)p_self; + bool &valid = *r_valid; + return self->booleanize(valid); } -void GDAPI godot_variant_destroy(godot_variant *p_v) { - ((Variant *)p_v)->~Variant(); +void GDAPI godot_variant_destroy(godot_variant *p_self) { + Variant *self = (Variant *)p_self; + self->~Variant(); } #ifdef __cplusplus diff --git a/modules/gdnative/godot/godot_variant.h b/modules/gdnative/godot/godot_variant.h index 0a5771d2f6..d46b87c41b 100644 --- a/modules/gdnative/godot/godot_variant.h +++ b/modules/gdnative/godot/godot_variant.h @@ -42,9 +42,6 @@ typedef struct godot_variant { } godot_variant; #endif -struct godot_transform2d; -typedef struct godot_transform2d godot_transform2d; - typedef enum godot_variant_type { GODOT_VARIANT_TYPE_NIL, @@ -62,26 +59,25 @@ typedef enum godot_variant_type { GODOT_VARIANT_TYPE_TRANSFORM2D, GODOT_VARIANT_TYPE_PLANE, GODOT_VARIANT_TYPE_QUAT, // 10 - GODOT_VARIANT_TYPE_RECT3, //sorry naming convention fail :( not like it's used often + GODOT_VARIANT_TYPE_RECT3, GODOT_VARIANT_TYPE_BASIS, GODOT_VARIANT_TYPE_TRANSFORM, // misc types GODOT_VARIANT_TYPE_COLOR, - GODOT_VARIANT_TYPE_IMAGE, // 15 - GODOT_VARIANT_TYPE_NODE_PATH, + GODOT_VARIANT_TYPE_NODE_PATH, // 15 GODOT_VARIANT_TYPE_RID, GODOT_VARIANT_TYPE_OBJECT, - GODOT_VARIANT_TYPE_INPUT_EVENT, - GODOT_VARIANT_TYPE_DICTIONARY, // 20 - GODOT_VARIANT_TYPE_ARRAY, + GODOT_VARIANT_TYPE_INPUT_EVENT, // TODO: remove me once input_event is removed from main Godot codebase + GODOT_VARIANT_TYPE_DICTIONARY, + GODOT_VARIANT_TYPE_ARRAY, // 20 // arrays GODOT_VARIANT_TYPE_POOL_BYTE_ARRAY, GODOT_VARIANT_TYPE_POOL_INT_ARRAY, GODOT_VARIANT_TYPE_POOL_REAL_ARRAY, - GODOT_VARIANT_TYPE_POOL_STRING_ARRAY, // 25 - GODOT_VARIANT_TYPE_POOL_VECTOR2_ARRAY, + GODOT_VARIANT_TYPE_POOL_STRING_ARRAY, + GODOT_VARIANT_TYPE_POOL_VECTOR2_ARRAY, // 25 GODOT_VARIANT_TYPE_POOL_VECTOR3_ARRAY, GODOT_VARIANT_TYPE_POOL_COLOR_ARRAY, } godot_variant_type; @@ -102,90 +98,99 @@ typedef struct godot_variant_call_error { } godot_variant_call_error; #include "godot_array.h" +#include "godot_basis.h" +#include "godot_color.h" #include "godot_dictionary.h" -#include "godot_input_event.h" #include "godot_node_path.h" +#include "godot_plane.h" +#include "godot_pool_arrays.h" +#include "godot_quat.h" +#include "godot_rect2.h" +#include "godot_rect3.h" #include "godot_rid.h" +#include "godot_string.h" +#include "godot_transform.h" #include "godot_transform2d.h" +#include "godot_variant.h" +#include "godot_vector2.h" +#include "godot_vector3.h" + +#include "../godot.h" godot_variant_type GDAPI godot_variant_get_type(const godot_variant *p_v); -void GDAPI godot_variant_copy(godot_variant *p_dest, const godot_variant *p_src); +void GDAPI godot_variant_copy(godot_variant *r_dest, const godot_variant *p_src); -void GDAPI godot_variant_new_nil(godot_variant *p_v); +void GDAPI godot_variant_new_nil(godot_variant *r_dest); void GDAPI godot_variant_new_bool(godot_variant *p_v, const godot_bool p_b); -void GDAPI godot_variant_new_uint(godot_variant *p_v, const uint64_t p_i); -void GDAPI godot_variant_new_int(godot_variant *p_v, const int64_t p_i); -void GDAPI godot_variant_new_real(godot_variant *p_v, const double p_r); -void GDAPI godot_variant_new_string(godot_variant *p_v, const godot_string *p_s); -void GDAPI godot_variant_new_vector2(godot_variant *p_v, const godot_vector2 *p_v2); -void GDAPI godot_variant_new_rect2(godot_variant *p_v, const godot_rect2 *p_rect2); -void GDAPI godot_variant_new_vector3(godot_variant *p_v, const godot_vector3 *p_v3); -void GDAPI godot_variant_new_transform2d(godot_variant *p_v, const godot_transform2d *p_t2d); -void GDAPI godot_variant_new_plane(godot_variant *p_v, const godot_plane *p_plane); -void GDAPI godot_variant_new_quat(godot_variant *p_v, const godot_quat *p_quat); -void GDAPI godot_variant_new_rect3(godot_variant *p_v, const godot_rect3 *p_rect3); -void GDAPI godot_variant_new_basis(godot_variant *p_v, const godot_basis *p_basis); -void GDAPI godot_variant_new_transform(godot_variant *p_v, const godot_transform *p_trans); -void GDAPI godot_variant_new_color(godot_variant *p_v, const godot_color *p_color); -void GDAPI godot_variant_new_image(godot_variant *p_v, const godot_image *p_img); -void GDAPI godot_variant_new_node_path(godot_variant *p_v, const godot_node_path *p_np); -void GDAPI godot_variant_new_rid(godot_variant *p_v, const godot_rid *p_rid); -void GDAPI godot_variant_new_object(godot_variant *p_v, const godot_object *p_obj); -void GDAPI godot_variant_new_input_event(godot_variant *p_v, const godot_input_event *p_event); -void GDAPI godot_variant_new_dictionary(godot_variant *p_v, const godot_dictionary *p_dict); -void GDAPI godot_variant_new_array(godot_variant *p_v, const godot_array *p_arr); -void GDAPI godot_variant_new_pool_byte_array(godot_variant *p_v, const godot_pool_byte_array *p_pba); -void GDAPI godot_variant_new_pool_int_array(godot_variant *p_v, const godot_pool_int_array *p_pia); -void GDAPI godot_variant_new_pool_real_array(godot_variant *p_v, const godot_pool_real_array *p_pra); -void GDAPI godot_variant_new_pool_string_array(godot_variant *p_v, const godot_pool_string_array *p_psa); -void GDAPI godot_variant_new_pool_vector2_array(godot_variant *p_v, const godot_pool_vector2_array *p_pv2a); -void GDAPI godot_variant_new_pool_vector3_array(godot_variant *p_v, const godot_pool_vector3_array *p_pv3a); -void GDAPI godot_variant_new_pool_color_array(godot_variant *p_v, const godot_pool_color_array *p_pca); - -godot_bool GDAPI godot_variant_as_bool(const godot_variant *p_v); -uint64_t GDAPI godot_variant_as_uint(const godot_variant *p_v); -int64_t GDAPI godot_variant_as_int(const godot_variant *p_v); -double GDAPI godot_variant_as_real(const godot_variant *p_v); -godot_string GDAPI godot_variant_as_string(const godot_variant *p_v); -godot_vector2 GDAPI godot_variant_as_vector2(const godot_variant *p_v); -godot_rect2 GDAPI godot_variant_as_rect2(const godot_variant *p_v); -godot_vector3 GDAPI godot_variant_as_vector3(const godot_variant *p_v); -godot_transform2d GDAPI godot_variant_as_transform2d(const godot_variant *p_v); -godot_plane GDAPI godot_variant_as_plane(const godot_variant *p_v); -godot_quat GDAPI godot_variant_as_quat(const godot_variant *p_v); -godot_rect3 GDAPI godot_variant_as_rect3(const godot_variant *p_v); -godot_basis GDAPI godot_variant_as_basis(const godot_variant *p_v); -godot_transform GDAPI godot_variant_as_transform(const godot_variant *p_v); -godot_color GDAPI godot_variant_as_color(const godot_variant *p_v); -godot_image GDAPI godot_variant_as_image(const godot_variant *p_v); -godot_node_path GDAPI godot_variant_as_node_path(const godot_variant *p_v); -godot_rid GDAPI godot_variant_as_rid(const godot_variant *p_v); -godot_object GDAPI *godot_variant_as_object(const godot_variant *p_v); -godot_input_event GDAPI godot_variant_as_input_event(const godot_variant *p_v); -godot_dictionary GDAPI godot_variant_as_dictionary(const godot_variant *p_v); -godot_array GDAPI godot_variant_as_array(const godot_variant *p_v); -godot_pool_byte_array GDAPI godot_variant_as_pool_byte_array(const godot_variant *p_v); -godot_pool_int_array GDAPI godot_variant_as_pool_int_array(const godot_variant *p_v); -godot_pool_real_array GDAPI godot_variant_as_pool_real_array(const godot_variant *p_v); -godot_pool_string_array GDAPI godot_variant_as_pool_string_array(const godot_variant *p_v); -godot_pool_vector2_array GDAPI godot_variant_as_pool_vector2_array(const godot_variant *p_v); -godot_pool_vector3_array GDAPI godot_variant_as_pool_vector3_array(const godot_variant *p_v); -godot_pool_color_array GDAPI godot_variant_as_pool_color_array(const godot_variant *p_v); - -godot_variant GDAPI godot_variant_call(godot_variant *p_v, const godot_string *p_method, const godot_variant **p_args, const godot_int p_argcount, godot_variant_call_error *p_error); - -godot_bool GDAPI godot_variant_has_method(godot_variant *p_v, const godot_string *p_method); - -godot_bool GDAPI godot_variant_operator_equal(const godot_variant *p_a, const godot_variant *p_b); -godot_bool GDAPI godot_variant_operator_less(const godot_variant *p_a, const godot_variant *p_b); - -godot_bool GDAPI godot_variant_hash_compare(const godot_variant *p_a, const godot_variant *p_b); - -godot_bool GDAPI godot_variant_booleanize(const godot_variant *p_v, godot_bool *p_valid); - -void GDAPI godot_variant_destroy(godot_variant *p_v); +void GDAPI godot_variant_new_uint(godot_variant *r_dest, const uint64_t p_i); +void GDAPI godot_variant_new_int(godot_variant *r_dest, const int64_t p_i); +void GDAPI godot_variant_new_real(godot_variant *r_dest, const double p_r); +void GDAPI godot_variant_new_string(godot_variant *r_dest, const godot_string *p_s); +void GDAPI godot_variant_new_vector2(godot_variant *r_dest, const godot_vector2 *p_v2); +void GDAPI godot_variant_new_rect2(godot_variant *r_dest, const godot_rect2 *p_rect2); +void GDAPI godot_variant_new_vector3(godot_variant *r_dest, const godot_vector3 *p_v3); +void GDAPI godot_variant_new_transform2d(godot_variant *r_dest, const godot_transform2d *p_t2d); +void GDAPI godot_variant_new_plane(godot_variant *r_dest, const godot_plane *p_plane); +void GDAPI godot_variant_new_quat(godot_variant *r_dest, const godot_quat *p_quat); +void GDAPI godot_variant_new_rect3(godot_variant *r_dest, const godot_rect3 *p_rect3); +void GDAPI godot_variant_new_basis(godot_variant *r_dest, const godot_basis *p_basis); +void GDAPI godot_variant_new_transform(godot_variant *r_dest, const godot_transform *p_trans); +void GDAPI godot_variant_new_color(godot_variant *r_dest, const godot_color *p_color); +void GDAPI godot_variant_new_node_path(godot_variant *r_dest, const godot_node_path *p_np); +void GDAPI godot_variant_new_rid(godot_variant *r_dest, const godot_rid *p_rid); +void GDAPI godot_variant_new_object(godot_variant *r_dest, const godot_object *p_obj); +void GDAPI godot_variant_new_dictionary(godot_variant *r_dest, const godot_dictionary *p_dict); +void GDAPI godot_variant_new_array(godot_variant *r_dest, const godot_array *p_arr); +void GDAPI godot_variant_new_pool_byte_array(godot_variant *r_dest, const godot_pool_byte_array *p_pba); +void GDAPI godot_variant_new_pool_int_array(godot_variant *r_dest, const godot_pool_int_array *p_pia); +void GDAPI godot_variant_new_pool_real_array(godot_variant *r_dest, const godot_pool_real_array *p_pra); +void GDAPI godot_variant_new_pool_string_array(godot_variant *r_dest, const godot_pool_string_array *p_psa); +void GDAPI godot_variant_new_pool_vector2_array(godot_variant *r_dest, const godot_pool_vector2_array *p_pv2a); +void GDAPI godot_variant_new_pool_vector3_array(godot_variant *r_dest, const godot_pool_vector3_array *p_pv3a); +void GDAPI godot_variant_new_pool_color_array(godot_variant *r_dest, const godot_pool_color_array *p_pca); + +godot_bool GDAPI godot_variant_as_bool(const godot_variant *p_self); +uint64_t GDAPI godot_variant_as_uint(const godot_variant *p_self); +int64_t GDAPI godot_variant_as_int(const godot_variant *p_self); +double GDAPI godot_variant_as_real(const godot_variant *p_self); +godot_string GDAPI godot_variant_as_string(const godot_variant *p_self); +godot_vector2 GDAPI godot_variant_as_vector2(const godot_variant *p_self); +godot_rect2 GDAPI godot_variant_as_rect2(const godot_variant *p_self); +godot_vector3 GDAPI godot_variant_as_vector3(const godot_variant *p_self); +godot_transform2d GDAPI godot_variant_as_transform2d(const godot_variant *p_self); +godot_plane GDAPI godot_variant_as_plane(const godot_variant *p_self); +godot_quat GDAPI godot_variant_as_quat(const godot_variant *p_self); +godot_rect3 GDAPI godot_variant_as_rect3(const godot_variant *p_self); +godot_basis GDAPI godot_variant_as_basis(const godot_variant *p_self); +godot_transform GDAPI godot_variant_as_transform(const godot_variant *p_self); +godot_color GDAPI godot_variant_as_color(const godot_variant *p_self); +godot_node_path GDAPI godot_variant_as_node_path(const godot_variant *p_self); +godot_rid GDAPI godot_variant_as_rid(const godot_variant *p_self); +godot_object GDAPI *godot_variant_as_object(const godot_variant *p_self); +godot_dictionary GDAPI godot_variant_as_dictionary(const godot_variant *p_self); +godot_array GDAPI godot_variant_as_array(const godot_variant *p_self); +godot_pool_byte_array GDAPI godot_variant_as_pool_byte_array(const godot_variant *p_self); +godot_pool_int_array GDAPI godot_variant_as_pool_int_array(const godot_variant *p_self); +godot_pool_real_array GDAPI godot_variant_as_pool_real_array(const godot_variant *p_self); +godot_pool_string_array GDAPI godot_variant_as_pool_string_array(const godot_variant *p_self); +godot_pool_vector2_array GDAPI godot_variant_as_pool_vector2_array(const godot_variant *p_self); +godot_pool_vector3_array GDAPI godot_variant_as_pool_vector3_array(const godot_variant *p_self); +godot_pool_color_array GDAPI godot_variant_as_pool_color_array(const godot_variant *p_self); + +godot_variant GDAPI godot_variant_call(godot_variant *p_self, const godot_string *p_method, const godot_variant **p_args, const godot_int p_argcount, godot_variant_call_error *r_error); + +godot_bool GDAPI godot_variant_has_method(const godot_variant *p_self, const godot_string *p_method); + +godot_bool GDAPI godot_variant_operator_equal(const godot_variant *p_self, const godot_variant *p_other); +godot_bool GDAPI godot_variant_operator_less(const godot_variant *p_self, const godot_variant *p_other); + +godot_bool GDAPI godot_variant_hash_compare(const godot_variant *p_self, const godot_variant *p_other); + +godot_bool GDAPI godot_variant_booleanize(const godot_variant *p_self, godot_bool *r_valid); + +void GDAPI godot_variant_destroy(godot_variant *p_self); #ifdef __cplusplus } diff --git a/modules/gdnative/godot/godot_vector2.cpp b/modules/gdnative/godot/godot_vector2.cpp index 87e60b6245..0ced800872 100644 --- a/modules/gdnative/godot/godot_vector2.cpp +++ b/modules/gdnative/godot/godot_vector2.cpp @@ -28,8 +28,9 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "godot_vector2.h" +#include "core/variant.h" -#include "math/math_2d.h" +#include "core/math/math_2d.h" #ifdef __cplusplus extern "C" { @@ -37,258 +38,258 @@ extern "C" { void _vector2_api_anchor() {} -godot_vector2 GDAPI godot_vector2_new(const godot_real p_x, const godot_real p_y) { - godot_vector2 value; - Vector2 *v = (Vector2 *)&value; - v->x = p_x; - v->y = p_y; - return value; +void GDAPI godot_vector2_new(godot_vector2 *r_dest, const godot_real p_x, const godot_real p_y) { + + Vector2 *dest = (Vector2 *)r_dest; + *dest = Vector2(p_x, p_y); } -void GDAPI godot_vector2_set_x(godot_vector2 *p_v, const godot_real p_x) { - Vector2 *v = (Vector2 *)p_v; - v->x = p_x; +godot_string GDAPI godot_vector2_as_string(const godot_vector2 *p_self) { + godot_string ret; + const Vector2 *self = (const Vector2 *)p_self; + memnew_placement(&ret, String(*self)); + return ret; } -void GDAPI godot_vector2_set_y(godot_vector2 *p_v, const godot_real p_y) { - Vector2 *v = (Vector2 *)p_v; - v->y = p_y; +godot_vector2 GDAPI godot_vector2_normalized(const godot_vector2 *p_self) { + godot_vector2 dest; + const Vector2 *self = (const Vector2 *)p_self; + *((Vector2 *)&dest) = self->normalized(); + return dest; } -godot_real GDAPI godot_vector2_get_x(const godot_vector2 *p_v) { - const Vector2 *v = (Vector2 *)p_v; - return v->x; +godot_real GDAPI godot_vector2_length(const godot_vector2 *p_self) { + const Vector2 *self = (const Vector2 *)p_self; + return self->length(); } -godot_real GDAPI godot_vector2_get_y(const godot_vector2 *p_v) { - const Vector2 *v = (Vector2 *)p_v; - return v->y; + +godot_real GDAPI godot_vector2_angle(const godot_vector2 *p_self) { + const Vector2 *self = (const Vector2 *)p_self; + return self->angle(); } -void GDAPI godot_vector2_normalize(godot_vector2 *p_v) { - Vector2 *v = (Vector2 *)p_v; - v->normalize(); +godot_real GDAPI godot_vector2_length_squared(const godot_vector2 *p_self) { + const Vector2 *self = (const Vector2 *)p_self; + return self->length_squared(); } -godot_vector2 GDAPI godot_vector2_normalized(const godot_vector2 *p_v) { - godot_vector2 dest; - const Vector2 *v = (Vector2 *)p_v; - Vector2 *d = (Vector2 *)&dest; - *d = v->normalized(); - return dest; +godot_bool GDAPI godot_vector2_is_normalized(const godot_vector2 *p_self) { + const Vector2 *self = (const Vector2 *)p_self; + return self->is_normalized(); } -godot_real GDAPI godot_vector2_length(const godot_vector2 *p_v) { - const Vector2 *v = (Vector2 *)p_v; - return v->length(); +godot_real GDAPI godot_vector2_distance_to(const godot_vector2 *p_self, const godot_vector2 *p_to) { + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *to = (const Vector2 *)p_to; + return self->distance_to(*to); } -godot_real GDAPI godot_vector2_length_squared(const godot_vector2 *p_v) { - const Vector2 *v = (Vector2 *)p_v; - return v->length_squared(); +godot_real GDAPI godot_vector2_distance_squared_to(const godot_vector2 *p_self, const godot_vector2 *p_to) { + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *to = (const Vector2 *)p_to; + return self->distance_squared_to(*to); } -godot_real GDAPI godot_vector2_distance_to(const godot_vector2 *p_v, const godot_vector2 p_b) { - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *b = (Vector2 *)&p_b; - return v->distance_to(*b); +godot_real GDAPI godot_vector2_angle_to(const godot_vector2 *p_self, const godot_vector2 *p_to) { + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *to = (const Vector2 *)p_to; + return self->angle_to(*to); } -godot_real GDAPI godot_vector2_distance_squared_to(const godot_vector2 *p_v, const godot_vector2 p_b) { - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *b = (Vector2 *)&p_b; - return v->distance_squared_to(*b); +godot_real GDAPI godot_vector2_angle_to_point(const godot_vector2 *p_self, const godot_vector2 *p_to) { + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *to = (const Vector2 *)p_to; + return self->angle_to_point(*to); } -godot_vector2 GDAPI godot_vector2_operator_add(const godot_vector2 *p_v, const godot_vector2 p_b) { +godot_vector2 GDAPI godot_vector2_linear_interpolate(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_real p_t) { godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *b = (Vector2 *)&p_b; - *d = *v + *b; + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *b = (const Vector2 *)p_b; + *((Vector2 *)&dest) = self->linear_interpolate(*b, p_t); return dest; } -godot_vector2 GDAPI godot_vector2_operator_subtract(const godot_vector2 *p_v, const godot_vector2 p_b) { +godot_vector2 GDAPI godot_vector2_cubic_interpolate(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_vector2 *p_pre_a, const godot_vector2 *p_post_b, const godot_real p_t) { godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *b = (Vector2 *)&p_b; - *d = *v - *b; + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *b = (const Vector2 *)p_b; + const Vector2 *pre_a = (const Vector2 *)p_pre_a; + const Vector2 *post_b = (const Vector2 *)p_post_b; + *((Vector2 *)&dest) = self->cubic_interpolate(*b, *pre_a, *post_b, p_t); return dest; } -godot_vector2 GDAPI godot_vector2_operator_multiply_vector(const godot_vector2 *p_v, const godot_vector2 p_b) { +godot_vector2 GDAPI godot_vector2_rotated(const godot_vector2 *p_self, const godot_real p_phi) { godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *b = (Vector2 *)&p_b; - *d = *v * *b; + const Vector2 *self = (const Vector2 *)p_self; + + *((Vector2 *)&dest) = self->rotated(p_phi); return dest; } -godot_vector2 GDAPI godot_vector2_operator_multiply_scalar(const godot_vector2 *p_v, const godot_real p_b) { +godot_vector2 GDAPI godot_vector2_tangent(const godot_vector2 *p_self) { godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - const Vector2 *v = (Vector2 *)p_v; - *d = *v * p_b; + const Vector2 *self = (const Vector2 *)p_self; + *((Vector2 *)&dest) = self->tangent(); return dest; } -godot_vector2 GDAPI godot_vector2_operator_divide_vector(const godot_vector2 *p_v, const godot_vector2 p_b) { +godot_vector2 GDAPI godot_vector2_floor(const godot_vector2 *p_self) { godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *b = (Vector2 *)&p_b; - *d = *v / *b; + const Vector2 *self = (const Vector2 *)p_self; + *((Vector2 *)&dest) = self->floor(); return dest; } -godot_vector2 GDAPI godot_vector2_operator_divide_scalar(const godot_vector2 *p_v, const godot_real p_b) { +godot_vector2 GDAPI godot_vector2_snapped(const godot_vector2 *p_self, const godot_vector2 *p_by) { godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - const Vector2 *v = (Vector2 *)p_v; - *d = *v / p_b; + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *by = (const Vector2 *)p_by; + *((Vector2 *)&dest) = self->snapped(*by); return dest; } -godot_bool GDAPI godot_vector2_operator_equal(const godot_vector2 *p_v, const godot_vector2 p_b) { - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *b = (Vector2 *)&p_b; - return *v == *b; +godot_real GDAPI godot_vector2_aspect(const godot_vector2 *p_self) { + const Vector2 *self = (const Vector2 *)p_self; + return self->aspect(); } -godot_bool GDAPI godot_vector2_operator_less(const godot_vector2 *p_v, const godot_vector2 p_b) { - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *b = (Vector2 *)&p_b; - return *v < *b; +godot_real GDAPI godot_vector2_dot(const godot_vector2 *p_self, const godot_vector2 *p_with) { + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *with = (const Vector2 *)p_with; + return self->dot(*with); } -godot_vector2 GDAPI godot_vector2_abs(const godot_vector2 *p_v) { +godot_vector2 GDAPI godot_vector2_slide(const godot_vector2 *p_self, const godot_vector2 *p_n) { godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - const Vector2 *v = (Vector2 *)p_v; - *d = v->abs(); + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *n = (const Vector2 *)p_n; + *((Vector2 *)&dest) = self->slide(*n); return dest; } -godot_real GDAPI godot_vector2_angle(const godot_vector2 *p_v) { - const Vector2 *v = (Vector2 *)p_v; - return v->angle(); -} - -godot_real GDAPI godot_vector2_angle_to(const godot_vector2 *p_v, const godot_vector2 p_to) { - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *to = (Vector2 *)&p_to; - return v->angle_to(*to); +godot_vector2 GDAPI godot_vector2_bounce(const godot_vector2 *p_self, const godot_vector2 *p_n) { + godot_vector2 dest; + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *n = (const Vector2 *)p_n; + *((Vector2 *)&dest) = self->bounce(*n); + return dest; } -godot_real GDAPI godot_vector2_angle_to_point(const godot_vector2 *p_v, const godot_vector2 p_to) { - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *to = (Vector2 *)&p_to; - return v->angle_to_point(*to); +godot_vector2 GDAPI godot_vector2_reflect(const godot_vector2 *p_self, const godot_vector2 *p_n) { + godot_vector2 dest; + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *n = (const Vector2 *)p_n; + *((Vector2 *)&dest) = self->reflect(*n); + return dest; } -godot_vector2 GDAPI godot_vector2_clamped(const godot_vector2 *p_v, const godot_real length) { +godot_vector2 GDAPI godot_vector2_abs(const godot_vector2 *p_self) { godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - const Vector2 *v = (Vector2 *)p_v; - *d = v->clamped(length); + const Vector2 *self = (const Vector2 *)p_self; + *((Vector2 *)&dest) = self->abs(); return dest; } -godot_vector2 GDAPI godot_vector2_cubic_interpolate( - const godot_vector2 *p_v, const godot_vector2 p_b, const godot_vector2 p_pre_a, - const godot_vector2 p_post_b, godot_real t) { +godot_vector2 GDAPI godot_vector2_clamped(const godot_vector2 *p_self, const godot_real p_length) { godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *b = (Vector2 *)&p_b; - const Vector2 *pre_a = (Vector2 *)&p_pre_a; - const Vector2 *post_b = (Vector2 *)&p_post_b; - *d = v->cubic_interpolate(*b, *pre_a, *post_b, t); + const Vector2 *self = (const Vector2 *)p_self; + + *((Vector2 *)&dest) = self->clamped(p_length); return dest; } -godot_real GDAPI godot_vector2_dot(const godot_vector2 *p_v, const godot_vector2 p_with) { - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *with = (Vector2 *)&p_with; - return v->dot(*with); +godot_vector2 GDAPI godot_vector2_operator_add(const godot_vector2 *p_self, const godot_vector2 *p_b) { + godot_vector2 raw_dest; + Vector2 *dest = (Vector2 *)&raw_dest; + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *b = (const Vector2 *)p_b; + *dest = *self + *b; + return raw_dest; } -godot_vector2 GDAPI godot_vector2_floor(const godot_vector2 *p_v) { - godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - const Vector2 *v = (Vector2 *)p_v; - *d = v->floor(); - return dest; +godot_vector2 GDAPI godot_vector2_operator_substract(const godot_vector2 *p_self, const godot_vector2 *p_b) { + godot_vector2 raw_dest; + Vector2 *dest = (Vector2 *)&raw_dest; + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *b = (const Vector2 *)p_b; + *dest = *self - *b; + return raw_dest; } -godot_real GDAPI godot_vector2_aspect(const godot_vector2 *p_v) { - const Vector2 *v = (Vector2 *)p_v; - return v->aspect(); +godot_vector2 GDAPI godot_vector2_operator_multiply_vector(const godot_vector2 *p_self, const godot_vector2 *p_b) { + godot_vector2 raw_dest; + Vector2 *dest = (Vector2 *)&raw_dest; + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *b = (const Vector2 *)p_b; + *dest = *self * *b; + return raw_dest; } -godot_vector2 GDAPI godot_vector2_linear_interpolate( - const godot_vector2 *p_v, - const godot_vector2 p_b, - godot_real t) { - godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *b = (Vector2 *)&p_b; - *d = v->linear_interpolate(*b, t); - return dest; +godot_vector2 GDAPI godot_vector2_operator_multiply_scalar(const godot_vector2 *p_self, const godot_real p_b) { + godot_vector2 raw_dest; + Vector2 *dest = (Vector2 *)&raw_dest; + const Vector2 *self = (const Vector2 *)p_self; + *dest = *self * p_b; + return raw_dest; } -godot_vector2 GDAPI godot_vector2_reflect(const godot_vector2 *p_v, const godot_vector2 p_vec) { - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *vec = (Vector2 *)&p_vec; - godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - *d = v->reflect(*vec); - return dest; +godot_vector2 GDAPI godot_vector2_operator_divide_vector(const godot_vector2 *p_self, const godot_vector2 *p_b) { + godot_vector2 raw_dest; + Vector2 *dest = (Vector2 *)&raw_dest; + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *b = (const Vector2 *)p_b; + *dest = *self / *b; + return raw_dest; } -godot_vector2 GDAPI godot_vector2_rotated(const godot_vector2 *p_v, godot_real phi) { - const Vector2 *v = (Vector2 *)p_v; - godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - *d = v->rotated(phi); - return dest; +godot_vector2 GDAPI godot_vector2_operator_divide_scalar(const godot_vector2 *p_self, const godot_real p_b) { + godot_vector2 raw_dest; + Vector2 *dest = (Vector2 *)&raw_dest; + const Vector2 *self = (const Vector2 *)p_self; + *dest = *self / p_b; + return raw_dest; } -godot_vector2 GDAPI godot_vector2_slide(const godot_vector2 *p_v, godot_vector2 p_vec) { - godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *vec = (Vector2 *)&p_vec; - *d = v->slide(*vec); - return dest; +godot_bool GDAPI godot_vector2_operator_equal(const godot_vector2 *p_self, const godot_vector2 *p_b) { + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *b = (const Vector2 *)p_b; + return *self == *b; } -godot_vector2 GDAPI godot_vector2_snapped(const godot_vector2 *p_v, godot_vector2 p_by) { - godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - const Vector2 *v = (Vector2 *)p_v; - const Vector2 *by = (Vector2 *)&p_by; - *d = v->snapped(*by); - return dest; +godot_bool GDAPI godot_vector2_operator_less(const godot_vector2 *p_self, const godot_vector2 *p_b) { + const Vector2 *self = (const Vector2 *)p_self; + const Vector2 *b = (const Vector2 *)p_b; + return *self < *b; } -godot_vector2 GDAPI godot_vector2_tangent(const godot_vector2 *p_v) { - godot_vector2 dest; - Vector2 *d = (Vector2 *)&dest; - const Vector2 *v = (Vector2 *)p_v; - *d = v->tangent(); - return dest; +godot_vector2 GDAPI godot_vector2_operator_neg(const godot_vector2 *p_self) { + godot_vector2 raw_dest; + Vector2 *dest = (Vector2 *)&raw_dest; + const Vector2 *self = (const Vector2 *)p_self; + *dest = -(*self); + return raw_dest; } -godot_string GDAPI godot_vector2_to_string(const godot_vector2 *p_v) { - godot_string dest; - String *d = (String *)&dest; - const Vector2 *v = (Vector2 *)p_v; - *d = "(" + *v + ")"; - return dest; +void GDAPI godot_vector2_set_x(godot_vector2 *p_self, const godot_real p_x) { + Vector2 *self = (Vector2 *)p_self; + self->x = p_x; +} + +void GDAPI godot_vector2_set_y(godot_vector2 *p_self, const godot_real p_y) { + Vector2 *self = (Vector2 *)p_self; + self->y = p_y; +} + +godot_real GDAPI godot_vector2_get_x(const godot_vector2 *p_self) { + const Vector2 *self = (const Vector2 *)p_self; + return self->x; +} + +godot_real GDAPI godot_vector2_get_y(const godot_vector2 *p_self) { + const Vector2 *self = (const Vector2 *)p_self; + return self->y; } #ifdef __cplusplus diff --git a/modules/gdnative/godot/godot_vector2.h b/modules/gdnative/godot/godot_vector2.h index 36a4f01d03..9c7590fedf 100644 --- a/modules/gdnative/godot/godot_vector2.h +++ b/modules/gdnative/godot/godot_vector2.h @@ -45,51 +45,79 @@ typedef struct godot_vector2 { #include "../godot.h" -godot_vector2 GDAPI godot_vector2_new(const godot_real p_x, const godot_real p_y); - -void GDAPI godot_vector2_set_x(godot_vector2 *p_v, const godot_real p_x); -void GDAPI godot_vector2_set_y(godot_vector2 *p_v, const godot_real p_y); -godot_real GDAPI godot_vector2_get_x(const godot_vector2 *p_v); -godot_real GDAPI godot_vector2_get_y(const godot_vector2 *p_v); - -void GDAPI godot_vector2_normalize(godot_vector2 *p_v); -godot_vector2 GDAPI godot_vector2_normalized(const godot_vector2 *p_v); - -godot_real GDAPI godot_vector2_length(const godot_vector2 *p_v); -godot_real GDAPI godot_vector2_length_squared(const godot_vector2 *p_v); - -godot_real GDAPI godot_vector2_distance_to(const godot_vector2 *p_v, const godot_vector2 p_b); -godot_real GDAPI godot_vector2_distance_squared_to(const godot_vector2 *p_v, const godot_vector2 p_b); - -godot_vector2 GDAPI godot_vector2_abs(const godot_vector2 *p_v); -godot_real GDAPI godot_vector2_angle(const godot_vector2 *p_v); -godot_real GDAPI godot_vector2_angle_to(const godot_vector2 *p_v, const godot_vector2 p_to); -godot_real GDAPI godot_vector2_angle_to_point(const godot_vector2 *p_v, const godot_vector2 p_to); -godot_vector2 GDAPI godot_vector2_clamped(const godot_vector2 *p_v, godot_real length); -godot_vector2 GDAPI godot_vector2_cubic_interpolate(const godot_vector2 *p_v, - const godot_vector2 p_b, const godot_vector2 p_pre_a, - const godot_vector2 p_post_b, godot_real t); -godot_real GDAPI godot_vector2_dot(const godot_vector2 *p_v, const godot_vector2 p_with); -godot_vector2 GDAPI godot_vector2_floor(const godot_vector2 *p_v); -godot_real GDAPI godot_vector2_aspect(const godot_vector2 *p_v); -godot_vector2 GDAPI godot_vector2_linear_interpolate(const godot_vector2 *p_v, - const godot_vector2 p_b, godot_real t); -godot_vector2 GDAPI godot_vector2_reflect(const godot_vector2 *p_v, const godot_vector2 p_vec); -godot_vector2 GDAPI godot_vector2_rotated(const godot_vector2 *p_v, godot_real phi); -godot_vector2 GDAPI godot_vector2_slide(const godot_vector2 *p_v, godot_vector2 p_vec); -godot_vector2 GDAPI godot_vector2_snapped(const godot_vector2 *p_v, godot_vector2 p_by); -godot_vector2 GDAPI godot_vector2_tangent(const godot_vector2 *p_v); -godot_string GDAPI godot_vector2_to_string(const godot_vector2 *p_v); - -godot_vector2 GDAPI godot_vector2_operator_add(const godot_vector2 *p_v, const godot_vector2 p_b); -godot_vector2 GDAPI godot_vector2_operator_subtract(const godot_vector2 *p_v, const godot_vector2 p_b); -godot_vector2 GDAPI godot_vector2_operator_multiply_vector(const godot_vector2 *p_v, const godot_vector2 p_b); -godot_vector2 GDAPI godot_vector2_operator_multiply_scalar(const godot_vector2 *p_v, const godot_real p_b); -godot_vector2 GDAPI godot_vector2_operator_divide_vector(const godot_vector2 *p_v, const godot_vector2 p_b); -godot_vector2 GDAPI godot_vector2_operator_divide_scalar(const godot_vector2 *p_v, const godot_real p_b); - -godot_bool GDAPI godot_vector2_operator_equal(const godot_vector2 *p_v, const godot_vector2 p_b); -godot_bool GDAPI godot_vector2_operator_less(const godot_vector2 *p_v, const godot_vector2 p_b); +void GDAPI godot_vector2_new(godot_vector2 *r_dest, const godot_real p_x, const godot_real p_y); + +godot_string GDAPI godot_vector2_as_string(const godot_vector2 *p_self); + +godot_vector2 GDAPI godot_vector2_normalized(const godot_vector2 *p_self); + +godot_real GDAPI godot_vector2_length(const godot_vector2 *p_self); + +godot_real GDAPI godot_vector2_angle(const godot_vector2 *p_self); + +godot_real GDAPI godot_vector2_length_squared(const godot_vector2 *p_self); + +godot_bool GDAPI godot_vector2_is_normalized(const godot_vector2 *p_self); + +godot_real GDAPI godot_vector2_distance_to(const godot_vector2 *p_self, const godot_vector2 *p_to); + +godot_real GDAPI godot_vector2_distance_squared_to(const godot_vector2 *p_self, const godot_vector2 *p_to); + +godot_real GDAPI godot_vector2_angle_to(const godot_vector2 *p_self, const godot_vector2 *p_to); + +godot_real GDAPI godot_vector2_angle_to_point(const godot_vector2 *p_self, const godot_vector2 *p_to); + +godot_vector2 GDAPI godot_vector2_linear_interpolate(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_real p_t); + +godot_vector2 GDAPI godot_vector2_cubic_interpolate(const godot_vector2 *p_self, const godot_vector2 *p_b, const godot_vector2 *p_pre_a, const godot_vector2 *p_post_b, const godot_real p_t); + +godot_vector2 GDAPI godot_vector2_rotated(const godot_vector2 *p_self, const godot_real p_phi); + +godot_vector2 GDAPI godot_vector2_tangent(const godot_vector2 *p_self); + +godot_vector2 GDAPI godot_vector2_floor(const godot_vector2 *p_self); + +godot_vector2 GDAPI godot_vector2_snapped(const godot_vector2 *p_self, const godot_vector2 *p_by); + +godot_real GDAPI godot_vector2_aspect(const godot_vector2 *p_self); + +godot_real GDAPI godot_vector2_dot(const godot_vector2 *p_self, const godot_vector2 *p_with); + +godot_vector2 GDAPI godot_vector2_slide(const godot_vector2 *p_self, const godot_vector2 *p_n); + +godot_vector2 GDAPI godot_vector2_bounce(const godot_vector2 *p_self, const godot_vector2 *p_n); + +godot_vector2 GDAPI godot_vector2_reflect(const godot_vector2 *p_self, const godot_vector2 *p_n); + +godot_vector2 GDAPI godot_vector2_abs(const godot_vector2 *p_self); + +godot_vector2 GDAPI godot_vector2_clamped(const godot_vector2 *p_self, const godot_real p_length); + +godot_vector2 GDAPI godot_vector2_operator_add(const godot_vector2 *p_self, const godot_vector2 *p_b); + +godot_vector2 GDAPI godot_vector2_operator_substract(const godot_vector2 *p_self, const godot_vector2 *p_b); + +godot_vector2 GDAPI godot_vector2_operator_multiply_vector(const godot_vector2 *p_self, const godot_vector2 *p_b); + +godot_vector2 GDAPI godot_vector2_operator_multiply_scalar(const godot_vector2 *p_self, const godot_real p_b); + +godot_vector2 GDAPI godot_vector2_operator_divide_vector(const godot_vector2 *p_self, const godot_vector2 *p_b); + +godot_vector2 GDAPI godot_vector2_operator_divide_scalar(const godot_vector2 *p_self, const godot_real p_b); + +godot_bool GDAPI godot_vector2_operator_equal(const godot_vector2 *p_self, const godot_vector2 *p_b); + +godot_bool GDAPI godot_vector2_operator_less(const godot_vector2 *p_self, const godot_vector2 *p_b); + +godot_vector2 GDAPI godot_vector2_operator_neg(const godot_vector2 *p_self); + +void GDAPI godot_vector2_set_x(godot_vector2 *p_self, const godot_real p_x); + +void GDAPI godot_vector2_set_y(godot_vector2 *p_self, const godot_real p_y); + +godot_real GDAPI godot_vector2_get_x(const godot_vector2 *p_self); + +godot_real GDAPI godot_vector2_get_y(const godot_vector2 *p_self); #ifdef __cplusplus } diff --git a/modules/gdnative/godot/godot_vector3.cpp b/modules/gdnative/godot/godot_vector3.cpp index 5f71b9f7e4..f9942af6e5 100644 --- a/modules/gdnative/godot/godot_vector3.cpp +++ b/modules/gdnative/godot/godot_vector3.cpp @@ -28,313 +28,274 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "godot_vector3.h" +#include "core/variant.h" -#include "math/vector3.h" +#include "core/vector.h" #ifdef __cplusplus extern "C" { #endif -void _vector3_api_anchor() { -} +void _vector3_api_anchor() {} -godot_vector3 GDAPI godot_vector3_new(const godot_real p_x, const godot_real p_y, const godot_real p_z) { - godot_vector3 value; - Vector3 *v = (Vector3 *)&value; - *v = Vector3(p_x, p_y, p_z); - return value; -} +void GDAPI godot_vector3_new(godot_vector3 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z) { -void GDAPI godot_vector3_set_axis(godot_vector3 *p_v, const godot_int p_axis, const godot_real p_val) { - Vector3 *v = (Vector3 *)p_v; - v->set_axis(p_axis, p_val); + Vector3 *dest = (Vector3 *)r_dest; + *dest = Vector3(p_x, p_y, p_z); } -godot_real GDAPI godot_vector3_get_axis(const godot_vector3 *p_v, const godot_int p_axis) { - Vector3 *v = (Vector3 *)p_v; - return v->get_axis(p_axis); +godot_string GDAPI godot_vector3_as_string(const godot_vector3 *p_self) { + godot_string ret; + const Vector3 *self = (const Vector3 *)p_self; + memnew_placement(&ret, String(*self)); + return ret; } -godot_int GDAPI godot_vector3_min_axis(const godot_vector3 *p_v) { - Vector3 *v = (Vector3 *)p_v; - return v->min_axis(); +godot_int GDAPI godot_vector3_min_axis(const godot_vector3 *p_self) { + const Vector3 *self = (const Vector3 *)p_self; + return self->min_axis(); } -godot_int GDAPI godot_vector3_max_axis(const godot_vector3 *p_v) { - Vector3 *v = (Vector3 *)p_v; - return v->max_axis(); +godot_int GDAPI godot_vector3_max_axis(const godot_vector3 *p_self) { + const Vector3 *self = (const Vector3 *)p_self; + return self->max_axis(); } -godot_real GDAPI godot_vector3_length(const godot_vector3 *p_v) { - Vector3 *v = (Vector3 *)p_v; - return v->length(); +godot_real GDAPI godot_vector3_length(const godot_vector3 *p_self) { + const Vector3 *self = (const Vector3 *)p_self; + return self->length(); } -godot_real GDAPI godot_vector3_length_squared(const godot_vector3 *p_v) { - Vector3 *v = (Vector3 *)p_v; - return v->length_squared(); +godot_real GDAPI godot_vector3_length_squared(const godot_vector3 *p_self) { + const Vector3 *self = (const Vector3 *)p_self; + return self->length_squared(); } -void GDAPI godot_vector3_normalize(godot_vector3 *p_v) { - Vector3 *v = (Vector3 *)p_v; - v->normalize(); +godot_bool GDAPI godot_vector3_is_normalized(const godot_vector3 *p_self) { + const Vector3 *self = (const Vector3 *)p_self; + return self->is_normalized(); } -godot_vector3 GDAPI godot_vector3_normalized(const godot_vector3 *p_v) { +godot_vector3 GDAPI godot_vector3_normalized(const godot_vector3 *p_self) { godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - Vector3 *v = (Vector3 *)p_v; - *d = v->normalized(); + const Vector3 *self = (const Vector3 *)p_self; + *((Vector3 *)&dest) = self->normalized(); return dest; } -godot_vector3 godot_vector3_inverse(const godot_vector3 *p_v) { +godot_vector3 GDAPI godot_vector3_inverse(const godot_vector3 *p_self) { godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Vector3 *v = (Vector3 *)p_v; - *d = v->inverse(); + const Vector3 *self = (const Vector3 *)p_self; + *((Vector3 *)&dest) = self->inverse(); return dest; } -void godot_vector3_zero(godot_vector3 *p_v) { - Vector3 *v = (Vector3 *)p_v; - v->zero(); -} - -void godot_vector3_snap(godot_vector3 *p_v, const godot_real val) { - Vector3 *v = (Vector3 *)p_v; - v->snap(val); -} - -godot_vector3 godot_vector3_snapped(const godot_vector3 *p_v, const godot_real val) { +godot_vector3 GDAPI godot_vector3_snapped(const godot_vector3 *p_self, const godot_real p_by) { godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Vector3 *v = (Vector3 *)p_v; - *d = v->snapped(val); - return dest; -} + const Vector3 *self = (const Vector3 *)p_self; -void godot_vector3_rotate(godot_vector3 *p_v, const godot_vector3 p_axis, const godot_real phi) { - Vector3 *v = (Vector3 *)p_v; - const Vector3 *axis = (Vector3 *)&p_axis; - v->rotate(*axis, phi); + *((Vector3 *)&dest) = self->snapped(p_by); + return dest; } -godot_vector3 godot_vector3_rotated(const godot_vector3 *p_v, const godot_vector3 p_axis, const godot_real phi) { +godot_vector3 GDAPI godot_vector3_rotated(const godot_vector3 *p_self, const godot_vector3 *p_axis, const godot_real p_phi) { godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Vector3 *v = (Vector3 *)p_v; - const Vector3 *axis = (Vector3 *)&p_axis; - *d = v->rotated(*axis, phi); + const Vector3 *self = (const Vector3 *)p_self; + const Vector3 *axis = (const Vector3 *)p_axis; + *((Vector3 *)&dest) = self->rotated(*axis, p_phi); return dest; } -godot_vector3 godot_vector3_linear_interpolate(const godot_vector3 *p_v, const godot_vector3 p_b, const godot_real t) { +godot_vector3 GDAPI godot_vector3_linear_interpolate(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_real p_t) { godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Vector3 *v = (Vector3 *)p_v; - const Vector3 *b = (Vector3 *)&p_b; - *d = v->linear_interpolate(*b, t); + const Vector3 *self = (const Vector3 *)p_self; + const Vector3 *b = (const Vector3 *)p_b; + *((Vector3 *)&dest) = self->linear_interpolate(*b, p_t); return dest; } -godot_vector3 godot_vector3_cubic_interpolate(const godot_vector3 *p_v, - const godot_vector3 p_b, const godot_vector3 p_pre_a, - const godot_vector3 p_post_b, const godot_real t) { +godot_vector3 GDAPI godot_vector3_cubic_interpolate(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_vector3 *p_pre_a, const godot_vector3 *p_post_b, const godot_real p_t) { godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Vector3 *v = (Vector3 *)p_v; - const Vector3 *b = (Vector3 *)&p_b; - const Vector3 *pre_a = (Vector3 *)&p_pre_a; - const Vector3 *post_b = (Vector3 *)&p_post_b; - *d = v->cubic_interpolate(*b, *pre_a, *post_b, t); + const Vector3 *self = (const Vector3 *)p_self; + const Vector3 *b = (const Vector3 *)p_b; + const Vector3 *pre_a = (const Vector3 *)p_pre_a; + const Vector3 *post_b = (const Vector3 *)p_post_b; + *((Vector3 *)&dest) = self->cubic_interpolate(*b, *pre_a, *post_b, p_t); return dest; } -godot_vector3 godot_vector3_cubic_interpolaten(const godot_vector3 *p_v, - const godot_vector3 p_b, const godot_vector3 p_pre_a, - const godot_vector3 p_post_b, const godot_real t) { - godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Vector3 *v = (Vector3 *)p_v; - const Vector3 *b = (Vector3 *)&p_b; - const Vector3 *pre_a = (Vector3 *)&p_pre_a; - const Vector3 *post_b = (Vector3 *)&p_post_b; - *d = v->cubic_interpolaten(*b, *pre_a, *post_b, t); - return dest; +godot_real GDAPI godot_vector3_dot(const godot_vector3 *p_self, const godot_vector3 *p_b) { + const Vector3 *self = (const Vector3 *)p_self; + const Vector3 *b = (const Vector3 *)p_b; + return self->dot(*b); } -godot_vector3 godot_vector3_cross(const godot_vector3 *p_v, const godot_vector3 p_b) { +godot_vector3 GDAPI godot_vector3_cross(const godot_vector3 *p_self, const godot_vector3 *p_b) { godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Vector3 *v = (Vector3 *)p_v; - const Vector3 *b = (Vector3 *)&p_b; - *d = v->cross(*b); + const Vector3 *self = (const Vector3 *)p_self; + const Vector3 *b = (const Vector3 *)p_b; + *((Vector3 *)&dest) = self->cross(*b); return dest; } -godot_real godot_vector3_dot(const godot_vector3 *p_v, const godot_vector3 p_b) { - const Vector3 *v = (Vector3 *)p_v; - const Vector3 *b = (Vector3 *)&p_b; - return v->dot(*b); -} - -godot_basis godot_vector3_outer(const godot_vector3 *p_v, const godot_vector3 p_b) { +godot_basis GDAPI godot_vector3_outer(const godot_vector3 *p_self, const godot_vector3 *p_b) { godot_basis dest; - Basis *d = (Basis *)&dest; - const Vector3 *v = (Vector3 *)p_v; - const Vector3 *b = (Vector3 *)&p_b; - *d = v->outer(*b); + const Vector3 *self = (const Vector3 *)p_self; + const Vector3 *b = (const Vector3 *)p_b; + *((Basis *)&dest) = self->outer(*b); return dest; } -godot_basis godot_vector3_to_diagonal_matrix(const godot_vector3 *p_v) { +godot_basis GDAPI godot_vector3_to_diagonal_matrix(const godot_vector3 *p_self) { godot_basis dest; - Basis *d = (Basis *)&dest; - const Vector3 *v = (Vector3 *)p_v; - *d = v->to_diagonal_matrix(); + const Vector3 *self = (const Vector3 *)p_self; + *((Basis *)&dest) = self->to_diagonal_matrix(); return dest; } -godot_vector3 godot_vector3_abs(const godot_vector3 *p_v) { +godot_vector3 GDAPI godot_vector3_abs(const godot_vector3 *p_self) { godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Vector3 *v = (Vector3 *)p_v; - *d = v->abs(); + const Vector3 *self = (const Vector3 *)p_self; + *((Vector3 *)&dest) = self->abs(); return dest; } -godot_vector3 godot_vector3_floor(const godot_vector3 *p_v) { +godot_vector3 GDAPI godot_vector3_floor(const godot_vector3 *p_self) { godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Vector3 *v = (Vector3 *)p_v; - *d = v->floor(); + const Vector3 *self = (const Vector3 *)p_self; + *((Vector3 *)&dest) = self->floor(); return dest; } -godot_vector3 godot_vector3_ceil(const godot_vector3 *p_v) { +godot_vector3 GDAPI godot_vector3_ceil(const godot_vector3 *p_self) { godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Vector3 *v = (Vector3 *)p_v; - *d = v->ceil(); + const Vector3 *self = (const Vector3 *)p_self; + *((Vector3 *)&dest) = self->ceil(); return dest; } -godot_real GDAPI godot_vector3_distance_to(const godot_vector3 *p_v, const godot_vector3 p_b) { - Vector3 *v = (Vector3 *)p_v; - Vector3 *b = (Vector3 *)&p_b; - return v->distance_to(*b); +godot_real GDAPI godot_vector3_distance_to(const godot_vector3 *p_self, const godot_vector3 *p_b) { + const Vector3 *self = (const Vector3 *)p_self; + const Vector3 *b = (const Vector3 *)p_b; + return self->distance_to(*b); } -godot_real GDAPI godot_vector3_distance_squared_to(const godot_vector3 *p_v, const godot_vector3 p_b) { - Vector3 *v = (Vector3 *)p_v; - Vector3 *b = (Vector3 *)&p_b; - return v->distance_squared_to(*b); +godot_real GDAPI godot_vector3_distance_squared_to(const godot_vector3 *p_self, const godot_vector3 *p_b) { + const Vector3 *self = (const Vector3 *)p_self; + const Vector3 *b = (const Vector3 *)p_b; + return self->distance_squared_to(*b); } -godot_real GDAPI godot_vector3_angle_to(const godot_vector3 *p_v, const godot_vector3 p_b) { - Vector3 *v = (Vector3 *)p_v; - Vector3 *b = (Vector3 *)&p_b; - return v->angle_to(*b); +godot_real GDAPI godot_vector3_angle_to(const godot_vector3 *p_self, const godot_vector3 *p_to) { + const Vector3 *self = (const Vector3 *)p_self; + const Vector3 *to = (const Vector3 *)p_to; + return self->angle_to(*to); } -godot_vector3 godot_vector3_slide(const godot_vector3 *p_v, const godot_vector3 p_vec) { +godot_vector3 GDAPI godot_vector3_slide(const godot_vector3 *p_self, const godot_vector3 *p_n) { godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Vector3 *v = (Vector3 *)p_v; - const Vector3 *vec = (Vector3 *)&p_vec; - *d = v->slide(*vec); + const Vector3 *self = (const Vector3 *)p_self; + const Vector3 *n = (const Vector3 *)p_n; + *((Vector3 *)&dest) = self->slide(*n); return dest; } -godot_vector3 godot_vector3_bounce(const godot_vector3 *p_v, const godot_vector3 p_vec) { +godot_vector3 GDAPI godot_vector3_bounce(const godot_vector3 *p_self, const godot_vector3 *p_n) { godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Vector3 *v = (Vector3 *)p_v; - const Vector3 *vec = (Vector3 *)&p_vec; - *d = v->bounce(*vec); + const Vector3 *self = (const Vector3 *)p_self; + const Vector3 *n = (const Vector3 *)p_n; + *((Vector3 *)&dest) = self->bounce(*n); return dest; } -godot_vector3 godot_vector3_reflect(const godot_vector3 *p_v, const godot_vector3 p_vec) { +godot_vector3 GDAPI godot_vector3_reflect(const godot_vector3 *p_self, const godot_vector3 *p_n) { godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - const Vector3 *v = (Vector3 *)p_v; - const Vector3 *vec = (Vector3 *)&p_vec; - *d = v->reflect(*vec); + const Vector3 *self = (const Vector3 *)p_self; + const Vector3 *n = (const Vector3 *)p_n; + *((Vector3 *)&dest) = self->reflect(*n); return dest; } -godot_vector3 GDAPI godot_vector3_operator_add(const godot_vector3 *p_v, const godot_vector3 p_b) { - godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - Vector3 *v = (Vector3 *)p_v; - Vector3 *b = (Vector3 *)&p_b; - *d = *v + *b; - return dest; +godot_vector3 GDAPI godot_vector3_operator_add(const godot_vector3 *p_self, const godot_vector3 *p_b) { + godot_vector3 raw_dest; + Vector3 *dest = (Vector3 *)&raw_dest; + Vector3 *self = (Vector3 *)p_self; + const Vector3 *b = (const Vector3 *)p_b; + *dest = *self + *b; + return raw_dest; } -godot_vector3 GDAPI godot_vector3_operator_subtract(const godot_vector3 *p_v, const godot_vector3 p_b) { - godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - Vector3 *v = (Vector3 *)p_v; - Vector3 *b = (Vector3 *)&p_b; - *d = *v - *b; - return dest; +godot_vector3 GDAPI godot_vector3_operator_substract(const godot_vector3 *p_self, const godot_vector3 *p_b) { + godot_vector3 raw_dest; + Vector3 *dest = (Vector3 *)&raw_dest; + Vector3 *self = (Vector3 *)p_self; + const Vector3 *b = (const Vector3 *)p_b; + *dest = *self - *b; + return raw_dest; } -godot_vector3 GDAPI godot_vector3_operator_multiply_vector(const godot_vector3 *p_v, const godot_vector3 p_b) { - godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - Vector3 *v = (Vector3 *)p_v; - Vector3 *b = (Vector3 *)&p_b; - *d = *v * *b; - return dest; +godot_vector3 GDAPI godot_vector3_operator_multiply_vector(const godot_vector3 *p_self, const godot_vector3 *p_b) { + godot_vector3 raw_dest; + Vector3 *dest = (Vector3 *)&raw_dest; + Vector3 *self = (Vector3 *)p_self; + const Vector3 *b = (const Vector3 *)p_b; + *dest = *self * *b; + return raw_dest; } -godot_vector3 GDAPI godot_vector3_operator_multiply_scalar(const godot_vector3 *p_v, const godot_real p_b) { - godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - Vector3 *v = (Vector3 *)p_v; - *d = *v * p_b; - return dest; +godot_vector3 GDAPI godot_vector3_operator_multiply_scalar(const godot_vector3 *p_self, const godot_real p_b) { + godot_vector3 raw_dest; + Vector3 *dest = (Vector3 *)&raw_dest; + Vector3 *self = (Vector3 *)p_self; + *dest = *self * p_b; + return raw_dest; } -godot_vector3 GDAPI godot_vector3_operator_divide_vector(const godot_vector3 *p_v, const godot_vector3 p_b) { - godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - Vector3 *v = (Vector3 *)p_v; - Vector3 *b = (Vector3 *)&p_b; - *d = *v / *b; - return dest; +godot_vector3 GDAPI godot_vector3_operator_divide_vector(const godot_vector3 *p_self, const godot_vector3 *p_b) { + godot_vector3 raw_dest; + Vector3 *dest = (Vector3 *)&raw_dest; + Vector3 *self = (Vector3 *)p_self; + const Vector3 *b = (const Vector3 *)p_b; + *dest = *self / *b; + return raw_dest; } -godot_vector3 GDAPI godot_vector3_operator_divide_scalar(const godot_vector3 *p_v, const godot_real p_b) { - godot_vector3 dest; - Vector3 *d = (Vector3 *)&dest; - Vector3 *v = (Vector3 *)p_v; - *d = *v / p_b; - return dest; +godot_vector3 GDAPI godot_vector3_operator_divide_scalar(const godot_vector3 *p_self, const godot_real p_b) { + godot_vector3 raw_dest; + Vector3 *dest = (Vector3 *)&raw_dest; + Vector3 *self = (Vector3 *)p_self; + *dest = *self / p_b; + return raw_dest; } -godot_bool GDAPI godot_vector3_operator_equal(const godot_vector3 *p_v, const godot_vector3 p_b) { - Vector3 *v = (Vector3 *)p_v; - Vector3 *b = (Vector3 *)&p_b; - return *v == *b; +godot_bool GDAPI godot_vector3_operator_equal(const godot_vector3 *p_self, const godot_vector3 *p_b) { + Vector3 *self = (Vector3 *)p_self; + const Vector3 *b = (const Vector3 *)p_b; + return *self == *b; } -godot_bool GDAPI godot_vector3_operator_less(const godot_vector3 *p_v, const godot_vector3 p_b) { - Vector3 *v = (Vector3 *)p_v; - Vector3 *b = (Vector3 *)&p_b; - return *v < *b; +godot_bool GDAPI godot_vector3_operator_less(const godot_vector3 *p_self, const godot_vector3 *p_b) { + Vector3 *self = (Vector3 *)p_self; + const Vector3 *b = (const Vector3 *)p_b; + return *self < *b; } -godot_string GDAPI godot_vector3_to_string(const godot_vector3 *p_v) { - godot_string dest; - String *d = (String *)&dest; - const Vector3 *v = (Vector3 *)p_v; - *d = "(" + *v + ")"; - return dest; +godot_vector3 GDAPI godot_vector3_operator_neg(const godot_vector3 *p_self) { + godot_vector3 raw_dest; + Vector3 *dest = (Vector3 *)&raw_dest; + const Vector3 *self = (const Vector3 *)p_self; + *dest = -(*self); + return raw_dest; +} + +void GDAPI godot_vector3_set_axis(godot_vector3 *p_self, const godot_vector3_axis p_axis, const godot_real p_val) { + Vector3 *self = (Vector3 *)p_self; + self->set_axis(p_axis, p_val); +} + +godot_real GDAPI godot_vector3_get_axis(const godot_vector3 *p_self, const godot_vector3_axis p_axis) { + const Vector3 *self = (const Vector3 *)p_self; + return self->get_axis(p_axis); } #ifdef __cplusplus diff --git a/modules/gdnative/godot/godot_vector3.h b/modules/gdnative/godot/godot_vector3.h index 654ddd7792..8e2aed8173 100644 --- a/modules/gdnative/godot/godot_vector3.h +++ b/modules/gdnative/godot/godot_vector3.h @@ -37,74 +37,94 @@ extern "C" { #include <stdint.h> #ifndef GODOT_CORE_API_GODOT_VECTOR3_TYPE_DEFINED +#define GODOT_CORE_API_GODOT_VECTOR3_TYPE_DEFINED typedef struct godot_vector3 { uint8_t _dont_touch_that[12]; } godot_vector3; #endif -#define GODOT_VECTOR3_AXIX_X 0 -#define GODOT_VECTOR3_AXIX_Y 1 -#define GODOT_VECTOR3_AXIX_Z 2 - #include "../godot.h" #include "godot_basis.h" -godot_vector3 GDAPI godot_vector3_new(const godot_real p_x, const godot_real p_y, const godot_real p_z); - -void GDAPI godot_vector3_set_axis(godot_vector3 *p_v, const godot_int p_axis, const godot_real p_val); -godot_real GDAPI godot_vector3_get_axis(const godot_vector3 *p_v, const godot_int p_axis); - -godot_int GDAPI godot_vector3_min_axis(const godot_vector3 *p_v); -godot_int GDAPI godot_vector3_max_axis(const godot_vector3 *p_v); - -godot_real GDAPI godot_vector3_length(const godot_vector3 *p_v); -godot_real GDAPI godot_vector3_length_squared(const godot_vector3 *p_v); - -void GDAPI godot_vector3_normalize(godot_vector3 *p_v); -godot_vector3 GDAPI godot_vector3_normalized(const godot_vector3 *p_v); - -godot_vector3 GDAPI godot_vector3_inverse(const godot_vector3 *p_v); -void GDAPI godot_vector3_zero(godot_vector3 *p_v); -void GDAPI godot_vector3_snap(godot_vector3 *p_v, const godot_real val); -godot_vector3 GDAPI godot_vector3_snapped(const godot_vector3 *p_v, const godot_real val); -void GDAPI godot_vector3_rotate(godot_vector3 *p_v, const godot_vector3 p_axis, const godot_real phi); -godot_vector3 GDAPI godot_vector3_rotated(const godot_vector3 *p_v, - const godot_vector3 p_axis, const godot_real phi); -godot_vector3 GDAPI godot_vector3_linear_interpolate(const godot_vector3 *p_v, - const godot_vector3 p_b, const godot_real t); -godot_vector3 GDAPI godot_vector3_cubic_interpolate(const godot_vector3 *p_v, - const godot_vector3 p_b, const godot_vector3 p_pre_a, - const godot_vector3 p_post_b, const godot_real t); -godot_vector3 GDAPI godot_vector3_cubic_interpolaten(const godot_vector3 *p_v, - const godot_vector3 p_b, const godot_vector3 p_pre_a, - const godot_vector3 p_post_b, const godot_real t); -godot_vector3 GDAPI godot_vector3_cross(const godot_vector3 *p_v, const godot_vector3 p_b); -godot_real GDAPI godot_vector3_dot(const godot_vector3 *p_v, const godot_vector3 p_b); -godot_basis GDAPI godot_vector3_outer(const godot_vector3 *p_v, const godot_vector3 p_b); -godot_basis GDAPI godot_vector3_to_diagonal_matrix(const godot_vector3 *p_v); -godot_vector3 GDAPI godot_vector3_abs(const godot_vector3 *p_v); -godot_vector3 GDAPI godot_vector3_floor(const godot_vector3 *p_v); -godot_vector3 GDAPI godot_vector3_ceil(const godot_vector3 *p_v); - -godot_real GDAPI godot_vector3_distance_to(const godot_vector3 *p_v, const godot_vector3 p_b); -godot_real GDAPI godot_vector3_distance_squared_to(const godot_vector3 *p_v, const godot_vector3 p_b); -godot_real GDAPI godot_vector3_angle_to(const godot_vector3 *p_v, const godot_vector3 p_b); - -godot_vector3 GDAPI godot_vector3_slide(const godot_vector3 *p_v, const godot_vector3 p_vec); -godot_vector3 GDAPI godot_vector3_bounce(const godot_vector3 *p_v, const godot_vector3 p_vec); -godot_vector3 GDAPI godot_vector3_reflect(const godot_vector3 *p_v, const godot_vector3 p_vec); - -godot_vector3 GDAPI godot_vector3_operator_add(const godot_vector3 *p_v, const godot_vector3 p_b); -godot_vector3 GDAPI godot_vector3_operator_subtract(const godot_vector3 *p_v, const godot_vector3 p_b); -godot_vector3 GDAPI godot_vector3_operator_multiply_vector(const godot_vector3 *p_v, const godot_vector3 p_b); -godot_vector3 GDAPI godot_vector3_operator_multiply_scalar(const godot_vector3 *p_v, const godot_real p_b); -godot_vector3 GDAPI godot_vector3_operator_divide_vector(const godot_vector3 *p_v, const godot_vector3 p_b); -godot_vector3 GDAPI godot_vector3_operator_divide_scalar(const godot_vector3 *p_v, const godot_real p_b); - -godot_bool GDAPI godot_vector3_operator_equal(const godot_vector3 *p_v, const godot_vector3 p_b); -godot_bool GDAPI godot_vector3_operator_less(const godot_vector3 *p_v, const godot_vector3 p_b); - -godot_string GDAPI godot_vector3_to_string(const godot_vector3 *p_v); +typedef enum { + GODOT_VECTOR3_AXIS_X, + GODOT_VECTOR3_AXIS_Y, + GODOT_VECTOR3_AXIS_Z, +} godot_vector3_axis; + +void GDAPI godot_vector3_new(godot_vector3 *r_dest, const godot_real p_x, const godot_real p_y, const godot_real p_z); + +godot_string GDAPI godot_vector3_as_string(const godot_vector3 *p_self); + +godot_int GDAPI godot_vector3_min_axis(const godot_vector3 *p_self); + +godot_int GDAPI godot_vector3_max_axis(const godot_vector3 *p_self); + +godot_real GDAPI godot_vector3_length(const godot_vector3 *p_self); + +godot_real GDAPI godot_vector3_length_squared(const godot_vector3 *p_self); + +godot_bool GDAPI godot_vector3_is_normalized(const godot_vector3 *p_self); + +godot_vector3 GDAPI godot_vector3_normalized(const godot_vector3 *p_self); + +godot_vector3 GDAPI godot_vector3_inverse(const godot_vector3 *p_self); + +godot_vector3 GDAPI godot_vector3_snapped(const godot_vector3 *p_self, const godot_real p_by); + +godot_vector3 GDAPI godot_vector3_rotated(const godot_vector3 *p_self, const godot_vector3 *p_axis, const godot_real p_phi); + +godot_vector3 GDAPI godot_vector3_linear_interpolate(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_real p_t); + +godot_vector3 GDAPI godot_vector3_cubic_interpolate(const godot_vector3 *p_self, const godot_vector3 *p_b, const godot_vector3 *p_pre_a, const godot_vector3 *p_post_b, const godot_real p_t); + +godot_real GDAPI godot_vector3_dot(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_vector3 GDAPI godot_vector3_cross(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_basis GDAPI godot_vector3_outer(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_basis GDAPI godot_vector3_to_diagonal_matrix(const godot_vector3 *p_self); + +godot_vector3 GDAPI godot_vector3_abs(const godot_vector3 *p_self); + +godot_vector3 GDAPI godot_vector3_floor(const godot_vector3 *p_self); + +godot_vector3 GDAPI godot_vector3_ceil(const godot_vector3 *p_self); + +godot_real GDAPI godot_vector3_distance_to(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_real GDAPI godot_vector3_distance_squared_to(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_real GDAPI godot_vector3_angle_to(const godot_vector3 *p_self, const godot_vector3 *p_to); + +godot_vector3 GDAPI godot_vector3_slide(const godot_vector3 *p_self, const godot_vector3 *p_n); + +godot_vector3 GDAPI godot_vector3_bounce(const godot_vector3 *p_self, const godot_vector3 *p_n); + +godot_vector3 GDAPI godot_vector3_reflect(const godot_vector3 *p_self, const godot_vector3 *p_n); + +godot_vector3 GDAPI godot_vector3_operator_add(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_vector3 GDAPI godot_vector3_operator_substract(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_vector3 GDAPI godot_vector3_operator_multiply_vector(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_vector3 GDAPI godot_vector3_operator_multiply_scalar(const godot_vector3 *p_self, const godot_real p_b); + +godot_vector3 GDAPI godot_vector3_operator_divide_vector(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_vector3 GDAPI godot_vector3_operator_divide_scalar(const godot_vector3 *p_self, const godot_real p_b); + +godot_bool GDAPI godot_vector3_operator_equal(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_bool GDAPI godot_vector3_operator_less(const godot_vector3 *p_self, const godot_vector3 *p_b); + +godot_vector3 GDAPI godot_vector3_operator_neg(const godot_vector3 *p_self); + +void GDAPI godot_vector3_set_axis(godot_vector3 *p_self, const godot_vector3_axis p_axis, const godot_real p_val); + +godot_real GDAPI godot_vector3_get_axis(const godot_vector3 *p_self, const godot_vector3_axis p_axis); #ifdef __cplusplus } diff --git a/modules/gdscript/gd_editor.cpp b/modules/gdscript/gd_editor.cpp index 5d404e2f7d..eea5b15236 100644 --- a/modules/gdscript/gd_editor.cpp +++ b/modules/gdscript/gd_editor.cpp @@ -1321,7 +1321,7 @@ static void _find_identifiers(GDCompletionContext &context, int p_line, bool p_o static const char *_type_names[Variant::VARIANT_MAX] = { "null", "bool", "int", "float", "String", "Vector2", "Rect2", "Vector3", "Transform2D", "Plane", "Quat", "AABB", "Basis", "Transform", - "Color", "Image", "NodePath", "RID", "Object", "InputEvent", "Dictionary", "Array", "RawArray", "IntArray", "FloatArray", "StringArray", + "Color", "NodePath", "RID", "Object", "Dictionary", "Array", "RawArray", "IntArray", "FloatArray", "StringArray", "Vector2Array", "Vector3Array", "ColorArray" }; @@ -1425,22 +1425,7 @@ void get_directory_contents(EditorFileSystemDirectory *p_dir, Set<String> &r_lis static void _find_type_arguments(GDCompletionContext &context, const GDParser::Node *p_node, int p_line, const StringName &p_method, const GDCompletionIdentifier &id, int p_argidx, Set<String> &result, String &arghint) { //print_line("find type arguments?"); - if (id.type == Variant::INPUT_EVENT && String(p_method) == "is_action" && p_argidx == 0) { - - List<PropertyInfo> pinfo; - GlobalConfig::get_singleton()->get_property_list(&pinfo); - - for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) { - const PropertyInfo &pi = E->get(); - - if (!pi.name.begins_with("input/")) - continue; - - String name = pi.name.substr(pi.name.find("/") + 1, pi.name.length()); - result.insert("\"" + name + "\""); - } - - } else if (id.type == Variant::OBJECT && id.obj_type != StringName()) { + if (id.type == Variant::OBJECT && id.obj_type != StringName()) { MethodBind *m = ClassDB::get_method(id.obj_type, p_method); if (!m) { @@ -2266,54 +2251,8 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_base } } else { - if (t.type == Variant::INPUT_EVENT) { - - //this is hardcoded otherwise it's not obvious - Set<String> exclude; - - for (int i = 0; i < InputEvent::TYPE_MAX; i++) { - - InputEvent ie; - ie.type = InputEvent::Type(i); - static const char *evnames[] = { - "# Common", - "# Key", - "# MouseMotion", - "# MouseButton", - "# JoypadMotion", - "# JoypadButton", - "# ScreenTouch", - "# ScreenDrag", - "# Action" - }; - - r_options->push_back(evnames[i]); - - Variant v = ie; - - if (i == 0) { - List<MethodInfo> mi; - v.get_method_list(&mi); - for (List<MethodInfo>::Element *E = mi.front(); E; E = E->next()) { - r_options->push_back(E->get().name + "("); - } - } - - List<PropertyInfo> pi; - v.get_property_list(&pi); - - for (List<PropertyInfo>::Element *E = pi.front(); E; E = E->next()) { - - if (i == 0) - exclude.insert(E->get().name); - else if (exclude.has(E->get().name)) - continue; - - r_options->push_back(E->get().name); - } - } - return OK; - } else { + //check InputEvent hint + { if (t.value.get_type() == Variant::NIL) { Variant::CallError ce; t.value = Variant::construct(t.type, NULL, 0, ce); diff --git a/modules/gdscript/gd_function.cpp b/modules/gdscript/gd_function.cpp index 608256c88a..fb32d23ad5 100644 --- a/modules/gdscript/gd_function.cpp +++ b/modules/gdscript/gd_function.cpp @@ -1433,9 +1433,21 @@ Variant GDFunctionState::_signal_callback(const Variant **p_args, int p_argcount return ret; } -bool GDFunctionState::is_valid() const { +bool GDFunctionState::is_valid(bool p_extended_check) const { + + if (function == NULL) + return false; + + if (p_extended_check) { + //class instance gone? + if (state.instance_id && !ObjectDB::get_instance(state.instance_id)) + return false; + //script gone? + if (state.script_id && !ObjectDB::get_instance(state.script_id)) + return false; + } - return function != NULL; + return true; } Variant GDFunctionState::resume(const Variant &p_arg) { @@ -1464,7 +1476,7 @@ Variant GDFunctionState::resume(const Variant &p_arg) { void GDFunctionState::_bind_methods() { ClassDB::bind_method(D_METHOD("resume:Variant", "arg"), &GDFunctionState::resume, DEFVAL(Variant())); - ClassDB::bind_method(D_METHOD("is_valid"), &GDFunctionState::is_valid); + ClassDB::bind_method(D_METHOD("is_valid", "extended_check"), &GDFunctionState::is_valid, DEFVAL(false)); ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "_signal_callback", &GDFunctionState::_signal_callback, MethodInfo("_signal_callback")); } diff --git a/modules/gdscript/gd_function.h b/modules/gdscript/gd_function.h index f0bf33147b..6d20b19777 100644 --- a/modules/gdscript/gd_function.h +++ b/modules/gdscript/gd_function.h @@ -237,7 +237,7 @@ protected: static void _bind_methods(); public: - bool is_valid() const; + bool is_valid(bool p_extended_check = false) const; Variant resume(const Variant &p_arg = Variant()); GDFunctionState(); ~GDFunctionState(); diff --git a/modules/gdscript/gd_tokenizer.cpp b/modules/gdscript/gd_tokenizer.cpp index 13674f1f9a..5e1a48ae86 100644 --- a/modules/gdscript/gd_tokenizer.cpp +++ b/modules/gdscript/gd_tokenizer.cpp @@ -800,10 +800,8 @@ void GDTokenizerText::_advance() { { Variant::BASIS, "Basis" }, { Variant::TRANSFORM, "Transform" }, { Variant::COLOR, "Color" }, - { Variant::IMAGE, "Image" }, { Variant::_RID, "RID" }, { Variant::OBJECT, "Object" }, - { Variant::INPUT_EVENT, "InputEvent" }, { Variant::NODE_PATH, "NodePath" }, { Variant::DICTIONARY, "Dictionary" }, { Variant::ARRAY, "Array" }, diff --git a/modules/gridmap/grid_map_editor_plugin.cpp b/modules/gridmap/grid_map_editor_plugin.cpp index d8993710a4..e567e08c79 100644 --- a/modules/gridmap/grid_map_editor_plugin.cpp +++ b/modules/gridmap/grid_map_editor_plugin.cpp @@ -508,146 +508,150 @@ void GridMapEditor::_duplicate_paste() { } } -bool GridMapEditor::forward_spatial_input_event(Camera *p_camera, const InputEvent &p_event) { +bool GridMapEditor::forward_spatial_input_event(Camera *p_camera, const Ref<InputEvent> &p_event) { if (!node) { return false; } if (edit_mode->get_selected() == 0) { // regular click - switch (p_event.type) { - case InputEvent::MOUSE_BUTTON: { - if (p_event.mouse_button.button_index == BUTTON_WHEEL_UP && (p_event.mouse_button.mod.command || p_event.mouse_button.mod.shift)) { - if (p_event.mouse_button.pressed) - floor->set_value(floor->get_value() + p_event.mouse_button.factor); + Ref<InputEventMouseButton> mb = p_event; - return true; //eaten - } else if (p_event.mouse_button.button_index == BUTTON_WHEEL_DOWN && (p_event.mouse_button.mod.command || p_event.mouse_button.mod.shift)) { - if (p_event.mouse_button.pressed) - floor->set_value(floor->get_value() - p_event.mouse_button.factor); - return true; - } + if (mb.is_valid()) { - if (p_event.mouse_button.pressed) { + if (mb->get_button_index() == BUTTON_WHEEL_UP && (mb->get_command() || mb->get_shift())) { + if (mb->is_pressed()) + floor->set_value(floor->get_value() + mb->get_factor()); - if (p_event.mouse_button.button_index == BUTTON_LEFT) { + return true; //eaten + } else if (mb->get_button_index() == BUTTON_WHEEL_DOWN && (mb->get_command() || mb->get_shift())) { + if (mb->is_pressed()) + floor->set_value(floor->get_value() - mb->get_factor()); + return true; + } - if (input_action == INPUT_DUPLICATE) { + if (mb->is_pressed()) { - //paste - _duplicate_paste(); - input_action = INPUT_NONE; - _update_duplicate_indicator(); - } else if (p_event.mouse_button.mod.shift) { - input_action = INPUT_SELECT; - } else if (p_event.mouse_button.mod.command) - input_action = INPUT_COPY; - else { - input_action = INPUT_PAINT; - set_items.clear(); - } - } else if (p_event.mouse_button.button_index == BUTTON_RIGHT) - if (input_action == INPUT_DUPLICATE) { - - input_action = INPUT_NONE; - _update_duplicate_indicator(); - } else { - input_action = INPUT_ERASE; - set_items.clear(); - } - else - return false; + if (mb->get_button_index() == BUTTON_LEFT) { - return do_input_action(p_camera, Point2(p_event.mouse_button.x, p_event.mouse_button.y), true); - } else { + if (input_action == INPUT_DUPLICATE) { - if ( - (p_event.mouse_button.button_index == BUTTON_RIGHT && input_action == INPUT_ERASE) || - (p_event.mouse_button.button_index == BUTTON_LEFT && input_action == INPUT_PAINT)) { + //paste + _duplicate_paste(); + input_action = INPUT_NONE; + _update_duplicate_indicator(); + } else if (mb->get_shift()) { + input_action = INPUT_SELECT; + } else if (mb->get_command()) + input_action = INPUT_COPY; + else { + input_action = INPUT_PAINT; + set_items.clear(); + } + } else if (mb->get_button_index() == BUTTON_RIGHT) + if (input_action == INPUT_DUPLICATE) { - if (set_items.size()) { - undo_redo->create_action("GridMap Paint"); - for (List<SetItem>::Element *E = set_items.front(); E; E = E->next()) { + input_action = INPUT_NONE; + _update_duplicate_indicator(); + } else { + input_action = INPUT_ERASE; + set_items.clear(); + } + else + return false; + + return do_input_action(p_camera, Point2(mb->get_pos().x, mb->get_pos().y), true); + } else { - const SetItem &si = E->get(); - undo_redo->add_do_method(node, "set_cell_item", si.pos.x, si.pos.y, si.pos.z, si.new_value, si.new_orientation); - } - for (List<SetItem>::Element *E = set_items.back(); E; E = E->prev()) { + if ( + (mb->get_button_index() == BUTTON_RIGHT && input_action == INPUT_ERASE) || + (mb->get_button_index() == BUTTON_LEFT && input_action == INPUT_PAINT)) { - const SetItem &si = E->get(); - undo_redo->add_undo_method(node, "set_cell_item", si.pos.x, si.pos.y, si.pos.z, si.old_value, si.old_orientation); - } + if (set_items.size()) { + undo_redo->create_action("GridMap Paint"); + for (List<SetItem>::Element *E = set_items.front(); E; E = E->next()) { - undo_redo->commit_action(); + const SetItem &si = E->get(); + undo_redo->add_do_method(node, "set_cell_item", si.pos.x, si.pos.y, si.pos.z, si.new_value, si.new_orientation); } - set_items.clear(); - input_action = INPUT_NONE; - return true; - } + for (List<SetItem>::Element *E = set_items.back(); E; E = E->prev()) { - if (p_event.mouse_button.button_index == BUTTON_LEFT && input_action != INPUT_NONE) { + const SetItem &si = E->get(); + undo_redo->add_undo_method(node, "set_cell_item", si.pos.x, si.pos.y, si.pos.z, si.old_value, si.old_orientation); + } - set_items.clear(); - input_action = INPUT_NONE; - return true; - } - if (p_event.mouse_button.button_index == BUTTON_RIGHT && (input_action == INPUT_ERASE || input_action == INPUT_DUPLICATE)) { - input_action = INPUT_NONE; - return true; + undo_redo->commit_action(); } + set_items.clear(); + input_action = INPUT_NONE; + return true; + } + + if (mb->get_button_index() == BUTTON_LEFT && input_action != INPUT_NONE) { + + set_items.clear(); + input_action = INPUT_NONE; + return true; + } + if (mb->get_button_index() == BUTTON_RIGHT && (input_action == INPUT_ERASE || input_action == INPUT_DUPLICATE)) { + input_action = INPUT_NONE; + return true; } - } break; - case InputEvent::MOUSE_MOTION: { + } + } + + Ref<InputEventMouseMotion> mm = p_event; - return do_input_action(p_camera, Point2(p_event.mouse_motion.x, p_event.mouse_motion.y), false); - } break; + if (mm.is_valid()) { + + return do_input_action(p_camera, mm->get_pos(), false); } } else if (edit_mode->get_selected() == 1) { //area mode, select an area - switch (p_event.type) { - case InputEvent::MOUSE_BUTTON: { + Ref<InputEventMouseButton> mb = p_event; - if (p_event.mouse_button.button_index == BUTTON_LEFT && p_event.mouse_button.pressed) { + if (mb.is_valid()) { - Point2 point = Point2(p_event.mouse_motion.x, p_event.mouse_motion.y); + if (mb->get_button_index() == BUTTON_LEFT && mb->is_pressed()) { - Camera *camera = p_camera; - Vector3 from = camera->project_ray_origin(point); - Vector3 normal = camera->project_ray_normal(point); - Transform local_xform = node->get_global_transform().affine_inverse(); - from = local_xform.xform(from); - normal = local_xform.basis.xform(normal).normalized(); + Point2 point = mb->get_pos(); - List<int> areas; - node->get_area_list(&areas); + Camera *camera = p_camera; + Vector3 from = camera->project_ray_origin(point); + Vector3 normal = camera->project_ray_normal(point); + Transform local_xform = node->get_global_transform().affine_inverse(); + from = local_xform.xform(from); + normal = local_xform.basis.xform(normal).normalized(); - float min_d = 1e10; - int min_area = -1; + List<int> areas; + node->get_area_list(&areas); - for (List<int>::Element *E = areas.front(); E; E = E->next()) { + float min_d = 1e10; + int min_area = -1; - int area = E->get(); - Rect3 aabb = node->area_get_bounds(area); - aabb.pos *= node->get_cell_size(); - aabb.size *= node->get_cell_size(); + for (List<int>::Element *E = areas.front(); E; E = E->next()) { - Vector3 rclip, rnormal; - if (!aabb.intersects_segment(from, from + normal * 10000, &rclip, &rnormal)) - continue; + int area = E->get(); + Rect3 aabb = node->area_get_bounds(area); + aabb.pos *= node->get_cell_size(); + aabb.size *= node->get_cell_size(); - float d = normal.dot(rclip); - if (d < min_d) { - min_d = d; - min_area = area; - } - } + Vector3 rclip, rnormal; + if (!aabb.intersects_segment(from, from + normal * 10000, &rclip, &rnormal)) + continue; - selected_area = min_area; - update_areas(); + float d = normal.dot(rclip); + if (d < min_d) { + min_d = d; + min_area = area; + } } - } break; + + selected_area = min_area; + update_areas(); + } } } diff --git a/modules/gridmap/grid_map_editor_plugin.h b/modules/gridmap/grid_map_editor_plugin.h index d928e6afac..1572f4fbe5 100644 --- a/modules/gridmap/grid_map_editor_plugin.h +++ b/modules/gridmap/grid_map_editor_plugin.h @@ -220,7 +220,7 @@ protected: static void _bind_methods(); public: - bool forward_spatial_input_event(Camera *p_camera, const InputEvent &p_event); + bool forward_spatial_input_event(Camera *p_camera, const Ref<InputEvent> &p_event); void edit(GridMap *p_gridmap); GridMapEditor() {} @@ -236,7 +236,7 @@ class GridMapEditorPlugin : public EditorPlugin { EditorNode *editor; public: - virtual bool forward_spatial_input_event(Camera *p_camera, const InputEvent &p_event) { return gridmap_editor->forward_spatial_input_event(p_camera, p_event); } + virtual bool forward_spatial_input_event(Camera *p_camera, const Ref<InputEvent> &p_event) { return gridmap_editor->forward_spatial_input_event(p_camera, p_event); } virtual String get_name() const { return "GridMap"; } bool has_main_screen() const { return false; } virtual void edit(Object *p_node); diff --git a/modules/jpg/image_loader_jpegd.cpp b/modules/jpg/image_loader_jpegd.cpp index 83685d6446..0741dd198a 100644 --- a/modules/jpg/image_loader_jpegd.cpp +++ b/modules/jpg/image_loader_jpegd.cpp @@ -89,7 +89,7 @@ Error jpeg_load_image_from_buffer(Image *p_image, const uint8_t *p_buffer, int p return OK; } -Error ImageLoaderJPG::load_image(Image *p_image, FileAccess *f) { +Error ImageLoaderJPG::load_image(Ref<Image> p_image, FileAccess *f) { PoolVector<uint8_t> src_image; int src_image_len = f->get_len(); @@ -102,7 +102,7 @@ Error ImageLoaderJPG::load_image(Image *p_image, FileAccess *f) { f->close(); - Error err = jpeg_load_image_from_buffer(p_image, w.ptr(), src_image_len); + Error err = jpeg_load_image_from_buffer(p_image.ptr(), w.ptr(), src_image_len); w = PoolVector<uint8_t>::Write(); @@ -115,10 +115,11 @@ void ImageLoaderJPG::get_recognized_extensions(List<String> *p_extensions) const p_extensions->push_back("jpeg"); } -static Image _jpegd_mem_loader_func(const uint8_t *p_png, int p_size) { +static Ref<Image> _jpegd_mem_loader_func(const uint8_t *p_png, int p_size) { - Image img; - Error err = jpeg_load_image_from_buffer(&img, p_png, p_size); + Ref<Image> img; + img.instance(); + Error err = jpeg_load_image_from_buffer(img.ptr(), p_png, p_size); if (err) ERR_PRINT("Couldn't initialize ImageLoaderJPG with the given resource."); diff --git a/modules/jpg/image_loader_jpegd.h b/modules/jpg/image_loader_jpegd.h index d23e8a7d48..57d7a2bb1c 100644 --- a/modules/jpg/image_loader_jpegd.h +++ b/modules/jpg/image_loader_jpegd.h @@ -38,7 +38,7 @@ class ImageLoaderJPG : public ImageFormatLoader { public: - virtual Error load_image(Image *p_image, FileAccess *f); + virtual Error load_image(Ref<Image> p_image, FileAccess *f); virtual void get_recognized_extensions(List<String> *p_extensions) const; ImageLoaderJPG(); }; diff --git a/modules/pvr/texture_loader_pvr.cpp b/modules/pvr/texture_loader_pvr.cpp index 62cbd9cd8d..bdd4779e28 100644 --- a/modules/pvr/texture_loader_pvr.cpp +++ b/modules/pvr/texture_loader_pvr.cpp @@ -164,8 +164,8 @@ RES ResourceFormatPVR::load(const String &p_path, const String &p_original_path, print_line("flip: " + itos(flags & PVR_VFLIP)); - Image image(width, height, mipmaps, format, data); - ERR_FAIL_COND_V(image.empty(), RES()); + Ref<Image> image = memnew(Image(width, height, mipmaps, format, data)); + ERR_FAIL_COND_V(image->empty(), RES()); Ref<ImageTexture> texture = memnew(ImageTexture); texture->create_from_image(image, tex_flags); @@ -193,30 +193,32 @@ String ResourceFormatPVR::get_resource_type(const String &p_path) const { static void _compress_pvrtc4(Image *p_img) { - Image img = *p_img; + Ref<Image> img = p_img->duplicate(); bool make_mipmaps = false; - if (img.get_width() % 8 || img.get_height() % 8) { - make_mipmaps = img.has_mipmaps(); - img.resize(img.get_width() + (8 - (img.get_width() % 8)), img.get_height() + (8 - (img.get_height() % 8))); + if (img->get_width() % 8 || img->get_height() % 8) { + make_mipmaps = img->has_mipmaps(); + img->resize(img->get_width() + (8 - (img->get_width() % 8)), img->get_height() + (8 - (img->get_height() % 8))); } - img.convert(Image::FORMAT_RGBA8); - if (!img.has_mipmaps() && make_mipmaps) - img.generate_mipmaps(); + img->convert(Image::FORMAT_RGBA8); + if (!img->has_mipmaps() && make_mipmaps) + img->generate_mipmaps(); - bool use_alpha = img.detect_alpha(); + bool use_alpha = img->detect_alpha(); - Image new_img; - new_img.create(img.get_width(), img.get_height(), true, use_alpha ? Image::FORMAT_PVRTC4A : Image::FORMAT_PVRTC4); - PoolVector<uint8_t> data = new_img.get_data(); + Ref<Image> new_img; + new_img.instance(); + new_img->create(img->get_width(), img->get_height(), true, use_alpha ? Image::FORMAT_PVRTC4A : Image::FORMAT_PVRTC4); + + PoolVector<uint8_t> data = new_img->get_data(); { PoolVector<uint8_t>::Write wr = data.write(); - PoolVector<uint8_t>::Read r = img.get_data().read(); + PoolVector<uint8_t>::Read r = img->get_data().read(); - for (int i = 0; i <= new_img.get_mipmap_count(); i++) { + for (int i = 0; i <= new_img->get_mipmap_count(); i++) { int ofs, size, w, h; - img.get_mipmap_offset_size_and_dimensions(i, ofs, size, w, h); + img->get_mipmap_offset_size_and_dimensions(i, ofs, size, w, h); Javelin::RgbaBitmap bm(w, h); copymem(bm.GetData(), &r[ofs], size); { @@ -226,12 +228,12 @@ static void _compress_pvrtc4(Image *p_img) { } } - new_img.get_mipmap_offset_size_and_dimensions(i, ofs, size, w, h); + new_img->get_mipmap_offset_size_and_dimensions(i, ofs, size, w, h); Javelin::PvrTcEncoder::EncodeRgba4Bpp(&wr[ofs], bm); } } - *p_img = Image(new_img.get_width(), new_img.get_height(), new_img.has_mipmaps(), new_img.get_format(), data); + p_img->create(new_img->get_width(), new_img->get_height(), new_img->has_mipmaps(), new_img->get_format(), data); } ResourceFormatPVR::ResourceFormatPVR() { @@ -676,8 +678,7 @@ static void _pvrtc_decompress(Image *p_img) { r = PoolVector<uint8_t>::Read(); bool make_mipmaps = p_img->has_mipmaps(); - Image newimg(p_img->get_width(), p_img->get_height(), false, Image::FORMAT_RGBA8, newdata); + p_img->create(p_img->get_width(), p_img->get_height(), false, Image::FORMAT_RGBA8, newdata); if (make_mipmaps) - newimg.generate_mipmaps(); - *p_img = newimg; + p_img->generate_mipmaps(); } diff --git a/modules/theora/video_stream_theora.cpp b/modules/theora/video_stream_theora.cpp index 61112f20b4..d895f60280 100644 --- a/modules/theora/video_stream_theora.cpp +++ b/modules/theora/video_stream_theora.cpp @@ -138,7 +138,7 @@ void VideoStreamPlaybackTheora::video_write(void) { format = Image::FORMAT_RGBA8; } - Image img(size.x, size.y, 0, Image::FORMAT_RGBA8, frame_data); //zero copy image creation + Ref<Image> img = memnew(Image(size.x, size.y, 0, Image::FORMAT_RGBA8, frame_data)); //zero copy image creation texture->set_data(img); //zero copy send to visual server diff --git a/modules/visual_script/register_types.cpp b/modules/visual_script/register_types.cpp index 4006ad3428..c0467a901b 100644 --- a/modules/visual_script/register_types.cpp +++ b/modules/visual_script/register_types.cpp @@ -88,7 +88,7 @@ void register_visual_script_types() { ClassDB::register_class<VisualScriptWhile>(); ClassDB::register_class<VisualScriptIterator>(); ClassDB::register_class<VisualScriptSequence>(); - ClassDB::register_class<VisualScriptInputFilter>(); + //ClassDB::register_class<VisualScriptInputFilter>(); ClassDB::register_class<VisualScriptSwitch>(); ClassDB::register_class<VisualScriptYield>(); diff --git a/modules/visual_script/visual_script.h b/modules/visual_script/visual_script.h index 273a819611..72843099c7 100644 --- a/modules/visual_script/visual_script.h +++ b/modules/visual_script/visual_script.h @@ -89,13 +89,11 @@ public: struct TypeGuess { Variant::Type type; - InputEvent::Type ev_type; StringName GDCLASS; Ref<Script> script; TypeGuess() { type = Variant::NIL; - ev_type = InputEvent::NONE; } }; diff --git a/modules/visual_script/visual_script_editor.cpp b/modules/visual_script/visual_script_editor.cpp index d515f301ce..5839bc9243 100644 --- a/modules/visual_script/visual_script_editor.cpp +++ b/modules/visual_script/visual_script_editor.cpp @@ -346,11 +346,9 @@ static Color _color_from_type(Variant::Type p_type) { case Variant::TRANSFORM: color = Color::html("f6a86e"); break; case Variant::COLOR: color = Color::html("9dff70"); break; - case Variant::IMAGE: color = Color::html("93f1b9"); break; case Variant::NODE_PATH: color = Color::html("6993ec"); break; case Variant::_RID: color = Color::html("69ec9a"); break; case Variant::OBJECT: color = Color::html("79f3e8"); break; - case Variant::INPUT_EVENT: color = Color::html("adf18f"); break; case Variant::DICTIONARY: color = Color::html("77edb1"); break; case Variant::ARRAY: color = Color::html("e0e0e0"); break; @@ -451,11 +449,9 @@ void VisualScriptEditor::_update_graph(int p_only_id) { Control::get_icon("MiniBasis", "EditorIcons"), Control::get_icon("MiniTransform", "EditorIcons"), Control::get_icon("MiniColor", "EditorIcons"), - Control::get_icon("MiniImage", "EditorIcons"), Control::get_icon("MiniPath", "EditorIcons"), Control::get_icon("MiniRid", "EditorIcons"), Control::get_icon("MiniObject", "EditorIcons"), - Control::get_icon("MiniInput", "EditorIcons"), Control::get_icon("MiniDictionary", "EditorIcons"), Control::get_icon("MiniArray", "EditorIcons"), Control::get_icon("MiniRawArray", "EditorIcons"), @@ -490,7 +486,7 @@ void VisualScriptEditor::_update_graph(int p_only_id) { } if (EditorSettings::get_singleton()->has("editors/visual_script/color_" + node->get_category())) { - gnode->set_self_modulate(EditorSettings::get_singleton()->get("editors/visual_script/color_" + node->get_category())); + gnode->set_modulate(EditorSettings::get_singleton()->get("editors/visual_script/color_" + node->get_category())); } gnode->set_meta("__vnode", node); @@ -735,11 +731,9 @@ void VisualScriptEditor::_update_members() { Control::get_icon("MiniMatrix3", "EditorIcons"), Control::get_icon("MiniTransform", "EditorIcons"), Control::get_icon("MiniColor", "EditorIcons"), - Control::get_icon("MiniImage", "EditorIcons"), Control::get_icon("MiniPath", "EditorIcons"), Control::get_icon("MiniRid", "EditorIcons"), Control::get_icon("MiniObject", "EditorIcons"), - Control::get_icon("MiniInput", "EditorIcons"), Control::get_icon("MiniDictionary", "EditorIcons"), Control::get_icon("MiniArray", "EditorIcons"), Control::get_icon("MiniRawArray", "EditorIcons"), @@ -1422,9 +1416,11 @@ void VisualScriptEditor::_on_nodes_duplicate() { } } -void VisualScriptEditor::_input(const InputEvent &p_event) { +void VisualScriptEditor::_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::MOUSE_BUTTON && !p_event.mouse_button.pressed && p_event.mouse_button.button_index == BUTTON_LEFT) { + Ref<InputEventMouseButton> mb = p_event; + + if (mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) { revert_on_drag = String(); //so we can still drag functions } } @@ -2643,7 +2639,7 @@ void VisualScriptEditor::_port_action_menu(int p_option) { } else { n->set_call_mode(VisualScriptPropertySet::CALL_MODE_BASIC_TYPE); n->set_basic_type(tg.type); - new_connect_node_select->select_property_from_basic_type(tg.type, tg.ev_type); + new_connect_node_select->select_property_from_basic_type(tg.type); } } break; case CREATE_GET: { @@ -2673,7 +2669,7 @@ void VisualScriptEditor::_port_action_menu(int p_option) { } else { n->set_call_mode(VisualScriptPropertyGet::CALL_MODE_BASIC_TYPE); n->set_basic_type(tg.type); - new_connect_node_select->select_property_from_basic_type(tg.type, tg.ev_type); + new_connect_node_select->select_property_from_basic_type(tg.type); } } break; @@ -2833,7 +2829,7 @@ void VisualScriptEditor::_node_filter_changed(const String &p_text) { void VisualScriptEditor::_notification(int p_what) { if (p_what == NOTIFICATION_READY) { - node_filter_icon->set_texture(Control::get_icon("Search", "EditorIcons")); + node_filter_icon->set_texture(Control::get_icon("Zoom", "EditorIcons")); } } diff --git a/modules/visual_script/visual_script_editor.h b/modules/visual_script/visual_script_editor.h index 1fd97cc1bc..bb832431a0 100644 --- a/modules/visual_script/visual_script_editor.h +++ b/modules/visual_script/visual_script_editor.h @@ -196,7 +196,7 @@ class VisualScriptEditor : public ScriptEditorBase { String revert_on_drag; - void _input(const InputEvent &p_event); + void _input(const Ref<InputEvent> &p_event); void _on_nodes_delete(); void _on_nodes_duplicate(); diff --git a/modules/visual_script/visual_script_flow_control.cpp b/modules/visual_script/visual_script_flow_control.cpp index 2deb6064d3..07d69db207 100644 --- a/modules/visual_script/visual_script_flow_control.cpp +++ b/modules/visual_script/visual_script_flow_control.cpp @@ -734,6 +734,7 @@ VisualScriptSwitch::VisualScriptSwitch() { ////////////////EVENT ACTION FILTER/////////// ////////////////////////////////////////// +#if 0 int VisualScriptInputFilter::get_output_sequence_port_count() const { return filters.size(); @@ -758,86 +759,86 @@ String VisualScriptInputFilter::get_output_sequence_port_text(int p_port) const String text; switch (filters[p_port].type) { - case InputEvent::NONE: { + case Ref<InputEvent>::NONE: { text = "None"; } break; - case InputEvent::KEY: { + case Ref<InputEvent>::KEY: { InputEventKey k = filters[p_port].key; - if (k.scancode == 0 && k.unicode == 0) { + if (k->get_scancode() == 0 && k.unicode == 0) { text = "No Key"; } else { - if (k.scancode != 0) { - text = "KeyCode: " + keycode_get_string(k.scancode); + if (k->get_scancode() != 0) { + text = "KeyCode: " + keycode_get_string(k->get_scancode()); } else if (k.unicode != 0) { text = "Uniode: " + String::chr(k.unicode); } - if (k.pressed) + if (k->is_pressed()) text += ", Pressed"; else text += ", Released"; if (k.echo) text += ", Echo"; - if (k.mod.alt) + if (k->get_alt()) text = "Alt+" + text; - if (k.mod.shift) + if (k->get_shift()) text = "Shift+" + text; - if (k.mod.control) + if (k->get_control()) text = "Ctrl+" + text; - if (k.mod.meta) + if (k->get_metakey()) text = "Meta+" + text; } } break; - case InputEvent::MOUSE_MOTION: { + case Ref<InputEvent>::MOUSE_MOTION: { InputEventMouseMotion mm = filters[p_port].mouse_motion; text = "Mouse Motion"; String b = "Left,Right,Middle,WheelUp,WheelDown,WheelLeft,WheelRight"; for (int i = 0; i < 7; i++) { - if (mm.button_mask & (1 << i)) { + if (mm->get_button_mask() & (1 << i)) { text = b.get_slice(",", i) + "+" + text; } } - if (mm.mod.alt) + if (mm->get_alt()) text = "Alt+" + text; - if (mm.mod.shift) + if (mm->get_shift()) text = "Shift+" + text; - if (mm.mod.control) + if (mm->get_control()) text = "Ctrl+" + text; - if (mm.mod.meta) + if (mm->get_metakey()) text = "Meta+" + text; } break; - case InputEvent::MOUSE_BUTTON: { + case Ref<InputEvent>::MOUSE_BUTTON: { InputEventMouseButton mb = filters[p_port].mouse_button; String b = "Any,Left,Right,Middle,WheelUp,WheelDown,WheelLeft,WheelRight"; - text = b.get_slice(",", mb.button_index) + " Mouse Button"; + text = b.get_slice(",", mb->get_button_index()) + " Mouse Button"; - if (mb.pressed) + if (mb->is_pressed()) text += ", Pressed"; else text += ", Released"; if (mb.doubleclick) text += ", DblClick"; - if (mb.mod.alt) + if (mb->get_alt()) text = "Alt+" + text; - if (mb.mod.shift) + if (mb->get_shift()) text = "Shift+" + text; - if (mb.mod.control) + if (mb->get_control()) text = "Ctrl+" + text; - if (mb.mod.meta) + if (mb->get_metakey()) text = "Meta+" + text; } break; - case InputEvent::JOYPAD_MOTION: { + case Ref<InputEvent>::JOYPAD_MOTION: { InputEventJoypadMotion jm = filters[p_port].joy_motion; @@ -848,29 +849,29 @@ String VisualScriptInputFilter::get_output_sequence_port_text(int p_port) const text += " < " + rtos(-jm.axis_value); } break; - case InputEvent::JOYPAD_BUTTON: { + case Ref<InputEvent>::JOYPAD_BUTTON: { InputEventJoypadButton jb = filters[p_port].joy_button; - text = "JoyButton " + itos(jb.button_index); - if (jb.pressed) + text = "JoyButton " + itos(jb->get_button_index()); + if (jb->is_pressed()) text += ", Pressed"; else text += ", Released"; } break; - case InputEvent::SCREEN_TOUCH: { + case Ref<InputEvent>::SCREEN_TOUCH: { InputEventScreenTouch sd = filters[p_port].screen_touch; text = "Touch Finger " + itos(sd.index); - if (sd.pressed) + if (sd->is_pressed()) text += ", Pressed"; else text += ", Released"; } break; - case InputEvent::SCREEN_DRAG: { + case Ref<InputEvent>::SCREEN_DRAG: { InputEventScreenDrag sd = filters[p_port].screen_drag; text = "Drag Finger " + itos(sd.index); } break; - case InputEvent::ACTION: { + case Ref<InputEvent>::ACTION: { List<PropertyInfo> pinfo; GlobalConfig::get_singleton()->get_property_list(&pinfo); @@ -890,7 +891,7 @@ String VisualScriptInputFilter::get_output_sequence_port_text(int p_port) const index++; } - if (filters[p_port].action.pressed) + if (filters[p_port].action->is_pressed()) text += ", Pressed"; else text += ", Released"; @@ -939,20 +940,20 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va String what = String(p_name).get_slice("/", 1); if (what == "type") { - filters[idx] = InputEvent(); - filters[idx].type = InputEvent::Type(int(p_value)); - if (filters[idx].type == InputEvent::JOYPAD_MOTION) { + filters[idx] = Ref<InputEvent>(); + filters[idx].type = Ref<InputEvent>::Type(int(p_value)); + if (filters[idx].type == Ref<InputEvent>::JOYPAD_MOTION) { filters[idx].joy_motion.axis_value = 0.5; //for treshold - } else if (filters[idx].type == InputEvent::KEY) { - filters[idx].key.pressed = true; //put these as true to make it more user friendly - } else if (filters[idx].type == InputEvent::MOUSE_BUTTON) { - filters[idx].mouse_button.pressed = true; - } else if (filters[idx].type == InputEvent::JOYPAD_BUTTON) { - filters[idx].joy_button.pressed = true; - } else if (filters[idx].type == InputEvent::SCREEN_TOUCH) { - filters[idx].screen_touch.pressed = true; - } else if (filters[idx].type == InputEvent::ACTION) { - filters[idx].action.pressed = true; + } else if (filters[idx].type == Ref<InputEvent>::KEY) { + filters[idx]->is_pressed() = true; //put these as true to make it more user friendly + } else if (filters[idx].type == Ref<InputEvent>::MOUSE_BUTTON) { + filters[idx]->is_pressed() = true; + } else if (filters[idx].type == Ref<InputEvent>::JOYPAD_BUTTON) { + filters[idx].joy_button->is_pressed() = true; + } else if (filters[idx].type == Ref<InputEvent>::SCREEN_TOUCH) { + filters[idx].screen_touch->is_pressed() = true; + } else if (filters[idx].type == Ref<InputEvent>::ACTION) { + filters[idx].action->is_pressed() = true; } _change_notify(); ports_changed_notify(); @@ -967,14 +968,14 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va switch (filters[idx].type) { - case InputEvent::KEY: { + case Ref<InputEvent>::KEY: { if (what == "scancode") { String sc = p_value; if (sc == String()) { - filters[idx].key.scancode = 0; + filters[idx]->get_scancode() = 0; } else { - filters[idx].key.scancode = find_keycode(p_value); + filters[idx]->get_scancode() = find_keycode(p_value); } } else if (what == "unicode") { @@ -989,22 +990,22 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va } else if (what == "pressed") { - filters[idx].key.pressed = p_value; + filters[idx]->is_pressed() = p_value; } else if (what == "echo") { - filters[idx].key.echo = p_value; + filters[idx]->is_echo() = p_value; } else if (what == "mod_alt") { - filters[idx].key.mod.alt = p_value; + filters[idx]->get_alt() = p_value; } else if (what == "mod_shift") { - filters[idx].key.mod.shift = p_value; + filters[idx]->get_shift() = p_value; } else if (what == "mod_ctrl") { - filters[idx].key.mod.control = p_value; + filters[idx]->get_control() = p_value; } else if (what == "mod_meta") { - filters[idx].key.mod.meta = p_value; + filters[idx]->get_metakey() = p_value; } else { return false; } @@ -1012,22 +1013,22 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va return true; } break; - case InputEvent::MOUSE_MOTION: { + case Ref<InputEvent>::MOUSE_MOTION: { if (what == "button_mask") { - filters[idx].mouse_motion.button_mask = p_value; + filters[idx]->get_button_mask() = p_value; } else if (what == "mod_alt") { - filters[idx].mouse_motion.mod.alt = p_value; + filters[idx].mouse_motion->get_alt() = p_value; } else if (what == "mod_shift") { - filters[idx].mouse_motion.mod.shift = p_value; + filters[idx].mouse_motion->get_shift() = p_value; } else if (what == "mod_ctrl") { - filters[idx].mouse_motion.mod.control = p_value; + filters[idx].mouse_motion->get_control() = p_value; } else if (what == "mod_meta") { - filters[idx].mouse_motion.mod.meta = p_value; + filters[idx].mouse_motion->get_metakey() = p_value; } else { return false; } @@ -1036,26 +1037,26 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va return true; } break; - case InputEvent::MOUSE_BUTTON: { + case Ref<InputEvent>::MOUSE_BUTTON: { if (what == "button_index") { - filters[idx].mouse_button.button_index = p_value; + filters[idx]->get_button_index() = p_value; } else if (what == "pressed") { - filters[idx].mouse_button.pressed = p_value; + filters[idx]->is_pressed() = p_value; } else if (what == "doubleclicked") { filters[idx].mouse_button.doubleclick = p_value; } else if (what == "mod_alt") { - filters[idx].mouse_button.mod.alt = p_value; + filters[idx].mouse_button->get_alt() = p_value; } else if (what == "mod_shift") { - filters[idx].mouse_button.mod.shift = p_value; + filters[idx].mouse_button->get_shift() = p_value; } else if (what == "mod_ctrl") { - filters[idx].mouse_button.mod.control = p_value; + filters[idx].mouse_button->get_control() = p_value; } else if (what == "mod_meta") { - filters[idx].mouse_button.mod.meta = p_value; + filters[idx].mouse_button->get_metakey() = p_value; } else { return false; } @@ -1063,7 +1064,7 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va return true; } break; - case InputEvent::JOYPAD_MOTION: { + case Ref<InputEvent>::JOYPAD_MOTION: { if (what == "axis") { filters[idx].joy_motion.axis = int(p_value) << 1 | filters[idx].joy_motion.axis; @@ -1078,12 +1079,12 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va return true; } break; - case InputEvent::JOYPAD_BUTTON: { + case Ref<InputEvent>::JOYPAD_BUTTON: { if (what == "button_index") { - filters[idx].joy_button.button_index = p_value; + filters[idx].joy_button->get_button_index() = p_value; } else if (what == "pressed") { - filters[idx].joy_button.pressed = p_value; + filters[idx].joy_button->is_pressed() = p_value; } else { return false; } @@ -1091,19 +1092,19 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va return true; } break; - case InputEvent::SCREEN_TOUCH: { + case Ref<InputEvent>::SCREEN_TOUCH: { if (what == "finger_index") { filters[idx].screen_touch.index = p_value; } else if (what == "pressed") { - filters[idx].screen_touch.pressed = p_value; + filters[idx].screen_touch->is_pressed() = p_value; } else { return false; } ports_changed_notify(); return true; } break; - case InputEvent::SCREEN_DRAG: { + case Ref<InputEvent>::SCREEN_DRAG: { if (what == "finger_index") { filters[idx].screen_drag.index = p_value; } else { @@ -1112,7 +1113,7 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va ports_changed_notify(); return true; } break; - case InputEvent::ACTION: { + case Ref<InputEvent>::ACTION: { if (what == "action_name") { @@ -1144,7 +1145,7 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va } else if (what == "pressed") { - filters[idx].action.pressed = p_value; + filters[idx].action->is_pressed() = p_value; ports_changed_notify(); return true; } @@ -1181,14 +1182,14 @@ bool VisualScriptInputFilter::_get(const StringName &p_name, Variant &r_ret) con switch (filters[idx].type) { - case InputEvent::KEY: { + case Ref<InputEvent>::KEY: { if (what == "scancode") { - if (filters[idx].key.scancode == 0) + if (filters[idx]->get_scancode() == 0) r_ret = String(); else { - r_ret = keycode_get_string(filters[idx].key.scancode); + r_ret = keycode_get_string(filters[idx]->get_scancode()); } } else if (what == "unicode") { @@ -1202,44 +1203,44 @@ bool VisualScriptInputFilter::_get(const StringName &p_name, Variant &r_ret) con } else if (what == "pressed") { - r_ret = filters[idx].key.pressed; + r_ret = filters[idx]->is_pressed(); } else if (what == "echo") { - r_ret = filters[idx].key.echo; + r_ret = filters[idx]->is_echo(); } else if (what == "mod_alt") { - r_ret = filters[idx].key.mod.alt; + r_ret = filters[idx]->get_alt(); } else if (what == "mod_shift") { - r_ret = filters[idx].key.mod.shift; + r_ret = filters[idx]->get_shift(); } else if (what == "mod_ctrl") { - r_ret = filters[idx].key.mod.control; + r_ret = filters[idx]->get_control(); } else if (what == "mod_meta") { - r_ret = filters[idx].key.mod.meta; + r_ret = filters[idx]->get_metakey(); } else { return false; } return true; } break; - case InputEvent::MOUSE_MOTION: { + case Ref<InputEvent>::MOUSE_MOTION: { if (what == "button_mask") { - r_ret = filters[idx].mouse_motion.button_mask; + r_ret = filters[idx]->get_button_mask(); } else if (what == "mod_alt") { - r_ret = filters[idx].mouse_motion.mod.alt; + r_ret = filters[idx].mouse_motion->get_alt(); } else if (what == "mod_shift") { - r_ret = filters[idx].mouse_motion.mod.shift; + r_ret = filters[idx].mouse_motion->get_shift(); } else if (what == "mod_ctrl") { - r_ret = filters[idx].mouse_motion.mod.control; + r_ret = filters[idx].mouse_motion->get_control(); } else if (what == "mod_meta") { - r_ret = filters[idx].mouse_motion.mod.meta; + r_ret = filters[idx].mouse_motion->get_metakey(); } else { return false; } @@ -1247,33 +1248,33 @@ bool VisualScriptInputFilter::_get(const StringName &p_name, Variant &r_ret) con return true; } break; - case InputEvent::MOUSE_BUTTON: { + case Ref<InputEvent>::MOUSE_BUTTON: { if (what == "button_index") { - r_ret = filters[idx].mouse_button.button_index; + r_ret = filters[idx]->get_button_index(); } else if (what == "pressed") { - r_ret = filters[idx].mouse_button.pressed; + r_ret = filters[idx]->is_pressed(); } else if (what == "doubleclicked") { r_ret = filters[idx].mouse_button.doubleclick; } else if (what == "mod_alt") { - r_ret = filters[idx].mouse_button.mod.alt; + r_ret = filters[idx].mouse_button->get_alt(); } else if (what == "mod_shift") { - r_ret = filters[idx].mouse_button.mod.shift; + r_ret = filters[idx].mouse_button->get_shift(); } else if (what == "mod_ctrl") { - r_ret = filters[idx].mouse_button.mod.control; + r_ret = filters[idx].mouse_button->get_control(); } else if (what == "mod_meta") { - r_ret = filters[idx].mouse_button.mod.meta; + r_ret = filters[idx].mouse_button->get_metakey(); } else { return false; } return true; } break; - case InputEvent::JOYPAD_MOTION: { + case Ref<InputEvent>::JOYPAD_MOTION: { if (what == "axis_index") { r_ret = filters[idx].joy_motion.axis >> 1; @@ -1287,30 +1288,30 @@ bool VisualScriptInputFilter::_get(const StringName &p_name, Variant &r_ret) con return true; } break; - case InputEvent::JOYPAD_BUTTON: { + case Ref<InputEvent>::JOYPAD_BUTTON: { if (what == "button_index") { - r_ret = filters[idx].joy_button.button_index; + r_ret = filters[idx].joy_button->get_button_index(); } else if (what == "pressed") { - r_ret = filters[idx].joy_button.pressed; + r_ret = filters[idx].joy_button->is_pressed(); } else { return false; } return true; } break; - case InputEvent::SCREEN_TOUCH: { + case Ref<InputEvent>::SCREEN_TOUCH: { if (what == "finger_index") { r_ret = filters[idx].screen_touch.index; } else if (what == "pressed") { - r_ret = filters[idx].screen_touch.pressed; + r_ret = filters[idx].screen_touch->is_pressed(); } else { return false; } return true; } break; - case InputEvent::SCREEN_DRAG: { + case Ref<InputEvent>::SCREEN_DRAG: { if (what == "finger_index") { r_ret = filters[idx].screen_drag.index; } else { @@ -1318,7 +1319,7 @@ bool VisualScriptInputFilter::_get(const StringName &p_name, Variant &r_ret) con } return true; } break; - case InputEvent::ACTION: { + case Ref<InputEvent>::ACTION: { if (what == "action_name") { @@ -1344,7 +1345,7 @@ bool VisualScriptInputFilter::_get(const StringName &p_name, Variant &r_ret) con } else if (what == "pressed") { - r_ret = filters[idx].action.pressed; + r_ret = filters[idx].action->is_pressed(); return true; } @@ -1354,7 +1355,7 @@ bool VisualScriptInputFilter::_get(const StringName &p_name, Variant &r_ret) con return false; } -static const char *event_type_names[InputEvent::TYPE_MAX] = { +static const char *event_type_names[Ref<InputEvent>::TYPE_MAX] = { "None", "Key", "MouseMotion", @@ -1371,7 +1372,7 @@ void VisualScriptInputFilter::_get_property_list(List<PropertyInfo> *p_list) con p_list->push_back(PropertyInfo(Variant::INT, "filter_count", PROPERTY_HINT_RANGE, "0,64")); String et; - for (int i = 0; i < InputEvent::TYPE_MAX; i++) { + for (int i = 0; i < Ref<InputEvent>::TYPE_MAX; i++) { if (i > 0) et += ","; @@ -1388,10 +1389,10 @@ void VisualScriptInputFilter::_get_property_list(List<PropertyInfo> *p_list) con p_list->push_back(PropertyInfo(Variant::INT, base + "device")); switch (filters[i].type) { - case InputEvent::NONE: { + case Ref<InputEvent>::NONE: { } break; - case InputEvent::KEY: { + case Ref<InputEvent>::KEY: { if (kc == String()) { int kcc = keycode_get_count(); kc = "None"; @@ -1410,7 +1411,7 @@ void VisualScriptInputFilter::_get_property_list(List<PropertyInfo> *p_list) con p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_meta")); } break; - case InputEvent::MOUSE_MOTION: { + case Ref<InputEvent>::MOUSE_MOTION: { p_list->push_back(PropertyInfo(Variant::INT, base + "button_mask", PROPERTY_HINT_FLAGS, "Left,Right,Middle,WheelUp,WheelDown,WheelLeft,WheelRight")); p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_alt")); p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_shift")); @@ -1418,7 +1419,7 @@ void VisualScriptInputFilter::_get_property_list(List<PropertyInfo> *p_list) con p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_meta")); } break; - case InputEvent::MOUSE_BUTTON: { + case Ref<InputEvent>::MOUSE_BUTTON: { p_list->push_back(PropertyInfo(Variant::INT, base + "button_index", PROPERTY_HINT_ENUM, "Any,Left,Right,Middle,WheelUp,WheelDown,WheelLeft,WheelRight")); p_list->push_back(PropertyInfo(Variant::BOOL, base + "pressed")); p_list->push_back(PropertyInfo(Variant::BOOL, base + "doubleclicked")); @@ -1428,26 +1429,26 @@ void VisualScriptInputFilter::_get_property_list(List<PropertyInfo> *p_list) con p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_meta")); } break; - case InputEvent::JOYPAD_MOTION: { + case Ref<InputEvent>::JOYPAD_MOTION: { p_list->push_back(PropertyInfo(Variant::INT, base + "axis_index")); p_list->push_back(PropertyInfo(Variant::INT, base + "mode", PROPERTY_HINT_ENUM, "Min,Max")); p_list->push_back(PropertyInfo(Variant::REAL, base + "treshold", PROPERTY_HINT_RANGE, "0,1,0.01")); } break; - case InputEvent::JOYPAD_BUTTON: { + case Ref<InputEvent>::JOYPAD_BUTTON: { p_list->push_back(PropertyInfo(Variant::INT, base + "button_index")); p_list->push_back(PropertyInfo(Variant::BOOL, base + "pressed")); } break; - case InputEvent::SCREEN_TOUCH: { + case Ref<InputEvent>::SCREEN_TOUCH: { p_list->push_back(PropertyInfo(Variant::INT, base + "finger_index")); p_list->push_back(PropertyInfo(Variant::BOOL, base + "pressed")); } break; - case InputEvent::SCREEN_DRAG: { + case Ref<InputEvent>::SCREEN_DRAG: { p_list->push_back(PropertyInfo(Variant::INT, base + "finger_index")); } break; - case InputEvent::ACTION: { + case Ref<InputEvent>::ACTION: { if (actions == String()) { @@ -1485,7 +1486,7 @@ void VisualScriptInputFilter::_get_property_list(List<PropertyInfo> *p_list) con class VisualScriptNodeInstanceInputFilter : public VisualScriptNodeInstance { public: VisualScriptInstance *instance; - Vector<InputEvent> filters; + Vector<Ref<InputEvent>> filters; //virtual int get_working_memory_size() const { return 0; } //virtual bool is_output_port_unsequenced(int p_idx) const { return false; } @@ -1499,11 +1500,11 @@ public: return 0; } - InputEvent event = *p_inputs[0]; + Ref<InputEvent> event = *p_inputs[0]; for (int i = 0; i < filters.size(); i++) { - const InputEvent &ie = filters[i]; + const Ref<InputEvent> &ie = filters[i]; if (ie.type != event.type) continue; @@ -1511,25 +1512,25 @@ public: switch (ie.type) { - case InputEvent::NONE: { + case Ref<InputEvent>::NONE: { match = true; } break; - case InputEvent::KEY: { + case Ref<InputEvent>::KEY: { InputEventKey k = ie.key; InputEventKey k2 = event.key; - if (k.scancode == 0 && k.unicode == 0 && k2.scancode == 0 && k2.unicode == 0) { + if (k->get_scancode() == 0 && k.unicode == 0 && k2->get_scancode() == 0 && k2.unicode == 0) { match = true; } else { - if ((k.scancode != 0 && k.scancode == k2.scancode) || (k.unicode != 0 && k.unicode == k2.unicode)) { + if ((k->get_scancode() != 0 && k->get_scancode() == k2->get_scancode()) || (k.unicode != 0 && k.unicode == k2.unicode)) { //key valid if ( - k.pressed == k2.pressed && + k->is_pressed() == k2->is_pressed() && k.echo == k2.echo && k.mod == k2.mod) { match = true; @@ -1538,30 +1539,30 @@ public: } } break; - case InputEvent::MOUSE_MOTION: { + case Ref<InputEvent>::MOUSE_MOTION: { InputEventMouseMotion mm = ie.mouse_motion; InputEventMouseMotion mm2 = event.mouse_motion; - if (mm.button_mask == mm2.button_mask && + if (mm->get_button_mask() == mm2->get_button_mask() && mm.mod == mm2.mod) { match = true; } } break; - case InputEvent::MOUSE_BUTTON: { + case Ref<InputEvent>::MOUSE_BUTTON: { InputEventMouseButton mb = ie.mouse_button; InputEventMouseButton mb2 = event.mouse_button; - if (mb.button_index == mb2.button_index && - mb.pressed == mb2.pressed && + if (mb->get_button_index() == mb2->get_button_index() && + mb->is_pressed() == mb2->is_pressed() && mb.doubleclick == mb2.doubleclick && mb.mod == mb2.mod) { match = true; } } break; - case InputEvent::JOYPAD_MOTION: { + case Ref<InputEvent>::JOYPAD_MOTION: { InputEventJoypadMotion jm = ie.joy_motion; InputEventJoypadMotion jm2 = event.joy_motion; @@ -1584,26 +1585,26 @@ public: } } break; - case InputEvent::JOYPAD_BUTTON: { + case Ref<InputEvent>::JOYPAD_BUTTON: { InputEventJoypadButton jb = ie.joy_button; InputEventJoypadButton jb2 = event.joy_button; - if (jb.button_index == jb2.button_index && - jb.pressed == jb2.pressed) { + if (jb->get_button_index() == jb2->get_button_index() && + jb->is_pressed() == jb2->is_pressed()) { match = true; } } break; - case InputEvent::SCREEN_TOUCH: { + case Ref<InputEvent>::SCREEN_TOUCH: { InputEventScreenTouch st = ie.screen_touch; InputEventScreenTouch st2 = event.screen_touch; if (st.index == st2.index && - st.pressed == st2.pressed) { + st->is_pressed() == st2->is_pressed()) { match = true; } } break; - case InputEvent::SCREEN_DRAG: { + case Ref<InputEvent>::SCREEN_DRAG: { InputEventScreenDrag sd = ie.screen_drag; InputEventScreenDrag sd2 = event.screen_drag; @@ -1611,13 +1612,13 @@ public: match = true; } } break; - case InputEvent::ACTION: { + case Ref<InputEvent>::ACTION: { InputEventAction ia = ie.action; InputEventAction ia2 = event.action; if (ia.action == ia2.action && - ia.pressed == ia2.pressed) { + ia->is_pressed() == ia2->is_pressed()) { match = true; } } break; @@ -1643,7 +1644,7 @@ VisualScriptNodeInstance *VisualScriptInputFilter::instance(VisualScriptInstance VisualScriptInputFilter::VisualScriptInputFilter() { } - +#endif ////////////////////////////////////////// ////////////////TYPE CAST/////////// ////////////////////////////////////////// @@ -1832,6 +1833,6 @@ void register_visual_script_flow_control_nodes() { VisualScriptLanguage::singleton->add_register_func("flow_control/iterator", create_node_generic<VisualScriptIterator>); VisualScriptLanguage::singleton->add_register_func("flow_control/sequence", create_node_generic<VisualScriptSequence>); VisualScriptLanguage::singleton->add_register_func("flow_control/switch", create_node_generic<VisualScriptSwitch>); - VisualScriptLanguage::singleton->add_register_func("flow_control/input_filter", create_node_generic<VisualScriptInputFilter>); + //VisualScriptLanguage::singleton->add_register_func("flow_control/input_filter", create_node_generic<VisualScriptInputFilter>); VisualScriptLanguage::singleton->add_register_func("flow_control/type_cast", create_node_generic<VisualScriptTypeCast>); } diff --git a/modules/visual_script/visual_script_flow_control.h b/modules/visual_script/visual_script_flow_control.h index e3936da9e5..314804602e 100644 --- a/modules/visual_script/visual_script_flow_control.h +++ b/modules/visual_script/visual_script_flow_control.h @@ -228,11 +228,12 @@ public: VisualScriptSwitch(); }; +#if 0 class VisualScriptInputFilter : public VisualScriptNode { GDCLASS(VisualScriptInputFilter, VisualScriptNode) - Vector<InputEvent> filters; + Vector<Ref<InputEvent>> filters; protected: bool _set(const StringName &p_name, const Variant &p_value); @@ -259,7 +260,7 @@ public: VisualScriptInputFilter(); }; - +#endif class VisualScriptTypeCast : public VisualScriptNode { GDCLASS(VisualScriptTypeCast, VisualScriptNode) diff --git a/modules/visual_script/visual_script_func_nodes.cpp b/modules/visual_script/visual_script_func_nodes.cpp index 84224dfcbe..b466e64aec 100644 --- a/modules/visual_script/visual_script_func_nodes.cpp +++ b/modules/visual_script/visual_script_func_nodes.cpp @@ -943,18 +943,6 @@ static Ref<VisualScriptNode> create_function_call_node(const String &p_name) { ////////////////SET////////////////////// ////////////////////////////////////////// -static const char *event_type_names[InputEvent::TYPE_MAX] = { - "None", - "Key", - "MouseMotion", - "MouseButton", - "JoypadMotion", - "JoypadButton", - "ScreenTouch", - "ScreenDrag", - "Action" -}; - int VisualScriptPropertySet::get_output_sequence_port_count() const { return call_mode != CALL_MODE_BASIC_TYPE ? 1 : 0; @@ -1119,24 +1107,6 @@ Variant::Type VisualScriptPropertySet::get_basic_type() const { return basic_type; } -void VisualScriptPropertySet::set_event_type(InputEvent::Type p_type) { - - if (event_type == p_type) - return; - event_type = p_type; - if (call_mode == CALL_MODE_BASIC_TYPE) { - _update_cache(); - } - _change_notify(); - _update_base_type(); - ports_changed_notify(); -} - -InputEvent::Type VisualScriptPropertySet::get_event_type() const { - - return event_type; -} - void VisualScriptPropertySet::set_base_type(const StringName &p_type) { if (base_type == p_type) @@ -1182,14 +1152,8 @@ void VisualScriptPropertySet::_update_cache() { //not super efficient.. Variant v; - if (basic_type == Variant::INPUT_EVENT) { - InputEvent ev; - ev.type = event_type; - v = ev; - } else { - Variant::CallError ce; - v = Variant::construct(basic_type, NULL, 0, ce); - } + Variant::CallError ce; + v = Variant::construct(basic_type, NULL, 0, ce); List<PropertyInfo> pinfo; v.get_property_list(&pinfo); @@ -1341,12 +1305,6 @@ void VisualScriptPropertySet::_validate_property(PropertyInfo &property) const { } } - if (property.name == "property/event_type") { - if (call_mode != CALL_MODE_BASIC_TYPE || basic_type != Variant::INPUT_EVENT) { - property.usage = 0; - } - } - if (property.name == "property/node_path") { if (call_mode != CALL_MODE_NODE_PATH) { property.usage = 0; @@ -1418,9 +1376,6 @@ void VisualScriptPropertySet::_bind_methods() { ClassDB::bind_method(D_METHOD("_set_type_cache", "type_cache"), &VisualScriptPropertySet::_set_type_cache); ClassDB::bind_method(D_METHOD("_get_type_cache"), &VisualScriptPropertySet::_get_type_cache); - ClassDB::bind_method(D_METHOD("set_event_type", "event_type"), &VisualScriptPropertySet::set_event_type); - ClassDB::bind_method(D_METHOD("get_event_type"), &VisualScriptPropertySet::get_event_type); - ClassDB::bind_method(D_METHOD("set_property", "property"), &VisualScriptPropertySet::set_property); ClassDB::bind_method(D_METHOD("get_property"), &VisualScriptPropertySet::get_property); @@ -1438,14 +1393,6 @@ void VisualScriptPropertySet::_bind_methods() { bt += Variant::get_type_name(Variant::Type(i)); } - String et; - for (int i = 0; i < InputEvent::TYPE_MAX; i++) { - if (i > 0) - et += ","; - - et += event_type_names[i]; - } - List<String> script_extensions; for (int i = 0; i < ScriptServer::get_language_count(); i++) { ScriptServer::get_language(i)->get_recognized_extensions(&script_extensions); @@ -1463,7 +1410,6 @@ void VisualScriptPropertySet::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::STRING, "property/base_script", PROPERTY_HINT_FILE, script_ext_hint), "set_base_script", "get_base_script"); ADD_PROPERTY(PropertyInfo(Variant::INT, "property/type_cache", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_type_cache", "_get_type_cache"); ADD_PROPERTY(PropertyInfo(Variant::INT, "property/basic_type", PROPERTY_HINT_ENUM, bt), "set_basic_type", "get_basic_type"); - ADD_PROPERTY(PropertyInfo(Variant::INT, "property/event_type", PROPERTY_HINT_ENUM, et), "set_event_type", "get_event_type"); ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "property/node_path", PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE), "set_base_path", "get_base_path"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "property/property"), "set_property", "get_property"); @@ -1574,7 +1520,6 @@ VisualScriptPropertySet::VisualScriptPropertySet() { call_mode = CALL_MODE_SELF; base_type = "Object"; basic_type = Variant::NIL; - event_type = InputEvent::NONE; } template <VisualScriptPropertySet::CallMode cmode> @@ -1764,14 +1709,8 @@ void VisualScriptPropertyGet::_update_cache() { //not super efficient.. Variant v; - if (basic_type == Variant::INPUT_EVENT) { - InputEvent ev; - ev.type = event_type; - v = ev; - } else { - Variant::CallError ce; - v = Variant::construct(basic_type, NULL, 0, ce); - } + Variant::CallError ce; + v = Variant::construct(basic_type, NULL, 0, ce); List<PropertyInfo> pinfo; v.get_property_list(&pinfo); @@ -1919,24 +1858,6 @@ Variant::Type VisualScriptPropertyGet::get_basic_type() const { return basic_type; } -void VisualScriptPropertyGet::set_event_type(InputEvent::Type p_type) { - - if (event_type == p_type) - return; - event_type = p_type; - if (call_mode == CALL_MODE_BASIC_TYPE) { - _update_cache(); - } - _change_notify(); - _update_base_type(); - ports_changed_notify(); -} - -InputEvent::Type VisualScriptPropertyGet::get_event_type() const { - - return event_type; -} - void VisualScriptPropertyGet::_set_type_cache(Variant::Type p_type) { type_cache = p_type; } @@ -1965,11 +1886,6 @@ void VisualScriptPropertyGet::_validate_property(PropertyInfo &property) const { property.usage = 0; } } - if (property.name == "property/event_type") { - if (call_mode != CALL_MODE_BASIC_TYPE || basic_type != Variant::INPUT_EVENT) { - property.usage = 0; - } - } if (property.name == "property/node_path") { if (call_mode != CALL_MODE_NODE_PATH) { @@ -2041,9 +1957,6 @@ void VisualScriptPropertyGet::_bind_methods() { ClassDB::bind_method(D_METHOD("_set_type_cache", "type_cache"), &VisualScriptPropertyGet::_set_type_cache); ClassDB::bind_method(D_METHOD("_get_type_cache"), &VisualScriptPropertyGet::_get_type_cache); - ClassDB::bind_method(D_METHOD("set_event_type", "event_type"), &VisualScriptPropertyGet::set_event_type); - ClassDB::bind_method(D_METHOD("get_event_type"), &VisualScriptPropertyGet::get_event_type); - ClassDB::bind_method(D_METHOD("set_property", "property"), &VisualScriptPropertyGet::set_property); ClassDB::bind_method(D_METHOD("get_property"), &VisualScriptPropertyGet::get_property); @@ -2061,14 +1974,6 @@ void VisualScriptPropertyGet::_bind_methods() { bt += Variant::get_type_name(Variant::Type(i)); } - String et; - for (int i = 0; i < InputEvent::TYPE_MAX; i++) { - if (i > 0) - et += ","; - - et += event_type_names[i]; - } - List<String> script_extensions; for (int i = 0; i < ScriptServer::get_language_count(); i++) { ScriptServer::get_language(i)->get_recognized_extensions(&script_extensions); @@ -2086,7 +1991,6 @@ void VisualScriptPropertyGet::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::STRING, "property/base_script", PROPERTY_HINT_FILE, script_ext_hint), "set_base_script", "get_base_script"); ADD_PROPERTY(PropertyInfo(Variant::INT, "property/type_cache", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_type_cache", "_get_type_cache"); ADD_PROPERTY(PropertyInfo(Variant::INT, "property/basic_type", PROPERTY_HINT_ENUM, bt), "set_basic_type", "get_basic_type"); - ADD_PROPERTY(PropertyInfo(Variant::INT, "property/event_type", PROPERTY_HINT_ENUM, et), "set_event_type", "get_event_type"); ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "property/node_path", PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE), "set_base_path", "get_base_path"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "property/property"), "set_property", "get_property"); @@ -2184,7 +2088,6 @@ VisualScriptPropertyGet::VisualScriptPropertyGet() { call_mode = CALL_MODE_SELF; base_type = "Object"; basic_type = Variant::NIL; - event_type = InputEvent::NONE; type_cache = Variant::NIL; } diff --git a/modules/visual_script/visual_script_func_nodes.h b/modules/visual_script/visual_script_func_nodes.h index b56a3c2bcc..3b284952c5 100644 --- a/modules/visual_script/visual_script_func_nodes.h +++ b/modules/visual_script/visual_script_func_nodes.h @@ -155,7 +155,6 @@ private: String base_script; NodePath base_path; StringName property; - InputEvent::Type event_type; Node *_get_base_node() const; StringName _get_base_type() const; @@ -197,9 +196,6 @@ public: void set_basic_type(Variant::Type p_type); Variant::Type get_basic_type() const; - void set_event_type(InputEvent::Type p_type); - InputEvent::Type get_event_type() const; - void set_property(const StringName &p_type); StringName get_property() const; @@ -238,7 +234,6 @@ private: String base_script; NodePath base_path; StringName property; - InputEvent::Type event_type; void _update_base_type(); Node *_get_base_node() const; @@ -279,9 +274,6 @@ public: void set_basic_type(Variant::Type p_type); Variant::Type get_basic_type() const; - void set_event_type(InputEvent::Type p_type); - InputEvent::Type get_event_type() const; - void set_property(const StringName &p_type); StringName get_property() const; diff --git a/modules/visual_script/visual_script_nodes.cpp b/modules/visual_script/visual_script_nodes.cpp index 08f4191d3d..8ea3b8098d 100644 --- a/modules/visual_script/visual_script_nodes.cpp +++ b/modules/visual_script/visual_script_nodes.cpp @@ -3460,14 +3460,8 @@ void VisualScriptDeconstruct::_update_elements() { elements.clear(); Variant v; - if (type == Variant::INPUT_EVENT) { - InputEvent ie; - ie.type = input_type; - v = ie; - } else { - Variant::CallError ce; - v = Variant::construct(type, NULL, 0, ce); - } + Variant::CallError ce; + v = Variant::construct(type, NULL, 0, ce); List<PropertyInfo> pinfo; v.get_property_list(&pinfo); @@ -3497,21 +3491,6 @@ Variant::Type VisualScriptDeconstruct::get_deconstruct_type() const { return type; } -void VisualScriptDeconstruct::set_deconstruct_input_type(InputEvent::Type p_input_type) { - - if (input_type == p_input_type) - return; - - input_type = p_input_type; - _update_elements(); - ports_changed_notify(); -} - -InputEvent::Type VisualScriptDeconstruct::get_deconstruct_input_type() const { - - return input_type; -} - void VisualScriptDeconstruct::_set_elem_cache(const Array &p_elements) { ERR_FAIL_COND(p_elements.size() % 2 == 1); @@ -3570,12 +3549,6 @@ VisualScriptNodeInstance *VisualScriptDeconstruct::instance(VisualScriptInstance } void VisualScriptDeconstruct::_validate_property(PropertyInfo &property) const { - - if (property.name == "input_type") { - if (type != Variant::INPUT_EVENT) { - property.usage = 0; - } - } } void VisualScriptDeconstruct::_bind_methods() { @@ -3583,9 +3556,6 @@ void VisualScriptDeconstruct::_bind_methods() { ClassDB::bind_method(D_METHOD("set_deconstruct_type", "type"), &VisualScriptDeconstruct::set_deconstruct_type); ClassDB::bind_method(D_METHOD("get_deconstruct_type"), &VisualScriptDeconstruct::get_deconstruct_type); - ClassDB::bind_method(D_METHOD("set_deconstruct_input_type", "input_type"), &VisualScriptDeconstruct::set_deconstruct_input_type); - ClassDB::bind_method(D_METHOD("get_deconstruct_input_type"), &VisualScriptDeconstruct::get_deconstruct_input_type); - ClassDB::bind_method(D_METHOD("_set_elem_cache", "_cache"), &VisualScriptDeconstruct::_set_elem_cache); ClassDB::bind_method(D_METHOD("_get_elem_cache"), &VisualScriptDeconstruct::_get_elem_cache); @@ -3594,17 +3564,13 @@ void VisualScriptDeconstruct::_bind_methods() { argt += "," + Variant::get_type_name(Variant::Type(i)); } - String iet = "None,Key,MouseMotion,MouseButton,JoypadMotion,JoypadButton,ScreenTouch,ScreenDrag,Action"; - ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, argt), "set_deconstruct_type", "get_deconstruct_type"); - ADD_PROPERTY(PropertyInfo(Variant::INT, "input_type", PROPERTY_HINT_ENUM, iet), "set_deconstruct_input_type", "get_deconstruct_input_type"); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "elem_cache", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_elem_cache", "_get_elem_cache"); } VisualScriptDeconstruct::VisualScriptDeconstruct() { type = Variant::NIL; - input_type = InputEvent::NONE; } void register_visual_script_nodes() { diff --git a/modules/visual_script/visual_script_nodes.h b/modules/visual_script/visual_script_nodes.h index c0933d1a78..402093fa80 100644 --- a/modules/visual_script/visual_script_nodes.h +++ b/modules/visual_script/visual_script_nodes.h @@ -923,7 +923,6 @@ class VisualScriptDeconstruct : public VisualScriptNode { void _update_elements(); Variant::Type type; - InputEvent::Type input_type; void _set_elem_cache(const Array &p_elements); Array _get_elem_cache() const; @@ -952,9 +951,6 @@ public: void set_deconstruct_type(Variant::Type p_type); Variant::Type get_deconstruct_type() const; - void set_deconstruct_input_type(InputEvent::Type p_input_type); - InputEvent::Type get_deconstruct_input_type() const; - virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance); VisualScriptDeconstruct(); diff --git a/modules/webp/image_loader_webp.cpp b/modules/webp/image_loader_webp.cpp index 889eac71a7..7313cb6c7c 100644 --- a/modules/webp/image_loader_webp.cpp +++ b/modules/webp/image_loader_webp.cpp @@ -37,23 +37,23 @@ #include <webp/decode.h> #include <webp/encode.h> -static PoolVector<uint8_t> _webp_lossy_pack(const Image &p_image, float p_quality) { +static PoolVector<uint8_t> _webp_lossy_pack(const Ref<Image> &p_image, float p_quality) { - ERR_FAIL_COND_V(p_image.empty(), PoolVector<uint8_t>()); + ERR_FAIL_COND_V(p_image.is_null() || p_image->empty(), PoolVector<uint8_t>()); - Image img = p_image; - if (img.detect_alpha()) - img.convert(Image::FORMAT_RGBA8); + Ref<Image> img = p_image->duplicate(); + if (img->detect_alpha()) + img->convert(Image::FORMAT_RGBA8); else - img.convert(Image::FORMAT_RGB8); + img->convert(Image::FORMAT_RGB8); - Size2 s(img.get_width(), img.get_height()); - PoolVector<uint8_t> data = img.get_data(); + Size2 s(img->get_width(), img->get_height()); + PoolVector<uint8_t> data = img->get_data(); PoolVector<uint8_t>::Read r = data.read(); uint8_t *dst_buff = NULL; size_t dst_size = 0; - if (img.get_format() == Image::FORMAT_RGB8) { + if (img->get_format() == Image::FORMAT_RGB8) { dst_size = WebPEncodeRGB(r.ptr(), s.width, s.height, 3 * s.width, CLAMP(p_quality * 100.0, 0, 100.0), &dst_buff); } else { @@ -74,17 +74,17 @@ static PoolVector<uint8_t> _webp_lossy_pack(const Image &p_image, float p_qualit return dst; } -static Image _webp_lossy_unpack(const PoolVector<uint8_t> &p_buffer) { +static Ref<Image> _webp_lossy_unpack(const PoolVector<uint8_t> &p_buffer) { int size = p_buffer.size() - 4; - ERR_FAIL_COND_V(size <= 0, Image()); + ERR_FAIL_COND_V(size <= 0, Ref<Image>()); PoolVector<uint8_t>::Read r = p_buffer.read(); - ERR_FAIL_COND_V(r[0] != 'W' || r[1] != 'E' || r[2] != 'B' || r[3] != 'P', Image()); + ERR_FAIL_COND_V(r[0] != 'W' || r[1] != 'E' || r[2] != 'B' || r[3] != 'P', Ref<Image>()); WebPBitstreamFeatures features; if (WebPGetFeatures(&r[4], size, &features) != VP8_STATUS_OK) { ERR_EXPLAIN("Error unpacking WEBP image:"); - ERR_FAIL_V(Image()); + ERR_FAIL_V(Ref<Image>()); } /* @@ -107,14 +107,15 @@ static Image _webp_lossy_unpack(const PoolVector<uint8_t> &p_buffer) { } //ERR_EXPLAIN("Error decoding webp! - "+p_file); - ERR_FAIL_COND_V(errdec, Image()); + ERR_FAIL_COND_V(errdec, Ref<Image>()); dst_w = PoolVector<uint8_t>::Write(); - return Image(features.width, features.height, 0, features.has_alpha ? Image::FORMAT_RGBA8 : Image::FORMAT_RGB8, dst_image); + Ref<Image> img = memnew(Image(features.width, features.height, 0, features.has_alpha ? Image::FORMAT_RGBA8 : Image::FORMAT_RGB8, dst_image)); + return img; } -Error ImageLoaderWEBP::load_image(Image *p_image, FileAccess *f) { +Error ImageLoaderWEBP::load_image(Ref<Image> p_image, FileAccess *f) { uint32_t size = f->get_len(); PoolVector<uint8_t> src_image; @@ -160,7 +161,7 @@ Error ImageLoaderWEBP::load_image(Image *p_image, FileAccess *f) { src_r = PoolVector<uint8_t>::Read(); dst_w = PoolVector<uint8_t>::Write(); - *p_image = Image(features.width, features.height, 0, features.has_alpha ? Image::FORMAT_RGBA8 : Image::FORMAT_RGB8, dst_image); + p_image->create(features.width, features.height, 0, features.has_alpha ? Image::FORMAT_RGBA8 : Image::FORMAT_RGB8, dst_image); return OK; } diff --git a/modules/webp/image_loader_webp.h b/modules/webp/image_loader_webp.h index 2d0ac796d3..ba817e0ecd 100644 --- a/modules/webp/image_loader_webp.h +++ b/modules/webp/image_loader_webp.h @@ -38,7 +38,7 @@ class ImageLoaderWEBP : public ImageFormatLoader { public: - virtual Error load_image(Image *p_image, FileAccess *f); + virtual Error load_image(Ref<Image> p_image, FileAccess *f); virtual void get_recognized_extensions(List<String> *p_extensions) const; ImageLoaderWEBP(); }; |