feat: added project

Author: Thundernerd

Editor.meta

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using TNRD.Items;
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine.Assertions;
+using Object = UnityEngine.Object;
+
+namespace TNRD
+{
+    internal sealed class AssetsItemBuilder
+    {
+        private readonly HashSet<string> addedItems;
+        private readonly Dictionary<string, AdvancedDropdownItem> splitToItem;
+        private readonly Type interfaceType;
+
+        public AssetsItemBuilder(Type interfaceType)
+        {
+            Assert.IsNotNull(interfaceType);
+            Assert.IsTrue(interfaceType.IsInterface);
+
+            addedItems = new HashSet<string>();
+            splitToItem = new Dictionary<string, AdvancedDropdownItem>();
+            this.interfaceType = interfaceType;
+        }
+
+        public AdvancedDropdownItem Build()
+        {
+            AdvancedDropdownItem root = new AdvancedDropdownItem("Assets");
+            splitToItem.Add("Assets/", root); // Needs the trailing slash to be recognized later on
+
+            TypeCache.TypeCollection types = TypeCache.GetTypesDerivedFrom(interfaceType);
+            foreach (Type type in types)
+            {
+                if (type.IsAbstract || type.IsInterface) continue;
+                if (!type.IsSubclassOf(typeof(Object))) continue;
+
+                IEnumerable<string> paths = AssetDatabase.FindAssets($"t:{type.Name}")
+                    .Select(AssetDatabase.GUIDToAssetPath);
+
+                foreach (string path in paths)
+                {
+                    CreateItemForPath(root, path);
+                }
+            }
+
+            return root;
+        }
+
+        private void CreateItemForPath(AdvancedDropdownItem root, string path)
+        {
+            if (addedItems.Contains(path))
+                return;
+
+            AdvancedDropdownItem parent = GetOrCreateParentItem(root, path);
+            parent.AddChild(new AssetDropdownItem(path));
+            addedItems.Add(path);
+        }
+
+        private AdvancedDropdownItem GetOrCreateParentItem(AdvancedDropdownItem root, string path)
+        {
+            string currentPath = string.Empty;
+            string[] splits = path.Split('/');
+
+            AdvancedDropdownItem item = root;
+
+            for (int i = 0; i < splits.Length - 1; i++)
+            {
+                string split = splits[i];
+                currentPath += split + '/';
+
+                if (splitToItem.TryGetValue(currentPath, out AdvancedDropdownItem foundItem))
+                {
+                    item = foundItem;
+                    continue;
+                }
+
+                AdvancedDropdownItem advancedDropdownItem = new AdvancedDropdownItem(split)
+                {
+                    icon = IconUtility.FolderIcon
+                };
+                item.AddChild(advancedDropdownItem);
+                item = advancedDropdownItem;
+                splitToItem.Add(currentPath, advancedDropdownItem);
+            }
+
+            return item;
+        }
+    }
+}

Editor/Builders.meta

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using TNRD.Items;
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine.Assertions;
+
+namespace TNRD
+{
+    internal sealed class ClassesItemBuilder
+    {
+        private readonly Dictionary<string, AdvancedDropdownItem> splitToItem;
+        private readonly Type interfaceType;
+
+        public ClassesItemBuilder(Type interfaceType)
+        {
+            Assert.IsNotNull(interfaceType);
+            Assert.IsTrue(interfaceType.IsInterface);
+
+            splitToItem = new Dictionary<string, AdvancedDropdownItem>();
+            this.interfaceType = interfaceType;
+        }
+
+        public AdvancedDropdownItem Build()
+        {
+            AdvancedDropdownItem root = new AdvancedDropdownItem("Classes");
+
+            TypeCache.TypeCollection types = TypeCache.GetTypesDerivedFrom(interfaceType);
+            foreach (Type type in types)
+            {
+                if (type.IsAbstract || type.IsInterface) continue;
+                if (type.IsSubclassOf(typeof(UnityEngine.Object))) continue;
+
+                AdvancedDropdownItem parent = GetOrCreateParentItem(type, root);
+                parent.AddChild(new ClassDropdownItem(type));
+            }
+
+            return root;
+        }
+
+        private AdvancedDropdownItem GetOrCreateParentItem(Type type, AdvancedDropdownItem root)
+        {
+            Assert.IsNotNull(type);
+            Assert.IsNotNull(root);
+            Assert.IsNotNull(splitToItem);
+
+            if (string.IsNullOrEmpty(type.Namespace))
+                return root;
+
+            string[] splits = type.Namespace.Split('.');
+
+            AdvancedDropdownItem splitItem = root;
+
+            string currentPath = string.Empty;
+            foreach (string split in splits)
+            {
+                currentPath += split + '.';
+                
+                if (splitToItem.TryGetValue(currentPath, out AdvancedDropdownItem foundItem))
+                {
+                    splitItem = foundItem;
+                    continue;
+                }
+
+                AdvancedDropdownItem newSplitItem = new AdvancedDropdownItem(split)
+                {
+                    icon = IconUtility.FolderIcon
+                };
+                splitToItem.Add(currentPath, newSplitItem);
+                splitItem.AddChild(newSplitItem);
+                splitItem = newSplitItem;
+            }
+
+            return splitItem;
+        }
+    }
+}

Editor/Builders/AssetsItemBuilder.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Linq;
+using TNRD.Items;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+using UnityEngine.Assertions;
+using UnityEngine.SceneManagement;
+
+namespace TNRD
+{
+    internal sealed class SceneItemBuilder
+    {
+        private readonly Type interfaceType;
+        private readonly Scene? scene;
+
+        public SceneItemBuilder(Type interfaceType, Scene? scene)
+        {
+            Assert.IsNotNull(interfaceType);
+
+            this.interfaceType = interfaceType;
+            this.scene = scene;
+        }
+
+        public AdvancedDropdownItem Build()
+        {
+            if (scene == null)
+            {
+                return new AdvancedDropdownItem("Scene")
+                {
+                    enabled = false
+                };
+            }
+
+            AdvancedDropdownItem root = new AdvancedDropdownItemWrapper("Scene");
+
+            GameObject[] rootGameObjects = scene.Value.GetRootGameObjects();
+            
+            foreach (GameObject rootGameObject in rootGameObjects)
+            {
+                CreateItemsRecursive(rootGameObject.transform, root);
+            }
+
+            return root;
+        }
+
+        private void CreateItemsRecursive(Transform transform, AdvancedDropdownItem parent)
+        {
+            AdvancedDropdownItem advancedDropdownItem = new AdvancedDropdownItem(transform.name)
+            {
+                icon = IconUtility.GameObjectIcon
+            };
+
+            Component[] components = transform.GetComponents(interfaceType);
+            
+            foreach (Component component in components)
+            {
+                advancedDropdownItem.AddChild(new SceneDropdownItem(component));
+            }
+            
+            foreach (Transform child in transform)
+            {
+                CreateItemsRecursive(child, advancedDropdownItem);
+            }
+
+            if (advancedDropdownItem.children.Any())
+                parent.AddChild(advancedDropdownItem);
+        }
+    }
+}

Editor/Builders/AssetsItemBuilder.cs.meta

@@ -0,0 +1,29 @@
+using System.IO;
+using UnityEditor;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine;
+
+namespace TNRD.Items
+{
+    internal sealed class AssetDropdownItem : AdvancedDropdownItem, IDropdownItem
+    {
+        private readonly string path;
+
+        /// <inheritdoc />
+        public AssetDropdownItem(string path)
+            : base(Path.GetFileNameWithoutExtension(path))
+        {
+            this.path = path;
+            icon = IconUtility.GetIconForObject(path);
+        }
+
+        /// <inheritdoc />
+        ReferenceMode IDropdownItem.Mode => ReferenceMode.Unity;
+
+        /// <inheritdoc />
+        object IDropdownItem.GetValue()
+        {
+            return AssetDatabase.LoadAssetAtPath<Object>(path);
+        }
+    }
+}