Fix visibility of some internal NativeInterop methods for game bindings

Source/Engine/Engine/NativeInterop.cs

@@ -24,7 +24,8 @@ namespace FlaxEngine.Interop
     /// <summary>
     /// Provides a Mono-like API for native code to access managed runtime.
     /// </summary>
-    internal static unsafe partial class NativeInterop
+    [HideInEditor]
+    public static unsafe partial class NativeInterop
     {
         internal static Dictionary<string, string> AssemblyLocations = new();
 
@@ -147,7 +148,13 @@ namespace FlaxEngine.Interop
             NativeMemory.AlignedFree(ptr);
         }
 
-        internal static T[] GCHandleArrayToManagedArray<T>(ManagedArray ptrArray) where T : class
+        /// <summary>
+        /// Converts array of GC Handles from native runtime to managed array.
+        /// </summary>
+        /// <typeparam name="T">Array element type.</typeparam>
+        /// <param name="ptrArray">Input array.</param>
+        /// <returns>Output array.</returns>
+        public static T[] GCHandleArrayToManagedArray<T>(ManagedArray ptrArray) where T : class
         {
             Span<IntPtr> span = ptrArray.ToSpan<IntPtr>();
             T[] managedArray = new T[ptrArray.Length];
@@ -156,7 +163,12 @@ namespace FlaxEngine.Interop
             return managedArray;
         }
 
-        internal static IntPtr[] ManagedArrayToGCHandleArray(Array array)
+        /// <summary>
+        /// Converts managed array wrapper into array of GC Handles for native runtime.
+        /// </summary>
+        /// <param name="array">Input array.</param>
+        /// <returns>Output array.</returns>
+        public static IntPtr[] ManagedArrayToGCHandleArray(Array array)
         {
             if (array.Length == 0)
                 return Array.Empty<IntPtr>();
@@ -170,13 +182,26 @@ namespace FlaxEngine.Interop
             return pointerArray;
         }
 
-        internal static ManagedArray ManagedArrayToGCHandleWrappedArray(Array array)
+        /// <summary>
+        /// Converts managed array wrapper into array of GC Handles for native runtime.
+        /// </summary>
+        /// <param name="array">Input array.</param>
+        /// <returns>Output array.</returns>
+        public static ManagedArray ManagedArrayToGCHandleWrappedArray(Array array)
         {
             IntPtr[] pointerArray = ManagedArrayToGCHandleArray(array);
             return ManagedArray.WrapNewArray(pointerArray, array.GetType());
         }
 
-        internal static TDst[] ConvertArray<TSrc, TDst>(Span<TSrc> src, Func<TSrc, TDst> convertFunc)
+        /// <summary>
+        /// Converts array with a custom converter function for each element.
+        /// </summary>
+        /// <typeparam name="TSrc">Input data type.</typeparam>
+        /// <typeparam name="TDst">Output data type.</typeparam>
+        /// <param name="src">The input array.</param>
+        /// <param name="convertFunc">Converter callback.</param>
+        /// <returns>The output array.</returns>
+        public static TDst[] ConvertArray<TSrc, TDst>(Span<TSrc> src, Func<TSrc, TDst> convertFunc)
         {
             TDst[] dst = new TDst[src.Length];
             for (int i = 0; i < src.Length; i++)
@@ -184,7 +209,15 @@ namespace FlaxEngine.Interop
             return dst;
         }
 
-        internal static TDst[] ConvertArray<TSrc, TDst>(TSrc[] src, Func<TSrc, TDst> convertFunc)
+        /// <summary>
+        /// Converts array with a custom converter function for each element.
+        /// </summary>
+        /// <typeparam name="TSrc">Input data type.</typeparam>
+        /// <typeparam name="TDst">Output data type.</typeparam>
+        /// <param name="src">The input array.</param>
+        /// <param name="convertFunc">Converter callback.</param>
+        /// <returns>The output array.</returns>
+        public static TDst[] ConvertArray<TSrc, TDst>(TSrc[] src, Func<TSrc, TDst> convertFunc)
         {
             TDst[] dst = new TDst[src.Length];
             for (int i = 0; i < src.Length; i++)
@@ -1024,11 +1057,12 @@ namespace FlaxEngine.Interop
             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 TInternal ToNativeDelegate<T, TInternal>(T value);
+
             private delegate IntPtr UnboxerDelegate(object value, object converter);
 
-            private static ConcurrentDictionary<Type, (UnboxerDelegate deleg, object toNativeDeleg)> unboxers = new (1, 3);
+            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);
 
@@ -1089,7 +1123,8 @@ namespace FlaxEngine.Interop
                 return new IntPtr(Unsafe.AsPointer(ref Unsafe.Unbox<T>(value)));
             }
 
-            private static IntPtr UnboxPointerWithConverter<T, TInternal>(object value, object converter) where T : struct where TInternal : struct
+            private static IntPtr UnboxPointerWithConverter<T, TInternal>(object value, object converter) where T : struct
+                                                                                                          where TInternal : struct
             {
                 ToNativeDelegate<T, TInternal> toNative = Unsafe.As<ToNativeDelegate<T, TInternal>>(converter);
                 return PinValue<TInternal>(toNative(Unsafe.Unbox<T>(value)));