com.wallstop-studios.unity-helpers 2.0.0-rc49 → 2.0.0-rc51

package/Runtime/Core/Extension/UnityExtensions.cs

@@ -3,6 +3,7 @@
     using System;
     using System.Collections.Generic;
     using System.Linq;
+    using System.Threading.Tasks;
     using DataStructure;
     using DataStructure.Adapters;
     using Helper;
@@ -1577,6 +1578,13 @@
             return false;
         }
 
+        public static Task AsTask(this AsyncOperation asyncOp)
+        {
+            TaskCompletionSource<bool> taskCompletionSource = new();
+            asyncOp.completed += _ => taskCompletionSource.SetResult(true);
+            return taskCompletionSource.Task;
+        }
+
 #if UNITY_EDITOR
         public static IEnumerable<Sprite> GetSpritesFromClip(this AnimationClip clip)
         {

package/Runtime/Core/Helper/SceneHelper.cs

@@ -0,0 +1,216 @@
+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 Task<DeferredDisposalResult<T>> GetObjectOfTypeInScene<T>(
+            string scenePath
+        )
+            where T : Object
+        {
+            DeferredDisposalResult<T[]> result = await GetAllObjectsOfTypeInScene<T>(scenePath);
+            return new DeferredDisposalResult<T>(
+                result.Result.FirstOrDefault(),
+                result.DisposeAsync
+            );
+        }
+
+        public static async Task<DeferredDisposalResult<T[]>> GetAllObjectsOfTypeInScene<T>(
+            string scenePath
+        )
+            where T : Object
+        {
+            // Ensure singleton is created
+            _ = UnityMainThreadDispatcher.Instance;
+            TaskCompletionSource<T[]> taskCompletionSource = new();
+
+            SceneLoadScope sceneScope = new(scenePath, OnSceneLoaded);
+            return await taskCompletionSource.Task.ContinueWith(result =>
+            {
+                return new DeferredDisposalResult<T[]>(
+                    result.Result,
+                    async () =>
+                    {
+                        TaskCompletionSource<bool> disposalComplete = new();
+                        UnityMainThreadDispatcher.Instance.RunOnMainThread(
+                            () =>
+                                sceneScope
+                                    .DisposeAsync()
+                                    .ContinueWith(_ => 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.TrySetResult(foundObjects);
+            }
+        }
+
+        public sealed class SceneLoadScope
+        {
+            private 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 Task 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)
+                {
+                    AsyncOperation asyncOperation = SceneManager.UnloadSceneAsync(
+                        openedScene,
+                        UnloadSceneOptions.None
+                    );
+                    await asyncOperation.AsTask();
+                }
+                else
+                {
+                    EditorSceneManager.CloseScene(openedScene, true);
+                }
+#else
+                AsyncOperation asyncOperation = SceneManager.UnloadSceneAsync(
+                    openedScene,
+                    UnloadSceneOptions.None
+                );
+                await asyncOperation.AsTask();
+#endif
+            }
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 366d25a4bde54caa9dbb17d039c63e6f
+timeCreated: 1743955669

package/Runtime/Core/Helper/UnityMainThreadDispatcher.cs

@@ -0,0 +1,32 @@
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+    using System.Collections.Concurrent;
+    using UnityEngine;
+    using Utils;
+
+    public sealed class UnityMainThreadDispatcher : RuntimeSingleton<UnityMainThreadDispatcher>
+    {
+        private readonly ConcurrentQueue<Action> _actions = new();
+
+        public void RunOnMainThread(Action action)
+        {
+            _actions.Enqueue(action);
+        }
+
+        private void Update()
+        {
+            while (_actions.TryDequeue(out Action action))
+            {
+                try
+                {
+                    action();
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e, this);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6d44672eb7364a0995fa1055d4187970
+timeCreated: 1743968724

package/Runtime/Core/Random/AbstractRandom.cs

@@ -67,7 +67,13 @@
                 throw new ArgumentException("Max cannot be zero");
             }
 
-            return (uint)(NextDouble() * max);
+            uint result = (uint)(NextDouble() * max);
+            if (result == max)
+            {
+                return result - 1;
+            }
+
+            return result;
         }
 
         public uint NextUint(uint min, uint max)
@@ -129,7 +135,13 @@
                 throw new ArgumentException($"Max {max} cannot be less-than or equal-to 0");
             }
 
-            return (long)(NextDouble() * max);
+            long result = (long)(NextDouble() * max);
+            if (result == max)
+            {
+                return result - 1;
+            }
+
+            return result;
         }
 
         public long NextLong(long min, long max)
@@ -147,7 +159,13 @@
                 return unchecked((long)NextUlong());
             }
 
-            return unchecked((long)(NextDouble() * range + min));
+            long result = unchecked((long)(NextDouble() * range + min));
+            if (result == max)
+            {
+                return result - 1;
+            }
+
+            return result;
         }
 
         public ulong NextUlong()
@@ -159,7 +177,12 @@
 
         public ulong NextUlong(ulong max)
         {
-            return (ulong)(NextDouble() * max);
+            ulong result = (ulong)(NextDouble() * max);
+            if (result == max)
+            {
+                return result - 1;
+            }
+            return result;
         }
 
         public ulong NextUlong(ulong min, ulong max)

package/Runtime/Core/Serialization/JsonConverters/ColorConverter.cs

@@ -0,0 +1,88 @@
+namespace UnityHelpers.Core.Serialization.JsonConverters
+{
+    using System;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using UnityEngine;
+
+    public sealed class ColorConverter : JsonConverter<Color>
+    {
+        public static readonly ColorConverter Instance = new();
+
+        private ColorConverter() { }
+
+        public override Color Read(
+            ref Utf8JsonReader reader,
+            Type typeToConvert,
+            JsonSerializerOptions options
+        )
+        {
+            if (reader.TokenType != JsonTokenType.StartObject)
+            {
+                throw new JsonException($"Invalid token type {reader.TokenType}");
+            }
+
+            float r = 0;
+            float g = 0;
+            float b = 0;
+            float a = 1;
+
+            while (reader.Read())
+            {
+                if (reader.TokenType == JsonTokenType.EndObject)
+                {
+                    return new Color(r, g, b, a);
+                }
+
+                if (reader.TokenType == JsonTokenType.PropertyName)
+                {
+                    string propertyName = reader.GetString();
+                    reader.Read();
+                    switch (propertyName)
+                    {
+                        case "r":
+                        {
+                            r = reader.GetSingle();
+                            break;
+                        }
+                        case "g":
+                        {
+                            g = reader.GetSingle();
+                            break;
+                        }
+                        case "b":
+                        {
+                            b = reader.GetSingle();
+                            break;
+                        }
+                        case "a":
+                        {
+                            a = reader.GetSingle();
+                            break;
+                        }
+                        default:
+                        {
+                            throw new JsonException($"Unknown property: {propertyName}");
+                        }
+                    }
+                }
+            }
+
+            throw new JsonException("Incomplete JSON for Color");
+        }
+
+        public override void Write(
+            Utf8JsonWriter writer,
+            Color value,
+            JsonSerializerOptions options
+        )
+        {
+            writer.WriteStartObject();
+            writer.WriteNumber("r", value.r);
+            writer.WriteNumber("g", value.g);
+            writer.WriteNumber("b", value.b);
+            writer.WriteNumber("a", value.a);
+            writer.WriteEndObject();
+        }
+    }
+}

package/Runtime/Core/Serialization/JsonConverters/ColorConverter.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 637013e97e6d436a880092e239d12e4e
+timeCreated: 1743567974

package/Runtime/Core/Serialization/JsonConverters/GameObjectConverter.cs

@@ -0,0 +1,37 @@
+namespace UnityHelpers.Core.Serialization.JsonConverters
+{
+    using System;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using UnityEngine;
+    using Object = UnityEngine.Object;
+
+    public sealed class GameObjectConverter : JsonConverter<GameObject>
+    {
+        public static readonly GameObjectConverter Instance = new();
+
+        private GameObjectConverter() { }
+
+        public override GameObject Read(
+            ref Utf8JsonReader reader,
+            Type typeToConvert,
+            JsonSerializerOptions options
+        )
+        {
+            throw new NotImplementedException(nameof(Read));
+        }
+
+        public override void Write(
+            Utf8JsonWriter writer,
+            GameObject value,
+            JsonSerializerOptions options
+        )
+        {
+            writer.WriteStringValue(
+                value == null
+                    ? "{}"
+                    : new { name = value.name, type = value.GetType().FullName }.ToString()
+            );
+        }
+    }
+}

package/Runtime/Core/Serialization/JsonConverters/GameObjectConverter.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6c12adc5c56c4be9bb536628749979b0
+timeCreated: 1743567258

package/Runtime/Core/Serialization/JsonConverters/Matrix4x4Converter.cs

@@ -0,0 +1,218 @@
+namespace UnityHelpers.Core.Serialization.JsonConverters
+{
+    using System;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using UnityEngine;
+
+    public sealed class Matrix4x4Converter : JsonConverter<Matrix4x4>
+    {
+        private static readonly string[] PropertyNames =
+        {
+            "m00",
+            "m01",
+            "m02",
+            "m03",
+            "m10",
+            "m11",
+            "m12",
+            "m13",
+            "m20",
+            "m21",
+            "m22",
+            "m23",
+            "m30",
+            "m31",
+            "m32",
+            "m33",
+        };
+
+        public static readonly Matrix4x4Converter Instance = new();
+
+        private Matrix4x4Converter() { }
+
+        public override Matrix4x4 Read(
+            ref Utf8JsonReader reader,
+            Type typeToConvert,
+            JsonSerializerOptions options
+        )
+        {
+            if (reader.TokenType != JsonTokenType.StartObject)
+            {
+                throw new JsonException("Expected StartObject token when parsing Matrix4x4.");
+            }
+
+            float m00 = 0;
+            float m01 = 0;
+            float m02 = 0;
+            float m03 = 0;
+            float m10 = 0;
+            float m11 = 0;
+            float m12 = 0;
+            float m13 = 0;
+            float m20 = 0;
+            float m21 = 0;
+            float m22 = 0;
+            float m23 = 0;
+            float m30 = 0;
+            float m31 = 0;
+            float m32 = 0;
+            float m33 = 0;
+
+            bool[] found = new bool[16];
+
+            while (reader.Read())
+            {
+                if (reader.TokenType == JsonTokenType.EndObject)
+                {
+                    break;
+                }
+                if (reader.TokenType != JsonTokenType.PropertyName)
+                {
+                    throw new JsonException("Expected property name in Matrix4x4 JSON.");
+                }
+                string propertyName = reader.GetString();
+                if (!reader.Read())
+                {
+                    throw new JsonException($"Expected value for property '{propertyName}'.");
+                }
+                float value;
+                try
+                {
+                    value = reader.GetSingle();
+                }
+                catch (Exception ex)
+                {
+                    throw new JsonException($"Invalid value for property '{propertyName}'.", ex);
+                }
+                switch (propertyName)
+                {
+                    case "m00":
+                        m00 = value;
+                        found[0] = true;
+                        break;
+                    case "m01":
+                        m01 = value;
+                        found[1] = true;
+                        break;
+                    case "m02":
+                        m02 = value;
+                        found[2] = true;
+                        break;
+                    case "m03":
+                        m03 = value;
+                        found[3] = true;
+                        break;
+                    case "m10":
+                        m10 = value;
+                        found[4] = true;
+                        break;
+                    case "m11":
+                        m11 = value;
+                        found[5] = true;
+                        break;
+                    case "m12":
+                        m12 = value;
+                        found[6] = true;
+                        break;
+                    case "m13":
+                        m13 = value;
+                        found[7] = true;
+                        break;
+                    case "m20":
+                        m20 = value;
+                        found[8] = true;
+                        break;
+                    case "m21":
+                        m21 = value;
+                        found[9] = true;
+                        break;
+                    case "m22":
+                        m22 = value;
+                        found[10] = true;
+                        break;
+                    case "m23":
+                        m23 = value;
+                        found[11] = true;
+                        break;
+                    case "m30":
+                        m30 = value;
+                        found[12] = true;
+                        break;
+                    case "m31":
+                        m31 = value;
+                        found[13] = true;
+                        break;
+                    case "m32":
+                        m32 = value;
+                        found[14] = true;
+                        break;
+                    case "m33":
+                        m33 = value;
+                        found[15] = true;
+                        break;
+                }
+            }
+
+            for (int i = 0; i < found.Length; i++)
+            {
+                if (!found[i])
+                {
+                    throw new JsonException(
+                        $"Missing property '{PropertyNames[i]}' for Matrix4x4."
+                    );
+                }
+            }
+
+            Matrix4x4 matrix = new()
+            {
+                m00 = m00,
+                m01 = m01,
+                m02 = m02,
+                m03 = m03,
+                m10 = m10,
+                m11 = m11,
+                m12 = m12,
+                m13 = m13,
+                m20 = m20,
+                m21 = m21,
+                m22 = m22,
+                m23 = m23,
+                m30 = m30,
+                m31 = m31,
+                m32 = m32,
+                m33 = m33,
+            };
+
+            return matrix;
+        }
+
+        public override void Write(
+            Utf8JsonWriter writer,
+            Matrix4x4 matrix,
+            JsonSerializerOptions options
+        )
+        {
+            writer.WriteStartObject();
+
+            writer.WriteNumber("m00", matrix.m00);
+            writer.WriteNumber("m01", matrix.m01);
+            writer.WriteNumber("m02", matrix.m02);
+            writer.WriteNumber("m03", matrix.m03);
+            writer.WriteNumber("m10", matrix.m10);
+            writer.WriteNumber("m11", matrix.m11);
+            writer.WriteNumber("m12", matrix.m12);
+            writer.WriteNumber("m13", matrix.m13);
+            writer.WriteNumber("m20", matrix.m20);
+            writer.WriteNumber("m21", matrix.m21);
+            writer.WriteNumber("m22", matrix.m22);
+            writer.WriteNumber("m23", matrix.m23);
+            writer.WriteNumber("m30", matrix.m30);
+            writer.WriteNumber("m31", matrix.m31);
+            writer.WriteNumber("m32", matrix.m32);
+            writer.WriteNumber("m33", matrix.m33);
+
+            writer.WriteEndObject();
+        }
+    }
+}

package/Runtime/Core/Serialization/JsonConverters/Matrix4x4Converter.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 456d0090c1d744de924e8f18a895b87b
+timeCreated: 1743568330