/// <summary>
/// 生成一个指定路径的加载器并加载资源
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="url">资源唯一路径</param>
/// <param name="completeHandler">加载完成回调</param>
/// <param name="loadModel">加载模式(同步/异步) default=异步</param>
/// <param name="loadAssetPath">加载资源路径模式(外部/Resources/StreamAsset ) default=ResourcesPath</param>
protected static ByteLoader LoadAssetSync(string url, System.Action <BaseAbstracResourceLoader> onCompleteAct)
{
if (string.IsNullOrEmpty(url))
{
Debug.LogError(string.Format("Url Can't Be Null , TypeLoader={0}", typeof(ByteLoader)));
return(null);
}
bool isLoaderExit = false;
ByteLoader byteLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <ByteLoader>(url, ref isLoaderExit);
byteLoader.m_OnCompleteAct.Add(onCompleteAct);
if (isLoaderExit && byteLoader.IsCompleted)
{
byteLoader.LoadassetModel = LoadAssetModel.Sync; //这里貌似没必要
byteLoader.OnCompleteLoad(byteLoader.IsError, byteLoader.Description, byteLoader.ResultObj, true); //如果当前加载器已经完成加载 则手动触发事件
return(byteLoader);
}//如果当前加载器存在 且已经加载完成已经完成加载 则手动触发事件
if (byteLoader.LoadassetModel == LoadAssetModel.Async)
{
Debug.LogEditorInfor(string.Format("有资源({0})正在异步加载过程中，同时有同步加载请求 ，则之前的加载逻辑作废!! ", url));
byteLoader.ForceBreakLoaderProcess();
}//有一个正在异步加载的加载器运行着
byteLoader.LoadassetModel = LoadAssetModel.Sync;
byteLoader.LoadByteAssetSync(url);
return(byteLoader);
}
/// <summary>
/// (同步)加载材质球资源
/// </summary>
/// <param name="url"></param>
/// <param name="completeHandler"></param>
/// <returns></returns>
protected static MaterialLoader LoadAssetSync(Transform requestTarget, string url, System.Action <BaseAbstracResourceLoader> completeHandler)
{
if (string.IsNullOrEmpty(url))
{
Debug.LogError(string.Format("Url Can't Be Null , TypeLoader={0}", typeof(MaterialLoader)));
return(null);
}
bool isContainLoaders = false;
MaterialLoader materialLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <MaterialLoader>(url, ref isContainLoaders);
materialLoader.m_OnCompleteAct.Add(completeHandler);
materialLoader.AddReference(requestTarget, url);
if (isContainLoaders && materialLoader.IsCompleted)
{
materialLoader.LoadassetModel = LoadAssetModel.Sync; //这里貌似没必要（由于异步加载时候同步加载必定完成了）
materialLoader.OnCompleteLoad(materialLoader.IsError, materialLoader.Description, materialLoader.ResultObj, materialLoader.IsCompleted);
return(materialLoader);
}
if (materialLoader.LoadassetModel == LoadAssetModel.Async)
{
materialLoader.ForceBreakLoaderProcess();
}
materialLoader.m_LoadAssetCoroutine = null;
materialLoader.LoadassetModel = LoadAssetModel.Sync; //这里貌似没必要
materialLoader.LoadMaterialAssetSync(url);
return(materialLoader);
}
/// <summary>
/// (同步)生成一个指定路径的加载器并加载资源
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="url">资源唯一路径</param>
/// <param name="completeHandler">加载完成回调</param>
/// <param name="loadModel">加载模式(同步/异步) default=异步</param>
/// <param name="loadAssetPath">加载资源路径模式(外部/Resources/StreamAsset ) default=ResourcesPath</param>
public static FontLoader LoadFontAssetSync(string url, System.Action <BaseAbstracResourceLoader> completeHandler)
{
if (string.IsNullOrEmpty(url))
{
Debug.LogError(string.Format("Url Can't Be Null , TypeLoader={0}", typeof(FontLoader)));
return(null);
}
bool isContainLoaders = false;
FontLoader fontLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <FontLoader>(url, ref isContainLoaders);
fontLoader.m_OnCompleteAct.Add(completeHandler);
fontLoader.AddReference(null, url);
if (isContainLoaders && fontLoader.IsCompleted)
{
fontLoader.LoadassetModel = LoadAssetModel.Sync; //这里貌似没必要（由于异步加载时候同步加载必定完成了）
fontLoader.OnCompleteLoad(fontLoader.IsError, fontLoader.Description, fontLoader.ResultObj, fontLoader.IsCompleted);
return(fontLoader);
}
if (fontLoader.LoadassetModel == LoadAssetModel.Async)
{
fontLoader.ForceBreakLoaderProcess();
}
fontLoader.LoadassetModel = LoadAssetModel.Sync; //这里貌似没必要（由于异步加载时候同步加载必定完成了）
fontLoader.m_LoadAssetCoroutine = null;
fontLoader.LoadFontAssetSync(url);
return(fontLoader);
}
/// <summary>
/// 加载Texture2D 图片
/// </summary>
/// <param name="url"></param>
/// <param name="completeHandler"></param>
/// <returns></returns>
public static Teture2DLoader LoadTexture2DAssetAsync(Transform requestTarget, string url, System.Action <BaseAbstracResourceLoader> completeHandler)
{
Debug.LogError("TODO Teture2DLoader 还不完善 需要继续测试 ");
if (string.IsNullOrEmpty(url))
{
Debug.LogError(string.Format("Url Can't Be Null , TypeLoader={0}", typeof(Teture2DLoader)));
return(null);
}
bool isContainLoaders = false;
Teture2DLoader texture2DLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <Teture2DLoader>(url, ref isContainLoaders);
texture2DLoader.m_OnCompleteAct.Add(completeHandler);
texture2DLoader.LoadassetModel = LoadAssetModel.Async; //这里貌似没必要（由于异步加载时候同步加载必定完成了）
texture2DLoader.AddReference(requestTarget, url);
if (isContainLoaders)
{
if (texture2DLoader.IsCompleted)
{
texture2DLoader.OnCompleteLoad(texture2DLoader.IsError, texture2DLoader.Description, texture2DLoader.ResultObj, texture2DLoader.IsCompleted);
}
return(texture2DLoader);
}
texture2DLoader.m_LoadAssetCoroutine = EventCenter.Instance.StartCoroutine(texture2DLoader.LoadTexture2DAssetAsync(url));
return(texture2DLoader);
}
/// <summary>
/// (同步)加载.text 文件 并以string 形式返回
/// </summary>
/// <param name="requestTarget">请求加载资源的对象</param>
/// <param name="url"></param>
/// <param name="completeHandler"></param>
/// <returns></returns>
public static TextAssetLoader LoadAssetSync(string url, System.Action <BaseAbstracResourceLoader> completeHandler)
{
if (string.IsNullOrEmpty(url))
{
Debug.LogError(string.Format("Url Can't Be Null , TypeLoader={0}", typeof(TextAsset)));
return(null);
}
bool isContainLoaders = false;
TextAssetLoader textAssetLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <TextAssetLoader>(url, ref isContainLoaders);
textAssetLoader.m_OnCompleteAct.Add(completeHandler);
textAssetLoader.AddReference(null, url);
if (isContainLoaders && textAssetLoader.IsCompleted)
{
textAssetLoader.LoadassetModel = LoadAssetModel.Sync;
textAssetLoader.OnCompleteLoad(textAssetLoader.IsError, textAssetLoader.Description, textAssetLoader.ResultObj, textAssetLoader.IsCompleted);
return(textAssetLoader);
}
if (textAssetLoader.LoadassetModel == LoadAssetModel.Async)
{
textAssetLoader.ForceBreakLoaderProcess();
}
textAssetLoader.LoadassetModel = LoadAssetModel.Sync;
textAssetLoader.m_LoadAssetCoroutine = null;
textAssetLoader.LoadTextAssetSync(url);
return(textAssetLoader);
}
public override void OnCompleteLoad(bool isError, string description, object result, bool iscomplete, float process = 1)
{
if (result != null)
{
ResultObj = null;
}
else
{
if (typeof(AssetBundle) == result.GetType())
{
ResultObj = result as AssetBundle;
}
else
{
Debug.LogInfor("加载场景 未知类型 " + result.GetType());
ResultObj = result;
}
}
base.OnCompleteLoad(isError, description, ResultObj, iscomplete, process);
if (m_BridgeLoader != null)
{
ResourcesLoaderMgr.DeleteLoader(typeof(BridgeLoader), m_ResourcesUrl, false);
}
}
/// <summary>
/// 加载资源的桥连接器 会根据配置路径加载优先级加载资源
/// </summary>
/// <param name="url"></param>
/// <param name="onCompleteAct"></param>
/// <param name="isloadSceneAsset"> 如果加载的是场景资源 则这里必须为true 否则为false</param>
/// <returns></returns>
private static BridgeLoader LoadAssetAsync(string url, System.Action <BaseAbstracResourceLoader> onCompleteAct, bool isloadSceneAsset)
{
if (string.IsNullOrEmpty(url))
{
Debug.LogError(string.Format("Url Can't Be Null , TypeLoader={0}", typeof(BridgeLoader)));
return(null);
}
bool isLoaderExit = false;
BridgeLoader bridgeLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <BridgeLoader>(url, ref isLoaderExit);
bridgeLoader.m_OnCompleteAct.Add(onCompleteAct);
bridgeLoader.m_IsLoadSceneAsset = isloadSceneAsset;
bridgeLoader.LoadassetModel = LoadAssetModel.Async; //这里获得的加载器不需要特殊处理
if (isLoaderExit)
{
if (bridgeLoader.IsCompleted)
{
bridgeLoader.OnCompleteLoad(bridgeLoader.IsError, bridgeLoader.Description, bridgeLoader.ResultObj, true); //如果当前加载器已经完成加载 则手动触发事件
}
return(bridgeLoader); //如果已经存在 且当前加载器还在加载中，则只需要等待加载完成则回调用回调
}
EventCenter.Instance.StartCoroutine(bridgeLoader.LoadAssetByPriorityAsync(url, bridgeLoader, isloadSceneAsset));
EventCenter.Instance.StartCoroutine(bridgeLoader.LoadAssetAsync(url, bridgeLoader));
return(bridgeLoader);
}
/// <summary>
/// WWW 方式异步加载资源
/// </summary>
/// <param name="topPath">资源相对目录前的绝对目录</param>
/// <param name="url">资源相对目录</param>
/// <param name="onCompleteAct"></param>
/// <returns></returns>
public static WWWLoader WWWLoadAsset(string topPath, LoadAssetModel loadModel, string url, System.Action <BaseAbstracResourceLoader> onCompleteAct)
{
if (loadModel != LoadAssetModel.Async)
{
Debug.LogError("WWWLoader 只支持异步加载资源");
return(null);
}
if (string.IsNullOrEmpty(url))
{
Debug.LogError(string.Format("Url Can't Be Null , TypeLoader={0}", typeof(WWWLoader)));
return(null);
}
bool isLoaderExit = false;
Debug.LogInfor("WWWLoadAsset url=" + url);
WWWLoader wwwLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <WWWLoader>(url, ref isLoaderExit);
wwwLoader.m_OnCompleteAct.Add(onCompleteAct);
if (isLoaderExit)
{
if (wwwLoader.IsCompleted)
{
wwwLoader.OnCompleteLoad(wwwLoader.IsError, wwwLoader.Description, wwwLoader.ResultObj, true); //如果当前加载器已经完成加载 则手动触发事件
}
return(wwwLoader); //如果已经存在 且当前加载器还在加载中，则只需要等待加载完成则回调用回调
}
wwwLoader.m_TopPath = topPath;
wwwLoader.m_LoadAssetCoroutine = EventCenter.Instance.StartCoroutine(wwwLoader.LoadAssetAsync(topPath, url, wwwLoader));
return(wwwLoader);
}
/// <summary>
/// 加载精灵图片
/// </summary>
/// <param name="url"></param>
/// <param name="completeHandler"></param>
/// <returns></returns>
protected static PrefabLoader LoadAssetAsync(Transform requestTarget, string url, System.Action <BaseAbstracResourceLoader> completeHandler)
{
if (string.IsNullOrEmpty(url))
{
Debug.LogError(string.Format("Url Can't Be Null , TypeLoader={0}", typeof(PrefabLoader)));
if (completeHandler != null)
{
completeHandler(null);
}
return(null);
}
bool isContainLoaders = false;
PrefabLoader prefabloader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <PrefabLoader>(url, ref isContainLoaders);
prefabloader.m_OnCompleteAct.Add(completeHandler);
prefabloader.LoadassetModel = LoadAssetModel.Async; //这里貌似没必要（由于异步加载时候同步加载必定完成了）
prefabloader.AddReference(requestTarget, url);
if (isContainLoaders)
{
if (prefabloader.IsCompleted)
{
prefabloader.OnCompleteLoad(prefabloader.IsError, prefabloader.Description, prefabloader.ResultObj, prefabloader.IsCompleted);
}
return(prefabloader);
}
prefabloader.m_LoadAssetCoroutine = EventCenter.Instance.StartCoroutine(prefabloader.LoadPrefabAssetAsync(url));
return(prefabloader);
}
/// <summary>
/// 生成一个指定路径的加载器并加载资源
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="url">资源唯一路径</param>
/// <param name="completeHandler">加载完成回调</param>
/// <param name="loadAssetPath">加载资源路径模式(外部/Resources/StreamAsset ) default=ResourcesPath</param>
public static ShaderLoader LoadAssetAsync(string url, System.Action <BaseAbstracResourceLoader> completeHandler)
{
if (string.IsNullOrEmpty(url))
{
Debug.LogError(string.Format("Url Can't Be Null , TypeLoader={0}", typeof(ShaderLoader)));
return(null);
}
bool isContainLoaders = false;
ShaderLoader shaderLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <ShaderLoader>(url, ref isContainLoaders);
shaderLoader.m_OnCompleteAct.Add(completeHandler);
shaderLoader.LoadassetModel = LoadAssetModel.Async; //这里貌似没必要（由于异步加载时候同步加载必定完成了）
shaderLoader.AddReference(null, url);
if (isContainLoaders)
{
if (shaderLoader.IsCompleted)
{
shaderLoader.OnCompleteLoad(shaderLoader.IsError, shaderLoader.Description, shaderLoader.ResultObj, shaderLoader.IsCompleted);
}
return(shaderLoader);
}
shaderLoader.m_LoadAssetCoroutine = EventCenter.Instance.StartCoroutine(shaderLoader.LoadShaderAssetAsync(url));
return(shaderLoader);
}
/// <summary>
/// 加载Resources 资源
/// </summary>
/// <param name="url"></param>
/// <param name="onCompleteAct"></param>
/// <param name="isloadScene"> 如果加载的是场景 则这里必须填true ,否则false</param>
/// <returns></returns>
protected static ResourcesLoader LoadResourcesAssetSync(string url, System.Action <BaseAbstracResourceLoader> onCompleteAct, bool isloadScene = false)
{
if (string.IsNullOrEmpty(url))
{
Debug.LogError(string.Format("Url Can't Be Null , TypeLoader={0}", typeof(WWWLoader)));
return(null);
}
bool isLoaderExit = false;
ResourcesLoader resourcesLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <ResourcesLoader>(url, ref isLoaderExit);
resourcesLoader.m_OnCompleteAct.Add(onCompleteAct);
if (isLoaderExit && resourcesLoader.IsCompleted)
{
resourcesLoader.LoadassetModel = LoadAssetModel.Sync; //这里貌似没必要（由于异步加载时候同步加载必定完成了）
resourcesLoader.OnCompleteLoad(resourcesLoader.IsError, resourcesLoader.Description, resourcesLoader.ResultObj, true); //如果当前加载器已经完成加载 则手动触发事件
return(resourcesLoader); //如果已经存在 且当前加载器还在加载中，则只需要等待加载完成则回调用回调
}
if (resourcesLoader.LoadassetModel == LoadAssetModel.Async)
{
resourcesLoader.ForceBreakLoaderProcess();
}
resourcesLoader.LoadassetModel = LoadAssetModel.Sync; //这里貌似没必要（由于异步加载时候同步加载必定完成了）
resourcesLoader.m_LoadAssetCoroutine = null;
resourcesLoader.LoadAssetSync(url, resourcesLoader);
return(resourcesLoader);
}
/// <summary>
/// （同步）加载声音资源
/// </summary>
/// <param name="requestTarget"></param>
/// <param name="url"></param>
/// <param name="completeHandler"></param>
/// <returns></returns>
protected static AudioLoader LoadAudioClipSync(Transform requestTarget, string url, System.Action <BaseAbstracResourceLoader> completeHandler)
{
if (string.IsNullOrEmpty(url))
{
Debug.LogError(string.Format("Url Can't Be Null , TypeLoader={0}", typeof(AudioLoader)));
return(null);
}
bool isContainLoaders = false;
AudioLoader audiolLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <AudioLoader>(url, ref isContainLoaders);
audiolLoader.m_OnCompleteAct.Add(completeHandler);
audiolLoader.AddReference(requestTarget, url);
if (isContainLoaders && audiolLoader.IsCompleted)
{
audiolLoader.LoadassetModel = LoadAssetModel.Sync;
audiolLoader.OnCompleteLoad(audiolLoader.IsError, audiolLoader.Description, audiolLoader.ResultObj, audiolLoader.IsCompleted);
return(audiolLoader);
}
if (audiolLoader.LoadassetModel == LoadAssetModel.Sync)
{
audiolLoader.ForceBreakLoaderProcess();
}
audiolLoader.LoadassetModel = LoadAssetModel.Sync;
audiolLoader.m_LoadAssetCoroutine = null;
audiolLoader.LoadAudioClicpAssetSync(url);
return(audiolLoader);
}
public override void OnCompleteLoad(bool isError, string description, object result, bool iscomplete, float process = 1)
{
base.OnCompleteLoad(isError, description, result, iscomplete, process);
ResultObj = result as Shader;
if (m_BridgeLoader != null)
{
ResourcesLoaderMgr.DeleteLoader(typeof(BridgeLoader), m_ResourcesUrl, false);
}
}
public static void UnLoadAsset(string url, bool isForceDelete = false)
{
ResourcesLoader resourcesLoader = ResourcesLoaderMgr.GetExitLoaderInstance <ResourcesLoader>(url);
if (resourcesLoader == null)
{
return;
}
resourcesLoader.ReduceReference(resourcesLoader, isForceDelete);
}
/// <summary>
/// 卸载指定的资源
/// </summary>
/// <param name="url"></param>
/// <param name="requestTarget">为null 则卸载加载时候请求的对象</param>
public static void UnLoadAsset(string url, bool isForceDelete = false)
{
TextAssetLoader textAssetLoader = ResourcesLoaderMgr.GetExitLoaderInstance <TextAssetLoader>(url);
if (textAssetLoader == null)
{
//Debug.LogError("无法获取指定类型的加载器 " + typeof(TextAssetLoader));
return;
}
textAssetLoader.ReduceReference(textAssetLoader, isForceDelete);
}
/// <summary>
/// 同步加载资源 (这里处理的是最外层的AssetBundle ,当前资源依赖的AssetBundle 处理在LoadDepdenceAssetBundleAsync)
/// </summary>
/// <param name="url"></param>
protected void LoadAssetBundleSync(string url, string assetFileName, AssetBundleExitState assetBundleState, bool isloadScene)
{
m_ResourcesUrl = url;
if (System.IO.Path.GetExtension(m_ResourcesUrl) != ConstDefine.AssetBundleExtensionName)
{
m_ResourcesUrl += ConstDefine.AssetBundleExtensionName; //组合上扩展名
}
#region 加载依赖的资源
string[] dependenceAssets = AssetBundleMgr.Instance.S_AssetBundleManifest.GetAllDependencies(m_ResourcesUrl); //获取所有的依赖文件
List <NewAssetBundleLoader3> allDependenceAssetLoader = new List <NewAssetBundleLoader3>(); //所有依赖文件的加载器
foreach (var item in dependenceAssets)
{
bool isLoaderExit = false;
NewAssetBundleLoader3 subAssetBundleLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <NewAssetBundleLoader3>(item, ref isLoaderExit);
if (isLoaderExit && subAssetBundleLoader.IsCompleted)
{
Debug.LogEditorInfor("LoadAssetBundleASync Exit ," + item);
continue; //已经存在了 则继续
}
allDependenceAssetLoader.Add(subAssetBundleLoader);
LoadDepdenceAssetBundleSync(item, subAssetBundleLoader, assetBundleState);
} //递归加载资源的依赖项
for (int dex = 0; dex < allDependenceAssetLoader.Count; ++dex)
{
if (allDependenceAssetLoader[dex].IsError)
{
Debug.LogError("[AssetBundleLoader] LoadAssetBundleSync Fail, 依赖的 AssetBundle 资源不存在 " + allDependenceAssetLoader[dex].m_ResourcesUrl);
OnCompleteLoad(false, string.Format("[AssetBundleLoader] LoadAssetBundle Fail,AssetBundle Path= {0}", allDependenceAssetLoader[dex].m_ResourcesUrl), null, true);
break;
}
} //判断依赖项是否加载完成
#endregion
#region AssetBundle 同步加载
AssetLoaderResultInfor.LoadedAssetBundle = AssetBundle.LoadFromFile(S_AssetBundleTopPath + m_ResourcesUrl);
if (AssetLoaderResultInfor.LoadedAssetBundle == null)
{
ResultObj = null;
OnCompleteLoad(true, string.Format("同步加载本地AssetBundle 失败{0}", url), null, true, 1);
return;
}
LoadAndRecordAsset(AssetLoaderResultInfor, assetBundleState, isloadScene);
OnCompleteLoad(AssetLoaderResultInfor.LoadedAssetBundle == null, string.Format("[AssetBundleLoader] LoadAssetBundleSuccess {0}", m_ResourcesUrl), null, true);
#endregion
Debug.LogInfor("加载AssetBundle 成功");
}
/// <summary>
/// 减少引用计数 (新增在减少引用计数的时候 如果资源没有加载完 则强制结束并释放资源)
/// </summary>
/// <param name="loader"></param>
/// <param name="isForcesDelete"></param>
public virtual void ReduceReference(BaseAbstracResourceLoader loader, bool isForcesDelete)
{
if (loader.IsCompleted == false)
{
Debug.LogEditorInfor(string.Format("资源(TypeLoader={0})在加载过程中被中断 url={1}", this.GetType(), m_ResourcesUrl));
isForcesDelete = true;
loader.ForceBreakLoaderProcess();
} //被中断的加载器
--ReferCount;
if (ReferCount <= 0 || isForcesDelete)
{
ResourcesLoaderMgr.DeleteLoader(loader.GetType(), m_ResourcesUrl, false);
}//引用计数为0时候开始回收资源
}
public static void UnLoadAsset(string url, object requestTarget = null)
{
MaterialLoader materialLoader = ResourcesLoaderMgr.GetExitLoaderInstance <MaterialLoader>(url);
if (materialLoader == null)
{
//Debug.LogError("无法获取指定类型的加载器 " + typeof(materialLoader));
return;
}
if (requestTarget == null)
{
requestTarget = materialLoader.m_RequesterTarget;
}
materialLoader.ReduceReference(materialLoader, false);
}
/// <summary>
/// （同步加载）加载AssetBundle 资源
/// </summary>
/// <param name="url">相对于AseetBundle 资源存放路径的路径 (如果是打包成整个预制体则是整个预制体的路径)</param>
/// <param name="assetFileName">实际加载AssetBundle 时候的文件名称(考虑到加载整个AssetBundle 中一个资源的情况)</param>
/// <param name="onCompleteAct">加载完成回调</param>
/// <param name="isloadSceneAsset"> 如果加载的是场景 则这里必须填true ,否则false</param>
/// <returns></returns>
private static NewAssetBundleLoader3 LoadAssetBundleAssetSync(string url, string assetFileName, AssetBundleExitState assetBundleState, bool isloadSceneAsset)
{
if (string.IsNullOrEmpty(url))
{
Debug.LogError(string.Format("Url Can't Be Null , TypeLoader={0}", typeof(NewAssetBundleLoader3)));
return(null);
}
if (assetBundleState == AssetBundleExitState.None)
{
Debug.LogError("LoadAssetBundleAssetSync Fail,Not AssetBundle Asset" + url + " assetFileName=" + assetFileName);
return(null);
}
Debug.LogInfor("LoadAssetBundleAsset url=" + url + " assetFileName=" + assetFileName);
bool isLoaderExit = false;
NewAssetBundleLoader3 assetBundleLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <NewAssetBundleLoader3>(url, ref isLoaderExit);
if (isLoaderExit && assetBundleLoader.IsCompleted)
{
assetBundleLoader.LoadassetModel = LoadAssetModel.Sync;
//*** 判断当前资源是否加载了
if (string.IsNullOrEmpty(assetFileName) == false && assetBundleLoader.AssetLoaderResultInfor.m_AllNeedLoadAssetRecord.Contains(assetFileName) == false)
{
assetBundleLoader.AssetLoaderResultInfor.m_AllNeedLoadAssetRecord.Add(assetFileName);
}
assetBundleLoader.LoadAndRecordAsset(assetBundleLoader.AssetLoaderResultInfor, assetBundleState, isloadSceneAsset); //加载已经加载的AssetBundle 中的资源
assetBundleLoader.OnCompleteLoad(assetBundleLoader.IsError, assetBundleLoader.Description, null, true); //如果当前加载器已经完成加载 则手动触发事件
return(assetBundleLoader); //如果已经存在 且当前加载器还在加载中，则只需要等待加载完成则回调用回调
}
if (assetBundleLoader.LoadassetModel == LoadAssetModel.Async)
{
assetBundleLoader.ForceBreakLoaderProcess();
} //结束之前的加载进程
assetBundleLoader.LoadassetModel = LoadAssetModel.Sync;
assetBundleLoader.AssetLoaderResultInfor.SetAssetName(url, assetBundleState);
assetBundleLoader.m_LoadAssetCoroutine = null;
if (string.IsNullOrEmpty(assetFileName) == false)
{
assetBundleLoader.AssetLoaderResultInfor.m_AllNeedLoadAssetRecord.Add(assetFileName);
}
assetBundleLoader.LoadAssetBundleSync(url, assetFileName, assetBundleState, isloadSceneAsset);
return(assetBundleLoader);
}
/// <summary>
/// 加载AssetBundle 资源
/// </summary>
/// <param name="url">相对于AseetBundle 资源存放路径的路径 (如果是打包成整个预制体则是整个预制体的路径)</param>
/// <param name="assetFileName">实际加载AssetBundle 时候的文件名称(考虑到加载整个AssetBundle 中一个资源的情况)</param>
/// <param name="onCompleteAct">加载完成回调</param>
/// <param name="isloadSceneAsset"> 如果加载的是场景 则这里必须填true ,否则false</param>
/// <returns></returns>
private static NewAssetBundleLoader3 LoadAssetBundleAssetAsync(string url, string assetFileName, AssetBundleExitState assetBundleState, bool isloadSceneAsset)
{
if (string.IsNullOrEmpty(url) || string.IsNullOrEmpty(assetFileName))
{
Debug.LogError(string.Format("Url Can't Be Null , TypeLoader={0}", typeof(NewAssetBundleLoader3)));
return(null);
}
if (assetBundleState == AssetBundleExitState.None)
{
Debug.LogError("LoadAssetBundleAssetSync Fail,Not AssetBundle Asset" + url + " assetFileName=" + assetFileName);
return(null);
}
Debug.LogInfor("LoadAssetBundleAsset url=" + url + " assetFileName=" + assetFileName);
bool isLoaderExit = false;
NewAssetBundleLoader3 assetBundleLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <NewAssetBundleLoader3>(url, ref isLoaderExit);
assetBundleLoader.LoadassetModel = LoadAssetModel.Async; //这里貌似没必要（由于异步加载时候同步加载必定完成了）
if (isLoaderExit)
{
if (assetBundleLoader.IsCompleted)
{
assetBundleLoader.LoadAndRecordAsset(assetBundleLoader.AssetLoaderResultInfor, assetBundleState, isloadSceneAsset);
assetBundleLoader.OnCompleteLoad(assetBundleLoader.IsError, assetBundleLoader.Description, null, true); //如果当前加载器已经完成加载 则手动触发事件
}
else
{
assetBundleLoader.AssetLoaderResultInfor.m_AllNeedLoadAssetRecord.Add(assetFileName); //记录需要加载这个指定的资源
}
return(assetBundleLoader); //如果已经存在 且当前加载器还在加载中，则只需要等待加载完成则回调用回调
}
assetBundleLoader.AssetLoaderResultInfor.SetAssetName(url, assetBundleState);
assetBundleLoader.AssetLoaderResultInfor.m_AllNeedLoadAssetRecord.Add(assetFileName); //记录需要加载这个指定的资源
assetBundleLoader.m_LoadAssetCoroutine = EventCenter.Instance.StartCoroutine(assetBundleLoader.LoadAssetBundleASync(url, assetFileName, assetBundleState, isloadSceneAsset));
return(assetBundleLoader);
}
/// <summary>
/// 同步加载资源
/// </summary>
/// <param name="url"></param>
/// <param name="onCompleteAct"></param>
/// <param name="isloadSceneAsset"></param>
/// <returns></returns>
private static BridgeLoader LoadAssetSync(string url, System.Action <BaseAbstracResourceLoader> onCompleteAct, bool isloadSceneAsset)
{
if (string.IsNullOrEmpty(url))
{
Debug.LogError(string.Format("Url Can't Be Null , TypeLoader={0}", typeof(BridgeLoader)));
return(null);
}
bool isLoaderExit = false;
BridgeLoader bridgeLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <BridgeLoader>(url, ref isLoaderExit);
bridgeLoader.m_OnCompleteAct.Add(onCompleteAct);
bridgeLoader.m_IsLoadSceneAsset = isloadSceneAsset;
if (isLoaderExit && bridgeLoader.IsCompleted)
{
bridgeLoader.LoadassetModel = LoadAssetModel.Sync;
bridgeLoader.OnCompleteLoad(bridgeLoader.IsError, bridgeLoader.Description, bridgeLoader.ResultObj, true); //如果当前加载器已经完成加载 则手动触发事件
return(bridgeLoader); //如果已经存在 且当前加载器还在加载中，则只需要等待加载完成则回调用回调
}
if (bridgeLoader.LoadassetModel == LoadAssetModel.Async)
{
bridgeLoader.ForceBreakLoaderProcess();
}
bridgeLoader.LoadassetModel = LoadAssetModel.Sync;
#if UNITY_EDITOR
if (Application.isPlaying == false)
{
bridgeLoader.LoadAssetByPriority_Editor(url, bridgeLoader, isloadSceneAsset);
bridgeLoader.LoadAssetSync(url, bridgeLoader);
return(bridgeLoader);
}//编辑器下非运行状态特殊处理
#endif
bridgeLoader.LoadAssetByPrioritySync(url, bridgeLoader, isloadSceneAsset);
bridgeLoader.LoadAssetSync(url, bridgeLoader);
return(bridgeLoader);
}
/// <summary>
/// (异步)生成一个指定路径的加载器并加载资源
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="url">资源唯一路径</param>
/// <param name="completeHandler">加载完成回调</param>
/// <param name="loadModel">加载模式(同步/异步) default=异步</param>
/// <param name="loadAssetPath">加载资源路径模式(外部/Resources/StreamAsset ) default=ResourcesPath</param>
protected static ByteLoader LoadAssetAsync(string url, System.Action <BaseAbstracResourceLoader> onCompleteAct)
{
if (string.IsNullOrEmpty(url))
{
Debug.LogError(string.Format("Url Can't Be Null , TypeLoader={0}", typeof(ByteLoader)));
return(null);
}
bool isLoaderExit = false;
ByteLoader byteLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <ByteLoader>(url, ref isLoaderExit);
byteLoader.m_OnCompleteAct.Add(onCompleteAct);
byteLoader.LoadassetModel = LoadAssetModel.Async; //这里貌似没必要（由于异步加载时候同步加载必定完成了）
if (isLoaderExit)
{
if (byteLoader.IsCompleted)
{
byteLoader.OnCompleteLoad(byteLoader.IsError, byteLoader.Description, byteLoader.ResultObj, true); //如果当前加载器已经完成加载 则手动触发事件
}
return(byteLoader); //如果已经存在 且当前加载器还在加载中，则只需要等待加载完成则回调用回调
}
byteLoader.LoadByteAssetASync(url);
return(byteLoader);
}
public static void UnLoadScene(string url)
{
ResourcesLoaderMgr.DeleteLoader(typeof(SceneLoader), url, true);
}
/// <summary>
/// 加载当前AssetBundle 依赖的资源(注意 ： 这里加载成功之后不能直接生成)
/// </summary>
/// <param name="url"></param>
/// <param name="assetBundleLoade"></param>
/// <returns></returns>
protected virtual IEnumerator LoadDepdenceAssetBundleAsync(string url, NewAssetBundleLoader3 depdebceAssetBundleLoader)
{
Debug.Log("LoadDepdenceAssetBundleAsync url=" + url);
depdebceAssetBundleLoader.m_ResourcesUrl = url;
if (System.IO.Path.GetExtension(depdebceAssetBundleLoader.m_ResourcesUrl) != ConstDefine.AssetBundleExtensionName)
{
depdebceAssetBundleLoader.m_ResourcesUrl += ConstDefine.AssetBundleExtensionName; //组合上扩展名
}
string[] dependenceAssets = AssetBundleMgr.Instance.S_AssetBundleManifest.GetAllDependencies(depdebceAssetBundleLoader.m_ResourcesUrl); //获取所有的依赖文件
List <NewAssetBundleLoader3> allDependenceAssetLoader = new List <NewAssetBundleLoader3>(); //所有依赖文件的加载器
foreach (var item in dependenceAssets)
{
bool isLoaderExit = false;
NewAssetBundleLoader3 subAssetBundleLoader = ResourcesLoaderMgr.GetOrCreateLoaderInstance <NewAssetBundleLoader3>(item, ref isLoaderExit);
if (isLoaderExit && subAssetBundleLoader.IsCompleted)
{
Debug.LogEditorInfor("LoadDepdenceAssetBundleAsync Exit ," + item);
continue;
}
allDependenceAssetLoader.Add(subAssetBundleLoader);
Debug.Log("LoadDepdenceAssetBundleAsync allDependenceAssetLoader item=" + item);
EventCenter.Instance.StartCoroutine(LoadDepdenceAssetBundleAsync(item, subAssetBundleLoader));
} //递归加载资源的依赖项
for (int dex = 0; dex < allDependenceAssetLoader.Count; ++dex)
{
while (allDependenceAssetLoader[dex].IsCompleted == false)
{
yield return(null);
}
if (allDependenceAssetLoader[dex].IsError)
{
Debug.LogError("[AssetBundleLoader] LoadDepdenceAssetBundleAsync Fail, 依赖的 AssetBundle " + url + " 资源不存在 " + allDependenceAssetLoader[dex].m_ResourcesUrl);
OnCompleteLoadDepdenceAsset(allDependenceAssetLoader[dex], false,
string.Format("[AssetBundleLoader] LoadAssetBundle Fail,AssetBundle Path={0}" + allDependenceAssetLoader[dex].m_ResourcesUrl), null, true);
yield break;
}
} //判断依赖项是否加载完成
#region AssetBundleCreateRequest 加载
string fileAbsolutelyPath = string.Format("{0}{1}", S_AssetBundleTopPath, url); //当先需要下载的资源的绝对路径
AssetBundleCreateRequest request = AssetBundle.LoadFromFileAsync(fileAbsolutelyPath);
yield return(request);
if (request.isDone)
{
Debug.Log("LoadDepdenceAssetBundleAsync Success depdebceAssetBundleLoader.m_ResourcesUrl=" + depdebceAssetBundleLoader.m_ResourcesUrl);
depdebceAssetBundleLoader.AssetLoaderResultInfor.LoadedAssetBundle = request.assetBundle;
}
else
{
depdebceAssetBundleLoader.AssetLoaderResultInfor.LoadedAssetBundle = null;
Debug.LogError("LoadDepdenceAssetBundleAsync FailAA== " + url);
Debug.LogError("LoadDepdenceAssetBundleAsync Failbb== " + fileAbsolutelyPath);
}
depdebceAssetBundleLoader.OnCompleteLoad(depdebceAssetBundleLoader.AssetLoaderResultInfor.LoadedAssetBundle == null, string.Format("[AssetBundleLoader] Load DepdenceAssetBundel Success {0}", depdebceAssetBundleLoader.m_ResourcesUrl), null, true);
#endregion
//Debug.LogInfor("加载AssetBundle 成功");
yield break;
}
