Icon Colors (#11)

Combined commits:

* Changes folder icons in hierarchy

* Update HierarchyFolderIcon.cs

* Merge commit 'abd4a400c93429b198a91092a71e581162352c60' as 'Packages/UnityHierarchyFolders'

* Using reflection to set folder icons on the scene hierarchy

* Added folder icon colors

* Added color hardcoded palette

* Added shortcut for folder creation

* _hasProcessedFrame initial value set to true to ensure frame always processed before icon injection

* Fixed icon names for Unity 2020.1 and up

Co-authored-by: Mohammad Zamanian <mzage31@yahoo.com>
Co-authored-by: Lucas Pereira Vasconcelos <lucas.pv@gilp.studio>

Author: 3 people

Editor/FolderEditor.cs

@@ -0,0 +1,80 @@
+using System.Threading.Tasks;
+using UnityEditor;
+using UnityEditor.Experimental;
+using UnityEngine;
+using UnityHierarchyFolders.Runtime;
+
+namespace UnityHierarchyFolders.Editor
+{
+    [CustomEditor(typeof(Folder))]
+    public class FolderEditor : UnityEditor.Editor
+    {
+        public override bool RequiresConstantRepaint()
+        {
+            return true;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            DoIconColorPicker();
+        }
+
+        private void DoIconColorPicker()
+        {
+            GUILayout.Label("Icon Color", EditorStyles.boldLabel);
+
+            SerializedProperty colorIndexProperty = serializedObject.FindProperty("_colorIndex");
+
+            EditorGUILayout.BeginHorizontal();
+            GUILayout.FlexibleSpace();
+
+            var buttonSize = 25f;
+
+            var gridRect = EditorGUILayout.GetControlRect(false, buttonSize * HierarchyFolderIcon.IconRowCount,
+                GUILayout.Width(buttonSize * HierarchyFolderIcon.IconColumnCount));
+
+            int currentIndex = colorIndexProperty.intValue;
+            for (int row = 0; row < HierarchyFolderIcon.IconRowCount; row++)
+            {
+                for (int column = 0; column < HierarchyFolderIcon.IconColumnCount; column++)
+                {
+                    int index = 1 + column + row * HierarchyFolderIcon.IconColumnCount;
+                    float width = gridRect.width / HierarchyFolderIcon.IconColumnCount;
+                    float height = gridRect.height / HierarchyFolderIcon.IconRowCount;
+                    Rect rect = new Rect(gridRect.x + width * column, gridRect.y + height * row, width, height);
+                    var (icon, _) = HierarchyFolderIcon.coloredFolderIcons[index];
+
+                    if (Event.current.type == EventType.Repaint)
+                    {
+                        if (index == currentIndex)
+                        {
+                            GUIStyle hover = "TV Selection";
+                            hover.Draw(rect, false, false, false, false);
+                        }
+                        else if (rect.Contains(Event.current.mousePosition))
+                        {
+                            GUI.backgroundColor = new Color(.7f, .7f, .7f, 1f);
+                            GUIStyle white = "WhiteBackground";
+                            white.Draw(rect, false, false, true, false);
+                            GUI.backgroundColor = Color.white;
+                        }
+                    }
+
+                    if (GUI.Button(rect, icon, EditorStyles.label))
+                    {
+                        Undo.RecordObject(target, "Set Folder Color");
+                        colorIndexProperty.intValue = currentIndex == index ? 0 : index;
+                        serializedObject.ApplyModifiedProperties();
+                        EditorApplication.RepaintHierarchyWindow();
+                        GUIUtility.ExitGUI();
+                    }
+                }
+            }
+
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.EndHorizontal();
+
+            GUILayout.Space(10f);
+        }
+    }
+}

Editor/FolderEditor.cs.meta

@@ -9,7 +9,7 @@ namespace UnityHierarchyFolders.Editor
 {
     public static class FolderEditorUtils
     {
-        const string actionName = "Create Heirarchy Folder";
+        const string actionName = "Create Heirarchy Folder %#&N";
 
         /// <summary>Add new folder "prefab".</summary>
         /// <param name="command">Menu command information.</param>

Editor/FolderEditorUtils.cs

@@ -10,16 +10,24 @@
 using UnityHierarchyFolders.Runtime;
 using Object = UnityEngine.Object;
 
-namespace Plugins.UnityHierarchyFolders {
+namespace UnityHierarchyFolders.Editor
+{
     public class HierarchyFolderIcon
     {
+#if UNITY_2020_1_OR_NEWER
+        private const string OpenedFolderPrefix = "FolderOpened";
+#else
+        private const string OpenedFolderPrefix = "OpenedFolder";
+#endif
+        private const string ClosedFolderPrefix = "Folder";
+        
         private static Texture2D openFolderTexture;
         private static Texture2D closedFolderTexture;
         private static Texture2D openFolderSelectedTexture;
         private static Texture2D closedFolderSelectedTexture;
 
         private static bool isInitialized;
-        private static bool hasProcessedFrame; 
+        private static bool hasProcessedFrame = true; 
 
         // Reflected members
         private static PropertyInfo prop_sceneHierarchy;
@@ -32,29 +40,68 @@ public class HierarchyFolderIcon
         private static MethodInfo meth_isExpanded;
         private static MethodInfo meth_getAllSceneHierarchyWindows;
 
+        private static (Texture2D, Texture2D)[] _coloredFolderIcons; 
+        public static (Texture2D, Texture2D)[] coloredFolderIcons => _coloredFolderIcons;
+        
+        public static int IconColumnCount => IconColors.GetLength(0);
+        public static int IconRowCount => IconColors.GetLength(1);
+
+        public static readonly Color[,] IconColors = {
+            {new Color(0.09f, 0.57f, 0.82f), new Color(0.05f, 0.34f, 0.48f),},
+            {new Color(0.09f, 0.67f, 0.67f), new Color(0.05f, 0.42f, 0.42f),},
+            {new Color(0.23f, 0.73f, 0.36f), new Color(0.15f, 0.41f, 0.22f),},
+            {new Color(0.55f, 0.35f, 0.71f), new Color(0.35f, 0.24f, 0.44f),},
+            {new Color(0.78f, 0.27f, 0.55f), new Color(0.52f, 0.15f, 0.35f),},
+            {new Color(0.80f, 0.66f, 0.10f), new Color(0.56f, 0.46f, 0.02f),},
+            {new Color(0.91f, 0.49f, 0.13f), new Color(0.62f, 0.33f, 0.07f),},
+            {new Color(0.91f, 0.30f, 0.24f), new Color(0.77f, 0.15f, 0.09f),},
+            {new Color(0.35f, 0.49f, 0.63f), new Color(0.24f, 0.33f, 0.42f),},
+        };
+        
         [InitializeOnLoadMethod] 
         static void Startup()
         { 
-            Initialize();
             EditorApplication.update += ResetFolderIcons;
             EditorApplication.hierarchyWindowItemOnGUI += RefreshFolderIcons;
         }
 
-        private static Texture2D GetTintedTexture(Texture2D original)
+        private static Texture2D GetTintedTexture(Texture2D original, Color tint, string name = "")
+        {
+            Color32 TintColor(Color32 c)
+            {
+                return c * tint;
+            }
+
+            return GetColorizedTexture(original, TintColor, name);
+        }
+        
+        private static Texture2D GetWhiteTexture(Texture2D original, string name = "")
+        {
+            Color32 MakeColorsWhite(Color32 c)
+            {
+                byte a = c.a;
+                c = Color.HSVToRGB(0, 0, 1);
+                c.a = a;
+ 
+                return  c;
+            }
+
+            return GetColorizedTexture(original, MakeColorsWhite, name);
+        }
+
+        private static Texture2D GetColorizedTexture(Texture2D original, Func<Color32, Color32> colorManipulator, string name = "")
         {
             var tinted = new Texture2D(original.width, original.height, 
                 original.graphicsFormat, original.mipmapCount, TextureCreationFlags.MipChain);
+
+            tinted.name = name;
+            
+            Graphics.CopyTexture(original, tinted);
 
-            Graphics.CopyTexture(original, tinted); 
             var data = tinted.GetRawTextureData<Color32>();
             for (int index = 0, len = data.Length; index < len; index++)
             {
-                Color32 c = data[index];
-                byte a = c.a;
-                c = Color.HSVToRGB(0, 0, 1);
-                c.a = a;
- 
-                data[index] = c;
+                data[index] = colorManipulator(data[index]);
             }
 
             var mipmapSize = tinted.width * tinted.height * 4;
@@ -65,20 +112,44 @@ private static Texture2D GetTintedTexture(Texture2D original)
                 mipmapSize >>= 2;
                 offset += mipmapSize;
             }
+            
+            tinted.hideFlags = HideFlags.DontSave;
             tinted.Apply();
 
             return tinted;
         }
-
-        private static void Initialize()
+        
+        private static void InitIfNeeded()
         {
             if (isInitialized) { return; }
-
-            closedFolderTexture = (Texture2D) EditorGUIUtility.IconContent("Folder Icon").image;
-            openFolderTexture = (Texture2D) EditorGUIUtility.IconContent("FolderEmpty Icon").image;
- 
-            openFolderSelectedTexture = GetTintedTexture(openFolderTexture);
-            closedFolderSelectedTexture = GetTintedTexture(closedFolderTexture);
+            
+            openFolderTexture = (Texture2D) EditorGUIUtility.IconContent($"{OpenedFolderPrefix} Icon").image;
+            closedFolderTexture = (Texture2D) EditorGUIUtility.IconContent($"{ClosedFolderPrefix} Icon").image;
+            
+            // We could use the actual white folder icons but I prefer the look of the tinted folder icon
+            // so I'm leaving this as a documented alternative.
+            //openFolderSelectedTexture = (Texture2D) EditorGUIUtility.IconContent($"{OpenedFolderPrefix} On Icon").image;
+            //closedFolderSelectedTexture = (Texture2D) EditorGUIUtility.IconContent($"{ClosedFolderPrefix} On Icon").image;
+            openFolderSelectedTexture = GetWhiteTexture(openFolderTexture, $"{OpenedFolderPrefix} Icon White");
+            closedFolderSelectedTexture = GetWhiteTexture(closedFolderTexture, $"{ClosedFolderPrefix} Icon White");
+            
+            _coloredFolderIcons = new (Texture2D, Texture2D)[] {(openFolderTexture, closedFolderTexture)};
+            
+            for (int row = 0; row < IconRowCount; row++)
+            {
+                for (int column = 0; column < IconColumnCount; column++)
+                {
+                    int index = 1 + column + row * IconColumnCount;
+                    var color = IconColors[column, row];
+                    
+                    var openFolderIcon = GetTintedTexture(openFolderSelectedTexture, 
+                        color, $"{openFolderSelectedTexture.name} {index}");
+                    var closedFolderIcon = GetTintedTexture(closedFolderSelectedTexture, 
+                        color, $"{closedFolderSelectedTexture.name} {index}");
+                    
+                    ArrayUtility.Add(ref _coloredFolderIcons, (openFolderIcon, closedFolderIcon));
+                }
+            }
 
             const BindingFlags BindingAll = BindingFlags.Public 
               | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
@@ -108,31 +179,37 @@ private static void Initialize()
 
         private static void ResetFolderIcons()
         {
-            Initialize();
+            InitIfNeeded();
             hasProcessedFrame = false;
         }
 
         private static void RefreshFolderIcons(int instanceid, Rect selectionrect)
         {
             if (hasProcessedFrame) { return; }
+            
             hasProcessedFrame = true;
 
             var windows = ((IEnumerable)meth_getAllSceneHierarchyWindows.Invoke(null, Array.Empty<object>())).Cast<EditorWindow>().ToList();
-            foreach (EditorWindow h in windows)
+            foreach (EditorWindow window in windows)
             {
-                var sceneHierarchy = prop_sceneHierarchy.GetValue(h);
+                var sceneHierarchy = prop_sceneHierarchy.GetValue(window);
                 var treeView = prop_treeView.GetValue(sceneHierarchy);
                 var data = prop_data.GetValue(treeView);
 
                 var rows = (IList<TreeViewItem>) meth_getRows.Invoke(data, Array.Empty<object>());
                 foreach (TreeViewItem item in rows)
                 {
                     var itemObject = (Object) prop_objectPPTR.GetValue(item);
-                    if (!itemObject || !Folder.IsFolder(itemObject)) { continue; }
+                    if (!Folder.TryGetIconIndex(itemObject, out int colorIndex)) { continue; }
 
+                    
                     var isExpanded = (bool) meth_isExpanded.Invoke(data, new object[] { item });
 
-                    item.icon = isExpanded ? openFolderTexture : closedFolderTexture;
+                    Texture2D open, closed;
+                    var count = _coloredFolderIcons.Length;
+                    (open, closed) = coloredFolderIcons[Mathf.Clamp(colorIndex, 0, count) % count];
+                    item.icon = isExpanded ? open : closed;
+                    
                     prop_selectedIcon.SetValue(item, isExpanded ? openFolderSelectedTexture : closedFolderSelectedTexture);
                 }
             }

Editor/HierarchyFolderIcon.cs

@@ -55,21 +55,61 @@ private Folder()
 
         private static Tool lastTool;
         private static Folder toolLock;
+
+        [SerializeField]
+        private int _colorIndex = 0;
+
+        public int colorIndex => _colorIndex;
 
         /// <summary>
         /// The set of folder objects.
         /// </summary>
-        private static HashSet<int> folders = new HashSet<int>();
+        public static Dictionary<int, int> folders = new Dictionary<int, int>();
+
+        /// <summary>
+        /// Gets the icon index associated with the specified object.
+        /// </summary>
+        /// <param name="obj">Test object.</param>
+        /// <param name="index">The icon index.</param>
+        /// <returns>True if the specified object is a folder with a registered icon index.</returns>
+        public static bool TryGetIconIndex(UnityEngine.Object obj, out int index)
+        {
+            index = -1;
+            return obj && folders.TryGetValue(obj.GetInstanceID(), out index);
+        }
 
         /// <summary>
         /// Test if a Unity object is a folder by way of containing a Folder component.
         /// </summary>
         /// <param name="obj">Test object.</param>
         /// <returns>Is this object a folder?</returns>
-        public static bool IsFolder(UnityEngine.Object obj) => folders.Contains(obj.GetInstanceID());
+        public static bool IsFolder(UnityEngine.Object obj) => folders.ContainsKey(obj.GetInstanceID());
+ 
+        private void Start() => AddOrUpdateFolderData();
+        private void OnValidate() =>  AddOrUpdateFolderData();
+        private void OnDestroy() => RemoveFolderData();
+        
+        private void RemoveFolderData()
+        {
+            var instanceId = gameObject.GetInstanceID();
+            if (folders.ContainsKey(instanceId))
+            {
+                folders.Remove(gameObject.GetInstanceID());
+            }
+        }
 
-        private void Start() => folders.Add(gameObject.GetInstanceID());
-        private void OnDestroy() => folders.Remove(gameObject.GetInstanceID());
+        private void AddOrUpdateFolderData()
+        {
+            var instanceId = gameObject.GetInstanceID();
+            if (folders.ContainsKey(instanceId))
+            {
+                folders[instanceId] = _colorIndex;
+            }
+            else
+            {
+                folders.Add(instanceId, _colorIndex);
+            }
+        }
 
         /// <summary>Hides all gizmos if selected to avoid accidental editing of the transform.</summary>
         private void HandleSelection()
@@ -157,7 +197,7 @@ private void Update()
 #if UNITY_EDITOR
             if (!Application.IsPlaying(gameObject))
             {
-                folders.Add(gameObject.GetInstanceID());
+                AddOrUpdateFolderData();
             }
 
             this.EnsureExclusiveComponent();