protected virtual IEnumerator DoLoadAssetWithSubAssetsAsync <T>(IProgressPromise <float, T[]> promise, string name) where T : Object { string key = Key(name, typeof(T), "SubAssets"); AssetBundleRequest request; if (!this.requestCache.TryGetValue(key, out request)) { var fullName = GetFullName(name); request = this.AssetBundle.LoadAssetWithSubAssetsAsync(fullName, typeof(T)); this.requestCache.Add(key, request); } while (!request.isDone) { promise.UpdateProgress(request.progress); yield return(null); } this.requestCache.Remove(key); var all = request.allAssets; T[] assets = new T[all.Length]; for (int i = 0; i < all.Length; i++) { assets[i] = ((T)all[i]); } promise.UpdateProgress(1f); promise.SetResult(assets); }
protected virtual IEnumerator DoLoadAssetsToMapAsync <T>(IProgressPromise <float, Dictionary <string, T> > promise, params string[] names) where T : Object { Dictionary <string, T> results = new Dictionary <string, T>(); int count = names.Length; float progress = 0f; for (int i = 0; i < count; i++) { var name = names[i]; var fullName = GetFullName(name); AssetBundleRequest request = this.assetBundle.LoadAssetAsync <T>(fullName); while (!request.isDone) { promise.UpdateProgress(progress + request.progress / count); yield return(null); } progress += 1f / count; T asset = (T)request.asset; if (asset != null && !results.ContainsKey(name)) { results.Add(name, asset); } } promise.UpdateProgress(1f); promise.SetResult(results); }
/// <summary> /// Simulate a task. /// </summary> /// <returns>The task.</returns> /// <param name="promise">Promise.</param> protected void DoTask(IProgressPromise <float, string> promise) { try { int n = 50; float progress = 0f; StringBuilder buf = new StringBuilder(); for (int i = 0; i < n; i++) { /* If the task is cancelled, then stop the task */ if (promise.IsCancellationRequested) { promise.SetCancelled(); break; } progress = i / (float)n; buf.Append(" ").Append(i); promise.UpdateProgress(progress);/* update the progress of task. */ #if NETFX_CORE Task.Delay(200).Wait(); #else Thread.Sleep(200); #endif } promise.UpdateProgress(1f); promise.SetResult(buf.ToString()); /* update the result. */ } catch (System.Exception e) { promise.SetException(e); } }
private IEnumerator CreateViewGo <T>(IProgressPromise <float, T> promise, View view, string path, ViewModel viewModel) where T : View { var request = _res.LoadAssetAsync <GameObject>(path); while (!request.IsDone) { promise.UpdateProgress(request.Progress); yield return(null); } GameObject viewTemplateGo = request.Result; if (viewTemplateGo == null) { promise.UpdateProgress(1f); Log.Error($"Not found the window path = \"{path}\"."); promise.SetException(new FileNotFoundException(path)); yield break; } GameObject go = Object.Instantiate(viewTemplateGo); view.SetGameObject(go); go.name = viewTemplateGo.name; promise.UpdateProgress(1f); promise.SetResult(view); view.SetVm(viewModel); }
protected virtual IEnumerator DoLoadAssetAsync <T>(IProgressPromise <float, T> promise, string name) where T : Object { string key = Key(name, typeof(T)); AssetBundleRequest request; if (!this.requestCache.TryGetValue(key, out request)) { var fullName = GetFullName(name); request = this.AssetBundle.LoadAssetAsync <T>(fullName); this.requestCache.Add(key, request); } while (!request.isDone) { promise.UpdateProgress(request.progress); yield return(null); } this.requestCache.Remove(key); Object asset = request.asset; if (asset == null) { promise.SetException(new System.Exception(string.Format("Not found the asset '{0}'.", name))); yield break; } promise.UpdateProgress(1f); promise.SetResult(asset); }
protected virtual IEnumerator DoLoadAllAssetsAsync <T>(IProgressPromise <float, T[]> promise) where T : Object { List <T> assets = new List <T>(); string[] fullNames = AssetDatabase.GetAssetPathsFromAssetBundle(this.GetBundleNameWhitExtension()); for (int i = 0; i < fullNames.Length; i++) { var fullName = fullNames[i]; promise.UpdateProgress((float)i / fullNames.Length); if (fullName.EndsWith(".unity", System.StringComparison.OrdinalIgnoreCase)) { continue; } Object[] array = AssetDatabase.LoadAllAssetRepresentationsAtPath(fullName); foreach (Object asset in array) { if (asset != null && asset is T && !(asset is SceneAsset) && !(asset is DefaultAsset)) { assets.Add((T)asset); } } yield return(null); } promise.UpdateProgress(1f); promise.SetResult(assets.ToArray()); }
protected virtual IEnumerator DoLoadAssetsAsync <T>(IProgressPromise <float, T[]> promise, params string[] names) where T : Object { List <T> results = new List <T>(); int count = names.Length; float progress = 0f; foreach (string name in names) { var fullName = GetFullName(name); AssetBundleRequest request = this.AssetBundle.LoadAssetAsync <T>(fullName); while (!request.isDone) { promise.UpdateProgress(progress + request.progress / count); yield return(null); } progress += 1f / count; T asset = (T)request.asset; if (asset != null) { results.Add(asset); } } promise.UpdateProgress(1f); promise.SetResult(results.ToArray()); }
protected virtual IEnumerator DoDownloadFileAsync(string path, FileInfo fileInfo, IProgressPromise <ProgressInfo> promise, float overtimeTime) { if (fileInfo.Directory != null && !fileInfo.Directory.Exists) { fileInfo.Directory.Create(); } ProgressInfo progressInfo = new ProgressInfo { TotalCount = 1 }; using (UnityWebRequest www = new UnityWebRequest(path)) { var downloadFileHandler = new DownloadFileHandler(fileInfo); www.downloadHandler = downloadFileHandler; www.SendWebRequest(); float timer = 0; while (!www.isDone) { if (www.downloadProgress >= 0) { if (progressInfo.TotalSize <= 0) { progressInfo.TotalSize = (long)(www.downloadedBytes / www.downloadProgress); } progressInfo.CompletedSize = (long)www.downloadedBytes; promise.UpdateProgress(progressInfo); } timer += Time.deltaTime; if (timer > overtimeTime) { promise.SetException(new TimeoutException()); break; } yield return(null); } while (!downloadFileHandler.WriteFinish) { timer += Time.deltaTime; if (timer > overtimeTime) { promise.SetException(new TimeoutException()); break; } yield return(null); } if (www.isNetworkError || www.isHttpError) { promise.SetException(www.error); yield break; } progressInfo.CompletedCount = 1; progressInfo.CompletedSize = progressInfo.TotalSize; promise.UpdateProgress(progressInfo); promise.SetResult(fileInfo); } }
protected virtual IEnumerator DoLoadAssetsToMapAsync <T>(IProgressPromise <float, Dictionary <string, T> > promise, params string[] names) where T : Object { if (names == null || names.Length <= 0) { promise.SetResult(new Object[0]); yield break; } Dictionary <string, ResourceRequest> requests = new Dictionary <string, ResourceRequest>(); for (int i = 0; i < names.Length; i++) { var name = names[i]; if (requests.ContainsKey(name)) { continue; } var fullName = this.GetFilePathWithoutExtension(name); var request = Resources.LoadAsync <T>(fullName); requests.Add(name, request); } int count = requests.Count; float progress = 0f; bool finished = false; do { yield return(null); finished = true; progress = 0f; foreach (ResourceRequest request in requests.Values) { if (!request.isDone) { finished = false; } progress += request.progress; } promise.UpdateProgress(progress / count); } while (!finished); Dictionary <string, T> assets = new Dictionary <string, T>(); foreach (var kv in requests) { var key = kv.Key; var request = kv.Value; T asset = (T)request.asset; if (asset != null && !assets.ContainsKey(key)) { assets.Add(key, asset); } } promise.UpdateProgress(1f); promise.SetResult(assets); }
protected virtual IEnumerator DoLoadAssetsAsync(IProgressPromise <float, Object[]> promise, System.Type type, params string[] names) { if (names == null || names.Length <= 0) { promise.SetResult(new Object[0]); yield break; } Dictionary <string, ResourceRequest> requests = new Dictionary <string, ResourceRequest>(); foreach (string name in names) { var fullName = this.GetFilePathWithoutExtension(name); if (requests.ContainsKey(fullName)) { continue; } var request = Resources.LoadAsync(fullName, type); requests.Add(fullName, request); } int count = requests.Count; float progress = 0f; bool finished = false; do { yield return(null); finished = true; progress = 0f; foreach (ResourceRequest request in requests.Values) { if (!request.isDone) { finished = false; } progress += request.progress; } promise.UpdateProgress(progress / count); } while (!finished); List <Object> assets = new List <Object>(); foreach (ResourceRequest request in requests.Values) { Object asset = request.asset; if (asset != null) { assets.Add(asset); } } promise.UpdateProgress(1f); promise.SetResult(assets.ToArray()); }
protected virtual IEnumerator DoLoad <T>(IProgressPromise <float, T> promise, string name) { name = Normalize(name); WeakReference weakRef; GameObject viewTemplateGo = null; try { if (this.templates.TryGetValue(name, out weakRef) && weakRef.IsAlive) { viewTemplateGo = (GameObject)weakRef.Target; //Check if the object is valid because it may have been destroyed. //Unmanaged objects,the weak caches do not accurately track the validity of objects. if (viewTemplateGo != null) { string goName = viewTemplateGo.name; } } } catch (Exception) { viewTemplateGo = null; } if (viewTemplateGo == null) { ResourceRequest request = Resources.LoadAsync <GameObject>(name); while (!request.isDone) { promise.UpdateProgress(request.progress); yield return(null); } viewTemplateGo = (GameObject)request.asset; if (viewTemplateGo != null) { viewTemplateGo.SetActive(false); this.templates[name] = new WeakReference(viewTemplateGo); } } if (viewTemplateGo == null || viewTemplateGo.GetComponent <T>() == null) { promise.UpdateProgress(1f); promise.SetException(new NotFoundException(name)); yield break; } GameObject go = GameObject.Instantiate(viewTemplateGo); go.name = viewTemplateGo.name; promise.UpdateProgress(1f); promise.SetResult(go.GetComponent <T>()); }
private async void instantiateAsync(AsyncOperationHandle <GameObject> operation, IProgressPromise <float, GameObject> promise) { _handles.Add(operation); while (!operation.IsDone) { promise.UpdateProgress(operation.PercentComplete); await Task.Yield(); } promise.UpdateProgress(1); promise.SetResult(operation.Result); }
private IEnumerator DoLoadGameScene(IProgressPromise <float> progressPromise) { AsyncOperation asyncOperation = SceneManager.LoadSceneAsync("GameScene"); while (!asyncOperation.isDone) { progressPromise.UpdateProgress(asyncOperation.progress); yield return(null); } progressPromise.UpdateProgress(1f); progressPromise.SetResult(); }
protected override async void loadAssetAsync <T>(string key, IProgressPromise <float, T> promise) { var operation = Resources.LoadAsync <T>(key); while (!operation.isDone) { promise.UpdateProgress(operation.progress); await Task.Yield(); } promise.UpdateProgress(1); promise.SetResult(operation.asset as T); _handles.Add(operation.asset); }
private IEnumerator loadAsync <T>(string key, IProgressPromise <float, T> promise) where T : Object { var operation = Resources.LoadAsync <T>(key); requests.Add(operation); while (!operation.isDone) { promise.UpdateProgress(operation.progress); yield return(null); } promise.UpdateProgress(1); promise.SetResult(operation.asset as T); _handles.Add(operation.asset); }
protected override async void LoadScene(IProgressPromise <float, Scene> promise, string path, LoadSceneMode loadSceneMode) { var loader = Addressables.LoadSceneAsync(path, loadSceneMode); while (!loader.IsDone) { await Task.Yield(); promise.UpdateProgress(loader.PercentComplete); } promise.UpdateProgress(1); promise.SetResult(loader.Result.Scene); }
protected virtual IEnumerator DoLoadAllAssetsAsync(IProgressPromise <float, Object[]> promise, System.Type type) { try { Object[] assets = Resources.LoadAll(this.Root); promise.UpdateProgress(1f); promise.SetResult(assets); } catch (System.Exception e) { promise.UpdateProgress(0f); promise.SetException(e); } yield break; }
protected virtual IEnumerator DoLoadAllAssetsAsync <T>(IProgressPromise <float, T[]> promise) where T : Object { try { T[] assets = Resources.LoadAll <T>(this.Root); promise.UpdateProgress(1f); promise.SetResult(assets); } catch (System.Exception e) { promise.UpdateProgress(0f); promise.SetException(e); } yield break; }
protected virtual IEnumerator DoDownloadFileAsync(Uri path, FileInfo fileInfo, IProgressPromise <ProgressInfo> promise) { if (!fileInfo.Directory.Exists) { fileInfo.Directory.Create(); } ProgressInfo progressInfo = new ProgressInfo(); progressInfo.TotalCount = 1; using (UnityWebRequest www = new UnityWebRequest(this.GetAbsoluteUri(path).AbsoluteUri)) { www.downloadHandler = new DownloadFileHandler(fileInfo); #if UNITY_2018_1_OR_NEWER www.SendWebRequest(); #else www.Send(); #endif while (!www.isDone) { if (www.downloadProgress >= 0) { if (progressInfo.TotalSize <= 0) { progressInfo.TotalSize = (long)(www.downloadedBytes / www.downloadProgress); } progressInfo.CompletedSize = (long)www.downloadedBytes; promise.UpdateProgress(progressInfo); } yield return(null); } #if UNITY_2018_1_OR_NEWER if (www.isNetworkError) #else if (www.isError) #endif { promise.SetException(www.error); yield break; } progressInfo.CompletedCount = 1; progressInfo.CompletedSize = progressInfo.TotalSize; promise.UpdateProgress(progressInfo); promise.SetResult(fileInfo); } }
private static async void loadScene(string scene, LoadSceneMode loadSceneMode, IProgressPromise <float, SceneInstance> promise, bool activeOnLoaded) { var loader = Addressables.LoadSceneAsync(scene, loadSceneMode, activeOnLoaded); while (!loader.IsDone) { await Task.Yield(); promise.UpdateProgress(loader.PercentComplete); } promise.UpdateProgress(1); Log.Msg("加载场景", scene, loader.Status, loader.Result); promise.SetResult(loader.Result); }
protected virtual IEnumerator DoAnalyzeDownloadList(IProgressPromise <float, List <BundleInfo> > promise, BundleManifest manifest) { List <BundleInfo> downloads = new List <BundleInfo>(); BundleInfo[] bundleInfos = manifest.GetAll(); float last = Time.realtimeSinceStartup; int length = bundleInfos.Length; for (int i = 0; i < bundleInfos.Length; i++) { BundleInfo info = bundleInfos[i]; if (Time.realtimeSinceStartup - last > 0.15f) { yield return(null); last = Time.realtimeSinceStartup; } promise.UpdateProgress(i + 1 / (float)length); if (BundleUtil.Exists(info)) { continue; } downloads.Add(info); } promise.SetResult(downloads); }
/// <summary> /// run on the main thread. /// </summary> /// <returns>The check.</returns> /// <param name="promise">Promise.</param> protected IEnumerator DoLoadScene(IProgressPromise <float> promise) { ResourceRequest request = Resources.LoadAsync <GameObject> ("Scenes/Jungle"); while (!request.isDone) { promise.UpdateProgress(request.progress); yield return(null); } GameObject sceneTemplate = (GameObject)request.asset; GameObject.Instantiate(sceneTemplate); promise.UpdateProgress(1f); promise.SetResult(); }
void Task4(IProgressPromise <float, string> promise) { Debug.Log("The task4 start"); int n = 10; StringBuilder buf = new StringBuilder(); for (int i = 1; i <= n; i++) { /* If the task is cancelled, then stop the task */ if (promise.IsCancellationRequested) { promise.SetCancelled(); break; } buf.Append(i).Append(" "); promise.UpdateProgress(i / (float)n); #if NETFX_CORE Task.Delay(100).Wait(); #else Thread.Sleep(100); #endif } promise.SetResult(buf.ToString()); /* set a result of the task */ Debug.Log("The task4 end"); }
/// <summary> /// Simulate a task. /// </summary> /// <returns>The task.</returns> /// <param name="promise">Promise.</param> protected IEnumerator DoTask(IProgressPromise <Progress, string> promise) { int n = 50; Progress progress = new Progress(); progress.TotalBytes = n; progress.bytes = 0; StringBuilder buf = new StringBuilder(); for (int i = 0; i < n; i++) { /* If the task is cancelled, then stop the task */ if (promise.IsCancellationRequested) { promise.SetCancelled(); yield break; } progress.bytes += 1; buf.Append(" ").Append(i); promise.UpdateProgress(progress); /* update the progress of task. */ yield return(new WaitForSeconds(0.01f)); } promise.SetResult(buf.ToString()); /* update the result. */ }
protected virtual IEnumerator DoLoadAssetsAsync <T>(IProgressPromise <float, T[]> promise, params string[] names) where T : Object { List <T> assets = new List <T>(); for (int i = 0; i < names.Length; i++) { var asset = this.LoadAsset <T>(names[i]); if (asset != null) { assets.Add(asset); } promise.UpdateProgress((float)i / names.Length); yield return(null); } promise.UpdateProgress(1f); promise.SetResult(assets.ToArray()); }
protected virtual IEnumerator DoLoadAssetsAsync(IProgressPromise <float, Object[]> promise, System.Type type, params string[] names) { List <Object> assets = new List <Object>(); for (int i = 0; i < names.Length; i++) { var asset = this.LoadAsset(names[i], type); if (asset != null) { assets.Add(asset); } promise.UpdateProgress((float)i / names.Length); yield return(null); } promise.UpdateProgress(1f); promise.SetResult(assets.ToArray()); }
protected virtual async void DoLoad <T>(IProgressPromise <float, T> promise, string name, IWindowManager windowManager = null) { try { promise.UpdateProgress(0f); var result = Addressables.InstantiateAsync(name); while (!result.IsDone) { await new WaitForSecondsRealtime(0.05f); promise.UpdateProgress(result.PercentComplete); } if (result.OperationException != null) { promise.SetException(result.OperationException); return; } GameObject go = result.Result; go.SetActive(false); T view = go.GetComponent <T>(); if (view == null) { //GameObject.Destroy(go); Addressables.ReleaseInstance(go); promise.SetException(new NotFoundException(name)); } if (windowManager != null && view is IWindow) { (view as IWindow).WindowManager = windowManager; } promise.UpdateProgress(1f); promise.SetResult(view); } catch (Exception e) { promise.SetException(e); } }
protected virtual IEnumerator DoLoadAssetsToMapAsync <T>(IProgressPromise <float, Dictionary <string, T> > promise, params string[] names) where T : Object { Dictionary <string, T> assets = new Dictionary <string, T>(); for (int i = 0; i < names.Length; i++) { var name = names[i]; var asset = this.LoadAsset <T>(name); if (asset != null && !assets.ContainsKey(name)) { assets.Add(name, asset); } promise.UpdateProgress((float)i / names.Length); yield return(null); } promise.UpdateProgress(1f); promise.SetResult(assets); }
/// <summary> /// Simulate a task. /// </summary> /// <returns>The task.</returns> /// <param name="promise">Promise.</param> protected IEnumerator DoTask(IProgressPromise <float, bool> promise) { int n = 50; for (int i = 0; i < n; i++) { promise.UpdateProgress((float)i / n); yield return(new WaitForSeconds(0.1f)); } promise.SetResult(true); }
protected virtual IEnumerator DoLoad <T>(IProgressPromise <float, T> promise, string name) { name = Normalize(name); WeakReference weakRef; GameObject viewTemplateGo; if (this.templates.TryGetValue(name, out weakRef) && weakRef.IsAlive) { viewTemplateGo = (GameObject)weakRef.Target; } else { ResourceRequest request = Resources.LoadAsync <GameObject>(name); while (!request.isDone) { promise.UpdateProgress(request.progress); yield return(null); } viewTemplateGo = (GameObject)request.asset; if (viewTemplateGo != null) { viewTemplateGo.SetActive(false); this.templates[name] = new WeakReference(viewTemplateGo); } } if (viewTemplateGo == null || viewTemplateGo.GetComponent <T>() == null) { promise.UpdateProgress(1f); promise.SetException(new NotFoundException(name)); yield break; } GameObject go = GameObject.Instantiate(viewTemplateGo); go.name = viewTemplateGo.name; promise.UpdateProgress(1f); promise.SetResult(go.GetComponent <T>()); }