com.wallstop-studios.unity-helpers 2.0.0-rc73 → 2.0.0-rc73.10

package/Editor/SpriteCropper.cs

@@ -30,7 +30,7 @@
         private const float AlphaThreshold = 0.01f;
 
         [SerializeField]
-        private Object[] _inputDirectories;
+        private List<Object> _inputDirectories = new();
 
         [SerializeField]
         private bool _onlyNecessary;
@@ -44,12 +44,56 @@
         {
             GUILayout.Label("Drag folders below", EditorStyles.boldLabel);
             SerializedObject so = new(this);
+            so.Update();
             SerializedProperty dirs = so.FindProperty(nameof(_inputDirectories));
             EditorGUILayout.PropertyField(dirs, true);
             SerializedProperty onlyNecessary = so.FindProperty(nameof(_onlyNecessary));
             EditorGUILayout.PropertyField(onlyNecessary, true);
             so.ApplyModifiedProperties();
 
+            if (GUILayout.Button("Select Input Folder"))
+            {
+                string path = EditorUtility.OpenFolderPanel(
+                    "Select Sprite Input Folder",
+                    Application.dataPath,
+                    ""
+                );
+                if (!string.IsNullOrWhiteSpace(path))
+                {
+                    if (path.StartsWith(Application.dataPath, StringComparison.Ordinal))
+                    {
+                        path = "Assets" + path.Substring(Application.dataPath.Length);
+                        if (
+                            !_inputDirectories
+                                .Select(AssetDatabase.GetAssetPath)
+                                .Any(directory =>
+                                    string.Equals(
+                                        directory,
+                                        path,
+                                        StringComparison.OrdinalIgnoreCase
+                                    )
+                                )
+                        )
+                        {
+                            Object folder = AssetDatabase.LoadAssetAtPath<Object>(path);
+                            if (folder == null)
+                            {
+                                return;
+                            }
+                            _inputDirectories.Add(folder);
+                        }
+                    }
+                    else
+                    {
+                        EditorUtility.DisplayDialog(
+                            "Invalid Folder",
+                            "Please select a folder inside the project's Assets directory.",
+                            "OK"
+                        );
+                    }
+                }
+            }
+
             if (GUILayout.Button("Find Sprites To Process"))
             {
                 FindFilesToProcess();
@@ -79,7 +123,7 @@
         private void FindFilesToProcess()
         {
             _filesToProcess = new List<string>();
-            if (_inputDirectories == null || _inputDirectories.Length == 0)
+            if (_inputDirectories is not { Count: > 0 })
             {
                 this.LogWarn($"No input directories selected.");
                 return;
@@ -118,7 +162,7 @@
 
         private void ProcessFoundSprites()
         {
-            if (_filesToProcess == null || _filesToProcess.Count == 0)
+            if (_filesToProcess is not { Count: > 0 })
             {
                 this.LogWarn($"No files found or selected for processing.");
                 return;
@@ -169,11 +213,6 @@
                             newImporters.Add(newImporter);
                         }
                     }
-
-                    foreach (TextureImporter newImporter in newImporters)
-                    {
-                        newImporter.SaveAndReimport();
-                    }
                 }
                 finally
                 {
@@ -209,7 +248,7 @@
             }
 
             TextureImporter importer = AssetImporter.GetAtPath(assetPath) as TextureImporter;
-            if (importer == null || !importer.textureType.Equals(TextureImporterType.Sprite))
+            if (importer is not { textureType: TextureImporterType.Sprite })
             {
                 return;
             }
@@ -232,8 +271,10 @@
                 return null;
             }
 
-            TextureImporter importer = AssetImporter.GetAtPath(assetPath) as TextureImporter;
-            if (importer == null || !importer.textureType.Equals(TextureImporterType.Sprite))
+            if (
+                AssetImporter.GetAtPath(assetPath)
+                is not TextureImporter { textureType: TextureImporterType.Sprite } importer
+            )
             {
                 return null;
             }
@@ -241,7 +282,6 @@
             TextureImporterSettings originalSettings = new();
             importer.ReadTextureSettings(originalSettings);
 
-            bool originalReadableState = importer.isReadable;
             if (!importer.isReadable)
             {
                 importer.isReadable = true;
@@ -254,142 +294,128 @@
                 return null;
             }
 
-            TextureImporter resultImporter;
-            try
-            {
-                Color32[] pixels = tex.GetPixels32();
-
-                int width = tex.width;
-                int height = tex.height;
-                int minX = width;
-                int minY = height;
-                int maxX = 0;
-                int maxY = 0;
-                bool hasVisible = false;
-
-                object lockObject = new();
-
-                Parallel.For(
-                    0,
-                    width * height,
-                    () => (minX: width, minY: height, maxX: 0, maxY: 0, hasVisible: false),
-                    (index, _, localState) =>
-                    {
-                        int x = index % width;
-                        int y = index / width;
+            Color32[] pixels = tex.GetPixels32();
+            int width = tex.width;
+            int height = tex.height;
+            int minX = width;
+            int minY = height;
+            int maxX = 0;
+            int maxY = 0;
+            bool hasVisible = false;
+
+            object lockObject = new();
+
+            Parallel.For(
+                0,
+                width * height,
+                () => (minX: width, minY: height, maxX: 0, maxY: 0, hasVisible: false),
+                (index, _, localState) =>
+                {
+                    int x = index % width;
+                    int y = index / width;
 
-                        float a = pixels[index].a / 255f;
-                        if (a > AlphaThreshold)
-                        {
-                            localState.hasVisible = true;
-                            localState.minX = Mathf.Min(localState.minX, x);
-                            localState.minY = Mathf.Min(localState.minY, y);
-                            localState.maxX = Mathf.Max(localState.maxX, x);
-                            localState.maxY = Mathf.Max(localState.maxY, y);
-                        }
-                        return localState;
-                    },
-                    finalLocalState =>
+                    float a = pixels[index].a / 255f;
+                    if (a > AlphaThreshold)
                     {
-                        if (finalLocalState.hasVisible)
-                        {
-                            lock (lockObject)
-                            {
-                                hasVisible = true;
-                                minX = Mathf.Min(minX, finalLocalState.minX);
-                                minY = Mathf.Min(minY, finalLocalState.minY);
-                                maxX = Mathf.Max(maxX, finalLocalState.maxX);
-                                maxY = Mathf.Max(maxY, finalLocalState.maxY);
-                            }
-                        }
+                        localState.hasVisible = true;
+                        localState.minX = Mathf.Min(localState.minX, x);
+                        localState.minY = Mathf.Min(localState.minY, y);
+                        localState.maxX = Mathf.Max(localState.maxX, x);
+                        localState.maxY = Mathf.Max(localState.maxY, y);
                     }
-                );
-
-                if (!hasVisible)
-                {
-                    return null;
-                }
-
-                int cropWidth = maxX - minX + 1;
-                int cropHeight = maxY - minY + 1;
-
-                if (_onlyNecessary && cropWidth == width && cropHeight == height)
+                    return localState;
+                },
+                finalLocalState =>
                 {
-                    return null;
-                }
-
-                Texture2D cropped = new(cropWidth, cropHeight, TextureFormat.RGBA32, false);
-                Color32[] croppedPixels = new Color32[cropWidth * cropHeight];
-
-                Parallel.For(
-                    0,
-                    cropHeight,
-                    y =>
+                    if (finalLocalState.hasVisible)
                     {
-                        int sourceYOffset = (y + minY) * width;
-                        int destYOffset = y * cropWidth;
-                        for (int x = 0; x < cropWidth; ++x)
+                        lock (lockObject)
                         {
-                            croppedPixels[destYOffset + x] = pixels[sourceYOffset + x + minX];
+                            hasVisible = true;
+                            minX = Mathf.Min(minX, finalLocalState.minX);
+                            minY = Mathf.Min(minY, finalLocalState.minY);
+                            maxX = Mathf.Max(maxX, finalLocalState.maxX);
+                            maxY = Mathf.Max(maxY, finalLocalState.maxY);
                         }
                     }
-                );
-
-                cropped.SetPixels32(croppedPixels);
-                cropped.Apply();
-
-                string newPath = Path.Combine(
-                    assetDirectory,
-                    CroppedPrefix + Path.GetFileName(assetPath)
-                );
-                File.WriteAllBytes(newPath, cropped.EncodeToPNG());
-                DestroyImmediate(cropped);
-                AssetDatabase.ImportAsset(newPath);
-                TextureImporter newImporter = AssetImporter.GetAtPath(newPath) as TextureImporter;
-                if (newImporter == null)
-                {
-                    return null;
                 }
+            );
 
-                newImporter.textureType = importer.textureType;
-                newImporter.spriteImportMode = importer.spriteImportMode;
-                newImporter.filterMode = importer.filterMode;
-                newImporter.textureCompression = importer.textureCompression;
-                newImporter.wrapMode = importer.wrapMode;
-                newImporter.mipmapEnabled = importer.mipmapEnabled;
-                newImporter.spritePixelsPerUnit = importer.spritePixelsPerUnit;
-
-                TextureImporterSettings newSettings = new();
-                newImporter.ReadTextureSettings(newSettings);
-                newSettings.spriteExtrude = originalSettings.spriteExtrude;
-
-                Vector2 origPivot = GetSpritePivot(importer);
-                Vector2 origCenter = new(width * origPivot.x, height * origPivot.y);
-                Vector2 newPivotPixels = origCenter - new Vector2(minX, minY);
-                Vector2 newPivotNorm = new(
-                    cropWidth > 0 ? newPivotPixels.x / cropWidth : 0.5f,
-                    cropHeight > 0 ? newPivotPixels.y / cropHeight : 0.5f
-                );
-
-                newImporter.spriteImportMode = SpriteImportMode.Single;
-                newImporter.spritePivot = newPivotNorm;
-                newSettings.spritePivot = newPivotNorm;
-                newSettings.spriteAlignment = (int)SpriteAlignment.Custom;
+            if (!hasVisible)
+            {
+                return null;
+            }
 
-                newImporter.SetTextureSettings(newSettings);
-                newImporter.isReadable = false;
+            int cropWidth = maxX - minX + 1;
+            int cropHeight = maxY - minY + 1;
 
-                resultImporter = newImporter;
-            }
-            finally
+            if (_onlyNecessary && cropWidth == width && cropHeight == height)
             {
-                if (importer != null && importer.isReadable != originalReadableState)
+                return null;
+            }
+
+            Texture2D cropped = new(cropWidth, cropHeight, TextureFormat.RGBA32, false);
+            Color32[] croppedPixels = new Color32[cropWidth * cropHeight];
+
+            Parallel.For(
+                0,
+                cropHeight,
+                y =>
                 {
-                    importer.isReadable = originalReadableState;
-                    importer.SaveAndReimport();
+                    int sourceYOffset = (y + minY) * width;
+                    int destYOffset = y * cropWidth;
+                    for (int x = 0; x < cropWidth; ++x)
+                    {
+                        croppedPixels[destYOffset + x] = pixels[sourceYOffset + x + minX];
+                    }
                 }
+            );
+
+            cropped.SetPixels32(croppedPixels);
+            cropped.Apply();
+
+            string newPath = Path.Combine(
+                assetDirectory,
+                CroppedPrefix + Path.GetFileName(assetPath)
+            );
+            File.WriteAllBytes(newPath, cropped.EncodeToPNG());
+            DestroyImmediate(cropped);
+            AssetDatabase.ImportAsset(newPath);
+            TextureImporter newImporter = AssetImporter.GetAtPath(newPath) as TextureImporter;
+            if (newImporter == null)
+            {
+                return null;
             }
 
+            newImporter.textureType = importer.textureType;
+            newImporter.spriteImportMode = importer.spriteImportMode;
+            newImporter.filterMode = importer.filterMode;
+            newImporter.textureCompression = importer.textureCompression;
+            newImporter.wrapMode = importer.wrapMode;
+            newImporter.mipmapEnabled = importer.mipmapEnabled;
+            newImporter.spritePixelsPerUnit = importer.spritePixelsPerUnit;
+
+            TextureImporterSettings newSettings = new();
+            importer.ReadTextureSettings(newSettings);
+
+            Vector2 origPivot = GetSpritePivot(importer);
+            Vector2 origCenter = new(width * origPivot.x, height * origPivot.y);
+            Vector2 newPivotPixels = origCenter - new Vector2(minX, minY);
+            Vector2 newPivotNorm = new(
+                cropWidth > 0 ? newPivotPixels.x / cropWidth : 0.5f,
+                cropHeight > 0 ? newPivotPixels.y / cropHeight : 0.5f
+            );
+
+            newImporter.spriteImportMode = SpriteImportMode.Single;
+            newImporter.spritePivot = newPivotNorm;
+            newSettings.spritePivot = newPivotNorm;
+            newSettings.spriteAlignment = (int)SpriteAlignment.Custom;
+
+            newImporter.SetTextureSettings(newSettings);
+            newImporter.isReadable = true;
+            newImporter.SaveAndReimport();
+
+            TextureImporter resultImporter = newImporter;
             return resultImporter;
         }
 

package/Editor/SpriteSettingsApplier.cs

@@ -10,6 +10,7 @@ namespace WallstopStudios.UnityHelpers.Editor
     using System.Linq;
     using UnityEditor;
     using UnityEngine;
+    using Utils;
     using Object = UnityEngine.Object;
 
     [Serializable]
@@ -203,9 +204,10 @@ namespace WallstopStudios.UnityHelpers.Editor
                         valuePropHeight
                     );
 
-                    EditorGUI.indentLevel++;
-                    EditorGUI.PropertyField(valueRect, valueProp, GUIContent.none, true);
-                    EditorGUI.indentLevel--;
+                    using (new GUIIndentScope())
+                    {
+                        EditorGUI.PropertyField(valueRect, valueProp, GUIContent.none, true);
+                    }
 
                     currentRect.y += valueRect.height + EditorGUIUtility.standardVerticalSpacing;
                 }

package/Editor/Utils/GUIHorizontalScope.cs

@@ -0,0 +1,20 @@
+namespace WallstopStudios.UnityHelpers.Editor.Utils
+{
+#if UNITY_EDITOR
+    using System;
+    using UnityEditor;
+
+    public sealed class GUIHorizontalScope : IDisposable
+    {
+        public GUIHorizontalScope()
+        {
+            EditorGUILayout.BeginHorizontal();
+        }
+
+        public void Dispose()
+        {
+            EditorGUILayout.EndHorizontal();
+        }
+    }
+#endif
+}

package/Editor/Utils/GUIHorizontalScope.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 91a6cb913d1847ae9e2a82b1f59660a7
+timeCreated: 1746644886

package/Editor/Utils/GUIIndentScope.cs

@@ -0,0 +1,20 @@
+namespace WallstopStudios.UnityHelpers.Editor.Utils
+{
+#if UNITY_EDITOR
+    using System;
+    using UnityEditor;
+
+    public sealed class GUIIndentScope : IDisposable
+    {
+        public GUIIndentScope()
+        {
+            EditorGUI.indentLevel++;
+        }
+
+        public void Dispose()
+        {
+            EditorGUI.indentLevel--;
+        }
+    }
+#endif
+}

package/Editor/Utils/GUIIndentScope.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ba7be1ee2025494c963d393c9b5e5c2f
+timeCreated: 1746811930

package/Runtime/Core/DataStructure/Circle.cs

@@ -34,7 +34,7 @@
             float yN = Math.Max(center.y, rectangle.y);
             float dX = xN - center.x;
             float dY = yN - center.y;
-            return (dX * dX + dY * dY) <= _radiusSquared;
+            return dX * dX + dY * dY <= _radiusSquared;
         }
 
         public bool Overlaps(Bounds bounds)

package/Runtime/Core/DataStructure/QuadTree.cs

@@ -45,7 +45,7 @@
 
                 Bounds[] quadrants =
                 {
-                    new Bounds(
+                    new(
                         new Vector3(
                             boundary.center.x - halfQuadrantSize.x,
                             boundary.center.y + halfQuadrantSize.y,
@@ -53,7 +53,7 @@
                         ),
                         quadrantSize
                     ),
-                    new Bounds(
+                    new(
                         new Vector3(
                             boundary.center.x + halfQuadrantSize.x,
                             boundary.center.y + halfQuadrantSize.y,
@@ -61,7 +61,7 @@
                         ),
                         quadrantSize
                     ),
-                    new Bounds(
+                    new(
                         new Vector3(
                             boundary.center.x + halfQuadrantSize.x,
                             boundary.center.y - halfQuadrantSize.y,
@@ -69,7 +69,7 @@
                         ),
                         quadrantSize
                     ),
-                    new Bounds(
+                    new(
                         new Vector3(
                             boundary.center.x - halfQuadrantSize.x,
                             boundary.center.y - halfQuadrantSize.y,

package/Runtime/Core/Extension/ColorExtensions.cs

@@ -534,14 +534,14 @@
                 rgb.b > 0.04045 ? Mathf.Pow((rgb.b + 0.055f) / 1.055f, 2.4f) : rgb.b / 12.92f;
 
             double x = (r * 0.4124 + g * 0.3576 + b * 0.1805) / 0.95047;
-            double y = (r * 0.2126 + g * 0.7152 + b * 0.0722);
+            double y = r * 0.2126 + g * 0.7152 + b * 0.0722;
             double z = (r * 0.0193 + g * 0.1192 + b * 0.9505) / 1.08883;
 
-            x = x > 0.008856 ? Mathf.Pow((float)x, 1f / 3f) : (7.787 * x) + 16f / 116f;
-            y = y > 0.008856 ? Mathf.Pow((float)y, 1f / 3f) : (7.787 * y) + 16f / 116f;
-            z = z > 0.008856 ? Mathf.Pow((float)z, 1f / 3f) : (7.787 * z) + 16f / 116f;
+            x = x > 0.008856 ? Mathf.Pow((float)x, 1f / 3f) : 7.787 * x + 16f / 116f;
+            y = y > 0.008856 ? Mathf.Pow((float)y, 1f / 3f) : 7.787 * y + 16f / 116f;
+            z = z > 0.008856 ? Mathf.Pow((float)z, 1f / 3f) : 7.787 * z + 16f / 116f;
 
-            return new LABColor((116 * y) - 16, 500 * (x - y), 200 * (y - z));
+            return new LABColor(116 * y - 16, 500 * (x - y), 200 * (y - z));
         }
 
         private static Color LABToRGB(double l, double a, double b)

package/Runtime/Core/Extension/IEnumerableExtensions.cs

@@ -78,7 +78,7 @@
 
         public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> items, int size)
         {
-            using var enumerator = items.GetEnumerator();
+            using IEnumerator<T> enumerator = items.GetEnumerator();
             bool hasNext = enumerator.MoveNext();
 
             IEnumerable<T> NextPartitionOf()

package/Runtime/Core/Extension/StringExtensions.cs

@@ -4,6 +4,7 @@
     using System.Text;
     using System.Threading;
     using Serialization;
+    using UnityEngine;
 
     public static class StringExtensions
     {
@@ -48,6 +49,54 @@
             return Serializer.JsonStringify(value);
         }
 
+        public static int LevenshteinDistance(this string source1, string source2)
+        {
+            source1 ??= string.Empty;
+            source2 ??= string.Empty;
+
+            int source1Length = source1.Length;
+            int source2Length = source2.Length;
+
+            int[][] matrix = new int[source1Length + 1][];
+            for (int index = 0; index < source1Length + 1; index++)
+            {
+                matrix[index] = new int[source2Length + 1];
+            }
+
+            if (source1Length == 0)
+            {
+                return source2Length;
+            }
+
+            if (source2Length == 0)
+            {
+                return source1Length;
+            }
+
+            for (int i = 0; i <= source1Length; matrix[i][0] = ++i)
+            {
+                // Spin to force array population
+            }
+
+            for (int j = 0; j <= source2Length; matrix[0][j] = ++j)
+            {
+                // Spin to force array population
+            }
+
+            for (int i = 1; i <= source1Length; ++i)
+            {
+                for (int j = 1; j <= source2Length; ++j)
+                {
+                    int cost = source2[j - 1] == source1[i - 1] ? 0 : 1;
+                    matrix[i][j] = Mathf.Min(
+                        Mathf.Min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1),
+                        matrix[i - 1][j - 1] + cost
+                    );
+                }
+            }
+            return matrix[source1Length][source2Length];
+        }
+
         public static string ToPascalCase(this string value, string separator = "")
         {
             int startIndex = 0;

package/Runtime/Core/Extension/UnityExtensions.cs

@@ -126,9 +126,9 @@
                 xMin,
                 yMin,
                 zMin,
-                (xMax - xMin) + 1,
-                (yMax - yMin) + 1,
-                (zMax - zMin) + 1
+                xMax - xMin + 1,
+                yMax - yMin + 1,
+                zMax - zMin + 1
             );
         }
 
@@ -160,9 +160,9 @@
                 xMin,
                 yMin,
                 zMin,
-                (xMax - xMin) + 1,
-                (yMax - yMin) + 1,
-                (zMax - zMin) + 1
+                xMax - xMin + 1,
+                yMax - yMin + 1,
+                zMax - zMin + 1
             );
         }
 
@@ -584,8 +584,8 @@
             public float LargestAngle(FastVector3Int point)
             {
                 Vector2 worldPoint = _grid.CellToWorld(point);
-                float angleFrom = Vector2.Angle((toWorld - fromWorld), (worldPoint - fromWorld));
-                float angleTo = Vector2.Angle((fromWorld - toWorld), (worldPoint - toWorld));
+                float angleFrom = Vector2.Angle(toWorld - fromWorld, worldPoint - fromWorld);
+                float angleTo = Vector2.Angle(fromWorld - toWorld, worldPoint - toWorld);
                 return Math.Max(angleFrom, angleTo);
             }
         }
@@ -1126,7 +1126,7 @@
                 }
 
                 if (
-                    (newVector.x < position.x) == (position.x <= oldVector.x)
+                    newVector.x < position.x == position.x <= oldVector.x
                     && (position.y - (long)lhs.y) * (rhs.x - lhs.x)
                         < (rhs.y - (long)lhs.y) * (position.x - lhs.x)
                 )
@@ -1274,7 +1274,7 @@
                     yield break;
                 }
 
-                scaleFactor *= (4 / 3f);
+                scaleFactor *= 4 / 3f;
             }
         }
 
@@ -1416,8 +1416,8 @@
             float ty = v.y;
 
             Vector2 rotatedVector;
-            rotatedVector.x = (cos * tx) - (sin * ty);
-            rotatedVector.y = (sin * tx) + (cos * ty);
+            rotatedVector.x = cos * tx - sin * ty;
+            rotatedVector.y = sin * tx + cos * ty;
 
             return rotatedVector;
         }
@@ -1564,12 +1564,12 @@
 
         public static bool IsOnEdge2D(this FastVector3Int position, BoundsInt bounds)
         {
-            if (bounds.xMin == position.x || (bounds.xMax - 1) == position.x)
+            if (bounds.xMin == position.x || bounds.xMax - 1 == position.x)
             {
                 return bounds.yMin <= position.y && position.y < bounds.yMax;
             }
 
-            if (bounds.yMin == position.y || (bounds.yMax - 1) == position.y)
+            if (bounds.yMin == position.y || bounds.yMax - 1 == position.y)
             {
                 return bounds.xMin <= position.x && position.x < bounds.xMax;
             }