com.wallstop-studios.unity-helpers 2.0.0-rc41 → 2.0.0-rc43

package/Editor/AnimationCopier.cs

@@ -43,7 +43,7 @@
             }
         }
 
-        [MenuItem("Tools/Unity Helpers/Animation Copier")]
+        [MenuItem("Tools/Unity Helpers/Animation Copier", priority = -2)]
         public static void CopyAnimations()
         {
             _ = DisplayWizard<AnimationCopier>("Animation Copier", "Copy");

package/Editor/AnimationCreator.cs

@@ -25,7 +25,7 @@
         public List<Object> animationSources = new();
         public string text;
 
-        [MenuItem("Tools/Unity Helpers/Animation Creator")]
+        [MenuItem("Tools/Unity Helpers/Animation Creator", priority = -3)]
         public static void CreateAnimation()
         {
             _ = DisplayWizard<AnimationCreator>("Animation Creator", "Create");

package/Editor/{EnsureTextureSizeWizard.cs → FitTextureSizeWizard.cs}

@@ -6,16 +6,24 @@
     using UnityEditor;
     using UnityEngine;
 
-    public sealed class EnsureTextureSizeWizard : ScriptableWizard
+    public enum FitMode
     {
+        GrowAndShrink = 0,
+        GrowOnly = 1,
+        ShrinkOnly = 2,
+    }
+
+    public sealed class FitTextureSizeWizard : ScriptableWizard
+    {
+        public FitMode fitMode = FitMode.GrowAndShrink;
         public List<Texture2D> textures = new();
 
         public List<Object> textureSourcePaths = new();
 
-        [MenuItem("Tools/Unity Helpers/Ensure Texture Size")]
+        [MenuItem("Tools/Unity Helpers/Fit Texture Size", priority = -1)]
         public static void EnsureSizes()
         {
-            _ = DisplayWizard<EnsureTextureSizeWizard>("Ensure Texture Size", "Run");
+            _ = DisplayWizard<FitTextureSizeWizard>("Fit Texture Size", "Run");
         }
 
         private void OnWizardCreate()
@@ -68,36 +76,60 @@
             }
 
             int changedCount = 0;
-            foreach (Texture2D inputTexture in textures)
+            foreach (Texture2D texture in textures)
             {
-                Texture2D texture = inputTexture;
                 string assetPath = AssetDatabase.GetAssetPath(texture);
                 if (string.IsNullOrWhiteSpace(assetPath))
                 {
                     continue;
                 }
 
-                TextureImporter tImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
-                if (tImporter == null)
+                TextureImporter textureImporter =
+                    AssetImporter.GetAtPath(assetPath) as TextureImporter;
+                if (textureImporter == null)
                 {
                     continue;
                 }
-                tImporter.GetSourceTextureWidthAndHeight(out int width, out int height);
+                textureImporter.GetSourceTextureWidthAndHeight(out int width, out int height);
 
                 float size = Mathf.Max(width, height);
-                int textureSize = tImporter.maxTextureSize;
+                int textureSize = textureImporter.maxTextureSize;
+                int originalTextureSize = textureSize;
                 bool changed = false;
-                while (textureSize < size)
+                if (fitMode is FitMode.GrowAndShrink or FitMode.GrowOnly)
                 {
-                    changed = true;
-                    textureSize <<= 1;
+                    while (textureSize < size)
+                    {
+                        changed = true;
+                        textureSize <<= 1;
+                    }
                 }
-                tImporter.maxTextureSize = textureSize;
+
+                if (fitMode is FitMode.GrowAndShrink or FitMode.ShrinkOnly)
+                {
+                    while (0 < textureSize && size <= (textureSize >> 1))
+                    {
+                        changed = true;
+                        textureSize >>= 1;
+                    }
+                }
+
+                textureImporter.maxTextureSize = textureSize;
 
                 if (changed)
                 {
-                    changedCount++;
-                    tImporter.SaveAndReimport();
+                    ++changedCount;
+                    textureImporter.SaveAndReimport();
+                    if (textureImporter.maxTextureSize != textureSize)
+                    {
+                        this.LogError(
+                            $"Failed to update {texture.name}, need texture size {textureSize} but got {textureImporter.maxTextureSize}. Path: '{assetPath}'."
+                        );
+                        if (originalTextureSize != textureImporter.maxTextureSize)
+                        {
+                            --changedCount;
+                        }
+                    }
                 }
             }
 

package/Editor/PrefabCheckWizard.cs

@@ -23,7 +23,7 @@
         )]
         public List<Object> assetPaths = new();
 
-        [MenuItem("Tools/Unity Helpers/Prefab Check Wizard")]
+        [MenuItem("Tools/Unity Helpers/Prefab Check Wizard", priority = -1)]
         public static void CreatePrefabCheckWizard()
         {
             _ = DisplayWizard<PrefabCheckWizard>("Prefab sanity check", "Run");
@@ -34,7 +34,10 @@
             List<string> parsedAssetPaths;
             if (assetPaths is { Count: > 0 })
             {
-                parsedAssetPaths = assetPaths.Select(AssetDatabase.GetAssetPath).ToList();
+                parsedAssetPaths = assetPaths
+                    .Where(Objects.NotNull)
+                    .Select(AssetDatabase.GetAssetPath)
+                    .ToList();
                 parsedAssetPaths.RemoveAll(string.IsNullOrEmpty);
                 if (parsedAssetPaths.Count <= 0)
                 {
@@ -102,29 +105,6 @@
                 )
             )
             {
-                bool LogIfNull(object thing, int? position = null)
-                {
-                    if (thing == null || (thing is Object unityThing && !unityThing))
-                    {
-                        if (position == null)
-                        {
-                            component.LogError("Field {0} has a null element in it.", field.Name);
-                        }
-                        else
-                        {
-                            component.LogError(
-                                "Field {0} has a null element at position {1}.",
-                                field.Name,
-                                position
-                            );
-                        }
-
-                        return true;
-                    }
-
-                    return false;
-                }
-
                 object fieldValue = field.GetValue(component);
 
                 if (field.FieldType.IsArray)
@@ -158,6 +138,31 @@
                 {
                     _ = LogIfNull(thing, position++);
                 }
+
+                continue;
+
+                bool LogIfNull(object thing, int? position = null)
+                {
+                    if (thing == null || (thing is Object unityThing && !unityThing))
+                    {
+                        if (position == null)
+                        {
+                            component.LogError("Field {0} has a null element in it.", field.Name);
+                        }
+                        else
+                        {
+                            component.LogError(
+                                "Field {0} has a null element at position {1}.",
+                                field.Name,
+                                position
+                            );
+                        }
+
+                        return true;
+                    }
+
+                    return false;
+                }
             }
         }
     }

package/Editor/SpriteSettingsApplier.cs

@@ -5,7 +5,9 @@
     using System.Collections.Generic;
     using System.IO;
     using System.Linq;
+    using Core.Attributes;
     using Core.Extension;
+    using Core.Helper;
     using UnityEditor;
     using UnityEngine;
     using Object = UnityEngine.Object;
@@ -13,14 +15,53 @@
     [Serializable]
     public sealed class SpriteSettings
     {
+        public bool applyPixelsPerUnit;
+
+        [WShowIf(nameof(applyPixelsPerUnit))]
         public int pixelsPerUnit = 100;
+
+        public bool applyPivot;
+
+        [WShowIf(nameof(applyPivot))]
         public Vector2 pivot = new(0.5f, 0.5f);
+
+        public bool applySpriteMode;
+
+        [WShowIf(nameof(applySpriteMode))]
         public SpriteImportMode spriteMode = SpriteImportMode.Single;
-        public bool applyWrapMode = true;
+
+        public bool applyGenerateMipMaps;
+
+        [WShowIf(nameof(applyGenerateMipMaps))]
+        public bool generateMipMaps;
+
+        public bool applyAlphaIsTransparency;
+
+        [WShowIf(nameof(applyAlphaIsTransparency))]
+        public bool alphaIsTransparency = true;
+
+        public bool applyReadWriteEnabled;
+
+        [WShowIf(nameof(applyReadWriteEnabled))]
+        public bool readWriteEnabled = true;
+
+        public bool applyExtrudeEdges;
+
+        [WShowIf(nameof(applyExtrudeEdges))]
+        [Range(0, 32)]
+        public uint extrudeEdges = 1;
+
+        public bool applyWrapMode;
+
+        [WShowIf(nameof(applyWrapMode))]
         public TextureWrapMode wrapMode = TextureWrapMode.Clamp;
-        public bool applyFilterMode = true;
+
+        public bool applyFilterMode;
+
+        [WShowIf(nameof(applyFilterMode))]
         public FilterMode filterMode = FilterMode.Point;
-        public string name;
+
+        public string name = string.Empty;
     }
 
     public sealed class SpriteSettingsApplier : ScriptableWizard
@@ -38,7 +79,7 @@
         )]
         public List<Object> directories = new();
 
-        [MenuItem("Tools/Unity Helpers/Sprite Settings Applier")]
+        [MenuItem("Tools/Unity Helpers/Sprite Settings Applier", priority = -2)]
         public static void CreateAnimation()
         {
             _ = DisplayWizard<SpriteSettingsApplier>("Sprite Settings Directory Applier", "Set");
@@ -47,9 +88,13 @@
         private void OnWizardCreate()
         {
             HashSet<string> uniqueDirectories = new();
-            foreach (Object directory in directories)
+            foreach (
+                string assetPath in directories
+                    .Where(Objects.NotNull)
+                    .Select(AssetDatabase.GetAssetPath)
+                    .Where(assetPath => !string.IsNullOrWhiteSpace(assetPath))
+            )
             {
-                string assetPath = AssetDatabase.GetAssetPath(directory);
                 if (Directory.Exists(assetPath))
                 {
                     _ = uniqueDirectories.Add(assetPath);
@@ -59,9 +104,8 @@
             HashSet<string> processedSpritePaths = new();
             Queue<string> directoriesToCheck = new(uniqueDirectories);
             int spriteCount = 0;
-            while (0 < directoriesToCheck.Count)
+            while (directoriesToCheck.TryDequeue(out string directoryPath))
             {
-                string directoryPath = directoriesToCheck.Dequeue();
                 foreach (string fullFilePath in Directory.EnumerateFiles(directoryPath))
                 {
                     if (!spriteFileExtensions.Contains(Path.GetExtension(fullFilePath)))
@@ -102,14 +146,13 @@
                 }
             }
 
-            foreach (Sprite sprite in sprites)
+            foreach (
+                string filePath in sprites
+                    .Where(Objects.NotNull)
+                    .Select(AssetDatabase.GetAssetPath)
+                    .Where(Objects.NotNull)
+            )
             {
-                if (sprite == null)
-                {
-                    continue;
-                }
-
-                string filePath = AssetDatabase.GetAssetPath(sprite);
                 if (
                     processedSpritePaths.Add(Application.dataPath + filePath)
                     && TryUpdateTextureSettings(filePath)
@@ -128,40 +171,101 @@
 
         private bool TryUpdateTextureSettings(string filePath)
         {
+            bool changed = false;
+            if (string.IsNullOrWhiteSpace(filePath))
+            {
+                return changed;
+            }
+
             TextureImporter textureImporter = AssetImporter.GetAtPath(filePath) as TextureImporter;
             if (textureImporter == null)
             {
-                return false;
+                return changed;
             }
 
-            SpriteSettings spriteData = spriteSettings.FirstOrDefault(settings =>
-                string.IsNullOrEmpty(settings.name) || filePath.Contains(settings.name)
+            SpriteSettings spriteData = spriteSettings.Find(settings =>
+                string.IsNullOrWhiteSpace(settings.name) || filePath.Contains(settings.name)
             );
             if (spriteData == null)
             {
-                return false;
+                return changed;
+            }
+
+            if (spriteData.applyPixelsPerUnit)
+            {
+                // ReSharper disable once CompareOfFloatsByEqualityOperator
+                changed |= textureImporter.spritePixelsPerUnit != spriteData.pixelsPerUnit;
+                textureImporter.spritePixelsPerUnit = spriteData.pixelsPerUnit;
             }
 
-            textureImporter.spritePivot = spriteData.pivot;
-            textureImporter.spritePixelsPerUnit = spriteData.pixelsPerUnit;
+            if (spriteData.applyPivot)
+            {
+                changed |= textureImporter.spritePivot != spriteData.pivot;
+                textureImporter.spritePivot = spriteData.pivot;
+            }
 
+            if (spriteData.applyGenerateMipMaps)
+            {
+                changed |= textureImporter.mipmapEnabled != spriteData.generateMipMaps;
+                textureImporter.mipmapEnabled = spriteData.generateMipMaps;
+            }
+
+            bool changedSettings = false;
             TextureImporterSettings settings = new();
             textureImporter.ReadTextureSettings(settings);
-            settings.spriteAlignment = (int)SpriteAlignment.Custom;
-            settings.spriteMode = (int)spriteData.spriteMode;
+            if (spriteData.applyPivot)
+            {
+                changedSettings |= settings.spriteAlignment != (int)SpriteAlignment.Custom;
+                settings.spriteAlignment = (int)SpriteAlignment.Custom;
+            }
+
+            if (spriteData.applyAlphaIsTransparency)
+            {
+                changedSettings |= settings.alphaIsTransparency != spriteData.alphaIsTransparency;
+                settings.alphaIsTransparency = spriteData.alphaIsTransparency;
+            }
+
+            if (spriteData.applyReadWriteEnabled)
+            {
+                changedSettings |= settings.readable != spriteData.readWriteEnabled;
+                settings.readable = spriteData.readWriteEnabled;
+            }
+
+            if (spriteData.applySpriteMode)
+            {
+                changedSettings |= settings.spriteMode != (int)spriteData.spriteMode;
+                settings.spriteMode = (int)spriteData.spriteMode;
+            }
+
+            if (spriteData.applyExtrudeEdges)
+            {
+                changedSettings |= settings.spriteExtrude != spriteData.extrudeEdges;
+                settings.spriteExtrude = spriteData.extrudeEdges;
+            }
+
             if (spriteData.applyWrapMode)
             {
+                changedSettings |= settings.wrapMode != spriteData.wrapMode;
                 settings.wrapMode = spriteData.wrapMode;
             }
 
             if (spriteData.applyFilterMode)
             {
+                changedSettings |= settings.filterMode != spriteData.filterMode;
                 settings.filterMode = spriteData.filterMode;
             }
 
-            textureImporter.SetTextureSettings(settings);
-            textureImporter.SaveAndReimport();
-            return true;
+            if (changedSettings)
+            {
+                textureImporter.SetTextureSettings(settings);
+            }
+            changed |= changedSettings;
+            if (changed)
+            {
+                textureImporter.SaveAndReimport();
+            }
+
+            return changed;
         }
     }
 #endif

package/Editor/TextureSettingsApplier.cs

@@ -5,6 +5,7 @@
     using System.Collections.Generic;
     using System.IO;
     using System.Linq;
+    using Core.Attributes;
     using Core.Extension;
     using UnityEditor;
     using UnityEngine;
@@ -18,9 +19,15 @@
         public bool applyMipMaps = false;
         public bool generateMipMaps = false;
         public bool applyWrapMode = false;
+
+        [WShowIf(nameof(applyWrapMode))]
         public TextureWrapMode wrapMode = TextureWrapMode.Clamp;
+
         public bool applyFilterMode = false;
+
+        [WShowIf(nameof(applyFilterMode))]
         public FilterMode filterMode = FilterMode.Trilinear;
+
         public TextureImporterCompression compression = TextureImporterCompression.CompressedHQ;
         public bool useCrunchCompression = true;
         public TextureResizeAlgorithm textureResizeAlgorithm = TextureResizeAlgorithm.Bilinear;

package/Editor/WShowIfPropertyDrawer.cs

@@ -0,0 +1,63 @@
+namespace UnityHelpers.Editor
+{
+#if UNITY_EDITOR
+    using System.Reflection;
+    using Core.Attributes;
+    using Core.Extension;
+    using UnityEngine;
+    using UnityEditor;
+
+    [CustomPropertyDrawer(typeof(WShowIfAttribute))]
+    public sealed class WShowIfPropertyDrawer : PropertyDrawer
+    {
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            return !ShouldShow(property) ? 0f : EditorGUI.GetPropertyHeight(property, label, true);
+        }
+
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            if (ShouldShow(property))
+            {
+                EditorGUI.PropertyField(position, property, label, true);
+            }
+        }
+
+        private bool ShouldShow(SerializedProperty property)
+        {
+            if (attribute is not WShowIfAttribute showIf)
+            {
+                return true;
+            }
+
+            SerializedProperty conditionProperty = property.serializedObject.FindProperty(
+                showIf.conditionField
+            );
+            if (conditionProperty is not { propertyType: SerializedPropertyType.Boolean })
+            {
+                if (conditionProperty != null)
+                {
+                    return true;
+                }
+
+                // This might not be a unity object, so fall back to reflection
+                object enclosingObject = property.GetEnclosingObject(out _);
+                FieldInfo conditionField = enclosingObject
+                    ?.GetType()
+                    .GetField(
+                        showIf.conditionField,
+                        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
+                    );
+                if (conditionField?.GetValue(enclosingObject) is bool maybeCondition)
+                {
+                    return showIf.inverse ? !maybeCondition : maybeCondition;
+                }
+                return true;
+            }
+
+            bool condition = conditionProperty.boolValue;
+            return showIf.inverse ? !condition : condition;
+        }
+    }
+#endif
+}

package/Editor/WShowIfPropertyDrawer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 69dba17ab0994516865a375df33919f5
+timeCreated: 1742505739

package/Runtime/Core/Attributes/WShowIfAttribute.cs

@@ -0,0 +1,16 @@
+namespace UnityHelpers.Core.Attributes
+{
+    using UnityEngine;
+
+    public sealed class WShowIfAttribute : PropertyAttribute
+    {
+        public readonly string conditionField;
+        public readonly bool inverse;
+
+        public WShowIfAttribute(string conditionField, bool inverse = false)
+        {
+            this.conditionField = conditionField;
+            this.inverse = inverse;
+        }
+    }
+}

package/Runtime/Core/Attributes/WShowIfAttribute.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a8f5bc1c74414b2aaed62f49ae205f0b
+timeCreated: 1742505715