net.dreditor.core 0.1.5 → 0.1.7

package/Scripts/Utility/ComponentExtensions.cs

@@ -0,0 +1,170 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace DREditor.Utility
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class ComponentExtensions
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="components"></param>
+        /// <returns></returns>
+        public static T GetSelectedObjectOfType<T>(this IReadOnlyList<object> components)
+        {
+            foreach (var component in components)
+                if (component is T targetDigit &&
+                    component is MonoBehaviour behaviour &&
+                    behaviour.gameObject == EventSystem.current.currentSelectedGameObject)
+                    return targetDigit;
+
+            return default;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="components"></param>
+        /// <param name="invocationMethod"></param>
+        public static void InvokeComponents<T>(this IReadOnlyList<T> components, Action<T> invocationMethod)
+        {
+            if (components == null || invocationMethod == null)
+                return;
+
+            for (int i = 0; i < components.Count; i++)
+                invocationMethod(components[i]);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="behaviour"></param>
+        /// <param name="invocationMethod"></param>
+        public static void InvokeFamily<T>(this MonoBehaviour behaviour, Action<T> invocationMethod)
+        {
+            InvokeThisPlusComponents(behaviour, invocationMethod);
+
+            InvokeChildren(behaviour, invocationMethod);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="behaviour"></param>
+        /// <param name="invocationMethod"></param>
+        public static void InvokeThisPlusComponents<T>(this MonoBehaviour behaviour, Action<T> invocationMethod)
+        {
+            behaviour.InvokeThisAs(invocationMethod);
+
+            if (behaviour is IComponentsCache cache && cache.CachedComponents != null)
+                cache.CachedComponents.InvokeComponents(invocationMethod);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="behaviour"></param>
+        /// <param name="invocationMethod"></param>
+        public static void InvokeThisAs<T>(this MonoBehaviour behaviour, Action<T> invocationMethod)
+        {
+            if (behaviour == null || invocationMethod == null)
+                return;
+
+            if (behaviour is T soughtType)
+                invocationMethod(soughtType);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <typeparam name="T2"></typeparam>
+        /// <param name="components"></param>
+        /// <param name="invocationMethod"></param>
+        public static void InvokeComponents<T, T2>(this IReadOnlyList<T2> components, Action<T> invocationMethod)
+        {
+            if (components == null || invocationMethod == null)
+                return;
+
+            for (int i = 0; i < components.Count; i++)
+                if (components[i] is T soughtType)
+                    invocationMethod(soughtType);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="behaviour"></param>
+        /// <param name="invocationMethod"></param>
+        public static void InvokeChildren<T>(this MonoBehaviour behaviour, Action<T> invocationMethod)
+        {
+            if (behaviour is IComponentsCache cache)
+                InvokeChildCachesRecursively(cache, invocationMethod);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="parentCache"></param>
+        /// <param name="invocationMethod"></param>
+        public static void InvokeComponents<T>(this IComponentsCache parentCache, Action<T> invocationMethod)
+        {
+            if (parentCache.CachedComponents == null)
+                return;
+
+            foreach (var component in parentCache.CachedComponents)
+                if (component is T soughtType)
+                    invocationMethod(soughtType);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="parentCache"></param>
+        /// <param name="invocationMethod"></param>
+        private static void InvokeChildCachesRecursively<T>(IComponentsCache parentCache, Action<T> invocationMethod)
+        {
+            if (parentCache.CachedComponents == null) 
+                return;
+
+            foreach (var child in parentCache.CachedComponents)
+            {
+                if (child == null || child is IComponentsCache childCache && childCache == parentCache) 
+                    continue;
+
+                if (child is T soughtType)
+                    invocationMethod(soughtType);
+
+                if (child is MonoBehaviour childMono)
+                    childMono.InvokeThisPlusComponents(invocationMethod);
+
+                child.InvokeChildren(invocationMethod);
+            }
+        }
+    }
+
+    /// <summary>
+    ///
+    /// </summary>
+    public interface IComponentsCache
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        MonoBehaviour[] CachedComponents { get; }
+    }
+}

package/Scripts/Utility/ComponentExtensions.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: edb17c26f4d59314fbd52e0acb5c2377

package/Scripts/Utility/CreateMaterialsForTextures.cs

@@ -0,0 +1,48 @@
+//Author: KHeartz
+#if UNITY_EDITOR
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Utility
+{
+    public class CreateMaterialsForTextures : ScriptableWizard
+    {
+        public Shader shader;
+
+        [MenuItem("DREditor/Utility/Create Materials For Textures")]
+        static void CreateWizard()
+        {
+            ScriptableWizard.DisplayWizard<CreateMaterialsForTextures>("Create Materials", "Create");
+        }
+
+        void OnWizardCreate()
+        {
+            try
+            {
+                AssetDatabase.StartAssetEditing();
+                var textures = Selection.GetFiltered(typeof(Texture), SelectionMode.Assets).Cast<Texture>();
+                foreach (var tex in textures)
+                {
+                    string path = AssetDatabase.GetAssetPath(tex);
+                    path = path[..path.LastIndexOf(".")] + ".mat";
+                    if (AssetDatabase.LoadAssetAtPath(path, typeof(Material)) != null)
+                    {
+                        Debug.LogWarning("Can't create material, it already exists: " + path);
+                        continue;
+                    }
+                    var mat = new Material(shader);
+                    mat.mainTexture = tex;
+                    mat.color = Color.white;
+                    AssetDatabase.CreateAsset(mat, path);
+                }
+            }
+            finally
+            {
+                AssetDatabase.StopAssetEditing();
+                AssetDatabase.SaveAssets();
+            }
+        }
+    }
+}
+#endif

package/Scripts/Utility/CreateMaterialsForTextures.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 41f0a589d1ccac243ad398561808f708
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences:
+  - m_PersistentViewDataDictionary: {instanceID: 0}
+  - shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Scripts/Utility/DeepCopyExtensions.cs

@@ -0,0 +1,120 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+using System;
+using System.Reflection;
+using UnityEngine;
+
+namespace DREditor.Utility
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class DeepCopyExtensions
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="obj"></param>
+        /// <returns></returns>
+        public static T DeepCopy<T>(this T obj)
+        {
+            if (obj == null)
+                return default;
+
+            Type type = obj.GetType();
+
+            if (type.IsValueType || type == typeof(string))
+                return obj;
+            else if (type.IsArray)
+                return DeepCopyArray(obj);
+            else
+                return DeepCopyObject(obj);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="obj"></param>
+        /// <returns></returns>
+        static T DeepCopyArray<T>(T obj)
+        {
+            Type type = obj.GetType();
+
+            Type elementType = type.GetElementType();
+
+            var array = obj as Array;
+
+            Array copied = Array.CreateInstance(elementType, array.Length);
+
+            for (int i = 0; i < array.Length; i++)
+            {
+                var copiedField = array.GetValue(i) is ScriptableObject ? array.GetValue(i) : DeepCopy(array.GetValue(i));
+
+                copied.SetValue(copiedField, i);
+            }
+
+            return (T)(object)copied;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="obj"></param>
+        /// <returns></returns>
+        static T DeepCopyObject<T>(T obj)
+        {
+            Type type = obj.GetType();
+
+            if (obj is Texture2D texture)
+            {
+                UnityEngine.Debug.LogError($"ALERT: CAUGHT A TEXTURE2D Instance: " + texture.name);
+
+                return obj;
+            }
+
+            object copy = Activator.CreateInstance(type);
+
+            FieldInfo[] fields = type.GetFields(
+                BindingFlags.Public |
+                BindingFlags.NonPublic |
+                BindingFlags.Instance);
+
+            foreach (FieldInfo field in fields)
+            {
+                object fieldValue = field.GetValue(obj);
+
+                if (fieldValue != null)
+                {
+                    var copiedField = fieldValue is ScriptableObject ? fieldValue : DeepCopy(fieldValue);
+
+                    field.SetValue(copy, copiedField);
+                }
+            }
+
+            return (T)copy;
+        }
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="source"></param>
+        /// <returns></returns>
+        public static T DeepJsonCopy<T>(this T source) where T : ScriptableObject
+        {
+            if (source == null) 
+                return null;
+
+            string json = JsonUtility.ToJson(source);
+
+            T clone = ScriptableObject.CreateInstance<T>();
+
+            JsonUtility.FromJsonOverwrite(json, clone);
+
+            return clone;
+        }
+    }
+}

package/Scripts/Utility/DeepCopyExtensions.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 951898b866268b94d8250b3a25efa784

package/Scripts/Utility/GizmosSettings.cs

@@ -0,0 +1,14 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+using UnityEngine;
+
+namespace DREditor.Utility
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public class GizmosSettings : ProjectSettingsData<GizmosSettings>
+    {
+        [Tooltip("")]
+        public float gizmoSphereRadius = 1;
+    }
+}

package/Scripts/Utility/GizmosSettings.cs.meta

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

package/Scripts/Utility/GizmosUtility.cs

@@ -0,0 +1,43 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+using UnityEngine;
+
+namespace DREditor.Utility
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class GizmosUtility
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="bottom"></param>
+        /// <param name="top"></param>
+        public static void DrawSwipeLineGizmo(Vector3 bottom, Vector3 top)
+        {
+            Gizmos.DrawLine(bottom, top);
+
+            Gizmos.DrawSphere(top, GizmosSettings.Instance.gizmoSphereRadius);
+
+            Gizmos.DrawSphere(bottom, GizmosSettings.Instance.gizmoSphereRadius);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="startPosition"></param>
+        /// <param name="endPosition"></param>
+        public static void DrawSphereLine(Vector3 startPosition, Vector3 endPosition)
+        {
+            Gizmos.color = Color.green;
+
+            Gizmos.DrawSphere(startPosition, GizmosSettings.Instance.gizmoSphereRadius);
+
+            Gizmos.color = Color.yellow;
+
+            Gizmos.DrawSphere(endPosition, GizmosSettings.Instance.gizmoSphereRadius);
+
+            Gizmos.DrawLine(startPosition, endPosition);
+        }
+    }
+}

package/Scripts/Utility/GizmosUtility.cs.meta

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

package/Scripts/Utility/ImageUtility.cs

@@ -0,0 +1,40 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace DREditor.Utility
+{
+    public static class ImageUtility
+    {
+        public static void SetFade(this Graphic i, float alpha)
+        {
+            i.color = new Color(i.color.r, i.color.g, i.color.b, alpha);
+        }
+
+        public static void SetImageColorIgnoreAlpha(this Image i, Color c)
+        {
+            i.color = new Color(c.r, c.g, c.b, i.color.a);
+        }
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="images"></param>
+        public static void SetActiveBySprite(params Image[] images)
+        {
+            foreach (var image in images)
+                image.SetActiveBySprite();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="image"></param>
+        public static void SetActiveBySprite(this Image image)
+        {
+            if (image != null)
+                image.gameObject.SetActive(image.sprite != null);
+        }
+    }
+}

package/Scripts/Utility/ImageUtility.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 25c081d739daf184d89b2c5d2998c019

package/Scripts/Utility/LayerMaskExtensions.cs

@@ -0,0 +1,19 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+using UnityEngine;
+
+namespace DREditor.Utility
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class LayerMaskExtensions
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="mask"></param>
+        /// <param name="layer"></param>
+        /// <returns></returns>
+        public static bool Contains(this LayerMask mask, int layer) => (mask.value & (1 << layer)) != 0;
+    }
+}

package/Scripts/Utility/LayerMaskExtensions.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7fd15593686f2d64bb1aeeb2dec5b74e

package/Scripts/Utility/LayerUtility.cs

@@ -0,0 +1,25 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+using UnityEngine;
+
+namespace DREditor.Utility
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class LayerUtility
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="mask"></param>
+        /// <returns></returns>
+        public static int GetFirst(this LayerMask mask)
+        {
+            for (int i = 0; i < 32; i++)
+                if ((mask.value & (1 << i)) != 0)
+                    return i;
+
+            return -1;
+        }
+    }
+}

package/Scripts/Utility/LayerUtility.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 217920deb5d97664f898ee3aa6d677aa

package/Scripts/Utility/PixelUtility.cs

@@ -0,0 +1,131 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+using UnityEngine;
+
+namespace DREditor.Utility
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class PixelUtility
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="worldHitPoint"></param>
+        /// <param name="spriteRenderer"></param>
+        /// <returns></returns>
+        public static Color GetPixelColorUsingSpriteBounds(Vector2 worldHitPoint, SpriteRenderer spriteRenderer)
+        {
+            Vector2 normalized = GetNormalizedSpritePosition(worldHitPoint, spriteRenderer);
+
+            normalized = ApplyFlipping(normalized, spriteRenderer);
+
+            Vector2Int atlasCoord = GetAtlasPixelCoordinate(normalized, spriteRenderer);
+
+            return SamplePixelColor(spriteRenderer.sprite.texture, atlasCoord);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="worldHitPoint"></param>
+        /// <param name="spriteRenderer"></param>
+        /// <returns></returns>
+        private static Vector2 GetNormalizedSpritePosition(Vector2 worldHitPoint, SpriteRenderer spriteRenderer)
+        {
+            Bounds spriteBounds = spriteRenderer.bounds;
+
+            float normalizedX = (worldHitPoint.x - spriteBounds.min.x) / spriteBounds.size.x;
+
+            float normalizedY = (worldHitPoint.y - spriteBounds.min.y) / spriteBounds.size.y;
+
+            return new Vector2(normalizedX, normalizedY);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="normalized"></param>
+        /// <param name="spriteRenderer"></param>
+        /// <returns></returns>
+        private static Vector2 ApplyFlipping(Vector2 normalized, SpriteRenderer spriteRenderer)
+        {
+            float x = spriteRenderer.flipX ? 1f - normalized.x : normalized.x;
+
+            float y = spriteRenderer.flipY ? 1f - normalized.y : normalized.y;
+
+            return new Vector2(x, y);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="normalized"></param>
+        /// <param name="spriteRenderer"></param>
+        /// <returns></returns>
+        private static Vector2Int GetAtlasPixelCoordinate(Vector2 normalized, SpriteRenderer spriteRenderer)
+        {
+            Texture2D sourceTexture = spriteRenderer.sprite.texture;
+
+            Rect spriteRect = spriteRenderer.sprite.rect;
+
+            float spritePixelX = normalized.x * spriteRect.width;
+
+            float spritePixelY = normalized.y * spriteRect.height;
+
+            int atlasX = Mathf.Clamp(Mathf.FloorToInt(spriteRect.x + spritePixelX), 0, sourceTexture.width - 1);
+
+            int atlasY = Mathf.Clamp(Mathf.FloorToInt(spriteRect.y + spritePixelY), 0, sourceTexture.height - 1);
+
+            return new Vector2Int(atlasX, atlasY);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="sourceTexture"></param>
+        /// <param name="atlasCoordinate"></param>
+        /// <returns></returns>
+        private static Color SamplePixelColor(Texture2D sourceTexture, Vector2Int atlasCoordinate)
+        {
+            RenderTexture renderTex = RenderTexture.GetTemporary(
+                sourceTexture.width, sourceTexture.height, 0,
+                RenderTextureFormat.Default, RenderTextureReadWrite.Linear);
+
+            Graphics.Blit(sourceTexture, renderTex);
+
+            RenderTexture previous = RenderTexture.active;
+
+            RenderTexture.active = renderTex;
+
+            Texture2D readablePixel = CreateReadableTexture(atlasCoordinate.x, atlasCoordinate.y);
+
+            RenderTexture.active = previous;
+
+            RenderTexture.ReleaseTemporary(renderTex);
+
+            Color resultColor = readablePixel.GetPixel(0, 0);
+
+            MonoBehaviour.Destroy(readablePixel);
+
+            return resultColor;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="atlasX"></param>
+        /// <param name="atlasY"></param>
+        /// <returns></returns>
+        private static Texture2D CreateReadableTexture(int atlasX, int atlasY)
+        {
+            Texture2D readablePixel = new(1, 1, TextureFormat.RGBA32, false);
+
+            readablePixel.ReadPixels(new Rect(atlasX, atlasY, 1, 1), 0, 0);
+
+            readablePixel.Apply();
+
+            return readablePixel;
+        }
+    }
+}

package/Scripts/Utility/PixelUtility.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: cad4bbd307e3a37409370373ed5ef402