nccgs 1.0.0

package/.claude/skills/sprite-editor/references/templates.md

@@ -0,0 +1,72 @@
+# Sprite Editor Code Templates
+
+## Safe Core Pattern (MANDATORY)
+
+Types are fully qualified because this runs through `eval`, which rejects `using` directives.
+If you save it as a `.cs` file instead, add `using UnityEditor.U2D.Sprites;` and shorten them.
+
+Use this structure for all sprite modification tasks.
+
+**CRITICAL:** If capability checks fail, the script MUST return immediately. NEVER bypass capability checks even if you suspect the API might work - this can cause data corruption and violates Unity's data provider contract.
+
+```csharp
+// 1. Get and Init Data Provider
+var importer = UnityEditor.AssetImporter.GetAtPath(assetPath);
+var factory = new UnityEditor.U2D.Sprites.SpriteDataProviderFactories();
+factory.Init();
+var dataProvider = factory.GetSpriteEditorDataProviderFromObject(importer);
+dataProvider.InitSpriteEditorDataProvider();
+
+// 2. MANDATORY: Check Capabilities - ABORT if not supported
+var editCapability = dataProvider.GetDataProvider<UnityEditor.U2D.Sprites.ISpriteFrameEditCapability>();
+if (editCapability == null)
+{
+    throw new System.Exception("Edit capability not supported by importer. Operation aborted.");
+}
+
+var capability = editCapability.GetEditCapability();
+// Check for: EditSpriteName, EditSpriteRect, EditBorder, EditPivot, CreateAndDeleteSprite
+if (!capability.HasCapability(UnityEditor.U2D.Sprites.EEditCapability.EditSpriteName))
+{
+    throw new System.Exception("Operation not supported by importer. User action aborted.");
+}
+
+// 3. Read and Modify
+var spriteRects = dataProvider.GetSpriteRects();
+// ... logic here ...
+
+// 4. Apply and Reimport
+dataProvider.SetSpriteRects(spriteRects);
+dataProvider.Apply();
+importer.SaveAndReimport();
+```
+
+## Capability Check Pattern
+
+Before performing any modification operation, check if the importer supports it. **ABORT the user action if the capability is not supported.**
+
+**DO NOT rationalize bypassing this check.** Even if you believe the API might accept the operation, capability checks are mandatory for data integrity. Return immediately on failure - no exceptions.
+
+```csharp
+var editCapability = dataProvider.GetDataProvider<UnityEditor.U2D.Sprites.ISpriteFrameEditCapability>();
+if (editCapability == null)
+{
+    throw new System.Exception("Edit capability not supported by importer. User action aborted.");
+    return;
+}
+
+var capability = editCapability.GetEditCapability();
+if (!capability.HasCapability(UnityEditor.U2D.Sprites.EEditCapability.EditSpriteName)) // Adjust based on task
+{
+    throw new System.Exception("Importer does not support the requested operation. User action aborted.");
+    return;
+}
+```
+
+### Available Capabilities
+
+- `EditSpriteName` - Modify sprite names
+- `EditSpriteRect` - Modify sprite rectangles
+- `EditBorder` - Modify 9-slice borders
+- `EditPivot` - Modify pivot points
+- `CreateAndDeleteSprite` - Add/remove sprites or perform slicing

package/.claude/skills/sprite-editor/scripts/AutomaticSliceTexture.cs

@@ -0,0 +1,40 @@
+using System;
+using UnityEditor.U2D.Sprites;
+
+namespace Editor
+{
+    static public partial class SpriteEditorUtility
+    {
+        /// <summary>
+        /// Automatically slices a texture by detecting visible pixel regions and creating sprite rectangles.
+        /// Uses Unity's internal automatic sprite detection algorithm to find sprite boundaries.
+        /// </summary>
+        /// <param name="spriteDataProvider">The sprite data provider for the texture.</param>
+        /// <param name="textureProvider">The texture data provider.</param>
+        /// <param name="minRectSize">Minimum size in pixels for detected sprite rectangles.</param>
+        /// <param name="extrudeSize">Number of pixels to extrude (expand) sprite boundaries.</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="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 AutomaticSliceTexture(ISpriteEditorDataProvider spriteDataProvider, ITextureDataProvider textureProvider,
+            int minRectSize, int extrudeSize, AddNewSpriteMethod addNewSpriteMethod, Func<int, string> nameGenerator,
+            float kOverlapTolerance= 0.00001f, float kBestFitTolerance = 0.5f, bool bestFit = false)
+        {
+            var texture = GetTextureToSlice(textureProvider);
+            if (texture == null)
+            {
+                return false;
+            }
+
+            var rects = UnityEditorInternal.InternalSpriteUtility.GenerateAutomaticSpriteRectangles(texture, minRectSize, extrudeSize);
+
+            var newRects = GenerateNewSpriteRects(spriteDataProvider, rects, addNewSpriteMethod, nameGenerator, kOverlapTolerance, kBestFitTolerance, bestFit);
+            spriteDataProvider.SetSpriteRects(newRects.ToArray());
+
+            return true;
+        }
+    }
+}

package/.claude/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/.claude/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/.claude/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/.claude/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/.claude/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;
+            }
+        }
+    }
+}