com.wallstop-studios.unity-helpers 2.0.0-rc73.1 → 2.0.0-rc73.11

package/Editor/SpriteAtlasGenerator.cs

@@ -45,7 +45,7 @@
                 {
                     foreach (Sprite sprite in Sprites)
                     {
-                        if (sprite != null && sprite.rect is { width: > 0, height: > 0 })
+                        if (sprite is { rect: { width: > 0, height: > 0 } })
                         {
                             TotalArea += (long)(sprite.rect.width * sprite.rect.height);
                         }
@@ -249,7 +249,7 @@
                     Application.dataPath,
                     ""
                 );
-                if (!string.IsNullOrEmpty(absPath))
+                if (!string.IsNullOrWhiteSpace(absPath))
                 {
                     if (absPath.StartsWith(Application.dataPath, StringComparison.Ordinal))
                     {
@@ -295,16 +295,12 @@
             try
             {
                 float total = _sourceFolders.Length;
-                foreach (Object obj in _sourceFolders)
+                foreach (Object obj in _sourceFolders.Where(Objects.NotNull))
                 {
-                    if (obj == null)
-                    {
-                        continue;
-                    }
-
                     string folderPath = AssetDatabase.GetAssetPath(obj);
                     if (
-                        string.IsNullOrEmpty(folderPath) || !AssetDatabase.IsValidFolder(folderPath)
+                        string.IsNullOrWhiteSpace(folderPath)
+                        || !AssetDatabase.IsValidFolder(folderPath)
                     )
                     {
                         this.LogWarn($"Skipping invalid or null source folder entry.");
@@ -312,7 +308,7 @@
                     }
 
                     string[] guids = AssetDatabase.FindAssets("t:Sprite", new[] { folderPath });
-                    for (int i = 0; i < guids.Length; i++)
+                    for (int i = 0; i < guids.Length; ++i)
                     {
                         EditorUtility.DisplayProgressBar(
                             Name,
@@ -329,14 +325,8 @@
                             continue;
                         }
 
-                        IEnumerable<Sprite> sprites = assets.OfType<Sprite>();
-                        foreach (Sprite sp in sprites)
+                        foreach (Sprite sp in assets.OfType<Sprite>().Where(Objects.NotNull))
                         {
-                            if (sp == null)
-                            {
-                                continue;
-                            }
-
                             _totalCount++;
                             if (regex.IsMatch(sp.name))
                             {
@@ -369,11 +359,7 @@
                     return;
                 }
 
-                if (
-                    _sourceFolders == null
-                    || _sourceFolders.Length == 0
-                    || _sourceFolders.All(f => f == null)
-                )
+                if (_sourceFolders == null || Array.TrueForAll(_sourceFolders, Objects.Null))
                 {
                     this.LogError($"No valid source folders specified.");
                     EditorUtility.ClearProgressBar();
@@ -386,7 +372,10 @@
                     {
                         string parent = Path.GetDirectoryName(_outputFolder);
                         string newFolderName = Path.GetFileName(_outputFolder);
-                        if (string.IsNullOrEmpty(parent) || string.IsNullOrEmpty(newFolderName))
+                        if (
+                            string.IsNullOrWhiteSpace(parent)
+                            || string.IsNullOrWhiteSpace(newFolderName)
+                        )
                         {
                             this.LogError($"Output folder path '{_outputFolder}' is invalid.");
                             EditorUtility.ClearProgressBar();
@@ -415,7 +404,7 @@
                 string[] existing = AssetDatabase
                     .FindAssets("t:SpriteAtlas", new[] { _outputFolder })
                     .Select(AssetDatabase.GUIDToAssetPath)
-                    .Where(p => !string.IsNullOrEmpty(p))
+                    .Where(path => !string.IsNullOrWhiteSpace(path))
                     .ToArray();
 
                 if (existing.Length > 0)
@@ -439,7 +428,7 @@
                 Regex regex;
                 try
                 {
-                    regex = new(_nameRegex);
+                    regex = new Regex(_nameRegex);
                 }
                 catch (ArgumentException ex)
                 {
@@ -455,13 +444,8 @@
                     _sourceFolders.Length > 0 ? 0.2f / _sourceFolders.Length : 0f;
                 float sourceFolderProgress = 0.1f;
 
-                foreach (Object sourceDirectory in _sourceFolders)
+                foreach (Object sourceDirectory in _sourceFolders.Where(Objects.NotNull))
                 {
-                    if (sourceDirectory == null)
-                    {
-                        continue;
-                    }
-
                     string folderPath = AssetDatabase.GetAssetPath(sourceDirectory);
                     if (!AssetDatabase.IsValidFolder(folderPath))
                     {
@@ -485,7 +469,7 @@
                     )
                     {
                         string assetPath = AssetDatabase.GUIDToAssetPath(assetGuid);
-                        if (string.IsNullOrEmpty(assetPath))
+                        if (string.IsNullOrWhiteSpace(assetPath))
                         {
                             continue;
                         }
@@ -496,13 +480,8 @@
                             continue;
                         }
 
-                        foreach (Sprite sub in allAssets.OfType<Sprite>())
+                        foreach (Sprite sub in allAssets.OfType<Sprite>().Where(Objects.NotNull))
                         {
-                            if (sub == null)
-                            {
-                                continue;
-                            }
-
                             string assetName = sub.name;
                             if (!regex.IsMatch(assetName))
                             {
@@ -518,14 +497,13 @@
 
                 int totalChunks = 0;
                 Dictionary<string, List<List<Sprite>>> groupChunks = new();
-
                 EditorUtility.DisplayProgressBar(Name, "Calculating chunks...", 0.3f);
-
                 foreach (KeyValuePair<string, List<Sprite>> kv in groups)
                 {
                     List<Sprite> spritesInGroup = kv
-                        .Value.Where(s => s != null && s.rect is { width: > 0, height: > 0 })
-                        .OrderByDescending(s => s.rect.width * s.rect.height)
+                        .Value.Where(Objects.NotNull)
+                        .Where(sprite => sprite.rect is { width: > 0, height: > 0 })
+                        .OrderByDescending(sprite => sprite.rect.width * sprite.rect.height)
                         .ToList();
                     if (!spritesInGroup.Any())
                     {
@@ -599,7 +577,7 @@
                         ) in groupChunks
                     )
                     {
-                        for (int i = 0; i < chunksForThisGroup.Count; i++)
+                        for (int i = 0; i < chunksForThisGroup.Count; ++i)
                         {
                             if (!chunksForThisGroup[i].Any())
                             {
@@ -621,21 +599,21 @@
                     }
 
                     allInitialCandidates = allInitialCandidates
-                        .OrderByDescending(c => c.TotalArea)
-                        .ThenBy(c => c.CandidateName, StringComparer.Ordinal)
+                        .OrderByDescending(candidate => candidate.TotalArea)
+                        .ThenBy(candidate => candidate.CandidateName, StringComparer.Ordinal)
                         .ToList();
 
                     List<MergeableAtlas> workingAtlases = allInitialCandidates
-                        .Select(c => new MergeableAtlas(
-                            c.OriginalGroupKey,
-                            c.Sprites,
-                            c.CandidateName,
-                            c.TotalArea
+                        .Select(candidate => new MergeableAtlas(
+                            candidate.OriginalGroupKey,
+                            candidate.Sprites,
+                            candidate.CandidateName,
+                            candidate.TotalArea
                         ))
                         .ToList();
                     int passNumber = 0;
-                    float mergeOptimizationProgressStart = 0.30f;
-                    float mergeOptimizationProgressRange = 0.50f;
+                    const float mergeOptimizationProgressStart = 0.3f;
+                    const float mergeOptimizationProgressRange = 0.5f;
 
                     while (true)
                     {
@@ -643,7 +621,7 @@
                         bool mergedInThisPass = false;
                         float currentPassProgress =
                             mergeOptimizationProgressStart
-                            + passNumber * (mergeOptimizationProgressRange / 15.0f);
+                            + passNumber * (mergeOptimizationProgressRange / 15f);
                         EditorUtility.DisplayProgressBar(
                             Name,
                             $"Optimizing atlas count (Pass {passNumber}, {workingAtlases.Count} atlases)...",
@@ -654,13 +632,16 @@
                         );
 
                         workingAtlases = workingAtlases
-                            .OrderByDescending(a => a.TotalArea)
-                            .ThenBy(a => a.RepresentativeInitialName, StringComparer.Ordinal)
+                            .OrderByDescending(atlas => atlas.TotalArea)
+                            .ThenBy(
+                                atlas => atlas.RepresentativeInitialName,
+                                StringComparer.Ordinal
+                            )
                             .ToList();
 
                         bool[] isSubsumed = new bool[workingAtlases.Count];
 
-                        for (int i = 0; i < workingAtlases.Count; i++)
+                        for (int i = 0; i < workingAtlases.Count; ++i)
                         {
                             if (isSubsumed[i])
                             {
@@ -669,14 +650,14 @@
 
                             MergeableAtlas baseAtlas = workingAtlases[i];
                             string baseRepresentativeKey = baseAtlas
-                                .OriginalGroupKeys.OrderBy(k => k, StringComparer.Ordinal)
+                                .OriginalGroupKeys.OrderBy(key => key, StringComparer.Ordinal)
                                 .First();
 
                             int bestPartnerIndex = -1;
                             MergeableAtlas bestPartnerObject = null;
                             int currentMinLevenshtein = int.MaxValue;
 
-                            for (int j = i + 1; j < workingAtlases.Count; j++)
+                            for (int j = i + 1; j < workingAtlases.Count; ++j)
                             {
                                 if (isSubsumed[j])
                                 {
@@ -693,7 +674,7 @@
                                 }
 
                                 string partnerRepresentativeKey = potentialPartner
-                                    .OriginalGroupKeys.OrderBy(k => k, StringComparer.Ordinal)
+                                    .OriginalGroupKeys.OrderBy(key => key, StringComparer.Ordinal)
                                     .First();
                                 int distance = baseRepresentativeKey.LevenshteinDistance(
                                     partnerRepresentativeKey
@@ -754,8 +735,8 @@
                     }
 
                     finalAtlasesData = workingAtlases
-                        .Select(a => (Name: a.GenerateFinalName(), Sprites: a.Sprites))
-                        .OrderBy(a => a.Name)
+                        .Select(atlas => (Name: atlas.GenerateFinalName(), atlas.Sprites))
+                        .OrderBy(atlas => atlas.Name, StringComparer.Ordinal)
                         .ToList();
                 }
                 else
@@ -766,7 +747,7 @@
                             string prefix = chunk.Key;
                             List<List<Sprite>> chunks = chunk.Value;
                             List<(string, List<Sprite>)> finalChunks = new();
-                            for (int i = 0; i < chunks.Count; i++)
+                            for (int i = 0; i < chunks.Count; ++i)
                             {
                                 string atlasName = chunks.Count > 1 ? $"{prefix}_{i}" : prefix;
                                 finalChunks.Add((atlasName, chunks[i]));
@@ -775,15 +756,15 @@
                         })
                         .ToList();
                     int chunkIndex = 0;
-                    float atlasCreationProgressStart = 0.45f;
-                    float atlasCreationProgressRange = 0.5f;
+                    const float atlasCreationProgressStart = 0.45f;
+                    const float atlasCreationProgressRange = 0.5f;
 
                     foreach ((string prefix, List<List<Sprite>> chunks) in groupChunks)
                     {
-                        for (int i = 0; i < chunks.Count; i++)
+                        for (int i = 0; i < chunks.Count; ++i)
                         {
                             List<Sprite> chunk = chunks[i];
-                            if (chunk == null || chunk.Count == 0)
+                            if (chunk is not { Count: > 0 })
                             {
                                 continue;
                             }

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;
         }