Unity 客户端框架（六）：UI框架

最新推荐文章于 2023-05-06 15:56:48 发布

^_^！

最新推荐文章于 2023-05-06 15:56:48 发布

阅读量4k

点赞数

分类专栏： # unity

unity 专栏收录该内容

90 篇文章 7 订阅

订阅专栏

http://blog.csdn.net/lovethrain/article/details/52134167

引自百度：编写UI框架意义

打开，关闭，层级，页面跳转等管理问题集中化，将外部切换等逻辑交给UIManager处理
功能逻辑分散化，每个页面维护自身逻辑，依托于框架便于多人协同开发，不用关心跳转和显示关闭细节
通用性框架能够做到简单的代码复用和"项目经验"沉淀

这个UI框架不区别于NGUI与UGUI，通用

[csharp]view plaincopy 
    
 public abstract class BaseUI : MonoBehaviour  
     {  
         #region 缓存  
   
         private Transform _CachedTransform;  
         public Transform cachedTransform  
         {  
             get  
             {  
                 if(!_CachedTransform)  
                 {  
                     _CachedTransform = this.transform;  
                 }  
                 return _CachedTransform;  
             }  
         }  
   
         private GameObject _CachedGameobject;  
         public GameObject cachedGameobject  
         {  
             get  
             {  
                 if (!_CachedGameobject)  
                 {  
                     _CachedGameobject = this.gameObject;  
                 }  
                 return _CachedGameobject;  
             }  
         }  
  
         #endregion  
  
         #region Type && State  
   
         protected EnumObjectState state = EnumObjectState.None;  
   
         public event StateChangedEvent StateChanged;  
   
         public EnumObjectState State  
         {  
             get  
             {  
                 return this.state;  
             }  
             set  
             {  
                 if(value != state)  
                 {  
                     EnumObjectState oldState = value;  
                     state = value;  
                     if (null != StateChanged)  
                         StateChanged(this, state, oldState);  
                 }  
             }  
         }  
   
         public abstract EnumUIType GetUIType();  
  
         #endregion  
   
         public virtual void SetDepthToTop() { }  
   
         void Start()  
         {  
             OnStart();  
         }  
   
         void Awake()  
         {  
             this.State = EnumObjectState.Initial;  
             OnAwake();  
         }  
   
         void Update()  
         {  
             if (EnumObjectState.Ready == State)  
                 OnUpdate(Time.deltaTime);  
         }  
   
         public void Release()  
         {  
             this.State = EnumObjectState.Closing;  
             //GameObject.Destroy(cachedGameobject);  
             ObjPool.Instance.OnReturnObj(cachedGameobject);  
             OnRelease();  
         }  
   
         protected virtual void OnStart()  
         {  
   
         }  
   
         protected virtual void OnAwake()  
         {  
             this.State = EnumObjectState.Loading;  
             this.OnPlayOpenUIAudio();  
         }  
   
         protected virtual void OnUpdate(float dletaTime)  
         {  
   
         }  
   
         protected virtual void OnRelease()  
         {  
             this.OnPlayCloseUIAudio();  
         }  
   
         protected virtual void OnPlayOpenUIAudio()  
         {  
   
         }  
   
         protected virtual void OnPlayCloseUIAudio()  
         {  
   
         }  
   
         protected virtual void SetUI(params object[] uiParams)  
         {  
             this.State = EnumObjectState.Loading;  
         }  
   
         protected virtual void OnLoadData()  
         {  
   
         }  
   
         public void SetUIWhenOpening(params object[] uiParams)  
         {  
             SetUI(uiParams);  
             CoroutineInstance.Instance.StartCoroutine(AsyncOnLoadData());  
         }  
   
         private IEnumerator AsyncOnLoadData()  
         {  
             yield return new WaitForSeconds(0);  
             if(this.State == EnumObjectState.Loading)  
             {  
                 this.OnLoadData();  
                 this.State = EnumObjectState.Ready;  
             }  
         }  
   
   
     }  

[csharp]view plaincopy 
    
 public class UIManager : Singleton<UIManager>  
    {  
  
        #region UIInfoData  
   
        class UIInfoData  
        {  
            public EnumUIType UIType { get; private set; }  
   
            public Type ScriptType { get; private set; }  
   
            public string Path { get; private set; }  
   
            public object[] UIParams { get; private set; }  
   
            public UIInfoData(EnumUIType _uiType, string _path, params object[] _uiParams)  
            {  
                this.UIType = _uiType;  
                this.Path = _path;  
                this.UIParams = _uiParams;  
                this.ScriptType = UIPathDefines.GetUIScriptByType(this.UIType);  
            }  
        }  
  
        #endregion  
   
        private Dictionary<EnumUIType, GameObject> dicOpenedUIs = null;  
   
        private Stack<UIInfoData> stackOpeningUIs = null;  
   
        public override void Init()  
        {  
            dicOpenedUIs = new Dictionary<EnumUIType, GameObject>();  
            stackOpeningUIs = new Stack<UIInfoData>();  
        }  
  
        #region Get  
          
        public T GetUI<T>(EnumUIType _type) where T : BaseUI  
        {  
            GameObject _retObj = GetUIObject(_type);  
            if (_retObj != null)  
                return _retObj.GetComponent<T>();  
            return null;  
        }  
          
        public GameObject GetUIObject(EnumUIType _type)  
        {  
            GameObject _retObj = null;  
            if(!dicOpenedUIs.TryGetValue(_type,out _retObj))  
                throw new Exception("dicOpenedUIs TryGetValue Failure! _uiType :" + _type.ToString());  
            return _retObj;  
        }  
  
        #endregion  
  
        #region Preload  
   
        public void PreloadUI(EnumUIType[] _uiTypes)  
        {  
            for (int i = 0; i < _uiTypes.Length; i++)  
            {  
                PreloadUI(_uiTypes[i]);  
            }  
        }  
   
   
        public void PreloadUI(EnumUIType _uiType)  
        {  
            string path = UIPathDefines.UI_PREFAB + _uiType.ToString();  
            ResManager.Instance.Load(path);  
              
        }  
  
        #endregion  
  
        #region Open  
         
        public void OpenUI(EnumUIType[] uiTypes)  
        {  
            OpenUI(false, uiTypes, null);  
        }  
   
         
        public void OpenUI(EnumUIType uiType, params object[] uiObjParams)  
        {  
            EnumUIType[] uiTypes = new EnumUIType[1];  
            uiTypes[0] = uiType;  
            OpenUI(false, uiTypes, uiObjParams);  
        }  
   
        public void OpenUICloseOthers(EnumUIType[] uiTypes)  
        {  
            OpenUI(true, uiTypes, null);  
        }  
   
   
        public void OpenUICloseOthers(EnumUIType uiType, params object[] uiObjParams)  
        {  
            EnumUIType[] uiTypes = new EnumUIType[1];  
            uiTypes[0] = uiType;  
            OpenUI(true, uiTypes, uiObjParams);  
        }  
   
        
        private void OpenUI(bool _isCloseOthers, EnumUIType[] _uiTypes, params object[] _uiParams)  
        {  
            // Close Others UI.  
            if (_isCloseOthers)  
            {  
                CloseUIAll();  
            }  
   
            // push _uiTypes in Stack.  
            for (int i = 0; i < _uiTypes.Length; i++)  
            {  
                EnumUIType _uiType = _uiTypes[i];  
                if (!dicOpenedUIs.ContainsKey(_uiType))  
                {  
                    string _path = UIPathDefines.UI_PREFAB + _uiType.ToString();  
                    stackOpeningUIs.Push(new UIInfoData(_uiType, _path, _uiParams));  
                }  
            }  
   
            // Open UI.  
            if (stackOpeningUIs.Count > 0)  
            {  
                  CoroutineInstance.Instance.StartCoroutine(AsyncLoadData());  
            }  
        }  
   
   
        private IEnumerator<int> AsyncLoadData()  
        {  
            UIInfoData _uiInfoData = null;  
            GameObject _prefabObj = null;  
            //GameObject _uiObject = null;  
   
            if (stackOpeningUIs != null && stackOpeningUIs.Count > 0)  
            {  
                do  
                {  
                    _uiInfoData = stackOpeningUIs.Pop();  
   
                    //_prefabObj = ResManager.Instance.Load(_uiInfoData.Path);  
                    string[] str = _uiInfoData.Path.Split('/');  
                    _prefabObj = ObjPool.Instance.OnGetObj(str[1], str[0]);  
                    _prefabObj.transform.SetParent(null);  
   
   
                    if (_prefabObj != null)  
                    {  
                        //_uiObject = NGUITools.AddChild(Game.Instance.mainUICamera.gameObject, _prefabObj as GameObject);  
                        //_uiObject = MonoBehaviour.Instantiate(_prefabObj) as GameObject;  
                        BaseUI _baseUI = _prefabObj.GetComponent<BaseUI>();  
                        if (null == _baseUI)  
                        {  
                            _baseUI = _prefabObj.AddComponent(_uiInfoData.ScriptType) as BaseUI;  
                        }  
                        if (null != _baseUI)  
                        {  
                            _baseUI.SetUIWhenOpening(_uiInfoData.UIParams);  
                        }  
                        dicOpenedUIs.Add(_uiInfoData.UIType, _prefabObj);  
                    }  
   
                } while (stackOpeningUIs.Count > 0);  
            }  
            yield return 0;  
        }  
  
        #endregion  
  
        #region Close  
   
        public void CloseUI(EnumUIType _uiType)  
        {  
            GameObject _uiObj = null;  
            if (!dicOpenedUIs.TryGetValue(_uiType, out _uiObj))  
            {  
                Debug.Log("dicOpenedUIs TryGetValue Failure! _uiType :" + _uiType.ToString());  
                return;  
            }  
            CloseUI(_uiType, _uiObj);  
        }  
   
        public void CloseUI(EnumUIType[] _uiTypes)  
        {  
            for (int i = 0; i < _uiTypes.Length; i++)  
            {  
                CloseUI(_uiTypes[i]);  
            }  
        }  
   
   
        public void CloseUIAll()  
        {  
            List<EnumUIType> _keyList = new List<EnumUIType>(dicOpenedUIs.Keys);  
            foreach (EnumUIType _uiType in _keyList)  
            {  
                GameObject _uiObj = dicOpenedUIs[_uiType];  
                CloseUI(_uiType, _uiObj);  
            }  
            dicOpenedUIs.Clear();  
        }  
   
        private void CloseUI(EnumUIType _uiType, GameObject _uiObj)  
        {  
            if (_uiObj == null)  
            {  
                dicOpenedUIs.Remove(_uiType);  
            }  
            else  
            {  
                BaseUI _baseUI = _uiObj.GetComponent<BaseUI>();  
                if (_baseUI != null)  
                {  
                    _baseUI.StateChanged += CloseUIHandler;  
                    _baseUI.Release();  
                }  
                else  
                {  
                    GameObject.Destroy(_uiObj);  
                    dicOpenedUIs.Remove(_uiType);  
                }  
            }  
        }  
   
   
        private void CloseUIHandler(object _sender, EnumObjectState _newState, EnumObjectState _oldState)  
        {  
            if (_newState == EnumObjectState.Closing)  
            {  
                BaseUI _baseUI = _sender as BaseUI;  
                dicOpenedUIs.Remove(_baseUI.GetUIType());  
                _baseUI.StateChanged -= CloseUIHandler;  
            }  
        }  
        #endregion  
   
    }  