public void Start(ProvideHandle provideHandle)
{
provideHandle.SetProgressCallback(ProgressCallback);
subObjectName = null;
m_ProvideHandle = provideHandle;
m_RequestOperation = null;
List <object> deps = new List <object>(); // TODO: garbage. need to pass actual count and reuse the list
m_ProvideHandle.GetDependencies(deps);
AssetBundle bundle = LoadBundleFromDependecies(deps);
if (bundle == null)
{
m_ProvideHandle.Complete <AssetBundle>(null, false, new Exception("Unable to load dependent bundle from location " + m_ProvideHandle.Location));
}
else
{
var assetPath = m_ProvideHandle.ResourceManager.TransformInternalId(m_ProvideHandle.Location);
if (m_ProvideHandle.Type.IsArray)
{
m_RequestOperation = bundle.LoadAssetWithSubAssetsAsync(assetPath, m_ProvideHandle.Type.GetElementType());
}
else if (m_ProvideHandle.Type.IsGenericType && typeof(IList <>) == m_ProvideHandle.Type.GetGenericTypeDefinition())
{
m_RequestOperation = bundle.LoadAssetWithSubAssetsAsync(assetPath, m_ProvideHandle.Type.GetGenericArguments()[0]);
}
else
{
if (ResourceManagerConfig.ExtractKeyAndSubKey(assetPath, out string mainPath, out string subKey))
{
subObjectName = subKey;
m_RequestOperation = bundle.LoadAssetWithSubAssetsAsync(mainPath, m_ProvideHandle.Type);
}
public InternalProviderOperation <TObject> Start(IResourceLocation location, IAsyncOperation <IList <object> > loadDependencyOperation)
{
m_Result = null;
m_RequestOperation = null;
m_DependencyOperation = loadDependencyOperation;
loadDependencyOperation.Completed += op =>
{
if (op.Status == AsyncOperationStatus.Succeeded)
{
AssetBundle bundle = op.Result[0] as AssetBundle;
if (bundle == null)
{
var handler = op.Result[0] as DownloadHandlerAssetBundle;
if (handler != null)
{
bundle = handler.assetBundle;
}
}
if (bundle == null)
{
//TODO - handle error case properly
SetResult(default(TObject));
OnComplete();
}
else
{
var t = typeof(TObject);
if (t.IsArray)
{
m_RequestOperation = bundle.LoadAssetWithSubAssetsAsync(location.InternalId, t.GetElementType());
}
else if (t.IsGenericType && typeof(IList <>) == t.GetGenericTypeDefinition())
{
m_RequestOperation = bundle.LoadAssetWithSubAssetsAsync(location.InternalId, t.GetGenericArguments()[0]);
}
else
{
m_RequestOperation = bundle.LoadAssetAsync <TObject>(location.InternalId);
}
if (m_RequestOperation.isDone)
{
DelayedActionManager.AddAction((Action <AsyncOperation>)OnComplete, 0, m_RequestOperation);
}
else
{
m_RequestOperation.completed += OnComplete;
}
}
}
else
{
m_Error = op.OperationException;
SetResult(default(TObject));
OnComplete();
}
};
return(base.Start(location));
}
public void Start(ProvideHandle provideHandle)
{
provideHandle.SetProgressCallback(ProgressCallback);
subObjectName = null;
m_ProvideHandle = provideHandle;
m_RequestOperation = null;
List <object> deps = new List <object>(); // TODO: garbage. need to pass actual count and reuse the list
m_ProvideHandle.GetDependencies(deps);
AssetBundle bundle = LoadBundleFromDependecies(deps);
if (bundle == null)
{
m_ProvideHandle.Complete <AssetBundle>(null, false, new Exception("Unable to load dependent bundle from location " + m_ProvideHandle.Location));
}
else
{
var assetPath = m_ProvideHandle.Location.InternalId;
if (m_ProvideHandle.Type.IsArray)
{
m_RequestOperation = bundle.LoadAssetWithSubAssetsAsync(assetPath, m_ProvideHandle.Type.GetElementType());
}
else if (m_ProvideHandle.Type.IsGenericType && typeof(IList <>) == m_ProvideHandle.Type.GetGenericTypeDefinition())
{
m_RequestOperation = bundle.LoadAssetWithSubAssetsAsync(assetPath, m_ProvideHandle.Type.GetGenericArguments()[0]);
}
else
{
var i = assetPath.LastIndexOf('[');
if (i > 0)
{
var i2 = assetPath.LastIndexOf(']');
if (i2 < i)
{
m_ProvideHandle.Complete <AssetBundle>(null, false, new Exception(string.Format("Invalid index format in internal id {0}", assetPath)));
}
else
{
subObjectName = assetPath.Substring(i + 1, i2 - (i + 1));
assetPath = assetPath.Substring(0, i);
m_RequestOperation = bundle.LoadAssetWithSubAssetsAsync(assetPath, m_ProvideHandle.Type);
}
}
else
{
m_RequestOperation = bundle.LoadAssetAsync(assetPath, m_ProvideHandle.Type);
}
}
m_RequestOperation.completed += ActionComplete;
}
}
private void BeginAssetLoad()
{
if (m_AssetBundle == null)
{
m_ProvideHandle.Complete <AssetBundle>(null, false, new Exception("Unable to load dependent bundle from location " + m_ProvideHandle.Location));
}
else
{
var assetPath = m_ProvideHandle.ResourceManager.TransformInternalId(m_ProvideHandle.Location);
if (m_ProvideHandle.Type.IsArray)
{
#if !UNITY_2021_1_OR_NEWER
if (AsyncOperationHandle.IsWaitingForCompletion)
{
GetArrayResult(m_AssetBundle.LoadAssetWithSubAssets(assetPath, m_ProvideHandle.Type.GetElementType()));
CompleteOperation();
}
else
#endif
m_RequestOperation = m_AssetBundle.LoadAssetWithSubAssetsAsync(assetPath, m_ProvideHandle.Type.GetElementType());
}
else if (m_ProvideHandle.Type.IsGenericType && typeof(IList <>) == m_ProvideHandle.Type.GetGenericTypeDefinition())
{
#if !UNITY_2021_1_OR_NEWER
if (AsyncOperationHandle.IsWaitingForCompletion)
{
GetListResult(m_AssetBundle.LoadAssetWithSubAssets(assetPath, m_ProvideHandle.Type.GetGenericArguments()[0]));
CompleteOperation();
}
else
#endif
m_RequestOperation = m_AssetBundle.LoadAssetWithSubAssetsAsync(assetPath, m_ProvideHandle.Type.GetGenericArguments()[0]);
}
else
{
if (ResourceManagerConfig.ExtractKeyAndSubKey(assetPath, out string mainPath, out string subKey))
{
subObjectName = subKey;
#if !UNITY_2021_1_OR_NEWER
if (AsyncOperationHandle.IsWaitingForCompletion)
{
GetAssetSubObjectResult(m_AssetBundle.LoadAssetWithSubAssets(mainPath, m_ProvideHandle.Type));
CompleteOperation();
}
else
#endif
m_RequestOperation = m_AssetBundle.LoadAssetWithSubAssetsAsync(mainPath, m_ProvideHandle.Type);
}
private static int LoadAssetWithSubAssetsAsync(IntPtr L)
{
int result;
try
{
int num = LuaDLL.lua_gettop(L);
if (num == 2 && TypeChecker.CheckTypes(L, 1, typeof(AssetBundle), typeof(string)))
{
AssetBundle assetBundle = (AssetBundle)ToLua.ToObject(L, 1);
string text = ToLua.ToString(L, 2);
AssetBundleRequest o = assetBundle.LoadAssetWithSubAssetsAsync(text);
ToLua.PushObject(L, o);
result = 1;
}
else if (num == 3 && TypeChecker.CheckTypes(L, 1, typeof(AssetBundle), typeof(string), typeof(Type)))
{
AssetBundle assetBundle2 = (AssetBundle)ToLua.ToObject(L, 1);
string text2 = ToLua.ToString(L, 2);
Type type = (Type)ToLua.ToObject(L, 3);
AssetBundleRequest o2 = assetBundle2.LoadAssetWithSubAssetsAsync(text2, type);
ToLua.PushObject(L, o2);
result = 1;
}
else
{
result = LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.AssetBundle.LoadAssetWithSubAssetsAsync");
}
}
catch (Exception e)
{
result = LuaDLL.toluaL_exception(L, e, null);
}
return(result);
}
static int LoadAssetWithSubAssetsAsync(IntPtr L)
{
int count = LuaDLL.lua_gettop(L);
if (count == 2)
{
AssetBundle obj = LuaScriptMgr.GetUnityObject <AssetBundle>(L, 1);
string arg0 = LuaScriptMgr.GetLuaString(L, 2);
AssetBundleRequest o = obj.LoadAssetWithSubAssetsAsync(arg0);
LuaScriptMgr.PushObject(L, o);
return(1);
}
else if (count == 3)
{
AssetBundle obj = LuaScriptMgr.GetUnityObject <AssetBundle>(L, 1);
string arg0 = LuaScriptMgr.GetLuaString(L, 2);
Type arg1 = LuaScriptMgr.GetTypeObject(L, 3);
AssetBundleRequest o = obj.LoadAssetWithSubAssetsAsync(arg0, arg1);
LuaScriptMgr.PushObject(L, o);
return(1);
}
else
{
LuaDLL.luaL_error(L, "invalid arguments to method: AssetBundle.LoadAssetWithSubAssetsAsync");
}
return(0);
}
static AsyncOperationSet GetAssetBundleRequestMultiple <T>(AssetBundle assetBundle, AssetEntryRecord assetEntryRecord) where T : UnityEngine.Object
{
string assetName = assetEntryRecord.AssetName;
AssetBundleRequest request = assetBundle.LoadAssetWithSubAssetsAsync <T>(assetName);
return(AsyncOperationSet.CreateByAssetBundleRequest(request));
}
private IEnumerator LoadAssetOperation(string targetFullPath, string assetName)
{
AssetBundle assetBundle = _loadedAssetBundles[targetFullPath];
yield return(WaitByDependency(assetBundle));
AssetBundleRequest assetBundleRequest = assetBundle.LoadAssetWithSubAssetsAsync(assetName);
yield return(assetBundleRequest);
foreach (var asset in assetBundleRequest.allAssets)
{
Debug.LogFormat("Load Asset {0} : {1} From {2}", asset.name, asset.GetType(), targetFullPath);
_loadedAssetDictionary[asset.name] = asset;
foreach (var loadAssetAction in _loadAssetActions)
{
loadAssetAction(asset);
}
{
var manifest = asset as AssetBundleManifest;
if (manifest != null)
{
Debug.LogFormat("AssetBundleManifest を設定しました. 依存関係を考慮するようにします.");
_assetBundleManifest = manifest;
}
}
}
}
/// <summary>
/// Loads an object from an asset bundle, special-casing sprites and other subasset edge cases (asynchronous version)
/// </summary>
public static async Task <UnityEngine.Object> LoadAssetFromBundleAsync(string bundledName, AssetBundle bundle)
{
var bundleLoadRequest = bundle.LoadAssetAsync(bundledName);
while (!bundleLoadRequest.isDone)
{
await Task.Yield();
}
var asset = bundleLoadRequest.asset;
Type assetType = asset.GetType();
if (assetType == typeof(Texture2D)) //could be a sprite!
{
var bundleLoadRequest2 = bundle.LoadAssetWithSubAssetsAsync <Sprite>(bundledName);
while (!bundleLoadRequest2.isDone)
{
await Task.Yield();
}
var spriteAssets = bundleLoadRequest2.allAssets;
if (spriteAssets != null && spriteAssets.Length > 0)
{
return(spriteAssets[0]);
}
//will that work?
}
return(asset);
}
private IEnumerator _LoadAsync(AssetBundle assetBundle)
{
if (_type != null && _type == typeof(Sprite))
{
var request = assetBundle.LoadAssetWithSubAssetsAsync(_assetPath);
yield return(request);
if (!_disposed)
{
_objects = request.allAssets;
_object = _objects != null && _objects.Length > 0 ? _objects[0] : null;
Complete();
}
}
else
{
var request = _type != null
? assetBundle.LoadAssetAsync(_assetPath, _type)
: assetBundle.LoadAssetAsync(_assetPath);
yield return(request);
if (!_disposed)
{
_object = request.asset;
Complete();
}
}
}
public IEnumerator InstantiateAvatar(Action onInstantiated)
{
Debug.Log("InstantiateAvatar");
if (loadedAssetBundle == null)
{
UIManager.instance.SetMainTitle("Error", "Could not load avatar!");
yield break;
}
UIManager.instance.SetMainTitle(null, "Loading...");
var request = loadedAssetBundle.LoadAssetWithSubAssetsAsync("assets/_customavatar.prefab");
while (!request.isDone && !abort)
{
Debug.Log("loading " + request.progress);//comment this out in build
UIManager.instance.SetMainLoadingBarProgress(request.progress);
yield return(null);
}
if (abort)
{
Debug.Log("Aborting from instantiation...");
request = null;
}
else
{
UIManager.instance.SetMainTitle(null, "Instantiating...");
if ((request.asset as GameObject).transform.FindChild("WTA_IGNORE") != null)
{
Debug.Log("found WTA_IGNORE. Aborting.");
UIManager.instance.SetMainTitle("Error", "This avatar is not public.");
request = null;
yield break;
}
instantiatedAvatar = Instantiate(request.asset) as GameObject;
instantiatedAvatar.transform.position = Vector3.zero;
var bounds = instantiatedAvatar.GetComponentInChildren <Renderer>().bounds.center;
//instantiatedAvatar.transform.position = new Vector3(bounds.x, instantiatedAvatar.transform.position.y, bounds.z);//negative?
//WebGL has issues with alot of shaders.
#if UNITY_WEBGL && !UNITY_EDITOR
PrintOrReplaceShaders(instantiatedAvatar, false, true);
#endif
if (instantiatedAvatar.GetComponent <Animator>())
{
instantiatedAvatar.GetComponent <Animator>().runtimeAnimatorController = GameObject.FindObjectOfType <ObjectHolder>().animationController;
instantiatedAvatar.GetComponent <Animator>().applyRootMotion = false;
}
UIManager.instance.SetMainLoadingBarProgress(1f);
//UIManager.instance.SetStatusText();
loadedAssetBundle.Unload(false);
onInstantiated();
}
}
//-----------------------------------
internal IEnumerator LoadAssetAsyncImpl(string assetName, Type type, AssetBundleAssetLoadRequest req, int mode)
{
asyncCount++;
AssetBundleRequest abr = null;
if (mode == 0)
{
abr = assetBundle.LoadAssetAsync(assetName, type);
}
else if (mode == 1)
{
abr = assetBundle.LoadAssetWithSubAssetsAsync(assetName, type);
}
yield return(abr);
asyncCount--;
if (IsDispose)
{
//应该不会执行. 首先asyncCount>0的时候不会被处置. 如果是重置Mangager, 会停止所有协程
Debug.LogError("AssetBundleBundle is Dispose!");
}
if (!IsDispose)
{
if (mode == 0)
{
if (abr.asset)
{
req.SetAsset(CreateAsset(abr.asset, assetName));
}
}
else if (mode == 1)
{
if (abr.asset)
{
req.SetAsset(CreateAsset(abr.asset, assetName));
}
if (abr.allAssets != null)
{
List <AssetBundleAsset> rli = new List <AssetBundleAsset>();
foreach (var asset in abr.allAssets)
{
rli.Add(CreateAsset(asset, assetName));
}
req.SetAllAssets(rli.ToArray());
}
}
}
req.SetComplete();
}
private IEnumerator LoadCorotine <T>(string _name, AssetBundle _assetBundle, Action <T[], string> _callBack) where T : UnityEngine.Object
{
AssetBundleRequest request = _assetBundle.LoadAssetWithSubAssetsAsync <T>(_name);
yield return(request);
T[] asset = new T[request.allAssets.Length];
for (int i = 0; i < asset.Length; i++)
{
asset[i] = request.allAssets[i] as T;
}
_callBack(asset, string.Empty);
}
public void Start(ProvideHandle provideHandle)
{
m_ProvideHandle = provideHandle;
Type t = m_ProvideHandle.Type;
m_RequestOperation = null;
List <object> deps = new List <object>(); // TODO: garbage. need to pass actual count and reuse the list
m_ProvideHandle.GetDependencies(deps);
AssetBundle bundle = AssetBundleProvider.LoadBundleFromDependecies(deps);
if (bundle == null)
{
m_ProvideHandle.Complete <AssetBundle>(null, false, new Exception("Unable to load dependent bundle from location " + m_ProvideHandle.Location));
}
else
{
if (t.IsArray)
{
m_RequestOperation = bundle.LoadAssetWithSubAssetsAsync(m_ProvideHandle.Location.InternalId, t.GetElementType());
}
else if (t.IsGenericType && typeof(IList <>) == t.GetGenericTypeDefinition())
{
m_RequestOperation = bundle.LoadAssetWithSubAssetsAsync(m_ProvideHandle.Location.InternalId, t.GetGenericArguments()[0]);
}
else
{
m_RequestOperation = bundle.LoadAssetAsync(m_ProvideHandle.Location.InternalId, t);
}
m_RequestOperation.completed += ActionComplete;
provideHandle.SetProgressCallback(ProgressCallback);
}
}
/// <summary>
/// 読み込み開始
/// </summary>
public override void Load(AssetBundle assetBundle)
{
if (this.request == null)
{
if (assetBundle.Contains(this.assetName))
{
this.request = assetBundle.LoadAssetWithSubAssetsAsync<T>(this.assetName);
this.request.completed += (op) =>
{
this.onLoad.SafetyInvoke();
this.onLoad = null;
};
}
else
{
Debug.LogWarningFormat("AssetBundle={0}にassetName={1}は含まれていません", assetBundle.name, this.assetName);
}
}
}
public IObservable <Object> LoadFrom(AssetBundle bundle) => Observable.Defer(() =>
{
if (bundle == null)
{
throw new ArgumentNullException(nameof(bundle));
}
switch (LoadMethod)
{
case LoadMethod.Single:
return(bundle.LoadAssetAsync(AssetName, AssetType)
.AsAsyncOperationObservable().Select(req => req.asset));
case LoadMethod.Multi:
return(bundle.LoadAssetWithSubAssetsAsync(AssetName, AssetType)
.AsAsyncOperationObservable().SelectMany(req => req.allAssets));
default: throw new ArgumentException("Unknown LoadMethod. " + LoadMethod);
}
});
public static int LoadAssetWithSubAssetsAsync(IntPtr l)
{
int result;
try
{
int num = LuaDLL.lua_gettop(l);
if (num == 2)
{
AssetBundle assetBundle = (AssetBundle)LuaObject.checkSelf(l);
string name;
LuaObject.checkType(l, 2, out name);
AssetBundleRequest o = assetBundle.LoadAssetWithSubAssetsAsync(name);
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, o);
result = 2;
}
else if (num == 3)
{
AssetBundle assetBundle2 = (AssetBundle)LuaObject.checkSelf(l);
string name2;
LuaObject.checkType(l, 2, out name2);
Type type;
LuaObject.checkType(l, 3, out type);
AssetBundleRequest o2 = assetBundle2.LoadAssetWithSubAssetsAsync(name2, type);
LuaObject.pushValue(l, true);
LuaObject.pushValue(l, o2);
result = 2;
}
else
{
LuaObject.pushValue(l, false);
LuaDLL.lua_pushstring(l, "No matched override function LoadAssetWithSubAssetsAsync to call");
result = 2;
}
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
public AvatarPrefab(AssetBundle assetBundle, Action <GameObject> loadedCallback)
{
if (assetBundle == null)
{
return;
}
var assetBundleRequest = assetBundle.LoadAssetWithSubAssetsAsync <GameObject>(GameObjectName);
assetBundleRequest.completed += LoadAssetCompleted;
void LoadAssetCompleted(AsyncOperation asyncOperation)
{
Prefab = (GameObject)assetBundleRequest.asset;
if (Prefab != null)
{
_descriptor = Prefab.GetComponent <AvatarDescriptor>();
}
loadedCallback(Prefab);
}
}
private static int LoadAssetWithSubAssetsAsync(IntPtr L)
{
int num = LuaDLL.lua_gettop(L);
if (num == 2)
{
AssetBundle assetBundle = (AssetBundle)LuaScriptMgr.GetUnityObjectSelf(L, 1, "AssetBundle");
string luaString = LuaScriptMgr.GetLuaString(L, 2);
AssetBundleRequest o = assetBundle.LoadAssetWithSubAssetsAsync(luaString);
LuaScriptMgr.PushObject(L, o);
return(1);
}
if (num == 3)
{
AssetBundle assetBundle2 = (AssetBundle)LuaScriptMgr.GetUnityObjectSelf(L, 1, "AssetBundle");
string luaString2 = LuaScriptMgr.GetLuaString(L, 2);
Type typeObject = LuaScriptMgr.GetTypeObject(L, 3);
AssetBundleRequest o2 = assetBundle2.LoadAssetWithSubAssetsAsync(luaString2, typeObject);
LuaScriptMgr.PushObject(L, o2);
return(1);
}
LuaDLL.luaL_error(L, "invalid arguments to method: AssetBundle.LoadAssetWithSubAssetsAsync");
return(0);
}
public IEnumerator LoadResAsys(BundleInfo tmpNode)
{
if (this.ABRes != null)
{
if (tmpNode.isSingle)
{
AssetBundleRequest tmpRequest = ABRes.LoadAssetAsync(tmpNode.resName);
yield return(tmpRequest);
// Debug.Log("tmpRequest resName== "+tmpNode.resName+"==="+tmpRequest.asset.name);
//GameObject.Instantiate(tmpRequest.asset);
tmpNode.AddReses(tmpRequest.asset);
yield return(null);
}
else
{
AssetBundleRequest tmpRequest = ABRes.LoadAssetWithSubAssetsAsync(tmpNode.resName);
yield return(tmpRequest);
// Debug.Log("tmpRequest mutti resName== " + tmpNode.resName+"==="+tmpRequest.allAssets.Length);
tmpNode.AddReses(tmpRequest.allAssets);
yield return(null);
}
}
else
{
Debuger.Log("IResloader AB Not Cantain ==" + tmpNode.resName);
}
}
static AssetBundleRequest GetAssetBundleRequestMultiple <T>(AssetBundle assetBundle, AssetEntryRecord assetEntryRecord) where T : UnityEngine.Object
{
string assetName = assetEntryRecord.AssetName;
return(assetBundle.LoadAssetWithSubAssetsAsync <T>(assetName));
}
