public async Task <AssetRef> LoadAsync(string path, TYPE type) { var option = new LoadingOption() { block = true, allowSceneActivation = false, }; return(await LoadAsync(path, type, option, "")); }
protected async Task <AssetRef> LoadAssetBundleAsync(string path, LoadingOption option) { var assetBundleRef = FindAssetRef(path); if (assetBundleRef != null) { Log.Resource.I("LoadAssetBundleAsync {0} in Cache", path); return(assetBundleRef); } Log.Resource.I("LoadAssetBundleAsync {0}", path); return(await LoadAssetBundleAndDepencenciesAsync(path, option)); }
public virtual async Task <AssetRef> LoadAsync(string path, TYPE type, LoadingOption option, string assetBundlePath) { path = Core.Path.instance.Resolve(path, type); var name = System.IO.Path.GetFileNameWithoutExtension(path); var assetRef = FindAssetRef(path); if (assetRef != null) { Log.Resource.I("LoadAsync {0} in Cache", name); return(assetRef.Refrence()); } if (string.IsNullOrEmpty(assetBundlePath)) { assetBundlePath = Core.Path.instance.Resolve(path, TYPE.AssetBundle); } var assetBundleRef = await LoadAssetBundleAsync(assetBundlePath, option); if (assetBundleRef == null) { return(null); } var assetBundle = assetBundleRef.Get <AssetBundle>(); var assetBundleRequest = assetBundle.LoadAssetAsync(name); var result = await Loading.instance.Wrap(async() => { return(await HookProgress(assetBundleRequest, option.progress, 0.7f)); }, option); if (!result) { return(null); } var asset = assetBundleRequest.asset; if (asset == null) { return(null); } assetRef = new AssetRef(path, asset, new List <AssetRef>() { assetBundleRef }); CacheAssetRef(assetRef.Refrence()); return(assetRef); }
public async Task <T> Run <T>(Func <Task <T> > asynFunc, LoadingOption option) { try { if (option.block) { Show(); } return(await RunInner(asynFunc)); } finally { if (option.block) { Hide(); } } }
public async Task <AsyncOperation> LoadSceneAsync(string path, LoadingOption option) { path = Core.Path.instance.Resolve(path, TYPE.Scene); var operation = SceneManager.LoadSceneAsync(path); operation.allowSceneActivation = option.allowSceneActivation; var result = await Loading.instance.Wrap(async() => { return(await HookProgress(operation, option.progress)); }, option); if (!result) { return(null); } return(operation); }
public async Task <T> Wrap <T>(Func <Task <T> > asynFunc, LoadingOption option) { Func <Task <T> > WrapInner = async() => { try { var ret = await asynFunc(); return(ret); } catch (Exception e) { Log.Framework.Error(e); throw new LoadingTimeoutError(); } }; return(await Run <T>(WrapInner, option)); }
protected virtual async Task <AssetBundleManifest> LoadAssetBundleManifest() { var option = new LoadingOption(); var path = $"Assets/{Path.AssetBundleFolder}/{Path.AssetBundleFolder}"; var assetBundle = await LoadAssetBundleSingleAsync(path, option); var assetBundleRef = new AssetRef(path, assetBundle); var name = "AssetBundleManifest"; var manifest = await assetBundle.LoadAssetAsync <AssetBundleManifest>(name); var manifestRef = new AssetRef(name, manifest, new List <AssetRef>() { assetBundleRef }); CacheAssetRef(manifestRef.Refrence()); return(manifest as AssetBundleManifest); }
public async Task <AsyncOperation> Load(string name, LoadingOption option) { option.allowSceneActivation = false; return(await Resource.instance.LoadSceneAsync(name, option)); }
protected virtual async Task <AssetBundle> LoadAssetBundleSingleAsync(string path, LoadingOption option, float weight = 1.0f) { Log.Resource.Exception(new NotImplementedException()); await Observable.TimerFrame(1); return(null); }
protected async Task <AssetRef> LoadAssetBundleAndDepencenciesAsync(string path, LoadingOption option, Dictionary <string, bool> wait = null) { wait = wait ?? new Dictionary <string, bool>(); if (wait.ContainsKey(path)) { return(null); } wait[path] = true; var dependencies = assetBundleManifest.GetAllDependencies(path); foreach (var dependence in dependencies) { await LoadAssetBundleAndDepencenciesAsync(dependence, option, wait); } var assetBundle = await LoadAssetBundleSingleAsync(path, option); var dependenceRefs = dependencies.Select(x => FindAssetRef(x)).ToList(); var assetBundleRef = new AssetRef(path, assetBundle, dependenceRefs); CacheAssetRef(assetBundleRef); return(assetBundleRef); }
public async Task <AssetRef> LoadAsync(string path, LoadingOption option, TYPE type = TYPE.Prefab) { return(await LoadAsync(path, type, option, "")); }