using SK;
using UnityEngine;
using UnityEngine.Events;
using System.Collections;
using System.Collections.Generic;
public class ABMgr : Singleton<ABMgr>
{
public void Init()
{
D.Log("ABMgr Init()");
_downloadFaildNeedRemoveList = new List<string>();
_downloadSuccessdNeedRemoveList = new List<string>();
_assetBundleDic = new Dictionary<string, LoadedAssetBundle>();
_downloadingWWWDic = new Dictionary<string, WWWLoad>();
_downloadingEventDic = new Dictionary<string, DownloadingSameObjEvent>();
}
public void Reset()
{
FreeAllAssets();
Init();
}
private Dictionary<string, DownloadingSameObjEvent> _downloadingEventDic;
private Dictionary<string, LoadedAssetBundle> _assetBundleDic;
private Dictionary<string, WWWLoad> _downloadingWWWDic;
private List<string> _downloadFaildNeedRemoveList;
private List<string> _downloadSuccessdNeedRemoveList;
public struct WWWLoad
{
private string _abName;
private WWW _www;
private bool _canUseCache;
public WWW WWW
{
get
{
return _www;
}
}
public string ABName
{
get
{
return _abName;
}
}
public AssetBundle AssetBundle
{
get
{
if(WWW.isDone)
{
return WWW.assetBundle;
}
else
{
D.Log("[WWWLoad] [AssetBundle] WWW is null");
return null;
}
}
}
public void SetData(
bool canUseCache,
string url,
string abName,
int version)
{
init();
_canUseCache = canUseCache;
_abName = abName;
_www = getWWW(url, version);
}
private WWW getWWW(string url, int version)
{
if (_canUseCache)
{
return WWW.LoadFromCacheOrDownload(url, version);
}
else
{
return new WWW(url);
}
}
private void init()
{
_www = null;
_canUseCache = false;
}
public float GetProgress()
{
return _www == null ? 0f : _www.progress;
}
}
public void DownloadManifest(string abName, UnityAction<string> callback)
{
var url = string.Format("{0}{1}{2}", PathMgr.Self.ABDownloadPath, abName, "");
var version = Global.Self.AssetBundleVersion;
WWWLoad load = new WWWLoad();
load.SetData(false, url, abName,version);
request(load, abName, callback);
}
public void Download(string abName, UnityAction<string> callback)
{
var url = string.Format("{0}{1}{2}", PathMgr.Self.ABDownloadPath, abName, "");
var version = Global.Self.AssetBundleVersion;
WWWLoad load = new WWWLoad();
load.SetData(false, url, abName, version);
request(load, abName, callback);
}
public void Download(string[] abNameArr, UnityAction<bool> callback)
{
List<string> abNameList = new List<string>();
foreach(var item in abNameArr)
{
abNameList.Add(item);
}
Download(abNameList, callback);
}
public void Download(List<string> abNameList, UnityAction<bool> callback)
{
var successList = new List<string>();
UnityAction<string> action = (abNameTemp) =>
{
if (_assetBundleDic.ContainsKey(abNameTemp) && !successList.Contains(abNameTemp))
{
successList.Add(abNameTemp);
if (successList.Count == abNameList.Count && callback != null)
{
callback(true);
}
}
};
foreach (var abName in abNameList)
{
if (_assetBundleDic.ContainsKey(abName) && !successList.Contains(abName))
{
action(abName);
continue;
}
var url = string.Format("{0}{1}{2}", PathMgr.Self.ABDownloadPath, abName, "");
var version = Global.Self.AssetBundleVersion;
WWWLoad load = new WWWLoad();
load.SetData(false, url, abName, version);
request(load, abName, action);
}
}
private void request(WWWLoad load, string abName, UnityAction<string> downloadingSameObjAction)
{
if(_assetBundleDic.ContainsKey(abName))
{
D.Log(abName + " has downloaded.");
return;
}
if (!_downloadingEventDic.ContainsKey(abName))
{
var evnet = new DownloadingSameObjEvent();
_downloadingEventDic.Add(abName, evnet);
}
_downloadingEventDic[abName].AddListener(downloadingSameObjAction);
if (_downloadingWWWDic.ContainsKey(abName))
{
D.Log(abName + " is downloading.");
return;
}
_downloadingWWWDic.Add(abName, load);
}
public bool IsContainItem(string item)
{
return _assetBundleDic.ContainsKey(item);
}
public AssetBundle GetItem(string item)
{
if (IsContainItem(item))
{
return _assetBundleDic[item].AssetBundle;
}
return null;
}
public Object GetItemChild(string item, string name)
{
return _assetBundleDic[item].AssetBundle.LoadAsset(name);
}
public void FreeAssets(string[] items)
{
foreach (var item in items)
{
FreeAsset(item);
}
}
public void FreeAssets(List<string> items)
{
FreeAssets(items.ToArray());
}
public void FreeAllAssets()
{
List<string> items = new List<string>();
foreach (KeyValuePair<string, LoadedAssetBundle> obj in _assetBundleDic)
{
items.Add(obj.Key);
}
foreach(var item in items)
{
FreeAsset(item);
}
}
public void FreeAsset(string item)
{
_assetBundleDic[item].AssetBundle.Unload(false);
_assetBundleDic.Remove(item);
D.Log("[Asset Bundle]Free asset : " + item);
}
public void Update()
{
_downloadFaildNeedRemoveList.Clear();
_downloadSuccessdNeedRemoveList.Clear();
foreach (var keyValue in _downloadingWWWDic)
{
WWWLoad wwwLoad = keyValue.Value;
if (wwwLoad.WWW.error != null)
{
D.Error(wwwLoad.WWW.error);
_downloadFaildNeedRemoveList.Add(keyValue.Key);
continue;
}
if (wwwLoad.WWW.isDone)
{
D.Log("[ABMgr][Downloaded] : " + keyValue.Key + " isDone");
var loadedAssetBundle = new LoadedAssetBundle(keyValue.Key, wwwLoad.AssetBundle);
if (!_assetBundleDic.ContainsKey(keyValue.Key))
{
_assetBundleDic.Add(keyValue.Key, loadedAssetBundle);
}
_downloadSuccessdNeedRemoveList.Add(keyValue.Key);
}
}
DownloadSuccessFaild();
DownloadSuccess();
}
private void DownloadSuccessFaild()
{
foreach (var key in _downloadFaildNeedRemoveList)
{
WWWLoad wwwload = _downloadingWWWDic[key];
_downloadingWWWDic.Remove(key);
wwwload.WWW.Dispose();
}
}
private void DownloadSuccess()
{
foreach (var key in _downloadSuccessdNeedRemoveList)
{
WWWLoad wwwload = _downloadingWWWDic[key];
if (_downloadingEventDic.ContainsKey(key))
{
_downloadingEventDic[key].Invoke(key);
_downloadingEventDic[key].RemoveAllListeners();
_downloadingEventDic.Remove(key);
}
_downloadingWWWDic.Remove(key);
wwwload.WWW.Dispose();
}
}
}
public class LoadedAssetBundle
{
public string _name;
public AssetBundle _assetBundle;
public int _referencedCount;
public string Name { get { return _name; } }
public AssetBundle AssetBundle { get { return _assetBundle; } }
public int ReferencedCount { get { return _referencedCount; } }
public LoadedAssetBundle(string name, AssetBundle assetBundle)
{
_name = name;
_assetBundle = assetBundle;
_referencedCount = 1;
}
}
using SK;
using UnityEngine;
using UnityEngine.Events;
using System.Collections;
using System.Collections.Generic;
public class Load
{
private string _abName;
private UnityAction _loadAction;
private static AssetBundleManifest _assetBundlesManifest;
public static void LoadAssetBundlesManifest(UnityAction callback)
{
if (ABMgr.Self.IsContainItem("AssetBundles"))
{
if (callback != null)
{
callback();
}
return;
}
ABMgr.Self.DownloadManifest("AssetBundles", abName =>
{
if ("AssetBundles" == abName && ABMgr.Self.IsContainItem("AssetBundles"))
{
_assetBundlesManifest = ABMgr.Self.GetItemChild("AssetBundles", "AssetBundleManifest") as AssetBundleManifest;
if (callback != null) callback();
}
else
{
D.Error("[Load][LoadAssetBundlesManifest] ERROR");
}
});
}
public Load(string abName, UnityAction callback)
{
_abName = abName;
_loadAction = callback;
}
public void BeginLoad()
{
if (ABMgr.Self.IsContainItem(_abName))
{
_loadAction();
return;
}
if (_assetBundlesManifest != null)
{
string[] arr = _assetBundlesManifest.GetAllDependencies(_abName);
if (arr.Length == 0)
{
ABMgr.Self.Download(_abName, abName =>
{
if (abName == _abName) _loadAction();
});
}
else
{
var needDownLoadList = new List<string>();
foreach (var item in arr)
{
if (!ABMgr.Self.IsContainItem(item)) needDownLoadList.Add(item);
}
ABMgr.Self.Download(needDownLoadList, isSuccess =>
{
if (isSuccess)
{
ABMgr.Self.Download(_abName, abName =>
{
if (abName == _abName) _loadAction();
});
}
});
}
}
}
}
using System;
using UnityEngine;
using System.Collections;
using System.Linq.Expressions;
namespace SK
{
public class Singleton<T> where T : new()
{
private static T _self;
private static readonly object _lockObj;
static Singleton()
{
_lockObj = new object();
}
public static T Self
{
get
{
if (_self == null)
{
lock (_lockObj)
{
if (_self == null)
{
_self = (default(T) == null) ? Activator.CreateInstance<T>() : default(T);
}
}
}
return _self;
}
}
}
public class SingletonMono<T> : MonoBehaviour where T : MonoBehaviour
{
private static T _self;
private static readonly object _lockObj;
static SingletonMono()
{
_lockObj = new object();
}
public static T Self
{
get
{
if (_self == null)
{
lock (_lockObj)
{
if (_self == null)
{
var go = new GameObject(typeof(T).ToString()) ;
_self = go.AddComponent<T>();
DontDestroyOnLoad(go);
}
}
}
return _self;
}
}
}
}
using SK;
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class ABMgrTest : MonoBehaviour
{
void Start()
{
Load.LoadAssetBundlesManifest(LoadAssetBundlesManifestCallback);
}
void LoadAssetBundlesManifestCallback()
{
Load logoLoad = new Load("data", logoLoadCallback);
logoLoad.BeginLoad();
Load boxLoad = new Load("box", boxCallback);
boxLoad.BeginLoad();
}
void logoLoadCallback()
{
if (!ABMgr.Self.IsContainItem("data")) return;
GameObject obj = ABMgr.Self.GetItemChild("data", "pre_cryWolfLogo") as GameObject;
Instantiate(obj);
GameObject obj2 = ABMgr.Self.GetItemChild("data", "pre_cryWolfLogo_url") as GameObject;
Instantiate(obj2);
}
void boxCallback()
{
if (!ABMgr.Self.IsContainItem("box")) return;
GameObject obj = ABMgr.Self.GetItemChild("box", "box") as GameObject;
Instantiate(obj);
}
}