nccgs 2.1.1 → 3.0.0-rc.2

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

@@ -0,0 +1,191 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEditor;
+using UnityEditor.U2D;
+using UnityEngine;
+
+/// <summary>
+/// Demonstrates optimizing texture settings for SpriteAtlases.
+/// Proper texture settings are critical for performance and memory usage.
+/// </summary>
+public static class OptimizeTextureSettingsExample
+{
+    /// <summary>
+    /// Configures optimal texture settings for UI atlases.
+    /// UI sprites typically need high quality and alpha channel.
+    /// </summary>
+    public static void ConfigureUITextureSettings(string atlasPath)
+    {
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(atlasPath) as SpriteAtlasImporter;
+        if (importer == null)
+            return;
+
+        // UI textures need good quality with alpha
+        var textureSettings = importer.textureSettings;
+        textureSettings.filterMode = FilterMode.Bilinear;
+        importer.textureSettings = textureSettings;
+
+        // Set appropriate format for UI (with alpha)
+        var platformSettings = importer.GetPlatformSettings("DefaultTexturePlatform");
+        platformSettings.maxTextureSize = 2048;
+        platformSettings.format = TextureImporterFormat.ASTC_6x6;
+        platformSettings.compressionQuality = 50;
+        importer.SetPlatformSettings(platformSettings);
+
+        importer.SaveAndReimport();
+    }
+
+    /// <summary>
+    /// Configures optimal texture settings for game object atlases.
+    /// Game objects can use lower quality and don't always need alpha.
+    /// </summary>
+    public static void ConfigureGameObjectTextureSettings(string atlasPath)
+    {
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(atlasPath) as SpriteAtlasImporter;
+        if (importer == null)
+            return;
+
+        // Game object textures can use lower quality
+        var textureSettings = importer.textureSettings;
+        textureSettings.filterMode = FilterMode.Trilinear;
+        importer.textureSettings = textureSettings;
+
+        // Use DXT5 for desktop, ASTC for mobile
+        var platformSettings = importer.GetPlatformSettings("DefaultTexturePlatform");
+        platformSettings.maxTextureSize = 1024;
+        platformSettings.format = TextureImporterFormat.DXT5;
+        platformSettings.compressionQuality = 50;
+        importer.SetPlatformSettings(platformSettings);
+
+        importer.SaveAndReimport();
+    }
+
+    /// <summary>
+    /// Configures texture settings for a specific platform.
+    /// </summary>
+    public static void ConfigurePlatformTextureSettings(string atlasPath, string platformName, int maxTextureSize, TextureImporterFormat format)
+    {
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(atlasPath) as SpriteAtlasImporter;
+        if (importer == null)
+            return;
+
+        importer.SetPlatformSettings(new TextureImporterPlatformSettings
+        {
+            name = "DefaultTexturePlatform",
+            maxTextureSize = maxTextureSize,
+            format = format,
+            compressionQuality = 50
+        });
+
+        importer.SaveAndReimport();
+    }
+
+    /// <summary>
+    /// Optimizes texture settings for mobile platforms.
+    /// Focuses on reducing memory usage and improving loading times.
+    /// </summary>
+    public static void OptimizeForMobile(string atlasPath)
+    {
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(atlasPath) as SpriteAtlasImporter;
+        if (importer == null)
+            return;
+
+        // Android settings
+        importer.SetPlatformSettings(new TextureImporterPlatformSettings
+        {
+            name = "Android",
+            maxTextureSize = 1024,
+            format = TextureImporterFormat.ETC2_RGB4,
+            compressionQuality = 100,
+        });
+
+        // iOS settings
+        importer.SetPlatformSettings(new TextureImporterPlatformSettings
+        {
+            name = "iOS",
+            maxTextureSize = 1024,
+            format = TextureImporterFormat.ASTC_6x6,
+            compressionQuality = 100
+        });
+
+        importer.SaveAndReimport();
+    }
+
+    /// <summary>
+    /// Optimizes texture settings for web deployment.
+    /// Focuses on smaller file sizes and faster loading.
+    /// </summary>
+    public static void OptimizeForWeb(string atlasPath)
+    {
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(atlasPath) as SpriteAtlasImporter;
+        if (importer == null)
+            return;
+
+        importer.SetPlatformSettings(new TextureImporterPlatformSettings
+        {
+            name = "WebGL",
+            maxTextureSize = 1024,
+            format = TextureImporterFormat.DXT5Crunched,
+            compressionQuality = 100
+        });
+
+        importer.SaveAndReimport();
+    }
+}
+
+/// <summary>
+/// Editor window for batch optimizing texture settings across multiple atlases.
+/// </summary>
+public class OptimizeTextureSettingsWindow : EditorWindow
+{
+    private string _atlasFolder = "Assets/Atlases";
+    private bool _optimizeForMobile = false;
+    private bool _optimizeForWeb = false;
+
+    [MenuItem("Tools/Optimize Atlas Texture Settings")]
+    public static void ShowWindow()
+    {
+        GetWindow<OptimizeTextureSettingsWindow>("Optimize Atlases");
+    }
+
+    private void OnGUI()
+    {
+        EditorGUILayout.LabelField("Batch Optimize Texture Settings", EditorStyles.boldLabel);
+
+        _atlasFolder = EditorGUILayout.TextField("Atlas Folder", _atlasFolder);
+        _optimizeForMobile = EditorGUILayout.Toggle("Optimize for Mobile", _optimizeForMobile);
+        _optimizeForWeb = EditorGUILayout.Toggle("Optimize for Web", _optimizeForWeb);
+
+        if (GUILayout.Button("Optimize Atlases"))
+        {
+            BatchOptimize();
+        }
+    }
+
+    private void BatchOptimize()
+    {
+        string[] guids = AssetDatabase.FindAssets("t:SpriteAtlasAsset", new[] { _atlasFolder });
+
+        int processed = 0;
+        foreach (string guid in guids)
+        {
+            string path = AssetDatabase.GUIDToAssetPath(guid);
+            SpriteAtlasImporter importer = AssetImporter.GetAtPath(path) as SpriteAtlasImporter;
+
+            if (importer != null)
+            {
+                if (_optimizeForMobile)
+                {
+                    OptimizeTextureSettingsExample.OptimizeForMobile(path);
+                }
+                else if (_optimizeForWeb)
+                {
+                    OptimizeTextureSettingsExample.OptimizeForWeb(path);
+                }
+                processed++;
+            }
+        }
+
+        Debug.Log($"Optimized {processed} atlases");
+        AssetDatabase.Refresh();
+    }
+}

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

@@ -0,0 +1,158 @@
+// [UNITY-SKILL:SPRITEATLAS]
+
+using System.Collections.Generic;
+using UnityEditor.U2D;
+using UnityEngine;
+using Unity.Collections;
+
+/// <summary>
+/// Provides debugging utilities for custom packers.
+/// Includes logging, validation, and diagnostics for packing operations.
+/// </summary>
+public static class PackerDebugging
+{
+    /// <summary>
+    /// Logs detailed information about the packing operation.
+    /// Call this at the start of your Pack method for diagnostics.
+    /// </summary>
+    public static void LogPackingInfo(SpriteAtlasTextureSettings setting, SpriteAtlasPackingSettings config)
+    {
+        Debug.Log($"=== Packer Debug Info ===");
+        Debug.Log($"Atlas max size: {setting.maxTextureSize}");
+        Debug.Log($"Padding: {config.padding}");
+        Debug.Log($"Tight packing: {config.enableTightPacking}");
+        Debug.Log($"Enable rotation: {config.enableRotation}");
+        Debug.Log($"Enable alpha dilation: {config.enableAlphaDilation}");
+    }
+
+    /// <summary>
+    /// Validates all sprite outputs after packing.
+    /// Returns false if any sprite has invalid output data.
+    /// </summary>
+    public static bool ValidateOutputs(ScriptablePacker.PackerData input)
+    {
+        NativeArray<ScriptablePacker.SpriteData> sprites = input.spriteData;
+        bool valid = true;
+
+        for (int i = 0; i < sprites.Length; i++)
+        {
+            ScriptablePacker.SpriteData sprite = sprites[i];
+
+            // Check bounds
+            if (sprite.output.x < 0 || sprite.output.y < 0)
+            {
+                Debug.LogError($"Sprite {i}: Invalid position ({sprite.output.x}, {sprite.output.y})");
+                valid = false;
+            }
+
+            // Check page
+            if (sprite.output.page < 0)
+            {
+                Debug.LogError($"Sprite {i}: Invalid page {sprite.output.page}");
+                valid = false;
+            }
+        }
+
+        return valid;
+    }
+
+    /// <summary>
+    /// Logs statistics about the packing operation.
+    /// </summary>
+    public static void LogPackingStats(ScriptablePacker.PackerData input, int totalPages)
+    {
+        NativeArray<ScriptablePacker.SpriteData> sprites = input.spriteData;
+
+        Debug.Log($"=== Packing Statistics ===");
+        Debug.Log($"Sprites packed: {sprites.Length}");
+        Debug.Log($"Total pages: {totalPages}");
+
+        // Count by page
+        var pageCounts = new System.Collections.Generic.Dictionary<int, int>();
+        foreach (var sprite in sprites)
+        {
+            int page = sprite.output.page;
+            pageCounts[page] = pageCounts.GetValueOrDefault(page) + 1;
+        }
+
+        Debug.Log($"Sprites per page:");
+        foreach (var kvp in pageCounts)
+        {
+            Debug.Log($"  Page {kvp.Key}: {kvp.Value} sprites");
+        }
+    }
+
+    /// <summary>
+    /// Logs sprite data for debugging.
+    /// </summary>
+    public static void LogSpriteData(ScriptablePacker.PackerData input, int spriteIndex)
+    {
+        NativeArray<ScriptablePacker.SpriteData> sprites = input.spriteData;
+        NativeArray<ScriptablePacker.TextureData> textures = input.textureData;
+
+        if (spriteIndex >= sprites.Length)
+            return;
+
+        ScriptablePacker.SpriteData sprite = sprites[spriteIndex];
+        ScriptablePacker.TextureData texture = textures[sprite.texIndex];
+
+        Debug.Log($"=== Sprite {spriteIndex} ===");
+        Debug.Log($"GUID: {sprite.guid}");
+        Debug.Log($"Texture index: {sprite.texIndex}");
+        Debug.Log($"Texture size: {texture.width}x{texture.height}");
+        Debug.Log($"Source rect: {sprite.rect}");
+        Debug.Log($"Output position: ({sprite.output.x}, {sprite.output.y})");
+        Debug.Log($"Output page: {sprite.output.page}");
+        Debug.Log($"Rotation: {sprite.output.rot}");
+    }
+}
+
+/// <summary>
+/// Example packer with built-in debugging.
+/// </summary>
+public class DebuggableSpritePacker : ScriptablePacker
+{
+    public bool enableDebugLogging = false;
+
+    public override bool Pack(SpriteAtlasPackingSettings config,
+                             SpriteAtlasTextureSettings setting,
+                             PackerData input)
+    {
+        if (enableDebugLogging)
+        {
+            PackerDebugging.LogPackingInfo(setting, config);
+            PackerDebugging.LogSpriteData(input, 0); // Log first sprite
+        }
+
+        // Your packing logic here...
+        PackDefault(input);
+
+        if (enableDebugLogging)
+        {
+            bool valid = PackerDebugging.ValidateOutputs(input);
+            PackerDebugging.LogPackingStats(input, 1); // Assuming single page
+
+            if (!valid)
+            {
+                Debug.LogError("Packing validation failed!");
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private void PackDefault(PackerData input)
+    {
+        NativeArray<SpriteData> sprites = input.spriteData;
+        for (int i = 0; i < sprites.Length; i++)
+        {
+            SpriteData sprite = sprites[i];
+            sprite.output.x = i * 100;
+            sprite.output.y = 0;
+            sprite.output.page = 0;
+            sprite.output.rot = PackTransform.None;
+            sprites[i] = sprite;
+        }
+    }
+}

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

@@ -0,0 +1,51 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEngine;
+
+/// <summary>
+/// Sprite transformation options during packing.
+/// These transforms are applied to sprites when packing them into the atlas.
+/// </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
+}
+
+/// <summary>
+/// Extension methods for PackTransform.
+/// </summary>
+public static class PackTransformExtensions
+{
+    /// <summary>
+    /// Gets a human-readable name for the transform.
+    /// </summary>
+    public static string GetName(this PackTransform transform)
+    {
+        return transform.ToString();
+    }
+
+    /// <summary>
+    /// Checks if the transform includes horizontal flipping.
+    /// </summary>
+    public static bool HasHorizontalFlip(this PackTransform transform)
+    {
+        return transform == PackTransform.FlipHorizontal;
+    }
+
+    /// <summary>
+    /// Checks if the transform includes vertical flipping.
+    /// </summary>
+    public static bool HasVerticalFlip(this PackTransform transform)
+    {
+        return transform == PackTransform.FlipVertical;
+    }
+}

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

@@ -0,0 +1,127 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEditor;
+using UnityEditor.U2D;
+using UnityEngine;
+
+/// <summary>
+/// Demonstrates using correct platform names for SpriteAtlas configuration.
+/// Platform names must match Unity's BuildTarget enum values.
+/// </summary>
+public static class PlatformNamesExample
+{
+    /// <summary>
+    /// Gets the correct platform name string for a given BuildTarget.
+    /// </summary>
+    public static string GetPlatformName(BuildTarget target)
+    {
+        switch (target)
+        {
+            case BuildTarget.Android:
+                return "Android";
+            case BuildTarget.iOS:
+                return "iOS";
+            case BuildTarget.StandaloneWindows:
+            case BuildTarget.StandaloneWindows64:
+                return "Standalone";
+            case BuildTarget.StandaloneOSX:
+                return "Standalone";
+            case BuildTarget.StandaloneLinux64:
+                return "Standalone";
+            case BuildTarget.WebGL:
+                return "WebGL";
+            case BuildTarget.WSAPlayer:
+                return "WSA";
+            case BuildTarget.PS4:
+                return "PS4";
+            case BuildTarget.XboxOne:
+                return "XboxOne";
+            case BuildTarget.tvOS:
+                return "tvOS";
+            default:
+                Debug.LogWarning($"Unknown BuildTarget: {target}. Using 'Standalone'.");
+                return "Standalone";
+        }
+    }
+
+    /// <summary>
+    /// Configures platform settings for multiple platforms using correct names.
+    /// </summary>
+    public static void ConfigurePlatformSettings(string atlasPath)
+    {
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath(atlasPath) as SpriteAtlasImporter;
+        if (importer == null)
+            return;
+
+        // 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
+        });
+
+        // WebGL
+        importer.SetPlatformSettings(new TextureImporterPlatformSettings
+        {
+            name = "WebGL",
+            maxTextureSize = 1024,
+            format = TextureImporterFormat.DXT5Crunched,
+            compressionQuality = 100
+        });
+
+        // Save and reimport
+        importer.SaveAndReimport();
+    }
+
+    /// <summary>
+    /// Gets all supported platform names.
+    /// </summary>
+    public static string[] GetAllPlatformNames()
+    {
+        return new string[]
+        {
+            "Android",
+            "iOS",
+            "Standalone",
+            "WebGL",
+            "WSA",
+            "PS4",
+            "XboxOne",
+            "tvOS"
+        };
+    }
+
+    /// <summary>
+    /// Checks if a platform name is valid.
+    /// </summary>
+    public static bool IsValidPlatformName(string platformName)
+    {
+        string[] validPlatforms = GetAllPlatformNames();
+        for (int i = 0; i < validPlatforms.Length; i++)
+        {
+            if (validPlatforms[i] == platformName)
+                return true;
+        }
+        return false;
+    }
+
+}