/// <summary> /// Instantiate a single object. Note that the dependency loading is done asynchronously, but generally the actual instantiate is synchronous. /// </summary> /// <param name="key">The key of the location of the Object to instantiate.</param> /// <param name="instantiateParameters">Parameters for instantiation.</param> /// <param name="trackHandle">If true, Addressables will track this request to allow it to be released via the result object.</param> /// <returns>The operation handle for the request.</returns> public static AsyncOperationHandle <GameObject> InstantiateAsync(object key, InstantiationParameters instantiateParameters, bool trackHandle = true) { //DebugUtility.LogTrace(LoggerTags.AssetManager, "AssetManager.InstantiateAsync {0}", key); var h = Addressables.InstantiateAsync(key, instantiateParameters, trackHandle); return(h); }
public void ProvideInstance_CanProvide() { m_ResourceManager.ResourceProviders.Add(new GameObjectProvider()); ResourceLocationBase locDep = new ResourceLocationBase("prefab", "prefab1", "GOPRovider", typeof(UnityEngine.GameObject)); MockInstanceProvider iProvider = new MockInstanceProvider(); InstantiationParameters instantiationParameters = new InstantiationParameters(null, true); AsyncOperationHandle <GameObject>[] refResource = new AsyncOperationHandle <GameObject> [1]; iProvider.ProvideInstanceCallback = (rm, prefabHandle, iParam) => { refResource[0] = prefabHandle; Assert.AreEqual("prefab1", prefabHandle.Result.name); return(new GameObject("instance1")); }; iProvider.ReleaseInstanceCallback = (rm, go) => { rm.Release(refResource[0]); GameObject.Destroy(go); }; AsyncOperationHandle <GameObject> obj = m_ResourceManager.ProvideInstance(iProvider, locDep, instantiationParameters); m_ResourceManager.Update(0.0f); Assert.AreEqual(AsyncOperationStatus.Succeeded, obj.Status); Assert.AreEqual("instance1", obj.Result.name); Assert.AreEqual(1, m_ResourceManager.OperationCacheCount); obj.Release(); }
public void ConfirmSelection(GameObject character, InstantiationParameters instantiationParameters, int playerNumber) { _selectedCharacters[playerNumber] = Tuple.Create(character, instantiationParameters); if (_selectedCharacters[0] != null && _selectedCharacters[1] != null) { StartCoroutine(StartDuel()); } }
private async Task <GameObject> InstantiatePrefabAsync(string path, InstantiationParameters instantiateParameters = new InstantiationParameters()) { var operation = Addressables.InstantiateAsync(path, instantiateParameters); await operation.Task; if (operation.Status != AsyncOperationStatus.Succeeded) { throw operation.OperationException; } return(operation.Result); }
public AsyncOperationHandle <GameObject> InstantiateAsync(object key, InstantiationParameters instantiateParameters, bool trackHandle = true) { if (!InitializationOperation.IsDone) { return(InstantiateWithChain(key, instantiateParameters, trackHandle)); } key = EvaluateKey(key); IList <IResourceLocation> locs; for (int i = 0; i < m_ResourceLocators.Count; i++) { if (m_ResourceLocators[i].Locate(key, typeof(GameObject), out locs)) { return(InstantiateAsync(locs[0], instantiateParameters, trackHandle)); } } return(ResourceManager.CreateCompletedOperation <GameObject>(null, new InvalidKeyException(key).Message)); }
public GameObject ProvideInstance(ResourceManager rm, AsyncOperationHandle <GameObject> prefabHandle, InstantiationParameters instantiateParameters) { return(ProvideInstanceCallback(rm, prefabHandle, instantiateParameters)); }
public static async UniTask <GameObject> InstantiateAsync(object key, InstantiationParameters instantiationParameters, bool trackHandle = true, IProgress <float> progress = null, PlayerLoopTiming playerLoopTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default) { return(await Addressables.InstantiateAsync(key, instantiationParameters, trackHandle).ConfigureAwait(progress, playerLoopTiming, cancellationToken)); }
/// <summary> /// Instantiate a single object. Note that the dependency loading is done asynchronously, but generally the actual instantiate is synchronous. /// </summary> /// <param name="location">The location of the Object to instantiate.</param> /// <param name="instantiateParameters">Parameters for instantiation.</param> /// <param name="trackHandle">If true, Addressables will track this request to allow it to be released via the result object.</param> /// <returns>The operation handle for the request.</returns> public static AsyncOperationHandle <GameObject> InstantiateAsync(IResourceLocation location, InstantiationParameters instantiateParameters, bool trackHandle = true) { return(m_Addressables.InstantiateAsync(location, instantiateParameters, trackHandle)); }
/// <summary> /// Instantiate a single object. Note that the dependency loading is done asynchronously, but generally the actual instantiate is synchronous. /// </summary> /// <param name="key">The key of the location of the Object to instantiate.</param> /// <param name="instantiateParameters">Parameters for instantiation.</param> /// <param name="trackHandle">If true, Addressables will track this request to allow it to be released via the result object.</param> /// <returns>The operation handle for the request.</returns> public static AsyncOperationHandle <GameObject> InstantiateAsync(object key, InstantiationParameters instantiateParameters, bool trackHandle = true) { return(m_Addressables.InstantiateAsync(key, instantiateParameters, trackHandle)); }
public AsyncOperationHandle <GameObject> InstantiateAsync(IResourceLocation location, InstantiationParameters instantiateParameters, bool trackHandle = true) { var opHandle = ResourceManager.ProvideInstance(InstanceProvider, location, instantiateParameters); if (!trackHandle) { return(opHandle); } opHandle.CompletedTypeless += m_OnHandleCompleteAction; return(opHandle); }
AsyncOperationHandle <GameObject> InstantiateWithChain(object key, InstantiationParameters instantiateParameters, bool trackHandle = true) { return(ResourceManager.CreateChainOperation(InitializationOperation, op => InstantiateAsync(key, instantiateParameters, trackHandle))); }
public IAsyncOperation <IList <GameObject> > InstantiateAll(object key, Action <IAsyncOperation <GameObject> > callback, InstantiationParameters instantiateParameters) { return(Addressables.InstantiateAll(key, callback, instantiateParameters)); }
public IAsyncOperation <GameObject> Instantiate(object key, InstantiationParameters instantiateParameters) { return(Addressables.Instantiate(key, instantiateParameters)); }