Class ValueTypeUnboxer

Source/Engine/Engine/NativeInterop.cs:1527–1603

        }

        internal static class ValueTypeUnboxer
        {
            private static GCHandle[] pinnedBoxedValues = new GCHandle[256];
            private static uint pinnedBoxedValuesPointer = 0;
            private static (IntPtr ptr, int size)[] pinnedAllocations = new (IntPtr ptr, int size)[256];
            private static uint pinnedAllocationsPointer = 0;

            private delegate IntPtr UnboxerDelegate(object value, object converter);

            private static ConcurrentDictionary<Type, (UnboxerDelegate deleg, object toNativeDeleg)> unboxers = new(1, 3);
            private static MethodInfo unboxerMethod = typeof(ValueTypeUnboxer).GetMethod(nameof(ValueTypeUnboxer.UnboxPointer), BindingFlags.Static | BindingFlags.NonPublic);
            private static MethodInfo unboxerToNativeMethod = typeof(ValueTypeUnboxer).GetMethod(nameof(ValueTypeUnboxer.UnboxPointerWithConverter), BindingFlags.Static | BindingFlags.NonPublic);

            internal static IntPtr GetPointer(object value, Type type)
            {
                if (!unboxers.TryGetValue(type, out var tuple))
                {
                    // Non-POD structures use internal layout (eg. SpriteHandleManaged in C++ with SpriteHandleMarshaller.SpriteHandleInternal in C#) so convert C# data into C++ data
                    var attr = type.GetCustomAttribute<System.Runtime.InteropServices.Marshalling.NativeMarshallingAttribute>();
                    var toNativeMethod = attr?.NativeType.GetMethod("ToNative", BindingFlags.Static | BindingFlags.NonPublic);
                    if (toNativeMethod != null)
                    {
                        tuple.deleg = unboxerToNativeMethod.MakeGenericMethod(type, toNativeMethod.ReturnType).CreateDelegate<UnboxerDelegate>();
                        tuple.toNativeDeleg = toNativeMethod.CreateDelegate(typeof(ToNativeDelegate<,>).MakeGenericType(type, toNativeMethod.ReturnType));
                    }
                    else
                    {
                        tuple.deleg = unboxerMethod.MakeGenericMethod(type).CreateDelegate<UnboxerDelegate>();
                    }
                    tuple = unboxers.GetOrAdd(type, tuple);
                }
                return tuple.deleg(value, tuple.toNativeDeleg);
            }

            private static void PinValue(object value)
            {
                // Prevent garbage collector from relocating the boxed value by pinning it temporarily.
                // The pointer should remain valid quite long time but will be eventually unpinned.
                uint index = Interlocked.Increment(ref pinnedBoxedValuesPointer) % (uint)pinnedBoxedValues.Length;
                ref GCHandle handle = ref pinnedBoxedValues[index];
                if (handle.IsAllocated)
                    handle.Free();
                handle = GCHandle.Alloc(value, GCHandleType.Pinned);
            }

            private static IntPtr PinValue<T>(T value) where T : struct
            {
                // Store the converted value in unmanaged memory so it will not be relocated by the garbage collector.
                int size = TypeHelpers<T>.MarshalSize;
                uint index = Interlocked.Increment(ref pinnedAllocationsPointer) % (uint)pinnedAllocations.Length;
                ref (IntPtr ptr, int size) alloc = ref pinnedAllocations[index];
                if (alloc.size < size)
                {
                    if (alloc.ptr != IntPtr.Zero)
                        NativeFree(alloc.ptr.ToPointer());
                    alloc.ptr = new IntPtr(NativeAlloc(size));
                    alloc.size = size;
                }