com.wallstop-studios.unity-helpers 1.0.0-rc4

package/Runtime/Core/Helper/Helpers.cs.meta

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

package/Runtime/Core/Helper/IterationHelpers.cs

@@ -0,0 +1,32 @@
+namespace UnityHelpers.Core.Helper
+{
+    using System.Collections.Generic;
+
+    public static class IterationHelpers
+    {
+        public static IEnumerable<(int, int)> IndexOver<T>(this T[,] array)
+        {
+            for (int i = 0; i < array.GetLength(0); i++)
+            {
+                for (int j = 0; j < array.GetLength(1); j++)
+                {
+                    yield return (i, j);
+                }
+            }
+        }
+
+        public static IEnumerable<(int, int, int)> IndexOver<T>(this T[,,] array)
+        {
+            for (int i = 0; i < array.GetLength(0); i++)
+            {
+                for (int j = 0; j < array.GetLength(1); j++)
+                {
+                    for (int k = 0; k < array.GetLength(2); k++)
+                    {
+                        yield return (i, j, k);
+                    }
+                }
+            }
+        }
+    }
+}

package/Runtime/Core/Helper/IterationHelpers.cs.meta

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

package/Runtime/Core/Helper/LifetimeHelpers.cs

@@ -0,0 +1,12 @@
+namespace UnityHelpers.Core.Helper
+{
+    using Object = UnityEngine.Object;
+
+    public static class LifetimeHelpers
+    {
+        public static void Destroy<T>(this T source, float? afterTime = null) where T : Object
+        {
+            source.SmartDestroy(afterTime);
+        }
+    }
+}

package/Runtime/Core/Helper/LifetimeHelpers.cs.meta

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

package/Runtime/Core/Helper/Objects.cs

@@ -0,0 +1,447 @@
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+    using System.Collections;
+    using System.Runtime.CompilerServices;
+    using Object = System.Object;
+
+    public static class Objects
+    {
+        private const int HashBase = 839;
+        private const int HashMultiplier = 4021;
+
+        public static T FromWeakReference<T>(WeakReference weakReference) where T : class
+        {
+            object empty = weakReference.Target;
+            return (T)empty;
+        }
+
+        public static bool Null(UnityEngine.Object instance)
+        {
+            return instance == null;
+        }
+
+        public static bool Null(Object instance)
+        {
+            return instance == null;
+        }
+
+        public static bool NotNull(UnityEngine.Object instance)
+        {
+            return instance != null;
+        }
+
+        public static bool NotNull(Object instance)
+        {
+            return instance != null;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int NullSafeHashCode<T>(T param)
+        {
+            Type type = typeof(T);
+            if (type.IsValueType)
+            {
+                return param.GetHashCode();
+            }
+
+            return param == null ? type.GetHashCode() : param.GetHashCode();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1>(T1 param1) where T1 : unmanaged
+        {
+            unchecked
+            {
+                return HashBase * HashMultiplier + param1.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1, T2>(T1 param1, T2 param2) 
+            where T1 : unmanaged 
+            where T2 : unmanaged
+        {
+            unchecked
+            {
+                return ValueTypeHashCode(param1) * HashMultiplier + param2.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1, T2, T3>(T1 param1, T2 param2, T3 param3)
+            where T1 : unmanaged where T2 : unmanaged where T3 : unmanaged
+        {
+            unchecked
+            {
+                return ValueTypeHashCode(param1, param2) * HashMultiplier + param3.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1, T2, T3, T4>(T1 param1, T2 param2, T3 param3, T4 param4)
+            where T1 : unmanaged 
+            where T2 : unmanaged 
+            where T3 : unmanaged 
+            where T4 : unmanaged
+        {
+            unchecked
+            {
+                return ValueTypeHashCode(param1, param2, param3) * HashMultiplier + param4.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1, T2, T3, T4, T5>(T1 param1, T2 param2, T3 param3, T4 param4, T5 param5)
+            where T1 : unmanaged 
+            where T2 : unmanaged 
+            where T3 : unmanaged 
+            where T4 : unmanaged 
+            where T5 : unmanaged
+        {
+            unchecked
+            {
+                return ValueTypeHashCode(param1, param2, param3, param4) * HashMultiplier + param5.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1, T2, T3, T4, T5, T6>(T1 param1, T2 param2, T3 param3, T4 param4,
+            T5 param5, T6 param6) 
+            where T1 : unmanaged
+            where T2 : unmanaged
+            where T3 : unmanaged
+            where T4 : unmanaged
+            where T5 : unmanaged
+            where T6 : unmanaged
+        {
+            unchecked
+            {
+                return ValueTypeHashCode(param1, param2, param3, param4, param5) *
+                       HashMultiplier + param6.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1, T2, T3, T4, T5, T6, T7>(T1 param1, T2 param2, T3 param3, T4 param4,
+            T5 param5, T6 param6, T7 param7) 
+            where T1 : unmanaged
+            where T2 : unmanaged
+            where T3 : unmanaged
+            where T4 : unmanaged
+            where T5 : unmanaged
+            where T6 : unmanaged
+            where T7 : unmanaged
+        {
+            unchecked
+            {
+                return ValueTypeHashCode(param1, param2, param3, param4, param5, param6) *
+                       HashMultiplier + param7.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1, T2, T3, T4, T5, T6, T7, T8>(T1 param1, T2 param2, T3 param3, T4 param4,
+            T5 param5, T6 param6, T7 param7, T8 param8) 
+            where T1 : unmanaged
+            where T2 : unmanaged
+            where T3 : unmanaged
+            where T4 : unmanaged
+            where T5 : unmanaged
+            where T6 : unmanaged
+            where T7 : unmanaged
+            where T8 : unmanaged
+        {
+            unchecked
+            {
+                return ValueTypeHashCode(param1, param2, param3, param4, param5, param6, param7) *
+                       HashMultiplier + param8.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1, T2, T3, T4, T5, T6, T7, T8, T9>(T1 param1, T2 param2, T3 param3, T4 param4,
+            T5 param5, T6 param6, T7 param7, T8 param8, T9 param9)
+            where T1 : unmanaged
+            where T2 : unmanaged
+            where T3 : unmanaged
+            where T4 : unmanaged
+            where T5 : unmanaged
+            where T6 : unmanaged
+            where T7 : unmanaged
+            where T8 : unmanaged
+            where T9 : unmanaged
+        {
+            unchecked
+            {
+                return ValueTypeHashCode(param1, param2, param3, param4, param5, param6, param7, param8) *
+                    HashMultiplier + param9.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(T1 param1, T2 param2, T3 param3, T4 param4,
+            T5 param5, T6 param6, T7 param7, T8 param8, T9 param9, T10 param10)
+            where T1 : unmanaged
+            where T2 : unmanaged
+            where T3 : unmanaged
+            where T4 : unmanaged
+            where T5 : unmanaged
+            where T6 : unmanaged
+            where T7 : unmanaged
+            where T8 : unmanaged
+            where T9 : unmanaged
+            where T10: unmanaged
+        {
+            unchecked
+            {
+                return ValueTypeHashCode(param1, param2, param3, param4, param5, param6, param7, param8, param9) *
+                    HashMultiplier + param10.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(T1 param1, T2 param2, T3 param3, T4 param4,
+            T5 param5, T6 param6, T7 param7, T8 param8, T9 param9, T10 param10, T11 param11)
+            where T1 : unmanaged
+            where T2 : unmanaged
+            where T3 : unmanaged
+            where T4 : unmanaged
+            where T5 : unmanaged
+            where T6 : unmanaged
+            where T7 : unmanaged
+            where T8 : unmanaged
+            where T9 : unmanaged
+            where T10 : unmanaged
+            where T11 : unmanaged
+        {
+            unchecked
+            {
+                return ValueTypeHashCode(param1, param2, param3, param4, param5, param6, param7, param8, param9, param10) *
+                    HashMultiplier + param11.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(T1 param1, T2 param2, T3 param3, T4 param4,
+            T5 param5, T6 param6, T7 param7, T8 param8, T9 param9, T10 param10, T11 param11, T12 param12)
+            where T1 : unmanaged
+            where T2 : unmanaged
+            where T3 : unmanaged
+            where T4 : unmanaged
+            where T5 : unmanaged
+            where T6 : unmanaged
+            where T7 : unmanaged
+            where T8 : unmanaged
+            where T9 : unmanaged
+            where T10 : unmanaged
+            where T11 : unmanaged
+            where T12 : unmanaged
+        {
+            unchecked
+            {
+                return ValueTypeHashCode(param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11) *
+                    HashMultiplier + param12.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(T1 param1, T2 param2, T3 param3, T4 param4,
+            T5 param5, T6 param6, T7 param7, T8 param8, T9 param9, T10 param10, T11 param11, T12 param12, T13 param13)
+            where T1 : unmanaged
+            where T2 : unmanaged
+            where T3 : unmanaged
+            where T4 : unmanaged
+            where T5 : unmanaged
+            where T6 : unmanaged
+            where T7 : unmanaged
+            where T8 : unmanaged
+            where T9 : unmanaged
+            where T10 : unmanaged
+            where T11 : unmanaged
+            where T12 : unmanaged
+            where T13 : unmanaged
+        {
+            unchecked
+            {
+                return ValueTypeHashCode(param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12) *
+                    HashMultiplier + param13.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(T1 param1, T2 param2, T3 param3, T4 param4,
+            T5 param5, T6 param6, T7 param7, T8 param8, T9 param9, T10 param10, T11 param11, T12 param12, T13 param13, T14 param14)
+            where T1 : unmanaged
+            where T2 : unmanaged
+            where T3 : unmanaged
+            where T4 : unmanaged
+            where T5 : unmanaged
+            where T6 : unmanaged
+            where T7 : unmanaged
+            where T8 : unmanaged
+            where T9 : unmanaged
+            where T10 : unmanaged
+            where T11 : unmanaged
+            where T12 : unmanaged
+            where T13 : unmanaged
+            where T14 : unmanaged
+        {
+            unchecked
+            {
+                return ValueTypeHashCode(param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13) *
+                    HashMultiplier + param14.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(T1 param1, T2 param2, T3 param3, T4 param4,
+            T5 param5, T6 param6, T7 param7, T8 param8, T9 param9, T10 param10, T11 param11, T12 param12, T13 param13, T14 param14, T15 param15)
+            where T1 : unmanaged
+            where T2 : unmanaged
+            where T3 : unmanaged
+            where T4 : unmanaged
+            where T5 : unmanaged
+            where T6 : unmanaged
+            where T7 : unmanaged
+            where T8 : unmanaged
+            where T9 : unmanaged
+            where T10 : unmanaged
+            where T11 : unmanaged
+            where T12 : unmanaged
+            where T13 : unmanaged
+            where T14 : unmanaged
+            where T15 : unmanaged
+        {
+            unchecked
+            {
+                return ValueTypeHashCode(param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14) *
+                    HashMultiplier + param15.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int ValueTypeHashCode<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(T1 param1, T2 param2, T3 param3, T4 param4,
+            T5 param5, T6 param6, T7 param7, T8 param8, T9 param9, T10 param10, T11 param11, T12 param12, T13 param13, T14 param14, T15 param15, T16 param16)
+            where T1 : unmanaged
+            where T2 : unmanaged
+            where T3 : unmanaged
+            where T4 : unmanaged
+            where T5 : unmanaged
+            where T6 : unmanaged
+            where T7 : unmanaged
+            where T8 : unmanaged
+            where T9 : unmanaged
+            where T10 : unmanaged
+            where T11 : unmanaged
+            where T12 : unmanaged
+            where T13 : unmanaged
+            where T14 : unmanaged
+            where T15 : unmanaged
+            where T16 : unmanaged
+        {
+            unchecked
+            {
+                return ValueTypeHashCode(param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14, param15) *
+                    HashMultiplier + param16.GetHashCode();
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int HashCode<T1>(T1 param1)
+        {
+            unchecked
+            {
+                return HashBase * NullSafeHashCode(param1);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int HashCode<T1, T2>(T1 param1, T2 param2)
+        {
+            unchecked
+            {
+                return HashCode(param1) * HashMultiplier + NullSafeHashCode(param2);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int HashCode<T1, T2, T3>(T1 param1, T2 param2, T3 param3)
+        {
+            unchecked
+            {
+                return HashCode(param1, param2) * HashMultiplier + NullSafeHashCode(param3);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int HashCode<T1, T2, T3, T4>(T1 param1, T2 param2, T3 param3, T4 param4)
+        {
+            unchecked
+            {
+                return HashCode(param1, param2, param3) * HashMultiplier + NullSafeHashCode(param4);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int HashCode<T1, T2, T3, T4, T5>(T1 param1, T2 param2, T3 param3, T4 param4, T5 param5)
+        {
+            unchecked
+            {
+                return HashCode(param1, param2, param3, param4) * HashMultiplier + NullSafeHashCode(param5);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int HashCode<T1, T2, T3, T4, T5, T6>(T1 param1, T2 param2, T3 param3, T4 param4, T5 param5,
+            T6 param6)
+        {
+            unchecked
+            {
+                return HashCode(param1, param2, param3, param4, param5) * HashMultiplier + NullSafeHashCode(param6);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int HashCode<T1, T2, T3, T4, T5, T6, T7>(T1 param1, T2 param2, T3 param3, T4 param4, T5 param5,
+            T6 param6, T7 param7)
+        {
+            unchecked
+            {
+                return HashCode(param1, param2, param3, param4, param5, param6) *
+                       HashMultiplier + NullSafeHashCode(param7);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int HashCode<T1, T2, T3, T4, T5, T6, T7, T8>(T1 param1, T2 param2, T3 param3, T4 param4, T5 param5,
+            T6 param6, T7 param7, T8 param8)
+        {
+            unchecked
+            {
+                return HashCode(param1, param2, param3, param4, param5, param6, param7) *
+                    HashMultiplier + NullSafeHashCode(param8);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int EnumerableHashCode(IEnumerable enumerable)
+        {
+            if (ReferenceEquals(enumerable, null))
+            {
+                return 0;
+            }
+            unchecked
+            {
+                int hash = HashBase;
+                IEnumerator walker = enumerable.GetEnumerator();
+                while (walker.MoveNext())
+                {
+                    hash = hash * HashMultiplier + NullSafeHashCode(walker.Current);
+                }
+
+                return hash;
+            }
+        }
+    }
+}

package/Runtime/Core/Helper/Objects.cs.meta

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

package/Runtime/Core/Helper/SpriteHelpers.cs

@@ -0,0 +1,53 @@
+namespace UnityHelpers.Core.Helper
+{
+    using UnityEditor;
+    using UnityEngine;
+    using Utils;
+
+    public static class SpriteHelpers
+    {
+        public static void SetSpritePivot(string fullSpritePath, Vector2 pivot)
+        {
+#if UNITY_EDITOR
+            SetSpritePivot(AssetImporter.GetAtPath(fullSpritePath) as TextureImporter, pivot);
+#endif
+        }
+
+        public static void SetSpritePivot(Sprite sprite, Vector2 pivot)
+        {
+#if UNITY_EDITOR
+            SetSpritePivot(AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(sprite)) as TextureImporter, pivot);
+#endif
+        }
+
+#if UNITY_EDITOR
+        public static void SetSpritePivot(TextureImporter textureImporter, Vector2 pivot)
+        {
+            if (textureImporter == null)
+            {
+                return;
+            }
+
+            TextureImporterSettings textureImportSettings = new TextureImporterSettings();
+            textureImporter.ReadTextureSettings(textureImportSettings);
+            textureImportSettings.spriteAlignment = (int) SpriteAlignment.Custom;
+            textureImportSettings.wrapMode = TextureWrapMode.Clamp;
+            textureImportSettings.filterMode = FilterMode.Trilinear;
+            textureImporter.SetTextureSettings(textureImportSettings);
+
+            TextureImporterPlatformSettings importerSettings = new TextureImporterPlatformSettings
+            {
+                resizeAlgorithm = TextureResizeAlgorithm.Bilinear,
+                maxTextureSize = SetTextureImportData.RegularTextureSize,
+                textureCompression = TextureImporterCompression.Compressed,
+                format = TextureImporterFormat.Automatic
+            };
+
+            textureImporter.SetPlatformTextureSettings(importerSettings);
+            textureImporter.isReadable = true;
+            textureImporter.spritePivot = pivot;
+            textureImporter.SaveAndReimport();
+        }
+#endif
+    }
+}

package/Runtime/Core/Helper/SpriteHelpers.cs.meta

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

package/Runtime/Core/Helper/StringInList.cs

@@ -0,0 +1,31 @@
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+    using System.Reflection;
+    using UnityEngine;
+
+    public sealed class StringInList : PropertyAttribute
+    {
+        public delegate string[] GetStringList();
+
+        public StringInList(params string[] list)
+        {
+            List = list;
+        }
+
+        public StringInList(Type type, string methodName)
+        {
+            MethodInfo method = type.GetMethod(methodName);
+            if (method != null)
+            {
+                List = method.Invoke(null, null) as string[];
+            }
+            else
+            {
+                Debug.LogError("NO SUCH METHOD " + methodName + " FOR " + type);
+            }
+        }
+
+        public string[] List { get; private set; }
+    }
+}

package/Runtime/Core/Helper/StringInList.cs.meta

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