609 lines
21 KiB
C#
609 lines
21 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
namespace UnityEngine.ResourceManagement.AsyncOperations
|
|
{
|
|
/// <summary>
|
|
/// Handle for internal operations. This allows for reference counting and checking for valid references.
|
|
/// </summary>
|
|
/// <typeparam name="TObject">The object type of the underlying operation.</typeparam>
|
|
public struct AsyncOperationHandle<TObject> : IEnumerator, IEquatable<AsyncOperationHandle<TObject>>
|
|
{
|
|
internal AsyncOperationBase<TObject> m_InternalOp;
|
|
int m_Version;
|
|
string m_LocationName;
|
|
|
|
internal string LocationName
|
|
{
|
|
get { return m_LocationName; }
|
|
set { m_LocationName = value; }
|
|
}
|
|
|
|
bool m_UnloadSceneOpExcludeReleaseCallback;
|
|
|
|
internal bool UnloadSceneOpExcludeReleaseCallback
|
|
{
|
|
get { return m_UnloadSceneOpExcludeReleaseCallback; }
|
|
set { m_UnloadSceneOpExcludeReleaseCallback = value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Conversion from typed to non typed handles. This does not increment the reference count.
|
|
/// To convert from non-typed back, use AsyncOperationHandle.Convert<T>()
|
|
/// </summary>
|
|
/// <param name="obj">The typed handle to convert.</param>
|
|
/// <returns>Returns the converted operation handle.</returns>
|
|
static public implicit operator AsyncOperationHandle(AsyncOperationHandle<TObject> obj)
|
|
{
|
|
return new AsyncOperationHandle(obj.m_InternalOp, obj.m_Version, obj.m_LocationName);
|
|
}
|
|
|
|
internal AsyncOperationHandle(AsyncOperationBase<TObject> op)
|
|
{
|
|
m_InternalOp = op;
|
|
m_Version = op?.Version ?? 0;
|
|
m_LocationName = null;
|
|
m_UnloadSceneOpExcludeReleaseCallback = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the current download status for this operation and its dependencies.
|
|
/// </summary>
|
|
/// <returns>The download status.</returns>
|
|
public DownloadStatus GetDownloadStatus()
|
|
{
|
|
return InternalGetDownloadStatus(new HashSet<object>());
|
|
}
|
|
|
|
internal DownloadStatus InternalGetDownloadStatus(HashSet<object> visited)
|
|
{
|
|
if (visited == null)
|
|
visited = new HashSet<object>();
|
|
return visited.Add(InternalOp) ? InternalOp.GetDownloadStatus(visited) : new DownloadStatus() {IsDone = IsDone};
|
|
}
|
|
|
|
internal AsyncOperationHandle(IAsyncOperation op)
|
|
{
|
|
m_InternalOp = (AsyncOperationBase<TObject>)op;
|
|
m_Version = op?.Version ?? 0;
|
|
m_LocationName = null;
|
|
m_UnloadSceneOpExcludeReleaseCallback = false;
|
|
}
|
|
|
|
internal AsyncOperationHandle(IAsyncOperation op, int version)
|
|
{
|
|
m_InternalOp = (AsyncOperationBase<TObject>)op;
|
|
m_Version = version;
|
|
m_LocationName = null;
|
|
m_UnloadSceneOpExcludeReleaseCallback = false;
|
|
}
|
|
|
|
internal AsyncOperationHandle(IAsyncOperation op, string locationName)
|
|
{
|
|
m_InternalOp = (AsyncOperationBase<TObject>)op;
|
|
m_Version = op?.Version ?? 0;
|
|
m_LocationName = locationName;
|
|
m_UnloadSceneOpExcludeReleaseCallback = false;
|
|
}
|
|
|
|
internal AsyncOperationHandle(IAsyncOperation op, int version, string locationName)
|
|
{
|
|
m_InternalOp = (AsyncOperationBase<TObject>)op;
|
|
m_Version = version;
|
|
m_LocationName = locationName;
|
|
m_UnloadSceneOpExcludeReleaseCallback = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Acquire a new handle to the internal operation. This will increment the reference count, therefore the returned handle must also be released.
|
|
/// </summary>
|
|
/// <returns>A new handle to the operation. This handle must also be released.</returns>
|
|
internal AsyncOperationHandle<TObject> Acquire()
|
|
{
|
|
InternalOp.IncrementReferenceCount();
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Completion event for the internal operation. If this is assigned on a completed operation, the callback is deferred until the LateUpdate of the current frame.
|
|
/// </summary>
|
|
public event Action<AsyncOperationHandle<TObject>> Completed
|
|
{
|
|
add { InternalOp.Completed += value; }
|
|
remove { InternalOp.Completed -= value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Completion event for non-typed callback handlers. If this is assigned on a completed operation, the callback is deferred until the LateUpdate of the current frame.
|
|
/// </summary>
|
|
public event Action<AsyncOperationHandle> CompletedTypeless
|
|
{
|
|
add { InternalOp.CompletedTypeless += value; }
|
|
remove { InternalOp.CompletedTypeless -= value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Debug name of the operation.
|
|
/// </summary>
|
|
public string DebugName
|
|
{
|
|
get
|
|
{
|
|
if (!IsValid())
|
|
return "InvalidHandle";
|
|
return ((IAsyncOperation)InternalOp).DebugName;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get dependency operations.
|
|
/// </summary>
|
|
/// <param name="deps">The list of AsyncOperationHandles that are dependencies of a given AsyncOperationHandle</param>
|
|
public void GetDependencies(List<AsyncOperationHandle> deps)
|
|
{
|
|
InternalOp.GetDependencies(deps);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Event for handling the destruction of the operation.
|
|
/// </summary>
|
|
public event Action<AsyncOperationHandle> Destroyed
|
|
{
|
|
add { InternalOp.Destroyed += value; }
|
|
remove { InternalOp.Destroyed -= value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Provide equality for this struct.
|
|
/// </summary>
|
|
/// <param name="other">The operation to compare to.</param>
|
|
/// <returns>True if the the operation handles reference the same AsyncOperation and the version is the same.</returns>
|
|
public bool Equals(AsyncOperationHandle<TObject> other)
|
|
{
|
|
return m_Version == other.m_Version && m_InternalOp == other.m_InternalOp;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get hash code of this struct.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override int GetHashCode()
|
|
{
|
|
return m_InternalOp == null ? 0 : m_InternalOp.GetHashCode() * 17 + m_Version;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Synchronously complete the async operation.
|
|
/// </summary>
|
|
/// <returns>The result of the operation or null.</returns>
|
|
public TObject WaitForCompletion()
|
|
{
|
|
#if !UNITY_2021_1_OR_NEWER
|
|
AsyncOperationHandle.IsWaitingForCompletion = true;
|
|
try
|
|
{
|
|
if (IsValid() && !InternalOp.IsDone)
|
|
InternalOp.WaitForCompletion();
|
|
if (IsValid())
|
|
return Result;
|
|
}
|
|
finally
|
|
{
|
|
AsyncOperationHandle.IsWaitingForCompletion = false;
|
|
m_InternalOp?.m_RM?.Update(Time.unscaledDeltaTime);
|
|
}
|
|
#else
|
|
if (IsValid() && !InternalOp.IsDone)
|
|
InternalOp.WaitForCompletion();
|
|
|
|
m_InternalOp?.m_RM?.Update(Time.unscaledDeltaTime);
|
|
if (IsValid())
|
|
return Result;
|
|
#endif
|
|
return default(TObject);
|
|
}
|
|
|
|
internal AsyncOperationBase<TObject> InternalOp
|
|
{
|
|
get
|
|
{
|
|
if (m_InternalOp == null || m_InternalOp.Version != m_Version)
|
|
throw new Exception("Attempting to use an invalid operation handle");
|
|
return m_InternalOp;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// True if the operation is complete.
|
|
/// </summary>
|
|
public bool IsDone
|
|
{
|
|
get { return !IsValid() || InternalOp.IsDone; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if the handle references an internal operation.
|
|
/// </summary>
|
|
/// <returns>True if valid.</returns>
|
|
public bool IsValid()
|
|
{
|
|
return m_InternalOp != null && m_InternalOp.Version == m_Version;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The exception for a failed operation. This will be null unless Status is failed.
|
|
/// </summary>
|
|
public Exception OperationException
|
|
{
|
|
get { return InternalOp.OperationException; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// The progress of the internal operation.
|
|
/// This is evenly weighted between all sub-operations. For example, a LoadAssetAsync call could potentially
|
|
/// be chained with InitializeAsync and have multiple dependent operations that download and load content.
|
|
/// In that scenario, PercentComplete would reflect how far the overal operation was, and would not accurately
|
|
/// represent just percent downloaded or percent loaded into memory.
|
|
/// For accurate download percentages, use GetDownloadStatus().
|
|
/// </summary>
|
|
public float PercentComplete
|
|
{
|
|
get { return InternalOp.PercentComplete; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// The current reference count of the internal operation.
|
|
/// </summary>
|
|
internal int ReferenceCount
|
|
{
|
|
get { return InternalOp.ReferenceCount; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Release the handle. If the internal operation reference count reaches 0, the resource will be released.
|
|
/// </summary>
|
|
internal void Release()
|
|
{
|
|
InternalOp.DecrementReferenceCount();
|
|
m_InternalOp = null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The result object of the operations.
|
|
/// </summary>
|
|
public TObject Result
|
|
{
|
|
get { return InternalOp.Result; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// The status of the internal operation.
|
|
/// </summary>
|
|
public AsyncOperationStatus Status
|
|
{
|
|
get { return InternalOp.Status; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return a Task object to wait on when using async await.
|
|
/// </summary>
|
|
public System.Threading.Tasks.Task<TObject> Task
|
|
{
|
|
get { return InternalOp.Task; }
|
|
}
|
|
|
|
object IEnumerator.Current
|
|
{
|
|
get { return Result; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overload for <see cref="IEnumerator.MoveNext"/>.
|
|
/// </summary>
|
|
/// <returns>Returns true if the enumerator can advance to the next element in the collectin. Returns false otherwise.</returns>
|
|
bool IEnumerator.MoveNext()
|
|
{
|
|
return !IsDone;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overload for <see cref="IEnumerator.Reset"/>.
|
|
/// </summary>
|
|
void IEnumerator.Reset()
|
|
{
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Non typed operation handle. This allows for reference counting and checking for valid references.
|
|
/// </summary>
|
|
public struct AsyncOperationHandle : IEnumerator
|
|
{
|
|
#if !UNITY_2021_1_OR_NEWER
|
|
private static bool m_IsWaitingForCompletion = false;
|
|
/// <summary>
|
|
/// Indicates that the async operation is in the process of being completed synchronously.
|
|
/// </summary>
|
|
public static bool IsWaitingForCompletion
|
|
{
|
|
get { return m_IsWaitingForCompletion; }
|
|
internal set { m_IsWaitingForCompletion = value; }
|
|
}
|
|
#endif
|
|
|
|
internal IAsyncOperation m_InternalOp;
|
|
int m_Version;
|
|
string m_LocationName;
|
|
|
|
internal string LocationName
|
|
{
|
|
get { return m_LocationName; }
|
|
set { m_LocationName = value; }
|
|
}
|
|
|
|
internal AsyncOperationHandle(IAsyncOperation op)
|
|
{
|
|
m_InternalOp = op;
|
|
m_Version = op?.Version ?? 0;
|
|
m_LocationName = null;
|
|
}
|
|
|
|
internal AsyncOperationHandle(IAsyncOperation op, int version)
|
|
{
|
|
m_InternalOp = op;
|
|
m_Version = version;
|
|
m_LocationName = null;
|
|
}
|
|
|
|
internal AsyncOperationHandle(IAsyncOperation op, string locationName)
|
|
{
|
|
m_InternalOp = op;
|
|
m_Version = op?.Version ?? 0;
|
|
m_LocationName = locationName;
|
|
}
|
|
|
|
internal AsyncOperationHandle(IAsyncOperation op, int version, string locationName)
|
|
{
|
|
m_InternalOp = op;
|
|
m_Version = version;
|
|
m_LocationName = locationName;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Acquire a new handle to the internal operation. This will increment the reference count, therefore the returned handle must also be released.
|
|
/// </summary>
|
|
/// <returns>A new handle to the operation. This handle must also be released.</returns>
|
|
internal AsyncOperationHandle Acquire()
|
|
{
|
|
InternalOp.IncrementReferenceCount();
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Completion event for the internal operation. If this is assigned on a completed operation, the callback is deferred until the LateUpdate of the current frame.
|
|
/// </summary>
|
|
public event Action<AsyncOperationHandle> Completed
|
|
{
|
|
add { InternalOp.CompletedTypeless += value; }
|
|
remove { InternalOp.CompletedTypeless -= value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converts handle to be typed. This does not increment the reference count.
|
|
/// To convert back to non-typed, implicit conversion is available.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of the handle.</typeparam>
|
|
/// <returns>A new handle that is typed.</returns>
|
|
public AsyncOperationHandle<T> Convert<T>()
|
|
{
|
|
return new AsyncOperationHandle<T>(InternalOp, m_Version, m_LocationName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Provide equality for this struct.
|
|
/// </summary>
|
|
/// <param name="other">The operation to compare to.</param>
|
|
/// <returns>True if the the operation handles reference the same AsyncOperation and the version is the same.</returns>
|
|
public bool Equals(AsyncOperationHandle other)
|
|
{
|
|
return m_Version == other.m_Version && m_InternalOp == other.m_InternalOp;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Debug name of the operation.
|
|
/// </summary>
|
|
public string DebugName
|
|
{
|
|
get
|
|
{
|
|
if (!IsValid())
|
|
return "InvalidHandle";
|
|
return InternalOp.DebugName;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Event for handling the destruction of the operation.
|
|
/// </summary>
|
|
public event Action<AsyncOperationHandle> Destroyed
|
|
{
|
|
add { InternalOp.Destroyed += value; }
|
|
remove { InternalOp.Destroyed -= value; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get dependency operations.
|
|
/// </summary>
|
|
/// <param name="deps"></param>
|
|
public void GetDependencies(List<AsyncOperationHandle> deps)
|
|
{
|
|
InternalOp.GetDependencies(deps);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get hash code of this struct.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public override int GetHashCode()
|
|
{
|
|
return m_InternalOp == null ? 0 : m_InternalOp.GetHashCode() * 17 + m_Version;
|
|
}
|
|
|
|
IAsyncOperation InternalOp
|
|
{
|
|
get
|
|
{
|
|
if (m_InternalOp == null || m_InternalOp.Version != m_Version)
|
|
throw new Exception("Attempting to use an invalid operation handle");
|
|
return m_InternalOp;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// True if the operation is complete.
|
|
/// </summary>
|
|
public bool IsDone
|
|
{
|
|
get { return !IsValid() || InternalOp.IsDone; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if the internal operation is not null and has the same version of this handle.
|
|
/// </summary>
|
|
/// <returns>True if valid.</returns>
|
|
public bool IsValid()
|
|
{
|
|
return m_InternalOp != null && m_InternalOp.Version == m_Version;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The exception for a failed operation. This will be null unless Status is failed.
|
|
/// </summary>
|
|
public Exception OperationException
|
|
{
|
|
get { return InternalOp.OperationException; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// The progress of the internal operation.
|
|
/// This is evenly weighted between all sub-operations. For example, a LoadAssetAsync call could potentially
|
|
/// be chained with InitializeAsync and have multiple dependent operations that download and load content.
|
|
/// In that scenario, PercentComplete would reflect how far the overal operation was, and would not accurately
|
|
/// represent just percent downloaded or percent loaded into memory.
|
|
/// For accurate download percentages, use GetDownloadStatus().
|
|
/// </summary>
|
|
public float PercentComplete
|
|
{
|
|
get { return InternalOp.PercentComplete; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the current download status for this operation and its dependencies. In some instances, the information will not be available. This can happen if the operation
|
|
/// is dependent on the initialization operation for addressables. Once the initialization operation completes, the information returned will be accurate.
|
|
/// </summary>
|
|
/// <returns>The download status.</returns>
|
|
public DownloadStatus GetDownloadStatus()
|
|
{
|
|
return InternalGetDownloadStatus(new HashSet<object>());
|
|
}
|
|
|
|
internal DownloadStatus InternalGetDownloadStatus(HashSet<object> visited)
|
|
{
|
|
if (visited == null)
|
|
visited = new HashSet<object>();
|
|
return visited.Add(InternalOp) ? InternalOp.GetDownloadStatus(visited) : new DownloadStatus() {IsDone = IsDone};
|
|
}
|
|
|
|
/// <summary>
|
|
/// The current reference count of the internal operation.
|
|
/// </summary>
|
|
internal int ReferenceCount
|
|
{
|
|
get { return InternalOp.ReferenceCount; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Release the handle. If the internal operation reference count reaches 0, the resource will be released.
|
|
/// </summary>
|
|
internal void Release()
|
|
{
|
|
InternalOp.DecrementReferenceCount();
|
|
m_InternalOp = null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The result object of the operations.
|
|
/// </summary>
|
|
public object Result
|
|
{
|
|
get { return InternalOp.GetResultAsObject(); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// The status of the internal operation.
|
|
/// </summary>
|
|
public AsyncOperationStatus Status
|
|
{
|
|
get { return InternalOp.Status; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return a Task object to wait on when using async await.
|
|
/// </summary>
|
|
public System.Threading.Tasks.Task<object> Task
|
|
{
|
|
get { return InternalOp.Task; }
|
|
}
|
|
|
|
object IEnumerator.Current
|
|
{
|
|
get { return Result; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overload for <see cref="IEnumerator.MoveNext"/>.
|
|
/// </summary>
|
|
/// <returns>Returns true if the enumerator can advance to the next element in the collectin. Returns false otherwise.</returns>
|
|
bool IEnumerator.MoveNext()
|
|
{
|
|
return !IsDone;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overload for <see cref="IEnumerator.Reset"/>.
|
|
/// </summary>
|
|
void IEnumerator.Reset()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Synchronously complete the async operation.
|
|
/// </summary>
|
|
/// <returns>The result of the operation or null.</returns>
|
|
public object WaitForCompletion()
|
|
{
|
|
#if !UNITY_2021_1_OR_NEWER
|
|
IsWaitingForCompletion = true;
|
|
try
|
|
{
|
|
if (IsValid() && !InternalOp.IsDone)
|
|
InternalOp.WaitForCompletion();
|
|
if (IsValid())
|
|
return Result;
|
|
}
|
|
finally
|
|
{
|
|
IsWaitingForCompletion = false;
|
|
}
|
|
#else
|
|
if (IsValid() && !InternalOp.IsDone)
|
|
InternalOp.WaitForCompletion();
|
|
if (IsValid())
|
|
return Result;
|
|
#endif
|
|
return null;
|
|
}
|
|
}
|
|
}
|