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

package/Editor/SpriteAtlasGenerator.cs

@@ -7,17 +7,134 @@
     using System.Linq;
     using System.Text.RegularExpressions;
     using Core.Extension;
-    using Extensions;
+    using Core.Helper;
     using UnityEditor;
     using UnityEditor.U2D;
     using UnityEngine;
     using UnityEngine.U2D;
+    using Utils;
     using Object = UnityEngine.Object;
 
     public sealed class SpriteAtlasGenerator : EditorWindow
     {
         private const string Name = "Sprite Atlas Generator";
         private const string DefaultPlatformName = "DefaultTexturePlatform";
+        private const int MaxAtlasDimension = 8192;
+        private const int MaxTextureSize = 16384;
+        private const long AtlasAreaBudget = (long)MaxAtlasDimension * MaxAtlasDimension;
+        private const int MaxAtlasNameLength = 100;
+
+        private sealed class AtlasCandidate
+        {
+            public string OriginalGroupKey { get; }
+            public List<Sprite> Sprites { get; }
+            public long TotalArea { get; }
+            public string CandidateName { get; }
+
+            public AtlasCandidate(
+                string originalGroupKey,
+                List<Sprite> sprites,
+                string candidateName
+            )
+            {
+                OriginalGroupKey = originalGroupKey;
+                Sprites = new List<Sprite>(sprites);
+                CandidateName = candidateName;
+                TotalArea = 0;
+                if (Sprites != null)
+                {
+                    foreach (Sprite sprite in Sprites)
+                    {
+                        if (sprite is { rect: { width: > 0, height: > 0 } })
+                        {
+                            TotalArea += (long)(sprite.rect.width * sprite.rect.height);
+                        }
+                    }
+                }
+            }
+        }
+
+        private sealed class MergeableAtlas
+        {
+            public HashSet<string> OriginalGroupKeys { get; }
+            public List<Sprite> Sprites { get; }
+            public long TotalArea { get; }
+            public string RepresentativeInitialName { get; }
+
+            public MergeableAtlas(
+                string originalGroupKey,
+                List<Sprite> initialSprites,
+                string initialCandidateName,
+                long totalArea
+            )
+            {
+                OriginalGroupKeys = new HashSet<string>(StringComparer.Ordinal)
+                {
+                    originalGroupKey,
+                };
+                Sprites = initialSprites;
+                TotalArea = totalArea;
+                RepresentativeInitialName = initialCandidateName;
+            }
+
+            private MergeableAtlas(
+                HashSet<string> combinedKeys,
+                List<Sprite> combinedSprites,
+                long combinedArea,
+                string representativeName
+            )
+            {
+                OriginalGroupKeys = combinedKeys;
+                Sprites = combinedSprites;
+                TotalArea = combinedArea;
+                RepresentativeInitialName = representativeName;
+            }
+
+            public static MergeableAtlas Merge(MergeableAtlas atlas1, MergeableAtlas atlas2)
+            {
+                HashSet<string> newKeys = new(atlas1.OriginalGroupKeys, StringComparer.Ordinal);
+                newKeys.UnionWith(atlas2.OriginalGroupKeys);
+
+                List<Sprite> newSprites = new(atlas1.Sprites.Count + atlas2.Sprites.Count);
+                newSprites.AddRange(atlas1.Sprites);
+                newSprites.AddRange(atlas2.Sprites);
+
+                long newArea = atlas1.TotalArea + atlas2.TotalArea;
+
+                return new MergeableAtlas(
+                    newKeys,
+                    newSprites,
+                    newArea,
+                    atlas1.RepresentativeInitialName
+                );
+            }
+
+            public string GenerateFinalName()
+            {
+                if (!OriginalGroupKeys.Any())
+                {
+                    return "EmptyOrInvalidAtlas";
+                }
+
+                List<string> sortedKeys = OriginalGroupKeys
+                    .OrderBy(k => k, StringComparer.Ordinal)
+                    .ToList();
+                string name = string.Join("_", sortedKeys);
+
+                if (name.Length > MaxAtlasNameLength)
+                {
+                    const string suffix = "_etc";
+                    int actualLength = MaxAtlasNameLength - suffix.Length;
+                    if (actualLength <= 0)
+                    {
+                        return name.Substring(0, MaxAtlasNameLength);
+                    }
+
+                    name = name.Substring(0, actualLength) + suffix;
+                }
+                return name;
+            }
+        }
 
         [SerializeField]
         private Object[] _sourceFolders = Array.Empty<Object>();
@@ -35,8 +152,12 @@
         private TextureImporterCompression _compressionLevel =
             TextureImporterCompression.Compressed;
 
+        [SerializeField]
+        private bool _optimizeGroupings = true;
+
         private int _matchCount;
         private int _totalCount;
+        private GUIStyle _impactButtonStyle;
 
         [MenuItem("Tools/Wallstop Studios/Unity Helpers/" + Name)]
         public static void ShowWindow() => GetWindow<SpriteAtlasGenerator>("Atlas Generator");
@@ -57,38 +178,70 @@
 
         private void OnGUI()
         {
+            _impactButtonStyle ??= new GUIStyle(GUI.skin.button)
+            {
+                normal = { textColor = Color.yellow },
+                fontStyle = FontStyle.Bold,
+            };
             GUILayout.Label("Source Folders", EditorStyles.boldLabel);
             SerializedObject so = new(this);
             so.Update();
             EditorGUILayout.PropertyField(so.FindProperty(nameof(_sourceFolders)), true);
             so.ApplyModifiedProperties();
             GUILayout.Space(8);
-            EditorGUILayout.LabelField("Sprite Name Regex");
-            _nameRegex = EditorGUILayout.TextField(_nameRegex);
+            using (new GUIHorizontalScope())
+            {
+                EditorGUILayout.LabelField("Sprite Name Regex");
+                GUILayout.FlexibleSpace();
+                _nameRegex = EditorGUILayout.TextField(_nameRegex);
+            }
 
             GUILayout.Space(4);
+            using (new GUIHorizontalScope())
+            {
+                if (GUILayout.Button("Calculate Matches"))
+                {
+                    UpdateMatchCounts();
+                }
+            }
 
-            if (GUILayout.Button("Calculate Matches"))
+            using (new GUIHorizontalScope())
             {
-                UpdateMatchCounts();
+                EditorGUILayout.LabelField($"Matches: {_matchCount}");
+                GUILayout.FlexibleSpace();
+                EditorGUILayout.LabelField($"Non-matches: {_totalCount - _matchCount}");
             }
 
-            EditorGUILayout.LabelField(
-                $"Matches: {_matchCount}    Non-matches: {_totalCount - _matchCount}"
-            );
+            GUILayout.Space(4);
+            using (new GUIHorizontalScope())
+            {
+                EditorGUILayout.LabelField("Crunch Compression");
+                GUILayout.FlexibleSpace();
+                _crunchCompression = EditorGUILayout.IntField(_crunchCompression);
+            }
 
             GUILayout.Space(4);
-            EditorGUILayout.LabelField("Crunch Compression");
-            _crunchCompression = EditorGUILayout.IntField(_crunchCompression);
+            using (new GUIHorizontalScope())
+            {
+                EditorGUILayout.LabelField("Compression Level", GUILayout.Width(150));
+                _compressionLevel = (TextureImporterCompression)
+                    EditorGUILayout.EnumPopup(_compressionLevel);
+            }
 
             GUILayout.Space(4);
-            EditorGUILayout.LabelField("Compression Level");
-            _compressionLevel = (TextureImporterCompression)
-                EditorGUILayout.EnumPopup(_compressionLevel);
+            using (new GUIHorizontalScope())
+            {
+                EditorGUILayout.LabelField("Optimize Groupings");
+                _optimizeGroupings = EditorGUILayout.Toggle(_optimizeGroupings);
+            }
 
             GUILayout.Space(12);
-            EditorGUILayout.LabelField("Atlas Output Folder");
-            EditorGUILayout.LabelField(_outputFolder, EditorStyles.textField);
+            using (new GUIHorizontalScope())
+            {
+                EditorGUILayout.LabelField("Atlas Output Folder");
+                EditorGUILayout.LabelField(_outputFolder, EditorStyles.textField);
+            }
+
             if (GUILayout.Button("Select Output Folder"))
             {
                 string absPath = EditorUtility.OpenFolderPanel(
@@ -96,7 +249,7 @@
                     Application.dataPath,
                     ""
                 );
-                if (!string.IsNullOrEmpty(absPath))
+                if (!string.IsNullOrWhiteSpace(absPath))
                 {
                     if (absPath.StartsWith(Application.dataPath, StringComparison.Ordinal))
                     {
@@ -114,9 +267,12 @@
             }
 
             GUILayout.Space(12);
-            if (GUILayout.Button("Generate Atlases"))
+            using (new GUIHorizontalScope())
             {
-                GenerateAtlases();
+                if (GUILayout.Button("Generate Atlases", _impactButtonStyle))
+                {
+                    GenerateAtlases();
+                }
             }
         }
 
@@ -136,47 +292,54 @@
                 return;
             }
 
-            foreach (Object obj in _sourceFolders)
+            try
             {
-                if (obj == null)
-                {
-                    continue;
-                }
-
-                string folderPath = AssetDatabase.GetAssetPath(obj);
-                if (string.IsNullOrEmpty(folderPath) || !AssetDatabase.IsValidFolder(folderPath))
+                float total = _sourceFolders.Length;
+                foreach (Object obj in _sourceFolders.Where(Objects.NotNull))
                 {
-                    this.LogWarn($"Skipping invalid or null source folder entry.");
-                    continue;
-                }
-
-                string[] guids = AssetDatabase.FindAssets("t:Sprite", new[] { folderPath });
-                foreach (string guid in guids)
-                {
-                    string path = AssetDatabase.GUIDToAssetPath(guid);
-
-                    Object[] assets = AssetDatabase.LoadAllAssetsAtPath(path);
-                    if (assets == null)
+                    string folderPath = AssetDatabase.GetAssetPath(obj);
+                    if (
+                        string.IsNullOrWhiteSpace(folderPath)
+                        || !AssetDatabase.IsValidFolder(folderPath)
+                    )
                     {
+                        this.LogWarn($"Skipping invalid or null source folder entry.");
                         continue;
                     }
 
-                    IEnumerable<Sprite> sprites = assets.OfType<Sprite>();
-                    foreach (Sprite sp in sprites)
+                    string[] guids = AssetDatabase.FindAssets("t:Sprite", new[] { folderPath });
+                    for (int i = 0; i < guids.Length; ++i)
                     {
-                        if (sp == null)
+                        EditorUtility.DisplayProgressBar(
+                            Name,
+                            "Calculating...",
+                            i * 1f / guids.Length / total
+                        );
+
+                        string guid = guids[i];
+                        string path = AssetDatabase.GUIDToAssetPath(guid);
+
+                        Object[] assets = AssetDatabase.LoadAllAssetsAtPath(path);
+                        if (assets == null)
                         {
                             continue;
                         }
 
-                        _totalCount++;
-                        if (regex.IsMatch(sp.name))
+                        foreach (Sprite sp in assets.OfType<Sprite>().Where(Objects.NotNull))
                         {
-                            _matchCount++;
+                            _totalCount++;
+                            if (regex.IsMatch(sp.name))
+                            {
+                                _matchCount++;
+                            }
                         }
                     }
                 }
             }
+            finally
+            {
+                EditorUtility.ClearProgressBar();
+            }
 
             Repaint();
         }
@@ -185,6 +348,7 @@
         {
             List<SpriteAtlas> atlases = new();
             int processed = 0;
+            AssetDatabase.StartAssetEditing();
             try
             {
                 EditorUtility.DisplayProgressBar(Name, "Initializing...", 0f);
@@ -195,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();
@@ -212,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();
@@ -237,11 +400,11 @@
                     }
                 }
 
-                EditorUtility.DisplayProgressBar(Name, "Deleting old atlases...", 0.1f);
+                EditorUtility.DisplayProgressBar(Name, "Deleting old atlases...", 0.05f);
                 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)
@@ -257,11 +420,15 @@
                     AssetDatabase.Refresh();
                 }
 
-                EditorUtility.DisplayProgressBar(Name, "Scanning sprites...", 0.25f);
+                EditorUtility.DisplayProgressBar(
+                    Name,
+                    "Scanning sprites & initial grouping...",
+                    0.1f
+                );
                 Regex regex;
                 try
                 {
-                    regex = new(_nameRegex);
+                    regex = new Regex(_nameRegex);
                 }
                 catch (ArgumentException ex)
                 {
@@ -273,16 +440,12 @@
                 }
                 Dictionary<string, List<Sprite>> groups = new(StringComparer.Ordinal);
 
-                float sourceFolderProgressIncrement = 0.15f / _sourceFolders.Length;
-                float currentProgress = 0.25f;
+                float sourceFolderIncrement =
+                    _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))
                     {
@@ -295,9 +458,9 @@
                     EditorUtility.DisplayProgressBar(
                         Name,
                         $"Scanning folder '{folderPath}'...",
-                        currentProgress
+                        sourceFolderProgress
                     );
-
+                    sourceFolderProgress += sourceFolderIncrement;
                     foreach (
                         string assetGuid in AssetDatabase.FindAssets(
                             "t:Sprite",
@@ -306,7 +469,7 @@
                     )
                     {
                         string assetPath = AssetDatabase.GUIDToAssetPath(assetGuid);
-                        if (string.IsNullOrEmpty(assetPath))
+                        if (string.IsNullOrWhiteSpace(assetPath))
                         {
                             continue;
                         }
@@ -317,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))
                             {
@@ -335,43 +493,37 @@
                             groups.GetOrAdd(key).Add(sub);
                         }
                     }
-                    currentProgress += sourceFolderProgressIncrement;
                 }
 
-                const int atlasSize = 8192;
-                const long budget = (long)atlasSize * atlasSize;
                 int totalChunks = 0;
                 Dictionary<string, List<List<Sprite>>> groupChunks = new();
-
-                EditorUtility.DisplayProgressBar(Name, "Calculating chunks...", 0.4f);
-
+                EditorUtility.DisplayProgressBar(Name, "Calculating chunks...", 0.3f);
                 foreach (KeyValuePair<string, List<Sprite>> kv in groups)
                 {
-                    List<Sprite> sprites = kv
-                        .Value.OrderByDescending(s => s.rect.width * s.rect.height)
+                    List<Sprite> spritesInGroup = kv
+                        .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())
+                    {
+                        continue;
+                    }
+
                     List<List<Sprite>> chunks = new();
                     List<Sprite> current = new();
                     long currentArea = 0;
-                    foreach (Sprite sprite in sprites)
+                    foreach (Sprite sprite in spritesInGroup)
                     {
-                        if (sprite == null || sprite.rect.width <= 0 || sprite.rect.height <= 0)
-                        {
-                            this.LogWarn(
-                                $"Skipping invalid sprite '{sprite?.name ?? "null"}' in group '{kv.Key}'."
-                            );
-                            continue;
-                        }
-
                         long area = (long)(sprite.rect.width * sprite.rect.height);
-                        if (area > budget)
+                        if (area > AtlasAreaBudget)
                         {
                             this.LogWarn(
                                 $"Sprite '{sprite.name}' ({sprite.rect.width}x{sprite.rect.height}) is larger than max atlas area budget and will be placed in its own atlas chunk."
                             );
                             continue;
                         }
-                        if (currentArea + area <= budget && current.Count < 2000)
+                        if (currentArea + area <= AtlasAreaBudget && current.Count < 2000)
                         {
                             current.Add(sprite);
                             currentArea += area;
@@ -408,166 +560,307 @@
                     return;
                 }
 
-                int chunkIndex = 0;
-                float atlasCreationProgressStart = 0.45f;
-                float atlasCreationProgressRange = 0.5f;
-
-                foreach ((string prefix, List<List<Sprite>> chunks) in groupChunks)
+                List<(string Name, List<Sprite> Sprites)> finalAtlasesData;
+                if (_optimizeGroupings)
                 {
-                    for (int i = 0; i < chunks.Count; i++)
+                    EditorUtility.DisplayProgressBar(
+                        Name,
+                        "Preparing for merge optimization...",
+                        0.4f
+                    );
+
+                    List<AtlasCandidate> allInitialCandidates = new();
+                    foreach (
+                        (
+                            string originalGroupKey,
+                            List<List<Sprite>> chunksForThisGroup
+                        ) in groupChunks
+                    )
                     {
-                        List<Sprite> chunk = chunks[i];
-                        if (chunk == null || chunk.Count == 0)
+                        for (int i = 0; i < chunksForThisGroup.Count; ++i)
                         {
-                            continue;
+                            if (!chunksForThisGroup[i].Any())
+                            {
+                                continue;
+                            }
+
+                            string candidateName =
+                                chunksForThisGroup.Count > 1
+                                    ? $"{originalGroupKey}_{i}"
+                                    : originalGroupKey;
+                            allInitialCandidates.Add(
+                                new AtlasCandidate(
+                                    originalGroupKey,
+                                    chunksForThisGroup[i],
+                                    candidateName
+                                )
+                            );
                         }
+                    }
+
+                    allInitialCandidates = allInitialCandidates
+                        .OrderByDescending(candidate => candidate.TotalArea)
+                        .ThenBy(candidate => candidate.CandidateName, StringComparer.Ordinal)
+                        .ToList();
 
-                        float progress =
-                            atlasCreationProgressStart
-                            + atlasCreationProgressRange * (chunkIndex / (float)totalChunks);
+                    List<MergeableAtlas> workingAtlases = allInitialCandidates
+                        .Select(candidate => new MergeableAtlas(
+                            candidate.OriginalGroupKey,
+                            candidate.Sprites,
+                            candidate.CandidateName,
+                            candidate.TotalArea
+                        ))
+                        .ToList();
+                    int passNumber = 0;
+                    const float mergeOptimizationProgressStart = 0.3f;
+                    const float mergeOptimizationProgressRange = 0.5f;
 
-                        string atlasName = chunks.Count > 1 ? $"{prefix}_{i}" : prefix;
+                    while (true)
+                    {
+                        passNumber++;
+                        bool mergedInThisPass = false;
+                        float currentPassProgress =
+                            mergeOptimizationProgressStart
+                            + passNumber * (mergeOptimizationProgressRange / 15f);
                         EditorUtility.DisplayProgressBar(
                             Name,
-                            $"Creating atlas '{atlasName}' ({i + 1}/{chunks.Count})... Sprites: {chunk.Count}",
-                            progress
+                            $"Optimizing atlas count (Pass {passNumber}, {workingAtlases.Count} atlases)...",
+                            Mathf.Min(
+                                currentPassProgress,
+                                mergeOptimizationProgressStart + mergeOptimizationProgressRange
+                            )
                         );
 
-                        SpriteAtlas atlas = new();
-                        atlases.Add(atlas);
+                        workingAtlases = workingAtlases
+                            .OrderByDescending(atlas => atlas.TotalArea)
+                            .ThenBy(
+                                atlas => atlas.RepresentativeInitialName,
+                                StringComparer.Ordinal
+                            )
+                            .ToList();
 
-                        SpriteAtlasPackingSettings packingSettings = atlas.GetPackingSettings();
-                        packingSettings.enableTightPacking = true;
-                        packingSettings.padding = 4;
-                        packingSettings.enableRotation = false;
-                        atlas.SetPackingSettings(packingSettings);
+                        bool[] isSubsumed = new bool[workingAtlases.Count];
 
-                        SpriteAtlasTextureSettings textureSettings = atlas.GetTextureSettings();
-                        textureSettings.generateMipMaps = false;
-                        textureSettings.filterMode = FilterMode.Bilinear;
-                        textureSettings.readable = false;
-                        atlas.SetTextureSettings(textureSettings);
+                        for (int i = 0; i < workingAtlases.Count; ++i)
+                        {
+                            if (isSubsumed[i])
+                            {
+                                continue;
+                            }
+
+                            MergeableAtlas baseAtlas = workingAtlases[i];
+                            string baseRepresentativeKey = baseAtlas
+                                .OriginalGroupKeys.OrderBy(key => key, StringComparer.Ordinal)
+                                .First();
 
-                        TextureImporterPlatformSettings platformSettings =
-                            atlas.GetPlatformSettings(DefaultPlatformName);
+                            int bestPartnerIndex = -1;
+                            MergeableAtlas bestPartnerObject = null;
+                            int currentMinLevenshtein = int.MaxValue;
 
-                        if (platformSettings == null)
+                            for (int j = i + 1; j < workingAtlases.Count; ++j)
+                            {
+                                if (isSubsumed[j])
+                                {
+                                    continue;
+                                }
+
+                                MergeableAtlas potentialPartner = workingAtlases[j];
+                                if (
+                                    baseAtlas.TotalArea + potentialPartner.TotalArea
+                                    > AtlasAreaBudget
+                                )
+                                {
+                                    continue;
+                                }
+
+                                string partnerRepresentativeKey = potentialPartner
+                                    .OriginalGroupKeys.OrderBy(key => key, StringComparer.Ordinal)
+                                    .First();
+                                int distance = baseRepresentativeKey.LevenshteinDistance(
+                                    partnerRepresentativeKey
+                                );
+                                bool updateBest = false;
+                                if (bestPartnerObject == null || distance < currentMinLevenshtein)
+                                {
+                                    updateBest = true;
+                                }
+                                else if (distance == currentMinLevenshtein)
+                                {
+                                    if (
+                                        potentialPartner.TotalArea > bestPartnerObject.TotalArea
+                                        || (
+                                            potentialPartner.TotalArea
+                                                == bestPartnerObject.TotalArea
+                                            && string.Compare(
+                                                potentialPartner.RepresentativeInitialName,
+                                                bestPartnerObject.RepresentativeInitialName,
+                                                StringComparison.Ordinal
+                                            ) < 0
+                                        )
+                                    )
+                                    {
+                                        updateBest = true;
+                                    }
+                                }
+                                if (updateBest)
+                                {
+                                    currentMinLevenshtein = distance;
+                                    bestPartnerObject = potentialPartner;
+                                    bestPartnerIndex = j;
+                                }
+                            }
+                            if (bestPartnerObject != null)
+                            {
+                                workingAtlases[i] = MergeableAtlas.Merge(
+                                    baseAtlas,
+                                    bestPartnerObject
+                                );
+                                isSubsumed[bestPartnerIndex] = true;
+                                mergedInThisPass = true;
+                            }
+                        }
+                        if (!mergedInThisPass)
+                        {
+                            break;
+                        }
+
+                        workingAtlases = workingAtlases.Where((_, k) => !isSubsumed[k]).ToList();
+                        if (passNumber > 100)
                         {
-                            platformSettings = new TextureImporterPlatformSettings();
-                            platformSettings.name = DefaultPlatformName;
                             this.LogWarn(
-                                $"Could not get default platform settings for {atlasName}. Creating new default."
+                                $"Merge optimization exceeded 100 passes, aborting merge loop."
                             );
+                            break;
                         }
+                    }
 
-                        platformSettings.overridden = true;
-                        platformSettings.maxTextureSize = atlasSize;
-                        platformSettings.textureCompression = _compressionLevel;
-                        platformSettings.format = TextureImporterFormat.Automatic;
-
-                        if (_crunchCompression is >= 0 and <= 100)
+                    finalAtlasesData = workingAtlases
+                        .Select(atlas => (Name: atlas.GenerateFinalName(), atlas.Sprites))
+                        .OrderBy(atlas => atlas.Name, StringComparer.Ordinal)
+                        .ToList();
+                }
+                else
+                {
+                    finalAtlasesData = groupChunks
+                        .SelectMany(chunk =>
                         {
-                            platformSettings.crunchedCompression = true;
-                            platformSettings.compressionQuality = _crunchCompression;
-                        }
-                        else
+                            string prefix = chunk.Key;
+                            List<List<Sprite>> chunks = chunk.Value;
+                            List<(string, List<Sprite>)> finalChunks = new();
+                            for (int i = 0; i < chunks.Count; ++i)
+                            {
+                                string atlasName = chunks.Count > 1 ? $"{prefix}_{i}" : prefix;
+                                finalChunks.Add((atlasName, chunks[i]));
+                            }
+                            return finalChunks;
+                        })
+                        .ToList();
+                    int chunkIndex = 0;
+                    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)
                         {
-                            if (100 < _crunchCompression)
+                            List<Sprite> chunk = chunks[i];
+                            if (chunk is not { Count: > 0 })
                             {
-                                this.LogWarn(
-                                    $"Invalid crunch compression: {_crunchCompression}. Using default (off)."
-                                );
+                                continue;
                             }
-                            platformSettings.crunchedCompression = false;
-                            platformSettings.compressionQuality = 50;
-                        }
 
-                        atlas.SetPlatformSettings(platformSettings);
+                            float progress =
+                                atlasCreationProgressStart
+                                + atlasCreationProgressRange * (chunkIndex / (float)totalChunks);
 
-                        Object[] validSprites = chunk
-                            .Where(s => s != null)
-                            .Select(sprite => sprite as Object)
-                            .ToArray();
-                        if (validSprites.Length == 0)
-                        {
-                            this.LogWarn(
-                                $"Skipping atlas '{atlasName}' as it contained no valid sprites after filtering."
+                            string atlasName = chunks.Count > 1 ? $"{prefix}_{i}" : prefix;
+                            EditorUtility.DisplayProgressBar(
+                                Name,
+                                $"Creating atlas '{atlasName}' ({i + 1}/{chunks.Count})... Sprites: {chunk.Count}",
+                                progress
                             );
-                            atlases.Remove(atlas);
-                        }
-                        else
-                        {
-                            atlas.Add(validSprites);
-                            atlas.SetIncludeInBuild(true);
-                            string path = Path.Combine(_outputFolder, atlasName + ".spriteatlas");
-                            path = AssetDatabase.GenerateUniqueAssetPath(path);
-                            AssetDatabase.CreateAsset(atlas, path);
-                            processed++;
+
+                            chunkIndex++;
                         }
-                        chunkIndex++;
                     }
                 }
 
-                if (processed > 0)
+                foreach ((string atlasName, List<Sprite> sprites) in finalAtlasesData)
                 {
-                    EditorUtility.DisplayProgressBar(Name, "Saving assets...", 0.95f);
-                    AssetDatabase.SaveAssets();
-                    AssetDatabase.Refresh();
-
-                    EditorUtility.DisplayProgressBar(Name, "Packing atlases...", 0.97f);
-                    SpriteAtlasUtility.PackAllAtlases(
-                        EditorUserBuildSettings.activeBuildTarget,
-                        false
+                    SpriteAtlas atlas = new();
+                    atlases.Add(atlas);
+
+                    SpriteAtlasPackingSettings packingSettings = atlas.GetPackingSettings();
+                    packingSettings.enableTightPacking = true;
+                    packingSettings.padding = 4;
+                    packingSettings.enableRotation = false;
+                    atlas.SetPackingSettings(packingSettings);
+
+                    SpriteAtlasTextureSettings textureSettings = atlas.GetTextureSettings();
+                    textureSettings.generateMipMaps = false;
+                    textureSettings.filterMode = FilterMode.Bilinear;
+                    textureSettings.readable = true;
+                    atlas.SetTextureSettings(textureSettings);
+
+                    TextureImporterPlatformSettings platformSettings = atlas.GetPlatformSettings(
+                        DefaultPlatformName
                     );
 
-                    bool anyChanged = false;
-                    EditorUtility.DisplayProgressBar(Name, "Optimizing atlas sizes...", 0.98f);
-                    foreach (
-                        SpriteAtlas atlas in atlases
-                            .Select(AssetDatabase.GetAssetPath)
-                            .Where(p => !string.IsNullOrEmpty(p))
-                            .Select(AssetDatabase.LoadAssetAtPath<SpriteAtlas>)
-                            .Where(a => a != null)
-                    )
+                    if (platformSettings == null)
                     {
-                        Texture2D preview = atlas.GetPreviewTexture();
-                        if (preview == null)
+                        platformSettings = new TextureImporterPlatformSettings
                         {
-                            continue;
-                        }
-
-                        TextureImporterPlatformSettings platformSettings =
-                            atlas.GetPlatformSettings(DefaultPlatformName);
-                        if (platformSettings is not { overridden: true })
-                        {
-                            continue;
-                        }
-
-                        int actualWidth = preview.width;
-                        int actualHeight = preview.height;
-                        int newMaxSize = Mathf.Max(
-                            Mathf.NextPowerOfTwo(actualWidth),
-                            Mathf.NextPowerOfTwo(actualHeight)
+                            name = DefaultPlatformName,
+                        };
+                        this.LogWarn(
+                            $"Could not get default platform settings for {atlasName}. Creating new default."
                         );
-                        newMaxSize = Mathf.Clamp(newMaxSize, 32, atlasSize);
+                    }
 
-                        if (newMaxSize < platformSettings.maxTextureSize)
+                    platformSettings.overridden = true;
+                    platformSettings.maxTextureSize = MaxAtlasDimension;
+                    platformSettings.textureCompression = _compressionLevel;
+                    platformSettings.format = TextureImporterFormat.Automatic;
+
+                    if (_crunchCompression is >= 0 and <= 100)
+                    {
+                        platformSettings.crunchedCompression = true;
+                        platformSettings.compressionQuality = _crunchCompression;
+                    }
+                    else
+                    {
+                        if (100 < _crunchCompression)
                         {
-                            this.Log(
-                                $"Optimizing atlas '{atlas.name}' max size from {platformSettings.maxTextureSize} to {newMaxSize}"
+                            this.LogWarn(
+                                $"Invalid crunch compression: {_crunchCompression}. Using default (off)."
                             );
-                            platformSettings.maxTextureSize = newMaxSize;
-                            atlas.SetPlatformSettings(platformSettings);
-                            EditorUtility.SetDirty(atlas);
-                            anyChanged = true;
                         }
+
+                        platformSettings.crunchedCompression = false;
+                        platformSettings.compressionQuality = 50;
                     }
 
-                    if (anyChanged)
+                    atlas.SetPlatformSettings(platformSettings);
+
+                    Object[] validSprites = sprites
+                        .Select(sprite => sprite as Object)
+                        .Where(Objects.NotNull)
+                        .ToArray();
+                    if (validSprites.Length == 0)
                     {
-                        EditorUtility.DisplayProgressBar(Name, "Saving optimizations...", 0.99f);
-                        AssetDatabase.SaveAssets();
-                        AssetDatabase.Refresh();
+                        this.LogWarn(
+                            $"Skipping atlas '{atlasName}' as it contained no valid sprites after filtering."
+                        );
+                        atlases.Remove(atlas);
+                    }
+                    else
+                    {
+                        atlas.Add(validSprites);
+                        atlas.SetIncludeInBuild(true);
+                        string path = Path.Combine(_outputFolder, atlasName + ".spriteatlas");
+                        path = AssetDatabase.GenerateUniqueAssetPath(path);
+                        AssetDatabase.CreateAsset(atlas, path);
+                        processed++;
                     }
                 }
             }
@@ -577,11 +870,15 @@
             }
             finally
             {
+                AssetDatabase.StopAssetEditing();
                 EditorUtility.ClearProgressBar();
             }
 
             if (processed > 0)
             {
+                AssetDatabase.SaveAssets();
+                AssetDatabase.Refresh();
+                SpriteAtlasUtility.PackAllAtlases(EditorUserBuildSettings.activeBuildTarget, false);
                 this.Log(
                     $"[SpriteAtlasGenerator] Successfully created or updated {processed} atlases in '{_outputFolder}'."
                 );