net.dreditor.core 0.1.5 → 0.1.6

package/Scripts/Editor/Utility/ScriptableObjectAssigner.cs

@@ -0,0 +1,404 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace DREditor.Editor.Utility
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public class ScriptableObjectAssigner : EditorWindow
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        public List<ScriptableObject> scriptableObjects = new();
+
+        /// <summary>
+        ///
+        /// </summary>
+        public List<MonoScript> components;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <remarks></remarks>
+        public string sendMessage = string.Empty;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public bool thisSceneOnly = true;
+
+        /// <summary>
+        ///
+        /// </summary>
+        public bool applyToBuildScenesOnly = false;
+
+        /// <summary>
+        ///
+        /// </summary>
+        public bool scriptableObjectNameIsField = true;
+
+        /// <summary>
+        ///
+        /// </summary>
+        public List<string> fieldNames = new();
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected int assignedCount = 0;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected SerializedObject scriptableObjectsProperty;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected SerializedObject componentsProperty;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected SerializedObject fieldNamesProperty;
+
+
+        [MenuItem("DREditor/Utility/Scriptable Object Assigner")]
+        public static void ShowWindow() => GetWindow<ScriptableObjectAssigner>("Scriptable Object Assigner");
+
+        protected virtual void OnGUI()
+        {
+            DisplayListProperties();
+
+            CustomLayoutUtility.DisplayHorizontal(SendMessageField);
+
+            DisplayOptionFields();
+
+            try
+            {
+                DisplayFieldNamesProperty();
+
+                if (GUILayout.Button("Assign to All Components in Scenes"))
+                    AssignAllInstancesInScenes();
+            }
+            catch (ArgumentException exception)
+            {
+                UnityEngine.Debug.Log("Skipping Noticed argument exception: " + exception.ToString());
+                // This is to skip getting the 
+                // ArgumentException: Getting control 4's position in a group with only 4 controls when doing repaint
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected virtual void DisplayListProperties()
+        {
+            GUILayout.Label("Assign Scriptable Object to Components", EditorStyles.boldLabel);
+
+            scriptableObjectsProperty = DisplayProperty(scriptableObjectsProperty, "scriptableObjects");
+
+            componentsProperty = DisplayProperty(componentsProperty, "components");
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected virtual void SendMessageField()
+        {
+            GUILayout.Label("Send Message:");
+
+            sendMessage = GUILayout.TextField(sendMessage);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected virtual void DisplayOptionFields()
+        {
+            applyToBuildScenesOnly = GUILayout.Toggle(applyToBuildScenesOnly, "Apply to Build Scenes Only");
+
+            thisSceneOnly = GUILayout.Toggle(thisSceneOnly, "This Scene Only");
+
+            if (scriptableObjects != null)
+                scriptableObjectNameIsField = GUILayout.Toggle(scriptableObjectNameIsField, "Scriptable Object Name Is Field");
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected virtual void DisplayFieldNamesProperty()
+        {
+            if (fieldNames.Count != scriptableObjects.Count)
+            {
+                fieldNames.Clear();
+
+                foreach (var obj in scriptableObjects)
+                    if (obj != null)
+                        fieldNames.Add(obj.name);
+            }
+
+            if (!scriptableObjectNameIsField &&
+                scriptableObjects != null && scriptableObjects.Count > 0 && scriptableObjects[0] != null)
+                fieldNamesProperty = DisplayProperty(fieldNamesProperty, "fieldNames");
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="serializedObject"></param>
+        /// <param name="fieldName"></param>
+        /// <returns></returns>
+        protected virtual SerializedObject DisplayProperty(SerializedObject serializedObject, string fieldName)
+        {
+            if (serializedObject != null)
+            {
+                serializedObject.Update();
+
+                EditorGUILayout.PropertyField(serializedObject.FindProperty(fieldName), true);
+
+                serializedObject.ApplyModifiedProperties();
+            }
+            else
+                serializedObject = new SerializedObject(this);
+
+            return serializedObject;
+        }
+
+        #region AssignAllInstancesInScenes
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void AssignAllInstancesInScenes()
+        {
+            if (!ValidObjects() || !ValidComponentTypes())
+                return;
+
+            if (!thisSceneOnly && GetScenePaths() is string[] allScenePaths)
+                foreach (var scenePath in allScenePaths)
+                    AssignAllInstancesIn(EditorSceneManager.OpenScene(scenePath, OpenSceneMode.Single));
+            else
+                AssignAllInstancesIn(SceneManager.GetActiveScene());
+
+            EditorUtility.DisplayDialog("Complete", $"Completed assigning Scriptable Objects {assignedCount} times.", "OK");
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool ValidObjects()
+        {
+            bool result = !scriptableObjects.Contains(null) && !components.Contains(null);
+
+            if (!result)
+                EditorUtility.DisplayDialog("Error", "Please ensure Scriptable Objects and Components are assigned.", "OK");
+
+            return result;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool ValidComponentTypes()
+        {
+            foreach (var component in components)
+                if (!ValidComponentType(component))
+                    return false;
+
+            return true;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool ValidComponentType(MonoScript component)
+        {
+            bool result = component.GetClass() != null && typeof(MonoBehaviour).IsAssignableFrom(component.GetClass());
+
+            if (!result)
+                EditorUtility.DisplayDialog("Error", "The assigned script is not a MonoBehaviour.", "OK");
+
+            return result;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual string[] GetScenePaths()
+            => applyToBuildScenesOnly
+                ? GetBuildScenesPaths()
+                : AssetDatabase.FindAssets("t:Scene").Select(AssetDatabase.GUIDToAssetPath).ToArray();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        /// <remarks></remarks>
+        public static string[] GetBuildScenesPaths()
+            => EditorBuildSettings.scenes
+            .Where(scene => scene.enabled)
+            .Select(scene => scene.path)
+            .ToArray();
+
+        #endregion
+
+        #region AssignAllInstancesInSceneAndObjects
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="scene"></param>
+        protected virtual void AssignAllInstancesIn(Scene scene)
+        {
+            var allObjects = scene.GetRootGameObjects();
+
+            int initialCount = assignedCount;
+
+            foreach (var gameObject in allObjects)
+                if (components.Count != 0)
+                    foreach (var component in components)
+                        AssignAllInstancesOnObject(scene, gameObject, component.GetClass());
+                else
+                    AssignAllInstancesInFamily(scene, gameObject);
+
+            if (initialCount != assignedCount)
+                EditorSceneManager.SaveScene(scene);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="scene"></param>
+        /// <param name="gameObject"></param>
+        protected virtual void AssignAllInstancesInFamily(Scene scene, GameObject gameObject)
+        {
+            var components = gameObject.GetComponents<Component>();
+
+            foreach (var component in components)
+                foreach (var scriptableObject in scriptableObjects)
+                {
+                    AssignAllInstancesOnComponent(component, component.GetType(), scriptableObject);
+
+                    EditorUtility.SetDirty(component);
+                }
+
+            if (gameObject.transform.childCount > 0)
+                foreach (Transform child in gameObject.transform)
+                    AssignAllInstancesInFamily(scene, child.gameObject);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="scene"></param>
+        /// <param name="gameObject"></param>
+        /// <param name="componentType"></param>
+        protected virtual void AssignAllInstancesOnObject(Scene scene, GameObject gameObject, Type componentType)
+        {
+            var components = gameObject.GetComponentsInChildren(componentType, true);
+
+            if (components.Length > 0 && !thisSceneOnly)
+                UnityEngine.Debug.Log(GetType() + ": " + components.Length +
+                    " Found on Object: " + gameObject.name + " in scene: " + scene.name);
+
+            foreach (var component in components)
+                foreach (var scriptableObject in scriptableObjects)
+                    AssignAllInstancesOnComponent(component, componentType, scriptableObject);
+        }
+
+        #endregion
+
+        #region AssignAllInstancesOnComponent
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="component"></param>
+        /// <param name="componentType"></param>
+        /// <param name="scriptableObject"></param>
+        /// <remarks></remarks>
+        protected virtual void AssignAllInstancesOnComponent(Component component, Type componentType,
+            ScriptableObject scriptableObject)
+        {
+            FieldInfo fieldInfo = GetFieldInfo(componentType, fieldNames[scriptableObjects.IndexOf(scriptableObject)]);
+
+            if (FieldMatchesObject(fieldInfo, scriptableObject))
+                AssignObjectToField(component, fieldInfo, scriptableObject);
+            else if (!thisSceneOnly)
+                UnityEngine.Debug.LogWarning(GetType() + ": ALERT: The field Info for: "
+                    + fieldNames[scriptableObjects.IndexOf(scriptableObject)] + " couldn't be found.");
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="componentType"></param>
+        /// <param name="fieldName"></param>
+        /// <returns></returns>
+        protected virtual FieldInfo GetFieldInfo(Type componentType, string fieldName)
+        {
+            FieldInfo fieldInfo = componentType
+                .GetField(fieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+
+            if (fieldInfo == null && fieldName.Length >= 2 && char.IsUpper(fieldName[0]))
+            {
+                string pascalName = char.ToLower(fieldName[0]) + fieldName[1..];
+
+                if (!thisSceneOnly)
+                    UnityEngine.Debug.Log(GetType().ToString() + ": Field info couldn't be found with name : " + fieldName +
+                        " So checking with name: " + pascalName);
+
+                return GetFieldInfo(componentType, pascalName);
+            }
+
+            return fieldInfo;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="fieldInfo"></param>
+        /// <param name="scriptableObject"></param>
+        /// <returns></returns>
+        protected virtual bool FieldMatchesObject(FieldInfo fieldInfo, ScriptableObject scriptableObject)
+            => fieldInfo != null && fieldInfo.FieldType == scriptableObject.GetType();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="component"></param>
+        /// <param name="fieldInfo"></param>
+        /// <param name="scriptableObject"></param>
+        protected virtual void AssignObjectToField(Component component, FieldInfo fieldInfo, ScriptableObject scriptableObject)
+        {
+            UnityEngine.Debug.Log($"{GetType()}: Field info was found! Assigning value.");
+
+            fieldInfo.SetValue(component, scriptableObject);
+
+            if (!string.IsNullOrEmpty(sendMessage))
+            {
+                component.SendMessage(sendMessage, SendMessageOptions.DontRequireReceiver);
+
+                EditorUtility.SetDirty(component);
+            }
+
+            assignedCount++;
+        }
+
+        #endregion
+    }
+}

package/Scripts/Editor/Utility/ScriptableObjectAssigner.cs.meta

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

package/Scripts/Editor/Utility/SerializedPropertyExtensions.cs

@@ -0,0 +1,59 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+#if UNITY_EDITOR
+using System.Linq;
+using System.Reflection;
+using UnityEditor;
+
+namespace DREditor.Editor.Utility
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class SerializedPropertyExtensions
+    {
+        public static object GetTargetObjectOfProperty(this SerializedProperty prop)
+        {
+            object target = prop.serializedObject.targetObject;
+
+            string[] path = prop.propertyPath.Replace(".Array.data[", "[").Split('.');
+
+            foreach (var part in path)
+            {
+                if (part.Contains("["))
+                {
+                    string elementName = part[..part.IndexOf("[")];
+
+                    int index = int.Parse(part[part.IndexOf("[")..].Replace("[", "").Replace("]", ""));
+
+                    target = GetFieldValue(target, elementName);
+
+                    target = ((System.Collections.IEnumerable)target).Cast<object>().ElementAt(index);
+                }
+                else
+                    target = GetFieldValue(target, part);
+            }
+
+            return target;
+        }
+
+        private static object GetFieldValue(object obj, string name)
+        {
+            if (obj == null)
+                return null;
+
+            var type = obj.GetType();
+
+            FieldInfo field = null;
+
+            while (type != null && field == null)
+            {
+                field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+
+                type = type.BaseType;
+            }
+
+            return field?.GetValue(obj);
+        }
+    }
+}
+#endif

package/Scripts/Editor/Utility/SerializedPropertyExtensions.cs.meta

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

package/Scripts/Editor/Utility/SimpleFilteredSOWindow.cs

@@ -0,0 +1,169 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+#if UNITY_EDITOR
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Utility
+{
+    /// <summary>
+    ///
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class SimpleFilteredSOWindow<T> : FilteredSOPickerWindow<T>
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        protected Rect currentlyDrawnRow;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected readonly float rowSpacing = 28;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected readonly float rowHeight = 24;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected readonly float iconSpacing = 3;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected readonly float iconWidth = 18;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected readonly float iconHeight = 18;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected readonly string refreshButtonText = "Refresh";
+
+
+        protected virtual void OnGUI()
+        {
+            DrawToolbar();
+
+            DrawCountLabel();
+
+            DrawNoneRow();
+
+            HandySplitters.UISplitter(Color.gray);
+
+            DrawFilteredAssetList();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void DrawToolbar()
+        {
+            using (new EditorGUILayout.HorizontalScope(EditorStyles.toolbar))
+            {
+                EditorGUI.BeginChangeCheck();
+
+                search = EditorGUILayout.TextField(search, EditorStyles.toolbarSearchField, GUILayout.ExpandWidth(true));
+
+                if (EditorGUI.EndChangeCheck())
+                    ApplySearch();
+
+                if (HandyFields.ToolbarButton(refreshButtonText))
+                    RefreshAssets();
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void DrawCountLabel()
+            => EditorGUILayout.LabelField($"{GetAssetCountString()} implementing {typeof(T).Name}",
+                EditorStyles.centeredGreyMiniLabel);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual string GetAssetCountString() => $"{filteredObjects.Count} asset{(filteredObjects.Count != 1 ? "s" : "")}";
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void DrawNoneRow() => DrawRow(null);
+
+        protected override void DrawRow(ScriptableObject asset)
+        {
+            currentlyDrawnRow = EditorGUILayout.GetControlRect(false, rowHeight);
+
+            DrawRowBackground(asset);
+
+            DrawRowIcon(asset);
+
+            DrawRowLabel(asset);
+
+            HandyEditor.PingAndDoOnClick(asset, currentlyDrawnRow, Assign);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="asset"></param>
+        protected virtual void DrawRowBackground(ScriptableObject asset)
+        {
+            if (asset == current)
+                EditorGUI.DrawRect(currentlyDrawnRow, selectedBackgroundColor);
+            else if (currentlyDrawnRow.Contains(Event.current.mousePosition))
+                EditorGUI.DrawRect(currentlyDrawnRow, hoverBackgroundColor);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="asset"></param>
+        protected virtual void DrawRowIcon(ScriptableObject asset)
+        {
+            if (asset != null)
+            {
+                Texture icon = EditorGUIUtility.ObjectContent(asset, asset.GetType()).image;
+
+                if (icon != null)
+                    GUI.DrawTexture(
+                        new Rect(currentlyDrawnRow.x + iconSpacing, currentlyDrawnRow.y + iconSpacing, iconWidth, iconHeight),
+                        icon,
+                        ScaleMode.ScaleToFit);
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="asset"></param>
+        protected virtual void DrawRowLabel(ScriptableObject asset)
+        {
+            string display = asset == null ? "None"
+                : $"{asset.name}   <color=#{ColorUtility.ToHtmlStringRGBA(Color.gray)}><i>{asset.GetType().Name}</i></color>";
+
+            GUIStyle labelStyle = new(EditorStyles.label)
+            {
+                richText = true,
+                alignment = TextAnchor.MiddleLeft
+            };
+
+            if (asset == current)
+                labelStyle.fontStyle = FontStyle.Bold;
+
+            Rect labelRect = new(currentlyDrawnRow.x + rowSpacing, currentlyDrawnRow.y,
+                currentlyDrawnRow.width - rowSpacing, currentlyDrawnRow.height);
+
+            GUI.Label(labelRect, display, labelStyle);
+        }
+    }
+}
+#endif

package/Scripts/Editor/Utility/SimpleFilteredSOWindow.cs.meta

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