IndieGame/client/Assets/Ether/Scripts/Module/UI/UIManager.cs

360 lines
11 KiB
C#
Raw Normal View History

2024-10-11 10:12:15 +08:00
/********************************************************************
: UIManager.cs
:
: 1982614048@qq.com
: 2024/03/29 17:28:19
:
: 2024/04/03 15:10:11
:
*********************************************************************/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.Accessibility;
using UnityEngine.UI;
namespace Ether
{
public class UIManager : SingletonAutoMono<UIManager>
{
[HideInInspector]
public GameObject MainCanvas; //主画布
List<Transform> tierList = new List<Transform>(); //所有的层级
//所有打开的界面
private DictionaryEx<string, FrameBase> allOpenFrames = new DictionaryEx<string, FrameBase>();
//所有界面需要保存的数据
private DictionaryEx<string, FrameData> allFrameData = new DictionaryEx<string, FrameData>();
private LinkedSequence<string> frameOpenStack = new LinkedSequence<string>();
private LinkedSequence<string> windowOpenStack = new LinkedSequence<string>();
public override void Init()
{
Clear();
MainCanvas = EntityManager.Inst.GetEntity("MainCanvas").gameObject;
CheckMainCanvasLayer();
}
#region
/// <summary>
/// 检查MainCanvas下的层级
/// </summary>
private void CheckMainCanvasLayer()
{
tierList.Clear();
//获取当前Canvas下所有的物体
int childNum = MainCanvas.transform.childCount;
Transform[] childTrans = new Transform[childNum];
for (int i = 0; i < childNum; i++)
{
childTrans[i] = MainCanvas.transform.GetChild(i);
}
//动态创建UI层级
string[] frameLayers = CommonTools.GetAllEnumName<FrameTier>();
foreach (string layer in frameLayers)
{
if (string.IsNullOrEmpty(layer))
{
continue;
}
Transform trans = MainCanvas.transform.Find(layer);
if (trans == null)
{
trans = new GameObject(layer, typeof(RectTransform)).transform;
trans.SetParent(MainCanvas.transform, false);
RectTransform rectTrans = trans.GetComponent<RectTransform>();
rectTrans.anchorMin = new Vector2(0, 0);
rectTrans.anchorMax = new Vector2(1, 1);
rectTrans.anchoredPosition = Vector2.zero;
rectTrans.sizeDelta = Vector2.zero;
}
tierList.Add(trans);
trans.SetAsLastSibling();
}
//设置Canvas下之前的物体层级到最上层
foreach (Transform trans in childTrans)
{
trans.SetAsLastSibling();
}
}
/// <summary>
/// 获取层级
/// </summary>
public Transform GetTier(int tierIndex)
{
if (tierList.Count <= tierIndex)
{
Debug.LogError($"没有该层级:{tierIndex},请检查配置");
return null;
}
return tierList[tierIndex];
}
/// <summary>
/// 获取层级
/// </summary>
public Transform GetTier(FrameTier tier)
{
int tierIndex = (int)tier;
if (tierList.Count <= tierIndex)
{
Debug.LogError($"没有该层级:{tier},请检查配置");
return null;
}
return tierList[tierIndex];
}
#endregion
/// <summary>
/// 循环
/// </summary>
private void Update()
{
float deltaTime = Time.deltaTime;
foreach (var viewPair in allOpenFrames)
{
FrameBase frame = viewPair.Value;
if (frame.IsActive)
{
frame.OnUpdate(deltaTime);
}
}
}
/// <summary>
/// 打开界面
/// </summary>
/// <param name="framName"></param>
public void OpenFrame(string framName, FrameData openFrameData = null, Action callback = null)
{
Type frameType = CommonTools.GetType(framName);
OpenFrame(framName, frameType, callback, openFrameData);
}
/// <summary>
/// 打开界面
/// </summary>
/// <typeparam name="T"></typeparam>
public void OpenFrame<T>(FrameData openFrameData = null, Action callback = null) where T : FrameBase
{
string name = typeof(T).Name;
OpenFrame(name, typeof(T), callback, openFrameData);
}
/// <summary>
/// 打开界面
/// </summary>
/// <param name="name"></param>
/// <param name="type"></param>
private void OpenFrame(string name, Type type, Action callback = null, FrameData openFrameData = null)
{
FrameBase frame;
if (allOpenFrames.ContainsKey(name))
{
frame = allOpenFrames[name];
frame.SetVisible(false);
}
else
{
frame = (FrameBase)Activator.CreateInstance(type);
allOpenFrames.Add(name, frame);
}
if (openFrameData == null)
{
if (allFrameData.ContainsKey(name))
{
openFrameData = allFrameData[name];
}
}
else
{
if (allFrameData.ContainsKey(name))
{
allFrameData[name] = openFrameData;
}
else
{
allFrameData.Add(name, openFrameData);
}
}
frame.SetVisible(true, callback, openFrameData);
switch (frame.UIElement.frameType)
{
case FrameType.Frame:
frameOpenStack.Add(name);
string str = "当前打开的界面 ";
foreach (var node in frameOpenStack)
{
str += node.Value + " ";
}
Debug.Log(str);
//全屏界面打开时关闭所有窗口界面
foreach (var node in windowOpenStack)
{
CloseFrame(node.Value);
}
break;
case FrameType.Window:
windowOpenStack.Add(name);
string winStr = "当前打开的窗口 ";
foreach (var node in windowOpenStack)
{
winStr += node.Value + " ";
}
Debug.Log(winStr);
break;
case FrameType.Pop:
break;
default:
break;
}
}
/// <summary>
/// 关闭界面
/// </summary>
/// <typeparam name="T"></typeparam>
public void CloseFrame<T>(Action callback = null) where T : FrameBase
{
string name = typeof(T).Name;
CloseFrame(name, callback);
}
/// <summary>
/// 关闭界面
/// </summary>
/// <param name="frameName"></param>
public void CloseFrame(string frameName, Action callback = null)
{
if (allOpenFrames.ContainsKey(frameName))
{
FrameBase frame = allOpenFrames[frameName];
frame.SetVisible(false, callback);
allOpenFrames.Remove(frameName);
}
frameOpenStack.Remove(frameName);
}
/// <summary>
/// 获取界面资源
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="frame"></param>
/// <returns></returns>
public GameObject GetFrameRes<T>(T frame) where T : FrameBase
{
Type viewType = typeof(T);
UIElement element = frame.UIElement;
if (element != null && !string.IsNullOrEmpty(element.prefabPath))
{
GameObject obj = LoaderTools.LoadGameObjectAndInstantiateAsync(element.prefabPath, GetTier(element.tier));
if (obj == null)
{
Debug.LogErrorFormat("加载Frame Prefab失败:{0}", element.prefabPath);
return null;
}
obj.AddComponent<Canvas>();
obj.AddComponent<CanvasGroup>();
obj.AddComponent<GraphicRaycaster>();
return obj;
}
else
{
Debug.LogErrorFormat("当前Frame:{0}没有对应的Prefab路径请添加入配置", viewType);
return null;
}
}
/// <summary>
/// 获取界面
/// </summary>
public T GetFrame<T>() where T : FrameBase
{
string name = typeof(T).Name;
if (allOpenFrames.TryGetValue(name, out FrameBase frameBase))
{
return frameBase as T;
}
return null;
}
/// <summary>
/// 是否开启
/// </summary>
public bool IsOpen<T>() where T : FrameBase
{
return GetFrame<T>() != null;
}
/// <summary>
/// 窗口聚焦
/// </summary>
public void FocusWindow(string name)
{
var node = windowOpenStack[name];
node.SetAsLastSibling();
}
/// <summary>
/// 返回
/// </summary>
public void BackFrame(string name, FrameType frameType)
{
switch (frameType)
{
case FrameType.Frame:
frameOpenStack.Remove(name);
if (frameOpenStack.Count > 0)
{
OpenFrame(frameOpenStack.Last().Value);
}
break;
case FrameType.Window:
frameOpenStack.Remove(name);
break;
case FrameType.Pop:
break;
default:
break;
}
}
/// <summary>
/// 清理
/// </summary>
public override void Clear()
{
tierList.Clear();
frameOpenStack.Clear();
windowOpenStack.Clear();
foreach (var frameNodePair in allOpenFrames)
{
frameNodePair.Value.Close();
}
}
}
}