protected override void StartOneLoadAsync(IAssetLoadTask task)
{
var assetId = task.AssetId;
var loadState = GetLoadState(assetId);
var callback = task.Callback;
switch (loadState)
{
case LoadState.NotLoad:
OnNotLoad();
break;
case LoadState.Loaded:
OnLoaded();
break;
case LoadState.Loading:
OnLoading();
break;
default:
throw new ArgumentOutOfRangeException();
}
if (LoadingIds.Contains(assetId))
{
return;
}
void OnNotLoad()
{
Callbcker.AddCallback(assetId, ConvertAction);
SetLoadState(assetId, LoadState.Loading);
LoadingIds.Add(assetId);
StartLoadBundle(task);
}
void OnLoaded()
{
var asset = Buffer.GetValue(assetId);
callback(asset);
}
void OnLoading()
{
Callbcker.AddCallback(assetId, ConvertAction);
}
void ConvertAction(UnityEngine.Object tCallback)
{
LoadingIds.Remove(assetId);
var finalAsset = tCallback;
callback?.Invoke(finalAsset);
}
}
private void PushChianTask(string initiatedBundleId, BundleDependInfo dependInfo, AsyncTask asyncTask)
{
#if DEBUG
m_countChian++;
if (m_countChian > 10000)
{
Debug.LogError("严重错误：异步加载堆栈超过10000，请检查加载逻辑或资源依赖关系：" + initiatedBundleId);
return;
}
#endif
var dependIds = dependInfo.DirectDepends;
var dependCount = dependIds.Count;
var index = 0;
LoadState loadState = GetLoadState(dependInfo.BundleId);
if (loadState == LoadState.AddTask)
{
return;
}
SetLoadState(dependInfo.BundleId, LoadState.AddTask);
while (index < dependCount)
{
var sonId = dependIds[index];
loadState = GetLoadState(sonId);
if (loadState != LoadState.NotLoad)
{
index++;
continue;
}
var sonDepndInfo = DependInfoHelper.GetDependInfo(sonId);
if (sonDepndInfo.DirectDepends.Count == 0)
{
var sonTask = TakeTask();
asyncTask.AddCount();
Callbcker.AddCallback(sonId, asyncTask.OneLoadDown);
sonTask.InitiatedBundleId = initiatedBundleId;
sonTask.TargetBundleId = sonId;
//LoadingIds.Add(sonId);
WaitTasks.Enqueue(sonTask);
SetLoadState(sonId, LoadState.Loading);
index++;
#if UNITY_EDITOR
////AnalyzeProfiler.AddBundleToBundleRef(sonId, dependInfo.BundleId);
#endif
}
else
{
PushChianTask(initiatedBundleId, sonDepndInfo, asyncTask);
index++;
}
}
//loadState = GetLoadState(dependInfo.BundleId);
//if (loadState != LoadState.NotLoad)
//{
// return;
//}
var task = TakeTask();
asyncTask.AddCount();
Callbcker.AddCallback(dependInfo.BundleId, asyncTask.OneLoadDown);
task.InitiatedBundleId = initiatedBundleId;
task.TargetBundleId = dependInfo.BundleId;
//LoadingIds.Add(dependInfo.BundleId);
WaitTasks.Enqueue(task);
SetLoadState(task.TargetBundleId, LoadState.Loading);
#if UNITY_EDITOR
if (task.IsMainTask)
{
////AnalyzeProfiler.AddAssetToBundleRef(task.TargetBundleId, initiatedBundleId);
}
else
{
////AnalyzeProfiler.AddBundleToBundleRef(task.TargetBundleId, initiatedBundleId);
}
#endif
}
private int m_countChian; //链式加载堆栈计数，以免死循环
#endif
public void LoadAsync(string assetId, Action <IBundleRef> callback)
{
var assetLowerId = assetId.ToLower();
var bundleId = BundlePathInfoHelepr.GetBundleId(assetLowerId);
var loadState = GetLoadState(bundleId);
switch (loadState)
{
case LoadState.NotLoad:
OnNotLoad();
break;
case LoadState.Loaded:
OnLoaded();
break;
case LoadState.Loading:
OnLoading();
break;
default:
callback?.Invoke(null);
throw new ArgumentOutOfRangeException();
}
void OnNotLoad()
{
AsyncTask task = AsyncTask.Get();
task.SetCallback(callback);
Callbcker.AddCallback(bundleId, task.MainLoadDown);
var dependInfo = DependInfoHelper.GetDependInfo(bundleId);
var dependIds = dependInfo.DirectDepends;
if (dependIds.Count == 0)
{
Callbcker.AddCallback(bundleId, task.OneLoadDown);
task.AddCount();
SetLoadState(bundleId, LoadState.Loading);
WaitTasks.Enqueue(CreateMainTask(assetLowerId, bundleId));
}
else
{
#if DEBUG
m_countChian = 0;
#endif
PushChianTask(bundleId, dependInfo, task);
}
}
void OnLoaded()
{
callback(Buffer.GetValue(bundleId));
Buffer.As <BundleBuffer>().IncreaseRef(bundleId);
}
void OnLoading()
{
Callbcker.AddCallback(bundleId, callback);
}
}