smart-bow-infrared/Assets/ShotSimulator/Scripts/ProjectBase/UI/UIManager.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;

namespace ProjectBase.UI
{
    public class UIManager : MonoSingleton<UIManager>
    {
        public Camera m_UICamera;

        private Dictionary<string, SOUIViewConfig> uiViewConfigDic = new Dictionary<string, SOUIViewConfig>();

        private Dictionary<UIViewLayer, UIViewLayerController> viewLayerControllerDic = new Dictionary<UIViewLayer, UIViewLayerController>();

        private List<BaseUIView> onShowUIViews = new List<BaseUIView>();

        private Dictionary<string, Queue<BaseUIView>> uiViewCacheDic = new Dictionary<string, Queue<BaseUIView>>();
        public override void InitManager()
        {
            base.InitManager();

            InitViewLayers();
            InitUIViewConfig();
        }

        private void InitViewLayers()
        {
            UIViewLayerController[] layerControllers = GetComponentsInChildren<UIViewLayerController>();
            for(int i = 0; i < layerControllers.Length; i++)
            {
                viewLayerControllerDic.Add(layerControllers[i].viewLayer, layerControllers[i]);
            }
        }

        private void InitUIViewConfig()
        {
            SOUIViewConfig[] uiViewConfigs = Resources.LoadAll<SOUIViewConfig>("ScriptableObjects/UI");
            for (int i = 0; i < uiViewConfigs.Length; i++)
            {
                uiViewConfigDic.Add(uiViewConfigs[i].viewName, uiViewConfigs[i]);
            }
        }

        public BaseUIView ShowUIView(string viewName, params object[] args)
        {
            SOUIViewConfig config = GetUIViewConfig(viewName);
            if (config == null)
                return null;

            BaseUIView view = null;
            if (config.unique)
            {
                for(int i = 0; i < onShowUIViews.Count; i++)
                {
                    if (onShowUIViews[i].uiViewConfig.viewName == viewName)
                    {
                        view = onShowUIViews[i];
                        onShowUIViews.RemoveAt(i);
                        break;
                    }
                }
            }
            if (view == null)
            {
                view = GetViewFromCacheOrCreateNew(config);
            }
            if (view != null)
            {
                view.SetArguments(args);
                onShowUIViews.Add(view);
                viewLayerControllerDic[view.uiViewConfig.viewLayer].PushUIView(view);
            }

            RefreshViewHideState();

            return view;
        }
        public BaseUIView GetOnShowUIView(string viewName)
        {
            foreach(var v in onShowUIViews)
            {
                if(v.uiViewConfig.viewName== viewName)
                {
                    return v;
                }
            }
            return null;
        }
        private SOUIViewConfig GetUIViewConfig(string viewName)
        {
            SOUIViewConfig config = null;
            if (uiViewConfigDic.TryGetValue(viewName, out config))
            {
                return config;
            }
            return null;
        }

        private BaseUIView GetViewFromCacheOrCreateNew(SOUIViewConfig config)
        {
            BaseUIView view = GetViewFromCache(config);

            if (view == null)
            {
                view = GetViewFromCreateNew(config);
            }
            return view;
        }

        private BaseUIView GetViewFromCache(SOUIViewConfig config)
        {
            if (config == null)
                return null;

            BaseUIView view = null;
            if(uiViewCacheDic.TryGetValue(config.viewName, out var caches))
            {
                if (caches != null && caches.Count != 0)
                {
                    view = caches.Dequeue();
                }
            }
            return view;
        }

        private BaseUIView GetViewFromCreateNew(SOUIViewConfig config)
        {
            GameObject obj = GameObject.Instantiate<GameObject>(ResourceManager.GetInstance().Load<GameObject>(config.assetName));
            BaseUIView view = obj.GetComponent<BaseUIView>();
            if (view != null)
            {
                view.Init();
            }
            return view;
        }

        public void HideUIView(BaseUIView view)
        {
            if (view == null)
            {
                return;
            }
            if (view.viewLayerController != null)
            {
                onShowUIViews.Remove(view);
                view.viewLayerController.PopupUIView(view);
                CacheUIViewByScheme(view);
                RefreshViewHideState();
            }
        }

        public void HideAllUIView()
        {
            for(int i = onShowUIViews.Count - 1; i >= 0; i--)
            {
                HideUIView(onShowUIViews[i]);
            }
        }

        private void CacheUIViewByScheme(BaseUIView view)
        {
            if (view != null)
            {
                switch (view.uiViewConfig.cacheScheme)
                {
                    case UIViewCacheScheme.Cache:
                        CacheUIView(view);
                        break;
                    case UIViewCacheScheme.Remove:
                        ReleaseUIview(view);
                        break;
                }
            }
        }

        private void CacheUIView(BaseUIView view)
        {
            if (view == null)
            {
                return;
            }

            Queue<BaseUIView> caches;
            if(!uiViewCacheDic.TryGetValue(view.uiViewConfig.viewName, out caches))
            {
                caches = new Queue<BaseUIView>();
                uiViewCacheDic.Add(view.uiViewConfig.viewName, caches);
            }
            caches.Enqueue(view);
        }

        private void ReleaseUIview(BaseUIView view)
        {
            if (view != null)
            {
                view.OnExit();
                GameObject.Destroy(view.gameObject);
            }
        }

        private void RefreshViewHideState()
        {
            bool covered = false;
            covered = viewLayerControllerDic[UIViewLayer.Debug].RefreshView(covered);
            covered = viewLayerControllerDic[UIViewLayer.Top].RefreshView(covered);
            covered = viewLayerControllerDic[UIViewLayer.Popup].RefreshView(covered);
            covered = viewLayerControllerDic[UIViewLayer.Base].RefreshView(covered);
            covered = viewLayerControllerDic[UIViewLayer.BackGround].RefreshView(covered);
        }
    }
}