devbox
运维做开发
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity3d游戏开发框架-UI管理类 UIManager之美_unity3d中如何管理ui ,比如我需要按下按钮以后需要隐藏上一个ui,显示当前ui

作者：运维做开发 | 2024-06-27 06:36:37

赞

踩

unity3d中如何管理ui ,比如我需要按下按钮以后需要隐藏上一个ui,显示当前ui

新建一个文件夹：UIMgr
新建2个C#脚本：BaseUI.cs UIMgr.cs
里面的UIMgr.cs继承了EventNode。EventNode在前面有讲，这里重新给出一下。
IResLoadListener.cs接口，资源加载回调

  1. using UnityEngine;
  2. using System.Collections;
  3.  
  4. public class BaseUI : MonoBehaviour 
  5. {
  6.     
  7.     /// <summary>
  8.     /// 当前界面名称
  9.     /// </summary>
  10.     [HideInInspector]
  11.     public string UIName;
  12.  
  13.     private Transform mTransform;
  14.     public Transform CacheTransform
  15.     {
  16.         get
  17.         {
  18.             if (mTransform == null) mTransform = this.transform;
  19.             return mTransform;
  20.         }
  21.     }
  22.  
  23.     private GameObject mGo;
  24.     public GameObject CacheGameObject
  25.     {
  26.         get
  27.         {
  28.             if (mGo == null) mGo = this.gameObject;
  29.             return mGo;
  30.         }
  31.     }
  32.  
  33.     /// <summary>
  34.     /// 显示当前UI
  35.     /// </summary>
  36.     /// <param name="param">附加参数</param>
  37.     public void Show(object param = null)
  38.     {
  39.         CacheGameObject.SetActive(true);
  40.     }
  41.  
  42.     /// <summary>
  43.     /// 隐藏当前界面
  44.     /// </summary>
  45.     public void Hide()
  46.     {
  47.         CacheGameObject.SetActive(false);
  48.     }
  49.  
  50.    
  51.  
  52. 	/// <summary>
  53. 	/// 绑定脚本并且激活游戏物体会调用的方法
  54. 	/// </summary>
  55. 	void Awake() 
  56. 	{
  57.         OnAwake();
  58. 	}
  59.  
  60.     /// <summary>
  61.     /// 初始化UI主要用于寻找组件等
  62.     /// </summary>
  63.     public void UIInit()
  64.     {
  65.         OnInit();
  66.     }
  67.  
  68.     /// <summary>
  69.     /// 显示当前界面
  70.     /// </summary>
  71.     /// <param name="param">附加参数</param>
  72.     protected virtual void OnShow(object param){ }
  73.  
  74.     /// <summary>
  75.     /// 隐藏当前界面
  76.     /// </summary>
  77.     protected virtual void OnHide() { }
  78.  
  79.     /// <summary>
  80.     /// 初始化当前界面
  81.     /// </summary>
  82.     protected virtual void OnInit() { }
  83.  
  84.     protected virtual void OnAwake() { }
  85.  
  86.     /// <summary>
  87.     /// 删除当前UI 
  88.     /// </summary>
  89.     protected virtual void OnDestroy() { }
  90. }
  1. using UnityEngine;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4.  
  5. public class EventNode : MonoBehaviour
  6. {
  7.     /// <summary>
  8.     /// 节点优先级
  9.     /// </summary>
  10.     public int EventNodePriority { set; get; }
  11.  
  12.     /// <summary>
  13.     /// 所有消息集合
  14.     /// </summary>
  15.     private Dictionary<int, List<IEventListener>> mListeners = new Dictionary<int, List<IEventListener>>();
  16.  
  17.     /// <summary>
  18.     /// 消息节点
  19.     /// </summary>
  20.     private List<EventNode> mNodeList = new List<EventNode>();
  21.  
  22.     /// <summary>
  23.     /// 挂载一个消息节点到当前节点上
  24.     /// </summary>
  25.     /// <param name="node">消息节点</param>
  26.     /// <returns>如果当前节点里面已经包含要添加的这个节点那么返回false</returns>
  27.     public bool AttachEventNode(EventNode node)
  28.     {
  29.         if (node == null)
  30.         {
  31.             return false;
  32.         }
  33.  
  34.         if (mNodeList.Contains(node))
  35.         {
  36.             return false;
  37.         }
  38.         int pos = 0;
  39.         for (int i = 0; i < mNodeList.Count;i++ )
  40.         {
  41.             if (node.EventNodePriority > mNodeList[i].EventNodePriority)
  42.             {
  43.                 break;
  44.             }
  45.             pos++;
  46.         }
  47.  
  48.         mNodeList.Insert(pos,node);
  49.         return true;
  50.     }
  51.  
  52.     /// <summary>
  53.     /// 卸载一个消息节点
  54.     /// </summary>
  55.     /// <param name="node">消息节点</param>
  56.     /// <returns>如果节点不存在那么返回false</returns>
  57.     public bool DetachEventNode(EventNode node)
  58.     {
  59.         if (!mNodeList.Contains(node))
  60.         {
  61.             return false;
  62.         }
  63.         mNodeList.Remove(node);
  64.         return true;
  65.     }
  66.  
  67.     /// <summary>
  68.     /// 挂载一个消息监听器到当前的消息节点
  69.     /// </summary>
  70.     /// <param name="key">消息ID</param>
  71.     /// <param name="listener">消息监听器</param>
  72.     /// <returns>当前消息节点已经挂载了这个消息监听器那么返回false</returns>
  73.     public bool AttachEventListener(int key,IEventListener listener)
  74.     {
  75.         if (listener == null)
  76.         {
  77.             return false;
  78.         }
  79.         if (!mListeners.ContainsKey(key))
  80.         {
  81.             mListeners.Add(key,new List<IEventListener>() { listener });
  82.             return true;
  83.         }
  84.         if (mListeners[key].Contains(listener))
  85.         {
  86.             return false;
  87.         }
  88.         int pos = 0;
  89.         for (int i = 0;i< mListeners[key].Count;i++ )
  90.         {
  91.             if (listener.EventPriority() > mListeners[key][i].EventPriority())
  92.             {
  93.                 break;
  94.             }
  95.             pos++;
  96.         }
  97.         mListeners[key].Insert(pos,listener);
  98.         return true;
  99.     }
  100.  
  101.     /// <summary>
  102.     /// 卸载一个消息节点
  103.     /// </summary>
  104.     /// <returns>如果当前消息节点不存在那么返回false</returns>
  105.     public bool DetachEventListener(int key,IEventListener listener)
  106.     {
  107.        if (mListeners.ContainsKey(key) && mListeners[key].Contains(listener))
  108.        {
  109.            mListeners[key].Remove(listener);
  110.            return true;
  111.        }
  112.        return false;
  113.     }
  114.  
  115.     public void SendEvent(int key,object param1 = null,object param2 = null)
  116.     {
  117.         DispatchEvent(key, param1, param2);
  118.     }
  119.  
  120.     /// <summary>
  121.     /// 派发消息到子消息节点以及自己节点下的监听器上
  122.     /// </summary>
  123.     /// <param name="key">消息ID</param>
  124.     /// <param name="param1"></param>
  125.     /// <param name="param2"></param>
  126.     /// <returns>如果中断消息返回true</returns>
  127.     private bool DispatchEvent(int key,object param1,object param2)
  128.     {
  129.         for (int i = 0; i < mNodeList.Count;i++ )
  130.         {
  131.             if (mNodeList[i].DispatchEvent(key, param1, param2)) return true;
  132.         }
  133.         return TriggerEvent(key, param1, param2);
  134.     }
  135.  
  136.   
  137.     /// <summary>
  138.     /// 消息触发
  139.     /// </summary>
  140.     /// <param name="key">消息id</param>
  141.     /// <param name="param1"></param>
  142.     /// <param name="param2"></param>
  143.     /// <returns>是否中断</returns>
  144.     private bool TriggerEvent(int key,object param1,object param2)
  145.     {
  146.         if (!this.gameObject.activeSelf || !this.gameObject.activeInHierarchy || !this.enabled)
  147.         {
  148.             return false;
  149.         }
  150.  
  151.         if (!mListeners.ContainsKey(key))
  152.         {
  153.             return false;
  154.         }
  155.         List<IEventListener> listeners = mListeners[key];
  156.         for (int i = 0; i < listeners.Count; i++)
  157.         {
  158.             if (listeners[i].HandleEvent(key, param1, param2)) return true;
  159.         }
  160.         return false;
  161.     }
  162.  
  163.    void OnApplicationQuit()
  164.     {
  165.         mListeners.Clear();
  166.         mNodeList.Clear();
  167.     }
  168.  
  169. }

新建一个类UIMgr .cs继承EventNode

  1. using UnityEngine;
  2. using System.Collections;
  3. using System;
  4. using System.Collections.Generic;
  5.  
  6. public class UIMgr : EventNode 
  7. {
  8.     private static UIMgr mInstance;
  9.     public static UIMgr Instance
  10.     {
  11.         get
  12.         {
  13.             return mInstance;
  14.         }
  15.     }
  16.  
  17.     /// <summary>
  18.     /// 所有UI
  19.     /// </summary>
  20.     private Dictionary<string, BaseUI> mDicUI = new Dictionary<string, BaseUI>();
  21.  
  22.     /// <summary>
  23.     /// 添加一个UI
  24.     /// </summary>
  25.     /// <param name="ui"></param>
  26.     public void AddUI(BaseUI ui)
  27.     {
  28.         if (ui != null)
  29.         {
  30.             mDicUI[ui.UIName] = ui;
  31.             
  32.         }
  33.         
  34.     }
  35.  
  36.     /// <summary>
  37.     /// 移除一个UI
  38.     /// </summary>
  39.     /// <param name="ui"></param>
  40.     public void RemoveUI(BaseUI ui)
  41.     {
  42.         if (ui != null && mDicUI.ContainsKey(ui.UIName))
  43.         {
  44.             mDicUI.Remove(ui.UIName);
  45.         }
  46.     }
  47.  
  48.     /// <summary>
  49.     /// 所有命令集合
  50.     /// </summary>
  51.     public List<Command> cmdList = new List<Command>();
  52.  
  53.     internal Transform UIROOT = null;
  54. 	void Awake() 
  55. 	{
  56.         UIROOT = this.transform.FindChild("UIRoot");
  57.         mInstance = this;
  58.         DontDestroyOnLoad(this.gameObject);
  59. 	}
  60.  
  61.     #region 创建UI
  62.  
  63.     /// <summary>
  64.     /// 创建UI
  65.     /// </summary>
  66.     /// <param name="uiName">UI名称</param>
  67.     /// <param name="type">要绑定的脚本</param>
  68.     /// <param name="listener">创建完成的回调</param>
  69.     public void CreateUI(string uiName, Type type, ILoadUIListener listener)
  70.     {
  71.         cmdList.Add(Command.CreateCmd(type,uiName,listener));
  72.     }
  73.  
  74.     /// <summary>
  75.     /// 创建UI的实体部分
  76.     /// </summary>
  77.     /// <param name="cmd">命令</param>
  78.     private void _Create(Command cmd)
  79.     {
  80.         BaseUI ui= null;
  81.         mDicUI.TryGetValue(cmd.uiName, out ui);
  82.         if (ui != null)
  83.         {
  84.             if (cmd.listener != null) cmd.listener.FiniSh(ui);
  85.         }
  86.         else
  87.         {
  88.             ResMgr.Instance.Load(cmd.uiName,new LoadResFinish(cmd));
  89.         }
  90.     }
  91.  
  92.     #endregion
  93.  
  94.     #region 显示UI
  95.  
  96.     /// <summary>
  97.     /// 显示一个UI界面  如果不存在就创建
  98.     /// </summary>
  99.     /// <param name="uiName">ui名称</param>
  100.     /// <param name="type">要绑定的脚本</param>
  101.     /// <param name="listener">如果界面不存在则会有界面加载完成后的回调</param>
  102.     /// <param name="param">要传入的参数</param>
  103.     public void ShowUI(string uiName, Type type, ILoadUIListener listener,object param = null,bool createCanCall = false)
  104.     {
  105.         BaseUI ui = null;
  106.         mDicUI.TryGetValue(uiName,out ui);
  107.         if (ui == null)
  108.         {
  109.             cmdList.Add(Command.CreateAndShowCmd(uiName,type,listener, param, createCanCall));
  110.         }
  111.         else
  112.         {
  113.             cmdList.Add(Command.ShowCmd(uiName, listener, param, createCanCall));
  114.         }
  115.         
  116.         
  117.     }
  118.  
  119.     /// <summary>
  120.     /// 显示一个界面
  121.     /// </summary>
  122.     /// <param name="cmd"></param>
  123.     private void _ShowUI(Command cmd)
  124.     {
  125.  
  126.         BaseUI ui = null;
  127.         mDicUI.TryGetValue(cmd.uiName, out ui);
  128.         if (ui != null)
  129.         {
  130.             if (cmd.listener != null)
  131.             {
  132.                 cmd.listener.FiniSh(ui);
  133.             }
  134.             ui.Show();
  135.             
  136.         }
  137.     }
  138.  
  139.    
  140.     #endregion
  141.  
  142.     #region  隐藏UI
  143.  
  144.     /// <summary>
  145.     /// 隐藏这个UI
  146.     /// </summary>
  147.     /// <param name="uiName"></param>
  148.     public void HideUI(string uiName)
  149.     {
  150.         
  151.         cmdList.Add(Command.HideCmd(uiName));
  152.     }
  153.  
  154.  
  155.     private void _HideUI(Command cmd)
  156.     {
  157.         Debug.Log("_HideUI " + cmd.uiName);
  158.         BaseUI ui = null;
  159.         mDicUI.TryGetValue(cmd.uiName, out ui);
  160.         if (ui != null)
  161.         {
  162.             ui.Hide();
  163.         }
  164.     }
  165. #endregion
  166.  
  167.     #region  删除UI
  168.  
  169.     /// <summary>
  170.     /// 删除UI
  171.     /// </summary>
  172.     /// <param name="uiName">UI名称</param>
  173.     public void DestroyUI(string uiName)
  174.     {
  175.         cmdList.Add(Command.DestroyCmd(uiName));
  176.     }
  177.  
  178.     private void _DestroyUI(Command cmd)
  179.     {
  180.         BaseUI ui = null;
  181.         mDicUI.TryGetValue(cmd.uiName, out ui);
  182.         if (ui != null)
  183.         {
  184.             mDicUI.Remove(ui.UIName);
  185.             Destroy(ui.CacheGameObject);
  186.         }
  187.     }
  188.  
  189.     #endregion
  190.  
  191. 	// Update is called every frame, if the MonoBehaviour is enabled.
  192. 	void Update() 
  193. 	{
  194.  
  195.         if (cmdList.Count > 0)
  196.         {
  197.             Command tempCmd = null;
  198.             tempCmd = cmdList[0];
  199.             if (tempCmd == null)
  200.             {
  201.                 cmdList.RemoveAt(0);
  202.             }
  203.             else
  204.             {
  205.                 switch(tempCmd.cmdType)
  206.                 {
  207.                     case Command.CmdType.CreateAndShow:
  208.                         _Create(tempCmd);
  209.                         break;
  210.                     case Command.CmdType.Create:
  211.                         _Create(tempCmd);
  212.                         break;
  213.                     case Command.CmdType.Destroy:
  214.                         _DestroyUI(tempCmd);
  215.                         break;
  216.                     case Command.CmdType.Hide:
  217.                         
  218.                         _HideUI(tempCmd);
  219.                         break;
  220.                     case Command.CmdType.Show:
  221.                         _ShowUI(tempCmd);
  222.                         break;
  223.                 }
  224.                 cmdList.RemoveAt(0);
  225.             }
  226.         }
  227. 	}
  228.  
  229.     /// <summary>
  230.     /// UI资源加载完成的回调
  231.     /// </summary>
  232.     public class LoadResFinish : IResLoadListener
  233.     {
  234.         /// <summary>
  235.         /// 命令
  236.         /// </summary>
  237.         public Command cmd;
  238.         public LoadResFinish(Command _cmd)
  239.         {
  240.             cmd = _cmd;
  241.         }
  242.  
  243.         public void Finish(object asset)
  244.         {
  245.  
  246.             if (cmd == null)
  247.             {
  248.                 return;
  249.             }
  250.             GameObject go = Instantiate<GameObject>(asset as GameObject);
  251.             go.SetActive(false);
  252.             BaseUI ui =  go.AddComponent(cmd.type) as BaseUI;
  253.             ui.UIInit();
  254.             ui.UIName = cmd.uiName;
  255.             go.gameObject.name = ui.UIName;
  256.             ui.CacheTransform.SetParent(UIMgr.Instance.UIROOT, false);
  257.             UIMgr.Instance.AddUI(ui);
  258.             if (cmd.cmdType == Command.CmdType.CreateAndShow)
  259.             {
  260.                 UIMgr.Instance.ShowUI(cmd.uiName, cmd.type, cmd.listener);
  261.             }
  262.             else if (cmd.createCanCall && cmd.listener != null)
  263.             {
  264.                 cmd.listener.FiniSh(ui);
  265.             }
  266.         }
  267.  
  268.         public void Failure()
  269.         {
  270.             if (cmd.createCanCall && cmd.listener != null)
  271.             {
  272.                 cmd.listener.Failure();
  273.             }
  274.         }
  275.     }
  276.  
  277.     /// <summary>
  278.     /// 界面加载回调
  279.     /// </summary>
  280.     public interface ILoadUIListener
  281.     {
  282.         void FiniSh(BaseUI ui);
  283.         void Failure();
  284.     }
  285.  
  286.     /// <summary>
  287.     /// 操作UI命令集
  288.     /// </summary>
  289.     public class Command
  290.     {
  291.         /// <summary>
  292.         /// 命令类型
  293.         /// </summary>
  294.         public enum CmdType
  295.         {
  296.             /// <summary>
  297.             /// 创建
  298.             /// </summary>
  299.             CreateAndShow,
  300.             /// <summary>
  301.             /// 创建
  302.             /// </summary>
  303.             Create,
  304.             /// <summary>
  305.             /// 显示或者刷新
  306.             /// </summary>
  307.             Show,
  308.             /// <summary>
  309.             /// 隐藏
  310.             /// </summary>
  311.             Hide,
  312.             /// <summary>
  313.             /// 删除
  314.             /// </summary>
  315.             Destroy,
  316.         }
  317.  
  318.         /// <summary>
  319.         /// UI名称
  320.         /// </summary>
  321.         public string uiName;
  322.  
  323.         /// <summary>
  324.         /// 要绑定的脚本
  325.         /// </summary>
  326.         public Type type;
  327.  
  328.         /// <summary>
  329.         /// 加载完成之后的回调
  330.         /// </summary>
  331.         public ILoadUIListener listener;
  332.  
  333.         /// <summary>
  334.         /// 要传入的数据
  335.         /// </summary>
  336.         public object param;
  337.  
  338.         /// <summary>
  339.         /// 命令类型
  340.         /// </summary>
  341.         public CmdType cmdType;
  342.  
  343.         /// <summary>
  344.         /// 创建时候需要回调
  345.         /// </summary>
  346.         public bool createCanCall = true;
  347.  
  348.         /// <summary>
  349.         /// 获取一个显示的命令
  350.         /// </summary>
  351.         /// <param name="_uiName">UI名称</param>
  352.         /// <param name="_param">要传入的参数</param>
  353.         public static Command CreateAndShowCmd(string uiName, Type type, ILoadUIListener listener, object param , bool createCanCall)
  354.         {
  355.             Command cmd = new Command(CmdType.CreateAndShow, uiName, type);
  356.             cmd.createCanCall = createCanCall;
  357.             cmd.listener = listener;
  358.             cmd.type = type;
  359.             cmd.param = param;
  360.             return cmd;
  361.         }
  362.         /// <summary>
  363.         /// 获取一个显示的命令
  364.         /// </summary>
  365.         /// <param name="_uiName">UI名称</param>
  366.         /// <param name="_param">要传入的参数</param>
  367.         public static Command ShowCmd(string _uiName,ILoadUIListener listener ,object _param, bool _createCanCall)
  368.         {
  369.             Command cmd = new Command(CmdType.Show, _uiName, _param);
  370.             cmd.createCanCall = _createCanCall;
  371.             cmd.listener = listener;
  372.             return cmd;
  373.         }
  374.  
  375.  
  376.         /// <summary>
  377.         /// 获取一个创建的命令
  378.         /// </summary>
  379.         /// <param name="_type">要绑定的脚本</param>
  380.         /// <param name="_listener">加载完成之后的回调</param>
  381.         public static Command CreateCmd(Type _type,string _uiName, ILoadUIListener _listener)
  382.         {
  383.             return new Command(CmdType.Create, _uiName, _type, _listener);
  384.         }
  385.  
  386.         /// <summary>
  387.         /// 获取一个隐藏命令
  388.         /// </summary>
  389.         /// <param name="_uiName">要隐藏的UI名称</param>
  390.         /// <returns></returns>
  391.         public static Command HideCmd(string _uiName)
  392.         {
  393.             return new Command(CmdType.Hide, _uiName,null);
  394.         }
  395.  
  396.         /// <summary>
  397.         /// 获取一个删除的命令
  398.         /// </summary>
  399.         /// <param name="_uiName">UI名称</param>
  400.         /// <returns></returns>
  401.         public static Command DestroyCmd(string _uiName)
  402.         {
  403.             return new Command(CmdType.Destroy, _uiName, null);
  404.         }
  405.  
  406.         /// <summary>
  407.         /// 构造函数
  408.         /// </summary>
  409.         /// <param name="_cmdType">命令类型</param>
  410.         /// <param name="_uiName">UI名称</param>
  411.         /// <param name="_param">要传入的参数</param>
  412.         public Command(CmdType _cmdType, string _uiName, object _param)
  413.         {
  414.             uiName = _uiName;
  415.             cmdType = _cmdType;
  416.             param = _param;
  417.         }
  418.  
  419.         /// <summary>
  420.         /// 构造
  421.         /// </summary>
  422.         /// <param name="_cmdType">命令类型</param>
  423.         /// <param name="_type">要绑定的脚本</param>
  424.         /// <param name="_listener">加载完成之后的回调</param>
  425.         public Command(CmdType _cmdType,string _uiName,Type _type,ILoadUIListener _listener)
  426.         {
  427.             cmdType = _cmdType;
  428.             type = _type;
  429.             listener = _listener;
  430.             uiName = _uiName;
  431.         }
  432.     }
  433. }
  434.

 

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号