com.wallstop-studios.unity-helpers 2.0.0-rc42 → 2.0.0-rc44

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/README.md

@@ -129,6 +129,22 @@ random.NextNoiseMap(width, height); // A configurable noise map generated using
 - XorShift
 - XorShiro
 
+## Performance (Number of Operations / Second)
+
+| Random | NextBool | Next | NextUInt | NextFloat | NextDouble | NextUint - Range | NextInt - Range |
+| ------ | -------- | ---- | -------- | --------- | ---------- | ---------------- | --------------- |
+| PcgRandom | 34,260,478 | 34,303,866 | 35,148,246 | 24,818,438 | 30,034,632 |22,436,474 |20,801,797 |
+| SystemRandom | 28,698,806 | 30,040,782 | 20,435,092 | 24,079,399 | 27,284,147 |20,735,769 |19,861,780 |
+| SquirrelRandom | 33,285,784 | 33,439,909 | 34,611,893 | 23,885,731 | 28,958,725 |21,520,279 |20,311,372 |
+| XorShiftRandom | 34,695,989 | 35,147,320 | 35,997,718 | 25,248,238 | 31,582,991 |22,679,928 |21,255,319 |
+| DotNetRandom | 18,097,489 | 18,191,042 | 18,783,063 | 14,061,444 | 15,730,439 |13,284,050 |12,596,913 |
+| WyRandom | 28,490,852 | 29,086,052 | 29,724,907 | 20,252,065 | 24,542,201 |18,474,790 |17,404,641 |
+| SplitMix64 | 34,301,843 | 34,343,404 | 35,512,284 | 24,289,416 | 30,586,231 |22,470,330 |20,850,965 |
+| RomuDuo | 32,969,889 | 33,413,212 | 34,339,227 | 23,755,059 | 29,483,136 |21,671,641 |20,253,479 |
+| XorShiroRandom | 31,529,025 | 31,717,709 | 32,536,277 | 22,421,715 | 27,619,417 |20,843,993 |19,270,063 |
+| UnityRandom | 24,925,268 | 24,830,594 | 26,429,283 | 17,864,528 | 21,206,384 |16,376,626 |15,528,972 |
+| LinearCongruentialGenerator | 35,013,818 | 35,025,182 | 35,843,533 | 25,093,401 | 31,553,487 |22,579,798 |21,211,175 |
+
 # Spatial Trees
 There are three implemented 2D immutable spatial trees that can store generic objects, as long as there is some resolution function that can convert them into Vector2 spatial positions.
 

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