nccgs 2.1.1 → 3.0.0-rc.2

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

@@ -0,0 +1,164 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEditor;
+using UnityEditor.U2D;
+using UnityEngine;
+
+/// <summary>
+/// Demonstrates setting includeInBuild for SpriteAtlases.
+/// Controls whether atlases are included in the build or loaded externally.
+/// </summary>
+public static class SetIncludeInBuildExample
+{
+    /// <summary>
+    /// Includes an atlas in the build (built-in data).
+    /// Atlases with includeInBuild=true are embedded in the game build.
+    /// </summary>
+    public static void IncludeInBuild(string atlasPath)
+    {
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(atlasPath) as SpriteAtlasImporter;
+        if (importer == null)
+            return;
+
+        importer.includeInBuild = true;
+        importer.SaveAndReimport();
+
+        Debug.Log($"Included {atlasPath} in build");
+    }
+
+    /// <summary>
+    /// Excludes an atlas from the build (for Addressables or AssetBundles).
+    /// Atlases with includeInBuild=false are not embedded and must be loaded separately.
+    /// </summary>
+    public static void ExcludeFromBuild(string atlasPath)
+    {
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(atlasPath) as SpriteAtlasImporter;
+        if (importer == null)
+            return;
+
+        importer.includeInBuild = false;
+        importer.SaveAndReimport();
+
+        Debug.Log($"Excluded {atlasPath} from build");
+    }
+
+    /// <summary>
+    /// Configures all atlases in a folder for built-in delivery.
+    /// Use this when you want all atlases included in the game build.
+    /// </summary>
+    public static void IncludeAllInBuild(string folderPath)
+    {
+        string[] guids = AssetDatabase.FindAssets("t:SpriteAtlasAsset", new[] { folderPath });
+
+        foreach (string guid in guids)
+        {
+            string path = AssetDatabase.GUIDToAssetPath(guid);
+            SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+
+            if (importer != null)
+            {
+                importer.includeInBuild = true;
+                importer.SaveAndReimport();
+            }
+        }
+
+        Debug.Log($"Configured {guids.Length} atlases for built-in delivery");
+    }
+
+    /// <summary>
+    /// Configures all atlases in a folder for Addressables delivery.
+    /// Use this when using Addressables for late-binding atlas loading.
+    /// </summary>
+    public static void ExcludeAllForAddressables(string folderPath)
+    {
+        string[] guids = AssetDatabase.FindAssets("t:SpriteAtlasAsset", new[] { folderPath });
+
+        foreach (string guid in guids)
+        {
+            string path = AssetDatabase.GUIDToAssetPath(guid);
+            SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+
+            if (importer != null)
+            {
+                importer.includeInBuild = false; // Exclude from build for Addressables
+                importer.SaveAndReimport();
+            }
+        }
+
+        Debug.Log($"Configured {guids.Length} atlases for Addressables delivery");
+    }
+
+    /// <summary>
+    /// Checks if an atlas is configured to be included in the build.
+    /// </summary>
+    public static bool IsIncludedInBuild(string atlasPath)
+    {
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(atlasPath) as SpriteAtlasImporter;
+        if (importer == null)
+            return false;
+
+        return importer.includeInBuild;
+    }
+
+    /// <summary>
+    /// Toggles the includeInBuild setting for an atlas.
+    /// </summary>
+    public static void ToggleIncludeInBuild(string atlasPath)
+    {
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(atlasPath) as SpriteAtlasImporter;
+        if (importer == null)
+            return;
+
+        importer.includeInBuild = !importer.includeInBuild;
+        importer.SaveAndReimport();
+
+        Debug.Log($"Set {atlasPath} includeInBuild to {importer.includeInBuild}");
+    }
+}
+
+/// <summary>
+/// Editor window for batch configuring includeInBuild settings.
+/// </summary>
+public class IncludeInBuildWindow : EditorWindow
+{
+    private string _atlasFolder = "Assets/Atlases";
+    private bool _includeInBuild = true;
+
+    [MenuItem("Tools/Configure Include In Build")]
+    public static void ShowWindow()
+    {
+        GetWindow<IncludeInBuildWindow>("Include In Build");
+    }
+
+    private void OnGUI()
+    {
+        EditorGUILayout.LabelField("Batch Configure Include In Build", EditorStyles.boldLabel);
+
+        _atlasFolder = EditorGUILayout.TextField("Atlas Folder", _atlasFolder);
+        _includeInBuild = EditorGUILayout.Toggle("Include in Build", _includeInBuild);
+
+        if (GUILayout.Button("Configure Atlases"))
+        {
+            BatchConfigure();
+        }
+    }
+
+    private void BatchConfigure()
+    {
+        string[] guids = AssetDatabase.FindAssets("t:SpriteAtlasAsset", new[] { _atlasFolder });
+
+        foreach (string guid in guids)
+        {
+            string path = AssetDatabase.GUIDToAssetPath(guid);
+            SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+
+            if (importer != null)
+            {
+                importer.includeInBuild = _includeInBuild;
+                importer.SaveAndReimport();
+            }
+        }
+
+        Debug.Log($"Configured {guids.Length} atlases (includeInBuild={_includeInBuild})");
+        AssetDatabase.Refresh();
+    }
+}

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

@@ -0,0 +1,88 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEditor.U2D;
+using UnityEngine;
+using Unity.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+/// <summary>
+/// Size-optimized sprite packer that places larger sprites first.
+/// Uses a simple bin-packing approach to minimize atlas space usage.
+/// </summary>
+public class SizeOptimizedPacker : ScriptablePacker
+{
+    /// <summary>Maximum atlas size (width and height) in pixels</summary>
+    public int atlasSize = 2048;
+
+    /// <summary>Padding between sprites in pixels</summary>
+    public int padding = 4;
+
+    /// <summary>
+    /// Packs sprites with larger ones first for better space utilization.
+    /// Sorts sprites by area (width * height) and places them using first-fit bin packing.
+    /// </summary>
+    public override bool Pack(SpriteAtlasPackingSettings config,
+                             SpriteAtlasTextureSettings setting,
+                             PackerData input)
+    {
+        NativeArray<SpriteData> sprites = input.spriteData;
+        NativeArray<TextureData> textures = input.textureData;
+
+        // Create sorted list by area (largest first)
+        var sortedIndices = new List<int>();
+        for (int i = 0; i < sprites.Length; i++)
+        {
+            sortedIndices.Add(i);
+        }
+
+        sortedIndices = sortedIndices
+            .OrderByDescending(i =>
+            {
+                var sprite = sprites[i];
+                return sprite.rect.width * sprite.rect.height;
+            })
+            .ToList();
+
+        // Simple bin packing
+        int currentX = padding;
+        int currentY = padding;
+        int maxHeightInRow = 0;
+
+        foreach (int idx in sortedIndices)
+        {
+            SpriteData sprite = sprites[idx];
+
+            int spriteWidth = sprite.rect.width;
+            int spriteHeight = sprite.rect.height;
+
+            // Check if we need a new row
+            if (currentX + spriteWidth + padding > atlasSize)
+            {
+                currentX = padding;
+                currentY += maxHeightInRow + padding;
+                maxHeightInRow = 0;
+            }
+
+            // Check if atlas is full
+            if (currentY + spriteHeight + padding > atlasSize)
+            {
+                Debug.LogError("Atlas size exceeded. Increase atlas size or reduce sprite count.");
+                return false;
+            }
+
+            // Set output
+            sprite.output.x = currentX;
+            sprite.output.y = currentY;
+            sprite.output.page = 0;
+            sprite.output.rot = PackTransform.None;
+
+            // Update position for next sprite
+            currentX += spriteWidth + padding;
+            maxHeightInRow = Mathf.Max(maxHeightInRow, spriteHeight);
+
+            sprites[idx] = sprite;
+        }
+
+        return true;
+    }
+}

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

@@ -0,0 +1,123 @@
+// [UNITY-SKILL:SPRITEATLAS]
+// [TYPE:RUNTIME-LOADER]
+// Generated by SpriteAtlas Skill
+// This script handles late-binding atlas loading via Addressables
+
+using UnityEngine;
+using UnityEngine.U2D;
+using System.Collections.Generic;
+
+#if UNITY_ADDRESSABLES
+using UnityEngine.AddressableAssets;
+using UnityEngine.ResourceManagement.AsyncOperations;
+#endif
+
+/// <summary>
+/// Late-binding loader for SpriteAtlas via Addressables
+/// Automatically loads atlases on-demand when sprites are requested
+/// </summary>
+public class SpriteAtlasLateBinding : MonoBehaviour
+{
+    private static SpriteAtlasLateBinding instance;
+
+#if UNITY_ADDRESSABLES
+    private Dictionary<string, AsyncOperationHandle<SpriteAtlas>> loadedAtlases = new Dictionary<string, AsyncOperationHandle<SpriteAtlas>>();
+#endif
+
+    void Awake()
+    {
+        if (instance != null && instance != this)
+        {
+            Destroy(gameObject);
+            return;
+        }
+
+        instance = this;
+        DontDestroyOnLoad(gameObject);
+
+        // Register late-binding callback
+        SpriteAtlasManager.atlasRequested += OnAtlasRequested;
+        SpriteAtlasManager.atlasRegistered += OnAtlasRegistered;
+    }
+
+    void OnDestroy()
+    {
+        SpriteAtlasManager.atlasRequested -= OnAtlasRequested;
+        SpriteAtlasManager.atlasRegistered -= OnAtlasRegistered;
+
+#if UNITY_ADDRESSABLES
+        // Release all loaded atlases
+        foreach (var handle in loadedAtlases.Values)
+        {
+            if (handle.IsValid())
+            {
+                Addressables.Release(handle);
+            }
+        }
+        loadedAtlases.Clear();
+#endif
+    }
+
+    private void OnAtlasRequested(string tag, System.Action<SpriteAtlas> callback)
+    {
+#if UNITY_ADDRESSABLES
+        // Check if already loaded
+        if (loadedAtlases.ContainsKey(tag))
+        {
+            var handle = loadedAtlases[tag];
+            if (handle.IsDone && handle.Status == AsyncOperationStatus.Succeeded)
+            {
+                callback(handle.Result);
+                return;
+            }
+        }
+
+        // Load atlas asynchronously
+        Debug.Log($"[SpriteAtlas] Loading atlas via Addressables: {tag}");
+        var loadHandle = Addressables.LoadAssetAsync<SpriteAtlas>(tag);
+        loadedAtlases[tag] = loadHandle;
+
+        loadHandle.Completed += (handle) =>
+        {
+            if (handle.Status == AsyncOperationStatus.Succeeded)
+            {
+                Debug.Log($"[SpriteAtlas] Successfully loaded atlas: {tag} with {handle.Result.spriteCount} sprites");
+                callback(handle.Result);
+            }
+            else
+            {
+                Debug.LogError($"[SpriteAtlas] Failed to load atlas: {tag}");
+            }
+        };
+#else
+        Debug.LogError($"[SpriteAtlas] Addressables package not installed. Cannot load atlas: {tag}");
+        callback(null);
+#endif
+    }
+
+    private void OnAtlasRegistered(SpriteAtlas atlas)
+    {
+        Debug.Log($"[SpriteAtlas] Atlas registered: {atlas.name}");
+    }
+
+    /// <summary>
+    /// Manually preload an atlas (optional)
+    /// </summary>
+    public static void PreloadAtlas(string atlasName)
+    {
+#if UNITY_ADDRESSABLES
+        if (instance == null)
+        {
+            Debug.LogError("[SpriteAtlas] SpriteAtlasLateBinding instance not found. Add to scene.");
+            return;
+        }
+
+        if (!instance.loadedAtlases.ContainsKey(atlasName))
+        {
+            var handle = Addressables.LoadAssetAsync<SpriteAtlas>(atlasName);
+            instance.loadedAtlases[atlasName] = handle;
+            Debug.Log($"[SpriteAtlas] Preloading atlas: {atlasName}");
+        }
+#endif
+    }
+}

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

@@ -0,0 +1,219 @@
+// [UNITY-SKILL:SPRITEATLAS]
+// [TYPE:PREBUILD]
+// Generated by SpriteAtlas V2 Skill
+// This script automatically generates SpriteAtlas assets during prebuild
+
+using UnityEditor;
+using UnityEditor.Build;
+using UnityEditor.Build.Reporting;
+using UnityEditor.U2D;
+using UnityEngine;
+using UnityEngine.U2D;
+using System.Linq;
+using System.Collections.Generic;
+
+#if UNITY_ADDRESSABLES
+using UnityEditor.AddressableAssets;
+using UnityEditor.AddressableAssets.Settings;
+#endif
+
+public class SpriteAtlasPrebuildGenerator : IPreprocessBuildWithReport
+{
+    public int callbackOrder => 0;
+
+    private List<string> generatedAtlasPaths = new List<string>();
+
+    public void OnPreprocessBuild(BuildReport report)
+    {
+        Debug.Log("[SpriteAtlas] Generating atlases for late-binding via Addressables...");
+
+        // CRITICAL: Enable Sprite Packer mode
+        EditorSettings.spritePackerMode = SpritePackerMode.SpriteAtlasV2;
+
+        generatedAtlasPaths.Clear();
+
+        // Customize these paths - includeInBuild is FALSE for Addressables
+        GenerateAtlasByFolder("Assets/Art/UI", "Assets/Atlases/UI_Atlas.spriteatlasv2", includeInBuild: false);
+        GenerateAtlasByFolder("Assets/Art/Characters", "Assets/Atlases/Characters_Atlas.spriteatlasv2", includeInBuild: false);
+        GenerateAtlasByNaming("Assets/Art/Items", "item_", "Assets/Atlases/Items_Atlas.spriteatlasv2", includeInBuild: false);
+
+        AssetDatabase.SaveAssets();
+        AssetDatabase.Refresh();
+
+        // Setup Addressables for all generated atlases
+        SetupAddressables();
+    }
+
+    private void SetupAddressables()
+    {
+#if UNITY_ADDRESSABLES
+        var settings = AddressableAssetSettingsDefaultObject.Settings;
+        if (settings == null)
+        {
+            Debug.LogError("[SpriteAtlas] Addressables is not initialized. Please install and setup Addressables package.");
+            return;
+        }
+
+        var group = settings.DefaultGroup;
+        if (group == null)
+        {
+            Debug.LogError("[SpriteAtlas] Default Addressables group not found.");
+            return;
+        }
+
+        foreach (var atlasPath in generatedAtlasPaths)
+        {
+            var guid = AssetDatabase.AssetPathToGUID(atlasPath);
+            if (string.IsNullOrEmpty(guid))
+            {
+                Debug.LogWarning($"[SpriteAtlas] Could not find GUID for {atlasPath}");
+                continue;
+            }
+
+            // Check if already exists
+            var existingEntry = settings.FindAssetEntry(guid);
+            if (existingEntry != null)
+            {
+                Debug.Log($"[SpriteAtlas] Atlas already addressable: {atlasPath}");
+                continue;
+            }
+
+            // Create addressable entry
+            var entry = settings.CreateOrMoveEntry(guid, group, false, false);
+            var atlasName = System.IO.Path.GetFileNameWithoutExtension(atlasPath);
+            entry.address = atlasName; // Use atlas name as address
+
+            Debug.Log($"[SpriteAtlas] Added to Addressables: {atlasName} at {atlasPath}");
+        }
+
+        settings.SetDirty(AddressableAssetSettings.ModificationEvent.EntryAdded, null, true);
+#else
+        Debug.LogError("[SpriteAtlas] Addressables package is not installed. Please install 'com.unity.addressables' package.");
+#endif
+    }
+
+    // CRITICAL: Validate sprite is from project Assets folder only
+    private bool IsValidProjectSprite(string assetPath)
+    {
+        return assetPath.StartsWith("Assets/") &&
+               !assetPath.Contains("/Packages/");
+    }
+
+    private void GenerateAtlasByFolder(string spriteFolder, string atlasPath, bool includeInBuild)
+    {
+        // Find all sprites in folder - with path validation
+        string[] guids = AssetDatabase.FindAssets("t:Sprite", new[] { spriteFolder });
+        Object[] sprites = guids
+            .Select(g => AssetDatabase.GUIDToAssetPath(g))
+            .Where(path => IsValidProjectSprite(path))
+            .Select(path => AssetDatabase.LoadAssetAtPath<Sprite>(path))
+            .Where(s => s != null)
+            .Cast<Object>()
+            .ToArray();
+
+        if (sprites.Length == 0)
+        {
+            Debug.LogWarning($"[SpriteAtlas] No sprites found in {spriteFolder}");
+            return;
+        }
+
+        // Create or load existing atlas
+        SpriteAtlasAsset atlasAsset;
+        if (System.IO.File.Exists(atlasPath))
+        {
+            atlasAsset = SpriteAtlasAsset.Load(atlasPath);
+            var spriteAtlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(atlasPath);
+            atlasAsset.Remove(spriteAtlas.GetPackables()); // Clear existing
+        }
+        else
+        {
+            atlasAsset = new SpriteAtlasAsset();
+            System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(atlasPath));
+        }
+
+        // Add sprites and save
+        atlasAsset.Add(sprites);
+        SpriteAtlasAsset.Save(atlasAsset, atlasPath);
+        AssetDatabase.ImportAsset(atlasPath);
+
+        // Configure via importer
+        ConfigureAtlasImporter(atlasPath, includeInBuild);
+
+        // Track for Addressables setup
+        generatedAtlasPaths.Add(atlasPath);
+
+        Debug.Log($"[SpriteAtlas] Generated {atlasPath} with {sprites.Length} sprites (includeInBuild={includeInBuild})");
+    }
+
+    private void GenerateAtlasByNaming(string searchFolder, string namePrefix, string atlasPath, bool includeInBuild)
+    {
+        // Find sprites matching naming convention - with path validation
+        string[] guids = AssetDatabase.FindAssets("t:Sprite", new[] { searchFolder });
+        Object[] sprites = guids
+            .Select(g => AssetDatabase.GUIDToAssetPath(g))
+            .Where(path => IsValidProjectSprite(path))
+            .Select(path => AssetDatabase.LoadAssetAtPath<Sprite>(path))
+            .Where(s => s != null && s.name.StartsWith(namePrefix))
+            .Cast<Object>()
+            .ToArray();
+
+        if (sprites.Length == 0) return;
+
+        // Create or update atlas (same pattern as folder-based)
+        SpriteAtlasAsset atlasAsset = System.IO.File.Exists(atlasPath)
+            ? SpriteAtlasAsset.Load(atlasPath)
+            : new SpriteAtlasAsset();
+
+        if (System.IO.File.Exists(atlasPath))
+        {
+            var spriteAtlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>(atlasPath);
+            atlasAsset.Remove(spriteAtlas.GetPackables());
+        }
+
+        atlasAsset.Add(sprites);
+        SpriteAtlasAsset.Save(atlasAsset, atlasPath);
+        AssetDatabase.ImportAsset(atlasPath);
+        ConfigureAtlasImporter(atlasPath, includeInBuild);
+
+        // Track for Addressables setup
+        generatedAtlasPaths.Add(atlasPath);
+    }
+
+    private void ConfigureAtlasImporter(string atlasPath, bool includeInBuild)
+    {
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(atlasPath) as SpriteAtlasImporter;
+        if (importer == null) return;
+
+        // Texture settings
+        var textureSettings = importer.textureSettings;
+        textureSettings.filterMode = FilterMode.Bilinear;
+        textureSettings.generateMipMaps = false;
+        importer.textureSettings = textureSettings;
+
+        // Packing settings
+        var packingSettings = importer.packingSettings;
+        packingSettings.padding = 4;
+        packingSettings.enableAlphaDilation = true;
+        importer.packingSettings = packingSettings;
+
+        // Platform settings
+        SetPlatformSettings(importer, "Android", TextureImporterFormat.ASTC_6x6);
+        SetPlatformSettings(importer, "iOS", TextureImporterFormat.ASTC_4x4);
+
+        // Set build inclusion based on delivery mechanism
+        importer.includeInBuild = includeInBuild;
+        importer.SaveAndReimport();
+    }
+
+    private void SetPlatformSettings(SpriteAtlasImporter importer, string platformName, TextureImporterFormat format)
+    {
+        var settings = new TextureImporterPlatformSettings
+        {
+            name = platformName,
+            overridden = true,
+            maxTextureSize = 2048,
+            format = format
+        };
+        importer.SetPlatformSettings(settings);
+    }
+}

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

@@ -0,0 +1,35 @@
+// [UNITY-SKILL:SPRITEATLAS]
+
+using UnityEditor.U2D;
+using UnityEngine;
+
+/// <summary>
+/// Information about each sprite in the packing process.
+/// This structure is populated by Unity and used by custom packers.
+/// </summary>
+public struct SpriteData
+{
+    /// <summary>Unique identifier for the sprite asset</summary>
+    public GUID guid;
+
+    /// <summary>Index into the textureData array</summary>
+    public int texIndex;
+
+    /// <summary>Source rectangle in the source texture</summary>
+    public RectInt rect;
+
+    /// <summary>Number of mesh indices for this sprite</summary>
+    public int indexCount;
+
+    /// <summary>Number of mesh vertices for this sprite</summary>
+    public int vertexCount;
+
+    /// <summary>Offset into the indexData array</summary>
+    public int indexOffset;
+
+    /// <summary>Offset into the vertexData array</summary>
+    public int vertexOffset;
+
+    /// <summary>OUTPUT: Set this to specify packing result</summary>
+    public ScriptablePacker.SpritePack output;
+}

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

@@ -0,0 +1,39 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEngine;
+
+/// <summary>
+/// Output structure for sprite packing.
+/// Set this on each SpriteData to specify where and how the sprite should be packed.
+/// </summary>
+public struct SpritePack
+{
+    /// <summary>X position in the atlas (OUTPUT)</summary>
+    public int x;
+
+    /// <summary>Y position in the atlas (OUTPUT)</summary>
+    public int y;
+
+    /// <summary>Atlas page index for multi-page atlases (OUTPUT)</summary>
+    public int page;
+
+    /// <summary>Rotation/flip transform to apply (OUTPUT)</summary>
+    public PackTransform rot;
+}
+
+/// <summary>
+/// Sprite transformation options during packing.
+/// </summary>
+public enum PackTransform
+{
+    /// <summary>No transformation applied</summary>
+    None,
+
+    /// <summary>Flip horizontally</summary>
+    FlipHorizontal,
+
+    /// <summary>Flip vertically</summary>
+    FlipVertical,
+
+    /// <summary>Rotate 180 degrees</summary>
+    Rotate180
+}

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

@@ -0,0 +1,15 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEngine;
+
+/// <summary>
+/// Source texture information provided to custom packers.
+/// Contains dimensions and metadata about source textures.
+/// </summary>
+public struct TextureData
+{
+    /// <summary>Texture width in pixels</summary>
+    public int width;
+
+    /// <summary>Texture height in pixels</summary>
+    public int height;
+}