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

package/Runtime/Core/Extension/SerializedPropertyExtensions.cs

@@ -0,0 +1,157 @@
+namespace UnityHelpers.Core.Extension
+{
+#if UNITY_EDITOR
+    using UnityEditor;
+    using System;
+    using System.Reflection;
+
+    public static class SerializedPropertyExtensions
+    {
+        /// <summary>
+        /// Gets the instance object that contains the given SerializedProperty.
+        /// </summary>
+        /// <param name="property">The SerializedProperty.</param>
+        /// <param name="fieldInfo">Outputs the FieldInfo of the referenced field.</param>
+        /// <returns>The instance object that owns the field.</returns>
+        public static object GetEnclosingObject(
+            this SerializedProperty property,
+            out FieldInfo fieldInfo
+        )
+        {
+            fieldInfo = null;
+            object obj = property.serializedObject.targetObject;
+            if (obj == null)
+            {
+                return null;
+            }
+            Type type = obj.GetType();
+            string[] pathParts = property.propertyPath.Split('.');
+
+            // Traverse the path but stop at the second-to-last field
+            for (int i = 0; i < pathParts.Length - 1; ++i)
+            {
+                string fieldName = pathParts[i];
+
+                if (string.Equals(fieldName, "Array", StringComparison.Ordinal))
+                {
+                    // Move to "data[i]", no need to length-check, we're guarded above
+
+                    ++i;
+                    if (
+                        !int.TryParse(
+                            pathParts[i]
+                                .Replace("data[", string.Empty, StringComparison.Ordinal)
+                                .Replace("]", string.Empty, StringComparison.Ordinal),
+                            out int index
+                        )
+                    )
+                    {
+                        // Unexpected, die
+                        fieldInfo = null;
+                        return null;
+                    }
+                    obj = GetElementAtIndex(obj, index);
+                    type = obj?.GetType();
+                    continue;
+                }
+
+                fieldInfo = type?.GetField(
+                    fieldName,
+                    BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance
+                );
+                if (fieldInfo == null)
+                {
+                    return null;
+                }
+
+                // Move deeper but stop before the last property in the path
+                if (i < pathParts.Length - 2)
+                {
+                    obj = fieldInfo.GetValue(obj);
+                    type = fieldInfo.FieldType;
+                }
+            }
+
+            return obj;
+        }
+
+        /// <summary>
+        /// Gets the FieldInfo and the instance object that owns the field for a given SerializedProperty.
+        /// </summary>
+        /// <param name="property">The SerializedProperty to reflect upon.</param>
+        /// <param name="fieldInfo">Outputs the FieldInfo of the referenced field.</param>
+        /// <returns>The instance object that owns the field.</returns>
+        public static object GetTargetObjectWithField(
+            this SerializedProperty property,
+            out FieldInfo fieldInfo
+        )
+        {
+            fieldInfo = null;
+            object obj = property.serializedObject.targetObject;
+            if (obj == null)
+            {
+                return null;
+            }
+
+            Type type = obj.GetType();
+            string[] pathParts = property.propertyPath.Split('.');
+
+            for (int i = 0; i < pathParts.Length; ++i)
+            {
+                string fieldName = pathParts[i];
+
+                if (string.Equals(fieldName, "Array", StringComparison.Ordinal))
+                {
+                    // Move to "data[i]"
+                    ++i;
+                    if (pathParts.Length <= i)
+                    {
+                        break;
+                    }
+
+                    if (
+                        !int.TryParse(
+                            pathParts[i]
+                                .Replace("data[", string.Empty, StringComparison.Ordinal)
+                                .Replace("]", string.Empty, StringComparison.Ordinal),
+                            out int index
+                        )
+                    )
+                    {
+                        // Unexpected, die
+                        fieldInfo = null;
+                        return null;
+                    }
+                    obj = GetElementAtIndex(obj, index);
+                    type = obj?.GetType();
+                    continue;
+                }
+
+                fieldInfo = type?.GetField(
+                    fieldName,
+                    BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance
+                );
+                if (fieldInfo == null)
+                {
+                    return null;
+                }
+
+                // Move deeper into the object tree
+                obj = fieldInfo.GetValue(obj);
+                type = fieldInfo.FieldType;
+            }
+
+            return obj;
+        }
+
+        private static object GetElementAtIndex(object obj, int index)
+        {
+            if (obj is System.Collections.IList list && index >= 0 && index < list.Count)
+            {
+                return list[index];
+            }
+            return null;
+        }
+    }
+#endif
+}

package/Runtime/Core/Extension/SerializedPropertyExtensions.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f58cbae584d8414a89cc3996d16fc5b0
+timeCreated: 1742507900

package/Runtime/Core/Helper/Objects.cs

@@ -18,7 +18,8 @@
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool Null(UnityEngine.Object instance)
+        public static bool Null<T>(T instance)
+            where T : UnityEngine.Object
         {
             return instance == null;
         }
@@ -29,7 +30,8 @@
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool NotNull(UnityEngine.Object instance)
+        public static bool NotNull<T>(T instance)
+            where T : UnityEngine.Object
         {
             return instance != null;
         }

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

@@ -1,7 +1,6 @@
 namespace UnityHelpers.Core.Helper
 {
     using System.Collections.Generic;
-    using System.Linq;
     using UnityEngine;
 
     public static partial class Helpers
@@ -171,10 +170,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 +180,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/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/Core/Threading/SingleThreadedThreadPool.cs

@@ -7,6 +7,7 @@
     public sealed class SingleThreadedThreadPool : IDisposable
     {
         public ConcurrentQueue<Exception> Exceptions => _exceptions;
+        public int Count => _work.Count + Interlocked.CompareExchange(ref _working, 0, 0);
 
         private int _active;
         private int _working;
@@ -16,14 +17,14 @@
         private bool _disposed;
         private readonly ConcurrentQueue<Exception> _exceptions;
 
-        public SingleThreadedThreadPool()
+        public SingleThreadedThreadPool(bool runInBackground = false)
         {
             _active = 1;
             _working = 1;
             _work = new ConcurrentQueue<Action>();
             _exceptions = new ConcurrentQueue<Exception>();
             _waitHandle = new AutoResetEvent(false);
-            _worker = new Thread(DoWork);
+            _worker = new Thread(DoWork) { IsBackground = runInBackground };
             _worker.Start();
         }
 
@@ -32,40 +33,12 @@
             Dispose(false);
         }
 
-        private void DoWork()
-        {
-            while (Interlocked.CompareExchange(ref _active, 0, 0) != 0)
-            {
-                _ = Interlocked.Exchange(ref _working, 0);
-                if (_work.TryDequeue(out Action workItem))
-                {
-                    _ = Interlocked.Exchange(ref _working, 1);
-                    try
-                    {
-                        workItem();
-                    }
-                    catch (Exception e)
-                    {
-                        _exceptions.Enqueue(e);
-                    }
-                }
-                else
-                {
-                    _ = _waitHandle.WaitOne(TimeSpan.FromSeconds(1));
-                }
-
-                _ = Interlocked.Exchange(ref _working, 0);
-            }
-        }
-
         public void Enqueue(Action work)
         {
             _work.Enqueue(work);
             _ = _waitHandle.Set();
         }
 
-        public int Count => _work.Count + Interlocked.CompareExchange(ref _working, 0, 0);
-
         public void Dispose()
         {
             Dispose(true);
@@ -79,17 +52,16 @@
                 return;
             }
 
-            int active;
-            do
+            while (Interlocked.CompareExchange(ref _active, 0, _active) != 0)
             {
-                active = Interlocked.CompareExchange(ref _active, 0, _active);
-            } while (active != 0);
+                // Spin
+            }
 
             if (disposing)
             {
                 try
                 {
-                    _worker?.Join();
+                    _worker?.Join(TimeSpan.FromSeconds(30));
                     _waitHandle?.Dispose();
                 }
                 catch
@@ -103,5 +75,42 @@
 
             _disposed = true;
         }
+
+        private void DoWork()
+        {
+            while (Interlocked.CompareExchange(ref _active, 0, 0) != 0)
+            {
+                try
+                {
+                    if (_work.TryDequeue(out Action workItem))
+                    {
+                        _ = Interlocked.Exchange(ref _working, 1);
+                        try
+                        {
+                            workItem();
+                        }
+                        catch (Exception e)
+                        {
+                            _exceptions.Enqueue(e);
+                        }
+                    }
+                    else
+                    {
+                        try
+                        {
+                            _ = _waitHandle?.WaitOne(TimeSpan.FromSeconds(1));
+                        }
+                        catch (ObjectDisposedException)
+                        {
+                            return;
+                        }
+                    }
+                }
+                finally
+                {
+                    _ = Interlocked.Exchange(ref _working, 0);
+                }
+            }
+        }
     }
 }

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/package.json

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