Added the new Variant types to (hoipefully all) glue code.

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"

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"
 

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"

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"

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"
 

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<Resource>(p_from);

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"
 

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));

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;
 

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<GDMonoMarshal::M_Vector2>(p_obj));
+			}
 
-			if (vtclass == CACHED_CLASS(Rect2))
+			if (vtclass == CACHED_CLASS(Rect2)) {
 				return MARSHALLED_IN(Rect2, unbox_addr<GDMonoMarshal::M_Rect2>(p_obj));
+			}
 
-			if (vtclass == CACHED_CLASS(Transform2D))
+			if (vtclass == CACHED_CLASS(Vector2i)) {
+				return MARSHALLED_IN(Vector2i, unbox_addr<GDMonoMarshal::M_Vector2i>(p_obj));
+			}
+
+			if (vtclass == CACHED_CLASS(Rect2i)) {
+				return MARSHALLED_IN(Rect2i, unbox_addr<GDMonoMarshal::M_Rect2i>(p_obj));
+			}
+
+			if (vtclass == CACHED_CLASS(Transform2D)) {
 				return MARSHALLED_IN(Transform2D, unbox_addr<GDMonoMarshal::M_Transform2D>(p_obj));
+			}
 
-			if (vtclass == CACHED_CLASS(Vector3))
+			if (vtclass == CACHED_CLASS(Vector3)) {
 				return MARSHALLED_IN(Vector3, unbox_addr<GDMonoMarshal::M_Vector3>(p_obj));
+			}
 
-			if (vtclass == CACHED_CLASS(Basis))
+			if (vtclass == CACHED_CLASS(Vector3i)) {
+				return MARSHALLED_IN(Vector3i, unbox_addr<GDMonoMarshal::M_Vector3i>(p_obj));
+			}
+
+			if (vtclass == CACHED_CLASS(Vector4)) {
+				return MARSHALLED_IN(Vector4, unbox_addr<GDMonoMarshal::M_Vector4>(p_obj));
+			}
+
+			if (vtclass == CACHED_CLASS(Vector4i)) {
+				return MARSHALLED_IN(Vector4i, unbox_addr<GDMonoMarshal::M_Vector4i>(p_obj));
+			}
+
+			if (vtclass == CACHED_CLASS(Basis)) {
 				return MARSHALLED_IN(Basis, unbox_addr<GDMonoMarshal::M_Basis>(p_obj));
+			}
 
-			if (vtclass == CACHED_CLASS(Quaternion))
+			if (vtclass == CACHED_CLASS(Quaternion)) {
 				return MARSHALLED_IN(Quaternion, unbox_addr<GDMonoMarshal::M_Quaternion>(p_obj));
+			}
 
-			if (vtclass == CACHED_CLASS(Transform))
+			if (vtclass == CACHED_CLASS(Transform)) {
 				return MARSHALLED_IN(Transform, unbox_addr<GDMonoMarshal::M_Transform>(p_obj));
+			}
 
-			if (vtclass == CACHED_CLASS(AABB))
+			if (vtclass == CACHED_CLASS(Projection)) {
+				return MARSHALLED_IN(Projection, unbox_addr<GDMonoMarshal::M_Projection>(p_obj));
+			}
+
+			if (vtclass == CACHED_CLASS(AABB)) {
 				return MARSHALLED_IN(AABB, unbox_addr<GDMonoMarshal::M_AABB>(p_obj));
+			}
 
-			if (vtclass == CACHED_CLASS(Color))
+			if (vtclass == CACHED_CLASS(Color)) {
 				return MARSHALLED_IN(Color, unbox_addr<GDMonoMarshal::M_Color>(p_obj));
+			}
 
-			if (vtclass == CACHED_CLASS(Plane))
+			if (vtclass == CACHED_CLASS(Plane)) {
 				return MARSHALLED_IN(Plane, unbox_addr<GDMonoMarshal::M_Plane>(p_obj));
+			}
 
-			if (mono_class_is_enum(vtclass->get_mono_ptr()))
+			if (mono_class_is_enum(vtclass->get_mono_ptr())) {
 				return unbox<int32_t>(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<StringName *>(CACHED_FIELD(StringName, ptr)->get_value(p_obj));
+				return ptr ? Variant(*ptr) : Variant();
+			}
+
 			if (CACHED_CLASS(RID) == type_class) {
 				RID *ptr = unbox<RID *>(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

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<InteropLayout::MATCHES_##m_type>(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)

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());
 }

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);

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);