unity 目录树

已于 2023-12-26 20:10:52 修改
阅读量1.1k 收藏 2
点赞数
分类专栏： Unity UGUI 文章标签： Unity UGUI
于 2019-05-23 20:44:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xdedzl/article/details/90487155
版权
Unity 同时被 2 个专栏收录
32 篇文章 6 订阅
订阅专栏
UGUI
5 篇文章 0 订阅
订阅专栏

最近项目上需要对一些编组信息进行树状展示,为了通用，将目录树写成一个组件，完整的代码包括测试代码已经上传到了github上目录树代码，代码需要配合RectTransform的锚点使用，所以写了一个编辑器扩展，可以像创建其他UI组件一样创建一个目录树编辑器代码

使用方式

1.在编辑器中创建一个Tree

在这里插入图片描述

2.在代码中获取并创建

  首先要在对应面板中获取到Tree组件，用于构造一棵树的函数为

Tree.GenerateTree(TreeNode rootNode)

  这个函数需要传入一个节点，这个节点可以是一个空节点，也可以是一个已经构造好父子关系的根节点。传入之后，会根据这个节点的子节点信息创建一棵树。
  TreeNode支持链式添加父子关系，可以像下面一样构造一棵树。

TreeNode root = new TreeNode("1");

root.AddChild(new TreeNode("11")
        .AddChild(new TreeNode("111")
            .AddChild(new TreeNode("1111")
                .AddChild(new TreeNode("11111"))
                .AddChild(new TreeNode("11112")))
            .AddChild(new TreeNode("1112")))
        .AddChild(new TreeNode("112")))
    .AddChild(new TreeNode("12")
        .AddChild(new TreeNode("121"))
        .AddChild(new TreeNode("122")
            .AddChild(new TreeNode("1221"))
            .AddChild(new TreeNode("1222")))
        .AddChild(new TreeNode("123")))
    .AddChild(new TreeNode("13")
        .AddChild(new TreeNode("131")));

tree.GenerateTree(root);

  但大多数情况下，树的信息应该是由另外一个信息类或者数据表之类的东西转来的，所以父子关系的创建需要自己写。

代码

1.树的节点

  在大多数的时候外界并不需要对TreeNode进行直接控制，但是在初始化树的时候，要传入一个已经设置好父子关系的根节点，这个类里面的几个核心方法都利用了递归，所以在更新一个节点的信息的时候，这个节点的所有子节点也会改变。
树的节点的初始化是根据对应的模板来，目前还不是很灵活，模板结构变化比较大的话需要修改InitEnity方法。

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

namespace XFramework.UI
{
    /// <summary>
    /// 树节点
    /// </summary>
    public class TreeNode
    {
        private RectTransform m_Rect;
        /// <summary>
        /// 当前结点所归属的树
        /// </summary>
        private Tree m_Tree;
        /// <summary>
        /// 子结点
        /// </summary>
        private List<TreeNode> m_Childs;
        /// <summary>
        /// 父结点
        /// </summary>
        private TreeNode m_Parent;
        /// <summary>
        /// 开启状态
        /// </summary>
        private bool m_IsOn;
        /// <summary>
        /// 层级
        /// </summary>
        private int m_level;

        /// <summary>
        /// 显示文字
        /// </summary>
        public string Text { get; private set; }

        public TreeNode()
        {
            m_IsOn = true;
            m_Childs = new List<TreeNode>();
        }

        public TreeNode(string text) : this()
        {
            this.Text = text;
        }

        /// <summary>
        /// 初始化场景中对应的实体
        /// </summary>
        /// <param name="tree"></param>
        private void InitEnity(Tree tree)
        {
            m_Tree = tree;

            // 创建自己
            if (m_Parent == null)
            {
                m_Rect = Object.Instantiate(m_Tree.NodeTemplate, m_Tree.NodeTemplate.transform.parent.Find("Root")).GetComponent<RectTransform>();
                m_level = 0;
            }
            else
            {
                m_Rect = Object.Instantiate(m_Tree.NodeTemplate, m_Parent.m_Rect.Find("Child")).GetComponent<RectTransform>();
                m_level = m_Parent.m_level + 1;
            }

            // UI组件设置
            m_Rect.Find("Toggle").GetComponent<Toggle>().onValueChanged.AddListener((value) =>
            {
                m_IsOn = value;

                Refresh(value);
                Root.RefreshPos();

                tree.onOn_Off.Invoke(value, this);
            });

            m_Rect.Find("Button").GetComponent<Button>().onClick.AddListener(() =>
            {
                tree.onSelectNode.Invoke(this);
            });

            m_Rect.Find("Button").Find("Text").GetComponent<Text>().text = this.Text;
        }

        /// <summary>
        /// 刷新位置及显示隐藏
        /// </summary>
        private void Refresh(bool isOn)
        {
            isOn &= m_IsOn;
            if (isOn)
            {
                foreach (var item in m_Childs)
                {
                    item.Refresh(isOn);
                    item.m_Rect.localScale = new Vector3(1, 1, 1);
                }
            }
            else
            {
                foreach (var item in m_Childs)
                {
                    item.Refresh(isOn);
                    item.m_Rect.localScale = new Vector3(1, 0, 1);
                }
            }
        }

        /// <summary>
        /// 刷新位置
        /// </summary>
        public void RefreshPos()
        {
            int index = 0;

            if (m_Parent != null)
            {
                foreach (var item in m_Parent.m_Childs)
                {
                    if (item == this)
                        break;
                    index += item.GetItemCount();
                }
            }

            m_Rect.anchoredPosition = new Vector2(0, -index * 30);

            foreach (var item in m_Childs)
            {
                item.RefreshPos();
            }
        }

        /// <summary>
        /// 添加一个父子关系
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public TreeNode AddChild(TreeNode item)
        {
            m_Childs.Add(item);
            item.m_Parent = this;
            return this;
        }

        public TreeNode AddChild(string text)
        {
            return AddChild(new TreeNode(text));
        }

        /// <summary>
        /// 根据已有的父子关系创建一颗（子）树
        /// </summary>
        /// <param name="m_Parent"></param>
        /// <param name="gameObject"></param>
        public void CreateTree(Tree tree)
        {
            InitEnity(tree);

            // 继续创建
            foreach (var child in m_Childs)
            {
                child.CreateTree(m_Tree);
            }

            if (m_Parent == null)
            {
                RefreshPos();
            }
        }

        /// <summary>
        /// 添加一个父子关系并创建实体
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public TreeNode CreateChild(TreeNode item)
        {
            AddChild(item);

            item.InitEnity(m_Tree);
            Refresh(m_IsOn);
            Root.RefreshPos();
            return this;
        }

        public TreeNode CreateChild(string text)
        {
            TreeNode item = new TreeNode(text);
            return CreateChild(item);
        }

        /// <summary>
        /// 删除自身
        /// </summary>
        public void Delete()
        {
            if(m_Parent == null)
            {
                Debug.Log("根结点不能删除");
                return;
            }
            Object.Destroy(m_Rect.gameObject);
            m_Parent.m_Childs.Remove(this);
            Root.RefreshPos();
        }

        /// <summary>
        /// 子物体的数量 +1
        /// </summary>
        public int GetItemCount()
        {
            if (m_Childs.Count == 0 || !m_IsOn)
            {
                return 1;
            }
            else
            {
                int count = 0;
                foreach (var item in m_Childs)
                {
                    count += item.GetItemCount();
                }
                return count + 1;
            }
        }

        /// <summary>
        /// 获取自己在父物体种的索引
        /// </summary>
        public int GetSiblingIndex()
        {
            if(m_Parent != null)
            {
                int index = 0;
                foreach (var item in m_Parent.m_Childs)
                {
                    if (item == this)
                        return index;
                }
            }
            return 0;
        }

        /// <summary>
        /// 根结点
        /// </summary>
        public TreeNode Root
        {
            get
            {
                TreeNode item = this;
                while(item.m_Parent != null)
                {
                    item = item.m_Parent;
                }
                return item;
            }
        }

        /// <summary>
        /// 重置父物体
        /// </summary>
        /// <param name="parent"></param>
        public void SetParent(TreeNode parent)
        {
            m_Parent.m_Childs.Remove(this);
            parent.AddChild(this);
        }

        /// <summary>
        /// 通过字符串找寻子节点
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public TreeNode Find(string path)
        {
            var temp = path.Split(new char[] { '/' }, 2);
            if (temp.Length == 1)
                return this;

            TreeNode node = null;
            foreach (var item in m_Childs)
            {
                if (item.Text == temp[0])
                {
                    node = item;
                    break;
                }
            }

            if (node == null)
                return node;
            else
                return node.Find(temp[1]);
        }

        /// <summary>
        /// 根据索引获取子节点
        /// </summary>
        public TreeNode GetChild(int index)
        {
            return m_Childs[index];
        }
    }
}

2.树

  这个类的使用方式就像Button一样，可以先注册事件，然后调用GenerateTree在场景中构造一棵树，注意事件的实际调用者不是Tree而是TreeNode

using UnityEngine;

namespace XFramework.UI
{
    /// <summary>
    /// 目录树
    /// </summary>
    public class Tree : MonoBehaviour
    {
        /// <summary>
        /// 模板
        /// </summary>
        public GameObject NodeTemplate { get; private set; }
        /// <summary>
        /// 树的根节点
        /// </summary>
        private TreeNode m_RootTreeNode;

        public string rootText = "Root";

        /// <summary>
        /// 节点被选中的事件
        /// </summary>
        public TreeEvent onSelectNode = new TreeEvent();
        /// <summary>
        /// 节点展开关闭事件
        /// </summary>
        public SwitchEvent onOn_Off = new SwitchEvent();

        private void Awake()
        {
            NodeTemplate = transform.Find("NodeTemplate").gameObject;
            NodeTemplate.GetComponent<RectTransform>().anchoredPosition = new Vector2(10000, 10000);
        }

        /// <summary>
        /// 构造一棵树
        /// </summary>
        /// <param name="rootNode">父子关系已经设置好的根节点</param>
        public void GenerateTree(TreeNode rootNode)
        {
            if (m_RootTreeNode != null)
                m_RootTreeNode.Delete();

            m_RootTreeNode = rootNode;

            m_RootTreeNode.CreateTree(this);
        }

        /// <summary>
        /// 删除某个节点
        /// </summary>
        /// <param name="path">路径</param>
        public bool Delete(string path)
        {
            TreeNode node = m_RootTreeNode.Find(path);
            if (node != null)
            {
                node.Delete();
                return true;
            }
            return false;
        }

        public class TreeEvent : UnityEngine.Events.UnityEvent<TreeNode> { }
        public class SwitchEvent : UnityEngine.Events.UnityEvent<bool,TreeNode> { }
    }
}

3.Editor

  最后放上编辑器代码，可以直接在场景中创建出一棵树

using UnityEngine;
using UnityEditor;
using UnityEngine.UI;

/// <summary>
/// 用于创建一些自定义UI组件
/// </summary>
public class CreateComponent
{
    private static DefaultControls.Resources s_StandardResources;

    private const string kUILayerName = "UI";

    private const string kStandardSpritePath = "UI/Skin/UISprite.psd";
    private const string kBackgroundSpritePath = "UI/Skin/Background.psd";
    private const string kInputFieldBackgroundPath = "UI/Skin/InputFieldBackground.psd";
    private const string kKnobPath = "UI/Skin/Knob.psd";
    private const string kCheckmarkPath = "UI/Skin/Checkmark.psd";
    private const string kDropdownArrowPath = "UI/Skin/DropdownArrow.psd";
    private const string kMaskPath = "UI/Skin/UIMask.psd";

    [MenuItem("GameObject/UI/Tree")]
    public static void CreateTree()
    {
        GameObject parent = Selection.activeGameObject;

        RectTransform tree = new GameObject("Tree").AddComponent<RectTransform>();
        tree.SetParent(parent.transform);
        tree.localPosition = Vector3.zero;
        tree.gameObject.AddComponent<XFramework.UI.Tree>();
        tree.sizeDelta = new Vector2(180, 30);

        // 设置模板
        RectTransform itemTemplate = new GameObject("NodeTemplate").AddComponent<RectTransform>();
        itemTemplate.SetParent(tree);
        itemTemplate.pivot = new Vector2(0, 1);
        itemTemplate.anchorMin = new Vector2(0.5f, 1);
        itemTemplate.anchorMax = new Vector2(0.5f, 1);
        itemTemplate.anchoredPosition = new Vector2(-90, 0);
        itemTemplate.sizeDelta = new Vector2(180, 30);

        RectTransform button = DefaultControls.CreateButton(GetStandardResources()).GetComponent<RectTransform>();
        button.SetParent(itemTemplate);
        button.anchoredPosition = new Vector2(10, 0);
        button.sizeDelta = new Vector2(160, 30);

        RectTransform toggle = DefaultControls.CreateToggle(GetStandardResources()).GetComponent<RectTransform>();
        toggle.SetParent(itemTemplate);
        Object.DestroyImmediate(toggle.Find("Label").gameObject);
        toggle.anchoredPosition = new Vector2(-80, 0);
        toggle.sizeDelta = new Vector2(20, 20);

        RectTransform child = new GameObject("Child").AddComponent<RectTransform>();
        child.SetParent(itemTemplate);
        child.pivot = new Vector2(0, 1);
        child.anchorMin = new Vector2(0, 1);
        child.anchorMax = new Vector2(0, 1);
        child.sizeDelta = Vector2.zero;
        child.anchoredPosition = new Vector2(20, -30);


        // 设置树的跟结点位置
        RectTransform treeRoot = new GameObject("Root").AddComponent<RectTransform>();
        treeRoot.SetParent(tree);
        treeRoot.anchoredPosition = new Vector2(-90, 0);
        treeRoot.sizeDelta = new Vector2(100, 30);
    }

    private static DefaultControls.Resources GetStandardResources()
    {
        if (s_StandardResources.standard == null)
        {
            s_StandardResources.standard = AssetDatabase.GetBuiltinExtraResource<Sprite>(kStandardSpritePath);
            s_StandardResources.background = AssetDatabase.GetBuiltinExtraResource<Sprite>(kBackgroundSpritePath);
            s_StandardResources.inputField = AssetDatabase.GetBuiltinExtraResource<Sprite>(kInputFieldBackgroundPath);
            s_StandardResources.knob = AssetDatabase.GetBuiltinExtraResource<Sprite>(kKnobPath);
            s_StandardResources.checkmark = AssetDatabase.GetBuiltinExtraResource<Sprite>(kCheckmarkPath);
            s_StandardResources.dropdown = AssetDatabase.GetBuiltinExtraResource<Sprite>(kDropdownArrowPath);
            s_StandardResources.mask = AssetDatabase.GetBuiltinExtraResource<Sprite>(kMaskPath);
        }
        return s_StandardResources;
    }
}
xdedzl
关注
专栏目录
关于Unity中的目录
Zero
07-06 4865
打开一个Unity工程，会看到其中有不同的目录，Unity工程的外部目录也有不少的目录，了解这些目录能帮助我们了解整个资源加载和导出的流程。 Resources目录 特点 Resources目录中的内容在打包时会直接被打到发布包中去。Resources目录有以下特点： 只读，无法动态更改，所以需要热更的资源不能放在这个目录里 目录内的资源会集成到.asset文件里 使用Resources.Loa...
Unity3D树形图插件
01-19
Unity3D树形图插件
Unity3D 自定义树组件（树形菜单）
11-05
这是一个完整的Unity树形菜单项目工程，菜单可以进行折叠，点击某个节点，可以显示出所点击菜单的信息。
unity编写树形结构的文件管理页面
lsyiwxy的博客
08-14 741
实现点击“+”按钮展开对应分类下的所有训练科目，再次点击“–”按钮将对应分类下的训练科目隐藏并收起整个面板。
unity3d：TabView，UGUI多标签页组件，TreeView树状展开菜单
最新发布
Have a nice day.
07-28 1343
1.最外层DataForm为空壳编辑数据用。可以有多个DataForm，例如福利DataForm，抽奖DataForm2.Menu层为左边栏层，每个DataForm可以使用不同样式的MenuForm预制体3.DataForm中使用ReorderList，可排列配置4.有定位功能，跳转到对应页签5.DataForm具有树状图管理，1级，2级菜单6.PageForm为每个页签的具体生命周期脚本，由DataForm控制。需要显示时如果没加载过，从资源加载。
Unity自定义组件之(五) 目录树 UITree
热门推荐
SpringD
06-01 1万+
前言 之前在项目中多次用到目录树，由于UGUI没有目录树这样组件，需要我们拿基础的UI去拼凑，但是这样拼凑的目录树一般需要制作为预制物，在我们想要迁移到别的工程时，总是因为打包且少资源而产生一些问题。而且很多新手也会遇到自己写的目录树因为逻辑问题只能打开/关闭几个层级，并不是可无限打开关闭的，且容易出现多种Bug。基于这些问题，我们可以基于UGUI的部分源码开发一个目录树组件(UITree)，简
unity自定义树形目录结构
qq_42898629的博客
08-04 989
废话不多说，先看一下最终效果: 备注:树形目录全部都是通过JSON配置文件动态添加，非常灵活，功能的核心思想是递归 如果你正好需要，那么请添加QQ:943829967,联系博主索取！ ...
Unity UGUI目录树实现
weixin_42268146的博客
06-15 1474
学习笔记 之前项目中有需求要实现构件树，实现文章目录的效果，在空余时间研究出个简陋版的目录树，主要依赖UGUI自带的组件 VerticalLayoutGroup和ContentSizeFitter，其次是通过脚本创建节点 1、首先是Hierarchy面板中创建Canvas画布，然后创建一个Image，改名为ScrollRect，然后添加Mask遮罩组件，然后添加ScrollRect组件，如图所式：2、创建完后开始创建子节点，创建一个空物体，可以命名为Tree，这个是用来挂载脚本(当然挂其它地方也一样)，然后
Unity 自定义多级树状目录
qq_40178842的博客
05-31 314
链接：https://pan.baidu.com/s/1a3o0LOofQJBBOHmaelkRvQ?--来自百度网盘超级会员V6的分享。3、目录item 的逻辑。最后附上Unity 工程。
Unity目录结构
weixin_30815469的博客
05-01 330
最外层是项目名称 Assets：资源文件夹，保存游戏中所有的资源 Library：库文件夹，保存当前项目需要的库文件 ProjectSettings：项目设置文件夹，保存项目设置信息 Temp：零时文件夹 Editor Unity软件核心文件 MonoDevelop 一款内置脚本软件 资源商店下载的资源文件位置 ...Windows ~/Library/Unity/Asset Store ...在...
unity植物树木模型资源
03-29
导入后，模型、纹理和其他资源会被添加到项目的Asset目录下，可以通过Unity编辑器的Inspector视图进行详细设置，如调整模型的缩放比例、修改材质和纹理、甚至绑定动画。 在游戏引擎中，植物树木的优化也是一个关键...
unity UI树形菜单结构
12-29
通过json配置文件，按照要求配置树形格式，生成树形菜单结构。根据需求，可以自由配置层级目录。如资源出现问题，可联系我。
Unity TreeView树形菜单
12-04
Unity 树形菜单，TreeView组件，自定义的美化TreeView源码和对应demo，样式好看，对初学者是很好的学习资料，然后也可用于Unity项目中
unity树状图插件TreeView
05-19
unity树状图插件TreeView
UITree 目录树制作
07-30
使用UGUI制作目录树结构，显示Scene视图中的层级目录。并有控制显隐的按钮。
unity 的 TreeView
07-08
unity 的 treeview，可以自定义节点大小或统一节点大小 自定义介个或统一间隔
unity树形结构菜单demo
05-30
可动态添加分级目录，可勾选，全选，自动拓展！
八叉树Demo - Unity下
06-24
3. `Assets`：这个目录包含了Unity项目的所有资源，如脚本、模型、纹理、音频等，其中可能包含了实现八叉树的C#脚本和其他相关资源。 4. `ProjectSettings`：这个目录包含Unity项目的设置，如分辨率、质量设置、输入...
unity2——tree树（自带）
qq_37576129的博客
05-27 3486
Unity3D自带功能：树物体（Tree） 通过菜单GameObject > 3D Object > Tree可以为当前场景创建一个Tree （树），同时还会把相应的Tree asset资源存放在项目文件夹中。 unity_tree_01.png Tree是标准的Fractal（分形）结构，按“第一层主干上长出数根枝干，然后枝干上又各自长出数根细枝，……最后细枝上长出多片树叶”这样一层层搭建而来。Maya中的笔刷树也是用的这种构成方法，但Unity3D相对来说更简化了一些。 TreeStru
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值