com.wallstop-studios.unity-helpers 2.0.0-rc26 → 2.0.0-rc30

package/Runtime/Core/Helper/Partials/ObjectHelpers.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 321716db87b24857a466b1c6c895c72b
+fileFormatVersion: 2
+guid: 321716db87b24857a466b1c6c895c72b
 timeCreated: 1732646645

package/Runtime/Core/Helper/Partials/TransformHelpers.cs

@@ -1,167 +1,167 @@
-namespace UnityHelpers.Core.Helper
-{
-    using System.Collections.Generic;
-    using UnityEngine;
-
-    public static partial class Helpers
-    {
-        public static IEnumerable<GameObject> IterateOverChildGameObjects(
-            this GameObject gameObject
-        )
-        {
-            for (int i = 0; i < gameObject.transform.childCount; i++)
-            {
-                yield return gameObject.transform.GetChild(i).gameObject;
-            }
-        }
-
-        public static IEnumerable<GameObject> IterateOverChildGameObjectsRecursively(
-            this GameObject gameObject
-        )
-        {
-            for (int i = 0; i < gameObject.transform.childCount; i++)
-            {
-                GameObject child = gameObject.transform.GetChild(i).gameObject;
-                yield return child;
-                foreach (GameObject go in child.IterateOverChildGameObjectsRecursively())
-                {
-                    yield return go;
-                }
-            }
-        }
-
-        public static IEnumerable<GameObject> IterateOverChildGameObjectsRecursivelyIncludingSelf(
-            this GameObject gameObject
-        )
-        {
-            yield return gameObject;
-
-            for (int i = 0; i < gameObject.transform.childCount; ++i)
-            {
-                GameObject child = gameObject.transform.GetChild(i).gameObject;
-                foreach (
-                    GameObject c in child.IterateOverChildGameObjectsRecursivelyIncludingSelf()
-                )
-                {
-                    yield return c;
-                }
-            }
-        }
-
-        public static IEnumerable<GameObject> IterateOverParentGameObjects(
-            this GameObject gameObject
-        )
-        {
-            Transform currentTransform = gameObject.transform.parent;
-            while (currentTransform != null)
-            {
-                yield return currentTransform.gameObject;
-                currentTransform = currentTransform.parent;
-            }
-        }
-
-        public static IEnumerable<GameObject> IterateOverParentGameObjectsRecursivelyIncludingSelf(
-            this GameObject gameObject
-        )
-        {
-            yield return gameObject;
-
-            foreach (GameObject parent in IterateOverParentGameObjects(gameObject))
-            {
-                yield return parent;
-            }
-        }
-
-        public static IEnumerable<T> IterateOverAllChildComponentsRecursively<T>(
-            this Component component
-        )
-        {
-            if (component == null)
-            {
-                yield break;
-            }
-
-            foreach (T c in component.gameObject.GetComponents<T>())
-            {
-                yield return c;
-            }
-
-            for (int i = 0; i < component.transform.childCount; ++i)
-            {
-                Transform child = component.transform.GetChild(i);
-
-                foreach (T c in child.IterateOverAllChildComponentsRecursively<T>())
-                {
-                    yield return c;
-                }
-            }
-        }
-
-        public static IEnumerable<Transform> IterateOverAllChildren(this Component component)
-        {
-            if (component == null)
-            {
-                yield break;
-            }
-
-            for (int i = 0; i < component.transform.childCount; ++i)
-            {
-                yield return component.transform.GetChild(i);
-            }
-        }
-
-        public static IEnumerable<Transform> IterateOverAllParents(this Component component)
-        {
-            if (component == null)
-            {
-                yield break;
-            }
-
-            Transform transform = component.transform;
-            while (transform.parent != null)
-            {
-                yield return transform.parent;
-                transform = transform.parent;
-            }
-        }
-
-        public static IEnumerable<Transform> IterateOverAllParentsIncludingSelf(
-            this Component component
-        )
-        {
-            if (component == null)
-            {
-                yield break;
-            }
-
-            Transform transform = component.transform;
-            while (transform != null)
-            {
-                yield return transform;
-                transform = transform.parent;
-            }
-        }
-
-        public static IEnumerable<Transform> IterateOverAllChildrenRecursively(
-            this Component component
-        )
-        {
-            if (component == null)
-            {
-                yield break;
-            }
-
-            for (int i = 0; i < component.transform.childCount; ++i)
-            {
-                Transform childTransform = component.transform.GetChild(i);
-                yield return childTransform;
-                foreach (
-                    Transform childChildTransform in childTransform.IterateOverAllChildrenRecursively()
-                )
-                {
-                    yield return childChildTransform;
-                }
-            }
-        }
-    }
-}
+namespace UnityHelpers.Core.Helper
+{
+    using System.Collections.Generic;
+    using UnityEngine;
+
+    public static partial class Helpers
+    {
+        public static IEnumerable<GameObject> IterateOverChildGameObjects(
+            this GameObject gameObject
+        )
+        {
+            for (int i = 0; i < gameObject.transform.childCount; i++)
+            {
+                yield return gameObject.transform.GetChild(i).gameObject;
+            }
+        }
+
+        public static IEnumerable<GameObject> IterateOverChildGameObjectsRecursively(
+            this GameObject gameObject
+        )
+        {
+            for (int i = 0; i < gameObject.transform.childCount; i++)
+            {
+                GameObject child = gameObject.transform.GetChild(i).gameObject;
+                yield return child;
+                foreach (GameObject go in child.IterateOverChildGameObjectsRecursively())
+                {
+                    yield return go;
+                }
+            }
+        }
+
+        public static IEnumerable<GameObject> IterateOverChildGameObjectsRecursivelyIncludingSelf(
+            this GameObject gameObject
+        )
+        {
+            yield return gameObject;
+
+            for (int i = 0; i < gameObject.transform.childCount; ++i)
+            {
+                GameObject child = gameObject.transform.GetChild(i).gameObject;
+                foreach (
+                    GameObject c in child.IterateOverChildGameObjectsRecursivelyIncludingSelf()
+                )
+                {
+                    yield return c;
+                }
+            }
+        }
+
+        public static IEnumerable<GameObject> IterateOverParentGameObjects(
+            this GameObject gameObject
+        )
+        {
+            Transform currentTransform = gameObject.transform.parent;
+            while (currentTransform != null)
+            {
+                yield return currentTransform.gameObject;
+                currentTransform = currentTransform.parent;
+            }
+        }
+
+        public static IEnumerable<GameObject> IterateOverParentGameObjectsRecursivelyIncludingSelf(
+            this GameObject gameObject
+        )
+        {
+            yield return gameObject;
+
+            foreach (GameObject parent in IterateOverParentGameObjects(gameObject))
+            {
+                yield return parent;
+            }
+        }
+
+        public static IEnumerable<T> IterateOverAllChildComponentsRecursively<T>(
+            this Component component
+        )
+        {
+            if (component == null)
+            {
+                yield break;
+            }
+
+            foreach (T c in component.gameObject.GetComponents<T>())
+            {
+                yield return c;
+            }
+
+            for (int i = 0; i < component.transform.childCount; ++i)
+            {
+                Transform child = component.transform.GetChild(i);
+
+                foreach (T c in child.IterateOverAllChildComponentsRecursively<T>())
+                {
+                    yield return c;
+                }
+            }
+        }
+
+        public static IEnumerable<Transform> IterateOverAllChildren(this Component component)
+        {
+            if (component == null)
+            {
+                yield break;
+            }
+
+            for (int i = 0; i < component.transform.childCount; ++i)
+            {
+                yield return component.transform.GetChild(i);
+            }
+        }
+
+        public static IEnumerable<Transform> IterateOverAllParents(this Component component)
+        {
+            if (component == null)
+            {
+                yield break;
+            }
+
+            Transform transform = component.transform;
+            while (transform.parent != null)
+            {
+                yield return transform.parent;
+                transform = transform.parent;
+            }
+        }
+
+        public static IEnumerable<Transform> IterateOverAllParentsIncludingSelf(
+            this Component component
+        )
+        {
+            if (component == null)
+            {
+                yield break;
+            }
+
+            Transform transform = component.transform;
+            while (transform != null)
+            {
+                yield return transform;
+                transform = transform.parent;
+            }
+        }
+
+        public static IEnumerable<Transform> IterateOverAllChildrenRecursively(
+            this Component component
+        )
+        {
+            if (component == null)
+            {
+                yield break;
+            }
+
+            for (int i = 0; i < component.transform.childCount; ++i)
+            {
+                Transform childTransform = component.transform.GetChild(i);
+                yield return childTransform;
+                foreach (
+                    Transform childChildTransform in childTransform.IterateOverAllChildrenRecursively()
+                )
+                {
+                    yield return childChildTransform;
+                }
+            }
+        }
+    }
+}

package/Runtime/Core/Helper/Partials/TransformHelpers.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 6fa254f39ddb413799e14fc26fccc6ea
+fileFormatVersion: 2
+guid: 6fa254f39ddb413799e14fc26fccc6ea
 timeCreated: 1732647396

package/Runtime/Core/Helper/Partials.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 4316246bccd04b778b1bdeee96f54110
+fileFormatVersion: 2
+guid: 4316246bccd04b778b1bdeee96f54110
 timeCreated: 1732646634

package/Runtime/Core/Helper/ReflectionHelpers.cs

@@ -0,0 +1,152 @@
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Reflection;
+    using System.Reflection.Emit;
+    using System.Runtime.CompilerServices;
+    using Extension;
+
+    public static class ReflectionHelpers
+    {
+        private static readonly Dictionary<Type, Func<int, Array>> ArrayCreators = new();
+        private static readonly Dictionary<Type, Func<IList>> ListCreators = new();
+        private static readonly Dictionary<Type, Func<int, IList>> ListWithCapacityCreators = new();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Func<int, Array> GetOrCreateArrayCreator(Type type)
+        {
+            return ArrayCreators.GetOrAdd(type, elementType => GetArrayCreator(elementType));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Array CreateArray(Type type, int length)
+        {
+            return GetOrCreateArrayCreator(type).Invoke(length);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static IList CreateList(Type elementType, int length)
+        {
+            return ListWithCapacityCreators
+                .GetOrAdd(elementType, type => GetListWithCapacityCreator(type))
+                .Invoke(length);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static IList CreateList(Type elementType)
+        {
+            return ListCreators.GetOrAdd(elementType, type => GetListCreator(type)).Invoke();
+        }
+
+        public static Action<object, object> CreateFieldSetter(Type type, FieldInfo field)
+        {
+#if WEB_GL
+            return field.SetValue;
+#else
+            DynamicMethod dynamicMethod = new(
+                $"SetField{field.Name}",
+                null,
+                new[] { typeof(object), typeof(object) },
+                type.Module,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+
+            il.Emit(OpCodes.Ldarg_0); // Load the object (arg0)
+            il.Emit(OpCodes.Castclass, type); // Cast to the actual type
+
+            il.Emit(OpCodes.Ldarg_1); // Load the value (arg1)
+            il.Emit(
+                field.FieldType.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass,
+                field.FieldType
+            ); // Cast for reference types
+            // Unbox if it's a value type
+            il.Emit(OpCodes.Stfld, field); // Set the field
+            il.Emit(OpCodes.Ret); // Return
+            return (Action<object, object>)
+                dynamicMethod.CreateDelegate(typeof(Action<object, object>));
+#endif
+        }
+
+        public static Func<int, Array> GetArrayCreator(Type elementType)
+        {
+#if WEB_GL
+            return size => Array.CreateInstance(elementType, size);
+#else
+
+            DynamicMethod dynamicMethod = new DynamicMethod(
+                $"CreateArray{elementType.Namespace}",
+                typeof(Array), // Return type: Array
+                new[] { typeof(int) }, // Parameter: int (size)
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+            il.Emit(OpCodes.Ldarg_0); // Load the array size
+            il.Emit(OpCodes.Newarr, elementType); // Create a new array of 'type'
+            il.Emit(OpCodes.Ret); // Return the array
+            return (Func<int, Array>)dynamicMethod.CreateDelegate(typeof(Func<int, Array>));
+#endif
+        }
+
+        public static Func<IList> GetListCreator(Type elementType)
+        {
+            Type listType = typeof(List<>).MakeGenericType(elementType);
+#if WEB_GL
+            return () => (IList)Activator.CreateInstance(listType);
+#else
+            DynamicMethod dynamicMethod = new DynamicMethod(
+                $"CreateList{listType.Name}",
+                typeof(IList), // Return type: IList
+                Type.EmptyTypes, // No parameters
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+            ConstructorInfo constructor = listType.GetConstructor(Type.EmptyTypes);
+            if (constructor == null)
+            {
+                throw new ArgumentException(
+                    $"Type {listType} does not have a parameterless constructor."
+                );
+            }
+
+            il.Emit(OpCodes.Newobj, constructor); // Call List<T> constructor
+            il.Emit(OpCodes.Ret); // Return the instance
+            return (Func<IList>)dynamicMethod.CreateDelegate(typeof(Func<IList>));
+#endif
+        }
+
+        public static Func<int, IList> GetListWithCapacityCreator(Type elementType)
+        {
+            Type listType = typeof(List<>).MakeGenericType(elementType);
+#if WEB_GL
+            return _ => (IList)Activator.CreateInstance(listType);
+#else
+            DynamicMethod dynamicMethod = new DynamicMethod(
+                $"CreateListWithCapacity{listType.Name}",
+                typeof(IList), // Return type: IList
+                new[] { typeof(int) }, // Parameter: int (size)
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+            ConstructorInfo constructor = listType.GetConstructor(new[] { typeof(int) });
+            if (constructor == null)
+            {
+                throw new ArgumentException(
+                    $"Type {listType} does not have a constructor accepting an int."
+                );
+            }
+
+            il.Emit(OpCodes.Ldarg_0); // Load capacity argument
+            il.Emit(OpCodes.Newobj, constructor); // Call List<T>(int capacity) constructor
+            il.Emit(OpCodes.Ret); // Return the instance
+            return (Func<int, IList>)dynamicMethod.CreateDelegate(typeof(Func<int, IList>));
+#endif
+        }
+    }
+}

package/Runtime/Core/Helper/ReflectionHelpers.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7d4e9b4eb4764c7881cc89a54582ec35
+timeCreated: 1742066830