bool loadAssetAsync(CarpDefineAB checkAsset, AssetBundle assetBundle, System.Type t)
{
requestLoads[checkAsset.assetKey] = null;
if (assetBundle == null)
{
errorAssets.Add(checkAsset.assetKey, true);
}
else if (checkAsset.assetName.Equals(string.Empty))
{
requestLoads[checkAsset.assetKey] = t == null?assetBundle.LoadAllAssetsAsync() : assetBundle.LoadAllAssetsAsync(t);
errorAssets.Add(checkAsset.assetKey, false);
}
else
{
bool exist = assetBundle.Contains(checkAsset.assetName);
if (exist)
{
requestLoads[checkAsset.assetKey] = t == null?assetBundle.LoadAssetAsync(checkAsset.assetName) : assetBundle.LoadAssetAsync(checkAsset.assetName, t);
}
checkError(!exist, string.Format("资源加载错误：（{0}），发生在加载资源内容阶段", checkAsset.assetKey));
errorAssets.Add(checkAsset.assetKey, !exist);
}
return(true);
}
IEnumerator GetAssetBundle()
{
UnityWebRequest www = UnityWebRequest.GetAssetBundle(home.url);
yield return(www.SendWebRequest());
if (www.isNetworkError || www.isHttpError)
{
Debug.Log(www.error);
}
else
{
AssetBundle bundle = DownloadHandlerAssetBundle.GetContent(www);
Debug.Log("Success");
bundle.LoadAllAssetsAsync();
foreach (var name in bundle.GetAllAssetNames())
{
Debug.Log(name);
AssetBundleRequest request = bundle.LoadAssetAsync(name, typeof(GameObject));
yield return(request);
GameObject obj = request.asset as GameObject;
GameObject.Instantiate(obj);
bundle.Unload(false);
}
RestoreAll(LightmapsMode.CombinedDirectional, false, true);
GameObject.FindObjectOfType <Customizer> ().initialize();
}
}
//アセットバンドルのロード
//実際のアセットをロードする
//宴の場合は1アセットバンドル＝1アセットなのでそれに合わせたロードを
IEnumerator LoadAssetBundleAsync(AssetBundle assetBundle, Action onComplete, Action onFailed)
{
AssetBundleRequest request = assetBundle.LoadAllAssetsAsync(GetResourceType());
while (!request.isDone)
{
yield return(null);
}
UnityEngine.Object[] assets = request.allAssets;
if (assets == null || assets.Length <= 0)
{
SetLoadError("AssetBundleType Error");
assetBundle.Unload(true);
onFailed();
}
else
{
LoadAsset(assets[0], onComplete, onFailed);
assets = null;
request = null;
//アセットバンドルを保持して、assetBundle.Unload(true)を呼ぶ
if (FileType == AssetFileType.UnityObject && FileManager.UnloadUnusedType == AssetFileManager.UnloadType.NoneAndUnloadAssetBundleTrue)
{
this.AssetBundle = assetBundle;
}
else
{
assetBundle.Unload(false);
}
}
}
public IEnumerator LoadAsync()
{
FARLogger.Debug($"Loading asset bundle {BundlePath}");
AssetBundleCreateRequest createRequest = AssetBundle.LoadFromFileAsync(BundlePath);
yield return(createRequest);
assetBundle = createRequest.assetBundle;
if (assetBundle == null)
{
FARLogger.Error($"Could not load asset bundle from {BundlePath}");
yield break;
}
AssetBundleRequest loadRequest = assetBundle.LoadAllAssetsAsync(typeof(T));
yield return(loadRequest);
foreach (Object asset in loadRequest.allAssets)
{
FARLogger.Debug($"Adding {asset} to dictionary");
Add(asset.name, (T)asset);
}
FARLogger.Debug($"Finished loading {typeof(T)} assets from {BundlePath}");
AssetsLoaded = true;
OnLoad();
}
/// <summary>
/// 加载Asset
/// </summary>
/// <param name="abName"></param>
/// <param name="assetType"></param>
/// <returns></returns>
IEnumerator OnLoadAsset(string abName, Type assetType)
{
AssetBundleData bundleData = GetLoadedAssetBundle(abName);
if (bundleData == null)
{
yield return(StartCoroutine(OnLoadAssetBundle(abName, assetType)));
bundleData = GetLoadedAssetBundle(abName);
if (bundleData == null)
{
m_loadRequests.Remove(abName);
Debug.LogError("OnLoadAsset-->>" + abName);
yield break;
}
}
List <LoadAssetRequest> list = null;
if (!m_loadRequests.TryGetValue(abName, out list))
{
m_loadRequests.Remove(abName);
}
for (int i = 0; i < list.Count; i++)
{
string[] assetNames = list[i].assetNames;
List <Object> result = new List <Object>();
AssetBundle ab = bundleData.assetBundle;
if (assetNames != null)
{
for (int j = 0; j < assetNames.Length; j++)
{
string assetPath = assetNames[i];
var request = ab.LoadAssetAsync(assetPath, assetType);
yield return(request);
result.Add(request.asset);
}
}
else
{
var request = ab.LoadAllAssetsAsync();
yield return(request);
result = new List <Object>(request.allAssets);
}
if (list[i].callback != null)
{
list[i].callback(result.ToArray());
list[i].callback = null;
}
bundleData.referencedCount++;
}
m_loadRequests.Remove(abName);
}
IEnumerator cacheAllAssets()
{
if (_assetBundle == null)
{
yield break;
}
_isCachingAssets = true;
AssetBundleRequest allAssetsRequest = _assetBundle.LoadAllAssetsAsync();
yield return(allAssetsRequest);
if (_assetBundle == null || _cachedObjects == null)
{
_isCachingAssets = false;
yield break;
}
foreach (UnityEngine.Object asset in allAssetsRequest.allAssets)
{
string name = asset.name;
if (!_cachedObjects.ContainsKey(name)) // This object might have already been added to the cache from GetObject
{
_cachedObjects.Add(name, asset);
}
}
unloadAssetBundle();
_isCachingAssets = false;
}
/// <summary>
/// アセットバンドルから全てのアセットを非同期読み込みする
/// </summary>
/// <returns>コルーチン</returns>
/// <param name="assetBundle">アセットバンドル</param>
/// <param name="onError">エラー時コールバック</param>
/// <param name="onCompleted">完了時コールバック</param>
public IEnumerator LoadAllAssetsAsyncFromAssetBundle(AssetBundle assetBundle,
System.Action <string> onError,
System.Action <Object[]> onCompleted)
{
var assetBundleRequest = assetBundle.LoadAllAssetsAsync();
while (!assetBundleRequest.isDone)
{
yield return(null);
}
if (assetBundleRequest.allAssets == null || assetBundleRequest.allAssets.Length <= 0)
{
if (onError != null)
{
onError.Invoke(string.Format("{0} AllAssetsLoadFailed.", assetBundle.name));
}
yield break;
}
if (onCompleted != null)
{
onCompleted.Invoke(assetBundleRequest.allAssets);
}
}
IEnumerator LoadManifest(Action initSuccess, Action <string> initFail)
{
// 只可能是从 StreamingAssets 里面 ， 或者download path 里面 ----
string url = m_pathConfig.getManifestPath();
WWW loader = new WWW(url);
yield return(loader);
if (!string.IsNullOrEmpty(loader.error))
{
initFail("Load Manifest Url:" + url + " error: " + loader.error);
yield break;
}
AssetBundle assetObj = loader.assetBundle;
AssetBundleRequest request = assetObj.LoadAllAssetsAsync <AssetBundleManifest>();
yield return(request);
if (request == null || request.asset == null)
{
initFail("Load Manifest Url: " + url + " error: no AssetBundleManifest in the Bundle file");
yield break;
}
m_assetBundleManifest = request.asset as AssetBundleManifest;
m_allManifest = m_assetBundleManifest.GetAllAssetBundles();
initSuccess();
}
static int LoadAllAssetsAsync(IntPtr L)
{
int count = LuaDLL.lua_gettop(L);
if (count == 1)
{
AssetBundle obj = (AssetBundle)LuaScriptMgr.GetUnityObjectSelf(L, 1, "AssetBundle");
AssetBundleRequest o = obj.LoadAllAssetsAsync();
LuaScriptMgr.PushObject(L, o);
return(1);
}
else if (count == 2)
{
AssetBundle obj = (AssetBundle)LuaScriptMgr.GetUnityObjectSelf(L, 1, "AssetBundle");
Type arg0 = LuaScriptMgr.GetTypeObject(L, 2);
AssetBundleRequest o = obj.LoadAllAssetsAsync(arg0);
LuaScriptMgr.PushObject(L, o);
return(1);
}
else
{
LuaDLL.luaL_error(L, "invalid arguments to method: AssetBundle.LoadAllAssetsAsync");
}
return(0);
}
private static int LoadAllAssetsAsync(IntPtr L)
{
int result;
try
{
int num = LuaDLL.lua_gettop(L);
if (num == 1 && TypeChecker.CheckTypes(L, 1, typeof(AssetBundle)))
{
AssetBundle assetBundle = (AssetBundle)ToLua.ToObject(L, 1);
AssetBundleRequest o = assetBundle.LoadAllAssetsAsync();
ToLua.PushObject(L, o);
result = 1;
}
else if (num == 2 && TypeChecker.CheckTypes(L, 1, typeof(AssetBundle), typeof(Type)))
{
AssetBundle assetBundle2 = (AssetBundle)ToLua.ToObject(L, 1);
Type type = (Type)ToLua.ToObject(L, 2);
AssetBundleRequest o2 = assetBundle2.LoadAllAssetsAsync(type);
ToLua.PushObject(L, o2);
result = 1;
}
else
{
result = LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.AssetBundle.LoadAllAssetsAsync");
}
}
catch (Exception e)
{
result = LuaDLL.toluaL_exception(L, e, null);
}
return(result);
}
public IEnumerator LoadAsync()
{
FARLogger.Debug(string.Format("Loading asset bundle {0}", BundlePath));
var createRequest = AssetBundle.LoadFromFileAsync(BundlePath);
yield return(createRequest);
assetBundle = createRequest.assetBundle;
if (assetBundle == null)
{
FARLogger.Error(string.Format("Could not load asset bundle from {0}", BundlePath));
yield break;
}
var loadRequest = assetBundle.LoadAllAssetsAsync(typeof(T));
yield return(loadRequest);
foreach (var asset in loadRequest.allAssets)
{
FARLogger.Debug(string.Format("Adding {0} to dictionary", asset));
Add(asset.name, (T)asset);
}
FARLogger.Debug(string.Format("Finished loading {0} assets from {1}", typeof(T), BundlePath));
AssetsLoaded = true;
OnLoad();
}
private IEnumerator DoLoadAllAssetBundle(AssetBundle assetBundle)
{
var request = assetBundle.LoadAllAssetsAsync <T>();
while (!request.isDone)
{
assetInfo.Progress = request.progress;
asc.SetProgress(assetInfo.Progress);
yield return(null);
}
assetInfo.Progress = 1f;
asc.SetProgress(assetInfo.Progress);
assetInfo.IsCompleted = request.isDone;
assetInfo.Asset = request.allAssets as T;
assetInfo.IsSuccess = assetInfo.Asset != null;
assetInfo.IsError = assetInfo.Asset == null;
if (assetInfo.IsError && assetInfo.Asset == null)
{
assetInfo.ErrorMsg = $"load all asset in {assetInfo.AssetPath} is null";
asc.SetException(new AssetLoaderException(assetInfo.ErrorMsg));
}
else
{
asc.SetResult(assetInfo.Asset);
}
}
/// <summary>
/// 异步加载 by邓成
/// </summary>
protected IEnumerator LoadAssetAsync <T>(AssetBundle _assetBundle,
string _shortURL,
string _name,
System.Action <T, EResult> _onComplete,
System.Action <float> _onLoadAsyncProgressUpdate = null) where T : UnityEngine.Object
{
AssetBundleRequest request = _assetBundle.LoadAllAssetsAsync(typeof(T));
if (_onLoadAsyncProgressUpdate == null)
{
yield return(request);
}
else
{
while (request.isDone == false)
{
_onLoadAsyncProgressUpdate(request.progress);
yield return(null);
}
_onLoadAsyncProgressUpdate(request.progress);
}
T asset = request.asset as T;
if (asset != null)
{
_onComplete(asset, EResult.Success);
}
else
{
Debug.LogError("Failed to load " + _name + " from " + _shortURL);
_onComplete(asset, EResult.NotFound);
}
}
internal AssetBundleRequest GetAssetPreloadRequest()
{
if (m_PreloadCompleted || GetAssetBundle() == null)
{
return(null);
}
if (m_Options.AssetLoadMode == AssetLoadMode.AllPackedAssetsAndDependencies)
{
#if !UNITY_2021_1_OR_NEWER
if (AsyncOperationHandle.IsWaitingForCompletion)
{
m_AssetBundle.LoadAllAssets();
m_PreloadCompleted = true;
return(null);
}
#endif
if (m_PreloadRequest == null)
{
m_PreloadRequest = m_AssetBundle.LoadAllAssetsAsync();
m_PreloadRequest.completed += operation => m_PreloadCompleted = true;
}
return(m_PreloadRequest);
}
return(null);
}
IEnumerator loadEmotion(AssetBundle ab, string name, UnityAction <Sprite[]> callback)
{
if (!ab)
{
Debug.LogError("ab is null");
yield break;
}
if (name.isNullOrEmpty())
{
Debug.LogError("name is null");
yield break;
}
if (callback.isNull())
{
Debug.LogError("callback is null");
yield break;
}
var request = ab.LoadAllAssetsAsync <Sprite>();
yield return(request);
callback(request.allAssets.Cast <Sprite>().ToArray());
if (emotionCounter.ContainsKey(name))
{
emotionCounter[name] += 1;
}
else
{
emotionCounter.Add(name, 1);
}
}
private IEnumerator LoadAssetObject(AssetBundle bundle, LoadObjectCallback callback)
{
var request = bundle.LoadAllAssetsAsync <Object> ();
while (!request.isDone)
{
yield return(request);
}
if (request.asset != null)
{
if (callback != null)
{
callback(0, request.asset);
}
}
else
{
if (callback != null)
{
Debug.LogErrorFormat("LoadAssetObject {0} null", bundle.name);
callback(-1, null);
}
}
request = null;
}
public static async ETTask <UnityEngine.Object[]> UnityLoadAssetAsync(AssetBundle assetBundle)
{
var tcs = new ETTaskCompletionSource <UnityEngine.Object[]>();
AssetBundleRequest request = assetBundle.LoadAllAssetsAsync();
request.completed += operation => { tcs.SetResult(request.allAssets); };
return(await tcs);
}
private IEnumerator LoadAllAssets_ByAssetbundle(AssetLoaderRequest rRequest, AssetBundle rAssetbundle)
{
var rAllAssetsRequest = rAssetbundle.LoadAllAssetsAsync();
yield return(rAllAssetsRequest);
rRequest.AllAssets = rAllAssetsRequest.allAssets;
}
override public IEnumerator LoadAsync(AssetBundle bundle)
{
var request = bundle.LoadAllAssetsAsync();
yield return(request);
_object = request.allAssets;
}
/// <summary>
/// 异步加载
/// </summary>
/// <returns></returns>
public AssetBundleRequest LoadAllAssetsAsync()
{
if (Bundle != null)
{
return(Bundle.LoadAllAssetsAsync());
}
return(null);
}
public static IObservable <AssetBundleRequest> LoadAllAsObserable(this AssetBundle bundle)
{
if (bundle == null)
{
return(Observable.Empty <AssetBundleRequest>());
}
return(bundle.LoadAllAssetsAsync().AsAsyncOperationObservable());
}
IEnumerator ShowImage()
{
AssetBundleRequest pAssetBundleTexture = _pAssetBundle.LoadAllAssetsAsync <Sprite>();
yield return(pAssetBundleTexture);
_pImage.sprite = pAssetBundleTexture.asset as Sprite;
}
private IEnumerator LoadAllAssetsAsync(AssetBundle assetBundle)
{
AssetBundleRequest req = assetBundle.LoadAllAssetsAsync();
while (!req.isDone)
{
yield return(null);
}
}
private IEnumerator GetProjectFromLocalAssetBundle(string fullPath)
{
print("2");
while (!Caching.ready)
{
yield return(null);
}
IsDownload = true;
using (WWW objLocal = WWW.LoadFromCacheOrDownload(fullPath, BUNDLE_VERSION))
{
objLocal.threadPriority = ThreadPriority.Low;
while (!objLocal.isDone)
{
yield return(null);
}
_commonAssetBundle = objLocal.assetBundle;
AssetBundleRequest assetsRequest = _commonAssetBundle.LoadAllAssetsAsync();
// ActivityIndicator.SetActive(true);
yield return(assetsRequest);
// ActivityIndicator.SetActive(false);
var assets = assetsRequest.allAssets;
List <GameObject> instantiateAssets = new List <GameObject>();
foreach (Object asset in assets)
{
var prefab = InstantiateModel((GameObject)asset, true, asset.name.ToLower(),
!asset.name.ToLower().Contains("armode"));
instantiateAssets.Add(prefab);
}
IsDownload = false;
_assetsList.AddRange(instantiateAssets);
_commonAssetBundle.Unload(false);
//_arMarker.SetActive(false);
//if (!FindObjectOfType<MainCanvasController>().IsTracking)
//{
// ScanLine.SetActive(true);
//}
//_closeContent.SetActive(true);
//Events.OnProjectScanEvent(true);
WriteToPrefs(fullPath);
yield return(new WaitForEndOfFrame());
}
}
///アセットバンドルのメインアセットをロード
public IEnumerator LoadAssetBundleAllAsync <T>(bool unloadAllLoadedObjects, Action <T[]> onComplete, Action onFailed) where T : UnityEngine.Object
{
AssetBundle assetBundle = null;
yield return(LoadAssetBundleAsync(
//OnComplete
(_www, _assetBundle) =>
{
assetBundle = _assetBundle;
},
//OnFailed
(_www) =>
{
//失敗
if (onFailed != null)
{
onFailed();
}
}
));
if (assetBundle == null)
{
yield break;
}
AssetBundleRequest request = assetBundle.LoadAllAssetsAsync <T>();
while (!request.isDone)
{
yield return(null);
}
T[] assets = request.allAssets as T[];
if (assets == null || assets.Length <= 0)
{
//失敗
if (!IgnoreDebugLog)
{
Debug.LogError(Url + " " + " is not AssetBundle of " + typeof(T).Name);
}
if (onFailed != null)
{
onFailed();
}
}
else
{
//成功！
if (onComplete != null)
{
onComplete(assets);
}
}
assets = null;
request = null;
assetBundle.Unload(unloadAllLoadedObjects);
}
private void OnCreateRequest(AsyncOperation async)
{
var request = (AssetBundleCreateRequest)async;
bundle = request.assetBundle;
var bundleRequest = bundle.LoadAllAssetsAsync();
bundleRequest.completed += OnBundleRequest;
}
public Task <UnityEngine.Object[]> LoadAllAssetsAsync()
{
this.tcs = new TaskCompletionSource <UnityEngine.Object[]>();
this.request = assetBundle.LoadAllAssetsAsync();
GameLoop.onUpdate += Update;
return(this.tcs.Task);
}
IEnumerator DoGetAllResourcesAsync <T>(AssetBundle ab, BKAction <T[]> onComplete)
where T : UnityEngine.Object
{
var req = ab.LoadAllAssetsAsync <T>();
yield return(req);
onComplete((T[])req.allAssets);
}
public void LoadCatalogFromBundleAsync()
{
//Debug.Log($"LoadCatalogFromBundleAsync frame : {Time.frameCount}");
if (m_OpInProgress)
{
Addressables.LogError($"Operation in progress : A catalog is already being loaded. Please wait for the operation to complete.");
return;
}
m_OpInProgress = true;
if (ResourceManagerConfig.ShouldPathUseWebRequest(m_BundlePath))
{
var req = UnityWebRequestAssetBundle.GetAssetBundle(m_BundlePath);
if (m_WebRequestTimeout > 0)
{
req.timeout = m_WebRequestTimeout;
}
m_WebRequestQueueOperation = WebRequestQueue.QueueRequest(req);
if (m_WebRequestQueueOperation.IsDone)
{
m_RequestOperation = m_WebRequestQueueOperation.Result;
if (m_RequestOperation.isDone)
{
WebRequestOperationCompleted(m_RequestOperation);
}
else
{
m_RequestOperation.completed += WebRequestOperationCompleted;
}
}
else
{
m_WebRequestQueueOperation.OnComplete += asyncOp =>
{
m_RequestOperation = asyncOp;
m_RequestOperation.completed += WebRequestOperationCompleted;
};
}
}
else
{
m_LoadBundleRequest = AssetBundle.LoadFromFileAsync(m_BundlePath);
m_LoadBundleRequest.completed += loadOp =>
{
if (loadOp is AssetBundleCreateRequest createRequest && createRequest.assetBundle != null)
{
m_CatalogAssetBundle = createRequest.assetBundle;
m_LoadTextAssetRequest = m_CatalogAssetBundle.LoadAllAssetsAsync <TextAsset>();
if (m_LoadTextAssetRequest.isDone)
{
LoadTextAssetRequestComplete(m_LoadTextAssetRequest);
}
m_LoadTextAssetRequest.completed += LoadTextAssetRequestComplete;
}
// --------- AssetBundle extension methods --------- //
public static IPromise LoadAllAssetsPromise(this AssetBundle bundle)
{
var p = Promise.Create();
var request = bundle.LoadAllAssetsAsync();
CoroutineExtensions.WaitUntil(request)
.ThenDo(() => p.Resolve(request.allAssets));
return(p);
}
// Wait for the Caching system to be ready
IEnumerator LoadFromFile(string gameCodeName)
{
while (!Caching.ready)
yield return null;
// Load the AssetBundle file from Cache if it exists with the same version or download and store it in the cache
using (www = WWW.LoadFromCacheOrDownload(_localizationFile, 1))
{
#if UNITY_ANDROID || UNITY_EDITOR
if (DeviceDetector.device == DeviceDetector.Device.Android && MainScript.isCurrentActivity)
{
activity.Call("onGameBundleLoadStart", gameCodeName);
}
#endif
yield return www;
if (www.error != null)
{
#if UNITY_ANDROID || UNITY_EDITOR
if (DeviceDetector.device == DeviceDetector.Device.Android && MainScript.isCurrentActivity)
{
activity.Call("onGameBundleLoadError", new object[] { gameCodeName, www.error });
}
#endif
throw new Exception("WWW download had an error:" + www.error);
}
bundle = www.assetBundle;
assetRequest = bundle.LoadAllAssetsAsync();
yield return assetRequest;
if (assetRequest.isDone == true)
{
#if UNITY_ANDROID || UNITY_EDITOR
if (DeviceDetector.device == DeviceDetector.Device.Android && MainScript.isCurrentActivity)
{
activity.Call("onGameBundleLoadComplete", gameCodeName);
}
#endif
LoadScene();
}
}
}