@aqian0/dsh-unity 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,357 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEditor;
+using UnityEditor.Build;
+using UnityEditor.Build.Reporting;
+using UnityEditor.U2D;
+using UnityEngine;
+
+/// <summary>
+/// Demonstrates updating build scripts for SpriteAtlas V2.
+/// Shows how to migrate from old build patterns to the prebuild pipeline.
+/// </summary>
+public static class UpdateBuildScriptsDocumentation
+{
+    /// <summary>
+    /// OLD Pattern: Manual atlas packing in build script (NO LONGER RECOMMENDED)
+    ///
+    /// ❌ OLD CODE:
+    /// public static void BuildGame()
+    /// {
+    ///     // Manually pack atlases before build
+    ///     SpriteAtlasUtility.PackAtlases(atlases, target);
+    ///     BuildPipeline.BuildPlayer(...);
+    /// }
+    ///
+    /// ✅ NEW V2 CODE:
+    /// Implement IPreprocessBuildWithReport for automatic packing
+    /// </summary>
+    public static void Update_BuildScript_Packing()
+    {
+        // ===== UPDATING: Build Script with Manual Packing =====
+
+        // ❌ OLD (V1 - Not recommended):
+        /*
+        [MenuItem("Tools/Build Game")]
+        public static void BuildGame()
+        {
+            // Manually pack atlases
+            var guids = AssetDatabase.FindAssets("t:SpriteAtlasAsset", new[] { "Assets" });
+            var atlases = new SpriteAtlas[guids.Length];
+            for (int i = 0; i < guids.Length; i++)
+            {
+                atlases[i] = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(
+                    AssetDatabase.GUIDToAssetPath(guids[i]));
+            }
+
+            // Manual packing before build
+            SpriteAtlasUtility.PackAtlases(atlases, EditorUserBuildSettings.activeBuildTarget);
+
+            // Then build
+            BuildPipeline.BuildPlayer(...);
+        }
+        */
+
+        // ✅ NEW (V2 - Recommended):
+        /*
+        // Implement this as a prebuild processor instead:
+        public class AtlasPreprocessor : IPreprocessBuildWithReport
+        {
+            public int callbackOrder => 0;
+
+            public void OnPreprocessBuild(BuildTarget target, string path)
+            {
+                // Atlases are automatically packed during build
+                // Use this for generation/configuration only
+            }
+        }
+
+        [MenuItem("Tools/Build Game")]
+        public static void BuildGame()
+        {
+            // Just build - atlases are handled automatically
+            BuildPipeline.BuildPlayer(...);
+        }
+        */
+    }
+
+    /// <summary>
+    /// OLD Pattern: Building with Addressables (REQUIRES UPDATES)
+    ///
+    /// ❌ OLD CODE:
+    /// public static void BuildWithAddressables()
+    /// {
+    ///     // Manually build atlases
+    ///     BuildPipeline.BuildAssetBundles(...);
+    ///     AddressableAssetSettings.BuildPlayerContent();
+    /// }
+    ///
+    /// ✅ NEW V2 CODE:
+    /// Use IPreprocessBuildWithReport for atlas generation,
+    /// IPostprocessBuildWithReport for Addressables content building
+    /// </summary>
+    public static void Update_BuildScript_Addressables()
+    {
+        // ===== UPDATING: Build Script with Addressables =====
+
+        // ❌ OLD (V1 - Requires updates):
+        /*
+        [MenuItem("Tools/Build With Addressables")]
+        public static void BuildWithAddressables()
+        {
+            // Generate atlases
+            GenerateAtlases();
+
+            // Build asset bundles
+            BuildPipeline.BuildAssetBundles(...);
+
+            // Build addressables content
+            AddressableAssetSettings.BuildPlayerContent();
+        }
+        */
+
+        // ✅ NEW (V2 - Recommended):
+        /*
+        // Step 1: Prebuild processor for atlas generation
+        public class AtlasPreprocessor : IPreprocessBuildWithReport
+        {
+            public void OnPreprocessBuild(BuildTarget target, string path)
+            {
+                GenerateAtlases(); // Generate atlases before build
+            }
+        }
+
+        // Step 2: Postprocess processor for Addressables
+        public class AddressablesPostprocessor : IPostprocessBuildWithReport
+        {
+            public void OnPostprocessBuild(BuildTarget target, string path)
+            {
+                AddressableAssetSettings.BuildPlayerContent();
+            }
+        }
+
+        // Step 3: Simple build script
+        [MenuItem("Tools/Build With Addressables")]
+        public static void BuildWithAddressables()
+        {
+            // Atlases and addressables are handled automatically
+            BuildPipeline.BuildPlayer(...);
+        }
+        */
+    }
+
+    /// <summary>
+    /// Complete example: Updated build pipeline with prebuild.
+    /// </summary>
+    public static void Complete_UpdatedBuildPipeline()
+    {
+        // ===== COMPLETE: Updated Build Pipeline (V2) =====
+
+        /*
+        // ============================================
+        // PREBUILD: Generate atlases automatically
+        // ============================================
+
+        public class AtlasPreprocessor : IPreprocessBuildWithReport
+        {
+            public int callbackOrder => 0;
+
+            public void OnPreprocessBuild(BuildTarget target, string path)
+            {
+                Debug.Log("Generating atlases before build...");
+
+                // Find all sprite folders
+                var folderConfigs = new[]
+                {
+                    new { Folder = "Assets/Art/UI", Output = "Assets/Atlases/UI.spriteatlasv2" },
+                    new { Folder = "Assets/Art/Characters", Output = "Assets/Atlases/Characters.spriteatlasv2" }
+                };
+
+                foreach (var config in folderConfigs)
+                {
+                    GenerateAtlasByFolder(config.Folder, config.Output);
+                }
+
+                Debug.Log("Atlas generation complete.");
+            }
+
+            private void GenerateAtlasByFolder(string folderPath, string outputPath)
+            {
+                // Find sprites in folder
+                var guids = AssetDatabase.FindAssets("t:Sprite", new[] { folderPath });
+
+                // Load sprites
+                var sprites = new Object[guids.Length];
+                for (int i = 0; i < guids.Length; i++)
+                {
+                    sprites[i] = AssetDatabase.LoadAssetAtPath<Sprite>(
+                        AssetDatabase.GUIDToAssetPath(guids[i]));
+                }
+
+                // Create atlas asset
+                var asset = new SpriteAtlasAsset();
+                asset.Add(sprites);
+
+                // Save and import
+                SpriteAtlasAsset.Save(asset, outputPath);
+                AssetDatabase.ImportAsset(outputPath);
+
+                // Configure via importer
+                var importer = AssetImporter.GetAtPath(outputPath) as SpriteAtlasImporter;
+                if (importer != null)
+                {
+                    importer.includeInBuild = true;
+                    importer.packingSettings.tightPacking = true;
+                    importer.SaveAndReimport();
+                }
+            }
+        }
+
+        // ============================================
+        // BUILD: Simple build script
+        // ============================================
+
+        [MenuItem("Tools/Build Game")]
+        public static void BuildGame()
+        {
+            Debug.Log("Starting build...");
+
+            // Atlases are automatically generated by preprocessor
+            // No manual packing needed!
+
+            var buildResult = BuildPipeline.BuildPlayer(GetBuildOptions());
+            if (buildResult.summary.result == BuildResult.Succeeded)
+            {
+                Debug.Log($"Build succeeded: {buildResult.outputPath}");
+            }
+        }
+
+        private static BuildPlayerOptions GetBuildOptions()
+        {
+            return new BuildPlayerOptions
+            {
+                scenes = EditorBuildSettings.scenes,
+                locationPathName = "Builds/Game.exe",
+                target = EditorUserBuildSettings.activeBuildTarget,
+                options = BuildOptions.None
+            };
+        }
+        */
+    }
+
+    /// <summary>
+    /// Migration checklist for build scripts:
+    ///
+    /// [ ] Remove manual SpriteAtlasUtility.PackAtlases() calls
+    /// [ ] Implement IPreprocessBuildWithReport for atlas generation
+    /// [ ] Use IPostprocessBuildWithReport for post-build steps (Addressables, etc.)
+    /// [ ] Simplify build scripts - most work is now automated
+    /// </summary>
+    public static void Migration_Checklist()
+    {
+        /*
+        MIGRATION CHECKLIST:
+        ====================
+
+        1. Remove Manual Packing
+           - OLD: SpriteAtlasUtility.PackAtlases() in build script
+           - NEW: Automatic during build (remove manual calls)
+
+        2. Add Prebuild Processor
+           - Implement IPreprocessBuildWithReport.OnPreprocessBuild()
+           - Generate or update atlases here
+
+        3. Add Postbuild Processor (if needed)
+           - Implement IPostprocessBuildWithReport.OnPostprocessBuild()
+           - Handle Addressables, asset bundles, etc.
+
+        4. Simplify Build Script
+           - Remove manual atlas generation/packing
+           - Just call BuildPipeline.BuildPlayer()
+
+        5. Test Build Pipeline
+           - Verify atlases are generated before build
+           - Check that atlases are included in build output
+        */
+    }
+}
+
+/// <summary>
+/// Example: Complete prebuild processor for atlas generation.
+/// </summary>
+public class CompletePreprocessor : IPreprocessBuildWithReport
+{
+    public int callbackOrder => 0;
+    public void OnPreprocessBuild(BuildReport report)
+    {
+        Debug.Log($"[AtlasPreprocessor] Generating atlases...");
+
+        // Generate atlases by folder
+        GenerateAtlasByFolder("Assets/Art/UI", "Assets/Atlases/UI.spriteatlasv2");
+        GenerateAtlasByFolder("Assets/Art/Characters", "Assets/Atlases/Characters.spriteatlasv2");
+
+        Debug.Log("[AtlasPreprocessor] Atlas generation complete.");
+    }
+
+    private void GenerateAtlasByFolder(string folderPath, string outputPath)
+    {
+        // Find sprites in folder
+        var guids = AssetDatabase.FindAssets("t:Sprite", new[] { folderPath });
+
+        if (guids.Length == 0)
+            return;
+
+        Debug.Log($"[AtlasPreprocessor] Found {guids.Length} sprites in {folderPath}");
+
+        // Load sprites
+        var sprites = new Object[guids.Length];
+        for (int i = 0; i < guids.Length; i++)
+        {
+            sprites[i] = AssetDatabase.LoadAssetAtPath<Sprite>(
+                AssetDatabase.GUIDToAssetPath(guids[i]));
+        }
+
+        // Create or update atlas asset
+        SpriteAtlasAsset asset;
+        if (System.IO.File.Exists(outputPath))
+        {
+            asset = AssetDatabase.LoadAssetAtPath<SpriteAtlasAsset>(outputPath);
+        }
+        else
+        {
+            asset = new SpriteAtlasAsset();
+        }
+
+        asset.Add(sprites);
+
+        // Save and import
+        SpriteAtlasAsset.Save(asset, outputPath);
+        AssetDatabase.ImportAsset(outputPath);
+
+        // Configure via importer
+        var importer = AssetImporter.GetAtPath(outputPath) as SpriteAtlasImporter;
+        if (importer != null)
+        {
+            importer.includeInBuild = true;
+            var packingSettings = importer.packingSettings;
+            packingSettings.enableTightPacking = true;
+            importer.packingSettings = packingSettings;
+
+            // Platform-specific settings
+            importer.SetPlatformSettings(new TextureImporterPlatformSettings
+            {
+                name = "Android",
+                maxTextureSize = 1024,
+                format = TextureImporterFormat.ETC2_RGB4
+            });
+
+            importer.SetPlatformSettings(new TextureImporterPlatformSettings
+            {
+                name = "Standalone",
+                maxTextureSize = 2048,
+                format = TextureImporterFormat.DXT5
+            });
+
+            importer.SaveAndReimport();
+        }
+    }
+}

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

@@ -0,0 +1,135 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEditor;
+using UnityEditor.U2D;
+using UnityEngine;
+
+/// <summary>
+/// Demonstrates updating settings configuration for SpriteAtlases.
+/// Shows how to migrate from old configuration patterns to V2.
+/// </summary>
+public static class UpdateSettingsConfigurationDocumentation
+{
+    /// <summary>
+    /// OLD V1 Pattern: Using SetBuildSettings (NO LONGER AVAILABLE)
+    ///
+    /// ❌ OLD CODE:
+    /// var importer = (SpriteAtlasImporter)AssetImporter.GetAtPath(path);
+    /// importer.SetBuildSettings(settings);
+    ///
+    /// ✅ NEW V2 CODE:
+    /// var importer = (SpriteAtlasImporter)AssetImporter.GetAtPath(path);
+    /// importer.packingSettings = settings;
+    /// importer.SaveAndReimport();
+    /// </summary>
+    public static void Update_PackingSettings()
+    {
+        // ===== UPDATING: Packing Settings =====
+
+        string path = "Assets/MyAtlas.spriteatlasv2";
+
+        // ❌ OLD (V1 - Method removed):
+        /*
+        var importer = (SpriteAtlasImporter)AssetImporter.GetAtPath(path);
+        importer.SetBuildSettings(settings); // Compile error!
+        */
+
+        // ✅ NEW (V2):
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+        if (importer != null)
+        {
+            var packingSettings = importer.packingSettings;
+            packingSettings.padding = 2;
+            packingSettings.enableTightPacking = true;
+            packingSettings.enableRotation = true;
+            importer.packingSettings = packingSettings;
+
+            // ✅ CRITICAL: Save and reimport
+            importer.SaveAndReimport();
+        }
+    }
+
+    /// <summary>
+    /// OLD V1 Pattern: Direct texture settings modification (CHANGED)
+    ///
+    /// ❌ OLD CODE:
+    /// var importer = (SpriteAtlasImporter)AssetImporter.GetAtPath(path);
+    /// importer.textureSettings.filterMode = FilterMode.Trilinear;
+    ///
+    /// ✅ NEW V2 CODE:
+    /// Use SetPlatformTextureSettings() for platform-specific settings
+    /// </summary>
+    public static void Update_TextureSettings()
+    {
+        // ===== UPDATING: Texture Settings =====
+
+        string path = "Assets/MyAtlas.spriteatlasv2";
+
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+        if (importer != null)
+        {
+            // ✅ NEW: Use platform-specific texture settings
+            importer.SetPlatformSettings(new TextureImporterPlatformSettings
+            {
+                name = "Standalone",
+                maxTextureSize = 1024,
+                format = TextureImporterFormat.DXT5,
+                compressionQuality = 100
+            });
+
+            // ✅ CRITICAL: Save and reimport
+            importer.SaveAndReimport();
+        }
+    }
+
+    /// <summary>
+    /// OLD V1 Pattern: Platform settings (RESTRUCTURED)
+    ///
+    /// ❌ OLD CODE:
+    /// var importer = (SpriteAtlasImporter)AssetImporter.GetAtPath(path);
+    /// importer.platformSettings.maxTextureSize = 1024;
+    ///
+    /// ✅ NEW V2 CODE:
+    /// Use SetPlatformTextureSettings() for each platform
+    /// </summary>
+    public static void Update_PlatformSettings()
+    {
+        // ===== UPDATING: Platform Settings =====
+
+        string path = "Assets/MyAtlas.spriteatlasv2";
+
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+        if (importer != null)
+        {
+            // ✅ NEW: Set platform-specific settings
+            // Mobile platform (Android/iOS)
+            importer.SetPlatformSettings(new TextureImporterPlatformSettings
+            {
+                name = "Android",
+                maxTextureSize = 1024,
+                format = TextureImporterFormat.ETC2_RGB4,
+                compressionQuality = 100
+            });
+
+            // IOS
+            importer.SetPlatformSettings(new TextureImporterPlatformSettings
+            {
+                name = "iOS",
+                maxTextureSize = 1024,
+                format = TextureImporterFormat.ASTC_6x6,
+                compressionQuality = 100
+            });
+
+            // Desktop platform (Windows/Mac/Linux)
+            importer.SetPlatformSettings(new TextureImporterPlatformSettings
+            {
+                name = "Standalone",
+                maxTextureSize = 1024,
+                format = TextureImporterFormat.DXT5,
+                compressionQuality = 100
+            });
+
+            // ✅ CRITICAL: Save and reimport
+            importer.SaveAndReimport();
+        }
+    }
+}

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

@@ -0,0 +1,179 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEditor;
+using UnityEditor.U2D;
+using UnityEngine;
+using UnityEngine.U2D;
+
+/// <summary>
+/// Demonstrates using SpriteAtlas variants wisely.
+/// Variants allow different atlases for different platforms or resolutions.
+/// </summary>
+public static class UseVariantsWiselyExample
+{
+    /// <summary>
+    /// Creates a variant atlas from a master atlas.
+    /// Variants inherit settings from the master but can override texture formats.
+    /// </summary>
+    public static void CreateVariantAtlas(string masterPath, string variantPath)
+    {
+        // Load the master atlas (runtime type)
+        SpriteAtlas masterAtlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(masterPath);
+
+        if (masterAtlas == null)
+        {
+            Debug.LogError($"Could not load master atlas at {masterPath}");
+            return;
+        }
+
+        // Create variant asset
+        SpriteAtlasAsset variantAsset = new SpriteAtlasAsset();
+        variantAsset.SetMasterAtlas(masterAtlas); // Link to master
+
+        // Add sprites from master (optional - variants can use same packables)
+        Object[] masterPackables = masterAtlas.GetPackables();
+        variantAsset.Add(masterPackables);
+
+        // Save variant
+        SpriteAtlasAsset.Save(variantAsset, variantPath);
+        AssetDatabase.ImportAsset(variantPath);
+
+        Debug.Log($"Created variant atlas at {variantPath}");
+    }
+
+    /// <summary>
+    /// Configures platform-specific variants for different quality levels.
+    /// High-quality variant for desktop, low-quality for mobile.
+    /// </summary>
+    public static void CreateQualityVariants(string masterPath)
+    {
+        // Create high-quality variant
+        string highVariantPath = masterPath.Replace(".spriteatlasv2", "_HQ.spriteatlasv2");
+        ConfigureVariantForPlatform(highVariantPath, "Standalone", 2048, TextureImporterFormat.ASTC_6x6);
+
+        // Create low-quality variant for mobile
+        string lowVariantPath = masterPath.Replace(".spriteatlasv2", "_LQ.spriteatlasv2");
+        ConfigureVariantForPlatform(lowVariantPath, "Android", 1024, TextureImporterFormat.ASTC_6x6);
+    }
+
+    /// <summary>
+    /// Configures a variant for a specific platform with given settings.
+    /// </summary>
+    private static void ConfigureVariantForPlatform(string variantPath, string platformName, int maxTextureSize, TextureImporterFormat format)
+    {
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(variantPath) as SpriteAtlasImporter;
+        if (importer == null)
+            return;
+
+        // Configure platform-specific settings
+        importer.SetPlatformSettings(new TextureImporterPlatformSettings
+        {
+            name = platformName,
+            maxTextureSize = maxTextureSize,
+            format = format,
+            compressionQuality = 50
+        });
+
+        importer.SaveAndReimport();
+    }
+
+    /// <summary>
+    /// Creates resolution variants for different screen sizes.
+    /// Example: 1x, 2x, and 3x variants for different DPI support.
+    /// </summary>
+    public static void CreateResolutionVariants(string masterPath)
+    {
+        // Create 2x variant
+        string x2Path = masterPath.Replace(".spriteatlasv2", "_2x.spriteatlasv2");
+        SpriteAtlasImporter importerX2 = CreateVariantImporter(x2Path);
+        if (importerX2 != null)
+        {
+            importerX2.variantScale = 2.0f;
+            importerX2.SaveAndReimport();
+        }
+
+        // Create 3x variant
+        string x3Path = masterPath.Replace(".spriteatlasv2", "_3x.spriteatlasv2");
+        SpriteAtlasImporter importerX3 = CreateVariantImporter(x3Path);
+        if (importerX3 != null)
+        {
+            importerX3.variantScale = 3.0f;
+            importerX3.SaveAndReimport();
+        }
+    }
+
+    /// <summary>
+    /// Creates a variant importer for a new variant atlas.
+    /// </summary>
+    private static SpriteAtlasImporter CreateVariantImporter(string path)
+    {
+        // Check if file exists
+        if (!System.IO.File.Exists(path))
+        {
+            Debug.LogWarning($"Variant file does not exist: {path}");
+            return null;
+        }
+
+        return AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+    }
+
+    /// <summary>
+    /// Gets the appropriate variant for a given platform.
+    /// Use this at runtime to load the correct variant.
+    /// </summary>
+    public static string GetVariantForPlatform(string masterPath, BuildTarget target)
+    {
+        switch (target)
+        {
+            case BuildTarget.StandaloneWindows:
+            case BuildTarget.StandaloneOSX:
+            case BuildTarget.StandaloneLinux64:
+                // Desktop - use high quality
+                return masterPath.Replace(".spriteatlasv2", "_HQ.spriteatlasv2");
+            case BuildTarget.Android:
+            case BuildTarget.iOS:
+            case BuildTarget.WebGL:
+                // Mobile - use optimized
+                return masterPath.Replace(".spriteatlasv2", "_LQ.spriteatlasv2");
+            default:
+                return masterPath; // Use master for unknown platforms
+        }
+    }
+
+    /// <summary>
+    /// Cleans up unused variant atlases.
+    /// Remove variants that are no longer needed.
+    /// </summary>
+    public static void CleanupUnusedVariants(string folderPath)
+    {
+        string[] guids = AssetDatabase.FindAssets("t:SpriteAtlasAsset", new[] { folderPath });
+
+        foreach (string guid in guids)
+        {
+            string path = AssetDatabase.GUIDToAssetPath(guid);
+
+            // Check if this is a variant (has quality suffix)
+            if (path.Contains("_HQ") || path.Contains("_LQ") || path.Contains("_2x") || path.Contains("_3x"))
+            {
+                Debug.Log($"Checking variant: {path}");
+                // Add cleanup logic here as needed
+            }
+        }
+    }
+}
+
+/// <summary>
+/// Component that loads the appropriate atlas variant at runtime.
+/// </summary>
+public class VariantAtlasLoader : MonoBehaviour
+{
+    [SerializeField] private string _masterAtlasPath = "Atlases/MyAtlas.spriteatlasv2";
+
+    private void Start()
+    {
+        BuildTarget target = EditorUserBuildSettings.activeBuildTarget;
+        string variantPath = UseVariantsWiselyExample.GetVariantForPlatform(_masterAtlasPath, target);
+
+        Debug.Log($"Loading variant for {target}: {variantPath}");
+        // Load the appropriate variant...
+    }
+}