private LoadTask CreatTaskAndStart(string _key, BaseBundle _bundle, System.Action <string, object> _callback, bool _retain)
{
LoadTask ret = new LoadTask(_key, _bundle, _callback, _retain);
mBundleTaskList.Add(ret);
return(ret);
}
private IEnumerator runTask(LoadTask task)
{
task._taskStartTime = Time.time;
yield return(StartCoroutine(task.coroutine));
task.isDone = true;
}
//todo
internal void Release(string resPath, bool isUnloadAB = false)
{
if (!AppConst.s_IsUseAB)
{
return;
}
if (string.IsNullOrEmpty(resPath))
{
return;
}
if (isUnloadAB && loadedResource.ContainsKey(resPath))
{
LoadTask task = loadedResource[resPath];
task.Unload(true);
loadedResource.Remove(resPath);
string[] dependence = _manifest.GetAllDependencies(resPath);
for (int i = 0; i < dependence.Length; ++i)
{
if (loadedResource.ContainsKey(dependence[i]))
{
loadedResource[dependence[i]].Unload(false);
loadedResource.Remove(dependence[i]);
}
}
}
}
// 特殊的接口，比如加载
void PushLoadTask(long nAwaitPtr, long nRetPtr, string szAssetName, float fWaitTime)
{
ScriptInfo info = new ScriptInfo();
info.nPtr = nAwaitPtr;
info.nReturnPtr = nRetPtr;
for (int i = 0; i < m_AwaitTask.Count; ++i)
{
if (m_AwaitTask[i].szAssetName == szAssetName)
{
m_AwaitTask[i].AwaitPtr.Add(info);
return;
}
}
LoadTask rTask = new LoadTask();
rTask.fStartTime = Time.time;
rTask.fWaitTime = fWaitTime;
rTask.szAssetName = szAssetName;
rTask.AwaitPtr = new List <ScriptInfo>();
rTask.AwaitPtr.Add(info);
m_AwaitTask.Add(rTask);
}
/// <summary>
/// 移除加载任务
/// </summary>
/// <param name="abPath"></param>
/// <param name="abcr"></param>
static public void RemoveGlobalLoadTask(LoadTask loadTask)
{
if (loadTask.IsDone)
{
GLOBAL_LOAD_TASK_MAP.Remove(loadTask.LocalPath);
}
}
//public void Init()
//{
// ResourceLoadParam param = new ResourceLoadParam();
// string fileName = Helper.GetFileNameFromFullPath(GAMEOBJPOOL_CONFIG_FILEPATH);
// param.keyID = GAMEOBJPOOL_CONFIG_FILEPATH;
// param.name = fileName;
// ResourceManager.GetSingleton().LoadAssetBundle(GAMEOBJPOOL_CONFIG_FILEPATH, fileName, typeof(TextAsset), OnLoadConfigCallback, param);
//}
/// <summary>
/// 加载/获得 某个对象物体
/// </summary>
/// <param name="varTask"></param>
public void LoadObj(LoadTask varTask)
{
if (varTask == null)
{
Helper.LogError("GameObjPool LoadObj:Error caused by null LoadTask instance");
return;
}
if (varTask.mType == typeof(Texture) || varTask.mType == typeof(Texture2D) || varTask.mType == typeof(Texture3D))
{
varTask.mObjFlag = ObjFlag.UseOriObj;
}
if (string.IsNullOrEmpty(varTask.mFilePath))
{
Helper.LogError("GameObjPool LoadObj:Error caused by null LoadTask.mFilePath");
return;
}
if (IsExistObjInfo(varTask.mFilePath))
{
varTask.Callback(GetCacheObjInfo(varTask.mFilePath, varTask.mObjFlag));
}
else
{
if (IsInLoading(varTask.mFilePath) == false)
{
TaskQueue queue = new TaskQueue(varTask.mFilePath, varTask);
AddTaskQueue(queue);
queue.Excute();
}
else
{
AddLoadTaskToQueue(varTask);
}
}
}
public IAsyncTask LoadAssetAsync <T>(string assetPath, Action <bool, T> callback) where T : UnityEngine.Object
{
ResourceRequest reques = Resources.LoadAsync <T>(assetPath);
IAsyncTask task = new LoadTask <T>(reques, callback);
return(task);
}
//
public static void NotifyTaskFinish(LoadTask t)
{
if (t != null)
{
g_LoadTask.Remove(t);
}
StartRunTask();
}
public LoadManager()
{
m_LoadTask = new LoadTask();
if (ConstantData.enableAssetBundle)
{
}
}
private void init(string bundle_url, string asset_name, Action<UnityEngine.Object> cbk)
{
LoadTask load_task = new LoadTask ();
load_task.bundleUrl = bundle_url;
load_task.assetName = asset_name;
load_task.successCbk = cbk;
_load_tasks.Add (load_task);
}
/// <summary>
/// send load task to load task actor
/// </summary>
/// <param name="message"></param>
/// <remarks>in the future, this may be enhanced with a start
/// location, so that it might not only have to be a full farm reload
/// </remarks>
public void Handle(LoadTask message)
{
IActorRef newTaskActor =
ActorSystemReference.ActorSystem.ActorOf(LoadTaskActor.Props(eventAggregator, repository,
message.Title, message.Id, message.StartLocation), message.Id.ToString());
taskActors.Add(message.Id, newTaskActor);
}
/// <summary>
/// 加载AssetBundle文件
/// </summary>
/// <param name="assetbundleFileName">ab文件名</param>
/// <returns></returns>
public void LoadAssetBundle(string assetbundleFileName, int offset = 0)
{
AssetBundleWapper abw = GetAssetBundleFromCache(assetbundleFileName);
if (abw == null)
{
//取消加载任务
this.CancelUnloadTask(assetbundleFileName);
//寻找加载路径
var abLocalPath = FindMultiAddressAsset(assetbundleFileName);
#if UNITY_EDITOR
if (!File.Exists(abLocalPath))
{
return;
}
#endif
//这里需要判断task列表，异步转同步
var loadTask = GetExsitLoadTask(abLocalPath);
if (loadTask != null)
{
if (loadTask.IsAsyncTask)
{
loadTask.ToSynchronizationTask();
BDebug.Log("【AssetbundleV2】异步转同步:" + loadTask.LocalPath);
}
else
{
BDebug.LogError("【AssetbundleV2】同步任务调度错误~");
}
}
else
{
//同步也要创建任务
loadTask = new LoadTask(abLocalPath, 0u, (ulong)offset);
AddGlobalLoadTask(loadTask);
{
//同步加载
loadTask.Load();
}
RemoveGlobalLoadTask(loadTask);
}
#if UNITY_EDITOR
if (loadTask.AssetBundle == null)
{
Debug.LogError($"【AssetBundleV2】 ab加载失败{loadTask.LocalPath}");
}
#endif
//添加
abw = this.AddAssetBundleToCache(assetbundleFileName, loadTask.AssetBundle);
}
//使用
abw.Use();
}
/// <summary>
/// Add a task to load
/// </summary>
/// <param name="task"></param>
public static void AddTask(LoadTask task)
{
if (Tasks == null)
{
Tasks = new List <LoadTask>();
}
Tasks.Add(task);
}
static void Initialize()
{
_characterList = new List <CharacterData>();
_characters = new Dictionary <uint, CharacterData>();
_scenes = new List <SceneData>();
AssetBundleManager.AddHandler <CharacterData>(AddCharacter);
AssetBundleManager.AddHandler <SceneData>(AddScene);
Characters = new ReadOnlyCollection <CharacterData>(_characterList);
Scenes = new ReadOnlyCollection <SceneData>(_scenes);
SceneManager.sceneLoaded += SceneLoad;
var bundlePath = BundleUtility.StoragePath;
log.Info("Storage Path: {0}", bundlePath);
#if UNITY_EDITOR
if (AssetBundleManager.SimulateAssetBundleInEditor)
{
LoadFromEditor <CharacterData>(AddCharacter);
LoadFromEditor <SceneData>(AddScene);
LoadTask.Resolve();
}
else
#endif
{
var dataFilePath = Path.Combine(bundlePath, "data");
if (!File.Exists(dataFilePath))
{
log.Info("Cannot find {0} copying StreamingAssets...", dataFilePath, bundlePath);
AssetBundleManager.CopyDirectory(Application.streamingAssetsPath, bundlePath);
}
var file = File.ReadAllText(dataFilePath);
var whitelist = new List <string>();
var blacklist = new List <string>();
foreach (var entry in file.Split('\n'))
{
if (entry.StartsWith("-"))
{
blacklist.Add(entry.Substring(1).Trim());
log.Info("Registered bundle blacklist: {0}".With(entry.Substring(1).Trim()));
}
else
{
whitelist.Add(entry.Trim());
log.Info("Registered bundle whitelist: {0}".With(entry.Trim()));
}
}
var task = AssetBundleManager.LoadLocalBundles(whitelist, blacklist);
task.Then(() => LoadTask.Resolve());
task.Done();
}
}
public void RemoveTask(string url)
{
LoadTask loadTask = null;
if (_taskDictionary.TryGetValue(url, out loadTask))
{
RemoveTask(loadTask);
}
}
private void init(string bundle_url, string asset_name, Action <UnityEngine.Object> cbk)
{
LoadTask load_task = new LoadTask();
load_task.bundleUrl = bundle_url;
load_task.assetName = asset_name;
load_task.successCbk = cbk;
_load_tasks.Add(load_task);
}
private void addLoad(string resName, string resPath, Action <string> callBack)
{
LoadTask task = new LoadTask(resName, resPath);
loadMap.Add(resName, task);
task.addHandler(onLoadFinish);
task.addHandler(callBack);
LoadThread.Instance.StartCoroutine(task.doLoad());
}
public LoadTask addTask(float weight, string name = null)
{
var task = new LoadTask();
task.name = name;
task.weight = weight;
waitingTasks.Add(task);
return(task);
}
private static void StartLoad(LoadTask task)
{
string abName = task.abName;
//先加载依赖AB
string[] dependenciesAB = _manifest.GetAllDependencies(abName);
foreach (string dpdAB in dependenciesAB)
{
if (_abDic.ContainsKey(dpdAB))
{
continue;
}
task.dependencies.Add(dpdAB);
if (_loadingABCountDic.ContainsKey(dpdAB))
{
_loadingABCountDic[dpdAB]++;
continue;
}
_loadingABCountDic.Add(dpdAB, 1);
string relativePath = AssetPathUtil.PlatformString + "/" + dpdAB;
string dpdUrl;
if (VersionManager.HasCache(relativePath))
{
dpdUrl = VersionManager.GetPath(relativePath);
}
else
{
dpdUrl = AssetPathUtil.GetAssetBundlePath(dpdAB);
}
LoaderManager.Load(dpdUrl, EnumResouceType.ASSETBUNDLE, OnABLoadComplete);
}
if (task.IsDependenciesLoadComplete())
{
if (!_loadingABCountDic.ContainsKey(abName))
{
_loadingABCountDic.Add(abName, 1);
string relativePath = AssetPathUtil.PlatformString + "/" + abName;
string abUrl;
if (VersionManager.HasCache(relativePath))
{
abUrl = VersionManager.GetPath(relativePath);
}
else
{
abUrl = AssetPathUtil.GetAssetBundlePath(abName);
}
LoaderManager.Load(abUrl, EnumResouceType.ASSETBUNDLE, OnABLoadComplete);
}
else
{
_loadingABCountDic[task.abName]++;
}
}
}
protected override void Dispose(bool isDisposing)
{
base.Dispose(isDisposing);
if (isDisposing)
{
// if the player never got pushed, we should explicitly dispose it.
DisposalTask = LoadTask?.ContinueWith(_ => player?.Dispose());
}
}
/// <summary>
/// 锁住加载AB
/// </summary>
static public void AddGlobalLoadTask(LoadTask loadTask)
{
if (GLOBAL_LOAD_TASK_MAP.ContainsKey(loadTask.LocalPath))
{
BDebug.LogError("【AssetbundleV2】 重复任务 " + loadTask.LocalPath);
return;
}
GLOBAL_LOAD_TASK_MAP[loadTask.LocalPath] = loadTask;
}
/// <summary>
/// 增加加载队列
/// </summary>
/// <param name="assets"></param>
public override void AddResTask(List <string> assets, string callBackEvent)
{
LoadTask loadTask = new LoadTask();
loadTask.list = assets;
loadTask.callBackEvent = callBackEvent;
if (!mDownLoadQueue.Contains(loadTask))
{
mDownLoadQueue.Add(loadTask);
}
}
private void OnTaskComplete(AsyncOperation async)
{
loadingTask.aysncOpertation.completed -= OnTaskComplete;
if (async != loadingTask.aysncOpertation)
{
return;
}
//AssetBundle加载
if (async is AssetBundleCreateRequest)
{
AssetBundleCreateRequest request = (AssetBundleCreateRequest)async;
if (request.assetBundle == null)
{
FileLog.LogError("<" + loadingTask.relativePath + "> 不存在于目录:" + loadingTask.resPath);
loadingTask.resource = null;
}
else
{
loadingTask.resource = request.assetBundle.LoadAsset(loadingTask.resName);
if (!loadedResource.ContainsKey(loadingTask.resPath))
{
loadedResource[loadingTask.resPath] = loadingTask;
}
}
}
else if (async is ResourceRequest)//Resource下直接加载
{
// FileLog.Log("资源：" + loadingTask.resName + "加载耗时：" + (Time.fixedTime - loadingTask.startTime));
if (async == loadingTask.aysncOpertation)
{
object obj = ((ResourceRequest)async).asset;
if (obj is Texture2D)
{
Texture2D tex = (Texture2D)obj;
Sprite sp = Sprite.Create(tex, new Rect(0, 0, tex.width, tex.height), Vector2.zero);
loadingTask.resource = sp;
}
else
{
loadingTask.resource = obj;
}
if (!loadedResource.ContainsKey(loadingTask.resPath))
{
loadedResource[loadingTask.resPath] = loadingTask;
}
}
}
loadingTask.completeCallback?.Invoke(loadingTask.resource);
loadingTask = null;
StartLoadTask();
}
private bool isAllDependenciesReady(LoadTask task)
{
for (int i = 0; i < task.dependents.Length; i++)
{
if (!task.dependents[i].isDone)
{
return(false);
}
}
return(true);
}
// Update is called once per frame
void Update()
{
if (_loadTask != null)
{
CheckLoadTask(_loadTask);
if (_loadTask.IsDone())
{
_loadTask = null;
}
}
}
public static void AddLoadTask(string ABRelativePath,
string ObjName,
System.Type type,
bool IsCacheAsset,
bool IsCacheAB,
bool IsFreeUnUseABRes,
AssetLoadHook pfun)
{
LoadTask info = new LoadTask(ABRelativePath, ObjName, type, IsCacheAsset, IsCacheAB, IsFreeUnUseABRes, pfun);
AddLoadQueue(info);
}
public void Add(LoadTask _task)
{
if (!mList.Contains(_task))
{
_task.Parent = this;
mList.Add(_task);
}
else
{
DLog.LogError("LoadTaskVector 重复添加. _task = " + _task.TaskKey);
}
}
/// <summary>
/// 正在运行的任务不能为相同的ab包。
/// </summary>
public bool EqualRunTask(LoadTask task)
{
if (task == null)
{
return(false);
}
if (string.Compare(this.m_ABRelativePath, task.m_ABRelativePath) == 0)
{
return(true);
}
return(false);
}
public TaskQueue(string varFilePath, LoadTask varTask)
{
mLoadTasks = new List <LoadTask>();
if (varTask == null)
{
return;
}
mFilePath = varFilePath;
mType = varTask.mType;
mObjFlag = varTask.mObjFlag;
mLoadTasks.Add(varTask);
mFileName = Helper.GetFileNameFromFullPath(varFilePath);
}
/// <summary>
/// 向队列中添加一个加载任务
/// </summary>
/// <param name="varTask"></param>
public void AddLoadTask(LoadTask varTask)
{
if (mLoadTasks == null)
{
mLoadTasks = new List <LoadTask>();
}
if (mLoadTasks.Contains(varTask))
{
return;
}
mType = varTask.mType;
mLoadTasks.Add(varTask);
}
/// <summary>
/// 增加加载队列
/// </summary>
/// <param name="assets"></param>
public override void AddResTask(List <string> assets, string callBackEvent)
{
LoadTask loadTask = new LoadTask();
loadTask.list = assets;
loadTask.callBackEvent = callBackEvent;
//Debug.LogError("AddResTask...");
if (!mDownLoadQueue.Contains(loadTask))
{
//Debug.LogError(222);
mDownLoadQueue.Add(loadTask);
}
}
