Fixed IntPtr unboxing (#11949)

- Fix boolean never reset to false
- Fix IntPtr unboxing and cleanup

modules/mono/csharp_script.cpp

@@ -782,7 +782,7 @@ bool CSharpInstance::set(const StringName &p_name, const Variant &p_value) {
 		if (method) {
 			MonoObject *ret = method->invoke(mono_object, args);
 
-			if (ret && UNBOX_BOOLEAN(ret))
+			if (ret && GDMonoMarshal::unbox<MonoBoolean>(ret) == true)
 				return true;
 		}
 

modules/mono/mono_gd/gd_mono_assembly.cpp

@@ -52,12 +52,12 @@ MonoAssembly *GDMonoAssembly::_search_hook(MonoAssemblyName *aname, void *user_d
 	if (no_search)
 		return NULL;
 
-	no_search = true; // Avoid the recursion madness
-
 	GDMonoAssembly **loaded_asm = GDMono::get_singleton()->get_loaded_assembly(has_extension ? name.get_basename() : name);
 	if (loaded_asm)
 		return (*loaded_asm)->get_assembly();
 
+	no_search = true; // Avoid the recursion madness
+
 	String path;
 	MonoAssembly *res = NULL;
 

modules/mono/mono_gd/gd_mono_field.cpp

@@ -279,11 +279,11 @@ void GDMonoField::set_value(MonoObject *p_object, const Variant &p_value) {
 }
 
 bool GDMonoField::get_bool_value(MonoObject *p_object) {
-	return UNBOX_BOOLEAN(get_value(p_object));
+	return (bool)GDMonoMarshal::unbox<MonoBoolean>(get_value(p_object));
 }
 
 int GDMonoField::get_int_value(MonoObject *p_object) {
-	return UNBOX_INT32(get_value(p_object));
+	return GDMonoMarshal::unbox<int32_t>(get_value(p_object));
 }
 
 String GDMonoField::get_string_value(MonoObject *p_object) {

modules/mono/mono_gd/gd_mono_marshal.cpp

@@ -41,11 +41,11 @@ namespace GDMonoMarshal {
 		return mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(m_t), raw); \
 	}
 
-#define RETURN_UNBOXED_STRUCT(m_t, m_var_in)    \
+#define RETURN_UNBOXED_STRUCT(m_t, m_var_in)               \
-	{                                           \
+	{                                                      \
-		float *raw = UNBOX_FLOAT_PTR(m_var_in); \
+		float *raw = (float *)mono_object_unbox(m_var_in); \
-		MARSHALLED_IN(m_t, raw, ret);           \
+		MARSHALLED_IN(m_t, raw, ret);                      \
-		return ret;                             \
+		return ret;                                        \
 	}
 
 Variant::Type managed_to_variant_type(const ManagedType &p_type) {
@@ -453,30 +453,30 @@ Variant mono_object_to_variant(MonoObject *p_obj) {
 Variant mono_object_to_variant(MonoObject *p_obj, const ManagedType &p_type) {
 	switch (p_type.type_encoding) {
 		case MONO_TYPE_BOOLEAN:
-			return (bool)UNBOX_BOOLEAN(p_obj);
+			return (bool)unbox<MonoBoolean>(p_obj);
 
 		case MONO_TYPE_I1:
-			return UNBOX_INT8(p_obj);
+			return unbox<int8_t>(p_obj);
 		case MONO_TYPE_I2:
-			return UNBOX_INT16(p_obj);
+			return unbox<int16_t>(p_obj);
 		case MONO_TYPE_I4:
-			return UNBOX_INT32(p_obj);
+			return unbox<int32_t>(p_obj);
 		case MONO_TYPE_I8:
-			return UNBOX_INT64(p_obj);
+			return unbox<int64_t>(p_obj);
 
 		case MONO_TYPE_U1:
-			return UNBOX_UINT8(p_obj);
+			return unbox<uint8_t>(p_obj);
 		case MONO_TYPE_U2:
-			return UNBOX_UINT16(p_obj);
+			return unbox<uint16_t>(p_obj);
 		case MONO_TYPE_U4:
-			return UNBOX_UINT32(p_obj);
+			return unbox<uint32_t>(p_obj);
 		case MONO_TYPE_U8:
-			return UNBOX_UINT64(p_obj);
+			return unbox<uint64_t>(p_obj);
 
 		case MONO_TYPE_R4:
-			return UNBOX_FLOAT(p_obj);
+			return unbox<float>(p_obj);
 		case MONO_TYPE_R8:
-			return UNBOX_DOUBLE(p_obj);
+			return unbox<double>(p_obj);
 
 		case MONO_TYPE_STRING: {
 			String str = mono_string_to_godot((MonoString *)p_obj);
@@ -554,29 +554,18 @@ Variant mono_object_to_variant(MonoObject *p_obj, const ManagedType &p_type) {
 
 			// GodotObject
 			if (CACHED_CLASS(GodotObject)->is_assignable_from(type_class)) {
-				GDMonoField *ptr_field = CACHED_FIELD(GodotObject, ptr);
+				Object *ptr = unbox<Object *>(CACHED_FIELD(GodotObject, ptr)->get_value(p_obj));
-
+				return ptr ? Variant(ptr) : Variant();
-				ERR_FAIL_NULL_V(ptr_field, Variant());
-
-				void *ptr_to_unmanaged = UNBOX_PTR(ptr_field->get_value(p_obj));
-
-				if (!ptr_to_unmanaged) // IntPtr.Zero
-					return Variant();
-
-				Object *object_ptr = static_cast<Object *>(ptr_to_unmanaged);
-
-				if (!object_ptr)
-					return Variant();
-
-				return object_ptr;
 			}
 
 			if (CACHED_CLASS(NodePath) == type_class) {
-				return UNBOX_PTR(CACHED_FIELD(NodePath, ptr)->get_value(p_obj));
+				NodePath *ptr = unbox<NodePath *>(CACHED_FIELD(NodePath, ptr)->get_value(p_obj));
+				return ptr ? Variant(*ptr) : Variant();
 			}
 
 			if (CACHED_CLASS(RID) == type_class) {
-				return UNBOX_PTR(CACHED_FIELD(RID, ptr)->get_value(p_obj));
+				RID *ptr = unbox<RID *>(CACHED_FIELD(RID, ptr)->get_value(p_obj));
+				return ptr ? Variant(*ptr) : Variant();
 			}
 		} break;
 

modules/mono/mono_gd/gd_mono_marshal.h

@@ -36,21 +36,10 @@
 
 namespace GDMonoMarshal {
 
-#define UNBOX_CHAR_PTR(x) (char *)mono_object_unbox(x)
+template <typename T>
-#define UNBOX_FLOAT_PTR(x) (float *)mono_object_unbox(x)
+T unbox(MonoObject *p_obj) {
-
+	return *(T *)mono_object_unbox(p_obj);
-#define UNBOX_DOUBLE(x) *(double *)mono_object_unbox(x)
+}
-#define UNBOX_FLOAT(x) *(float *)mono_object_unbox(x)
-#define UNBOX_INT64(x) *(int64_t *)mono_object_unbox(x)
-#define UNBOX_INT32(x) *(int32_t *)mono_object_unbox(x)
-#define UNBOX_INT16(x) *(int16_t *)mono_object_unbox(x)
-#define UNBOX_INT8(x) *(int8_t *)mono_object_unbox(x)
-#define UNBOX_UINT64(x) *(uint64_t *)mono_object_unbox(x)
-#define UNBOX_UINT32(x) *(uint32_t *)mono_object_unbox(x)
-#define UNBOX_UINT16(x) *(uint16_t *)mono_object_unbox(x)
-#define UNBOX_UINT8(x) *(uint8_t *)mono_object_unbox(x)
-#define UNBOX_BOOLEAN(x) *(MonoBoolean *)mono_object_unbox(x)
-#define UNBOX_PTR(x) mono_object_unbox(x)
 
 #define BOX_DOUBLE(x) mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(double), &x)
 #define BOX_FLOAT(x) mono_value_box(mono_domain_get(), CACHED_CLASS_RAW(float), &x)