private static Dictionary <string, LayerNode> LoadDicFromObj(ConfigBuildObj buildObj)
 {
     if (buildObj.needBuilds == null)
     {
         return(null);
     }
     else
     {
         Dictionary <string, LayerNode> nodeDic = new Dictionary <string, LayerNode>();
         LayerNode node;
         if (LayerNode.TryCreateNode(rootFolder, out node))
         {
             nodeDic.Add(rootFolder, node);
         }
         foreach (var item in buildObj.needBuilds)
         {
             RetriveAddFolder(item.assetPath, nodeDic);
             if (!nodeDic.ContainsKey(item.assetPath))
             {
                 var       path = AssetDatabase.GetAssetPath(item.obj);
                 LayerNode layernode;
                 if (LayerNode.TryCreateNode(path, out layernode))
                 {
                     nodeDic.Add(item.assetPath, layernode);
                 }
             }
         }
         return(nodeDic);
     }
 }
        private static void RetriveAddFolder(string assetPath, Dictionary <string, LayerNode> nodeDic)
        {
            var folder = assetPath.Remove(assetPath.LastIndexOf("/"));

            if (folder != assetPath && !nodeDic.ContainsKey(folder))
            {
                LayerNode layernode;
                if (LayerNode.TryCreateNode(folder, out layernode))
                {
                    nodeDic.Add(folder, layernode);
                }
            }
            if (folder.Contains("/"))
            {
                RetriveAddFolder(folder, nodeDic);
            }
        }
        private void AddGroupOfObject(params string[] paths)
        {
            foreach (var item in paths)
            {
                var assetPath = item;
                RetriveObject(assetPath, (x) =>
                {
                    RetriveAddFolder(assetPath, nodeDic);

                    assetPath = AssetDatabase.GetAssetPath(x);

                    if (!nodeDic.ContainsKey(assetPath))
                    {
                        LayerNode node;
                        if (LayerNode.TryCreateNode(assetPath, out node))
                        {
                            nodeDic.Add(assetPath, node);
                        }
                    }
                });
            }

            rootNode = LoadNodesFromDic(nodeDic);
        }
        //绘制添加,删除,重置等功能
        private void DrawHeadTools()
        {
            using (var hor = new EditorGUILayout.HorizontalScope())
            {
                if (GUILayout.Button(new GUIContent("+", "从Project添加"), GUILayout.Width(20)))
                {
                    if (Selection.activeObject == null)
                    {
                        return;
                    }

                    var assetPath = AssetDatabase.GetAssetPath(Selection.activeObject);

                    AddGroupOfObject(assetPath);
                }
                if (GUILayout.Button(new GUIContent("-", "移除选中"), GUILayout.Width(20)))
                {
                    var selectedNode = new List <string>();
                    foreach (var item in nodeDic)
                    {
                        if (item.Value.selected && item.Key != rootFolder)
                        {
                            selectedNode.Add(item.Key);
                        }
                    }
                    foreach (var item in selectedNode)
                    {
                        nodeDic.Remove(item);
                    }
                    rootNode = LoadNodesFromDic(nodeDic);
                }
                //导入相关
                if (GUILayout.Button(new GUIContent("~", "导入关联资源"), GUILayout.Width(20)))
                {
                    var needAdd = new List <string>();
                    foreach (var item in nodeDic)
                    {
                        if (item.Value.selected)
                        {
                            var childs = AssetDatabase.GetDependencies(item.Value.assetPath, true);
                            foreach (var child in childs)
                            {
                                if (!needAdd.Contains(child))
                                {
                                    needAdd.Add(child);
                                }
                            }
                        }
                    }
                    foreach (var item in needAdd)
                    {
                        RetriveAddFolder(item, nodeDic);
                        if (!nodeDic.ContainsKey(item))
                        {
                            LayerNode layernode;
                            if (LayerNode.TryCreateNode(item, out layernode))
                            {
                                nodeDic.Add(item, layernode);
                            }
                        }
                    }
                    rootNode = LoadNodesFromDic(nodeDic);
                }
                //选中所有引用
                if (GUILayout.Button(new GUIContent("&", "关联资源"), GUILayout.Width(20)))
                {
                    var needSelect = new List <string>();
                    foreach (var item in nodeDic)
                    {
                        if (item.Value.selected)
                        {
                            var childs = AssetDatabase.GetDependencies(item.Value.assetPath, true);
                            foreach (var child in childs)
                            {
                                if (!needSelect.Contains(child))
                                {
                                    needSelect.Add(child);
                                }
                            }
                        }
                    }
                    foreach (var item in nodeDic)
                    {
                        item.Value.Select((needSelect.Contains(item.Key)));
                    }
                }
                //刷新
                if (GUILayout.Button(new GUIContent("*", "刷新重置"), GUILayout.Width(20)))
                {
                    var buildObj = target as ConfigBuildObj;
                    nodeDic  = LoadDicFromObj(buildObj);
                    rootNode = LoadNodesFromDic(nodeDic);
                }

                if (GUILayout.Button(new GUIContent("s", "保存配制"), GUILayout.Width(20)))
                {
                    var buildObj = target as ConfigBuildObj;
                    buildObj.needBuilds.Clear();
                    StoreLayerNodeToAsset(nodeDic, buildObj);
                    EditorUtility.SetDirty(buildObj);
                }
            }
        }