com.wallstop-studios.unity-helpers 1.0.1-rc03 → 1.0.1-rc04

package/Editor/AnimationCopier.cs

@@ -0,0 +1,124 @@
+namespace UnityHelpers.Editor
+{
+#if UNITY_EDITOR
+    using System;
+    using System.IO;
+    using Core.Attributes;
+    using Core.Extension;
+    using UnityEditor;
+    using UnityEngine;
+    using Utils;
+
+    public sealed class AnimationCopier : ScriptableWizard
+    {
+        private string _fullSourcePath;
+        private string _fullDestinationPath;
+
+        [ReadOnly]
+        public string animationSourcePath;
+
+        [ReadOnly]
+        public string animationDestinationPath;
+
+        [MenuItem("Tools/Unity Helpers/Animation Copier")]
+        public static void CopyAnimations()
+        {
+            _ = DisplayWizard<AnimationCopier>("Animation Copier", "Copy");
+        }
+
+        protected override bool DrawWizardGUI()
+        {
+            bool returnValue = base.DrawWizardGUI();
+
+            if (GUILayout.Button("Set Animation Source Path"))
+            {
+                string sourcePath = EditorUtility.OpenFolderPanel(
+                    "Select Animation Source Path", EditorUtilities.GetCurrentPathOfProjectWindow(), string.Empty);
+                int assetIndex = sourcePath?.IndexOf("Assets", StringComparison.Ordinal) ?? -1;
+                if (assetIndex < 0)
+                {
+                    return false;
+                }
+
+                _fullSourcePath = animationSourcePath = sourcePath ?? string.Empty;
+                animationSourcePath = animationSourcePath.Substring(assetIndex);
+                return true;
+            }
+
+            if (GUILayout.Button("Set Animation Destination Path"))
+            {
+                string sourcePath = EditorUtility.OpenFolderPanel(
+                    "Select Animation Destination Path", EditorUtilities.GetCurrentPathOfProjectWindow(), string.Empty);
+                int assetIndex = sourcePath?.IndexOf("Assets", StringComparison.Ordinal) ?? -1;
+                if (assetIndex < 0)
+                {
+                    return false;
+                }
+
+                _fullDestinationPath = animationDestinationPath = sourcePath ?? string.Empty;
+                animationDestinationPath = animationDestinationPath.Substring(assetIndex);
+                return true;
+            }
+
+            return returnValue;
+        }
+
+        private void OnWizardCreate()
+        {
+            if (string.IsNullOrEmpty(_fullSourcePath) || string.IsNullOrEmpty(_fullDestinationPath))
+            {
+                return;
+            }
+
+            if (string.IsNullOrEmpty(animationSourcePath) || string.IsNullOrEmpty(animationDestinationPath))
+            {
+                return;
+            }
+
+            foreach (string assetGuid in AssetDatabase.FindAssets("t:AnimationClip", new[] { animationSourcePath }))
+            {
+                string path = AssetDatabase.GUIDToAssetPath(assetGuid);
+
+                AnimationClip animationClip = AssetDatabase.LoadAssetAtPath<AnimationClip>(path);
+                if (animationClip == null)
+                {
+                    this.LogError("Invalid AnimationClip (null) found at path '{0}', skipping.", path);
+                    continue;
+                }
+
+                string prefix = animationClip.name;
+                string relativePath = path.Substring(animationSourcePath.Length);
+                int animIndex = relativePath.LastIndexOf(prefix, StringComparison.OrdinalIgnoreCase);
+                if (animIndex < 0)
+                {
+                    this.LogWarn("Unsupported animation at '{0}', expected to be prefixed by '{1}'.", path, prefix);
+                    continue;
+                }
+
+                string partialPath = relativePath.Substring(0, animIndex);
+                string outputPath = _fullDestinationPath + partialPath;
+
+                if (!Directory.Exists(outputPath))
+                {
+                    _ = Directory.CreateDirectory(outputPath);
+                }
+
+                string destination = animationDestinationPath + partialPath + relativePath.Substring(animIndex);
+                bool copySuccessful = AssetDatabase.CopyAsset(path, destination);
+                if (copySuccessful)
+                {
+                    bool deleteSuccessful = AssetDatabase.DeleteAsset(path);
+                    if (!deleteSuccessful)
+                    {
+                        this.LogError("Failed to delete asset at path '{0}'.", path);
+                    }
+                }
+                else
+                {
+                    this.LogError("Failed to copy animation from '{0}' to '{1}'.", path, destination);
+                }
+            }
+        }
+    }
+#endif
+}

package/Editor/AnimationCopier.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 40462f0dd8a4429e983409e3374ae66e
+timeCreated: 1720665801

package/Editor/AnimationCreator.cs

@@ -17,7 +17,6 @@
         public List<Texture2D> frames;
         public int framesPerSecond = DefaultFramesPerSecond;
         public string animationName;
-        public string assetPath;
     }
 
     public sealed class AnimationCreator : ScriptableWizard
@@ -41,7 +40,7 @@
                 AnimationData data = animationData[0];
 
                 bool filled = false;
-                if (data.frames is {Count: 0} && GUILayout.Button("Fill Sprites From Animation Sources"))
+                if (data.frames is { Count: 0 } && GUILayout.Button("Fill Sprites From Animation Sources"))
                 {
                     List<string> animationPaths = new();
                     foreach (Object animationSource in animationSources)
@@ -49,7 +48,7 @@
                         string assetPath = AssetDatabase.GetAssetPath(animationSource);
                         animationPaths.Add(assetPath);
                     }
-                    
+
                     foreach (string assetGuid in AssetDatabase.FindAssets("t:sprite", animationPaths.ToArray()))
                     {
                         string path = AssetDatabase.GUIDToAssetPath(assetGuid);
@@ -63,14 +62,15 @@
                     filled = true;
                 }
 
-                if (data.frames is { Count: > 0} && (filled || GUILayout.Button("Auto Parse Sprites")))
+                if (data.frames is { Count: > 0 } && (filled || GUILayout.Button("Auto Parse Sprites")))
                 {
                     Dictionary<string, Dictionary<string, List<Texture2D>>> texturesByPrefixAndAssetPath = new();
                     foreach (Texture2D frame in data.frames)
                     {
                         string assetPathWithFrameName = AssetDatabase.GetAssetPath(frame);
                         string frameName = frame.name;
-                        string assetPath = assetPathWithFrameName.Substring(0, assetPathWithFrameName.LastIndexOf(frameName, StringComparison.Ordinal));
+                        string assetPath = assetPathWithFrameName.Substring(
+                            0, assetPathWithFrameName.LastIndexOf(frameName, StringComparison.Ordinal));
                         int lastNumericIndex = frameName.Length - 1;
                         for (int i = frameName.Length - 1; 0 <= i; --i)
                         {
@@ -87,7 +87,8 @@
                             : Math.Max(lastUnderscoreIndex, lastNumericIndex);
                         if (0 < lastIndex)
                         {
-                            Dictionary<string, List<Texture2D>> texturesByPrefix = texturesByPrefixAndAssetPath.GetOrAdd(assetPath);
+                            Dictionary<string, List<Texture2D>> texturesByPrefix =
+                                texturesByPrefixAndAssetPath.GetOrAdd(assetPath);
                             string key = frameName.Substring(0, lastIndex);
                             texturesByPrefix.GetOrAdd(key).Add(frame);
                         }
@@ -100,16 +101,16 @@
                     if (0 < texturesByPrefixAndAssetPath.Count)
                     {
                         animationData.Clear();
-                        foreach (KeyValuePair<string, Dictionary<string, List<Texture2D>>> assetPathAndTextures in texturesByPrefixAndAssetPath)
+                        foreach (KeyValuePair<string, Dictionary<string, List<Texture2D>>> assetPathAndTextures in
+                                 texturesByPrefixAndAssetPath)
                         {
-                            string assetPath = assetPathAndTextures.Key;
-                            foreach (KeyValuePair<string, List<Texture2D>> textureAndPrefix in assetPathAndTextures.Value)
+                            foreach (KeyValuePair<string, List<Texture2D>> textureAndPrefix in assetPathAndTextures
+                                         .Value)
                             {
                                 AnimationData newData = new()
                                 {
                                     frames = textureAndPrefix.Value,
                                     framesPerSecond = data.framesPerSecond,
-                                    assetPath = assetPath,
                                     animationName = $"Anim_{textureAndPrefix.Key}"
                                 };
                                 animationData.Add(newData);
@@ -165,7 +166,8 @@
                 int framesPerSecond = data.framesPerSecond;
                 if (framesPerSecond <= 0)
                 {
-                    this.LogWarn("Ignoring animationData with FPS of {0} with name {1}.", framesPerSecond, animationName);
+                    this.LogWarn(
+                        "Ignoring animationData with FPS of {0} with name {1}.", framesPerSecond, animationName);
                     continue;
                 }
 
@@ -205,7 +207,8 @@
                     animationClip,
                     EditorCurveBinding.PPtrCurve("", typeof(SpriteRenderer), "m_Sprite"), keyFrames.ToArray());
                 string assetPathWithFileNameAndExtension = AssetDatabase.GetAssetPath(frames[0]);
-                string assetPath = assetPathWithFileNameAndExtension.Substring(0, assetPathWithFileNameAndExtension.LastIndexOf("/", StringComparison.Ordinal) + 1);
+                string assetPath = assetPathWithFileNameAndExtension.Substring(
+                    0, assetPathWithFileNameAndExtension.LastIndexOf("/", StringComparison.Ordinal) + 1);
 
                 ProjectWindowUtil.CreateAsset(animationClip, assetPath + animationName + ".anim");
             }

package/Editor/CustomEditors/MatchColliderToSpriteEditor.cs

@@ -0,0 +1,31 @@
+namespace UnityHelpers.Editor.CustomEditors
+{
+#if UNITY_EDITOR
+    using Core.Extension;
+    using UnityEditor;
+    using UnityEngine;
+    using UnityHelpers.Utils;
+
+    [CustomEditor(typeof(MatchColliderToSprite))]
+    public sealed class MatchColliderToSpriteEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            base.OnInspectorGUI();
+
+            MatchColliderToSprite matchColliderToSprite = target as MatchColliderToSprite;
+            if (matchColliderToSprite == null)
+            {
+                this.LogError(
+                    "Target was of type {0}, expected {1}.", target?.GetType(), typeof(MatchColliderToSprite));
+                return;
+            }
+
+            if (GUILayout.Button("MatchColliderToSprite"))
+            {
+                matchColliderToSprite.OnValidate();
+            }
+        }
+    }
+#endif
+}

package/Editor/CustomEditors/MatchColliderToSpriteEditor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 47c2b6576aee42869685c6b9c1d565bd
+timeCreated: 1720738619

package/Editor/CustomEditors.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2edcc08721b94e54b6d2795c2000eee6
+timeCreated: 1720738611

package/Editor/PrefabCheckWizard.cs

@@ -11,7 +11,7 @@
     using UnityEngine;
     using Core.Extension;
     using Core.Helper;
-    using Utils;
+    using UnityHelpers.Utils;
     using Object = UnityEngine.Object;
 
     public sealed class PrefabCheckWizard : ScriptableWizard

package/Editor/SpriteSettingsApplier.cs

@@ -0,0 +1,154 @@
+namespace UnityHelpers.Editor
+{
+#if UNITY_EDITOR
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using Core.Extension;
+    using UnityEditor;
+    using UnityEngine;
+    using Object = UnityEngine.Object;
+
+    [Serializable]
+    public sealed class SpriteSettings
+    {
+        public int pixelsPerUnit = 100;
+        public Vector2 pivot = new(0.5f, 0.5f);
+        public SpriteImportMode spriteMode = SpriteImportMode.Single;
+        public bool applyWrapMode = true;
+        public TextureWrapMode wrapMode = TextureWrapMode.Clamp;
+        public bool applyFilterMode = true;
+        public FilterMode filterMode = FilterMode.Point;
+        public string name;
+    }
+
+    public sealed class SpriteSettingsApplier : ScriptableWizard
+    {
+        public List<Sprite> sprites = new();
+        public List<string> spriteFileExtensions = new() { ".png" };
+
+        [Tooltip(
+            "Drag various sprite settings here, where the name property matches a sprite asset name. The first settings with an empty or matching name will be applied to each and every sprite.")]
+        public List<SpriteSettings> spriteSettings = new() { new SpriteSettings() };
+
+        [Tooltip(
+            "Drag a folder from Unity here to apply the configuration to all settings under it. No sprites are modified if no directories are provided.")]
+        public List<Object> directories = new();
+
+        [MenuItem("Tools/Unity Helpers/Sprite Settings Applier")]
+        public static void CreateAnimation()
+        {
+            _ = DisplayWizard<SpriteSettingsApplier>("Sprite Settings Directory Applier", "Set");
+        }
+
+        private void OnWizardCreate()
+        {
+            HashSet<string> uniqueDirectories = new();
+            foreach (Object directory in directories)
+            {
+                string assetPath = AssetDatabase.GetAssetPath(directory);
+                if (Directory.Exists(assetPath))
+                {
+                    _ = uniqueDirectories.Add(assetPath);
+                }
+            }
+
+            HashSet<string> processedSpritePaths = new();
+            Queue<string> directoriesToCheck = new(uniqueDirectories);
+            int spriteCount = 0;
+            while (0 < directoriesToCheck.Count)
+            {
+                string directoryPath = directoriesToCheck.Dequeue();
+                foreach (string fullFilePath in Directory.EnumerateFiles(directoryPath))
+                {
+                    if (!spriteFileExtensions.Contains(Path.GetExtension(fullFilePath)))
+                    {
+                        continue;
+                    }
+
+                    int index = fullFilePath.LastIndexOf(directoryPath, StringComparison.OrdinalIgnoreCase);
+                    if (index < 0)
+                    {
+                        continue;
+                    }
+
+                    string filePath = fullFilePath.Substring(index);
+                    if (processedSpritePaths.Add(fullFilePath) && TryUpdateTextureSettings(filePath))
+                    {
+                        ++spriteCount;
+                    }
+                }
+
+                foreach (string subDirectory in Directory.EnumerateDirectories(directoryPath))
+                {
+                    int index = subDirectory.LastIndexOf(directoryPath, StringComparison.OrdinalIgnoreCase);
+                    if (index < 0)
+                    {
+                        continue;
+                    }
+
+                    directoriesToCheck.Enqueue(subDirectory.Substring(index));
+                }
+            }
+
+            foreach (Sprite sprite in sprites)
+            {
+                if (sprite == null)
+                {
+                    continue;
+                }
+
+                string filePath = AssetDatabase.GetAssetPath(sprite);
+                if (processedSpritePaths.Add(Application.dataPath + filePath) && TryUpdateTextureSettings(filePath))
+                {
+                    ++spriteCount;
+                }
+            }
+
+            this.Log("Processed {0} sprites.", spriteCount);
+            if (0 < spriteCount)
+            {
+                AssetDatabase.Refresh();
+            }
+        }
+
+        private bool TryUpdateTextureSettings(string filePath)
+        {
+            TextureImporter textureImporter = AssetImporter.GetAtPath(filePath) as TextureImporter;
+            if (textureImporter == null)
+            {
+                return false;
+            }
+
+            SpriteSettings spriteData = spriteSettings.FirstOrDefault(
+                settings => string.IsNullOrEmpty(settings.name) || filePath.Contains(settings.name));
+            if (spriteData == null)
+            {
+                return false;
+            }
+
+            textureImporter.spritePivot = spriteData.pivot;
+            textureImporter.spritePixelsPerUnit = spriteData.pixelsPerUnit;
+
+            TextureImporterSettings settings = new();
+            textureImporter.ReadTextureSettings(settings);
+            settings.spriteAlignment = (int)SpriteAlignment.Custom;
+            settings.spriteMode = (int)spriteData.spriteMode;
+            if (spriteData.applyWrapMode)
+            {
+                settings.wrapMode = spriteData.wrapMode;
+            }
+
+            if (spriteData.applyFilterMode)
+            {
+                settings.filterMode = spriteData.filterMode;
+            }
+
+            textureImporter.SetTextureSettings(settings);
+            textureImporter.SaveAndReimport();
+            return true;
+        }
+    }
+#endif
+}

package/Editor/SpriteSettingsApplier.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d9b66c9d9bef484c9c916fc474d24c86
+timeCreated: 1720665873

package/Editor/TextureResizerWizard.cs

@@ -0,0 +1,158 @@
+namespace UnityHelpers.Editor
+{
+#if UNITY_EDITOR
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.IO;
+    using System.Linq;
+    using Core.Extension;
+    using Core.Helper;
+    using UnityEditor;
+    using UnityEngine;
+    using UnityEngine.Serialization;
+    using UnityHelpers.Utils;
+    using Utils;
+    using Object = UnityEngine.Object;
+
+    public sealed class TextureResizerWizard : ScriptableWizard
+    {
+        public enum ResizeAlgorithm
+        {
+            Bilinear,
+            Point
+        }
+
+        public List<Texture2D> textures = new();
+
+        [FormerlySerializedAs("animationSources")]
+        [Tooltip(
+            "Drag a folder from Unity here to apply the configuration to all textures under it. No textures are modified if no directories are provided.")]
+        public List<Object> textureSourcePaths = new();
+
+        public int numResizes = 1;
+
+        [Tooltip("Resize algorithm to use for scaling.")]
+        public ResizeAlgorithm scalingResizeAlgorithm = ResizeAlgorithm.Bilinear;
+
+        public int pixelsPerUnit = 100;
+        public float widthMultiplier = 0.54f;
+        public float heightMultiplier = 0.245f;
+
+        [MenuItem("Tools/Unity Helpers/Texture Resizer")]
+        public static void ResizeTextures()
+        {
+            _ = DisplayWizard<TextureResizerWizard>("Texture Resizer", "Resize");
+        }
+
+        private void OnWizardCreate()
+        {
+            textures ??= new List<Texture2D>();
+            textureSourcePaths ??= new List<Object>();
+            HashSet<string> animationPaths = new();
+            foreach (Object animationSource in textureSourcePaths)
+            {
+                string assetPath = AssetDatabase.GetAssetPath(animationSource);
+                if (!string.IsNullOrEmpty(assetPath))
+                {
+                    _ = animationPaths.Add(assetPath);
+                }
+            }
+
+            if (animationPaths.Any())
+            {
+                foreach (string assetGuid in AssetDatabase.FindAssets("t:texture2D", animationPaths.ToArray()))
+                {
+                    string path = AssetDatabase.GUIDToAssetPath(assetGuid);
+                    if (string.IsNullOrEmpty(path))
+                    {
+                        continue;
+                    }
+
+                    Texture2D texture = AssetDatabase.LoadAssetAtPath<Texture2D>(path);
+                    if (texture != null)
+                    {
+                        textures.Add(texture);
+                    }
+                }
+            }
+
+            textures = textures.Distinct().OrderBy(texture => texture.name).ToList();
+            if (textures.Count <= 0 || numResizes <= 0)
+            {
+                return;
+            }
+
+            for (int i = 0; i < numResizes; ++i)
+            {
+                foreach (Texture2D inputTexture in textures)
+                {
+                    Texture2D texture = inputTexture;
+                    string assetPath = AssetDatabase.GetAssetPath(texture);
+                    if (string.IsNullOrEmpty(assetPath))
+                    {
+                        continue;
+                    }
+
+                    TextureImporter tImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
+                    if (tImporter == null)
+                    {
+                        continue;
+                    }
+
+                    bool isReadable = tImporter.isReadable;
+                    if (!isReadable)
+                    {
+                        tImporter.isReadable = true;
+                        tImporter.SaveAndReimport();
+                        AssetDatabase.Refresh();
+                        texture = AssetDatabase.LoadAssetAtPath<Texture2D>(assetPath);
+                    }
+
+                    Texture2D copy = Instantiate(texture);
+                    try
+                    {
+                        int extraWidth = (int)Math.Round(copy.width / (pixelsPerUnit * widthMultiplier));
+                        int extraHeight = (int)Math.Round(
+                            copy.height / (pixelsPerUnit * heightMultiplier));
+                        if (extraWidth == 0 && extraHeight == 0)
+                        {
+                            continue;
+                        }
+
+                        switch (scalingResizeAlgorithm)
+                        {
+                            case ResizeAlgorithm.Bilinear:
+                                TextureScale.Bilinear(copy, copy.width + extraWidth, copy.height + extraHeight);
+                                break;
+                            case ResizeAlgorithm.Point:
+                                TextureScale.Point(copy, copy.width + extraWidth, copy.height + extraHeight);
+                                break;
+                            default:
+                                throw new InvalidEnumArgumentException(
+                                    nameof(scalingResizeAlgorithm), (int)scalingResizeAlgorithm,
+                                    typeof(ResizeAlgorithm));
+                        }
+
+                        byte[] bytes = copy.EncodeToPNG();
+                        File.WriteAllBytes(assetPath, bytes);
+                        this.Log(
+                            "Resized {0} from [{1}x{2}] to [{3}x{4}]", texture.name, texture.width, texture.height,
+                            copy.width, copy.height);
+                    }
+                    catch (Exception e)
+                    {
+                        this.LogError("Failed to resize {0}.", e, texture.name);
+                    }
+                    finally
+                    {
+                        copy.Destroy();
+                    }
+                }
+
+                AssetDatabase.Refresh();
+            }
+        }
+    }
+#endif
+}

package/Editor/TextureResizerWizard.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7c92d51f5bf348dfac9d569358f42c13
+timeCreated: 1720666783

package/Editor/TextureSettingsApplier.cs

@@ -0,0 +1,158 @@
+namespace UnityHelpers.Editor
+{
+#if UNITY_EDITOR
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using Core.Extension;
+    using UnityEditor;
+    using UnityEngine;
+    using UnityHelpers.Utils;
+    using Object = UnityEngine.Object;
+
+    public sealed class TextureSettingsApplier : ScriptableWizard
+    {
+        public bool applyReadOnly = false;
+        public bool isReadOnly = false;
+        public bool applyMipMaps = false;
+        public bool generateMipMaps = false;
+        public bool applyWrapMode = false;
+        public TextureWrapMode wrapMode = TextureWrapMode.Clamp;
+        public bool applyFilterMode = false;
+        public FilterMode filterMode = FilterMode.Trilinear;
+        public TextureImporterCompression compression = TextureImporterCompression.CompressedHQ;
+        public bool useCrunchCompression = true;
+        public TextureResizeAlgorithm textureResizeAlgorithm = TextureResizeAlgorithm.Bilinear;
+        public int maxTextureSize = SetTextureImportData.MaxTextureSize;
+        public TextureImporterFormat textureFormat = TextureImporterFormat.Automatic;
+        public List<string> spriteFileExtensions = new() { ".png" };
+
+        public List<Texture2D> textures = new();
+
+        [Tooltip(
+            "Drag a folder from Unity here to apply the configuration to all settings under it. No sprites are modified if no directories are provided.")]
+        public List<Object> directories = new();
+
+        [MenuItem("Tools/Unity Helpers/Texture Settings Applier")]
+        public static void CreateAnimation()
+        {
+            _ = DisplayWizard<TextureSettingsApplier>("Texture Settings Directory Applier", "Set");
+        }
+
+        private void OnWizardCreate()
+        {
+            HashSet<string> uniqueDirectories = new();
+            foreach (Object directory in directories)
+            {
+                string assetPath = AssetDatabase.GetAssetPath(directory);
+                if (Directory.Exists(assetPath))
+                {
+                    _ = uniqueDirectories.Add(assetPath);
+                }
+            }
+
+            int textureCount = 0;
+            HashSet<string> processedPaths = new();
+            foreach (Texture2D texture in textures?
+                                              .Distinct()
+                                              .OrderBy(texture => texture != null ? texture.name : string.Empty) ??
+                                          Enumerable.Empty<Texture2D>())
+            {
+                if (texture == null)
+                {
+                    continue;
+                }
+
+                string assetPath = AssetDatabase.GetAssetPath(texture);
+                if (processedPaths.Add(Application.dataPath + assetPath) && TryUpdateTextureSettings(assetPath))
+                {
+                    ++textureCount;
+                }
+            }
+
+            Queue<string> directoriesToCheck = new(uniqueDirectories);
+            while (directoriesToCheck.TryDequeue(out string directoryPath))
+            {
+                foreach (string fullFilePath in Directory.EnumerateFiles(directoryPath))
+                {
+                    if (!spriteFileExtensions.Contains(Path.GetExtension(fullFilePath)))
+                    {
+                        continue;
+                    }
+
+                    int index = fullFilePath.LastIndexOf(directoryPath, StringComparison.OrdinalIgnoreCase);
+                    if (index < 0)
+                    {
+                        continue;
+                    }
+
+                    string filePath = fullFilePath.Substring(index);
+                    if (processedPaths.Add(fullFilePath) && TryUpdateTextureSettings(filePath))
+                    {
+                        ++textureCount;
+                    }
+                }
+
+                foreach (string subDirectory in Directory.EnumerateDirectories(directoryPath))
+                {
+                    int index = subDirectory.LastIndexOf(directoryPath, StringComparison.OrdinalIgnoreCase);
+                    if (index < 0)
+                    {
+                        continue;
+                    }
+
+                    directoriesToCheck.Enqueue(subDirectory.Substring(index));
+                }
+            }
+
+            this.Log("Processed {0} textures.", textureCount);
+            if (0 < textureCount)
+            {
+                AssetDatabase.Refresh();
+            }
+        }
+
+        private bool TryUpdateTextureSettings(string filePath)
+        {
+            TextureImporter textureImporter = AssetImporter.GetAtPath(filePath) as TextureImporter;
+            if (textureImporter == null)
+            {
+                return false;
+            }
+
+            textureImporter.SetPlatformTextureSettings(
+                new TextureImporterPlatformSettings
+                {
+                    resizeAlgorithm = textureResizeAlgorithm,
+                    maxTextureSize = maxTextureSize,
+                    format = textureFormat,
+                    textureCompression = compression,
+                    crunchedCompression = useCrunchCompression,
+                });
+            if (applyReadOnly)
+            {
+                textureImporter.isReadable = !isReadOnly;
+            }
+
+            if (applyMipMaps)
+            {
+                textureImporter.mipmapEnabled = generateMipMaps;
+            }
+
+            if (applyWrapMode)
+            {
+                textureImporter.wrapMode = wrapMode;
+            }
+
+            if (applyFilterMode)
+            {
+                textureImporter.filterMode = filterMode;
+            }
+
+            textureImporter.SaveAndReimport();
+            return true;
+        }
+    }
+#endif
+}

package/Editor/TextureSettingsApplier.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 23e3474825574ecfa1084d4d4ca83ebd
+timeCreated: 1720666563

package/Editor/Utils/EditorUtilities.cs

@@ -0,0 +1,20 @@
+namespace UnityHelpers.Editor.Utils
+{
+#if UNITY_EDITOR
+    using System;
+    using System.Reflection;
+    using UnityEditor;
+
+    public static class EditorUtilities
+    {
+        public static string GetCurrentPathOfProjectWindow()
+        {
+            Type projectWindowUtilType = typeof(ProjectWindowUtil);
+            MethodInfo getActiveFolderPath = projectWindowUtilType.GetMethod(
+                "GetActiveFolderPath", BindingFlags.Static | BindingFlags.NonPublic);
+            object obj = getActiveFolderPath?.Invoke(null, Array.Empty<object>());
+            return obj?.ToString() ?? string.Empty;
+        }
+    }
+#endif
+}

package/Editor/Utils/EditorUtilities.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9256940fb08e3b847a327d916cdce82c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/Utils/ReadOnlyPropertyDrawer.cs

@@ -0,0 +1,28 @@
+namespace UnityHelpers.Editor.Utils
+{
+#if UNITY_EDITOR
+    using Core.Attributes;
+    using UnityEditor;
+    using UnityEngine;
+
+    // https://www.patrykgalach.com/2020/01/20/readonly-attribute-in-unity-editor/
+    [CustomPropertyDrawer(typeof(ReadOnlyAttribute))]
+    public sealed class ReadOnlyPropertyDrawer : PropertyDrawer
+    {
+        public override float GetPropertyHeight(
+            SerializedProperty property,
+            GUIContent label)
+        {
+            return EditorGUI.GetPropertyHeight(property, label, true);
+        }
+
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            bool previousGUIState = GUI.enabled;
+            GUI.enabled = false;
+            _ = EditorGUI.PropertyField(position, property, label);
+            GUI.enabled = previousGUIState;
+        }
+    }
+#endif
+}

package/Editor/Utils/ReadOnlyPropertyDrawer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c10f5b90c98ae0d48a81cf8d36a9d9ef
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/Utils.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b8d1e55b56715f64db1fa9dabc1cb498
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Utils/CenterPointOffset.cs

@@ -0,0 +1,31 @@
+namespace UnityHelpers.Utils
+{
+    using Core.Attributes;
+    using UnityEngine;
+
+    [DisallowMultipleComponent]
+    public sealed class CenterPointOffset : MonoBehaviour
+    {
+        public Vector2 offset = Vector2.zero;
+
+        public bool spriteUsesOffset = true;
+
+        [SiblingComponent]
+        private Transform _transform;
+
+        private void Awake()
+        {
+            this.AssignSiblingComponents();
+        }
+
+        public Vector2 CenterPoint
+        {
+            get
+            {
+                Vector2 scaledOffset = offset * _transform.localScale;
+                return (Vector2)_transform.position + scaledOffset;
+            }
+        }
+    }
+
+}

package/Runtime/Utils/CenterPointOffset.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f1e1dfbe10214f8b8f30acd34d67aa7f
+timeCreated: 1720737954

package/Runtime/Utils/CoroutineHandler.cs

@@ -0,0 +1,4 @@
+namespace UnityHelpers.Utils
+{
+    public sealed class CoroutineHandler : RuntimeSingleton<CoroutineHandler> { }
+}

package/Runtime/Utils/CoroutineHandler.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ba52cce99edd4592999c269422e4f20a
+timeCreated: 1720740992

package/Runtime/Utils/MatchColliderToSprite.cs

@@ -0,0 +1,80 @@
+namespace UnityHelpers.Utils
+{
+    using System;
+    using System.Collections.Generic;
+    using Core.Attributes;
+    using Core.Extension;
+    using UnityEngine;
+
+    [DisallowMultipleComponent]
+    public sealed class MatchColliderToSprite : MonoBehaviour
+    {
+        [SerializeField]
+        [SiblingComponent]
+        private SpriteRenderer _spriteRenderer;
+        
+        [SerializeField]
+        [SiblingComponent]
+        private PolygonCollider2D _collider;
+
+        private Sprite _lastHandled;
+
+        private void Awake()
+        {
+            this.AssignSiblingComponents();
+            OnValidate();
+        }
+
+        private void Update()
+        {
+            if (_lastHandled == _spriteRenderer.sprite)
+            {
+                return;
+            }
+
+            OnValidate();
+        }
+
+        // Visible for testing
+        public void OnValidate()
+        {
+            if (_spriteRenderer == null)
+            {
+                _spriteRenderer = GetComponent<SpriteRenderer>();
+                if (_spriteRenderer == null)
+                {
+                    this.LogError("No SpriteRenderer detected - cannot match collider shape.");
+                    return;
+                }
+            }
+
+            if (_collider == null)
+            {
+                _collider = GetComponent<PolygonCollider2D>();
+                if (_collider == null)
+                {
+                    this.LogError("No PolygonCollider2D detected - cannot match collider shape.");
+                    return;
+                }
+            }
+
+            _lastHandled = _spriteRenderer.sprite;
+            _collider.points = Array.Empty<Vector2>();
+            if (_lastHandled == null)
+            {
+                _collider.pathCount = 0;
+                return;
+            }
+
+            int physicsShapes = _lastHandled.GetPhysicsShapeCount();
+            _collider.pathCount = physicsShapes;
+            List<Vector2> buffer = Buffers<Vector2>.List;
+            for (int i = 0; i < physicsShapes; ++i)
+            {
+                buffer.Clear();
+                _ = _lastHandled.GetPhysicsShape(i, buffer);
+                _collider.SetPath(i, buffer);
+            }
+        }
+    }
+}

package/Runtime/Utils/MatchColliderToSprite.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 90f375924f7247ab87a73467faae06b7
+timeCreated: 1720738383

package/Runtime/Utils/RuntimeSingleton.cs

@@ -0,0 +1,31 @@
+namespace UnityHelpers.Utils
+{
+    using UnityEngine;
+
+    [DisallowMultipleComponent]
+    public abstract class RuntimeSingleton<T> : MonoBehaviour where T : RuntimeSingleton<T>
+    {
+        private static T _instance;
+
+        protected virtual bool DontDestroyOnLoad => true;
+
+        public static T Instance
+        {
+            get
+            {
+                if (_instance != null)
+                {
+                    return _instance;
+                }
+
+                GameObject instance = new(typeof(T).Name + "Singleton", typeof(T));
+                _ = instance.TryGetComponent(out _instance);
+                if (_instance.DontDestroyOnLoad)
+                {
+                    DontDestroyOnLoad(instance);
+                }
+                return _instance;
+            }
+        }
+    }
+}

package/Runtime/Utils/RuntimeSingleton.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cbebf3402056afd46a0e23363875c813
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Utils/SetTextureImportData.cs

@@ -17,6 +17,7 @@
             {
                 return;
             }
+
             TextureImporter tImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
 
             if (tImporter == null)
@@ -42,13 +43,14 @@
             {
                 return;
             }
+
             TextureImporter tImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
 
             if (tImporter == null)
             {
                 return;
             }
-            
+
             tImporter.isReadable = isReadable;
 
             TextureImporterPlatformSettings importerSettings = new TextureImporterPlatformSettings
@@ -64,4 +66,4 @@
 # endif
         }
     }
-}
+}

package/Runtime/Utils/TextureScale.cs

@@ -0,0 +1,164 @@
+namespace UnityHelpers.Utils
+{
+    using System.Threading;
+    using UnityEngine;
+
+    // https://answers.unity.com/questions/348163/resize-texture2d-comes-out-grey.html
+    // http://wiki.unity3d.com/index.php/TextureScale
+    public static class TextureScale
+    {
+        private sealed class ThreadData
+        {
+            public readonly int start;
+            public readonly int end;
+
+            public ThreadData(int s, int e)
+            {
+                start = s;
+                end = e;
+            }
+        }
+
+        private static Color[] texColors;
+        private static Color[] newColors;
+        private static int w;
+        private static float ratioX;
+        private static float ratioY;
+        private static int w2;
+        private static int finishCount;
+        private static Mutex mutex;
+
+        public static void Point(Texture2D tex, int newWidth, int newHeight)
+        {
+            ThreadedScale(tex, newWidth, newHeight, false);
+        }
+
+        public static void Bilinear(Texture2D tex, int newWidth, int newHeight)
+        {
+            ThreadedScale(tex, newWidth, newHeight, true);
+        }
+
+        private static void ThreadedScale(Texture2D tex, int newWidth, int newHeight, bool useBilinear)
+        {
+            texColors = tex.GetPixels();
+            newColors = new Color[newWidth * newHeight];
+            if (useBilinear)
+            {
+                ratioX = 1.0f / ((float)newWidth / (tex.width - 1));
+                ratioY = 1.0f / ((float)newHeight / (tex.height - 1));
+            }
+            else
+            {
+                ratioX = ((float)tex.width) / newWidth;
+                ratioY = ((float)tex.height) / newHeight;
+            }
+
+            w = tex.width;
+            w2 = newWidth;
+            int cores = Mathf.Min(SystemInfo.processorCount, newHeight);
+            int slice = newHeight / cores;
+
+            finishCount = 0;
+            mutex ??= new Mutex(false);
+            if (1 < cores)
+            {
+                int i;
+                ThreadData threadData;
+                for (i = 0; i < cores - 1; i++)
+                {
+                    threadData = new ThreadData(slice * i, slice * (i + 1));
+                    ParameterizedThreadStart ts = useBilinear ? BilinearScale : PointScale;
+                    Thread thread = new(ts);
+                    thread.Start(threadData);
+                }
+
+                threadData = new ThreadData(slice * i, newHeight);
+                if (useBilinear)
+                {
+                    BilinearScale(threadData);
+                }
+                else
+                {
+                    PointScale(threadData);
+                }
+
+                while (finishCount < cores)
+                {
+                    Thread.Sleep(1);
+                }
+            }
+            else
+            {
+                ThreadData threadData = new(0, newHeight);
+                if (useBilinear)
+                {
+                    BilinearScale(threadData);
+                }
+                else
+                {
+                    PointScale(threadData);
+                }
+            }
+
+            _ = tex.Reinitialize(newWidth, newHeight);
+            tex.SetPixels(newColors);
+            tex.Apply();
+
+            texColors = null;
+            newColors = null;
+        }
+
+        private static void BilinearScale(System.Object obj)
+        {
+            ThreadData threadData = (ThreadData)obj;
+            for (int y = threadData.start; y < threadData.end; y++)
+            {
+                int yFloor = (int)Mathf.Floor(y * ratioY);
+                int y1 = yFloor * w;
+                int y2 = (yFloor + 1) * w;
+                int yw = y * w2;
+
+                for (var x = 0; x < w2; x++)
+                {
+                    int xFloor = (int)Mathf.Floor(x * ratioX);
+                    float xLerp = x * ratioX - xFloor;
+                    newColors[yw + x] = ColorLerpUnclamped(
+                        ColorLerpUnclamped(texColors[y1 + xFloor], texColors[y1 + xFloor + 1], xLerp),
+                        ColorLerpUnclamped(texColors[y2 + xFloor], texColors[y2 + xFloor + 1], xLerp),
+                        y * ratioY - yFloor);
+                }
+            }
+
+            _ = mutex.WaitOne();
+            finishCount++;
+            mutex.ReleaseMutex();
+        }
+
+        private static void PointScale(System.Object obj)
+        {
+            ThreadData threadData = (ThreadData)obj;
+            for (int y = threadData.start; y < threadData.end; y++)
+            {
+                int thisY = (int)(ratioY * y) * w;
+                int yw = y * w2;
+                for (var x = 0; x < w2; x++)
+                {
+                    newColors[yw + x] = texColors[(int)(thisY + ratioX * x)];
+                }
+            }
+
+            _ = mutex.WaitOne();
+            finishCount++;
+            mutex.ReleaseMutex();
+        }
+
+        private static Color ColorLerpUnclamped(Color c1, Color c2, float value)
+        {
+            return new Color(
+                c1.r + (c2.r - c1.r) * value,
+                c1.g + (c2.g - c1.g) * value,
+                c1.b + (c2.b - c1.b) * value,
+                c1.a + (c2.a - c1.a) * value);
+        }
+    }
+}

package/Runtime/Utils/TextureScale.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 985292b70519406bafda70e5ab4e06ce
+timeCreated: 1720667849

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "1.0.1-rc03",
+  "version": "1.0.1-rc04",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {