@aqian0/dsh-unity 0.0.0-stage → 0.1.0

package/skills/sprite-editor/scripts/GenerateNewSpriteRects.cs

@@ -0,0 +1,200 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.U2D.Sprites;
+using UnityEngine;
+
+namespace Editor
+{
+    static public partial class SpriteEditorUtility
+    {
+        public enum AddNewSpriteMethod
+        {
+            DeleteAll,  // Remove all existing sprites and create new ones
+            Smart,      // Update overlapping sprites, add non-overlapping ones
+            Safe        // Only add sprites that don't overlap with existing ones
+        }
+
+        /// <summary>
+        /// Generates new sprite rectangles from a collection of rects, handling existing sprites based on the specified method.
+        /// Automatically assigns unique names using the provided name generator function.
+        /// </summary>
+        /// <param name="spriteDataProvider">The sprite data provider containing existing sprites.</param>
+        /// <param name="rects">Collection of rectangles to create sprites from.</param>
+        /// <param name="addNewSpriteMethod">Strategy for handling existing sprites.</param>
+        /// <param name="nameGenerator">Function that takes an index and returns a sprite name.</param>
+        /// <param name="kOverlapTolerance">Minimum overlap area ratio to consider sprites overlapping.</param>
+        /// <param name="kBestFitTolerance">Maximum overlap ratio difference for best-fit matching.</param>
+        /// <param name="bestFit">If true, finds the best matching existing sprite; if false, uses first match.</param>
+        /// <returns>List of sprite rectangles ready to be set on the data provider.</returns>
+        public static List<SpriteRect> GenerateNewSpriteRects(ISpriteEditorDataProvider spriteDataProvider, IEnumerable<Rect> rects, AddNewSpriteMethod addNewSpriteMethod, Func<int, string> nameGenerator,
+            float kOverlapTolerance= 0.00001f, float kBestFitTolerance = 0.5f, bool bestFit = false)
+        {
+            const int k_NameFindBreakLimit = 1000000;
+            var existingSpriteRects = spriteDataProvider.GetSpriteRects();
+            List<SpriteRect> newRects = new List<SpriteRect>();
+            HashSet<string> existingNames = new HashSet<string>();
+
+            Func<Rect, SpriteRect> newRectLambda = (frame) =>
+            {
+                int nameIndex = existingNames.Count;
+                var spriteName = "";
+                while (nameIndex < k_NameFindBreakLimit)
+                {
+                    spriteName = nameGenerator(nameIndex++);
+                    if (!existingNames.Contains(spriteName))
+                        break;
+                }
+
+                if(nameIndex >= k_NameFindBreakLimit)
+                {
+                    Debug.LogError("Failed to generate unique sprite name for automatic slicing. Please check the name generator function.");
+                    return null;
+                }
+
+                existingNames.Add(spriteName);
+                return new SpriteRect()
+                {
+                    name = spriteName,
+                    alignment = SpriteAlignment.Center,
+                    rect = frame,
+                };
+            };
+
+            Action<Rect> deleteAllSliceMethodLambda = (frame) =>
+            {
+                var newRect = newRectLambda(frame);
+                if (newRect != null)
+                {
+                    newRects.Add(newRect);
+                }
+            };
+
+            Action<Rect> smartSliceMethodLambda = (frame) =>
+            {
+                var outSprite = GetExistingOverlappingSprite(spriteDataProvider, frame, kOverlapTolerance, kBestFitTolerance, bestFit);
+                if (outSprite != -1)
+                {
+                    var existingRect = existingSpriteRects[outSprite];
+                    existingRect.rect = frame;
+                    if (existingNames.Contains(existingRect.name))
+                    {
+                        // Handle name conflict by renaming the previous sprite
+                        var conflictRect = newRects.FindIndex(x => x.name == existingRect.name);
+                        if (conflictRect != -1)
+                        {
+                            int nameIndex = existingNames.Count;
+                            var spriteName = "";
+                            while (nameIndex < k_NameFindBreakLimit)
+                            {
+                                spriteName = nameGenerator(nameIndex++);
+                                if (!existingNames.Contains(spriteName))
+                                    break;
+                            }
+                            if(nameIndex >= k_NameFindBreakLimit)
+                            {
+                                Debug.LogError("Failed to generate unique sprite name for automatic slicing. Removing conflicting sprite.");
+                                newRects.RemoveAt(conflictRect);
+                            }
+                            else
+                                newRects[conflictRect].name = spriteName;
+                        }
+                    }
+                    else
+                        existingNames.Add(existingRect.name);
+                    newRects.Add(existingRect);
+                }
+                else
+                {
+                    var newRect = newRectLambda(frame);
+                    if (newRect != null)
+                    {
+                        newRects.Add(newRect);
+                    }
+                }
+            };
+
+            Action<Rect> safeSliceMethodLambda = (frame) =>
+            {
+                var outSprite = GetExistingOverlappingSprite(spriteDataProvider, frame, kOverlapTolerance, kBestFitTolerance, bestFit);
+                if (outSprite == -1)
+                {
+                    var newRect = newRectLambda(frame);
+                    if (newRect != null)
+                    {
+                        newRects.Add(newRect);
+                    }
+                }
+            };
+
+            Action<Rect> sliceMethodLambda = safeSliceMethodLambda;
+            switch (addNewSpriteMethod)
+            {
+                case AddNewSpriteMethod.DeleteAll:
+                    sliceMethodLambda = deleteAllSliceMethodLambda;
+                    break;
+                case AddNewSpriteMethod.Smart:
+                    sliceMethodLambda = smartSliceMethodLambda;
+                    break;
+                case AddNewSpriteMethod.Safe:
+                    // Preserve all existing sprites
+                    foreach(var existingRect in existingSpriteRects)
+                    {
+                        existingNames.Add(existingRect.name);
+                    }
+                    newRects.AddRange(existingSpriteRects);
+                    break;
+            }
+
+            foreach (var frame in rects)
+            {
+                sliceMethodLambda(frame);
+            }
+
+            return newRects;
+        }
+
+        private static int GetExistingOverlappingSprite(ISpriteEditorDataProvider dataProvider, Rect rect, float kOverlapTolerance= 0.00001f, float kBestFitTolerance = 0.5f, bool bestFit = false)
+        {
+            var spriteRects = dataProvider.GetSpriteRects();
+            var count = spriteRects.Length;
+            var bestRect = -1;
+            var rectArea = rect.width * rect.height;
+            if (rectArea < kOverlapTolerance)
+                return bestRect;
+
+            var bestRatio = float.MaxValue;
+            var bestArea = float.MaxValue;
+            for (int i = 0; i < count; i++)
+            {
+                Rect existingRect = spriteRects[i].rect;
+                if (existingRect.Overlaps(rect))
+                {
+                    if (bestFit)
+                    {
+                        var dx = Math.Min(rect.xMax, existingRect.xMax) - Math.Max(rect.xMin, existingRect.xMin);
+                        var dy = Math.Min(rect.yMax, existingRect.yMax) - Math.Max(rect.yMin, existingRect.yMin);
+                        var overlapArea = dx * dy;
+                        var overlapRatio = Math.Abs((overlapArea / rectArea) - 1.0f);
+                        var existingArea = existingRect.width * existingRect.height;
+                        if (overlapRatio < bestRatio || (overlapRatio < kOverlapTolerance && existingArea < bestArea))
+                        {
+                            bestRatio = overlapRatio;
+                            if (overlapRatio < kOverlapTolerance)
+                                bestArea = existingArea;
+                            bestRect = i;
+                        }
+                    }
+                    else
+                    {
+                        bestRect = i;
+                        break;
+                    }
+                }
+            }
+            if (bestFit && bestRatio > kBestFitTolerance)
+                return -1;
+            return bestRect;
+        }
+    }
+}

package/skills/sprite-editor/scripts/GetTextureSourceImageSize.cs

@@ -0,0 +1,32 @@
+using UnityEditor;
+using UnityEditor.U2D.Sprites;
+using UnityEngine;
+
+namespace Editor
+{
+    static public partial class SpriteEditorUtility
+    {
+        /// <summary>
+        /// Get the original source image size of a texture, which is different from the texture size when the texture is imported with "Max Size" smaller than the original image size.
+        /// This method will try to get the original source image size from TextureImporter, if it fails, it will return the texture size as fallback.
+        /// </summary>
+        /// <param name="texture"></param>
+        /// <param name="width"></param>
+        /// <param name="height"></param>
+        static public void GetTextureSourceImageSize(Texture2D texture, out int width, out int height)
+        {
+            SpriteDataProviderFactories factories = new SpriteDataProviderFactories();
+            factories.Init();
+            var dataProvider = factories.GetSpriteEditorDataProviderFromObject(texture);
+            var textureDataProvider = dataProvider?.GetDataProvider<ITextureDataProvider>();
+            if(textureDataProvider != null)
+            {
+                textureDataProvider.GetTextureActualWidthAndHeight(out width, out height);
+                return;
+            }
+
+            width = texture.width;
+            height = texture.height;
+        }
+    }
+}

package/skills/sprite-editor/scripts/GetTextureToSlice.cs

@@ -0,0 +1,55 @@
+using UnityEditor;
+using UnityEditor.U2D.Sprites;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering;
+
+namespace Editor
+{
+    static public partial class SpriteEditorUtility
+    {
+        /// <summary>
+        /// Gets a readable texture for slicing operations, upscaling if necessary to match original dimensions.
+        /// This ensures slicing is performed on the original image size, not the imported texture size.
+        /// </summary>
+        /// <param name="textureDataProvider">The texture data provider.</param>
+        /// <returns>A readable Texture2D at original dimensions, or null if texture is not readable.</returns>
+        static public Texture2D GetTextureToSlice(ITextureDataProvider textureDataProvider)
+        {
+            textureDataProvider.GetTextureActualWidthAndHeight(out var width, out var height);
+            var readableTexture = textureDataProvider.GetReadableTexture2D();
+            if (readableTexture == null || (readableTexture.width == width && readableTexture.height == height))
+                return readableTexture;
+
+            // Upscale the imported texture to match original dimensions for accurate slicing
+            var texture = CreateTemporaryDuplicate(readableTexture, width, height);
+            texture.hideFlags = HideFlags.HideAndDontSave;
+
+            return texture;
+        }
+
+        /// <summary>
+        /// Creates a temporary duplicate of a texture at a specified size using RenderTexture.
+        /// Used internally to upscale textures for slicing operations.
+        /// </summary>
+        public static Texture2D CreateTemporaryDuplicate(Texture2D original, int width, int height)
+        {
+            if (!ShaderUtil.hardwareSupportsRectRenderTexture || !(bool) (Object) original)
+                return null;
+
+            RenderTexture active = RenderTexture.active;
+            RenderTexture temporary = RenderTexture.GetTemporary(width, height, 0, SystemInfo.GetGraphicsFormat(DefaultFormat.LDR));
+            Graphics.Blit(original, temporary);
+            RenderTexture.active = temporary;
+
+            bool flag = width >= SystemInfo.maxTextureSize || height >= SystemInfo.maxTextureSize;
+            Texture2D temporaryDuplicate = new Texture2D(width, height, TextureFormat.RGBA32, original.mipmapCount > 1 | flag);
+            temporaryDuplicate.ReadPixels(new Rect(0.0f, 0.0f, width, height), 0, 0);
+            temporaryDuplicate.Apply();
+
+            RenderTexture.ReleaseTemporary(temporary);
+            temporaryDuplicate.alphaIsTransparency = original.alphaIsTransparency;
+
+            return temporaryDuplicate;
+        }
+    }
+}

package/skills/sprite-editor/scripts/GridSliceTexture.cs

@@ -0,0 +1,40 @@
+using System;
+using UnityEngine;
+using UnityEditor.U2D.Sprites;
+
+namespace Editor
+{
+    static public partial class SpriteEditorUtility
+    {
+        /// <summary>
+        /// Slices a texture into a regular grid of sprite rectangles based on specified cell size, offset, and padding.
+        /// Optionally keeps or discards empty rectangles based on pixel alpha values.
+        /// </summary>
+        /// <param name="spriteDataProvider">The sprite data provider for the texture.</param>
+        /// <param name="textureProvider">The texture data provider.</param>
+        /// <param name="offset">The offset from the top-left corner to start the grid.</param>
+        /// <param name="size">The size of each grid cell (width x height).</param>
+        /// <param name="padding">The padding between grid cells.</param>
+        /// <param name="addNewSpriteMethod">Method for handling existing sprites (DeleteAll, Smart, Safe).</param>
+        /// <param name="nameGenerator">Function to generate sprite names based on index.</param>
+        /// <param name="keepEmptyRects">Whether to keep sprites with no visible pixels.</param>
+        /// <param name="kOverlapTolerance">Tolerance for detecting overlapping sprites.</param>
+        /// <param name="kBestFitTolerance">Tolerance for best-fit matching.</param>
+        /// <param name="bestFit">Whether to use best-fit algorithm for overlap detection.</param>
+        /// <returns>True if slicing succeeded, false if texture is not readable.</returns>
+        static public bool GridSliceTexture(ISpriteEditorDataProvider spriteDataProvider, ITextureDataProvider textureProvider, Vector2 offset, Vector2 size, Vector2 padding,
+            AddNewSpriteMethod addNewSpriteMethod, Func<int, string> nameGenerator,
+            bool keepEmptyRects =false, float kOverlapTolerance= 0.00001f, float kBestFitTolerance = 0.5f, bool bestFit = false)
+        {
+            var textureToUse = GetTextureToSlice(textureProvider);
+            if (textureToUse == null)
+            {
+                return false;
+            }
+            var rects = UnityEditorInternal.InternalSpriteUtility.GenerateGridSpriteRectangles(textureToUse, offset, size, padding, keepEmptyRects);
+            var newRects = GenerateNewSpriteRects(spriteDataProvider, rects, addNewSpriteMethod, nameGenerator, kOverlapTolerance, kBestFitTolerance, bestFit);
+            spriteDataProvider.SetSpriteRects(newRects.ToArray());
+            return true;
+        }
+    }
+}

package/skills/sprite-editor/scripts/IsometricSliceTexture.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor.U2D.Sprites;
+using UnityEngine;
+
+namespace Editor
+{
+    static public class IsometricSliceUtility
+    {
+        /// <summary>
+        /// Slices a texture into isometric tiles based on specified size and offset.
+        /// Creates sprite rectangles in an isometric diamond pattern and optionally sets diamond-shaped outlines.
+        /// </summary>
+        /// <param name="spriteDataProvider">The sprite data provider for the texture.</param>
+        /// <param name="textureProvider">The texture data provider.</param>
+        /// <param name="size">The size of each isometric tile (width x height).</param>
+        /// <param name="offset">The offset from the top-left corner to start slicing.</param>
+        /// <param name="alignment">The alignment value for sprites.</param>
+        /// <param name="pivot">The pivot point for sprites.</param>
+        /// <param name="slicingMethod">Method for handling existing sprites (DeleteAll, Smart, Safe).</param>
+        /// <param name="nameGenerator">Function to generate sprite names based on index.</param>
+        /// <param name="kOverlapTolerance">Tolerance for detecting overlapping sprites.</param>
+        /// <param name="kBestFitTolerance">Tolerance for best-fit matching.</param>
+        /// <param name="bestFit">Whether to use best-fit algorithm for overlap detection.</param>
+        /// <param name="keepEmptyRects">Whether to keep sprites with no visible pixels.</param>
+        /// <param name="isAlternate">Whether to start with alternating row offset.</param>
+        /// <returns>True if slicing succeeded, false if texture is not readable.</returns>
+        static public bool IsometricSliceTexture(ISpriteEditorDataProvider spriteDataProvider, ITextureDataProvider textureProvider,
+            Vector2 size, Vector2 offset, int alignment, Vector2 pivot, SpriteEditorUtility.AddNewSpriteMethod slicingMethod, Func<int, string> nameGenerator,
+            float kOverlapTolerance = 0.00001f, float kBestFitTolerance = 0.5f, bool bestFit = false, bool keepEmptyRects = false, bool isAlternate = false)
+        {
+            var texture = SpriteEditorUtility.GetTextureToSlice(textureProvider);
+            if (texture == null)
+            {
+                return false;
+            }
+            var rects = GetIsometricRects(texture, size, offset, isAlternate, keepEmptyRects);
+            var newRects = SpriteEditorUtility.GenerateNewSpriteRects(spriteDataProvider, rects, slicingMethod, nameGenerator, kOverlapTolerance, kBestFitTolerance, bestFit);
+            spriteDataProvider.SetSpriteRects(newRects.ToArray());
+
+            // Set diamond-shaped outlines for isometric sprites
+            var outlineDataProvider = spriteDataProvider.GetDataProvider<ISpriteOutlineDataProvider>();
+            if (outlineDataProvider != null)
+            {
+                List<Vector2[]> outlines = new List<Vector2[]>(4);
+                outlines.Add(new[] {
+                    new Vector2(0.0f, -size.y / 2),
+                    new Vector2(size.x / 2, 0.0f),
+                    new Vector2(0.0f, size.y / 2),
+                    new Vector2(-size.x / 2, 0.0f)
+                });
+                foreach (var rect in newRects)
+                {
+                    outlineDataProvider.SetOutlines(rect.spriteID, outlines);
+                }
+            }
+
+            return true;
+        }
+
+        private static bool PixelHasAlpha(int x, int y, int width, bool[] alphaPixelCache)
+        {
+            var index = y * width + x;
+            return alphaPixelCache[index];
+        }
+
+        /// <summary>
+        /// Generates rectangles for isometric tile slicing by walking the texture in an isometric pattern.
+        /// Optionally filters out empty rectangles based on alpha pixel density.
+        /// </summary>
+        public static IEnumerable<Rect> GetIsometricRects(Texture2D textureToUse, Vector2 size, Vector2 offset, bool isAlternate, bool keepEmptyRects)
+        {
+            var alphaPixelCache = new bool[textureToUse.width * textureToUse.height];
+            Color32[] pixels = textureToUse.GetPixels32();
+            for (int i = 0; i < pixels.Length; i++)
+                alphaPixelCache[i] = pixels[i].a != 0;
+
+            var gradient = (size.x / 2) / (size.y / 2);
+            bool isAlt = isAlternate;
+            float x = offset.x;
+            if (isAlt)
+                x += size.x / 2;
+            float y = textureToUse.height - offset.y;
+
+            while (y - size.y >= 0)
+            {
+                while (x + size.x <= textureToUse.width)
+                {
+                    var rect = new Rect(x, y - size.y, size.x, size.y);
+                    if (!keepEmptyRects)
+                    {
+                        // Check if the isometric diamond area has sufficient alpha pixels
+                        int sx = (int)rect.x;
+                        int sy = (int)rect.y;
+                        int width = (int)size.x;
+                        int odd = ((int)size.y) % 2;
+                        int topY = ((int)size.y / 2) - 1;
+                        int bottomY = topY + odd;
+                        int totalPixels = 0;
+                        int alphaPixels = 0;
+
+                        // Sample pixels in diamond shape
+                        for (int ry = 0; ry <= topY; ry++)
+                        {
+                            var pixelOffset = Mathf.CeilToInt(gradient * ry);
+                            for (int rx = pixelOffset; rx < width - pixelOffset; ++rx)
+                            {
+                                if (PixelHasAlpha(sx + rx, sy + topY - ry, textureToUse.width, alphaPixelCache))
+                                    alphaPixels++;
+                                if (PixelHasAlpha(sx + rx, sy + bottomY + ry, textureToUse.width, alphaPixelCache))
+                                    alphaPixels++;
+                                totalPixels += 2;
+                            }
+                        }
+
+                        if (odd > 0)
+                        {
+                            int ry = topY + 1;
+                            for (int rx = 0; rx < size.x; ++rx)
+                            {
+                                if (PixelHasAlpha(sx + rx, sy + ry, textureToUse.width, alphaPixelCache))
+                                    alphaPixels++;
+                                totalPixels++;
+                            }
+                        }
+                        if (totalPixels > 0 && ((float)alphaPixels) / totalPixels > 0.01f)
+                            yield return rect;
+                    }
+                    else
+                        yield return rect;
+                    x += size.x;
+                }
+                isAlt = !isAlt;
+                x = offset.x;
+                if (isAlt)
+                    x += size.x / 2;
+                y -= size.y / 2;
+            }
+        }
+    }
+}

package/skills/sprite-editor/scripts/README.md

@@ -0,0 +1,134 @@
+# Sprite Editor Utility Examples
+
+Reference implementations demonstrating sprite editing operations. Each file contains a single method for token efficiency.
+
+## Basic Operations
+
+### GetTextureSourceImageSize.cs
+Gets the original source image dimensions (before import).
+
+**Use when:** You need to know the true image dimensions, not the imported texture size.
+
+**Key APIs:** ITextureDataProvider.GetTextureActualWidthAndHeight()
+
+### SpriteToPng.cs
+Exports a sprite to PNG byte array by rendering its mesh geometry.
+
+**Use when:** Extracting individual sprites from sprite sheets.
+
+**Key concepts:** Renders sprite vertices, UVs, and triangles. Handles tight packing and custom meshes.
+
+### SetPivotExample.cs
+Demonstrates setting sprite pivots using both predefined alignments and custom pivot positions.
+
+**Use when:** Changing sprite pivot points.
+
+**Key methods:**
+- `SpriteEditorUtility.SetCustomPivot()` - Sets custom pivot position. Must set `alignment = SpriteAlignment.Custom` and `pivot = Vector2`
+- `SpriteEditorUtility.SetPivot()` - Sets predefined alignment (Center, BottomLeft, TopRight, etc.)
+
+**Important:** Always set `alignment` field when changing pivots. Custom pivots require `SpriteAlignment.Custom`.
+
+## Slicing Operations
+
+### GetTextureToSlice.cs
+Prepares a readable texture for slicing, upscaling to original dimensions if needed.
+
+**Use when:** Before any slicing operation to ensure correct coordinates.
+
+**Key concept:** See [../references/background.md](../references/background.md#critical-for-slicing-operations) for why this is necessary.
+
+### AutomaticSliceTexture.cs
+Automatically detects sprite regions using Unity's built-in detection algorithm.
+
+**Use when:** Slicing sprite sheets where sprites have transparent borders.
+
+**Key APIs:**
+- UnityEditorInternal.InternalSpriteUtility.GenerateAutomaticSpriteRectangles()
+- GenerateNewSpriteRects() for sprite management
+
+### GridSliceTexture.cs
+Slices textures into regular grid patterns.
+
+**Use when:** Sprite sheet has evenly-spaced sprites (e.g., animation frames, tile sets).
+
+**Parameters:** offset, size, padding, keepEmptyRects
+
+**Key APIs:** UnityEditorInternal.InternalSpriteUtility.GenerateGridSpriteRectangles()
+
+### IsometricSliceTexture.cs
+Slices textures into isometric diamond-pattern tiles.
+
+**Use when:** Working with isometric tile sets (e.g., isometric RPG tiles).
+
+**Key features:**
+- Diamond-shaped outline generation
+- Empty tile detection based on alpha pixels
+- Alternating row offset support
+
+**Key APIs:** ISpriteOutlineDataProvider for diamond outlines
+
+### GenerateNewSpriteRects.cs
+Core utility for managing sprite rectangles during slicing operations.
+
+**Three modes:**
+- **DeleteAll**: Replace all existing sprites with new ones
+- **Smart**: Update overlapping sprites, add non-overlapping ones
+- **Safe**: Only add sprites that don't overlap with existing sprites
+
+**Key features:**
+- Automatic sprite naming with conflict resolution
+- Overlap detection (with tolerance and best-fit options)
+- Preserves existing sprites in Safe/Smart modes
+
+**Use when:** Implementing custom slicing logic or managing sprite updates.
+
+## Usage Pattern
+
+All slicing utilities follow this pattern:
+
+```csharp
+// 1. Get texture at original size
+var texture = GetTextureToSlice(textureProvider);
+
+// 2. Generate rectangles
+var rects = [algorithm to generate Rect collection];
+
+// 3. Convert to SpriteRects with management logic
+var newRects = GenerateNewSpriteRects(
+    spriteDataProvider,
+    rects,
+    addNewSpriteMethod,
+    nameGenerator
+);
+
+// 4. Apply to data provider
+spriteDataProvider.SetSpriteRects(newRects.ToArray());
+```
+
+## Name Generator Examples
+
+The `nameGenerator` parameter is a function that takes an integer index and returns a sprite name string.
+
+### Using Asset Filename from Data Provider
+```csharp
+string assetPath = AssetDatabase.GetAssetPath(spriteDataProvider.targetObject);
+string filename = !string.IsNullOrEmpty(assetPath)
+    ? System.IO.Path.GetFileNameWithoutExtension(assetPath)
+    : "sprite";
+Func<int, string> nameGenerator = (index) => $"{filename}_{index}";
+// Produces: character_sheet_0, character_sheet_1, etc. (or sprite_0, sprite_1 if no path)
+```
+
+### Simple Numbered Names
+```csharp
+Func<int, string> nameGenerator = (index) => $"sprite_{index}";
+// Produces: sprite_0, sprite_1, sprite_2, etc.
+```
+
+## Important Notes
+
+- All coordinates are in **original image space** (see [../references/background.md](../references/background.md#original-vs-imported-image-sizes))
+- Use GetTextureToSlice before any slicing operation
+- GenerateNewSpriteRects handles name conflicts and overlap detection
+- For Unity 2021.2+ requirements, see [../references/background.md](../references/background.md#version-specific-requirements)

package/skills/sprite-editor/scripts/SetPivotExample.cs

@@ -0,0 +1,58 @@
+using UnityEditor;
+using UnityEditor.U2D.Sprites;
+using UnityEngine;
+
+namespace Editor
+{
+    static public partial class SpriteEditorUtility
+    {
+        /// <summary>
+        /// Sets a custom pivot point for a specific sprite within a sprite editor data provider.
+        /// The pivot is specified as a normalized Vector2 where (0,0) is bottom-left and (1,1) is top-right.
+        /// </summary>
+        /// <param name="dataProvider">The sprite editor data provider containing the sprite data.</param>
+        /// <param name="sprite">The GUID of the sprite to modify.</param>
+        /// <param name="pivot">The normalized pivot position (0-1 range for both x and y).</param>
+        /// <returns>True if the sprite was found and the pivot was set successfully; otherwise, false.</returns>
+        public static bool SetCustomPivot(ISpriteEditorDataProvider dataProvider, GUID sprite, Vector2 pivot)
+        {
+            var rects = dataProvider.GetSpriteRects();
+            for (int i = 0; i < rects.Length; ++i)
+            {
+                if (rects[i].spriteID == sprite)
+                {
+                    rects[i].pivot = pivot;
+                    rects[i].alignment = SpriteAlignment.Custom;
+                    dataProvider.SetSpriteRects(rects);
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Sets a predefined pivot alignment for a specific sprite within a sprite editor data provider.
+        /// Uses Unity's built-in alignment options (e.g., Center, TopLeft, BottomRight).
+        /// </summary>
+        /// <param name="dataProvider">The sprite editor data provider containing the sprite data.</param>
+        /// <param name="sprite">The GUID of the sprite to modify.</param>
+        /// <param name="alignment">The predefined sprite alignment to apply.</param>
+        /// <returns>True if the sprite was found and the alignment was set successfully; otherwise, false.</returns>
+        public static bool SetPivot(ISpriteEditorDataProvider dataProvider, GUID sprite, SpriteAlignment alignment)
+        {
+            var rects = dataProvider.GetSpriteRects();
+            for (int i = 0; i < rects.Length; ++i)
+            {
+                if (rects[i].spriteID == sprite)
+                {
+                    rects[i].alignment = alignment;
+                    dataProvider.SetSpriteRects(rects);
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}