com.wallstop-studios.unity-helpers 2.0.0-rc81.7 → 2.0.0-rc81.9

package/Editor/Sprites/SpritePivotAdjustor.cs

@@ -1,265 +1,605 @@
-namespace WallstopStudios.UnityHelpers.Editor.Sprites
-{
-#if UNITY_EDITOR
-    using System;
-    using System.Collections.Generic;
-    using System.IO;
-    using System.Linq;
-    using System.Text.RegularExpressions;
-    using System.Threading;
-    using System.Threading.Tasks;
-    using Core.Extension;
-    using CustomEditors;
-    using UnityEditor;
-    using UnityEngine;
-    using Object = UnityEngine.Object;
-
-    public class SpritePivotAdjuster : EditorWindow
-    {
-        private const float AlphaCutoff = 0.01f;
-
-        private static readonly string[] ImageFileExtensions =
-        {
-            ".png",
-            ".jpg",
-            ".jpeg",
-            ".bmp",
-            ".tga",
-            ".psd",
-            ".gif",
-        };
-
-        [SerializeField]
-        private List<Object> _directoryPaths = new();
-
-        [SerializeField]
-        private string _spriteNameRegex = ".*";
-
-        private SerializedObject _serializedObject;
-        private SerializedProperty _directoryPathsProperty;
-        private SerializedProperty _spriteNameRegexProperty;
-
-        private List<string> _filesToProcess;
-        private Regex _regex;
-
-        [MenuItem("Tools/Wallstop Studios/Unity Helpers/Sprite Pivot Adjuster")]
-        public static void ShowWindow()
-        {
-            GetWindow<SpritePivotAdjuster>("Sprite Pivot Adjuster");
-        }
-
-        private void OnEnable()
-        {
-            _serializedObject = new SerializedObject(this);
-            _directoryPathsProperty = _serializedObject.FindProperty(nameof(_directoryPaths));
-            _spriteNameRegexProperty = _serializedObject.FindProperty(nameof(_spriteNameRegex));
-        }
-
-        private void OnGUI()
-        {
-            EditorGUILayout.LabelField("Input directories", EditorStyles.boldLabel);
-            _serializedObject.Update();
-            PersistentDirectoryGUI.PathSelectorObjectArray(
-                _directoryPathsProperty,
-                nameof(SpriteCropper)
-            );
-
-            using (new GUILayout.HorizontalScope())
-            {
-                EditorGUILayout.LabelField("Sprite Name Regex", EditorStyles.boldLabel);
-                _spriteNameRegex = EditorGUILayout.TextField(_spriteNameRegex);
-            }
-
-            _serializedObject.ApplyModifiedProperties();
-            if (GUILayout.Button("Find Sprites To Process"))
-            {
-                _regex = !string.IsNullOrWhiteSpace(_spriteNameRegex)
-                    ? new Regex(_spriteNameRegex)
-                    : null;
-                FindFilesToProcess();
-            }
-
-            if (_filesToProcess is { Count: > 0 })
-            {
-                GUILayout.Label(
-                    $"Found {_filesToProcess.Count} sprites to process.",
-                    EditorStyles.boldLabel
-                );
-                if (GUILayout.Button("Adjust Pivots in Directory"))
-                {
-                    AdjustPivotsInDirectory();
-                    _filesToProcess = null;
-                }
-            }
-            else if (_filesToProcess != null)
-            {
-                GUILayout.Label(
-                    "No sprites found to process in the selected directories.",
-                    EditorStyles.label
-                );
-            }
-        }
-
-        private void FindFilesToProcess()
-        {
-            _filesToProcess = new List<string>();
-            if (_directoryPaths is not { Count: > 0 })
-            {
-                this.LogWarn($"No input directories selected.");
-                return;
-            }
-
-            foreach (Object maybeDirectory in _directoryPaths.Where(d => d != null))
-            {
-                string assetPath = AssetDatabase.GetAssetPath(maybeDirectory);
-                if (!AssetDatabase.IsValidFolder(assetPath))
-                {
-                    this.LogWarn($"Skipping invalid path: {assetPath}");
-                    continue;
-                }
-
-                IEnumerable<string> files = Directory
-                    .GetFiles(assetPath, "*.*", SearchOption.AllDirectories)
-                    .Where(file =>
-                        Array.Exists(
-                            ImageFileExtensions,
-                            extension =>
-                                file.EndsWith(extension, StringComparison.OrdinalIgnoreCase)
-                        )
-                    );
-
-                foreach (string file in files)
-                {
-                    string fileName = Path.GetFileNameWithoutExtension(file);
-                    if (_regex != null && !_regex.IsMatch(fileName))
-                    {
-                        continue;
-                    }
-
-                    _filesToProcess.Add(file);
-                }
-            }
-            Repaint();
-        }
-
-        private void AdjustPivotsInDirectory()
-        {
-            HashSet<string> processedFiles = new(StringComparer.OrdinalIgnoreCase);
-            List<TextureImporter> importers = new();
-            AssetDatabase.StartAssetEditing();
-            try
-            {
-                for (int i = 0; i < _filesToProcess.Count; i++)
-                {
-                    string assetPath = _filesToProcess[i];
-                    if (!processedFiles.Add(assetPath))
-                    {
-                        continue;
-                    }
-                    if (
-                        AssetImporter.GetAtPath(assetPath)
-                        is not TextureImporter { textureType: TextureImporterType.Sprite } importer
-                    )
-                    {
-                        return;
-                    }
-
-                    Sprite sprite = AssetDatabase.LoadAssetAtPath<Sprite>(assetPath);
-
-                    if (sprite == null)
-                    {
-                        continue;
-                    }
-
-                    EditorUtility.DisplayProgressBar(
-                        "Processing sprites",
-                        $"Processing {sprite.name}",
-                        (float)i / _filesToProcess.Count
-                    );
-
-                    if (importer.spriteImportMode == SpriteImportMode.Single)
-                    {
-                        TextureImporterSettings settings = new();
-                        importer.ReadTextureSettings(settings);
-
-                        Vector2 newPivot = CalculateCenterOfMassPivot(sprite);
-                        settings.spritePivot = newPivot;
-                        settings.spriteAlignment = (int)SpriteAlignment.Custom;
-                        importer.SetTextureSettings(settings);
-
-                        importer.spritePivot = newPivot;
-                        importer.SaveAndReimport();
-                        importers.Add(importer);
-                    }
-                }
-            }
-            finally
-            {
-                EditorUtility.ClearProgressBar();
-                AssetDatabase.StopAssetEditing();
-                foreach (TextureImporter importer in importers)
-                {
-                    importer.SaveAndReimport();
-                }
-                AssetDatabase.SaveAssets();
-                AssetDatabase.Refresh();
-            }
-        }
-
-        private static Vector2 CalculateCenterOfMassPivot(Sprite sprite)
-        {
-            Texture2D texture = sprite.texture;
-            Rect spriteRect = sprite.rect;
-            int startX = Mathf.FloorToInt(spriteRect.x);
-            int startY = Mathf.FloorToInt(spriteRect.y);
-            int width = Mathf.FloorToInt(spriteRect.width);
-            int height = Mathf.FloorToInt(spriteRect.height);
-
-            long totalX = 0;
-            long totalY = 0;
-            long pixelCount = 0;
-
-            Color[] pixels = texture.GetPixels(startX, startY, width, height);
-
-            Parallel.For(
-                0,
-                height,
-                () => (sumX: 0L, sumY: 0L, count: 0L),
-                (y, _, local) =>
-                {
-                    int rowOffset = y * width;
-                    for (int x = 0; x < width; ++x)
-                    {
-                        if (pixels[rowOffset + x].a > AlphaCutoff)
-                        {
-                            local.sumX += x;
-                            local.sumY += y;
-                            local.count++;
-                        }
-                    }
-                    return local;
-                },
-                local =>
-                {
-                    Interlocked.Add(ref totalX, local.sumX);
-                    Interlocked.Add(ref totalY, local.sumY);
-                    Interlocked.Add(ref pixelCount, local.count);
-                }
-            );
-
-            if (pixelCount == 0L)
-            {
-                return new Vector2(0.5f, 0.5f);
-            }
-
-            double averageX = (double)totalX / pixelCount;
-            double averageY = (double)totalY / pixelCount;
-
-            double pivotX = averageX / width;
-            double pivotY = averageY / height;
-
-            return new Vector2((float)pivotX, (float)pivotY);
-        }
-    }
-#endif
-}
+namespace WallstopStudios.UnityHelpers.Editor.Sprites
+{
+#if UNITY_EDITOR
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using CustomEditors;
+    using UnityEditor;
+    using UnityEngine;
+    using WallstopStudios.UnityHelpers.Core.Extension;
+    using WallstopStudios.UnityHelpers.Utils;
+    using Object = UnityEngine.Object;
+
+    /// <summary>
+    /// Computes and applies a new sprite pivot based on an alpha-weighted center-of-mass
+    /// calculation, with optional regex filtering, fuzzy skip of unchanged results, and a force
+    /// reimport override.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Problems this solves: aligning sprites around a perceptual center (ignoring transparent
+    /// pixels below a cutoff) to simplify positioning and animation.
+    /// </para>
+    /// <para>
+    /// How it works: for each single-sprite texture in the selected folders (filtered by optional
+    /// regex), computes the pixel-weighted centroid using <c>alpha &gt;= cutoff</c> and writes the
+    /// pivot into the importer settings.
+    /// </para>
+    /// <para>
+    /// Pros: predictable pivots for varied silhouettes; skip unchanged to speed runs.
+    /// Caveats: multi-sprite textures are not supported; importer may be dirtied frequently.
+    /// </para>
+    /// </remarks>
+    public class SpritePivotAdjuster : EditorWindow
+    {
+        internal static bool SuppressUserPrompts { get; set; }
+        private const float PivotEpsilon = 1e-3f;
+
+        private static readonly string[] ImageFileExtensions =
+        {
+            ".png",
+            ".jpg",
+            ".jpeg",
+            ".bmp",
+            ".tga",
+            ".psd",
+            ".gif",
+        };
+
+        [SerializeField]
+        internal List<Object> _directoryPaths = new();
+
+        [SerializeField]
+        private string _spriteNameRegex = ".*";
+
+        [SerializeField]
+        internal float _alphaCutoff = 0.01f;
+
+        [SerializeField]
+        internal bool _skipUnchanged = true;
+
+        [SerializeField]
+        internal bool _forceReimport;
+
+        private SerializedObject _serializedObject;
+        private SerializedProperty _directoryPathsProperty;
+        private List<string> _filesToProcess;
+        private Regex _regex;
+        private string _regexError;
+        private string _lastValidatedRegex;
+
+        [MenuItem("Tools/Wallstop Studios/Unity Helpers/Sprite Pivot Adjuster")]
+        public static void ShowWindow()
+        {
+            GetWindow<SpritePivotAdjuster>("Sprite Pivot Adjuster");
+        }
+
+        static SpritePivotAdjuster()
+        {
+            // Auto-suppress UI prompts in batch mode and test runs
+            try
+            {
+                if (Application.isBatchMode || Utils.EditorUi.Suppress)
+                {
+                    SuppressUserPrompts = true;
+                }
+            }
+            catch
+            {
+                // Ignore environment probing failures
+            }
+        }
+
+        private static bool IsInvokedByTestRunner()
+        {
+            // Heuristic: Unity test runs pass -runTests/-testResults on the command line
+            string[] args = Environment.GetCommandLineArgs();
+            for (int i = 0; i < args.Length; ++i)
+            {
+                string a = args[i];
+                if (
+                    a.IndexOf("runTests", StringComparison.OrdinalIgnoreCase) >= 0
+                    || a.IndexOf("testResults", StringComparison.OrdinalIgnoreCase) >= 0
+                    || a.IndexOf("testPlatform", StringComparison.OrdinalIgnoreCase) >= 0
+                )
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        private void OnEnable()
+        {
+            _serializedObject = new SerializedObject(this);
+            _directoryPathsProperty = _serializedObject.FindProperty(nameof(_directoryPaths));
+            // _spriteNameRegexProperty was unused; using direct field to enable inline validation and tooltips.
+        }
+
+        private void OnGUI()
+        {
+            EditorGUILayout.LabelField(
+                new GUIContent(
+                    "Input Directories",
+                    "Folders to scan for textures. Only supported image extensions are considered."
+                ),
+                EditorStyles.boldLabel
+            );
+            _serializedObject.Update();
+            PersistentDirectoryGUI.PathSelectorObjectArray(
+                _directoryPathsProperty,
+                nameof(SpriteCropper)
+            );
+
+            using (new GUILayout.HorizontalScope())
+            {
+                _spriteNameRegex = EditorGUILayout.TextField(
+                    new GUIContent(
+                        "Sprite Name Regex",
+                        "Optional .NET regex applied to file names (no extension). Leave empty for all."
+                    ),
+                    _spriteNameRegex
+                );
+            }
+
+            // Inline regex validation (validate only when the text changes to avoid per-frame cost)
+            if (!string.Equals(_spriteNameRegex, _lastValidatedRegex, StringComparison.Ordinal))
+            {
+                _lastValidatedRegex = _spriteNameRegex;
+                if (string.IsNullOrWhiteSpace(_spriteNameRegex))
+                {
+                    _regexError = null;
+                }
+                else
+                {
+                    try
+                    {
+                        _ = new Regex(_spriteNameRegex, RegexOptions.CultureInvariant);
+                        _regexError = null;
+                    }
+                    catch (ArgumentException ex)
+                    {
+                        _regexError = ex.Message;
+                    }
+                }
+            }
+
+            if (!string.IsNullOrEmpty(_regexError))
+            {
+                EditorGUILayout.HelpBox($"Invalid regex: {_regexError}", MessageType.Error);
+            }
+
+            EditorGUILayout.HelpBox(
+                "Single-sprite textures only. Alpha Cutoff ignores pixels at/under the threshold when computing center-of-mass pivot. 'Skip Unchanged' avoids reimport if change < "
+                    + PivotEpsilon
+                    + ". 'Force Reimport' overrides that.",
+                MessageType.Info
+            );
+
+            _alphaCutoff = EditorGUILayout.Slider(
+                new GUIContent(
+                    "Alpha Cutoff",
+                    "Pixels with alpha <= cutoff are ignored when computing the pivot."
+                ),
+                _alphaCutoff,
+                0f,
+                1f
+            );
+
+            using (new GUILayout.HorizontalScope())
+            {
+                _skipUnchanged = EditorGUILayout.ToggleLeft(
+                    new GUIContent(
+                        "Skip Unchanged (fuzzy)",
+                        "If pivot delta < " + PivotEpsilon + ", skip reimport to save time."
+                    ),
+                    _skipUnchanged
+                );
+            }
+
+            using (new GUILayout.HorizontalScope())
+            {
+                _forceReimport = EditorGUILayout.ToggleLeft(
+                    new GUIContent(
+                        "Force Reimport",
+                        "Reimport even if the computed pivot is unchanged. Overrides 'Skip Unchanged'."
+                    ),
+                    _forceReimport
+                );
+            }
+
+            _serializedObject.ApplyModifiedProperties();
+            if (
+                GUILayout.Button(
+                    new GUIContent(
+                        "Find Sprites To Process",
+                        "Scan selected folders and filter by regex."
+                    )
+                )
+            )
+            {
+                _regex = null;
+                if (!string.IsNullOrEmpty(_regexError))
+                {
+                    ShowNotification(new GUIContent("Invalid regex. Fix it before searching."));
+                    return;
+                }
+                if (!string.IsNullOrWhiteSpace(_spriteNameRegex))
+                {
+                    try
+                    {
+                        _regex = new Regex(
+                            _spriteNameRegex,
+                            RegexOptions.Compiled | RegexOptions.CultureInvariant
+                        );
+                    }
+                    catch (ArgumentException ex)
+                    {
+                        this.LogWarn($"Invalid regex '{_spriteNameRegex}': {ex.Message}");
+                        ShowNotification(new GUIContent("Invalid regex. Fix it before searching."));
+                        return;
+                    }
+                }
+                FindFilesToProcess();
+            }
+
+            if (_filesToProcess is { Count: > 0 })
+            {
+                GUILayout.Label(
+                    $"Found {_filesToProcess.Count} sprites to process.",
+                    EditorStyles.boldLabel
+                );
+                using (new GUILayout.HorizontalScope())
+                {
+                    if (
+                        GUILayout.Button(
+                            new GUIContent(
+                                "Dry Run",
+                                "Simulate pivot changes without applying. Shows a brief summary."
+                            )
+                        )
+                    )
+                    {
+                        AdjustPivotsInDirectory(dryRun: true);
+                    }
+                    if (
+                        GUILayout.Button(
+                            new GUIContent(
+                                "Adjust Pivots in Directory",
+                                "Compute and apply pivots (cancelable). Honors Alpha Cutoff, Skip Unchanged, and Force Reimport."
+                            )
+                        )
+                    )
+                    {
+                        AdjustPivotsInDirectory(dryRun: false);
+                        _filesToProcess = null;
+                    }
+                }
+            }
+            else if (_filesToProcess != null)
+            {
+                GUILayout.Label(
+                    "No sprites found to process in the selected directories.",
+                    EditorStyles.label
+                );
+            }
+        }
+
+        internal void FindFilesToProcess()
+        {
+            _filesToProcess = new List<string>();
+            if (_directoryPaths is not { Count: > 0 })
+            {
+                this.LogWarn($"No input directories selected.");
+                return;
+            }
+
+            // Use AssetDatabase to find textures in selected folders to ensure asset-relative paths.
+            using PooledResource<HashSet<string>> seenRes = SetBuffers<string>
+                .GetHashSetPool(StringComparer.OrdinalIgnoreCase)
+                .Get(out HashSet<string> seen);
+            foreach (Object maybeDirectory in _directoryPaths.Where(d => d != null))
+            {
+                string assetPath = AssetDatabase.GetAssetPath(maybeDirectory);
+                if (!AssetDatabase.IsValidFolder(assetPath))
+                {
+                    this.LogWarn($"Skipping invalid path: {assetPath}");
+                    continue;
+                }
+
+                string[] guids = AssetDatabase.FindAssets("t:Texture2D", new[] { assetPath });
+                foreach (string guid in guids)
+                {
+                    string file = AssetDatabase.GUIDToAssetPath(guid);
+                    if (string.IsNullOrEmpty(file))
+                    {
+                        continue;
+                    }
+
+                    // Extension filter
+                    if (
+                        !Array.Exists(
+                            ImageFileExtensions,
+                            ext => file.EndsWith(ext, StringComparison.OrdinalIgnoreCase)
+                        )
+                    )
+                    {
+                        continue;
+                    }
+
+                    string fileName = Path.GetFileNameWithoutExtension(file);
+                    if (_regex != null && !_regex.IsMatch(fileName))
+                    {
+                        continue;
+                    }
+                    if (seen.Add(file))
+                    {
+                        _filesToProcess.Add(file);
+                    }
+                }
+            }
+            Repaint();
+        }
+
+        internal void AdjustPivotsInDirectory(bool dryRun)
+        {
+            if (_filesToProcess == null || _filesToProcess.Count == 0)
+            {
+                ShowNotification(new GUIContent("Nothing to process. Run 'Find' first."));
+                return;
+            }
+            using PooledResource<HashSet<string>> processedFilesRes = SetBuffers<string>
+                .GetHashSetPool(StringComparer.OrdinalIgnoreCase)
+                .Get(out HashSet<string> processedFiles);
+            using PooledResource<List<TextureImporter>> importersRes =
+                Buffers<TextureImporter>.List.Get(out List<TextureImporter> importers);
+            int totalCandidates = _filesToProcess?.Count ?? 0;
+            int processedSingles = 0;
+            int changed = 0;
+            int skippedUnchanged = 0;
+            int skippedNonReadable = 0;
+            int skippedNotSprite = 0;
+            int skippedNullSprite = 0;
+            int skippedNotSingle = 0;
+            bool canceled = false;
+            if (!dryRun)
+            {
+                AssetDatabase.StartAssetEditing();
+            }
+            try
+            {
+                if (_filesToProcess == null)
+                {
+                    return;
+                }
+
+                for (int i = 0; i < _filesToProcess.Count; i++)
+                {
+                    string assetPath = _filesToProcess[i];
+                    if (!processedFiles.Add(assetPath))
+                    {
+                        continue;
+                    }
+
+                    if (
+                        AssetImporter.GetAtPath(assetPath)
+                        is not TextureImporter { textureType: TextureImporterType.Sprite } importer
+                    )
+                    {
+                        // Not a sprite texture; skip to next file
+                        skippedNotSprite++;
+                        continue;
+                    }
+
+                    Sprite sprite = AssetDatabase.LoadAssetAtPath<Sprite>(assetPath);
+
+                    if (sprite == null)
+                    {
+                        skippedNullSprite++;
+                        continue;
+                    }
+
+                    if (
+                        ShowCancelableProgress(
+                            "Processing sprites",
+                            $"Processing {sprite.name}",
+                            (float)i / _filesToProcess.Count
+                        )
+                    )
+                    {
+                        canceled = true;
+                        break; // user canceled
+                    }
+
+                    if (importer.spriteImportMode == SpriteImportMode.Single)
+                    {
+                        processedSingles++;
+                        if (!importer.isReadable)
+                        {
+                            skippedNonReadable++;
+                            this.LogWarn($"Skipping non-readable texture: {assetPath}");
+                            continue;
+                        }
+
+                        Vector2 newPivot = CalculateCenterOfMassPivot(sprite, _alphaCutoff);
+                        Vector2 currentPivot = importer.spritePivot;
+                        bool unchanged =
+                            Mathf.Abs(currentPivot.x - newPivot.x) < PivotEpsilon
+                            && Mathf.Abs(currentPivot.y - newPivot.y) < PivotEpsilon;
+                        if (_skipUnchanged && !_forceReimport && unchanged)
+                        {
+                            skippedUnchanged++;
+                            continue; // no meaningful change and not forced
+                        }
+
+                        if (!dryRun)
+                        {
+                            TextureImporterSettings settings = new();
+                            importer.ReadTextureSettings(settings);
+                            settings.spritePivot = newPivot;
+                            settings.spriteAlignment = (int)SpriteAlignment.Custom;
+                            importer.SetTextureSettings(settings);
+                            importer.spritePivot = newPivot;
+                            importers.Add(importer);
+                        }
+
+                        changed++;
+                    }
+                    else
+                    {
+                        skippedNotSingle++;
+                    }
+                }
+            }
+            finally
+            {
+                ClearProgress();
+                if (!dryRun)
+                {
+                    AssetDatabase.StopAssetEditing();
+                    foreach (TextureImporter importer in importers)
+                    {
+                        importer.SaveAndReimport();
+                    }
+                    AssetDatabase.SaveAssets();
+                    AssetDatabase.Refresh();
+                }
+
+                using PooledResource<StringBuilder> sbRes = Buffers.StringBuilder.Get(
+                    out StringBuilder sb
+                );
+                sb.AppendLine(
+                    canceled ? "Canceled by user."
+                    : dryRun ? "Dry run completed."
+                    : "Completed."
+                );
+                sb.AppendLine($"Total candidates: {totalCandidates}");
+                sb.AppendLine($"Single sprites processed: {processedSingles}");
+                sb.AppendLine(
+                    "Changed pivots" + (dryRun ? " (would change)" : "") + $": {changed}"
+                );
+                sb.AppendLine($"Skipped unchanged: {skippedUnchanged}");
+                sb.AppendLine($"Skipped non-readable: {skippedNonReadable}");
+                sb.AppendLine($"Skipped not sprite: {skippedNotSprite}");
+                sb.AppendLine($"Skipped missing sprite: {skippedNullSprite}");
+                sb.AppendLine($"Skipped multi-sprite textures: {skippedNotSingle}");
+                Info(
+                    dryRun ? "Sprite Pivot Adjuster — Dry Run" : "Sprite Pivot Adjuster",
+                    sb.ToString()
+                );
+            }
+        }
+
+        private static bool ShowCancelableProgress(string title, string info, float progress)
+        {
+            return Utils.EditorUi.CancelableProgress(title, info, progress);
+        }
+
+        private static void ClearProgress()
+        {
+            Utils.EditorUi.ClearProgress();
+        }
+
+        private static void Info(string title, string message)
+        {
+            Utils.EditorUi.Info(title, message);
+        }
+
+        private static Vector2 CalculateCenterOfMassPivot(Sprite sprite, float alphaCutoff)
+        {
+            Texture2D texture = sprite.texture;
+            Rect spriteRect = sprite.rect;
+            int startX = Mathf.FloorToInt(spriteRect.x);
+            int startY = Mathf.FloorToInt(spriteRect.y);
+            int width = Mathf.FloorToInt(spriteRect.width);
+            int height = Mathf.FloorToInt(spriteRect.height);
+
+            long totalX = 0;
+            long totalY = 0;
+            long pixelCount = 0;
+
+            // Fast path: sprite covers entire texture, use GetPixels32 for lower allocation and faster access
+            if (startX == 0 && startY == 0 && width == texture.width && height == texture.height)
+            {
+                Color32[] pixels32 = texture.GetPixels32();
+                byte alphaThreshold = (byte)Mathf.CeilToInt(alphaCutoff * 255f);
+
+                Parallel.For(
+                    0,
+                    height,
+                    () => (sumX: 0L, sumY: 0L, count: 0L),
+                    (y, _, local) =>
+                    {
+                        int rowOffset = y * width;
+                        for (int x = 0; x < width; ++x)
+                        {
+                            if (pixels32[rowOffset + x].a > alphaThreshold)
+                            {
+                                local.sumX += x;
+                                local.sumY += y;
+                                local.count++;
+                            }
+                        }
+                        return local;
+                    },
+                    local =>
+                    {
+                        Interlocked.Add(ref totalX, local.sumX);
+                        Interlocked.Add(ref totalY, local.sumY);
+                        Interlocked.Add(ref pixelCount, local.count);
+                    }
+                );
+            }
+            else
+            {
+                Color[] pixels = texture.GetPixels(startX, startY, width, height);
+
+                Parallel.For(
+                    0,
+                    height,
+                    () => (sumX: 0L, sumY: 0L, count: 0L),
+                    (y, _, local) =>
+                    {
+                        int rowOffset = y * width;
+                        for (int x = 0; x < width; ++x)
+                        {
+                            if (pixels[rowOffset + x].a > alphaCutoff)
+                            {
+                                local.sumX += x;
+                                local.sumY += y;
+                                local.count++;
+                            }
+                        }
+                        return local;
+                    },
+                    local =>
+                    {
+                        Interlocked.Add(ref totalX, local.sumX);
+                        Interlocked.Add(ref totalY, local.sumY);
+                        Interlocked.Add(ref pixelCount, local.count);
+                    }
+                );
+            }
+
+            if (pixelCount == 0L)
+            {
+                return new Vector2(0.5f, 0.5f);
+            }
+
+            double averageX = (double)totalX / pixelCount;
+            double averageY = (double)totalY / pixelCount;
+
+            double pivotX = averageX / width;
+            double pivotY = averageY / height;
+
+            return new Vector2(Mathf.Clamp01((float)pivotX), Mathf.Clamp01((float)pivotY));
+        }
+    }
+#endif
+}