com.wallstop-studios.unity-helpers 2.0.0-rc39 → 2.0.0-rc41

package/Runtime/Core/Helper/ReflectionHelpers.cs

@@ -8,22 +8,20 @@
     using System.Runtime.CompilerServices;
     using Extension;
 
+    public delegate void FieldSetter<TInstance, in TValue>(ref TInstance instance, TValue value);
+
     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);
+            return ArrayCreators
+                .GetOrAdd(type, elementType => GetArrayCreator(elementType))
+                .Invoke(length);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -40,32 +38,180 @@
             return ListCreators.GetOrAdd(elementType, type => GetListCreator(type)).Invoke();
         }
 
-        public static Action<object, object> CreateFieldSetter(Type type, FieldInfo field)
+        public static Func<object, object> GetFieldGetter(FieldInfo field)
+        {
+#if WEB_GL
+            return field.GetValue;
+#else
+            DynamicMethod dynamicMethod = new(
+                $"Get{(field.DeclaringType?.Name ?? string.Empty)}{field.Name}",
+                typeof(object),
+                new[] { typeof(object) },
+                field.DeclaringType,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+            il.Emit(OpCodes.Ldarg_0);
+            il.Emit(
+                field.DeclaringType.IsValueType ? OpCodes.Unbox : OpCodes.Castclass,
+                field.DeclaringType
+            );
+
+            il.Emit(OpCodes.Ldfld, field);
+
+            // If the field's type is a value type, box it.
+            if (field.FieldType.IsValueType)
+            {
+                il.Emit(OpCodes.Box, field.FieldType);
+            }
+
+            il.Emit(OpCodes.Ret);
+
+            return (Func<object, object>)dynamicMethod.CreateDelegate(typeof(Func<object, object>));
+#endif
+        }
+
+        public static Func<TInstance, TValue> GetFieldGetter<TInstance, TValue>(FieldInfo field)
+        {
+#if WEB_GL
+            return Getter;
+            TValue Getter(TInstance instance)
+            {
+                return (TValue)field.GetValue(instance);
+            }
+#else
+            DynamicMethod dynamicMethod = new(
+                $"GetGeneric{field.DeclaringType.Name}{field.Name}",
+                typeof(TValue),
+                new[] { typeof(TInstance) },
+                field.DeclaringType,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+
+            if (!field.IsStatic)
+            {
+                if (typeof(TInstance).IsValueType)
+                {
+                    il.Emit(OpCodes.Ldarga_S, 0);
+                }
+                else
+                {
+                    il.Emit(OpCodes.Ldarg_0);
+                }
+
+                if (field.DeclaringType != typeof(TInstance))
+                {
+                    il.Emit(
+                        field.DeclaringType.IsValueType ? OpCodes.Unbox : OpCodes.Castclass,
+                        field.DeclaringType
+                    );
+                }
+
+                il.Emit(OpCodes.Ldfld, field);
+            }
+            else
+            {
+                il.Emit(OpCodes.Ldsfld, field);
+            }
+
+            if (field.FieldType.IsValueType)
+            {
+                if (!typeof(TValue).IsValueType)
+                {
+                    il.Emit(OpCodes.Box, field.FieldType);
+                }
+            }
+            else
+            {
+                if (typeof(TValue).IsValueType)
+                {
+                    il.Emit(OpCodes.Unbox_Any, typeof(TValue));
+                }
+                else if (typeof(TValue) != field.FieldType)
+                {
+                    il.Emit(OpCodes.Castclass, typeof(TValue));
+                }
+            }
+
+            il.Emit(OpCodes.Ret);
+            return (Func<TInstance, TValue>)
+                dynamicMethod.CreateDelegate(typeof(Func<TInstance, TValue>));
+#endif
+        }
+
+        public static FieldSetter<TInstance, TValue> GetFieldSetter<TInstance, TValue>(
+            FieldInfo field
+        )
+        {
+#if WEB_GL
+            return Setter;
+            void Setter(ref TInstance instance, TValue newValue)
+            {
+                object value = instance;
+                field.SetValue(value, newValue);
+                instance = (TInstance)value;
+            }
+#else
+            Type instanceType = field.DeclaringType;
+            Type valueType = field.FieldType;
+
+            DynamicMethod dynamicMethod = new(
+                $"SetFieldGeneric{field.DeclaringType.Name}{field.Name}",
+                MethodAttributes.Public | MethodAttributes.Static,
+                CallingConventions.Standard,
+                typeof(void),
+                new[] { instanceType.MakeByRefType(), valueType },
+                field.Module,
+                true
+            );
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+            il.Emit(OpCodes.Ldarg_0);
+            if (!instanceType.IsValueType)
+            {
+                il.Emit(OpCodes.Ldind_Ref);
+            }
+
+            il.Emit(OpCodes.Ldarg_1);
+            il.Emit(OpCodes.Stfld, field);
+            il.Emit(OpCodes.Ret);
+
+            Type delegateType = typeof(FieldSetter<,>).MakeGenericType(instanceType, valueType);
+            return (FieldSetter<TInstance, TValue>)dynamicMethod.CreateDelegate(delegateType);
+#endif
+        }
+
+        public static Action<object, object> GetFieldSetter(FieldInfo field)
         {
 #if WEB_GL
             return field.SetValue;
 #else
             DynamicMethod dynamicMethod = new(
-                $"SetField{field.Name}",
+                $"SetField{field.DeclaringType.Name}{field.Name}",
                 null,
                 new[] { typeof(object), typeof(object) },
-                type.Module,
+                field.DeclaringType.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_0);
+            il.Emit(
+                field.DeclaringType.IsValueType ? OpCodes.Unbox : OpCodes.Castclass,
+                field.DeclaringType
+            );
 
-            il.Emit(OpCodes.Ldarg_1); // Load the value (arg1)
+            il.Emit(OpCodes.Ldarg_1);
             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
+            );
+            il.Emit(OpCodes.Stfld, field);
+            il.Emit(OpCodes.Ret);
             return (Action<object, object>)
                 dynamicMethod.CreateDelegate(typeof(Action<object, object>));
 #endif
@@ -76,9 +222,8 @@
 #if WEB_GL
             return size => Array.CreateInstance(elementType, size);
 #else
-
-            DynamicMethod dynamicMethod = new DynamicMethod(
-                $"CreateArray{elementType.Namespace}",
+            DynamicMethod dynamicMethod = new(
+                $"CreateArray{elementType.Name}",
                 typeof(Array), // Return type: Array
                 new[] { typeof(int) }, // Parameter: int (size)
                 true
@@ -98,7 +243,7 @@
 #if WEB_GL
             return () => (IList)Activator.CreateInstance(listType);
 #else
-            DynamicMethod dynamicMethod = new DynamicMethod(
+            DynamicMethod dynamicMethod = new(
                 $"CreateList{listType.Name}",
                 typeof(IList), // Return type: IList
                 Type.EmptyTypes, // No parameters
@@ -126,7 +271,7 @@
 #if WEB_GL
             return _ => (IList)Activator.CreateInstance(listType);
 #else
-            DynamicMethod dynamicMethod = new DynamicMethod(
+            DynamicMethod dynamicMethod = new(
                 $"CreateListWithCapacity{listType.Name}",
                 typeof(IList), // Return type: IList
                 new[] { typeof(int) }, // Parameter: int (size)

package/Tests/Runtime/Components/{RelationalComponentTester.cs → RelationalComponentTesterComplex.cs}

@@ -8,7 +8,7 @@
     [RequireComponent(typeof(BoxCollider2D))]
     [RequireComponent(typeof(BoxCollider2D))]
     [RequireComponent(typeof(PolygonCollider2D))]
-    public sealed class RelationalComponentTester : MonoBehaviour
+    public sealed class RelationalComponentTesterComplex : MonoBehaviour
     {
         [SiblingComponent]
         internal SpriteRenderer _spriteRenderer;

package/Tests/Runtime/Components/RelationalComponentsTesterSimple.cs

@@ -0,0 +1,40 @@
+namespace UnityHelpers.Tests.Components
+{
+    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 RelationalComponentTesterSimple : MonoBehaviour
+        {
+            [SiblingComponent]
+            internal SpriteRenderer _spriteRenderer;
+
+            [SiblingComponent]
+            internal Transform _transform;
+
+            [SiblingComponent]
+            internal PolygonCollider2D _polygonCollider;
+
+            // [ParentComponent]
+            // internal PolygonCollider2D _polygonColliderParent;
+
+            [SiblingComponent]
+            internal BoxCollider2D _boxCollider;
+
+            // [ParentComponent]
+            // internal BoxCollider2D _boxColliderParent;
+            //
+            // [ChildComponent]
+            // internal BoxCollider2D _boxColliderChild;
+            //
+            // [ChildComponent]
+            // internal BoxCollider2D _boxColliderParentChild;
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 56d8fae7976140d3b7eb031a8dfccdba
+timeCreated: 1742094536

package/Tests/Runtime/Helper/ReflectionHelperTests.cs

@@ -0,0 +1,215 @@
+namespace UnityHelpers.Tests.Tests.Runtime.Helper
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using Core.Helper;
+    using NUnit.Framework;
+
+    public struct TestStruct
+    {
+        public int intValue;
+    }
+
+    public sealed class TestClass
+    {
+        public int intValue;
+    }
+
+    public sealed class ReflectionHelperTests
+    {
+        internal const int NumTries = 1_000;
+
+        private readonly Random _random = new();
+
+        // TODO: Test on static fields
+        [Test]
+        public void GetFieldGetterClass()
+        {
+            TestClass testClass = new();
+            Func<object, object> classGetter = ReflectionHelpers.GetFieldGetter(
+                typeof(TestClass).GetField(nameof(TestClass.intValue))
+            );
+            Assert.AreEqual(testClass.intValue, classGetter(testClass));
+            for (int i = 0; i < NumTries; ++i)
+            {
+                testClass.intValue = _random.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(testClass.intValue, classGetter(testClass));
+            }
+        }
+
+        // TODO: Test on static fields
+        [Test]
+        public void GetFieldGetterStruct()
+        {
+            TestStruct testStruct = new();
+            Func<object, object> structGetter = ReflectionHelpers.GetFieldGetter(
+                typeof(TestStruct).GetField(nameof(TestStruct.intValue))
+            );
+            Assert.AreEqual(testStruct.intValue, structGetter(testStruct));
+            for (int i = 0; i < NumTries; ++i)
+            {
+                testStruct.intValue = _random.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(testStruct.intValue, structGetter(testStruct));
+            }
+        }
+
+        // TODO: Test on static fields
+        [Test]
+        public void GetFieldSetterClass()
+        {
+            TestClass testClass = new();
+            Action<object, object> structSetter = ReflectionHelpers.GetFieldSetter(
+                typeof(TestClass).GetField(nameof(TestClass.intValue))
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = _random.Next(int.MinValue, int.MaxValue);
+                structSetter(testClass, expected);
+                Assert.AreEqual(expected, testClass.intValue);
+            }
+        }
+
+        // TODO: Test on static fields
+        [Test]
+        public void GetFieldSetterStruct()
+        {
+            // Need boxing
+            object testStruct = new TestStruct();
+            Action<object, object> structSetter = ReflectionHelpers.GetFieldSetter(
+                typeof(TestStruct).GetField(nameof(TestStruct.intValue))
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = _random.Next(int.MinValue, int.MaxValue);
+                structSetter(testStruct, expected);
+                Assert.AreEqual(expected, ((TestStruct)testStruct).intValue);
+            }
+        }
+
+        // TODO: Test on static fields
+        [Test]
+        public void GetFieldSetterClassGeneric()
+        {
+            TestClass testClass = new();
+            FieldSetter<TestClass, int> classSetter = ReflectionHelpers.GetFieldSetter<
+                TestClass,
+                int
+            >(typeof(TestClass).GetField(nameof(TestClass.intValue)));
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = _random.Next(int.MinValue, int.MaxValue);
+                classSetter(ref testClass, expected);
+                Assert.AreEqual(expected, testClass.intValue);
+            }
+        }
+
+        // TODO: Test on static fields
+        [Test]
+        public void GetFieldSetterStructGeneric()
+        {
+            TestStruct testStruct = new();
+            FieldSetter<TestStruct, int> structSetter = ReflectionHelpers.GetFieldSetter<
+                TestStruct,
+                int
+            >(typeof(TestStruct).GetField(nameof(TestStruct.intValue)));
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int expected = _random.Next(int.MinValue, int.MaxValue);
+                structSetter(ref testStruct, expected);
+                Assert.AreEqual(expected, testStruct.intValue);
+            }
+        }
+
+        // TODO: Test on static fields
+        [Test]
+        public void GetFieldGetterClassGeneric()
+        {
+            TestClass testClass = new();
+            Func<TestClass, int> classGetter = ReflectionHelpers.GetFieldGetter<TestClass, int>(
+                typeof(TestClass).GetField(nameof(TestClass.intValue))
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                testClass.intValue = _random.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(testClass.intValue, classGetter(testClass));
+            }
+        }
+
+        // TODO: Test on static fields
+        [Test]
+        public void GetFieldGetterStructGeneric()
+        {
+            TestStruct testStruct = new();
+            Func<TestStruct, int> structSetter = ReflectionHelpers.GetFieldGetter<TestStruct, int>(
+                typeof(TestStruct).GetField(nameof(TestStruct.intValue))
+            );
+            for (int i = 0; i < NumTries; ++i)
+            {
+                testStruct.intValue = _random.Next(int.MinValue, int.MaxValue);
+                Assert.AreEqual(testStruct.intValue, structSetter(testStruct));
+            }
+        }
+
+        [Test]
+        public void ArrayCreator()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int count = _random.Next(1_000);
+                Array created = ReflectionHelpers.CreateArray(typeof(int), count);
+                Assert.AreEqual(count, created.Length);
+                Assert.IsTrue(created is int[]);
+                int[] typed = (int[])created;
+                Assert.AreEqual(count, typed.Length);
+            }
+        }
+
+        [Test]
+        public void ListCreator()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                IList created = ReflectionHelpers.CreateList(typeof(int));
+                Assert.AreEqual(0, created.Count);
+                Assert.IsTrue(created is List<int>);
+                List<int> typedCreated = (List<int>)created;
+                int count = _random.Next(50);
+                List<int> expected = new();
+                for (int j = 0; j < count; ++j)
+                {
+                    int element = _random.Next();
+                    created.Add(element);
+                    expected.Add(element);
+                    Assert.AreEqual(j + 1, created.Count);
+                    Assert.That(expected, Is.EqualTo(typedCreated));
+                }
+            }
+        }
+
+        [Test]
+        public void ListWithSizeCreator()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int capacity = _random.Next(1_000);
+                IList created = ReflectionHelpers.CreateList(typeof(int), capacity);
+                Assert.AreEqual(0, created.Count);
+                Assert.IsTrue(created is List<int>);
+                List<int> typedCreated = (List<int>)created;
+                Assert.AreEqual(capacity, typedCreated.Capacity);
+
+                int count = _random.Next(50);
+                List<int> expected = new();
+                for (int j = 0; j < count; ++j)
+                {
+                    int element = _random.Next();
+                    created.Add(element);
+                    expected.Add(element);
+                    Assert.AreEqual(j + 1, created.Count);
+                    Assert.That(expected, Is.EqualTo(typedCreated));
+                }
+            }
+        }
+    }
+}

package/Tests/Runtime/Helper/ReflectionHelperTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 727a306f7f144d758b6f6425b6a442ed
+timeCreated: 1742157564

package/Tests/Runtime/Performance/RelationComponentPerformanceTests.cs

@@ -3,6 +3,7 @@
     using System;
     using System.Diagnostics;
     using Components;
+    using Components.UnityHelpers.Tests.Components;
     using Core.Attributes;
     using NUnit.Framework;
     using UnityEngine;
@@ -10,12 +11,13 @@
     public sealed class RelationComponentPerformanceTests
     {
         [Test]
-        public void RelationalPerformanceTest()
+        public void RelationalPerformanceComplexTest()
         {
             int count = 0;
 
-            GameObject go = new("Test", typeof(RelationalComponentTester));
-            RelationalComponentTester tester = go.GetComponent<RelationalComponentTester>();
+            GameObject go = new("Test", typeof(RelationalComponentTesterComplex));
+            RelationalComponentTesterComplex tester =
+                go.GetComponent<RelationalComponentTesterComplex>();
             // Pre-warm
             tester.AssignRelationalComponents();
 
@@ -33,5 +35,27 @@
             Assert.AreNotEqual(0, tester._parentColliders.Length);
             Assert.AreNotEqual(0, tester._siblingColliders.Length);
         }
+
+        [Test]
+        public void RelationalPerformanceSimpleTest()
+        {
+            int count = 0;
+
+            GameObject go = new("Test", typeof(RelationalComponentTesterSimple));
+            RelationalComponentTesterSimple tester =
+                go.GetComponent<RelationalComponentTesterSimple>();
+            // 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.");
+        }
     }
 }

package/package.json

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

package/.github/workflows/unity-package.yml

@@ -1,105 +0,0 @@
-name: Export and Release Unity Package
-
-on:
-  workflow_run:
-    workflows: ["Unity Tests"]
-    types:
-      - completed
-  workflow_dispatch:
-    inputs:
-      logLevel:
-        description: 'Log level'
-        required: true
-        default: 'warning'
-      environment:
-        description: 'Environment to deploy'
-        required: false
-        default: 'staging'
-
-env:
-  UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
-
-jobs:
-  package_unity:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0  # Ensure full commit history for version comparison
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 18
-
-      - name: Check if version changed
-        id: version_check
-        run: |
-          PREV_VERSION=$(git show HEAD~1:package.json | jq -r '.version' || echo "0.0.0")
-          NEW_VERSION=$(jq -r '.version' package.json)
-          echo "Previous version: $PREV_VERSION"
-          echo "New version: $NEW_VERSION"
-
-          if [ "$PREV_VERSION" != "$NEW_VERSION" ]; then
-            echo "Version changed, proceeding..."
-            echo "NEW_VERSION=$NEW_VERSION" >> $GITHUB_ENV
-            echo "should_build=true" >> $GITHUB_ENV
-
-            # Check for pre-release versions
-            if [[ "$NEW_VERSION" == *"rc"* ]]; then
-              echo "This is a pre-release (next tag)."
-              echo "IS_PRERELEASE=true" >> $GITHUB_ENV
-            else
-              echo "This is a stable release."
-              echo "IS_PRERELEASE=false" >> $GITHUB_ENV
-            fi
-          else
-            echo "Version did not change, skipping..."
-            echo "should_build=false" >> $GITHUB_ENV
-          fi
-
-      - name: Set up Unity
-        if: env.should_build == 'true'
-        uses: game-ci/unity-builder@v4
-        env:
-          UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
-          UNITY_EMAIL: ${{ secrets.UNITY_EMAIL }}
-          UNITY_PASSWORD: ${{ secrets.UNITY_PASSWORD }}
-        with:
-          unityVersion: 2022.3.5f1
-          targetPlatform: StandaloneLinux64
-          buildMethod: BuildScript.BuildLinux
-          projectPath: .   
-
-      - name: Export Unity Package
-        if: env.should_build == 'true'
-        run: |
-          EXPORT_DIR="UnityHelpers"
-          PACKAGE_NAME="WallstopStudios.UnityHelpers.unitypackage"
-          
-          mkdir -p $EXPORT_DIR
-          
-          echo "Exporting package: $EXPORT_DIR/$PACKAGE_NAME"
-          
-          /opt/unity/Editor/Unity \
-            -batchmode -quit \
-            -projectPath "$(pwd)" \
-            -exportPackage "Assets" "$EXPORT_DIR/$PACKAGE_NAME"
-
-          echo "PACKAGE_PATH=$EXPORT_DIR/$PACKAGE_NAME" >> $GITHUB_ENV
-
-      - name: Create GitHub Release
-        if: env.should_build == 'true'
-        id: create_release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: v${{ env.NEW_VERSION }}
-          release_name: "Unity Helpers v${{ env.NEW_VERSION }}"
-          body: "Automatically generated release for version ${{ env.NEW_VERSION }}."
-          draft: false
-          prerelease: ${{ env.IS_PRERELEASE == 'true' }}
-          files: ${{ env.PACKAGE_PATH }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}