public object LoadAsset(string assetPath, LoadMode mode)
{
if (string.IsNullOrEmpty(assetPath))
{
throw new ArgumentNullException("invalid path");
}
string absolutePath = GetAbsolutePath(assetPath, mode);
string assetName = Path.GetFileNameWithoutExtension(absolutePath);
string internalAssetName = GetInternalAssetName(absolutePath, assetName);
while (true)
{
LoadAssetInfo info = GetLoadingAssetInfo(absolutePath, assetName);
if (info == null)
{
break;
}
}
if (m_Holder.HasAsset(internalAssetName))
{
return(m_Holder.GetAsset(internalAssetName));
}
object asset = m_Loader.LoadAsset(absolutePath, mode);
m_Holder.AddAsset(internalAssetName, asset);
return(asset);
}
private void OnResourceLoaderLoadAssetComplete(LoadAssetCompleteEventArgs args)
{
IsLoading = false;
LoadAssetInfo info = (LoadAssetInfo)m_LoadingInfos.First.Value;
m_LoadingInfos.RemoveFirst();
if (args.AssetName.Equals(info.AssetName))
{
string internalAssetName = GetInternalAssetName(info.AssetPath, info.AssetName);
if (args.Asset != null)
{
m_Holder.AddAsset(internalAssetName, args.Asset);
}
LoadAssetCompleteEventArgs completeEventArgs = new LoadAssetCompleteEventArgs(args.AssetName, args.Asset, args.Error, info.UserData);
if (info.Handler != null)
{
info.Handler(completeEventArgs);
}
if (OnAssetLoaded != null)
{
OnAssetLoaded(completeEventArgs);
}
}
else
{
throw new DrbException("internal error");
}
CheckLoad();
}
/// <summary>
/// 取消加载
/// 如果正在加载中 加载成功之后会卸载，同时回调也不会触发
/// </summary>
/// <param name="requestId"></param>
/// <returns></returns>
public static void CancelLoadAssetAsync(int requestId)
{
LoadAssetInfo loadAssetInfo = GetLoadAssetInfo(requestId);
if (loadAssetInfo == null)
{
return;
}
// 等待加载状态中 直接回收(如果不回收将会先加载在卸载)
if (loadAssetInfo.step == LoadAssetStep.LoadWait)
{
RecoveryLoadAssetInfo(loadAssetInfo);
}
else
{
PendingLoadAssetInfo pendingLoadAssetInfo = _pendingLoadAssetInfoList[loadAssetInfo.bundleName];
// 资源还未加载 因为在加载依赖的bundle
if (pendingLoadAssetInfo != null)
{
// 取消依赖加载bundle
RequestLoadBundle.CancelLoadBundleAsync(pendingLoadAssetInfo.reqeustId);
RecoveryPendingLoadAssetInfo(pendingLoadAssetInfo);
// 这时资源还未加载 直接回收
RecoveryLoadAssetInfo(loadAssetInfo);
}
}
}
/// <summary>
/// 进入加载
/// </summary>
/// <param name="loadAssetInfo"></param>
private static void EnterLoading(LoadAssetInfo loadAssetInfo)
{
loadAssetInfo.step = LoadAssetStep.Loading;
if (ResourceManager.isLog)
{
Debug.Log("loadAsset step 3 EnterLoading : " + loadAssetInfo.assetName);
}
}
/// <summary>
/// 进入加载回调
/// </summary>
/// <param name="loadAssetInfo"></param>
private static void EnterWaitCall(LoadAssetInfo loadAssetInfo)
{
loadAssetInfo.step = LoadAssetStep.WaitCall;
if (ResourceManager.isLog)
{
Debug.Log("loadAsset step 4 EnterWaitCall : " + loadAssetInfo.assetName);
}
}
/// <summary>
/// 进入等待加载
/// </summary>
/// <param name="loadAssetInfo"></param>
private static void EnterLoadWait(LoadAssetInfo loadAssetInfo)
{
loadAssetInfo.step = LoadAssetStep.LoadWait;
if (ResourceUtil.isLog)
{
Debug.Log("loadAsset step 1 EnterLoadWait : " + loadAssetInfo.assetName);
}
}
/// <summary>
/// 进入依赖加载
/// </summary>
/// <param name="loadAssetInfo"></param>
private static void EnterLoadDepend(LoadAssetInfo loadAssetInfo)
{
loadAssetInfo.step = LoadAssetStep.LoadDepend;
if (ResourceManager.isLog)
{
Debug.Log("loadAsset step 2 EnterLoadDepend : " + loadAssetInfo.assetName);
}
}
/// <summary>
/// 异步加载资源
/// </summary>
/// <param name="assetName">资源名</param>
private static void LoadAssetAsync(LoadAssetInfo loadAssetInfo)
{
AssetBundle assetBundle = ReferenceBundle.GetAssetBundle(loadAssetInfo.bundleName);
string assetInBundleName = BundleAsset.GetAssetInBundleName(loadAssetInfo.assetName);
AssetBundleRequest request = assetBundle.LoadAssetAsync(assetInBundleName);
loadAssetInfo.request = request;
EnterLoading(loadAssetInfo);
}
/// <summary>
/// 异步加载资源
/// </summary>
/// <param name="assetName">需要加载的资源路径</param>
/// <param name="onLoadAsset">加载成功之后的回调</param>
/// <returns>请求Id</returns>
public static int LoadAssetAsync(string assetName, OnLoadAsset onLoadAsset)
{
// 回调不存在不允加载
if (onLoadAsset == null)
{
GameLogger.LogError("[资源加载错误] 加载函数回调不能为空，加载后也没有引用");
return(0);
}
// 资源对应bundle名
string abName = BundleAsset.GetBundleName(assetName);
if (abName == null)
{
GameLogger.LogError("[资源加载错误] 找不到资源 ", assetName);
return(0);
}
// 获取请求ID
int requestId = ResourceManager.GetRequestId();
LoadAssetInfo loadAssetInfo = GetTempLoadAssetInfo();
loadAssetInfo.requestId = requestId;
loadAssetInfo.assetName = assetName;
loadAssetInfo.onLoadAsset = onLoadAsset;
loadAssetInfo.bundleName = abName;
EnterLoadWait(loadAssetInfo);
// 1 asset是否已加载
if (ReferenceObject.IsObjectCreate(loadAssetInfo.assetName))
{
EnterWaitCall(loadAssetInfo);
}
// 2 bundle是否已加载
else if (!ReferenceBundle.IsAssetBundleCraete(abName))
{
PushPending(loadAssetInfo);
}
// 3 从bundle加载资源
else
{
List <LoadAssetInfo> loadingAssetList = GetLoadAssetStateList(LoadAssetStep.Loading);
if (loadingAssetList.Count < _frameLoadMaxCount)
{
LoadAssetAsync(loadAssetInfo);
}
}
_loadAssetInfoList.Add(loadAssetInfo);
return(requestId);
}
//更新加载资源
private void UpdateLoadAssetInfos()
{
if (m_LoadAssetInfos.Count > 0)
{
int count = 0;
for (index = 0; index < m_LoadAssetInfos.Count && count < m_LoadAssetCountPerFrame;)
{
LoadAssetInfo loadAssetInfo = m_LoadAssetInfos[index];
float elapseSeconds = (float)(DateTime.Now - loadAssetInfo.StartTime).TotalSeconds;
if (elapseSeconds >= loadAssetInfo.DelaySeconds)
{
UnityEngine.Object asset = null;
#if UNITY_EDITOR
if (loadAssetInfo.AssetType != null)
{
asset = UnityEditor.AssetDatabase.LoadAssetAtPath(loadAssetInfo.AssetName, loadAssetInfo.AssetType);
}
else
{
asset = UnityEditor.AssetDatabase.LoadMainAssetAtPath(loadAssetInfo.AssetName);
}
#endif
if (asset != null)
{
if (loadAssetInfo.LoadAssetCallbacks.LoadAssetSuccessCallback != null)
{
loadAssetInfo.LoadAssetCallbacks.LoadAssetSuccessCallback.Invoke(loadAssetInfo.AssetName, asset, elapseSeconds, loadAssetInfo.UserData);
}
}
else
{
if (loadAssetInfo.LoadAssetCallbacks.LoadAssetFailureCallback != null)
{
loadAssetInfo.LoadAssetCallbacks.LoadAssetFailureCallback.Invoke(loadAssetInfo.AssetName, LoadResourceStatus.NotExist, "Can not load this asset from asset database.", loadAssetInfo.UserData);
}
}
m_LoadAssetInfos.RemoveAt(index); //移除
count++; //加载的数量+1
}
else
{
index++; //进行下一次循环
if (loadAssetInfo.LoadAssetCallbacks.LoadAssetUpdateCallback != null)
{
loadAssetInfo.LoadAssetCallbacks.LoadAssetUpdateCallback.Invoke(loadAssetInfo.AssetName, elapseSeconds / loadAssetInfo.DelaySeconds, loadAssetInfo.UserData);
}
}
}
}
}
/// <summary>
/// 获取一个临时asset加载信息
/// </summary>
/// <returns></returns>
private static LoadAssetInfo GetTempLoadAssetInfo()
{
LoadAssetInfo assetInfo = null;
if (_freeLoadAssetInfoList.Count > 0)
{
assetInfo = _freeLoadAssetInfoList[0];
_freeLoadAssetInfoList.RemoveAt(0);
}
else
{
assetInfo = new LoadAssetInfo();
}
return(assetInfo);
}
/// <summary>
///依赖bundle加载状态
/// </summary>
/// <param name="loadAssetInfo"></param>
private static void PushPending(LoadAssetInfo loadAssetInfo)
{
EnterLoadDepend(loadAssetInfo);
string bundleName = loadAssetInfo.bundleName;
if (!_pendingLoadAssetInfoList.ContainsKey(bundleName))
{
// 加载bundle
int abRequestId = ResourceUtils.CreateAssetBundleAsync(bundleName, OnLoadPeningBundle);
PendingLoadAssetInfo pendingInfo = new PendingLoadAssetInfo();
pendingInfo = GetTempPendingLoadAssetInfo();
pendingInfo.reqeustId = abRequestId;
pendingInfo.bundleName = bundleName;
_pendingLoadAssetInfoList.Add(bundleName, pendingInfo);
}
}
public void LoadAsync(string assetName, IResLoadListener listener)
{
for (int i = 0; i < mInLoads.Count; i++)
{
if (mInLoads[i].assetName == assetName)
{
if (!mInLoads[i].listeners.Contains(listener))
{
mInLoads[i].listeners.Add(listener);
}
return;
}
}
ResourceRequest request = Resources.LoadAsync(assetName);
LoadAssetInfo load = new LoadAssetInfo(request, assetName);
load.listeners.Add(listener);
mInLoads.Add(load);
}
public object LoadAssetFromAssetBundle(string assetBundlePath, string assetName, LoadMode mode)
{
if (string.IsNullOrEmpty(assetBundlePath))
{
throw new ArgumentNullException("invalid path");
}
string assetBundleAbsolutePath = GetAbsolutePath(assetBundlePath, mode);
string internalAssetName = GetInternalAssetName(assetBundleAbsolutePath, assetName);
while (true)
{
LoadAssetInfo info = GetLoadingAssetInfo(assetBundleAbsolutePath, assetName);
if (info == null)
{
break;
}
}
if (m_Holder.HasAsset(internalAssetName))
{
return(m_Holder.GetAsset(internalAssetName));
}
object assetBundle = null;
if (m_Holder.HasAssetBundle(assetBundleAbsolutePath))
{
assetBundle = m_Holder.GetAssetBundle(assetBundleAbsolutePath);
}
else
{
assetBundle = LoadAssetBundle(assetBundlePath, mode);
}
if (assetBundle == null)
{
return(null);
}
object asset = m_Loader.LoadAssetFromAssetBundle(assetBundle, assetName, mode);
m_Holder.AddAsset(internalAssetName, asset);
return(asset);
}
public void LoadAssetFromAssetBundleAsync(string assetBundlePath, string assetName, LoadMode mode, LoadAssetCompleteEventHandler onComplete, object userData)
{
if (string.IsNullOrEmpty(assetBundlePath))
{
throw new ArgumentNullException("invalid path");
}
string absolutePath = GetAbsolutePath(assetBundlePath, mode);
string internalAssetName = GetInternalAssetName(absolutePath, assetName);
if (m_Holder.HasAsset(internalAssetName))
{
if (onComplete != null)
{
onComplete(new LoadAssetCompleteEventArgs(assetName, m_Holder.GetAsset(internalAssetName), null, userData));
}
return;
}
LoadAssetInfo info = GetLoadingAssetInfo(absolutePath, assetName);
if (info != null)
{
info.Handler += onComplete;
info.UserData = userData;
}
else
{
info = new LoadAssetInfo()
{
AssetPath = absolutePath,
AssetName = assetName,
Mode = mode,
IsAssetBundle = true,
Handler = onComplete,
UserData = userData
};
if (!m_Holder.HasAssetBundle(absolutePath))
{
LoadAssetBundleAsync(assetBundlePath, mode, null, info);
}
m_LoadingInfos.AddLast(info);
CheckLoad();
}
}
/// <summary>
/// 获取某一步的列表
/// </summary>
/// <param name="step"></param>
/// <returns></returns>
private static List <LoadAssetInfo> GetLoadAssetStateList(LoadAssetStep step, bool isDelete = false)
{
List <LoadAssetInfo> list = new List <LoadAssetInfo>();
for (int i = _loadAssetInfoList.Count - 1; i >= 0; i--)
{
LoadAssetInfo loadAssetInfo = _loadAssetInfoList[i];
if (step == loadAssetInfo.step)
{
list.Add(loadAssetInfo);
if (isDelete)
{
_loadAssetInfoList.RemoveAt(i);
}
}
}
return(list);
}
/// <summary>
/// 回收资源加载信息
/// </summary>
/// <param name="assetInfo">asset加载信息</param>
private static void RecoveryLoadAssetInfo(LoadAssetInfo info)
{
if (info == null)
{
return;
}
foreach (LoadAssetInfo loadAssetInfo in _loadAssetInfoList)
{
if (loadAssetInfo == info)
{
_loadAssetInfoList.Remove(loadAssetInfo);
break;
}
}
info.Clear();
_freeLoadAssetInfoList.Add(info);
}
private void CheckLoad()
{
if (IsLoading)
{
return;
}
if (m_LoadingInfos.Count == 0)
{
return;
}
IsLoading = true;
ILoadInfo info = m_LoadingInfos.First.Value;
if (info is LoadAssetBundleInfo)
{
LoadAssetBundleInfo loadAssetBundleInfo = (LoadAssetBundleInfo)info;
m_Loader.LoadAssetBundleBytesAsync(loadAssetBundleInfo.AssetBundlePath, loadAssetBundleInfo.Mode);
}
else if (info is LoadAssetInfo)
{
LoadAssetInfo loadAssetInfo = (LoadAssetInfo)info;
if (loadAssetInfo.IsAssetBundle)
{
if (m_Holder.HasAssetBundle(loadAssetInfo.AssetPath))
{
m_Loader.LoadAssetFromAssetBundleAsync(m_Holder.GetAssetBundle(loadAssetInfo.AssetPath), loadAssetInfo.AssetName, loadAssetInfo.Mode);
}
else
{
//加载assetbundle失败
OnResourceLoaderLoadAssetComplete(new LoadAssetCompleteEventArgs(loadAssetInfo.AssetName, null, string.Format("asset bundle '{0}' not exists", loadAssetInfo.AssetPath), loadAssetInfo.UserData));
}
}
else
{
m_Loader.LoadAssetAsync(loadAssetInfo.AssetPath, loadAssetInfo.Mode);
}
}
}
/// <summary>
/// 进入加载回调
/// </summary>
/// <param name="loadAssetInfo"></param>
private static void EnterWaitCall(LoadAssetInfo loadAssetInfo)
{
loadAssetInfo.step = LoadAssetStep.WaitCall;
Debug.Log("loadAsset step 4 EnterWaitCall : " + loadAssetInfo.assetName);
}
/// <summary>
/// 进入加载
/// </summary>
/// <param name="loadAssetInfo"></param>
private static void EnterLoading(LoadAssetInfo loadAssetInfo)
{
loadAssetInfo.step = LoadAssetStep.Loading;
Debug.Log("loadAsset step 3 EnterLoading : " + loadAssetInfo.assetName);
}
/// <summary>
/// 进入依赖加载
/// </summary>
/// <param name="loadAssetInfo"></param>
private static void EnterLoadDepend(LoadAssetInfo loadAssetInfo)
{
loadAssetInfo.step = LoadAssetStep.LoadDepend;
Debug.Log("loadAsset step 2 EnterLoadDepend : " + loadAssetInfo.assetName);
}
/// <summary>
/// 进入等待加载
/// </summary>
/// <param name="loadAssetInfo"></param>
private static void EnterLoadWait(LoadAssetInfo loadAssetInfo)
{
loadAssetInfo.step = LoadAssetStep.LoadWait;
Debug.Log("loadAsset step 1 EnterLoadWait : " + loadAssetInfo.assetName);
}
/// <summary>
/// 回收资源加载信息
/// </summary>
/// <param name="assetInfo">asset加载信息</param>
private static void RecoveryLoadAssetInfo(LoadAssetInfo info)
{
info.Clear();
_freeLoadAssetInfoList.Add(info);
}
private void Update()
{
if (m_LoadAssetInfos.Count > 0)
{
int count = 0;
LinkedListNode <LoadAssetInfo> current = m_LoadAssetInfos.First;
while (current != null && count < m_LoadAssetCountPerFrame)
{
LoadAssetInfo loadAssetInfo = current.Value;
float elapseSeconds = (float)(DateTime.Now - loadAssetInfo.StartTime).TotalSeconds;
if (elapseSeconds >= loadAssetInfo.DelaySeconds)
{
UnityEngine.Object asset = null;
#if UNITY_EDITOR
if (loadAssetInfo.AssetType != null)
{
asset = UnityEditor.AssetDatabase.LoadAssetAtPath(loadAssetInfo.AssetName, loadAssetInfo.AssetType);
}
else
{
asset = UnityEditor.AssetDatabase.LoadMainAssetAtPath(loadAssetInfo.AssetName);
}
#endif
if (asset != null)
{
if (loadAssetInfo.LoadAssetCallbacks.LoadAssetSuccessCallback != null)
{
loadAssetInfo.LoadAssetCallbacks.LoadAssetSuccessCallback(loadAssetInfo.AssetName, asset, elapseSeconds, loadAssetInfo.UserData);
}
}
else
{
if (loadAssetInfo.LoadAssetCallbacks.LoadAssetFailureCallback != null)
{
loadAssetInfo.LoadAssetCallbacks.LoadAssetFailureCallback(loadAssetInfo.AssetName, LoadResourceStatus.NotExist, "Can not load this asset from asset database.", loadAssetInfo.UserData);
}
}
LinkedListNode <LoadAssetInfo> next = current.Next;
m_LoadAssetInfos.Remove(loadAssetInfo);
current = next;
count++;
}
else
{
if (loadAssetInfo.LoadAssetCallbacks.LoadAssetUpdateCallback != null)
{
loadAssetInfo.LoadAssetCallbacks.LoadAssetUpdateCallback(loadAssetInfo.AssetName, elapseSeconds / loadAssetInfo.DelaySeconds, loadAssetInfo.UserData);
}
current = current.Next;
}
}
}
if (m_LoadSceneInfos.Count > 0)
{
LinkedListNode <LoadSceneInfo> current = m_LoadSceneInfos.First;
while (current != null)
{
LoadSceneInfo loadSceneInfo = current.Value;
if (loadSceneInfo.AsyncOperation.isDone)
{
if (loadSceneInfo.AsyncOperation.allowSceneActivation)
{
if (loadSceneInfo.LoadSceneCallbacks.LoadSceneSuccessCallback != null)
{
loadSceneInfo.LoadSceneCallbacks.LoadSceneSuccessCallback(loadSceneInfo.SceneAssetName, (float)(DateTime.Now - loadSceneInfo.StartTime).TotalSeconds, loadSceneInfo.UserData);
}
}
else
{
if (loadSceneInfo.LoadSceneCallbacks.LoadSceneFailureCallback != null)
{
loadSceneInfo.LoadSceneCallbacks.LoadSceneFailureCallback(loadSceneInfo.SceneAssetName, LoadResourceStatus.NotExist, "Can not load this scene from asset database.", loadSceneInfo.UserData);
}
}
LinkedListNode <LoadSceneInfo> next = current.Next;
m_LoadSceneInfos.Remove(loadSceneInfo);
current = next;
}
else
{
if (loadSceneInfo.LoadSceneCallbacks.LoadSceneUpdateCallback != null)
{
loadSceneInfo.LoadSceneCallbacks.LoadSceneUpdateCallback(loadSceneInfo.SceneAssetName, loadSceneInfo.AsyncOperation.progress, loadSceneInfo.UserData);
}
current = current.Next;
}
}
}
if (m_UnloadSceneInfos.Count > 0)
{
LinkedListNode <UnloadSceneInfo> current = m_UnloadSceneInfos.First;
while (current != null)
{
UnloadSceneInfo unloadSceneInfo = current.Value;
if (unloadSceneInfo.AsyncOperation.isDone)
{
if (unloadSceneInfo.AsyncOperation.allowSceneActivation)
{
if (unloadSceneInfo.UnloadSceneCallbacks.UnloadSceneSuccessCallback != null)
{
unloadSceneInfo.UnloadSceneCallbacks.UnloadSceneSuccessCallback(unloadSceneInfo.SceneAssetName, unloadSceneInfo.UserData);
}
}
else
{
if (unloadSceneInfo.UnloadSceneCallbacks.UnloadSceneFailureCallback != null)
{
unloadSceneInfo.UnloadSceneCallbacks.UnloadSceneFailureCallback(unloadSceneInfo.SceneAssetName, unloadSceneInfo.UserData);
}
}
LinkedListNode <UnloadSceneInfo> next = current.Next;
m_UnloadSceneInfos.Remove(unloadSceneInfo);
current = next;
}
else
{
current = current.Next;
}
}
}
}
private void Update()
{
if (m_LoadAssetInfos.Count > 0)
{
LinkedListNode <LoadAssetInfo> current = m_LoadAssetInfos.First;
while (current != null)
{
LoadAssetInfo loadAssetInfo = current.Value;
float elapseSeconds = (float)(DateTime.Now - loadAssetInfo.StartTime).TotalSeconds;
if (elapseSeconds >= loadAssetInfo.DelaySeconds)
{
UnityEngine.Object asset = null;
#if UNITY_EDITOR
if (loadAssetInfo.AssetType != null)
{
asset = AssetDatabase.LoadAssetAtPath(loadAssetInfo.AssetName, loadAssetInfo.AssetType);
}
else
{
asset = AssetDatabase.LoadMainAssetAtPath(loadAssetInfo.AssetName);
}
#endif
if (asset != null)
{
if (loadAssetInfo.LoadAssetCallbacks.LoadAssetSuccessCallback != null)
{
loadAssetInfo.LoadAssetCallbacks.LoadAssetSuccessCallback(loadAssetInfo.AssetName, asset, elapseSeconds, loadAssetInfo.UserData);
}
}
else
{
if (loadAssetInfo.LoadAssetCallbacks.LoadAssetFailureCallback != null)
{
loadAssetInfo.LoadAssetCallbacks.LoadAssetFailureCallback(loadAssetInfo.AssetName, LoadResourceStatus.NotExist, "Can not load this asset from asset database.", loadAssetInfo.UserData);
}
}
LinkedListNode <LoadAssetInfo> next = current.Next;
m_LoadAssetInfos.Remove(loadAssetInfo);
current = next;
}
else
{
if (loadAssetInfo.LoadAssetCallbacks.LoadAssetUpdateCallback != null)
{
loadAssetInfo.LoadAssetCallbacks.LoadAssetUpdateCallback(loadAssetInfo.AssetName, elapseSeconds / loadAssetInfo.DelaySeconds, loadAssetInfo.UserData);
}
current = current.Next;
}
}
}
else
{
if (_startLoadAssets)
{
_startLoadAssets = false;
_loadAssetsComplete(this,
new GameFramework.Resource.
LoadAssetsCompleteEventArgs
(_assetNames.ToArray(), _assets.ToArray(), _duration, _userData));
_clerCache();
}
}
if (m_LoadSceneInfos.Count > 0)
{
LinkedListNode <LoadSceneInfo> current = m_LoadSceneInfos.First;
while (current != null)
{
LoadSceneInfo loadSceneInfo = current.Value;
if (loadSceneInfo.AsyncOperation.isDone)
{
if (loadSceneInfo.AsyncOperation.allowSceneActivation)
{
if (loadSceneInfo.LoadSceneCallbacks.LoadSceneSuccessCallback != null)
{
loadSceneInfo.LoadSceneCallbacks.LoadSceneSuccessCallback(loadSceneInfo.SceneAssetName, (float)(DateTime.Now - loadSceneInfo.StartTime).TotalSeconds, loadSceneInfo.UserData);
}
}
else
{
if (loadSceneInfo.LoadSceneCallbacks.LoadSceneFailureCallback != null)
{
loadSceneInfo.LoadSceneCallbacks.LoadSceneFailureCallback(loadSceneInfo.SceneAssetName, LoadResourceStatus.NotExist, "Can not load this scene from asset database.", loadSceneInfo.UserData);
}
}
LinkedListNode <LoadSceneInfo> next = current.Next;
m_LoadSceneInfos.Remove(loadSceneInfo);
current = next;
}
else
{
if (loadSceneInfo.LoadSceneCallbacks.LoadSceneUpdateCallback != null)
{
loadSceneInfo.LoadSceneCallbacks.LoadSceneUpdateCallback(loadSceneInfo.SceneAssetName, loadSceneInfo.AsyncOperation.progress, loadSceneInfo.UserData);
}
current = current.Next;
}
}
}
if (m_UnloadSceneInfos.Count > 0)
{
LinkedListNode <UnloadSceneInfo> current = m_UnloadSceneInfos.First;
while (current != null)
{
UnloadSceneInfo unloadSceneInfo = current.Value;
if (unloadSceneInfo.AsyncOperation.isDone)
{
if (unloadSceneInfo.AsyncOperation.allowSceneActivation)
{
if (unloadSceneInfo.UnloadSceneCallbacks.UnloadSceneSuccessCallback != null)
{
unloadSceneInfo.UnloadSceneCallbacks.UnloadSceneSuccessCallback(unloadSceneInfo.SceneAssetName, unloadSceneInfo.UserData);
}
}
else
{
if (unloadSceneInfo.UnloadSceneCallbacks.UnloadSceneFailureCallback != null)
{
unloadSceneInfo.UnloadSceneCallbacks.UnloadSceneFailureCallback(unloadSceneInfo.SceneAssetName, unloadSceneInfo.UserData);
}
}
LinkedListNode <UnloadSceneInfo> next = current.Next;
m_UnloadSceneInfos.Remove(unloadSceneInfo);
current = next;
}
else
{
current = current.Next;
}
}
}
}
