com.wallstop-studios.unity-helpers 2.0.0-rc13 → 2.0.0-rc15

package/Runtime/Core/DataStructure/RTree.cs

@@ -6,19 +6,25 @@
     using System.Linq;
     using Extension;
     using UnityEngine;
+    using Utils;
 
     [Serializable]
     public sealed class RTree<T>
     {
         [Serializable]
-        private sealed class RTreeNode<V>
+        public sealed class RTreeNode<V>
         {
             public readonly Bounds boundary;
-            public readonly RTreeNode<V>[] children;
+            internal readonly RTreeNode<V>[] children;
             public readonly V[] elements;
             public readonly bool isTerminal;
 
-            public RTreeNode(List<V> elements, Func<V, Bounds> elementTransformer, int bucketSize, int branchFactor)
+            public RTreeNode(
+                List<V> elements,
+                Func<V, Bounds> elementTransformer,
+                int bucketSize,
+                int branchFactor
+            )
             {
                 float minX = float.MaxValue;
                 float minY = float.MaxValue;
@@ -35,7 +41,13 @@
                     maxY = Math.Max(maxY, max.y);
                 }
 
-                boundary = elements.Count <= 0 ? new Bounds() : new Bounds(new Vector3(minX + (maxX - minX) / 2, minY + (maxY - minY) / 2), new Vector3(maxX - minX, maxY - minY));
+                boundary =
+                    elements.Count <= 0
+                        ? new Bounds()
+                        : new Bounds(
+                            new Vector3(minX + (maxX - minX) / 2, minY + (maxY - minY) / 2),
+                            new Vector3(maxX - minX, maxY - minY)
+                        );
                 this.elements = elements.ToArray();
                 isTerminal = elements.Count <= bucketSize;
                 if (isTerminal)
@@ -61,28 +73,44 @@
                 double slicesPerAxis = Math.Sqrt(branchFactor);
                 int rectanglesPerPagePerAxis = (int)(slicesPerAxis * targetSize);
 
-                int XAxis(V lhs, V rhs)
-                {
-                    return elementTransformer(lhs).center.x.CompareTo(elementTransformer(rhs).center.x);
-                }
-
-                int YAxis(V lhs, V rhs)
-                {
-                    return elementTransformer(lhs).center.y.CompareTo(elementTransformer(rhs).center.y);
-                }
-
                 elements.Sort(XAxis);
-                foreach (List<V> xSlice in elements.Partition(rectanglesPerPagePerAxis).Select(enumerable => enumerable as List<V> ?? enumerable.ToList()))
+                foreach (
+                    List<V> xSlice in elements
+                        .Partition(rectanglesPerPagePerAxis)
+                        .Select(enumerable => enumerable as List<V> ?? enumerable.ToList())
+                )
                 {
                     xSlice.Sort(YAxis);
-                    foreach (List<V> ySlice in xSlice.Partition(intTargetSize).Select(enumerable => enumerable as List<V> ?? enumerable.ToList()))
+                    foreach (
+                        List<V> ySlice in xSlice
+                            .Partition(intTargetSize)
+                            .Select(enumerable => enumerable as List<V> ?? enumerable.ToList())
+                    )
                     {
-                        RTreeNode<V> node = new(ySlice, elementTransformer, bucketSize, branchFactor);
+                        RTreeNode<V> node = new(
+                            ySlice,
+                            elementTransformer,
+                            bucketSize,
+                            branchFactor
+                        );
                         tempChildren.Add(node);
                     }
                 }
 
                 children = tempChildren.ToArray();
+                return;
+
+                int XAxis(V lhs, V rhs)
+                {
+                    return elementTransformer(lhs)
+                        .center.x.CompareTo(elementTransformer(rhs).center.x);
+                }
+
+                int YAxis(V lhs, V rhs)
+                {
+                    return elementTransformer(lhs)
+                        .center.y.CompareTo(elementTransformer(rhs).center.y);
+                }
             }
         }
 
@@ -97,16 +125,30 @@
         private readonly RTreeNode<T> _head;
 
         public RTree(
-            IEnumerable<T> points, Func<T, Bounds> elementTransformer, int bucketSize = DefaultBucketSize,
-            int branchFactor = DefaultBranchFactor)
+            IEnumerable<T> points,
+            Func<T, Bounds> elementTransformer,
+            int bucketSize = DefaultBucketSize,
+            int branchFactor = DefaultBranchFactor
+        )
         {
-            _elementTransformer = elementTransformer ?? throw new ArgumentNullException(nameof(elementTransformer));
-            elements = points?.ToImmutableArray() ?? throw new ArgumentNullException(nameof(points));
+            _elementTransformer =
+                elementTransformer ?? throw new ArgumentNullException(nameof(elementTransformer));
+            elements =
+                points?.ToImmutableArray() ?? throw new ArgumentNullException(nameof(points));
             _bounds = elements.Select(elementTransformer).GetBounds() ?? new Bounds();
-            _head = new RTreeNode<T>(elements.ToList(), elementTransformer, bucketSize, branchFactor);
+            _head = new RTreeNode<T>(
+                elements.ToList(),
+                elementTransformer,
+                bucketSize,
+                branchFactor
+            );
         }
 
-        public IEnumerable<T> GetElementsInRange(Vector2 position, float range, float minimumRange = 0f)
+        public IEnumerable<T> GetElementsInRange(
+            Vector2 position,
+            float range,
+            float minimumRange = 0f
+        )
         {
             Circle area = new(position, range);
             if (0 < minimumRange)
@@ -115,25 +157,10 @@
                 return GetElementsInBounds(
                         new Bounds(
                             new Vector3(position.x, position.y, 0f),
-                            new Vector3(range * 2f, range * 2f, 1f)))
-                    .Where(
-                        element =>
-                        {
-                            Bounds elementBoundary = _elementTransformer(element);
-                            if (!area.Intersects(elementBoundary))
-                            {
-                                return false;
-                            }
-
-                            return !minimumArea.Intersects(elementBoundary);
-                        });
-            }
-            return GetElementsInBounds(
-                    new Bounds(
-                        new Vector3(position.x, position.y, 0f),
-                        new Vector3(range * 2f, range * 2f, 1f)))
-                .Where(
-                    element =>
+                            new Vector3(range * 2f, range * 2f, 1f)
+                        )
+                    )
+                    .Where(element =>
                     {
                         Bounds elementBoundary = _elementTransformer(element);
                         if (!area.Intersects(elementBoundary))
@@ -141,18 +168,42 @@
                             return false;
                         }
 
-                        return true;
+                        return !minimumArea.Intersects(elementBoundary);
                     });
+            }
+            return GetElementsInBounds(
+                    new Bounds(
+                        new Vector3(position.x, position.y, 0f),
+                        new Vector3(range * 2f, range * 2f, 1f)
+                    )
+                )
+                .Where(element =>
+                {
+                    Bounds elementBoundary = _elementTransformer(element);
+                    if (!area.Intersects(elementBoundary))
+                    {
+                        return false;
+                    }
+
+                    return true;
+                });
         }
 
         public IEnumerable<T> GetElementsInBounds(Bounds bounds)
+        {
+            Stack<RTreeNode<T>> nodeBuffer = Buffers<RTreeNode<T>>.Stack;
+            return GetElementsInBounds(bounds, nodeBuffer);
+        }
+
+        public IEnumerable<T> GetElementsInBounds(Bounds bounds, Stack<RTreeNode<T>> nodeBuffer)
         {
             if (!bounds.FastIntersects2D(_bounds))
             {
                 yield break;
             }
 
-            Stack<RTreeNode<T>> nodesToVisit = new();
+            Stack<RTreeNode<T>> nodesToVisit = nodeBuffer ?? new Stack<RTreeNode<T>>();
+            nodeBuffer.Clear();
             nodesToVisit.Push(_head);
 
             while (nodesToVisit.TryPop(out RTreeNode<T> currentNode))
@@ -197,18 +248,45 @@
             }
         }
 
+        public void GetApproximateNearestNeighbors(
+            Vector2 position,
+            int count,
+            List<T> nearestNeighbors
+        )
+        {
+            Stack<RTreeNode<T>> nodeBuffer = Buffers<RTreeNode<T>>.Stack;
+            List<RTreeNode<T>> childrenBuffer = Buffers<RTreeNode<T>>.List;
+            HashSet<T> nearestNeighborBuffer = Buffers<T>.HashSet;
+            GetApproximateNearestNeighbors(
+                position,
+                count,
+                nearestNeighbors,
+                nodeBuffer,
+                childrenBuffer,
+                nearestNeighborBuffer
+            );
+        }
+
         // Heavily adapted http://homepage.divms.uiowa.edu/%7Ekvaradar/sp2012/daa/ann.pdf
-        public void GetApproximateNearestNeighbors(Vector2 position, int count, List<T> nearestNeighbors)
+        public void GetApproximateNearestNeighbors(
+            Vector2 position,
+            int count,
+            List<T> nearestNeighbors,
+            Stack<RTreeNode<T>> nodeBuffer,
+            List<RTreeNode<T>> childrenBuffer,
+            HashSet<T> nearestNeighborsBuffer
+        )
         {
             nearestNeighbors.Clear();
 
             RTreeNode<T> current = _head;
-            Stack<RTreeNode<T>> stack = new();
+            Stack<RTreeNode<T>> stack = nodeBuffer ?? new Stack<RTreeNode<T>>();
+            stack.Clear();
             stack.Push(_head);
-            List<RTreeNode<T>> childrenCopy = new();
-            HashSet<T> nearestNeighborsSet = new(count);
-
-            int Comparison(RTreeNode<T> lhs, RTreeNode<T> rhs) => ((Vector2)lhs.boundary.center - position).sqrMagnitude.CompareTo(((Vector2)rhs.boundary.center - position).sqrMagnitude);
+            List<RTreeNode<T>> childrenCopy = childrenBuffer ?? new List<RTreeNode<T>>();
+            childrenCopy.Clear();
+            HashSet<T> nearestNeighborsSet = nearestNeighborsBuffer ?? new HashSet<T>(count);
+            nearestNeighborsSet.Clear();
 
             while (!current.isTerminal)
             {
@@ -238,10 +316,21 @@
             nearestNeighbors.AddRange(nearestNeighborsSet);
             if (count < nearestNeighbors.Count)
             {
-                int NearestComparison(T lhs, T rhs) => ((Vector2)_elementTransformer(lhs).center - position).sqrMagnitude.CompareTo(((Vector2)_elementTransformer(rhs).center - position).sqrMagnitude);
                 nearestNeighbors.Sort(NearestComparison);
                 nearestNeighbors.RemoveRange(count, nearestNeighbors.Count - count);
             }
+
+            return;
+
+            int Comparison(RTreeNode<T> lhs, RTreeNode<T> rhs) =>
+                ((Vector2)lhs.boundary.center - position).sqrMagnitude.CompareTo(
+                    ((Vector2)rhs.boundary.center - position).sqrMagnitude
+                );
+
+            int NearestComparison(T lhs, T rhs) =>
+                ((Vector2)_elementTransformer(lhs).center - position).sqrMagnitude.CompareTo(
+                    ((Vector2)_elementTransformer(rhs).center - position).sqrMagnitude
+                );
         }
     }
 }

package/Runtime/Core/Extension/ColorExtensions.cs

@@ -1,13 +1,279 @@
 namespace UnityHelpers.Core.Extension
 {
     using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Linq;
+    using Helper;
     using Random;
     using UnityEngine;
 
+    public enum ColorAveragingMethod
+    {
+        LAB = 0, // CIE L*a*b* space averaging
+        HSV = 1, // HSV space averaging
+        Weighted = 2, // Weighted RGB averaging using perceived luminance
+        Dominant = 3, // Find most dominant color cluster
+    }
+
     // https://sharpsnippets.wordpress.com/2014/03/11/c-extension-complementary-color/
     public static class ColorExtensions
     {
-        public static Color GetComplement(this Color source, IRandom random = null, float variance = 0f)
+        public static Color GetAverageColor(
+            this Sprite sprite,
+            ColorAveragingMethod method = ColorAveragingMethod.LAB,
+            float alphaCutoff = 0.01f
+        )
+        {
+            return GetAverageColor(Enumerables.Of(sprite), method, alphaCutoff);
+        }
+
+        public static Color GetAverageColor(
+            this IEnumerable<Sprite> sprites,
+            ColorAveragingMethod method = ColorAveragingMethod.LAB,
+            float alphaCutoff = 0.01f
+        )
+        {
+            return GetAverageColor(
+                sprites
+                    .Where(Objects.NotNull)
+                    .Select(sprite => sprite.texture)
+                    .Where(Objects.NotNull)
+                    .SelectMany(texture =>
+                    {
+                        texture.MakeReadable();
+                        Color[] pixels = texture.GetPixels();
+                        return pixels;
+                    }),
+                method,
+                alphaCutoff
+            );
+        }
+
+        public static Color GetAverageColor(
+            this IEnumerable<Color> pixels,
+            ColorAveragingMethod method = ColorAveragingMethod.LAB,
+            float alphaCutoff = 0.01f
+        )
+        {
+            switch (method)
+            {
+                case ColorAveragingMethod.LAB:
+                {
+                    return AverageInLABSpace(pixels, alphaCutoff);
+                }
+                case ColorAveragingMethod.HSV:
+                {
+                    return AverageInHSVSpace(pixels, alphaCutoff);
+                }
+                case ColorAveragingMethod.Weighted:
+                {
+                    return WeightedRGBAverage(pixels, alphaCutoff);
+                }
+                case ColorAveragingMethod.Dominant:
+                {
+                    return GetDominantColor(pixels, alphaCutoff);
+                }
+                default:
+                {
+                    throw new InvalidEnumArgumentException(
+                        nameof(method),
+                        (int)method,
+                        typeof(ColorAveragingMethod)
+                    );
+                }
+            }
+        }
+
+        // CIE L*a*b* space averaging - most perceptually accurate
+        private static Color AverageInLABSpace(IEnumerable<Color> pixels, float alphaCutoff)
+        {
+            List<LABColor> labValues = pixels
+                .Where(pixel => pixel.a > alphaCutoff)
+                .Select(RGBToLAB)
+                .ToList();
+
+            double avgL = labValues.Average(lab => lab.l);
+            double avgA = labValues.Average(lab => lab.a);
+            double avgB = labValues.Average(lab => lab.b);
+
+            return LABToRGB(avgL, avgA, avgB);
+        }
+
+        // HSV space averaging - good for preserving vibrant colors
+        private static Color AverageInHSVSpace(IEnumerable<Color> pixels, float alphaCutoff)
+        {
+            float avgH = 0f;
+            float avgS = 0f;
+            float avgV = 0f;
+            int count = 0;
+
+            foreach (Color pixel in pixels.Where(pixel => pixel.a > alphaCutoff))
+            {
+                Color.RGBToHSV(pixel, out float h, out float s, out float v);
+
+                // Handle hue wrapping around 360 degrees
+                float hRad = h * 2f * Mathf.PI;
+                avgH += Mathf.Cos(hRad);
+                avgH += Mathf.Sin(hRad);
+
+                avgS += s;
+                avgV += v;
+                count++;
+            }
+
+            avgH = Mathf.Atan2(avgH / count, avgH / count) / (2f * Mathf.PI);
+            if (avgH < 0)
+            {
+                avgH += 1f;
+            }
+
+            if (count <= 0)
+            {
+                count = 1;
+            }
+
+            avgS /= count;
+            avgV /= count;
+
+            return Color.HSVToRGB(avgH, avgS, avgV);
+        }
+
+        // Weighted RGB averaging using perceived luminance
+        private static Color WeightedRGBAverage(IEnumerable<Color> pixels, float alphaCutoff)
+        {
+            // Use perceived luminance weights
+            const float rWeight = 0.299f;
+            const float gWeight = 0.587f;
+            const float bWeight = 0.114f;
+
+            float totalWeight = 0f;
+            float r = 0f,
+                g = 0f,
+                b = 0f,
+                a = 0f;
+
+            foreach (Color pixel in pixels.Where(pixel => pixel.a > alphaCutoff))
+            {
+                float weight = pixel.r * rWeight + pixel.g * gWeight + pixel.b * bWeight;
+                r += pixel.r * weight;
+                g += pixel.g * weight;
+                b += pixel.b * weight;
+                a += pixel.a * weight;
+                totalWeight += weight;
+            }
+
+            if (totalWeight > 0f)
+            {
+                r /= totalWeight;
+                g /= totalWeight;
+                b /= totalWeight;
+                a /= totalWeight;
+            }
+
+            return new Color(r, g, b, a);
+        }
+
+        // Find dominant color using simple clustering
+        private static Color GetDominantColor(IEnumerable<Color> pixels, float alphaCutoff)
+        {
+            Dictionary<Vector3Int, int> colorBuckets = new();
+            const int bucketSize = 32; // Adjust for different precision
+
+            foreach (Color pixel in pixels.Where(pixel => pixel.a > alphaCutoff))
+            {
+                Vector3Int bucket = new(
+                    Mathf.RoundToInt(pixel.r * 255 / bucketSize),
+                    Mathf.RoundToInt(pixel.g * 255 / bucketSize),
+                    Mathf.RoundToInt(pixel.b * 255 / bucketSize)
+                );
+
+                colorBuckets.TryAdd(bucket, 0);
+                colorBuckets[bucket]++;
+            }
+
+            Vector3Int dominantBucket = colorBuckets
+                .OrderByDescending(kvp => kvp.Value)
+                .First()
+                .Key;
+            return new Color(
+                dominantBucket.x * bucketSize / 255f,
+                dominantBucket.y * bucketSize / 255f,
+                dominantBucket.z * bucketSize / 255f
+            );
+        }
+
+        // Helper struct for LAB color space
+        private readonly struct LABColor
+        {
+            public readonly double l;
+            public readonly double a;
+            public readonly double b;
+
+            public LABColor(double l, double a, double b)
+            {
+                this.l = l;
+                this.a = a;
+                this.b = b;
+            }
+        }
+
+        private static LABColor RGBToLAB(Color rgb)
+        {
+            // First convert to XYZ
+            double r =
+                rgb.r > 0.04045 ? Mathf.Pow((rgb.r + 0.055f) / 1.055f, 2.4f) : rgb.r / 12.92f;
+            double g =
+                rgb.g > 0.04045 ? Mathf.Pow((rgb.g + 0.055f) / 1.055f, 2.4f) : rgb.g / 12.92f;
+            double b =
+                rgb.b > 0.04045 ? Mathf.Pow((rgb.b + 0.055f) / 1.055f, 2.4f) : rgb.b / 12.92f;
+
+            double x = (r * 0.4124 + g * 0.3576 + b * 0.1805) / 0.95047;
+            double y = (r * 0.2126 + g * 0.7152 + b * 0.0722);
+            double z = (r * 0.0193 + g * 0.1192 + b * 0.9505) / 1.08883;
+
+            x = x > 0.008856 ? Mathf.Pow((float)x, 1f / 3f) : (7.787 * x) + 16f / 116f;
+            y = y > 0.008856 ? Mathf.Pow((float)y, 1f / 3f) : (7.787 * y) + 16f / 116f;
+            z = z > 0.008856 ? Mathf.Pow((float)z, 1f / 3f) : (7.787 * z) + 16f / 116f;
+
+            return new LABColor((116 * y) - 16, 500 * (x - y), 200 * (y - z));
+        }
+
+        private static Color LABToRGB(double l, double a, double b)
+        {
+            double y = (l + 16) / 116;
+            double x = a / 500 + y;
+            double z = y - b / 200;
+
+            double x3 = x * x * x;
+            double y3 = y * y * y;
+            double z3 = z * z * z;
+
+            x = 0.95047 * (x3 > 0.008856 ? x3 : (x - 16.0 / 116.0) / 7.787);
+            y = y3 > 0.008856 ? y3 : (y - 16.0 / 116.0) / 7.787;
+            z = 1.08883 * (z3 > 0.008856 ? z3 : (z - 16.0 / 116.0) / 7.787);
+
+            double r = x * 3.2406 + y * -1.5372 + z * -0.4986;
+            double g = x * -0.9689 + y * 1.8758 + z * 0.0415;
+            double b2 = x * 0.0557 + y * -0.2040 + z * 1.0570;
+
+            r = r > 0.0031308 ? 1.055 * Mathf.Pow((float)r, 1 / 2.4f) - 0.055 : 12.92 * r;
+            g = g > 0.0031308 ? 1.055 * Mathf.Pow((float)g, 1 / 2.4f) - 0.055 : 12.92 * g;
+            b2 = b2 > 0.0031308 ? 1.055 * Mathf.Pow((float)b2, 1 / 2.4f) - 0.055 : 12.92 * b2;
+
+            return new Color(
+                Mathf.Clamp01((float)r),
+                Mathf.Clamp01((float)g),
+                Mathf.Clamp01((float)b2),
+                1f
+            );
+        }
+
+        public static Color GetComplement(
+            this Color source,
+            IRandom random = null,
+            float variance = 0f
+        )
         {
             Color inputColor = source;
             //if RGB values are close to each other by a diff less than 10%, then if RGB values are lighter side, decrease the blue by 50% (eventually it will increase in conversion below), if RBB values are on darker side, decrease yellow by about 50% (it will increase in conversion)

package/Runtime/Core/Extension/UnityExtensions.cs

@@ -14,6 +14,16 @@
 
     public static class UnityExtensions
     {
+        public static Vector2 GetCenter(this GameObject gameObject)
+        {
+            if (gameObject.TryGetComponent(out CenterPointOffset centerPointOffset))
+            {
+                return centerPointOffset.CenterPoint;
+            }
+
+            return gameObject.transform.position;
+        }
+
         public static Bounds Bounds(this Rect rect)
         {
             return new Bounds(rect.center, rect.size);

package/Runtime/Core/Helper/Geometry.cs

@@ -1,9 +1,26 @@
 namespace UnityHelpers.Core.Helper
 {
+    using System.Collections.Generic;
+    using System.Linq;
     using UnityEngine;
 
     public static class Geometry
     {
+        public static Rect Accumulate(this IEnumerable<Rect> rects)
+        {
+            return rects.Aggregate(
+                (accumulated, next) =>
+                    new Rect(
+                        Mathf.Min(accumulated.xMin, next.xMin),
+                        Mathf.Min(accumulated.yMin, next.yMin),
+                        Mathf.Max(accumulated.xMax, next.xMax)
+                            - Mathf.Min(accumulated.xMin, next.xMin),
+                        Mathf.Max(accumulated.yMax, next.yMax)
+                            - Mathf.Min(accumulated.yMin, next.yMin)
+                    )
+            );
+        }
+
         //Where is p in relation to a-b
         // < 0 -> to the right
         // = 0 -> on the line

package/Runtime/Core/Helper/SpriteHelpers.cs

@@ -1,11 +1,41 @@
 namespace UnityHelpers.Core.Helper
 {
+    using Extension;
     using UnityEditor;
     using UnityEngine;
     using Utils;
 
     public static class SpriteHelpers
     {
+        public static void MakeReadable(this Texture2D texture)
+        {
+            if (texture.isReadable)
+            {
+                return;
+            }
+
+#if UNITY_EDITOR
+            string assetPath = AssetDatabase.GetAssetPath(texture);
+            if (string.IsNullOrEmpty(assetPath))
+            {
+                texture.LogError("Failed to get asset path.");
+                return;
+            }
+
+            TextureImporter tImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
+            if (tImporter == null)
+            {
+                texture.LogError("Failed to get texture importer.");
+                return;
+            }
+
+            tImporter.isReadable = true;
+            EditorUtility.SetDirty(tImporter);
+            tImporter.SaveAndReimport();
+            EditorUtility.SetDirty(texture);
+#endif
+        }
+
         public static void SetSpritePivot(string fullSpritePath, Vector2 pivot)
         {
 #if UNITY_EDITOR
@@ -16,7 +46,10 @@
         public static void SetSpritePivot(Sprite sprite, Vector2 pivot)
         {
 #if UNITY_EDITOR
-            SetSpritePivot(AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(sprite)) as TextureImporter, pivot);
+            SetSpritePivot(
+                AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(sprite)) as TextureImporter,
+                pivot
+            );
 #endif
         }
 
@@ -30,7 +63,7 @@
 
             TextureImporterSettings textureImportSettings = new TextureImporterSettings();
             textureImporter.ReadTextureSettings(textureImportSettings);
-            textureImportSettings.spriteAlignment = (int) SpriteAlignment.Custom;
+            textureImportSettings.spriteAlignment = (int)SpriteAlignment.Custom;
             textureImportSettings.wrapMode = TextureWrapMode.Clamp;
             textureImportSettings.filterMode = FilterMode.Trilinear;
             textureImporter.SetTextureSettings(textureImportSettings);
@@ -40,7 +73,7 @@
                 resizeAlgorithm = TextureResizeAlgorithm.Bilinear,
                 maxTextureSize = SetTextureImportData.RegularTextureSize,
                 textureCompression = TextureImporterCompression.Compressed,
-                format = TextureImporterFormat.Automatic
+                format = TextureImporterFormat.Automatic,
             };
 
             textureImporter.SetPlatformTextureSettings(importerSettings);