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

package/README.md

@@ -1,7 +1,19 @@
 # A Grab-Bag
 Various Unity Helpers. Includes many deterministic, seedable random number generators.
 
-# To Install as Unity Package
+# Compatibility
+| Platform | Compatible |
+| --- | --- |
+| Unity 2021 | Likely, but untested |
+| Unity 2022 | ✓ |
+| Unity 2023 | ✓ |
+| Unity 6 | ✓ |
+| URP | ✓ |
+| HDRP | ✓ |
+
+# Installation
+
+## To Install as Unity Package
 1. Open Unity Package Manager
 2. (Optional) Enable Pre-release packages to get the latest, cutting-edge builds
 3. Open the Advanced Package Settings
@@ -11,6 +23,12 @@ Various Unity Helpers. Includes many deterministic, seedable random number gener
     - Scope(s): `com.wallstop-studios.unity-helpers`
 5. Resolve the latest `com.wallstop-studios.unity-helpers`
 
+## From Source
+Grab a copy of this repo (either `git clone` or [download a zip of the source](https://github.com/wallstop/unity-helpers/archive/refs/heads/main.zip)) and copy the contents to your project's `Assets` folder.
+
+## From Releases
+Check out the latest [Releases](https://github.com/wallstop/unity-helpers/releases) to grab the Unity Package and import to your project.
+
 # Package Contents
 - Random Number Generators
 - Spatial Trees

package/Runtime/Core/Attributes/ChildComponentAttribute.cs

@@ -20,12 +20,15 @@
 
     public static class ChildComponentExtensions
     {
-        private static readonly Dictionary<Type, FieldInfo[]> FieldsByType = new();
+        private static readonly Dictionary<
+            Type,
+            (FieldInfo field, Action<object, object> setter)[]
+        > FieldsByType = new();
 
         public static void AssignChildComponents(this Component component)
         {
             Type componentType = component.GetType();
-            FieldInfo[] fields = FieldsByType.GetOrAdd(
+            (FieldInfo field, Action<object, object> setter)[] fields = FieldsByType.GetOrAdd(
                 componentType,
                 type =>
                 {
@@ -34,11 +37,12 @@
                     );
                     return fields
                         .Where(field => Attribute.IsDefined(field, typeof(ChildComponentAttribute)))
+                        .Select(field => (field, ReflectionHelpers.CreateFieldSetter(type, field)))
                         .ToArray();
                 }
             );
 
-            foreach (FieldInfo field in fields)
+            foreach ((FieldInfo field, Action<object, object> setter) in fields)
             {
                 Type fieldType = field.FieldType;
                 bool isArray = fieldType.IsArray;
@@ -59,12 +63,12 @@
 
                         foundChild = 0 < children.Count;
 
-                        Array correctTypedArray = Array.CreateInstance(
+                        Array correctTypedArray = ReflectionHelpers.CreateArray(
                             childComponentType,
                             children.Count
                         );
                         Array.Copy(children.ToArray(), correctTypedArray, children.Count);
-                        field.SetValue(component, correctTypedArray);
+                        setter(component, correctTypedArray);
                     }
                     else if (
                         fieldType.IsGenericType
@@ -72,11 +76,8 @@
                     )
                     {
                         childComponentType = fieldType.GenericTypeArguments[0];
-                        Type constructedListType = typeof(List<>).MakeGenericType(
-                            childComponentType
-                        );
-                        IList instance = (IList)Activator.CreateInstance(constructedListType);
 
+                        IList instance = ReflectionHelpers.CreateList(childComponentType);
                         foundChild = false;
                         foreach (
                             Component childComponent in component
@@ -90,7 +91,7 @@
                             foundChild = true;
                         }
 
-                        field.SetValue(component, instance);
+                        setter(component, instance);
                     }
                     else
                     {
@@ -107,7 +108,7 @@
                         }
                         if (foundChild)
                         {
-                            field.SetValue(component, childComponent);
+                            setter(component, childComponent);
                         }
                     }
                 }
@@ -121,12 +122,12 @@
                         );
                         foundChild = 0 < childComponents.Length;
 
-                        Array correctTypedArray = Array.CreateInstance(
+                        Array correctTypedArray = ReflectionHelpers.CreateArray(
                             childComponentType,
                             childComponents.Length
                         );
                         Array.Copy(childComponents, correctTypedArray, childComponents.Length);
-                        field.SetValue(component, correctTypedArray);
+                        setter(component, correctTypedArray);
                     }
                     else if (
                         fieldType.IsGenericType
@@ -134,11 +135,16 @@
                     )
                     {
                         childComponentType = fieldType.GenericTypeArguments[0];
-                        Type constructedListType = typeof(List<>).MakeGenericType(
-                            childComponentType
+
+                        Component[] children = component.GetComponentsInChildren(
+                            childComponentType,
+                            true
                         );
-                        IList instance = (IList)Activator.CreateInstance(constructedListType);
 
+                        IList instance = ReflectionHelpers.CreateList(
+                            childComponentType,
+                            children.Length
+                        );
                         foundChild = false;
                         foreach (
                             Component childComponent in component.GetComponentsInChildren(
@@ -151,7 +157,7 @@
                             foundChild = true;
                         }
 
-                        field.SetValue(component, instance);
+                        setter(component, instance);
                     }
                     else
                     {
@@ -162,7 +168,7 @@
                         foundChild = childComponent != null;
                         if (foundChild)
                         {
-                            field.SetValue(component, childComponent);
+                            setter(component, childComponent);
                         }
                     }
                 }

package/Runtime/Core/Attributes/ParentComponent.cs

@@ -6,6 +6,7 @@
     using System.Linq;
     using System.Reflection;
     using Extension;
+    using Helper;
     using JetBrains.Annotations;
     using UnityEngine;
 
@@ -19,12 +20,15 @@
 
     public static class ParentComponentExtensions
     {
-        private static readonly Dictionary<Type, FieldInfo[]> FieldsByType = new();
+        private static readonly Dictionary<
+            Type,
+            (FieldInfo field, Action<object, object> setter)[]
+        > FieldsByType = new();
 
         public static void AssignParentComponents(this Component component)
         {
             Type componentType = component.GetType();
-            FieldInfo[] fields = FieldsByType.GetOrAdd(
+            (FieldInfo field, Action<object, object> setter)[] fields = FieldsByType.GetOrAdd(
                 componentType,
                 type =>
                 {
@@ -35,11 +39,12 @@
                         .Where(field =>
                             Attribute.IsDefined(field, typeof(ParentComponentAttribute))
                         )
+                        .Select(field => (field, ReflectionHelpers.CreateFieldSetter(type, field)))
                         .ToArray();
                 }
             );
 
-            foreach (FieldInfo field in fields)
+            foreach ((FieldInfo field, Action<object, object> setter) in fields)
             {
                 Type fieldType = field.FieldType;
                 bool isArray = fieldType.IsArray;
@@ -61,12 +66,12 @@
                         );
                         foundParent = 0 < parentComponents.Length;
 
-                        Array correctTypedArray = Array.CreateInstance(
+                        Array correctTypedArray = ReflectionHelpers.CreateArray(
                             parentComponentType,
                             parentComponents.Length
                         );
                         Array.Copy(parentComponents, correctTypedArray, parentComponents.Length);
-                        field.SetValue(component, correctTypedArray);
+                        setter(component, correctTypedArray);
                     }
                     else if (
                         fieldType.IsGenericType
@@ -74,24 +79,25 @@
                     )
                     {
                         parentComponentType = fieldType.GenericTypeArguments[0];
-                        Type constructedListType = typeof(List<>).MakeGenericType(
-                            parentComponentType
+
+                        Component[] parents = parent.GetComponentsInParent(
+                            parentComponentType,
+                            true
+                        );
+
+                        IList instance = ReflectionHelpers.CreateList(
+                            parentComponentType,
+                            parents.Length
                         );
-                        IList instance = (IList)Activator.CreateInstance(constructedListType);
 
                         foundParent = false;
-                        foreach (
-                            Component parentComponent in parent.GetComponentsInParent(
-                                parentComponentType,
-                                true
-                            )
-                        )
+                        foreach (Component parentComponent in parents)
                         {
                             instance.Add(parentComponent);
                             foundParent = true;
                         }
 
-                        field.SetValue(component, instance);
+                        setter(component, instance);
                     }
                     else
                     {
@@ -102,7 +108,7 @@
                         foundParent = childComponent != null;
                         if (foundParent)
                         {
-                            field.SetValue(component, childComponent);
+                            setter(component, childComponent);
                         }
                     }
                 }
@@ -116,12 +122,12 @@
                         );
                         foundParent = 0 < parentComponents.Length;
 
-                        Array correctTypedArray = Array.CreateInstance(
+                        Array correctTypedArray = ReflectionHelpers.CreateArray(
                             parentComponentType,
                             parentComponents.Length
                         );
                         Array.Copy(parentComponents, correctTypedArray, parentComponents.Length);
-                        field.SetValue(component, correctTypedArray);
+                        setter(component, correctTypedArray);
                     }
                     else if (
                         fieldType.IsGenericType
@@ -129,24 +135,24 @@
                     )
                     {
                         parentComponentType = fieldType.GenericTypeArguments[0];
-                        Type constructedListType = typeof(List<>).MakeGenericType(
-                            parentComponentType
+
+                        Component[] parents = component.GetComponentsInParent(
+                            parentComponentType,
+                            true
+                        );
+
+                        IList instance = ReflectionHelpers.CreateList(
+                            parentComponentType,
+                            parents.Length
                         );
-                        IList instance = (IList)Activator.CreateInstance(constructedListType);
 
                         foundParent = false;
-                        foreach (
-                            Component parentComponent in component.GetComponentsInParent(
-                                parentComponentType,
-                                true
-                            )
-                        )
+                        foreach (Component parentComponent in parents)
                         {
                             instance.Add(parentComponent);
                             foundParent = true;
                         }
-
-                        field.SetValue(component, instance);
+                        setter(component, instance);
                     }
                     else
                     {
@@ -157,7 +163,7 @@
                         foundParent = childComponent != null;
                         if (foundParent)
                         {
-                            field.SetValue(component, childComponent);
+                            setter(component, childComponent);
                         }
                     }
                 }

package/Runtime/Core/Attributes/SiblingComponentAttribute.cs

@@ -6,6 +6,7 @@
     using System.Linq;
     using System.Reflection;
     using Extension;
+    using Helper;
     using JetBrains.Annotations;
     using UnityEngine;
 
@@ -18,12 +19,15 @@
 
     public static class SiblingComponentExtensions
     {
-        private static readonly Dictionary<Type, FieldInfo[]> FieldsByType = new();
+        private static readonly Dictionary<
+            Type,
+            (FieldInfo field, Action<object, object> setter)[]
+        > FieldsByType = new();
 
         public static void AssignSiblingComponents(this Component component)
         {
             Type componentType = component.GetType();
-            FieldInfo[] fields = FieldsByType.GetOrAdd(
+            (FieldInfo field, Action<object, object> setter)[] fields = FieldsByType.GetOrAdd(
                 componentType,
                 type =>
                 {
@@ -34,11 +38,12 @@
                         .Where(field =>
                             Attribute.IsDefined(field, typeof(SiblingComponentAttribute))
                         )
+                        .Select(field => (field, ReflectionHelpers.CreateFieldSetter(type, field)))
                         .ToArray();
                 }
             );
 
-            foreach (FieldInfo field in fields)
+            foreach ((FieldInfo field, Action<object, object> setter) in fields)
             {
                 Type fieldType = field.FieldType;
                 bool isArray = fieldType.IsArray;
@@ -50,12 +55,12 @@
                     Component[] siblingComponents = component.GetComponents(siblingComponentType);
                     foundSibling = 0 < siblingComponents.Length;
 
-                    Array correctTypedArray = Array.CreateInstance(
+                    Array correctTypedArray = ReflectionHelpers.CreateArray(
                         siblingComponentType,
                         siblingComponents.Length
                     );
                     Array.Copy(siblingComponents, correctTypedArray, siblingComponents.Length);
-                    field.SetValue(component, correctTypedArray);
+                    setter(component, correctTypedArray);
                 }
                 else if (
                     fieldType.IsGenericType
@@ -63,19 +68,22 @@
                 )
                 {
                     siblingComponentType = fieldType.GenericTypeArguments[0];
-                    Type constructedListType = typeof(List<>).MakeGenericType(siblingComponentType);
-                    IList instance = (IList)Activator.CreateInstance(constructedListType);
+
+                    Component[] siblings = component.GetComponents(siblingComponentType);
+
+                    IList instance = ReflectionHelpers.CreateList(
+                        siblingComponentType,
+                        siblings.Length
+                    );
 
                     foundSibling = false;
-                    foreach (
-                        Component siblingComponent in component.GetComponents(siblingComponentType)
-                    )
+                    foreach (Component siblingComponent in siblings)
                     {
                         instance.Add(siblingComponent);
                         foundSibling = true;
                     }
 
-                    field.SetValue(component, instance);
+                    setter(component, instance);
                 }
                 else
                 {
@@ -87,7 +95,7 @@
                     )
                     {
                         foundSibling = true;
-                        field.SetValue(component, siblingComponent);
+                        setter(component, siblingComponent);
                     }
                     else
                     {

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

package/Tests/Runtime/Components/RelationalComponentTester.cs

@@ -0,0 +1,34 @@
+namespace UnityHelpers.Tests.Components
+{
+    using Core.Attributes;
+    using UnityEngine;
+
+    [DisallowMultipleComponent]
+    [RequireComponent(typeof(SpriteRenderer))]
+    [RequireComponent(typeof(BoxCollider2D))]
+    [RequireComponent(typeof(BoxCollider2D))]
+    [RequireComponent(typeof(PolygonCollider2D))]
+    public sealed class RelationalComponentTester : MonoBehaviour
+    {
+        [SiblingComponent]
+        internal SpriteRenderer _spriteRenderer;
+
+        [SiblingComponent]
+        internal Transform _transform;
+
+        [SiblingComponent]
+        internal PolygonCollider2D _polygonCollider;
+
+        [SiblingComponent]
+        internal BoxCollider2D _boxCollider;
+
+        [ChildComponent]
+        internal Collider2D[] _childColliders;
+
+        [ParentComponent]
+        internal Collider2D[] _parentColliders;
+
+        [SiblingComponent]
+        internal Collider2D[] _siblingColliders;
+    }
+}

package/Tests/Runtime/Components/RelationalComponentTester.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: aaa52c6bc8884eae8f45a9bb306d2841
+timeCreated: 1742066326

package/Tests/Runtime/Components.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f1cf7d23925e4ee2a7482f99e4153b53
+timeCreated: 1742066312

package/Tests/Runtime/Performance/RelationComponentPerformanceTests.cs

@@ -0,0 +1,37 @@
+namespace UnityHelpers.Tests.Performance
+{
+    using System;
+    using System.Diagnostics;
+    using Components;
+    using Core.Attributes;
+    using NUnit.Framework;
+    using UnityEngine;
+
+    public sealed class RelationComponentPerformanceTests
+    {
+        [Test]
+        public void RelationalPerformanceTest()
+        {
+            int count = 0;
+
+            GameObject go = new("Test", typeof(RelationalComponentTester));
+            RelationalComponentTester tester = go.GetComponent<RelationalComponentTester>();
+            // Pre-warm
+            tester.AssignRelationalComponents();
+
+            TimeSpan timeout = TimeSpan.FromSeconds(10);
+            Stopwatch timer = Stopwatch.StartNew();
+            do
+            {
+                tester.AssignRelationalComponents();
+                ++count;
+            } while (timer.Elapsed < timeout);
+
+            UnityEngine.Debug.Log($"Averaged {count / timeout.TotalSeconds} operations / second.");
+
+            Assert.AreNotEqual(0, tester._childColliders.Length);
+            Assert.AreNotEqual(0, tester._parentColliders.Length);
+            Assert.AreNotEqual(0, tester._siblingColliders.Length);
+        }
+    }
+}

package/Tests/Runtime/Performance/RelationComponentPerformanceTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 08f1585008ba43b0b666e27eb45f0768
+timeCreated: 1742065801

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc26",
+  "version": "2.0.0-rc27",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},