diff options
43 files changed, 2529 insertions, 2346 deletions
diff --git a/core/variant_call.cpp b/core/variant_call.cpp index 8bc9f085ad..df81d2111e 100644 --- a/core/variant_call.cpp +++ b/core/variant_call.cpp @@ -1460,7 +1460,6 @@ void register_variant_methods() { ADDFUNC1(VECTOR3, BASIS, Vector3, outer, VECTOR3, "b", varray()); ADDFUNC0(VECTOR3, BASIS, Vector3, to_diagonal_matrix, varray()); ADDFUNC0(VECTOR3, VECTOR3, Vector3, abs, varray()); - ADDFUNC0(VECTOR3, VECTOR3, Vector3, abs, varray()); ADDFUNC0(VECTOR3, VECTOR3, Vector3, floor, varray()); ADDFUNC0(VECTOR3, VECTOR3, Vector3, ceil, varray()); ADDFUNC1(VECTOR3, REAL, Vector3, distance_to, VECTOR3, "b", varray()); diff --git a/modules/gdnative/config.py b/modules/gdnative/config.py index 4f89ca0d4c..9f57b9bb74 100644 --- a/modules/gdnative/config.py +++ b/modules/gdnative/config.py @@ -1,7 +1,7 @@ def can_build(platform): - return False + return True def configure(env): 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 bf0e2bf64e..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, @@ -68,20 +65,19 @@ typedef enum godot_variant_type { // 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 } |