精华内容
下载资源
问答
  • Unity层级

    2020-10-30 09:18:12
    层级层级Unity中场景物体的一种属性。摄像机可以指明渲染层级以渲染场景中的部分物体。灯光可以指明照射层级以照亮部分物体(可以指定照亮某些层级的物体以显示阴影)。层级还能用于设置物理碰撞关系。 层级顺序...

    层级: 层级是Unity中场景物体的一种属性。摄像机可以指明渲染层级以渲染场景中的部分物体。灯光可以指明照射层级以照亮部分物体(可以指定照亮某些层级的物体以显示阴影)。层级还能用于设置物理碰撞关系。

    层级顺序:Unity中的渲染顺序自上而下大致分为三层。 最高层为Camera层,可以在Camera的depth那里设置,设置之后,图形的渲染顺序就是先绘制depth低的相机下的物体,再绘制depth高的相机下的物体,也就是说,depth高的相机会覆盖depth低的相机。比sorting layer再低一层的是sorting order。
    渲染关系的层级顺序:
    1 Camera
    在这里插入图片描述
    在这里插入图片描述
    2 sorting layer
    在这里插入图片描述
    3 sorting order
    在这里插入图片描述
    在这里插入图片描述
    如图 两个物体在同一层级 就通过Order in Layer确定层级高低 数字越大层级越高

    添加设置层级都在Inspector面板中操作

    展开全文
  • QHierarchy 4.3,Unity 层级编辑器强化插件,对Unity Hierarchy视图的加强插件,可以显示很多有用信息,帮助对场景的编辑和游戏对象的识别
  • QHierarchy 4.3,Unity 层级编辑器强化插件,对Unity Hierarchy视图的加强插件,可以显示很多有用信息,帮助对场景的编辑和游戏对象的识别
  • Unity层级面板

    千次阅读 2019-02-27 22:45:21
    Unity层级面板 入坑程序员也差不多一年有余了,但是一直没有养成写博客的良好习惯,这是不好滴,正好心血来潮,记录自己的一次学习心得,也供大家参考学习,大神请绕道走。 主要实现Unity中的Hierarchy层级面板...

    Unity层级面板

    入坑程序员也差不多一年有余了,但是一直没有养成写博客的良好习惯,这是不好滴,正好心血来潮,记录自己的一次学习心得,也供大家参考学习,大神请绕道走。

    完整功能请参考Demo案例。 下载地址


    ## 主要实现Unity中的Hierarchy层级面板功能

    在之前的一次开发中需要实现如上的功能,参考Unity的Hierarchy层级,也参考了网上一些道友的实现思路,已完成了功能模块的开发,现将功能模块提取出来记录,主要实现如下的一些功能:

    1. 给定对象自动生成层级对象(包含子物体)
    2. 自动刷新层级排序
    3. Ctrl多选,Shift多选
    4. 双击重命名选中对象
    5. 按下不放拖动改变层级关系
    6. 多选同时改变多个对象层级
      层级面板

    **生成层级对象** 按照给定对象的父子物体层级生成,根据子物体顺序对应生成子对象,并记录子物体深度作为在层级面板中的层级,再根据层级对应刷新显示,刷新时根据层级对应排序。
        private void GenerateHierarchy()
        {
            // 记录当前在所有层级中的起点
            currentCreatIndex = allHierarchyItems.Count;
            // 生成层级面板UI初始化
            for (int i = 0; i < currentGenerateDatas.Count; i++)
            {
                GameObject treeObj = Instantiate(hierarchyItem, ItemParent) as GameObject;
                treeObj.transform.name = currentGenerateDatas[i].nameID;
                treeObj.transform.localPosition = Vector3.zero;
                treeObj.transform.localScale = Vector3.one;
                treeObj.transform.localRotation = Quaternion.Euler(Vector3.zero);
    
                HierarchyItem tvi = treeObj.GetComponent<HierarchyItem>();
                tvi.GameObjID = currentGenerateDatas[i].gameObjID;
                tvi.NameID = currentGenerateDatas[i].nameID;
                tvi.ChildDeep = currentGenerateDatas[i].childDeep;
                tvi.hierarchyText.text = tvi.NameID;
                allHierarchyItems.Add(tvi);
    
                // 添加监听事件
                UIEventListener.Get(tvi.hierarchyButton).onPress += delegate (GameObject go, bool isPressed)
                {
                    OnClickSelect(treeObj, isPressed);
                };
                UIEventListener.Get(tvi.checkIdentical).onPress += delegate (GameObject go, bool isPressed)
                {
                    OnClickSelect(treeObj, isPressed);
                };
                UIEventListener.Get(tvi.unfoladButton).onClick += delegate (GameObject go)
                {
                    UnfoldButtonClick(tvi);
                };
            }
            // 设置层级
            for (int i = currentCreatIndex; i < allHierarchyItems.Count; i++)
            {
                HierarchyItem item = allHierarchyItems[i];
                // 根据TreeID设置树初始层级
                if (allHierarchyItems[i].ChildDeep == -1) 
                {
                    item.Hierarchy = 0;
                    item.HierarchyParent = null;
                }
                else
                {
                    HierarchyItem itemParent = allHierarchyItems[currentCreatIndex];
                    for (int j = currentCreatIndex; j < allHierarchyItems.Count; j++)
                    {
                        if (allHierarchyItems[i].GameObjID.transform.parent == allHierarchyItems[j].GameObjID.transform)
                        {
                            itemParent = allHierarchyItems[j];
                            break;
                        }
                    }
                    item.Hierarchy = itemParent.Hierarchy + 1;
                    item.HierarchyParent = itemParent;
                    itemParent.AddChildren(item);
                }
            }
            // 刷新资源树
            RefreshHierarchy();
        }
    

    **选择层级对象**

    点击选择对象,所有操作都在此处触发;
    按下鼠标时只为预选择状态,此时并没有真正选中对象,如果按下没有松开鼠标,则可以继续拖动选择要改变的层级,方可鼠标则改变对象层级;按下鼠标如果没有拖动,抬起鼠标则选中当前对象,多选的话就添加选择;如果两次点击选择对象相同,则可以重命名该对象。

    public void OnClickSelect(GameObject gameObj, bool isPressed)
        {
            if (isPressed)
            {
                isCanDragChangeUI = false;
                isCanCheckDrag = false;
    
                // 选择预处理
                HierarchyItem selectItem = gameObj.GetComponent<HierarchyItem>();
                // 如果是Shift多选 获取多选指针位置
                if (IsAnyShiftKeyPressed())
                {
                    ShiftPreSelection(selectItem);
                }
                else if (!IsAnyCtrlKeyPressed())
                {
                    // 此处是判断是否是多选拖动改变层级
                    if (!currentSelectItems.Contains(selectItem))
                    {
                        preSelectItems.Clear();
                        foreach (HierarchyItem tvi in currentSelectItems)
                        {
                            OnSelectionMarker(tvi, false);
                        }
                    }
                }
                // 设置标记信息
                OnSelectionMarker(selectItem, true);
                // 预选择对象
                if (!preSelectItems.Contains(selectItem))
                    preSelectItems.Add(selectItem);
    
                // 赋值操作对象
                _currentTargetItem = selectItem;
    
                isCanCheckDrag = true;
            }
            else
            {
                isCanCheckDrag = false;
    
                // 如果可以拖动改变层级
                if (isCanDragChangeUI)
                {
                    // 改变层级
                    ChangeHierarchy(TreeRankSort(preSelectItems), _rayTargetObj);
                    currentSelectItems = new List<HierarchyItem>(preSelectItems);
                    markerFrame.SetActive(false);
                    markerLine.SetActive(false);
                }
                else
                {
                    HierarchyItem tvi = _currentTargetItem;
                    // Ctrl多选
                    if (IsAnyCtrlKeyPressed())
                    {
                        if (currentSelectItems.Contains(tvi))
                        {
                            OnSelectionMarker(tvi, false);
                            currentSelectItems.Remove(tvi);
                        }
                        else
                            currentSelectItems.Add(tvi);
                    }
                    else // Shift多选
                    if (IsAnyShiftKeyPressed())
                    {
                        currentSelectItems.Clear();
                        if (startIndex != -1 && endIndex != -1)
                        {
                            for (int i = startIndex; i <= endIndex; i++)
                            {
                                currentSelectItems.Add(allHierarchyItems[i]);
                            }
                        }
                    }
                    else
                    {
                        currentSelectItems.Clear();
                        currentSelectItems.Add(tvi);
                    }
    
                    preSelectItems = new List<HierarchyItem>(currentSelectItems);
    
                    // 重命名
                    if (!IsAnyCtrlKeyPressed() && !IsAnyShiftKeyPressed())
                        ReNameItem(_currentTargetItem);
                }
            }
        }
    

    **改变对象层级关系**

    改变对象层级时先进行拖动范围检测,超过对象本身的范围才可以拖动改变,改变层级有两种方式,一是与目标对象同级,二是拖动到目标对象下一级。
    这里使用的时List插入排序,如果同时操作多个对象的话比较吃性能,项目已经搁置了,也懒得做优化了,不过如果哪位道友有更优解的话,欢迎评论。

    public void ChangeHierarchy(List<HierarchyItem> dragItems, GameObject targetObj)
        {
            if (dragItems.Count > 0 && targetObj)
            {
                // 获取组件
                HierarchyItem targetItem = targetObj.transform.parent.GetComponent<HierarchyItem>();
    
                if (targetItem)
                {
                    for (int i = 0; i < dragItems.Count; i++)
                    {
                        // 拖动对象不是目标对象本身或目标对象的子物体
                        if (dragItems[i] == targetItem || dragItems[i].GetAllDethChildItem(true).Contains(targetItem)) continue;
    
                        // 如果在资源树中有父物体 先从父物体中移除
                        if (dragItems[i].HierarchyParent)
                            dragItems[i].HierarchyParent.RemoveChildren(dragItems[i]);
    
                        // 将所有子物体先从链表中移除(否则会影响重新插入时的位置)
                        foreach (var tvi in dragItems[i].GetAllDethChildItem(true))
                            allHierarchyItems.Remove(tvi);
    
                        // 从所有资源树元素链表中移除当前元素 
                        allHierarchyItems.Remove(dragItems[i]);
    
                        // 拖动到同一层级
                        if (targetObj.tag == "CheckIdentical")
                        {
                            // 重新插入到拖动到的位置
                            allHierarchyItems.Insert(allHierarchyItems.IndexOf(targetItem), dragItems[i]);
    
                            // 设置资源树层级与拖动到的层级相同
                            dragItems[i].Hierarchy = targetItem.Hierarchy;
                            // 设置资源树父物体与拖动到的父物体相同
                            dragItems[i].HierarchyParent = targetItem.HierarchyParent;
    
                            // 从拖动到的位置添加到拖动到的对象的子物体
                            if (targetItem.HierarchyParent)
                                targetItem.HierarchyParent.InsertChildren(targetItem, dragItems[i]);
    
                            // 改变子物体
                            if (dragItems[i].GetChildrenCount() > 0)
                                ChangeChildHierarchy(dragItems[i]);
    
                            // 改变父物体
                            ChangeParent(dragItems[i], targetItem.HierarchyParent);
    
                        }
                        // 拖动到下一层级
                        else
                        {
                            // 重新插入到拖动到的位置
                            allHierarchyItems.Insert(GetInsertIndex(targetItem) + 1, dragItems[i]);
    
                            // 设置资源树层级到拖动到的对象的下一层级
                            dragItems[i].Hierarchy = targetItem.Hierarchy + 1;
                            // 设置资源树父物体为拖动到的对象
                            dragItems[i].HierarchyParent = targetItem;
    
                            // 将当前添加到拖动到的对象的子物体
                            targetItem.AddChildren(dragItems[i]);
    
                            // 改变子物体
                            if (dragItems[i].GetChildrenCount() > 0)
                                ChangeChildHierarchy(dragItems[i]);
    
                            // 改变物体父物体
                            dragItems[i].GameObjID.transform.parent = targetItem.GameObjID.transform;
                        }
                        // 设置选中标记信息
                        OnSelectionMarker(dragItems[i], true);
                    }
    
                    // 刷新资源树
                    RefreshHierarchy();
                }
            }
        }
    

    完整功能请参考Demo案例。 下载地址

    展开全文
  • Hierarchy PRO v2019.3p4, Unity 层级编辑器插件最新版,扩展层级编辑器的显示和操作功能,对于游戏开发的效率有很大提高,小白能很快上手。
  • Unity层级关系

    2021-07-02 21:03:23
    所有的渲染 遵循 Camera 、SortingLayer、OrderInLayer 3个优先级由高到低的渲染顺序。相同数值大的会后渲染。(类似刷油漆) UGUI中 ...层级由 Camera的Depth,SortingLayer,OrderInLayer决定 ...

    所有的渲染

    Camera 、SortingLayer、OrderInLayer 、RenderQueue 、ZDepth(距离摄像机的距离)决定渲染顺序。

    Camera depth:

    优先级永远最高,值小的最先进入渲染队列。

    SortingLayer和OrderInLayer

    SortingLayer和OrderInLayer优先级其次。SortingLayer值相同时会比较OrderInLayer。

    RenderQueue
    ZDepth

    总结

    如果物体的RenderQueue在2500的同一侧:
    Camera Depth > SortingLayer > OrderInLayer > RenderQueue > 距离相机z值
    如果物体的RenderQueueu在2500的不同侧:
    Camera Depth > RenderQueue > SortingLayer > OrderInLayer > 距离相机z值

    UGUI中

    一、相机渲染模式为Camera
    层级由 Camera的Depth,SortingLayer,OrderInLayer决定。此时UI的层级可以当做2D层级来处理。
    二、Canvas相机渲染模式为Override
    层级由Canvas的sortOrder决定。
    三、相机渲染模式为World时则按照3d物体处理。层级排序规则按照上述总结处理。

    展开全文
  • Unity层级碰撞

    千次阅读 2018-09-16 23:46:50
    unity中这种情况的处理是通过分层碰撞来解决的! 先给一个官方资料:http://docs.unity3d.com/Documentation/Components/LayerBasedCollision.html 第一步:当然在实现效果之前你要为这几...

    没有同学遇到过这种情况:在游戏开发3D游戏中很常见,比如让一个物体能穿过一个物体 而另一个物体不能穿过这个物体,而且3个物体都不能穿过地面。在unity中这种情况的处理是通过分层碰撞来解决的!

    先给一个官方资料:http://docs.unity3d.com/Documentation/Components/LayerBasedCollision.html

    第一步:当然在实现效果之前你要为这几个物体设置不同分层名称

    第二步:设置好分层后就要进行碰撞设置了,打钩表示能够碰撞,不打钩表示不碰撞

    然后整分层碰撞设置完毕!

    http://sygame.lofter.com/

    展开全文
  • QHierarchy 4.3是一款用于管理Unity3D游戏开发引擎中所有对象的插件,可以加快开发效率,仅供参考学习,商用请支持正版。
  • Transform[],GameObject[]这些class类型,Unity会进行自动初始化。 但[ExecuteInEditMode]在编辑模式下执行的时候,会发现初始化其实也是有顺序的,并且在Update之后。 这时候就会遇到等于NULL的情况。 转载于...
  • 提示:选中右侧目录,可快速找到所需内容 本系列博客地址:传送门 插件资源:购买本专栏后可私信我。 一、插件功能截图镇楼 立刻打开文档、脚本,立刻编辑 ...Ctrl+Shift+W:关闭除当前选中的文件外...
  • Unity渲染层级

    2020-11-02 19:18:15
    Unity的渲染层级有三种:Camera、Sorting layer、Order in layer 一般创建新场景的摄像机都是为Camera层,而且初始的depth为-1,在同一个摄像机下,也就是在Camera下,层级的优先级就需要根据Sorting layer来进行...
  • unity 忽略层级

    2020-07-31 15:19:11
    有时侯我们想在射线检测的时候忽略掉某些物体的碰撞,从而达到检测物体背后的物体的碰撞,这是个时候我们使用layerMask layerMask参数使用按位与<<设置的一些总结: 1 << 10 打开第10的层。...
  • Unity 渲染层级

    千次阅读 2016-07-21 22:30:24
    转载自: ... 最近连续遇到了几个绘制图像之间相互遮挡关系不正确的问题,网上查找的信息比较凌乱,所以这里就把自己...简单总结一下,决定Unity渲染关系的层级顺序是: Camera sorting layer sorting order
  • Unity UI层级/遮挡顺序

    2021-09-23 14:13:06
    Unity的Hierarchy层级面板中,层级在下的会遮挡住层级在上的UI视图,如下图所示,有三个Image物体Red、Yellow、Blue 层级从上到下,在Scene窗口中可以看见蓝色在最上层,会遮挡住黄色和红色、黄色在中间层,被蓝色...
  • Unity层级渲染

    2018-08-22 11:36:40
    渲染 3D 3D/2D 2D Camera 目录: Part1 3D渲染 Part2 UGUI Canvas渲染 Overlay 模式 Camera 模式 ... Unity中根据 Z 轴,即物体的深度来进行渲染。越靠近摄像机的物体越显示在前面 其中,Cu...
  • Unity关于层级细节(LOD);网上有很多教程,插件里面有两个demo的,可以参考
  • unity 渲染层级详解

    千次阅读 2019-02-25 14:08:39
    Camera是unity中最优先的渲染顺序控制。depth越大,渲染顺序越靠后。  2、Sorting Layer 在Tags &amp; Layers设置中可见 3、Order In Layer 相对于Sorting Layer的子排序,用这个值做比较时只有都在同一...
  • Unity2D 渲染层级

    千次阅读 2018-02-13 17:58:41
    Unity 渲染层级 渲染效果:谁被在下面,谁在上面。 -渲染层级 camera(摄像机) Depth(值越高物体越在上面) 在同一个camera中 sorting layer(越在下面的sorting layer 越在上面) 例如:player ...
  • unity-渲染层级关系Camera层级在同一Camera下,Sorting LayerOrder in Layer层级Layer层级小结 渲染主要是针对Game窗口下显示的内容,类似于画板,先画一层后画一层,后画的可以把之前的一层给覆盖掉。于是unity有...
  • Unity中的层级以及渲染顺序

    万次阅读 2017-10-17 21:51:19
    在使用unity3d开发游戏项目时,层级的问题往往伴随着UI的开发,而在引入了3D模型、粒子特效后,层级的问题就变得有些扑朔迷离了,甚至会牵扯到Unity的渲染顺序。本篇主要从UGUI的角度出发,浅析UGUI中影响层级的因素...
  • Unity渲染层级关系

    千次阅读 2018-01-24 11:35:33
    简单总结一下,决定Unity渲染关系的层级顺序是: Camera //在不同的Camera中,渲染顺序由Depth决定,depth值越低,越先渲染,值越高, 越后渲染。 sorting layer //在相同的Camera...
  • Unity中的渲染顺序自上而下大致分为三层。 最高层为Camera层,可以在Camera的depth那里设置,设置之后,图形的渲染顺序就是先绘制depth低的相机下的物体,再绘制depth高的相机下的物体,也就是说,depth高的相机会...
  • Unity3D渲染层级

    2018-05-12 13:15:19
    渲染层级的优先级(从上往下降序排列)Camera sorting layer (类似不同的文件夹)sorting order(类似文件夹下的文件 数值越大越后渲染 例:2&gt;1 所以当2和1 重叠放置的时候 2覆盖1 2在1上边 你可以看见2 ...
  • 层级菜单在Unity中用到的并不多,主要是做分类的时候用的比较多,今天就给大家分享几个层级代码,扩充一下,写成插件也是不错的。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,915
精华内容 3,166
关键字:

unity层级