nccgs 2.1.1 → 3.0.0-rc.2

package/unity-skills/manage-sprite-atlas/references/custom-packing.md

@@ -0,0 +1,147 @@
+# Custom Sprite Packing with ScriptablePacker
+
+Guide for implementing custom sprite packing algorithms in SpriteAtlas V2.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Use Cases](#use-cases)
+- [ScriptablePacker API](#scriptablepacker-api)
+  - [Abstract Methods](#abstract-methods)
+  - [PackerData Structure](#packerdata-structure)
+  - [SpriteData Structure](#spritedata-structure)
+  - [SpritePack Output Structure](#spritepack-output-structure)
+  - [TextureData Structure](#texturedata-structure)
+  - [PackTransform Options](#packtransform-options)
+- [Example: Grid-Based Packer](#example-grid-based-packer)
+- [Example: Multi-Page Packer](#example-multi-page-packer)
+- [Example: Size-Optimized Packer](#example-size-optimized-packer)
+- [Assigning Custom Packer to Atlas](#assigning-custom-packer-to-atlas)
+- [Best Practices](#best-practices)
+  - [Performance](#performance)
+  - [Correctness](#correctness)
+  - [Maintainability](#maintainability)
+- [Common Pitfalls](#common-pitfalls)
+- [Debugging Tips](#debugging-tips)
+
+## Overview
+
+`ScriptablePacker` is an abstract base class for creating custom packing algorithms. Extend it to implement specialized packing strategies beyond Unity's default algorithms.
+
+**Namespace:** `UnityEditor.U2D`
+**Location:** `SpriteAtlasAsset.bindings.cs`
+
+## Use Cases
+
+Custom packers are useful for:
+- Non-standard sprite arrangements (circular, grid-based, specific patterns)
+- Multi-page atlas generation with custom page selection
+- Sprite preprocessing and optimization before packing
+- Platform-specific packing strategies
+- Domain-specific packing requirements (UI layouts, sprite sheets)
+
+## ScriptablePacker API
+
+### Abstract Methods
+
+See [resources/scriptablepacker.cs](../resources/scriptablepacker.cs).
+
+### PackerData Structure
+
+Contains all input data for packing:
+
+```csharp
+struct PackerData
+{
+    NativeArray<Color32> colorData;   // Pixel data from source textures
+    NativeArray<SpriteData> spriteData; // Sprite information
+    NativeArray<TextureData> textureData; // Texture dimensions
+    NativeArray<int> indexData;       // Sprite mesh indices
+    NativeArray<Vector2> vertexData;  // Sprite mesh vertices
+}
+```
+
+**Important:** Do NOT dispose these arrays - they're managed externally by Unity.
+
+### SpriteData Structure
+
+Information about each sprite:
+
+See [resources/spritedata.cs](../resources/spritedata.cs).
+
+### SpritePack Output Structure
+
+Set this on each `SpriteData` to specify packing result:
+
+See [resources/spritepack.cs](../resources/spritepack.cs).
+
+### TextureData Structure
+
+Source texture information:
+
+See [resources/texturedata.cs](../resources/texturedata.cs).
+
+### PackTransform Options
+
+Sprite transformations during packing:
+
+See [resources/packtransform.cs](../resources/packtransform.cs).
+
+## Example: Grid-Based Packer
+
+Simple example that arranges sprites in a grid pattern.
+
+See [resources/gridspritepacker.cs](../resources/gridspritepacker.cs).
+
+## Example: Multi-Page Packer
+
+Distributes sprites across multiple atlas pages.
+
+See [resources/multipagepacker.cs](../resources/multipagepacker.cs).
+
+## Example: Size-Optimized Packer
+
+Packs larger sprites first for better space utilization.
+
+See [resources/sizeoptimizedpacker.cs](../resources/sizeoptimizedpacker.cs).
+
+## Assigning Custom Packer to Atlas
+
+Use `SpriteAtlasAsset.SetScriptablePacker()` to assign your custom packer.
+
+See [resources/custompackersetup.cs](../resources/custompackersetup.cs).
+
+## Best Practices
+
+### Performance
+
+1. **Minimize array access**: Cache NativeArray values when accessing multiple times
+2. **Avoid allocations**: Don't create new arrays or collections in hot paths
+3. **Use simple algorithms**: Complex packing algorithms can slow down import times
+
+### Correctness
+
+1. **Don't dispose input arrays**: Unity manages these - don't dispose them
+2. **Validate output bounds**: Ensure sprites fit within atlas dimensions
+3. **Handle edge cases**: Empty sprite lists, oversized sprites, etc.
+4. **Return false on failure**: Let Unity know packing failed
+
+### Maintainability
+
+1. **Make packer configurable**: Add public properties for tweaking behavior
+2. **Add debug logging**: Log packing statistics and warnings
+3. **Document algorithm**: Explain packing strategy in comments
+4. **Test with various inputs**: Different sprite sizes, counts, and arrangements
+
+## Common Pitfalls
+
+1. **Disposing input arrays**: Unity manages these - don't dispose them
+2. **Forgetting to set `sprite.output`**: Each sprite needs output position
+3. **Exceeding atlas bounds**: Validate that packed sprites fit within max texture size
+4. **Not handling multi-page**: Set `sprite.output.page` correctly for multi-page atlases
+5. **Modifying read-only fields**: Some fields like texture dimensions are read-only
+6. **Forgetting to assign packer**: Use `SetScriptablePacker()` before saving atlas
+
+## Debugging Tips
+
+See [resources/packerdebugging.cs](../resources/packerdebugging.cs).

package/unity-skills/manage-sprite-atlas/references/manual-authoring.md

@@ -0,0 +1,39 @@
+# Manual Authoring (Advanced - Not Default)
+
+> ⚠ **WARNING**: Manual authoring is NOT the default approach. Only use these patterns when the user EXPLICITLY requests manual control or editor preview during development.
+
+> 🚨 **DEFAULT APPROACH**: Use prebuild generation with `IPreprocessBuildWithReport` instead. See the main SKILL.md Quick Start section.
+
+## When to Use Manual Authoring
+
+**Manual authoring is appropriate ONLY for:**
+- Hand-optimized sprite layouts where exact positioning matters
+- Custom sprite ordering requirements
+- Editor preview during authoring workflow
+- Explicitly requested by user
+
+**DO NOT use manual authoring when:**
+- User asks to "create sprite atlas" (use prebuild)
+- User asks to "optimize sprites" (use prebuild)
+- User asks for automated workflow (use prebuild)
+- No specific manual control requirement mentioned
+
+## Create and Configure Master Atlas (Manual Pattern)
+
+> 🚨 **REMINDER**: Only use this if explicitly requested. Default is prebuild with `IPreprocessBuildWithReport`.
+
+See [resources/createandconfiguremasteratlas.cs](../resources/createandconfiguremasteratlas.cs).
+
+## Create Variant Atlas (Manual Pattern)
+
+> 🚨 **REMINDER**: Only use this if explicitly requested. Default is prebuild with `IPreprocessBuildWithReport`.
+
+See [resources/variantatlas.cs](../resources/variantatlas.cs).
+
+## Runtime Dynamic Loading
+
+See [resources/runtimeatlasloader.cs](../resources/runtimeatlasloader.cs).
+
+## Runtime Sprite Access
+
+See [resources/runtimespriteaccess.cs](../resources/runtimespriteaccess.cs).

package/unity-skills/manage-sprite-atlas/resources/authoringvsruntime.cs

@@ -0,0 +1,176 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEditor;
+using UnityEditor.U2D;
+using UnityEngine;
+using UnityEngine.U2D;
+
+/// <summary>
+/// Explains the critical distinction between editor authoring and runtime access.
+/// SpriteAtlasAsset (editor) vs SpriteAtlas (runtime) - never mix them!
+/// </summary>
+public static class AuthoringVsRuntimeDocumentation
+{
+    /// <summary>
+    /// SPRITEATLASASSET - Editor-Only Type
+    /// Used for creating, modifying, and configuring atlases in the editor.
+    /// Cannot be used at runtime.
+    /// </summary>
+    public static void Use_SpriteAtlasAsset_Editor()
+    {
+        // ✅ CORRECT: Using SpriteAtlasAsset in editor code
+
+        // Create new atlas asset
+        SpriteAtlasAsset asset = new SpriteAtlasAsset();
+
+        // Add sprites for authoring
+        Object[] sprites = AssetDatabase.LoadAllAssetsAtPath("Assets/Sprites/mySprite.png");
+        asset.Add(sprites);
+
+        // Save to disk
+        SpriteAtlasAsset.Save(asset, "Assets/MyAtlas.spriteatlasv2");
+
+        // Configure via importer (editor-only)
+        AssetDatabase.ImportAsset("Assets/MyAtlas.spriteatlasv2");
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath("Assets/MyAtlas.spriteatlasv2") as SpriteAtlasImporter;
+        importer.includeInBuild = true;
+        importer.SaveAndReimport();
+    }
+
+    /// <summary>
+    /// SPRITEATLAS - Runtime-Only Type
+    /// Used for querying packed sprites at runtime.
+    /// Cannot be created or modified in editor code.
+    /// </summary>
+    public static void Use_SpriteAtlas_Runtime()
+    {
+        // ✅ CORRECT: Using SpriteAtlas at runtime
+
+        // Register for late-binding to load atlases on-demand
+        SpriteAtlasManager.atlasRegistered += OnAtlasLoaded;
+    }
+
+    private static void OnAtlasLoaded(SpriteAtlas atlas)
+    {
+        // Query sprites from loaded atlas (runtime only)
+        Object[] packables = atlas.GetPackables();
+        // ... use sprites ...
+    }
+
+    /// <summary>
+    /// ❌ WRONG: Using SpriteAtlas in editor code.
+    /// SpriteAtlas is a runtime type and cannot be constructed in editor.
+    /// </summary>
+    public static void Wrong_UseSpriteAtlasInEditor()
+    {
+        // ❌ WRONG: Cannot construct SpriteAtlas in editor
+        // SpriteAtlas atlas = new SpriteAtlas(); // Compile error!
+
+        // ❌ WRONG: Cannot load SpriteAtlas in editor
+        // SpriteAtlas atlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>("path"); // Runtime error!
+    }
+
+    /// <summary>
+    /// ❌ WRONG: Using SpriteAtlasAsset at runtime.
+    /// SpriteAtlasAsset is an asset file, not a runtime object.
+    /// </summary>
+    public static void Wrong_UseSpriteAtlasAssetRuntime()
+    {
+        // ❌ WRONG: Cannot use SpriteAtlasAsset in runtime code
+        // SpriteAtlasAsset asset = someReference; // This is an editor type!
+    }
+
+    /// <summary>
+    /// ✅ CORRECT: Two-step V2 pattern for atlas creation.
+    /// Step 1: Create with SpriteAtlasAsset (editor)
+    /// Step 2: Use at runtime via SpriteAtlas
+    /// </summary>
+    public static void Correct_TwoStepPattern()
+    {
+        // ===== STEP 1: EDITOR AUTHORING (SpriteAtlasAsset) =====
+
+        // In editor script or prebuild processor:
+        SpriteAtlasAsset asset = new SpriteAtlasAsset();
+        asset.Add(AssetDatabase.LoadAllAssetsAtPath("Assets/Sprites/mySprite.png"));
+        SpriteAtlasAsset.Save(asset, "Assets/MyAtlas.spriteatlasv2");
+        AssetDatabase.ImportAsset("Assets/MyAtlas.spriteatlasv2");
+
+        // Configure via importer
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath("Assets/MyAtlas.spriteatlasv2") as SpriteAtlasImporter;
+        importer.includeInBuild = true; // Include in build for immediate loading
+        importer.SaveAndReimport();
+
+        // ===== STEP 2: RUNTIME ACCESS (SpriteAtlas) =====
+
+        // In runtime script:
+        /*
+        public class MyRuntimeScript : MonoBehaviour
+        {
+            private void Awake()
+            {
+                // Register for late-binding if using Addressables
+                SpriteAtlasManager.atlasRegistrationNeeded += OnAtlasRegistrationNeeded;
+            }
+
+            private void OnAtlasRegistrationNeeded(Sprite sprite)
+            {
+                // Load atlas via Addressables/AssetBundles
+                // The loaded SpriteAtlas is what you query at runtime
+            }
+        }
+        */
+    }
+
+    /// <summary>
+    /// Summary table of when to use each type:
+    ///
+    /// | Context      | Type              | Purpose                              |
+    /// |--------------|-------------------|--------------------------------------|
+    /// | Editor       | SpriteAtlasAsset  | Create, modify, configure atlases    |
+    /// | Editor       | SpriteAtlasImporter | Set texture, packing, platform settings |
+    /// | Runtime      | SpriteAtlas       | Query packed sprites (read-only)     |
+    /// | Runtime      | SpriteAtlasManager| Dynamic loading callbacks            |
+    /// </summary>
+    public static void Summary_Table()
+    {
+        /*
+        +------------------+-------------------+--------------------------------------+
+        | Context          | Type              | Purpose                              |
+        +------------------+-------------------+--------------------------------------+
+        | Editor           | SpriteAtlasAsset  | Create, modify, configure atlases    |
+        | Editor           | SpriteAtlasImporter | Set texture, packing, platform settings |
+        | Runtime          | SpriteAtlas       | Query packed sprites (read-only)     |
+        | Runtime          | SpriteAtlasManager| Dynamic loading callbacks            |
+        +------------------+-------------------+--------------------------------------+
+        */
+    }
+}
+
+/// <summary>
+/// Example: Editor script that creates an atlas using the correct types.
+/// </summary>
+public static class CorrectEditorScript
+{
+    [MenuItem("Tools/Create Atlas")]
+    public static void CreateAtlas()
+    {
+        // Use SpriteAtlasAsset for editor authoring
+        SpriteAtlasAsset asset = new SpriteAtlasAsset();
+
+        // Add sprites from a folder
+        string[] guids = AssetDatabase.FindAssets("t:Sprite", new[] { "Assets/Sprites" });
+        Object[] sprites = new Object[guids.Length];
+        for (int i = 0; i < guids.Length; i++)
+        {
+            sprites[i] = AssetDatabase.LoadAssetAtPath<Sprite>(
+                AssetDatabase.GUIDToAssetPath(guids[i]));
+        }
+        asset.Add(sprites);
+
+        // Save and import
+        string path = "Assets/Atlases/MyAtlas.spriteatlasv2";
+        SpriteAtlasAsset.Save(asset, path);
+        AssetDatabase.ImportAsset(path);
+
+        Debug.Log($"Created atlas at {path}");
+    }
+}

package/unity-skills/manage-sprite-atlas/resources/buildaddressablespostprocess.cs

@@ -0,0 +1,59 @@
+// [UNITY-SKILL:SPRITEATLAS]
+// [TYPE:POSTPROCESS-ADDRESSABLES]
+// Generated by SpriteAtlas V2 Skill
+// This script builds Addressables content after atlas generation
+
+using UnityEditor;
+using UnityEditor.Build;
+using UnityEditor.Build.Reporting;
+using UnityEngine;
+
+#if UNITY_ADDRESSABLES
+using UnityEditor.AddressableAssets;
+using UnityEditor.AddressableAssets.Settings;
+using UnityEditor.AddressableAssets.Build;
+#endif
+
+/// <summary>
+/// Builds Addressables content after atlas generation
+/// This ensures atlases are available for on-demand loading
+/// </summary>
+public class BuildAddressablesPostprocess : IPostprocessBuildWithReport
+{
+    public int callbackOrder => 1; // Run after atlas generation (callbackOrder 0)
+
+    public void OnPostprocessBuild(BuildReport report)
+    {
+#if UNITY_ADDRESSABLES
+        Debug.Log("[Addressables] Building Addressables content...");
+
+        var settings = AddressableAssetSettingsDefaultObject.Settings;
+        if (settings == null)
+        {
+            Debug.LogError("[Addressables] Addressables settings not found. Cannot build addressables content.");
+            return;
+        }
+
+        try
+        {
+            // Build addressables content
+            AddressableAssetSettings.BuildPlayerContent(out AddressablesPlayerBuildResult result);
+
+            if (!string.IsNullOrEmpty(result.Error))
+            {
+                Debug.LogError($"[Addressables] Build failed: {result.Error}");
+            }
+            else
+            {
+                Debug.Log($"[Addressables] Build completed successfully. Duration: {result.Duration}");
+            }
+        }
+        catch (System.Exception ex)
+        {
+            Debug.LogError($"[Addressables] Build exception: {ex.Message}");
+        }
+#else
+        Debug.LogWarning("[Addressables] Addressables package not installed. Skipping addressables build.");
+#endif
+    }
+}

package/unity-skills/manage-sprite-atlas/resources/cacheloadedatlases.cs

@@ -0,0 +1,145 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEngine;
+using UnityEngine.U2D;
+using System.Collections.Generic;
+
+/// <summary>
+/// Demonstrates caching loaded SpriteAtlases for efficient reuse.
+/// Avoid reloading the same atlas multiple times by caching loaded instances.
+/// </summary>
+public class CacheLoadedAtlases : MonoBehaviour
+{
+    /// <summary>Cached dictionary of loaded atlases</summary>
+    private readonly Dictionary<string, SpriteAtlas> _loadedAtlases = new Dictionary<string, SpriteAtlas>();
+
+    /// <summary>Reference to SpriteAtlasManager for loading</summary>
+    private SpriteAtlasManager _atlasManager;
+
+    private void Awake()
+    {
+        RegisterCallbacks();
+    }
+
+    private void OnDestroy()
+    {
+        UnregisterCallbacks();
+        ClearCache();
+    }
+
+    private void RegisterCallbacks()
+    {
+        SpriteAtlasManager.atlasRegistered += OnAtlasLoaded;
+    }
+
+    private void UnregisterCallbacks()
+    {
+        SpriteAtlasManager.atlasRegistered -= OnAtlasLoaded;
+    }
+
+    /// <summary>
+    /// Gets an atlas by name, loading it if not already cached.
+    /// Returns true if the atlas was found (cached or newly loaded).
+    /// </summary>
+    public bool GetAtlas(string atlasName, out SpriteAtlas atlas)
+    {
+        // Check cache first
+        if (_loadedAtlases.TryGetValue(atlasName, out atlas))
+        {
+            return true;
+        }
+
+        // Not cached - load it
+        return LoadAndCacheAtlas(atlasName);
+    }
+
+    /// <summary>
+    /// Loads an atlas and adds it to the cache.
+    /// </summary>
+    private bool LoadAndCacheAtlas(string atlasName)
+    {
+        // Example: Load from Resources (not recommended for production)
+        // SpriteAtlas atlas = Resources.Load<SpriteAtlas>($"Atlases/{atlasName}");
+
+        // For production, use Addressables or AssetBundle loading
+        // SpriteAtlas atlas = await Addressables.LoadAssetAsync<SpriteAtlas>($"Atlases/{atlasName}").Task;
+
+        Debug.Log($"Loading and caching atlas: {atlasName}");
+
+        // Placeholder - replace with actual loading logic
+        SpriteAtlas atlas = null; // Replace with actual loaded atlas
+
+        if (atlas != null)
+        {
+            _loadedAtlases[atlasName] = atlas;
+            return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Gets a cached atlas without attempting to load it.
+    /// Returns false if not found in cache.
+    /// </summary>
+    public bool TryGetCachedAtlas(string atlasName, out SpriteAtlas atlas)
+    {
+        return _loadedAtlases.TryGetValue(atlasName, out atlas);
+    }
+
+    /// <summary>
+    /// Checks if an atlas is currently cached.
+    /// </summary>
+    public bool IsAtlasCached(string atlasName)
+    {
+        return _loadedAtlases.ContainsKey(atlasName);
+    }
+
+    /// <summary>
+    /// Removes an atlas from the cache without destroying it.
+    /// The atlas can still be used, but will need to be reloaded if requested again.
+    /// </summary>
+    public bool RemoveFromCache(string atlasName)
+    {
+        return _loadedAtlases.Remove(atlasName);
+    }
+
+    /// <summary>
+    /// Clears all cached atlases.
+    /// Use this when switching scenes or cleaning up.
+    /// </summary>
+    public void ClearCache()
+    {
+        _loadedAtlases.Clear();
+        Debug.Log("Atlas cache cleared");
+    }
+
+    /// <summary>
+    /// Gets the number of atlases currently in the cache.
+    /// </summary>
+    public int CachedAtlasCount => _loadedAtlases.Count;
+
+    /// <summary>
+    /// Logs all cached atlas names.
+    /// </summary>
+    public void LogCachedAtlases()
+    {
+        Debug.Log("Cached atlases:");
+        foreach (var kvp in _loadedAtlases)
+        {
+            Debug.Log($"  - {kvp.Key}");
+        }
+    }
+
+    /// <summary>
+    /// Callback when an atlas is loaded by SpriteAtlasManager.
+    /// Adds the loaded atlas to our cache for future use.
+    /// </summary>
+    private void OnAtlasLoaded(SpriteAtlas atlas)
+    {
+        if (atlas != null && !_loadedAtlases.ContainsKey(atlas.name))
+        {
+            _loadedAtlases[atlas.name] = atlas;
+            Debug.Log($"Atlas cached: {atlas.name}");
+        }
+    }
+}

package/unity-skills/manage-sprite-atlas/resources/cleanupbatchoperations.cs

@@ -0,0 +1,119 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEditor;
+using UnityEditor.U2D;
+using UnityEngine;
+
+/// <summary>
+/// Demonstrates proper cleanup after batch operations on SpriteAtlases.
+/// Always use try/finally blocks to ensure cleanup happens even on errors.
+/// </summary>
+public static class CleanupBatchOperationsExample
+{
+    /// <summary>
+    /// Creates multiple atlases in a batch with proper cleanup.
+    /// Uses try/finally to ensure AssetDatabase.ImportAsset is called for each atlas.
+    /// </summary>
+    public static void BatchCreateAtlases()
+    {
+        var atlasConfigs = new[]
+        {
+            new { Folder = "Assets/Sprites/UI", Output = "Assets/Atlases/UI.spriteatlasv2" },
+            new { Folder = "Assets/Sprites/Characters", Output = "Assets/Atlases/Characters.spriteatlasv2" },
+            new { Folder = "Assets/Sprites/Items", Output = "Assets/Atlases/Items.spriteatlasv2" }
+        };
+
+        for (int i = 0; i < atlasConfigs.Length; i++)
+        {
+            try
+            {
+                CreateAtlasFromFolder(atlasConfigs[i].Folder, atlasConfigs[i].Output);
+            }
+            catch (System.Exception ex)
+            {
+                Debug.LogError($"Failed to create atlas {atlasConfigs[i].Output}: {ex.Message}");
+            }
+        }
+
+        // Final cleanup - refresh asset database
+        AssetDatabase.Refresh();
+        Debug.Log("Batch atlas creation completed");
+    }
+
+    /// <summary>
+    /// Creates an atlas from a folder and configures it.
+    /// </summary>
+    private static void CreateAtlasFromFolder(string folderPath, string outputPath)
+    {
+        // Find sprites in folder
+        string[] guids = AssetDatabase.FindAssets("t:Sprite", new[] { folderPath });
+
+        Object[] sprites = new Object[guids.Length];
+        for (int i = 0; i < guids.Length; i++)
+        {
+            sprites[i] = AssetDatabase.LoadAssetAtPath<Sprite>(
+                AssetDatabase.GUIDToAssetPath(guids[i])
+            );
+        }
+
+        // Create and save atlas
+        SpriteAtlasAsset atlasAsset = new SpriteAtlasAsset();
+        atlasAsset.Add(sprites);
+        SpriteAtlasAsset.Save(atlasAsset, outputPath);
+
+        // Import and configure via importer
+        AssetDatabase.ImportAsset(outputPath);
+
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(outputPath) as SpriteAtlasImporter;
+        if (importer != null)
+        {
+            importer.includeInBuild = true;
+            var packingSettings = importer.packingSettings;
+            packingSettings.enableTightPacking = true;
+            importer.packingSettings = packingSettings;
+            importer.SaveAndReimport();
+        }
+    }
+
+    /// <summary>
+    /// Processes multiple atlases with progress bar and proper cleanup.
+    /// </summary>
+    public static void ProcessAtlasesWithProgress(string[] atlasPaths)
+    {
+        for (int i = 0; i < atlasPaths.Length; i++)
+        {
+            string path = atlasPaths[i];
+            float progress = (float)i / atlasPaths.Length;
+
+            if (EditorUtility.DisplayCancelableProgressBar(
+                "Processing Atlases",
+                $"Processing: {path}",
+                progress))
+            {
+                break; // User cancelled
+            }
+
+            try
+            {
+                ProcessSingleAtlas(path);
+            }
+            finally
+            {
+                // Ensure progress bar is cleared even on error
+                EditorUtility.ClearProgressBar();
+            }
+        }
+    }
+
+    /// <summary>
+    /// Processes a single atlas.
+    /// </summary>
+    private static void ProcessSingleAtlas(string path)
+    {
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+        if (importer != null)
+        {
+            // Reimport to update
+            importer.SaveAndReimport();
+        }
+    }
+}