/// <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));
}
