From 9863e95b0246296eca83735294c8e62a448ca5fe Mon Sep 17 00:00:00 2001 From: Relintai Date: Thu, 1 Jun 2023 14:14:19 +0200 Subject: [PATCH] Added the new Variant types to (hoipefully all) glue code. --- glue/base_object_glue.cpp | 2 +- glue/collections_glue.h | 2 +- glue/gd_glue.cpp | 4 +- glue/glue_header.h | 2 +- glue/nodepath_glue.h | 2 +- glue/rid_glue.cpp | 2 +- glue/rid_glue.h | 2 +- mono_gd/gd_mono_cache.cpp | 20 +- mono_gd/gd_mono_cache.h | 10 +- mono_gd/gd_mono_marshal.cpp | 463 +++++++++++++++++++++++++++++++----- mono_gd/gd_mono_marshal.h | 146 +++++++++++- mono_gd/gd_mono_method.cpp | 12 +- mono_gd/gd_mono_utils.cpp | 12 + mono_gd/gd_mono_utils.h | 1 + 14 files changed, 606 insertions(+), 74 deletions(-) diff --git a/glue/base_object_glue.cpp b/glue/base_object_glue.cpp index 5eafe61..2c7cbd4 100644 --- a/glue/base_object_glue.cpp +++ b/glue/base_object_glue.cpp @@ -33,7 +33,7 @@ #ifdef MONO_GLUE_ENABLED #include "core/object/reference.h" -#include "core/string_name.h" +#include "core/string/string_name.h" #include "../csharp_script.h" #include "../mono_gd/gd_mono_cache.h" diff --git a/glue/collections_glue.h b/glue/collections_glue.h index 043a7d5..6aa6e8e 100644 --- a/glue/collections_glue.h +++ b/glue/collections_glue.h @@ -33,7 +33,7 @@ #ifdef MONO_GLUE_ENABLED -#include "core/array.h" +#include "core/variant/array.h" #include "../mono_gd/gd_mono_marshal.h" diff --git a/glue/gd_glue.cpp b/glue/gd_glue.cpp index 4b788b8..45904c4 100644 --- a/glue/gd_glue.cpp +++ b/glue/gd_glue.cpp @@ -32,12 +32,12 @@ #ifdef MONO_GLUE_ENABLED -#include "core/array.h" +#include "core/variant/array.h" #include "core/io/marshalls.h" #include "core/os/os.h" #include "core/string/ustring.h" #include "core/variant/variant.h" -#include "core/variant_parser.h" +#include "core/variant/variant_parser.h" #include "../mono_gd/gd_mono_cache.h" #include "../mono_gd/gd_mono_utils.h" diff --git a/glue/glue_header.h b/glue/glue_header.h index 0bb6237..25aea6c 100644 --- a/glue/glue_header.h +++ b/glue/glue_header.h @@ -61,7 +61,7 @@ void godot_register_glue_header_icalls() { #include "core/object/class_db.h" #include "core/variant/dictionary.h" #include "core/config/engine.h" -#include "core/method_bind.h" +#include "core/object/method_bind.h" #include "core/string/node_path.h" #include "core/object/object.h" #include "core/object/reference.h" diff --git a/glue/nodepath_glue.h b/glue/nodepath_glue.h index 4ad226c..7d91415 100644 --- a/glue/nodepath_glue.h +++ b/glue/nodepath_glue.h @@ -33,7 +33,7 @@ #ifdef MONO_GLUE_ENABLED -#include "core/node_path.h" +#include "core/string/node_path.h" #include "../mono_gd/gd_mono_marshal.h" diff --git a/glue/rid_glue.cpp b/glue/rid_glue.cpp index 1812710..af6c792 100644 --- a/glue/rid_glue.cpp +++ b/glue/rid_glue.cpp @@ -32,7 +32,7 @@ #ifdef MONO_GLUE_ENABLED -#include "core/resource.h" +#include "core/object/resource.h" RID *godot_icall_RID_Ctor(Object *p_from) { Resource *res_from = Object::cast_to(p_from); diff --git a/glue/rid_glue.h b/glue/rid_glue.h index 74d70d7..fb2f0b5 100644 --- a/glue/rid_glue.h +++ b/glue/rid_glue.h @@ -34,7 +34,7 @@ #ifdef MONO_GLUE_ENABLED #include "core/object/object.h" -#include "core/rid.h" +#include "core/containers/rid.h" #include "../mono_gd/gd_mono_marshal.h" diff --git a/mono_gd/gd_mono_cache.cpp b/mono_gd/gd_mono_cache.cpp index 3cde178..49c93fe 100644 --- a/mono_gd/gd_mono_cache.cpp +++ b/mono_gd/gd_mono_cache.cpp @@ -101,17 +101,24 @@ void CachedData::clear_godot_api_cache() { rawclass_Dictionary = NULL; - class_Vector2 = NULL; class_Rect2 = NULL; + class_Rect2i = NULL; class_Transform2D = NULL; + class_Vector2 = NULL; + class_Vector2i = NULL; class_Vector3 = NULL; + class_Vector3i = NULL; + class_Vector4 = NULL; + class_Vector4i = NULL; class_Basis = NULL; class_Quaternion = NULL; class_Transform = NULL; + class_Projection = NULL; class_AABB = NULL; class_Color = NULL; class_Plane = NULL; class_NodePath = NULL; + class_StringName = NULL; class_RID = NULL; class_GodotObject = NULL; class_GodotResource = NULL; @@ -147,6 +154,7 @@ void CachedData::clear_godot_api_cache() { field_GodotObject_ptr = NULL; field_NodePath_ptr = NULL; + field_StringName_ptr = NULL; field_Image_ptr = NULL; field_RID_ptr = NULL; @@ -217,17 +225,24 @@ void update_corlib_cache() { } void update_godot_api_cache() { - CACHE_CLASS_AND_CHECK(Vector2, GODOT_API_CLASS(Vector2)); CACHE_CLASS_AND_CHECK(Rect2, GODOT_API_CLASS(Rect2)); + CACHE_CLASS_AND_CHECK(Rect2i, GODOT_API_CLASS(Rect2i)); CACHE_CLASS_AND_CHECK(Transform2D, GODOT_API_CLASS(Transform2D)); + CACHE_CLASS_AND_CHECK(Vector2, GODOT_API_CLASS(Vector2)); + CACHE_CLASS_AND_CHECK(Vector2i, GODOT_API_CLASS(Vector2i)); CACHE_CLASS_AND_CHECK(Vector3, GODOT_API_CLASS(Vector3)); + CACHE_CLASS_AND_CHECK(Vector3i, GODOT_API_CLASS(Vector3i)); + CACHE_CLASS_AND_CHECK(Vector4, GODOT_API_CLASS(Vector4i)); + CACHE_CLASS_AND_CHECK(Vector4i, GODOT_API_CLASS(Vector4i)); CACHE_CLASS_AND_CHECK(Basis, GODOT_API_CLASS(Basis)); CACHE_CLASS_AND_CHECK(Quaternion, GODOT_API_CLASS(Quaternion)); CACHE_CLASS_AND_CHECK(Transform, GODOT_API_CLASS(Transform)); + CACHE_CLASS_AND_CHECK(Projection, GODOT_API_CLASS(Projection)); CACHE_CLASS_AND_CHECK(AABB, GODOT_API_CLASS(AABB)); CACHE_CLASS_AND_CHECK(Color, GODOT_API_CLASS(Color)); CACHE_CLASS_AND_CHECK(Plane, GODOT_API_CLASS(Plane)); CACHE_CLASS_AND_CHECK(NodePath, GODOT_API_CLASS(NodePath)); + CACHE_CLASS_AND_CHECK(StringName, GODOT_API_CLASS(StringName)); CACHE_CLASS_AND_CHECK(RID, GODOT_API_CLASS(RID)); CACHE_CLASS_AND_CHECK(GodotObject, GODOT_API_CLASS(Object)); CACHE_CLASS_AND_CHECK(GodotResource, GODOT_API_CLASS(Resource)); @@ -263,6 +278,7 @@ void update_godot_api_cache() { CACHE_FIELD_AND_CHECK(GodotObject, ptr, CACHED_CLASS(GodotObject)->get_field(BINDINGS_PTR_FIELD)); CACHE_FIELD_AND_CHECK(NodePath, ptr, CACHED_CLASS(NodePath)->get_field(BINDINGS_PTR_FIELD)); + CACHE_FIELD_AND_CHECK(StringName, ptr, CACHED_CLASS(StringName)->get_field(BINDINGS_PTR_FIELD)); CACHE_FIELD_AND_CHECK(RID, ptr, CACHED_CLASS(RID)->get_field(BINDINGS_PTR_FIELD)); CACHE_METHOD_THUNK_AND_CHECK(GodotObject, Dispose, CACHED_CLASS(GodotObject)->get_method("Dispose", 0)); diff --git a/mono_gd/gd_mono_cache.h b/mono_gd/gd_mono_cache.h index cc1b119..f4205dd 100644 --- a/mono_gd/gd_mono_cache.h +++ b/mono_gd/gd_mono_cache.h @@ -72,17 +72,24 @@ struct CachedData { MonoClass *rawclass_Dictionary; // ----------------------------------------------- - GDMonoClass *class_Vector2; GDMonoClass *class_Rect2; + GDMonoClass *class_Rect2i; GDMonoClass *class_Transform2D; + GDMonoClass *class_Vector2; + GDMonoClass *class_Vector2i; GDMonoClass *class_Vector3; + GDMonoClass *class_Vector3i; + GDMonoClass *class_Vector4; + GDMonoClass *class_Vector4i; GDMonoClass *class_Basis; GDMonoClass *class_Quaternion; GDMonoClass *class_Transform; + GDMonoClass *class_Projection; GDMonoClass *class_AABB; GDMonoClass *class_Color; GDMonoClass *class_Plane; GDMonoClass *class_NodePath; + GDMonoClass *class_StringName; GDMonoClass *class_RID; GDMonoClass *class_GodotObject; GDMonoClass *class_GodotResource; @@ -118,6 +125,7 @@ struct CachedData { GDMonoField *field_GodotObject_ptr; GDMonoField *field_NodePath_ptr; + GDMonoField *field_StringName_ptr; GDMonoField *field_Image_ptr; GDMonoField *field_RID_ptr; diff --git a/mono_gd/gd_mono_marshal.cpp b/mono_gd/gd_mono_marshal.cpp index 60ebe3c..0c99c45 100644 --- a/mono_gd/gd_mono_marshal.cpp +++ b/mono_gd/gd_mono_marshal.cpp @@ -71,80 +71,147 @@ Variant::Type managed_to_variant_type(const ManagedType &p_type) { case MONO_TYPE_VALUETYPE: { GDMonoClass *vtclass = p_type.type_class; - if (vtclass == CACHED_CLASS(Vector2)) + if (vtclass == CACHED_CLASS(Vector2)) { return Variant::VECTOR2; + } - if (vtclass == CACHED_CLASS(Rect2)) + if (vtclass == CACHED_CLASS(Vector2i)) { + return Variant::VECTOR2I; + } + + if (vtclass == CACHED_CLASS(Rect2)) { return Variant::RECT2; + } - if (vtclass == CACHED_CLASS(Transform2D)) + if (vtclass == CACHED_CLASS(Rect2i)) { + return Variant::RECT2I; + } + + if (vtclass == CACHED_CLASS(Transform2D)) { return Variant::TRANSFORM2D; + } - if (vtclass == CACHED_CLASS(Vector3)) + if (vtclass == CACHED_CLASS(Vector3)) { return Variant::VECTOR3; + } - if (vtclass == CACHED_CLASS(Basis)) + if (vtclass == CACHED_CLASS(Vector3i)) { + return Variant::VECTOR3I; + } + + if (vtclass == CACHED_CLASS(Vector4)) { + return Variant::VECTOR4; + } + + if (vtclass == CACHED_CLASS(Vector4i)) { + return Variant::VECTOR4I; + } + + if (vtclass == CACHED_CLASS(Basis)) { return Variant::BASIS; + } - if (vtclass == CACHED_CLASS(Quaternion)) + if (vtclass == CACHED_CLASS(Quaternion)) { return Variant::QUATERNION; + } - if (vtclass == CACHED_CLASS(Transform)) + if (vtclass == CACHED_CLASS(Transform)) { return Variant::TRANSFORM; + } - if (vtclass == CACHED_CLASS(AABB)) + if (vtclass == CACHED_CLASS(Projection)) { + return Variant::PROJECTION; + } + + if (vtclass == CACHED_CLASS(AABB)) { return Variant::AABB; + } - if (vtclass == CACHED_CLASS(Color)) + if (vtclass == CACHED_CLASS(Color)) { return Variant::COLOR; + } - if (vtclass == CACHED_CLASS(Plane)) + if (vtclass == CACHED_CLASS(Plane)) { return Variant::PLANE; + } - if (mono_class_is_enum(vtclass->get_mono_ptr())) + if (mono_class_is_enum(vtclass->get_mono_ptr())) { return Variant::INT; + } } break; case MONO_TYPE_ARRAY: case MONO_TYPE_SZARRAY: { MonoClass *elem_class = mono_class_get_element_class(p_type.type_class->get_mono_ptr()); - if (elem_class == CACHED_CLASS_RAW(MonoObject)) + if (elem_class == CACHED_CLASS_RAW(MonoObject)) { return Variant::ARRAY; + } - if (elem_class == CACHED_CLASS_RAW(uint8_t)) + if (elem_class == CACHED_CLASS_RAW(uint8_t)) { return Variant::POOL_BYTE_ARRAY; + } - if (elem_class == CACHED_CLASS_RAW(int32_t)) + if (elem_class == CACHED_CLASS_RAW(int32_t)) { return Variant::POOL_INT_ARRAY; + } - if (elem_class == REAL_T_MONOCLASS) + if (elem_class == REAL_T_MONOCLASS) { return Variant::POOL_REAL_ARRAY; + } - if (elem_class == CACHED_CLASS_RAW(String)) + if (elem_class == CACHED_CLASS_RAW(String)) { return Variant::POOL_STRING_ARRAY; + } - if (elem_class == CACHED_CLASS_RAW(Vector2)) + if (elem_class == CACHED_CLASS_RAW(Vector2)) { return Variant::POOL_VECTOR2_ARRAY; + } - if (elem_class == CACHED_CLASS_RAW(Vector3)) + if (elem_class == CACHED_CLASS_RAW(Vector2i)) { + return Variant::POOL_VECTOR2I_ARRAY; + } + + if (elem_class == CACHED_CLASS_RAW(Vector3)) { return Variant::POOL_VECTOR3_ARRAY; + } - if (elem_class == CACHED_CLASS_RAW(Color)) + if (elem_class == CACHED_CLASS_RAW(Vector3i)) { + return Variant::POOL_VECTOR3I_ARRAY; + } + + if (elem_class == CACHED_CLASS_RAW(Vector4)) { + return Variant::POOL_VECTOR4_ARRAY; + } + + if (elem_class == CACHED_CLASS_RAW(Vector4i)) { + return Variant::POOL_VECTOR4I_ARRAY; + } + + if (elem_class == CACHED_CLASS_RAW(Color)) { return Variant::POOL_COLOR_ARRAY; + } - if (elem_class == CACHED_CLASS_RAW(NodePath)) + if (elem_class == CACHED_CLASS_RAW(NodePath)) { return Variant::ARRAY; + } - if (elem_class == CACHED_CLASS_RAW(RID)) + if (elem_class == CACHED_CLASS_RAW(StringName)) { return Variant::ARRAY; + } - if (mono_class_is_enum(elem_class)) + if (elem_class == CACHED_CLASS_RAW(RID)) { return Variant::ARRAY; + } + + if (mono_class_is_enum(elem_class)) { + return Variant::ARRAY; + } GDMonoClass *array_type_class = GDMono::get_singleton()->get_class(elem_class); - if (CACHED_CLASS(GodotObject)->is_assignable_from(array_type_class)) + if (CACHED_CLASS(GodotObject)->is_assignable_from(array_type_class)) { return Variant::ARRAY; + } } break; case MONO_TYPE_CLASS: { @@ -159,6 +226,10 @@ Variant::Type managed_to_variant_type(const ManagedType &p_type) { return Variant::NODE_PATH; } + if (CACHED_CLASS(StringName) == type_class) { + return Variant::STRING_NAME; + } + if (CACHED_CLASS(RID) == type_class) { return Variant::RID; } @@ -307,8 +378,9 @@ String mono_to_utf16_string(MonoString *p_mono_string) { int len = mono_string_length(p_mono_string); String ret; - if (len == 0) + if (len == 0) { return ret; + } ret.resize(len + 1); ret.set(len, 0); @@ -357,10 +429,26 @@ MonoArray *variant_to_mono_array(const Variant &p_var, GDMonoClass *p_type_class return PoolVector2Array_to_mono_array(p_var.operator PoolVector2Array()); } + if (array_type->eklass == CACHED_CLASS_RAW(Vector2i)) { + return PoolVector2iArray_to_mono_array(p_var.operator PoolVector2iArray()); + } + if (array_type->eklass == CACHED_CLASS_RAW(Vector3)) { return PoolVector3Array_to_mono_array(p_var.operator PoolVector3Array()); } + if (array_type->eklass == CACHED_CLASS_RAW(Vector3i)) { + return PoolVector3iArray_to_mono_array(p_var.operator PoolVector3iArray()); + } + + if (array_type->eklass == CACHED_CLASS_RAW(Vector4)) { + return PoolVector4Array_to_mono_array(p_var.operator PoolVector4Array()); + } + + if (array_type->eklass == CACHED_CLASS_RAW(Vector4i)) { + return PoolVector4iArray_to_mono_array(p_var.operator PoolVector4iArray()); + } + if (array_type->eklass == CACHED_CLASS_RAW(Color)) { return PoolColorArray_to_mono_array(p_var.operator PoolColorArray()); } @@ -369,6 +457,10 @@ MonoArray *variant_to_mono_array(const Variant &p_var, GDMonoClass *p_type_class return Array_to_mono_array(p_var.operator Array()); } + if (array_type->eklass == CACHED_CLASS_RAW(StringName)) { + return Array_to_mono_array(p_var.operator Array()); + } + if (array_type->eklass == CACHED_CLASS_RAW(RID)) { return Array_to_mono_array(p_var.operator Array()); } @@ -390,6 +482,10 @@ MonoObject *variant_to_mono_object_of_class(const Variant &p_var, GDMonoClass *p return GDMonoUtils::create_managed_from(p_var.operator NodePath()); } + if (CACHED_CLASS(StringName) == p_type_class) { + return GDMonoUtils::create_managed_from(p_var.operator StringName()); + } + if (CACHED_CLASS(RID) == p_type_class) { return GDMonoUtils::create_managed_from(p_var.operator ::RID()); } @@ -494,10 +590,30 @@ MonoObject *variant_to_mono_object(const Variant &p_var) { GDMonoMarshal::M_Rect2 from = MARSHALLED_OUT(Rect2, p_var.operator ::Rect2()); return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Rect2), &from); } + case Variant::VECTOR2I: { + GDMonoMarshal::M_Vector2i from = MARSHALLED_OUT(Vector2i, p_var.operator ::Vector2i()); + return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Vector2i), &from); + } + case Variant::RECT2I: { + GDMonoMarshal::M_Rect2i from = MARSHALLED_OUT(Rect2i, p_var.operator ::Rect2i()); + return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Rect2i), &from); + } case Variant::VECTOR3: { GDMonoMarshal::M_Vector3 from = MARSHALLED_OUT(Vector3, p_var.operator ::Vector3()); return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Vector3), &from); } + case Variant::VECTOR3I: { + GDMonoMarshal::M_Vector3i from = MARSHALLED_OUT(Vector3i, p_var.operator ::Vector3i()); + return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Vector3i), &from); + } + case Variant::VECTOR4: { + GDMonoMarshal::M_Vector4 from = MARSHALLED_OUT(Vector4, p_var.operator ::Vector4()); + return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Vector4), &from); + } + case Variant::VECTOR4I: { + GDMonoMarshal::M_Vector4i from = MARSHALLED_OUT(Vector4i, p_var.operator ::Vector4i()); + return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Vector4i), &from); + } case Variant::TRANSFORM2D: { GDMonoMarshal::M_Transform2D from = MARSHALLED_OUT(Transform2D, p_var.operator ::Transform2D()); return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Transform2D), &from); @@ -522,12 +638,18 @@ MonoObject *variant_to_mono_object(const Variant &p_var) { GDMonoMarshal::M_Transform from = MARSHALLED_OUT(Transform, p_var.operator ::Transform()); return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Transform), &from); } + case Variant::PROJECTION: { + GDMonoMarshal::M_Projection from = MARSHALLED_OUT(Projection, p_var.operator ::Projection()); + return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Projection), &from); + } case Variant::COLOR: { GDMonoMarshal::M_Color from = MARSHALLED_OUT(Color, p_var.operator ::Color()); return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(Color), &from); } case Variant::NODE_PATH: return GDMonoUtils::create_managed_from(p_var.operator NodePath()); + case Variant::STRING_NAME: + return GDMonoUtils::create_managed_from(p_var.operator StringName()); case Variant::RID: return GDMonoUtils::create_managed_from(p_var.operator ::RID()); case Variant::OBJECT: @@ -546,8 +668,16 @@ MonoObject *variant_to_mono_object(const Variant &p_var) { return (MonoObject *)PoolStringArray_to_mono_array(p_var.operator PoolStringArray()); case Variant::POOL_VECTOR2_ARRAY: return (MonoObject *)PoolVector2Array_to_mono_array(p_var.operator PoolVector2Array()); + case Variant::POOL_VECTOR2I_ARRAY: + return (MonoObject *)PoolVector2iArray_to_mono_array(p_var.operator PoolVector2iArray()); case Variant::POOL_VECTOR3_ARRAY: return (MonoObject *)PoolVector3Array_to_mono_array(p_var.operator PoolVector3Array()); + case Variant::POOL_VECTOR3I_ARRAY: + return (MonoObject *)PoolVector3iArray_to_mono_array(p_var.operator PoolVector3iArray()); + case Variant::POOL_VECTOR4_ARRAY: + return (MonoObject *)PoolVector4Array_to_mono_array(p_var.operator PoolVector4Array()); + case Variant::POOL_VECTOR4I_ARRAY: + return (MonoObject *)PoolVector4iArray_to_mono_array(p_var.operator PoolVector4iArray()); case Variant::POOL_COLOR_ARRAY: return (MonoObject *)PoolColorArray_to_mono_array(p_var.operator PoolColorArray()); default: @@ -597,11 +727,17 @@ size_t variant_get_managed_unboxed_size(const ManagedType &p_type) { RETURN_CHECK_FOR_STRUCT(Vector2); RETURN_CHECK_FOR_STRUCT(Rect2); + RETURN_CHECK_FOR_STRUCT(Vector2i); + RETURN_CHECK_FOR_STRUCT(Rect2i); RETURN_CHECK_FOR_STRUCT(Transform2D); RETURN_CHECK_FOR_STRUCT(Vector3); + RETURN_CHECK_FOR_STRUCT(Vector3i); + RETURN_CHECK_FOR_STRUCT(Vector4); + RETURN_CHECK_FOR_STRUCT(Vector4i); RETURN_CHECK_FOR_STRUCT(Basis); RETURN_CHECK_FOR_STRUCT(Quaternion); RETURN_CHECK_FOR_STRUCT(Transform); + RETURN_CHECK_FOR_STRUCT(Projection); RETURN_CHECK_FOR_STRUCT(AABB); RETURN_CHECK_FOR_STRUCT(Color); RETURN_CHECK_FOR_STRUCT(Plane); @@ -697,11 +833,17 @@ void *variant_to_managed_unboxed(const Variant &p_var, const ManagedType &p_type RETURN_CHECK_FOR_STRUCT(Vector2); RETURN_CHECK_FOR_STRUCT(Rect2); + RETURN_CHECK_FOR_STRUCT(Vector2i); + RETURN_CHECK_FOR_STRUCT(Rect2i); RETURN_CHECK_FOR_STRUCT(Transform2D); RETURN_CHECK_FOR_STRUCT(Vector3); + RETURN_CHECK_FOR_STRUCT(Vector3i); + RETURN_CHECK_FOR_STRUCT(Vector4); + RETURN_CHECK_FOR_STRUCT(Vector4i); RETURN_CHECK_FOR_STRUCT(Basis); RETURN_CHECK_FOR_STRUCT(Quaternion); RETURN_CHECK_FOR_STRUCT(Transform); + RETURN_CHECK_FOR_STRUCT(Projection); RETURN_CHECK_FOR_STRUCT(AABB); RETURN_CHECK_FOR_STRUCT(Color); RETURN_CHECK_FOR_STRUCT(Plane); @@ -837,11 +979,17 @@ MonoObject *variant_to_mono_object(const Variant &p_var, const ManagedType &p_ty RETURN_CHECK_FOR_STRUCT(Vector2); RETURN_CHECK_FOR_STRUCT(Rect2); + RETURN_CHECK_FOR_STRUCT(Vector2i); + RETURN_CHECK_FOR_STRUCT(Rect2i); RETURN_CHECK_FOR_STRUCT(Transform2D); RETURN_CHECK_FOR_STRUCT(Vector3); + RETURN_CHECK_FOR_STRUCT(Vector3i); + RETURN_CHECK_FOR_STRUCT(Vector4); + RETURN_CHECK_FOR_STRUCT(Vector4i); RETURN_CHECK_FOR_STRUCT(Basis); RETURN_CHECK_FOR_STRUCT(Quaternion); RETURN_CHECK_FOR_STRUCT(Transform); + RETURN_CHECK_FOR_STRUCT(Projection); RETURN_CHECK_FOR_STRUCT(AABB); RETURN_CHECK_FOR_STRUCT(Color); RETURN_CHECK_FOR_STRUCT(Plane); @@ -951,38 +1099,73 @@ Variant mono_object_to_variant_impl(MonoObject *p_obj, const ManagedType &p_type case MONO_TYPE_VALUETYPE: { GDMonoClass *vtclass = p_type.type_class; - if (vtclass == CACHED_CLASS(Vector2)) + if (vtclass == CACHED_CLASS(Vector2)) { return MARSHALLED_IN(Vector2, unbox_addr(p_obj)); + } - if (vtclass == CACHED_CLASS(Rect2)) + if (vtclass == CACHED_CLASS(Rect2)) { return MARSHALLED_IN(Rect2, unbox_addr(p_obj)); + } - if (vtclass == CACHED_CLASS(Transform2D)) + if (vtclass == CACHED_CLASS(Vector2i)) { + return MARSHALLED_IN(Vector2i, unbox_addr(p_obj)); + } + + if (vtclass == CACHED_CLASS(Rect2i)) { + return MARSHALLED_IN(Rect2i, unbox_addr(p_obj)); + } + + if (vtclass == CACHED_CLASS(Transform2D)) { return MARSHALLED_IN(Transform2D, unbox_addr(p_obj)); + } - if (vtclass == CACHED_CLASS(Vector3)) + if (vtclass == CACHED_CLASS(Vector3)) { return MARSHALLED_IN(Vector3, unbox_addr(p_obj)); + } - if (vtclass == CACHED_CLASS(Basis)) + if (vtclass == CACHED_CLASS(Vector3i)) { + return MARSHALLED_IN(Vector3i, unbox_addr(p_obj)); + } + + if (vtclass == CACHED_CLASS(Vector4)) { + return MARSHALLED_IN(Vector4, unbox_addr(p_obj)); + } + + if (vtclass == CACHED_CLASS(Vector4i)) { + return MARSHALLED_IN(Vector4i, unbox_addr(p_obj)); + } + + if (vtclass == CACHED_CLASS(Basis)) { return MARSHALLED_IN(Basis, unbox_addr(p_obj)); + } - if (vtclass == CACHED_CLASS(Quaternion)) + if (vtclass == CACHED_CLASS(Quaternion)) { return MARSHALLED_IN(Quaternion, unbox_addr(p_obj)); + } - if (vtclass == CACHED_CLASS(Transform)) + if (vtclass == CACHED_CLASS(Transform)) { return MARSHALLED_IN(Transform, unbox_addr(p_obj)); + } - if (vtclass == CACHED_CLASS(AABB)) + if (vtclass == CACHED_CLASS(Projection)) { + return MARSHALLED_IN(Projection, unbox_addr(p_obj)); + } + + if (vtclass == CACHED_CLASS(AABB)) { return MARSHALLED_IN(AABB, unbox_addr(p_obj)); + } - if (vtclass == CACHED_CLASS(Color)) + if (vtclass == CACHED_CLASS(Color)) { return MARSHALLED_IN(Color, unbox_addr(p_obj)); + } - if (vtclass == CACHED_CLASS(Plane)) + if (vtclass == CACHED_CLASS(Plane)) { return MARSHALLED_IN(Plane, unbox_addr(p_obj)); + } - if (mono_class_is_enum(vtclass->get_mono_ptr())) + if (mono_class_is_enum(vtclass->get_mono_ptr())) { return unbox(p_obj); + } } break; case MONO_TYPE_STRING: { if (p_obj == NULL) { @@ -994,39 +1177,70 @@ Variant mono_object_to_variant_impl(MonoObject *p_obj, const ManagedType &p_type case MONO_TYPE_SZARRAY: { MonoArrayType *array_type = mono_type_get_array_type(p_type.type_class->get_mono_type()); - if (array_type->eklass == CACHED_CLASS_RAW(MonoObject)) + if (array_type->eklass == CACHED_CLASS_RAW(MonoObject)) { return mono_array_to_Array((MonoArray *)p_obj); + } - if (array_type->eklass == CACHED_CLASS_RAW(uint8_t)) + if (array_type->eklass == CACHED_CLASS_RAW(uint8_t)) { return mono_array_to_PoolByteArray((MonoArray *)p_obj); + } - if (array_type->eklass == CACHED_CLASS_RAW(int32_t)) + if (array_type->eklass == CACHED_CLASS_RAW(int32_t)) { return mono_array_to_PoolIntArray((MonoArray *)p_obj); + } - if (array_type->eklass == REAL_T_MONOCLASS) + if (array_type->eklass == REAL_T_MONOCLASS) { return mono_array_to_PoolRealArray((MonoArray *)p_obj); + } - if (array_type->eklass == CACHED_CLASS_RAW(String)) + if (array_type->eklass == CACHED_CLASS_RAW(String)) { return mono_array_to_PoolStringArray((MonoArray *)p_obj); + } - if (array_type->eklass == CACHED_CLASS_RAW(Vector2)) + if (array_type->eklass == CACHED_CLASS_RAW(Vector2)) { return mono_array_to_PoolVector2Array((MonoArray *)p_obj); + } - if (array_type->eklass == CACHED_CLASS_RAW(Vector3)) + if (array_type->eklass == CACHED_CLASS_RAW(Vector2i)) { + return mono_array_to_PoolVector2iArray((MonoArray *)p_obj); + } + + if (array_type->eklass == CACHED_CLASS_RAW(Vector3)) { return mono_array_to_PoolVector3Array((MonoArray *)p_obj); + } - if (array_type->eklass == CACHED_CLASS_RAW(Color)) + if (array_type->eklass == CACHED_CLASS_RAW(Vector3i)) { + return mono_array_to_PoolVector3iArray((MonoArray *)p_obj); + } + + if (array_type->eklass == CACHED_CLASS_RAW(Vector4)) { + return mono_array_to_PoolVector4Array((MonoArray *)p_obj); + } + + if (array_type->eklass == CACHED_CLASS_RAW(Vector4i)) { + return mono_array_to_PoolVector4iArray((MonoArray *)p_obj); + } + + if (array_type->eklass == CACHED_CLASS_RAW(Color)) { return mono_array_to_PoolColorArray((MonoArray *)p_obj); + } - if (array_type->eklass == CACHED_CLASS_RAW(NodePath)) + if (array_type->eklass == CACHED_CLASS_RAW(NodePath)) { return mono_array_to_Array((MonoArray *)p_obj); + } - if (array_type->eklass == CACHED_CLASS_RAW(RID)) + if (array_type->eklass == CACHED_CLASS_RAW(StringName)) { return mono_array_to_Array((MonoArray *)p_obj); + } + + if (array_type->eklass == CACHED_CLASS_RAW(RID)) { + return mono_array_to_Array((MonoArray *)p_obj); + } GDMonoClass *array_type_class = GDMono::get_singleton()->get_class(array_type->eklass); - if (CACHED_CLASS(GodotObject)->is_assignable_from(array_type_class)) + if (CACHED_CLASS(GodotObject)->is_assignable_from(array_type_class)) { return mono_array_to_Array((MonoArray *)p_obj); + } if (p_fail_with_err) { ERR_FAIL_V_MSG(Variant(), "Attempted to convert a managed array of unmarshallable element type to Variant."); @@ -1052,6 +1266,11 @@ Variant mono_object_to_variant_impl(MonoObject *p_obj, const ManagedType &p_type return ptr ? Variant(*ptr) : Variant(); } + if (CACHED_CLASS(StringName) == type_class) { + StringName *ptr = unbox(CACHED_FIELD(StringName, ptr)->get_value(p_obj)); + return ptr ? Variant(*ptr) : Variant(); + } + if (CACHED_CLASS(RID) == type_class) { RID *ptr = unbox(CACHED_FIELD(RID, ptr)->get_value(p_obj)); return ptr ? Variant(*ptr) : Variant(); @@ -1128,8 +1347,9 @@ Variant mono_object_to_variant_impl(MonoObject *p_obj, const ManagedType &p_type } Variant mono_object_to_variant(MonoObject *p_obj) { - if (!p_obj) + if (!p_obj) { return Variant(); + } ManagedType type = ManagedType::from_class(mono_object_get_class(p_obj)); @@ -1137,15 +1357,17 @@ Variant mono_object_to_variant(MonoObject *p_obj) { } Variant mono_object_to_variant(MonoObject *p_obj, const ManagedType &p_type) { - if (!p_obj) + if (!p_obj) { return Variant(); + } return mono_object_to_variant_impl(p_obj, p_type); } Variant mono_object_to_variant_no_err(MonoObject *p_obj, const ManagedType &p_type) { - if (!p_obj) + if (!p_obj) { return Variant(); + } return mono_object_to_variant_impl(p_obj, p_type, /* fail_with_err: */ false); } @@ -1164,8 +1386,9 @@ String mono_object_to_variant_string(MonoObject *p_obj, MonoException **r_exc) { MonoString *mono_str = GDMonoUtils::object_to_string(p_obj, &exc); if (exc) { - if (r_exc) + if (r_exc) { *r_exc = exc; + } return String(); } @@ -1285,8 +1508,9 @@ MonoArray *Array_to_mono_array(const Array &p_array, MonoClass *p_array_type_cla Array mono_array_to_Array(MonoArray *p_array) { Array ret; - if (!p_array) + if (!p_array) { return ret; + } int length = mono_array_length(p_array); ret.resize(length); @@ -1314,8 +1538,9 @@ MonoArray *PoolIntArray_to_mono_array(const PoolIntArray &p_array) { PoolIntArray mono_array_to_PoolIntArray(MonoArray *p_array) { PoolIntArray ret; - if (!p_array) + if (!p_array) { return ret; + } int length = mono_array_length(p_array); ret.resize(length); PoolIntArray::Write w = ret.write(); @@ -1341,8 +1566,9 @@ MonoArray *PoolByteArray_to_mono_array(const PoolByteArray &p_array) { PoolByteArray mono_array_to_PoolByteArray(MonoArray *p_array) { PoolByteArray ret; - if (!p_array) + if (!p_array) { return ret; + } int length = mono_array_length(p_array); ret.resize(length); PoolByteArray::Write w = ret.write(); @@ -1368,8 +1594,9 @@ MonoArray *PoolRealArray_to_mono_array(const PoolRealArray &p_array) { PoolRealArray mono_array_to_PoolRealArray(MonoArray *p_array) { PoolRealArray ret; - if (!p_array) + if (!p_array) { return ret; + } int length = mono_array_length(p_array); ret.resize(length); PoolRealArray::Write w = ret.write(); @@ -1396,8 +1623,9 @@ MonoArray *PoolStringArray_to_mono_array(const PoolStringArray &p_array) { PoolStringArray mono_array_to_PoolStringArray(MonoArray *p_array) { PoolStringArray ret; - if (!p_array) + if (!p_array) { return ret; + } int length = mono_array_length(p_array); ret.resize(length); PoolStringArray::Write w = ret.write(); @@ -1425,8 +1653,9 @@ MonoArray *PoolColorArray_to_mono_array(const PoolColorArray &p_array) { PoolColorArray mono_array_to_PoolColorArray(MonoArray *p_array) { PoolColorArray ret; - if (!p_array) + if (!p_array) { return ret; + } int length = mono_array_length(p_array); ret.resize(length); PoolColorArray::Write w = ret.write(); @@ -1453,8 +1682,9 @@ MonoArray *PoolVector2Array_to_mono_array(const PoolVector2Array &p_array) { PoolVector2Array mono_array_to_PoolVector2Array(MonoArray *p_array) { PoolVector2Array ret; - if (!p_array) + if (!p_array) { return ret; + } int length = mono_array_length(p_array); ret.resize(length); PoolVector2Array::Write w = ret.write(); @@ -1466,6 +1696,35 @@ PoolVector2Array mono_array_to_PoolVector2Array(MonoArray *p_array) { return ret; } +MonoArray *PoolVector2iArray_to_mono_array(const PoolVector2iArray &p_array) { + PoolVector2iArray::Read r = p_array.read(); + + MonoArray *ret = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(Vector2i), p_array.size()); + + for (int i = 0; i < p_array.size(); i++) { + M_Vector2i *raw = (M_Vector2i *)mono_array_addr_with_size(ret, sizeof(M_Vector2i), i); + *raw = MARSHALLED_OUT(Vector2i, r[i]); + } + + return ret; +} + +PoolVector2iArray mono_array_to_PoolVector2iArray(MonoArray *p_array) { + PoolVector2iArray ret; + if (!p_array) { + return ret; + } + int length = mono_array_length(p_array); + ret.resize(length); + PoolVector2iArray::Write w = ret.write(); + + for (int i = 0; i < length; i++) { + w[i] = MARSHALLED_IN(Vector2i, (M_Vector2i *)mono_array_addr_with_size(p_array, sizeof(M_Vector2i), i)); + } + + return ret; +} + MonoArray *PoolVector3Array_to_mono_array(const PoolVector3Array &p_array) { PoolVector3Array::Read r = p_array.read(); @@ -1481,8 +1740,9 @@ MonoArray *PoolVector3Array_to_mono_array(const PoolVector3Array &p_array) { PoolVector3Array mono_array_to_PoolVector3Array(MonoArray *p_array) { PoolVector3Array ret; - if (!p_array) + if (!p_array) { return ret; + } int length = mono_array_length(p_array); ret.resize(length); PoolVector3Array::Write w = ret.write(); @@ -1494,4 +1754,91 @@ PoolVector3Array mono_array_to_PoolVector3Array(MonoArray *p_array) { return ret; } +MonoArray *PoolVector3iArray_to_mono_array(const PoolVector3iArray &p_array) { + PoolVector3iArray::Read r = p_array.read(); + + MonoArray *ret = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(Vector3i), p_array.size()); + + for (int i = 0; i < p_array.size(); i++) { + M_Vector3i *raw = (M_Vector3i *)mono_array_addr_with_size(ret, sizeof(M_Vector3i), i); + *raw = MARSHALLED_OUT(Vector3i, r[i]); + } + + return ret; +} + +PoolVector3iArray mono_array_to_PoolVector3iArray(MonoArray *p_array) { + PoolVector3iArray ret; + if (!p_array) { + return ret; + } + int length = mono_array_length(p_array); + ret.resize(length); + PoolVector3iArray::Write w = ret.write(); + + for (int i = 0; i < length; i++) { + w[i] = MARSHALLED_IN(Vector3i, (M_Vector3i *)mono_array_addr_with_size(p_array, sizeof(M_Vector3i), i)); + } + + return ret; +} + +MonoArray *PoolVector4Array_to_mono_array(const PoolVector4Array &p_array) { + PoolVector4Array::Read r = p_array.read(); + + MonoArray *ret = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(Vector4), p_array.size()); + + for (int i = 0; i < p_array.size(); i++) { + M_Vector4 *raw = (M_Vector4 *)mono_array_addr_with_size(ret, sizeof(M_Vector4), i); + *raw = MARSHALLED_OUT(Vector4, r[i]); + } + + return ret; +} + +PoolVector4Array mono_array_to_PoolVector4Array(MonoArray *p_array) { + PoolVector4Array ret; + if (!p_array) { + return ret; + } + int length = mono_array_length(p_array); + ret.resize(length); + PoolVector4Array::Write w = ret.write(); + + for (int i = 0; i < length; i++) { + w[i] = MARSHALLED_IN(Vector4, (M_Vector4 *)mono_array_addr_with_size(p_array, sizeof(M_Vector4), i)); + } + + return ret; +} + +MonoArray *PoolVector4iArray_to_mono_array(const PoolVector4iArray &p_array) { + PoolVector4iArray::Read r = p_array.read(); + + MonoArray *ret = mono_array_new(mono_domain_get(), CACHED_CLASS_RAW(Vector4i), p_array.size()); + + for (int i = 0; i < p_array.size(); i++) { + M_Vector4i *raw = (M_Vector4i *)mono_array_addr_with_size(ret, sizeof(M_Vector4i), i); + *raw = MARSHALLED_OUT(Vector4i, r[i]); + } + + return ret; +} + +PoolVector4iArray mono_array_to_PoolVector4iArray(MonoArray *p_array) { + PoolVector4iArray ret; + if (!p_array) { + return ret; + } + int length = mono_array_length(p_array); + ret.resize(length); + PoolVector4iArray::Write w = ret.write(); + + for (int i = 0; i < length; i++) { + w[i] = MARSHALLED_IN(Vector4i, (M_Vector4i *)mono_array_addr_with_size(p_array, sizeof(M_Vector4i), i)); + } + + return ret; +} + } // namespace GDMonoMarshal diff --git a/mono_gd/gd_mono_marshal.h b/mono_gd/gd_mono_marshal.h index 432668d..89be3d8 100644 --- a/mono_gd/gd_mono_marshal.h +++ b/mono_gd/gd_mono_marshal.h @@ -191,16 +191,38 @@ PoolColorArray mono_array_to_PoolColorArray(MonoArray *p_array); MonoArray *PoolVector2Array_to_mono_array(const PoolVector2Array &p_array); PoolVector2Array mono_array_to_PoolVector2Array(MonoArray *p_array); +// PoolVector2iArray + +MonoArray *PoolVector2iArray_to_mono_array(const PoolVector2iArray &p_array); +PoolVector2iArray mono_array_to_PoolVector2iArray(MonoArray *p_array); + // PoolVector3Array MonoArray *PoolVector3Array_to_mono_array(const PoolVector3Array &p_array); PoolVector3Array mono_array_to_PoolVector3Array(MonoArray *p_array); +// PoolVector3iArray + +MonoArray *PoolVector3iArray_to_mono_array(const PoolVector3iArray &p_array); +PoolVector3iArray mono_array_to_PoolVector3iArray(MonoArray *p_array); + +// PoolVector4Array + +MonoArray *PoolVector4Array_to_mono_array(const PoolVector4Array &p_array); +PoolVector4Array mono_array_to_PoolVector4Array(MonoArray *p_array); + +// PoolVector4iArray + +MonoArray *PoolVector4iArray_to_mono_array(const PoolVector4iArray &p_array); +PoolVector4iArray mono_array_to_PoolVector4iArray(MonoArray *p_array); + // Structures namespace InteropLayout { enum { + MATCHES_int = (sizeof(int) == sizeof(int32_t)), + MATCHES_float = (sizeof(float) == sizeof(uint32_t)), MATCHES_double = (sizeof(double) == sizeof(uint64_t)), @@ -219,6 +241,14 @@ enum { offsetof(Rect2, position) == (sizeof(Vector2) * 0) && offsetof(Rect2, size) == (sizeof(Vector2) * 1)), + MATCHES_Vector2i = (MATCHES_int && (sizeof(Vector2i) == (sizeof(int32_t) * 2)) && + offsetof(Vector2i, x) == (sizeof(int32_t) * 0) && + offsetof(Vector2i, y) == (sizeof(int32_t) * 1)), + + MATCHES_Rect2i = (MATCHES_Vector2i && (sizeof(Rect2i) == (sizeof(Vector2i) * 2)) && + offsetof(Rect2i, position) == (sizeof(Vector2i) * 0) && + offsetof(Rect2i, size) == (sizeof(Vector2i) * 1)), + MATCHES_Transform2D = (MATCHES_Vector2 && (sizeof(Transform2D) == (sizeof(Vector2) * 3))), // No field offset required, it stores an array MATCHES_Vector3 = (MATCHES_real_t && (sizeof(Vector3) == (sizeof(real_t) * 3)) && @@ -226,8 +256,27 @@ enum { offsetof(Vector3, y) == (sizeof(real_t) * 1) && offsetof(Vector3, z) == (sizeof(real_t) * 2)), + MATCHES_Vector3i = (MATCHES_int && (sizeof(Vector3i) == (sizeof(int32_t) * 3)) && + offsetof(Vector3i, x) == (sizeof(int32_t) * 0) && + offsetof(Vector3i, y) == (sizeof(int32_t) * 1) && + offsetof(Vector3i, z) == (sizeof(int32_t) * 2)), + + MATCHES_Vector4 = (MATCHES_real_t && (sizeof(Vector4) == (sizeof(real_t) * 4)) && + offsetof(Vector4, x) == (sizeof(real_t) * 0) && + offsetof(Vector4, y) == (sizeof(real_t) * 1) && + offsetof(Vector4, z) == (sizeof(real_t) * 2) && + offsetof(Vector4, w) == (sizeof(real_t) * 2)), + + MATCHES_Vector4i = (MATCHES_int && (sizeof(Vector4i) == (sizeof(int32_t) * 4)) && + offsetof(Vector4i, x) == (sizeof(int32_t) * 0) && + offsetof(Vector4i, y) == (sizeof(int32_t) * 1) && + offsetof(Vector4i, z) == (sizeof(int32_t) * 2) && + offsetof(Vector4i, w) == (sizeof(int32_t) * 2)), + MATCHES_Basis = (MATCHES_Vector3 && (sizeof(Basis) == (sizeof(Vector3) * 3))), // No field offset required, it stores an array + MATCHES_Projection = (MATCHES_Vector4 && (sizeof(Projection) == (sizeof(Vector4) * 4))), // No field offset required, it stores an array + MATCHES_Quaternion = (MATCHES_real_t && (sizeof(Quaternion) == (sizeof(real_t) * 4)) && offsetof(Quaternion, x) == (sizeof(real_t) * 0) && offsetof(Quaternion, y) == (sizeof(real_t) * 1) && @@ -293,6 +342,34 @@ struct M_Rect2 { } }; +struct M_Vector2i { + int32_t x, y; + + static _FORCE_INLINE_ Vector2i convert_to(const M_Vector2i &p_from) { + return Vector2(p_from.x, p_from.y); + } + + static _FORCE_INLINE_ M_Vector2i convert_from(const Vector2i &p_from) { + M_Vector2i ret = { p_from.x, p_from.y }; + return ret; + } +}; + +struct M_Rect2i { + M_Vector2i position; + M_Vector2i size; + + static _FORCE_INLINE_ Rect2i convert_to(const M_Rect2i &p_from) { + return Rect2i(M_Vector2i::convert_to(p_from.position), + M_Vector2i::convert_to(p_from.size)); + } + + static _FORCE_INLINE_ M_Rect2i convert_from(const Rect2i &p_from) { + M_Rect2i ret = { M_Vector2i::convert_from(p_from.position), M_Vector2i::convert_from(p_from.size) }; + return ret; + } +}; + struct M_Transform2D { M_Vector2 columns[3]; @@ -325,6 +402,45 @@ struct M_Vector3 { } }; +struct M_Vector3i { + int32_t x, y, z; + + static _FORCE_INLINE_ Vector3i convert_to(const M_Vector3i &p_from) { + return Vector3i(p_from.x, p_from.y, p_from.z); + } + + static _FORCE_INLINE_ M_Vector3i convert_from(const Vector3i &p_from) { + M_Vector3i ret = { p_from.x, p_from.y, p_from.z }; + return ret; + } +}; + +struct M_Vector4 { + real_t x, y, z, w; + + static _FORCE_INLINE_ Vector4 convert_to(const M_Vector4 &p_from) { + return Vector4(p_from.x, p_from.y, p_from.z, p_from.w); + } + + static _FORCE_INLINE_ M_Vector4 convert_from(const Vector4 &p_from) { + M_Vector4 ret = { p_from.x, p_from.y, p_from.z, p_from.w }; + return ret; + } +}; + +struct M_Vector4i { + int32_t x, y, z, w; + + static _FORCE_INLINE_ Vector4i convert_to(const M_Vector4i &p_from) { + return Vector4i(p_from.x, p_from.y, p_from.z, p_from.w); + } + + static _FORCE_INLINE_ M_Vector4i convert_from(const Vector4i &p_from) { + M_Vector4i ret = { p_from.x, p_from.y, p_from.z, p_from.w }; + return ret; + } +}; + struct M_Basis { M_Vector3 rows[3]; @@ -344,6 +460,28 @@ struct M_Basis { } }; +struct M_Projection { + M_Vector4 matrix[4]; + + static _FORCE_INLINE_ Projection convert_to(const M_Projection &p_from) { + return Projection(M_Vector4::convert_to(p_from.matrix[0]), + M_Vector4::convert_to(p_from.matrix[1]), + M_Vector4::convert_to(p_from.matrix[2]), + M_Vector4::convert_to(p_from.matrix[3]) + ); + } + + static _FORCE_INLINE_ M_Projection convert_from(const Projection &p_from) { + M_Projection ret = { + M_Vector4::convert_from(p_from.matrix[0]), + M_Vector4::convert_from(p_from.matrix[1]), + M_Vector4::convert_from(p_from.matrix[2]), + M_Vector4::convert_from(p_from.matrix[3]) + }; + return ret; + } +}; + struct M_Quaternion { real_t x, y, z, w; @@ -449,13 +587,19 @@ struct M_Plane { return marshalled_out_##m_type##_impl(p_from); \ } -DECL_TYPE_MARSHAL_TEMPLATES(Vector2) DECL_TYPE_MARSHAL_TEMPLATES(Rect2) +DECL_TYPE_MARSHAL_TEMPLATES(Rect2i) DECL_TYPE_MARSHAL_TEMPLATES(Transform2D) +DECL_TYPE_MARSHAL_TEMPLATES(Vector2) +DECL_TYPE_MARSHAL_TEMPLATES(Vector2i) DECL_TYPE_MARSHAL_TEMPLATES(Vector3) +DECL_TYPE_MARSHAL_TEMPLATES(Vector3i) +DECL_TYPE_MARSHAL_TEMPLATES(Vector4) +DECL_TYPE_MARSHAL_TEMPLATES(Vector4i) DECL_TYPE_MARSHAL_TEMPLATES(Basis) DECL_TYPE_MARSHAL_TEMPLATES(Quaternion) DECL_TYPE_MARSHAL_TEMPLATES(Transform) +DECL_TYPE_MARSHAL_TEMPLATES(Projection) DECL_TYPE_MARSHAL_TEMPLATES(AABB) DECL_TYPE_MARSHAL_TEMPLATES(Color) DECL_TYPE_MARSHAL_TEMPLATES(Plane) diff --git a/mono_gd/gd_mono_method.cpp b/mono_gd/gd_mono_method.cpp index 4b344fe..b5b2729 100644 --- a/mono_gd/gd_mono_method.cpp +++ b/mono_gd/gd_mono_method.cpp @@ -160,11 +160,13 @@ MonoObject *GDMonoMethod::invoke_raw(MonoObject *p_object, void **p_params, Mono bool GDMonoMethod::has_attribute(GDMonoClass *p_attr_class) { ERR_FAIL_NULL_V(p_attr_class, false); - if (!attrs_fetched) + if (!attrs_fetched) { fetch_attributes(); + } - if (!attributes) + if (!attributes) { return false; + } return mono_custom_attrs_has_attr(attributes, p_attr_class->get_mono_ptr()); } @@ -172,11 +174,13 @@ bool GDMonoMethod::has_attribute(GDMonoClass *p_attr_class) { MonoObject *GDMonoMethod::get_attribute(GDMonoClass *p_attr_class) { ERR_FAIL_NULL_V(p_attr_class, NULL); - if (!attrs_fetched) + if (!attrs_fetched) { fetch_attributes(); + } - if (!attributes) + if (!attributes) { return NULL; + } return mono_custom_attrs_get_attr(attributes, p_attr_class->get_mono_ptr()); } diff --git a/mono_gd/gd_mono_utils.cpp b/mono_gd/gd_mono_utils.cpp index 50da6a4..6faa27d 100644 --- a/mono_gd/gd_mono_utils.cpp +++ b/mono_gd/gd_mono_utils.cpp @@ -234,6 +234,18 @@ MonoObject *create_managed_from(const NodePath &p_from) { return mono_object; } +MonoObject *create_managed_from(const StringName &p_from) { + MonoObject *mono_object = mono_object_new(mono_domain_get(), CACHED_CLASS_RAW(StringName)); + ERR_FAIL_NULL_V(mono_object, NULL); + + // Construct + GDMonoUtils::runtime_object_init(mono_object, CACHED_CLASS(StringName)); + + CACHED_FIELD(StringName, ptr)->set_value_raw(mono_object, memnew(StringName(p_from))); + + return mono_object; +} + MonoObject *create_managed_from(const RID &p_from) { MonoObject *mono_object = mono_object_new(mono_domain_get(), CACHED_CLASS_RAW(RID)); ERR_FAIL_NULL_V(mono_object, NULL); diff --git a/mono_gd/gd_mono_utils.h b/mono_gd/gd_mono_utils.h index f4059b9..1257b47 100644 --- a/mono_gd/gd_mono_utils.h +++ b/mono_gd/gd_mono_utils.h @@ -104,6 +104,7 @@ GDMonoClass *get_class_native_base(GDMonoClass *p_class); MonoObject *create_managed_for_godot_object(GDMonoClass *p_class, const StringName &p_native, Object *p_object); MonoObject *create_managed_from(const NodePath &p_from); +MonoObject *create_managed_from(const StringName &p_from); MonoObject *create_managed_from(const RID &p_from); MonoObject *create_managed_from(const Array &p_from, GDMonoClass *p_class); MonoObject *create_managed_from(const Dictionary &p_from, GDMonoClass *p_class);