renaming namspeac to Cysharp.Threading.Tasks and move to under Plugins/UniTask

Assets/Plugins/System.Runtime.CompilerServices.Unsafe.dll.meta

@@ -1,33 +0,0 @@
-fileFormatVersion: 2
-guid: 28705d6096348bb4893f8f783cd912bb
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      Any: 
-    second:
-      enabled: 1
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Windows Store Apps: WindowsStoreApps
-    second:
-      enabled: 0
-      settings:
-        CPU: AnyCPU
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Plugins/System.Threading.Tasks.Extensions.dll.meta

@@ -1,33 +0,0 @@
-fileFormatVersion: 2
-guid: 563706d062bb0b545959896ab500001a
-PluginImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  iconMap: {}
-  executionOrder: {}
-  defineConstraints: []
-  isPreloaded: 0
-  isOverridable: 0
-  isExplicitlyReferenced: 0
-  validateReferences: 1
-  platformData:
-  - first:
-      Any: 
-    second:
-      enabled: 1
-      settings: {}
-  - first:
-      Editor: Editor
-    second:
-      enabled: 0
-      settings:
-        DefaultValueInitialized: true
-  - first:
-      Windows Store Apps: WindowsStoreApps
-    second:
-      enabled: 0
-      settings:
-        CPU: AnyCPU
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/Plugins/UniTask.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4929ac1f6fcfe944a99529b6fb5bd9ef
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/AsyncLazy.cs

@@ -0,0 +1,121 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks
+{
+    public class AsyncLazy
+    {
+        Func<UniTask> valueFactory;
+        UniTask target;
+        object syncLock;
+        bool initialized;
+
+        public AsyncLazy(Func<UniTask> valueFactory)
+        {
+            this.valueFactory = valueFactory;
+            this.target = default;
+            this.syncLock = new object();
+            this.initialized = false;
+        }
+
+        internal AsyncLazy(UniTask value)
+        {
+            this.valueFactory = null;
+            this.target = value;
+            this.syncLock = null;
+            this.initialized = true;
+        }
+
+        public UniTask Task => EnsureInitialized();
+
+        public UniTask.Awaiter GetAwaiter() => EnsureInitialized().GetAwaiter();
+
+        UniTask EnsureInitialized()
+        {
+            if (Volatile.Read(ref initialized))
+            {
+                return target;
+            }
+
+            return EnsureInitializedCore();
+        }
+
+        UniTask EnsureInitializedCore()
+        {
+            lock (syncLock)
+            {
+                if (!Volatile.Read(ref initialized))
+                {
+                    var f = Interlocked.Exchange(ref valueFactory, null);
+                    if (f != null)
+                    {
+                        target = f().Preserve(); // with preserve(allow multiple await).
+                        Volatile.Write(ref initialized, true);
+                    }
+                }
+            }
+
+            return target;
+        }
+    }
+
+    public class AsyncLazy<T>
+    {
+        Func<UniTask<T>> valueFactory;
+        UniTask<T> target;
+        object syncLock;
+        bool initialized;
+
+        public AsyncLazy(Func<UniTask<T>> valueFactory)
+        {
+            this.valueFactory = valueFactory;
+            this.target = default;
+            this.syncLock = new object();
+            this.initialized = false;
+        }
+
+        internal AsyncLazy(UniTask<T> value)
+        {
+            this.valueFactory = null;
+            this.target = value;
+            this.syncLock = null;
+            this.initialized = true;
+        }
+
+        public UniTask<T> Task => EnsureInitialized();
+
+        public UniTask<T>.Awaiter GetAwaiter() => EnsureInitialized().GetAwaiter();
+
+        UniTask<T> EnsureInitialized()
+        {
+            if (Volatile.Read(ref initialized))
+            {
+                return target;
+            }
+
+            return EnsureInitializedCore();
+        }
+
+        UniTask<T> EnsureInitializedCore()
+        {
+            lock (syncLock)
+            {
+                if (!Volatile.Read(ref initialized))
+                {
+                    var f = Interlocked.Exchange(ref valueFactory, null);
+                    if (f != null)
+                    {
+                        target = f().Preserve(); // with preserve(allow multiple await).
+                        Volatile.Write(ref initialized, true);
+                    }
+                }
+            }
+
+            return target;
+        }
+    }
+}
+#endif

Assets/Plugins/UniTask/AsyncLazy.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 01d1404ca421466419a7db7340ff5e77
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/AsyncUnit.cs

@@ -0,0 +1,28 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or 
+
+using System;
+
+namespace Cysharp.Threading.Tasks
+{
+    public struct AsyncUnit : IEquatable<AsyncUnit>
+    {
+        public static readonly AsyncUnit Default = new AsyncUnit();
+
+        public override int GetHashCode()
+        {
+            return 0;
+        }
+
+        public bool Equals(AsyncUnit other)
+        {
+            return true;
+        }
+
+        public override string ToString()
+        {
+            return "()";
+        }
+    }
+}
+#endif

Assets/Plugins/UniTask/AsyncUnit.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4f95ac245430d304bb5128d13b6becc8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/CancellationTokenEqualityComparer.cs

@@ -0,0 +1,25 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks
+{
+    public class CancellationTokenEqualityComparer : IEqualityComparer<CancellationToken>
+    {
+        public static readonly IEqualityComparer<CancellationToken> Default = new CancellationTokenEqualityComparer();
+
+        public bool Equals(CancellationToken x, CancellationToken y)
+        {
+            return x.Equals(y);
+        }
+
+        public int GetHashCode(CancellationToken obj)
+        {
+            return obj.GetHashCode();
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/CancellationTokenEqualityComparer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7d739f510b125b74fa7290ac4335e46e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/CancellationTokenExtensions.cs

@@ -0,0 +1,76 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks
+{
+    public static class CancellationTokenExtensions
+    {
+        static readonly Action<object> cancellationTokenCallback = Callback;
+
+        public static (UniTask, CancellationTokenRegistration) ToUniTask(this CancellationToken cts)
+        {
+            if (cts.IsCancellationRequested)
+            {
+                return (UniTask.FromCanceled(cts), default(CancellationTokenRegistration));
+            }
+
+            var promise = new UniTaskCompletionSource();
+            return (promise.Task, cts.RegisterWithoutCaptureExecutionContext(cancellationTokenCallback, promise));
+        }
+
+        static void Callback(object state)
+        {
+            var promise = (UniTaskCompletionSource)state;
+            promise.TrySetResult();
+        }
+
+        public static CancellationTokenRegistration RegisterWithoutCaptureExecutionContext(this CancellationToken cancellationToken, Action callback)
+        {
+            var restoreFlow = false;
+            if (!ExecutionContext.IsFlowSuppressed())
+            {
+                ExecutionContext.SuppressFlow();
+                restoreFlow = true;
+            }
+
+            try
+            {
+                return cancellationToken.Register(callback, false);
+            }
+            finally
+            {
+                if (restoreFlow)
+                {
+                    ExecutionContext.RestoreFlow();
+                }
+            }
+        }
+
+        public static CancellationTokenRegistration RegisterWithoutCaptureExecutionContext(this CancellationToken cancellationToken, Action<object> callback, object state)
+        {
+            var restoreFlow = false;
+            if (!ExecutionContext.IsFlowSuppressed())
+            {
+                ExecutionContext.SuppressFlow();
+                restoreFlow = true;
+            }
+
+            try
+            {
+                return cancellationToken.Register(callback, state, false);
+            }
+            finally
+            {
+                if (restoreFlow)
+                {
+                    ExecutionContext.RestoreFlow();
+                }
+            }
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/CancellationTokenExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4be7209f04146bd45ac5ee775a5f7c26
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/CancellationTokenSourceExtensions.cs

@@ -0,0 +1,52 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Threading;
+using UnityEngine;
+using Cysharp.Threading.Tasks.Triggers;
+using System;
+
+namespace Cysharp.Threading.Tasks
+{
+    public static class CancellationTokenSourceExtensions
+    {
+        public static void CancelAfterSlim(this CancellationTokenSource cts, int millisecondsDelay, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
+        {
+            var delay = UniTask.Delay(millisecondsDelay, ignoreTimeScale, delayTiming, cts.Token);
+            CancelAfterCore(cts, delay).Forget();
+        }
+
+        public static void CancelAfterSlim(this CancellationTokenSource cts, TimeSpan delayTimeSpan, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update)
+        {
+            var delay = UniTask.Delay(delayTimeSpan, ignoreTimeScale, delayTiming, cts.Token);
+            CancelAfterCore(cts, delay).Forget();
+        }
+
+        static async UniTaskVoid CancelAfterCore(CancellationTokenSource cts, UniTask delayTask)
+        {
+            var alreadyCanceled = await delayTask.SuppressCancellationThrow();
+            if (!alreadyCanceled)
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
+        }
+
+        public static void RegisterRaiseCancelOnDestroy(this CancellationTokenSource cts, Component component)
+        {
+            RegisterRaiseCancelOnDestroy(cts, component.gameObject);
+        }
+
+        public static void RegisterRaiseCancelOnDestroy(this CancellationTokenSource cts, GameObject gameObject)
+        {
+            var trigger = gameObject.GetAsyncDestroyTrigger();
+            trigger.CancellationToken.RegisterWithoutCaptureExecutionContext(state =>
+            {
+                var cts2 = (CancellationTokenSource)state;
+                cts2.Cancel();
+            }, cts);
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/CancellationTokenSourceExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 22d85d07f1e70ab42a7a4c25bd65e661
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/CompilerServices.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 64b064347ca7a404494a996b072e2e29
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/CompilerServices/AsyncMethodBuilderAttribute.cs

@@ -0,0 +1,19 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+#pragma warning disable CS0436
+
+namespace System.Runtime.CompilerServices
+{
+    internal sealed class AsyncMethodBuilderAttribute : Attribute
+    {
+        public Type BuilderType { get; }
+
+        public AsyncMethodBuilderAttribute(Type builderType)
+        {
+            BuilderType = builderType;
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/CompilerServices/AsyncMethodBuilderAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 02ce354d37b10454e8376062f7cbe57a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/CompilerServices/AsyncUniTaskMethodBuilder.cs

@@ -0,0 +1,273 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace Cysharp.Threading.Tasks.CompilerServices
+{
+    [StructLayout(LayoutKind.Auto)]
+    public struct AsyncUniTaskMethodBuilder
+    {
+        // cache items.
+        AutoResetUniTaskCompletionSource promise;
+        IMoveNextRunner runner;
+
+        // 1. Static Create method.
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AsyncUniTaskMethodBuilder Create()
+        {
+            return default;
+        }
+
+        // 2. TaskLike Task property.
+        public UniTask Task
+        {
+            [DebuggerHidden]
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                if (promise != null)
+                {
+                    return promise.Task;
+                }
+
+                if (runner == null)
+                {
+                    return UniTask.CompletedTask;
+                }
+
+                promise = AutoResetUniTaskCompletionSource.Create();
+                return promise.Task;
+            }
+        }
+
+        // 3. SetException
+        [DebuggerHidden]
+        public void SetException(Exception exception)
+        {
+            // runner is finished, return first.
+            if (runner != null)
+            {
+                runner.Return();
+                runner = null;
+            }
+
+            if (promise != null)
+            {
+                promise.TrySetException(exception);
+            }
+            else
+            {
+                promise = AutoResetUniTaskCompletionSource.CreateFromException(exception, out _);
+            }
+        }
+
+        // 4. SetResult
+        [DebuggerHidden]
+        public void SetResult()
+        {
+            // runner is finished, return first.
+            if (runner != null)
+            {
+                runner.Return();
+                runner = null;
+            }
+
+            if (promise != null)
+            {
+                promise.TrySetResult();
+            }
+        }
+
+        // 5. AwaitOnCompleted
+        [DebuggerHidden]
+        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : INotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            if (promise == null)
+            {
+                promise = AutoResetUniTaskCompletionSource.Create();
+            }
+            if (runner == null)
+            {
+                runner = MoveNextRunner<TStateMachine>.Create(ref stateMachine);
+            }
+
+            awaiter.OnCompleted(runner.CallMoveNext);
+        }
+
+        // 6. AwaitUnsafeOnCompleted
+        [DebuggerHidden]
+        [SecuritySafeCritical]
+        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : ICriticalNotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            if (promise == null)
+            {
+                promise = AutoResetUniTaskCompletionSource.Create();
+            }
+            if (runner == null)
+            {
+                runner = MoveNextRunner<TStateMachine>.Create(ref stateMachine);
+            }
+
+            awaiter.OnCompleted(runner.CallMoveNext);
+        }
+
+        // 7. Start
+        [DebuggerHidden]
+        public void Start<TStateMachine>(ref TStateMachine stateMachine)
+            where TStateMachine : IAsyncStateMachine
+        {
+            stateMachine.MoveNext();
+        }
+
+        // 8. SetStateMachine
+        [DebuggerHidden]
+        public void SetStateMachine(IAsyncStateMachine stateMachine)
+        {
+            // don't use boxed stateMachine.
+        }
+    }
+
+    [StructLayout(LayoutKind.Auto)]
+    public struct AsyncUniTaskMethodBuilder<T>
+    {
+        // cache items.
+        AutoResetUniTaskCompletionSource<T> promise;
+        IMoveNextRunner runner;
+        T result;
+
+        // 1. Static Create method.
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AsyncUniTaskMethodBuilder<T> Create()
+        {
+            return default;
+        }
+
+        // 2. TaskLike Task property.
+        [DebuggerHidden]
+        public UniTask<T> Task
+        {
+            get
+            {
+                if (promise != null)
+                {
+                    return promise.Task;
+                }
+
+                if (runner == null)
+                {
+                    return UniTask.FromResult(result);
+                }
+
+                promise = AutoResetUniTaskCompletionSource<T>.Create();
+                return promise.Task;
+            }
+        }
+
+        // 3. SetException
+        [DebuggerHidden]
+        public void SetException(Exception exception)
+        {
+            // runner is finished, return first.
+            if (runner != null)
+            {
+                runner.Return();
+                runner = null;
+            }
+
+            if (promise == null)
+            {
+                promise = AutoResetUniTaskCompletionSource<T>.CreateFromException(exception, out _);
+            }
+            else
+            {
+                promise.TrySetException(exception);
+            }
+        }
+
+        // 4. SetResult
+        [DebuggerHidden]
+        public void SetResult(T result)
+        {
+            // runner is finished, return first.
+            if (runner != null)
+            {
+                runner.Return();
+                runner = null;
+            }
+
+            if (promise == null)
+            {
+                this.result = result;
+                return;
+            }
+
+            promise.TrySetResult(result);
+        }
+
+        // 5. AwaitOnCompleted
+        [DebuggerHidden]
+        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : INotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            if (promise == null)
+            {
+                promise = AutoResetUniTaskCompletionSource<T>.Create();
+            }
+            if (runner == null)
+            {
+                runner = MoveNextRunner<TStateMachine>.Create(ref stateMachine);
+            }
+
+            awaiter.OnCompleted(runner.CallMoveNext);
+        }
+
+        // 6. AwaitUnsafeOnCompleted
+        [DebuggerHidden]
+        [SecuritySafeCritical]
+        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : ICriticalNotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            if (promise == null)
+            {
+                promise = AutoResetUniTaskCompletionSource<T>.Create();
+            }
+            if (runner == null)
+            {
+                runner = MoveNextRunner<TStateMachine>.Create(ref stateMachine);
+            }
+
+            awaiter.OnCompleted(runner.CallMoveNext);
+        }
+
+        // 7. Start
+        [DebuggerHidden]
+        public void Start<TStateMachine>(ref TStateMachine stateMachine)
+            where TStateMachine : IAsyncStateMachine
+        {
+            stateMachine.MoveNext();
+        }
+
+        // 8. SetStateMachine
+        [DebuggerHidden]
+        public void SetStateMachine(IAsyncStateMachine stateMachine)
+        {
+            // don't use boxed stateMachine.
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/CompilerServices/AsyncUniTaskMethodBuilder.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 68d72a45afdec574ebc26e7de2c38330
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/CompilerServices/AsyncUniTaskVoidMethodBuilder.cs

@@ -0,0 +1,107 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Security;
+
+namespace Cysharp.Threading.Tasks.CompilerServices
+{
+    public struct AsyncUniTaskVoidMethodBuilder
+    {
+        IMoveNextRunner runner;
+
+        // 1. Static Create method.
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AsyncUniTaskVoidMethodBuilder Create()
+        {
+            return default;
+        }
+
+        // 2. TaskLike Task property(void)
+        public UniTaskVoid Task
+        {
+            [DebuggerHidden]
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return default;
+            }
+        }
+
+        // 3. SetException
+        [DebuggerHidden]
+        public void SetException(Exception exception)
+        {
+            // runner is finished, return first.
+            if (runner != null)
+            {
+                runner.Return();
+                runner = null;
+            }
+
+            UniTaskScheduler.PublishUnobservedTaskException(exception);
+        }
+
+        // 4. SetResult
+        [DebuggerHidden]
+        public void SetResult()
+        {
+            // runner is finished, return.
+            if (runner != null)
+            {
+                runner.Return();
+                runner = null;
+            }
+        }
+
+        // 5. AwaitOnCompleted
+        [DebuggerHidden]
+        public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : INotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            if (runner == null)
+            {
+                runner = MoveNextRunner<TStateMachine>.Create(ref stateMachine);
+            }
+
+            awaiter.OnCompleted(runner.CallMoveNext);
+        }
+
+        // 6. AwaitUnsafeOnCompleted
+        [DebuggerHidden]
+        [SecuritySafeCritical]
+        public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+            where TAwaiter : ICriticalNotifyCompletion
+            where TStateMachine : IAsyncStateMachine
+        {
+            if (runner == null)
+            {
+                runner = MoveNextRunner<TStateMachine>.Create(ref stateMachine);
+            }
+
+            awaiter.OnCompleted(runner.CallMoveNext);
+        }
+
+        // 7. Start
+        [DebuggerHidden]
+        public void Start<TStateMachine>(ref TStateMachine stateMachine)
+            where TStateMachine : IAsyncStateMachine
+        {
+            stateMachine.MoveNext();
+        }
+
+        // 8. SetStateMachine
+        [DebuggerHidden]
+        public void SetStateMachine(IAsyncStateMachine stateMachine)
+        {
+            // don't use boxed stateMachine.
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/CompilerServices/AsyncUniTaskVoidMethodBuilder.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e891aaac17b933a47a9d7fa3b8e1226f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/CompilerServices/MoveNextRunner.cs

@@ -0,0 +1,59 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using Cysharp.Threading.Tasks.Internal;
+
+namespace Cysharp.Threading.Tasks.CompilerServices
+{
+    internal interface IMoveNextRunner
+    {
+        Action CallMoveNext { get; }
+        void Return();
+    }
+
+    internal sealed class MoveNextRunner<TStateMachine> : IMoveNextRunner, IPromisePoolItem
+        where TStateMachine : IAsyncStateMachine
+    {
+        static PromisePool<MoveNextRunner<TStateMachine>> pool = new PromisePool<MoveNextRunner<TStateMachine>>();
+
+        TStateMachine stateMachine;
+        internal readonly Action callMoveNext;
+
+        public Action CallMoveNext => callMoveNext;
+
+        MoveNextRunner()
+        {
+            callMoveNext = MoveNext;
+        }
+
+        public static MoveNextRunner<TStateMachine> Create(ref TStateMachine stateMachine)
+        {
+            var result = pool.TryRent() ?? new MoveNextRunner<TStateMachine>();
+            result.stateMachine = stateMachine;
+            return result;
+        }
+
+        [DebuggerHidden]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        void MoveNext()
+        {
+            stateMachine.MoveNext();
+        }
+
+        public void Return()
+        {
+            pool.TryReturn(this);
+        }
+
+        void IPromisePoolItem.Reset()
+        {
+            stateMachine = default;
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/CompilerServices/MoveNextRunner.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 98649642833cabf44a9dc060ce4c84a1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 275b87293edc6634f9d72387851dbbdf
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Editor/SplitterGUILayout.cs

@@ -0,0 +1,64 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Linq;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+
+namespace Cysharp.Threading.Tasks.Editor
+{
+    // reflection call of UnityEditor.SplitterGUILayout
+    internal static class SplitterGUILayout
+    {
+        static BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;
+
+        static Lazy<Type> splitterStateType = new Lazy<Type>(() =>
+        {
+            var type = typeof(EditorWindow).Assembly.GetTypes().First(x => x.FullName == "UnityEditor.SplitterState");
+            return type;
+        });
+
+        static Lazy<ConstructorInfo> splitterStateCtor = new Lazy<ConstructorInfo>(() =>
+        {
+            var type = splitterStateType.Value;
+            return type.GetConstructor(flags, null, new Type[] { typeof(float[]), typeof(int[]), typeof(int[]) }, null);
+        });
+
+        static Lazy<Type> splitterGUILayoutType = new Lazy<Type>(() =>
+        {
+            var type = typeof(EditorWindow).Assembly.GetTypes().First(x => x.FullName == "UnityEditor.SplitterGUILayout");
+            return type;
+        });
+
+        static Lazy<MethodInfo> beginVerticalSplit = new Lazy<MethodInfo>(() =>
+        {
+            var type = splitterGUILayoutType.Value;
+            return type.GetMethod("BeginVerticalSplit", flags, null, new Type[] { splitterStateType.Value, typeof(GUILayoutOption[]) }, null);
+        });
+
+        static Lazy<MethodInfo> endVerticalSplit = new Lazy<MethodInfo>(() =>
+        {
+            var type = splitterGUILayoutType.Value;
+            return type.GetMethod("EndVerticalSplit", flags, null, Type.EmptyTypes, null);
+        });
+
+        public static object CreateSplitterState(float[] relativeSizes, int[] minSizes, int[] maxSizes)
+        {
+            return splitterStateCtor.Value.Invoke(new object[] { relativeSizes, minSizes, maxSizes });
+        }
+
+        public static void BeginVerticalSplit(object splitterState, params GUILayoutOption[] options)
+        {
+            beginVerticalSplit.Value.Invoke(null, new object[] { splitterState, options });
+        }
+
+        public static void EndVerticalSplit()
+        {
+            endVerticalSplit.Value.Invoke(null, Type.EmptyTypes);
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Editor/SplitterGUILayout.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 40ef2e46f900131419e869398a8d3c9d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Editor/UniRx.Async.Editor.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "UniRx.Async.Editor",
+    "references": [
+        "UniRx.Async"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": []
+}

Assets/Plugins/UniTask/Editor/UniRx.Async.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4129704b5a1a13841ba16f230bf24a57
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Editor/UniTaskTrackerTreeView.cs

@@ -0,0 +1,184 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System;
+using UnityEditor.IMGUI.Controls;
+using Cysharp.Threading.Tasks.Internal;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace Cysharp.Threading.Tasks.Editor
+{
+    public class UniTaskTrackerViewItem : TreeViewItem
+    {
+        static Regex removeHref = new Regex("<a href.+>(.+)</a>", RegexOptions.Compiled);
+
+        public string TaskType { get; set; }
+        public string Elapsed { get; set; }
+        public string Status { get; set; }
+
+        string position;
+        public string Position
+        {
+            get { return position; }
+            set
+            {
+                position = value;
+                PositionFirstLine = GetFirstLine(position);
+            }
+        }
+
+        public string PositionFirstLine { get; private set; }
+
+        static string GetFirstLine(string str)
+        {
+            var sb = new StringBuilder();
+            for (int i = 0; i < str.Length; i++)
+            {
+                if (str[i] == '\r' || str[i] == '\n')
+                {
+                    break;
+                }
+                sb.Append(str[i]);
+            }
+
+            return removeHref.Replace(sb.ToString(), "$1");
+        }
+
+        public UniTaskTrackerViewItem(int id) : base(id)
+        {
+
+        }
+    }
+
+    public class UniTaskTrackerTreeView : TreeView
+    {
+        const string sortedColumnIndexStateKey = "UniTaskTrackerTreeView_sortedColumnIndex";
+
+        public IReadOnlyList<TreeViewItem> CurrentBindingItems;
+
+        public UniTaskTrackerTreeView()
+            : this(new TreeViewState(), new MultiColumnHeader(new MultiColumnHeaderState(new[]
+            {
+                new MultiColumnHeaderState.Column() { headerContent = new GUIContent("TaskType"), width = 20},
+                new MultiColumnHeaderState.Column() { headerContent = new GUIContent("Elapsed"), width = 10},
+                new MultiColumnHeaderState.Column() { headerContent = new GUIContent("Status"), width = 10},
+                new MultiColumnHeaderState.Column() { headerContent = new GUIContent("Position")},
+            })))
+        {
+        }
+
+        UniTaskTrackerTreeView(TreeViewState state, MultiColumnHeader header)
+            : base(state, header)
+        {
+            rowHeight = 20;
+            showAlternatingRowBackgrounds = true;
+            showBorder = true;
+            header.sortingChanged += Header_sortingChanged;
+
+            header.ResizeToFit();
+            Reload();
+
+            header.sortedColumnIndex = SessionState.GetInt(sortedColumnIndexStateKey, 1);
+        }
+
+        public void ReloadAndSort()
+        {
+            var currentSelected = this.state.selectedIDs;
+            Reload();
+            Header_sortingChanged(this.multiColumnHeader);
+            this.state.selectedIDs = currentSelected;
+        }
+
+        private void Header_sortingChanged(MultiColumnHeader multiColumnHeader)
+        {
+            SessionState.SetInt(sortedColumnIndexStateKey, multiColumnHeader.sortedColumnIndex);
+            var index = multiColumnHeader.sortedColumnIndex;
+            var ascending = multiColumnHeader.IsSortedAscending(multiColumnHeader.sortedColumnIndex);
+
+            var items = rootItem.children.Cast<UniTaskTrackerViewItem>();
+
+            IOrderedEnumerable<UniTaskTrackerViewItem> orderedEnumerable;
+            switch (index)
+            {
+                case 0:
+                    orderedEnumerable = ascending ? items.OrderBy(item => item.TaskType) : items.OrderByDescending(item => item.TaskType);
+                    break;
+                case 1:
+                    orderedEnumerable = ascending ? items.OrderBy(item => double.Parse(item.Elapsed)) : items.OrderByDescending(item => double.Parse(item.Elapsed));
+                    break;
+                case 2:
+                    orderedEnumerable = ascending ? items.OrderBy(item => item.Status) : items.OrderByDescending(item => item.Elapsed);
+                    break;
+                case 3:
+                    orderedEnumerable = ascending ? items.OrderBy(item => item.Position) : items.OrderByDescending(item => item.PositionFirstLine);
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(index), index, null);
+            }
+
+            CurrentBindingItems = rootItem.children = orderedEnumerable.Cast<TreeViewItem>().ToList();
+            BuildRows(rootItem);
+        }
+
+        protected override TreeViewItem BuildRoot()
+        {
+            var root = new TreeViewItem { depth = -1 };
+
+            var children = new List<TreeViewItem>();
+
+            TaskTracker.ForEachActiveTask((trackingId, awaiterType, status, created, stackTrace) =>
+            {
+                children.Add(new UniTaskTrackerViewItem(trackingId) { TaskType = awaiterType, Status = status.ToString(), Elapsed = (DateTime.UtcNow - created).TotalSeconds.ToString("00.00"), Position = stackTrace });
+            });
+
+            CurrentBindingItems = children;
+            root.children = CurrentBindingItems as List<TreeViewItem>;
+            return root;
+        }
+
+        protected override bool CanMultiSelect(TreeViewItem item)
+        {
+            return false;
+        }
+
+        protected override void RowGUI(RowGUIArgs args)
+        {
+            var item = args.item as UniTaskTrackerViewItem;
+
+            for (var visibleColumnIndex = 0; visibleColumnIndex < args.GetNumVisibleColumns(); visibleColumnIndex++)
+            {
+                var rect = args.GetCellRect(visibleColumnIndex);
+                var columnIndex = args.GetColumn(visibleColumnIndex);
+
+                var labelStyle = args.selected ? EditorStyles.whiteLabel : EditorStyles.label;
+                labelStyle.alignment = TextAnchor.MiddleLeft;
+                switch (columnIndex)
+                {
+                    case 0:
+                        EditorGUI.LabelField(rect, item.TaskType, labelStyle);
+                        break;
+                    case 1:
+                        EditorGUI.LabelField(rect, item.Elapsed, labelStyle);
+                        break;
+                    case 2:
+                        EditorGUI.LabelField(rect, item.Status, labelStyle);
+                        break;
+                    case 3:
+                        EditorGUI.LabelField(rect, item.PositionFirstLine, labelStyle);
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(columnIndex), columnIndex, null);
+                }
+            }
+        }
+    }
+
+}
+
+#endif

Assets/Plugins/UniTask/Editor/UniTaskTrackerTreeView.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 52e2d973a2156674e8c1c9433ed031f7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Editor/UniTaskTrackerWindow.cs

@@ -0,0 +1,211 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System;
+using UnityEditor.IMGUI.Controls;
+using Cysharp.Threading.Tasks.Internal;
+
+namespace Cysharp.Threading.Tasks.Editor
+{
+    public class UniTaskTrackerWindow : EditorWindow
+    {
+        static int interval;
+
+        static UniTaskTrackerWindow window;
+
+        [MenuItem("Window/UniTask Tracker")]
+        public static void OpenWindow()
+        {
+            if (window != null)
+            {
+                window.Close();
+            }
+
+            // will called OnEnable(singleton instance will be set).
+            GetWindow<UniTaskTrackerWindow>("UniTask Tracker").Show();
+        }
+
+        static readonly GUILayoutOption[] EmptyLayoutOption = new GUILayoutOption[0];
+
+        UniTaskTrackerTreeView treeView;
+        object splitterState;
+
+        void OnEnable()
+        {
+            window = this; // set singleton.
+            splitterState = SplitterGUILayout.CreateSplitterState(new float[] { 75f, 25f }, new int[] { 32, 32 }, null);
+            treeView = new UniTaskTrackerTreeView();
+            TaskTracker.EditorEnableState.EnableAutoReload = EditorPrefs.GetBool(TaskTracker.EnableAutoReloadKey, false);
+            TaskTracker.EditorEnableState.EnableTracking = EditorPrefs.GetBool(TaskTracker.EnableTrackingKey, false);
+            TaskTracker.EditorEnableState.EnableStackTrace = EditorPrefs.GetBool(TaskTracker.EnableStackTraceKey, false);
+        }
+
+        void OnGUI()
+        {
+            // Head
+            RenderHeadPanel();
+
+            // Splittable
+            SplitterGUILayout.BeginVerticalSplit(this.splitterState, EmptyLayoutOption);
+            {
+                // Column Tabble
+                RenderTable();
+
+                // StackTrace details
+                RenderDetailsPanel();
+            }
+            SplitterGUILayout.EndVerticalSplit();
+        }
+
+        #region HeadPanel
+
+        public static bool EnableAutoReload => TaskTracker.EditorEnableState.EnableAutoReload;
+        public static bool EnableTracking => TaskTracker.EditorEnableState.EnableTracking;
+        public static bool EnableStackTrace => TaskTracker.EditorEnableState.EnableStackTrace;
+        static readonly GUIContent EnableAutoReloadHeadContent = EditorGUIUtility.TrTextContent("Enable AutoReload", "Reload automatically.", (Texture)null);
+        static readonly GUIContent ReloadHeadContent = EditorGUIUtility.TrTextContent("Reload", "Reload View.", (Texture)null);
+        static readonly GUIContent GCHeadContent = EditorGUIUtility.TrTextContent("GC.Collect", "Invoke GC.Collect.", (Texture)null);
+        static readonly GUIContent EnableTrackingHeadContent = EditorGUIUtility.TrTextContent("Enable Tracking", "Start to track async/await UniTask. Performance impact: low", (Texture)null);
+        static readonly GUIContent EnableStackTraceHeadContent = EditorGUIUtility.TrTextContent("Enable StackTrace", "Capture StackTrace when task is started. Performance impact: high", (Texture)null);
+
+        // [Enable Tracking] | [Enable StackTrace]
+        void RenderHeadPanel()
+        {
+            EditorGUILayout.BeginVertical(EmptyLayoutOption);
+            EditorGUILayout.BeginHorizontal(EditorStyles.toolbar, EmptyLayoutOption);
+
+            if (GUILayout.Toggle(EnableAutoReload, EnableAutoReloadHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption) != EnableAutoReload)
+            {
+                TaskTracker.EditorEnableState.EnableAutoReload = !EnableAutoReload;
+            }
+
+            if (GUILayout.Toggle(EnableTracking, EnableTrackingHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption) != EnableTracking)
+            {
+                TaskTracker.EditorEnableState.EnableTracking = !EnableTracking;
+            }
+
+            if (GUILayout.Toggle(EnableStackTrace, EnableStackTraceHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption) != EnableStackTrace)
+            {
+                TaskTracker.EditorEnableState.EnableStackTrace = !EnableStackTrace;
+            }
+
+            GUILayout.FlexibleSpace();
+
+            if (GUILayout.Button(ReloadHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption))
+            {
+                TaskTracker.CheckAndResetDirty();
+                treeView.ReloadAndSort();
+                Repaint();
+            }
+
+            if (GUILayout.Button(GCHeadContent, EditorStyles.toolbarButton, EmptyLayoutOption))
+            {
+                GC.Collect(0);
+            }
+
+            EditorGUILayout.EndHorizontal();
+            EditorGUILayout.EndVertical();
+        }
+
+        #endregion
+
+        #region TableColumn
+
+        Vector2 tableScroll;
+        GUIStyle tableListStyle;
+
+        void RenderTable()
+        {
+            if (tableListStyle == null)
+            {
+                tableListStyle = new GUIStyle("CN Box");
+                tableListStyle.margin.top = 0;
+                tableListStyle.padding.left = 3;
+            }
+
+            EditorGUILayout.BeginVertical(tableListStyle, EmptyLayoutOption);
+
+            this.tableScroll = EditorGUILayout.BeginScrollView(this.tableScroll, new GUILayoutOption[]
+            {
+                GUILayout.ExpandWidth(true),
+                GUILayout.MaxWidth(2000f)
+            });
+            var controlRect = EditorGUILayout.GetControlRect(new GUILayoutOption[]
+            {
+                GUILayout.ExpandHeight(true),
+                GUILayout.ExpandWidth(true)
+            });
+
+
+            treeView?.OnGUI(controlRect);
+
+            EditorGUILayout.EndScrollView();
+            EditorGUILayout.EndVertical();
+        }
+
+        private void Update()
+        {
+            if (EnableAutoReload)
+            {
+                if (interval++ % 120 == 0)
+                {
+                    if (TaskTracker.CheckAndResetDirty())
+                    {
+                        treeView.ReloadAndSort();
+                        Repaint();
+                    }
+                }
+            }
+        }
+
+        #endregion
+
+        #region Details
+
+        static GUIStyle detailsStyle;
+        Vector2 detailsScroll;
+
+        void RenderDetailsPanel()
+        {
+            if (detailsStyle == null)
+            {
+                detailsStyle = new GUIStyle("CN Message");
+                detailsStyle.wordWrap = false;
+                detailsStyle.stretchHeight = true;
+                detailsStyle.margin.right = 15;
+            }
+
+            string message = "";
+            var selected = treeView.state.selectedIDs;
+            if (selected.Count > 0)
+            {
+                var first = selected[0];
+                var item = treeView.CurrentBindingItems.FirstOrDefault(x => x.id == first) as UniTaskTrackerViewItem;
+                if (item != null)
+                {
+                    message = item.Position;
+                }
+            }
+
+            detailsScroll = EditorGUILayout.BeginScrollView(this.detailsScroll, EmptyLayoutOption);
+            var vector = detailsStyle.CalcSize(new GUIContent(message));
+            EditorGUILayout.SelectableLabel(message, detailsStyle, new GUILayoutOption[]
+            {
+                GUILayout.ExpandHeight(true),
+                GUILayout.ExpandWidth(true),
+                GUILayout.MinWidth(vector.x),
+                GUILayout.MinHeight(vector.y)
+            });
+            EditorGUILayout.EndScrollView();
+        }
+
+        #endregion
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Editor/UniTaskTrackerWindow.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5bee3e3860e37484aa3b861bf76d129f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/EnumerableAsyncExtensions.cs

@@ -0,0 +1,36 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+
+namespace Cysharp.Threading.Tasks
+{
+    public static class EnumerableAsyncExtensions
+    {
+        // overload resolver - .Select(async x => { }) : IEnumerable<UniTask<T>>
+
+        public static IEnumerable<UniTask> Select<T>(this IEnumerable<T> source, Func<T, UniTask> selector)
+        {
+            return System.Linq.Enumerable.Select(source, selector);
+        }
+
+        public static IEnumerable<UniTask<TR>> Select<T, TR>(this IEnumerable<T> source, Func<T, UniTask<TR>> selector)
+        {
+            return System.Linq.Enumerable.Select(source, selector);
+        }
+
+        public static IEnumerable<UniTask> Select<T>(this IEnumerable<T> source, Func<T, int, UniTask> selector)
+        {
+            return System.Linq.Enumerable.Select(source, selector);
+        }
+
+        public static IEnumerable<UniTask<TR>> Select<T, TR>(this IEnumerable<T> source, Func<T, int, UniTask<TR>> selector)
+        {
+            return System.Linq.Enumerable.Select(source, selector);
+        }
+    }
+}
+
+
+#endif

Assets/Plugins/UniTask/EnumerableAsyncExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ff50260d74bd54c4b92cf99895549445
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/EnumeratorAsyncExtensions.cs

@@ -0,0 +1,230 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections;
+using System.Reflection;
+using System.Runtime.ExceptionServices;
+using System.Threading;
+using Cysharp.Threading.Tasks.Internal;
+using UnityEngine;
+
+namespace Cysharp.Threading.Tasks
+{
+    public static class EnumeratorAsyncExtensions
+    {
+        public static UniTask.Awaiter GetAwaiter(this IEnumerator enumerator)
+        {
+            return new UniTask(EnumeratorPromise.Create(enumerator, PlayerLoopTiming.Update, CancellationToken.None, out var token), token).GetAwaiter();
+        }
+
+        public static UniTask ToUniTask(this IEnumerator enumerator)
+        {
+            return new UniTask(EnumeratorPromise.Create(enumerator, PlayerLoopTiming.Update, CancellationToken.None, out var token), token);
+        }
+
+        public static UniTask ConfigureAwait(this IEnumerator enumerator, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return new UniTask(EnumeratorPromise.Create(enumerator, timing, cancellationToken, out var token), token);
+        }
+
+        class EnumeratorPromise : IUniTaskSource, IPlayerLoopItem, IPromisePoolItem
+        {
+            static readonly PromisePool<EnumeratorPromise> pool = new PromisePool<EnumeratorPromise>();
+
+            IEnumerator innerEnumerator;
+            CancellationToken cancellationToken;
+
+            UniTaskCompletionSourceCore<object> core;
+
+            EnumeratorPromise()
+            {
+            }
+
+            public static IUniTaskSource Create(IEnumerator innerEnumerator, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                var result = pool.TryRent() ?? new EnumeratorPromise();
+
+                result.innerEnumerator = ConsumeEnumerator(innerEnumerator);
+                result.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                PlayerLoopHelper.AddAction(timing, result);
+
+                token = result.core.Version;
+                return result;
+            }
+
+            public void GetResult(short token)
+            {
+                try
+                {
+                    TaskTracker.RemoveTracking(this);
+                    core.GetResult(token);
+                }
+                finally
+                {
+                    pool.TryReturn(this);
+                }
+            }
+
+            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;
+                }
+
+                try
+                {
+                    if (innerEnumerator.MoveNext())
+                    {
+                        return true;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    core.TrySetException(ex);
+                    return false;
+                }
+
+                core.TrySetResult(null);
+                return false;
+            }
+
+            public void Reset()
+            {
+                core.Reset();
+                innerEnumerator = default;
+                cancellationToken = default;
+            }
+
+            ~EnumeratorPromise()
+            {
+                if (pool.TryReturn(this))
+                {
+                    GC.ReRegisterForFinalize(this);
+                }
+            }
+
+            // Unwrap YieldInstructions
+
+            static IEnumerator ConsumeEnumerator(IEnumerator enumerator)
+            {
+                while (enumerator.MoveNext())
+                {
+                    var current = enumerator.Current;
+                    if (current == null)
+                    {
+                        yield return null;
+                    }
+                    else if (current is CustomYieldInstruction)
+                    {
+                        // WWW, WaitForSecondsRealtime
+                        var e2 = UnwrapWaitCustomYieldInstruction((CustomYieldInstruction)current);
+                        while (e2.MoveNext())
+                        {
+                            yield return null;
+                        }
+                    }
+                    else if (current is YieldInstruction)
+                    {
+                        IEnumerator innerCoroutine = null;
+                        switch (current)
+                        {
+                            case AsyncOperation ao:
+                                innerCoroutine = UnwrapWaitAsyncOperation(ao);
+                                break;
+                            case WaitForSeconds wfs:
+                                innerCoroutine = UnwrapWaitForSeconds(wfs);
+                                break;
+                        }
+                        if (innerCoroutine != null)
+                        {
+                            while (innerCoroutine.MoveNext())
+                            {
+                                yield return null;
+                            }
+                        }
+                        else
+                        {
+                            yield return null;
+                        }
+                    }
+                    else if (current is IEnumerator e3)
+                    {
+                        var e4 = ConsumeEnumerator(e3);
+                        while (e4.MoveNext())
+                        {
+                            yield return null;
+                        }
+                    }
+                    else
+                    {
+                        // WaitForEndOfFrame, WaitForFixedUpdate, others.
+                        yield return null;
+                    }
+                }
+            }
+
+            // WWW and others as CustomYieldInstruction.
+            static IEnumerator UnwrapWaitCustomYieldInstruction(CustomYieldInstruction yieldInstruction)
+            {
+                while (yieldInstruction.keepWaiting)
+                {
+                    yield return null;
+                }
+            }
+
+            static readonly FieldInfo waitForSeconds_Seconds = typeof(WaitForSeconds).GetField("m_Seconds", BindingFlags.Instance | BindingFlags.GetField | BindingFlags.NonPublic);
+
+            static IEnumerator UnwrapWaitForSeconds(WaitForSeconds waitForSeconds)
+            {
+                var second = (float)waitForSeconds_Seconds.GetValue(waitForSeconds);
+                var startTime = DateTimeOffset.UtcNow;
+                while (true)
+                {
+                    yield return null;
+
+                    var elapsed = (DateTimeOffset.UtcNow - startTime).TotalSeconds;
+                    if (elapsed >= second)
+                    {
+                        break;
+                    }
+                };
+            }
+
+            static IEnumerator UnwrapWaitAsyncOperation(AsyncOperation asyncOperation)
+            {
+                while (!asyncOperation.isDone)
+                {
+                    yield return null;
+                }
+            }
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/EnumeratorAsyncExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bc661232f11e4a741af54ba1c175d5ee
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/ExceptionExtensions.cs

@@ -0,0 +1,16 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+
+using System;
+
+namespace Cysharp.Threading.Tasks
+{
+    public static class ExceptionExtensions
+    {
+        public static bool IsOperationCanceledException(this Exception exception)
+        {
+            return exception is OperationCanceledException;
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/ExceptionExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 930800098504c0d46958ce23a0495202
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/IUniTaskSource.cs

@@ -0,0 +1,68 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Cysharp.Threading.Tasks
+{
+    public enum UniTaskStatus
+    {
+        /// <summary>The operation has not yet completed.</summary>
+        Pending = 0,
+        /// <summary>The operation completed successfully.</summary>
+        Succeeded = 1,
+        /// <summary>The operation completed with an error.</summary>
+        Faulted = 2,
+        /// <summary>The operation completed due to cancellation.</summary>
+        Canceled = 3
+    }
+
+    // similar as IValueTaskSource
+    public interface IUniTaskSource
+    {
+        UniTaskStatus GetStatus(short token);
+        void OnCompleted(Action<object> continuation, object state, short token);
+        void GetResult(short token);
+
+        UniTaskStatus UnsafeGetStatus(); // only for debug use.
+    }
+
+    public interface IUniTaskSource<out T> : IUniTaskSource
+    {
+        new T GetResult(short token);
+    }
+
+    public static class UniTaskStatusExtensions
+    {
+        /// <summary>status != Pending.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsCompleted(this UniTaskStatus status)
+        {
+            return status != UniTaskStatus.Pending;
+        }
+
+        /// <summary>status == Succeeded.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsCompletedSuccessfully(this UniTaskStatus status)
+        {
+            return status == UniTaskStatus.Succeeded;
+        }
+
+        /// <summary>status == Canceled.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsCanceled(this UniTaskStatus status)
+        {
+            return status == UniTaskStatus.Canceled;
+        }
+
+        /// <summary>status == Faulted.</summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool IsFaulted(this UniTaskStatus status)
+        {
+            return status == UniTaskStatus.Faulted;
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/IUniTaskSource.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3e4d023d8404ab742b5e808c98097c3c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 633f49a8aafb6fa43894cd4646c71743
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal/ArrayPool.cs

@@ -0,0 +1,152 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    // Same interface as System.Buffers.ArrayPool<T> but only provides Shared.
+
+    internal sealed class ArrayPool<T>
+    {
+        // Same size as System.Buffers.DefaultArrayPool<T>
+        const int DefaultMaxNumberOfArraysPerBucket = 50;
+
+        static readonly T[] EmptyArray = new T[0];
+
+        public static readonly ArrayPool<T> Shared = new ArrayPool<T>();
+
+        readonly MinimumQueue<T[]>[] buckets;
+        readonly SpinLock[] locks;
+
+        ArrayPool()
+        {
+            // see: GetQueueIndex
+            buckets = new MinimumQueue<T[]>[18];
+            locks = new SpinLock[18];
+            for (int i = 0; i < buckets.Length; i++)
+            {
+                buckets[i] = new MinimumQueue<T[]>(4);
+                locks[i] = new SpinLock(false);
+            }
+        }
+
+        public T[] Rent(int minimumLength)
+        {
+            if (minimumLength < 0)
+            {
+                throw new ArgumentOutOfRangeException("minimumLength");
+            }
+            else if (minimumLength == 0)
+            {
+                return EmptyArray;
+            }
+
+            var size = CalculateSize(minimumLength);
+            var index = GetQueueIndex(size);
+            if (index != -1)
+            {
+                var q = buckets[index];
+                var lockTaken = false;
+                try
+                {
+                    locks[index].Enter(ref lockTaken);
+
+                    if (q.Count != 0)
+                    {
+                        return q.Dequeue();
+                    }
+                }
+                finally
+                {
+                    if (lockTaken) locks[index].Exit(false);
+                }
+            }
+
+            return new T[size];
+        }
+
+        public void Return(T[] array, bool clearArray = false)
+        {
+            if (array == null || array.Length == 0)
+            {
+                return;
+            }
+
+            var index = GetQueueIndex(array.Length);
+            if (index != -1)
+            {
+                if (clearArray)
+                {
+                    Array.Clear(array, 0, array.Length);
+                }
+
+                var q = buckets[index];
+                var lockTaken = false;
+
+                try
+                {
+                    locks[index].Enter(ref lockTaken);
+
+                    if (q.Count > DefaultMaxNumberOfArraysPerBucket)
+                    {
+                        return;
+                    }
+
+                    q.Enqueue(array);
+                }
+                finally
+                {
+                    if (lockTaken) locks[index].Exit(false);
+                }
+            }
+        }
+
+        static int CalculateSize(int size)
+        {
+            size--;
+            size |= size >> 1;
+            size |= size >> 2;
+            size |= size >> 4;
+            size |= size >> 8;
+            size |= size >> 16;
+            size += 1;
+
+            if (size < 8)
+            {
+                size = 8;
+            }
+
+            return size;
+        }
+
+        static int GetQueueIndex(int size)
+        {
+            switch (size)
+            {
+                case 8: return 0;
+                case 16: return 1;
+                case 32: return 2;
+                case 64: return 3;
+                case 128: return 4;
+                case 256: return 5;
+                case 512: return 6;
+                case 1024: return 7;
+                case 2048: return 8;
+                case 4096: return 9;
+                case 8192: return 10;
+                case 16384: return 11;
+                case 32768: return 12;
+                case 65536: return 13;
+                case 131072: return 14;
+                case 262144: return 15;
+                case 524288: return 16;
+                case 1048576: return 17; // max array length
+                default:
+                    return -1;
+            }
+        }
+    }
+}
+#endif

Assets/Plugins/UniTask/Internal/ArrayPool.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f83ebad81fb89fb4882331616ca6d248
+timeCreated: 1532361008
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal/ArrayPoolUtil.cs

@@ -0,0 +1,107 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    internal static class ArrayPoolUtil
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static void EnsureCapacity<T>(ref T[] array, int index, ArrayPool<T> pool)
+        {
+            if (array.Length <= index)
+            {
+                EnsureCapacityCore(ref array, index, pool);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static void EnsureCapacityCore<T>(ref T[] array, int index, ArrayPool<T> pool)
+        {
+            if (array.Length <= index)
+            {
+                var newSize = array.Length * 2;
+                var newArray = pool.Rent((index < newSize) ? newSize : (index * 2));
+                Array.Copy(array, 0, newArray, 0, array.Length);
+
+                pool.Return(array, clearArray: !RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType<T>());
+
+                array = newArray;
+            }
+        }
+
+        public static RentArray<T> CopyToRentArray<T>(IEnumerable<T> source)
+        {
+            var defaultCount = 32;
+            if (source is ICollection<T> coll)
+            {
+                defaultCount = coll.Count;
+                var pool = ArrayPool<T>.Shared;
+                var buffer = pool.Rent(defaultCount);
+                coll.CopyTo(buffer, 0);
+                return new RentArray<T>(buffer, coll.Count, pool);
+            }
+            else if (source is IReadOnlyCollection<T> rcoll)
+            {
+                defaultCount = rcoll.Count;
+            }
+
+            if (defaultCount == 0)
+            {
+                return new RentArray<T>(Array.Empty<T>(), 0, null);
+            }
+
+            {
+                var pool = ArrayPool<T>.Shared;
+
+                var index = 0;
+                var buffer = pool.Rent(defaultCount);
+                foreach (var item in source)
+                {
+                    EnsureCapacity(ref buffer, index, pool);
+                    buffer[index++] = item;
+                }
+
+                return new RentArray<T>(buffer, index, pool);
+            }
+        }
+
+        public struct RentArray<T> : IDisposable
+        {
+            public readonly T[] Array;
+            public readonly int Length;
+            ArrayPool<T> pool;
+
+            public RentArray(T[] array, int length, ArrayPool<T> pool)
+            {
+                this.Array = array;
+                this.Length = length;
+                this.pool = pool;
+            }
+
+            public void Dispose()
+            {
+                DisposeManually(!RuntimeHelpersAbstraction.IsWellKnownNoReferenceContainsType<T>());
+            }
+
+            public void DisposeManually(bool clearArray)
+            {
+                if (pool != null)
+                {
+                    if (clearArray)
+                    {
+                        System.Array.Clear(Array, 0, Length);
+                    }
+
+                    pool.Return(Array, clearArray: false);
+                    pool = null;
+                }
+            }
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Internal/ArrayPoolUtil.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 424cc208fb61d4e448b08fcfa0eee25e
+timeCreated: 1532361007
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal/ArrayUtil.cs

@@ -0,0 +1,75 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    internal static class ArrayUtil
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void EnsureCapacity<T>(ref T[] array, int index)
+        {
+            if (array.Length <= index)
+            {
+                EnsureCore(ref array, index);
+            }
+        }
+
+        // rare case, no inlining.
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static void EnsureCore<T>(ref T[] array, int index)
+        {
+            var newSize = array.Length * 2;
+            var newArray = new T[(index < newSize) ? newSize : (index * 2)];
+            Array.Copy(array, 0, newArray, 0, array.Length);
+
+            array = newArray;
+        }
+
+        /// <summary>
+        /// Optimizing utility to avoid .ToArray() that creates buffer copy(cut to just size).
+        /// </summary>
+        public static (T[] array, int length) Materialize<T>(IEnumerable<T> source)
+        {
+            if (source is T[] array)
+            {
+                return (array, array.Length);
+            }
+
+            var defaultCount = 4;
+            if (source is ICollection<T> coll)
+            {
+                defaultCount = coll.Count;
+                var buffer = new T[defaultCount];
+                coll.CopyTo(buffer, 0);
+                return (buffer, defaultCount);
+            }
+            else if (source is IReadOnlyCollection<T> rcoll)
+            {
+                defaultCount = rcoll.Count;
+            }
+
+            if (defaultCount == 0)
+            {
+                return (Array.Empty<T>(), 0);
+            }
+
+            {
+                var index = 0;
+                var buffer = new T[defaultCount];
+                foreach (var item in source)
+                {
+                    EnsureCapacity(ref buffer, index);
+                    buffer[index++] = item;
+                }
+
+                return (buffer, index);
+            }
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Internal/ArrayUtil.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 23146a82ec99f2542a87971c8d3d7988
+timeCreated: 1532361007
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal/ContinuationQueue.cs

@@ -0,0 +1,124 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    internal sealed class ContinuationQueue
+    {
+        const int MaxArrayLength = 0X7FEFFFFF;
+        const int InitialSize = 16;
+
+        SpinLock gate = new SpinLock();
+        bool dequing = false;
+
+        int actionListCount = 0;
+        Action[] actionList = new Action[InitialSize];
+
+        int waitingListCount = 0;
+        Action[] waitingList = new Action[InitialSize];
+
+        public void Enqueue(Action continuation)
+        {
+            bool lockTaken = false;
+            try
+            {
+                gate.Enter(ref lockTaken);
+
+                if (dequing)
+                {
+                    // Ensure Capacity
+                    if (waitingList.Length == waitingListCount)
+                    {
+                        var newLength = waitingListCount * 2;
+                        if ((uint)newLength > MaxArrayLength) newLength = MaxArrayLength;
+
+                        var newArray = new Action[newLength];
+                        Array.Copy(waitingList, newArray, waitingListCount);
+                        waitingList = newArray;
+                    }
+                    waitingList[waitingListCount] = continuation;
+                    waitingListCount++;
+                }
+                else
+                {
+                    // Ensure Capacity
+                    if (actionList.Length == actionListCount)
+                    {
+                        var newLength = actionListCount * 2;
+                        if ((uint)newLength > MaxArrayLength) newLength = MaxArrayLength;
+
+                        var newArray = new Action[newLength];
+                        Array.Copy(actionList, newArray, actionListCount);
+                        actionList = newArray;
+                    }
+                    actionList[actionListCount] = continuation;
+                    actionListCount++;
+                }
+            }
+            finally
+            {
+                if (lockTaken) gate.Exit(false);
+            }
+        }
+
+        public void Clear()
+        {
+            actionListCount = 0;
+            actionList = new Action[InitialSize];
+
+            waitingListCount = 0;
+            waitingList = new Action[InitialSize];
+        }
+
+        public void Run()
+        {
+            {
+                bool lockTaken = false;
+                try
+                {
+                    gate.Enter(ref lockTaken);
+                    if (actionListCount == 0) return;
+                    dequing = true;
+                }
+                finally
+                {
+                    if (lockTaken) gate.Exit(false);
+                }
+            }
+
+            for (int i = 0; i < actionListCount; i++)
+            {
+                var action = actionList[i];
+                actionList[i] = null;
+
+                action();
+            }
+
+            {
+                bool lockTaken = false;
+                try
+                {
+                    gate.Enter(ref lockTaken);
+                    dequing = false;
+
+                    var swapTempActionList = actionList;
+
+                    actionListCount = waitingListCount;
+                    actionList = waitingList;
+
+                    waitingListCount = 0;
+                    waitingList = swapTempActionList;
+                }
+                finally
+                {
+                    if (lockTaken) gate.Exit(false);
+                }
+            }
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Internal/ContinuationQueue.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f66c32454e50f2546b17deadc80a4c77
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal/DiagnosticsExtensions.cs

@@ -0,0 +1,251 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Security;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    internal static class DiagnosticsExtensions
+    {
+        static bool displayFilenames = true;
+
+        static readonly Regex typeBeautifyRegex = new Regex("`.+$", RegexOptions.Compiled);
+
+        static readonly Dictionary<Type, string> builtInTypeNames = new Dictionary<Type, string>
+        {
+            { typeof(void), "void" },
+            { typeof(bool), "bool" },
+            { typeof(byte), "byte" },
+            { typeof(char), "char" },
+            { typeof(decimal), "decimal" },
+            { typeof(double), "double" },
+            { typeof(float), "float" },
+            { typeof(int), "int" },
+            { typeof(long), "long" },
+            { typeof(object), "object" },
+            { typeof(sbyte), "sbyte" },
+            { typeof(short), "short" },
+            { typeof(string), "string" },
+            { typeof(uint), "uint" },
+            { typeof(ulong), "ulong" },
+            { typeof(ushort), "ushort" },
+            { typeof(Task), "Task" },
+            { typeof(UniTask), "UniTask" },
+            { typeof(UniTaskVoid), "UniTaskVoid" }
+        };
+
+        public static string CleanupAsyncStackTrace(this StackTrace stackTrace)
+        {
+            if (stackTrace == null) return "";
+
+            var sb = new StringBuilder();
+            for (int i = 0; i < stackTrace.FrameCount; i++)
+            {
+                var sf = stackTrace.GetFrame(i);
+
+                var mb = sf.GetMethod();
+
+                if (IgnoreLine(mb)) continue;
+                if (IsAsync(mb))
+                {
+                    sb.Append("async ");
+                    TryResolveStateMachineMethod(ref mb, out var decType);
+                }
+
+                // return type
+                if (mb is MethodInfo mi)
+                {
+                    sb.Append(BeautifyType(mi.ReturnType, false));
+                    sb.Append(" ");
+                }
+
+                // method name
+                sb.Append(BeautifyType(mb.DeclaringType, false));
+                if (!mb.IsConstructor)
+                {
+                    sb.Append(".");
+                }
+                sb.Append(mb.Name);
+                if (mb.IsGenericMethod)
+                {
+                    sb.Append("<");
+                    foreach (var item in mb.GetGenericArguments())
+                    {
+                        sb.Append(BeautifyType(item, true));
+                    }
+                    sb.Append(">");
+                }
+
+                // parameter
+                sb.Append("(");
+                sb.Append(string.Join(", ", mb.GetParameters().Select(p => BeautifyType(p.ParameterType, true) + " " + p.Name)));
+                sb.Append(")");
+
+                // file name
+                if (displayFilenames && (sf.GetILOffset() != -1))
+                {
+                    String fileName = null;
+
+                    try
+                    {
+                        fileName = sf.GetFileName();
+                    }
+                    catch (NotSupportedException)
+                    {
+                        displayFilenames = false;
+                    }
+                    catch (SecurityException)
+                    {
+                        displayFilenames = false;
+                    }
+
+                    if (fileName != null)
+                    {
+                        sb.Append(' ');
+                        sb.AppendFormat(CultureInfo.InvariantCulture, "(at {0})", AppendHyperLink(fileName, sf.GetFileLineNumber().ToString()));
+                    }
+                }
+
+                sb.AppendLine();
+            }
+            return sb.ToString();
+        }
+
+
+        static bool IsAsync(MethodBase methodInfo)
+        {
+            var declareType = methodInfo.DeclaringType;
+            return typeof(IAsyncStateMachine).IsAssignableFrom(declareType);
+        }
+
+        // code from Ben.Demystifier/EnhancedStackTrace.Frame.cs
+        static bool TryResolveStateMachineMethod(ref MethodBase method, out Type declaringType)
+        {
+            declaringType = method.DeclaringType;
+
+            var parentType = declaringType.DeclaringType;
+            if (parentType == null)
+            {
+                return false;
+            }
+
+            var methods = parentType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly);
+            if (methods == null)
+            {
+                return false;
+            }
+
+            foreach (var candidateMethod in methods)
+            {
+                var attributes = candidateMethod.GetCustomAttributes<StateMachineAttribute>();
+                if (attributes == null)
+                {
+                    continue;
+                }
+
+                foreach (var asma in attributes)
+                {
+                    if (asma.StateMachineType == declaringType)
+                    {
+                        method = candidateMethod;
+                        declaringType = candidateMethod.DeclaringType;
+                        // Mark the iterator as changed; so it gets the + annotation of the original method
+                        // async statemachines resolve directly to their builder methods so aren't marked as changed
+                        return asma is IteratorStateMachineAttribute;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        static string BeautifyType(Type t, bool shortName)
+        {
+            if (builtInTypeNames.TryGetValue(t, out var builtin))
+            {
+                return builtin;
+            }
+            if (t.IsGenericParameter) return t.Name;
+            if (t.IsArray) return BeautifyType(t.GetElementType(), shortName) + "[]";
+            if (t.FullName?.StartsWith("System.ValueTuple") ?? false)
+            {
+                return "(" + string.Join(", ", t.GetGenericArguments().Select(x => BeautifyType(x, true))) + ")";
+            }
+            if (!t.IsGenericType) return shortName ? t.Name : t.FullName.Replace("Cysharp.Threading.Tasks.Triggers.", "").Replace("Cysharp.Threading.Tasks.Internal.", "").Replace("Cysharp.Threading.Tasks.", "") ?? t.Name;
+
+            var innerFormat = string.Join(", ", t.GetGenericArguments().Select(x => BeautifyType(x, true)));
+
+            var genericType = t.GetGenericTypeDefinition().FullName;
+            if (genericType == "System.Threading.Tasks.Task`1")
+            {
+                genericType = "Task";
+            }
+
+            return typeBeautifyRegex.Replace(genericType, "").Replace("Cysharp.Threading.Tasks.Triggers.", "").Replace("Cysharp.Threading.Tasks.Internal.", "").Replace("Cysharp.Threading.Tasks.", "") + "<" + innerFormat + ">";
+        }
+
+        static bool IgnoreLine(MethodBase methodInfo)
+        {
+            var declareType = methodInfo.DeclaringType.FullName;
+            if (declareType == "System.Threading.ExecutionContext")
+            {
+                return true;
+            }
+            else if (declareType.StartsWith("System.Runtime.CompilerServices"))
+            {
+                return true;
+            }
+            else if (declareType.StartsWith("Cysharp.Threading.Tasks.CompilerServices"))
+            {
+                return true;
+            }
+            else if (declareType == "System.Threading.Tasks.AwaitTaskContinuation")
+            {
+                return true;
+            }
+            else if (declareType.StartsWith("System.Threading.Tasks.Task"))
+            {
+                return true;
+            }
+            else if (declareType.StartsWith("Cysharp.Threading.Tasks.UniTaskCompletionSourceCore"))
+            {
+                return true;
+            }
+            else if (declareType.StartsWith("Cysharp.Threading.Tasks.AwaiterActions"))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        static string AppendHyperLink(string path, string line)
+        {
+            var fi = new FileInfo(path);
+            if (fi.Directory == null)
+            {
+                return fi.Name;
+            }
+            else
+            {
+                var fname = fi.FullName.Replace(Path.DirectorySeparatorChar, '/').Replace(Application.dataPath, "");
+                var withAssetsPath = "Assets/" + fname;
+                return "<a href=\"" + withAssetsPath + "\" line=\"" + line + "\">" + withAssetsPath + ":" + line + "</a>";
+            }
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Internal/DiagnosticsExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f80fb1c9ed4c99447be1b0a47a8d980b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal/Error.cs

@@ -0,0 +1,63 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    internal static class Error
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ThrowArgumentNullException<T>(T value, string paramName)
+          where T : class
+        {
+            if (value == null) ThrowArgumentNullExceptionCore(paramName);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static void ThrowArgumentNullExceptionCore(string paramName)
+        {
+            throw new ArgumentNullException(paramName);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static void ThrowArgumentException<T>(string message)
+        {
+            throw new ArgumentException(message);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static void ThrowNotYetCompleted()
+        {
+            throw new InvalidOperationException("Not yet completed.");
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static T ThrowNotYetCompleted<T>()
+        {
+            throw new InvalidOperationException("Not yet completed.");
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void ThrowWhenContinuationIsAlreadyRegistered<T>(T continuationField)
+          where T : class
+        {
+            if (continuationField != null) ThrowInvalidOperationExceptionCore("continuation is already registered.");
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        static void ThrowInvalidOperationExceptionCore(string message)
+        {
+            throw new InvalidOperationException(message);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public static void ThrowOperationCanceledException()
+        {
+            throw new OperationCanceledException();
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Internal/Error.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 5f39f495294d4604b8082202faf98554
+timeCreated: 1532361007
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal/Hack.cs

@@ -0,0 +1,23 @@
+#if NET_4_6 || NET_STANDARD_2_0 || CSHARP_7_OR_LATER
+
+using System;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    internal static class FuncExtensions
+    {
+        // avoid lambda capture
+
+        internal static Action<T> AsFuncOfT<T>(this Action action)
+        {
+            return new Action<T>(action.Invoke);
+        }
+
+        static void Invoke<T>(this Action action, T unused)
+        {
+            action();
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Internal/Hack.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4d5a9a3e1f0f069478969f752fde29a9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal/MinimumQueue.cs

@@ -0,0 +1,114 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+#endif
+
+using System;
+using System.Runtime.CompilerServices;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    // optimized version of Standard Queue<T>.
+    internal class MinimumQueue<T>
+    {
+        const int MinimumGrow = 4;
+        const int GrowFactor = 200;
+
+        T[] array;
+        int head;
+        int tail;
+        int size;
+
+        public MinimumQueue(int capacity)
+        {
+            if (capacity < 0) throw new ArgumentOutOfRangeException("capacity");
+            array = new T[capacity];
+            head = tail = size = 0;
+        }
+
+        public int Count
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get { return size; }
+        }
+
+        public T Peek()
+        {
+            if (size == 0) ThrowForEmptyQueue();
+            return array[head];
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Enqueue(T item)
+        {
+            if (size == array.Length)
+            {
+                Grow();
+            }
+
+            array[tail] = item;
+            MoveNext(ref tail);
+            size++;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public T Dequeue()
+        {
+            if (size == 0) ThrowForEmptyQueue();
+
+            int head = this.head;
+            T[] array = this.array;
+            T removed = array[head];
+            array[head] = default(T);
+            MoveNext(ref this.head);
+            size--;
+            return removed;
+        }
+
+        void Grow()
+        {
+            int newcapacity = (int)((long)array.Length * (long)GrowFactor / 100);
+            if (newcapacity < array.Length + MinimumGrow)
+            {
+                newcapacity = array.Length + MinimumGrow;
+            }
+            SetCapacity(newcapacity);
+        }
+
+        void SetCapacity(int capacity)
+        {
+            T[] newarray = new T[capacity];
+            if (size > 0)
+            {
+                if (head < tail)
+                {
+                    Array.Copy(array, head, newarray, 0, size);
+                }
+                else
+                {
+                    Array.Copy(array, head, newarray, 0, array.Length - head);
+                    Array.Copy(array, 0, newarray, array.Length - head, tail);
+                }
+            }
+
+            array = newarray;
+            head = 0;
+            tail = (size == capacity) ? 0 : size;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        void MoveNext(ref int index)
+        {
+            int tmp = index + 1;
+            if (tmp == array.Length)
+            {
+                tmp = 0;
+            }
+            index = tmp;
+        }
+
+        void ThrowForEmptyQueue()
+        {
+            throw new InvalidOperationException("EmptyQueue");
+        }
+    }
+}

Assets/Plugins/UniTask/Internal/MinimumQueue.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7d63add489ccc99498114d79702b904d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal/PlayerLoopRunner.cs

@@ -0,0 +1,164 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+
+using System;
+using UnityEngine;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    internal sealed class PlayerLoopRunner
+    {
+        const int InitialSize = 16;
+
+        readonly object runningAndQueueLock = new object();
+        readonly object arrayLock = new object();
+        readonly Action<Exception> unhandledExceptionCallback;
+
+        int tail = 0;
+        bool running = false;
+        IPlayerLoopItem[] loopItems = new IPlayerLoopItem[InitialSize];
+        MinimumQueue<IPlayerLoopItem> waitQueue = new MinimumQueue<IPlayerLoopItem>(InitialSize);
+
+        public PlayerLoopRunner()
+        {
+            this.unhandledExceptionCallback = ex => Debug.LogException(ex);
+        }
+
+        public void AddAction(IPlayerLoopItem item)
+        {
+            lock (runningAndQueueLock)
+            {
+                if (running)
+                {
+                    waitQueue.Enqueue(item);
+                    return;
+                }
+            }
+
+            lock (arrayLock)
+            {
+                // Ensure Capacity
+                if (loopItems.Length == tail)
+                {
+                    Array.Resize(ref loopItems, checked(tail * 2));
+                }
+                loopItems[tail++] = item;
+            }
+        }
+
+        public void Clear()
+        {
+            lock (arrayLock)
+            {
+                for (var index = 0; index < loopItems.Length; index++)
+                {
+                    loopItems[index] = null;
+                }
+            }
+        }
+
+        public void Run()
+        {
+            lock (runningAndQueueLock)
+            {
+                running = true;
+            }
+
+            lock (arrayLock)
+            {
+                var j = tail - 1;
+
+                // eliminate array-bound check for i
+                for (int i = 0; i < loopItems.Length; i++)
+                {
+                    var action = loopItems[i];
+                    if (action != null)
+                    {
+                        try
+                        {
+                            if (!action.MoveNext())
+                            {
+                                loopItems[i] = null;
+                            }
+                            else
+                            {
+                                continue; // next i 
+                            }
+                        }
+                        catch (Exception ex)
+                        {
+                            loopItems[i] = null;
+                            try
+                            {
+                                unhandledExceptionCallback(ex);
+                            }
+                            catch { }
+                        }
+                    }
+
+                    // find null, loop from tail
+                    while (i < j)
+                    {
+                        var fromTail = loopItems[j];
+                        if (fromTail != null)
+                        {
+                            try
+                            {
+                                if (!fromTail.MoveNext())
+                                {
+                                    loopItems[j] = null;
+                                    j--;
+                                    continue; // next j
+                                }
+                                else
+                                {
+                                    // swap
+                                    loopItems[i] = fromTail;
+                                    loopItems[j] = null;
+                                    j--;
+                                    goto NEXT_LOOP; // next i
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                loopItems[j] = null;
+                                j--;
+                                try
+                                {
+                                    unhandledExceptionCallback(ex);
+                                }
+                                catch { }
+                                continue; // next j
+                            }
+                        }
+                        else
+                        {
+                            j--;
+                        }
+                    }
+
+                    tail = i; // loop end
+                    break; // LOOP END
+
+                    NEXT_LOOP:
+                    continue;
+                }
+
+
+                lock (runningAndQueueLock)
+                {
+                    running = false;
+                    while (waitQueue.Count != 0)
+                    {
+                        if (loopItems.Length == tail)
+                        {
+                            Array.Resize(ref loopItems, checked(tail * 2));
+                        }
+                        loopItems[tail++] = waitQueue.Dequeue();
+                    }
+                }
+            }
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Internal/PlayerLoopRunner.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 340c6d420bb4f484aa8683415ea92571
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal/PromisePool.cs

@@ -0,0 +1,53 @@
+using System.Collections.Concurrent;
+using System.Runtime.CompilerServices;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    internal interface IPromisePoolItem
+    {
+        void Reset();
+    }
+
+    internal class PromisePool<T>
+        where T : class, IPromisePoolItem
+    {
+        int count = 0;
+        readonly ConcurrentQueue<T> queue = new ConcurrentQueue<T>();
+        readonly int maxSize;
+
+        public PromisePool(int maxSize = 256)
+        {
+            this.maxSize = maxSize;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public T TryRent()
+        {
+            if (queue.TryDequeue(out var value))
+            {
+                Interlocked.Decrement(ref count);
+                return value;
+            }
+
+            return null;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool TryReturn(T value)
+        {
+            value.Reset(); // reset when return.
+
+            if (count < maxSize)
+            {
+                queue.Enqueue(value);
+                Interlocked.Increment(ref count);
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+    }
+}

Assets/Plugins/UniTask/Internal/PromisePool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fcb1f7467a3e2b64c8a016c8aee2f9b4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal/RuntimeHelpersAbstraction.cs

@@ -0,0 +1,60 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using UnityEngine;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    internal static class RuntimeHelpersAbstraction
+    {
+        // If we can use RuntimeHelpers.IsReferenceOrContainsReferences(.NET Core 2.0), use it.
+        public static bool IsWellKnownNoReferenceContainsType<T>()
+        {
+            return WellKnownNoReferenceContainsType<T>.IsWellKnownType;
+        }
+
+        static bool WellKnownNoReferenceContainsTypeInitialize(Type t)
+        {
+            // The primitive types are Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double, and Single.
+            if (t.IsPrimitive) return true;
+
+            if (t.IsEnum) return true;
+            if (t == typeof(DateTime)) return true;
+            if (t == typeof(DateTimeOffset)) return true;
+            if (t == typeof(Guid)) return true;
+            if (t == typeof(decimal)) return true;
+
+            // unwrap nullable
+            if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>))
+            {
+                return WellKnownNoReferenceContainsTypeInitialize(t.GetGenericArguments()[0]);
+            }
+
+            // or add other wellknown types(Vector, etc...) here
+            if (t == typeof(Vector2)) return true;
+            if (t == typeof(Vector3)) return true;
+            if (t == typeof(Vector4)) return true;
+            if (t == typeof(Color)) return true;
+            if (t == typeof(Rect)) return true;
+            if (t == typeof(Bounds)) return true;
+            if (t == typeof(Quaternion)) return true;
+            if (t == typeof(Vector2Int)) return true;
+            if (t == typeof(Vector3Int)) return true;
+
+            return false;
+        }
+
+        static class WellKnownNoReferenceContainsType<T>
+        {
+            public static readonly bool IsWellKnownType;
+
+            static WellKnownNoReferenceContainsType()
+            {
+                IsWellKnownType = WellKnownNoReferenceContainsTypeInitialize(typeof(T));
+            }
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Internal/RuntimeHelpersAbstraction.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 94975e4d4e0c0ea4ba787d3872ce9bb4
+timeCreated: 1532361007
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal/StatePool.cs

@@ -0,0 +1,153 @@
+using System;
+using System.Collections.Concurrent;
+using System.Runtime.CompilerServices;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    internal static class StateTuple
+    {
+        public static StateTuple<T1> Create<T1>(T1 item1)
+        {
+            return StatePool<T1>.Create(item1);
+        }
+
+        public static StateTuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2)
+        {
+            return StatePool<T1, T2>.Create(item1, item2);
+        }
+
+        public static StateTuple<T1, T2, T3> Create<T1, T2, T3>(T1 item1, T2 item2, T3 item3)
+        {
+            return StatePool<T1, T2, T3>.Create(item1, item2, item3);
+        }
+    }
+
+    internal class StateTuple<T1> : IDisposable
+    {
+        public T1 Item1;
+
+        public void Deconstruct(out T1 item1)
+        {
+            item1 = this.Item1;
+        }
+
+        public void Dispose()
+        {
+            StatePool<T1>.Return(this);
+        }
+    }
+
+    internal static class StatePool<T1>
+    {
+        static readonly ConcurrentQueue<StateTuple<T1>> queue = new ConcurrentQueue<StateTuple<T1>>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static StateTuple<T1> Create(T1 item1)
+        {
+            if (queue.TryDequeue(out var value))
+            {
+                value.Item1 = item1;
+                return value;
+            }
+
+            return new StateTuple<T1> { Item1 = item1 };
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Return(StateTuple<T1> tuple)
+        {
+            tuple.Item1 = default;
+            queue.Enqueue(tuple);
+        }
+    }
+
+    internal class StateTuple<T1, T2> : IDisposable
+    {
+        public T1 Item1;
+        public T2 Item2;
+
+        public void Deconstruct(out T1 item1, out T2 item2)
+        {
+            item1 = this.Item1;
+            item2 = this.Item2;
+        }
+
+        public void Dispose()
+        {
+            StatePool<T1, T2>.Return(this);
+        }
+    }
+
+    internal static class StatePool<T1, T2>
+    {
+        static readonly ConcurrentQueue<StateTuple<T1, T2>> queue = new ConcurrentQueue<StateTuple<T1, T2>>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static StateTuple<T1, T2> Create(T1 item1, T2 item2)
+        {
+            if (queue.TryDequeue(out var value))
+            {
+                value.Item1 = item1;
+                value.Item2 = item2;
+                return value;
+            }
+
+            return new StateTuple<T1, T2> { Item1 = item1, Item2 = item2 };
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Return(StateTuple<T1, T2> tuple)
+        {
+            tuple.Item1 = default;
+            tuple.Item2 = default;
+            queue.Enqueue(tuple);
+        }
+    }
+
+    internal class StateTuple<T1, T2, T3> : IDisposable
+    {
+        public T1 Item1;
+        public T2 Item2;
+        public T3 Item3;
+
+        public void Deconstruct(out T1 item1, out T2 item2, out T3 item3)
+        {
+            item1 = this.Item1;
+            item2 = this.Item2;
+            item3 = this.Item3;
+        }
+
+        public void Dispose()
+        {
+            StatePool<T1, T2, T3>.Return(this);
+        }
+    }
+
+    internal static class StatePool<T1, T2, T3>
+    {
+        static readonly ConcurrentQueue<StateTuple<T1, T2, T3>> queue = new ConcurrentQueue<StateTuple<T1, T2, T3>>();
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static StateTuple<T1, T2, T3> Create(T1 item1, T2 item2, T3 item3)
+        {
+            if (queue.TryDequeue(out var value))
+            {
+                value.Item1 = item1;
+                value.Item2 = item2;
+                value.Item3 = item3;
+                return value;
+            }
+
+            return new StateTuple<T1, T2, T3> { Item1 = item1, Item2 = item2, Item3 = item3 };
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Return(StateTuple<T1, T2, T3> tuple)
+        {
+            tuple.Item1 = default;
+            tuple.Item2 = default;
+            tuple.Item3 = default;
+            queue.Enqueue(tuple);
+        }
+    }
+}

Assets/Plugins/UniTask/Internal/StatePool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 60cdf0bcaea36b444a7ae7263ae7598f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal/TaskTracker.cs

@@ -0,0 +1,132 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using Cysharp.Threading.Tasks.Internal;
+
+namespace Cysharp.Threading.Tasks
+{
+    // public for add user custom.
+
+    public static class TaskTracker
+    {
+#if UNITY_EDITOR
+
+        static int trackingId = 0;
+
+        public const string EnableAutoReloadKey = "UniTaskTrackerWindow_EnableAutoReloadKey";
+        public const string EnableTrackingKey = "UniTaskTrackerWindow_EnableTrackingKey";
+        public const string EnableStackTraceKey = "UniTaskTrackerWindow_EnableStackTraceKey";
+
+        public static class EditorEnableState
+        {
+            static bool enableAutoReload;
+            public static bool EnableAutoReload
+            {
+                get { return enableAutoReload; }
+                set
+                {
+                    enableAutoReload = value;
+                    UnityEditor.EditorPrefs.SetBool(EnableAutoReloadKey, value);
+                }
+            }
+
+            static bool enableTracking;
+            public static bool EnableTracking
+            {
+                get { return enableTracking; }
+                set
+                {
+                    enableTracking = value;
+                    UnityEditor.EditorPrefs.SetBool(EnableTrackingKey, value);
+                }
+            }
+
+            static bool enableStackTrace;
+            public static bool EnableStackTrace
+            {
+                get { return enableStackTrace; }
+                set
+                {
+                    enableStackTrace = value;
+                    UnityEditor.EditorPrefs.SetBool(EnableStackTraceKey, value);
+                }
+            }
+        }
+
+#endif
+
+
+        static List<KeyValuePair<IUniTaskSource, (int trackingId, DateTime addTime, string stackTrace)>> listPool = new List<KeyValuePair<IUniTaskSource, (int trackingId, DateTime addTime, string stackTrace)>>();
+
+        static readonly WeakDictionary<IUniTaskSource, (int trackingId, DateTime addTime, string stackTrace)> tracking = new WeakDictionary<IUniTaskSource, (int trackingId, DateTime addTime, string stackTrace)>();
+
+        [Conditional("UNITY_EDITOR")]
+        public static void TrackActiveTask(IUniTaskSource task, int skipFrame)
+        {
+#if UNITY_EDITOR
+            dirty = true;
+            if (!EditorEnableState.EnableTracking) return;
+            var stackTrace = EditorEnableState.EnableStackTrace ? new StackTrace(skipFrame, true).CleanupAsyncStackTrace() : "";
+            tracking.TryAdd(task, (Interlocked.Increment(ref trackingId), DateTime.UtcNow, stackTrace));
+#endif
+        }
+
+        [Conditional("UNITY_EDITOR")]
+        public static void RemoveTracking(IUniTaskSource task)
+        {
+#if UNITY_EDITOR
+            dirty = true;
+            if (!EditorEnableState.EnableTracking) return;
+            var success = tracking.TryRemove(task);
+#endif
+        }
+
+        static bool dirty;
+
+        public static bool CheckAndResetDirty()
+        {
+            var current = dirty;
+            dirty = false;
+            return current;
+        }
+
+        /// <summary>(trackingId, awaiterType, awaiterStatus, createdTime, stackTrace)</summary>
+        public static void ForEachActiveTask(Action<int, string, UniTaskStatus, DateTime, string> action)
+        {
+            lock (listPool)
+            {
+                var count = tracking.ToList(ref listPool, clear: false);
+                try
+                {
+                    for (int i = 0; i < count; i++)
+                    {
+                        string typeName = null;
+                        var keyType = listPool[i].Key.GetType();
+                        if (keyType.IsNested)
+                        {
+                            typeName = keyType.DeclaringType.Name + "." + keyType.Name;
+                        }
+                        else
+                        {
+                            typeName = keyType.Name;
+                        }
+
+                        action(listPool[i].Value.trackingId, typeName, listPool[i].Key.UnsafeGetStatus(), listPool[i].Value.addTime, listPool[i].Value.stackTrace);
+                        listPool[i] = new KeyValuePair<IUniTaskSource, (int trackingId, DateTime addTime, string stackTrace)>(null, (0, default(DateTime), null)); // clear
+                    }
+                }
+                catch
+                {
+                    listPool.Clear();
+                    throw;
+                }
+            }
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Internal/TaskTracker.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a203c73eb4ccdbb44bddfd82d38fdda9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal/UnityEqualityComparer.cs

@@ -0,0 +1,271 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+#endif
+
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    internal static class UnityEqualityComparer
+    {
+        public static readonly IEqualityComparer<Vector2> Vector2 = new Vector2EqualityComparer();
+        public static readonly IEqualityComparer<Vector3> Vector3 = new Vector3EqualityComparer();
+        public static readonly IEqualityComparer<Vector4> Vector4 = new Vector4EqualityComparer();
+        public static readonly IEqualityComparer<Color> Color = new ColorEqualityComparer();
+        public static readonly IEqualityComparer<Color32> Color32 = new Color32EqualityComparer();
+        public static readonly IEqualityComparer<Rect> Rect = new RectEqualityComparer();
+        public static readonly IEqualityComparer<Bounds> Bounds = new BoundsEqualityComparer();
+        public static readonly IEqualityComparer<Quaternion> Quaternion = new QuaternionEqualityComparer();
+
+        static readonly RuntimeTypeHandle vector2Type = typeof(Vector2).TypeHandle;
+        static readonly RuntimeTypeHandle vector3Type = typeof(Vector3).TypeHandle;
+        static readonly RuntimeTypeHandle vector4Type = typeof(Vector4).TypeHandle;
+        static readonly RuntimeTypeHandle colorType = typeof(Color).TypeHandle;
+        static readonly RuntimeTypeHandle color32Type = typeof(Color32).TypeHandle;
+        static readonly RuntimeTypeHandle rectType = typeof(Rect).TypeHandle;
+        static readonly RuntimeTypeHandle boundsType = typeof(Bounds).TypeHandle;
+        static readonly RuntimeTypeHandle quaternionType = typeof(Quaternion).TypeHandle;
+
+#if UNITY_2017_2_OR_NEWER
+
+        public static readonly IEqualityComparer<Vector2Int> Vector2Int = new Vector2IntEqualityComparer();
+        public static readonly IEqualityComparer<Vector3Int> Vector3Int = new Vector3IntEqualityComparer();
+        public static readonly IEqualityComparer<RangeInt> RangeInt = new RangeIntEqualityComparer();
+        public static readonly IEqualityComparer<RectInt> RectInt = new RectIntEqualityComparer();
+        public static readonly IEqualityComparer<BoundsInt> BoundsInt = new BoundsIntEqualityComparer();
+
+        static readonly RuntimeTypeHandle vector2IntType = typeof(Vector2Int).TypeHandle;
+        static readonly RuntimeTypeHandle vector3IntType = typeof(Vector3Int).TypeHandle;
+        static readonly RuntimeTypeHandle rangeIntType = typeof(RangeInt).TypeHandle;
+        static readonly RuntimeTypeHandle rectIntType = typeof(RectInt).TypeHandle;
+        static readonly RuntimeTypeHandle boundsIntType = typeof(BoundsInt).TypeHandle;
+
+#endif
+
+        static class Cache<T>
+        {
+            public static readonly IEqualityComparer<T> Comparer;
+
+            static Cache()
+            {
+                var comparer = GetDefaultHelper(typeof(T));
+                if (comparer == null)
+                {
+                    Comparer = EqualityComparer<T>.Default;
+                }
+                else
+                {
+                    Comparer = (IEqualityComparer<T>)comparer;
+                }
+            }
+        }
+
+        public static IEqualityComparer<T> GetDefault<T>()
+        {
+            return Cache<T>.Comparer;
+        }
+
+        static object GetDefaultHelper(Type type)
+        {
+            var t = type.TypeHandle;
+
+            if (t.Equals(vector2Type)) return (object)UnityEqualityComparer.Vector2;
+            if (t.Equals(vector3Type)) return (object)UnityEqualityComparer.Vector3;
+            if (t.Equals(vector4Type)) return (object)UnityEqualityComparer.Vector4;
+            if (t.Equals(colorType)) return (object)UnityEqualityComparer.Color;
+            if (t.Equals(color32Type)) return (object)UnityEqualityComparer.Color32;
+            if (t.Equals(rectType)) return (object)UnityEqualityComparer.Rect;
+            if (t.Equals(boundsType)) return (object)UnityEqualityComparer.Bounds;
+            if (t.Equals(quaternionType)) return (object)UnityEqualityComparer.Quaternion;
+
+#if UNITY_2017_2_OR_NEWER
+
+            if (t.Equals(vector2IntType)) return (object)UnityEqualityComparer.Vector2Int;
+            if (t.Equals(vector3IntType)) return (object)UnityEqualityComparer.Vector3Int;
+            if (t.Equals(rangeIntType)) return (object)UnityEqualityComparer.RangeInt;
+            if (t.Equals(rectIntType)) return (object)UnityEqualityComparer.RectInt;
+            if (t.Equals(boundsIntType)) return (object)UnityEqualityComparer.BoundsInt;
+#endif
+
+            return null;
+        }
+
+        sealed class Vector2EqualityComparer : IEqualityComparer<Vector2>
+        {
+            public bool Equals(Vector2 self, Vector2 vector)
+            {
+                return self.x.Equals(vector.x) && self.y.Equals(vector.y);
+            }
+
+            public int GetHashCode(Vector2 obj)
+            {
+                return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2;
+            }
+        }
+
+        sealed class Vector3EqualityComparer : IEqualityComparer<Vector3>
+        {
+            public bool Equals(Vector3 self, Vector3 vector)
+            {
+                return self.x.Equals(vector.x) && self.y.Equals(vector.y) && self.z.Equals(vector.z);
+            }
+
+            public int GetHashCode(Vector3 obj)
+            {
+                return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2 ^ obj.z.GetHashCode() >> 2;
+            }
+        }
+
+        sealed class Vector4EqualityComparer : IEqualityComparer<Vector4>
+        {
+            public bool Equals(Vector4 self, Vector4 vector)
+            {
+                return self.x.Equals(vector.x) && self.y.Equals(vector.y) && self.z.Equals(vector.z) && self.w.Equals(vector.w);
+            }
+
+            public int GetHashCode(Vector4 obj)
+            {
+                return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2 ^ obj.z.GetHashCode() >> 2 ^ obj.w.GetHashCode() >> 1;
+            }
+        }
+
+        sealed class ColorEqualityComparer : IEqualityComparer<Color>
+        {
+            public bool Equals(Color self, Color other)
+            {
+                return self.r.Equals(other.r) && self.g.Equals(other.g) && self.b.Equals(other.b) && self.a.Equals(other.a);
+            }
+
+            public int GetHashCode(Color obj)
+            {
+                return obj.r.GetHashCode() ^ obj.g.GetHashCode() << 2 ^ obj.b.GetHashCode() >> 2 ^ obj.a.GetHashCode() >> 1;
+            }
+        }
+
+        sealed class RectEqualityComparer : IEqualityComparer<Rect>
+        {
+            public bool Equals(Rect self, Rect other)
+            {
+                return self.x.Equals(other.x) && self.width.Equals(other.width) && self.y.Equals(other.y) && self.height.Equals(other.height);
+            }
+
+            public int GetHashCode(Rect obj)
+            {
+                return obj.x.GetHashCode() ^ obj.width.GetHashCode() << 2 ^ obj.y.GetHashCode() >> 2 ^ obj.height.GetHashCode() >> 1;
+            }
+        }
+
+        sealed class BoundsEqualityComparer : IEqualityComparer<Bounds>
+        {
+            public bool Equals(Bounds self, Bounds vector)
+            {
+                return self.center.Equals(vector.center) && self.extents.Equals(vector.extents);
+            }
+
+            public int GetHashCode(Bounds obj)
+            {
+                return obj.center.GetHashCode() ^ obj.extents.GetHashCode() << 2;
+            }
+        }
+
+        sealed class QuaternionEqualityComparer : IEqualityComparer<Quaternion>
+        {
+            public bool Equals(Quaternion self, Quaternion vector)
+            {
+                return self.x.Equals(vector.x) && self.y.Equals(vector.y) && self.z.Equals(vector.z) && self.w.Equals(vector.w);
+            }
+
+            public int GetHashCode(Quaternion obj)
+            {
+                return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2 ^ obj.z.GetHashCode() >> 2 ^ obj.w.GetHashCode() >> 1;
+            }
+        }
+
+        sealed class Color32EqualityComparer : IEqualityComparer<Color32>
+        {
+            public bool Equals(Color32 self, Color32 vector)
+            {
+                return self.a.Equals(vector.a) && self.r.Equals(vector.r) && self.g.Equals(vector.g) && self.b.Equals(vector.b);
+            }
+
+            public int GetHashCode(Color32 obj)
+            {
+                return obj.a.GetHashCode() ^ obj.r.GetHashCode() << 2 ^ obj.g.GetHashCode() >> 2 ^ obj.b.GetHashCode() >> 1;
+            }
+        }
+
+#if UNITY_2017_2_OR_NEWER
+
+        sealed class Vector2IntEqualityComparer : IEqualityComparer<Vector2Int>
+        {
+            public bool Equals(Vector2Int self, Vector2Int vector)
+            {
+                return self.x.Equals(vector.x) && self.y.Equals(vector.y);
+            }
+
+            public int GetHashCode(Vector2Int obj)
+            {
+                return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2;
+            }
+        }
+
+        sealed class Vector3IntEqualityComparer : IEqualityComparer<Vector3Int>
+        {
+            public static readonly Vector3IntEqualityComparer Default = new Vector3IntEqualityComparer();
+
+            public bool Equals(Vector3Int self, Vector3Int vector)
+            {
+                return self.x.Equals(vector.x) && self.y.Equals(vector.y) && self.z.Equals(vector.z);
+            }
+
+            public int GetHashCode(Vector3Int obj)
+            {
+                return obj.x.GetHashCode() ^ obj.y.GetHashCode() << 2 ^ obj.z.GetHashCode() >> 2;
+            }
+        }
+
+        sealed class RangeIntEqualityComparer : IEqualityComparer<RangeInt>
+        {
+            public bool Equals(RangeInt self, RangeInt vector)
+            {
+                return self.start.Equals(vector.start) && self.length.Equals(vector.length);
+            }
+
+            public int GetHashCode(RangeInt obj)
+            {
+                return obj.start.GetHashCode() ^ obj.length.GetHashCode() << 2;
+            }
+        }
+
+        sealed class RectIntEqualityComparer : IEqualityComparer<RectInt>
+        {
+            public bool Equals(RectInt self, RectInt other)
+            {
+                return self.x.Equals(other.x) && self.width.Equals(other.width) && self.y.Equals(other.y) && self.height.Equals(other.height);
+            }
+
+            public int GetHashCode(RectInt obj)
+            {
+                return obj.x.GetHashCode() ^ obj.width.GetHashCode() << 2 ^ obj.y.GetHashCode() >> 2 ^ obj.height.GetHashCode() >> 1;
+            }
+        }
+
+        sealed class BoundsIntEqualityComparer : IEqualityComparer<BoundsInt>
+        {
+            public bool Equals(BoundsInt self, BoundsInt vector)
+            {
+                return Vector3IntEqualityComparer.Default.Equals(self.position, vector.position)
+                    && Vector3IntEqualityComparer.Default.Equals(self.size, vector.size);
+            }
+
+            public int GetHashCode(BoundsInt obj)
+            {
+                return Vector3IntEqualityComparer.Default.GetHashCode(obj.position) ^ Vector3IntEqualityComparer.Default.GetHashCode(obj.size) << 2;
+            }
+        }
+
+#endif
+    }
+}

Assets/Plugins/UniTask/Internal/UnityEqualityComparer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ebaaf14253c9cfb47b23283218ff9b67
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Internal/WeakDictionary.cs

@@ -0,0 +1,336 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Internal
+{
+    // Add, Remove, Enumerate with sweep. All operations are thread safe(in spinlock).
+    internal class WeakDictionary<TKey, TValue>
+        where TKey : class
+    {
+        Entry[] buckets;
+        int size;
+        SpinLock gate; // mutable struct(not readonly)
+
+        readonly float loadFactor;
+        readonly IEqualityComparer<TKey> keyEqualityComparer;
+
+        public WeakDictionary(int capacity = 4, float loadFactor = 0.75f, IEqualityComparer<TKey> keyComparer = null)
+        {
+            var tableSize = CalculateCapacity(capacity, loadFactor);
+            this.buckets = new Entry[tableSize];
+            this.loadFactor = loadFactor;
+            this.gate = new SpinLock(false);
+            this.keyEqualityComparer = keyComparer ?? EqualityComparer<TKey>.Default;
+        }
+
+        public bool TryAdd(TKey key, TValue value)
+        {
+            bool lockTaken = false;
+            try
+            {
+                gate.Enter(ref lockTaken);
+                return TryAddInternal(key, value);
+            }
+            finally
+            {
+                if (lockTaken) gate.Exit(false);
+            }
+        }
+
+        public bool TryGetValue(TKey key, out TValue value)
+        {
+            bool lockTaken = false;
+            try
+            {
+                gate.Enter(ref lockTaken);
+                if (TryGetEntry(key, out _, out var entry))
+                {
+                    value = entry.Value;
+                    return true;
+                }
+
+                value = default(TValue);
+                return false;
+            }
+            finally
+            {
+                if (lockTaken) gate.Exit(false);
+            }
+        }
+
+        public bool TryRemove(TKey key)
+        {
+            bool lockTaken = false;
+            try
+            {
+                gate.Enter(ref lockTaken);
+                if (TryGetEntry(key, out var hashIndex, out var entry))
+                {
+                    Remove(hashIndex, entry);
+                    return true;
+                }
+
+                return false;
+            }
+            finally
+            {
+                if (lockTaken) gate.Exit(false);
+            }
+        }
+
+        bool TryAddInternal(TKey key, TValue value)
+        {
+            var nextCapacity = CalculateCapacity(size + 1, loadFactor);
+
+            TRY_ADD_AGAIN:
+            if (buckets.Length < nextCapacity)
+            {
+                // rehash
+                var nextBucket = new Entry[nextCapacity];
+                for (int i = 0; i < buckets.Length; i++)
+                {
+                    var e = buckets[i];
+                    while (e != null)
+                    {
+                        AddToBuckets(nextBucket, key, e.Value, e.Hash);
+                        e = e.Next;
+                    }
+                }
+
+                buckets = nextBucket;
+                goto TRY_ADD_AGAIN;
+            }
+            else
+            {
+                // add entry
+                var successAdd = AddToBuckets(buckets, key, value, keyEqualityComparer.GetHashCode(key));
+                if (successAdd) size++;
+                return successAdd;
+            }
+        }
+
+        bool AddToBuckets(Entry[] targetBuckets, TKey newKey, TValue value, int keyHash)
+        {
+            var h = keyHash;
+            var hashIndex = h & (targetBuckets.Length - 1);
+
+            TRY_ADD_AGAIN:
+            if (targetBuckets[hashIndex] == null)
+            {
+                targetBuckets[hashIndex] = new Entry
+                {
+                    Key = new WeakReference<TKey>(newKey, false),
+                    Value = value,
+                    Hash = h
+                };
+
+                return true;
+            }
+            else
+            {
+                // add to last.
+                var entry = targetBuckets[hashIndex];
+                while (entry != null)
+                {
+                    if (entry.Key.TryGetTarget(out var target))
+                    {
+                        if (keyEqualityComparer.Equals(newKey, target))
+                        {
+                            return false; // duplicate
+                        }
+                    }
+                    else
+                    {
+                        Remove(hashIndex, entry);
+                        if (targetBuckets[hashIndex] == null) goto TRY_ADD_AGAIN; // add new entry
+                    }
+
+                    if (entry.Next != null)
+                    {
+                        entry = entry.Next;
+                    }
+                    else
+                    {
+                        // found last
+                        entry.Next = new Entry
+                        {
+                            Key = new WeakReference<TKey>(newKey, false),
+                            Value = value,
+                            Hash = h
+                        };
+                        entry.Next.Prev = entry;
+                    }
+                }
+
+                return false;
+            }
+        }
+
+        bool TryGetEntry(TKey key, out int hashIndex, out Entry entry)
+        {
+            var table = buckets;
+            var hash = keyEqualityComparer.GetHashCode(key);
+            hashIndex = hash & table.Length - 1;
+            entry = table[hashIndex];
+
+            while (entry != null)
+            {
+                if (entry.Key.TryGetTarget(out var target))
+                {
+                    if (keyEqualityComparer.Equals(key, target))
+                    {
+                        return true;
+                    }
+                }
+                else
+                {
+                    // sweap
+                    Remove(hashIndex, entry);
+                }
+
+                entry = entry.Next;
+            }
+
+            return false;
+        }
+
+        void Remove(int hashIndex, Entry entry)
+        {
+            if (entry.Prev == null && entry.Next == null)
+            {
+                buckets[hashIndex] = null;
+            }
+            else
+            {
+                if (entry.Prev == null)
+                {
+                    buckets[hashIndex] = entry.Next;
+                }
+                if (entry.Prev != null)
+                {
+                    entry.Prev.Next = entry.Next;
+                }
+                if (entry.Next != null)
+                {
+                    entry.Next.Prev = entry.Prev;
+                }
+            }
+            size--;
+        }
+
+        public List<KeyValuePair<TKey, TValue>> ToList()
+        {
+            var list = new List<KeyValuePair<TKey, TValue>>(size);
+            ToList(ref list, false);
+            return list;
+        }
+
+        // avoid allocate everytime.
+        public int ToList(ref List<KeyValuePair<TKey, TValue>> list, bool clear = true)
+        {
+            if (clear)
+            {
+                list.Clear();
+            }
+
+            var listIndex = 0;
+
+            bool lockTaken = false;
+            try
+            {
+                for (int i = 0; i < buckets.Length; i++)
+                {
+                    var entry = buckets[i];
+                    while (entry != null)
+                    {
+                        if (entry.Key.TryGetTarget(out var target))
+                        {
+                            var item = new KeyValuePair<TKey, TValue>(target, entry.Value);
+                            if (listIndex < list.Count)
+                            {
+                                list[listIndex++] = item;
+                            }
+                            else
+                            {
+                                list.Add(item);
+                                listIndex++;
+                            }
+                        }
+                        else
+                        {
+                            // sweap
+                            Remove(i, entry);
+                        }
+
+                        entry = entry.Next;
+                    }
+                }
+            }
+            finally
+            {
+                if (lockTaken) gate.Exit(false);
+            }
+
+            return listIndex;
+        }
+
+        static int CalculateCapacity(int collectionSize, float loadFactor)
+        {
+            var size = (int)(((float)collectionSize) / loadFactor);
+
+            size--;
+            size |= size >> 1;
+            size |= size >> 2;
+            size |= size >> 4;
+            size |= size >> 8;
+            size |= size >> 16;
+            size += 1;
+
+            if (size < 8)
+            {
+                size = 8;
+            }
+            return size;
+        }
+
+        class Entry
+        {
+            public WeakReference<TKey> Key;
+            public TValue Value;
+            public int Hash;
+            public Entry Prev;
+            public Entry Next;
+
+            // debug only
+            public override string ToString()
+            {
+                if (Key.TryGetTarget(out var target))
+                {
+                    return target + "(" + Count() + ")";
+                }
+                else
+                {
+                    return "(Dead)";
+                }
+            }
+
+            int Count()
+            {
+                var count = 1;
+                var n = this;
+                while (n.Next != null)
+                {
+                    count++;
+                    n = n.Next;
+                }
+                return count;
+            }
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Internal/WeakDictionary.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6c78563864409714593226af59bcb6f3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/PlayerLoopHelper.cs

@@ -0,0 +1,288 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Linq;
+using UnityEngine;
+using Cysharp.Threading.Tasks.Internal;
+using System.Threading;
+
+#if UNITY_2019_3_OR_NEWER
+using UnityEngine.LowLevel;
+#else
+using UnityEngine.Experimental.LowLevel;
+#endif
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace Cysharp.Threading.Tasks
+{
+    public static class UniTaskLoopRunners
+    {
+        public struct UniTaskLoopRunnerInitialization { };
+        public struct UniTaskLoopRunnerEarlyUpdate { };
+        public struct UniTaskLoopRunnerFixedUpdate { };
+        public struct UniTaskLoopRunnerPreUpdate { };
+        public struct UniTaskLoopRunnerUpdate { };
+        public struct UniTaskLoopRunnerPreLateUpdate { };
+        public struct UniTaskLoopRunnerPostLateUpdate { };
+
+        // Last
+
+        public struct UniTaskLoopRunnerLastInitialization { };
+        public struct UniTaskLoopRunnerLastEarlyUpdate { };
+        public struct UniTaskLoopRunnerLastFixedUpdate { };
+        public struct UniTaskLoopRunnerLastPreUpdate { };
+        public struct UniTaskLoopRunnerLastUpdate { };
+        public struct UniTaskLoopRunnerLastPreLateUpdate { };
+        public struct UniTaskLoopRunnerLastPostLateUpdate { };
+
+        // Yield
+
+        public struct UniTaskLoopRunnerYieldInitialization { };
+        public struct UniTaskLoopRunnerYieldEarlyUpdate { };
+        public struct UniTaskLoopRunnerYieldFixedUpdate { };
+        public struct UniTaskLoopRunnerYieldPreUpdate { };
+        public struct UniTaskLoopRunnerYieldUpdate { };
+        public struct UniTaskLoopRunnerYieldPreLateUpdate { };
+        public struct UniTaskLoopRunnerYieldPostLateUpdate { };
+
+        // Yield Last
+
+        public struct UniTaskLoopRunnerLastYieldInitialization { };
+        public struct UniTaskLoopRunnerLastYieldEarlyUpdate { };
+        public struct UniTaskLoopRunnerLastYieldFixedUpdate { };
+        public struct UniTaskLoopRunnerLastYieldPreUpdate { };
+        public struct UniTaskLoopRunnerLastYieldUpdate { };
+        public struct UniTaskLoopRunnerLastYieldPreLateUpdate { };
+        public struct UniTaskLoopRunnerLastYieldPostLateUpdate { };
+    }
+
+    public enum PlayerLoopTiming
+    {
+        Initialization = 0,
+        LastInitialization = 1,
+
+        EarlyUpdate = 2,
+        LastEarlyUpdate = 3,
+
+        FixedUpdate = 4,
+        LastFixedUpdate = 5,
+
+        PreUpdate = 6,
+        LastPreUpdate = 7,
+
+        Update = 8,
+        LastUpdate = 9,
+
+        PreLateUpdate = 10,
+        LastPreLateUpdate = 11,
+
+        PostLateUpdate = 12,
+        LastPostLateUpdate = 13
+    }
+
+    public interface IPlayerLoopItem
+    {
+        bool MoveNext();
+    }
+
+    public static class PlayerLoopHelper
+    {
+        public static SynchronizationContext UnitySynchronizationContext => unitySynchronizationContetext;
+        public static int MainThreadId => mainThreadId;
+
+        static int mainThreadId;
+        static SynchronizationContext unitySynchronizationContetext;
+        static ContinuationQueue[] yielders;
+        static PlayerLoopRunner[] runners;
+
+        static PlayerLoopSystem[] InsertRunner(PlayerLoopSystem loopSystem,
+            Type loopRunnerYieldType, ContinuationQueue cq, Type lastLoopRunnerYieldType, ContinuationQueue lastCq,
+            Type loopRunnerType, PlayerLoopRunner runner, Type lastLoopRunnerType, PlayerLoopRunner lastRunner)
+        {
+
+#if UNITY_EDITOR
+            EditorApplication.playModeStateChanged += (state) =>
+            {
+                if (state == PlayModeStateChange.EnteredEditMode || state == PlayModeStateChange.EnteredPlayMode)
+                {
+                    return;
+                }
+
+                if (runner != null)
+                {
+                    runner.Clear();
+                }
+                if (lastRunner != null)
+                {
+                    lastRunner.Clear();
+                }
+
+                if (cq != null)
+                {
+                    cq.Clear();
+                }
+                if (lastCq != null)
+                {
+                    lastCq.Clear();
+                }
+            };
+#endif
+
+            var yieldLoop = new PlayerLoopSystem
+            {
+                type = loopRunnerYieldType,
+                updateDelegate = cq.Run
+            };
+
+            var lastYieldLoop = new PlayerLoopSystem
+            {
+                type = lastLoopRunnerYieldType,
+                updateDelegate = lastCq.Run
+            };
+
+            var runnerLoop = new PlayerLoopSystem
+            {
+                type = loopRunnerType,
+                updateDelegate = runner.Run
+            };
+
+            var lastRunnerLoop = new PlayerLoopSystem
+            {
+                type = lastLoopRunnerType,
+                updateDelegate = lastRunner.Run
+            };
+
+            // Remove items from previous initializations.
+            var source = loopSystem.subSystemList
+                .Where(ls => ls.type != loopRunnerYieldType && ls.type != loopRunnerType && ls.type != lastLoopRunnerYieldType && ls.type != lastLoopRunnerType)
+                .ToArray();
+
+            var dest = new PlayerLoopSystem[source.Length + 4];
+
+            Array.Copy(source, 0, dest, 2, source.Length);
+            dest[0] = yieldLoop;
+            dest[1] = runnerLoop;
+            dest[dest.Length - 2] = lastYieldLoop;
+            dest[dest.Length - 1] = lastRunnerLoop;
+
+            return dest;
+        }
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        static void Init()
+        {
+            // capture default(unity) sync-context.
+            unitySynchronizationContetext = SynchronizationContext.Current;
+            mainThreadId = Thread.CurrentThread.ManagedThreadId;
+
+#if UNITY_EDITOR && UNITY_2019_3_OR_NEWER
+            // When domain reload is disabled, re-initialization is required when entering play mode; 
+            // otherwise, pending tasks will leak between play mode sessions.
+            var domainReloadDisabled = UnityEditor.EditorSettings.enterPlayModeOptionsEnabled &&
+                UnityEditor.EditorSettings.enterPlayModeOptions.HasFlag(UnityEditor.EnterPlayModeOptions.DisableDomainReload);
+            if (!domainReloadDisabled && runners != null) return;
+#else
+            if (runners != null) return; // already initialized
+#endif
+
+            var playerLoop =
+#if UNITY_2019_3_OR_NEWER
+                PlayerLoop.GetCurrentPlayerLoop();
+#else
+                PlayerLoop.GetDefaultPlayerLoop();
+#endif
+
+            Initialize(ref playerLoop);
+        }
+
+
+#if UNITY_EDITOR
+        [InitializeOnLoadMethod]
+        static void InitOnEditor()
+        {
+            //Execute the play mode init method
+            Init();
+
+            //register an Editor update delegate, used to forcing playerLoop update
+            EditorApplication.update += ForceEditorPlayerLoopUpdate;
+        }
+
+        private static void ForceEditorPlayerLoopUpdate()
+        {
+            if (EditorApplication.isPlayingOrWillChangePlaymode || EditorApplication.isCompiling ||
+                EditorApplication.isUpdating)
+            {
+                // Not in Edit mode, don't interfere
+                return;
+            }
+
+            //force unity to update PlayerLoop callbacks
+            EditorApplication.QueuePlayerLoopUpdate();
+        }
+
+#endif
+
+        public static void Initialize(ref PlayerLoopSystem playerLoop)
+        {
+            yielders = new ContinuationQueue[14];
+            runners = new PlayerLoopRunner[14];
+
+            var copyList = playerLoop.subSystemList.ToArray();
+
+            // Initialization
+            copyList[0].subSystemList = InsertRunner(copyList[0], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldInitialization), yielders[0] = new ContinuationQueue(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldInitialization), yielders[1] = new ContinuationQueue(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerInitialization), runners[1] = new PlayerLoopRunner(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastInitialization), runners[1] = new PlayerLoopRunner());
+            // EarlyUpdate
+            copyList[1].subSystemList = InsertRunner(copyList[1], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldEarlyUpdate), yielders[2] = new ContinuationQueue(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldEarlyUpdate), yielders[3] = new ContinuationQueue(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerEarlyUpdate), runners[2] = new PlayerLoopRunner(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastEarlyUpdate), runners[3] = new PlayerLoopRunner());
+            // FixedUpdate
+            copyList[2].subSystemList = InsertRunner(copyList[2], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldFixedUpdate), yielders[4] = new ContinuationQueue(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldFixedUpdate), yielders[5] = new ContinuationQueue(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerFixedUpdate), runners[4] = new PlayerLoopRunner(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastFixedUpdate), runners[5] = new PlayerLoopRunner());
+            // PreUpdate
+            copyList[3].subSystemList = InsertRunner(copyList[3], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreUpdate), yielders[6] = new ContinuationQueue(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPreUpdate), yielders[7] = new ContinuationQueue(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreUpdate), runners[6] = new PlayerLoopRunner(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPreUpdate), runners[7] = new PlayerLoopRunner());
+            // Update
+            copyList[4].subSystemList = InsertRunner(copyList[4], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldUpdate), yielders[8] = new ContinuationQueue(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldUpdate), yielders[9] = new ContinuationQueue(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerUpdate), runners[8] = new PlayerLoopRunner(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastUpdate), runners[9] = new PlayerLoopRunner());
+            // PreLateUpdate
+            copyList[5].subSystemList = InsertRunner(copyList[5], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreLateUpdate), yielders[10] = new ContinuationQueue(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPreLateUpdate), yielders[11] = new ContinuationQueue(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreLateUpdate), runners[10] = new PlayerLoopRunner(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPreLateUpdate), runners[11] = new PlayerLoopRunner());
+            // PostLateUpdate
+            copyList[6].subSystemList = InsertRunner(copyList[6], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPostLateUpdate), yielders[12] = new ContinuationQueue(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPostLateUpdate), yielders[13] = new ContinuationQueue(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerPostLateUpdate), runners[12] = new PlayerLoopRunner(),
+                                                                  typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPostLateUpdate), runners[13] = new PlayerLoopRunner());
+
+            playerLoop.subSystemList = copyList;
+            PlayerLoop.SetPlayerLoop(playerLoop);
+        }
+
+        public static void AddAction(PlayerLoopTiming timing, IPlayerLoopItem action)
+        {
+            runners[(int)timing].AddAction(action);
+        }
+
+        public static void AddContinuation(PlayerLoopTiming timing, Action continuation)
+        {
+            yielders[(int)timing].Enqueue(continuation);
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/PlayerLoopHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 15fb5b85042f19640b973ce651795aca
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Progress.cs

@@ -0,0 +1,88 @@
+#if NET_4_6 || NET_STANDARD_2_0 || CSHARP_7_OR_LATER
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using Cysharp.Threading.Tasks.Internal;
+
+namespace Cysharp.Threading.Tasks
+{
+    /// <summary>
+    /// Lightweight IProgress[T] factory.
+    /// </summary>
+    public static class Progress
+    {
+        public static IProgress<T> Create<T>(Action<T> handler)
+        {
+            if (handler == null) return NullProgress<T>.Instance;
+            return new AnonymousProgress<T>(handler);
+        }
+
+        public static IProgress<T> CreateOnlyValueChanged<T>(Action<T> handler, IEqualityComparer<T> comparer = null)
+        {
+            if (handler == null) return NullProgress<T>.Instance;
+            return new OnlyValueChangedProgress<T>(handler, comparer ?? UnityEqualityComparer.GetDefault<T>());
+        }
+
+        sealed class NullProgress<T> : IProgress<T>
+        {
+            public static readonly IProgress<T> Instance = new NullProgress<T>();
+
+            NullProgress()
+            {
+
+            }
+
+            public void Report(T value)
+            {
+            }
+        }
+
+        sealed class AnonymousProgress<T> : IProgress<T>
+        {
+            readonly Action<T> action;
+
+            public AnonymousProgress(Action<T> action)
+            {
+                this.action = action;
+            }
+
+            public void Report(T value)
+            {
+                action(value);
+            }
+        }
+
+        sealed class OnlyValueChangedProgress<T> : IProgress<T>
+        {
+            readonly Action<T> action;
+            readonly IEqualityComparer<T> comparer;
+            bool isFirstCall;
+            T latestValue;
+
+            public OnlyValueChangedProgress(Action<T> action, IEqualityComparer<T> comparer)
+            {
+                this.action = action;
+                this.comparer = comparer;
+                this.isFirstCall = true;
+            }
+
+            public void Report(T value)
+            {
+                if (isFirstCall)
+                {
+                    isFirstCall = false;
+                }
+                else if (comparer.Equals(value, latestValue))
+                {
+                    return;
+                }
+
+                latestValue = value;
+                action(value);
+            }
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Progress.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e3377e2ae934ed54fb8fd5388e2d9eb9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Triggers.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 85c0c768ced512e42b24021b3258b669
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Triggers/AsyncAwakeTrigger.cs

@@ -0,0 +1,77 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Threading;
+using UnityEngine;
+
+namespace Cysharp.Threading.Tasks.Triggers
+{
+    public static partial class AsyncTriggerExtensions
+    {
+        public static AsyncAwakeTrigger GetAsyncAwakeTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncAwakeTrigger>(gameObject);
+        }
+
+        public static AsyncAwakeTrigger GetAsyncAwakeTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncAwakeTrigger();
+        }
+    }
+
+    [DisallowMultipleComponent]
+    public class AsyncAwakeTrigger : MonoBehaviour
+    {
+        bool called = false;
+        TriggerEvent<AsyncUnit> triggerEvent;
+
+        void Awake()
+        {
+            called = true;
+            triggerEvent?.TrySetResult(AsyncUnit.Default);
+            triggerEvent = null;
+        }
+
+        public UniTask AwakeAsync()
+        {
+            if (called) return UniTask.CompletedTask;
+
+            PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
+
+            if (triggerEvent == null)
+            {
+                triggerEvent = new TriggerEvent<AsyncUnit>();
+            }
+
+            return ((IAsyncOneShotTrigger)new AsyncTriggerHandler<AsyncUnit>(triggerEvent, true)).OneShotAsync();
+        }
+
+        private void OnDestroy()
+        {
+            triggerEvent?.TrySetCanceled(CancellationToken.None);
+        }
+
+        class AwakeMonitor : IPlayerLoopItem
+        {
+            readonly AsyncAwakeTrigger trigger;
+
+            public AwakeMonitor(AsyncAwakeTrigger trigger)
+            {
+                this.trigger = trigger;
+            }
+
+            public bool MoveNext()
+            {
+                if (trigger.called) return false;
+                if (trigger == null)
+                {
+                    trigger.OnDestroy();
+                    return false;
+                }
+                return true;
+            }
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Triggers/AsyncAwakeTrigger.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ef2840a2586894741a0ae211b8fd669b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Triggers/AsyncDestroyTrigger.cs

@@ -0,0 +1,98 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Threading;
+using UnityEngine;
+
+namespace Cysharp.Threading.Tasks.Triggers
+{
+    public static partial class AsyncTriggerExtensions
+    {
+        public static AsyncDestroyTrigger GetAsyncDestroyTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncDestroyTrigger>(gameObject);
+        }
+
+        public static AsyncDestroyTrigger GetAsyncDestroyTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncDestroyTrigger();
+        }
+    }
+
+    [DisallowMultipleComponent]
+    public class AsyncDestroyTrigger : MonoBehaviour
+    {
+        bool awakeCalled = false;
+        bool called = false;
+        TriggerEvent<AsyncUnit> triggerEvent;
+        CancellationTokenSource cancellationTokenSource;
+
+        public CancellationToken CancellationToken
+        {
+            get
+            {
+                if (cancellationTokenSource == null)
+                {
+                    cancellationTokenSource = new CancellationTokenSource();
+                }
+                return cancellationTokenSource.Token;
+            }
+        }
+
+        void Awake()
+        {
+            awakeCalled = true;
+        }
+
+        void OnDestroy()
+        {
+            called = true;
+
+            triggerEvent?.TrySetResult(AsyncUnit.Default);
+            cancellationTokenSource?.Cancel();
+            cancellationTokenSource?.Dispose();
+
+            triggerEvent = null;
+        }
+
+        public UniTask OnDestroyAsync()
+        {
+            if (called) return UniTask.CompletedTask;
+
+            if (!awakeCalled)
+            {
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
+            }
+
+            if (triggerEvent == null)
+            {
+                triggerEvent = new TriggerEvent<AsyncUnit>();
+            }
+
+            return ((IAsyncOneShotTrigger)new AsyncTriggerHandler<AsyncUnit>(triggerEvent, true)).OneShotAsync();
+        }
+
+        class AwakeMonitor : IPlayerLoopItem
+        {
+            readonly AsyncDestroyTrigger trigger;
+
+            public AwakeMonitor(AsyncDestroyTrigger trigger)
+            {
+                this.trigger = trigger;
+            }
+
+            public bool MoveNext()
+            {
+                if (trigger.called) return false;
+                if (trigger == null)
+                {
+                    trigger.OnDestroy();
+                    return false;
+                }
+                return true;
+            }
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Triggers/AsyncDestroyTrigger.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f4afdcb1cbadf954ba8b1cf465429e17
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Triggers/AsyncStartTrigger.cs

@@ -0,0 +1,87 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Threading;
+using UnityEngine;
+
+namespace Cysharp.Threading.Tasks.Triggers
+{
+    public static partial class AsyncTriggerExtensions
+    {
+        public static AsyncStartTrigger GetAsyncStartTrigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<AsyncStartTrigger>(gameObject);
+        }
+
+        public static AsyncStartTrigger GetAsyncStartTrigger(this Component component)
+        {
+            return component.gameObject.GetAsyncStartTrigger();
+        }
+    }
+
+    [DisallowMultipleComponent]
+    public class AsyncStartTrigger : MonoBehaviour
+    {
+        bool awakeCalled = false;
+        bool called = false;
+        TriggerEvent<AsyncUnit> triggerEvent;
+
+        void Awake()
+        {
+            awakeCalled = true;
+        }
+
+        void Start()
+        {
+            called = true;
+            triggerEvent?.TrySetResult(AsyncUnit.Default);
+            triggerEvent = null;
+        }
+
+        public UniTask StartAsync()
+        {
+            if (called) return UniTask.CompletedTask;
+
+            if (!awakeCalled)
+            {
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
+            }
+
+            if (triggerEvent == null)
+            {
+                triggerEvent = new TriggerEvent<AsyncUnit>();
+            }
+
+            return ((IAsyncOneShotTrigger)new AsyncTriggerHandler<AsyncUnit>(triggerEvent, true)).OneShotAsync();
+        }
+
+        private void OnDestroy()
+        {
+            triggerEvent?.TrySetCanceled(CancellationToken.None);
+        }
+
+        class AwakeMonitor : IPlayerLoopItem
+        {
+            readonly AsyncStartTrigger trigger;
+
+            public AwakeMonitor(AsyncStartTrigger trigger)
+            {
+                this.trigger = trigger;
+            }
+
+            public bool MoveNext()
+            {
+                if (trigger.called) return false;
+                if (trigger == null)
+                {
+                    trigger.OnDestroy();
+                    return false;
+                }
+                return true;
+            }
+        }
+    }
+
+}
+
+#endif

Assets/Plugins/UniTask/Triggers/AsyncStartTrigger.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b4fd0f75e54ec3d4fbcb7fc65b11646b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Triggers/AsyncTriggerBase.cs

@@ -0,0 +1,385 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using Cysharp.Threading.Tasks.Internal;
+using UnityEngine;
+
+namespace Cysharp.Threading.Tasks.Triggers
+{
+    public abstract class AsyncTriggerBase : MonoBehaviour
+    {
+        bool calledAwake;
+        bool calledDestroy;
+        ICancelPromise triggerSlot;
+
+        void Awake()
+        {
+            calledAwake = true;
+        }
+
+        protected TriggerEvent<T> SetTriggerEvent<T>(ref TriggerEvent<T> field)
+        {
+            if (field == null)
+            {
+                field = new TriggerEvent<T>();
+                if (triggerSlot == null)
+                {
+                    triggerSlot = field;
+                }
+                else
+                {
+                    throw new InvalidOperationException("triggerSlot is already filled.");
+                }
+            }
+
+            if (!calledAwake)
+            {
+                PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
+            }
+
+            return field;
+        }
+
+        void OnDestroy()
+        {
+            if (calledDestroy) return;
+            calledDestroy = true;
+
+            triggerSlot?.TrySetCanceled();
+            triggerSlot = null;
+        }
+
+        class AwakeMonitor : IPlayerLoopItem
+        {
+            readonly AsyncTriggerBase trigger;
+
+            public AwakeMonitor(AsyncTriggerBase trigger)
+            {
+                this.trigger = trigger;
+            }
+
+            public bool MoveNext()
+            {
+                if (trigger.calledAwake) return false;
+                if (trigger == null)
+                {
+                    trigger.OnDestroy();
+                    return false;
+                }
+                return true;
+            }
+        }
+    }
+
+    public interface IAsyncOneShotTrigger
+    {
+        UniTask OneShotAsync();
+    }
+
+    public partial class AsyncTriggerHandler<T> : IAsyncOneShotTrigger
+    {
+        UniTask IAsyncOneShotTrigger.OneShotAsync()
+        {
+            core.Reset();
+            return new UniTask((IUniTaskSource)this, core.Version);
+        }
+    }
+
+    public sealed partial class AsyncTriggerHandler<T> : IUniTaskSource<T>, IResolvePromise<T>, ICancelPromise, IDisposable
+    {
+        static Action<object> cancellationCallback = CancellationCallback;
+
+        readonly TriggerEvent<T> trigger;
+
+        CancellationToken cancellationToken;
+        CancellationTokenRegistration registration;
+        bool isDisposed;
+        bool callOnce;
+
+        UniTaskCompletionSourceCore<T> core;
+
+        internal CancellationToken CancellationToken => cancellationToken;
+
+        public AsyncTriggerHandler(TriggerEvent<T> trigger, bool callOnce)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                isDisposed = true;
+                return;
+            }
+
+            this.trigger = trigger;
+            this.cancellationToken = default;
+            this.registration = default;
+            this.callOnce = callOnce;
+
+            trigger.Add(this);
+
+            TaskTracker.TrackActiveTask(this, 3);
+        }
+
+        public AsyncTriggerHandler(TriggerEvent<T> trigger, CancellationToken cancellationToken, bool callOnce)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                isDisposed = true;
+                return;
+            }
+
+            this.trigger = trigger;
+            this.cancellationToken = cancellationToken;
+            this.callOnce = callOnce;
+
+            trigger.Add(this);
+
+            if (cancellationToken.CanBeCanceled)
+            {
+                registration = cancellationToken.RegisterWithoutCaptureExecutionContext(cancellationCallback, this);
+            }
+
+            TaskTracker.TrackActiveTask(this, 3);
+        }
+
+        static void CancellationCallback(object state)
+        {
+            var self = (AsyncTriggerHandler<T>)state;
+            self.Dispose();
+
+            self.core.TrySetCanceled(self.cancellationToken);
+        }
+
+        public void Dispose()
+        {
+            if (!isDisposed)
+            {
+                isDisposed = true;
+                TaskTracker.RemoveTracking(this);
+                registration.Dispose();
+                trigger.Remove(this);
+            }
+        }
+
+        T IUniTaskSource<T>.GetResult(short token)
+        {
+            try
+            {
+                return core.GetResult(token);
+            }
+            finally
+            {
+                if (callOnce)
+                {
+                    Dispose();
+                }
+            }
+        }
+
+        bool IResolvePromise<T>.TrySetResult(T result)
+        {
+            return core.TrySetResult(result);
+        }
+
+        bool ICancelPromise.TrySetCanceled(CancellationToken cancellationToken)
+        {
+            return core.TrySetCanceled(cancellationToken);
+        }
+
+        void IUniTaskSource.GetResult(short token)
+        {
+            ((IUniTaskSource<T>)this).GetResult(token);
+        }
+
+        UniTaskStatus IUniTaskSource.GetStatus(short token)
+        {
+            return core.GetStatus(token);
+        }
+
+        UniTaskStatus IUniTaskSource.UnsafeGetStatus()
+        {
+            return core.UnsafeGetStatus();
+        }
+
+        void IUniTaskSource.OnCompleted(Action<object> continuation, object state, short token)
+        {
+            core.OnCompleted(continuation, state, token);
+        }
+    }
+
+    public sealed class TriggerEvent<T> : IResolvePromise<T>, ICancelPromise
+    {
+        // optimize: many cases, handler is single.
+        AsyncTriggerHandler<T> singleHandler;
+
+        List<AsyncTriggerHandler<T>> handlers;
+
+        public bool TrySetResult(T value)
+        {
+            List<Exception> exceptions = null;
+
+            if (singleHandler != null)
+            {
+                try
+                {
+                    ((IResolvePromise<T>)singleHandler).TrySetResult(value);
+                }
+                catch (Exception ex)
+                {
+                    if (handlers == null)
+                    {
+                        throw;
+                    }
+                    else
+                    {
+                        exceptions = new List<Exception>();
+                        exceptions.Add(ex);
+                    }
+                }
+            }
+
+            if (handlers != null)
+            {
+                // make snapshot
+                var rentArray = ArrayPoolUtil.CopyToRentArray(handlers);
+                var clearArray = true;
+                try
+                {
+                    var array = rentArray.Array;
+                    var len = rentArray.Length;
+                    for (int i = 0; i < len; i++)
+                    {
+                        try
+                        {
+                            ((IResolvePromise<T>)array[i]).TrySetResult(value);
+                        }
+                        catch (Exception ex)
+                        {
+                            if (exceptions == null)
+                            {
+                                exceptions = new List<Exception>();
+                            }
+                            exceptions.Add(ex);
+                        }
+                        finally
+                        {
+                            array[i] = null;
+                        }
+                    }
+                }
+                finally
+                {
+                    rentArray.DisposeManually(clearArray);
+                }
+            }
+
+            if (exceptions != null)
+            {
+                throw new AggregateException(exceptions);
+            }
+
+            return true;
+        }
+
+        public bool TrySetCanceled(CancellationToken cancellationToken)
+        {
+            List<Exception> exceptions = null;
+
+            if (singleHandler != null)
+            {
+                try
+                {
+                    ((ICancelPromise)singleHandler).TrySetCanceled(cancellationToken);
+                }
+                catch (Exception ex)
+                {
+                    if (handlers == null)
+                    {
+                        throw;
+                    }
+                    else
+                    {
+                        exceptions = new List<Exception>();
+                        exceptions.Add(ex);
+                    }
+                }
+            }
+
+            if (handlers != null)
+            {
+                // make snapshot
+                var rentArray = ArrayPoolUtil.CopyToRentArray(handlers);
+                var clearArray = true;
+                try
+                {
+                    var array = rentArray.Array;
+                    var len = rentArray.Length;
+                    for (int i = 0; i < len; i++)
+                    {
+                        try
+                        {
+                            ((ICancelPromise)array[i]).TrySetCanceled(cancellationToken);
+                        }
+                        catch (Exception ex)
+                        {
+                            if (exceptions == null)
+                            {
+                                exceptions = new List<Exception>();
+                            }
+                            exceptions.Add(ex);
+                        }
+                        finally
+                        {
+                            array[i] = null;
+                        }
+                    }
+                }
+                finally
+                {
+                    rentArray.DisposeManually(clearArray);
+                }
+            }
+
+            if (exceptions != null)
+            {
+                throw new AggregateException(exceptions);
+            }
+
+            return true;
+        }
+
+        public void Add(AsyncTriggerHandler<T> handler)
+        {
+            if (singleHandler == null)
+            {
+                singleHandler = handler;
+            }
+            else
+            {
+                if (handlers != null)
+                {
+                    handlers = new List<AsyncTriggerHandler<T>>();
+                    handlers.Add(handler);
+                }
+            }
+        }
+
+        public void Remove(AsyncTriggerHandler<T> handler)
+        {
+            if (singleHandler == handler)
+            {
+                singleHandler = null;
+            }
+            else
+            {
+                if (handlers != null)
+                {
+                    handlers.Remove(handler);
+                }
+            }
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Triggers/AsyncTriggerBase.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2c0c2bcee832c6641b25949c412f020f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Triggers/AsyncTriggerExtensions.cs

@@ -0,0 +1,80 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Threading;
+using UnityEngine;
+using Cysharp.Threading.Tasks.Triggers;
+
+namespace Cysharp.Threading.Tasks
+{
+    public static class UniTaskCancellationExtensions
+    {
+        /// <summary>This CancellationToken is canceled when the MonoBehaviour will be destroyed.</summary>
+        public static CancellationToken GetCancellationTokenOnDestroy(this GameObject gameObject)
+        {
+            return gameObject.GetAsyncDestroyTrigger().CancellationToken;
+        }
+
+        /// <summary>This CancellationToken is canceled when the MonoBehaviour will be destroyed.</summary>
+        public static CancellationToken GetCancellationTokenOnDestroy(this Component component)
+        {
+            return component.GetAsyncDestroyTrigger().CancellationToken;
+        }
+    }
+}
+
+namespace Cysharp.Threading.Tasks.Triggers
+{
+    public static partial class AsyncTriggerExtensions
+    {
+        // Util.
+
+        static T GetOrAddComponent<T>(GameObject gameObject)
+            where T : Component
+        {
+            var component = gameObject.GetComponent<T>();
+            if (component == null)
+            {
+                component = gameObject.AddComponent<T>();
+            }
+
+            return component;
+        }
+
+        // Special for single operation.
+
+        /// <summary>This function is called when the MonoBehaviour will be destroyed.</summary>
+        public static UniTask OnDestroyAsync(this GameObject gameObject)
+        {
+            return gameObject.GetAsyncDestroyTrigger().OnDestroyAsync();
+        }
+
+        /// <summary>This function is called when the MonoBehaviour will be destroyed.</summary>
+        public static UniTask OnDestroyAsync(this Component component)
+        {
+            return component.GetAsyncDestroyTrigger().OnDestroyAsync();
+        }
+
+        public static UniTask StartAsync(this GameObject gameObject)
+        {
+            return gameObject.GetAsyncStartTrigger().StartAsync();
+        }
+
+        public static UniTask StartAsync(this Component component)
+        {
+            return component.GetAsyncStartTrigger().StartAsync();
+        }
+
+        public static UniTask AwakeAsync(this GameObject gameObject)
+        {
+            return gameObject.GetAsyncAwakeTrigger().AwakeAsync();
+        }
+
+        public static UniTask AwakeAsync(this Component component)
+        {
+            return component.GetAsyncAwakeTrigger().AwakeAsync();
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/Triggers/AsyncTriggerExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 59b61dbea1562a84fb7a38ae0a0a0f88
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Triggers/MonoBehaviourMessagesTriggers.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c30655636c35c3d4da44064af3d2d9a7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/Triggers/MonoBehaviourMessagesTriggers.tt

@@ -0,0 +1,186 @@
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".cs" #>
+<#
+    var empty = new (string, string)[0];
+
+    var triggers = new (string triggerName, string methodName, string returnType, string handlerInterface, (string argType, string argName)[] arguments)[]
+    {
+        ("AnimatorIK", "OnAnimatorIK", "int", null, new []{ ("int", "layerIndex") }),
+        ("AnimatorMove", "OnAnimatorMove", "AsyncUnit", null, empty),
+        ("OnCanvasGroupChanged", "OnCanvasGroupChanged", "AsyncUnit", null, empty ),
+        ("CollisionEnter2D", "OnCollisionEnter2D", "Collision2D", null, new []{ ("Collision2D", "coll") }),
+        ("CollisionExit2D", "OnCollisionExit2D", "Collision2D", null, new []{ ("Collision2D", "coll") }),
+        ("CollisionStay2D", "OnCollisionStay2D", "Collision2D", null, new []{ ("Collision2D", "coll") }),
+        ("CollisionEnter", "OnCollisionEnter", "Collision", null, new []{ ("Collision", "coll") }),
+        ("CollisionExit", "OnCollisionExit", "Collision", null, new []{ ("Collision", "coll") }),
+        ("CollisionStay", "OnCollisionStay", "Collision", null, new []{ ("Collision", "coll") }),
+        ("Enable", "OnEnable", "AsyncUnit", null, empty),
+        ("Disable", "OnDisable", "AsyncUnit", null, empty),
+        ("JointBreak", "OnJointBreak", "float", null, new []{ ("float", "breakForce") }),
+        ("JointBreak2D", "OnJointBreak2D", "Joint2D", null, new []{ ("Joint2D", "brokenJoint") }),
+        ("Update", "Update", "AsyncUnit", null, empty),
+        ("FixedUpdate", "FixedUpdate", "AsyncUnit", null, empty),
+        ("LateUpdate", "LateUpdate", "AsyncUnit", null, empty),
+        ("MouseDown", "OnMouseDown", "AsyncUnit", null, empty),
+        ("MouseDrag", "OnMouseDrag", "AsyncUnit", null, empty),
+        ("MouseEnter", "OnMouseEnter", "AsyncUnit", null, empty),
+        ("MouseExit", "OnMouseExit", "AsyncUnit", null, empty),
+        ("MouseOver", "OnMouseOver", "AsyncUnit", null, empty),
+        ("MouseUp", "OnMouseUp", "AsyncUnit", null, empty),
+        ("MouseUpAsButton", "OnMouseUpAsButton", "AsyncUnit", null, empty),
+        ("ParticleCollision", "OnParticleCollision", "GameObject", null, new []{ ("GameObject", "other") }),
+        ("RectTransformDimensionsChange", "OnRectTransformDimensionsChange", "AsyncUnit", null, empty),
+        ("RectTransformRemoved", "OnRectTransformRemoved", "AsyncUnit", null, empty),
+        ("BeforeTransformParentChanged", "OnBeforeTransformParentChanged", "AsyncUnit", null, empty),
+        ("TransformParentChanged", "OnTransformParentChanged", "AsyncUnit", null, empty),
+        ("TransformChildrenChanged", "OnTransformChildrenChanged", "AsyncUnit", null, empty),
+        ("TriggerEnter2D", "OnTriggerEnter2D", "Collider2D", null, new []{ ("Collider2D", "other") }),
+        ("TriggerExit2D", "OnTriggerExit2D", "Collider2D", null, new []{ ("Collider2D", "other") }),
+        ("TriggerStay2D", "OnTriggerStay2D", "Collider2D", null, new []{ ("Collider2D", "other") }),
+        ("TriggerEnter", "OnTriggerEnter", "Collider", null, new []{ ("Collider", "other") }),
+        ("TriggerExit", "OnTriggerExit", "Collider", null, new []{ ("Collider", "other") }),
+        ("TriggerStay", "OnTriggerStay", "Collider", null, new []{ ("Collider", "other") }),
+        ("BecameInvisible", "OnBecameInvisible", "AsyncUnit", null, empty),
+        ("BecameVisible", "OnBecameVisible", "AsyncUnit", null, empty),
+        
+        // new in v2
+        ("ApplicationFocus", "OnApplicationFocus", "bool", null, new []{("bool", "hasFocus") }),
+        ("ApplicationPause", "OnApplicationPause", "bool", null, new []{("bool", "pauseStatus") }),
+        ("ApplicationQuit", "OnApplicationQuit", "AsyncUnit", null, empty),
+        ("AudioFilterRead", "OnAudioFilterRead", "(float[] data, int channels)", null, new[]{("float[]", "data"), ("int", "channels")}),
+        ("ControllerColliderHit", "OnControllerColliderHit", "ControllerColliderHit", null, new[]{("ControllerColliderHit", "hit")}),
+        ("DrawGizmos", "OnDrawGizmos", "AsyncUnit", null, empty),
+        ("DrawGizmosSelected", "OnDrawGizmosSelected", "AsyncUnit", null, empty),
+        ("GUI", "OnGUI", "AsyncUnit", null, empty),
+        ("ParticleSystemStopped", "OnParticleSystemStopped", "AsyncUnit", null, empty),
+        ("ParticleTrigger", "OnParticleTrigger", "AsyncUnit", null, empty),
+        ("PostRender", "OnPostRender", "AsyncUnit", null, empty),
+        ("PreCull", "OnPreCull", "AsyncUnit", null, empty),
+        ("PreRender", "OnPreRender", "AsyncUnit", null, empty),
+        ("RenderImage", "OnRenderImage", "(RenderTexture source, RenderTexture destination)", null, new[]{("RenderTexture", "source"), ("RenderTexture", "destination")}),
+        ("RenderObject", "OnRenderObject", "AsyncUnit", null, empty),
+        ("ServerInitialized", "OnServerInitialized", "AsyncUnit", null, empty),
+        ("Validate", "OnValidate", "AsyncUnit", null, empty),
+        ("WillRenderObject", "OnWillRenderObject", "AsyncUnit", null, empty),
+        ("Reset", "Reset", "AsyncUnit", null, empty),
+
+        // uGUI
+        ("BeginDrag", "OnBeginDrag", "PointerEventData", "IBeginDragHandler", new []{ ("PointerEventData", "eventData") }),
+        ("Cancel", "OnCancel", "BaseEventData", "ICancelHandler", new []{ ("BaseEventData", "eventData") }),
+        ("Deselect", "OnDeselect", "BaseEventData", "IDeselectHandler", new []{ ("BaseEventData", "eventData") }),
+        ("Drag", "OnDrag", "PointerEventData", "IDragHandler", new []{ ("PointerEventData", "eventData") }),
+        ("Drop", "OnDrop", "PointerEventData", "IDropHandler", new []{ ("PointerEventData", "eventData") }),
+        ("EndDrag", "OnEndDrag", "PointerEventData", "IEndDragHandler", new []{ ("PointerEventData", "eventData") }),
+        ("InitializePotentialDrag", "OnInitializePotentialDrag", "PointerEventData", "IInitializePotentialDragHandler", new []{ ("PointerEventData", "eventData") }),
+        ("Move", "OnMove", "AxisEventData", "IMoveHandler", new []{ ("AxisEventData", "eventData") }),
+        ("PointerClick", "OnPointerClick", "PointerEventData", "IPointerClickHandler", new []{ ("PointerEventData", "eventData") }),
+        ("PointerDown", "OnPointerDown", "PointerEventData", "IPointerDownHandler", new []{ ("PointerEventData", "eventData") }),
+        ("PointerEnter", "OnPointerEnter", "PointerEventData", "IPointerEnterHandler", new []{ ("PointerEventData", "eventData") }),
+        ("PointerExit", "OnPointerExit", "PointerEventData", "IPointerExitHandler", new []{ ("PointerEventData", "eventData") }),
+        ("PointerUp", "OnPointerUp", "PointerEventData", "IPointerUpHandler", new []{ ("PointerEventData", "eventData") }),
+        ("Scroll", "OnScroll", "PointerEventData", "IScrollHandler", new []{ ("PointerEventData", "eventData") }),
+        ("Select", "OnSelect", "BaseEventData", "ISelectHandler", new []{ ("BaseEventData", "eventData") }),
+        ("Submit", "OnSubmit", "BaseEventData", "ISubmitHandler", new []{ ("BaseEventData", "eventData") }),
+        ("UpdateSelected", "OnUpdateSelected", "BaseEventData", "IUpdateSelectedHandler", new []{ ("BaseEventData", "eventData") }),
+
+        // 2019.3
+        ("ParticleUpdateJobScheduled", "OnParticleUpdateJobScheduled", "UnityEngine.ParticleSystemJobs.ParticleSystemJobData", null, new[]{("UnityEngine.ParticleSystemJobs.ParticleSystemJobData", "particles")}),
+
+        // Oneshot
+        // Awake, Start, Destroy
+    };
+
+    triggers = triggers.OrderBy(x => x.handlerInterface != null).ThenBy(x => x.handlerInterface != null ? x.handlerInterface : x.methodName).ToArray();
+
+    Func<string, string> ToInterfaceName = x => $"IAsync{x}Handler";
+    Func<string, string> ToUniTaskName = x => x == "AsyncUnit" ? "UniTask" : $"UniTask<{x}>";
+    Func<string, string> ToCastUniTasSourceType = x => x == "AsyncUnit" ? "IUniTaskSource" : $"IUniTaskSource<{x}>";
+    Func<string, string> TriggerFieldName = x => char.ToLowerInvariant(x[0]) + x.Substring(1, x.Length - 1) + "TriggerEvent";
+    Func<string, string> OnInvokeSuffix = x => x == "AsyncUnit" ? ".AsUniTask()" : $"";
+    Func<(string argType, string argName)[], string> BuildMethodArgument = x => string.Join(", ", x.Select(y => y.argType + " " + y.argName));
+    Func<(string argType, string argName)[], string> BuildResultParameter = x => x.Length == 0 ? "AsyncUnit.Default" : "(" + string.Join(", ", x.Select(y => y.argName)) + ")";
+
+    Func<string, bool> Is2019_3 = x => x == "ParticleUpdateJobScheduled";
+#>
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace Cysharp.Threading.Tasks.Triggers
+{
+<# foreach(var t in triggers) { #>
+#region <#= t.triggerName #>
+<# if(Is2019_3(t.triggerName)) { #>
+#if UNITY_2019_3_OR_NEWER
+<# } #>
+
+    public interface <#= ToInterfaceName(t.methodName) #>
+    {
+        <#= ToUniTaskName(t.returnType) #> <#= t.methodName #>Async();
+    }
+
+    public partial class AsyncTriggerHandler<T> : <#= ToInterfaceName(t.methodName) #>
+    {
+        <#= ToUniTaskName(t.returnType) #> <#= ToInterfaceName(t.methodName) #>.<#= t.methodName #>Async()
+        {
+            core.Reset();
+            return new <#= ToUniTaskName(t.returnType) #>((<#= ToCastUniTasSourceType(t.returnType) #>)(object)this, core.Version);
+        }
+    }
+
+    public static partial class AsyncTriggerExtensions
+    {
+        public static Async<#= t.triggerName #>Trigger GetAsync<#= t.triggerName #>Trigger(this GameObject gameObject)
+        {
+            return GetOrAddComponent<Async<#= t.triggerName #>Trigger>(gameObject);
+        }
+        
+        public static Async<#= t.triggerName #>Trigger GetAsync<#= t.triggerName #>Trigger(this Component component)
+        {
+            return component.gameObject.GetAsync<#= t.triggerName #>Trigger();
+        }
+    }
+
+    [DisallowMultipleComponent]
+    public sealed class Async<#= t.triggerName #>Trigger : AsyncTriggerBase<#= (t.handlerInterface == null) ? "" : $", {t.handlerInterface}" #>
+    {
+        TriggerEvent<<#= t.returnType #>> <#= TriggerFieldName(t.methodName) #>;
+
+        void <#= (t.handlerInterface == null) ? "" : $"{t.handlerInterface}." #><#= t.methodName #>(<#= BuildMethodArgument(t.arguments) #>)
+        {
+            <#= TriggerFieldName(t.methodName) #>?.TrySetResult(<#= BuildResultParameter(t.arguments) #>);
+        }
+
+        public <#= ToInterfaceName(t.methodName) #> Get<#= t.methodName #>AsyncHandler()
+        {
+            return new AsyncTriggerHandler<<#= t.returnType #>>(SetTriggerEvent(ref <#= TriggerFieldName(t.methodName) #>), false);
+        }
+
+        public <#= ToInterfaceName(t.methodName) #> Get<#= t.methodName #>AsyncHandler(CancellationToken cancellationToken)
+        {
+            return new AsyncTriggerHandler<<#= t.returnType #>>(SetTriggerEvent(ref <#= TriggerFieldName(t.methodName) #>), cancellationToken, false);
+        }
+
+        public <#= ToUniTaskName(t.returnType) #> <#= t.methodName #>Async()
+        {
+            return ((<#= ToInterfaceName(t.methodName) #>)new AsyncTriggerHandler<<#= t.returnType #>>(SetTriggerEvent(ref <#= TriggerFieldName(t.methodName) #>), true)).<#= t.methodName #>Async();
+        }
+
+        public <#= ToUniTaskName(t.returnType) #> <#= t.methodName #>Async(CancellationToken cancellationToken)
+        {
+            return ((<#= ToInterfaceName(t.methodName) #>)new AsyncTriggerHandler<<#= t.returnType #>>(SetTriggerEvent(ref <#= TriggerFieldName(t.methodName) #>), cancellationToken, true)).<#= t.methodName #>Async();
+        }
+    }
+<# if(Is2019_3(t.triggerName)) { #>
+#endif
+<# } #>
+#endregion
+
+<# } #>
+}

Assets/Plugins/UniTask/Triggers/MonoBehaviourMessagesTriggers.tt.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 3ca26d0cd9373354c8cd147490f32c8e
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/UniRx.Async.asmdef

@@ -0,0 +1,12 @@
+{
+    "name": "UniRx.Async",
+    "references": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": []
+}

Assets/Plugins/UniTask/UniRx.Async.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: f51ebe6a0ceec4240a699833d6309b23
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/UniTask.Bridge.cs

@@ -0,0 +1,20 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Collections;
+
+namespace Cysharp.Threading.Tasks
+{
+    // UnityEngine Bridges.
+
+    public partial struct UniTask
+    {
+        public static IEnumerator ToCoroutine(Func<UniTask> taskFactory)
+        {
+            return taskFactory().ToCoroutine();
+        }
+    }
+}
+
+#endif

Assets/Plugins/UniTask/UniTask.Bridge.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bd6beac8e0ebd264e9ba246c39429c72
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/UniTask.Delay.cs

@@ -0,0 +1,483 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using Cysharp.Threading.Tasks.Internal;
+using UnityEngine;
+
+namespace Cysharp.Threading.Tasks
+{
+    public partial struct UniTask
+    {
+        public static YieldAwaitable Yield(PlayerLoopTiming timing = PlayerLoopTiming.Update)
+        {
+            // optimized for single continuation
+            return new YieldAwaitable(timing);
+        }
+
+        public static UniTask Yield(PlayerLoopTiming timing, CancellationToken cancellationToken)
+        {
+            return new UniTask(YieldPromise.Create(timing, cancellationToken, out var token), token);
+        }
+
+        public static UniTask DelayFrame(int delayFrameCount, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            if (delayFrameCount < 0)
+            {
+                throw new ArgumentOutOfRangeException("Delay does not allow minus delayFrameCount. delayFrameCount:" + delayFrameCount);
+            }
+
+            return new UniTask(DelayFramePromise.Create(delayFrameCount, delayTiming, cancellationToken, out var token), token);
+        }
+
+        public static UniTask Delay(int millisecondsDelay, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var delayTimeSpan = TimeSpan.FromMilliseconds(millisecondsDelay);
+            if (delayTimeSpan < TimeSpan.Zero)
+            {
+                throw new ArgumentOutOfRangeException("Delay does not allow minus millisecondsDelay. millisecondsDelay:" + millisecondsDelay);
+            }
+
+            return (ignoreTimeScale)
+                ? new UniTask(DelayIgnoreTimeScalePromise.Create(delayTimeSpan, delayTiming, cancellationToken, out var token), token)
+                : new UniTask(DelayPromise.Create(delayTimeSpan, delayTiming, cancellationToken, out token), token);
+        }
+
+        public static UniTask Delay(TimeSpan delayTimeSpan, bool ignoreTimeScale = false, PlayerLoopTiming delayTiming = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            if (delayTimeSpan < TimeSpan.Zero)
+            {
+                throw new ArgumentOutOfRangeException("Delay does not allow minus delayTimeSpan. delayTimeSpan:" + delayTimeSpan);
+            }
+
+            return (ignoreTimeScale)
+                ? new UniTask(DelayIgnoreTimeScalePromise.Create(delayTimeSpan, delayTiming, cancellationToken, out var token), token)
+                : new UniTask(DelayPromise.Create(delayTimeSpan, delayTiming, cancellationToken, out token), token);
+        }
+
+        sealed class YieldPromise : IUniTaskSource, IPlayerLoopItem, IPromisePoolItem
+        {
+            static readonly PromisePool<YieldPromise> pool = new PromisePool<YieldPromise>();
+
+            CancellationToken cancellationToken;
+            UniTaskCompletionSourceCore<object> core;
+
+            YieldPromise()
+            {
+            }
+
+            public static IUniTaskSource Create(PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                var result = pool.TryRent() ?? new YieldPromise();
+
+                result.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                PlayerLoopHelper.AddAction(timing, result);
+
+                token = result.core.Version;
+                return result;
+            }
+
+            public void GetResult(short token)
+            {
+                try
+                {
+                    TaskTracker.RemoveTracking(this);
+                    core.GetResult(token);
+                }
+                finally
+                {
+                    pool.TryReturn(this);
+                }
+            }
+
+            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;
+                }
+
+                core.TrySetResult(null);
+                return false;
+            }
+
+            public void Reset()
+            {
+                core.Reset();
+                cancellationToken = default;
+            }
+
+            ~YieldPromise()
+            {
+                if (pool.TryReturn(this))
+                {
+                    GC.ReRegisterForFinalize(this);
+                }
+            }
+        }
+
+        sealed class DelayFramePromise : IUniTaskSource, IPlayerLoopItem, IPromisePoolItem
+        {
+            static readonly PromisePool<DelayFramePromise> pool = new PromisePool<DelayFramePromise>();
+
+            int delayFrameCount;
+            CancellationToken cancellationToken;
+
+            int currentFrameCount;
+            UniTaskCompletionSourceCore<object> core;
+
+            DelayFramePromise()
+            {
+            }
+
+            public static IUniTaskSource Create(int delayFrameCount, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                var result = pool.TryRent() ?? new DelayFramePromise();
+
+                result.delayFrameCount = delayFrameCount;
+                result.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                PlayerLoopHelper.AddAction(timing, result);
+
+                token = result.core.Version;
+                return result;
+            }
+
+            public void GetResult(short token)
+            {
+                try
+                {
+                    TaskTracker.RemoveTracking(this);
+                    core.GetResult(token);
+                }
+                finally
+                {
+                    pool.TryReturn(this);
+                }
+            }
+
+            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 (currentFrameCount == delayFrameCount)
+                {
+                    core.TrySetResult(null);
+                    return false;
+                }
+
+                currentFrameCount++;
+                return true;
+            }
+
+            public void Reset()
+            {
+                core.Reset();
+                currentFrameCount = default;
+                delayFrameCount = default;
+                cancellationToken = default;
+            }
+
+            ~DelayFramePromise()
+            {
+                if (pool.TryReturn(this))
+                {
+                    GC.ReRegisterForFinalize(this);
+                }
+            }
+        }
+
+        sealed class DelayPromise : IUniTaskSource, IPlayerLoopItem, IPromisePoolItem
+        {
+            static readonly PromisePool<DelayPromise> pool = new PromisePool<DelayPromise>();
+
+            float delayFrameTimeSpan;
+            float elapsed;
+            CancellationToken cancellationToken;
+
+            UniTaskCompletionSourceCore<object> core;
+
+            DelayPromise()
+            {
+            }
+
+            public static IUniTaskSource Create(TimeSpan delayFrameTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                var result = pool.TryRent() ?? new DelayPromise();
+
+                result.elapsed = 0.0f;
+                result.delayFrameTimeSpan = (float)delayFrameTimeSpan.TotalSeconds;
+                result.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                PlayerLoopHelper.AddAction(timing, result);
+
+                token = result.core.Version;
+                return result;
+            }
+
+            public void GetResult(short token)
+            {
+                try
+                {
+                    TaskTracker.RemoveTracking(this);
+                    core.GetResult(token);
+                }
+                finally
+                {
+                    pool.TryReturn(this);
+                }
+            }
+
+            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;
+                }
+
+                elapsed += Time.deltaTime;
+                if (elapsed >= delayFrameTimeSpan)
+                {
+                    core.TrySetResult(null);
+                    return false;
+                }
+
+                return true;
+            }
+
+            public void Reset()
+            {
+                core.Reset();
+                delayFrameTimeSpan = default;
+                elapsed = default;
+                cancellationToken = default;
+            }
+
+            ~DelayPromise()
+            {
+                if (pool.TryReturn(this))
+                {
+                    GC.ReRegisterForFinalize(this);
+                }
+            }
+        }
+
+        sealed class DelayIgnoreTimeScalePromise : IUniTaskSource, IPlayerLoopItem, IPromisePoolItem
+        {
+            static readonly PromisePool<DelayIgnoreTimeScalePromise> pool = new PromisePool<DelayIgnoreTimeScalePromise>();
+
+            float delayFrameTimeSpan;
+            float elapsed;
+            CancellationToken cancellationToken;
+
+            UniTaskCompletionSourceCore<object> core;
+
+            DelayIgnoreTimeScalePromise()
+            {
+            }
+
+            public static IUniTaskSource Create(TimeSpan delayFrameTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken, out short token)
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return AutoResetUniTaskCompletionSource.CreateFromCanceled(cancellationToken, out token);
+                }
+
+                var result = pool.TryRent() ?? new DelayIgnoreTimeScalePromise();
+
+                result.elapsed = 0.0f;
+                result.delayFrameTimeSpan = (float)delayFrameTimeSpan.TotalSeconds;
+                result.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(result, 3);
+
+                PlayerLoopHelper.AddAction(timing, result);
+
+                token = result.core.Version;
+                return result;
+            }
+
+            public void GetResult(short token)
+            {
+                try
+                {
+                    TaskTracker.RemoveTracking(this);
+                    core.GetResult(token);
+                }
+                finally
+                {
+                    pool.TryReturn(this);
+                }
+            }
+
+            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;
+                }
+
+                elapsed += Time.unscaledDeltaTime;
+                if (elapsed >= delayFrameTimeSpan)
+                {
+                    core.TrySetResult(null);
+                    return false;
+                }
+
+                return true;
+            }
+
+            public void Reset()
+            {
+                core.Reset();
+                delayFrameTimeSpan = default;
+                elapsed = default;
+                cancellationToken = default;
+            }
+
+            ~DelayIgnoreTimeScalePromise()
+            {
+                if (pool.TryReturn(this))
+                {
+                    GC.ReRegisterForFinalize(this);
+                }
+            }
+        }
+    }
+
+    public readonly struct YieldAwaitable
+    {
+        readonly PlayerLoopTiming timing;
+
+        public YieldAwaitable(PlayerLoopTiming timing)
+        {
+            this.timing = timing;
+        }
+
+        public Awaiter GetAwaiter()
+        {
+            return new Awaiter(timing);
+        }
+
+        public UniTask ToUniTask()
+        {
+            return UniTask.Yield(timing, CancellationToken.None);
+        }
+
+        public readonly struct Awaiter : ICriticalNotifyCompletion
+        {
+            readonly PlayerLoopTiming timing;
+
+            public Awaiter(PlayerLoopTiming timing)
+            {
+                this.timing = timing;
+            }
+
+            public bool IsCompleted => false;
+
+            public void GetResult() { }
+
+            public void OnCompleted(Action continuation)
+            {
+                PlayerLoopHelper.AddContinuation(timing, continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                PlayerLoopHelper.AddContinuation(timing, continuation);
+            }
+        }
+    }
+}
+#endif

Assets/Plugins/UniTask/UniTask.Delay.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ecff7972251de0848b2c0fa89bbd3489
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/UniTask.Factory.cs

@@ -0,0 +1,145 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+using System.Threading;
+using UnityEngine.Events;
+
+namespace Cysharp.Threading.Tasks
+{
+    public partial struct UniTask
+    {
+        static readonly UniTask CanceledUniTask = new Func<UniTask>(() =>
+        {
+            var promise = new UniTaskCompletionSource();
+            promise.TrySetCanceled(CancellationToken.None);
+            promise.MarkHandled();
+            return promise.Task;
+        })();
+
+        static class CanceledUniTaskCache<T>
+        {
+            public static readonly UniTask<T> Task;
+
+            static CanceledUniTaskCache()
+            {
+                var promise = new UniTaskCompletionSource<T>();
+                promise.TrySetCanceled(CancellationToken.None);
+                promise.MarkHandled();
+                Task = promise.Task;
+            }
+        }
+
+        public static readonly UniTask CompletedTask = new UniTask();
+
+        public static UniTask FromException(Exception ex)
+        {
+            var promise = new UniTaskCompletionSource();
+            promise.TrySetException(ex);
+            promise.MarkHandled();
+            return promise.Task;
+        }
+
+        public static UniTask<T> FromException<T>(Exception ex)
+        {
+            var promise = new UniTaskCompletionSource<T>();
+            promise.TrySetException(ex);
+            promise.MarkHandled();
+            return promise.Task;
+        }
+
+        public static UniTask<T> FromResult<T>(T value)
+        {
+            return new UniTask<T>(value);
+        }
+
+        public static UniTask FromCanceled(CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken == CancellationToken.None)
+            {
+                return CanceledUniTask;
+            }
+            else
+            {
+                var promise = new UniTaskCompletionSource();
+                promise.TrySetCanceled(cancellationToken);
+                promise.MarkHandled();
+                return promise.Task;
+            }
+        }
+
+        public static UniTask<T> FromCanceled<T>(CancellationToken cancellationToken = default)
+        {
+            if (cancellationToken == CancellationToken.None)
+            {
+                return CanceledUniTaskCache<T>.Task;
+            }
+            else
+            {
+                var promise = new UniTaskCompletionSource<T>();
+                promise.TrySetCanceled(cancellationToken);
+                promise.MarkHandled();
+                return promise.Task;
+            }
+        }
+
+        public static UniTask Create(Func<UniTask> factory)
+        {
+            return factory();
+        }
+
+        public static UniTask<T> Create<T>(Func<UniTask<T>> factory)
+        {
+            return factory();
+        }
+
+        public static AsyncLazy Lazy(Func<UniTask> factory)
+        {
+            return new AsyncLazy(factory);
+        }
+
+        public static AsyncLazy<T> Lazy<T>(Func<UniTask<T>> factory)
+        {
+            return new AsyncLazy<T>(factory);
+        }
+
+        /// <summary>
+        /// helper of create add UniTaskVoid to delegate.
+        /// For example: FooEvent += () => UniTask.Void(async () => { /* */ })
+        /// </summary>
+        public static void Void(Func<UniTask> asyncAction)
+        {
+            asyncAction().Forget();
+        }
+
+        public static Action VoidAction(Func<UniTask> asyncAction)
+        {
+            return () => Void(asyncAction);
+        }
+
+        public static UnityAction VoidUnityAction(Func<UniTask> asyncAction)
+        {
+            return () => Void(asyncAction);
+        }
+
+        /// <summary>
+        /// helper of create add UniTaskVoid to delegate.
+        /// For example: FooEvent += (sender, e) => UniTask.Void(async arg => { /* */ }, (sender, e))
+        /// </summary>
+        public static void Void<T>(Func<T, UniTask> asyncAction, T state)
+        {
+            asyncAction(state).Forget();
+        }
+    }
+
+    internal static class CompletedTasks
+    {
+        public static readonly UniTask<AsyncUnit> AsyncUnit = UniTask.FromResult(Cysharp.Threading.Tasks.AsyncUnit.Default);
+        public static readonly UniTask<bool> True = UniTask.FromResult(true);
+        public static readonly UniTask<bool> False = UniTask.FromResult(false);
+        public static readonly UniTask<int> Zero = UniTask.FromResult(0);
+        public static readonly UniTask<int> MinusOne = UniTask.FromResult(-1);
+        public static readonly UniTask<int> One = UniTask.FromResult(1);
+    }
+}
+#endif

Assets/Plugins/UniTask/UniTask.Factory.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4e12b66d6b9bd7845b04a594cbe386b4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/UniTask/UniTask.Run.cs

@@ -0,0 +1,99 @@
+#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+using System;
+
+namespace Cysharp.Threading.Tasks
+{
+    public partial struct UniTask
+    {
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask Run(Action action, bool configureAwait = true)
+        {
+            await UniTask.SwitchToThreadPool();
+
+            if (configureAwait)
+            {
+                try
+                {
+                    action();
+                }
+                finally
+                {
+                    await UniTask.Yield();
+                }
+            }
+            else
+            {
+                action();
+            }
+        }
+
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask Run(Action<object> action, object state, bool configureAwait = true)
+        {
+            await UniTask.SwitchToThreadPool();
+
+            if (configureAwait)
+            {
+                try
+                {
+                    action(state);
+                }
+                finally
+                {
+                    await UniTask.Yield();
+                }
+            }
+            else
+            {
+                action(state);
+            }
+        }
+
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask<T> Run<T>(Func<T> func, bool configureAwait = true)
+        {
+            await UniTask.SwitchToThreadPool();
+            if (configureAwait)
+            {
+                try
+                {
+                    return func();
+                }
+                finally
+                {
+                    await UniTask.Yield();
+                }
+            }
+            else
+            {
+                return func();
+            }
+        }
+
+        /// <summary>Run action on the threadPool and return to main thread if configureAwait = true.</summary>
+        public static async UniTask<T> Run<T>(Func<object, T> func, object state, bool configureAwait = true)
+        {
+            await UniTask.SwitchToThreadPool();
+
+            if (configureAwait)
+            {
+                try
+                {
+                    return func(state);
+                }
+                finally
+                {
+                    await UniTask.Yield();
+                }
+            }
+            else
+            {
+                return func(state);
+            }
+        }
+    }
+}
+
+#endif