com.wallstop-studios.unity-helpers 2.0.0-rc73.6 → 2.0.0-rc73.8

package/Editor/AnimationCreator.cs

@@ -140,7 +140,7 @@
                 return;
             }
 
-            absolutePath = absolutePath.Replace("\\", "/");
+            absolutePath = absolutePath.SanitizePath();
             if (absolutePath.StartsWith(Application.dataPath, StringComparison.OrdinalIgnoreCase))
             {
                 string relativePath =
@@ -595,7 +595,7 @@
 
                     string firstFramePath = AssetDatabase.GetAssetPath(validFrames[0]);
                     string assetPath =
-                        Path.GetDirectoryName(firstFramePath)?.Replace("\\", "/") ?? "Assets";
+                        Path.GetDirectoryName(firstFramePath).SanitizePath() ?? "Assets";
                     if (!assetPath.EndsWith("/"))
                     {
                         assetPath += "/";
@@ -775,8 +775,7 @@
                     }
 
                     string assetPath = AssetDatabase.GetAssetPath(sprite);
-                    string directoryPath =
-                        Path.GetDirectoryName(assetPath)?.Replace("\\", "/") ?? "";
+                    string directoryPath = Path.GetDirectoryName(assetPath).SanitizePath() ?? "";
                     string frameName = sprite.name;
 
                     int splitIndex = frameName.LastIndexOf('_');

package/Editor/FitTextureSizeWindow.cs

@@ -336,6 +336,14 @@
                         _ = updatedImporters.Remove(textureImporter);
                     }
                 }
+            }
+            finally
+            {
+                if (applyChanges)
+                {
+                    AssetDatabase.StopAssetEditing();
+                }
+                EditorUtility.ClearProgressBar();
 
                 if (applyChanges)
                 {
@@ -356,14 +364,6 @@
                     }
                 }
             }
-            finally
-            {
-                if (applyChanges)
-                {
-                    AssetDatabase.StopAssetEditing();
-                }
-                EditorUtility.ClearProgressBar();
-            }
             return changedCount;
         }
     }

package/Editor/SpriteCropper.cs

@@ -213,11 +213,6 @@
                             newImporters.Add(newImporter);
                         }
                     }
-
-                    foreach (TextureImporter newImporter in newImporters)
-                    {
-                        newImporter.SaveAndReimport();
-                    }
                 }
                 finally
                 {
@@ -276,8 +271,10 @@
                 return null;
             }
 
-            TextureImporter importer = AssetImporter.GetAtPath(assetPath) as TextureImporter;
-            if (importer is not { textureType: TextureImporterType.Sprite })
+            if (
+                AssetImporter.GetAtPath(assetPath)
+                is not TextureImporter { textureType: TextureImporterType.Sprite } importer
+            )
             {
                 return null;
             }
@@ -285,7 +282,6 @@
             TextureImporterSettings originalSettings = new();
             importer.ReadTextureSettings(originalSettings);
 
-            bool originalReadableState = importer.isReadable;
             if (!importer.isReadable)
             {
                 importer.isReadable = true;
@@ -298,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 localState;
+                },
+                finalLocalState =>
                 {
-                    return null;
-                }
-
-                int cropWidth = maxX - minX + 1;
-                int cropHeight = maxY - minY + 1;
-
-                if (_onlyNecessary && cropWidth == width && cropHeight == height)
-                {
-                    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/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/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;
             }

package/Runtime/Core/Helper/Helpers.cs

@@ -47,9 +47,9 @@
             }
 
             float a =
-                (targetVelocity.x * targetVelocity.x)
-                + (targetVelocity.y * targetVelocity.y)
-                - (projectileSpeed * projectileSpeed);
+                targetVelocity.x * targetVelocity.x
+                + targetVelocity.y * targetVelocity.y
+                - projectileSpeed * projectileSpeed;
 
             float b =
                 2
@@ -59,10 +59,10 @@
                 );
 
             float c =
-                ((target.x - launchLocation.x) * (target.x - launchLocation.x))
-                + ((target.y - launchLocation.y) * (target.y - launchLocation.y));
+                (target.x - launchLocation.x) * (target.x - launchLocation.x)
+                + (target.y - launchLocation.y) * (target.y - launchLocation.y);
 
-            float disc = b * b - (4 * a * c);
+            float disc = b * b - 4 * a * c;
             if (disc < 0)
             {
                 return target;
@@ -72,8 +72,8 @@
             float t2 = (-1 * b - Mathf.Sqrt(disc)) / (2 * a);
             float t = Mathf.Max(t1, t2); // let us take the larger time value
 
-            float aimX = target.x + (targetVelocity.x * t);
-            float aimY = target.y + (targetVelocity.y * t);
+            float aimX = target.x + targetVelocity.x * t;
+            float aimY = target.y + targetVelocity.y * t;
 
             if (float.IsNaN(aimX) || float.IsNaN(aimY))
             {
@@ -283,7 +283,7 @@
                 // optional delay execution from happening on 0, 1, 2, ... n-1 to 1, 2, ... n
                 if (
                     totalExecuted < totalCount
-                    && ((totalExecuted + (delay ? 1f : 0f)) / totalCount) <= percent
+                    && (totalExecuted + (delay ? 1f : 0f)) / totalCount <= percent
                 )
                 {
                     action();

package/Runtime/Core/Helper/Logging/UnityLogTagFormatter.cs

@@ -137,11 +137,9 @@
             const string sizeCheck = "size=";
             AddDecoration(
                 format =>
-                    (
-                        format.StartsWith(sizeCheck, StringComparison.OrdinalIgnoreCase)
-                            && int.TryParse(format.Substring(sizeCheck.Length), out _)
-                        || int.TryParse(format, out _)
-                    ),
+                    format.StartsWith(sizeCheck, StringComparison.OrdinalIgnoreCase)
+                        && int.TryParse(format.Substring(sizeCheck.Length), out _)
+                    || int.TryParse(format, out _),
                 format: (format, value) =>
                 {
                     if (!int.TryParse(format, out int size))
@@ -373,11 +371,26 @@
         )
         {
             bool stopLooping = false;
-            foreach (var entry in _matchingDecorations)
+            foreach (
+                KeyValuePair<
+                    int,
+                    List<(
+                        string tag,
+                        bool editorOnly,
+                        Func<string, bool> predicate,
+                        Func<string, object, string> formatter
+                    )>
+                > entry in _matchingDecorations
+            )
             {
                 for (int i = 0; i < entry.Value.Count; i++)
                 {
-                    var existingDecoration = entry.Value[i];
+                    (
+                        string tag,
+                        bool editorOnly,
+                        Func<string, bool> predicate,
+                        Func<string, object, string> formatter
+                    ) existingDecoration = entry.Value[i];
                     if (
                         !string.Equals(
                             existingDecoration.tag,
@@ -459,7 +472,17 @@
             ) decoration
         )
         {
-            foreach (var entry in _matchingDecorations)
+            foreach (
+                KeyValuePair<
+                    int,
+                    List<(
+                        string tag,
+                        bool editorOnly,
+                        Func<string, bool> predicate,
+                        Func<string, object, string> formatter
+                    )>
+                > entry in _matchingDecorations
+            )
             {
                 for (int i = 0; i < entry.Value.Count; ++i)
                 {

package/Runtime/Core/Helper/Partials/ObjectHelpers.cs

@@ -156,7 +156,7 @@
                 }
             }
 
-            Transform transform = (component as Transform) ?? component.transform;
+            Transform transform = component as Transform ?? component.transform;
             if (transform == null)
             {
                 return;
@@ -187,7 +187,7 @@
                 behavior.enabled = enabled;
             }
 
-            Transform transform = (component as Transform) ?? component.transform;
+            Transform transform = component as Transform ?? component.transform;
             if (transform == null)
             {
                 return;

package/Runtime/Core/Random/DotNetRandom.cs

@@ -11,7 +11,7 @@
         public static DotNetRandom Instance => ThreadLocalRandom<DotNetRandom>.Instance;
 
         public override RandomState InternalState =>
-            new RandomState(unchecked((ulong)_seed), state2: _numberGenerated);
+            new(unchecked((ulong)_seed), state2: _numberGenerated);
 
         private ulong _numberGenerated;
         private int _seed;

package/Runtime/Core/Random/SplitMix64.cs

@@ -45,7 +45,7 @@
                 ulong z = _state;
                 z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9UL;
                 z = (z ^ (z >> 27)) * 0x94D049BB133111EBUL;
-                z ^= (z >> 31);
+                z ^= z >> 31;
 
                 return (uint)z;
             }