精华内容
下载资源
问答
  • 一套完整的UnityUI框架、可用于实际开发。经过本人开发的考验
  • Unity UI 框架

    2018-06-15 09:39:23
    Unity 实用的UI框架结构,开源的代码
  • Unity UI框架

    2018-07-20 09:43:46
    一个还不错的UI框架
  • 利用栈的特性,搭建的UI框架,,涉及到UIManage管理,还有BasePanel所要继承的基类等等,,可以直接拿来使用哦,,好用不贵,,方便扩展
  • unity ui框架

    2018-12-12 11:20:21
    unityui框架视频教程,适合已经学会unity但是还没自己ui框架的同学学习.
  • 一个高效率,低耦合的Ui框架 ,易于和lua结合 ,开发卡牌 棋牌类游戏
  • Unity UI框架的搭建

    2021-01-06 12:22:33
    在我刚使用Unity开发UI界面时,根本没想过用什么UI框架,都是想到要什么界面就通过UGUI拖动什么界面。如果需要实现交互功能,就会绑定对应的监听函数,这样的做法固然是非常的简单直接,但是也会留下一定的弊端。 当...

    为什么要使用UI框架呢?

    在我刚使用Unity开发UI界面时,根本没想过用什么UI框架,都是想到要什么界面就通过UGUI拖动什么界面。如果需要实现交互功能,就会绑定对应的监听函数,这样的做法固然是非常的简单直接,但是也会留下一定的弊端。

    当你的项目不在简单时,UI界面和控件越来越多时,你有时候会找不到哪个对象和哪个对象关联,要是团队合作的话,别人找你的UI接口更是找半天,耦合度非常之高,经常会牵一发而动全身,代码混乱,所以这个时候有一个好的UI框架,会更便于我们整合和使用UI。

    设计UI框架的要点

    1.设计一个UI的基类BaseUI,里面有UI的一些基本属性,显示方式等,所有UI的脚本都继承它
    2.设计一个管理UI的框架UIManager,为UI的显示、销毁、切换等提供方法接口,并把该脚本设为单例模式,每个UI间互不干扰
    3.UI间通信、UI和游戏层的通信通过一个消息分发的脚本去实现,即利用观察者模式,都通过MessageCenter来联系

    部分伪代码:

    建立一个定义UI类型的脚本

         //窗体ID
         public enum E_UiId
        {
           MainUI,//主界面
           PlayUI,//游戏界面
        }
        //窗体的层级
        public enum E_UIRootType
        {
            KeepAbove,//  保持在最前方的窗体
            Normal//  普通窗体
        }
        //窗体的显示方式
        public enum E_ShowUIMode
        {
            //  窗体显示出来的时候,不会去隐藏任何窗体
            DoNothing,
            //  窗体显示出来的时候,会隐藏掉所有的普通窗体,但是不会隐藏保持在最前方的窗体
            HideOther,
            //  窗体显示出来的时候,会隐藏所有的窗体,不管是普通的还是保持在最前方的
            HideAll
        }
        //  消息类型
        public enum E_MessageType
        {
            ImageChange,//  图片更换
            textChange,//  文字更换
            RewardChange,// 奖励更换
            WeaponChange,// 武器更换
            BulletTips// 弹药提示
        }
        public class GameDefine
        {
            //  导入UI预制体文件(名字,路径)
            public static Dictionary<E_UiId, string> dicPath = new Dictionary<E_UiId, string>()
            {
                { E_UiId.MainUI,"UIPrefab/"+"MainPanel"},
                { E_UiId.PlayUI,"UIPrefab/"+"PlayPanel"}
            };
            //  自动挂载UI脚本
            public static Type GetUIScriptType(E_UiId uiId)
            {
                Type scriptType = null;
                switch (uiId)
                {
                    case E_UiId.NullUI:
                        break;
                    case E_UiId.MainUI:
                        scriptType = typeof(MainUI);
                        break;
                    case E_UiId.PlayUI:
                        scriptType = typeof(PlayUI);
                        break;
                    default:
                        break;
                }
                return scriptType;
            }
        }
    

    定义UI基类

    //窗体类型
        public class UIType
        {
            //显示方式
            public E_ShowUIMode showMode = E_ShowUIMode.HideOther;
            //父节点的类型
            public E_UIRootType uiRootType = E_UIRootType.Normal;
        }
         public class BaseUI : MonoBehaviour
        {
            //窗体类型
            public UIType uiType;
    
            //缓存窗体的RectTransform组件
            protected RectTransform thisTrans;
            //当前窗体的ID
            protected E_UiId uiId = E_UiId.NullUI;
            //上一个窗体的ID
            protected E_UiId beforeUiId = E_UiId.NullUI;
    
            //获取当前窗体的ID
            public E_UiId GetUiId
            {
                get
                {
                    return uiId;
                }
                //为什么没有set?
                //因为每个窗体的ID都是固定的,不能被外界随意修改,外界只能获取它的值
                //只有在子类才能对该窗体的ID进行赋值或修改
                //set
                //{
                //    uiId = value;
                //}
            }
            protected virtual void Awake()
            {
                if (uiType == null)
                {
                    uiType = new UIType();
                }
                thisTrans = this.GetComponent<RectTransform>();
                InitUiOnAwake();
                InitDataOnAwake();
            }
            //用于判断窗体显示出来的时候,是否需要去隐藏其他窗体
            public bool IsHideOtherUI()
            {
                if (this.uiType.showMode == E_ShowUIMode.DoNothing)
                {
                    return false;//不需要隐藏其他窗体
                }
                else
                {
    
                    //需要去处理隐藏其他窗体的逻辑
                    return true;// E_ShowUIMode.HideOther与  E_ShowUIMode.HideAll
                }
            }
            //初始化界面元素
            protected virtual void InitUiOnAwake()
            {
            }
            //初始化数据
            protected virtual void InitDataOnAwake()
            {
            }
            protected virtual void Start()
            {
                InitOnStart();
            }
            //初始化相关逻辑
            protected virtual void InitOnStart()
            {
    
            }
            //窗体的显示
            public virtual void ShowUI()
            {
                this.gameObject.SetActive(true);
            }
            //窗体额隐藏
            public virtual void HideUI(Del_AfterHideUI del = null)
            {
                this.gameObject.SetActive(false);
                if (del != null)
                {
                    del();
                }
            }
    

    定义UIManager框架

    //这里我把单例模式写成了一个基类UnitySingleton并继承
    public class UIManager : UnitySingleton<UIManager>
    {
    //缓存所有打开过的窗体
            private Dictionary<E_UiId, BaseUI> dicAllUI;
            //缓存正在显示的窗体
            private Dictionary<E_UiId, BaseUI> dicShowUI;
    
            //缓存最近显示出来的窗体
            private BaseUI currentUI = null;
            //缓存上一个窗体
           // private BaseUI beforeUI = null;
            private E_UiId beforeUiId = E_UiId.NullUI;
    
            //缓存画布
            private Transform canvas;
            //缓存保持在最前方的窗体的父节点
            private Transform keepAboveUIRoot;
            //缓存普通窗体的父节点
            private Transform normalUIRoot;
    
            private void Awake()
            {
                //Test.Instance.Show();
                dicAllUI = new Dictionary<E_UiId, BaseUI>();
                dicShowUI = new Dictionary<E_UiId, BaseUI>();
                InitUIManager();
            }
            //初始化UI管理类
            private void InitUIManager()
            {
                canvas = this.transform.parent;
                //设置画布在场景切换的时候不被销毁,因为整个游戏共用唯一的一个画布
                DontDestroyOnLoad(canvas);
                if (keepAboveUIRoot==null)
                {
                    keepAboveUIRoot = GameTool.FindTheChild(canvas.gameObject, "KeepAboveUIRoot");
                }
                if (normalUIRoot==null)
                {
                    normalUIRoot= GameTool.FindTheChild(canvas.gameObject, "NormalUIRoot");
                }
            }
            //供外界调用,销毁窗体
            public void DestroyUI(E_UiId uiId)
            {
                if (dicAllUI.ContainsKey(uiId))
                {
                    //存在该窗体,去销毁
                    Destroy( dicAllUI[uiId].gameObject);
                    dicAllUI.Remove(uiId);
                }
            }
            //供外界调用的,显示窗体的方法
            public BaseUI ShowUI(E_UiId uiId,bool isSaveBeforeUiId=true)
            {
                if (uiId == E_UiId.NullUI)
                {
                    uiId = E_UiId.MainUI;
                }
                BaseUI baseUI=JudgeShowUI(uiId);
                if (baseUI!=null)
                {
                    baseUI.ShowUI();
                }
                if (isSaveBeforeUiId)
                {
                    baseUI.BeforeUiId = beforeUiId;
                }
                return baseUI;
            }
            //供外界调用,反向切换窗体的方法
            public void ReturnBeforeUI(E_UiId uiId)
            {
                ShowUI(uiId,false);
            }
            //供外界调用的,隐藏单个窗体的方法
            public void HideSingleUI(E_UiId uiId, Del_AfterHideUI del=null)
            {
                if (!dicShowUI.ContainsKey(uiId))
                {
                    return; 
                }
                dicShowUI[uiId].HideUI(del);
                dicShowUI.Remove(uiId);
            }
            private BaseUI JudgeShowUI(E_UiId uiId)
            {
                //判断将要显示的窗体是否已经正在显示了
                if (dicShowUI.ContainsKey(uiId))
                {
                    //如果已经正在显示了,就不需要处理其他逻辑了
                    return null;
                }
                //判断窗体是否有加载过
                BaseUI baseUI = GetBaseUI(uiId);
                if (baseUI == null)
                {
                    //说明这个窗体没显示过(没有加载过),要去动态加载
                    string path = GameDefine.dicPath[uiId];
                    GameObject theUI = Resources.Load<GameObject>(path);
                    if (theUI != null)
                    {
                        //把该窗体生成出来
                        GameObject willShowUI = Instantiate(theUI);
                        //窗体生成出来后,要确保有挂对应的UI脚本
                        baseUI = willShowUI.GetComponent<BaseUI>();
                        if (baseUI == null)
                        {
                            //说明生成出来的这个窗体上面没有挂载对应的UI脚本
                            //那么就需要给这个窗体自动添加对应的脚本
                            Type type = GameDefine.GetUIScriptType(uiId);
                            baseUI = willShowUI.AddComponent(type) as BaseUI;
                        }
                        //判断这个窗体是属于哪个父节点的
                        Transform uiRoot = GetTheUIRoot(baseUI);
                        GameTool.AddChildToParent(uiRoot, willShowUI.transform);
                        willShowUI.GetComponent<RectTransform>().sizeDelta = Vector2.zero;
                        //这个窗体是第一次加载显示出来的,那么就需要缓存起来
                        dicAllUI.Add(uiId, baseUI);
                    }
                    else
                    {
                        Debug.LogError("指定路径下面找不到对应的预制体");
                    }
                }
                UpdateDicShowUIAndHideUI(baseUI);
                return baseUI;
            }
            //更新缓存正在显示的窗体的字典并且隐藏对应的窗体
            private void UpdateDicShowUIAndHideUI(BaseUI baseUI)
            {
                //判断是否需要隐藏其他窗体
                if (baseUI.IsHideOtherUI())
                {
                    //如果返回值为true, E_ShowUIMode.HideOther与 E_ShowUIMode.HideAll
                    //需要隐藏其他窗体
                    if (dicShowUI.Count>0)
                    {
                        //有窗体正在显示,就要隐藏对应的窗体
                        if (baseUI.uiType.showMode == E_ShowUIMode.HideOther)
                        {
                            HideAllUI(false, baseUI);
                        }
                        else
                        {
                            HideAllUI(true, baseUI);
                        }
                      
                    }
                }
                //更新缓存正在显示的窗体的字典
                dicShowUI.Add(baseUI.GetUiId, baseUI);
            }
            public void HideAllUI(bool isHideAboveUI,BaseUI baseUI)
            {               
                if (isHideAboveUI)
                {
                    //1、隐藏所有的窗体,不管是普通窗体还是保持在最前方的窗体,都需要全部隐藏
                    foreach (KeyValuePair<E_UiId,BaseUI> uiItem in dicShowUI)
                    {
                        uiItem.Value.HideUI(); 
                    }
                    dicShowUI.Clear();
                }
                else
                {
                    //2、隐藏所有的窗体,但是不包含保持在最前方的窗体
                    //缓存所有被隐藏的窗体
                    List<E_UiId> list = new List<E_UiId>();
                    foreach (KeyValuePair<E_UiId, BaseUI> uiItem in dicShowUI)
                    {
                        //如果不是保持在最前方的窗体
                        if (uiItem.Value.uiType.uiRootType != E_UIRootType.KeepAbove)
                        {
                            uiItem.Value.HideUI();
                            //存储上一个窗体的ID
                            beforeUiId = uiItem.Key;
                           // baseUI.BeforeUiId= uiItem.Key;
                            list.Add(uiItem.Key);
                        }
                    }
                    for (int i = 0; i < list.Count; i++)
                    {
                        dicShowUI.Remove(list[i]);
                    }
                }
            }
            //判断窗体的父物体
            private Transform GetTheUIRoot(BaseUI baseUI)
            {
                if (baseUI.uiType.uiRootType == E_UIRootType.KeepAbove)
                {
                    return keepAboveUIRoot;
                }
                else
                {
                    return normalUIRoot;
                }
            }
            private BaseUI GetBaseUI(E_UiId UiId)
            {
                if (dicAllUI.ContainsKey(UiId))
                {
                    return dicAllUI[UiId];
                }
                else
                {
                    return null;
                }
            }
    }
    

    定义通讯中心MessageCenter

    public class MessageCenter : MonoBehaviour
    {
        public delegate void CallBack(object obj);
        //一个用来存放所有监听的字典<消息类型,监听到消息后所要处理的逻辑>
        public static Dictionary<E_MessageType, CallBack> dicMessageType = new Dictionary<E_MessageType, CallBack>();
        //添加监听
        public static void AddMessageListener(E_MessageType messageType, CallBack callBack)
        {
            if (!dicMessageType.ContainsKey(messageType))
            {
                dicMessageType.Add(messageType, null);
            }
            dicMessageType[messageType] += callBack;
        }
        //取消监听
        public static void RemoveListener(E_MessageType messageType, CallBack callBack)
        {
            if (dicMessageType.ContainsKey(messageType))
            {
                dicMessageType[messageType] -= callBack;
            }
        }
        //取消所有的监听
        public static void RemoveAllMessage()
        {
            dicMessageType.Clear();
        }
        //广播消息
        public static void SendMessage(E_MessageType messageType, object obj = null)
        {
            CallBack callBack;
            if (dicMessageType.TryGetValue(messageType, out callBack))
            {
                if (callBack != null)
                {
                    callBack(obj);
                }
            }
        }
    }
    

    以上就是一个基本的UI框架了,接下来只要自己去创建对应的UI界面并处理好继承问题和初始化一些基础的UI属性即可,其他的一些UI框架其实也万变不离其中,主要目的还是解耦,便于处理,如果有好用的框架欢迎私信或者底下留言我,大家一起分享!

    链接: 看到一位已经转行做厨师的兄弟有感而发

    展开全文
  • 用于开发Unity UGUI的底层框架
  • FairyGUI是一个跨平台的UI编辑器和UI框架。 与传统的Unity UI引擎(例如NGUI和UGUI)相比,FairyGUI使用一种更贴近设计人员的思维方式来重新定义UI的生产过程,从而大大减少了程序员需要花费的时间来制作UI。 在...
  • 这一套用于unity中管理UI框架,各个UI的生成,销毁,切换,都是通过这个Manager单例来实现。OnEnter:面板进入时调用 ,OnPause:面板停止时调用(鼠标与面板的交互停止),OnResume:面板恢复使用时调用(鼠标与...
  • 简易UnityUI框架

    万次阅读 热门讨论 2018-05-27 21:58:03
    最近自己写了一套简单的UI框架,基本思想是基于mvc的,但是由于是给比较小型的项目设计的框架,整体解耦并不十分彻底,这样降低了调试难度,整体复杂度也相对较低,算是按自己的理解做了取舍。 1.接口部分 ...

    UGUI系列博文,可通过导航帖查看

    前言

    最近自己写了一套简单的UI框架,基本思想是基于mvc的,但是由于是给比较小型的项目设计的框架,整体解耦并不十分彻底,这样降低了调试难度,整体复杂度也相对较低,算是按自己的理解做了取舍。

    1.接口部分

    1)底层系统类,全局唯一

    AUIRoot:是根节点抽象类,负责所有系统的初始化
    IUIManager:是UI组件的管理类,提供UI界面显示,返回等统一接口
    IUIDataHandlerManager :是数据处理器管理类,提供对数据处理器的缓存,添加,移除等接口
    IUILayerManager :是UI层级管理类,根据UI预设的层级划分,系统自动设置UI的父物体,利用unity的自然层级管理UI的显示层级
    IUIEffectManager :是UI动效管理类,架构内的动效类与UI系统完全解耦,此类负责管理UI动效的播放,提供UI物体Active状态及对象初始化状态的回调接口
    AUIPathManager :UI路径管理接口,类似与配置文件,需要手动在类的字典UIPathDic里配置路径
    ####2)其他接口
    AUIBase :UI基类,定义了处理UI的状态切换及回调事件等接口
    AUIEffect :UI动效基类,定义了UI动效切换的接口及回调事件
    IData :数据基类,用标记类为数据类
    DataHandler :数据处理器接口,定义数据初始化,数据更新接口,此类进行数据的操作

    2.结构构思

    1)枚举

    UI状态枚举
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mG9OgytF-1577879706134)(https://i.loli.net/2018/05/27/5b0aa498e8a67.jpg)]
    NOTINIT:是一个UI的默认状态,也就是UI对象还未生成出来的状态
    INIT:是UI对象生成出来时,第一个执行的状态,初始化完成会自动执行SHOW状态,类似unity的Awake只执行一次
    SHOW:是当UI显示时执行的函数
    HIDE:UI隐藏时执行的函数

    UI层级枚举

    2)基本构思

    ------1)UIRoot会自动初始化所有系统,其中UILayerManager会自动生成层级父物体
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NoYUUBgp-1577879706136)(https://i.loli.net/2018/05/27/5b0aa70515420.jpg)]
    用这种方式来给UI分层

    ------2)通过UIManager来控制UI的状态切换,在调用UIManager的show方法时,会自动调用UIlayerManger来设置UI的层级,并生成对象到对应的父物体下

    ------3)通过事件绑定的方式,若是对象上有动效脚本就会自动执行,没有就正常执行逻辑,动效部分代码是完全和UI逻辑分离的,就算删除动效部分的代码,完全不影响UI系统的执行

    ------4)所有的UI类要继承UIBase类,所有的UI类只处理UI的显示,每一个UI类都有对应的数据类和数据处理类

    3.使用说明

    1)自定义枚举

    需要自定义UI的ID枚举,如

    实际在框架内部,我是使用的string来存放ID,所以这里有两种方式:
    ------1.像图中这样,定义枚举来定义ID,在使用UIManager的show方法时,传进去即可
    ------2.定义一个类,在类中定义ID的静态只读字符串

    2)自定义管理类

    -----(1)继承UIDataHandlerManager类,实现自定义数据处理器管理类,需要实现RegisterHandler方法,如:

    需要在RegisterHandler方法内如图中的方式,初始化自定义的数据处理器类,并缓存到字典内
    -----(2)继承AUIPathManager类,实现自定义路径管理类,需要实现InitPathDic方法,如:

    图中value的字符串是路径,测试代码的预制体直接放到了Resources下,所以这里直接赋值的预制体名称
    有两种应用方式:
    -----------1.EUiId枚举直接定义成预制体名称,这样就不需要自己配置字符串了,但是这样预制体在Resources下必须都放到一个文件夹下,不能分类存放
    -----------2.如图中这样,分别配置每个预制体的路径,可以在Resources下分类存放
    -----(3)继承UIRoot类,实现自定义UI节点类,需要继承两个方法
    -----------1.继承Start方法,如
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FQrPip1u-1577879706144)(https://i.loli.net/2018/05/27/5b0ab6162e29b.jpg)]
    实现启动主界面的业务逻辑
    ------------2.继承InitUISystem方法,初始化需要自定义的系统,如

    3)自定义UI显示层脚本

    ------1.需要根据UI的自身的需要选择继承基类,如主界面之类的这种全屏界面,一般是继承BasicUI类,像浮框这种界面,一般继承OverlayUI类,还有需要显示在这之上的UI就可以继承TopUI类
    这些自定义类需要实现类的Init方法,并在Init方法中初始化调用InitUI方法来初始化UI数据,如:
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eUaqPupQ-1577879706146)(https://i.loli.net/2018/05/27/5b0ab434d6c9c.jpg)]
    需要赋值这个界面的ID还有自定义数据处理类的ID

    ------2.每个类需要定义它自己的UI数据类和数据处理器
    每个数据处理器的NAME需要唯一,需要自己在创建类时定义,如
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gBNtO5Qa-1577879706147)(https://i.loli.net/2018/05/27/5b0ab4ce55460.jpg)]
    数据的初始化是在InitData方法中,如

    例子中就这样简单写,实际应该是从本地或者云端获取数据

    4)自定义UI动效类

    继承AUIEffect类实现自定义UI动效类,这个类需要继承两个方法
    ------1.Enter方法,在UI显示的时候执行,所以在这个方法里定义UI显示时的动效
    ------2.Exit方法,在UI隐藏的时候执行,所以在这个方法里定义UI隐藏时的动效
    使用时需要把预制体需要的UI动效类挂载到UI预制体上即可,或者也可以自己写一个类进行管理,动态挂载

    以上便是本人自己花了几天时间,写的UI框架,比较简单,希望路过的大牛能花点点时间,给与指证。
    GitHub地址:https://github.com/BlueMonk1107/BlueUIFrame

    我会在我的公众号上推送新的博文,也可以帮大家解答问题
    微信公众号 Andy and Unity 搜索名称或扫描二维码
    在这里插入图片描述
    希望我们能共同成长,共同进步

    展开全文
  • Unity3D UI 框架

    2018-11-08 09:27:19
    一套完整的UI框架,基于MVVM的原理,方便快速开发,简单快捷
  • 这是一个简单的Unity UI 框架,功能持续完善中 支持功能: 1.支持Resources/Assetbundle同步加载UI,先将资源放置在Resources目录或Assetbundles目录下(需运行Build Assetbundle来创建Assetbundle资源,默认放置于...
  • 简单的Unity UI 框架

    2018-10-31 22:23:15
    简单的Unity UGUI框架视频教程 适合新手学习 绝对精品
  • https://wenku.baidu.com/view/b6afb8dffe4733687f21aa45.html?from=search https://blog.csdn.net/qq_35361471/article/details/79957612
    展开全文
  • 基于Unity3D简单UI框架

    千次下载 热门讨论 2015-07-14 22:46:58
    基于Unity3D和NGUI实现的简单的UI框架,实现内容如下 1.加载,显示,隐藏,关闭页面,根据标示获得相应界面实例 2.提供界面显示隐藏动画接口 3.单独界面层级,Collider,背景管理 4.根据存储的导航信息完成界面导航...
  • unity 2017.2.2 ugui UI框架 结合了网上的一些demo 重新写了一下。 主要就是层级管理,以及界面的进出栈管理~~~想用来做新项目的ui框架的,不过我也是新手上路~~ui框架之后估计还是会有一波修改的,毕竟是正式项目用...
  • unity UI框架

    2018-05-26 18:01:42
    UI管理者类:包含全部子控件信息,给外加提供接口,以访问全部子控件UIBase类:通过UI管理者给子控件添加事件监听UIBehavior:给自身添加事件监听源码:UIManger:using System.Collections.Generic; using ...

    UI管理者类:包含全部子控件信息,给外加提供接口,以访问全部子控件
    UIBase类:通过UI管理者给子控件添加事件监听
    UIBehavior:给自身添加事件监听

    源码:

    UIManger:
    using System.Collections.Generic;
    using UnityEngine;
    
    public class UIManager : MonoBehaviour {
    
        private GameObject mainCanvas;
    
        public GameObject MainCanvas
        {
            get
            {
                if (mainCanvas == null)
                    mainCanvas = GameObject.FindGameObjectWithTag("MainCanvas");
    
                return mainCanvas;
            }
        }
    
    
        /// <summary>
        ///  获取panel 身上的UIBase
        /// </summary>
        /// <param name="panelName"></param>
        /// <returns></returns>
        public UIBase GetPanelCtrl(string  panelName)
        {
    
            GameObject  tmpObj=  GetGameObject(panelName, panelName);
    
             return tmpObj.GetComponent<UIBase>();
        }
    
        /// <summary>
        ///   string  哪个panel Dictionary<string, GameObject>  panel上的每个子控件
        /// </summary>
        Dictionary<string, Dictionary<string, GameObject>> allChilds;
    
    
        public static UIManager Instance;
        private void Awake()
        {
            Instance = this;
    
            allChilds = new Dictionary<string, Dictionary<string, GameObject>>();
    
    
        }
    
    
        /// <summary>
        ///  将panel下面的子控件 object  存入账本
        /// </summary>
        /// <param name="panelName"></param>
        /// <param name="wedgetName"> 同一个panel 下面子控件的名字不能一样</param>
        /// <param name="obj"></param>
        public void RegistGameObject(string panelName,string wedgetName,GameObject obj)
        {
            if (!allChilds.ContainsKey(panelName))
            {
    
               // allChilds[panelName] = new Dictionary<string, GameObject>();
    
                allChilds.Add(panelName,new Dictionary<string, GameObject>());
         
            }
    
            if (!allChilds[panelName].ContainsKey(wedgetName))
            {
                allChilds[panelName].Add(wedgetName, obj);
    
            }
        }
    
        /// <summary>
        //  提供接口 供外界 获取 wedget Object
        /// </summary>
        /// <param name="panelName"></param>
        /// <param name="wedgetName"></param>
        /// <returns></returns>
        public GameObject GetGameObject(string  panelName ,string wedgetName)
        {
            // 是否包含panel
            if (allChilds.ContainsKey(panelName))
            {
                return allChilds[panelName][wedgetName];
            }
            return null;
        }
    
    
        /// <summary>
        ///  将整个panel 从账本 中 删除
        ///  销毁整个panel
        /// </summary>
        /// <param name="panelName"></param>
        public void UnRegistPanel(string  panelName )
        {
    
            if (allChilds.ContainsKey(panelName))
            {
    
                allChilds[panelName].Clear();
    
                allChilds[panelName] = null;
            }
        }
    }
    

    UIBase:

    using UnityEngine;
    
    using UnityEngine.Events;
    
    using UnityEngine.EventSystems;
    
    
    public class UIBase : MonoBehaviour {
    
        private void Awake()
        {
            //  获取panel下面 所有的子控件
           Transform[] allChild=   transform.GetComponentsInChildren<Transform>();
    
            for (int i = 0; i < allChild.Length; i++)
            {
    
                if (allChild[i].name.EndsWith("_N"))
                {
                    allChild[i].gameObject.AddComponent<UIBehaour>();
                }
            }
    
        }
    
    
        public void ShowOrHide(bool  isShow)
        {
    
            transform.GetChild(0).gameObject.SetActive(isShow);
          //  gameObject.SetActive(isShow);
    
    
        }
    
        public GameObject GetGameObject(string widgetName)
        {
            //   从UIManager  获取想要的物体
            GameObject tmpObj = UIManager.Instance.GetGameObject(transform.name, widgetName);
    
            return tmpObj;
        }
    
        public UIBehaour GetBehaour(string widgetName )
        {
    
            GameObject tmpObj = UIManager.Instance.GetGameObject(transform.name, widgetName);
    
            if (tmpObj != null)
            {
                UIBehaour tmpBehaour = tmpObj.GetComponent<UIBehaour>();
    
                return tmpBehaour;
            }
            return null;
        }
    
        /// <summary>
        ///  对外提供接口 对button 事件绑定
        /// </summary>
        public void AddButtonListen(string widgetName ,UnityAction  func)
        {
    
            UIBehaour  tmpBehaour= GetBehaour(widgetName);
    
            if (tmpBehaour != null)
            {
                tmpBehaour.AddButtonListen(func);
            }
    
        }
    
    
        /// <summary>
        ///  提供外界一个 注册 slider 事件接口
        /// </summary>
        /// <param name="widgetName"></param>
        /// <param name="func"></param>
        public void AddSliderListen(string widgetName ,UnityAction<float> func )
        {
            UIBehaour tmpBehaour = GetBehaour(widgetName);
    
            if (tmpBehaour != null)
            {
                tmpBehaour.AddSliderListen(func);
            }
    
        }
    
    
        public  void  AddInputEndEditor(string widgetName, UnityAction<string> func)
        {
            UIBehaour tmpBehaour = GetBehaour(widgetName);
    
            if (tmpBehaour != null)
            {
                tmpBehaour.AddInputFiledEndEditor(func);
            }
        }
    
    
        public void AddDragEvent(string widgetName, UnityAction<BaseEventData> func)
        {
            UIBehaour tmpBehaour = GetBehaour(widgetName);
    
            if (tmpBehaour != null)
            {
                tmpBehaour.AddDragLisenter(func);
            }
        }
    }
    

    UIBhavior

    using UnityEngine.Events;
    
    using UnityEngine.EventSystems;
    
    
    public class UIBehaour : MonoBehaviour {
    
    
        private void Awake()
        {
            // 找到自己所在的panel的名字
            UIBase tmpBase=  transform.GetComponentInParent<UIBase>();
            //在管理者注册自身信息*
            UIManager.Instance.RegistGameObject(tmpBase.name, transform.name,gameObject);
        }
    
    
    
        /// <summary>
        ///  获取button 事件
        /// </summary>
        /// <param name="func"></param>
        public void AddButtonListen(UnityAction  func)
        {
            Button tmpBtn = transform.GetComponent<Button>();
    
            if (tmpBtn != null)
            {
                tmpBtn.onClick.AddListener(func);
            }
        }
    
    
        public void AddSliderListen(UnityAction<float>  func)
        {
            Slider tmpBtn = transform.GetComponent<Slider>();
    
            if (tmpBtn != null)
            {
                tmpBtn.onValueChanged.AddListener(func);
            }
        }
    
        public void AddInputFiledEndEditor(UnityAction<string> func)
        {
    
            InputField tmpBtn = transform.GetComponent<InputField>();
    
            if (tmpBtn != null)
    
            {
    
                // 结束 编辑
                tmpBtn.onEndEdit.AddListener(func);
    
                //  每次值改变  
                //tmpBtn.onValueChanged.AddListener();
            }
    
        }
    
        public void AddInputFiledValueChange(UnityAction<string> func)
        {
    
            InputField tmpBtn = transform.GetComponent<InputField>();
    
            if (tmpBtn != null)
    
            {
    
                // 结束 编辑
              //  tmpBtn.onEndEdit.AddListener(func);
    
                //  每次值改变  
                tmpBtn.onValueChanged.AddListener(func);
            }
    
        }
    
    
    
        /// <summary>
        ///  动态 添加  接口时间 回调
        /// </summary>
        /// <param name="action"></param>
        public void AddButtonDownLisenter(UnityAction<BaseEventData> action)
        {
    
            EventTrigger trigger = gameObject.GetComponent<EventTrigger>();
    
            if (trigger == null)
                trigger = gameObject.AddComponent<EventTrigger>();
    
            EventTrigger.Entry entry = new EventTrigger.Entry();
    
    
            //绑定哪个接口
            entry.eventID = EventTriggerType.PointerClick;
    
            entry.callback = new EventTrigger.TriggerEvent();
    
            entry.callback.AddListener(action);
    
    
            trigger.triggers.Add(entry);
    
        }
    
    
    
        public void AddDragLisenter(UnityAction<BaseEventData> action)
        {
    
            EventTrigger trigger = gameObject.GetComponent<EventTrigger>();
    
            if (trigger == null)
                trigger = gameObject.AddComponent<EventTrigger>();
    
            EventTrigger.Entry entry = new EventTrigger.Entry();
    
    
            //绑定哪个接口
            entry.eventID = EventTriggerType.Drag;
    
            entry.callback = new EventTrigger.TriggerEvent();
    
            entry.callback.AddListener(action);
    
    
            trigger.triggers.Add(entry);
    
        }
    
    }
    
    收工~  一个常见的Unity UI框架
    展开全文
  • Unity UI框架开发(1)--框架介绍

    千次阅读 2016-10-16 16:45:47
    记录下自己经常使用的这个UI框架。首先说下这个UI框架整体吧,该框架主要实现了UI的的显示、隐藏、按钮点击、UI数值更新,这也是大多数游戏UI的功能。 该框架主要分三个部分来理解,分别是窗口(window)、视图...
  • UnityUI框架简单版

    2020-11-22 15:30:31
    当一个程序的界面多达十几、几十个的时候,若是没有一个...UI框架简单版 核心思想 把程序的UI界面做成预制体,等到需要用到的时候加载 把所有的UI界面的名字、路径保存成配置文件 编写基类,基类包括所有界面的通
  • 最近的工作内容中有比较多UI的内容,学到了比较多有意思的东西,写几篇文章来分析一下。 第一篇文章主要来进行需求分析和大致的实现思路。 1:数据和UI的分离。采用MVC架构,模块耦合度低,重用性高。 2:UI界面的...
  • Unity Ui框架,使用CatLib作为核心,只适配UGui
  • Unity UI框架开发(3)--实现UIBaseView

    千次阅读 2016-10-30 17:57:04
    下面继续实现第二个基类UIBaseView。abstract public class UIBaseView { public GameObject view; private UIBaseWindow _window; public UIBaseView(UIBaseWindow parent,string path) { _window = pare
  • unity-UI框架包.rar

    2019-12-27 16:41:01
    unity UI框架Demo 含有:教学资源和UML框架图和一个简单示例,主要提供为大家提供一个思路 如果有疑惑欢迎在下面评论或来找我一起探讨
  • 这里我用一个简单案例 2个界面 ...2个UI脚本 CoinPanel.cs BuyPanel.cs 一个记录金币脚本 问题一 UI对象的获取 例如脚本中写了一些变量,如何赋值。 方式1 代码获取 start方法中Fi...

空空如也

空空如也

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

unityui框架