com.wallstop-studios.unity-helpers 2.0.0-rc40 → 2.0.0-rc42

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

@@ -171,10 +171,9 @@
         {
             if (component == null)
             {
-                return Enumerable.Empty<Transform>();
+                yield break;
             }
 
-            Queue<Transform> results = new();
             Queue<Transform> iteration = new();
             iteration.Enqueue(component.transform);
             while (iteration.TryDequeue(out Transform current))
@@ -182,12 +181,10 @@
                 for (int i = 0; i < current.childCount; ++i)
                 {
                     Transform childTransform = current.GetChild(i);
-                    results.Enqueue(childTransform);
                     iteration.Enqueue(childTransform);
+                    yield return childTransform;
                 }
             }
-
-            return results;
         }
     }
 }

package/Runtime/Core/Helper/ReflectionHelpers.cs

@@ -72,6 +72,76 @@
 #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
         )

package/Runtime/Core/Helper/StringInList.cs

@@ -22,7 +22,7 @@
             }
             else
             {
-                Debug.LogError("NO SUCH METHOD " + methodName + " FOR " + type);
+                Debug.LogError($"NO SUCH METHOD {methodName} FOR {type}");
             }
         }
 

package/Runtime/Utils/Buffers.cs

@@ -7,7 +7,6 @@
     {
         public const int BufferSize = 10_000;
 
-        public static readonly HashSet<Collider2D> UniqueColliders = new();
         public static readonly Collider2D[] Colliders = new Collider2D[BufferSize];
         public static readonly RaycastHit2D[] RaycastHits = new RaycastHit2D[BufferSize];
 
@@ -16,6 +15,8 @@
             DO NOT USE with random values.
          */
         public static readonly Dictionary<float, WaitForSeconds> WaitForSeconds = new();
+        public static readonly Dictionary<float, WaitForSecondsRealtime> WaitForSecondsRealtime =
+            new();
         public static readonly System.Random Random = new();
         public static readonly WaitForFixedUpdate WaitForFixedUpdate = new();
         public static readonly WaitForEndOfFrame WaitForEndOfFrame = new();

package/Tests/Runtime/Helper/ReflectionHelperTests.cs

@@ -22,6 +22,7 @@
 
         private readonly Random _random = new();
 
+        // TODO: Test on static fields
         [Test]
         public void GetFieldGetterClass()
         {
@@ -37,6 +38,7 @@
             }
         }
 
+        // TODO: Test on static fields
         [Test]
         public void GetFieldGetterStruct()
         {
@@ -52,6 +54,7 @@
             }
         }
 
+        // TODO: Test on static fields
         [Test]
         public void GetFieldSetterClass()
         {
@@ -67,6 +70,7 @@
             }
         }
 
+        // TODO: Test on static fields
         [Test]
         public void GetFieldSetterStruct()
         {
@@ -83,22 +87,24 @@
             }
         }
 
+        // TODO: Test on static fields
         [Test]
         public void GetFieldSetterClassGeneric()
         {
             TestClass testClass = new();
-            FieldSetter<TestClass, int> structSetter = ReflectionHelpers.GetFieldSetter<
+            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);
-                structSetter(ref testClass, expected);
+                classSetter(ref testClass, expected);
                 Assert.AreEqual(expected, testClass.intValue);
             }
         }
 
+        // TODO: Test on static fields
         [Test]
         public void GetFieldSetterStructGeneric()
         {
@@ -115,6 +121,36 @@
             }
         }
 
+        // 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()
         {

package/package.json

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