#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
|
|
using System;
|
using System.Threading;
|
using UnityEngine.Rendering;
|
|
namespace Cysharp.Threading.Tasks
|
{
|
public static partial class UnityAsyncExtensions
|
{
|
#region AsyncGPUReadbackRequest
|
|
public static UniTask<AsyncGPUReadbackRequest>.Awaiter GetAwaiter(this AsyncGPUReadbackRequest asyncOperation)
|
{
|
return ToUniTask(asyncOperation).GetAwaiter();
|
}
|
|
public static UniTask<AsyncGPUReadbackRequest> WithCancellation(this AsyncGPUReadbackRequest asyncOperation, CancellationToken cancellationToken)
|
{
|
return ToUniTask(asyncOperation, cancellationToken: cancellationToken);
|
}
|
|
public static UniTask<AsyncGPUReadbackRequest> WithCancellation(this AsyncGPUReadbackRequest asyncOperation, CancellationToken cancellationToken, bool cancelImmediately)
|
{
|
return ToUniTask(asyncOperation, cancellationToken: cancellationToken, cancelImmediately: cancelImmediately);
|
}
|
|
public static UniTask<AsyncGPUReadbackRequest> ToUniTask(this AsyncGPUReadbackRequest asyncOperation, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken), bool cancelImmediately = false)
|
{
|
if (asyncOperation.done) return UniTask.FromResult(asyncOperation);
|
return new UniTask<AsyncGPUReadbackRequest>(AsyncGPUReadbackRequestAwaiterConfiguredSource.Create(asyncOperation, timing, cancellationToken, cancelImmediately, out var token), token);
|
}
|
|
sealed class AsyncGPUReadbackRequestAwaiterConfiguredSource : IUniTaskSource<AsyncGPUReadbackRequest>, IPlayerLoopItem, ITaskPoolNode<AsyncGPUReadbackRequestAwaiterConfiguredSource>
|
{
|
static TaskPool<AsyncGPUReadbackRequestAwaiterConfiguredSource> pool;
|
AsyncGPUReadbackRequestAwaiterConfiguredSource nextNode;
|
public ref AsyncGPUReadbackRequestAwaiterConfiguredSource NextNode => ref nextNode;
|
|
static AsyncGPUReadbackRequestAwaiterConfiguredSource()
|
{
|
TaskPool.RegisterSizeGetter(typeof(AsyncGPUReadbackRequestAwaiterConfiguredSource), () => pool.Size);
|
}
|
|
AsyncGPUReadbackRequest asyncOperation;
|
CancellationToken cancellationToken;
|
CancellationTokenRegistration cancellationTokenRegistration;
|
bool cancelImmediately;
|
UniTaskCompletionSourceCore<AsyncGPUReadbackRequest> core;
|
|
AsyncGPUReadbackRequestAwaiterConfiguredSource()
|
{
|
}
|
|
public static IUniTaskSource<AsyncGPUReadbackRequest> Create(AsyncGPUReadbackRequest asyncOperation, PlayerLoopTiming timing, CancellationToken cancellationToken, bool cancelImmediately, out short token)
|
{
|
if (cancellationToken.IsCancellationRequested)
|
{
|
return AutoResetUniTaskCompletionSource<AsyncGPUReadbackRequest>.CreateFromCanceled(cancellationToken, out token);
|
}
|
|
if (!pool.TryPop(out var result))
|
{
|
result = new AsyncGPUReadbackRequestAwaiterConfiguredSource();
|
}
|
|
result.asyncOperation = asyncOperation;
|
result.cancellationToken = cancellationToken;
|
result.cancelImmediately = cancelImmediately;
|
|
if (cancelImmediately && cancellationToken.CanBeCanceled)
|
{
|
result.cancellationTokenRegistration = cancellationToken.RegisterWithoutCaptureExecutionContext(state =>
|
{
|
var promise = (AsyncGPUReadbackRequestAwaiterConfiguredSource)state;
|
promise.core.TrySetCanceled(promise.cancellationToken);
|
}, result);
|
}
|
|
TaskTracker.TrackActiveTask(result, 3);
|
|
PlayerLoopHelper.AddAction(timing, result);
|
|
token = result.core.Version;
|
return result;
|
}
|
|
public AsyncGPUReadbackRequest GetResult(short token)
|
{
|
try
|
{
|
return core.GetResult(token);
|
}
|
finally
|
{
|
if (!(cancelImmediately && cancellationToken.IsCancellationRequested))
|
{
|
TryReturn();
|
}
|
else
|
{
|
TaskTracker.RemoveTracking(this);
|
}
|
}
|
}
|
|
void IUniTaskSource.GetResult(short token)
|
{
|
GetResult(token);
|
}
|
|
public UniTaskStatus GetStatus(short token)
|
{
|
return core.GetStatus(token);
|
}
|
|
public UniTaskStatus UnsafeGetStatus()
|
{
|
return core.UnsafeGetStatus();
|
}
|
|
public void OnCompleted(Action<object> continuation, object state, short token)
|
{
|
core.OnCompleted(continuation, state, token);
|
}
|
|
public bool MoveNext()
|
{
|
if (cancellationToken.IsCancellationRequested)
|
{
|
core.TrySetCanceled(cancellationToken);
|
return false;
|
}
|
|
if (asyncOperation.hasError)
|
{
|
core.TrySetException(new Exception("AsyncGPUReadbackRequest.hasError = true"));
|
return false;
|
}
|
|
if (asyncOperation.done)
|
{
|
core.TrySetResult(asyncOperation);
|
return false;
|
}
|
|
return true;
|
}
|
|
bool TryReturn()
|
{
|
TaskTracker.RemoveTracking(this);
|
core.Reset();
|
asyncOperation = default;
|
cancellationToken = default;
|
cancellationTokenRegistration.Dispose();
|
cancelImmediately = default;
|
return pool.TryPush(this);
|
}
|
}
|
|
#endregion
|
}
|
}
|
