Method InstantiateAsync
InstantiateAsync(IResourceLocation, Transform, bool, bool)
Instantiate a single object.
Declaration
public static AsyncOperationHandle<GameObject> InstantiateAsync(IResourceLocation location, Transform parent = null, bool instantiateInWorldSpace = false, bool trackHandle = true)Parameters
| Type | Name | Description |
|---|---|---|
| IResourceLocation | location | The location of the Object to instantiate. |
| Transform | parent | Parent transform for instantiated object. |
| bool | instantiateInWorldSpace | Option to retain world space when instantiated with a parent. |
| bool | trackHandle | If true, Addressables will track this request to allow it to be released via the result object. |
Returns
| Type | Description |
|---|---|
| AsyncOperationHandle<GameObject> | AsyncOperationHandle that is used to check when the operation has completed. The result of the operation is a GameObject. |
Remarks
Loads a Prefab and instantiates a copy of the prefab into the active scene or parent GameObject. The Prefab and any resources associated with it are loaded asynchronously, whereas the instantiation is executed synchronously. In the situation where the Prefab and resources are already loaded, the entire operation is completed synchronously.
Most versions of the function shares the same parameters(position, rotation, etc.) as Object.Instantiate. You can create an InstantiationParameters struct to store these parameters, pass it into the function instead.
Examples
The example below instantiates a GameObject using by a `key`, specifically an AssetReference. By default `trackHandle` is set to `true`. Since the instance is tracked, a reference from the instance to the handle is stored and released via ReleaseInstance(GameObject). Alternatively a reference to the operation handle can be stored and released via Release(AsyncOperationHandle), similar to the second example below.
public AssetReferenceGameObject assetRefTracked; // Identify the asset
public Transform parentTransformTracked; // Identify the transform of the parent GameObject
GameObject instanceTracked;
void UsingInstantiateAsyncSampleKeyTracked()
{
var instParams = new InstantiationParameters(parentTransformTracked, false);
Addressables.InstantiateAsync(assetRefTracked, instParams).Completed += OnInstantiateCompleteObjectTracked;
}
void OnInstantiateCompleteObjectTracked(AsyncOperationHandle<GameObject> handle)
{
if (handle.Status == AsyncOperationStatus.Succeeded)
{
instanceTracked = handle.Result;
Debug.Log($"Successfully instantiated GameObject with name ''.");
}
}
void ReleaseTrackedResources()
{
Addressables.ReleaseInstance(instanceTracked);
}
// When ready to release the asset, call ReleaseTrackedResources().
// For example during OnDestroy().
//void OnDestroy()
//{
// ReleaseTrackedResources();
//}
The example below shows how to release a GameObject when `trackHandle` is set to `false`. The instance is not tracked and cannot be used to release the object, instead a reference to the operation handle is stored and released via Release(AsyncOperationHandle).
public AssetReferenceGameObject assetRefUntracked; // Identify the asset
public Transform parentTransformUntracked; // Identify the transform component of the parent GameObject
AsyncOperationHandle<GameObject> handleUntracked;
void UsingInstantiateAsyncSampleKeyUntracked()
{
var instParams = new InstantiationParameters(parentTransformUntracked, false);
handleUntracked = Addressables.InstantiateAsync(assetRefUntracked, instParams, false);
handleUntracked.Completed += OnInstantiateCompleteObjectUntracked;
}
void OnInstantiateCompleteObjectUntracked(AsyncOperationHandle<GameObject> handle)
{
if (handle.Status == AsyncOperationStatus.Succeeded)
{
Debug.Log($"Successfully instantiated GameObject with name ''.");
}
}
void ReleaseUntrackedResources()
{
handleUntracked.Release();
}
// When ready to release the asset, call ReleaseUntrackedResources().
// For example during OnDestroy().
//void OnDestroy()
//{
// ReleaseUntrackedResources();
//}
The example below instantiates a GameObject using an IResourceLocation.
public AssetReferenceGameObject assetRefLocation; // Identify the asset
public Transform parentTransformLocation; // Identify the transform of the parent GameObject
AsyncOperationHandle<IList<IResourceLocation>> locHandle;
GameObject instanceLocation;
void UsingInstantiateAsyncSampleLocation()
{
locHandle = Addressables.LoadResourceLocationsAsync(assetRefLocation, typeof(GameObject));
locHandle.Completed += OnLoadComplete;
}
void OnLoadComplete(AsyncOperationHandle<IList<IResourceLocation>> handle)
{
if (handle.Status == AsyncOperationStatus.Succeeded)
{
Debug.Log($"Successfully loaded resource locations");
foreach (IResourceLocation location in handle.Result)
{
string locationKey = location.InternalId;
var instParams = new InstantiationParameters(parentTransformLocation, false);
Addressables.InstantiateAsync(location, instParams).Completed += OnInstantiateCompleteLocation;
}
}
}
void OnInstantiateCompleteLocation(AsyncOperationHandle<GameObject> handle)
{
if (handle.Status == AsyncOperationStatus.Succeeded)
{
instanceLocation = handle.Result;
Debug.Log($"Successfully instantiated GameObject with name ''.");
}
}
void ReleaseResourcesLocation()
{
locHandle.Release();
Addressables.ReleaseInstance(instanceLocation);
}
// When ready to release the asset, call ReleaseTrackedResources().
// For example during OnDestroy().
//void OnDestroy()
//{
// ReleaseResourcesLocation();
//}
InstantiateAsync(IResourceLocation, Vector3, Quaternion, Transform, bool)
Instantiate a single object.
Declaration
public static AsyncOperationHandle<GameObject> InstantiateAsync(IResourceLocation location, Vector3 position, Quaternion rotation, Transform parent = null, bool trackHandle = true)Parameters
| Type | Name | Description |
|---|---|---|
| IResourceLocation | location | The location of the Object to instantiate. |
| Vector3 | position | The position of the instantiated object. |
| Quaternion | rotation | The rotation of the instantiated object. |
| Transform | parent | Parent transform for instantiated object. |
| bool | trackHandle | If true, Addressables will track this request to allow it to be released via the result object. |
Returns
| Type | Description |
|---|---|
| AsyncOperationHandle<GameObject> | AsyncOperationHandle that is used to check when the operation has completed. The result of the operation is a GameObject. |
InstantiateAsync(object, Transform, bool, bool)
Instantiate a single object.
Declaration
public static AsyncOperationHandle<GameObject> InstantiateAsync(object key, Transform parent = null, bool instantiateInWorldSpace = false, bool trackHandle = true)Parameters
| Type | Name | Description |
|---|---|---|
| object | key | The key of the location of the Object to instantiate. |
| Transform | parent | Parent transform for instantiated object. |
| bool | instantiateInWorldSpace | Option to retain world space when instantiated with a parent. |
| bool | trackHandle | If true, Addressables will track this request to allow it to be released via the result object. |
Returns
| Type | Description |
|---|---|
| AsyncOperationHandle<GameObject> | AsyncOperationHandle that is used to check when the operation has completed. The result of the operation is a GameObject. |
InstantiateAsync(object, Vector3, Quaternion, Transform, bool)
Instantiate a single object.
Declaration
public static AsyncOperationHandle<GameObject> InstantiateAsync(object key, Vector3 position, Quaternion rotation, Transform parent = null, bool trackHandle = true)Parameters
| Type | Name | Description |
|---|---|---|
| object | key | The key of the location of the Object to instantiate. |
| Vector3 | position | The position of the instantiated object. |
| Quaternion | rotation | The rotation of the instantiated object. |
| Transform | parent | Parent transform for instantiated object. |
| bool | trackHandle | If true, Addressables will track this request to allow it to be released via the result object. |
Returns
| Type | Description |
|---|---|
| AsyncOperationHandle<GameObject> | AsyncOperationHandle that is used to check when the operation has completed. The result of the operation is a GameObject. |
InstantiateAsync(object, InstantiationParameters, bool)
Instantiate a single object.
Declaration
public static AsyncOperationHandle<GameObject> InstantiateAsync(object key, InstantiationParameters instantiateParameters, bool trackHandle = true)Parameters
| Type | Name | Description |
|---|---|---|
| object | key | The key of the location of the Object to instantiate. |
| InstantiationParameters | instantiateParameters | Parameters for instantiation. |
| bool | trackHandle | If true, Addressables will track this request to allow it to be released via the result object. |
Returns
| Type | Description |
|---|---|
| AsyncOperationHandle<GameObject> | AsyncOperationHandle that is used to check when the operation has completed. The result of the operation is a GameObject. |
InstantiateAsync(IResourceLocation, InstantiationParameters, bool)
Instantiate a single object.
Declaration
public static AsyncOperationHandle<GameObject> InstantiateAsync(IResourceLocation location, InstantiationParameters instantiateParameters, bool trackHandle = true)Parameters
| Type | Name | Description |
|---|---|---|
| IResourceLocation | location | The location of the Object to instantiate. |
| InstantiationParameters | instantiateParameters | Parameters for instantiation. |
| bool | trackHandle | If true, Addressables will track this request to allow it to be released via the result object. |
Returns
| Type | Description |
|---|---|
| AsyncOperationHandle<GameObject> | AsyncOperationHandle that is used to check when the operation has completed. The result of the operation is a GameObject. |