Unity UI框架

最新推荐文章于 2024-04-29 17:40:26 发布
最新推荐文章于 2024-04-29 17:40:26 发布
阅读量442 收藏 1
点赞数 2
分类专栏： Unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Icecoldless/article/details/103919705
版权

在这里插入图片描述
UI分为三个类型，正常显示，显示后隐藏其他所有UI，和反向切换，我用模板设计出这三个类型接口，将公共的显示与隐藏，释放，初始化，更新等公共接口抽象于父类IUserInterface，UISystem是管理容器，对所有生成的UIFrm进行资源管理，UITool提供帮助方法，UIMaskMgr控制弹窗的遮罩。UIFactory是创建UIFrm工厂，通常都是创建出来建造然后交给System管理。
可扩展，若有不同类型的UIFrm，可继承IUserInterface重写逻辑，避免修改其他类。
内存释放，交给UISystem管理类来单独释放某个UIFrm的资源或者全部释放，释放某个UIFrm的时候会销毁3d成像和代码引用。同时强转垃圾回收。
使用：利用泛型创建panel，同时传递动态参数，将显示与UI界面分离，即UI界面不挂任何一个脚本，UISystem内控制显示Panel的更新，可以自己改写一个游戏循环框架，配合UI。

文章目录

IUserInterface

using ABFW;
using System.Dynamic;
using UnityEngine;

namespace UIFW
{
    /// <summary>
    /// UI界面
    /// 模板设计模式：接口控制流程
    /// </summary>
    public abstract class IUserInterface
    {
        public string ResName; //资源名称
        protected UISystem _UISystem; //UIContext
        protected Vector3 _SpawnPosition = Vector3.zero; //生成位置
        //3D成像
        protected GameObject _GameObject;
        public IUserInterface()
        {

        }
        /// <summary>
        /// UI界面初始化
        /// </summary>
        public virtual void Initialize()
        {
        }
        /// <summary>
        /// UI逻辑更新
        /// </summary>
        public virtual void Update()
        {

        }
        /// <summary>
        /// UI释放
        /// </summary>
        public virtual void Release()
        {
            //删除3D成像
            GameObject.Destroy(_GameObject);
            //释放prefab的内存镜像资源。
            GameManager.Instance.ReleaseResource(ResName);
        }
        /// <summary>
        /// 设置3D成像
        /// </summary>
        /// <param name="_gameobject"></param>
        public virtual void SetObject(GameObject _gameObject)
        {
            _GameObject = _gameObject;
        }
        /// <summary>
        /// 设置管理上下文
        /// </summary>
        /// <param name="uiSystem"></param>
        public void AddContext(UISystem uiSystem)
        {
            _UISystem = uiSystem;
        }
        /// <summary>
        /// 窗体的显示
        /// </summary>
        public virtual void Display()
        {
            _GameObject.SetActive(true);
        }
        /// <summary>
        /// 窗体的隐藏
        /// </summary>
        public virtual void Hide()
        {
            _GameObject.SetActive(false);
        }
        /// <summary>
        /// 窗体的打开
        /// </summary>
        public abstract void Open();
        /// <summary>
        /// 窗体的关闭
        /// </summary>
        public abstract void Close();
        /// <summary>
        /// 窗体是否打开
        /// </summary>
        /// <returns></returns>
        public virtual bool IsOpen()
        {
            return _GameObject.activeSelf;
        }
    }
}

INormalUserInterface

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;

namespace UIFW
{
    public class INormalUserInterface : IUserInterface
    {
        /// <summary>
        /// Normal的父节点：可能为Fixed或者Normal
        /// </summary>
        protected Transform TraParent;
        /// <summary>
        /// 设置3D成像
        /// </summary>
        /// <param name="_gameObject"></param>
        public override void SetObject(GameObject _gameObject)
        {
            base.SetObject(_gameObject);
            _GameObject.transform.SetParent(TraParent, false);
        }
        public override void Close()
        {
            Hide();
            if (base._UISystem.DicCurShowUIFrm.ContainsKey(ResName))
                _UISystem.DicCurShowUIFrm.Remove(ResName);
        }

        public override void Open()
        {
            Display();
            if (!base._UISystem.DicCurShowUIFrm.ContainsKey(ResName))
            {
                _UISystem.DicCurShowUIFrm[ResName] = this;
            }
        }
        public override void Release()
        {
            if (base._UISystem.DicCurShowUIFrm.ContainsKey(ResName))
                _UISystem.DicCurShowUIFrm.Remove(ResName);
            base.Release();
        }
    }
}

IHideOtherUserInterface

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UIFW;
using UnityEngine;

namespace UIFW
{
    public class IHideOtherUserInterface : IUserInterface
    {
        /// <summary>
        /// 设置3D成像
        /// </summary>
        /// <param name="_gameObject"></param>
        public override void SetObject(GameObject _gameObject)
        {
            base.SetObject(_gameObject);
            _GameObject.transform.SetParent(_UISystem.TraNormal, false);
        }
        public override void Close()
        {
            IUserInterface ui;
            Hide();
            if (_UISystem.DicCurShowUIFrm.ContainsKey(ResName))
                _UISystem.DicCurShowUIFrm.Remove(ResName);
            //显示Normal
            foreach (var item in _UISystem.DicCurShowUIFrm)
            {
                item.Value.Display();
            }
            //显示PopUp
            ui = _UISystem.StackUIFrm.Peek();
            ui.Display();
        }

        public override void Open()
        {
            IUserInterface ui;
            //隐藏Normal
            foreach (var item in _UISystem.DicCurShowUIFrm)
            {
                item.Value.Hide();
            }
            //隐藏PopUp
            ui = _UISystem.StackUIFrm.Peek();
            ui.Hide();
            //显示自身
            Display();
            if (!_UISystem.DicCurShowUIFrm.ContainsKey(ResName))
                _UISystem.DicCurShowUIFrm.Add(ResName, this);
        }

        public override void Release()
        {
            if (!_UISystem.DicCurShowUIFrm.ContainsKey(ResName))
                _UISystem.DicCurShowUIFrm.Remove(ResName);
            base.Release();
        }
    }
}

IReverseChangeUserInterface

using System.Collections.Generic;
using System.Linq;
using UnityEngine;

namespace UIFW
{
    public class IReverseChangeUserInterface : IUserInterface
    {
        /// <summary>
        /// 设置3D成像
        /// </summary>
        /// <param name="_gameObject"></param>
        public override void SetObject(GameObject _gameObject)
        {
            base.SetObject(_gameObject);
            _GameObject.transform.SetParent(_UISystem.TraPopUp, false);
        }
        /// <summary>
        /// 关闭
        /// </summary>
        public override void Close()
        {
            if (!IsOpen())
            {
                Debug.LogWarning($"这个窗体还没有打开，不需要关闭！{this.GetType().Name}");
                return;
            }
            //关闭遮罩
            _UISystem.UIMaskMgr.CancelMaskWindow();
            //清除栈顶元素
            IUserInterface userInterface = base._UISystem.StackUIFrm.Pop();
            if (userInterface != this)
            {
                Debug.LogError("当前PopUp不是栈顶元素无法关闭!Close");
                return;
            }
            userInterface.Hide();
            //重绘栈顶元素
            if (base._UISystem.StackUIFrm.Count > 0)
            {
                userInterface = base._UISystem.StackUIFrm.Peek();
                userInterface.Display();
            }
        }
        /// <summary>
        /// 打开
        /// </summary>
        public override void Open()
        {
            IUserInterface ui;
            //需要显示的场景
            if (_UISystem.StackUIFrm.Count() > 0)
            {
                ui = _UISystem.StackUIFrm.Peek();
                ui.Hide();
            }
            else
            {
                //打开遮罩
                _UISystem.UIMaskMgr.SetMaskWindow(_GameObject);
            }
            //把栈顶元素隐藏
            if (_UISystem.StackUIFrm.Contains(this))
            {
                Stack<IUserInterface> tmpS = new Stack<IUserInterface>();
                while (this != _UISystem.StackUIFrm.Peek())
                {
                    tmpS.Push(_UISystem.StackUIFrm.Pop());
                }
                //找到自身
                _UISystem.StackUIFrm.Pop();
                //把tmps中的元素重新加会stack中
                while (tmpS.Count() > 0)
                {
                    ui = tmpS.Pop();
                    _UISystem.StackUIFrm.Push(ui);
                }
                //把自身换到最顶层
                _UISystem.StackUIFrm.Push(this);
            }
            else
            {
                //加入栈顶元素
                _UISystem.StackUIFrm.Push(this);
            }
            //显示自身元素
            Display();
        }

        public override void Release()
        {
            //删除缓存中元素
            if (base._UISystem.StackUIFrm.Contains(this))
            {
                Stack<IUserInterface> tmps = new Stack<IUserInterface>();
                while (base._UISystem.StackUIFrm.Peek() != this)
                {
                    tmps.Push(base._UISystem.StackUIFrm.Pop());
                }
                base._UISystem.StackUIFrm.Pop();
                while (tmps.Count() > 0)
                {
                    _UISystem.StackUIFrm.Push(tmps.Pop());
                }
            }
            base.Release();
        }
    }
}

UIMaskMgr

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

/***
*	Title：
        UI遮罩管理器
*	Description：
*	    控制启用遮罩和关闭遮罩的功能
*	    
*/
namespace UIFW
{
    public class UIMaskMgr
    {
        /// <summary>
        /// 节点
        /// </summary>
        GameObject UIMask; //遮罩的物体

        public UIMaskMgr(GameObject uiMask)
        {
            //获得UIMask
            UIMask = uiMask;
        }
        public void SetMaskWindow(GameObject UIForm)
        {
            UIMask.SetActive(true);
            //PopUp UIForm下移
            UIForm.transform.SetAsLastSibling();
        }
        public void CancelMaskWindow()
        {
            //隐藏UiMask
            if (UIMask.activeInHierarchy)
                UIMask.SetActive(false);
        }
    }
}

UIFactory

using ABFW;
using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;

namespace UIFW
{
    /// <summary>
    /// 创建UI Panel对象
    /// </summary>
    public class UIFactory
    {
        private UISystem _UISystem;
        public UIFactory(UISystem uisystem)
        {
            this._UISystem = uisystem;
        }
        /// <summary>
        /// 创建一个UI窗体
        /// </summary>
        /// <typeparam name="T">UI窗体类型</typeparam>
        /// <param name="obj">Model</param>
        /// <returns></returns>
        public IUserInterface GetUIPanel<T>() where T:IUserInterface,new()
        {
            T panel = new T();
            //建造3D成像
            GameObject prefab = GameManager.Instance.Asset.LoadAsset<GameObject>(panel.ResName);
            Debug.Log($"加载UI Prefab={prefab.name}");
            //设置上下文
            panel.AddContext(_UISystem);
            //实例化
            GameObject RootUI = GameObject.Instantiate(prefab);
            panel.SetObject(RootUI);
            //新UI的初始化
            panel.Initialize();
            return panel;
        }
    }
}

UISystem

using ABFW;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UIFW;
using UnityEngine;

namespace UIFW
{
    /// <summary>
    /// UI框架管理容器
    /// 管理所有已加载UIFrm
    /// </summary>
    public class UISystem
    {
        private static UISystem _Instance;
        public static UISystem Instance
        {
            get
            {
                if (_Instance == null)
                    _Instance = new UISystem();
                return _Instance;
            }
        }
        //工厂
        private UIFactory _Factory;
        //Canvas
        public Transform TraCanvas;
        //Normal
        public Transform TraNormal;
        //Fixed
        public Transform TraFixed;
        //PopUp
        public Transform TraPopUp;
        //UIMask
        public UIMaskMgr UIMaskMgr;
        //是否处于更新UI逻辑之中
        public bool IsUpdate;
        //所有UIFrm
        public Dictionary<string, IUserInterface> DicAllUIFrm;
        //用于添加新的UIFrm，确保在UI逻辑更新完成时添加进DicAllUIFrm中
        public Dictionary<string, IUserInterface> DicAllUIFrmTmp;
        //用于删除UIFrm的缓存容器
        public Dictionary<string, IUserInterface> DicDelUIFrmTmp;
        //当前显示在游戏中的UIFrm
        public Dictionary<string, IUserInterface> DicCurShowUIFrm;
        //堆栈中的UIFrm
        public Stack<IUserInterface> StackUIFrm;

        public UISystem()
        {
            //加载Canvas
            TraCanvas = LoadCanvas();
            Debug.Log("获得TraCanvas" + TraCanvas.name);
            //获得Normal
            TraNormal = UITool.FindChildNode(TraCanvas, "Normal");
            Debug.Log("获得TraNormal" + TraNormal.name);
            //获得Fixed
            TraFixed = UITool.FindChildNode(TraCanvas, "Fixed");
            Debug.Log("获得TraFixed" + TraFixed.name);
            //获得PopUp
            TraPopUp = UITool.FindChildNode(TraCanvas, "PopUp");
            Debug.Log("获得TraPopUp" + TraPopUp.name);
            //获得UIMask
            GameObject maskObj = UITool.FindChildNode(TraCanvas, "UIMask").gameObject;
            UIMaskMgr = new UIMaskMgr(maskObj);
            //获得工厂 
            _Factory = new UIFactory(this);

            //集合分配内存空间
            IsUpdate = false;
            DicAllUIFrm = new Dictionary<string, IUserInterface>();
            DicAllUIFrmTmp = new Dictionary<string, IUserInterface>();
            DicDelUIFrmTmp = new Dictionary<string, IUserInterface>();
            DicCurShowUIFrm = new Dictionary<string, IUserInterface>();
            StackUIFrm = new Stack<IUserInterface>();
        }
        /// <summary>
        /// 加载Canvas
        /// </summary>
        /// <returns></returns>
        public Transform LoadCanvas()
        {
            GameObject prefab = Asset.Instance.LoadAsset<GameObject>("Canvas");
            GameObject go = GameObject.Instantiate(prefab);
            Asset.Instance.ReleaseResources("Canvas");
            return go.transform;
        }
        /// <summary>
        /// 打开一个UI窗体
        /// </summary>
        /// <param name="uiFrmName"></param>
        /// <returns></returns>
        public IUserInterface OpenUIFrm<T>() where T:IUserInterface,new()
        {
            IUserInterface userInterface = null;
            //key
            string key = typeof(T).Name;
            Debug.Log("开启："+key);
            //从缓存中查询
            if(DicAllUIFrm.ContainsKey(key))
            {
                userInterface = DicAllUIFrm[key];
                //UI资源已经加载在游戏中，只需要显示即可
                if(userInterface.IsOpen())
                {
                    Debug.LogWarning($"UI已经处于显示中...{key}");
                }
                else
                    userInterface.Open();
                Debug.Log("UI项目已经加载在游戏中了");
                return userInterface;
            }
            //获得Panel
            userInterface = _Factory.GetUIPanel<T>();
            //开启UIPanel
            userInterface.Open();
            //加入缓存
            if (!IsUpdate)
                DicAllUIFrm[key] = userInterface;
            else
                DicAllUIFrmTmp[key] = userInterface;
            return userInterface;
        }
        /// <summary>
        /// 关闭UIFrm
        /// </summary>
        /// <param name="userInterface"></param>
        public void CloseUIFrm<T>()
        {
            string key = typeof(T).Name;
            IUserInterface userInterface = null;
            Debug.Log($"关闭：{key}");

            if (DicAllUIFrm.ContainsKey(key))
                userInterface = DicAllUIFrm[key];
            else if (DicAllUIFrmTmp.ContainsKey(key))
                userInterface = DicAllUIFrmTmp[key];

            if(userInterface==null)
            {
                Debug.LogWarning($"这个资源并没有开启，未加载进缓存中，不需要关闭{key}");
                return;
            }

            if (!userInterface.IsOpen())
            {
                Debug.LogWarning("这个资源并没有开启，不需要关闭");
                return;
            }
            userInterface.Close();
        }
        /// <summary>
        /// 卸载某个指定的UIFrm
        /// </summary>
        /// <param name="userInterface"></param>
        public void ReleaseUIFrm<T>()
        {
            string key = typeof(T).Name;
            Debug.Log("释放：" + key);
            IUserInterface userInterface = null;

            if (DicAllUIFrm.ContainsKey(key))
            {
                userInterface = DicAllUIFrm[key];
                //加入删除缓存
                DicDelUIFrmTmp.Add(key, userInterface);
            }
            else if (DicAllUIFrmTmp.ContainsKey(key))
            {
                userInterface = DicAllUIFrmTmp[key];
                DicAllUIFrmTmp.Remove(key);
            }
            if (userInterface == null)
            {
                Debug.LogWarning($"这个资源未加载进缓存中，不需要释放{key}");
                return;
            }
            userInterface.Close();
            userInterface.Release();
        }
        /// <summary>
        /// 更新界面UI逻辑
        /// </summary>
        public void Update()
        {
            //以当前场景下还存在显示的UI物体来判断需要显示的UI,不能根据字典DicAllUIFrm来更新UI，字典会动态变化
            //更新场景下的UI
            IsUpdate = true;
            foreach (var kv in DicAllUIFrm)
            {
                if (kv.Value.IsOpen())
                    kv.Value.Update();
            }
            IsUpdate = false;
            //检查挂起容器内是否有新加入的UI，添加到当前UI中
            foreach (var kv in DicAllUIFrmTmp)
            {
                DicAllUIFrm.Add(kv.Key, kv.Value);
            }
            DicAllUIFrmTmp.Clear();
            //检查删除容器
            foreach (var kv in DicDelUIFrmTmp)
            {
                DicAllUIFrm.Remove(kv.Key);
            }
            DicDelUIFrmTmp.Clear();
        }
        /// <summary>
        /// 卸载全部资源
        /// </summary>
        public void ReleaseAll()
        {
            //清除场景引用
            foreach (var item in DicAllUIFrm)
            {
                DicDelUIFrmTmp.Add(item.Key, item.Value);
                item.Value.Release();
            }
            foreach (var item in DicAllUIFrmTmp)
            {
                item.Value.Release();
            }
            DicAllUIFrmTmp.Clear();
            //清除Canvas
            GameObject.Destroy(TraCanvas.gameObject);
            //清除代码引用
            DicAllUIFrmTmp.Clear();
            TraCanvas = null;
            TraNormal = null;
            TraFixed = null;
            TraPopUp = null;   
            //资源回收
            Resources.UnloadUnusedAssets();
        }
    }
}

UITool

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;

namespace UIFW
{
    /// <summary>
    /// 工具人
    /// </summary>
    public class UITool
    {
        /// <summary>
        /// 根据父节点和子节点名称来查找到子节点
        /// </summary>
        /// <param name="parent">父节点</param>
        /// <param name="childName">子节点名字</param>
        /// <returns></returns>
        public static Transform FindChildNode(Transform parent, string childName)
        {
            Transform target = null;
            target = parent.Find(childName);
            if (target == null)
            {
                foreach (Transform childTran in parent)
                {
                    if (childTran != parent)
                    {
                        target = FindChildNode(childTran, childName);
                        if (target != null) //这一句很关键，如果搜索出来的target等于null了，返回了就不会继续搜索了
                            return target;
                    }
                }
            }
            return target;
        }
        /// <summary>
        /// 根据父节点和子节点名字来返回T类型的脚本组件
        /// Button
        /// </summary>
        /// <typeparam name="T">需要返回的脚本类型</typeparam>
        /// <param name="parent">父节点</param>
        /// <param name="chlldName">子节点名字</param>
        /// <returns></returns>
        public static T GetComponentFromChildNode<T>(Transform parent, string childName) where T : Component
        {
            T res = null;
            Transform childTran = FindChildNode(parent, childName);
            if (childTran != null)
            {
                res = childTran.GetComponent<T>();
            }
            return res;
        }
    }
}

CanvasScript

在这里插入图片描述

结果展示

在这里插入图片描述
关闭PopUp会重绘栈顶元素，关闭HideOther会重绘其他正常显示的元素。使用了我前面自己写的Assetbundle框架来加载元素。

使用

根据泛型来Open Panel同时可以传递动态Model参数供给View初始化的时候使用。
在这里插入图片描述

不同类型的UIFrm分别继承不同的接口即可，按需求更改3D成像的Prefab和显示位置和父亲结点。有需要传递额外模型数据的话，这样。
在这里插入图片描述

某某某某某某某某某某某某某某某
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
UI框架_unityui框架_unity_
10-01
用于开发Unity UGUI的底层框架
一套完整的UnityUI框架、可用于实际开发
03-20
一套完整的UnityUI框架、可用于实际开发。经过本人开发的考验
UniVue一个基于MVVM设计的Unity高效率UI框架
最新发布
m0_62135731的博客
04-29 356
基于Unity的UGUI框架，使用MVVM思想编写的一款UI框架。支持数据和UI的双向绑定，同时还包含了一个高效的UI事件系统。使用UniVue可以让你不用再写任何GetComponent()函数去获取指定的UI组件，也不用自己去将事件绑定到UI上。这些重复、低效的代码都由框架完成。
unity ui框架
12-12
unity的ui框架视频教程，适合已经学会unity但是还没自己ui框架的同学学习.
Unity UI框架
07-20
一个还不错的UI框架。
Unity之UI
qq_45548042的博客
10-28 1万+
Unity之UI一、Canvas1.创建Canvas2.Render Mode（1）Screen Space - Overlay（2）Screen Space - Camera（3）World Space3.Pixel Perfect二、基本布局1.矩形工具2.矩形变换(Rect Transform)3.大小与缩放4.枢(Pivot)5.锚(Anchors)三、视觉组件1.Text2.Image3.Raw Image4.Mask5.RectMask2D6.Shadow7.Outline8.Position
Unity基础笔记（3）—— Unity UI系统
Dukenone的博客
09-17 8494
Unity UI系统
Unity3D学习之UI系统——NGUI
Lmz_0314的博客
01-26 1871
资源商店搜索学习版自行搜索导入即可创建UI管理渲染相关内容UI模式是根据组件深度处理事件World模式 根据距离著摄像机的远近来响应排序（这两个的主要区别在 眼睛看到在前面的，进行交互时UI模式点击看起来在被前面的窗口压在后面的，但被压在的那一层层级更高，会先相应被压在下面的UI）EventMask 决定哪个层级接受事件Debug就是测试时，你点击这个UI，会打印出来交互的时什么对象点击New 新建选择 加入图集的文件创建图集，一般存放在Resources文件夹内，方便读取。
分享一个简单的unityAI框架，基于神经网络和遗传算法，可以简单的实现自成长的游戏对象
a827443469的博客
01-10 6616
基于神经网络和遗传算法的unity开发框架，可以轻易的应用到各种不同类型的游戏中 20171226 完成第一个demo，坦克扫雷 核心代码参考：https://github.com/ArztSamuel/Applying_EANNs 参考书籍：游戏编程中的人工智能技术（详细的介绍了神经网络和遗传算法在游戏领域的应用，虽然有点老，但不失为一本很好的入门书籍） # EasyAIFra
Unity 核心系统详解 -- UI 系统
话唠扇贝的博客
02-10 951
Unity 提供了三个 UI 系统，可以使用它们在 Unity 编辑器中创建的应用程序创建用户界面 (UI)： * UI Toolkit * Unity UI 软件包 (uGUI) * IMGUI
Unity高性能高效率自动化UI框架(一)
独立游戏阿杰的博客
06-18 1986
窗口基类：windowBehaviour 窗口实现通用基类 windowBase窗体管理类：UIModule具体窗体类： 入口类：UIMain Unity调试：VS打断点=》附加到Unity调试程序=》Unity点击运行F11 F10获取和隐藏代码：测试： windowBase：...
Unity UI 框架
01-08
自己写的一套UI框架，基于 MVC， UGUI、NGUI 都可使用，跟使用哪种 UI 插件无关
Unity--UI框架
qq_62947569的博客
05-19 2456
UI框架
Unity3D的UI系统（UGUI）初级入门
03-21
本课程主要介绍Unity3d的UI系统（UGUI），先对UGUI做一个总体概述，之后对每个UI控件逐一进行详细讲述，内容包括控件的作用、设置方法、使用场景及属性细节，帮助大家熟练使用UGUI设计游戏的交互界面。
Unity高性能、自动化UI框架(ZMUIFrameWork)
06-05
高性能、自动化是该框架的特点。能够让你再使用时彻底解放双手，节约%70的开发时间。该框架共有七大系统，七个章节：1.Mono分离式UI管理系统 (脱离Mono的分离式架构，彻底解决声明周期不受自己控制的问题，窗口从生成到销毁所有流程全部掌握在自己手中，可自定义任何阶段)2.堆栈系统 (成熟的堆栈管理。首页堆栈弹出、顺序控制、半路压入等,兼容各种情况，全局任意地方皆可使用)3.遮罩系统 (完善遮罩的处理。提供单遮、叠遮模式两种模式，无缝切换)4.层级系统 (负责框架中UI的层级管理，清晰透明， 解决UI叠加，特效模型穿插问题)5.高性能系统 (负责Untiy UGUI相关极致的性能优化，彻底解决UI卡顿、不流畅的问题)6.自动化系统 (提供代码查找、组件自动绑定、字段、方法、事件接口声明、UI组件事件绑定、脚本生成等一条龙服务)7.高效率系统 (提供预制体管理系统，预制体模板拖拽、Editor编译器、Editor针对框架特殊优化、提升开发效率)
Unity项目UI管理简易框架
Tandre的成长之路
11-09 3762
一个易于实现且扩展性比较强的，包含了UI的显示隐藏、数据加载、事件监听事件系统等功能UI界面管理的简易框架的实现思路。
Unity3D通用UI框架设计，美术，策划，程序互不干扰，易于扩展，解决多个UI同时打开的层级问题，以及使用快捷键关闭最近打开的UI
m0_72922928的博客
11-14 1077
本文介绍了一种通用的UI框架的设计方式，让策划，美术，程序的工作互不干扰，且资源发生改变时无需修改代码，只需替换对应的资源，易于扩展，并且可以使用快捷键快速关闭最近打开的UI
unity进阶学习笔记：UI框架
Raine_Yang的博客
05-12 1084
在UI系统中，我们放弃之前消息系统中使用的广播框架，因为该方案需要专门为每一个UI组件编写发送和接受消息的方法，过于复杂。我们希望通过UIController和UI Manager可以让每一个UI组件访问到任何一个另外的UI组件。在下面程序中我们获取到该游戏物体的按钮组件control，并在control上挂载对action的监听。UI框架主要分3层：UIManager用于管理所有UI组件，UIController用于管理某一个UI面板，如角色信息面板，商店面板等。一般来说，一个游戏内具有大量的UI组件。
Unity3D基础UI框架，Unity MVVM
热门推荐
Soso
03-05 2万+
unity ui框架 游戏框架

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

某某某某某某某某某某某某某某某

谢谢您

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值