@aqian0/dsh-unity 0.0.0-stage → 0.1.0

package/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/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();
+        }
+    }
+}

package/skills/manage-sprite-atlas/resources/createandconfiguremasteratlas.cs

@@ -0,0 +1,57 @@
+using System;
+using UnityEditor;
+using UnityEditor.U2D;
+using UnityEngine;
+using UnityEngine.U2D;
+using Object = UnityEngine.Object;
+
+public static class MasterAtlasCreator
+{
+    public static void CreateMasterAtlas(string path, Object[] spritesOrFolders)
+    {
+        // CRITICAL: Validate all sprites are from Assets/ folder before calling this
+        // Use: sprites.All(s => AssetDatabase.GetAssetPath(s).StartsWith("Assets/"))
+
+        // Step 1: Author content (editor-only)
+        SpriteAtlasAsset atlasAsset = new SpriteAtlasAsset();
+        atlasAsset.Add(spritesOrFolders); // Add sprites/folders - ONLY from Assets/ folder
+        SpriteAtlasAsset.Save(atlasAsset, path);
+        AssetDatabase.ImportAsset(path);
+
+        // Step 2: Configure via importer (editor-only)
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+        if (importer == null) throw new InvalidOperationException("Failed to get SpriteAtlasImporter");
+
+        // Texture settings is a struct, so members cannot be edited directly.
+        var textureSettings = importer.textureSettings;
+        textureSettings.filterMode = FilterMode.Bilinear;
+        textureSettings.generateMipMaps = false;
+        importer.textureSettings = textureSettings;
+
+        // Packing settings is a struct, so members cannot be edited directly.
+        var packingSettings = importer.packingSettings;
+        packingSettings.padding = 4;
+        packingSettings.enableAlphaDilation = true;
+        importer.packingSettings = packingSettings;
+
+        // Platform settings (safe loop with type checks)
+        SetPlatformSettings(importer, "Android", TextureImporterFormat.ASTC_6x6); // Ensure format is valid.
+        SetPlatformSettings(importer, "iOS", TextureImporterFormat.ASTC_4x4); // [critical] TextureImporterPlatformSettings format type is TextureImporterFormat
+
+        // Mark for build inclusion
+        importer.includeInBuild = true;
+        importer.SaveAndReimport(); // REQUIRED
+    }
+
+    private static void SetPlatformSettings(SpriteAtlasImporter importer, string platformName, TextureImporterFormat format)
+    {
+        var settings = new TextureImporterPlatformSettings
+        {
+            name = platformName,
+            overridden = true,
+            maxTextureSize = 2048,
+            format = format // ✅ Direct enum assignment (no cast) - Unity stores internally as int but struct expects enum
+        };
+        importer.SetPlatformSettings(settings);
+    }
+}

package/skills/manage-sprite-atlas/resources/custompackersetup.cs

@@ -0,0 +1,88 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEditor;
+using UnityEditor.U2D;
+using UnityEngine;
+
+/// <summary>
+/// Utility class for creating atlases with custom packers.
+/// Demonstrates how to assign a custom ScriptablePacker to a SpriteAtlasAsset.
+/// </summary>
+public static class CustomPackerSetup
+{
+    /// <summary>
+    /// Creates an atlas with a custom grid packer using menu item.
+    /// Menu path: Tools/Create Atlas with Custom Packer
+    /// </summary>
+    [MenuItem("Tools/Create Atlas with Custom Packer")]
+    public static void CreateAtlasWithCustomPacker()
+    {
+        // Create atlas asset
+        SpriteAtlasAsset atlasAsset = new SpriteAtlasAsset();
+
+        // Add sprites from Assets/Sprites 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])
+            );
+        }
+        atlasAsset.Add(sprites);
+
+        // Create custom packer instance
+        GridSpritePacker customPacker = ScriptableObject.CreateInstance<GridSpritePacker>();
+        customPacker.columns = 8;
+        customPacker.cellSize = 128;
+        customPacker.padding = 2;
+
+        // Assign custom packer to atlas
+        atlasAsset.SetScriptablePacker(customPacker);
+
+        // Save atlas to disk
+        string path = "Assets/CustomPackedAtlas.spriteatlas";
+        SpriteAtlasAsset.Save(atlasAsset, path);
+        AssetDatabase.ImportAsset(path);
+
+        // Configure via importer
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+        importer.includeInBuild = true;
+        importer.SaveAndReimport();
+
+        Debug.Log($"Created atlas with custom packer at {path}");
+    }
+
+    /// <summary>
+    /// Creates an atlas with a size-optimized packer programmatically.
+    /// </summary>
+    public static void CreateSizeOptimizedAtlas()
+    {
+        SpriteAtlasAsset atlasAsset = new SpriteAtlasAsset();
+
+        // Add sprites...
+        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])
+            );
+        }
+        atlasAsset.Add(sprites);
+
+        // Use size-optimized packer
+        SizeOptimizedPacker packer = ScriptableObject.CreateInstance<SizeOptimizedPacker>();
+        packer.atlasSize = 4096;
+        packer.padding = 4;
+
+        atlasAsset.SetScriptablePacker(packer);
+
+        string path = "Assets/OptimizedAtlas.spriteatlas";
+        SpriteAtlasAsset.Save(atlasAsset, path);
+        AssetDatabase.ImportAsset(path);
+
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+        importer.includeInBuild = true;
+        importer.SaveAndReimport();
+    }
+}

package/skills/manage-sprite-atlas/resources/deprecatedmethods.cs

@@ -0,0 +1,142 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEditor;
+using UnityEditor.U2D;
+
+/// <summary>
+/// Documents deprecated SpriteAtlas methods and their replacements.
+/// Always use the latest V2 API patterns.
+/// </summary>
+public static class DeprecatedMethodsDocumentation
+{
+    /// <summary>
+    /// ⚠ DEPRECATED: SetBuildSettings method.
+    /// This method was used in early V1/V2 preview versions but is no longer available.
+    ///
+    /// REPLACEMENT: Use SpriteAtlasImporter for all configuration settings.
+    /// </summary>
+    [System.Obsolete("SetBuildSettings is deprecated. Use SpriteAtlasImporter instead.")]
+    public static void Old_SetBuildSettings()
+    {
+        // OLD (deprecated):
+        // SpriteAtlasAsset atlas = new SpriteAtlasAsset();
+        // atlas.SetBuildSettings(settings);
+
+        // NEW:
+        // Create asset, save it, then configure via SpriteAtlasImporter
+        // SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+        // importer.packingSettings = settings;
+        // importer.SaveAndReimport();
+    }
+
+    /// <summary>
+    /// ⚠ DEPRECATED: GetBuildSettings method.
+    /// Use SpriteAtlasImporter to read configuration instead.
+    /// </summary>
+    [System.Obsolete("GetBuildSettings is deprecated. Read from SpriteAtlasImporter instead.")]
+    public static void Old_GetBuildSettings()
+    {
+        // OLD (deprecated):
+        // var settings = atlas.GetBuildSettings();
+
+        // NEW:
+        // SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+        // var settings = importer.packingSettings;
+    }
+
+    /// <summary>
+    /// ⚠ DEPRECATED: Direct modification of SpriteAtlas after creation.
+    /// In V2, SpriteAtlas is read-only at runtime and cannot be modified in editor.
+    ///
+    /// REPLACEMENT: Modify SpriteAtlasAsset before saving, then reimport.
+    /// </summary>
+    [System.Obsolete("Direct SpriteAtlas modification is deprecated. Use SpriteAtlasAsset for editing.")]
+    public static void Old_DirectModification()
+    {
+        // OLD (deprecated):
+        // atlas.Add(sprites); // Not allowed in editor!
+
+        // NEW:
+        // SpriteAtlasAsset asset = new SpriteAtlasAsset();
+        // asset.Add(sprites);
+        // SpriteAtlasAsset.Save(asset, path);
+    }
+
+    /// <summary>
+    /// ⚠ DEPRECATED: Using AssetDatabase.LoadAssetAtPath<SpriteAtlas>() in editor.
+    /// SpriteAtlas is runtime-only and cannot be loaded in editor context.
+    ///
+    /// REPLACEMENT: Use SpriteAtlasAsset for editor operations.
+    /// </summary>
+    [System.Obsolete("Loading SpriteAtlas in editor is deprecated. Use SpriteAtlasAsset instead.")]
+    public static void Old_LoadSpriteAtlasInEditor()
+    {
+        // OLD (deprecated):
+        // SpriteAtlas atlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(path);
+
+        // NEW:
+        // SpriteAtlasAsset asset = AssetDatabase.LoadAssetAtPath<SpriteAtlasAsset>(path);
+    }
+
+    /// <summary>
+    /// ⚠ DEPRECATED: Manual packing in editor using SpriteAtlasUtility.
+    /// SpriteAtlasUtility.PackAtlases() is for preview only, not build-time packing.
+    ///
+    /// REPLACEMENT: Use the prebuild pipeline with IPreprocessBuildWithReport.
+    /// </summary>
+    [System.Obsolete("Manual packing is deprecated. Use IPreprocessBuildWithReport instead.")]
+    public static void Old_ManualPacking()
+    {
+        // OLD (deprecated):
+        // SpriteAtlasUtility.PackAtlases(atlases, BuildTarget.NoAPI);
+
+        // NEW:
+        // Implement IPreprocessBuildWithReport.OnPreprocessBuild() for automatic packing
+    }
+}
+
+/// <summary>
+/// Migration guide: Old code patterns vs new V2 patterns.
+/// </summary>
+public static class MigrationGuide
+{
+    /// <summary>
+    /// Pattern 1: Creating an atlas
+    /// </summary>
+    public static void CreateAtlas_Old()
+    {
+        // ❌ OLD (deprecated):
+        // var atlas = ScriptableObject.CreateInstance<SpriteAtlas>();
+        // AssetDatabase.AddObjectToAsset(atlas, path);
+        // EditorUtility.SetDirty(atlas);
+
+        // ✅ NEW (V2):
+        SpriteAtlasAsset asset = new SpriteAtlasAsset();
+        // Add sprites...
+        SpriteAtlasAsset.Save(asset, "Assets/MyAtlas.spriteatlasv2");
+    }
+
+    /// <summary>
+    /// Pattern 2: Configuring an atlas
+    /// </summary>
+    public static void ConfigureAtlas_Old()
+    {
+        // ❌ OLD (deprecated):
+        // var importer = (SpriteAtlasImporter)AssetImporter.GetAtPath(path);
+        // importer.SetBuildSettings(settings);
+
+        // ✅ NEW (V2):
+        SpriteAtlasImporter importer = null; // Get from AssetImporter
+        // importer.packingSettings = settings;
+        // importer.SaveAndReimport();
+    }
+
+    /// <summary>
+    /// Pattern 3: Loading an atlas at runtime
+    /// </summary>
+    public static void LoadAtlas_Runtime()
+    {
+        // ✅ CORRECT (runtime only):
+        // SpriteAtlasManager.atlasLoaded += OnAtlasLoaded;
+        // Or use Addressables/AssetBundles for dynamic loading
+    }
+}

package/skills/manage-sprite-atlas/resources/dontmodifywithoutsaving.cs

@@ -0,0 +1,120 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEditor;
+using UnityEditor.U2D;
+
+/// <summary>
+/// Demonstrates why you must call SaveAndReimport() after modifying SpriteAtlasImporter.
+/// Changes to importer settings are not persisted without explicitly saving.
+/// </summary>
+public static class DontModifyWithoutSavingDocumentation
+{
+    /// <summary>
+    /// ❌ WRONG: Modifying importer settings and expecting them to persist.
+    /// Unity's asset database requires explicit SaveAndReimport() calls.
+    /// </summary>
+    public static void Wrong_ModifyAndForget()
+    {
+        string path = "Assets/MyAtlas.spriteatlasv2";
+
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+        if (importer != null)
+        {
+            // Make changes
+            importer.includeInBuild = true;
+            var packingSettings = importer.packingSettings;
+            packingSettings.enableTightPacking = true;
+            importer.packingSettings = packingSettings;
+
+            // ❌ NOT CALLING SaveAndReimport()!
+            // Changes are lost when Unity reimports or restarts
+        }
+    }
+
+    /// <summary>
+    /// ❌ WRONG: Modifying multiple settings without saving.
+    /// Each setting change needs to be followed by SaveAndReimport().
+    /// </summary>
+    public static void Wrong_MultipleChangesNoSave()
+    {
+        string path = "Assets/MyAtlas.spriteatlasv2";
+
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+        if (importer != null)
+        {
+            var packingSettings = importer.packingSettings;
+            var textureSettings = importer.GetPlatformSettings("DefaultTexturePlatform");
+
+            // Change 1: Include in build
+            importer.includeInBuild = true;
+
+            // Change 2: Tight packing
+            packingSettings.enableTightPacking = true;
+
+            // Change 3: Max texture size
+            textureSettings.maxTextureSize = 2048;
+
+            // Change 4: Format
+            textureSettings.format = TextureImporterFormat.ASTC_6x6;
+
+            importer.SetPlatformSettings(textureSettings);
+            importer.packingSettings = packingSettings;
+
+            // ❌ NOT CALLING SaveAndReimport()!
+            // All changes are lost
+        }
+    }
+
+    /// <summary>
+    /// ✅ CORRECT: Always call SaveAndReimport() after modifications.
+    /// This ensures changes are saved and the asset is reimported.
+    /// </summary>
+    public static void Correct_SaveAfterModify()
+    {
+        string path = "Assets/MyAtlas.spriteatlasv2";
+
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+        if (importer != null)
+        {
+            var packingSettings = importer.packingSettings;
+            var textureSettings = importer.GetPlatformSettings("DefaultTexturePlatform");
+
+            // Change 1: Include in build
+            importer.includeInBuild = true;
+
+            // Change 2: Tight packing
+            packingSettings.enableTightPacking = true;
+
+            // Change 3: Max texture size
+            textureSettings.maxTextureSize = 2048;
+
+            // Change 4: Format
+            textureSettings.format = TextureImporterFormat.ASTC_6x6;
+
+            importer.SetPlatformSettings(textureSettings);
+            importer.packingSettings = packingSettings;
+
+            // ✅ CALL SaveAndReimport()!
+            importer.SaveAndReimport();
+        }
+    }
+}
+
+/// <summary>
+/// Editor window that demonstrates the difference between saving and not saving.
+/// </summary>
+public class ModifyWithoutSavingDemo : EditorWindow
+{
+    private static void CreateDemoAtlas(string path)
+    {
+        // Clean up if exists
+        if (System.IO.File.Exists(path))
+        {
+            AssetDatabase.DeleteAsset(path);
+        }
+
+        // Create new atlas
+        SpriteAtlasAsset asset = new SpriteAtlasAsset();
+        SpriteAtlasAsset.Save(asset, path);
+        AssetDatabase.ImportAsset(path);
+    }
+}