6 files changed, 87 insertions, 13 deletions
diff --git a/modules/mono/glue/cs_files/Color.cs b/modules/mono/glue/cs_files/Color.cs
index 1195071bd3..49e04b333a 100644
--- a/modules/mono/glue/cs_files/Color.cs
+++ b/modules/mono/glue/cs_files/Color.cs
@@ -258,11 +258,6 @@ namespace Godot
             return res;
         }
 
-        public float Gray()
-        {
-            return (r + g + b) / 3.0f;
-        }
-
         public Color Inverted()
         {
             return new Color(
diff --git a/modules/mono/glue/cs_files/Plane.cs b/modules/mono/glue/cs_files/Plane.cs
index 1020f06bf5..9611dce11e 100644
--- a/modules/mono/glue/cs_files/Plane.cs
+++ b/modules/mono/glue/cs_files/Plane.cs
@@ -145,6 +145,15 @@ namespace Godot
             return point - _normal * DistanceTo(point);
         }
         
+        // Constants
+        private static readonly Plane _planeYZ = new Plane(1, 0, 0, 0);
+        private static readonly Plane _planeXZ = new Plane(0, 1, 0, 0);
+        private static readonly Plane _planeXY = new Plane(0, 0, 1, 0);
+
+        public static Plane PlaneYZ { get { return _planeYZ; } }
+        public static Plane PlaneXZ { get { return _planeXZ; } }
+        public static Plane PlaneXY { get { return _planeXY; } }
+        
         // Constructors 
         public Plane(real_t a, real_t b, real_t c, real_t d)
         {
diff --git a/modules/mono/mono_gd/gd_mono_assembly.cpp b/modules/mono/mono_gd/gd_mono_assembly.cpp
index 9d3bee2176..27ce39b6d7 100644
--- a/modules/mono/mono_gd/gd_mono_assembly.cpp
+++ b/modules/mono/mono_gd/gd_mono_assembly.cpp
@@ -42,8 +42,25 @@
 #include "gd_mono_class.h"
 
 bool GDMonoAssembly::no_search = false;
+bool GDMonoAssembly::in_preload = false;
+
 Vector<String> GDMonoAssembly::search_dirs;
 
+void GDMonoAssembly::assembly_load_hook(MonoAssembly *assembly, void *user_data) {
+
+	if (no_search)
+		return;
+
+	// If our search and preload hooks fail to load the assembly themselves, the mono runtime still might.
+	// Just do Assembly.LoadFrom("/Full/Path/On/Disk.dll");
+	// In this case, we wouldn't have the assembly known in GDMono, which causes crashes
+	// if any class inside the assembly is looked up by Godot.
+	// And causing a lookup like that is as easy as throwing an exception defined in it...
+	// No, we can't make the assembly load hooks smart enough because they get passed a MonoAssemblyName* only,
+	// not the disk path passed to say Assembly.LoadFrom().
+	_wrap_mono_assembly(assembly);
+}
+
 MonoAssembly *GDMonoAssembly::assembly_search_hook(MonoAssemblyName *aname, void *user_data) {
 	return GDMonoAssembly::_search_hook(aname, user_data, false);
 }
@@ -111,6 +128,8 @@ MonoAssembly *GDMonoAssembly::_search_hook(MonoAssemblyName *aname, void *user_d
 	return res ? res->get_assembly() : NULL;
 }
 
+static _THREAD_LOCAL_(MonoImage *) image_corlib_loading = NULL;
+
 MonoAssembly *GDMonoAssembly::_preload_hook(MonoAssemblyName *aname, char **assemblies_path, void *user_data, bool refonly) {
 
 	(void)user_data; // UNUSED
@@ -138,16 +157,38 @@ MonoAssembly *GDMonoAssembly::_preload_hook(MonoAssemblyName *aname, char **asse
 		}
 	}
 
+	{
+		// If we find the assembly here, we load it with `mono_assembly_load_from_full`,
+		// which in turn invokes load hooks before returning the MonoAssembly to us.
+		// One of the load hooks is `load_aot_module`. This hook can end up calling preload hooks
+		// again for the same assembly in certain in certain circumstances (the `do_load_image` part).
+		// If this is the case and we return NULL due to the no_search condition below,
+		// it will result in an internal crash later on. Therefore we need to return the assembly we didn't
+		// get yet from `mono_assembly_load_from_full`. Luckily we have the image, which already got it.
+		// This must be done here. If done in search hooks, it would cause `mono_assembly_load_from_full`
+		// to think another MonoAssembly for this assembly was already loaded, making it delete its own,
+		// when in fact both pointers were the same... This hooks thing is confusing.
+		if (image_corlib_loading) {
+			return mono_image_get_assembly(image_corlib_loading);
+		}
+	}
+
+	if (no_search)
+		return NULL;
+
+	no_search = true;
+	in_preload = true;
+
 	String name = mono_assembly_name_get_name(aname);
 	bool has_extension = name.ends_with(".dll");
 
+	GDMonoAssembly *res = NULL;
 	if (has_extension ? name == "mscorlib.dll" : name == "mscorlib") {
 		GDMonoAssembly **stored_assembly = GDMono::get_singleton()->get_loaded_assembly(has_extension ? name.get_basename() : name);
 		if (stored_assembly)
 			return (*stored_assembly)->get_assembly();
 
 		String path;
-		GDMonoAssembly *res = NULL;
 
 		for (int i = 0; i < search_dirs.size(); i++) {
 			const String &search_dir = search_dirs[i];
@@ -168,11 +209,12 @@ MonoAssembly *GDMonoAssembly::_preload_hook(MonoAssemblyName *aname, char **asse
 				}
 			}
 		}
-
-		return res ? res->get_assembly() : NULL;
 	}
 
-	return NULL;
+	no_search = false;
+	in_preload = false;
+
+	return res ? res->get_assembly() : NULL;
 }
 
 GDMonoAssembly *GDMonoAssembly::_load_assembly_from(const String &p_name, const String &p_path, bool p_refonly) {
@@ -192,12 +234,30 @@ GDMonoAssembly *GDMonoAssembly::_load_assembly_from(const String &p_name, const
 	return assembly;
 }
 
+void GDMonoAssembly::_wrap_mono_assembly(MonoAssembly *assembly) {
+	String name = mono_assembly_name_get_name(mono_assembly_get_name(assembly));
+
+	MonoImage *image = mono_assembly_get_image(assembly);
+
+	GDMonoAssembly *gdassembly = memnew(GDMonoAssembly(name, mono_image_get_filename(image)));
+	Error err = gdassembly->wrapper_for_image(image);
+
+	if (err != OK) {
+		memdelete(gdassembly);
+		ERR_FAIL();
+	}
+
+	MonoDomain *domain = mono_domain_get();
+	GDMono::get_singleton()->add_assembly(domain ? mono_domain_get_id(domain) : 0, gdassembly);
+}
+
 void GDMonoAssembly::initialize() {
 
 	mono_install_assembly_search_hook(&assembly_search_hook, NULL);
 	mono_install_assembly_refonly_search_hook(&assembly_refonly_search_hook, NULL);
 	mono_install_assembly_preload_hook(&assembly_preload_hook, NULL);
 	mono_install_assembly_refonly_preload_hook(&assembly_refonly_preload_hook, NULL);
+	mono_install_assembly_load_hook(&assembly_load_hook, NULL);
 }
 
 Error GDMonoAssembly::load(bool p_refonly) {
@@ -241,8 +301,16 @@ no_pdb:
 
 #endif
 
+	bool is_corlib_preload = in_preload && name == "mscorlib";
+
+	if (is_corlib_preload)
+		image_corlib_loading = image;
+
 	assembly = mono_assembly_load_from_full(image, image_filename.utf8().get_data(), &status, refonly);
 
+	if (is_corlib_preload)
+		image_corlib_loading = NULL;
+
 	ERR_FAIL_COND_V(status != MONO_IMAGE_OK || assembly == NULL, ERR_FILE_CANT_OPEN);
 
 	loaded = true;
diff --git a/modules/mono/mono_gd/gd_mono_assembly.h b/modules/mono/mono_gd/gd_mono_assembly.h
index 5cf744a5a2..2c6d367fc6 100644
--- a/modules/mono/mono_gd/gd_mono_assembly.h
+++ b/modules/mono/mono_gd/gd_mono_assembly.h
@@ -89,8 +89,10 @@ class GDMonoAssembly {
 #endif
 
 	static bool no_search;
+	static bool in_preload;
 	static Vector<String> search_dirs;
 
+	static void assembly_load_hook(MonoAssembly *assembly, void *user_data);
 	static MonoAssembly *assembly_search_hook(MonoAssemblyName *aname, void *user_data);
 	static MonoAssembly *assembly_refonly_search_hook(MonoAssemblyName *aname, void *user_data);
 	static MonoAssembly *assembly_preload_hook(MonoAssemblyName *aname, char **assemblies_path, void *user_data);
@@ -100,6 +102,7 @@ class GDMonoAssembly {
 	static MonoAssembly *_preload_hook(MonoAssemblyName *aname, char **assemblies_path, void *user_data, bool refonly);
 
 	static GDMonoAssembly *_load_assembly_from(const String &p_name, const String &p_path, bool p_refonly);
+	static void _wrap_mono_assembly(MonoAssembly *assembly);
 
 	friend class GDMono;
 	static void initialize();
diff --git a/modules/mono/utils/thread_local.cpp b/modules/mono/utils/thread_local.cpp
index ae9f130518..a0e28fca5f 100644
--- a/modules/mono/utils/thread_local.cpp
+++ b/modules/mono/utils/thread_local.cpp
@@ -69,7 +69,7 @@ struct ThreadLocalStorage::Impl {
 #define _CALLBACK_FUNC_
 #endif
 
-	Impl(void (_CALLBACK_FUNC_ *p_destr_callback_func)(void *)) {
+	Impl(void(_CALLBACK_FUNC_ *p_destr_callback_func)(void *)) {
 #ifdef WINDOWS_ENABLED
 		dwFlsIndex = FlsAlloc(p_destr_callback_func);
 		ERR_FAIL_COND(dwFlsIndex == FLS_OUT_OF_INDEXES);
@@ -95,7 +95,7 @@ void ThreadLocalStorage::set_value(void *p_value) const {
 	pimpl->set_value(p_value);
 }
 
-void ThreadLocalStorage::alloc(void (_CALLBACK_FUNC_ *p_destr_callback)(void *)) {
+void ThreadLocalStorage::alloc(void(_CALLBACK_FUNC_ *p_destr_callback)(void *)) {
 	pimpl = memnew(ThreadLocalStorage::Impl(p_destr_callback));
 }
 
diff --git a/modules/mono/utils/thread_local.h b/modules/mono/utils/thread_local.h
index 783e40dc01..84dae1d86b 100644
--- a/modules/mono/utils/thread_local.h
+++ b/modules/mono/utils/thread_local.h
@@ -76,7 +76,7 @@ struct ThreadLocalStorage {
 	void *get_value() const;
 	void set_value(void *p_value) const;
 
-	void alloc(void (_CALLBACK_FUNC_ *p_dest_callback)(void *));
+	void alloc(void(_CALLBACK_FUNC_ *p_dest_callback)(void *));
 	void free();
 
 private:
@@ -95,7 +95,6 @@ class ThreadLocal {
 		memdelete(static_cast<T *>(tls_data));
 	}
 
-
 	T *_tls_get_value() const {
 		void *tls_data = storage.get_value();