Merge pull request #113 from Grizmu/feature/tree-line-renderer

 [Feature Request] Hierarchy Tree View #99

Author: arimger

Assets/Editor Toolbox/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.12.13 [WIP]
+
+### Changed:
+- Hierarchy: Added Tree List renderer, which improves visual identification of parent and child gameobjects
+- Fix SceneView settings change events firing when they shouldn't
+
 ## 0.12.12 [17.06.2024]
 
 ### Changed:

Assets/Editor Toolbox/Editor/Hierarchy/HierarchyItemDataType.cs

@@ -6,6 +6,7 @@ public enum HierarchyItemDataType
         Toggle,
         Tag,
         Layer,
-        Script
+        Script,
+        TreeLines
     }
 }

Assets/Editor Toolbox/Editor/Hierarchy/HierarchyPropertyLabel.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Text;
 
 using UnityEditor;
@@ -15,6 +16,15 @@ public abstract class HierarchyPropertyLabel
     {
         protected GameObject target;
 
+        /// <summary>
+        /// Does this label draw over the whole item?
+        /// </summary>
+        public virtual bool UsesWholeItemRect { get; } = false;
+
+        /// <summary>
+        /// Should this label draw for headers too?
+        /// </summary>
+        public virtual bool DrawForHeaders { get; } = false;
 
         public virtual bool Prepare(GameObject target, Rect availableRect)
         {
@@ -60,6 +70,8 @@ public static HierarchyPropertyLabel GetPropertyLabel(HierarchyItemDataType data
                     return new HierarchyLayerLabel();
                 case HierarchyItemDataType.Script:
                     return new HierarchyScriptLabel();
+                case HierarchyItemDataType.TreeLines:
+                    return new HierarchyTreeLinesLabel();
             }
 
             return null;
@@ -282,6 +294,159 @@ public override void OnGui(Rect rect)
             }
         }
 
+        private class HierarchyTreeLinesLabel : HierarchyPropertyLabel, IDisposable
+        {
+            private const float firstElementWidthOffset = 4.0f;
+            private const float firstElementXOffset = -45.0f;
+            private const float startXPosition = 30.0f;
+            private const float columnSize = 14.0f;
+
+            private readonly List<TreeLineLevelRenderer> levelRenderers = new List<TreeLineLevelRenderer>();
+            private int itemRenderCount = 0;
+
+            public HierarchyTreeLinesLabel()
+            {
+                EditorApplication.update += ResetItemRenderCount; 
+            }
+
+            public void Dispose()
+            {
+                EditorApplication.update -= ResetItemRenderCount;
+            }
+
+            public override sealed void OnGui(Rect rect)
+            {
+                if (Event.current.type != EventType.Repaint)
+                {
+                    return;
+                }
+
+                var levels = (int)((rect.x + firstElementXOffset) / columnSize);
+
+                if (levels <= 0)
+                {
+                    return;
+                }
+
+                if (IsFirstRenderedElement)
+                {
+                    levelRenderers.Clear();
+                }
+
+                itemRenderCount++;
+
+                rect.x = startXPosition;
+                rect.width = columnSize + firstElementWidthOffset;
+
+                var targetTransform = target.transform;
+                var siblingIndex = targetTransform.GetSiblingIndex();
+
+                if (levels > levelRenderers.Count)
+                {
+                    //Initialize missing tree line level render
+                    var startIndex = levelRenderers.Count;
+                    int x;
+                    for (x = startIndex; x < levels; x++)
+                    {
+                        var levelRenderer = new TreeLineLevelRenderer();
+                        levelRenderers.Add(levelRenderer);
+                    }
+
+                    x--;
+
+                    Transform transformBuffer = targetTransform;
+                    for (; x >= startIndex; x--)
+                    {
+                        levelRenderers[x].Initialize(transformBuffer);
+                        transformBuffer = transformBuffer.parent;
+                    }
+                }
+
+                Color colorCache = GUI.color;
+                GUI.color = Color.gray;
+
+                int i = 0;
+                for (; i < (levels - 1); i++)
+                {
+                    levelRenderers[i].OnGUI(rect, target, siblingIndex, false);
+                    rect.x += columnSize;
+                }
+
+                levelRenderers[i].OnGUI(rect, target, siblingIndex, true);
+
+                GUI.color = colorCache;
+            }
+
+            private void ResetItemRenderCount()
+            {
+                itemRenderCount = 0;
+            }
+
+            public override sealed bool UsesWholeItemRect => true;
+
+            public override sealed bool DrawForHeaders => true;
+
+            private bool IsFirstRenderedElement => itemRenderCount == 0;
+
+            private class TreeLineLevelRenderer
+            {
+                private bool renderedLastLevelGameobject = false;
+
+                public void Initialize(Transform transform)
+                {
+                    var siblingIndex = transform.GetSiblingIndex();
+                    renderedLastLevelGameobject = GetParentChildCount(transform) == (siblingIndex + 1);
+                }
+
+                public void OnGUI(Rect rect, GameObject target, int siblingIndex, bool isCurrentLevel)
+                {
+                    if (isCurrentLevel)
+                    {
+                        if (GetParentChildCount(target) == (siblingIndex + 1))
+                        {
+                            renderedLastLevelGameobject = true;
+                            EditorGUI.LabelField(rect, Style.elementLast, Style.centreAlignTreeLineStyle);
+                        }
+                        else
+                        {
+                            renderedLastLevelGameobject = false;
+                            EditorGUI.LabelField(rect, Style.elementCross, Style.centreAlignTreeLineStyle);
+                        }
+                    }
+                    else
+                    {
+                        if (!renderedLastLevelGameobject)
+                        {
+                            EditorGUI.LabelField(rect, Style.elementPass, Style.centreAlignTreeLineStyle);
+                        }
+                    }
+                }
+
+                private int GetParentChildCount(Transform transform)
+                {
+                    var parent = transform.parent;
+                    if (parent != null)
+                    {
+                        return parent.childCount;
+                    }
+
+                    var scene = transform.gameObject.scene;
+                    return scene.rootCount;
+                }
+
+                private int GetParentChildCount(GameObject gameObject)
+                {
+                    var parent = gameObject.transform.parent;
+                    if (parent != null)
+                    {
+                        return parent.childCount;
+                    }
+
+                    var scene = gameObject.scene;
+                    return scene.rootCount;
+                }
+            }
+        }
         #endregion
 
         protected static class Style
@@ -292,9 +457,18 @@ protected static class Style
             internal static readonly GUIStyle defaultAlignTextStyle;
             internal static readonly GUIStyle centreAlignTextStyle;
             internal static readonly GUIStyle rightAlignTextStyle;
+            internal static readonly GUIStyle centreAlignTreeLineStyle;
+
+            internal static readonly GUIContent elementLast;
+            internal static readonly GUIContent elementCross;
+            internal static readonly GUIContent elementPass;
 
             static Style()
             {
+                elementLast = new GUIContent("└");
+                elementCross = new GUIContent("├");
+                elementPass = new GUIContent("│");
+
                 defaultAlignTextStyle = new GUIStyle(EditorStyles.miniLabel)
                 {
 #if UNITY_2019_3_OR_NEWER
@@ -307,28 +481,26 @@ static Style()
                 {
 #if UNITY_2019_3_OR_NEWER
                     fontSize = 9,
-#else
-                    fontSize = 8,
-#endif
-#if UNITY_2019_3_OR_NEWER
                     alignment = TextAnchor.MiddleCenter
 #else
+                    fontSize = 8,
                     alignment = TextAnchor.UpperCenter
 #endif
                 };
                 rightAlignTextStyle = new GUIStyle(EditorStyles.miniLabel)
                 {
 #if UNITY_2019_3_OR_NEWER
                     fontSize = 9,
-#else
-                    fontSize = 8,
-#endif
-#if UNITY_2019_3_OR_NEWER
                     alignment = TextAnchor.MiddleRight
 #else
+                    fontSize = 8,
                     alignment = TextAnchor.UpperRight
 #endif
                 };
+                centreAlignTreeLineStyle = new GUIStyle(EditorStyles.miniLabel)
+                {
+                    fontSize = 18,
+                };
             }
         }
     }

Assets/Editor Toolbox/Editor/ToolboxEditorHierarchy.cs

@@ -124,6 +124,23 @@ private static void DrawHeaderItemLabel(Rect rect, GameObject gameObject, string
             var itemContent = new GUIContent(label, iconContent.image);
 
             EditorGUI.LabelField(rect, itemContent, Style.headerLabelStyle);
+
+            var contentRect = rect;
+            var labelsCount = propertyLabels.Count;
+            var availableRect = contentRect;
+
+            for (var i = 0; i < labelsCount; i++)
+            {
+                if (!propertyLabels[i].DrawForHeaders)
+                {
+                    continue;
+                }
+
+                contentRect = AppendPropertyLabel(propertyLabels[i], gameObject, availableRect);
+                availableRect.xMax -= contentRect.width;
+
+                EditorGUI.DrawRect(new Rect(contentRect.xMin, rect.y, Style.lineWidth, rect.height), Style.lineColor);
+            }
         }
 
         /// <summary>
@@ -167,6 +184,16 @@ private static void DrawDefaultItemLabel(Rect rect, GameObject gameObject, strin
 
         private static Rect AppendPropertyLabel(HierarchyPropertyLabel propertyLabel, GameObject target, Rect availableRect)
         {
+            if (propertyLabel.UsesWholeItemRect)
+            {
+                if (propertyLabel.Prepare(target, availableRect))
+                {
+                    propertyLabel.OnGui(availableRect);
+                }
+
+                return availableRect;
+            }
+
             //prepare currently used property label
             if (propertyLabel.Prepare(target, availableRect, out var width))
             {
@@ -275,6 +302,14 @@ internal static void CreateAllowedHierarchyContentCallbacks(params HierarchyItem
 
         internal static void RemoveAllowedHierarchyContentCallbacks()
         {
+            for (int i = 0; i < propertyLabels.Count; i++)
+            {
+                if (propertyLabels[i] is IDisposable disposable)
+                {
+                    disposable.Dispose();
+                }
+            }
+
             propertyLabels.Clear();
         }
 

Assets/Editor Toolbox/Editor/ToolboxEditorSettings.cs

@@ -192,7 +192,7 @@ internal void Validate()
         private void OnValidate()
         {
             //determine if any section was changed within the Editor
-            var settingsDirty = hierarchySettingsDirty || projectSettingsDirty || inspectorSettingsDirty;
+            var settingsDirty = hierarchySettingsDirty || projectSettingsDirty || inspectorSettingsDirty || sceneViewSettingsDirty;
             if (settingsDirty)
             {
                 //check exactly what settings are changed and apply them
@@ -229,6 +229,7 @@ private void OnValidate()
             hierarchySettingsDirty = false;
             projectSettingsDirty = false;
             inspectorSettingsDirty = false;
+            sceneViewSettingsDirty = false;
         }
 
         #endregion
@@ -464,7 +465,8 @@ private static class Defaults
                 HierarchyItemDataType.Toggle,
                 HierarchyItemDataType.Tag,
                 HierarchyItemDataType.Layer,
-                HierarchyItemDataType.Script
+                HierarchyItemDataType.Script,
+                HierarchyItemDataType.TreeLines
             };
         }
     }

README.md

@@ -842,7 +842,7 @@ Each row can contain:
 - Tag
 - Toggle to enable/disable GameObject
 - Icon
-
+- Tree Lines
 ![inspector](https://github.com/arimger/Unity-Editor-Toolbox/blob/develop/Docs/hierarchy.png)
 
 ### Project <a name="project"></a>