com.wallstop-studios.unity-helpers 2.0.0-rc74.1 → 2.0.0-rc74.3

package/Editor/Utils/ScriptableObjectSingletonCreator.cs

@@ -0,0 +1,52 @@
+namespace WallstopStudios.UnityHelpers.Editor.Utils
+{
+#if UNITY_EDITOR
+    using System;
+    using UnityEditor;
+    using UnityEngine;
+    using Object = UnityEngine.Object;
+
+    [InitializeOnLoad]
+    public static class ScriptableObjectSingletonCreator
+    {
+        static ScriptableObjectSingletonCreator()
+        {
+            bool anyCreated = false;
+            foreach (
+                Type derivedType in TypeCache.GetTypesDerivedFrom(
+                    typeof(UnityHelpers.Utils.ScriptableObjectSingleton<>)
+                )
+            )
+            {
+                if (!derivedType.IsAbstract && !derivedType.IsGenericType)
+                {
+                    Object[] existing = Resources.LoadAll(string.Empty, derivedType);
+                    if (existing.Length != 0)
+                    {
+                        continue;
+                    }
+
+                    if (!AssetDatabase.IsValidFolder("Assets/Resources"))
+                    {
+                        AssetDatabase.CreateFolder("Assets", "Resources");
+                    }
+
+                    ScriptableObject instance = ScriptableObject.CreateInstance(derivedType);
+                    string assetPathName = AssetDatabase.GenerateUniqueAssetPath(
+                        "Assets/Resources/" + derivedType.Name + ".asset"
+                    );
+                    AssetDatabase.CreateAsset(instance, assetPathName);
+                    Debug.Log($"Creating missing singleton for type {derivedType.Name}.");
+                    anyCreated = true;
+                }
+            }
+
+            if (anyCreated)
+            {
+                AssetDatabase.SaveAssets();
+                AssetDatabase.Refresh();
+            }
+        }
+    }
+#endif
+}

package/Editor/Utils/ScriptableObjectSingletonCreator.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7dc31b57f14246e78ea4686c7acc64b7
+timeCreated: 1747541418

package/Runtime/Core/Attributes/ChildComponentAttribute.cs

@@ -7,7 +7,6 @@
     using System.Reflection;
     using Extension;
     using Helper;
-    using Helper.Partials;
     using JetBrains.Annotations;
     using UnityEngine;
 

package/Runtime/Core/Helper/Helpers.cs

@@ -7,7 +7,6 @@
     using System.Reflection;
     using DataStructure.Adapters;
     using Extension;
-    using Partials;
     using Random;
     using UnityEngine;
     using Utils;
@@ -132,7 +131,8 @@
         public static GameObject FindChildGameObjectWithTag(this GameObject gameObject, string tag)
         {
             return gameObject
-                .IterateOverChildGameObjectsRecursivelyIncludingSelf()
+                .transform.IterateOverAllChildrenRecursively(includeSelf: true)
+                .Select(t => t.gameObject)
                 .FirstOrDefault(child => child.CompareTag(tag));
         }
 
@@ -485,7 +485,8 @@
         )
         {
             return gameObject
-                .IterateOverChildGameObjectsRecursivelyIncludingSelf()
+                .transform.IterateOverAllChildrenRecursively(includeSelf: true)
+                .Select(t => t.gameObject)
                 .FirstOrDefault(go => go.CompareTag(tag));
         }
 

package/Runtime/Core/Helper/LifetimeHelpers.cs

@@ -1,6 +1,5 @@
 namespace WallstopStudios.UnityHelpers.Core.Helper
 {
-    using Partials;
     using Object = UnityEngine.Object;
 
     public static class LifetimeHelpers

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

@@ -1,79 +1,107 @@
-namespace WallstopStudios.UnityHelpers.Core.Helper.Partials
+namespace WallstopStudios.UnityHelpers.Core.Helper
 {
     using System.Collections.Generic;
     using UnityEngine;
+    using Utils;
 
     public static partial class Helpers
     {
-        public static IEnumerable<GameObject> IterateOverChildGameObjects(
-            this GameObject gameObject
+        public static List<T> IterateOverAllParentComponentsRecursively<T>(
+            this Component component,
+            List<T> buffer,
+            bool includeSelf = false
         )
         {
-            for (int i = 0; i < gameObject.transform.childCount; i++)
+            buffer.Clear();
+            if (component == null)
             {
-                yield return gameObject.transform.GetChild(i).gameObject;
+                return buffer;
             }
-        }
 
-        public static IEnumerable<GameObject> IterateOverChildGameObjectsRecursively(
-            this GameObject gameObject
-        )
-        {
-            for (int i = 0; i < gameObject.transform.childCount; i++)
+            List<T> internalBuffer = Buffers<T>.List;
+            if (includeSelf)
             {
-                GameObject child = gameObject.transform.GetChild(i).gameObject;
-                yield return child;
-                foreach (GameObject go in child.IterateOverChildGameObjectsRecursively())
+                component.GetComponents(internalBuffer);
+                foreach (T c in internalBuffer)
                 {
-                    yield return go;
+                    buffer.Add(c);
                 }
             }
+
+            Transform parent = component.transform.parent;
+            while (parent != null)
+            {
+                parent.GetComponents(internalBuffer);
+                foreach (T c in internalBuffer)
+                {
+                    buffer.Add(c);
+                }
+                parent = parent.parent;
+            }
+
+            return buffer;
         }
 
-        public static IEnumerable<GameObject> IterateOverChildGameObjectsRecursivelyIncludingSelf(
-            this GameObject gameObject
+        public static IEnumerable<T> IterateOverAllParentComponentsRecursively<T>(
+            this Component component,
+            bool includeSelf = false
         )
         {
-            yield return gameObject;
+            if (component == null)
+            {
+                yield break;
+            }
 
-            for (int i = 0; i < gameObject.transform.childCount; ++i)
+            List<T> buffer = new();
+            foreach (Transform parent in IterateOverAllParents(component, includeSelf))
             {
-                GameObject child = gameObject.transform.GetChild(i).gameObject;
-                foreach (
-                    GameObject c in child.IterateOverChildGameObjectsRecursivelyIncludingSelf()
-                )
+                parent.GetComponents(buffer);
+                foreach (T c in buffer)
                 {
                     yield return c;
                 }
             }
         }
 
-        public static IEnumerable<GameObject> IterateOverParentGameObjects(
-            this GameObject gameObject
+        public static List<T> IterateOverAllChildComponentsRecursively<T>(
+            this Component component,
+            List<T> buffer,
+            bool includeSelf = false
         )
         {
-            Transform currentTransform = gameObject.transform.parent;
-            while (currentTransform != null)
+            buffer.Clear();
+            if (component == null)
             {
-                yield return currentTransform.gameObject;
-                currentTransform = currentTransform.parent;
+                return buffer;
             }
-        }
 
-        public static IEnumerable<GameObject> IterateOverParentGameObjectsRecursivelyIncludingSelf(
-            this GameObject gameObject
-        )
-        {
-            yield return gameObject;
+            List<T> internalBuffer = Buffers<T>.List;
+            if (includeSelf)
+            {
+                component.GetComponents(internalBuffer);
+                foreach (T c in internalBuffer)
+                {
+                    buffer.Add(c);
+                }
+            }
 
-            foreach (GameObject parent in IterateOverParentGameObjects(gameObject))
+            Transform transform = component.transform;
+            for (int i = 0; i < transform.childCount; ++i)
             {
-                yield return parent;
+                Transform child = transform.GetChild(i);
+                child.GetComponentsInChildren(true, internalBuffer);
+                foreach (T c in internalBuffer)
+                {
+                    buffer.Add(c);
+                }
             }
+
+            return buffer;
         }
 
         public static IEnumerable<T> IterateOverAllChildComponentsRecursively<T>(
-            this Component component
+            this Component component,
+            bool includeSelf = false
         )
         {
             if (component == null)
@@ -81,52 +109,79 @@
                 yield break;
             }
 
-            foreach (T c in component.gameObject.GetComponents<T>())
+            List<T> buffer = new();
+            if (includeSelf)
             {
-                yield return c;
+                component.GetComponents(buffer);
+                foreach (T c in buffer)
+                {
+                    yield return c;
+                }
             }
 
-            for (int i = 0; i < component.transform.childCount; ++i)
+            Transform transform = component.transform;
+            for (int i = 0; i < transform.childCount; ++i)
             {
-                Transform child = component.transform.GetChild(i);
-
-                foreach (T c in child.IterateOverAllChildComponentsRecursively<T>())
+                Transform child = transform.GetChild(i);
+                child.GetComponentsInChildren(true, buffer);
+                foreach (T c in buffer)
                 {
                     yield return c;
                 }
             }
         }
 
-        public static IEnumerable<Transform> IterateOverAllChildren(this Component component)
+        public static IEnumerable<Transform> IterateOverAllChildren(
+            this Component component,
+            bool includeSelf = false
+        )
         {
             if (component == null)
             {
                 yield break;
             }
 
-            for (int i = 0; i < component.transform.childCount; ++i)
+            Transform transform = component.transform;
+            if (includeSelf)
+            {
+                yield return transform;
+            }
+
+            for (int i = 0; i < transform.childCount; ++i)
             {
-                yield return component.transform.GetChild(i);
+                yield return transform.GetChild(i);
             }
         }
 
-        public static IEnumerable<Transform> IterateOverAllParents(this Component component)
+        public static List<Transform> IterateOverAllChildren(
+            this Component component,
+            List<Transform> buffer,
+            bool includeSelf = false
+        )
         {
+            buffer.Clear();
             if (component == null)
             {
-                yield break;
+                return buffer;
             }
 
             Transform transform = component.transform;
-            while (transform.parent != null)
+            if (includeSelf)
+            {
+                buffer.Add(transform);
+            }
+
+            for (int i = 0; i < transform.childCount; ++i)
             {
-                yield return transform.parent;
-                transform = transform.parent;
+                buffer.Add(transform.GetChild(i));
             }
+
+            return buffer;
         }
 
-        public static IEnumerable<Transform> IterateOverAllParentsIncludingSelf(
-            this Component component
+        public static IEnumerable<Transform> IterateOverAllParents(
+            this Component component,
+            bool includeSelf = false
         )
         {
             if (component == null)
@@ -135,15 +190,50 @@
             }
 
             Transform transform = component.transform;
-            while (transform != null)
+            if (includeSelf)
             {
                 yield return transform;
-                transform = transform.parent;
             }
+
+            Transform parent = transform.parent;
+            while (parent != null)
+            {
+                yield return parent;
+                parent = parent.parent;
+            }
+        }
+
+        public static List<Transform> IterateOverAllParents(
+            this Component component,
+            List<Transform> buffer,
+            bool includeSelf = false
+        )
+        {
+            buffer.Clear();
+            if (component == null)
+            {
+                return buffer;
+            }
+
+            Transform transform = component.transform;
+            if (includeSelf)
+            {
+                buffer.Add(transform);
+            }
+
+            Transform parent = transform.parent;
+            while (parent != null)
+            {
+                buffer.Add(parent);
+                parent = parent.parent;
+            }
+
+            return buffer;
         }
 
         public static IEnumerable<Transform> IterateOverAllChildrenRecursively(
-            this Component component
+            this Component component,
+            bool includeSelf = false
         )
         {
             if (component == null)
@@ -151,21 +241,65 @@
                 yield break;
             }
 
-            for (int i = 0; i < component.transform.childCount; ++i)
+            Transform transform = component.transform;
+            if (includeSelf)
+            {
+                yield return transform;
+            }
+
+            for (int i = 0; i < transform.childCount; ++i)
             {
-                Transform childTransform = component.transform.GetChild(i);
-                yield return childTransform;
                 foreach (
-                    Transform childChildTransform in childTransform.IterateOverAllChildrenRecursively()
+                    Transform child in IterateOverAllChildrenRecursively(
+                        transform.GetChild(i),
+                        includeSelf: true
+                    )
                 )
                 {
-                    yield return childChildTransform;
+                    yield return child;
                 }
             }
         }
 
+        public static List<Transform> IterateOverAllChildrenRecursively(
+            this Component component,
+            List<Transform> buffer,
+            bool includeSelf = false
+        )
+        {
+            buffer.Clear();
+            if (component == null)
+            {
+                return buffer;
+            }
+
+            Transform transform = component.transform;
+            if (includeSelf)
+            {
+                buffer.Add(transform);
+            }
+
+            return InternalIterateOverAllChildrenRecursively(transform, buffer);
+        }
+
+        private static List<Transform> InternalIterateOverAllChildrenRecursively(
+            this Transform transform,
+            List<Transform> buffer
+        )
+        {
+            for (int i = 0; i < transform.childCount; ++i)
+            {
+                Transform child = transform.GetChild(i);
+                buffer.Add(child);
+                InternalIterateOverAllChildrenRecursively(child, buffer);
+            }
+
+            return buffer;
+        }
+
         public static IEnumerable<Transform> IterateOverAllChildrenRecursivelyBreadthFirst(
-            this Component component
+            this Component component,
+            bool includeSelf = false
         )
         {
             if (component == null)
@@ -173,8 +307,14 @@
                 yield break;
             }
 
+            Transform transform = component.transform;
+            if (includeSelf)
+            {
+                yield return transform;
+            }
+
             Queue<Transform> iteration = new();
-            iteration.Enqueue(component.transform);
+            iteration.Enqueue(transform);
             while (iteration.TryDequeue(out Transform current))
             {
                 for (int i = 0; i < current.childCount; ++i)
@@ -185,5 +325,38 @@
                 }
             }
         }
+
+        public static List<Transform> IterateOverAllChildrenRecursivelyBreadthFirst(
+            this Component component,
+            List<Transform> buffer,
+            bool includeSelf = false
+        )
+        {
+            buffer.Clear();
+            if (component == null)
+            {
+                return buffer;
+            }
+
+            Transform transform = component.transform;
+            if (includeSelf)
+            {
+                buffer.Add(transform);
+            }
+
+            Queue<Transform> iteration = Buffers<Transform>.Queue;
+            iteration.Clear();
+            iteration.Enqueue(transform);
+            while (iteration.TryDequeue(out Transform current))
+            {
+                for (int i = 0; i < current.childCount; ++i)
+                {
+                    Transform childTransform = current.GetChild(i);
+                    iteration.Enqueue(childTransform);
+                    buffer.Add(childTransform);
+                }
+            }
+            return buffer;
+        }
     }
 }

package/Runtime/Utils/RuntimeSingleton.cs

@@ -5,14 +5,23 @@
     using Core.Extension;
     using Core.Helper;
     using UnityEngine;
+#if ODIN_INSPECTOR
+    using Sirenix.OdinInspector;
+#endif
 
     [DisallowMultipleComponent]
-    public abstract class RuntimeSingleton<T> : MonoBehaviour
+    public abstract class RuntimeSingleton<T> :
+#if ODIN_INSPECTOR
+        SerializedMonoBehaviour
+#else
+        MonoBehaviour
+#endif
         where T : RuntimeSingleton<T>
     {
         public static bool HasInstance => _instance != null;
 
         protected static T _instance;
+        protected static bool _isQuitting;
 
         protected virtual bool Preserve => true;
 
@@ -25,6 +34,11 @@
                     return _instance;
                 }
 
+                if (_isQuitting)
+                {
+                    return null;
+                }
+
                 Type type = typeof(T);
                 GameObject instance = new($"{type.Name}-Singleton", type);
                 if (
@@ -67,5 +81,10 @@
                 _instance = null;
             }
         }
+
+        protected virtual void OnApplicationQuit()
+        {
+            _isQuitting = true;
+        }
     }
 }

package/Runtime/Utils/ScriptableObjectSingleton.cs

@@ -0,0 +1,44 @@
+namespace WallstopStudios.UnityHelpers.Utils
+{
+    using System;
+    using UnityEngine;
+#if ODIN_INSPECTOR
+    using Sirenix.OdinInspector;
+#endif
+
+    public abstract class ScriptableObjectSingleton<T> :
+#if ODIN_INSPECTOR
+        SerializedScriptableObject
+#else
+        ScriptableObject
+#endif
+        where T : ScriptableObjectSingleton<T>
+    {
+        protected static readonly Lazy<T> LazyInstance = new(() =>
+        {
+            T[] instances = Resources.LoadAll<T>(string.Empty);
+            switch (instances.Length)
+            {
+                case 1:
+                {
+                    return instances[0];
+                }
+                case 0:
+                {
+                    Debug.LogError($"Failed to find ScriptableSingleton of type {typeof(T).Name}.");
+                    return null;
+                }
+            }
+
+            Debug.LogWarning(
+                $"Found multiple ScriptableSingletons of type {typeof(T).Name}, defaulting to first by name."
+            );
+            Array.Sort(instances, UnityObjectNameComparer<T>.Instance);
+            return instances[0];
+        });
+
+        public static bool HasInstance => LazyInstance.IsValueCreated && LazyInstance.Value != null;
+
+        public static T Instance => LazyInstance.Value;
+    }
+}

package/Runtime/Utils/ScriptableObjectSingleton.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b45bfc0f847a4d13ad5458b06a424c7c
+timeCreated: 1747539772

package/Runtime/Utils/UnityObjectNameComparer.cs

@@ -2,6 +2,9 @@
 {
     using System;
     using System.Collections.Generic;
+#if UNITY_EDITOR
+    using UnityEditor;
+#endif
 
     public sealed class UnityObjectNameComparer<T> : IComparer<T>
         where T : UnityEngine.Object
@@ -27,7 +30,25 @@
                 return -1;
             }
 
-            return string.Compare(x.name, y.name, StringComparison.OrdinalIgnoreCase);
+            int comparison = string.Compare(x.name, y.name, StringComparison.OrdinalIgnoreCase);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+#if UNITY_EDITOR
+            comparison = string.Compare(
+                AssetDatabase.GetAssetOrScenePath(x),
+                AssetDatabase.GetAssetOrScenePath(y),
+                StringComparison.OrdinalIgnoreCase
+            );
+#endif
+            if (comparison == 0)
+            {
+                return x.GetInstanceID().CompareTo(y.GetInstanceID());
+            }
+
+            return comparison;
         }
     }
 }

package/Tests/Runtime/Helper/ObjectHelperTests.cs

@@ -2,7 +2,6 @@
 {
     using System.Collections;
     using Core.Helper;
-    using Core.Helper.Partials;
     using JetBrains.Annotations;
     using NUnit.Framework;
     using UnityEngine;

package/package.json

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