Add project files.

Author: JunaMeinhold

Hexa.NET.Utilities.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.10.35027.167
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Hexa.NET.Utilities", "Hexa.NET.Utilities\Hexa.NET.Utilities.csproj", "{055E63D3-810C-4289-97D4-E27BCDB86548}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{055E63D3-810C-4289-97D4-E27BCDB86548}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{055E63D3-810C-4289-97D4-E27BCDB86548}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{055E63D3-810C-4289-97D4-E27BCDB86548}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{055E63D3-810C-4289-97D4-E27BCDB86548}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {33E217DF-77B4-4AE7-8F53-548592C9A6DD}
+	EndGlobalSection
+EndGlobal

Hexa.NET.Utilities/AllocationCallbacks.cs

@@ -0,0 +1,132 @@
+namespace HexaEngine.Core.Unsafes
+{
+    using System.Runtime.InteropServices;
+
+    public unsafe class AllocationCallbacks : IAllocationCallbacks
+    {
+#if TRACELEAK
+        private readonly List<Allocation> allocations = [];
+
+        public IReadOnlyList<Allocation> Allocations => allocations;
+#endif
+#if TRACELEAK
+
+        public struct Allocation
+        {
+            public void* Ptr;
+            public nint Size;
+            public string Caller;
+
+            public Allocation(void* ptr, nint size, string caller)
+            {
+                Ptr = ptr;
+                Size = size;
+                Caller = caller;
+            }
+        }
+
+#endif
+
+#if TRACELEAK
+
+        private void Remove(void* ptr)
+        {
+            if (ptr == null)
+            {
+                return;
+            }
+
+            lock (allocations)
+            {
+                for (int i = 0; i < allocations.Count; i++)
+                {
+                    Allocation allocation = allocations[i];
+                    if (allocation.Ptr == ptr)
+                    {
+                        allocations.RemoveAt(i);
+                        return;
+                    }
+                }
+            }
+        }
+
+#endif
+
+        public void ReportInstances()
+        {
+#if TRACELEAK
+            lock (allocations)
+            {
+                foreach (Allocation allocation in allocations)
+                {
+                    Logger.Warn($"*** Live allocation ({allocation.Caller}):\n\t{(nint)allocation.Ptr:X}\n\tSize: {allocation.Size}\n");
+                }
+            }
+#endif
+        }
+
+        public void ReportDuplicateInstances()
+        {
+#if TRACELEAK
+            lock (allocations)
+            {
+                foreach (Allocation allocation in allocations)
+                {
+                    foreach (Allocation allocationCmp in allocations)
+                    {
+                        if (allocation.Caller == allocationCmp.Caller && allocation.Size == allocationCmp.Size)
+                        {
+                            Logger.Warn($"*** Possible duplicate instance ({allocation.Caller}):\n\t{(nint)allocation.Ptr:X}\n\tSize: {allocation.Size}\n");
+                        }
+                    }
+                }
+            }
+#endif
+        }
+
+        public void* Alloc(nint size
+#if TRACELEAK
+            , string name
+#endif
+            )
+        {
+            void* ptr = (void*)Marshal.AllocHGlobal(size); ;
+#if TRACELEAK
+            Allocation allocation = new(ptr, size, name);
+            lock (allocations)
+            {
+                allocations.Add(allocation);
+            }
+#endif
+            return ptr;
+        }
+
+        public void* ReAlloc(void* ptr, nint size
+#if TRACELEAK
+            , string name
+#endif
+            )
+        {
+#if TRACELEAK
+            Remove(ptr);
+#endif
+            ptr = (void*)Marshal.ReAllocHGlobal((nint)ptr, size); ;
+#if TRACELEAK
+            Allocation allocation = new(ptr, size, name);
+            lock (allocations)
+            {
+                allocations.Add(allocation);
+            }
+#endif
+            return ptr;
+        }
+
+        public void Free(void* ptr)
+        {
+#if TRACELEAK
+            Remove(ptr);
+#endif
+            Marshal.FreeHGlobal((nint)ptr);
+        }
+    }
+}

Hexa.NET.Utilities/ArrayUtils.cs

@@ -0,0 +1,75 @@
+namespace HexaEngine.Core
+{
+    using System;
+
+    /// <summary>
+    /// Utilities for managed and unmanaged arrays.
+    /// </summary>
+    public static unsafe class ArrayUtils
+    {
+        /// <summary>
+        /// Adds a value to an array and resizes it to accommodate the new value.
+        /// </summary>
+        /// <typeparam name="T">The type of elements in the array.</typeparam>
+        /// <param name="array">Reference to the array to which the value will be added.</param>
+        /// <param name="value">The value to add to the array.</param>
+        public static void Add<T>(ref T[] array, T value)
+        {
+            Array.Resize(ref array, array.Length + 1);
+            array[^1] = value;
+        }
+
+        /// <summary>
+        /// Removes the first occurrence of a value from an array and resizes it accordingly.
+        /// </summary>
+        /// <typeparam name="T">The type of elements in the array.</typeparam>
+        /// <param name="array">Reference to the array from which the value will be removed.</param>
+        /// <param name="value">The value to remove from the array.</param>
+        public static void Remove<T>(ref T[] array, T value)
+        {
+            int index = Array.IndexOf(array, value);
+            var count = array.Length - index;
+            Buffer.BlockCopy(array, index + 1, array, index, count);
+            Array.Resize(ref array, array.Length - 1);
+        }
+
+        /// <summary>
+        /// Adds a value to a list if it doesn't already exist and returns a boolean indicating success.
+        /// </summary>
+        /// <typeparam name="T">The type of elements in the list.</typeparam>
+        /// <param name="list">The list to which the value will be added.</param>
+        /// <param name="t">The value to add to the list.</param>
+        /// <returns>Returns true if the value was added (not already in the list), otherwise false.</returns>
+        public static bool AddUnique<T>(this IList<T> list, T t)
+        {
+            if (list.Contains(t))
+            {
+                return false;
+            }
+
+            list.Add(t);
+
+            return true;
+        }
+
+        /// <summary>
+        /// Finds the index of a specified item within an unmanaged array.
+        /// </summary>
+        /// <typeparam name="T">The type of elements in the array.</typeparam>
+        /// <param name="ptr">Pointer to the beginning of the array.</param>
+        /// <param name="item">Pointer to the item to search for.</param>
+        /// <param name="count">The number of items in the array.</param>
+        /// <returns>The index of the item if found; otherwise, -1.</returns>
+        public static int IndexOf<T>(T* ptr, T* item, int count) where T : unmanaged
+        {
+            for (int i = 0; i < count; i++)
+            {
+                if (&ptr[i] == item)
+                {
+                    return i;
+                }
+            }
+            return -1;
+        }
+    }
+}