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

package/Runtime/Core/Helper/UnityMainThreadDispatcher.cs

@@ -1,80 +1,82 @@
-namespace UnityHelpers.Core.Helper
-{
-    using System;
-    using System.Collections.Concurrent;
-    using UnityEditor;
-    using UnityEngine;
-    using Utils;
-
-    [ExecuteAlways]
-    public sealed class UnityMainThreadDispatcher : RuntimeSingleton<UnityMainThreadDispatcher>
-    {
-        private readonly ConcurrentQueue<Action> _actions = new();
-
-#if UNITY_EDITOR
-        private readonly EditorApplication.CallbackFunction _update;
-        private bool _attachedEditorUpdate;
-#endif
-
-        public UnityMainThreadDispatcher()
-        {
-#if UNITY_EDITOR
-            _update = Update;
-#endif
-        }
-
-        public void RunOnMainThread(Action action)
-        {
-            _actions.Enqueue(action);
-        }
-
-        private void OnEnable()
-        {
-#if UNITY_EDITOR
-            if (!_attachedEditorUpdate)
-            {
-                EditorApplication.update += _update;
-                _attachedEditorUpdate = true;
-            }
-#endif
-        }
-
-        private void OnDisable()
-        {
-#if UNITY_EDITOR
-            if (_attachedEditorUpdate)
-            {
-                EditorApplication.update -= _update;
-                _attachedEditorUpdate = false;
-            }
-#endif
-        }
-
-        protected override void OnDestroy()
-        {
-#if UNITY_EDITOR
-            if (_attachedEditorUpdate)
-            {
-                EditorApplication.update -= _update;
-                _attachedEditorUpdate = false;
-            }
-#endif
-            base.OnDestroy();
-        }
-
-        private void Update()
-        {
-            while (_actions.TryDequeue(out Action action))
-            {
-                try
-                {
-                    action();
-                }
-                catch (Exception e)
-                {
-                    Debug.LogException(e, this);
-                }
-            }
-        }
-    }
-}
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+    using System.Collections.Concurrent;
+    using UnityEngine;
+    using Utils;
+#if UNITY_EDITOR
+    using UnityEditor;
+#endif
+
+    [ExecuteAlways]
+    public sealed class UnityMainThreadDispatcher : RuntimeSingleton<UnityMainThreadDispatcher>
+    {
+        private readonly ConcurrentQueue<Action> _actions = new();
+
+#if UNITY_EDITOR
+        private readonly EditorApplication.CallbackFunction _update;
+        private bool _attachedEditorUpdate;
+#endif
+
+        public UnityMainThreadDispatcher()
+        {
+#if UNITY_EDITOR
+            _update = Update;
+#endif
+        }
+
+        public void RunOnMainThread(Action action)
+        {
+            _actions.Enqueue(action);
+        }
+
+        private void OnEnable()
+        {
+#if UNITY_EDITOR
+            if (!_attachedEditorUpdate)
+            {
+                EditorApplication.update += _update;
+                _attachedEditorUpdate = true;
+            }
+#endif
+        }
+
+        private void OnDisable()
+        {
+#if UNITY_EDITOR
+            if (_attachedEditorUpdate)
+            {
+                EditorApplication.update -= _update;
+                _attachedEditorUpdate = false;
+            }
+#endif
+        }
+
+        protected override void OnDestroy()
+        {
+#if UNITY_EDITOR
+            if (_attachedEditorUpdate)
+            {
+                EditorApplication.update -= _update;
+                _attachedEditorUpdate = false;
+            }
+#endif
+            base.OnDestroy();
+        }
+
+        private void Update()
+        {
+            while (_actions.TryDequeue(out Action action))
+            {
+                try
+                {
+                    action();
+                }
+                catch (Exception e)
+                {
+                    Debug.LogException(e, this);
+                }
+            }
+        }
+    }
+}

package/Runtime/Core/Helper/WallMath.cs

@@ -1,166 +1,166 @@
-namespace UnityHelpers.Core.Helper
-{
-    using System;
-    using UnityEngine;
-
-    public static class WallMath
-    {
-        /**
-            http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/8-b132/java/util/concurrent/ThreadLocalRandom.java#356
-            <summary>
-                BoundedDouble borrowed from Java's ThreadLocalRandom
-            </summary>
-        */
-
-        public static double BoundedDouble(double max, double value)
-        {
-            return value < max
-                ? value
-                : BitConverter.Int64BitsToDouble(BitConverter.DoubleToInt64Bits(value) - 1);
-        }
-
-        public static float BoundedFloat(float max, float value)
-        {
-            return value < max
-                ? value
-                : BitConverter.ToSingle(
-                    BitConverter.GetBytes(
-                        BitConverter.ToInt32(BitConverter.GetBytes(value), 0) - 1
-                    ),
-                    0
-                );
-        }
-
-        public static float PositiveMod(this float value, float max)
-        {
-            value %= max;
-            value += max;
-            return value % max;
-        }
-
-        public static double PositiveMod(this double value, double max)
-        {
-            value %= max;
-            value += max;
-            return value % max;
-        }
-
-        public static int PositiveMod(this int value, int max)
-        {
-            value %= max;
-            value += max;
-            return value % max;
-        }
-
-        public static long PositiveMod(this long value, long max)
-        {
-            value %= max;
-            value += max;
-            return value % max;
-        }
-
-        public static int WrappedAdd(this int value, int increment, int max)
-        {
-            WrappedAdd(ref value, increment, max);
-            return value;
-        }
-
-        public static int WrappedAdd(ref int value, int increment, int max)
-        {
-            value += increment;
-            if (value < max)
-            {
-                return value;
-            }
-            return value %= max;
-        }
-
-        public static int WrappedIncrement(this int value, int max)
-        {
-            return WrappedAdd(value, 1, max);
-        }
-
-        public static int WrappedIncrement(ref int value, int max)
-        {
-            return WrappedAdd(ref value, 1, max);
-        }
-
-        public static T Clamp<T>(this T value, T min, T max)
-            where T : IComparable<T>
-        {
-            if (value.CompareTo(min) < 0)
-            {
-                return min;
-            }
-
-            return max.CompareTo(value) < 0 ? max : value;
-        }
-
-        public static Vector2 Clamp(this Rect bounds, Vector2 point)
-        {
-            return Clamp(bounds, ref point);
-        }
-
-        public static Vector2 Clamp(this Rect bounds, ref Vector2 point)
-        {
-            if (bounds.Contains(point))
-            {
-                return point;
-            }
-
-            Vector2 center = bounds.center;
-            Vector2 direction = point - center;
-
-            if (direction == Vector2.zero)
-            {
-                return center;
-            }
-
-            float tMax = float.MaxValue;
-            Vector2 min = bounds.min;
-            Vector2 max = bounds.max;
-
-            if (direction.x != 0)
-            {
-                if (0 < direction.x)
-                {
-                    float t2 = (max.x - center.x) / direction.x;
-                    tMax = Mathf.Min(tMax, t2);
-                }
-                else
-                {
-                    float t1 = (min.x - center.x) / direction.x;
-                    tMax = Mathf.Min(tMax, t1);
-                }
-            }
-
-            if (direction.y != 0)
-            {
-                if (direction.y > 0)
-                {
-                    float t2 = (max.y - center.y) / direction.y;
-                    tMax = Mathf.Min(tMax, t2);
-                }
-                else
-                {
-                    float t1 = (min.y - center.y) / direction.y;
-                    tMax = Mathf.Min(tMax, t1);
-                }
-            }
-
-            tMax = Mathf.Clamp01(tMax);
-
-            point = center + direction * tMax;
-            point = new Vector2(
-                Mathf.Clamp(point.x, min.x, max.x),
-                Mathf.Clamp(point.y, min.y, max.y)
-            );
-            return point;
-        }
-
-        public static bool Approximately(this float lhs, float rhs, float tolerance = 0.045f)
-        {
-            return Mathf.Abs(lhs - rhs) <= tolerance;
-        }
-    }
-}
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+    using UnityEngine;
+
+    public static class WallMath
+    {
+        /**
+            http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/8-b132/java/util/concurrent/ThreadLocalRandom.java#356
+            <summary>
+                BoundedDouble borrowed from Java's ThreadLocalRandom
+            </summary>
+        */
+
+        public static double BoundedDouble(double max, double value)
+        {
+            return value < max
+                ? value
+                : BitConverter.Int64BitsToDouble(BitConverter.DoubleToInt64Bits(value) - 1);
+        }
+
+        public static float BoundedFloat(float max, float value)
+        {
+            return value < max
+                ? value
+                : BitConverter.ToSingle(
+                    BitConverter.GetBytes(
+                        BitConverter.ToInt32(BitConverter.GetBytes(value), 0) - 1
+                    ),
+                    0
+                );
+        }
+
+        public static float PositiveMod(this float value, float max)
+        {
+            value %= max;
+            value += max;
+            return value % max;
+        }
+
+        public static double PositiveMod(this double value, double max)
+        {
+            value %= max;
+            value += max;
+            return value % max;
+        }
+
+        public static int PositiveMod(this int value, int max)
+        {
+            value %= max;
+            value += max;
+            return value % max;
+        }
+
+        public static long PositiveMod(this long value, long max)
+        {
+            value %= max;
+            value += max;
+            return value % max;
+        }
+
+        public static int WrappedAdd(this int value, int increment, int max)
+        {
+            WrappedAdd(ref value, increment, max);
+            return value;
+        }
+
+        public static int WrappedAdd(ref int value, int increment, int max)
+        {
+            value += increment;
+            if (value < max)
+            {
+                return value;
+            }
+            return value %= max;
+        }
+
+        public static int WrappedIncrement(this int value, int max)
+        {
+            return WrappedAdd(value, 1, max);
+        }
+
+        public static int WrappedIncrement(ref int value, int max)
+        {
+            return WrappedAdd(ref value, 1, max);
+        }
+
+        public static T Clamp<T>(this T value, T min, T max)
+            where T : IComparable<T>
+        {
+            if (value.CompareTo(min) < 0)
+            {
+                return min;
+            }
+
+            return max.CompareTo(value) < 0 ? max : value;
+        }
+
+        public static Vector2 Clamp(this Rect bounds, Vector2 point)
+        {
+            return Clamp(bounds, ref point);
+        }
+
+        public static Vector2 Clamp(this Rect bounds, ref Vector2 point)
+        {
+            if (bounds.Contains(point))
+            {
+                return point;
+            }
+
+            Vector2 center = bounds.center;
+            Vector2 direction = point - center;
+
+            if (direction == Vector2.zero)
+            {
+                return center;
+            }
+
+            float tMax = float.MaxValue;
+            Vector2 min = bounds.min;
+            Vector2 max = bounds.max;
+
+            if (direction.x != 0)
+            {
+                if (0 < direction.x)
+                {
+                    float t2 = (max.x - center.x) / direction.x;
+                    tMax = Mathf.Min(tMax, t2);
+                }
+                else
+                {
+                    float t1 = (min.x - center.x) / direction.x;
+                    tMax = Mathf.Min(tMax, t1);
+                }
+            }
+
+            if (direction.y != 0)
+            {
+                if (direction.y > 0)
+                {
+                    float t2 = (max.y - center.y) / direction.y;
+                    tMax = Mathf.Min(tMax, t2);
+                }
+                else
+                {
+                    float t1 = (min.y - center.y) / direction.y;
+                    tMax = Mathf.Min(tMax, t1);
+                }
+            }
+
+            tMax = Mathf.Clamp01(tMax);
+
+            point = center + direction * tMax;
+            point = new Vector2(
+                Mathf.Clamp(point.x, min.x, max.x),
+                Mathf.Clamp(point.y, min.y, max.y)
+            );
+            return point;
+        }
+
+        public static bool Approximately(this float lhs, float rhs, float tolerance = 0.045f)
+        {
+            return Mathf.Abs(lhs - rhs) <= tolerance;
+        }
+    }
+}

package/Runtime/Core/Math/Line.cs

@@ -1,55 +1,55 @@
-namespace UnityHelpers.Core.Math
-{
-    using System;
-    using System.Runtime.Serialization;
-    using Extension;
-    using UnityEngine;
-
-    // https://pastebin.com/iQDhQTFN
-    [Serializable]
-    [DataContract]
-    public readonly struct Line
-    {
-        public readonly Vector2 from;
-        public readonly Vector2 to;
-
-        private readonly float _a;
-        private readonly float _b;
-        private readonly float _c;
-
-        public Line(Vector2 from, Vector2 to)
-        {
-            this.from = from;
-            this.to = to;
-            _a = to.y - from.y;
-            _b = from.x - to.x;
-            _c = _a * from.x + _b * from.y;
-        }
-
-        public bool Intersects(Line other)
-        {
-            return UnityExtensions.Intersects(from, to, other.from, other.to);
-        }
-
-        public bool TryGetIntersectionPoint(Line other, out Vector2 intersection)
-        {
-            if (!Intersects(other))
-            {
-                intersection = default;
-                return false;
-            }
-
-            float determinant = _a * other._b - other._a * _b;
-            if (Mathf.Approximately(determinant, 0))
-            {
-                intersection = default;
-                return false;
-            }
-
-            float x = (other._b * _c - _b * other._c) / determinant;
-            float y = (_a * other._c - other._a * _c) / determinant;
-            intersection = new Vector2(x, y);
-            return true;
-        }
-    }
-}
+namespace UnityHelpers.Core.Math
+{
+    using System;
+    using System.Runtime.Serialization;
+    using Extension;
+    using UnityEngine;
+
+    // https://pastebin.com/iQDhQTFN
+    [Serializable]
+    [DataContract]
+    public readonly struct Line
+    {
+        public readonly Vector2 from;
+        public readonly Vector2 to;
+
+        private readonly float _a;
+        private readonly float _b;
+        private readonly float _c;
+
+        public Line(Vector2 from, Vector2 to)
+        {
+            this.from = from;
+            this.to = to;
+            _a = to.y - from.y;
+            _b = from.x - to.x;
+            _c = _a * from.x + _b * from.y;
+        }
+
+        public bool Intersects(Line other)
+        {
+            return UnityExtensions.Intersects(from, to, other.from, other.to);
+        }
+
+        public bool TryGetIntersectionPoint(Line other, out Vector2 intersection)
+        {
+            if (!Intersects(other))
+            {
+                intersection = default;
+                return false;
+            }
+
+            float determinant = _a * other._b - other._a * _b;
+            if (Mathf.Approximately(determinant, 0))
+            {
+                intersection = default;
+                return false;
+            }
+
+            float x = (other._b * _c - _b * other._c) / determinant;
+            float y = (_a * other._c - other._a * _c) / determinant;
+            intersection = new Vector2(x, y);
+            return true;
+        }
+    }
+}