/// <summary>
/// 根据类型加载sprite,不是异步,不提供回调函数参数
/// </summary>
/// <param name="resType">从哪里加载</param>
/// <param name="assetPath"></param>
/// isRecycleOnDestroy : 当ResLoader被销毁时是否从内存中释放
/// <returns></returns>
public Sprite LoadSpriteSync(string assetPath, ResFromType resType, bool DestroyCache = false)
{
if (CheckNoCanLoad())
{
AFLogger.e("此Loader已经被释放,请注意!");
return(null);
}
return(LoadSync <Sprite>(resType, assetPath, true, DestroyCache));
}
public ResFromType GetResFrom(string path)
{
ResFromType resFromType = ResFromType.ResourcesRes;
if (path.Contains("Assets/") && path.Contains("."))
{
resFromType = ResFromType.ABRes;
}
return(resFromType);
}
/// <summary>
/// 预加载
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="resType"></param>
/// <param name="assetPath"></param>
/// <param name="count"></param>
/// <param name="clear"></param>
public void PreLoadObj <T>(ResFromType resType, string assetPath, int count = 1, bool clear = false) where T : Object
{
if (CheckNoCanLoad())
{
AFLogger.e("此Loader已经被释放,请注意!");
return;
}
for (int i = 0; i < count; i++)
{
ObjLoadInfo objLoadInfo = ObjLoadInfo.Allocate(resType, assetPath, null, false);
ResManager.Instance.PreLoadObj(objLoadInfo);
objLoadInfo.Recycle2Cache();
}
}
public void Open(int UITag, string UIPath, UIDataParent UIDataParent = null, ResFromType resFromType = ResFromType.ABRes,
UIPanelParent ParentPanel = null)
{
this.UITag = UITag;
this.resFromType = resFromType;
this.ParentPanel = ParentPanel;
this.UIPath = UIPath;
if (!isInit)
{
TransformBind();
InitUI(UIDataParent);
RegisterUIEvent();
isInit = true;
}
InitUIAll(UIDataParent);
}
public static ObjLoadInfo Allocate(ResFromType resType, string assetPath, Transform ObjParentTrans,
bool mclear = false, LoadResPriority loadResPriority = LoadResPriority.RES_NUM,
Action <bool, ResInfo> loadResCall = null, Action <bool, ResObject> loadObjCall = null)
{
ObjLoadInfo objLoadInfo = SafeObjectPool <ObjLoadInfo> .Instance.Allocate();
objLoadInfo.mCRC = Crc32.GetCrc32(assetPath);
objLoadInfo.mResFromType = resType;
objLoadInfo.ObjParentTrans = ObjParentTrans;
objLoadInfo.mClear = mclear;
objLoadInfo.mResPath = assetPath;
objLoadInfo.loadResPriority = loadResPriority;
objLoadInfo.loadResCall = loadResCall;
objLoadInfo.loadObjCall = loadObjCall;
return(objLoadInfo);
}
/// <summary>
/// 这里的mListen与调用loader传的参数并不相同
/// </summary>
/// <param name="resType"></param>
/// <param name="assetPath"></param>
/// <param name="isSprite"></param>
/// <param name="mListen"></param>
/// <returns></returns>
public static ResLoadInfo Allocate(ResFromType resType, string assetPath, bool isSprite,
Action <bool, ResInfo> mListen = null, Action <bool, ResInfo> mRealListener = null, bool DestroyCache = false,
LoadResPriority loadResPriority = LoadResPriority.RES_NUM)
{
ResLoadInfo resLoadInfo = SafeObjectPool <ResLoadInfo> .Instance.Allocate();
resLoadInfo.mResPath = assetPath;
resLoadInfo.mResFromType = resType;
resLoadInfo.mListener = mListen;
resLoadInfo.mIsSprite = isSprite;
resLoadInfo.DestroyCache = DestroyCache;
resLoadInfo.loadResPriority = loadResPriority;
resLoadInfo.mCRC = Crc32.GetCrc32(assetPath);
resLoadInfo.mRealListener = mRealListener;
return(resLoadInfo);
}
/// <summary>
/// 同步加载Prefab,返回其实例化的GameObject
/// </summary>
/// <param name="resType"></param>
/// <param name="assetPath"></param>
/// <param name="parTrans"></param>
/// <param name="bClear"></param>
/// <returns></returns>
public GameObject InstantiateObjectSync(ResFromType resType, string assetPath, Transform parTrans = null, bool bClear = true)
{
if (CheckNoCanLoad())
{
AFLogger.e("此Loader已经被释放,请注意!");
return(null);
}
ObjLoadInfo objLoadInfo = ObjLoadInfo.Allocate(resType, assetPath, parTrans, bClear);
GameObject objAsset = ResManager.Instance.InstantiateObjectSync(objLoadInfo);
if (objAsset != null)
{
//加载完成后添加到加载资源列表中
mObjList.AddValue(objAsset.GetInstanceID());
}
objLoadInfo.Recycle2Cache();
return(objAsset);
}
/// <summary>
/// 同步加载资源,这里不提供进度
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="resType">从哪里加载</param>
/// <param name="assetPath"></param>
/// <param name="isSprite">是否是加载Sprite</param>
/// isRecycleOnDestroy : 当ResLoader被销毁时是否从内存中释放
/// <returns></returns>
public T LoadSync <T>(ResFromType resType, string assetPath, bool isSprite = false,
bool DestroyCache = false)
where T : Object
{
if (CheckNoCanLoad())
{
AFLogger.e("此Loader已经被释放,请注意!");
return(null);
}
ResLoadInfo resLoadInfo = ResLoadInfo.Allocate(resType, assetPath, isSprite, null, null, DestroyCache);
Object resAsset = ResManager.Instance.LoadSync(resLoadInfo);
if (resAsset != null)
{
//加载完成后添加到加载资源列表中
mResList.AddValue(resLoadInfo.mResPath);
}
resLoadInfo.Recycle2Cache();
return(resAsset as T);
}
//此方法可用来创建panel,也可以刷新panel(不能重复创建panel),重复创建一般是子面板,在父面板中调用创建子面板方法即可
public T OpenUI <T>(int UITag, Transform parent, UIDataParent UIDataParent = null,
bool isClear = false) where T : UIPanelParent
{
AFUIAttribute uiAttri = GetClassData(UITag).Attribute as AFUIAttribute;
string scriptsName = typeof(T).ToString();
if (ScriptsNameToPanel.ContainsKey(scriptsName) && ScriptsNameToPanel[scriptsName].JudgePath(uiAttri.UIPath))
{
ScriptsNameToPanel[scriptsName].transform.SetParent(parent);
ScriptsNameToPanel[scriptsName].RefreshUIByData(UIDataParent);
if (!UITagToScriptsName.ContainsKey(UITag))
{
UITagToScriptsName[UITag] = scriptsName;
}
ScriptsNameToPanel[scriptsName].Show();
//显示
return(ScriptsNameToPanel[scriptsName] as T);
}
ResFromType resFromType = GetResFrom(uiAttri.UIPath);
GameObject panel = resLoader.InstantiateObjectSync(resFromType, uiAttri.UIPath, parent, isClear);
T scripts = panel.GetComponent <T>();
if (scripts == null)
{
scripts = panel.AddComponent <T>();
}
scripts.Open(UITag, uiAttri.UIPath, UIDataParent, resFromType);
if (ScriptsNameToPanel.ContainsKey(scriptsName))
{
ScriptsNameToPanel[scriptsName] = scripts as UIPanelParent;
}
else
{
ScriptsNameToPanel.Add(scriptsName, scripts as UIPanelParent);
}
UITagToScriptsName[UITag] = scriptsName;
return(scripts);
}
/// <summary>
/// 异步加载Prefab
/// </summary>
/// <param name="resType"></param>
/// <param name="assetPath"></param>
/// <param name="parTrans"></param>
/// <param name="loadObjFinish"></param>
/// <param name="loadResPriority"></param>
/// <param name="bClear"></param>
public void InstantiateObjectASync(ResFromType resType, string assetPath, System.Action <bool, ResObject> loadObjFinish,
Transform parTrans = null, LoadResPriority loadResPriority = LoadResPriority.RES_NUM,
bool bClear = true)
{
if (CheckNoCanLoad())
{
AFLogger.e("此Loader已经被释放,请注意!");
return;
}
ObjLoadInfo objLoadInfo = ObjLoadInfo.Allocate(resType, assetPath, parTrans, bClear, loadResPriority,
AsyncObjCallBack, loadObjFinish);
if (mAsyncLoadingObjDic.ContainsKey(assetPath))
{
mAsyncLoadingObjDic[assetPath].Add(objLoadInfo);
}
else
{
AsyncCount += 1;
mAsyncLoadingObjDic.AddValue(assetPath, objLoadInfo);
ResManager.Instance.InstantiateObjectASync(objLoadInfo);
}
}
/// <summary>
/// 异步加载
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="resType"></param>
/// <param name="assetPath"></param>
/// <param name="loadFinish"></param>
/// <param name="isSprite"></param>
/// <param name="DestroyCache">当ResLoader被销毁时是否从内存中释放</param>
/// <param name="loadResPriority">加载的优先级</param>
public void LoadAsync <T>(ResFromType resType, string assetPath, System.Action <bool, ResInfo> loadFinish,
bool isSprite = false, bool DestroyCache = false, LoadResPriority loadResPriority = LoadResPriority.RES_NUM)
where T : Object
{
if (CheckNoCanLoad())
{
AFLogger.e("此Loader已经被释放,请注意!");
return;
}
ResLoadInfo resLoadInfo = ResLoadInfo.Allocate(resType, assetPath, isSprite, AsyncResCallBack, loadFinish, DestroyCache);
//添加回调函数
if (mAsyncLoadingResDic.ContainsKey(resLoadInfo.mResPath))
{
mAsyncLoadingResDic[resLoadInfo.mResPath].Add(resLoadInfo);
}
else
{
AsyncCount += 1;
mAsyncLoadingResDic.AddValue(resLoadInfo.mResPath, resLoadInfo);
ResManager.Instance.LoadAsync(resLoadInfo);
}
}
public void OnRecycled()
{
IsRecycled = true;
mResPath = null;
mResFromType = ResFromType.None;
}
public void PreLoadRes <T>(ResFromType resType, string assetPath, bool isSprite = false) where T : Object
{
LoadSync <T>(resType, assetPath, isSprite, false);
}
