diff --git a/Source/Editor/Scripting/ScriptsBuilder.cpp b/Source/Editor/Scripting/ScriptsBuilder.cpp
index 1f119f9af..9c6554e9e 100644
--- a/Source/Editor/Scripting/ScriptsBuilder.cpp
+++ b/Source/Editor/Scripting/ScriptsBuilder.cpp
@@ -246,6 +246,8 @@ bool ScriptsBuilder::RunBuildTool(const StringView& args, const StringView& work
// Call build tool
const int32 result = Platform::RunProcess(StringView(*cmdLine, cmdLine.Length()), workingDir);
+ if (result != 0)
+ LOG(Error, "Failed to run build tool, result: {0:x}", (uint32)result);
return result != 0;
}
diff --git a/Source/Engine/Engine/NativeInterop.cs b/Source/Engine/Engine/NativeInterop.cs
index 841113c9b..4c06527eb 100644
--- a/Source/Engine/Engine/NativeInterop.cs
+++ b/Source/Engine/Engine/NativeInterop.cs
@@ -12,15 +12,11 @@ using System.Runtime.CompilerServices;
using FlaxEngine.Assertions;
using FlaxEngine.Utilities;
using System.Runtime.InteropServices.Marshalling;
-using System.Reflection.Metadata;
-using System.Reflection.PortableExecutable;
using FlaxEngine.Visject;
using System.Diagnostics;
using System.Collections;
-using FlaxEditor.Content;
-
-#pragma warning disable CS1591
-#pragma warning disable CS8632
+using System.Buffers;
+using System.Collections.Concurrent;
[assembly: DisableRuntimeMarshalling]
@@ -198,48 +194,88 @@ namespace FlaxEngine
#endregion
#region Wrappers
+
///
- /// Wrapper for managed arrays that needs to be pinned.
+ /// Wrapper for managed arrays which are passed to unmanaged code.
///
- internal class ManagedArray
+ internal unsafe class ManagedArray
{
- internal Array array = null;
- internal GCHandle handle;
- internal int elementSize;
+ private Array array;
+ private GCHandle pinnedArrayHandle;
+ private IntPtr unmanagedData;
+ private int elementSize;
+ private int length;
internal ManagedArray(Array arr)
{
- handle = GCHandle.Alloc(arr, GCHandleType.Pinned);
- elementSize = Marshal.SizeOf(arr.GetType().GetElementType());
array = arr;
+ unmanagedData = IntPtr.Zero;
+ length = arr.Length;
+ elementSize = Marshal.SizeOf(arr.GetType().GetElementType());
+ }
+
+ private ManagedArray(void* ptr, int length, int elementSize)
+ {
+ array = null;
+ this.unmanagedData = new IntPtr(ptr);
+ this.length = length;
+ this.elementSize = elementSize;
}
~ManagedArray()
{
- if (array != null)
+ if (unmanagedData != IntPtr.Zero || array != null)
Release();
}
internal void Release()
{
- handle.Free();
+ GC.SuppressFinalize(this);
+ if (pinnedArrayHandle.IsAllocated)
+ pinnedArrayHandle.Free();
array = null;
+ if (unmanagedData != IntPtr.Zero)
+ {
+ Marshal.FreeHGlobal(unmanagedData);
+ unmanagedData = IntPtr.Zero;
+ }
}
- internal IntPtr PointerToPinnedArray => Marshal.UnsafeAddrOfPinnedArrayElement(array, 0);
-
- internal int Length => array.Length;
-
- internal static ManagedArray Get(ref T[] arr)
+ internal IntPtr PointerToPinnedArray
{
- return new ManagedArray(arr);
+ get
+ {
+ if (array != null)
+ {
+ // Pin the array when it's accessed for the first time
+ if (!pinnedArrayHandle.IsAllocated)
+ pinnedArrayHandle = GCHandle.Alloc(array);
+ return Marshal.UnsafeAddrOfPinnedArrayElement(array, 0);
+ }
+ else
+ return unmanagedData;
+ }
}
- internal static ManagedArray Get(Array arr)
+ internal void SetValue(IntPtr value, int index)
{
- ManagedArray managedArray = new ManagedArray(arr);
- return managedArray;
+ if (array != null)
+ array.SetValue(value, index);
+ else
+ GetSpan()[index] = value;
}
+
+ internal int Length => length;
+
+ internal int ElementSize => elementSize;
+
+ internal Span GetSpan() where T : struct => array != null ? new Span((T[]) array) : new Span(unmanagedData.ToPointer(), length);
+
+ internal T[] GetArray() where T : struct => array != null ? (T[])array : new Span(unmanagedData.ToPointer(), length).ToArray();
+
+ internal static ManagedArray Get(Array arr) => new ManagedArray(arr);
+
+ internal static ManagedArray Get(T* ptr, int length) where T : unmanaged => new ManagedArray(ptr, length, Unsafe.SizeOf());
}
internal static class ManagedString
@@ -253,22 +289,10 @@ namespace FlaxEngine
return IntPtr.Zero;
else if (str == string.Empty)
return GCHandle.ToIntPtr(EmptyStringHandle);
-#if false
- // HACK: Pin the string and pass the address to it including the length, no marshalling required
- GCHandle handle = GCHandle.Alloc(str, GCHandleType.Pinned);
- IntPtr ptr = handle.AddrOfPinnedObject() - sizeof(int);
- pinnedStrings.TryAdd(ptr, handle);
- return ptr;
-#endif
+ Assert.IsTrue(str.Length > 0);
-#if false
- // HACK: Return address to the allocated string structure which includes the string length.
- // We assume the string content is copied in native side before GC frees it.
- IntPtr ptr = (Unsafe.Read(Unsafe.AsPointer(ref str)) + sizeof(int) * 2);
-#endif
- IntPtr ptr = GCHandle.ToIntPtr(GCHandle.Alloc(str, GCHandleType.Weak));
- return ptr;
+ return GCHandle.ToIntPtr(GCHandle.Alloc(str, GCHandleType.Weak));
}
[System.Diagnostics.DebuggerStepThrough]
@@ -277,7 +301,7 @@ namespace FlaxEngine
if (ptr == IntPtr.Zero)
return null;
- return (string)GCHandle.FromIntPtr(ptr).Target;
+ return Unsafe.As(GCHandle.FromIntPtr(ptr).Target);
}
[System.Diagnostics.DebuggerStepThrough]
@@ -294,7 +318,7 @@ namespace FlaxEngine
}
}
- #endregion
+#endregion
#region Marshallers
@@ -356,12 +380,12 @@ namespace FlaxEngine
}
}
- [CustomMarshaller(typeof(System.Type), MarshalMode.Default, typeof(SystemTypeMarshaller))]
+ [CustomMarshaller(typeof(Type), MarshalMode.Default, typeof(SystemTypeMarshaller))]
internal static class SystemTypeMarshaller
{
- internal static System.Type ConvertToManaged(IntPtr unmanaged) => (System.Type)GCHandleMarshaller.ConvertToManaged(unmanaged);
+ internal static Type ConvertToManaged(IntPtr unmanaged) => Unsafe.As(GCHandleMarshaller.ConvertToManaged(unmanaged));
- internal static IntPtr ConvertToUnmanaged(System.Type managed)
+ internal static IntPtr ConvertToUnmanaged(Type managed)
{
if (managed == null)
return IntPtr.Zero;
@@ -379,7 +403,7 @@ namespace FlaxEngine
[CustomMarshaller(typeof(Exception), MarshalMode.Default, typeof(ExceptionMarshaller))]
internal static class ExceptionMarshaller
{
- internal static Exception ConvertToManaged(IntPtr unmanaged) => (Exception)GCHandleMarshaller.ConvertToManaged(unmanaged);
+ internal static Exception ConvertToManaged(IntPtr unmanaged) => Unsafe.As(GCHandleMarshaller.ConvertToManaged(unmanaged));
internal static IntPtr ConvertToUnmanaged(Exception managed) => GCHandleMarshaller.ConvertToUnmanaged(managed);
internal static void Free(IntPtr unmanaged) => GCHandleMarshaller.Free(unmanaged);
}
@@ -394,7 +418,7 @@ namespace FlaxEngine
{
public static class NativeToManaged
{
- public static FlaxEngine.Object ConvertToManaged(IntPtr unmanaged) => unmanaged != IntPtr.Zero ? (FlaxEngine.Object)GCHandle.FromIntPtr(unmanaged).Target : null;
+ public static FlaxEngine.Object ConvertToManaged(IntPtr unmanaged) => unmanaged != IntPtr.Zero ? Unsafe.As(GCHandle.FromIntPtr(unmanaged).Target) : null;
}
public static class ManagedToNative
{
@@ -405,17 +429,44 @@ namespace FlaxEngine
[CustomMarshaller(typeof(CultureInfo), MarshalMode.Default, typeof(CultureInfoMarshaller))]
internal static class CultureInfoMarshaller
{
- internal static CultureInfo ConvertToManaged(IntPtr unmanaged) => (CultureInfo)GCHandleMarshaller.ConvertToManaged(unmanaged);
+ internal static CultureInfo ConvertToManaged(IntPtr unmanaged) => Unsafe.As(GCHandleMarshaller.ConvertToManaged(unmanaged));
internal static IntPtr ConvertToUnmanaged(CultureInfo managed) => GCHandleMarshaller.ConvertToUnmanaged(managed);
internal static void Free(IntPtr unmanaged) => GCHandleMarshaller.Free(unmanaged);
}
- [CustomMarshaller(typeof(Array), MarshalMode.Default, typeof(SystemArrayMarshaller))]
+ [CustomMarshaller(typeof(Array), MarshalMode.ManagedToUnmanagedIn, typeof(SystemArrayMarshaller.ManagedToNative))]
+ [CustomMarshaller(typeof(Array), MarshalMode.UnmanagedToManagedOut, typeof(SystemArrayMarshaller.ManagedToNative))]
internal static class SystemArrayMarshaller
{
- internal static Array ConvertToManaged(IntPtr unmanaged) => (Array)GCHandleMarshaller.ConvertToManaged(unmanaged);
- internal static IntPtr ConvertToUnmanaged(Array managed) => GCHandleMarshaller.ConvertToUnmanaged(managed);
- internal static void Free(IntPtr unmanaged) => GCHandleMarshaller.Free(unmanaged);
+ public struct ManagedToNative
+ {
+ ManagedArray managedArray;
+ GCHandle handle;
+
+ public void FromManaged(Array managed)
+ {
+ if (managed != null)
+ managedArray = ManagedArray.Get(managed);
+ }
+
+ public IntPtr ToUnmanaged()
+ {
+ if (managedArray == null)
+ return IntPtr.Zero;
+
+ handle = GCHandle.Alloc(managedArray);
+ return GCHandle.ToIntPtr(handle);
+ }
+
+ public void Free()
+ {
+ if (managedArray != null)
+ {
+ handle.Free();
+ managedArray.Release();
+ }
+ }
+ }
}
[CustomMarshaller(typeof(Dictionary<,>), MarshalMode.ManagedToUnmanagedIn, typeof(DictionaryMarshaller<,>.ManagedToNative))]
@@ -444,17 +495,31 @@ namespace FlaxEngine
{
Dictionary managed;
IntPtr unmanaged;
- public void FromManaged(Dictionary managed) { this.managed = managed; }
- public IntPtr ToUnmanaged() { unmanaged = DictionaryMarshaller.ToNative(managed); return unmanaged; }
- public void FromUnmanaged(IntPtr unmanaged) { this.unmanaged = unmanaged; }
- public Dictionary ToManaged() { managed = DictionaryMarshaller.ToManaged(unmanaged); unmanaged = IntPtr.Zero; return managed; }
+
+ public void FromManaged(Dictionary managed) => this.managed = managed;
+
+ public IntPtr ToUnmanaged()
+ {
+ unmanaged = DictionaryMarshaller.ToNative(managed);
+ return unmanaged;
+ }
+
+ public void FromUnmanaged(IntPtr unmanaged) => this.unmanaged = unmanaged;
+
+ public Dictionary ToManaged()
+ {
+ managed = DictionaryMarshaller.ToManaged(unmanaged);
+ unmanaged = IntPtr.Zero;
+ return managed;
+ }
+
public void Free() => DictionaryMarshaller.Free(unmanaged);
}
- public static Dictionary ConvertToManaged(IntPtr unmanaged) => unmanaged != IntPtr.Zero ? (Dictionary)GCHandle.FromIntPtr(unmanaged).Target : null;
+ public static Dictionary ConvertToManaged(IntPtr unmanaged) => unmanaged != IntPtr.Zero ? Unsafe.As>(GCHandle.FromIntPtr(unmanaged).Target) : null;
public static IntPtr ConvertToUnmanaged(Dictionary managed) => managed != null ? GCHandle.ToIntPtr(GCHandle.Alloc(managed)) : IntPtr.Zero;
- public static Dictionary ToManaged(IntPtr unmanaged) => unmanaged != IntPtr.Zero ? (Dictionary)GCHandle.FromIntPtr(unmanaged).Target : null;
+ public static Dictionary ToManaged(IntPtr unmanaged) => unmanaged != IntPtr.Zero ? Unsafe.As>(GCHandle.FromIntPtr(unmanaged).Target) : null;
public static IntPtr ToNative(Dictionary managed) => managed != null ? GCHandle.ToIntPtr(GCHandle.Alloc(managed)) : IntPtr.Zero;
public static void Free(IntPtr unmanaged)
{
@@ -473,8 +538,7 @@ namespace FlaxEngine
[CustomMarshaller(typeof(CustomMarshallerAttribute.GenericPlaceholder[]), MarshalMode.UnmanagedToManagedRef, typeof(ArrayMarshaller<,>.Bidirectional))]
[CustomMarshaller(typeof(CustomMarshallerAttribute.GenericPlaceholder[]), MarshalMode.ElementRef, typeof(ArrayMarshaller<,>))]
[ContiguousCollectionMarshaller]
- internal static unsafe class ArrayMarshaller
- where TUnmanagedElement : unmanaged
+ internal static unsafe class ArrayMarshaller where TUnmanagedElement : unmanaged
{
public static class NativeToManaged
{
@@ -483,20 +547,18 @@ namespace FlaxEngine
if (unmanaged is null)
return null;
- ManagedArray array = (ManagedArray)GCHandle.FromIntPtr(new IntPtr(unmanaged)).Target;
return new T[numElements];
}
- internal static Span GetManagedValuesDestination(T[]? managed)
- => managed;
+ internal static Span GetManagedValuesDestination(T[]? managed) => managed;
- internal static ReadOnlySpan GetUnmanagedValuesSource(TUnmanagedElement* unmanagedValue, int numElements)
+ internal static ReadOnlySpan GetUnmanagedValuesSource(TUnmanagedElement* unmanaged, int numElements)
{
- if (unmanagedValue == null)
+ if (unmanaged == null)
return ReadOnlySpan.Empty;
- ManagedArray array = (ManagedArray)GCHandle.FromIntPtr(new IntPtr(unmanagedValue)).Target;
- return new ReadOnlySpan(array.array as TUnmanagedElement[]);
+ ManagedArray managedArray = Unsafe.As(GCHandle.FromIntPtr(new IntPtr(unmanaged)).Target);
+ return managedArray.GetSpan();
}
internal static void Free(TUnmanagedElement* unmanaged)
@@ -505,7 +567,7 @@ namespace FlaxEngine
return;
GCHandle handle = GCHandle.FromIntPtr(new IntPtr(unmanaged));
- ((ManagedArray)handle.Target).Release();
+ (Unsafe.As(handle.Target)).Release();
handle.Free();
}
@@ -514,10 +576,11 @@ namespace FlaxEngine
if (unmanaged == null)
return Span.Empty;
- ManagedArray array = (ManagedArray)GCHandle.FromIntPtr(new IntPtr(unmanaged)).Target;
- return new Span(array.array as TUnmanagedElement[]);
+ ManagedArray managedArray = Unsafe.As(GCHandle.FromIntPtr(new IntPtr(unmanaged)).Target);
+ return managedArray.GetSpan();
}
}
+
public static class ManagedToNative
{
internal static TUnmanagedElement* AllocateContainerForUnmanagedElements(T[]? managed, out int numElements)
@@ -530,22 +593,21 @@ namespace FlaxEngine
numElements = managed.Length;
- ManagedArray array = ManagedArray.Get(new TUnmanagedElement[numElements]);
- var ptr = GCHandle.ToIntPtr(GCHandle.Alloc(array));
+ ManagedArray managedArray = ManagedArray.Get((TUnmanagedElement*)Marshal.AllocHGlobal(sizeof(TUnmanagedElement) * managed.Length), managed.Length);
+ var ptr = GCHandle.ToIntPtr(GCHandle.Alloc(managedArray));
return (TUnmanagedElement*)ptr;
}
- internal static ReadOnlySpan GetManagedValuesSource(T[]? managed)
- => managed;
+ internal static ReadOnlySpan GetManagedValuesSource(T[]? managed) => managed;
internal static Span GetUnmanagedValuesDestination(TUnmanagedElement* unmanaged, int numElements)
{
if (unmanaged == null)
return Span.Empty;
- ManagedArray array = (ManagedArray)GCHandle.FromIntPtr(new IntPtr(unmanaged)).Target;
- return new Span(array.array as TUnmanagedElement[]);
+ ManagedArray managedArray = Unsafe.As(GCHandle.FromIntPtr(new IntPtr(unmanaged)).Target);
+ return managedArray.GetSpan();
}
internal static void Free(TUnmanagedElement* unmanaged)
@@ -554,10 +616,11 @@ namespace FlaxEngine
return;
GCHandle handle = GCHandle.FromIntPtr(new IntPtr(unmanaged));
- ((ManagedArray)handle.Target).Release();
+ (Unsafe.As(handle.Target)).Release();
handle.Free();
}
}
+
public struct Bidirectional
{
T[] managedArray;
@@ -570,30 +633,27 @@ namespace FlaxEngine
return;
managedArray = managed;
- unmanagedArray = ManagedArray.Get(new TUnmanagedElement[managed.Length]);
+ unmanagedArray = ManagedArray.Get((TUnmanagedElement*)Marshal.AllocHGlobal(sizeof(TUnmanagedElement) * managed.Length), managed.Length);
handle = GCHandle.Alloc(unmanagedArray);
}
- public ReadOnlySpan GetManagedValuesSource()
- => managedArray;
+ public ReadOnlySpan GetManagedValuesSource() => managedArray;
public Span GetUnmanagedValuesDestination()
{
if (unmanagedArray == null)
return Span.Empty;
- return new Span(unmanagedArray.array as TUnmanagedElement[]);
+ return unmanagedArray.GetSpan();
}
- public TUnmanagedElement* ToUnmanaged()
- {
- return (TUnmanagedElement*)GCHandle.ToIntPtr(handle);
- }
+ public TUnmanagedElement* ToUnmanaged() => (TUnmanagedElement*)GCHandle.ToIntPtr(handle);
- public void FromUnmanaged(TUnmanagedElement* value)
+ public void FromUnmanaged(TUnmanagedElement* unmanaged)
{
- ManagedArray arr = (ManagedArray)GCHandle.FromIntPtr(new IntPtr(value)).Target;
- managedArray = new T[arr.Length];
+ ManagedArray arr = Unsafe.As(GCHandle.FromIntPtr(new IntPtr(unmanaged)).Target);
+ if (managedArray == null || managedArray.Length != arr.Length)
+ managedArray = new T[arr.Length];
}
public ReadOnlySpan GetUnmanagedValuesSource(int numElements)
@@ -601,14 +661,12 @@ namespace FlaxEngine
if (unmanagedArray == null)
return ReadOnlySpan.Empty;
- return new ReadOnlySpan(unmanagedArray.array as TUnmanagedElement[]);
+ return unmanagedArray.GetSpan();
}
- public Span GetManagedValuesDestination(int numElements)
- => managedArray;
+ public Span GetManagedValuesDestination(int numElements) => managedArray;
- public T[] ToManaged()
- => managedArray;
+ public T[] ToManaged() => managedArray;
public void Free()
{
@@ -627,43 +685,34 @@ namespace FlaxEngine
numElements = managed.Length;
- ManagedArray array = ManagedArray.Get(new TUnmanagedElement[numElements]);
- var ptr = GCHandle.ToIntPtr(GCHandle.Alloc(array));
+ ManagedArray managedArray = ManagedArray.Get((TUnmanagedElement*)Marshal.AllocHGlobal(sizeof(TUnmanagedElement) * managed.Length), managed.Length);
+ IntPtr handle = GCHandle.ToIntPtr(GCHandle.Alloc(managedArray));
- return (TUnmanagedElement*)ptr;
+ return (TUnmanagedElement*)handle;
}
- internal static ReadOnlySpan GetManagedValuesSource(T[]? managed)
- => managed;
+ internal static ReadOnlySpan GetManagedValuesSource(T[]? managed) => managed;
internal static Span GetUnmanagedValuesDestination(TUnmanagedElement* unmanaged, int numElements)
{
if (unmanaged == null)
return Span.Empty;
- ManagedArray array = (ManagedArray)GCHandle.FromIntPtr(new IntPtr(unmanaged)).Target;
- return new Span(array.array as TUnmanagedElement[]);
+ ManagedArray unmanagedArray = Unsafe.As(GCHandle.FromIntPtr(new IntPtr(unmanaged)).Target);
+ return unmanagedArray.GetSpan();
}
- internal static T[]? AllocateContainerForManagedElements(TUnmanagedElement* unmanaged, int numElements)
+ internal static T[]? AllocateContainerForManagedElements(TUnmanagedElement* unmanaged, int numElements) => unmanaged is null ? null : new T[numElements];
+
+ internal static Span GetManagedValuesDestination(T[]? managed) => managed;
+
+ internal static ReadOnlySpan GetUnmanagedValuesSource(TUnmanagedElement* unmanaged, int numElements)
{
- if (unmanaged is null)
- return null;
-
- ManagedArray array = (ManagedArray)GCHandle.FromIntPtr(new IntPtr(unmanaged)).Target;
- return new T[numElements];
- }
-
- internal static Span GetManagedValuesDestination(T[]? managed)
- => managed;
-
- internal static ReadOnlySpan GetUnmanagedValuesSource(TUnmanagedElement* unmanagedValue, int numElements)
- {
- if (unmanagedValue == null)
+ if (unmanaged == null)
return ReadOnlySpan.Empty;
- ManagedArray array = (ManagedArray)GCHandle.FromIntPtr(new IntPtr(unmanagedValue)).Target;
- return new ReadOnlySpan(array.array as TUnmanagedElement[]);
+ ManagedArray array = Unsafe.As(GCHandle.FromIntPtr(new IntPtr(unmanaged)).Target);
+ return array.GetSpan();
}
internal static void Free(TUnmanagedElement* unmanaged)
@@ -672,19 +721,9 @@ namespace FlaxEngine
return;
GCHandle handle = GCHandle.FromIntPtr(new IntPtr(unmanaged));
- ((ManagedArray)handle.Target).Release();
+ Unsafe.As(handle.Target).Release();
handle.Free();
}
-
- internal static ref T GetPinnableReference(T[]? array)
- {
- if (array is null)
- return ref Unsafe.NullRef();
-
- ManagedArray managedArray = ManagedArray.Get(array);
- var ptr = GCHandle.ToIntPtr(GCHandle.Alloc(managedArray));
- return ref Unsafe.AsRef(ptr.ToPointer());
- }
}
[CustomMarshaller(typeof(string), MarshalMode.ManagedToUnmanagedIn, typeof(StringMarshaller.ManagedToNative))]
@@ -703,41 +742,45 @@ namespace FlaxEngine
public static string ConvertToManaged(IntPtr unmanaged) => ManagedString.ToManaged(unmanaged);
public static void Free(IntPtr unmanaged) => ManagedString.Free(unmanaged);
}
+
public static class ManagedToNative
{
public static unsafe IntPtr ConvertToUnmanaged(string managed)
{
if (managed == null)
return IntPtr.Zero;
-#if false
- // HACK: Pin the string and pass the address to it including the length, no marshalling required
- GCHandle handle = GCHandle.Alloc(managed, GCHandleType.Pinned);
- IntPtr ptr = handle.AddrOfPinnedObject() - sizeof(int);
- pinnedStrings.TryAdd(ptr, handle);
- return ptr;
-#endif
-
-#if false
- // HACK: Return address to the allocated string structure which includes the string length.
- // We assume the string content is copied in native side before GC frees it.
- IntPtr ptr = (Unsafe.Read(Unsafe.AsPointer(ref managed)) + sizeof(int) * 2);
-#endif
- IntPtr ptr = GCHandle.ToIntPtr(GCHandle.Alloc(managed, GCHandleType.Pinned));
- return ptr;
+ return GCHandle.ToIntPtr(GCHandle.Alloc(managed, GCHandleType.Weak));
}
+
public static void Free(IntPtr unmanaged) => ManagedString.Free(unmanaged);
}
+
public struct Bidirectional
{
string managed;
IntPtr unmanaged;
- public void FromManaged(string managed) { this.managed = managed; }
- public IntPtr ToUnmanaged() { unmanaged = ManagedString.ToNative(managed); return unmanaged; }
- public void FromUnmanaged(IntPtr unmanaged) { this.unmanaged = unmanaged; }
- public string ToManaged() { managed = ManagedString.ToManaged(unmanaged); unmanaged = IntPtr.Zero; return managed; }
+
+ public void FromManaged(string managed) => this.managed = managed;
+
+ public IntPtr ToUnmanaged()
+ {
+ unmanaged = ManagedString.ToNative(managed);
+ return unmanaged;
+ }
+
+ public void FromUnmanaged(IntPtr unmanaged) => this.unmanaged = unmanaged;
+
+ public string ToManaged()
+ {
+ managed = ManagedString.ToManaged(unmanaged);
+ unmanaged = IntPtr.Zero;
+ return managed;
+ }
+
public void Free() => ManagedString.Free(unmanaged);
}
+
internal static string ConvertToManaged(IntPtr unmanaged) => ManagedString.ToManaged(unmanaged);
internal static IntPtr ConvertToUnmanaged(string managed) => ManagedString.ToNative(managed);
internal static void Free(IntPtr unmanaged) => ManagedString.Free(unmanaged);
@@ -753,23 +796,26 @@ namespace FlaxEngine
///
internal unsafe static partial class NativeInterop
{
+ ///
+ /// Enables first-chance exception handling in invoked methods while debugger is attached.
+ ///
+ public static bool CatchExceptions = true;
+
internal static Dictionary AssemblyLocations = new Dictionary();
private static bool firstAssemblyLoaded = false;
-
- private static Dictionary typeCache = new Dictionary();
- private static Dictionary marshallableStructCache = new Dictionary();
+ private static Dictionary typeCache = new Dictionary();
private static IntPtr boolTruePtr = GCHandle.ToIntPtr(GCHandle.Alloc((int)1, GCHandleType.Pinned));
private static IntPtr boolFalsePtr = GCHandle.ToIntPtr(GCHandle.Alloc((int)0, GCHandleType.Pinned));
private static List methodHandles = new();
private static List methodHandlesCollectible = new();
- private static Dictionary cachedDelegates = new Dictionary();
- private static Dictionary cachedDelegatesCollectible = new Dictionary();
- private static Dictionary typeHandleCache = new Dictionary();
- private static Dictionary typeHandleCacheCollectible = new Dictionary();
+ private static ConcurrentDictionary cachedDelegates = new ConcurrentDictionary();
+ private static ConcurrentDictionary cachedDelegatesCollectible = new ConcurrentDictionary();
+ private static Dictionary typeHandleCache = new Dictionary();
+ private static Dictionary typeHandleCacheCollectible = new Dictionary();
private static List fieldHandleCache = new();
private static List fieldHandleCacheCollectible = new();
private static Dictionary classAttributesCacheCollectible = new();
@@ -814,15 +860,12 @@ namespace FlaxEngine
{
}
- internal static T[] GCHandleArrayToManagedArray(ManagedArray array)
+ internal static T[] GCHandleArrayToManagedArray(ManagedArray ptrArray)
{
- IntPtr[] ptrArray = (IntPtr[])array.array;
- T[] managedArray = new T[array.Length];
+ Span span = ptrArray.GetSpan();
+ T[] managedArray = new T[ptrArray.Length];
for (int i = 0; i < managedArray.Length; i++)
- {
- IntPtr ptr = ptrArray[i];
- managedArray[i] = ptr != IntPtr.Zero ? (T)GCHandle.FromIntPtr(ptr).Target : default(T);
- }
+ managedArray[i] = span[i] != IntPtr.Zero ? (T)GCHandle.FromIntPtr(span[i]).Target : default;
return managedArray;
}
@@ -832,20 +875,17 @@ namespace FlaxEngine
for (int i = 0; i < pointerArray.Length; i++)
{
var obj = array.GetValue(i);
- pointerArray.SetValue(obj != null ? GCHandle.ToIntPtr(GCHandle.Alloc(obj)) : IntPtr.Zero, i);
+ if (obj != null)
+ pointerArray.SetValue(GCHandle.ToIntPtr(GCHandle.Alloc(obj)), i);
}
return pointerArray;
}
- internal static T[] NativeArrayToManagedArray(U[] nativeArray, Func toManagedFunc)
+ internal static T[] NativeArrayToManagedArray(Span nativeSpan, Func toManagedFunc)
{
- T[] managedArray = new T[nativeArray.Length];
- if (nativeArray.Length > 0)
- {
- Assert.IsTrue(toManagedFunc != null);
- for (int i = 0; i < nativeArray.Length; i++)
- managedArray[i] = toManagedFunc(nativeArray[i]);
- }
+ T[] managedArray = new T[nativeSpan.Length];
+ for (int i = 0; i < nativeSpan.Length; i++)
+ managedArray[i] = toManagedFunc(nativeSpan[i]);
return managedArray;
}
@@ -929,7 +969,7 @@ namespace FlaxEngine
string @namespace = string.Join('.', splits[0].Split('.').SkipLast(1));
string className = @namespace.Length > 0 ? splits[0].Substring(@namespace.Length + 1) : splits[0];
string parentClassName = "";
- if (className.Contains("+"))
+ if (className.Contains('+'))
{
parentClassName = className.Substring(0, className.LastIndexOf('+') + 1);
className = className.Substring(parentClassName.Length);
@@ -939,244 +979,564 @@ namespace FlaxEngine
return FindType(internalAssemblyQualifiedName);
}
- private static IntPtr EnsureAlignment(IntPtr ptr, int alignment)
+ internal class ReferenceTypePlaceholder { }
+ internal struct ValueTypePlaceholder { }
+
+ internal delegate object MarshalToManagedDelegate(IntPtr nativePtr, bool byRef);
+ internal delegate void MarshalToNativeDelegate(object managedObject, IntPtr nativePtr);
+ internal delegate void MarshalToNativeFieldDelegate(FieldInfo field, object fieldOwner, IntPtr nativePtr, out int fieldOffset);
+
+ internal static ConcurrentDictionary toManagedMarshallers = new ConcurrentDictionary(1, 3);
+ internal static ConcurrentDictionary toNativeMarshallers = new ConcurrentDictionary(1, 3);
+ internal static ConcurrentDictionary toNativeFieldMarshallers = new ConcurrentDictionary(1, 3);
+
+ internal static object MarshalToManaged(IntPtr nativePtr, Type type)
{
- if (ptr % alignment != 0)
- ptr = IntPtr.Add(ptr, alignment - (int)(ptr % alignment));
- return ptr;
+ static MarshalToManagedDelegate Factory(Type type)
+ {
+ Type marshalType = type;
+ if (marshalType.IsByRef)
+ marshalType = marshalType.GetElementType();
+ else if (marshalType.IsPointer)
+ marshalType = typeof(IntPtr);
+
+ MethodInfo method = typeof(MarshalHelper<>).MakeGenericType(marshalType).GetMethod(nameof(MarshalHelper.ToManagedWrapper), BindingFlags.Static | BindingFlags.NonPublic);
+ return method.CreateDelegate();
+ }
+
+ if (toManagedMarshallers.TryGetValue(type, out var deleg))
+ return deleg(nativePtr, type.IsByRef);
+ return toManagedMarshallers.GetOrAdd(type, Factory)(nativePtr, type.IsByRef);
}
- internal static void MarshalFromObject(object obj, Type objectType, ref IntPtr targetPtr)
+ internal static void MarshalToNative(object managedObject, IntPtr nativePtr, Type type)
{
- int readOffset = 0;
- if (objectType == typeof(IntPtr))
+ static MarshalToNativeDelegate Factory(Type type)
{
- targetPtr = EnsureAlignment(targetPtr, IntPtr.Size);
- Marshal.WriteIntPtr(targetPtr, (IntPtr)obj);
- readOffset = IntPtr.Size;
- }
- else if (objectType == typeof(byte))
- {
- targetPtr = EnsureAlignment(targetPtr, sizeof(byte));
- Marshal.WriteByte(targetPtr, (byte)obj);
- readOffset = sizeof(byte);
- }
- else if (objectType == typeof(bool))
- {
- targetPtr = EnsureAlignment(targetPtr, sizeof(byte));
- Marshal.WriteByte(targetPtr, ((bool)obj) ? (byte)1 : (byte)0);
- readOffset = sizeof(byte);
- }
- else if (objectType.IsEnum)
- {
- MarshalFromObject(obj, objectType.GetEnumUnderlyingType(), ref targetPtr);
- }
- else if (objectType == typeof(int) || objectType.Name == "Int32&")
- {
- targetPtr = EnsureAlignment(targetPtr, sizeof(int));
- Marshal.WriteInt32(targetPtr, (int)obj);
- readOffset = sizeof(int);
- }
- else if (objectType == typeof(long))
- {
- targetPtr = EnsureAlignment(targetPtr, sizeof(long));
- Marshal.WriteInt64(targetPtr, (long)obj);
- readOffset = sizeof(long);
- }
- else if (objectType == typeof(short))
- {
- targetPtr = EnsureAlignment(targetPtr, sizeof(short));
- Marshal.WriteInt16(targetPtr, (short)obj);
- readOffset = sizeof(short);
- }
- else if (objectType == typeof(string))
- {
- targetPtr = EnsureAlignment(targetPtr, IntPtr.Size);
- IntPtr strPtr = ManagedString.ToNative(obj as string);
- Marshal.WriteIntPtr(targetPtr, strPtr);
- readOffset = IntPtr.Size;
- }
- else if (objectType.IsByRef)
- throw new NotImplementedException();
- else if (objectType.IsClass)
- {
- if (objectType.IsPointer)
- {
- targetPtr = EnsureAlignment(targetPtr, IntPtr.Size);
- var unboxed = Pointer.Unbox(obj);
- if (unboxed == null)
- Marshal.WriteIntPtr(targetPtr, IntPtr.Zero);
- else if (obj is FlaxEngine.Object fobj)
- Marshal.WriteIntPtr(targetPtr, fobj.__unmanagedPtr);
- else
- Marshal.WriteIntPtr(targetPtr, GCHandle.ToIntPtr(GCHandle.Alloc(obj, GCHandleType.Weak)));
- readOffset = IntPtr.Size;
- }
+ MethodInfo method;
+ if (type.IsValueType)
+ method = typeof(MarshalHelperValueType<>).MakeGenericType(type).GetMethod(nameof(MarshalHelperValueType.ToNativeWrapper), BindingFlags.Static | BindingFlags.NonPublic);
else
- {
- targetPtr = EnsureAlignment(targetPtr, IntPtr.Size);
- Marshal.WriteIntPtr(targetPtr, obj != null ? GCHandle.ToIntPtr(GCHandle.Alloc(obj, GCHandleType.Weak)) : IntPtr.Zero);
- readOffset = IntPtr.Size;
- }
+ method = typeof(MarshalHelperReferenceType<>).MakeGenericType(type).GetMethod(nameof(MarshalHelperReferenceType.ToNativeWrapper), BindingFlags.Static | BindingFlags.NonPublic);
+ return method.CreateDelegate();
}
- else if (objectType.IsValueType)
- {
- if (GetMarshallableStructFields(objectType, out FieldInfo[] fields))
- {
- IntPtr origPtr = targetPtr;
- foreach (var field in fields)
- MarshalFromObject(field.GetValue(obj), field.FieldType, ref targetPtr);
-
- Assert.IsTrue((targetPtr-origPtr) == Marshal.SizeOf(objectType));
- }
- else
- {
- Marshal.StructureToPtr(obj, targetPtr, false);
- readOffset = Marshal.SizeOf(objectType);
- }
- }
+ if (toNativeMarshallers.TryGetValue(type, out var deleg))
+ deleg(managedObject, nativePtr);
else
- throw new NotImplementedException(objectType.FullName);
-
- targetPtr = IntPtr.Add(targetPtr, readOffset);
+ toNativeMarshallers.GetOrAdd(type, Factory)(managedObject, nativePtr);
}
- private static bool GetMarshallableStructFields(Type type, out FieldInfo[] fields)
+ internal static MarshalToNativeFieldDelegate GetToNativeFieldMarshallerDelegate(Type type)
{
- if (marshallableStructCache.TryGetValue(type, out fields))
- return fields != null;
-
- fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
- if (!fields.Any(x => x.FieldType.IsClass || x.FieldType.Name == "Boolean"))
- fields = null;
-
- marshallableStructCache.Add(type, fields);
- return fields != null;
- }
-
- internal static object MarshalToObject(Type type, IntPtr ptr, out int readSize)
- {
- readSize = 0;
- if (type.Name == "IntPtr&" || type.Name == "Byte*" || type.Name == "IntPtr")
+ static MarshalToNativeFieldDelegate Factory(Type type)
{
- readSize += IntPtr.Size;
+ MethodInfo method;
+ if (type.IsValueType)
+ method = typeof(MarshalHelperValueType<>).MakeGenericType(type).GetMethod(nameof(MarshalHelperValueType.ToNativeFieldWrapper), BindingFlags.Static | BindingFlags.NonPublic);
+ else
+ method = typeof(MarshalHelperReferenceType<>).MakeGenericType(type).GetMethod(nameof(MarshalHelperReferenceType.ToNativeFieldWrapper), BindingFlags.Static | BindingFlags.NonPublic);
+ return method.CreateDelegate();
+ }
+ if (toNativeFieldMarshallers.TryGetValue(type, out var deleg))
+ return deleg;
+ return toNativeFieldMarshallers.GetOrAdd(type, Factory);
+ }
+
+ internal static void MarshalToNativeField(FieldInfo field, object fieldOwner, IntPtr nativePtr, out int fieldOffset)
+ {
+ GetToNativeFieldMarshallerDelegate(fieldOwner.GetType())(field, fieldOwner, nativePtr, out fieldOffset);
+ }
+
+ ///
+ /// Helper class for managing stored marshaller delegates for each type.
+ ///
+ internal static class MarshalHelper
+ {
+ private delegate void MarshalToNativeTypedDelegate(ref T managedValue, IntPtr nativePtr);
+ private delegate void MarshalToManagedTypedDelegate(ref T managedValue, IntPtr nativePtr, bool byRef);
+ internal delegate void MarshalFieldTypedDelegate(FieldInfo field, ref T fieldOwner, IntPtr fieldPtr, out int fieldOffset);
+
+ internal static FieldInfo[] marshallableFields;
+ internal static MarshalFieldTypedDelegate[] toManagedFieldMarshallers;
+ internal static MarshalFieldTypedDelegate[] toNativeFieldMarshallers;
+
+ private static MarshalToNativeTypedDelegate toNativeTypedMarshaller;
+ private static MarshalToManagedTypedDelegate toManagedTypedMarshaller;
+
+ static MarshalHelper()
+ {
+ Type type = typeof(T);
+
+ // Setup marshallers for managed and native directions
+ MethodInfo toManagedMethod;
+ if (type.IsValueType)
+ toManagedMethod = typeof(MarshalHelperValueType<>).MakeGenericType(type).GetMethod(nameof(MarshalHelperValueType.ToManaged), BindingFlags.Static | BindingFlags.NonPublic);
+ else if (type.IsArray && type.GetElementType().IsValueType)
+ toManagedMethod = typeof(MarshalHelperValueType<>).MakeGenericType(type.GetElementType()).GetMethod(nameof(MarshalHelperValueType.ToManagedArray), BindingFlags.Static | BindingFlags.NonPublic);
+ else if (type.IsArray && !type.GetElementType().IsValueType)
+ toManagedMethod = typeof(MarshalHelperReferenceType<>).MakeGenericType(type.GetElementType()).GetMethod(nameof(MarshalHelperReferenceType.ToManagedArray), BindingFlags.Static | BindingFlags.NonPublic);
+ else
+ toManagedMethod = typeof(MarshalHelperReferenceType<>).MakeGenericType(type).GetMethod(nameof(MarshalHelperReferenceType.ToManaged), BindingFlags.Static | BindingFlags.NonPublic);
+ toManagedTypedMarshaller = toManagedMethod.CreateDelegate();
+
+ MethodInfo toNativeMethod;
+ if (type.IsValueType)
+ toNativeMethod = typeof(MarshalHelperValueType<>).MakeGenericType(type).GetMethod(nameof(MarshalHelperValueType.ToNative), BindingFlags.Static | BindingFlags.NonPublic);
+ else
+ toNativeMethod = typeof(MarshalHelperReferenceType<>).MakeGenericType(type).GetMethod(nameof(MarshalHelperReferenceType.ToNative), BindingFlags.Static | BindingFlags.NonPublic);
+ toNativeTypedMarshaller = toNativeMethod.CreateDelegate();
+
+ if (!type.IsPrimitive && !type.IsPointer && type != typeof(bool))
+ {
+ // Setup field-by-field marshallers for reference types or structures containing references
+ marshallableFields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+ if (type.IsValueType && !marshallableFields.Any(x => (x.FieldType.IsClass && !x.FieldType.IsPointer) || x.FieldType.Name == "Boolean"))
+ marshallableFields = null;
+ else if (!type.IsValueType && !marshallableFields.Any())
+ marshallableFields = null;
+
+ if (marshallableFields != null)
+ {
+ toManagedFieldMarshallers = new MarshalFieldTypedDelegate[marshallableFields.Length];
+ toNativeFieldMarshallers = new MarshalFieldTypedDelegate[marshallableFields.Length];
+ for (int i = 0; i < marshallableFields.Length; i++)
+ {
+ FieldInfo field = marshallableFields[i];
+ MethodInfo toManagedFieldMethod;
+ MethodInfo toNativeFieldMethod;
+
+ if (field.FieldType.IsPointer)
+ {
+ toManagedFieldMethod = typeof(MarshalHelper<>).MakeGenericType(type).GetMethod(nameof(MarshalHelper.ToManagedFieldPointer), BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+ toNativeFieldMethod = typeof(MarshalHelper<>).MakeGenericType(type).GetMethod(nameof(MarshalHelper.ToNativeFieldPointer), BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+ }
+ else if (field.FieldType.IsValueType)
+ {
+ toManagedFieldMethod = typeof(MarshalHelper<>.ValueTypeField<>).MakeGenericType(type, field.FieldType).GetMethod(nameof(MarshalHelper.ValueTypeField.ToManagedField), BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+ toNativeFieldMethod = typeof(MarshalHelper<>.ValueTypeField<>).MakeGenericType(type, field.FieldType).GetMethod(nameof(MarshalHelper.ValueTypeField.ToNativeField), BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+ }
+ else if (field.FieldType.IsArray)
+ {
+ Type arrayElementType = field.FieldType.GetElementType();
+ if (arrayElementType.IsValueType)
+ {
+ toManagedFieldMethod = typeof(MarshalHelper<>.ValueTypeField<>).MakeGenericType(type, arrayElementType).GetMethod(nameof(MarshalHelper.ValueTypeField.ToManagedFieldArray), BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+ toNativeFieldMethod = typeof(MarshalHelper<>.ReferenceTypeField<>).MakeGenericType(type, field.FieldType).GetMethod(nameof(MarshalHelper.ReferenceTypeField.ToNativeField), BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+ }
+ else
+ {
+ toManagedFieldMethod = typeof(MarshalHelper<>.ReferenceTypeField<>).MakeGenericType(type, field.FieldType).GetMethod(nameof(MarshalHelper.ReferenceTypeField.ToManagedField), BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+ toNativeFieldMethod = typeof(MarshalHelper<>.ReferenceTypeField<>).MakeGenericType(type, field.FieldType).GetMethod(nameof(MarshalHelper.ReferenceTypeField.ToNativeField), BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+ }
+ }
+ else
+ {
+ toManagedFieldMethod = typeof(MarshalHelper<>.ReferenceTypeField<>).MakeGenericType(type, field.FieldType).GetMethod(nameof(MarshalHelper.ReferenceTypeField.ToManagedField), BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+ toNativeFieldMethod = typeof(MarshalHelper<>.ReferenceTypeField<>).MakeGenericType(type, field.FieldType).GetMethod(nameof(MarshalHelper.ReferenceTypeField.ToNativeField), BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
+ }
+ toManagedFieldMarshallers[i] = toManagedFieldMethod.CreateDelegate();
+ toNativeFieldMarshallers[i] = toNativeFieldMethod.CreateDelegate();
+ }
+ }
+ }
+ }
+
+ internal static object ToManagedWrapper(IntPtr nativePtr, bool byRef)
+ {
+ T managed = default;
+ toManagedTypedMarshaller(ref managed, nativePtr, byRef);
+ return managed;
+ }
+
+ internal static void ToManaged(ref T managedValue, IntPtr nativePtr, bool byRef)
+ {
+ toManagedTypedMarshaller(ref managedValue, nativePtr, byRef);
+ }
+
+ internal static Array ToManagedArray(Span ptrSpan)
+ {
+ T[] arr = new T[ptrSpan.Length];
+ for (int i = 0; i < arr.Length; i++)
+ toManagedTypedMarshaller(ref arr[i], ptrSpan[i], false);
+ return arr;
+ }
+
+ internal static void ToNative(ref T managedValue, IntPtr nativePtr)
+ {
+ toNativeTypedMarshaller(ref managedValue, nativePtr);
+ }
+
+ internal static void ToNativeField(FieldInfo field, ref T fieldOwner, IntPtr nativePtr, out int fieldOffset)
+ {
+ if (marshallableFields != null)
+ {
+ for (int i = 0; i < marshallableFields.Length; i++)
+ {
+ if (marshallableFields[i] == field)
+ {
+ toNativeFieldMarshallers[i](marshallableFields[i], ref fieldOwner, nativePtr, out fieldOffset);
+ return;
+ }
+ }
+ }
+
+ throw new Exception($"Invalid field {field.Name} to marshal for type {typeof(T).Name}");
+ }
+
+ private static void ToManagedFieldPointer(FieldInfo field, ref T fieldOwner, IntPtr fieldPtr, out int fieldOffset)
+ {
+ ref IntPtr fieldValueRef = ref GetFieldReference(field, ref fieldOwner);
+ fieldValueRef = Unsafe.Read(fieldPtr.ToPointer());
+ fieldOffset = IntPtr.Size;
+ }
+
+ private static void ToNativeFieldPointer(FieldInfo field, ref T fieldOwner, IntPtr fieldPtr, out int fieldOffset)
+ {
+ ref IntPtr fieldValueRef = ref GetFieldReference(field, ref fieldOwner);
+ Unsafe.Write(fieldPtr.ToPointer(), fieldValueRef);
+ fieldOffset = IntPtr.Size;
+ }
+
+ ///
+ /// Returns a reference to the value of the field.
+ ///
+ private static ref TField GetFieldReference(FieldInfo field, ref T fieldOwner)
+ {
+ Assert.IsTrue(!field.IsInitOnly);
+
+ // Get the address of the field, source: https://stackoverflow.com/a/56512720
+ byte* fieldPtr = (byte*)Unsafe.AsPointer(ref fieldOwner) + (Marshal.ReadInt32(field.FieldHandle.Value + 4 + IntPtr.Size) & 0xFFFFFF);
+ if (typeof(T).IsValueType)
+ return ref Unsafe.AsRef(fieldPtr);
+ else
+ return ref Unsafe.AsRef(fieldPtr + IntPtr.Size);
+ }
+
+ private static IntPtr EnsureAlignment(IntPtr ptr, int alignment)
+ {
+ if (ptr % alignment != 0)
+ ptr = IntPtr.Add(ptr, alignment - (int)(ptr % alignment));
return ptr;
}
- else if (type.IsByRef)
- {
- return MarshalToObject(type.GetElementType(), ptr, out readSize);
- }
- else if (type == typeof(string))
- {
- readSize += IntPtr.Size;
- return ManagedString.ToManaged(ptr);
- }
- else if (type == typeof(bool))
- {
- readSize += sizeof(byte);
- return Marshal.ReadByte(ptr) != 0;
- }
- else if (type.IsEnum)
- {
- return Enum.ToObject(type, MarshalToObject(type.GetEnumUnderlyingType(), ptr, out readSize));
- }
- else if (type.IsArray)
- {
- readSize += IntPtr.Size;
- if (ptr == IntPtr.Zero)
- return null;
- Type elementType = type.GetElementType();
- ManagedArray arr = (ManagedArray)GCHandle.FromIntPtr(ptr).Target;
- if (arr.array.GetType().GetElementType() == elementType)
- return arr.array;
-
- IntPtr[] ptrs = (IntPtr[])arr.array;
- Array marshalledArray = Array.CreateInstance(elementType, ptrs.Length);
- for (int i = 0; i < marshalledArray.Length; i++)
- marshalledArray.SetValue(MarshalToObject(elementType, ptrs[i], out _), i);
- return marshalledArray;
- }
- else if (type.IsClass)
+ private static class ValueTypeField where TField : struct
{
- readSize += IntPtr.Size;
- if (ptr == IntPtr.Zero)
- return null;
+ private static int fieldAlignment;
- var obj = GCHandle.FromIntPtr(ptr).Target;
- return obj;
- }
- else if (type.IsValueType)
- {
- if (GetMarshallableStructFields(type, out FieldInfo[] fields))
+ static ValueTypeField()
{
- object target = RuntimeHelpers.GetUninitializedObject(type);
- IntPtr fieldPtr = ptr;
+ Type fieldType = typeof(TField);
+ if (fieldType.IsEnum)
+ fieldType = fieldType.GetEnumUnderlyingType();
+ else if (fieldType == typeof(bool))
+ fieldType = typeof(byte);
- foreach (var field in fields)
+ if (fieldType.IsValueType && !fieldType.IsEnum && !fieldType.IsPrimitive) // Is it a structure?
+ { }
+ else if (fieldType.IsClass || fieldType.IsPointer)
+ fieldAlignment = IntPtr.Size;
+ else
+ fieldAlignment = Marshal.SizeOf(fieldType);
+ }
+
+ internal static void ToManagedField(FieldInfo field, ref T fieldOwner, IntPtr fieldPtr, out int fieldOffset)
+ {
+ fieldOffset = Unsafe.SizeOf();
+ if (fieldAlignment > 1)
{
- object fieldValue;
- int size;
-
- if (field.FieldType.IsClass || field.FieldType == typeof(IntPtr))
- fieldValue = MarshalToObject(field.FieldType, Marshal.ReadIntPtr(fieldPtr), out size);
- else
- {
- int fieldSize;
- Type fieldType = field.FieldType;
- if (field.FieldType.IsEnum)
- fieldType = field.FieldType.GetEnumUnderlyingType();
- else if (field.FieldType == typeof(bool))
- fieldType = typeof(byte);
-
- if (fieldType.IsValueType && !fieldType.IsEnum && !fieldType.IsPrimitive) // Is it a structure?
- fieldSize = 1;
- else if (fieldType.IsClass || fieldType.IsPointer)
- fieldSize = IntPtr.Size;
- else
- fieldSize = Marshal.SizeOf(fieldType);
- fieldPtr = EnsureAlignment(fieldPtr, fieldSize);
-
- fieldValue = MarshalToObject(field.FieldType, fieldPtr, out size);
- }
-
- field.SetValue(target, fieldValue);
-
- fieldPtr = IntPtr.Add(fieldPtr, size);
+ IntPtr fieldStartPtr = fieldPtr;
+ fieldPtr = EnsureAlignment(fieldPtr, fieldAlignment);
+ fieldOffset += (fieldPtr - fieldStartPtr).ToInt32();
}
- var totalReadSize = fieldPtr.ToInt64() - ptr.ToInt64();
- Assert.IsTrue(totalReadSize == Marshal.SizeOf(type));
- readSize += (int)totalReadSize;
- return target;
+ ref TField fieldValueRef = ref GetFieldReference(field, ref fieldOwner);
+ MarshalHelperValueType.ToManaged(ref fieldValueRef, fieldPtr, false);
+ }
+
+ internal static void ToManagedFieldArray(FieldInfo field, ref T fieldOwner, IntPtr fieldPtr, out int fieldOffset)
+ {
+ fieldOffset = Unsafe.SizeOf();
+ if (fieldAlignment > 1)
+ {
+ IntPtr fieldStartPtr = fieldPtr;
+ fieldPtr = EnsureAlignment(fieldPtr, fieldAlignment);
+ fieldOffset += (fieldPtr - fieldStartPtr).ToInt32();
+ }
+
+ ref TField[] fieldValueRef = ref GetFieldReference(field, ref fieldOwner);
+ MarshalHelperValueType.ToManagedArray(ref fieldValueRef, fieldPtr, false);
+ }
+
+ internal static void ToNativeField(FieldInfo field, ref T fieldOwner, IntPtr fieldPtr, out int fieldOffset)
+ {
+ fieldOffset = Unsafe.SizeOf();
+ if (fieldAlignment > 1)
+ {
+ IntPtr startPtr = fieldPtr;
+ fieldPtr = EnsureAlignment(fieldPtr, fieldAlignment);
+ fieldOffset += (fieldPtr - startPtr).ToInt32();
+ }
+
+ if (field.IsInitOnly)
+ {
+ //TypedReference ownerRef = __makeref(fieldOwner);
+ //TField fieldValue = (TField)field.GetValueDirect(ownerRef);
+ TField fieldValue = (TField)field.GetValue(fieldOwner);
+ MarshalHelperValueType.ToNative(ref fieldValue, fieldPtr);
+ }
+ else
+ {
+ ref TField fieldValueRef = ref GetFieldReference(field, ref fieldOwner);
+ MarshalHelperValueType.ToNative(ref fieldValueRef, fieldPtr);
+ }
}
}
- else if (type.Name == "IDictionary")
- {
- readSize += IntPtr.Size;
- if (ptr == IntPtr.Zero)
- return null;
- return GCHandle.FromIntPtr(ptr).Target;
+ private static class ReferenceTypeField where TField : class
+ {
+ internal static void ToManagedField(FieldInfo field, ref T fieldOwner, IntPtr fieldPtr, out int fieldOffset)
+ {
+ ref TField fieldValueRef = ref GetFieldReference(field, ref fieldOwner);
+ MarshalHelperReferenceType.ToManaged(ref fieldValueRef, Marshal.ReadIntPtr(fieldPtr), false);
+ fieldOffset = IntPtr.Size;
+ }
+
+ internal static void ToNativeField(FieldInfo field, ref T fieldOwner, IntPtr fieldPtr, out int fieldOffset)
+ {
+ if (field.IsInitOnly)
+ {
+ //TypedReference ownerRef = __makeref(fieldOwner);
+ //TField fieldValue = (TField)field.GetValueDirect(ownerRef);
+ TField fieldValue = (TField)field.GetValue(fieldOwner);
+ MarshalHelperReferenceType.ToNative(ref fieldValue, fieldPtr);
+ }
+ else
+ {
+ ref TField fieldValueRef = ref GetFieldReference(field, ref fieldOwner);
+ MarshalHelperReferenceType.ToNative(ref fieldValueRef, fieldPtr);
+ }
+ fieldOffset = IntPtr.Size;
+ }
+ }
+ }
+
+ internal static class MarshalHelperValueType where T : struct
+ {
+ internal static void ToNativeWrapper(object managedObject, IntPtr nativePtr)
+ {
+ ToNative(ref Unsafe.Unbox(managedObject), nativePtr);
}
- readSize += Marshal.SizeOf(type);
- return Marshal.PtrToStructure(ptr, type);
+ internal static void ToNativeFieldWrapper(FieldInfo field, object fieldOwner, IntPtr nativePtr, out int fieldOffset)
+ {
+ MarshalHelper.ToNativeField(field, ref Unsafe.Unbox(fieldOwner), nativePtr, out fieldOffset);
+ }
+
+ internal static void ToManaged(ref T managedValue, IntPtr nativePtr, bool byRef)
+ {
+ Type type = typeof(T);
+ if (type.IsByRef || byRef)
+ {
+ if (type.IsByRef)
+ type = type.GetElementType();
+ Assert.IsTrue(type.IsValueType);
+ }
+
+ if (type == typeof(IntPtr))
+ managedValue = (T)(object)nativePtr;
+ else if (MarshalHelper.marshallableFields != null)
+ {
+ IntPtr fieldPtr = nativePtr;
+ for (int i = 0; i < MarshalHelper.marshallableFields.Length; i++)
+ {
+ MarshalHelper.toManagedFieldMarshallers[i](MarshalHelper.marshallableFields[i], ref managedValue, fieldPtr, out int fieldOffset);
+ fieldPtr += fieldOffset;
+ }
+
+ Assert.IsTrue((fieldPtr - nativePtr) == Unsafe.SizeOf());
+ }
+ else
+ managedValue = Unsafe.Read(nativePtr.ToPointer());
+ }
+
+ internal static void ToManagedArray(ref T[] managedValue, IntPtr nativePtr, bool byRef)
+ {
+ Assert.IsTrue(!byRef);
+
+ Type elementType = typeof(T);
+ if (nativePtr != IntPtr.Zero)
+ {
+ ManagedArray managedArray = Unsafe.As(GCHandle.FromIntPtr(nativePtr).Target);
+ if (ArrayFactory.GetMarshalledType(elementType) == elementType)
+ managedValue = Unsafe.As(managedArray.GetArray());
+ else
+ managedValue = Unsafe.As(MarshalHelper.ToManagedArray(managedArray.GetSpan()));
+ }
+ else
+ managedValue = null;
+ }
+
+ internal static void ToNative(ref T managedValue, IntPtr nativePtr)
+ {
+ if (typeof(T).IsByRef)
+ throw new NotImplementedException();
+
+ if (MarshalHelper.marshallableFields != null)
+ {
+ IntPtr fieldPtr = nativePtr;
+ for (int i = 0; i < MarshalHelper.marshallableFields.Length; i++)
+ {
+ MarshalHelper.toNativeFieldMarshallers[i](MarshalHelper.marshallableFields[i], ref managedValue, nativePtr, out int fieldOffset);
+ nativePtr += fieldOffset;
+ }
+
+ Assert.IsTrue((nativePtr - fieldPtr) == Unsafe.SizeOf());
+ }
+ else
+ Unsafe.AsRef(nativePtr.ToPointer()) = managedValue;
+ }
+ }
+
+ internal static class MarshalHelperReferenceType where T : class
+ {
+ internal static void ToNativeWrapper(object managedObject, IntPtr nativePtr)
+ {
+ T managedValue = Unsafe.As(managedObject);
+ ToNative(ref managedValue, nativePtr);
+ }
+
+ internal static void ToNativeFieldWrapper(FieldInfo field, object managedObject, IntPtr nativePtr, out int fieldOffset)
+ {
+ T managedValue = Unsafe.As(managedObject);
+ MarshalHelper.ToNativeField(field, ref managedValue, nativePtr, out fieldOffset);
+ }
+
+ internal static void ToManaged(ref T managedValue, IntPtr nativePtr, bool byRef)
+ {
+ Type type = typeof(T);
+ if (byRef)
+ nativePtr = Marshal.ReadIntPtr(nativePtr);
+
+ if (type == typeof(string))
+ managedValue = Unsafe.As(ManagedString.ToManaged(nativePtr));
+ else if (type.IsClass)
+ managedValue = nativePtr != IntPtr.Zero ? Unsafe.As(GCHandle.FromIntPtr(nativePtr).Target) : null;
+ else if (type.IsInterface) // Dictionary
+ managedValue = nativePtr != IntPtr.Zero ? Unsafe.As(GCHandle.FromIntPtr(nativePtr).Target) : null;
+ else
+ throw new NotImplementedException();
+ }
+
+ internal static void ToManagedArray(ref T[] managedValue, IntPtr nativePtr, bool byRef)
+ {
+ Assert.IsTrue(!byRef);
+
+ Type elementType = typeof(T);
+ if (nativePtr != IntPtr.Zero)
+ {
+ ManagedArray managedArray = Unsafe.As(GCHandle.FromIntPtr(nativePtr).Target);
+ managedValue = Unsafe.As(MarshalHelper.ToManagedArray(managedArray.GetSpan()));
+ }
+ else
+ managedValue = null;
+ }
+
+ internal static void ToNative(ref T managedValue, IntPtr nativePtr)
+ {
+ Type type = typeof(T);
+
+ IntPtr managedPtr;
+ if (type == typeof(string))
+ managedPtr = ManagedString.ToNative(managedValue as string);
+ else if (type.IsPointer)
+ {
+ if (Pointer.Unbox(managedValue) == null)
+ managedPtr = IntPtr.Zero;
+ else if (managedValue is FlaxEngine.Object flaxObj)
+ managedPtr = flaxObj.__unmanagedPtr;
+ else
+ managedPtr = GCHandle.ToIntPtr(GCHandle.Alloc(managedValue, GCHandleType.Weak));
+ }
+ else if (type == typeof(Type))
+ managedPtr = managedValue != null ? GCHandle.ToIntPtr(GetOrAddTypeGCHandle((Type)(object)managedValue)) : IntPtr.Zero;
+ else
+ managedPtr = managedValue != null ? GCHandle.ToIntPtr(GCHandle.Alloc(managedValue, GCHandleType.Weak)) : IntPtr.Zero;
+
+ Unsafe.Write(nativePtr.ToPointer(), managedPtr);
+ }
+ }
+
+ internal class FieldBlob
+ {
+ internal FieldInfo field;
+ internal MarshalToNativeFieldDelegate toNativeMarshaller;
+
+ internal FieldBlob(FieldInfo field, Type type)
+ {
+ this.field = field;
+ toNativeMarshaller = GetToNativeFieldMarshallerDelegate(type);
+ }
+ }
+
+ internal class MethodBlob
+ {
+ internal Type[] parameterTypes;
+ internal MethodInfo method;
+ private Invoker.MarshalAndInvokeDelegate invokeDelegate;
+ private object delegInvoke;
+
+ internal MethodBlob(MethodInfo method)
+ {
+ this.method = method;
+ parameterTypes = method.GetParameters().Select(x => x.ParameterType).ToArray();
+ }
+
+ internal bool TryGetDelegate(out Invoker.MarshalAndInvokeDelegate outDeleg, out object outDelegInvoke)
+ {
+ if (invokeDelegate == null)
+ {
+ List methodTypes = new List();
+ if (!method.IsStatic)
+ methodTypes.Add(method.DeclaringType);
+ if (method.ReturnType != typeof(void))
+ methodTypes.Add(method.ReturnType);
+ methodTypes.AddRange(parameterTypes);
+
+ List genericParamTypes = new List();
+ foreach (var type in methodTypes)
+ {
+ if (type.IsByRef)
+ genericParamTypes.Add(type.GetElementType());
+ else if (type.IsPointer)
+ genericParamTypes.Add(typeof(IntPtr));
+ else
+ genericParamTypes.Add(type);
+ }
+
+ string typeName = $"FlaxEngine.NativeInterop+Invoker+Invoker{(method.IsStatic ? "Static" : "")}{(method.ReturnType != typeof(void) ? "Ret" : "NoRet")}{parameterTypes.Length}{(genericParamTypes.Count > 0 ? "`" + genericParamTypes.Count : "")}";
+ Type invokerType = genericParamTypes.Count == 0 ? Type.GetType(typeName) : Type.GetType(typeName).MakeGenericType(genericParamTypes.ToArray());
+ invokeDelegate = invokerType.GetMethod(nameof(Invoker.InvokerStaticNoRet0.MarshalAndInvoke), BindingFlags.Static | BindingFlags.NonPublic).CreateDelegate();
+ delegInvoke = invokerType.GetMethod(nameof(Invoker.InvokerStaticNoRet0.CreateDelegate), BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, new object[] { method });
+ }
+
+ outDeleg = invokeDelegate;
+ outDelegInvoke = delegInvoke;
+
+ return outDeleg != null;
+ }
}
internal static GCHandle GetMethodGCHandle(MethodInfo method)
{
- Type[] parameterTypes = method.GetParameters().Select(x => x.ParameterType).ToArray();
+ MethodBlob methodBlob = new MethodBlob(method);
- GCHandle delegTupleHandle = GCHandle.Alloc(new Tuple(parameterTypes, method));
-
- if (parameterTypes.Any(x => x.IsCollectible) || method.IsCollectible)
- methodHandlesCollectible.Add(delegTupleHandle);
+ GCHandle handle = GCHandle.Alloc(methodBlob);
+ if (methodBlob.parameterTypes.Any(x => x.IsCollectible) || method.IsCollectible)
+ methodHandlesCollectible.Add(handle);
else
- methodHandles.Add(delegTupleHandle);
-
- return delegTupleHandle;
+ methodHandles.Add(handle);
+ return handle;
}
internal static GCHandle GetAssemblyHandle(Assembly assembly)
@@ -1192,7 +1552,7 @@ namespace FlaxEngine
[UnmanagedCallersOnly]
internal static unsafe void GetManagedClasses(IntPtr assemblyHandle, ManagedClass** managedClasses, int* managedClassCount)
{
- Assembly assembly = (Assembly)GCHandle.FromIntPtr(assemblyHandle).Target;
+ Assembly assembly = Unsafe.As(GCHandle.FromIntPtr(assemblyHandle).Target);
var assemblyTypes = GetAssemblyTypes(assembly);
ManagedClass* arr = (ManagedClass*)Marshal.AllocCoTaskMem(Unsafe.SizeOf() * assemblyTypes.Length).ToPointer();
@@ -1215,7 +1575,7 @@ namespace FlaxEngine
@namespace = Marshal.StringToCoTaskMemAnsi(type.Namespace ?? ""),
typeAttributes = (uint)type.Attributes,
};
- Marshal.StructureToPtr(managedClass, ptr, false);
+ Unsafe.Write(ptr.ToPointer(), managedClass);
}
*managedClasses = arr;
@@ -1225,8 +1585,7 @@ namespace FlaxEngine
[UnmanagedCallersOnly]
internal static unsafe void GetManagedClassFromType(IntPtr typeHandle, ManagedClass* managedClass, IntPtr* assemblyHandle)
{
- var type = (Type)GCHandle.FromIntPtr(typeHandle).Target;
-
+ Type type = Unsafe.As(GCHandle.FromIntPtr(typeHandle).Target);
GCHandle classTypeHandle = GetOrAddTypeGCHandle(type);
*managedClass = new ManagedClass()
@@ -1243,15 +1602,15 @@ namespace FlaxEngine
[UnmanagedCallersOnly]
internal static void GetClassMethods(IntPtr typeHandle, ClassMethod** classMethods, int* classMethodsCount)
{
- Type type = (Type)GCHandle.FromIntPtr(typeHandle).Target;
+ Type type = Unsafe.As(GCHandle.FromIntPtr(typeHandle).Target);
List methods = new List();
var staticMethods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
var instanceMethods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
- foreach (MethodInfo methodInfo in staticMethods)
- methods.Add(methodInfo);
- foreach (MethodInfo methodInfo in instanceMethods)
- methods.Add(methodInfo);
+ foreach (MethodInfo method in staticMethods)
+ methods.Add(method);
+ foreach (MethodInfo method in instanceMethods)
+ methods.Add(method);
ClassMethod* arr = (ClassMethod*)Marshal.AllocCoTaskMem(Unsafe.SizeOf() * methods.Count).ToPointer();
for (int i = 0; i < methods.Count; i++)
@@ -1264,7 +1623,7 @@ namespace FlaxEngine
methodAttributes = (uint)methods[i].Attributes,
};
classMethod.typeHandle = GCHandle.ToIntPtr(GetMethodGCHandle(methods[i]));
- Marshal.StructureToPtr(classMethod, ptr, false);
+ Unsafe.Write(ptr.ToPointer(), classMethod);
}
*classMethods = arr;
*classMethodsCount = methods.Count;
@@ -1273,7 +1632,7 @@ namespace FlaxEngine
[UnmanagedCallersOnly]
internal static void GetClassFields(IntPtr typeHandle, ClassField** classFields, int* classFieldsCount)
{
- Type type = (Type)GCHandle.FromIntPtr(typeHandle).Target;
+ Type type = Unsafe.As(GCHandle.FromIntPtr(typeHandle).Target);
var fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
ClassField* arr = (ClassField*)Marshal.AllocCoTaskMem(Unsafe.SizeOf() * fields.Length).ToPointer();
@@ -1281,7 +1640,9 @@ namespace FlaxEngine
{
IntPtr ptr = IntPtr.Add(new IntPtr(arr), Unsafe.SizeOf() * i);
- GCHandle fieldHandle = GCHandle.Alloc(fields[i]);
+ FieldBlob fieldBlob = new FieldBlob(fields[i], type);
+
+ GCHandle fieldHandle = GCHandle.Alloc(fieldBlob);
if (type.IsCollectible)
fieldHandleCacheCollectible.Add(fieldHandle);
else
@@ -1289,12 +1650,12 @@ namespace FlaxEngine
ClassField classField = new ClassField()
{
- name = Marshal.StringToCoTaskMemAnsi(fields[i].Name),
+ name = Marshal.StringToCoTaskMemAnsi(fieldBlob.field.Name),
fieldHandle = GCHandle.ToIntPtr(fieldHandle),
- fieldTypeHandle = GCHandle.ToIntPtr(GetOrAddTypeGCHandle(fields[i].FieldType)),
- fieldAttributes = (uint)fields[i].Attributes,
+ fieldTypeHandle = GCHandle.ToIntPtr(GetOrAddTypeGCHandle(fieldBlob.field.FieldType)),
+ fieldAttributes = (uint)fieldBlob.field.Attributes,
};
- Marshal.StructureToPtr(classField, ptr, false);
+ Unsafe.Write(ptr.ToPointer(), classField);
}
*classFields = arr;
*classFieldsCount = fields.Length;
@@ -1303,7 +1664,7 @@ namespace FlaxEngine
[UnmanagedCallersOnly]
internal static void GetClassProperties(IntPtr typeHandle, ClassProperty** classProperties, int* classPropertiesCount)
{
- Type type = (Type)GCHandle.FromIntPtr(typeHandle).Target;
+ Type type = Unsafe.As(GCHandle.FromIntPtr(typeHandle).Target);
var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
ClassProperty* arr = (ClassProperty*)Marshal.AllocCoTaskMem(Unsafe.SizeOf() * properties.Length).ToPointer();
@@ -1328,7 +1689,7 @@ namespace FlaxEngine
var setterHandle = GetMethodGCHandle(setterMethod);
classProperty.setterHandle = GCHandle.ToIntPtr(setterHandle);
}
- Marshal.StructureToPtr(classProperty, ptr, false);
+ Unsafe.Write(ptr.ToPointer(), classProperty);
}
*classProperties = arr;
*classPropertiesCount = properties.Length;
@@ -1337,7 +1698,7 @@ namespace FlaxEngine
[UnmanagedCallersOnly]
internal static void GetClassAttributes(IntPtr typeHandle, ClassAttribute** classAttributes, int* classAttributesCount)
{
- Type type = (Type)GCHandle.FromIntPtr(typeHandle).Target;
+ Type type = Unsafe.As(GCHandle.FromIntPtr(typeHandle).Target);
object[] attributeValues = type.GetCustomAttributes(false);
Type[] attributeTypes = type.GetCustomAttributes(false).Select(x => x.GetType()).ToArray();
@@ -1359,7 +1720,7 @@ namespace FlaxEngine
attributeTypeHandle = GCHandle.ToIntPtr(attributeTypeHandle),
attributeHandle = GCHandle.ToIntPtr(attributeHandle),
};
- Marshal.StructureToPtr(classAttribute, ptr, false);
+ Unsafe.Write(ptr.ToPointer(), classAttribute);
}
*classAttributes = arr;
*classAttributesCount = attributeTypes.Length;
@@ -1368,8 +1729,8 @@ namespace FlaxEngine
[UnmanagedCallersOnly]
internal static IntPtr GetCustomAttribute(IntPtr typeHandle, IntPtr attribHandle)
{
- Type type = (Type)GCHandle.FromIntPtr(typeHandle).Target;
- Type attribType = (Type)GCHandle.FromIntPtr(attribHandle).Target;
+ Type type = Unsafe.As(GCHandle.FromIntPtr(typeHandle).Target);
+ Type attribType = Unsafe.As(GCHandle.FromIntPtr(attribHandle).Target);
object attrib = type.GetCustomAttributes(false).FirstOrDefault(x => x.GetType() == attribType);
if (attrib != null)
@@ -1380,9 +1741,8 @@ namespace FlaxEngine
[UnmanagedCallersOnly]
internal static void GetClassInterfaces(IntPtr typeHandle, IntPtr* classInterfaces, int* classInterfacesCount)
{
- Type type = (Type)GCHandle.FromIntPtr(typeHandle).Target;
-
- var interfaces = type.GetInterfaces();
+ Type type = Unsafe.As(GCHandle.FromIntPtr(typeHandle).Target);
+ Type[] interfaces = type.GetInterfaces();
// mono doesn't seem to return any interfaces, or returns only "immediate" interfaces? // FIXME?
//foreach (Type interfaceType in type.BaseType.GetInterfaces())
@@ -1403,8 +1763,8 @@ namespace FlaxEngine
[UnmanagedCallersOnly]
internal static IntPtr GetMethodReturnType(IntPtr methodHandle)
{
- (Type[] parameterTypes, MethodInfo methodInfo) = (Tuple