com.wallstop-studios.unity-helpers 1.0.0-rc4

package/Runtime/Utils/AnimationEventEqualityComparer.cs

@@ -0,0 +1,149 @@
+namespace UnityHelpers.Utils
+{
+    using System;
+    using System.Collections.Generic;
+    using UnityEngine;
+
+    public sealed class AnimationEventEqualityComparer : EqualityComparer<AnimationEvent>, IComparer<AnimationEvent>
+    {
+        public static readonly AnimationEventEqualityComparer Instance = new();
+
+        private AnimationEventEqualityComparer()
+        {
+
+        }
+
+        // Returns a shallow copy with equatable values propagated
+        public AnimationEvent Copy(AnimationEvent instance)
+        {
+            if (instance == null)
+            {
+                return null;
+            }
+
+            AnimationEvent copy = new();
+            CopyInto(copy, instance);
+            return copy;
+        }
+
+        public void CopyInto(AnimationEvent into, AnimationEvent parameters)
+        {
+            if (into == null || parameters == null)
+            {
+                return;
+            }
+
+            into.time = parameters.time;
+            into.functionName = parameters.functionName;
+            into.intParameter = parameters.intParameter;
+            into.floatParameter = parameters.floatParameter;
+            into.stringParameter = parameters.stringParameter;
+            into.objectReferenceParameter = parameters.objectReferenceParameter;
+            into.messageOptions = parameters.messageOptions;
+        }
+
+        public override bool Equals(AnimationEvent lhs, AnimationEvent rhs)
+        {
+            if (ReferenceEquals(lhs, rhs))
+            {
+                return true;
+            }
+
+            if (lhs == null || rhs == null)
+            {
+                return false;
+            }
+
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            if (lhs.time != rhs.time)
+            {
+                return false;
+            }
+
+            if (lhs.functionName != rhs.functionName)
+            {
+                return false;
+            }
+
+            if (lhs.intParameter != rhs.intParameter)
+            {
+                return false;
+            }
+
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            if (lhs.floatParameter != rhs.floatParameter)
+            {
+                return false;
+            }
+
+            if (lhs.stringParameter != rhs.stringParameter)
+            {
+                return false;
+            }
+
+            if (lhs.objectReferenceParameter != rhs.objectReferenceParameter)
+            {
+                return false;
+            }
+
+            if (lhs.messageOptions != rhs.messageOptions)
+            {
+                return false;
+            }
+
+            return true;
+        }
+    
+
+        public override int GetHashCode(AnimationEvent instance)
+        {
+            return HashCode.Combine(
+                instance.time, instance.functionName, instance.intParameter, instance.floatParameter,
+                instance.stringParameter, instance.objectReferenceParameter, instance.messageOptions);
+        }
+
+        public int Compare(AnimationEvent lhs, AnimationEvent rhs)
+        {
+            if (ReferenceEquals(lhs, rhs))
+            {
+                return 0;
+            }
+
+            if (ReferenceEquals(null, rhs))
+            {
+                return 1;
+            }
+
+            if (ReferenceEquals(null, lhs))
+            {
+                return -1;
+            }
+
+            int timeComparison = lhs.time.CompareTo(rhs.time);
+            if (timeComparison != 0)
+            {
+                return timeComparison;
+            }
+
+            int functionNameComparison = string.Compare(lhs.functionName, rhs.functionName, StringComparison.Ordinal);
+            if (functionNameComparison != 0)
+            {
+                return functionNameComparison;
+            }
+
+            int intParameterComparison = lhs.intParameter.CompareTo(rhs.intParameter);
+            if (intParameterComparison != 0)
+            {
+                return intParameterComparison;
+            }
+
+            int stringParameterComparison = string.Compare(lhs.stringParameter, rhs.stringParameter, StringComparison.Ordinal);
+            if (stringParameterComparison != 0)
+            {
+                return stringParameterComparison;
+            }
+
+            return lhs.floatParameter.CompareTo(rhs.floatParameter);
+        }
+    }
+}

package/Runtime/Utils/AnimationEventEqualityComparer.cs.meta

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

package/Runtime/Utils/AnimatorEnumStateMachine.cs

@@ -0,0 +1,80 @@
+namespace UnityHelpers.Utils
+{
+    using Core.Extension;
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Linq;
+    using System.Runtime.Serialization;
+    using UnityEngine;
+
+    /// <summary>
+    ///     Maps & manages an enum parameter to bool Animator parameters.
+    /// </summary>
+    /// <typeparam name="T">Specific Enum being managed.</typeparam>
+    [DataContract]
+    public sealed class AnimatorEnumStateMachine<T>
+        where T : struct, IConvertible, IComparable,
+        IFormattable // This is as close as we can get to saying where T : Enum (https://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum)
+    {
+        private static readonly T[] Values = Enum.GetValues(typeof(T)).OfType<T>().ToArray();
+
+        [IgnoreDataMember] private readonly HashSet<string> _availableBools = new HashSet<string>();
+
+        [IgnoreDataMember] public readonly Animator Animator;
+
+        [IgnoreDataMember] private T _value;
+
+        [DataMember]
+        public T Value
+        {
+            get { return _value; }
+            set
+            {
+                foreach (T possibleValue in Values)
+                {
+                    string valueName = possibleValue.ToString(CultureInfo.InvariantCulture);
+                    if (_availableBools.Contains(valueName))
+                    {
+                        Animator.SetBool(valueName, Equals(value, possibleValue));
+                    }
+                }
+
+                _value = value;
+            }
+        }
+
+        [DataMember]
+        private string Type => typeof(T).Name;
+
+        public AnimatorEnumStateMachine(Animator animator, T defaultValue = default(T))
+        {
+            if (animator == null)
+            {
+                throw new ArgumentNullException(nameof(animator));
+            }
+
+            Animator = animator;
+
+            foreach (AnimatorControllerParameter parameter in Animator.parameters)
+            {
+                switch (parameter.type)
+                {
+                    case AnimatorControllerParameterType.Bool:
+                    case AnimatorControllerParameterType.Trigger:
+                        _availableBools.Add(parameter.name);
+                        continue;
+                    default:
+                        continue;
+                }
+            }
+
+            _value = defaultValue;
+        }
+
+        public override string ToString()
+        {
+            return this.ToJson();
+        }
+    }
+}

package/Runtime/Utils/AnimatorEnumStateMachine.cs.meta

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

package/Runtime/Utils/Buffers.cs

@@ -0,0 +1,32 @@
+namespace UnityHelpers.Utils
+{
+    using System.Collections.Generic;
+    using UnityEngine;
+
+    public static class Buffers
+    {
+        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];
+
+        /*
+            Note: Only use with CONSTANT time values, otherwise this is a memory leak.
+            DO NOT USE with random values.
+         */
+        public static readonly Dictionary<float, WaitForSeconds> WaitForSeconds = new();
+        public static readonly System.Random Random = new();
+        public static readonly WaitForFixedUpdate WaitForFixedUpdate = new();
+        public static readonly WaitForEndOfFrame WaitForEndOfFrame = new();
+    }
+
+    public static class Buffers<T>
+    {
+        public static readonly List<T> List = new();
+        public static readonly HashSet<T> HashSet = new();
+        public static readonly Queue<T> Queue = new();
+        public static readonly Stack<T> Stack = new();
+        public static readonly LinkedList<T> LinkedList = new();
+    }
+}

package/Runtime/Utils/Buffers.cs.meta

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

package/Runtime/Utils/CircleLineRenderer.cs

@@ -0,0 +1,122 @@
+namespace UnityHelpers.Utils
+{
+    using Core.Attributes;
+    using Core.Extension;
+    using Core.Helper;
+    using Core.Random;
+    using UnityEngine;
+
+    [RequireComponent(typeof(LineRenderer))]
+    [RequireComponent(typeof(CircleCollider2D))]
+    [DisallowMultipleComponent]
+    public sealed class CircleLineRenderer : MonoBehaviour
+    {
+        public float minLineWidth = 0.005f;
+        public float maxLineWidth = 0.02f;
+        public int numSegments = 4;
+        public int baseSegments = 4;
+        public float updateRateSeconds = 0.1f;
+        public Color color = Color.grey;
+        
+        public Vector3 Offset
+        {
+            get => _offset;
+            set => transform.localPosition = _offset = value;
+        }
+
+        [SiblingComponent]
+        private CircleCollider2D _collider;
+        [SiblingComponent]
+        private LineRenderer[] _lineRenderers;
+
+        private Vector3 _offset;
+
+        private Coroutine _update;
+
+        private void Awake()
+        {
+            this.AssignSiblingComponents();
+        }
+
+        private void OnEnable()
+        {
+            if (_update != null)
+            {
+                StopCoroutine(_update);
+            }
+            _update = this.StartFunctionAsCoroutine(Render, updateRateSeconds);
+        }
+
+        private void OnDisable()
+        {
+            if (_update != null)
+            {
+                StopCoroutine(_update);
+                _update = null;
+            }
+        }
+
+        private void OnValidate()
+        {
+            if (numSegments <= 2)
+            {
+                this.LogWarn("Invalid number of segments {0}.", numSegments);
+            }
+
+            if (updateRateSeconds <= 0)
+            {
+                this.LogWarn("Invalid update rate {0}.", updateRateSeconds);
+            }
+
+            if (maxLineWidth < minLineWidth)
+            {
+                this.LogWarn("MaxLineWidth {0} smaller than MinLineWidth {1}.", maxLineWidth, minLineWidth);
+            }
+        }
+
+        private void Update()
+        {
+            foreach (LineRenderer lineRenderer in _lineRenderers)
+            {
+                lineRenderer.enabled = _collider.enabled;
+            }
+        }
+
+        private void Render()
+        {
+            foreach (LineRenderer lineRenderer in _lineRenderers)
+            {
+                if (!lineRenderer.enabled)
+                {
+                    lineRenderer.positionCount = 0;
+                    return;
+                }
+
+                lineRenderer.startColor = color;
+                lineRenderer.endColor = color;
+                lineRenderer.loop = true;
+                lineRenderer.positionCount = numSegments;
+
+                // ReSharper disable once CompareOfFloatsByEqualityOperator
+                float lineWidth = minLineWidth == maxLineWidth ? minLineWidth : PcgRandom.Instance.NextFloat(minLineWidth, maxLineWidth);
+
+                lineRenderer.startWidth = lineWidth;
+                lineRenderer.endWidth = lineWidth;
+                lineRenderer.useWorldSpace = false; // All below positions are local space
+                float distanceMultiplier = _collider.radius;
+
+                float angle = 360f / numSegments;
+                float offsetRadians = PcgRandom.Instance.NextFloat(angle);
+                float currentOffset = offsetRadians;
+                Vector3[] positions = new Vector3[numSegments];
+                for (int i = 0; i < numSegments; ++i)
+                {
+                    positions[i] = new Vector3(Mathf.Cos(Mathf.Deg2Rad * currentOffset), Mathf.Sin(Mathf.Deg2Rad * currentOffset)) * distanceMultiplier;
+                    currentOffset += angle % 360f;
+                }
+
+                lineRenderer.SetPositions(positions);
+            }
+        }
+    }
+}

package/Runtime/Utils/CircleLineRenderer.cs.meta

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

package/Runtime/Utils/Oscillator.cs

@@ -0,0 +1,25 @@
+namespace UnityHelpers.Utils
+{
+    using UnityEngine;
+
+    [DisallowMultipleComponent]
+    public sealed class Oscillator : MonoBehaviour
+    {
+        public float speed = 1f;
+        public float width = 1f;
+        public float height = 1f;
+
+        private Vector3 _initialLocalPosition;
+        
+        private void Awake()
+        {
+            _initialLocalPosition = transform.localPosition;
+        }
+
+        private void Update()
+        {
+            float time = Time.time;
+            transform.localPosition = _initialLocalPosition + new Vector3(Mathf.Cos(time * speed) * width, Mathf.Sin(time * speed) * height);
+        }
+    }
+}

package/Runtime/Utils/Oscillator.cs.meta

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

package/Runtime/Utils/SetTextureImportData.cs

@@ -0,0 +1,67 @@
+namespace UnityHelpers.Utils
+{
+    using UnityEditor;
+    using UnityEngine;
+
+    public static class SetTextureImportData
+    {
+        public const int MaxTextureSize = 8192;
+        public const int RegularTextureSize = 2048;
+
+        public static void SetReadable(Texture2D texture)
+        {
+#if UNITY_EDITOR
+
+            string assetPath = AssetDatabase.GetAssetPath(texture);
+            if (string.IsNullOrEmpty(assetPath))
+            {
+                return;
+            }
+            TextureImporter tImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
+
+            if (tImporter == null)
+            {
+                return;
+            }
+
+            tImporter.isReadable = true;
+            tImporter.SaveAndReimport();
+#endif
+        }
+
+        public static void SetTextureImporterFormat(Texture2D texture, bool isReadable = true)
+        {
+#if UNITY_EDITOR
+            if (texture == null)
+            {
+                return;
+            }
+
+            string assetPath = AssetDatabase.GetAssetPath(texture);
+            if (string.IsNullOrEmpty(assetPath))
+            {
+                return;
+            }
+            TextureImporter tImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
+
+            if (tImporter == null)
+            {
+                return;
+            }
+            
+            tImporter.isReadable = isReadable;
+
+            TextureImporterPlatformSettings importerSettings = new TextureImporterPlatformSettings
+            {
+                resizeAlgorithm = TextureResizeAlgorithm.Bilinear,
+                maxTextureSize = MaxTextureSize,
+                format = TextureImporterFormat.Automatic,
+                textureCompression = TextureImporterCompression.Uncompressed,
+            };
+            tImporter.SetPlatformTextureSettings(importerSettings);
+
+            tImporter.SaveAndReimport();
+# endif
+        }
+    }
+}

package/Runtime/Utils/SetTextureImportData.cs.meta

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

package/Runtime/Utils.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 21a94927e8953294aa5277276d6a7bfd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/WallstopStudios.UnityHelpers.asmdef

@@ -0,0 +1,14 @@
+{
+    "name": "WallstopStudios.UnityHelpers",
+    "rootNamespace": "UnityHelpers",
+    "references": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Runtime/WallstopStudios.UnityHelpers.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 63a0f107903545b4fae68b24d4dd4b41
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4ab0b5c03f18e0845b8a5571f9704c0a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Editor/WallstopStudios.UnityHelpers.Tests.Editor.asmdef

@@ -0,0 +1,17 @@
+{
+    "name": "WallstopStudios.UnityHelpers.Tests.Editor",
+    "rootNamespace": "",
+    "references": [
+        "UnityEditor.TestRunner",
+        "UnityEngine.TestRunner"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Tests/Editor/WallstopStudios.UnityHelpers.Tests.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 2cefd41e6e454d642863fffc7f6185b0
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 90260f95a1a6f734192b29867185b5fd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/DataStructures/BalancedKDTreeTests.cs

@@ -0,0 +1,14 @@
+namespace UnityHelpers.Tests.DataStructures
+{
+    using System.Collections.Generic;
+    using UnityEngine;
+    using Core.DataStructure;
+
+    public sealed class BalancedKDTreeTests : SpatialTreeTests<KDTree<Vector2>>
+    {
+        protected override KDTree<Vector2> CreateTree(IEnumerable<Vector2> points)
+        {
+            return new KDTree<Vector2>(points, _ => _, balanced: true);
+        }
+    }
+}

package/Tests/Runtime/DataStructures/BalancedKDTreeTests.cs.meta

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

package/Tests/Runtime/DataStructures/QuadTreeTests.cs

@@ -0,0 +1,14 @@
+namespace UnityHelpers.Tests.DataStructures
+{
+    using System.Collections.Generic;
+    using UnityEngine;
+    using Core.DataStructure;
+
+    public sealed class QuadTreeTests : SpatialTreeTests<QuadTree<Vector2>>
+    {
+        protected override QuadTree<Vector2> CreateTree(IEnumerable<Vector2> points)
+        {
+            return new QuadTree<Vector2>(points, _ => _);
+        }
+    }
+}

package/Tests/Runtime/DataStructures/QuadTreeTests.cs.meta

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