/// <summary>
/// 协同打开UI。
/// </summary>
/// <returns>The callback open UI.</returns>
private IEnumerator <int> AyncCallbackOpenUI()
{
UIInfoData uiInfoData = null;
UnityEngine.Object prefab = null;
GameObject uiObject = null;
if (stackOpenUI != null && stackOpenUI.Count > 0)
{
do
{
uiInfoData = stackOpenUI.Pop();
prefab = Singleton <ResourceManager> .Instance.LoadPrefab(uiInfoData.Path);
if (prefab != null)
{
uiObject = NGUITools.AddChild(Game.Instance.UiRoot, prefab as GameObject);
GUIBase baseUi = uiObject.GetComponent <GUIBase>();
if (baseUi != null)
{
baseUi.SetUIWhenOpening(uiInfoData.UIObjParams);
}
allOpenUIDic.Add(uiInfoData.UIKey, uiObject);
}
} while (stackOpenUI.Count > 0);
}
yield return(0);
}
public bool ShowUI(UIInfoData infoData, OnOpenUIDelegate delOpenUI = null, object param = null)
{
//已经显示了
if (UILayerManager.Instance.IsUIShow(infoData))
{
Debug.Log("ShowUI :" + infoData.name + " already showed!");
return(true);
}
int refCount = AddLoadDicRefCount(infoData.name);
//已经在加载
if (refCount > 1)
{
return(true);
}
//从缓存里面找，如果找到了，则直接进行显示
if (UILayerManager.Instance.IsConatain(infoData))
{
Debug.Log("ShowUI :" + infoData.name + " already exist!");
GameObject uiGameObject = UILayerManager.Instance.GetUI(infoData);
DoAddUI(infoData, uiGameObject, delOpenUI, param);
return(true);
}
m_Instance.LoadUI(infoData, delOpenUI, param);
return(true);
}
private IEnumerator <int> asyncLoadData()
{
UIInfoData uiInfoData = null;
UnityEngine.Object prefabObj = null;
GameObject uiObj = null;
if (stackOpenUIs != null && stackOpenUIs.Count > 0)
{
do
{
uiInfoData = stackOpenUIs.Pop();
//prefabObj = Resources.Load(uiInfoData.Path);
prefabObj = ResManager.Instance.Load(uiInfoData.Path);
if (prefabObj != null)
{
uiObj = GameObject.Instantiate(prefabObj) as GameObject;
BaseUI baseUI = uiObj.GetComponent <BaseUI>();
if (baseUI == null)
{
baseUI = uiObj.AddComponent(uiInfoData.Scripts) as BaseUI;
}
if (null != baseUI)
{
baseUI.SetUIWhenOPening(uiInfoData.UIparams);
}
dicOpenUIs.Add(uiInfoData.UIType, uiObj);
}
}while (stackOpenUIs.Count > 0);
}
yield return(0);
}
public virtual ShowUIResult ShowUI(UIInfoData uiData, GameObject curWindow)
{
ShowUIResult result = ShowUIResult.ErrorNotShowed;
if (addedUIs.ContainsKey(uiData.name))
{
if (addedUIs[uiData.name].activeSelf == false)
{
addedUIs[uiData.name].SetActive(true);
result = ShowUIResult.ShowedFromDeactive;
}
else
{
result = ShowUIResult.ShowedDuplicate;
}
}
else
{
GameObject newWindow = GameObject.Instantiate(curWindow, Vector3.zero, Quaternion.identity, attachedParent) as GameObject;
if (null != newWindow)
{
newWindow.transform.localScale = Vector3.one;
addedUIs.Add(uiData.name, newWindow);
result = ShowUIResult.ShowedFromNotExist;
}
}
return(result);
}
private IEnumerator <int> AsyncLoadData()
{
UIInfoData uiInfoData = null;
UnityEngine.Object prefab = null;
GameObject uiObj = null;
if (stackOpenUIs != null && stackOpenUIs.Count > 0)
{
do
{
uiInfoData = stackOpenUIs.Pop();
prefab = Resources.Load(uiInfoData.Path);
if (null != prefab)
{
uiObj = MonoBehaviour.Instantiate(prefab) as GameObject;
BaseUI baseUI = uiObj.GetComponent <BaseUI>();
if (null != baseUI)
{
baseUI.SetUIWhenOpening();
}
else
{
baseUI = uiObj.AddComponent(uiInfoData.ScriptType) as BaseUI;
}
dicOpenUIs.Add(uiInfoData.UIType, uiObj);
}
} while (stackOpenUIs.Count > 0);
}
yield return(0);
}
private IEnumerator <int> AsyncLoadData()
{
UIInfoData _uiInfoData = null;
UnityEngine.Object _prefabObj = null;
GameObject _uiObject = null;
if (stackOpenUIs != null && stackOpenUIs.Count > 0)
{
do
{
_uiInfoData = stackOpenUIs.Pop();
_prefabObj = Resources.Load(_uiInfoData.Path);
if (_prefabObj != null)
{
//_uiObject = NUGITools.AddChild(Game.Instance.mainUICamera.gameObject,_prefabObj);
_uiObject = MonoBehaviour.Instantiate(_prefabObj) as GameObject;
BaseUI _baseUI = _uiObject.GetComponent <BaseUI>();
if (_baseUI == null)
{
_baseUI = _uiObject.AddComponent(_uiInfoData.ScriptType) as BaseUI;
}
else
{
_baseUI.SetUIWhenOpening(_uiInfoData.UIparams);
}
dicOpenUIs.Add(_uiInfoData.UIType, _uiObject);
}
} while(stackOpenUIs.Count > 0);
}
yield return(0);
}
public UILayer.ShowUIResult ShowUI(UIInfoData uiData, GameObject curWindow)
{
if (null != curWindow && null != m_UILayers[(int)uiData.uiType])
{
return(m_UILayers[(int)uiData.uiType].ShowUI(uiData, curWindow));
}
return(UILayer.ShowUIResult.ErrorNotShowed);
}
public UILayer.DestroyUIResult CloseUI(UIInfoData uiData)
{
if (null != m_UILayers[(int)uiData.uiType])
{
return(m_UILayers[(int)uiData.uiType].CloseUI(uiData.name));
}
return(UILayer.DestroyUIResult.NotHaveUI);
}
void DoLoadUIItem(IInfoData iData, GameObject curItem, object fun, object param)
{
UIInfoData uiData = iData as UIInfoData;
if (null != fun)
{
OnLoadUIItemDelegate delLoadItem = fun as OnLoadUIItemDelegate;
delLoadItem(curItem, param);
}
}
public bool IsUIShow(UIInfoData pathData)
{
bool result = m_UILayers[(int)pathData.uiType].addedUIs.ContainsKey(pathData.name);
if (result)
{
result = m_UILayers[(int)pathData.uiType].addedUIs[pathData.name].activeSelf;
}
return(result);
}
/// <summary>
/// 关闭UI，根据类型不同，触发不同行为
/// </summary>
/// <param name="pathData"></param>
public void CloseUI(UIInfoData pathData)
{
if (null == m_Instance)
{
return;
}
///删除记录的逻辑
RemoveLoadDicRefCount(pathData.name);
UILayerManager.Instance.CloseUI(pathData);
}
private IEnumerator <int> AsyncLoadData()
{
UIInfoData _uiInfoData = null;
UnityEngine.Object _prefabObj = null;
GameObject _uiObject = null;
if (stackOpenUIs != null && stackOpenUIs.Count > 0)
{
do
{
GameObject obj = null;
_uiInfoData = stackOpenUIs.Pop();
_prefabObj = Resources.Load(_uiInfoData.Path);
if (_prefabObj != null)
{
if (_prefabObj as GameObject)
{
obj = (GameObject)_prefabObj;
}
_uiObject = NGUITools.AddChild(cameraSP.gameObject, _prefabObj as GameObject);
BaseUI _baseUI = _uiObject.GetComponent <BaseUI>();
if (null == _baseUI)
{
_baseUI = _uiObject.AddComponent(_uiInfoData.ScriptType) as BaseUI;
}
if (null != _baseUI)
{
_baseUI.SetUIWhenOpening(cameraBG, _uiInfoData.UIParams);//把背景相机传过去，让UI内部更好的处理背景，把Y轴的位置信息传递过去，让UI自己处理
}
else
{
Debug.Log("_baseUI是空的");
}
dicOpenUIs.Add(_uiInfoData.UIType, _uiObject);
}
else
{
//Debug.Log("_prefabObj是空的");
}
}while (stackOpenUIs.Count > 0);
}
yield return(0);
}
private IEnumerator <int> AsyncLoadData()
{
UIInfoData _uiInfoData = null;
UnityEngine.Object _prefabObj = null;
GameObject _uiObject = null;
GameObject _uiParent = null;
if (stackOpenUIs != null && stackOpenUIs.Count > 0)
{
do
{
_uiInfoData = stackOpenUIs.Pop();
_uiParent = _uiInfoData.Parent;
_prefabObj = Resources.Load(_uiInfoData.Path);
if (_prefabObj != null)
{
//_uiObject = NGUITools.AddChild(Game.Instance.mainUICamera.gameObject, _prefabObj as GameObject);
_uiObject = MonoBehaviour.Instantiate(_prefabObj) as GameObject;
if (null != UIRootObj)
{
if (null == _uiParent)
{
_uiObject.transform.SetParent(UIRootObj.transform);
_uiObject.transform.localScale = Vector3.one;
_uiObject.GetComponent <Canvas>().worldCamera = UICamera;
}
else
{
_uiObject.transform.parent = _uiParent.transform;
_uiObject.transform.localScale = Vector3.one;
}
}
BaseUI _baseUI = _uiObject.GetComponent <BaseUI>();
if (null == _baseUI)
{
_baseUI = _uiObject.AddComponent(_uiInfoData.ScriptType) as BaseUI;
}
if (null != _baseUI)
{
_baseUI.SetUIWhenOpening(_uiInfoData.UIParams);
}
dicOpenUIs.Add(_uiInfoData.UIType, _uiObject);
}
} while(stackOpenUIs.Count > 0);
}
yield return(0);
}
/// <summary>
/// Opens the U.
/// </summary>
/// <param name="uiType">User interface type.</param>
public void OpenUI(EnumUIType uiType)
{
// 如果要打开的界面处于等待关闭状态，那么直接从等待管理状态中删除
if (_waitCloseUIs.Contains(uiType))
{
_waitCloseUIs.Remove(uiType);
return;
}
UIInfoData uiInfoData = _dicUiInfoDatas[uiType];
GameObject uiObject;
// 界面没有真正销毁，只是出于隐藏状态
if (_hideUIs.TryGetValue(uiType, out uiObject))
{
uiInfoData.IsHide = true;
// 需要关闭那些界面
var _closeUiTypes = uiInfoData.CloseUiTypes;
if (_closeUiTypes != null)
{
_waitCloseUIs.AddRange(_closeUiTypes);
}
_waitOpenUIs.Enqueue(uiType);
return;
}
// 如果尚未打开该UI
if (!_openedUIs.TryGetValue(uiType, out uiObject))
{
// 需要关闭那些界面
var _closeUiTypes = uiInfoData.CloseUiTypes;
if (_closeUiTypes != null)
{
_waitCloseUIs.AddRange(_closeUiTypes);
}
// 放入等待打开UI堆栈中
_waitOpenUIs.Enqueue(uiType);
// TODO xxxx
}
else
{
Debug.LogError("已经处于打开状态了：" + uiType);
}
}
private IEnumerator <int> AsyncLoadData()
{
UIInfoData _uiInfoData = null;
UnityEngine.Object _uiprefab = null;
GameObject _uiObject = null;
if (stackOpenUIs != null && stackOpenUIs.Count > 0)
{
do
{
_uiInfoData = stackOpenUIs.Pop();
_uiprefab = Resources.Load(_uiInfoData.Path);
if (_uiprefab != null)
{
_uiObject = MonoBehaviour.Instantiate(_uiprefab) as GameObject;
if (_uiObject == null)
{
yield break;
}
RectTransform rt = _uiObject.GetComponent <RectTransform>();
BaseUI _baseui = _uiObject.GetComponent <BaseUI>();
if (_baseui != null)
{
_baseui.SetUIWhenOpening(_uiInfoData.UIparams);
}
else
{
_baseui = _uiObject.AddComponent(_uiInfoData.ScriptType) as BaseUI;
}
Transform layer = uiContainer.FindChild(_baseui.GetUILayer().ToString());
rt.SetParent(layer, false);
dicOpenUIs.Add(_uiInfoData.UIType, _uiObject);
}
else
{
Debug.Log(" 当前路径不存在 " + _uiInfoData.Path);
}
} while (stackOpenUIs.Count > 0);
}
yield return(0);
}
private IEnumerator <int> AsyncLoadData(string loadPath = null)
{
UIInfoData _uiInfoData = null;
UnityEngine.Object _prefabObj = null;
GameObject _uiObject = null;
if (stackOpenUIs != null && stackOpenUIs.Count > 0)
{
do
{
_uiInfoData = stackOpenUIs.Pop();
_prefabObj = Resources.Load(_uiInfoData.Path);
if (_prefabObj != null)
{
//_uiObject = NGUITools.AddChild(Game.Instance.mainUICamera.gameObject, _prefabObj as GameObject);
_uiObject = MonoBehaviour.Instantiate(_prefabObj) as GameObject;
if (loadPath != null)
{
Vector3 rotTemp = _uiObject.transform.localScale;
Vector3 posTem = _uiObject.transform.localPosition;
_uiObject.transform.parent = GameObject.Find(loadPath).transform;//加载预制件的路径
//_uiObject.transform.
_uiObject.transform.localScale = rotTemp;
_uiObject.transform.localPosition = posTem;
}
_uiObject.transform.localPosition = new Vector3();
BaseUI _baseUI = _uiObject.GetComponent <BaseUI>();
if (null == _baseUI)
{
_baseUI = _uiObject.AddComponent(_uiInfoData.ScriptType) as BaseUI;
}
if (null != _baseUI)
{
_baseUI.SetUIWhenOpening(_uiInfoData.UIParams);
}
dicOpenUIs.Add(_uiInfoData.UIType, _uiObject);
}
} while (stackOpenUIs.Count > 0);
}
yield return(0);
}
public BaseUIModule Register(EnumUIType uiType)
{
BaseUIModule uiModule;
if (dicModules.TryGetValue(uiType, out uiModule))
{
// 已注册的，就返回null，防止数据模型层返回初始化
Debug.Log("已经注册过了：" + uiType);
return(null);
}
UIInfoData uiInfoData = UIManager.Instance.DicUiInfoDatas[uiType];
if (uiInfoData.UiModuleType != null)
{
uiModule = System.Activator.CreateInstance(uiInfoData.UiModuleType) as BaseUIModule;
dicModules.Add(uiType, uiModule);
return(uiModule);
}
return(uiModule);
}
private IEnumerator <int> AsyncLoadData()
{
UIInfoData _uiInfoData = null;
UnityEngine.Object _prefabObj = null;
GameObject _uiObject = null;
if (stackOpenUIs != null && stackOpenUIs.Count > 0)
{
do
{
_uiInfoData = stackOpenUIs.Pop();
if (dicOpenUIsCache.ContainsKey(_uiInfoData.UIType))
{
dicOpenUIsCache[_uiInfoData.UIType].SetActive(true);
dicOpenUIs.Add(_uiInfoData.UIType, _uiObject);
break;
}
_prefabObj = Resources.Load(_uiInfoData.Path);
if (_prefabObj != null)
{
_uiObject = MonoBehaviour.Instantiate(_prefabObj, canvas.transform) as GameObject;
dicOpenUIsCache.Add(_uiInfoData.UIType, _uiObject);
BaseUI _baseUI = _uiObject.GetComponent <BaseUI>();
if (null == _baseUI)
{
_baseUI = _uiObject.AddComponent(_uiInfoData.ScriptType) as BaseUI;
}
if (null != _baseUI)
{
_baseUI.SetUIWhenOpening(_uiInfoData.UIParams);
}
dicOpenUIs.Add(_uiInfoData.UIType, _uiObject);
}
} while (stackOpenUIs.Count > 0);
}
yield return(0);
}
void DoAddUI(IInfoData iData, GameObject curWindow, object fun, object param)
{
UIInfoData uiData = iData as UIInfoData;
Debug.Log("DoAddUI:" + uiData.name);
if (!m_dicWaitLoad.Remove(uiData.name))
{
DestroyBundle(uiData.name);
return;
}
UILayer.ShowUIResult showUIResult = UILayerManager.Instance.ShowUI(uiData, curWindow);
if (showUIResult != UILayer.ShowUIResult.ErrorNotShowed)
{
if (null != fun)
{
OnOpenUIDelegate delOpenUI = fun as OnOpenUIDelegate;
delOpenUI(curWindow != null, param);
}
}
}
/// <summary>
/// 协程 加载UI
/// </summary>
/// <returns></returns>
private IEnumerator <int> AsyncLoadData()
{
UIInfoData _uiInfoData = null;
UnityEngine.Object _prefabObj = null;
GameObject _uiObject = null;
if (stackOpenUIs != null && stackOpenUIs.Count > 0)
{
do
{
_uiInfoData = stackOpenUIs.Pop();
_prefabObj = Resources.Load(_uiInfoData.Path);
if (_prefabObj != null)
{
//_uiObject = NGUITools.AddChild(Game.Instance.mainUICamera.gameObject, _prefabObj as GameObject);
_uiObject = MonoBehaviour.Instantiate(_prefabObj) as GameObject;
BaseUI _baseUI = _uiObject.GetComponent <BaseUI>();
if (null == _baseUI)
{
_baseUI = _uiObject.AddComponent(_uiInfoData.ScriptType) as BaseUI;
}
// 自动注册指定UGUI
AutoInjectUGUI(_baseUI);
// 根据打开参数，View加载UI相关数据:比如音乐、动画等
if (null != _baseUI)
{
_baseUI.SetUIWhenOpening(_uiInfoData.UIParams);
}
dicOpenUIs.Add(_uiInfoData.UIType, _uiObject);
}
} while(stackOpenUIs.Count > 0);
}
yield return(0);
}
private IEnumerator <int> AsyncLoadData()
{
UIInfoData uiInfoData = null;
UnityEngine.Object prefabObj = null;
GameObject uiObject = null;
if (UIInfoStacks != null && UIInfoStacks.Count > 0)
{
do
{
uiInfoData = UIInfoStacks.Pop();
prefabObj = ResManager.Instance.Load(uiInfoData.Path);
if (prefabObj != null)
{
uiObject = ResManager.Instance.Instantiate(prefabObj) as GameObject;
string name = "";
if (uiInfoData.UITag == null)
{
name = uiInfoData.UIType;
}
else
{
List <string> tags;
if (!UIType_Tags.TryGetValue(uiInfoData.UIType, out tags))
{
tags = new List <string>();
}
tags.Add(uiInfoData.UITag);
UIType_Tags.Add(uiInfoData.UIType, tags);
name = string.Format("{0}_{1}", uiInfoData.UIType, uiInfoData.UITag);
}
uiObject.name = name;
GameObject fatherNode = null;
UIObject_FatherNodes.TryGetValue(uiInfoData.UIType, out fatherNode);
if (fatherNode != null)
{
uiObject.transform.SetParent(fatherNode.transform, false);
}
UIBase ui = uiObject.GetComponent <UIBase>();
if (ui == null)
{
throw new Exception("Error:On GetComponent<UIBase> in Instantiate GameObject is null!");
}
if (ui != null)
{
ui.SetUIWhenOpening(uiInfoData.UIParams);
ui.Display();
}
UIObject_Pool.Add(name, uiObject);
}
} while (UIInfoStacks.Count > 0);
}
yield return(0);
}
/// <summary>
/// 加载UI资源，实例化，并且挂载对应的BaseUI子类组件
/// </summary>
/// <returns></returns>
private IEnumerator _OpenUIAsync(EnumUIType uiType)
{
yield return(null);
// TODO 初始化模型层
BaseUIModule baseUiModule = UIModuleManager.Instance.Register(uiType);
if (baseUiModule != null)
{
// 数据模型初始化加载
baseUiModule.OnRegister();
yield return(null);
}
UIInfoData uiInfoData = _dicUiInfoDatas[uiType];
BaseUI baseUi = null;
GameObject uiObject = null;
#if UNITY_EDITOR
// TODO 处理开发阶段，可能不使用预制体的情况
baseUi = UnityEngine.Object.FindObjectOfType(uiInfoData.UiViewType) as BaseUI;
if (baseUi != null)
{
Debug.LogError("开发者模式下找到了对应的UI");
uiObject = baseUi.gameObject;
}
if (baseUi == null)
{
#endif
if (uiInfoData.IsHide) // 如果从隐藏状态改变
{
uiInfoData.IsHide = false;
if (_hideUIs.TryGetValue(uiType, out uiObject))
{
_hideUIs.Remove(uiType);
// 初始化View层
if (uiInfoData.UiViewType != null)
{
// 查找UI对应的BaseUI子类组件
baseUi = uiObject.GetComponent <BaseUI>();
}
}
}
else // 预制体创建
{
uiObject = ResManager.Instance.InstanceAssetObject(uiInfoData.UiAssetName) as GameObject;
if (uiObject == null)
{
Debug.LogError("无法加载对应的UI资源：" + uiInfoData.UiAssetName);
yield break;
}
// 初始化View层
if (uiInfoData.UiViewType != null)
{
// 查找UI对应的BaseUI子类组件
baseUi = uiObject.GetComponent <BaseUI>();
if (baseUi == null)
{
// 如果没有挂载BaseUI子类组件，自动挂载
baseUi = uiObject.AddComponent(uiInfoData.UiViewType) as BaseUI;
}
}
}
#if UNITY_EDITOR
}
#endif
_openedUIs.Add(uiType, uiObject);
if (baseUi != null)
{
yield return(null);
baseUi.UiModule = baseUiModule;
baseUi.OnShow();
}
}
public bool IsConatain(UIInfoData pathData)
{
return(m_UILayers[(int)pathData.uiType].addedUIs.ContainsKey(pathData.name));
}
public GameObject GetUI(UIInfoData pathData)
{
return(m_UILayers[(int)pathData.uiType].addedUIs[pathData.name]);
}
/// <summary>
/// 根据uidata加载对应的ui资源
/// </summary>
void LoadUI(UIInfoData uiData, object delOpenUI = null, object param = null)
{
StartCoroutine(BundleManager.Instance.LoadUI(uiData, DoAddUI, delOpenUI, param));
}
void LoadUIItem(UIInfoData uiData, OnLoadUIItemDelegate delLoadItem, object param = null, bool IsLoadItem = false)
{
StartCoroutine(BundleManager.Instance.LoadUI(uiData, DoLoadUIItem, delLoadItem, param));
}
public bool LoadItem(UIInfoData pathData, OnLoadUIItemDelegate delLoadItem, object param = null, bool IsLoadItem = false)
{
LoadUIItem(pathData, delLoadItem, param, IsLoadItem);
return(true);
}
