com.wallstop-studios.unity-helpers 2.0.0-rc56 → 2.0.0-rc58

package/Runtime/Core/Helper/ReflectionHelpers.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 7d4e9b4eb4764c7881cc89a54582ec35
+fileFormatVersion: 2
+guid: 7d4e9b4eb4764c7881cc89a54582ec35
 timeCreated: 1742066830

package/Runtime/Core/Helper/SceneHelper.cs

@@ -1,213 +1,209 @@
-namespace UnityHelpers.Core.Helper
-{
-    using System;
-    using System.Linq;
-    using System.Threading.Tasks;
-    using Extension;
-    using UnityEngine;
-    using UnityEngine.Events;
-    using UnityEngine.SceneManagement;
-    using Utils;
-    using Object = UnityEngine.Object;
-#if UNITY_EDITOR
-    using UnityEditor;
-    using UnityEditor.SceneManagement;
-#endif
-
-    public static class SceneHelper
-    {
-        public static string[] GetAllScenePaths(string[] searchFolders = null)
-        {
-#if UNITY_EDITOR
-            searchFolders ??= Array.Empty<string>();
-            return AssetDatabase
-                .FindAssets("t:Scene", searchFolders)
-                .Select(AssetDatabase.GUIDToAssetPath)
-                .ToArray();
-#else
-            return Array.Empty<string>();
-#endif
-        }
-
-        public static string[] GetScenesInBuild()
-        {
-#if UNITY_EDITOR
-            return EditorBuildSettings
-                .scenes.Where(scene => scene.enabled)
-                .Select(scene => scene.path)
-                .ToArray();
-#else
-            return Array.Empty<string>();
-#endif
-        }
-
-        public static async ValueTask<DeferredDisposalResult<T>> GetObjectOfTypeInScene<T>(
-            string scenePath
-        )
-            where T : Object
-        {
-            DeferredDisposalResult<T[]> result = await GetAllObjectsOfTypeInScene<T>(scenePath);
-            T value = result.result.Length == 0 ? default : result.result[0];
-            return new DeferredDisposalResult<T>(value, result.DisposeAsync);
-        }
-
-        public static async ValueTask<DeferredDisposalResult<T[]>> GetAllObjectsOfTypeInScene<T>(
-            string scenePath
-        )
-            where T : Object
-        {
-            // Ensure singleton is created
-            _ = UnityMainThreadDispatcher.Instance;
-            TaskCompletionSource<T[]> taskCompletionSource = new();
-
-            SceneLoadScope sceneScope = new(scenePath, OnSceneLoaded);
-            T[] result = await taskCompletionSource.Task;
-
-            return new DeferredDisposalResult<T[]>(
-                result,
-                async () =>
-                {
-                    TaskCompletionSource<bool> disposalComplete = new();
-                    UnityMainThreadDispatcher.Instance.RunOnMainThread(
-                        () =>
-                            _ = sceneScope
-                                .DisposeAsync()
-                                .WithContinuation(() => disposalComplete.SetResult(true))
-                    );
-
-                    await disposalComplete.Task;
-                }
-            );
-
-            void OnSceneLoaded(Scene scene, LoadSceneMode mode)
-            {
-                if (!string.Equals(scene.path, scenePath, StringComparison.Ordinal))
-                {
-                    return;
-                }
-
-                T[] foundObjects = Object
-                    .FindObjectsByType<T>(FindObjectsInactive.Include, FindObjectsSortMode.None)
-                    .Where(obj =>
-                    {
-                        GameObject go = obj.GetGameObject();
-                        if (go == null)
-                        {
-                            return false;
-                        }
-
-                        return go.scene == scene;
-                    })
-                    .ToArray();
-                taskCompletionSource.SetResult(foundObjects);
-            }
-        }
-
-        public
-#if UNITY_EDITOR
-        readonly
-#endif
-        struct SceneLoadScope
-        {
-            private
-#if UNITY_EDITOR
-            readonly
-#endif
-            Scene? _openedScene;
-            private readonly UnityAction<Scene, LoadSceneMode> _onSceneLoaded;
-            private readonly bool _eventAdded;
-
-            public SceneLoadScope(string scenePath, UnityAction<Scene, LoadSceneMode> onSceneLoaded)
-            {
-                _onSceneLoaded = onSceneLoaded;
-                _eventAdded = false;
-                Scene activeScene = SceneManager.GetActiveScene();
-                if (
-                    !activeScene.IsValid()
-                    || !activeScene.isLoaded
-                    || !string.Equals(activeScene.path, scenePath, StringComparison.Ordinal)
-                )
-                {
-#if UNITY_EDITOR
-                    if (Application.isPlaying)
-                    {
-                        SceneManager.sceneLoaded += onSceneLoaded;
-                        _eventAdded = true;
-                        _openedScene = EditorSceneManager.LoadSceneInPlayMode(
-                            scenePath,
-                            new LoadSceneParameters(LoadSceneMode.Additive, LocalPhysicsMode.None)
-                        );
-                    }
-                    else
-                    {
-                        _openedScene = EditorSceneManager.OpenScene(
-                            scenePath,
-                            OpenSceneMode.Additive
-                        );
-                        onSceneLoaded?.Invoke(_openedScene.Value, LoadSceneMode.Additive);
-                    }
-#else
-                    SceneManager.sceneLoaded += onSceneLoaded;
-                    _eventAdded = true;
-                    SceneManager.sceneLoaded += LocalSceneLoaded;
-                    SceneManager.LoadScene(scenePath, LoadSceneMode.Additive);
-                    _openedScene = SceneManager.GetSceneByPath(scenePath);
-
-                    void LocalSceneLoaded(Scene scene, LoadSceneMode mode)
-                    {
-                        if (!string.Equals(scene.path, scenePath, StringComparison.Ordinal))
-                        {
-                            return;
-                        }
-
-                        _openedScene = scene;
-                        SceneManager.sceneLoaded -= LocalSceneLoaded;
-                    }
-#endif
-                }
-                else
-                {
-                    onSceneLoaded?.Invoke(activeScene, LoadSceneMode.Single);
-                    _openedScene = null;
-                }
-            }
-
-            public async ValueTask DisposeAsync()
-            {
-                if (_eventAdded)
-                {
-                    SceneManager.sceneLoaded -= _onSceneLoaded;
-                }
-
-                if (_openedScene == null)
-                {
-                    return;
-                }
-
-                Scene openedScene = _openedScene.Value;
-                if (!openedScene.IsValid())
-                {
-                    return;
-                }
-
-                if (!openedScene.isLoaded)
-                {
-                    return;
-                }
-
-#if UNITY_EDITOR
-                if (Application.isPlaying)
-                {
-                    await SceneManager.UnloadSceneAsync(openedScene, UnloadSceneOptions.None);
-                }
-                else
-                {
-                    EditorSceneManager.CloseScene(openedScene, true);
-                }
-#else
-                await SceneManager.UnloadSceneAsync(openedScene, UnloadSceneOptions.None);
-#endif
-            }
-        }
-    }
-}
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+    using System.Linq;
+    using System.Threading.Tasks;
+    using Extension;
+    using UnityEngine;
+    using UnityEngine.Events;
+    using UnityEngine.SceneManagement;
+    using Utils;
+    using Object = UnityEngine.Object;
+#if UNITY_EDITOR
+    using UnityEditor;
+    using UnityEditor.SceneManagement;
+#endif
+
+    public static class SceneHelper
+    {
+        public static string[] GetAllScenePaths(string[] searchFolders = null)
+        {
+#if UNITY_EDITOR
+            searchFolders ??= Array.Empty<string>();
+            return AssetDatabase
+                .FindAssets("t:Scene", searchFolders)
+                .Select(AssetDatabase.GUIDToAssetPath)
+                .ToArray();
+#else
+            return Array.Empty<string>();
+#endif
+        }
+
+        public static string[] GetScenesInBuild()
+        {
+#if UNITY_EDITOR
+            return EditorBuildSettings
+                .scenes.Where(scene => scene.enabled)
+                .Select(scene => scene.path)
+                .ToArray();
+#else
+            return Array.Empty<string>();
+#endif
+        }
+
+        public static async ValueTask<DeferredDisposalResult<T>> GetObjectOfTypeInScene<T>(
+            string scenePath
+        )
+            where T : Object
+        {
+            DeferredDisposalResult<T[]> result = await GetAllObjectsOfTypeInScene<T>(scenePath);
+            T value = result.result.Length == 0 ? default : result.result[0];
+            return new DeferredDisposalResult<T>(value, result.DisposeAsync);
+        }
+
+        public static async ValueTask<DeferredDisposalResult<T[]>> GetAllObjectsOfTypeInScene<T>(
+            string scenePath
+        )
+            where T : Object
+        {
+            // Ensure singleton is created
+            _ = UnityMainThreadDispatcher.Instance;
+            TaskCompletionSource<T[]> taskCompletionSource = new();
+
+            SceneLoadScope sceneScope = new(scenePath, OnSceneLoaded);
+            T[] result = await taskCompletionSource.Task;
+
+            return new DeferredDisposalResult<T[]>(
+                result,
+                async () =>
+                {
+                    TaskCompletionSource<bool> disposalComplete = new();
+                    UnityMainThreadDispatcher.Instance.RunOnMainThread(
+                        () =>
+                            _ = sceneScope
+                                .DisposeAsync()
+                                .WithContinuation(() => disposalComplete.SetResult(true))
+                    );
+
+                    await disposalComplete.Task;
+                }
+            );
+
+            void OnSceneLoaded(Scene scene, LoadSceneMode mode)
+            {
+                if (!string.Equals(scene.path, scenePath, StringComparison.Ordinal))
+                {
+                    return;
+                }
+
+                T[] foundObjects = Object
+                    .FindObjectsByType<T>(FindObjectsInactive.Include, FindObjectsSortMode.None)
+                    .Where(obj =>
+                    {
+                        GameObject go = obj.GetGameObject();
+                        if (go == null)
+                        {
+                            return false;
+                        }
+
+                        return go.scene == scene;
+                    })
+                    .ToArray();
+                taskCompletionSource.SetResult(foundObjects);
+            }
+        }
+
+        public sealed class SceneLoadScope
+        {
+            private
+#if UNITY_EDITOR
+            readonly
+#endif
+            Scene? _openedScene;
+            private readonly UnityAction<Scene, LoadSceneMode> _onSceneLoaded;
+            private readonly bool _eventAdded;
+
+            public SceneLoadScope(string scenePath, UnityAction<Scene, LoadSceneMode> onSceneLoaded)
+            {
+                _onSceneLoaded = onSceneLoaded;
+                _eventAdded = false;
+                Scene activeScene = SceneManager.GetActiveScene();
+                if (
+                    !activeScene.IsValid()
+                    || !activeScene.isLoaded
+                    || !string.Equals(activeScene.path, scenePath, StringComparison.Ordinal)
+                )
+                {
+#if UNITY_EDITOR
+                    if (Application.isPlaying)
+                    {
+                        SceneManager.sceneLoaded += onSceneLoaded;
+                        _eventAdded = true;
+                        _openedScene = EditorSceneManager.LoadSceneInPlayMode(
+                            scenePath,
+                            new LoadSceneParameters(LoadSceneMode.Additive, LocalPhysicsMode.None)
+                        );
+                    }
+                    else
+                    {
+                        _openedScene = EditorSceneManager.OpenScene(
+                            scenePath,
+                            OpenSceneMode.Additive
+                        );
+                        onSceneLoaded?.Invoke(_openedScene.Value, LoadSceneMode.Additive);
+                    }
+#else
+                    SceneManager.sceneLoaded += onSceneLoaded;
+                    _eventAdded = true;
+                    SceneManager.sceneLoaded += LocalSceneLoaded;
+                    SceneManager.LoadScene(scenePath, LoadSceneMode.Additive);
+                    _openedScene = SceneManager.GetSceneByPath(scenePath);
+
+                    void LocalSceneLoaded(Scene scene, LoadSceneMode mode)
+                    {
+                        if (!string.Equals(scene.path, scenePath, StringComparison.Ordinal))
+                        {
+                            return;
+                        }
+
+                        _openedScene = scene;
+                        SceneManager.sceneLoaded -= LocalSceneLoaded;
+                    }
+#endif
+                }
+                else
+                {
+                    onSceneLoaded?.Invoke(activeScene, LoadSceneMode.Single);
+                    _openedScene = null;
+                }
+            }
+
+            public async ValueTask DisposeAsync()
+            {
+                if (_eventAdded)
+                {
+                    SceneManager.sceneLoaded -= _onSceneLoaded;
+                }
+
+                if (_openedScene == null)
+                {
+                    return;
+                }
+
+                Scene openedScene = _openedScene.Value;
+                if (!openedScene.IsValid())
+                {
+                    return;
+                }
+
+                if (!openedScene.isLoaded)
+                {
+                    return;
+                }
+
+#if UNITY_EDITOR
+                if (Application.isPlaying)
+                {
+                    await SceneManager.UnloadSceneAsync(openedScene, UnloadSceneOptions.None);
+                }
+                else
+                {
+                    EditorSceneManager.CloseScene(openedScene, true);
+                }
+#else
+                await SceneManager.UnloadSceneAsync(openedScene, UnloadSceneOptions.None);
+#endif
+            }
+        }
+    }
+}

package/Runtime/Core/Helper/SpriteHelpers.cs

@@ -1,41 +1,41 @@
-namespace UnityHelpers.Core.Helper
-{
-    using Extension;
-    using UnityEditor;
-    using UnityEngine;
-
-    public static class SpriteHelpers
-    {
-        public static void MakeReadable(this Texture2D texture)
-        {
-            if (texture == null || texture.isReadable)
-            {
-                return;
-            }
-
-#if UNITY_EDITOR
-            string assetPath = AssetDatabase.GetAssetPath(texture);
-            if (string.IsNullOrEmpty(assetPath))
-            {
-                texture.LogError("Failed to get asset path.");
-                return;
-            }
-
-            TextureImporter tImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
-            if (tImporter == null)
-            {
-                texture.LogError("Failed to get texture importer.");
-                return;
-            }
-
-            if (!tImporter.isReadable)
-            {
-                tImporter.isReadable = true;
-                EditorUtility.SetDirty(tImporter);
-                tImporter.SaveAndReimport();
-                EditorUtility.SetDirty(texture);
-            }
-#endif
-        }
-    }
-}
+namespace UnityHelpers.Core.Helper
+{
+    using Extension;
+    using UnityEditor;
+    using UnityEngine;
+
+    public static class SpriteHelpers
+    {
+        public static void MakeReadable(this Texture2D texture)
+        {
+            if (texture == null || texture.isReadable)
+            {
+                return;
+            }
+
+#if UNITY_EDITOR
+            string assetPath = AssetDatabase.GetAssetPath(texture);
+            if (string.IsNullOrEmpty(assetPath))
+            {
+                texture.LogError("Failed to get asset path.");
+                return;
+            }
+
+            TextureImporter tImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
+            if (tImporter == null)
+            {
+                texture.LogError("Failed to get texture importer.");
+                return;
+            }
+
+            if (!tImporter.isReadable)
+            {
+                tImporter.isReadable = true;
+                EditorUtility.SetDirty(tImporter);
+                tImporter.SaveAndReimport();
+                EditorUtility.SetDirty(texture);
+            }
+#endif
+        }
+    }
+}

package/Runtime/Core/Helper/SpriteHelpers.cs.meta

@@ -1,11 +1,11 @@
-fileFormatVersion: 2
-guid: d28a1e1f45dd4ccbbb71f8305aec8018
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: d28a1e1f45dd4ccbbb71f8305aec8018
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Helper/StringInList.cs

@@ -1,31 +1,31 @@
-namespace UnityHelpers.Core.Helper
-{
-    using System;
-    using System.Reflection;
-    using UnityEngine;
-
-    public sealed class StringInList : PropertyAttribute
-    {
-        public delegate string[] GetStringList();
-
-        public StringInList(params string[] list)
-        {
-            List = list;
-        }
-
-        public StringInList(Type type, string methodName)
-        {
-            MethodInfo method = type.GetMethod(methodName);
-            if (method != null)
-            {
-                List = method.Invoke(null, null) as string[];
-            }
-            else
-            {
-                Debug.LogError($"NO SUCH METHOD {methodName} FOR {type}");
-            }
-        }
-
-        public string[] List { get; private set; }
-    }
-}
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+    using System.Reflection;
+    using UnityEngine;
+
+    public sealed class StringInList : PropertyAttribute
+    {
+        public delegate string[] GetStringList();
+
+        public StringInList(params string[] list)
+        {
+            List = list;
+        }
+
+        public StringInList(Type type, string methodName)
+        {
+            MethodInfo method = type.GetMethod(methodName);
+            if (method != null)
+            {
+                List = method.Invoke(null, null) as string[];
+            }
+            else
+            {
+                Debug.LogError($"NO SUCH METHOD {methodName} FOR {type}");
+            }
+        }
+
+        public string[] List { get; private set; }
+    }
+}

package/Runtime/Core/Helper/StringInList.cs.meta

@@ -1,11 +1,11 @@
-fileFormatVersion: 2
-guid: 9b010398039c42f186240019389a5d46
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: 9b010398039c42f186240019389a5d46
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: