/// <summary>
/// 检查是否已在缓存
/// </summary>
/// <param name="group">加载组</param>
/// <param name="name">AssetBundle名称</param>
/// <param name="onLoaded">完成回调</param>
/// <param name="persistent">是否常驻</param>
/// <param name="async">是否异步</param>
/// <returns>已缓存(是-引用计数+1,并返回true, 否-返回false)</returns>
public bool CheckAssetBundleInfo(LoaderGroup group, string name, LoadMgr.GroupLoadedCallback onLoaded,
bool persistent, bool async)
{
AssetBundleInfo info = GetAssetBundleInfo(name, persistent);
if (info == null)
{
AddAssetBundleInfo(name, persistent);
return(false);
}
if (info.Bundle == null)
{
return(false);
}
if (onLoaded != null)
{
if (!async)
{
onLoaded(group, info);
}
else
{
m_task.AddAsyncCallback(onLoaded, group, info);
}
}
return(true);
}
// 加载关卡
public void LoadScene(string name, LoadedHandler onLoaded, bool async = true, bool additive = false)
{
LoaderGroup group = m_task.PopGroup(LoadPriority.High);
if (!additive)
{
m_task.AddLoadTask(group, Loader.LoaderType.Scene, "Empty", null, null, async);
}
if (ConstantData.EnableAssetBundle)
{
string path = string.Format("Scene/{0}", name).ToLower();
LoadAssetBundle(group, path, (group1, data1) => {
m_task.AddLoadTask(group1, Loader.LoaderType.Scene, name, additive, (group2, data2) => {
if (onLoaded != null)
{
onLoaded(data2);
}
}, async, group.Priority, true);
}, async);
}
else
{
m_task.AddLoadTask(group, Loader.LoaderType.Scene, name, additive, (group1, data1) => {
if (onLoaded != null)
{
onLoaded(data1);
}
}, async);
}
}
/// <summary>
/// 添加加载任务
/// </summary>
/// <param name="group">加载组</param>
/// <param name="type">类型</param>
/// <param name="path">路径</param>
/// <param name="param">附加参数</param>
/// <param name="onLoaded">回调</param>
/// <param name="async">异步</param>
/// <param name="priority">优先级</param>
/// <param name="insert">插入</param>
/// <returns></returns>
public void AddLoadTask(LoaderGroup group, Loader.LoaderType type, string path, object param,
LoadMgr.GroupLoadedCallback onLoaded, bool async,
LoadMgr.LoadPriority priority = LoadMgr.LoadPriority.Normal, bool insert = false)
{
if (!async)
{
Loader loader = PopLoader(type, path, param, false);
PushCallback(loader, (data) =>
{
if (onLoaded != null)
{
onLoaded(group, data);
}
});
loader.Load();
PushLoader(loader);
return;
}
if (group == null)
{
group = PopGroup(priority);
}
group.Add(type, path, param, onLoaded, true, insert);
}
/// <summary>
/// 更新
/// </summary>
private void UpdateGroup()
{
int index = 0;
while (index < m_groups.Count)
{
LoaderGroup group = m_groups[index];
group.Update();
if (group.IsFinish)
{
group.Reset();
m_groupPool.Enqueue(group);
m_groups.RemoveAt(index);
}
else
{
++index;
}
}
while (m_groups.Count < g_maxGroup)
{
if (!StartNextGroup())
{
break;
}
}
}
/// <summary>
/// 开始下一组
/// </summary>
/// <returns></returns>
private bool StartNextGroup()
{
LoaderGroup group = null;
for (int i = (int)LoadMgr.LoadPriority.Count - 1; i >= 0; --i)
{
Queue <LoaderGroup> groups = m_waitGroups[(LoadMgr.LoadPriority)i];
if (groups.Count == 0)
{
continue;
}
group = groups.Dequeue();
break;
}
if (group == null)
{
return(false);
}
m_groups.Add(group);
group.Start();
return(true);
}
/// <summary>
/// 获得加载组
/// </summary>
/// <returns></returns>
public LoaderGroup PopGroup(LoadMgr.LoadPriority priority = LoadMgr.LoadPriority.Normal)
{
LoaderGroup group = m_groupPool.Count > 0 ? m_groupPool.Dequeue() : new LoaderGroup(this);
group.Priority = priority;
m_waitGroups[priority].Enqueue(group);
return(group);
}
// 从AssetBundle中加载资源
public void LoadAssetFromBundle(LoaderGroup group, string path, string name, Type type,
GroupLoadedCallback onLoaded,
bool async = true, bool persistent = false,
LoadPriority priority = LoadPriority.Normal)
{
path = path.ToLower();
LoadAssetBundle(group, path, (group1, data) => {
AssetBundleInfo cache = data as AssetBundleInfo;
LoadBundleAsset(group1, cache, name, type, onLoaded, async);
}, async, persistent, true, priority);
}
// 依赖
// 加载依赖
private void LoadDependencies(LoaderGroup group, string name, bool async, bool persistent)
{
if (m_manifest == null)
{
return;
}
string[] dependencies =
m_manifest.GetDirectDependencies(string.Format("{0}{1}", name, ConstantData.AssetBundleExt));
for (int i = 0; i < dependencies.Length; ++i)
{
LoadAssetBundle(group, dependencies[i].Replace(ConstantData.AssetBundleExt, ""), null, async,
persistent);
}
}
/// <summary>
/// 增加异步回调
/// </summary>
/// <param name="onLoaded">回调</param>
/// <param name="group">加载组</param>
/// <param name="data">资源对象</param>
public void AddAsyncCallback(LoadMgr.GroupLoadedCallback onLoaded, LoaderGroup group, object data)
{
if (onLoaded == null)
{
return;
}
AsyncCallbackInfo info = new AsyncCallbackInfo
{
OnLoaded = onLoaded,
Group = group,
Data = data
};
m_asyncCallbackInfos.Add(info);
}
// ------------------------------------------------------------------------------------------
// 从AssetBundle里加载资源
private void LoadBundleAsset(LoaderGroup group, AssetBundleInfo info, string name, Type type,
GroupLoadedCallback onLoaded,
bool async = true, LoadPriority priority = LoadPriority.Normal)
{
if (info == null || string.IsNullOrEmpty(name))
{
if (onLoaded != null)
{
onLoaded(group, null);
}
return;
}
if (!async)
{
// 同步,直接加载
//Logger.Log(string.Format("-->LoadBundleAsset: {0}", name));
Object asset = info.LoadAsset(name, type);
if (onLoaded != null)
{
onLoaded(group, asset);
}
}
else
{
// 异步,创建一个加载器后加载
BundleAssetLoadParam param = new BundleAssetLoadParam {
Bundle = info.Bundle,
Type = type
};
m_task.AddLoadTask(group, Loader.LoaderType.BundleAsset, name, param, (group1, data1) => {
// 加载回调
if (onLoaded != null)
{
onLoaded(group1, data1);
}
}, true, priority, true);
}
}
// 加载AssetBundle(先从persistentData读,没有找到则从streamingAssets读,带后缀)
private void LoadAssetBundle(LoaderGroup group, string path, GroupLoadedCallback onLoaded,
bool async = true, bool persistent = false, bool manifest = true,
LoadPriority priority = LoadPriority.Normal)
{
path = path.ToLower();
if (async && group == null)
{
group = m_task.PopGroup(priority);
}
if (manifest)
{
if (!HasBundle(path))
{
// Manifest里没有这个AssetBundle,说明是一个错误的路径
Logger.LogError(string.Format("ab不存在:{0}", path));
if (onLoaded != null)
{
if (!async)
{
onLoaded(group, null);
}
else
{
m_task.AddAsyncCallback(onLoaded, group, null);
}
}
return;
}
// 加载依赖
LoadDependencies(group, path, async, persistent);
}
// 检查是否有缓存
if (m_cache.CheckAssetBundleInfo(group, path, onLoaded, persistent, async))
{
return;
}
// 添加加载任务
m_task.AddLoadTask(group, Loader.LoaderType.Bundle, path, null, (group1, data) => {
AssetBundle ab = data as AssetBundle;
AssetBundleInfo info = null;
if (ab != null)
{
info = m_cache.SetAssetBundle(path, ab);
#if UNITY_EDITOR
RefreshShader(ab);
#endif
}
// 加载回调
if (onLoaded != null)
{
onLoaded(group1, info);
}
}, async, priority);
}
