UI管理模块——UI基类

帮助面板通过代码快速找到各类子控件

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.EventSystems;
  5. using UnityEngine.UI;
  6. /// <summary>
  7. /// 面板基类
  8. /// 找到所有自己面板下的控件对象
  9. /// 他应该提供显示或隐藏的行为
  10. /// </summary>
  11. public class BasePanel : MonoBehaviour
  12. {
  13.     // 通过里氏转换原则, 来存储所有的控件
  14.     private Dictionary<string, List<UIBehaviour>> controlDic = new Dictionary<string, List<UIBehaviour>>();
  15.     void Awake()
  16.     {
  17.         FindChildrenControl<Button>();
  18.         FindChildrenControl<Image>();
  19.         FindChildrenControl<Text>();
  20.         FindChildrenControl<Toggle>();
  21.         FindChildrenControl<Slider>();
  22.         FindChildrenControl<ScrollRect>();
  23.     }
  25.     /// <summary>
  26.     /// 显示自己
  27.     /// </summary>
  28.     public virtual void ShowMe(){}
  29.     /// <summary>
  30.     /// 隐藏自己
  31.     /// </summary>
  32.     public virtual void HideMe(){}
  34.     /// <summary>
  35.     /// 找到子对象的对应控件
  36.     /// </summary>
  37.     /// <typeparam name="T"></typeparam>
  38.     private void FindChildrenControl<T>() where T : UIBehaviour
  39.     {
  40.         T[] controls = this.GetComponentsInChildren<T>();
  41.         string objName;
  42.         for (int i = 0; i < controls.Length; i++)
  43.         {
  44.             objName = controls[i].gameObject.name;
  45.             if (controlDic.ContainsKey(objName))
  46.             {
  47.                 controlDic[objName].Add(controls[i]);
  48.             }
  49.             else
  50.             {
  51.                 controlDic.Add(objName, new List<UIBehaviour>() { controls[i] });
  52.             }
  54.         }
  55.     }
  57.     /// <summary>
  58.     /// 得到对应名字的脚本
  59.     /// </summary>
  60.     /// <typeparam name="T"></typeparam>
  61.     /// <param name="controlName"></param>
  62.     /// <returns></returns>
  63.     protected T GetControl<T>(string controlName) where T : UIBehaviour
  64.     {
  65.         if (controlDic.ContainsKey(controlName))
  66.         {
  67.             for (int i = 0; i < controlDic[controlName].Count; ++i)
  68.             {
  69.                 if (controlDic[controlName][i] is T)
  70.                 {
  71.                     return controlDic[controlName][i] as T;
  72.                 }
  73.             }
  74.         }
  75.         return null;
  76.     }
  77. }

UI管理模块——UI管理器

管理所有显示的面板,提供给其他游戏系统接口,用来显示面板和隐藏面板

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.Events;
  6. /// <summary>
  7. /// UI层级枚举
  8. /// </summary>
  9. public enum E_UI_Layer
  10. {
  11.     Bot,
  12.     Mid,
  13.     Top,
  14.     System
  15. }
  17. public class UIManager : BaseManager<UIManager>
  18. {
  19.     public Dictionary<string, BasePanel> panelDic = new Dictionary<string, BasePanel>();
  20.     //private Transform canvas;
  22.     // 为UI分层
  23.     private Transform bot; // 底层
  24.     private Transform mid; // 中层
  25.     private Transform top; // 顶层
  26.     private Transform system; // 系统层
  28.     // 记录UI的Canvas父对象 方便以后外部可能会使用他
  29.     public RectTransform canvas;
  31.     public UIManager()
  32.     {
  33.         // 创建Canvas, 让其过场景不移除
  34.         GameObject obj = ResMgr.GetInstance().Load<GameObject>("UI/Canvas");
  35.         canvas = obj.transform as RectTransform;
  36.         GameObject.DontDestroyOnLoad(obj);
  38.         // 找到各层
  39.         bot = canvas.Find("Bot");
  40.         mid = canvas.Find("Mid");
  41.         top = canvas.Find("Top");
  42.         system = canvas.Find("System");
  44.         // 创建EventSystem
  45.         obj = ResMgr.GetInstance().Load<GameObject>("UI/EventSystem");
  46.         GameObject.DontDestroyOnLoad(obj);
  47.     }
  49.     /// <summary>
  50.     /// 显示面板
  51.     /// </summary>
  52.     /// <typeparam name="T">面板脚本类型</typeparam>
  53.     /// <param name="panelName">面板名</param>
  54.     /// <param name="layer">显示在哪一层</param>
  55.     /// <param name="callBack">当面板预设体创建成功后, 想要做的事</param>
  56.     public void ShowPanel<T>(string panelName, E_UI_Layer layer = E_UI_Layer.Mid, UnityAction<T> callBack = null) where T : BasePanel
  57.     {
  58.         // 面板已经存在
  59.         if (panelDic.ContainsKey(panelName))
  60.         {
  61.             panelDic[panelName].ShowMe();
  62.             if (callBack != null)
  63.             {
  64.                 callBack(panelDic[panelName] as T);
  65.             }
  66.             //// 避免面板重复加载, 如果存在该面板则直接显示, 调用回调函数后, 直接Return, 不再处理后面的异步加载
  67.             return;
  68.         }
  70.         // 异步加载面板
  71.         ResMgr.GetInstance().LoadAsync<GameObject>("UI/" + panelName, (obj) =>
  72.         {
  73.             // 把他作为Canvas的子对象, 并且要设置他的相对位置
  75.             // 找到父对象 , 显示在哪一层
  76.             Transform father = bot;
  77.             switch (layer)
  78.             {
  79.                 case E_UI_Layer.Mid:
  80.                     father = mid;
  81.                     break;
  82.                 case E_UI_Layer.Top:
  83.                     father = top;
  84.                     break;
  85.                 case E_UI_Layer.System:
  86.                     father = system;
  87.                     break;
  88.             }
  90.             // 设置父对象, 相对位置和大小
  91.             obj.transform.SetParent(father,false);
  93.             obj.transform.localPosition = Vector3.zero;
  94.             obj.transform.localScale = Vector3.one;
  96.             (obj.transform as RectTransform).offsetMax = Vector2.zero;
  97.             (obj.transform as RectTransform).offsetMin = Vector2.zero;
  99.             // 得到预设体上的的面板脚本 
  100.             T panel = obj.GetComponent<T>();
  101.             // 处理面板创建完成后的逻辑 (因为是异步加载面板, 要做延时处理, 只有当面板真正加载完时, 才会做外面想要做的事情.)
  102.             if (callBack != null)
  103.             {
  104.                 callBack(panel);
  105.             }
  107.             panelDic[panelName].ShowMe();
  109.             // 把面板存起来
  110.             panelDic.Add(panelName, panel);
  111.         });
  113.     }
  115.     /// <summary>
  116.     /// 隐藏面板
  117.     /// </summary>
  118.     /// <param name="panelName">面板名</param>
  119.     public void HidePanel(string panelName)
  120.     {
  121.         if (panelDic.ContainsKey(panelName))
  122.         {
  123.             panelDic[panelName].HideMe();
  124.             GameObject.Destroy(panelDic[panelName].gameObject);
  125.             panelDic.Remove(panelName);
  126.         }
  127.     }
  129.     /// <summary>
  130.     /// 得到某一个已经显示的面板
  131.     /// </summary>
  132.     /// <param name="panelName">面板名</param>
  133.     public T GetPanel<T>(string panelName)where T:BasePanel
  134.     {
  135.         if(panelDic.ContainsKey(panelName))
  136.         {
  137.             return panelDic[panelName] as T;
  138.         }
  139.         return null;
  140.     }
  141. }

使用

image.png

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  5. public class UITest : MonoBehaviour
  6. {
  7.     void Start()
  8.     {
  9.         UIManager.GetInstance().ShowPanel<LoginPanel>("LoginPanel", E_UI_Layer.Bot, showPanelOver);
  10.     }
  11.     private void showPanelOver(LoginPanel panel)
  12.     {
  13.         panel.IninInfo();
  14.         Invoke("DelayHide", 1); 
  15.     }
  17.     private void DelayHide()
  18.     {
  19.         UIManager.GetInstance().HidePanel("LoginPanel");
  20.     }
  21. }

UI管理模块——优化面板基类事件监听

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.EventSystems;
  5. using UnityEngine.UI;
  7. /// <summary>
  8. /// 面板基类 
  9. /// 帮助我门通过代码快速的找到所有的子控件
  10. /// 方便我们在子类中处理逻辑 
  11. /// 节约找控件的工作量
  12. /// </summary>
  13. public class BasePanel : MonoBehaviour
  14. {
  15.     //通过里式转换原则 来存储所有的控件
  16.     private Dictionary<string, List<UIBehaviour>> controlDic = new Dictionary<string, List<UIBehaviour>>();
  18.     // Use this for initialization
  19.     protected virtual void Awake () {
  20.         FindChildrenControl<Button>();
  21.         FindChildrenControl<Image>();
  22.         FindChildrenControl<Text>();
  23.         FindChildrenControl<Toggle>();
  24.         FindChildrenControl<Slider>();
  25.         FindChildrenControl<ScrollRect>();
  26.         FindChildrenControl<InputField>();
  27.     }
  29.     /// <summary>
  30.     /// 显示自己
  31.     /// </summary>
  32.     public virtual void ShowMe()
  33.     {
  35.     }
  37.     /// <summary>
  38.     /// 隐藏自己
  39.     /// </summary>
  40.     public virtual void HideMe()
  41.     {
  43.     }
  45.     protected virtual void OnClick(string btnName)
  46.     {
  48.     }
  50.     protected virtual void OnValueChanged(string toggleName, bool value)
  51.     {
  53.     }
  55.     /// <summary>
  56.     /// 得到对应名字的对应控件脚本
  57.     /// </summary>
  58.     /// <typeparam name="T"></typeparam>
  59.     /// <param name="controlName"></param>
  60.     /// <returns></returns>
  61.     protected T GetControl<T>(string controlName) where T : UIBehaviour
  62.     {
  63.         if(controlDic.ContainsKey(controlName))
  64.         {
  65.             for( int i = 0; i <controlDic[controlName].Count; ++i )
  66.             {
  67.                 if (controlDic[controlName][i] is T)
  68.                     return controlDic[controlName][i] as T;
  69.             }
  70.         }
  72.         return null;
  73.     }
  75.     /// <summary>
  76.     /// 找到子对象的对应控件
  77.     /// </summary>
  78.     /// <typeparam name="T"></typeparam>
  79.     private void FindChildrenControl<T>() where T:UIBehaviour
  80.     {
  81.         T[] controls = this.GetComponentsInChildren<T>();
  82.         for (int i = 0; i < controls.Length; ++i)
  83.         {
  84.             string objName = controls[i].gameObject.name;
  85.             if (controlDic.ContainsKey(objName))
  86.                 controlDic[objName].Add(controls[i]);
  87.             else
  88.                 controlDic.Add(objName, new List<UIBehaviour>() { controls[i] });
  89.             //如果是按钮控件
  90.             if(controls[i] is Button)
  91.             {
  92.                 (controls[i] as Button).onClick.AddListener(()=>
  93.                 {
  94.                     OnClick(objName);
  95.                 });
  96.             }
  97.             //如果是单选框或者多选框
  98.             else if(controls[i] is Toggle)
  99.             {
  100.                 (controls[i] as Toggle).onValueChanged.AddListener((value) =>
  101.                 {
  102.                     OnValueChanged(objName, value);
  103.                 });
  104.             }
  105.         }
  106.     }
  107. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.Events;
  6. /// <summary>
  7. /// UI层级
  8. /// </summary>
  9. public enum E_UI_Layer
  10. {
  11.     Bot,
  12.     Mid,
  13.     Top,
  14.     System,
  15. }
  17. /// <summary>
  18. /// UI管理器
  19. /// 1.管理所有显示的面板
  20. /// 2.提供给外部 显示和隐藏等等接口
  21. /// </summary>
  22. public class UIManager : BaseManager<UIManager>
  23. {
  24.     public Dictionary<string, BasePanel> panelDic = new Dictionary<string, BasePanel>();
  26.     private Transform bot;
  27.     private Transform mid;
  28.     private Transform top;
  29.     private Transform system;
  31.     //记录我们UI的Canvas父对象 方便以后外部可能会使用它
  32.     public RectTransform canvas;
  34.     public UIManager()
  35.     {
  36.         //创建Canvas 让其过场景的时候 不被移除
  37.         GameObject obj = ResMgr.GetInstance().Load<GameObject>("UI/Canvas");
  38.         canvas = obj.transform as RectTransform;
  39.         GameObject.DontDestroyOnLoad(obj);
  41.         //找到各层
  42.         bot = canvas.Find("Bot");
  43.         mid = canvas.Find("Mid");
  44.         top = canvas.Find("Top");
  45.         system = canvas.Find("System");
  47.         //创建EventSystem 让其过场景的时候 不被移除
  48.         obj = ResMgr.GetInstance().Load<GameObject>("UI/EventSystem");
  49.         GameObject.DontDestroyOnLoad(obj);
  50.     }
  52.     /// <summary>
  53.     /// 通过层级枚举 得到对应层级的父对象
  54.     /// </summary>
  55.     /// <param name="layer"></param>
  56.     /// <returns></returns>
  57.     public Transform GetLayerFather(E_UI_Layer layer)
  58.     {
  59.         switch(layer)
  60.         {
  61.             case E_UI_Layer.Bot:
  62.                 return this.bot;
  63.             case E_UI_Layer.Mid:
  64.                 return this.mid;
  65.             case E_UI_Layer.Top:
  66.                 return this.top;
  67.             case E_UI_Layer.System:
  68.                 return this.system;
  69.         }
  70.         return null;
  71.     }
  73.     /// <summary>
  74.     /// 显示面板
  75.     /// </summary>
  76.     /// <typeparam name="T">面板脚本类型</typeparam>
  77.     /// <param name="panelName">面板名</param>
  78.     /// <param name="layer">显示在哪一层</param>
  79.     /// <param name="callBack">当面板预设体创建成功后 你想做的事</param>
  80.     public void ShowPanel<T>(string panelName, E_UI_Layer layer = E_UI_Layer.Mid, UnityAction<T> callBack = null) where T:BasePanel
  81.     {
  82.         if (panelDic.ContainsKey(panelName))
  83.         {
  84.             panelDic[panelName].ShowMe();
  85.             // 处理面板创建完成后的逻辑
  86.             if (callBack != null)
  87.                 callBack(panelDic[panelName] as T);
  88.             //避免面板重复加载 如果存在该面板 即直接显示 调用回调函数后  直接return 不再处理后面的异步加载逻辑
  89.             return;
  90.         }
  92.         ResMgr.GetInstance().LoadAsync<GameObject>("UI/" + panelName, (obj) =>
  93.         {
  94.             //把他作为 Canvas的子对象
  95.             //并且 要设置它的相对位置
  96.             //找到父对象 你到底显示在哪一层
  97.             Transform father = bot;
  98.             switch(layer)
  99.             {
  100.                 case E_UI_Layer.Mid:
  101.                     father = mid;
  102.                     break;
  103.                 case E_UI_Layer.Top:
  104.                     father = top;
  105.                     break;
  106.                 case E_UI_Layer.System:
  107.                     father = system;
  108.                     break;
  109.             }
  110.             //设置父对象  设置相对位置和大小
  111.             obj.transform.SetParent(father);
  113.             obj.transform.localPosition = Vector3.zero;
  114.             obj.transform.localScale = Vector3.one;
  116.             (obj.transform as RectTransform).offsetMax = Vector2.zero;
  117.             (obj.transform as RectTransform).offsetMin = Vector2.zero;
  119.             //得到预设体身上的面板脚本
  120.             T panel = obj.GetComponent<T>();
  121.             // 处理面板创建完成后的逻辑
  122.             if (callBack != null)
  123.                 callBack(panel);
  125.             panel.ShowMe();
  127.             //把面板存起来
  128.             panelDic.Add(panelName, panel);
  129.         });
  130.     }
  132.     /// <summary>
  133.     /// 隐藏面板
  134.     /// </summary>
  135.     /// <param name="panelName"></param>
  136.     public void HidePanel(string panelName)
  137.     {
  138.         if(panelDic.ContainsKey(panelName))
  139.         {
  140.             panelDic[panelName].HideMe();
  141.             GameObject.Destroy(panelDic[panelName].gameObject);
  142.             panelDic.Remove(panelName);
  143.         }
  144.     }
  146.     /// <summary>
  147.     /// 得到某一个已经显示的面板 方便外部使用
  148.     /// </summary>
  149.     public T GetPanel<T>(string name) where T:BasePanel
  150.     {
  151.         if (panelDic.ContainsKey(name))
  152.             return panelDic[name] as T;
  153.         return null;
  154.     }
  156. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.EventSystems;
  5. using UnityEngine.UI;
  7. public class LoginPanel : BasePanel {
  9.     //public Button btnStart;
  10.     //public Button btnQuit;
  12.     protected override void Awake()
  13.     {
  14.         //一定不能少 因为需要执行父类的awake来初始化一些信息 比如找控件 加事件监听
  15.         base.Awake();
  16.         //在下面处理自己的一些初始化逻辑
  17.     }
  19.     // Use this for initialization
  20.     void Start () {
  22.         //GetControl<Button>("btnStart").onClick.AddListener(ClickStart);
  23.         //GetControl<Button>("btnQuit").onClick.AddListener(ClickQuit);
  25.         UIManager.AddCustomEventListener(GetControl<Button>("btnStart"), EventTriggerType.PointerEnter, (data)=>{
  26.             Debug.Log("进入");
  27.         });
  28.         UIManager.AddCustomEventListener(GetControl<Button>("btnStart"), EventTriggerType.PointerExit, (data) => {
  29.             Debug.Log("离开");
  30.         });
  31.     }
  33.     private void Drag(BaseEventData data)
  34.     {
  36.     }
  38.     private void PointerDown(BaseEventData data)
  39.     {
  41.     }
  43.     // Update is called once per frame
  44.     void Update () {
  46.     }
  48.     public override void ShowMe()
  49.     {
  50.         base.ShowMe();
  51.         //显示面板时 想要执行的逻辑 这个函数 在UI管理器中 会自动帮我们调用
  52.         //只要重写了它  就会执行里面的逻辑
  53.     }
  55.     protected override void OnClick(string btnName)
  56.     {
  57.         switch(btnName)
  58.         {
  59.             case "btnStart":
  60.                 Debug.Log("btnStart被点击");
  61.                 break;
  62.             case "btnQuit":
  63.                 Debug.Log("btnQuit被点击");
  64.                 break;
  65.         }
  66.     }
  68.     protected override void OnValueChanged(string toggleName, bool value)
  69.     {
  70.         //在这来根据名字判断 到底是那一个单选框或者多选框状态变化了 当前状态就是传入的value
  71.     }
  74.     public void InitInfo()
  75.     {
  76.         Debug.Log("初始化数据");
  77.     }
  79.     //点击开始按钮的处理
  80.     public void ClickStart()
  81.     {
  82.     }
  84.     //点击开始按钮的处理
  85.     public void ClickQuit()
  86.     {
  87.         Debug.Log("S");
  88.     }
  89. }

UI管理模块——自定义事件监听

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.Events;
  5. using UnityEngine.EventSystems;
  7. /// <summary>
  8. /// UI层级
  9. /// </summary>
  10. public enum E_UI_Layer
  11. {
  12.     Bot,
  13.     Mid,
  14.     Top,
  15.     System,
  16. }
  18. /// <summary>
  19. /// UI管理器
  20. /// 1.管理所有显示的面板
  21. /// 2.提供给外部 显示和隐藏等等接口
  22. /// </summary>
  23. public class UIManager : BaseManager<UIManager>
  24. {
  25.     public Dictionary<string, BasePanel> panelDic = new Dictionary<string, BasePanel>();
  27.     private Transform bot;
  28.     private Transform mid;
  29.     private Transform top;
  30.     private Transform system;
  32.     //记录我们UI的Canvas父对象 方便以后外部可能会使用它
  33.     public RectTransform canvas;
  35.     public UIManager()
  36.     {
  37.         //创建Canvas 让其过场景的时候 不被移除
  38.         GameObject obj = ResMgr.GetInstance().Load<GameObject>("UI/Canvas");
  39.         canvas = obj.transform as RectTransform;
  40.         GameObject.DontDestroyOnLoad(obj);
  42.         //找到各层
  43.         bot = canvas.Find("Bot");
  44.         mid = canvas.Find("Mid");
  45.         top = canvas.Find("Top");
  46.         system = canvas.Find("System");
  48.         //创建EventSystem 让其过场景的时候 不被移除
  49.         obj = ResMgr.GetInstance().Load<GameObject>("UI/EventSystem");
  50.         GameObject.DontDestroyOnLoad(obj);
  51.     }
  53.     /// <summary>
  54.     /// 通过层级枚举 得到对应层级的父对象
  55.     /// </summary>
  56.     /// <param name="layer"></param>
  57.     /// <returns></returns>
  58.     public Transform GetLayerFather(E_UI_Layer layer)
  59.     {
  60.         switch (layer)
  61.         {
  62.             case E_UI_Layer.Bot:
  63.                 return this.bot;
  64.             case E_UI_Layer.Mid:
  65.                 return this.mid;
  66.             case E_UI_Layer.Top:
  67.                 return this.top;
  68.             case E_UI_Layer.System:
  69.                 return this.system;
  70.         }
  71.         return null;
  72.     }
  74.     /// <summary>
  75.     /// 显示面板
  76.     /// </summary>
  77.     /// <typeparam name="T">面板脚本类型</typeparam>
  78.     /// <param name="panelName">面板名</param>
  79.     /// <param name="layer">显示在哪一层</param>
  80.     /// <param name="callBack">当面板预设体创建成功后 你想做的事</param>
  81.     public void ShowPanel<T>(string panelName, E_UI_Layer layer = E_UI_Layer.Mid, UnityAction<T> callBack = null) where T : BasePanel
  82.     {
  83.         if (panelDic.ContainsKey(panelName))
  84.         {
  85.             panelDic[panelName].ShowMe();
  86.             // 处理面板创建完成后的逻辑
  87.             if (callBack != null)
  88.                 callBack(panelDic[panelName] as T);
  89.             //避免面板重复加载 如果存在该面板 即直接显示 调用回调函数后  直接return 不再处理后面的异步加载逻辑
  90.             return;
  91.         }
  93.         ResMgr.GetInstance().LoadAsync<GameObject>("UI/" + panelName, (obj) =>
  94.         {
  95.             //把他作为 Canvas的子对象
  96.             //并且 要设置它的相对位置
  97.             //找到父对象 你到底显示在哪一层
  98.             Transform father = bot;
  99.             switch (layer)
  100.             {
  101.                 case E_UI_Layer.Mid:
  102.                     father = mid;
  103.                     break;
  104.                 case E_UI_Layer.Top:
  105.                     father = top;
  106.                     break;
  107.                 case E_UI_Layer.System:
  108.                     father = system;
  109.                     break;
  110.             }
  111.             //设置父对象  设置相对位置和大小
  112.             obj.transform.SetParent(father);
  114.             obj.transform.localPosition = Vector3.zero;
  115.             obj.transform.localScale = Vector3.one;
  117.             (obj.transform as RectTransform).offsetMax = Vector2.zero;
  118.             (obj.transform as RectTransform).offsetMin = Vector2.zero;
  120.             //得到预设体身上的面板脚本
  121.             T panel = obj.GetComponent<T>();
  122.             // 处理面板创建完成后的逻辑
  123.             if (callBack != null)
  124.                 callBack(panel);
  126.             panel.ShowMe();
  128.             //把面板存起来
  129.             panelDic.Add(panelName, panel);
  130.         });
  131.     }
  133.     /// <summary>
  134.     /// 隐藏面板
  135.     /// </summary>
  136.     /// <param name="panelName"></param>
  137.     public void HidePanel(string panelName)
  138.     {
  139.         if (panelDic.ContainsKey(panelName))
  140.         {
  141.             panelDic[panelName].HideMe();
  142.             GameObject.Destroy(panelDic[panelName].gameObject);
  143.             panelDic.Remove(panelName);
  144.         }
  145.     }
  147.     /// <summary>
  148.     /// 得到某一个已经显示的面板 方便外部使用
  149.     /// </summary>
  150.     public T GetPanel<T>(string name) where T : BasePanel
  151.     {
  152.         if (panelDic.ContainsKey(name))
  153.             return panelDic[name] as T;
  154.         return null;
  155.     }
  157.     /// <summary>
  158.     /// 给控件添加自定义事件监听
  159.     /// </summary>
  160.     /// <param name="control">控件对象</param>
  161.     /// <param name="type">事件类型</param>
  162.     /// <param name="callBack">事件的响应函数</param>
  163.     public static void AddCustomEventListener(UIBehaviour control, EventTriggerType type, UnityAction<BaseEventData> callBack)
  164.     {
  165.         EventTrigger trigger = control.GetComponent<EventTrigger>();
  166.         if (trigger == null)
  167.             trigger = control.gameObject.AddComponent<EventTrigger>();
  169.         EventTrigger.Entry entry = new EventTrigger.Entry();
  170.         entry.eventID = type;
  171.         entry.callback.AddListener(callBack);
  173.         trigger.triggers.Add(entry);
  174.     }
  176. }