Fix unboxing of array type Variants

Source/Engine/Engine/NativeInterop.Unmanaged.cs

@@ -586,8 +586,17 @@ namespace FlaxEngine.Interop
         internal static ManagedHandle GetArrayTypeFromElementType(ManagedHandle elementTypeHandle)
         {
             Type elementType = Unsafe.As<TypeHolder>(elementTypeHandle.Target);
-            Type classType = ArrayFactory.GetArrayType(elementType);
+            Type arrayType = ArrayFactory.GetArrayType(elementType);
-            return GetTypeManagedHandle(classType);
+            return GetTypeManagedHandle(arrayType);
+        }
+
+        [UnmanagedCallersOnly]
+        internal static ManagedHandle GetArrayTypeFromWrappedArray(ManagedHandle arrayHandle)
+        {
+            ManagedArray managedArray = Unsafe.As<ManagedArray>(arrayHandle.Target);
+            Type elementType = managedArray.ArrayType.GetElementType();
+            Type arrayType = ArrayFactory.GetArrayType(elementType);
+            return GetTypeManagedHandle(arrayType);
         }
 
         [UnmanagedCallersOnly]

Source/Engine/Scripting/Internal/StdTypesContainer.cpp

@@ -40,6 +40,8 @@ void StdTypesContainer::Clear()
     Json_SerializeDiff = nullptr;
     Json_Deserialize = nullptr;
 
+    ManagedArrayClass = nullptr;
+
 #if USE_EDITOR
     ExecuteInEditModeAttribute = nullptr;
 #endif
@@ -88,6 +90,8 @@ bool StdTypesContainer::Gather()
     GET_METHOD(Json_SerializeDiff, JSON, "SerializeDiff", 3);
     GET_METHOD(Json_Deserialize, JSON, "Deserialize", 3);
 
+    GET_CLASS(FlaxEngine, ManagedArrayClass, "FlaxEngine.Interop.ManagedArray");
+
 #if USE_EDITOR
     GET_CLASS(FlaxEngine, ExecuteInEditModeAttribute, "FlaxEngine.ExecuteInEditModeAttribute");
 #endif

Source/Engine/Scripting/Internal/StdTypesContainer.h

@@ -45,6 +45,8 @@ public:
     MMethod* Json_SerializeDiff;
     MMethod* Json_Deserialize;
 
+    MClass* ManagedArrayClass;
+
 #if USE_EDITOR
     MClass* ExecuteInEditModeAttribute;
 #endif

Source/Engine/Scripting/ManagedCLR/MCore.h

@@ -83,6 +83,7 @@ public:
     {
         static MArray* New(const MClass* elementKlass, int32 length);
         static MClass* GetClass(MClass* elementKlass);
+        static MClass* GetArrayClass(const MArray* obj);
         static int32 GetLength(const MArray* obj);
         static void* GetAddress(const MArray* obj);
         static MArray* Unbox(MObject* obj);

Source/Engine/Scripting/ManagedCLR/MUtils.cpp

@@ -394,14 +394,15 @@ Variant MUtils::UnboxVariant(MObject* value)
     case MTypes::Array:
     {
         void* ptr = MCore::Array::GetAddress((MArray*)value);
-        MClass* elementClass = klass->GetElementClass();
+        const MClass* arrayClass = klass == stdTypes.ManagedArrayClass ? MCore::Array::GetArrayClass((MArray*)value) : klass;
+        const MClass* elementClass = arrayClass->GetElementClass();
         if (elementClass == MCore::TypeCache::Byte)
         {
             Variant v;
             v.SetBlob(ptr, MCore::Array::GetLength((MArray*)value));
             return v;
         }
-        const StringAnsiView fullname = klass->GetFullName();
+        const StringAnsiView fullname = arrayClass->GetFullName();
         Variant v;
         v.SetType(MoveTemp(VariantType(VariantType::Array, fullname)));
         auto& array = v.AsArray();

Source/Engine/Scripting/Runtime/DotNet.cpp

@@ -402,8 +402,15 @@ MArray* MCore::Array::New(const MClass* elementKlass, int32 length)
 
 MClass* MCore::Array::GetClass(MClass* elementKlass)
 {
-    static void* GetArrayLengthPtr = GetStaticMethodPointer(TEXT("GetArrayTypeFromElementType"));
+    static void* GetArrayTypeFromElementTypePtr = GetStaticMethodPointer(TEXT("GetArrayTypeFromElementType"));
-    MType* typeHandle = (MType*)CallStaticMethod<void*, void*>(GetArrayLengthPtr, elementKlass->_handle);
+    MType* typeHandle = (MType*)CallStaticMethod<void*, void*>(GetArrayTypeFromElementTypePtr, elementKlass->_handle);
+    return GetOrCreateClass(typeHandle);
+}
+
+MClass* MCore::Array::GetArrayClass(const MArray* obj)
+{
+    static void* GetArrayTypeFromWrappedArrayPtr = GetStaticMethodPointer(TEXT("GetArrayTypeFromWrappedArray"));
+    MType* typeHandle = (MType*)CallStaticMethod<void*, void*>(GetArrayTypeFromWrappedArrayPtr, (void*)obj);
     return GetOrCreateClass(typeHandle);
 }
 

Source/Engine/Scripting/Runtime/Mono.cpp

@@ -795,6 +795,12 @@ MClass* MCore::Array::GetClass(MClass* elementKlass)
     return FindClass(monoClass);
 }
 
+MClass* MCore::Array::GetArrayClass(const MArray* obj)
+{
+    CRASH; // Not applicable
+    return nullptr;
+}
+
 int32 MCore::Array::GetLength(const MArray* obj)
 {
     return (int32)mono_array_length((MonoArray*)obj);

Source/Engine/Scripting/Runtime/None.cpp

@@ -130,6 +130,11 @@ MClass* MCore::Array::GetClass(MClass* elementKlass)
     return nullptr;
 }
 
+MClass* MCore::Array::GetArrayClass(const MArray* obj)
+{
+    return nullptr;
+}
+
 int32 MCore::Array::GetLength(const MArray* obj)
 {
     return 0;