/// <summary>
/// 异步加载场景包
/// </summary>
/// <param name="scenePath"></param>
///
private void _LoadSceneBundleAnsyc(string scenePath, Action loadedCallback /*,FadeMode mode*/)
{
if (Z.Resource.LoadFromAssetBundle)
{
ResourceItem resItem = Z.Resource.ResourceItemDic[scenePath];
if (!resItem.AnsycLoaded)
{
AssetBundleManager.LoadAssetBundleAsync(resItem);
AssetBundleManager.GetAssetBundleLoadedSubject(resItem).Subscribe(_ =>
{
if (FadeInDone)//如果渐变已经完成
{
_DoLoadScene(scenePath, loadedCallback);
}
Already = true;//标识已经加载完毕
});
}
}
//else
// ClearCache();
}
//private static SimpleSpinLock mSpinLock = new SimpleSpinLock();//考虑到
internal static void LoadABManifest()
{
//if (!Z.Resource.LoadFromAssetBundle)
// return;
string mAssetManifestPath = mABLoadPath + mManifestName;
AssetBundle manifestAB = AssetBundle.LoadFromFile(mAssetManifestPath);
TextAsset manifestBytes = manifestAB.LoadAsset <TextAsset>(mManifestName);
if (manifestBytes == null)
{
Z.Debug.Error("资源清单读取失败");
return;
}
MemoryStream stream = new MemoryStream(manifestBytes.bytes);
BinaryFormatter bf = new BinaryFormatter();
AssetManifest manifest = (AssetManifest)bf.Deserialize(stream);
stream.Close();
for (int i = 0; i < manifest.AssetLst.Count; i++)
{
AssetElement element = manifest.AssetLst[i];
ResourceItem resItem = Z.Pool.Take <ResourceItem>();
resItem.Path = element.Path;
resItem.AssetName = element.AssetName;
resItem.ABName = element.ABName;
resItem.DependAB = element.DependAB;
resItem.ClearDependFlag();
Z.Resource.ResourceItemDic.Add(resItem.Path, resItem);
}
//预留200个AB包壳
Z.Pool.RegisterClassCustomPool(() => new AssetBundleItem(), AssetBundleItem.Clean, 200);
Z.Pool.RegisterClassPool <ABLoadedSArgs>(60);//一次加载请求可能同时需要加载多个包 这时候每个包都要发一次事件 所以给多点 但上小于上面的数字
return;
}
private static IEnumerator _LoadAssetBundleAsync(string abName, ResourceItem resItem)
{
AssetBundleItem abItem = mAssetBundleItemDic.GetValue(abName);
if (abItem == null)
{
AssetBundleCreateRequest abRequest = null;
string fullPath = mABLoadPath + abName;
if (File.Exists(fullPath))
{
abRequest = AssetBundle.LoadFromFileAsync(fullPath); // ---正式的加载
}
while (!abRequest.isDone) //等待加载完成
{
yield return(null);
}
if (abRequest.assetBundle == null)
{
Debug.LogError("加载AB包失败:" + fullPath);
}
else
{
if (ReferenceEquals(abName, resItem.ABName))
{
resItem.AssetBundle = abRequest.assetBundle;
}
abItem = Z.Pool.Take <AssetBundleItem>();
abItem.AssetBundle = abRequest.assetBundle;
mAssetBundleItemDic.Add(abName, abItem); //协程是在主线程等待 因此这个操作并不需要加锁 ...又一次体现了协程的优越性
}
}
abItem.RefCount++;
//发送加载完成事件 接收方过滤name即可
Z.Subject.Fire(Z.Pool.Take <ABLoadedSArgs>().Fill(resItem, abName));
}
public void Add(ResourceItem resItem)
{
mResItemLst.Add(resItem);
}
public ABLoadedSArgs Fill(ResourceItem resItem, string loadedName)
{
ResItem = resItem;
LoadedName = loadedName;
return(this);
}
internal static IObservable <ABLoadedSArgs> GetAssetBundleLoadedSubject(ResourceItem resItem)
{
return(Z.Subject.GetSubject <ABLoadedSArgs>().Where(args => resItem == args.ResItem && args.ResItem.AnsycLoaded).First());
}
internal void IncreaseRefCount(ResourceItem resItem, int groupIndex)
{
resItem.RefCount++;
resItem.LastUseTime = Time.realtimeSinceStartup; //先存着再说
resItem.AddTo(groupIndex); //考虑到释放资源组时的操作即减少引用计数，则哪里增加的就在哪里加入组中，这样可保证加了多少，等减掉的时候就能不多不少得减掉 应该没错..
}
internal void IncreaseRefCount(ResourceItem resItem,int groupIndex ,int refCountAdd=1)
{
resItem.RefCount += refCountAdd;
resItem.LastUseTime= Time.realtimeSinceStartup;//先存着再说
Z.Obs.ForLoop(refCountAdd, _ => resItem.AddTo(groupIndex));//考虑到释放资源组时的操作即减少引用计数，则哪里增加的就在哪里加入组中，这样可保证加了多少，等减掉的时候就能不多不少得减掉 应该没错..
}
