protected override TreeViewItem BuildRoot()
        {
            var root = new TreeViewItem(-1, -1, "Root");

            root.children = new List <TreeViewItem>();

            if (targets != null && targets.Length == 1)
            {
                var target = targets[0];

                if (target == null)
                {
                    parentWindow.Close();

                    return(root);
                }

                // Build the minimal transform hierarchy
                var parents = new List <GameObject>();

                var currentParent = target;

                while (currentParent != null)
                {
                    parents.Add(currentParent);
                    currentParent = currentParent.transform.parent.AsUnityNull()?.gameObject;
                }

                parents.Reverse();

                var rootTransform = parents[0];
                var scene         = rootTransform.gameObject.scene;
                var sceneItem     = new SceneItem(scene);
                root.AddChild(sceneItem);
                Item currentParentItem = sceneItem;

                foreach (var parent in parents)
                {
                    var parentItem = new GameObjectItem(parent);
                    currentParentItem.AddChild(parentItem);
                    currentParentItem = parentItem;
                }

                AddChildrenRecursive((GameObjectItem)currentParentItem);

                // AddSiblings((GameObjectItem)currentParentItem);
            }
            else
            {
                var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();

                if (prefabStage != null)
                {
                    // Build the prefab stage hierarchy

                    var prefabRoot     = prefabStage.prefabContentsRoot;
                    var prefabRootItem = new GameObjectItem(prefabRoot);

                    var stageItem = new PrefabStageItem(prefabStage);
                    AddChildrenRecursive(prefabRootItem);
                    stageItem.AddChild(prefabRootItem);
                    root.AddChild(stageItem);
                }
                else
                {
                    // Build the full scene hierarchy

                    for (var i = 0; i < SceneManager.sceneCount; i++)
                    {
                        var scene = SceneManager.GetSceneAt(i);

                        if (!scene.IsValid())
                        {
                            continue;
                        }

                        var sceneItem = new SceneItem(scene);

                        if (scene.isLoaded)
                        {
                            foreach (var sceneRootGameObject in scene.GetRootGameObjects())
                            {
                                var sceneRootGameObjectItem = new GameObjectItem(sceneRootGameObject);

                                AddChildrenRecursive(sceneRootGameObjectItem);

                                sceneItem.AddChild(sceneRootGameObjectItem);
                            }
                        }

                        root.AddChild(sceneItem);
                    }
                }
            }

            // Override with search if needed
            if (hasSearch)
            {
                var searchRoot    = new TreeViewItem(-1, -1, "Results");
                var searchResults = new List <TreeViewItem>();

                var treeViewItemStack = new Stack <TreeViewItem>();
                treeViewItemStack.Push(root);

                while (treeViewItemStack.Count > 0)
                {
                    var treeViewItem = treeViewItemStack.Pop();

                    if (treeViewItem.children != null)
                    {
                        foreach (var child in treeViewItem.children)
                        {
                            if (child != null)
                            {
                                if (DoesItemMatchSearch(child, searchString))
                                {
                                    searchResults.Add(child);
                                }

                                treeViewItemStack.Push(child);
                            }
                        }
                    }
                }

                foreach (var searchResult in searchResults)
                {
                    searchResult.children = null;
                }

                searchResults.Sort((x, y) => SearchUtility.Relevance(searchString, x.displayName).CompareTo(SearchUtility.Relevance(searchString, y.displayName)));
                searchRoot.children = searchResults;
                root = searchRoot;
            }

            SetupDepthsFromParentsAndChildren(root);

            hoveredItem = null;

            return(root);
        }