void Release() { if (!Addressables.ReleaseInstance(gameObject)) { Destroy(gameObject); } }
private IEnumerator ReleaseInstance(AsyncOperationHandle <GameObject> asyncOperationHandle) { yield return(new WaitForSeconds(1)); Debug.Log("开始 ReleaseInstance"); Addressables.ReleaseInstance(asyncOperationHandle); }
static public void ReleaseInstance(GameObject obj) { if (obj != null) { Addressables.ReleaseInstance(obj); } }
IEnumerator BarrierBoxInitEffect() { material.SetFloat("_XLine", -0.5f); material.SetFloat("_YLine", -0.49f); material.SetFloat("_ZLine", -0.5f); material.SetFloat("_XFace", 0.5f); material.SetFloat("_YFace", -0.5f); material.SetFloat("_ZFace", 0.5f); StartCoroutine(ShaderFloatValueChanger(material, "_XLine", -0.5f, 0.5f, LineXTime)); yield return(new WaitForSeconds(LineXTime)); StartCoroutine(ShaderFloatValueChanger(material, "_ZLine", -0.5f, 0.5f, LineZTime)); yield return(new WaitForSeconds(LineZTime)); StartCoroutine(ShaderFloatValueChanger(material, "_YLine", -0.49f, 0.5f, LineYTime)); StartCoroutine(ShaderFloatValueChanger(material, "_YFace", -0.5f, 0.5f, FaceYTime)); yield return(new WaitForSeconds(FaceYTime)); if (target) { target.GetComponent <IEnemy>()?.DestroyWithScore(); } yield return(new WaitForSeconds(FaceYTime * 2)); Addressables.ReleaseInstance(gameObject); }
public override void Release(Object asset) { if (asset is GameObject) { Addressables.ReleaseInstance(asset as GameObject); } }
/// <summary> /// Load & Instantiate Asset. this will be helpful if we deal with prefabs (ex: slots) /// </summary> /// <param name="assetReference"> target asset reference </param> public void Instantiate <T>(AssetReference assetReference, Action <T> onComplete, Action <string> onFailed = null) where T : MonoBehaviour, IAsset { if (assetReference == null) { throw new NullReferenceException($"AssetReference must be not null!"); } var operation = Addressables.InstantiateAsync(assetReference); operation.Completed += (response) => { switch (operation.Status) { case AsyncOperationStatus.Failed: onFailed?.Invoke(operation.PercentComplete.ToString()); break; case AsyncOperationStatus.Succeeded: var asset = response.Result.GetComponent <IAsset>(); asset.OnDestroyed += () => { Addressables.ReleaseInstance(response.Result); }; //release onComplete?.Invoke(response.Result.GetComponent <T>()); break; default: Debug.LogError("No Result > " + response.Result); break; } }; }
IEnumerator CheckIfAlive() { ParticleSystem ps = this.GetComponent <ParticleSystem>(); while (true && ps != null) { yield return(new WaitForSeconds(0.5f)); if (!ps.IsAlive(true)) { if (OnlyDeactivate) { #if UNITY_3_5 this.gameObject.SetActiveRecursively(false); #else this.gameObject.SetActive(false); #endif } else { Addressables.ReleaseInstance(gameObject); } break; } } }
IEnumerator ShowEffect() { { var ao = Addressables.InstantiateAsync("prefabs/cube.prefab"); ao.Completed += handle => { GameObject obj = ao.Result; obj.transform.position = Vector3.zero; obj.transform.localScale = Vector3.one; }; yield return(ao); } Addressables.ReleaseInstance(gameObject); // Addressables.ClearResourceLocators(); Addressables.ClearDependencyCacheAsync("prefabs/launch.prefab"); { var rootLayer = GameObject.Find("LaunchLayer").GetComponent <Canvas>(); var loader = KVResourceMgr.Instance.LoadAssetAsync("prefabs/launch.prefab"); yield return(loader); // ao.Completed += handle => // { GameObject obj = loader.asset as GameObject; obj = Instantiate(obj, rootLayer.transform); obj.transform.localPosition = Vector3.zero; obj.transform.localScale = Vector3.one; // }; // yield return ao; } DestroyImmediate(gameObject); }
private void OnTriggerExit(Collider other) { if (other.tag == "Boundary") { Addressables.ReleaseInstance(gameObject); } }
void OnTriggerEnter(Collider other) { if (other.tag == "Boundary" || other.tag == "Enemy") { return; } if (explosion != null) { // ADDRESSABLES UPDATES explosion.InstantiateAsync(transform.position, transform.rotation); } if (other.tag == "Player") { // ADDRESSABLES UPDATES playerExplosion.InstantiateAsync(other.transform.position, other.transform.rotation); gameController.GameOver(); } gameController.AddScore(scoreValue); // ADDRESSABLES UPDATES Addressables.ReleaseInstance(other.gameObject); Addressables.ReleaseInstance(gameObject); }
private void Validate() { #if !UNITY_EDITOR && !DEBUG_BUILD Addressables.ReleaseInstance(gameObject); #endif Debugging.DisplayDebugMessage("CHEATS ENABLED! \n Culprit: " + name); }
private void OnDestroy() { if (_instanceHandle.IsValid()) { Addressables.ReleaseInstance(_instanceHandle); } }
/// <summary> /// 关闭UI /// </summary> /// <param name="uiName"></param> /// <param name="isDestroy">是否销毁</param> /// <param name="args"></param> public static void Close(string uiName, bool isDestroy = false, object args = null) { if (UIMaps.TryGetValue(uiName, out var ui)) { if (ui.View.activeSelf) { ui.Close(args); if (ui.UIConfig.IsMask) { CloseMask(ui); } } if (isDestroy) { UIMaps.Remove(uiName); if (ui.UIConfig.attachMode) { Object.Destroy(ui.View); } else { Addressables.ReleaseInstance(ui.View); } ui.Dispose(); } } }
public override void Exit(AState to) { missionPopup.gameObject.SetActive(false); inventoryCanvas.gameObject.SetActive(false); if (m_Character != null) { Addressables.ReleaseInstance(m_Character); } GameState gs = to as GameState; skyMeshFilter.gameObject.SetActive(false); UIGroundFilter.gameObject.SetActive(false); if (gs != null) { gs.currentModifier = m_CurrentModifier; // We reset the modifier to a default one, for next run (if a new modifier is applied, it will replace this default one before the run starts) m_CurrentModifier = new Modifier(); if (m_PowerupToUse != Consumable.ConsumableType.NONE) { PlayerData.instance.Consume(m_PowerupToUse); Consumable inv = Instantiate(ConsumableDatabase.GetConsumbale(m_PowerupToUse)); inv.gameObject.SetActive(false); gs.trackManager.characterController.inventory = inv; } } }
public static bool CanRelease(this AsyncOperationHandle <GameObject> targetAsyncOperationHandle, bool autoRelease = false) { if (!targetAsyncOperationHandle.IsValid()) { return(false); } if (targetAsyncOperationHandle.Status == AsyncOperationStatus.Succeeded) { if (autoRelease) { // Not entirely sure about this one, as it makes sense that we should be moving to a instanced version, // however games have shipped with the older method (.Release) Addressables.ReleaseInstance(targetAsyncOperationHandle); } return(true); } if (targetAsyncOperationHandle.Result == null) { return(false); } if (autoRelease) { Addressables.ReleaseInstance(targetAsyncOperationHandle); } return(true); }
void Update() { if (slaves.Count == 0) { Addressables.ReleaseInstance(gameObject); } }
void Update() { if (Object != null) { Addressables.ReleaseInstance(Object); } this.enabled = false; }
public void ReleaseObject(UnityEngine.Object obj, float delay = 0) { #if USE_ADDRESSABLE Addressables.ReleaseInstance(obj, delay); #else UnityEngine.Object.Destroy(obj, delay); #endif }
private void FinishDialogue() { UpdateManager.Instance.UnSubscribeFromGlobalUpdate(this.CheckPageFlip); QuestLibrary.BeginQuest(this.dialogue.questReference); PlayerController.Instance.EnableInputs(); Addressables.ReleaseInstance(gameObject); }
public void Release(string key, GameObject obj) { #if UNITY_OBJECTPOOLING_ADDRESSABLES_MANAGER AddressablesManager.ReleaseInstance(key, obj); #else Addressables.ReleaseInstance(obj); #endif }
// unload prefab from memory public void UnloadAssetInstance(Data obj) { if (!Addressables.ReleaseInstance(obj.instance)) { Destroy(obj.instance); Addressables.Release(obj.asset); } }
public void DeleteAll() { foreach (var expandViewItem in Items.Values) { Addressables.ReleaseInstance(expandViewItem.gameObject); } Items.Clear(); }
public void Close(string panelName) { if (_allPanelData.TryGetValue(panelName, out var panelData)) { Addressables.ReleaseInstance(panelData.handle); _allPanelData.Remove(panelName); } }
void Release() { //非经过Addressable创建的实例不能销毁,所以需要判断 if (!Addressables.ReleaseInstance(gameObject)) { Destroy(gameObject); } }
/// <summary> /// Releases and destroys an object that was created via Addressables.InstantiateAsync. /// </summary> /// <param name="instance">The GameObject instance to be released and destroyed.</param> /// <returns>Returns true if the instance was successfully released.</returns> public static bool ReleaseInstance(GameObject instance) { if (!Addressables.ReleaseInstance(instance)) { Destroy(instance); } return(true); }
private void Despawn() { foreach (var instance in _instances) { Addressables.ReleaseInstance(instance); } _instances.Clear(); }
private void DestroyAllCube() { foreach (var cube in cubes) { Addressables.ReleaseInstance(cube); } cubes.Clear(); }
void OnDisable() { allAvailablePools.Remove(assetReferenceToInstantiate); foreach (var obj in pool) { Addressables.ReleaseInstance(obj); } pool = null; }
private IEnumerator DestroyObjectOnDelay(PoolObject _poolObject, float _delay) { yield return(new WaitForSeconds(_delay)); if (_poolObject.IsActivated == false) { Addressables.ReleaseInstance(_poolObject.gameObject); } }
private void OnDestroy() { _loadAsssetsButton.onClick.RemoveAllListeners(); foreach (var addressablePrefab in _addressablePrefabs) { Addressables.ReleaseInstance(addressablePrefab); } _addressablePrefabs.Clear(); }