Compare commits

..

324 Commits

Author SHA1 Message Date
neuecc
887db5b281 2.0.24 2020-07-04 06:36:14 +09:00
neuecc
fee5518a82 Improve, Select/Where add UniTaskTracker 2020-07-04 06:29:50 +09:00
neuecc
551128e64c Add UniTaskAsyncEnumerable.Create 2020-07-04 06:29:33 +09:00
neuecc
c65ae8d18e error detail 2020-07-04 06:29:08 +09:00
neuecc
c1f75d9ebd Add UniTask.Never 2020-06-30 04:01:00 +09:00
neuecc
73a5ff6648 r 2020-06-29 03:24:10 +09:00
neuecc
1c264f380e 2.0.23 2020-06-29 03:22:33 +09:00
neuecc
f02bfa0a1e Fix lose exception stacktrace info when task is sync completed 2020-06-29 03:20:13 +09:00
neuecc
9d684006fc test 2020-06-29 03:02:23 +09:00
neuecc
c49f1ed028 r 2020-06-29 01:18:16 +09:00
neuecc
d935b226c0 2.0.22 2020-06-29 01:13:37 +09:00
neuecc
d9e20de8a5 Add UniTaskAsyncEnumerable.SkipUntil, TakeUntil. Fix SkipUntilCanceled behaviour. 2020-06-29 01:10:18 +09:00
neuecc
23997f0f93 SwitchToMainThread, ReturnToMainThread, SwitchToSynchronizationContext, ReturnToSynchronizationContext supports CancellationToken 2020-06-28 20:57:42 +09:00
neuecc
529272d11b more ignore 2020-06-28 18:01:01 +09:00
neuecc
1194c38568 Add AsyncGPUReadbackRequest await support 2020-06-28 17:59:03 +09:00
neuecc
f0d2ee2beb typo 2020-06-26 17:57:27 +09:00
neuecc
68cdda086a async UniTaskVoid Start 2020-06-26 17:53:07 +09:00
neuecc
54ceca6ceb R 2020-06-25 23:03:13 +09:00
neuecc
50bdf7460c 2.0.21 2020-06-25 23:02:40 +09:00
neuecc
c06e45d0bb ToCancellationToken(linkeToken) 2020-06-25 23:02:30 +09:00
neuecc
3ed6e28a00 Removed Timeout(bool ignoreTimeScale), changed to Timeout(DelayType delayType) 2020-06-25 22:35:55 +09:00
neuecc
ab76098895 Removed CancelAfterSlim(bool ignoreTimeScale), changed to CancelAfterSlim(DelayType delayType) 2020-06-25 22:35:35 +09:00
neuecc
0a447e43b0 Add UniTask.ToCancellationToken 2020-06-25 22:34:45 +09:00
neuecc
8df44f2768 Remove UniTask.DelayRealtime, Add UniTask.Delay(DelayType) overload 2020-06-25 22:15:44 +09:00
neuecc
a7ec64d644 more 20 2020-06-24 05:09:00 +09:00
neuecc
868e104d85 2.0.20 2020-06-24 05:04:18 +09:00
neuecc
7ced7f5764 separate external assemblies, add TMP_InputField extensions 2020-06-24 05:04:09 +09:00
neuecc
12b39c6ba1 Add UniTask.DelayRealtime 2020-06-24 01:40:43 +09:00
neuecc
93df9d7693 Prevent -> Preserve in ReadMe 2020-06-21 23:11:47 +09:00
neuecc
3980f314fa Fix UnityWebRequestExtensions obsolete warning in Unity 2020.2 2020-06-19 16:46:30 +09:00
neuecc
c2538da1cd Improve UnityWebRequestError performance 2020-06-19 16:45:55 +09:00
neuecc
5ed943bca2 Add UniTask.Post 2020-06-19 16:42:05 +09:00
neuecc
d6a0563319 ready 2.0.19 2020-06-18 03:39:44 +09:00
neuecc
af82a94b87 Fix TimeoutWithoutException does not suppress exception 2020-06-18 03:30:53 +09:00
neuecc
82219e6111 Fix UniTask.Delay does not run on threadpool thread 2020-06-18 03:28:03 +09:00
neuecc
81f9c55c7f Add UniTask.Run(Func<UniTask>) overload 2020-06-18 03:27:26 +09:00
neuecc
0640f278cc Fix AsyncLazy can not await multiple times when task is not completed 2020-06-18 03:02:01 +09:00
neuecc
769b5c6bab UniTaskCompletionSource can await multiple times(same behaviour as TaskCompletionSource) 2020-06-18 02:34:56 +09:00
neuecc
bdd569e213 fix can not close application in mono build 2020-06-17 21:37:45 +09:00
neuecc
5bfff5bc24 Subscribe ReadMe 2020-06-15 22:46:01 +09:00
neuecc
edf32496e4 re 2020-06-15 15:29:12 +09:00
neuecc
785f5837d1 Merge remote-tracking branch 'origin/master' 2020-06-15 15:28:29 +09:00
neuecc
8c9272bc9f 2.0.18 2020-06-15 15:26:28 +09:00
neuecc
3e00735b3d Add AsUniTaskAsyncEnumerable/AsAsyncEnumerable in .NET Core 2020-06-15 15:23:25 +09:00
neuecc
00a1be8666 await UnityWebRequestAsyncOperation throws UnityWebRequestException when isHttpError or isNetworkError 2020-06-15 15:23:07 +09:00
neuecc
a2783d3c8a yes meta 2020-06-15 12:29:46 +09:00
Yoshifumi Kawai
85d1a8a4a4 Update README.md 2020-06-14 15:44:40 +09:00
neuecc
bbfb8354bb 2.0.17 2020-06-14 15:32:37 +09:00
Yoshifumi Kawai
2f68e47443 Merge pull request #92 from yashihei/fix-cancellation-token
Fixed CancelationToken not being passed correctly
2020-06-14 15:08:37 +09:00
yashihei
89339ffb29 Fixed CancelationToken not being passed correctly 2020-06-14 08:24:25 +09:00
neuecc
0535862fe6 Merge remote-tracking branch 'origin/master' 2020-06-13 18:58:56 +09:00
neuecc
a9e5fd4589 Add UniTaskAsyncEnumerable.Subscribe 2020-06-13 18:58:43 +09:00
Yoshifumi Kawai
a3f3a28ea1 Update README.md 2020-06-12 17:18:31 +09:00
Yoshifumi Kawai
59020df965 Update README.md 2020-06-12 17:18:22 +09:00
Yoshifumi Kawai
ac01be79bf Update README.md 2020-06-12 16:59:14 +09:00
neuecc
de5951f208 lock q 2020-06-12 10:46:29 +09:00
neuecc
ded9a561db 2.0.16 2020-06-12 03:16:06 +09:00
neuecc
a2c18eb343 AsyncReactiveProperty document 2020-06-11 23:50:13 +09:00
neuecc
0b27c3a342 Merge remote-tracking branch 'origin/master' 2020-06-11 23:32:00 +09:00
neuecc
9c86cfb508 Add IDisposable.AddTo(cancellationToken) 2020-06-11 23:31:55 +09:00
Yoshifumi Kawai
7e5e6ed6c2 Update README.md 2020-06-11 20:21:51 +09:00
Yoshifumi Kawai
d081e5f40b Update README.md 2020-06-11 17:48:41 +09:00
neuecc
344ae0738c docs: update TOC 2020-06-11 08:44:42 +00:00
neuecc
1b553f67b0 compare table 2020-06-11 17:44:22 +09:00
neuecc
bf0adad427 test for IL2CPP bug 2020-06-11 17:10:29 +09:00
neuecc
11ca42a527 Merge remote-tracking branch 'origin/master' 2020-06-11 16:43:11 +09:00
neuecc
4898e4c7bf Add (I/ReadOnly)AsyncReactiveProperty.WaitAsync 2020-06-11 16:42:59 +09:00
Yoshifumi Kawai
d494e0b9e3 Merge pull request #88 from guitarrapc/master
chore: stop run build-unity via fork PR
2020-06-11 14:35:12 +09:00
Ikiru Yoshizaki
be26ab249b chore: strict filter 2020-06-10 18:17:53 +09:00
Ikiru Yoshizaki
611d8d5513 chore: filter build-unity to be run on Cysharp only 2020-06-10 18:06:50 +09:00
Yoshifumi Kawai
95c93b7c3d Merge pull request #87 from guitarrapc/master
feat: Android il2cpp support
2020-06-10 17:07:56 +09:00
Ikiru Yoshizaki
1dd0c49eec faet: android il2cpp 2020-06-10 13:06:45 +09:00
neuecc
5d8e0e61ad workaround for IL2CPP bug, back to zero allocation 2020-06-10 11:36:58 +09:00
neuecc
478126e256 v 2020-06-09 15:06:34 +09:00
neuecc
80704e489d Merge branch 'fix-il2cpp' 2020-06-09 14:52:23 +09:00
neuecc
3c0aa03643 if def 2020-06-09 14:52:04 +09:00
neuecc
37cd00d347 2.0.15? 2020-06-09 12:16:28 +09:00
neuecc
859c4d706f logging 2020-06-09 12:00:12 +09:00
neuecc
7289fe6e25 ToCoroutine throws exception when error detected 2020-06-09 11:26:03 +09:00
neuecc
0c33977f5a timer and delay skip current frame 2020-06-09 11:25:45 +09:00
neuecc
4d4466e801 Add UniTask.WaitForFixedUpdate 2020-06-08 02:22:10 +09:00
neuecc
79330d7cdb ReadMe 2020-06-08 01:50:20 +09:00
neuecc
680ce1098b ReadMe 2020-06-08 01:45:57 +09:00
neuecc
2337d705ec WithCancellation uses native timing of asyncOperation 2020-06-08 01:45:41 +09:00
neuecc
d2880a818f Add UniTask.NextFrame, UniTask.WaitForEndOfFrame 2020-06-08 01:44:31 +09:00
neuecc
86ea128bf4 t4gen 2020-06-08 00:30:27 +09:00
neuecc
a66f378622 // for CI 2020-06-07 00:27:33 +09:00
neuecc
265f88584b store application.datapath on initialize #86 2020-06-06 14:21:31 +09:00
neuecc
686394c861 2.0.14 pkg version 2020-06-05 17:16:34 +09:00
neuecc
8bad158ab4 fix ci 2020-06-05 17:05:36 +09:00
neuecc
5e59e7ec86 netstandard2.0 support #84 2020-06-05 16:45:40 +09:00
neuecc
8bb0a48720 workaround for struct enumerator await 2020-06-05 15:08:13 +09:00
neuecc
b4468b4eba improve DOTween Extensions 2020-06-05 12:32:16 +09:00
neuecc
0725bd1b30 Merge remote-tracking branch 'origin/master' 2020-06-05 00:44:16 +09:00
neuecc
ebd80243e0 Fix UniTask.ReturnToCurrentSynchronizationContext 2020-06-05 00:43:54 +09:00
neuecc
f1ac469058 Fix UniTask.Defer 2020-06-05 00:43:03 +09:00
neuecc
2e0b603d25 docs: update TOC 2020-06-04 08:54:24 +00:00
neuecc
1d90a40f66 more ReadMe 2020-06-04 17:53:57 +09:00
Mayuki Sawatari
1bec3f507e Merge pull request #75 from Cysharp/feature/docs
Generate and publish documentation to GitHub Pages
2020-06-04 16:16:03 +09:00
Mayuki Sawatari
1d5ecbb3ab Include sub-directory source codes 2020-06-04 15:46:21 +09:00
Mayuki Sawatari
e1a4aeb9da Update toc.yml 2020-06-04 15:46:21 +09:00
Mayuki Sawatari
43f1bb4d85 Generate and publish documentation to GitHub Pages 2020-06-04 15:46:21 +09:00
Yoshifumi Kawai
8b7a0e9b15 Update README.md 2020-06-04 15:31:42 +09:00
neuecc
da329e19d1 CI more 2020-06-04 15:24:09 +09:00
Yoshifumi Kawai
b8260d4e91 Merge pull request #61 from Cysharp/unitask2
UniTask2
2020-06-04 15:17:19 +09:00
neuecc
345e32aaf0 CI again 2020-06-04 15:14:40 +09:00
neuecc
d7bef8c5b5 setup release 2020-06-04 15:11:51 +09:00
neuecc
b2f82df4d3 fix action 2020-06-04 14:58:11 +09:00
neuecc
83596b3d1f docs: update TOC 2020-06-04 05:53:07 +00:00
neuecc
0022598a1c readme 2020-06-04 14:52:42 +09:00
neuecc
f4294d3752 Task Pool moved from Internal 2020-06-04 14:52:36 +09:00
neuecc
a1444c0b39 refactor DistinctUntilChanged 2020-06-03 02:03:31 +09:00
neuecc
e1d5359d73 refactor Where 2020-06-03 01:18:39 +09:00
neuecc
239bf749b6 refactor UniTaskAsyncEnumerable.Select 2020-06-03 00:50:39 +09:00
neuecc
2bf3b1e172 pj 2020-06-02 23:27:42 +09:00
neuecc
d225de201f gitignore 2020-06-02 23:00:47 +09:00
neuecc
c3b8a3852d UniTask.Linq.asmdef 2020-06-02 23:00:20 +09:00
neuecc
c31dab888e fix UnITaskTracker causes Stackoverflow 2020-06-02 22:49:40 +09:00
neuecc
d4cf59bd2f CI 2020-06-01 14:50:25 +09:00
neuecc
d5edc3acd3 guard for trigger invalid ops 2020-06-01 13:51:37 +09:00
neuecc
130286e8c2 TriggerEvent becomes linkedlist 2020-06-01 13:40:35 +09:00
neuecc
a9baa52309 Add ReturnToMainThread, ReturnToSynchronizationContext, ReturnToCurrentSynchronizationContext 2020-05-31 04:30:03 +09:00
neuecc
3001996298 Q check 2020-05-31 04:28:05 +09:00
neuecc
bfcd18aabb MoveNextRunner -> StateMachineRunner 2020-05-29 14:35:50 +09:00
neuecc
96aa299e7e support version -> unity 2018.4 2020-05-29 14:25:26 +09:00
neuecc
24faa34418 TaskPoolMonitor -> TaskPool 2020-05-29 03:58:22 +09:00
neuecc
21bf08a6b3 replace all promisepool to new taskpool system 2020-05-29 03:43:18 +09:00
neuecc
d5db96b913 rename StackNode to TaskPool 2020-05-29 02:08:11 +09:00
neuecc
a8455af16d Improve pooling mechanism 2020-05-29 01:22:46 +09:00
neuecc
2290b14532 reduce AsyncBuilder heap allocation 2020-05-28 22:20:06 +09:00
neuecc
90c5a6311b check il2cpp generics limitation 2020-05-28 21:18:35 +09:00
neuecc
6e0ad3623b non public 2020-05-27 09:16:46 +09:00
neuecc
005e02a1fa sealed 2020-05-27 07:39:19 +09:00
neuecc
10fb8060fa use PooledDelegate to avoid convert Action to Action<AsyncOperation> allocation 2020-05-27 07:37:16 +09:00
neuecc
35b933730b 2.0.11-rc8 2020-05-25 19:44:57 +09:00
neuecc
7ab9467069 IObservable<T>.ToUniTask parameter order changed from CancellationToken cancellationToken, bool useFirst to bool useFirst, CancellationToken cancellationToken 2020-05-25 19:42:51 +09:00
neuecc
598312ba61 DOTween's WithCancellation remove = default 2020-05-25 19:38:08 +09:00
neuecc
985aa5c43a add allocationchecker in netcore sandbox project 2020-05-25 19:37:11 +09:00
neuecc
10eff95a42 fix: does not work zero-allocation mechanism in release build 2020-05-25 19:36:39 +09:00
neuecc
d27d6d5d9d UniTask.Yield in .NET Core becomes zero allocation 2020-05-25 19:33:54 +09:00
neuecc
b8c109848e UniTaskVoid can not await. 2020-05-25 19:33:11 +09:00
neuecc
8b7f832c0f JobHandle.WaitAsync accepts CancellationToken 2020-05-25 09:58:06 +09:00
neuecc
7cce0f48e5 call webRequest.Abort() on canceled 2020-05-25 09:54:26 +09:00
neuecc
8a56838111 modify cannot await twice message 2020-05-25 01:55:35 +09:00
neuecc
ff15e00003 f 2020-05-24 03:33:25 +09:00
neuecc
f60d2c51fb fix in UnityEditor performance issue 2020-05-24 03:27:05 +09:00
neuecc
6dfb969015 Add ValueTask.AsUniTask only for .NET Core 2020-05-24 01:30:52 +09:00
neuecc
da7e9fc4b3 UniTask marked StructLayout(LayoutKind.Auto) 2020-05-24 01:30:33 +09:00
neuecc
70385c4115 Fix channel's cancellationTokenRegistration does not handle correctly 2020-05-24 00:19:13 +09:00
neuecc
51ba740413 In .NET Core, IUniTaskSource implements IValueTaskSource and implicit, zero overhead conversion 2020-05-24 00:18:39 +09:00
neuecc
f3e3ba8864 fix DOTweenExt's TweenCancelBehaviour.CancelAwait 2020-05-23 02:53:48 +09:00
neuecc
07cf65c1ec lower support is 2019.1 2020-05-23 02:12:19 +09:00
neuecc
eca5b1c096 2.0.10-rc7 2020-05-23 02:11:00 +09:00
neuecc
c74ce14ad1 DoTween -> DOTween 2020-05-23 02:10:18 +09:00
neuecc
f59c56506f Remove ConfigureAwait method from all async object extensions(renamed to ToUniTask). Add WithCancellation method to all async object extensions. Improved performance when async object is done. 2020-05-23 02:07:46 +09:00
neuecc
896eef1ee4 Add DoTween Extension 2020-05-23 01:10:04 +09:00
neuecc
ec0123eec7 rename UniTask.VoidAction -> UniTask.Action, UniTask.VoidUnityAction -> UniTask.UnityAction, there return type Func<UniTask> -> Func<UniTaskVoid> 2020-05-22 21:42:23 +09:00
neuecc
78f56b9b33 OCS 2020-05-22 17:15:36 +09:00
neuecc
1d88ed85bc fix ComibineLatest 2020-05-22 11:08:03 +09:00
neuecc
2b7986da19 2.0.9-rc6 2020-05-22 10:45:16 +09:00
neuecc
c3d22968e1 State rename to AsyncReadOnlyReactiveProperty and removed setter and implicit conversion. 2020-05-22 10:44:41 +09:00
neuecc
0e25122ee2 Add Pairwise 2020-05-22 03:19:54 +09:00
neuecc
4504d84aa8 cl2 2020-05-22 02:34:04 +09:00
neuecc
2b87cadba3 Add CombineLatest 2020-05-22 02:25:36 +09:00
neuecc
21dc83c641 2.0.8-rc5 2020-05-21 02:26:55 +09:00
neuecc
3b593f349c Add UnityEvent<T> and InputField AsyncEventHandler and extensions 2020-05-21 02:26:09 +09:00
neuecc
962c215e3b Fix UniTask.WaitUntilValueChanged does not handle UnityEngine.Object is destroyed correctly 2020-05-21 02:24:12 +09:00
neuecc
42dcfdbcdc Add UniTaskAsyncEnumerable.EveryValueChanged 2020-05-21 02:23:40 +09:00
neuecc
6d7e6ec871 Impl AsyncReactiveProperty.ToString, Add State 2020-05-21 02:22:24 +09:00
neuecc
36d53a3bcb rc4 2020-05-20 11:05:58 +09:00
neuecc
ea9e61c2e1 Add CancellationToken.WaitUntilCanceled 2020-05-20 11:04:59 +09:00
neuecc
a52c26102b guard for ForEachAsync 2020-05-20 10:48:28 +09:00
neuecc
e31c87b8a8 Add IUniTaskAsyncEnumerable.Publish 2020-05-19 15:58:04 +09:00
neuecc
cc165a6897 2.0.6-rc3 2020-05-19 04:14:23 +09:00
neuecc
f99910d802 Add TaskTracker to AsyncLINQ 2020-05-19 04:13:46 +09:00
neuecc
997b0b3710 Merge remote-tracking branch 'origin/unitask2' into unitask2 2020-05-19 03:43:09 +09:00
neuecc
ec7064083a Add TaskTracker to Channel 2020-05-19 03:43:06 +09:00
neuecc
07cccfddd6 docs: update TOC 2020-05-18 18:34:05 +00:00
neuecc
f07527cd06 ECS? 2020-05-19 03:33:44 +09:00
neuecc
7b273c4bd1 Add UniTask.Defer 2020-05-19 03:10:37 +09:00
neuecc
d36e7987b3 Add SkipUntilCanceled, TakeUntilCanceled 2020-05-19 02:41:45 +09:00
neuecc
bbd5686816 Add UniTask.WaitUntilCanceled 2020-05-19 01:35:16 +09:00
neuecc
fb1152d8f4 IAsyncReadOnlyReactiveProperty -> IReadOnlyAsyncReactiveProperty, .Dipose retrurns MoveNext -> false 2020-05-19 01:20:20 +09:00
neuecc
7a306118f5 AsyncTrigger returns MoveNext -> false when destroyed 2020-05-19 01:19:46 +09:00
neuecc
efaf3ee8f5 IAsyncReadOnlyReactiveProperty.WithoutCurrent 2020-05-18 23:36:26 +09:00
neuecc
2e4fe90956 Fix ChannelReader.Completion throws UnobservedException when not touched 2020-05-18 23:33:13 +09:00
neuecc
e33d572104 2.0.5-rc2 2020-05-18 11:33:24 +09:00
neuecc
2b2af9e455 meta 2020-05-18 11:31:23 +09:00
neuecc
d003597662 Changed AsyncReactiveProperty produce current value at first, Add AsyncReactiveProperty.WithoutCurrent 2020-05-18 11:30:49 +09:00
neuecc
ec0a8f5a8b Add IUniTaskAsyncEnumerable.Queue 2020-05-18 11:30:04 +09:00
neuecc
49ba57f20a Fix IUniTaskAsyncEnumerable.Take 2020-05-18 11:29:35 +09:00
neuecc
6f4d1183cc Add BindTo<TSource, TObject>(Action<TObject, TSource> bindAction) 2020-05-18 02:35:13 +09:00
neuecc
dd18c9fff8 Add Channel.CreateSingleConsumerUnbounded 2020-05-18 02:34:29 +09:00
neuecc
21f5f78ff1 Merge remote-tracking branch 'origin/unitask2' into unitask2 2020-05-17 16:51:20 +09:00
neuecc
1729f389db fix ReactiveProperty implements IAsyncReactiveProperty 2020-05-17 16:51:10 +09:00
neuecc
6d37bb7bac docs: update TOC 2020-05-17 07:50:05 +00:00
neuecc
957adfad7a fix Await UniTaskAsyncEnumerable.Timer is not over. #76 2020-05-17 16:49:44 +09:00
neuecc
3ef889e17d no artifact name? 2020-05-17 03:02:55 +09:00
neuecc
c73af7390f removed manifestjson 2020-05-17 02:51:51 +09:00
neuecc
c5b4376486 gh-actions 2020-05-17 02:43:54 +09:00
neuecc
ba65049dd8 2.0.4-rc1 2020-05-17 01:39:56 +09:00
neuecc
ee58aab0a9 Add AsyncReactiveProperty 2020-05-17 01:29:45 +09:00
neuecc
859eaa2278 reduce AsyncTrigger allocation 2020-05-16 23:31:49 +09:00
neuecc
79f770e687 Improve Stacktrace Part2 2020-05-13 11:36:33 +09:00
neuecc
8ff4de67a1 improving stacktrace 2020-05-13 05:49:48 +09:00
neuecc
6a7a6fde5c changed AsyncEnumerable.Timer reset timing 2020-05-12 16:32:10 +09:00
neuecc
6a5e259006 fix 2020-05-12 16:09:34 +09:00
neuecc
f6622ad29c StartAsyncCoroutine returns UniTask 2020-05-12 15:55:06 +09:00
neuecc
3de29a181d fixed project structure 2020-05-12 15:44:53 +09:00
neuecc
090cacece5 Add EveryUpdate, Time, Interval, TimerFrame, IntervalFrame 2020-05-12 15:36:42 +09:00
neuecc
354fd65d58 redesigned asyncenumerable ugui and monobehaviourmessagetrigger 2020-05-12 14:29:21 +09:00
neuecc
d3538bdc8f TriggerAsyncEnumerable 2020-05-12 13:15:26 +09:00
neuecc
bd6906792d UnityAsyncEventHandler as IUniTaskAsyncEnumerable 2020-05-12 11:51:50 +09:00
Yoshifumi Kawai
7fc6c6bd36 Merge pull request #73 from Cysharp/async-enumerable
UniTask LINQ
2020-05-12 03:49:01 +09:00
neuecc
c23b9ca480 move to underunity 2020-05-12 03:48:32 +09:00
neuecc
cda59ba9c2 Do 2020-05-12 03:41:53 +09:00
neuecc
61a3744fdd Buffer 2020-05-12 03:33:11 +09:00
neuecc
72efadd0a2 DistinctUntilChanged 2020-05-12 03:01:05 +09:00
neuecc
57c414a6e0 DistinctSelector 2020-05-12 02:45:12 +09:00
neuecc
85dc70a3ab OrderBy 2020-05-12 02:21:06 +09:00
neuecc
7298686d5a Join, GroupBy, GroupJoin 2020-05-12 00:38:06 +09:00
neuecc
418586fbfb GroupBy 2020-05-11 23:17:33 +09:00
neuecc
12c507574e Join 2020-05-11 17:33:41 +09:00
neuecc
b20b37e7a5 Distinct, Except, Intersect, Union 2020-05-11 15:53:27 +09:00
neuecc
8ef7a66081 TakeLast 2020-05-11 14:01:23 +09:00
neuecc
a5f47d4095 SkipLast 2020-05-11 12:38:32 +09:00
neuecc
1316328766 Skip, Take, TakeWhile, SkipWhile 2020-05-11 12:02:02 +09:00
neuecc
c0da316cb4 zip 2020-05-11 02:29:23 +09:00
neuecc
4d13523df7 SelectMany 2020-05-11 02:01:49 +09:00
neuecc
16c527fa89 try selectmany 2020-05-11 00:27:57 +09:00
neuecc
5db5beab29 Reverse 2020-05-10 23:26:25 +09:00
neuecc
3f082f1923 defaultifempty 2020-05-10 22:52:12 +09:00
neuecc
93dd82e3d4 exception testing 2020-05-10 22:44:40 +09:00
neuecc
af6dbd8868 append prepend concat 2020-05-10 03:50:29 +09:00
neuecc
716decd199 ToDict, ToLookup, ToList, TOHashSet, ToObservable 2020-05-10 02:39:13 +09:00
neuecc
f37cd703a9 Aggregate and ForEach 2020-05-10 00:33:46 +09:00
neuecc
31b788a2c9 All, ANy, Contains, SequeuceEqual 2020-05-10 00:07:51 +09:00
neuecc
e93bcbf564 Count, LongCount 2020-05-09 23:33:27 +09:00
neuecc
aa8cb80866 First, Last, Single, ElementAt 2020-05-09 23:22:51 +09:00
neuecc
dd6a8da96f generics MinMax and tests 2020-05-09 22:06:51 +09:00
neuecc
d4511c0f67 Average, MinMax, and others 2020-05-09 15:33:46 +09:00
neuecc
c16433e0fe Never 2020-05-08 15:16:43 +09:00
neuecc
ed0990e402 generator and tests 2020-05-08 12:08:15 +09:00
neuecc
856a049dd0 WithCancellation 2020-05-08 03:48:46 +09:00
neuecc
61b798b6e9 start to implements async linq 2020-05-08 03:23:14 +09:00
neuecc
be45066773 add 2020-05-07 15:17:29 +09:00
neuecc
5d0d29dffd preview3 2020-05-07 11:28:14 +09:00
neuecc
be539fdb10 fix WhenAll,WhenAny 0-length 2020-05-07 11:27:27 +09:00
neuecc
66fa203f7c improv package exporter 2020-05-07 07:38:41 +09:00
neuecc
a78dc55875 preview2 2020-05-07 07:29:31 +09:00
neuecc
84f4d8007d implicit operator UniTask<T> -> UniTask 2020-05-07 07:28:35 +09:00
neuecc
6be955816b Improve AsyncTrigger performance 2020-05-07 07:18:51 +09:00
neuecc
ebe3065c34 delete unitypackage 2020-05-06 03:38:03 +09:00
neuecc
5f90807cb7 + 2020-05-06 02:54:52 +09:00
neuecc
81d83c17c3 Merge branch 'master' into unitask2 2020-05-06 02:51:46 +09:00
neuecc
4e9d268d1c d 2020-05-06 02:50:30 +09:00
neuecc
6c1b590fd8 export 2020-05-06 02:48:29 +09:00
neuecc
32a4e84513 def 2020-05-06 01:17:37 +09:00
neuecc
7f61f85bc7 Addressable support 2020-05-06 00:51:21 +09:00
neuecc
f0d745924a exception choice 2020-05-05 22:51:19 +09:00
neuecc
51f4003bc5 ObjectIdForDebugger 2020-05-05 21:34:11 +09:00
neuecc
b9b2925e8d DotNetCore Version 2020-05-05 21:05:32 +09:00
neuecc
7cb0b17e6a move root to src/UniTask 2020-05-05 20:04:00 +09:00
neuecc
d565f39dde renaming namspeac to Cysharp.Threading.Tasks and move to under Plugins/UniTask 2020-05-05 19:46:43 +09:00
neuecc
a26a806b0f test all passed 2020-05-05 18:12:52 +09:00
neuecc
eb379903b8 some fix 2020-05-05 05:29:52 +09:00
neuecc
6e80295ec7 add PlayerLoopTiming.Last*** 2020-05-05 05:22:49 +09:00
neuecc
75f0bd26e7 ToAsyncLazy 2020-05-05 04:17:08 +09:00
neuecc
b8d1a09224 complete implementation(triggers and etc...) 2020-05-05 04:08:53 +09:00
neuecc
7bc9ef90f1 complete except trigger 2020-05-04 01:59:22 +09:00
neuecc
28e1fa98c9 1.3.1 2020-04-26 21:50:29 +09:00
neuecc
9f7b897837 Add ObjectIdForDebugger to allow IDE stepin debug, #66, #41 2020-04-26 21:49:07 +09:00
neuecc
f28743f7f6 more working 2020-04-26 02:38:16 +09:00
Yoshifumi Kawai
341953b441 Merge pull request #65 from vc-kusuha/fix_Timeout
Fix timeoutTask continues to remain.
2020-04-24 14:57:05 +09:00
くすは
623936c7b8 Fix timeoutTask continues to remain. 2020-04-24 12:32:58 +09:00
neuecc
3654a9e2f9 WhenAll and WhenAny 2020-04-21 13:36:23 +09:00
Yoshifumi Kawai
082f3e7335 more more 2020-04-20 08:35:06 +09:00
Yoshifumi Kawai
fbec6e9a58 check playerloop 2020-04-19 03:38:30 +09:00
Yoshifumi Kawai
ef248e2e0a remove legacy UniTask(occurs many compile error) 2020-04-19 03:24:53 +09:00
Yoshifumi Kawai
86fa934510 diagnosticsext move to internal 2020-04-19 03:00:47 +09:00
Yoshifumi Kawai
ca58784c4d complete delay and factory 2020-04-19 02:55:44 +09:00
Yoshifumi Kawai
11bc28b33f Update config.yml 2020-04-18 22:17:20 +09:00
Yoshifumi Kawai
b2d3423a33 T | IUniTaskSource 2020-04-18 22:11:40 +09:00
Yoshifumi Kawai
2ccaf0a03b complete infrastructure 2020-04-18 05:07:59 +09:00
Yoshifumi Kawai
b4ec35aadd Update config.yml 2020-04-17 11:31:27 +09:00
Yoshifumi Kawai
6c64205292 add readme 2020-04-17 11:15:48 +09:00
Yoshifumi Kawai
232e2eb1f2 add readme 2020-04-17 11:15:15 +09:00
Yoshifumi Kawai
34b065520f add managed dlls 2020-04-16 21:36:22 +09:00
Yoshifumi Kawai
e6734478c5 r 2020-04-16 21:08:56 +09:00
Yoshifumi Kawai
d5f607204b CI2 2020-04-16 20:55:27 +09:00
Yoshifumi Kawai
676aba7cce 1.3.0 2020-04-16 20:50:35 +09:00
Yoshifumi Kawai
745de32006 GetCancellationTokenOnDestroy is moved to UnIRx.Async namespace 2020-04-16 20:47:23 +09:00
Yoshifumi Kawai
a0ef75e797 Merge remote-tracking branch 'origin/master' 2020-04-16 20:37:26 +09:00
Yoshifumi Kawai
dda6cbd679 2019.3.9f1 2020-04-16 20:37:07 +09:00
Yoshifumi Kawai
141b447b30 Merge pull request #38 from BattlefieldNoob/master
Fix #37 and add possibility to use UniTasks in Edit Mode
2020-04-16 20:35:27 +09:00
Yoshifumi Kawai
8e7a89eff7 Add UPM Package document 2020-04-16 20:26:57 +09:00
Yoshifumi Kawai
7848f878d7 +meta 2020-04-16 20:19:50 +09:00
Yoshifumi Kawai
c3a02ffbe6 move path 2020-04-16 19:29:41 +09:00
Yoshifumi Kawai
d509317ed2 trial to add package.json 2020-04-16 19:23:36 +09:00
Yoshifumi Kawai
74738ab13e disable warning AsyncMethodBuilderAttribute conflict #53 2020-04-16 12:28:14 +09:00
Yoshifumi Kawai
de3d491375 Merge pull request #52 from Elringus/feature/support-disable-domain-reload
Support disable domain reload (fast enter play mode)
2020-04-15 21:30:22 +09:00
Yoshifumi Kawai
139f5f7914 more CI settings to release automatically 2020-04-15 15:29:29 +09:00
Yoshifumi Kawai
5e2a4934dd Merge remote-tracking branch 'origin/master' 2020-04-15 15:23:26 +09:00
Yoshifumi Kawai
4ef15f3a14 test streamingassets 2020-04-15 15:23:23 +09:00
Yoshifumi Kawai
6d56f8d2bb Merge pull request #46 from NewbieGameCoder/master
Add ToUniTask for AssetBundleCreateRequest.
2020-04-15 15:21:09 +09:00
Yoshifumi Kawai
6e441a2d14 Merge pull request #44 from vc-kusuha/fix_typo
Fix typo
2020-04-15 14:40:01 +09:00
neuecc
66ba4b9986 Improve document 2020-03-16 23:36:46 +09:00
Antonio
7e26573abb updated to unity 2019.3.2f1, fix missing UNITY_EDITOR preprocessor 2020-02-27 19:14:02 +01:00
Artyom Sovetnikov
9db6482f0a fix typo 2020-02-18 17:20:13 +03:00
Artyom Sovetnikov
9c257e44f0 fix formatting 2020-02-18 17:19:10 +03:00
Artyom Sovetnikov
ecd678117e support disable domain reload
When domain reload is disabled, re-initialization is required when entering play mode; otherwise, pending tasks will leak between play mode sessions.
2020-02-18 17:15:59 +03:00
NewbieGameCoder
ebce2e922d Add ToUniTask for AssetBundleCreateRequest. 2019-11-16 18:44:01 +08:00
くすは
e67562b823 Fix typo
OnDestory -> OnDestroy
2019-10-29 22:31:25 +09:00
Antonio
d639283f59 Add comments 2019-09-21 19:11:07 +02:00
Antonio
ecf6c1fba5 Fixed edit mode, clear continuations and runners on run mode change, edit mode unit tests 2019-09-21 19:11:07 +02:00
Yoshifumi Kawai
50ba93f951 Merge pull request #31 from JimmyLoveSiren/master
Fix #30 and add unit test
2019-09-20 20:55:35 +09:00
Yoshifumi Kawai
d6a7dd9fc5 Merge pull request #24 from yKimisaki/feature/ToUniTaskForAssetBundleResquest
Add ToUniTask for AssetBundleRequest.
2019-09-20 20:49:45 +09:00
Yoshifumi Kawai
1a2dfd1537 Merge pull request #32 from TORISOUP/implements_eventsystem_interfaces
Implements EventSystem interfaces.
2019-08-16 11:53:32 +09:00
TORISOUP
08913104a9 Implements EventSystem interfaces. 2019-08-13 23:33:00 +09:00
Js
85eeeb3dd5 UnitTest for UniTask.ToObservable() 2019-08-02 13:58:29 +09:00
Js
47b701eed0 fix #30 OnCompleted won't be called on UniTask.ToObservable()
when UniTask.IsCompleted == true
2019-08-02 13:57:19 +09:00
Yoshifumi Kawai
10ba7bcfde Merge pull request #28 from rarudo/fix/compile_error
Fixed compile error in some platform
2019-07-25 16:45:54 +09:00
Shunta Imai
89d7e7c5fb Fixed compile error in some platform 2019-07-24 15:49:53 +09:00
Yoshitaka Kimisaki
f7c95bcabd Add ToUniTask for AssetBundleRequest. 2019-07-05 14:41:42 +09:00
585 changed files with 82112 additions and 13014 deletions

View File

@@ -1,84 +0,0 @@
version: 2.1
executors:
unity:
# https://hub.docker.com/r/gableroux/unity3d/tags
parameters:
version: {type: string}
docker:
- image: gableroux/unity3d:<< parameters.version >>
commands:
unity_activate:
parameters:
unity_version: {type: string}
unity_license: {type: string}
steps:
# get activation file, if fail to activate unity, use this key and activate from https://license.unity3d.com/manual
- run: apt update && apt install libunwind8 -y
- run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -logFile -createManualActivationFile || exit 0
- run: cat Unity_v<< parameters.unity_version >>.alf
# get from UNITY_LICENSE envvar(base64 encoded(cat foo.ulf | base64 )), this file is generated from above manual activation
- run: echo << parameters.unity_license >> | base64 -di >> .circleci/Unity.ulf
- run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -manualLicenseFile .circleci/Unity.ulf || exit 0
jobs:
build-and-test:
parameters:
unity_version: {type: string}
unity_license: {type: string}
executor:
name: unity
version: << parameters.unity_version >>
steps:
- checkout
- unity_activate:
unity_version: << parameters.unity_version >>
unity_license: << parameters.unity_license >>
- run:
name: Build Linux(Mono)
command: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod UnitTestBuilder.BuildUnitTest /headless /ScriptBackend Mono2x /BuildTarget StandaloneLinux64
working_directory: .
# TODO:check unity version and packages...
# - run: ./bin/UnitTest/StandaloneLinux64_Mono2x/test
build-and-create-package:
parameters:
unity_version: {type: string}
unity_license: {type: string}
executor:
name: unity
version: << parameters.unity_version >>
steps:
- checkout
- unity_activate:
unity_version: << parameters.unity_version >>
unity_license: << parameters.unity_license >>
- run:
name: Export unitypackage
command: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
working_directory: .
- store_artifacts:
path: ./UniRx.Async.unitypackage
destination: /UniRx.Async.unitypackage
workflows:
version: 2
build-unity:
jobs:
# does not exists yet.
# - build-and-test:
# unity_version: 2019.3.0a2
# unity_license: ${UNITY_LICENSE_2019_3}
# - build-and-test:
# unity_version: 2019.2.0b2
# unity_license: ${UNITY_LICENSE_2019_2}
- build-and-create-package:
unity_version: 2019.1.2f1
unity_license: ${UNITY_LICENSE_2019_1}
- build-and-test:
unity_version: 2019.1.2f1
unity_license: ${UNITY_LICENSE_2019_1}
# test asmdef will not found.
# - build-and-test:
# unity_version: 2018.4.0f1
# unity_license: ${UNITY_LICENSE_2018_4}
# # UniTask minimum support version is 2018.3(C# 7.x)
# - build-and-test:
# unity_version: 2018.3.12f1
# unity_license: ${UNITY_LICENSE_2018_3}

74
.github/workflows/build-debug.yml vendored Normal file
View File

@@ -0,0 +1,74 @@
name: Build-Debug
on:
push:
branches:
- "**"
tags:
- "!*" # not a tag push
pull_request:
types:
- opened
- synchronize
jobs:
build-dotnet:
runs-on: ubuntu-latest
env:
DOTNET_CLI_TELEMETRY_OPTOUT: 1
DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
NUGET_XMLDOC_MODE: skip
steps:
- uses: actions/checkout@v2
- uses: actions/setup-dotnet@v1
with:
dotnet-version: 3.1.101
- run: dotnet test -c Debug ./src/UniTask.NetCoreTests/UniTask.NetCoreTests.csproj
build-unity:
if: "(github.event == 'push' && github.repository_owner == 'Cysharp') || startsWith(github.event.pull_request.head.label, 'Cysharp:')"
strategy:
matrix:
unity: ["2019.3.9f1", "2020.1.0b5"]
include:
- unity: 2019.3.9f1
license: UNITY_2019_3
- unity: 2020.1.0b5
license: UNITY_2020_1
runs-on: ubuntu-latest
container:
# with linux-il2cpp. image from https://hub.docker.com/r/gableroux/unity3d/tags
image: gableroux/unity3d:${{ matrix.unity }}-linux-il2cpp
steps:
- run: apt update && apt install git -y
- uses: actions/checkout@v2
# create unity activation file and store to artifacts.
- run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -logFile -createManualActivationFile || exit 0
- uses: actions/upload-artifact@v1
with:
name: Unity_v${{ matrix.unity }}.alf
path: ./Unity_v${{ matrix.unity }}.alf
# activate Unity from manual license file(ulf)
- run: echo -n "$UNITY_LICENSE" >> .Unity.ulf
env:
UNITY_LICENSE: ${{ secrets[matrix.license] }}
- name: Activate Unity, always returns a success. But if a subsequent run fails, the activation may have failed(if succeeded, shows `Next license update check is after` and not shows other message(like GUID != GUID). If fails not). In that case, upload the artifact's .alf file to https://license.unity3d.com/manual to get the .ulf file and set it to secrets.
run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -manualLicenseFile .Unity.ulf || exit 0
# Execute scripts: RuntimeUnitTestToolkit
- name: Build UnitTest(Linux64, mono)
run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod UnitTestBuilder.BuildUnitTest /headless /ScriptBackend mono /BuildTarget StandaloneLinux64
working-directory: src/UniTask
- name: Execute UnitTest
run: ./src/UniTask/bin/UnitTest/StandaloneLinux64_Mono2x/test
# Execute scripts: Export Package
- name: Export unitypackage
run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
working-directory: src/UniTask
# Store artifacts.
- uses: actions/upload-artifact@v2
with:
name: UniTask.unitypackage.zip
path: ./src/UniTask/*.unitypackage

31
.github/workflows/build-docs.yml vendored Normal file
View File

@@ -0,0 +1,31 @@
name: build-docs
on:
push:
branches:
- master
- feature/docs
jobs:
run-docfx:
if: "!(contains(github.event.head_commit.message, '[skip ci]') || contains(github.event.head_commit.message, '[ci skip]'))"
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- uses: actions/checkout@v2
with:
repository: Cysharp/DocfxTemplate
path: docs/_DocfxTemplate
- uses: Kirbyrawr/docfx-action@master
name: Docfx metadata
with:
args: metadata docs/docfx.json
- uses: Kirbyrawr/docfx-action@master
name: Docfx build
with:
args: build docs/docfx.json
- name: Publish to GitHub Pages
uses: peaceiris/actions-gh-pages@v3
with:
github_token: ${{ secrets.GITHUB_TOKEN }}
publish_dir: docs/_site

105
.github/workflows/build-release.yml vendored Normal file
View File

@@ -0,0 +1,105 @@
name: Build-Release
on:
push:
tags:
- "[0-9]+.[0-9]+.[0-9]+*"
jobs:
build-dotnet:
runs-on: ubuntu-latest
env:
DOTNET_CLI_TELEMETRY_OPTOUT: 1
DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
NUGET_XMLDOC_MODE: skip
steps:
- uses: actions/checkout@v2
- uses: actions/setup-dotnet@v1
with:
dotnet-version: 3.1.101
# set release tag(*.*.*) to env.GIT_TAG
- run: echo ::set-env name=GIT_TAG::${GITHUB_REF#refs/tags/}
# build and pack
- run: dotnet build -c Release -p:Version=${{ env.GIT_TAG }}
- run: dotnet test -c Release --no-build
- run: dotnet pack ./src/UniTask.NetCore/UniTask.NetCore.csproj -c Release --no-build -p:Version=${{ env.GIT_TAG }}
# Store artifacts.
- uses: actions/upload-artifact@v1
with:
name: nuget
path: ./src/UniTask.NetCore/bin/Release/UniTask.${{ env.GIT_TAG }}.nupkg
build-unity:
strategy:
matrix:
unity: ['2019.3.9f1']
include:
- unity: 2019.3.9f1
license: UNITY_2019_3
runs-on: ubuntu-latest
container:
# with linux-il2cpp. image from https://hub.docker.com/r/gableroux/unity3d/tags
image: gableroux/unity3d:${{ matrix.unity }}-linux-il2cpp
steps:
- run: apt update && apt install git -y
- uses: actions/checkout@v2
- run: echo -n "$UNITY_LICENSE" >> .Unity.ulf
env:
UNITY_LICENSE: ${{ secrets[matrix.license] }}
- run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -manualLicenseFile .Unity.ulf || exit 0
# set release tag(*.*.*) to env.GIT_TAG
- run: echo ::set-env name=GIT_TAG::${GITHUB_REF#refs/tags/}
# Execute scripts: Export Package
- name: Export unitypackage
run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
working-directory: src/UniTask
# Store artifacts.
- uses: actions/upload-artifact@v2
with:
name: UniTask.${{ env.GIT_TAG }}.unitypackage
path: ./src/UniTask/UniTask.${{ env.GIT_TAG }}.unitypackage
create-release:
needs: [build-dotnet, build-unity]
runs-on: ubuntu-latest
env:
DOTNET_CLI_TELEMETRY_OPTOUT: 1
DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
NUGET_XMLDOC_MODE: skip
steps:
# setup dotnet for nuget push
- uses: actions/setup-dotnet@v1
with:
dotnet-version: 3.1.101
# set release tag(*.*.*) to env.GIT_TAG
- run: echo ::set-env name=GIT_TAG::${GITHUB_REF#refs/tags/}
# Create Releases
- uses: actions/create-release@v1
id: create_release
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
tag_name: ${{ github.ref }}
release_name: Ver.${{ github.ref }}
# Download(All) Artifacts to current directory
- uses: actions/download-artifact@v2-preview
# Upload to NuGet
- run: dotnet nuget push "./nuget/*.nupkg" -s https://www.nuget.org/api/v2/package -k ${{ secrets.NUGET_KEY }}
# Upload to Releases(unitypackage)
- uses: actions/upload-release-asset@v1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
upload_url: ${{ steps.create_release.outputs.upload_url }}
asset_path: ./UniTask.${{ env.GIT_TAG }}.unitypackage/UniTask.${{ env.GIT_TAG }}.unitypackage
asset_name: UniTask.${{ env.GIT_TAG }}.unitypackage
asset_content_type: application/octet-stream

15
.github/workflows/toc.yml vendored Normal file
View File

@@ -0,0 +1,15 @@
name: TOC Generator
on:
push:
paths:
- 'README.md'
jobs:
generateTOC:
name: TOC Generator
runs-on: ubuntu-latest
steps:
- uses: technote-space/toc-generator@v2.4.0
with:
TOC_TITLE: "## Table of Contents"

60
.gitignore vendored
View File

@@ -145,3 +145,63 @@ RuntimeUnitTestToolkit\.csproj
Assembly-CSharp-Editor\.csproj
UniRx\.Async\.unitypackage
UniRx.Async.Tests.Editor.csproj
src/UniTask/UniTask.csproj
src/UniTask/UniTask.Editor.csproj
src/UniTask/UniTask.Tests.csproj
src/UniTask/UniTask.Tests.Editor.csproj
src/UniTask/UniTask.*.unitypackage
src/UniTask/UniTask.Linq.csproj
src/UniTask/DOTween.Modules.csproj
src/UniTask/Unity.Addressables.csproj
src/UniTask/Unity.Addressables.Editor.csproj
src/UniTask/Unity.Analytics.DataPrivacy.csproj
src/UniTask/Unity.Recorder.csproj
src/UniTask/Unity.Recorder.Editor.csproj
src/UniTask/Unity.ResourceManager.csproj
src/UniTask/Unity.Rider.Editor.csproj
src/UniTask/Unity.ScriptableBuildPipeline.csproj
src/UniTask/Unity.ScriptableBuildPipeline.Editor.csproj
src/UniTask/Unity.TextMeshPro.csproj
src/UniTask/Unity.TextMeshPro.Editor.csproj
src/UniTask/Unity.Timeline.csproj
src/UniTask/Unity.Timeline.Editor.csproj
src/UniTask/Unity.VisualStudio.Editor.csproj
src/UniTask/Unity.VSCode.Editor.csproj
src/UniTask/UnityEditor.CacheServer.csproj
src/UniTask/UnityEditor.TestRunner.csproj
src/UniTask/UnityEditor.UI.csproj
src/UniTask/UnityEngine.Advertisements.csproj
src/UniTask/UnityEngine.Monetization.csproj
src/UniTask/UnityEngine.TestRunner.csproj
src/UniTask/UnityEngine.UI.csproj

View File

@@ -1,35 +0,0 @@
#if UNITY_EDITOR
using System;
using System.IO;
using System.Linq;
using UnityEditor;
using UnityEngine;
public static class PackageExporter
{
[MenuItem("Tools/Export Unitypackage")]
public static void Export()
{
// configure
var root = "UniRx.Async";
var exportPath = "./UniRx.Async.unitypackage";
var path = Path.Combine(Application.dataPath, root);
var assets = Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories)
.Where(x => Path.GetExtension(x) == ".cs" || Path.GetExtension(x) == ".asmdef" || Path.GetExtension(x) == ".json")
.Select(x => "Assets" + x.Replace(Application.dataPath, "").Replace(@"\", "/"))
.ToArray();
UnityEngine.Debug.Log("Export below files" + Environment.NewLine + string.Join(Environment.NewLine, assets));
AssetDatabase.ExportPackage(
assets,
exportPath,
ExportPackageOptions.Default);
UnityEngine.Debug.Log("Export complete: " + Path.GetFullPath(exportPath));
}
}
#endif

View File

@@ -1,450 +0,0 @@
using NUnit.Framework;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.TestTools;
using UnityEngine.UI;
namespace RuntimeUnitTestToolkit
{
public class UnitTestRunner : MonoBehaviour
{
// object is IEnumerator or Func<IEnumerator>
Dictionary<string, List<KeyValuePair<string, object>>> tests = new Dictionary<string, List<KeyValuePair<string, object>>>();
List<Pair> additionalActionsOnFirst = new List<Pair>();
public Button clearButton;
public RectTransform list;
public Scrollbar listScrollBar;
public Text logText;
public Scrollbar logScrollBar;
readonly Color passColor = new Color(0f, 1f, 0f, 1f); // green
readonly Color failColor = new Color(1f, 0f, 0f, 1f); // red
readonly Color normalColor = new Color(1f, 1f, 1f, 1f); // white
bool allTestGreen = true;
void Start()
{
try
{
UnityEngine.Application.logMessageReceived += (a, b, c) =>
{
logText.text += "[" + c + "]" + a + "\n";
};
// register all test types
foreach (var item in GetTestTargetTypes())
{
RegisterAllMethods(item);
}
var executeAll = new List<Func<Coroutine>>();
foreach (var ___item in tests)
{
var actionList = ___item; // be careful, capture in lambda
executeAll.Add(() => StartCoroutine(RunTestInCoroutine(actionList)));
Add(actionList.Key, () => StartCoroutine(RunTestInCoroutine(actionList)));
}
var executeAllButton = Add("Run All Tests", () => StartCoroutine(ExecuteAllInCoroutine(executeAll)));
clearButton.gameObject.GetComponent<Image>().color = new Color(170 / 255f, 170 / 255f, 170 / 255f, 1);
executeAllButton.gameObject.GetComponent<Image>().color = new Color(250 / 255f, 150 / 255f, 150 / 255f, 1);
executeAllButton.transform.SetSiblingIndex(1);
additionalActionsOnFirst.Reverse();
foreach (var item in additionalActionsOnFirst)
{
var newButton = GameObject.Instantiate(clearButton);
newButton.name = item.Name;
newButton.onClick.RemoveAllListeners();
newButton.GetComponentInChildren<Text>().text = item.Name;
newButton.onClick.AddListener(item.Action);
newButton.transform.SetParent(list);
newButton.transform.SetSiblingIndex(1);
}
clearButton.onClick.AddListener(() =>
{
logText.text = "";
foreach (var btn in list.GetComponentsInChildren<Button>())
{
btn.interactable = true;
btn.GetComponent<Image>().color = normalColor;
}
executeAllButton.gameObject.GetComponent<Image>().color = new Color(250 / 255f, 150 / 255f, 150 / 255f, 1);
});
listScrollBar.value = 1;
logScrollBar.value = 1;
if (Application.isBatchMode)
{
// run immediately in player
StartCoroutine(ExecuteAllInCoroutine(executeAll));
}
}
catch (Exception ex)
{
if (Application.isBatchMode)
{
// when failed(can not start runner), quit immediately.
WriteToConsole(ex.ToString());
Application.Quit(1);
}
else
{
throw;
}
}
}
Button Add(string title, UnityAction test)
{
var newButton = GameObject.Instantiate(clearButton);
newButton.name = title;
newButton.onClick.RemoveAllListeners();
newButton.GetComponentInChildren<Text>().text = title;
newButton.onClick.AddListener(test);
newButton.transform.SetParent(list);
return newButton;
}
static IEnumerable<Type> GetTestTargetTypes()
{
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
var n = assembly.FullName;
if (n.StartsWith("UnityEngine")) continue;
if (n.StartsWith("mscorlib")) continue;
if (n.StartsWith("System")) continue;
foreach (var item in assembly.GetTypes())
{
foreach (var method in item.GetMethods())
{
var t1 = method.GetCustomAttribute<TestAttribute>(true);
if (t1 != null)
{
yield return item;
break;
}
var t2 = method.GetCustomAttribute<UnityTestAttribute>(true);
if (t2 != null)
{
yield return item;
break;
}
}
}
}
}
public void AddTest(string group, string title, Action test)
{
List<KeyValuePair<string, object>> list;
if (!tests.TryGetValue(group, out list))
{
list = new List<KeyValuePair<string, object>>();
tests[group] = list;
}
list.Add(new KeyValuePair<string, object>(title, test));
}
public void AddAsyncTest(string group, string title, Func<IEnumerator> asyncTestCoroutine)
{
List<KeyValuePair<string, object>> list;
if (!tests.TryGetValue(group, out list))
{
list = new List<KeyValuePair<string, object>>();
tests[group] = list;
}
list.Add(new KeyValuePair<string, object>(title, asyncTestCoroutine));
}
public void AddCutomAction(string name, UnityAction action)
{
additionalActionsOnFirst.Add(new Pair { Name = name, Action = action });
}
public void RegisterAllMethods<T>()
where T : new()
{
RegisterAllMethods(typeof(T));
}
public void RegisterAllMethods(Type testType)
{
try
{
var test = Activator.CreateInstance(testType);
var methods = testType.GetMethods(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
foreach (var item in methods)
{
try
{
var iteratorTest = item.GetCustomAttribute<UnityEngine.TestTools.UnityTestAttribute>(true);
if (iteratorTest != null)
{
if (item.GetParameters().Length == 0 && item.ReturnType == typeof(IEnumerator))
{
var factory = (Func<IEnumerator>)Delegate.CreateDelegate(typeof(Func<IEnumerator>), test, item);
AddAsyncTest(factory.Target.GetType().Name, factory.Method.Name, factory);
}
else
{
UnityEngine.Debug.Log(testType.Name + "." + item.Name + " currently does not supported in RuntumeUnitTestToolkit(multiple parameter or return type is invalid).");
}
}
var standardTest = item.GetCustomAttribute<NUnit.Framework.TestAttribute>(true);
if (standardTest != null)
{
if (item.GetParameters().Length == 0 && item.ReturnType == typeof(void))
{
var invoke = (Action)Delegate.CreateDelegate(typeof(Action), test, item);
AddTest(invoke.Target.GetType().Name, invoke.Method.Name, invoke);
}
else
{
UnityEngine.Debug.Log(testType.Name + "." + item.Name + " currently does not supported in RuntumeUnitTestToolkit(multiple parameter or return type is invalid).");
}
}
}
catch (Exception e)
{
UnityEngine.Debug.LogError(testType.Name + "." + item.Name + " failed to register method, exception: " + e.ToString());
}
}
}
catch (Exception ex)
{
Debug.LogException(ex);
}
}
System.Collections.IEnumerator ScrollLogToEndNextFrame()
{
yield return null;
yield return null;
logScrollBar.value = 0;
}
IEnumerator RunTestInCoroutine(KeyValuePair<string, List<KeyValuePair<string, object>>> actionList)
{
Button self = null;
foreach (var btn in list.GetComponentsInChildren<Button>())
{
btn.interactable = false;
if (btn.name == actionList.Key) self = btn;
}
if (self != null)
{
self.GetComponent<Image>().color = normalColor;
}
var allGreen = true;
logText.text += "<color=yellow>" + actionList.Key + "</color>\n";
WriteToConsole("Begin Test Class: " + actionList.Key);
yield return null;
var totalExecutionTime = new List<double>();
foreach (var item2 in actionList.Value)
{
// before start, cleanup
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
logText.text += "<color=teal>" + item2.Key + "</color>\n";
yield return null;
var v = item2.Value;
var methodStopwatch = System.Diagnostics.Stopwatch.StartNew();
Exception exception = null;
if (v is Action)
{
try
{
((Action)v).Invoke();
}
catch (Exception ex)
{
exception = ex;
}
}
else
{
var coroutineFactory = (Func<IEnumerator>)v;
IEnumerator coroutine = null;
try
{
coroutine = coroutineFactory();
}
catch (Exception ex)
{
exception = ex;
}
if (exception == null)
{
yield return StartCoroutine(UnwrapEnumerator(coroutine, ex =>
{
exception = ex;
}));
}
}
methodStopwatch.Stop();
totalExecutionTime.Add(methodStopwatch.Elapsed.TotalMilliseconds);
if (exception == null)
{
logText.text += "OK, " + methodStopwatch.Elapsed.TotalMilliseconds.ToString("0.00") + "ms\n";
WriteToConsoleResult(item2.Key + ", " + methodStopwatch.Elapsed.TotalMilliseconds.ToString("0.00") + "ms", true);
}
else
{
// found match line...
var line = string.Join("\n", exception.StackTrace.Split('\n').Where(x => x.Contains(actionList.Key) || x.Contains(item2.Key)).ToArray());
logText.text += "<color=red>" + exception.Message + "\n" + line + "</color>\n";
WriteToConsoleResult(item2.Key + ", " + exception.Message, false);
WriteToConsole(line);
allGreen = false;
allTestGreen = false;
}
}
logText.text += "[" + actionList.Key + "]" + totalExecutionTime.Sum().ToString("0.00") + "ms\n\n";
foreach (var btn in list.GetComponentsInChildren<Button>()) btn.interactable = true;
if (self != null)
{
self.GetComponent<Image>().color = allGreen ? passColor : failColor;
}
yield return StartCoroutine(ScrollLogToEndNextFrame());
}
IEnumerator ExecuteAllInCoroutine(List<Func<Coroutine>> tests)
{
allTestGreen = true;
foreach (var item in tests)
{
yield return item();
}
if (Application.isBatchMode)
{
var scene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
bool disableAutoClose = (scene.name.Contains("DisableAutoClose"));
if (allTestGreen)
{
WriteToConsole("Test Complete Successfully");
if (!disableAutoClose)
{
Application.Quit();
}
}
else
{
WriteToConsole("Test Failed, please see [NG] log.");
if (!disableAutoClose)
{
Application.Quit(1);
}
}
}
}
IEnumerator UnwrapEnumerator(IEnumerator enumerator, Action<Exception> exceptionCallback)
{
var hasNext = true;
while (hasNext)
{
try
{
hasNext = enumerator.MoveNext();
}
catch (Exception ex)
{
exceptionCallback(ex);
hasNext = false;
}
if (hasNext)
{
// unwrap self for bug of Unity
// https://issuetracker.unity3d.com/issues/does-not-stop-coroutine-when-it-throws-exception-in-movenext-at-first-frame
var moreCoroutine = enumerator.Current as IEnumerator;
if (moreCoroutine != null)
{
yield return StartCoroutine(UnwrapEnumerator(moreCoroutine, ex =>
{
exceptionCallback(ex);
hasNext = false;
}));
}
else
{
yield return enumerator.Current;
}
}
}
}
static void WriteToConsole(string msg)
{
if (Application.isBatchMode)
{
Console.WriteLine(msg);
}
}
static void WriteToConsoleResult(string msg, bool green)
{
if (Application.isBatchMode)
{
if (!green)
{
var currentForeground = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Red;
Console.Write("[NG]");
Console.ForegroundColor = currentForeground;
}
else
{
var currentForeground = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Green;
Console.Write("[OK]");
Console.ForegroundColor = currentForeground;
}
System.Console.WriteLine(msg);
}
}
struct Pair
{
public string Name;
public UnityAction Action;
}
}
}

View File

@@ -1,33 +0,0 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading;
using UniRx.Async;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.UI;
public class SandboxMain : MonoBehaviour
{
public Button okButton;
public Button cancelButton;
CancellationTokenSource cts;
async void Start()
{
await UniTask.CompletedTask; // ok
// var subject = new Subject<Unit>();
//subject.OnCompleted();
IObservable<AsyncUnit> subject = default;
try
{
await subject.ToUniTask(); // exception
}
catch (Exception exception)
{
Debug.Log(exception);
}
}
}

View File

@@ -1,76 +0,0 @@
#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 UniRx.Async
{
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<AsyncUnit>();
return (promise.Task, cts.RegisterWithoutCaptureExecutionContext(cancellationTokenCallback, promise));
}
static void Callback(object state)
{
var promise = (UniTaskCompletionSource<AsyncUnit>)state;
promise.TrySetResult(AsyncUnit.Default);
}
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

View File

@@ -1,90 +0,0 @@
#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 UniRx.Async.CompilerServices
{
public struct AsyncUniTaskVoidMethodBuilder
{
Action moveNext;
// 1. Static Create method.
[DebuggerHidden]
public static AsyncUniTaskVoidMethodBuilder Create()
{
var builder = new AsyncUniTaskVoidMethodBuilder();
return builder;
}
// 2. TaskLike Task property(void)
public UniTaskVoid Task => default(UniTaskVoid);
// 3. SetException
[DebuggerHidden]
public void SetException(Exception exception)
{
UniTaskScheduler.PublishUnobservedTaskException(exception);
}
// 4. SetResult
[DebuggerHidden]
public void SetResult()
{
// do nothing
}
// 5. AwaitOnCompleted
[DebuggerHidden]
public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
where TAwaiter : INotifyCompletion
where TStateMachine : IAsyncStateMachine
{
if (moveNext == null)
{
var runner = new MoveNextRunner<TStateMachine>();
moveNext = runner.Run;
runner.StateMachine = stateMachine; // set after create delegate.
}
awaiter.OnCompleted(moveNext);
}
// 6. AwaitUnsafeOnCompleted
[DebuggerHidden]
[SecuritySafeCritical]
public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
where TAwaiter : ICriticalNotifyCompletion
where TStateMachine : IAsyncStateMachine
{
if (moveNext == null)
{
var runner = new MoveNextRunner<TStateMachine>();
moveNext = runner.Run;
runner.StateMachine = stateMachine; // set after create delegate.
}
awaiter.UnsafeOnCompleted(moveNext);
}
// 7. Start
[DebuggerHidden]
public void Start<TStateMachine>(ref TStateMachine stateMachine)
where TStateMachine : IAsyncStateMachine
{
stateMachine.MoveNext();
}
// 8. SetStateMachine
[DebuggerHidden]
public void SetStateMachine(IAsyncStateMachine stateMachine)
{
}
}
}
#endif

View File

@@ -1,23 +0,0 @@
#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.Diagnostics;
using System.Runtime.CompilerServices;
namespace UniRx.Async.CompilerServices
{
internal class MoveNextRunner<TStateMachine>
where TStateMachine : IAsyncStateMachine
{
public TStateMachine StateMachine;
[DebuggerHidden]
public void Run()
{
StateMachine.MoveNext();
}
}
}
#endif

View File

@@ -1,64 +0,0 @@
#if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
#pragma warning disable CS1591
using System.Runtime.CompilerServices;
namespace UniRx.Async
{
public enum AwaiterStatus
{
/// <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
}
public interface IAwaiter : ICriticalNotifyCompletion
{
AwaiterStatus Status { get; }
bool IsCompleted { get; }
void GetResult();
}
public interface IAwaiter<out T> : IAwaiter
{
new T GetResult();
}
public static class AwaiterStatusExtensions
{
/// <summary>!= Pending.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool IsCompleted(this AwaiterStatus status)
{
return status != AwaiterStatus.Pending;
}
/// <summary>== Succeeded.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool IsCompletedSuccessfully(this AwaiterStatus status)
{
return status == AwaiterStatus.Succeeded;
}
/// <summary>== Canceled.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool IsCanceled(this AwaiterStatus status)
{
return status == AwaiterStatus.Canceled;
}
/// <summary>== Faulted.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool IsFaulted(this AwaiterStatus status)
{
return status == AwaiterStatus.Faulted;
}
}
}
#endif

View File

@@ -1,32 +0,0 @@
#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;
namespace UniRx.Async.Internal
{
internal static class CancellationTokenHelper
{
public static bool TrySetOrLinkCancellationToken(ref CancellationToken field, CancellationToken newCancellationToken)
{
if (newCancellationToken == CancellationToken.None)
{
return false;
}
else if (field == CancellationToken.None)
{
field = newCancellationToken;
return true;
}
else if (field == newCancellationToken)
{
return false;
}
field = CancellationTokenSource.CreateLinkedTokenSource(field, newCancellationToken).Token;
return true;
}
}
}
#endif

View File

@@ -1,115 +0,0 @@
#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 UniRx.Async.Internal
{
internal 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 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

View File

@@ -1,23 +0,0 @@
#if NET_4_6 || NET_STANDARD_2_0 || CSHARP_7_OR_LATER
using System;
namespace UniRx.Async.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

View File

@@ -1,130 +0,0 @@
#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 UniRx.Async.Internal
{
internal sealed class LazyPromise : IAwaiter
{
Func<UniTask> factory;
UniTask value;
public LazyPromise(Func<UniTask> factory)
{
this.factory = factory;
}
void Create()
{
var f = Interlocked.Exchange(ref factory, null);
if (f != null)
{
value = f();
}
}
public bool IsCompleted
{
get
{
Create();
return value.IsCompleted;
}
}
public AwaiterStatus Status
{
get
{
Create();
return value.Status;
}
}
public void GetResult()
{
Create();
value.GetResult();
}
void IAwaiter.GetResult()
{
GetResult();
}
public void UnsafeOnCompleted(Action continuation)
{
Create();
value.GetAwaiter().UnsafeOnCompleted(continuation);
}
public void OnCompleted(Action continuation)
{
UnsafeOnCompleted(continuation);
}
}
internal sealed class LazyPromise<T> : IAwaiter<T>
{
Func<UniTask<T>> factory;
UniTask<T> value;
public LazyPromise(Func<UniTask<T>> factory)
{
this.factory = factory;
}
void Create()
{
var f = Interlocked.Exchange(ref factory, null);
if (f != null)
{
value = f();
}
}
public bool IsCompleted
{
get
{
Create();
return value.IsCompleted;
}
}
public AwaiterStatus Status
{
get
{
Create();
return value.Status;
}
}
public T GetResult()
{
Create();
return value.Result;
}
void IAwaiter.GetResult()
{
GetResult();
}
public void UnsafeOnCompleted(Action continuation)
{
Create();
value.GetAwaiter().UnsafeOnCompleted(continuation);
}
public void OnCompleted(Action continuation)
{
UnsafeOnCompleted(continuation);
}
}
}
#endif

View File

@@ -1,34 +0,0 @@
#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;
namespace UniRx.Async.Internal
{
internal static class PromiseHelper
{
internal static void TrySetResultAll<TPromise, T>(IEnumerable<TPromise> source, T value)
where TPromise : class, IResolvePromise<T>
{
var rentArray = ArrayPoolUtil.Materialize(source);
var clearArray = true;
try
{
var array = rentArray.Array;
var len = rentArray.Length;
for (int i = 0; i < len; i++)
{
array[i].TrySetResult(value);
array[i] = null;
}
clearArray = false;
}
finally
{
rentArray.DisposeManually(clearArray);
}
}
}
}
#endif

View File

@@ -1,395 +0,0 @@
#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.ExceptionServices;
using System.Threading;
namespace UniRx.Async.Internal
{
// public for some types uses it.
public abstract class ReusablePromise : IAwaiter
{
ExceptionDispatchInfo exception;
object continuation; // Action or Queue<Action>
AwaiterStatus status;
public UniTask Task => new UniTask(this);
// can override for control 'start/reset' timing.
public virtual bool IsCompleted => status.IsCompleted();
public virtual void GetResult()
{
switch (status)
{
case AwaiterStatus.Succeeded:
return;
case AwaiterStatus.Faulted:
exception.Throw();
break;
case AwaiterStatus.Canceled:
throw new OperationCanceledException();
default:
break;
}
throw new InvalidOperationException("Invalid Status:" + status);
}
public AwaiterStatus Status => status;
void IAwaiter.GetResult()
{
GetResult();
}
public void ResetStatus(bool forceReset)
{
if (forceReset)
{
status = AwaiterStatus.Pending;
}
else if (status == AwaiterStatus.Succeeded)
{
status = AwaiterStatus.Pending;
}
}
public virtual bool TrySetCanceled()
{
if (status == AwaiterStatus.Pending)
{
status = AwaiterStatus.Canceled;
TryInvokeContinuation();
return true;
}
return false;
}
public virtual bool TrySetException(Exception ex)
{
if (status == AwaiterStatus.Pending)
{
status = AwaiterStatus.Faulted;
exception = ExceptionDispatchInfo.Capture(ex);
TryInvokeContinuation();
return true;
}
return false;
}
public virtual bool TrySetResult()
{
if (status == AwaiterStatus.Pending)
{
status = AwaiterStatus.Succeeded;
TryInvokeContinuation();
return true;
}
return false;
}
void TryInvokeContinuation()
{
if (continuation == null) return;
if (continuation is Action act)
{
continuation = null;
act();
}
else
{
// reuse Queue(don't null clear)
var q = (MinimumQueue<Action>)continuation;
var size = q.Count;
for (int i = 0; i < size; i++)
{
q.Dequeue().Invoke();
}
}
}
public void OnCompleted(Action action)
{
UnsafeOnCompleted(action);
}
public void UnsafeOnCompleted(Action action)
{
if (continuation == null)
{
continuation = action;
return;
}
else
{
if (continuation is Action act)
{
var q = new MinimumQueue<Action>(4);
q.Enqueue(act);
q.Enqueue(action);
continuation = q;
return;
}
else
{
((MinimumQueue<Action>)continuation).Enqueue(action);
}
}
}
}
public abstract class ReusablePromise<T> : IAwaiter<T>
{
T result;
ExceptionDispatchInfo exception;
object continuation; // Action or Queue<Action>
AwaiterStatus status;
public UniTask<T> Task => new UniTask<T>(this);
// can override for control 'start/reset' timing.
public virtual bool IsCompleted => status.IsCompleted();
protected T RawResult => result;
protected void ForceSetResult(T result)
{
this.result = result;
}
public virtual T GetResult()
{
switch (status)
{
case AwaiterStatus.Succeeded:
return result;
case AwaiterStatus.Faulted:
exception.Throw();
break;
case AwaiterStatus.Canceled:
throw new OperationCanceledException();
default:
break;
}
throw new InvalidOperationException("Invalid Status:" + status);
}
public AwaiterStatus Status => status;
void IAwaiter.GetResult()
{
GetResult();
}
public void ResetStatus(bool forceReset)
{
if (forceReset)
{
status = AwaiterStatus.Pending;
}
else if (status == AwaiterStatus.Succeeded)
{
status = AwaiterStatus.Pending;
}
}
public virtual bool TrySetCanceled()
{
if (status == AwaiterStatus.Pending)
{
status = AwaiterStatus.Canceled;
TryInvokeContinuation();
return true;
}
return false;
}
public virtual bool TrySetException(Exception ex)
{
if (status == AwaiterStatus.Pending)
{
status = AwaiterStatus.Faulted;
exception = ExceptionDispatchInfo.Capture(ex);
TryInvokeContinuation();
return true;
}
return false;
}
public virtual bool TrySetResult(T result)
{
if (status == AwaiterStatus.Pending)
{
status = AwaiterStatus.Succeeded;
this.result = result;
TryInvokeContinuation();
return true;
}
return false;
}
protected void TryInvokeContinuation()
{
if (continuation == null) return;
if (continuation is Action act)
{
continuation = null;
act();
}
else
{
// reuse Queue(don't null clear)
var q = (MinimumQueue<Action>)continuation;
var size = q.Count;
for (int i = 0; i < size; i++)
{
q.Dequeue().Invoke();
}
}
}
public void OnCompleted(Action action)
{
UnsafeOnCompleted(action);
}
public void UnsafeOnCompleted(Action action)
{
if (continuation == null)
{
continuation = action;
return;
}
else
{
if (continuation is Action act)
{
var q = new MinimumQueue<Action>(4);
q.Enqueue(act);
q.Enqueue(action);
continuation = q;
return;
}
else
{
((MinimumQueue<Action>)continuation).Enqueue(action);
}
}
}
}
public abstract class PlayerLoopReusablePromiseBase : ReusablePromise, IPlayerLoopItem
{
readonly PlayerLoopTiming timing;
protected readonly CancellationToken cancellationToken;
bool isRunning = false;
#if UNITY_EDITOR
string capturedStackTraceForDebugging;
#endif
public PlayerLoopReusablePromiseBase(PlayerLoopTiming timing, CancellationToken cancellationToken, int skipTrackFrameCountAdditive)
{
this.timing = timing;
this.cancellationToken = cancellationToken;
#if UNITY_EDITOR
this.capturedStackTraceForDebugging = TaskTracker.CaptureStackTrace(skipTrackFrameCountAdditive + 1); // 1 is self,
#endif
}
public override bool IsCompleted
{
get
{
if (Status == AwaiterStatus.Canceled || Status == AwaiterStatus.Faulted) return true;
if (!isRunning)
{
isRunning = true;
ResetStatus(false);
OnRunningStart();
#if UNITY_EDITOR
TaskTracker.TrackActiveTask(this, capturedStackTraceForDebugging);
#endif
PlayerLoopHelper.AddAction(timing, this);
}
return false;
}
}
protected abstract void OnRunningStart();
protected void Complete()
{
isRunning = false;
#if UNITY_EDITOR
TaskTracker.RemoveTracking(this);
#endif
}
public abstract bool MoveNext();
}
public abstract class PlayerLoopReusablePromiseBase<T> : ReusablePromise<T>, IPlayerLoopItem
{
readonly PlayerLoopTiming timing;
protected readonly CancellationToken cancellationToken;
bool isRunning = false;
#if UNITY_EDITOR
string capturedStackTraceForDebugging;
#endif
public PlayerLoopReusablePromiseBase(PlayerLoopTiming timing, CancellationToken cancellationToken, int skipTrackFrameCountAdditive)
{
this.timing = timing;
this.cancellationToken = cancellationToken;
#if UNITY_EDITOR
this.capturedStackTraceForDebugging = TaskTracker.CaptureStackTrace(skipTrackFrameCountAdditive + 1); // 1 is self,
#endif
}
public override bool IsCompleted
{
get
{
if (Status == AwaiterStatus.Canceled || Status == AwaiterStatus.Faulted) return true;
if (!isRunning)
{
isRunning = true;
ResetStatus(false);
OnRunningStart();
#if UNITY_EDITOR
TaskTracker.TrackActiveTask(this, capturedStackTraceForDebugging);
#endif
PlayerLoopHelper.AddAction(timing, this);
}
return false;
}
}
protected abstract void OnRunningStart();
protected void Complete()
{
isRunning = false;
#if UNITY_EDITOR
TaskTracker.RemoveTracking(this);
#endif
}
public abstract bool MoveNext();
}
#endif
}

View File

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

View File

@@ -1,152 +0,0 @@
#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;
namespace UniRx.Async.Internal
{
// 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<IAwaiter, (int trackingId, DateTime addTime, string stackTrace)>> listPool = new List<KeyValuePair<IAwaiter, (int trackingId, DateTime addTime, string stackTrace)>>();
static readonly WeakDictionary<IAwaiter, (int trackingId, DateTime addTime, string stackTrace)> tracking = new WeakDictionary<IAwaiter, (int trackingId, DateTime addTime, string stackTrace)>();
[Conditional("UNITY_EDITOR")]
public static void TrackActiveTask(IAwaiter task, int skipFrame = 1)
{
#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 TrackActiveTask(IAwaiter task, string stackTrace)
{
#if UNITY_EDITOR
dirty = true;
if (!EditorEnableState.EnableTracking) return;
var success = tracking.TryAdd(task, (Interlocked.Increment(ref trackingId), DateTime.UtcNow, stackTrace));
#endif
}
public static string CaptureStackTrace(int skipFrame)
{
#if UNITY_EDITOR
if (!EditorEnableState.EnableTracking) return "";
var stackTrace = EditorEnableState.EnableStackTrace ? new StackTrace(skipFrame + 1, true).CleanupAsyncStackTrace() : "";
return stackTrace;
#else
return null;
#endif
}
[Conditional("UNITY_EDITOR")]
public static void RemoveTracking(IAwaiter 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, AwaiterStatus, 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.Status, listPool[i].Value.addTime, listPool[i].Value.stackTrace);
listPool[i] = new KeyValuePair<IAwaiter, (int trackingId, DateTime addTime, string stackTrace)>(null, (0, default(DateTime), null)); // clear
}
}
catch
{
listPool.Clear();
throw;
}
}
}
}
}
#endif

View File

@@ -1,156 +0,0 @@
#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 UniRx.Async.Internal;
using System.Threading;
#if UNITY_2019_3_OR_NEWER
using UnityEngine.LowLevel;
#else
using UnityEngine.Experimental.LowLevel;
#endif
namespace UniRx.Async
{
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 { };
// Yield
public struct UniTaskLoopRunnerYieldInitialization { };
public struct UniTaskLoopRunnerYieldEarlyUpdate { };
public struct UniTaskLoopRunnerYieldFixedUpdate { };
public struct UniTaskLoopRunnerYieldPreUpdate { };
public struct UniTaskLoopRunnerYieldUpdate { };
public struct UniTaskLoopRunnerYieldPreLateUpdate { };
public struct UniTaskLoopRunnerYieldPostLateUpdate { };
}
public enum PlayerLoopTiming
{
Initialization = 0,
EarlyUpdate = 1,
FixedUpdate = 2,
PreUpdate = 3,
Update = 4,
PreLateUpdate = 5,
PostLateUpdate = 6
}
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 loopRunnerType, PlayerLoopRunner runner)
{
var yieldLoop = new PlayerLoopSystem
{
type = loopRunnerYieldType,
#if UNITY_EDITOR
updateDelegate = () =>
{
if (Application.isPlaying)
{
cq.Run();
}
}
#else
updateDelegate = cq.Run
#endif
};
var runnerLoop = new PlayerLoopSystem
{
type = loopRunnerType,
#if UNITY_EDITOR
updateDelegate = () =>
{
if (Application.isPlaying)
{
runner.Run();
}
}
#else
updateDelegate = runner.Run
#endif
};
var dest = new PlayerLoopSystem[loopSystem.subSystemList.Length + 2];
Array.Copy(loopSystem.subSystemList, 0, dest, 2, loopSystem.subSystemList.Length);
dest[0] = yieldLoop;
dest[1] = runnerLoop;
return dest;
}
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
static void Init()
{
// capture default(unity) sync-context.
unitySynchronizationContetext = SynchronizationContext.Current;
mainThreadId = Thread.CurrentThread.ManagedThreadId;
if (runners != null) return; // already initialized
var playerLoop =
#if UNITY_2019_3_OR_NEWER
PlayerLoop.GetCurrentPlayerLoop();
#else
PlayerLoop.GetDefaultPlayerLoop();
#endif
Initialize(ref playerLoop);
}
public static void Initialize(ref PlayerLoopSystem playerLoop)
{
yielders = new ContinuationQueue[7];
runners = new PlayerLoopRunner[7];
var copyList = playerLoop.subSystemList.ToArray();
copyList[0].subSystemList = InsertRunner(copyList[0], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldInitialization), yielders[0] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerInitialization), runners[0] = new PlayerLoopRunner());
copyList[1].subSystemList = InsertRunner(copyList[1], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldEarlyUpdate), yielders[1] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerEarlyUpdate), runners[1] = new PlayerLoopRunner());
copyList[2].subSystemList = InsertRunner(copyList[2], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldFixedUpdate), yielders[2] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerFixedUpdate), runners[2] = new PlayerLoopRunner());
copyList[3].subSystemList = InsertRunner(copyList[3], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreUpdate), yielders[3] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreUpdate), runners[3] = new PlayerLoopRunner());
copyList[4].subSystemList = InsertRunner(copyList[4], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldUpdate), yielders[4] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerUpdate), runners[4] = new PlayerLoopRunner());
copyList[5].subSystemList = InsertRunner(copyList[5], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreLateUpdate), yielders[5] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreLateUpdate), runners[5] = new PlayerLoopRunner());
copyList[6].subSystemList = InsertRunner(copyList[6], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPostLateUpdate), yielders[6] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPostLateUpdate), runners[6] = 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

View File

@@ -1,54 +0,0 @@
#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;
using UnityEngine;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncAnimatorTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<int> onAnimatorIK;
AsyncTriggerPromiseDictionary<int> onAnimatorIKs;
AsyncTriggerPromise<AsyncUnit> onAnimatorMove;
AsyncTriggerPromiseDictionary<AsyncUnit> onAnimatorMoves;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onAnimatorIK, onAnimatorIKs, onAnimatorMove, onAnimatorMoves);
}
void OnAnimatorIK(int layerIndex)
{
TrySetResult(onAnimatorIK, onAnimatorIKs, layerIndex);
}
public UniTask<int> OnAnimatorIKAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onAnimatorIK, ref onAnimatorIKs, cancellationToken);
}
void OnAnimatorMove()
{
TrySetResult(onAnimatorMove, onAnimatorMoves, AsyncUnit.Default);
}
public UniTask OnAnimatorMoveAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onAnimatorMove, ref onAnimatorMoves, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,55 +0,0 @@
#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;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncAwakeTrigger : MonoBehaviour
{
bool called = false;
UniTaskCompletionSource promise;
void Awake()
{
called = true;
promise?.TrySetResult();
}
public UniTask AwakeAsync()
{
if (called) return UniTask.CompletedTask;
PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
return new UniTask(promise ?? (promise = new UniTaskCompletionSource()));
}
private void OnDestroy()
{
promise?.TrySetCanceled();
}
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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncBeginDragTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<PointerEventData> onBeginDrag;
AsyncTriggerPromiseDictionary<PointerEventData> onBeginDrags;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onBeginDrag, onBeginDrags);
}
void OnBeginDrag(PointerEventData eventData)
{
TrySetResult(onBeginDrag, onBeginDrags, eventData);
}
public UniTask<PointerEventData> OnBeginDragAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onBeginDrag, ref onBeginDrags, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncCancelTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<BaseEventData> onCancel;
AsyncTriggerPromiseDictionary<BaseEventData> onCancels;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onCancel, onCancels);
}
void OnCancel(BaseEventData eventData)
{
TrySetResult(onCancel, onCancels, eventData);
}
public UniTask<BaseEventData> OnCancelAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onCancel, ref onCancels, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncCanvasGroupChangedTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<AsyncUnit> onCanvasGroupChanged;
AsyncTriggerPromiseDictionary<AsyncUnit> onCanvasGroupChangeds;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onCanvasGroupChanged, onCanvasGroupChangeds);
}
void OnCanvasGroupChanged()
{
TrySetResult(onCanvasGroupChanged, onCanvasGroupChangeds, AsyncUnit.Default);
}
public UniTask OnCanvasGroupChangedAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onCanvasGroupChanged, ref onCanvasGroupChangeds, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,69 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncCollision2DTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<Collision2D> onCollisionEnter2D;
AsyncTriggerPromiseDictionary<Collision2D> onCollisionEnter2Ds;
AsyncTriggerPromise<Collision2D> onCollisionExit2D;
AsyncTriggerPromiseDictionary<Collision2D> onCollisionExit2Ds;
AsyncTriggerPromise<Collision2D> onCollisionStay2D;
AsyncTriggerPromiseDictionary<Collision2D> onCollisionStay2Ds;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onCollisionEnter2D, onCollisionEnter2Ds, onCollisionExit2D, onCollisionExit2Ds, onCollisionStay2D, onCollisionStay2Ds);
}
void OnCollisionEnter2D(Collision2D coll)
{
TrySetResult(onCollisionEnter2D, onCollisionEnter2Ds, coll);
}
public UniTask<Collision2D> OnCollisionEnter2DAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onCollisionEnter2D, ref onCollisionEnter2Ds, cancellationToken);
}
void OnCollisionExit2D(Collision2D coll)
{
TrySetResult(onCollisionExit2D, onCollisionExit2Ds, coll);
}
public UniTask<Collision2D> OnCollisionExit2DAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onCollisionExit2D, ref onCollisionExit2Ds, cancellationToken);
}
void OnCollisionStay2D(Collision2D coll)
{
TrySetResult(onCollisionStay2D, onCollisionStay2Ds, coll);
}
public UniTask<Collision2D> OnCollisionStay2DAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onCollisionStay2D, ref onCollisionStay2Ds, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,69 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncCollisionTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<Collision> onCollisionEnter;
AsyncTriggerPromiseDictionary<Collision> onCollisionEnters;
AsyncTriggerPromise<Collision> onCollisionExit;
AsyncTriggerPromiseDictionary<Collision> onCollisionExits;
AsyncTriggerPromise<Collision> onCollisionStay;
AsyncTriggerPromiseDictionary<Collision> onCollisionStays;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onCollisionEnter, onCollisionEnters, onCollisionExit, onCollisionExits, onCollisionStay, onCollisionStays);
}
void OnCollisionEnter(Collision collision)
{
TrySetResult(onCollisionEnter, onCollisionEnters, collision);
}
public UniTask<Collision> OnCollisionEnterAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onCollisionEnter, ref onCollisionEnters, cancellationToken);
}
void OnCollisionExit(Collision collisionInfo)
{
TrySetResult(onCollisionExit, onCollisionExits, collisionInfo);
}
public UniTask<Collision> OnCollisionExitAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onCollisionExit, ref onCollisionExits, cancellationToken);
}
void OnCollisionStay(Collision collisionInfo)
{
TrySetResult(onCollisionStay, onCollisionStays, collisionInfo);
}
public UniTask<Collision> OnCollisionStayAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onCollisionStay, ref onCollisionStays, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncDeselectTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<BaseEventData> onDeselect;
AsyncTriggerPromiseDictionary<BaseEventData> onDeselects;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onDeselect, onDeselects);
}
void OnDeselect(BaseEventData eventData)
{
TrySetResult(onDeselect, onDeselects, eventData);
}
public UniTask<BaseEventData> OnDeselectAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onDeselect, ref onDeselects, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,93 +0,0 @@
#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 UniRx.Async.Internal;
using UnityEngine;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncDestroyTrigger : MonoBehaviour
{
bool called = false;
UniTaskCompletionSource promise;
CancellationTokenSource cancellationTokenSource; // main cancellation
object canellationTokenSourceOrQueue; // external from AddCancellationTriggerOnDestory
public CancellationToken CancellationToken
{
get
{
if (cancellationTokenSource == null)
{
cancellationTokenSource = new CancellationTokenSource();
}
return cancellationTokenSource.Token;
}
}
/// <summary>This function is called when the MonoBehaviour will be destroyed.</summary>
void OnDestroy()
{
called = true;
promise?.TrySetResult();
cancellationTokenSource?.Cancel();
cancellationTokenSource?.Dispose();
if (canellationTokenSourceOrQueue != null)
{
if (canellationTokenSourceOrQueue is CancellationTokenSource cts)
{
cts.Cancel();
cts.Dispose();
}
else
{
var q = (MinimumQueue<CancellationTokenSource>)canellationTokenSourceOrQueue;
while (q.Count != 0)
{
var c = q.Dequeue();
c.Cancel();
c.Dispose();
}
}
canellationTokenSourceOrQueue = null;
}
}
/// <summary>This function is called when the MonoBehaviour will be destroyed.</summary>
public UniTask OnDestroyAsync()
{
if (called) return UniTask.CompletedTask;
return new UniTask(promise ?? (promise = new UniTaskCompletionSource()));
}
/// <summary>Add Cancellation Triggers on destroy</summary>
public void AddCancellationTriggerOnDestory(CancellationTokenSource cts)
{
if (called)
{
cts.Cancel();
cts.Dispose();
}
if (canellationTokenSourceOrQueue == null)
{
canellationTokenSourceOrQueue = cts;
}
else if (canellationTokenSourceOrQueue is CancellationTokenSource c)
{
var q = new MinimumQueue<CancellationTokenSource>(4);
q.Enqueue(c);
q.Enqueue(cts);
canellationTokenSourceOrQueue = q;
}
else
{
((MinimumQueue<CancellationTokenSource>)canellationTokenSourceOrQueue).Enqueue(cts);
}
}
}
}
#endif

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncDragTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<PointerEventData> onDrag;
AsyncTriggerPromiseDictionary<PointerEventData> onDrags;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onDrag, onDrags);
}
void OnDrag(PointerEventData eventData)
{
TrySetResult(onDrag, onDrags, eventData);
}
public UniTask<PointerEventData> OnDragAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onDrag, ref onDrags, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncDropTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<PointerEventData> onDrop;
AsyncTriggerPromiseDictionary<PointerEventData> onDrops;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onDrop, onDrops);
}
void OnDrop(PointerEventData eventData)
{
TrySetResult(onDrop, onDrops, eventData);
}
public UniTask<PointerEventData> OnDropAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onDrop, ref onDrops, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,55 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncEnableDisableTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<AsyncUnit> onEnable;
AsyncTriggerPromiseDictionary<AsyncUnit> onEnables;
AsyncTriggerPromise<AsyncUnit> onDisable;
AsyncTriggerPromiseDictionary<AsyncUnit> onDisables;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onEnable, onEnables, onDisable, onDisables);
}
void OnEnable()
{
TrySetResult(onEnable, onEnables, AsyncUnit.Default);
}
public UniTask OnEnableAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onEnable, ref onEnables, cancellationToken);
}
void OnDisable()
{
TrySetResult(onDisable, onDisables, AsyncUnit.Default);
}
public UniTask OnDisableAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onDisable, ref onDisables, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncEndDragTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<PointerEventData> onEndDrag;
AsyncTriggerPromiseDictionary<PointerEventData> onEndDrags;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onEndDrag, onEndDrags);
}
void OnEndDrag(PointerEventData eventData)
{
TrySetResult(onEndDrag, onEndDrags, eventData);
}
public UniTask<PointerEventData> OnEndDragAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onEndDrag, ref onEndDrags, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,264 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncEventTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<BaseEventData> onDeselect;
AsyncTriggerPromiseDictionary<BaseEventData> onDeselects;
AsyncTriggerPromise<AxisEventData> onMove;
AsyncTriggerPromiseDictionary<AxisEventData> onMoves;
AsyncTriggerPromise<PointerEventData> onPointerDown;
AsyncTriggerPromiseDictionary<PointerEventData> onPointerDowns;
AsyncTriggerPromise<PointerEventData> onPointerEnter;
AsyncTriggerPromiseDictionary<PointerEventData> onPointerEnters;
AsyncTriggerPromise<PointerEventData> onPointerExit;
AsyncTriggerPromiseDictionary<PointerEventData> onPointerExits;
AsyncTriggerPromise<PointerEventData> onPointerUp;
AsyncTriggerPromiseDictionary<PointerEventData> onPointerUps;
AsyncTriggerPromise<BaseEventData> onSelect;
AsyncTriggerPromiseDictionary<BaseEventData> onSelects;
AsyncTriggerPromise<PointerEventData> onPointerClick;
AsyncTriggerPromiseDictionary<PointerEventData> onPointerClicks;
AsyncTriggerPromise<BaseEventData> onSubmit;
AsyncTriggerPromiseDictionary<BaseEventData> onSubmits;
AsyncTriggerPromise<PointerEventData> onDrag;
AsyncTriggerPromiseDictionary<PointerEventData> onDrags;
AsyncTriggerPromise<PointerEventData> onBeginDrag;
AsyncTriggerPromiseDictionary<PointerEventData> onBeginDrags;
AsyncTriggerPromise<PointerEventData> onEndDrag;
AsyncTriggerPromiseDictionary<PointerEventData> onEndDrags;
AsyncTriggerPromise<PointerEventData> onDrop;
AsyncTriggerPromiseDictionary<PointerEventData> onDrops;
AsyncTriggerPromise<BaseEventData> onUpdateSelected;
AsyncTriggerPromiseDictionary<BaseEventData> onUpdateSelecteds;
AsyncTriggerPromise<PointerEventData> onInitializePotentialDrag;
AsyncTriggerPromiseDictionary<PointerEventData> onInitializePotentialDrags;
AsyncTriggerPromise<BaseEventData> onCancel;
AsyncTriggerPromiseDictionary<BaseEventData> onCancels;
AsyncTriggerPromise<PointerEventData> onScroll;
AsyncTriggerPromiseDictionary<PointerEventData> onScrolls;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onDeselect, onDeselects, onMove, onMoves, onPointerDown, onPointerDowns, onPointerEnter, onPointerEnters, onPointerExit, onPointerExits, onPointerUp, onPointerUps, onSelect, onSelects, onPointerClick, onPointerClicks, onSubmit, onSubmits, onDrag, onDrags, onBeginDrag, onBeginDrags, onEndDrag, onEndDrags, onDrop, onDrops, onUpdateSelected, onUpdateSelecteds, onInitializePotentialDrag, onInitializePotentialDrags, onCancel, onCancels, onScroll, onScrolls);
}
void OnDeselect(BaseEventData eventData)
{
TrySetResult(onDeselect, onDeselects, eventData);
}
public UniTask<BaseEventData> OnDeselectAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onDeselect, ref onDeselects, cancellationToken);
}
void OnMove(AxisEventData eventData)
{
TrySetResult(onMove, onMoves, eventData);
}
public UniTask<AxisEventData> OnMoveAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onMove, ref onMoves, cancellationToken);
}
void OnPointerDown(PointerEventData eventData)
{
TrySetResult(onPointerDown, onPointerDowns, eventData);
}
public UniTask<PointerEventData> OnPointerDownAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onPointerDown, ref onPointerDowns, cancellationToken);
}
void OnPointerEnter(PointerEventData eventData)
{
TrySetResult(onPointerEnter, onPointerEnters, eventData);
}
public UniTask<PointerEventData> OnPointerEnterAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onPointerEnter, ref onPointerEnters, cancellationToken);
}
void OnPointerExit(PointerEventData eventData)
{
TrySetResult(onPointerExit, onPointerExits, eventData);
}
public UniTask<PointerEventData> OnPointerExitAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onPointerExit, ref onPointerExits, cancellationToken);
}
void OnPointerUp(PointerEventData eventData)
{
TrySetResult(onPointerUp, onPointerUps, eventData);
}
public UniTask<PointerEventData> OnPointerUpAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onPointerUp, ref onPointerUps, cancellationToken);
}
void OnSelect(BaseEventData eventData)
{
TrySetResult(onSelect, onSelects, eventData);
}
public UniTask<BaseEventData> OnSelectAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onSelect, ref onSelects, cancellationToken);
}
void OnPointerClick(PointerEventData eventData)
{
TrySetResult(onPointerClick, onPointerClicks, eventData);
}
public UniTask<PointerEventData> OnPointerClickAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onPointerClick, ref onPointerClicks, cancellationToken);
}
void OnSubmit(BaseEventData eventData)
{
TrySetResult(onSubmit, onSubmits, eventData);
}
public UniTask<BaseEventData> OnSubmitAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onSubmit, ref onSubmits, cancellationToken);
}
void OnDrag(PointerEventData eventData)
{
TrySetResult(onDrag, onDrags, eventData);
}
public UniTask<PointerEventData> OnDragAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onDrag, ref onDrags, cancellationToken);
}
void OnBeginDrag(PointerEventData eventData)
{
TrySetResult(onBeginDrag, onBeginDrags, eventData);
}
public UniTask<PointerEventData> OnBeginDragAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onBeginDrag, ref onBeginDrags, cancellationToken);
}
void OnEndDrag(PointerEventData eventData)
{
TrySetResult(onEndDrag, onEndDrags, eventData);
}
public UniTask<PointerEventData> OnEndDragAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onEndDrag, ref onEndDrags, cancellationToken);
}
void OnDrop(PointerEventData eventData)
{
TrySetResult(onDrop, onDrops, eventData);
}
public UniTask<PointerEventData> OnDropAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onDrop, ref onDrops, cancellationToken);
}
void OnUpdateSelected(BaseEventData eventData)
{
TrySetResult(onUpdateSelected, onUpdateSelecteds, eventData);
}
public UniTask<BaseEventData> OnUpdateSelectedAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onUpdateSelected, ref onUpdateSelecteds, cancellationToken);
}
void OnInitializePotentialDrag(PointerEventData eventData)
{
TrySetResult(onInitializePotentialDrag, onInitializePotentialDrags, eventData);
}
public UniTask<PointerEventData> OnInitializePotentialDragAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onInitializePotentialDrag, ref onInitializePotentialDrags, cancellationToken);
}
void OnCancel(BaseEventData eventData)
{
TrySetResult(onCancel, onCancels, eventData);
}
public UniTask<BaseEventData> OnCancelAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onCancel, ref onCancels, cancellationToken);
}
void OnScroll(PointerEventData eventData)
{
TrySetResult(onScroll, onScrolls, eventData);
}
public UniTask<PointerEventData> OnScrollAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onScroll, ref onScrolls, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncFixedUpdateTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<AsyncUnit> fixedUpdate;
AsyncTriggerPromiseDictionary<AsyncUnit> fixedUpdates;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(fixedUpdate, fixedUpdates);
}
void FixedUpdate()
{
TrySetResult(fixedUpdate, fixedUpdates, AsyncUnit.Default);
}
public UniTask FixedUpdateAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref fixedUpdate, ref fixedUpdates, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncInitializePotentialDragTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<PointerEventData> onInitializePotentialDrag;
AsyncTriggerPromiseDictionary<PointerEventData> onInitializePotentialDrags;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onInitializePotentialDrag, onInitializePotentialDrags);
}
void OnInitializePotentialDrag(PointerEventData eventData)
{
TrySetResult(onInitializePotentialDrag, onInitializePotentialDrags, eventData);
}
public UniTask<PointerEventData> OnInitializePotentialDragAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onInitializePotentialDrag, ref onInitializePotentialDrags, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,55 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncJointTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<float> onJointBreak;
AsyncTriggerPromiseDictionary<float> onJointBreaks;
AsyncTriggerPromise<Joint2D> onJointBreak2D;
AsyncTriggerPromiseDictionary<Joint2D> onJointBreak2Ds;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onJointBreak, onJointBreaks, onJointBreak2D, onJointBreak2Ds);
}
void OnJointBreak(float breakForce)
{
TrySetResult(onJointBreak, onJointBreaks, breakForce);
}
public UniTask<float> OnJointBreakAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onJointBreak, ref onJointBreaks, cancellationToken);
}
void OnJointBreak2D(Joint2D brokenJoint)
{
TrySetResult(onJointBreak2D, onJointBreak2Ds, brokenJoint);
}
public UniTask<Joint2D> OnJointBreak2DAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onJointBreak2D, ref onJointBreak2Ds, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncLateUpdateTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<AsyncUnit> lateUpdate;
AsyncTriggerPromiseDictionary<AsyncUnit> lateUpdates;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(lateUpdate, lateUpdates);
}
void LateUpdate()
{
TrySetResult(lateUpdate, lateUpdates, AsyncUnit.Default);
}
public UniTask LateUpdateAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref lateUpdate, ref lateUpdates, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,129 +0,0 @@
#if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO)
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncMouseTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<AsyncUnit> onMouseDown;
AsyncTriggerPromiseDictionary<AsyncUnit> onMouseDowns;
AsyncTriggerPromise<AsyncUnit> onMouseDrag;
AsyncTriggerPromiseDictionary<AsyncUnit> onMouseDrags;
AsyncTriggerPromise<AsyncUnit> onMouseEnter;
AsyncTriggerPromiseDictionary<AsyncUnit> onMouseEnters;
AsyncTriggerPromise<AsyncUnit> onMouseExit;
AsyncTriggerPromiseDictionary<AsyncUnit> onMouseExits;
AsyncTriggerPromise<AsyncUnit> onMouseOver;
AsyncTriggerPromiseDictionary<AsyncUnit> onMouseOvers;
AsyncTriggerPromise<AsyncUnit> onMouseUp;
AsyncTriggerPromiseDictionary<AsyncUnit> onMouseUps;
AsyncTriggerPromise<AsyncUnit> onMouseUpAsButton;
AsyncTriggerPromiseDictionary<AsyncUnit> onMouseUpAsButtons;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onMouseDown, onMouseDowns, onMouseDrag, onMouseDrags, onMouseEnter, onMouseEnters, onMouseExit, onMouseExits, onMouseOver, onMouseOvers, onMouseUp, onMouseUps, onMouseUpAsButton, onMouseUpAsButtons);
}
void OnMouseDown()
{
TrySetResult(onMouseDown, onMouseDowns, AsyncUnit.Default);
}
public UniTask OnMouseDownAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onMouseDown, ref onMouseDowns, cancellationToken);
}
void OnMouseDrag()
{
TrySetResult(onMouseDrag, onMouseDrags, AsyncUnit.Default);
}
public UniTask OnMouseDragAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onMouseDrag, ref onMouseDrags, cancellationToken);
}
void OnMouseEnter()
{
TrySetResult(onMouseEnter, onMouseEnters, AsyncUnit.Default);
}
public UniTask OnMouseEnterAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onMouseEnter, ref onMouseEnters, cancellationToken);
}
void OnMouseExit()
{
TrySetResult(onMouseExit, onMouseExits, AsyncUnit.Default);
}
public UniTask OnMouseExitAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onMouseExit, ref onMouseExits, cancellationToken);
}
void OnMouseOver()
{
TrySetResult(onMouseOver, onMouseOvers, AsyncUnit.Default);
}
public UniTask OnMouseOverAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onMouseOver, ref onMouseOvers, cancellationToken);
}
void OnMouseUp()
{
TrySetResult(onMouseUp, onMouseUps, AsyncUnit.Default);
}
public UniTask OnMouseUpAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onMouseUp, ref onMouseUps, cancellationToken);
}
void OnMouseUpAsButton()
{
TrySetResult(onMouseUpAsButton, onMouseUpAsButtons, AsyncUnit.Default);
}
public UniTask OnMouseUpAsButtonAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onMouseUpAsButton, ref onMouseUpAsButtons, cancellationToken);
}
}
}
#endif
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncMoveTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<AxisEventData> onMove;
AsyncTriggerPromiseDictionary<AxisEventData> onMoves;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onMove, onMoves);
}
void OnMove(AxisEventData eventData)
{
TrySetResult(onMove, onMoves, eventData);
}
public UniTask<AxisEventData> OnMoveAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onMove, ref onMoves, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncParticleTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<GameObject> onParticleCollision;
AsyncTriggerPromiseDictionary<GameObject> onParticleCollisions;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onParticleCollision, onParticleCollisions);
}
void OnParticleCollision(GameObject other)
{
TrySetResult(onParticleCollision, onParticleCollisions, other);
}
public UniTask<GameObject> OnParticleCollisionAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onParticleCollision, ref onParticleCollisions, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncPointerClickTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<PointerEventData> onPointerClick;
AsyncTriggerPromiseDictionary<PointerEventData> onPointerClicks;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onPointerClick, onPointerClicks);
}
void OnPointerClick(PointerEventData eventData)
{
TrySetResult(onPointerClick, onPointerClicks, eventData);
}
public UniTask<PointerEventData> OnPointerClickAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onPointerClick, ref onPointerClicks, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncPointerDownTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<PointerEventData> onPointerDown;
AsyncTriggerPromiseDictionary<PointerEventData> onPointerDowns;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onPointerDown, onPointerDowns);
}
void OnPointerDown(PointerEventData eventData)
{
TrySetResult(onPointerDown, onPointerDowns, eventData);
}
public UniTask<PointerEventData> OnPointerDownAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onPointerDown, ref onPointerDowns, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncPointerEnterTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<PointerEventData> onPointerEnter;
AsyncTriggerPromiseDictionary<PointerEventData> onPointerEnters;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onPointerEnter, onPointerEnters);
}
void OnPointerEnter(PointerEventData eventData)
{
TrySetResult(onPointerEnter, onPointerEnters, eventData);
}
public UniTask<PointerEventData> OnPointerEnterAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onPointerEnter, ref onPointerEnters, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncPointerExitTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<PointerEventData> onPointerExit;
AsyncTriggerPromiseDictionary<PointerEventData> onPointerExits;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onPointerExit, onPointerExits);
}
void OnPointerExit(PointerEventData eventData)
{
TrySetResult(onPointerExit, onPointerExits, eventData);
}
public UniTask<PointerEventData> OnPointerExitAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onPointerExit, ref onPointerExits, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncPointerUpTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<PointerEventData> onPointerUp;
AsyncTriggerPromiseDictionary<PointerEventData> onPointerUps;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onPointerUp, onPointerUps);
}
void OnPointerUp(PointerEventData eventData)
{
TrySetResult(onPointerUp, onPointerUps, eventData);
}
public UniTask<PointerEventData> OnPointerUpAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onPointerUp, ref onPointerUps, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,55 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncRectTransformTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<AsyncUnit> onRectTransformDimensionsChange;
AsyncTriggerPromiseDictionary<AsyncUnit> onRectTransformDimensionsChanges;
AsyncTriggerPromise<AsyncUnit> onRectTransformRemoved;
AsyncTriggerPromiseDictionary<AsyncUnit> onRectTransformRemoveds;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onRectTransformDimensionsChange, onRectTransformDimensionsChanges, onRectTransformRemoved, onRectTransformRemoveds);
}
void OnRectTransformDimensionsChange()
{
TrySetResult(onRectTransformDimensionsChange, onRectTransformDimensionsChanges, AsyncUnit.Default);
}
public UniTask OnRectTransformDimensionsChangeAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onRectTransformDimensionsChange, ref onRectTransformDimensionsChanges, cancellationToken);
}
void OnRectTransformRemoved()
{
TrySetResult(onRectTransformRemoved, onRectTransformRemoveds, AsyncUnit.Default);
}
public UniTask OnRectTransformRemovedAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onRectTransformRemoved, ref onRectTransformRemoveds, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncScrollTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<PointerEventData> onScroll;
AsyncTriggerPromiseDictionary<PointerEventData> onScrolls;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onScroll, onScrolls);
}
void OnScroll(PointerEventData eventData)
{
TrySetResult(onScroll, onScrolls, eventData);
}
public UniTask<PointerEventData> OnScrollAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onScroll, ref onScrolls, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncSelectTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<BaseEventData> onSelect;
AsyncTriggerPromiseDictionary<BaseEventData> onSelects;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onSelect, onSelects);
}
void OnSelect(BaseEventData eventData)
{
TrySetResult(onSelect, onSelects, eventData);
}
public UniTask<BaseEventData> OnSelectAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onSelect, ref onSelects, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,64 +0,0 @@
#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;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncStartTrigger : MonoBehaviour
{
bool awakeCalled = false;
bool called = false;
UniTaskCompletionSource promise;
void Awake()
{
awakeCalled = true;
}
void Start()
{
called = true;
promise?.TrySetResult();
}
public UniTask StartAsync()
{
if (called) return UniTask.CompletedTask;
if (!awakeCalled)
{
PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
}
return new UniTask(promise ?? (promise = new UniTaskCompletionSource()));
}
private void OnDestroy()
{
promise?.TrySetCanceled();
}
class AwakeMonitor : IPlayerLoopItem
{
readonly AsyncStartTrigger trigger;
public AwakeMonitor(AsyncStartTrigger trigger)
{
this.trigger = trigger;
}
public bool MoveNext()
{
if (trigger.awakeCalled) return false;
if (trigger == null)
{
trigger.OnDestroy();
return false;
}
return true;
}
}
}
}
#endif

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncSubmitTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<BaseEventData> onSubmit;
AsyncTriggerPromiseDictionary<BaseEventData> onSubmits;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onSubmit, onSubmits);
}
void OnSubmit(BaseEventData eventData)
{
TrySetResult(onSubmit, onSubmits, eventData);
}
public UniTask<BaseEventData> OnSubmitAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onSubmit, ref onSubmits, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,69 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncTransformChangedTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<AsyncUnit> onBeforeTransformParentChanged;
AsyncTriggerPromiseDictionary<AsyncUnit> onBeforeTransformParentChangeds;
AsyncTriggerPromise<AsyncUnit> onTransformParentChanged;
AsyncTriggerPromiseDictionary<AsyncUnit> onTransformParentChangeds;
AsyncTriggerPromise<AsyncUnit> onTransformChildrenChanged;
AsyncTriggerPromiseDictionary<AsyncUnit> onTransformChildrenChangeds;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onBeforeTransformParentChanged, onBeforeTransformParentChangeds, onTransformParentChanged, onTransformParentChangeds, onTransformChildrenChanged, onTransformChildrenChangeds);
}
void OnBeforeTransformParentChanged()
{
TrySetResult(onBeforeTransformParentChanged, onBeforeTransformParentChangeds, AsyncUnit.Default);
}
public UniTask OnBeforeTransformParentChangedAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onBeforeTransformParentChanged, ref onBeforeTransformParentChangeds, cancellationToken);
}
void OnTransformParentChanged()
{
TrySetResult(onTransformParentChanged, onTransformParentChangeds, AsyncUnit.Default);
}
public UniTask OnTransformParentChangedAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onTransformParentChanged, ref onTransformParentChangeds, cancellationToken);
}
void OnTransformChildrenChanged()
{
TrySetResult(onTransformChildrenChanged, onTransformChildrenChangeds, AsyncUnit.Default);
}
public UniTask OnTransformChildrenChangedAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onTransformChildrenChanged, ref onTransformChildrenChangeds, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,69 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncTrigger2DTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<Collider2D> onTriggerEnter2D;
AsyncTriggerPromiseDictionary<Collider2D> onTriggerEnter2Ds;
AsyncTriggerPromise<Collider2D> onTriggerExit2D;
AsyncTriggerPromiseDictionary<Collider2D> onTriggerExit2Ds;
AsyncTriggerPromise<Collider2D> onTriggerStay2D;
AsyncTriggerPromiseDictionary<Collider2D> onTriggerStay2Ds;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onTriggerEnter2D, onTriggerEnter2Ds, onTriggerExit2D, onTriggerExit2Ds, onTriggerStay2D, onTriggerStay2Ds);
}
void OnTriggerEnter2D(Collider2D other)
{
TrySetResult(onTriggerEnter2D, onTriggerEnter2Ds, other);
}
public UniTask<Collider2D> OnTriggerEnter2DAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onTriggerEnter2D, ref onTriggerEnter2Ds, cancellationToken);
}
void OnTriggerExit2D(Collider2D other)
{
TrySetResult(onTriggerExit2D, onTriggerExit2Ds, other);
}
public UniTask<Collider2D> OnTriggerExit2DAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onTriggerExit2D, ref onTriggerExit2Ds, cancellationToken);
}
void OnTriggerStay2D(Collider2D other)
{
TrySetResult(onTriggerStay2D, onTriggerStay2Ds, other);
}
public UniTask<Collider2D> OnTriggerStay2DAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onTriggerStay2D, ref onTriggerStay2Ds, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,271 +0,0 @@
#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 UniRx.Async.Internal;
using UnityEngine;
namespace UniRx.Async.Triggers
{
public interface ICancelablePromise
{
CancellationToken RegisteredCancellationToken { get; }
bool TrySetCanceled();
}
public class AsyncTriggerPromise<T> : ReusablePromise<T>, IPromise<T>, ICancelablePromise
{
public CancellationToken RegisteredCancellationToken { get; private set; }
public AsyncTriggerPromise()
: this(CancellationToken.None)
{
}
public AsyncTriggerPromise(CancellationToken cancellationToken)
{
this.RegisteredCancellationToken = cancellationToken;
TaskTracker.TrackActiveTask(this);
}
public override T GetResult()
{
if (Status == AwaiterStatus.Pending) return RawResult;
return base.GetResult();
}
public override bool TrySetResult(T result)
{
if (Status == AwaiterStatus.Pending)
{
// keep status as Pending.
this.ForceSetResult(result);
TryInvokeContinuation();
return true;
}
return false;
}
public override bool TrySetCanceled()
{
if (Status == AwaiterStatus.Canceled) return false;
TaskTracker.RemoveTracking(this);
return base.TrySetCanceled();
}
}
public interface ICancellationTokenKeyDictionary
{
void Remove(CancellationToken token);
}
public class AsyncTriggerPromiseDictionary<TPromiseType> :
Dictionary<CancellationToken, AsyncTriggerPromise<TPromiseType>>,
ICancellationTokenKeyDictionary,
IEnumerable<ICancelablePromise>
{
public AsyncTriggerPromiseDictionary()
: base(CancellationTokenEqualityComparer.Default)
{
}
IEnumerator<ICancelablePromise> IEnumerable<ICancelablePromise>.GetEnumerator()
{
return Values.GetEnumerator();
}
void ICancellationTokenKeyDictionary.Remove(CancellationToken token)
{
this.Remove(token);
}
}
public abstract class AsyncTriggerBase : MonoBehaviour
{
static readonly Action<object> Callback = CancelCallback;
bool calledAwake = false;
bool destroyCalled = false;
CancellationTokenRegistration[] registeredCancellations;
int registeredCancellationsCount;
protected abstract IEnumerable<ICancelablePromise> GetPromises();
static protected IEnumerable<ICancelablePromise> Concat(ICancelablePromise p1, IEnumerable<ICancelablePromise> p1s)
{
if (p1 != null) yield return p1;
if (p1s != null) foreach (var item in p1s) yield return item;
}
static protected IEnumerable<ICancelablePromise> Concat(
ICancelablePromise p1, IEnumerable<ICancelablePromise> p1s,
ICancelablePromise p2, IEnumerable<ICancelablePromise> p2s)
{
if (p1 != null) yield return p1;
if (p1s != null) foreach (var item in p1s) yield return item;
if (p2 != null) yield return p2;
if (p2s != null) foreach (var item in p2s) yield return item;
}
static protected IEnumerable<ICancelablePromise> Concat(
ICancelablePromise p1, IEnumerable<ICancelablePromise> p1s,
ICancelablePromise p2, IEnumerable<ICancelablePromise> p2s,
ICancelablePromise p3, IEnumerable<ICancelablePromise> p3s)
{
if (p1 != null) yield return p1;
if (p1s != null) foreach (var item in p1s) yield return item;
if (p2 != null) yield return p2;
if (p2s != null) foreach (var item in p2s) yield return item;
if (p3 != null) yield return p3;
if (p3s != null) foreach (var item in p3s) yield return item;
}
static protected IEnumerable<ICancelablePromise> Concat(
ICancelablePromise p1, IEnumerable<ICancelablePromise> p1s,
ICancelablePromise p2, IEnumerable<ICancelablePromise> p2s,
ICancelablePromise p3, IEnumerable<ICancelablePromise> p3s,
ICancelablePromise p4, IEnumerable<ICancelablePromise> p4s)
{
if (p1 != null) yield return p1;
if (p1s != null) foreach (var item in p1s) yield return item;
if (p2 != null) yield return p2;
if (p2s != null) foreach (var item in p2s) yield return item;
if (p3 != null) yield return p3;
if (p3s != null) foreach (var item in p3s) yield return item;
if (p4 != null) yield return p4;
if (p4s != null) foreach (var item in p4s) yield return item;
}
// otherwise...
static protected IEnumerable<ICancelablePromise> Concat(params object[] promises)
{
foreach (var item in promises)
{
if (item is ICancelablePromise p)
{
yield return p;
}
else if (item is IEnumerable<ICancelablePromise> ps)
{
foreach (var p2 in ps)
{
yield return p2;
}
}
}
}
protected UniTask<T> GetOrAddPromise<T>(ref AsyncTriggerPromise<T> promise, ref AsyncTriggerPromiseDictionary<T> promises, CancellationToken cancellationToken)
{
if (destroyCalled) return UniTask.FromCanceled<T>();
if (!cancellationToken.CanBeCanceled)
{
if (promise == null)
{
promise = new AsyncTriggerPromise<T>();
if (!calledAwake)
{
PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
}
}
return promise.Task;
}
if (promises == null) promises = new AsyncTriggerPromiseDictionary<T>();
if (promises.TryGetValue(cancellationToken, out var cancellablePromise))
{
return cancellablePromise.Task;
}
cancellablePromise = new AsyncTriggerPromise<T>();
promises.Add(cancellationToken, cancellablePromise);
if (!calledAwake)
{
PlayerLoopHelper.AddAction(PlayerLoopTiming.Update, new AwakeMonitor(this));
}
var registrationToken = cancellationToken.RegisterWithoutCaptureExecutionContext(Callback, Tuple.Create((ICancellationTokenKeyDictionary)promises, (ICancelablePromise)cancellablePromise));
if (registeredCancellations == null)
{
registeredCancellations = ArrayPool<CancellationTokenRegistration>.Shared.Rent(4);
}
ArrayPoolUtil.EnsureCapacity(ref registeredCancellations, registeredCancellationsCount + 1, ArrayPool<CancellationTokenRegistration>.Shared);
registeredCancellations[registeredCancellationsCount++] = registrationToken;
return cancellablePromise.Task;
}
static void CancelCallback(object state)
{
var tuple = (Tuple<ICancellationTokenKeyDictionary, ICancelablePromise>)state;
var dict = tuple.Item1;
var promise = tuple.Item2;
promise.TrySetCanceled();
dict.Remove(promise.RegisteredCancellationToken);
}
protected void TrySetResult<T>(ReusablePromise<T> promise, AsyncTriggerPromiseDictionary<T> promises, T value)
{
if (promise != null)
{
promise.TrySetResult(value);
}
if (promises != null)
{
PromiseHelper.TrySetResultAll(promises.Values, value);
}
}
void Awake()
{
calledAwake = true;
}
void OnDestroy()
{
if (destroyCalled) return;
destroyCalled = true;
foreach (var item in GetPromises())
{
item.TrySetCanceled();
}
if (registeredCancellations != null)
{
for (int i = 0; i < registeredCancellationsCount; i++)
{
registeredCancellations[i].Dispose();
registeredCancellations[i] = default(CancellationTokenRegistration);
}
ArrayPool<CancellationTokenRegistration>.Shared.Return(registeredCancellations);
}
}
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;
}
}
}
}
#endif

View File

@@ -1,511 +0,0 @@
#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 UniRx.Async.Triggers
{
public static 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();
}
/// <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;
}
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();
}
// Get Triggers.
/// <summary>Get for OnAnimatorIKAsync | OnAnimatorMoveAsync.</summary>
public static AsyncAnimatorTrigger GetAsyncAnimatorTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncAnimatorTrigger>(gameObject);
}
/// <summary>Get for OnAnimatorIKAsync | OnAnimatorMoveAsync.</summary>
public static AsyncAnimatorTrigger GetAsyncAnimatorTrigger(this Component component)
{
return component.gameObject.GetAsyncAnimatorTrigger();
}
/// <summary>Get for AwakeAsync.</summary>
public static AsyncAwakeTrigger GetAsyncAwakeTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncAwakeTrigger>(gameObject);
}
/// <summary>Get for AwakeAsync.</summary>
public static AsyncAwakeTrigger GetAsyncAwakeTrigger(this Component component)
{
return component.gameObject.GetAsyncAwakeTrigger();
}
/// <summary>Get for OnBeginDragAsync.</summary>
public static AsyncBeginDragTrigger GetAsyncBeginDragTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncBeginDragTrigger>(gameObject);
}
/// <summary>Get for OnBeginDragAsync.</summary>
public static AsyncBeginDragTrigger GetAsyncBeginDragTrigger(this Component component)
{
return component.gameObject.GetAsyncBeginDragTrigger();
}
/// <summary>Get for OnCancelAsync.</summary>
public static AsyncCancelTrigger GetAsyncCancelTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncCancelTrigger>(gameObject);
}
/// <summary>Get for OnCancelAsync.</summary>
public static AsyncCancelTrigger GetAsyncCancelTrigger(this Component component)
{
return component.gameObject.GetAsyncCancelTrigger();
}
/// <summary>Get for OnCanvasGroupChangedAsync.</summary>
public static AsyncCanvasGroupChangedTrigger GetAsyncCanvasGroupChangedTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncCanvasGroupChangedTrigger>(gameObject);
}
/// <summary>Get for OnCanvasGroupChangedAsync.</summary>
public static AsyncCanvasGroupChangedTrigger GetAsyncCanvasGroupChangedTrigger(this Component component)
{
return component.gameObject.GetAsyncCanvasGroupChangedTrigger();
}
/// <summary>Get for OnCollisionEnter2DAsync | OnCollisionExit2DAsync | OnCollisionStay2DAsync.</summary>
public static AsyncCollision2DTrigger GetAsyncCollision2DTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncCollision2DTrigger>(gameObject);
}
/// <summary>Get for OnCollisionEnter2DAsync | OnCollisionExit2DAsync | OnCollisionStay2DAsync.</summary>
public static AsyncCollision2DTrigger GetAsyncCollision2DTrigger(this Component component)
{
return component.gameObject.GetAsyncCollision2DTrigger();
}
/// <summary>Get for OnCollisionEnterAsync | OnCollisionExitAsync | OnCollisionStayAsync.</summary>
public static AsyncCollisionTrigger GetAsyncCollisionTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncCollisionTrigger>(gameObject);
}
/// <summary>Get for OnCollisionEnterAsync | OnCollisionExitAsync | OnCollisionStayAsync.</summary>
public static AsyncCollisionTrigger GetAsyncCollisionTrigger(this Component component)
{
return component.gameObject.GetAsyncCollisionTrigger();
}
/// <summary>Get for OnDeselectAsync.</summary>
public static AsyncDeselectTrigger GetAsyncDeselectTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncDeselectTrigger>(gameObject);
}
/// <summary>Get for OnDeselectAsync.</summary>
public static AsyncDeselectTrigger GetAsyncDeselectTrigger(this Component component)
{
return component.gameObject.GetAsyncDeselectTrigger();
}
/// <summary>Get for OnDestroyAsync.</summary>
public static AsyncDestroyTrigger GetAsyncDestroyTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncDestroyTrigger>(gameObject);
}
/// <summary>Get for OnDestroyAsync.</summary>
public static AsyncDestroyTrigger GetAsyncDestroyTrigger(this Component component)
{
return component.gameObject.GetAsyncDestroyTrigger();
}
/// <summary>Get for OnDragAsync.</summary>
public static AsyncDragTrigger GetAsyncDragTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncDragTrigger>(gameObject);
}
/// <summary>Get for OnDragAsync.</summary>
public static AsyncDragTrigger GetAsyncDragTrigger(this Component component)
{
return component.gameObject.GetAsyncDragTrigger();
}
/// <summary>Get for OnDropAsync.</summary>
public static AsyncDropTrigger GetAsyncDropTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncDropTrigger>(gameObject);
}
/// <summary>Get for OnDropAsync.</summary>
public static AsyncDropTrigger GetAsyncDropTrigger(this Component component)
{
return component.gameObject.GetAsyncDropTrigger();
}
/// <summary>Get for OnEnableAsync | OnDisableAsync.</summary>
public static AsyncEnableDisableTrigger GetAsyncEnableDisableTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncEnableDisableTrigger>(gameObject);
}
/// <summary>Get for OnEnableAsync | OnDisableAsync.</summary>
public static AsyncEnableDisableTrigger GetAsyncEnableDisableTrigger(this Component component)
{
return component.gameObject.GetAsyncEnableDisableTrigger();
}
/// <summary>Get for OnEndDragAsync.</summary>
public static AsyncEndDragTrigger GetAsyncEndDragTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncEndDragTrigger>(gameObject);
}
/// <summary>Get for OnEndDragAsync.</summary>
public static AsyncEndDragTrigger GetAsyncEndDragTrigger(this Component component)
{
return component.gameObject.GetAsyncEndDragTrigger();
}
/// <summary>Get for FixedUpdateAsync.</summary>
public static AsyncFixedUpdateTrigger GetAsyncFixedUpdateTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncFixedUpdateTrigger>(gameObject);
}
/// <summary>Get for FixedUpdateAsync.</summary>
public static AsyncFixedUpdateTrigger GetAsyncFixedUpdateTrigger(this Component component)
{
return component.gameObject.GetAsyncFixedUpdateTrigger();
}
/// <summary>Get for OnInitializePotentialDragAsync.</summary>
public static AsyncInitializePotentialDragTrigger GetAsyncInitializePotentialDragTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncInitializePotentialDragTrigger>(gameObject);
}
/// <summary>Get for OnInitializePotentialDragAsync.</summary>
public static AsyncInitializePotentialDragTrigger GetAsyncInitializePotentialDragTrigger(this Component component)
{
return component.gameObject.GetAsyncInitializePotentialDragTrigger();
}
/// <summary>Get for OnJointBreakAsync.</summary>
public static AsyncJointTrigger GetAsyncJointTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncJointTrigger>(gameObject);
}
/// <summary>Get for OnJointBreakAsync.</summary>
public static AsyncJointTrigger GetAsyncJointTrigger(this Component component)
{
return component.gameObject.GetAsyncJointTrigger();
}
/// <summary>Get for LateUpdateAsync.</summary>
public static AsyncLateUpdateTrigger GetAsyncLateUpdateTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncLateUpdateTrigger>(gameObject);
}
/// <summary>Get for LateUpdateAsync.</summary>
public static AsyncLateUpdateTrigger GetAsyncLateUpdateTrigger(this Component component)
{
return component.gameObject.GetAsyncLateUpdateTrigger();
}
#if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO)
/// <summary>Get for OnMouseDownAsync | OnMouseDragAsync | OnMouseEnterAsync | OnMouseExitAsync | OnMouseOverAsync | OnMouseUpAsync | OnMouseUpAsButtonAsync.</summary>
public static AsyncMouseTrigger GetAsyncMouseTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncMouseTrigger>(gameObject);
}
/// <summary>Get for OnMouseDownAsync | OnMouseDragAsync | OnMouseEnterAsync | OnMouseExitAsync | OnMouseOverAsync | OnMouseUpAsync | OnMouseUpAsButtonAsync.</summary>
public static AsyncMouseTrigger GetAsyncMouseTrigger(this Component component)
{
return component.gameObject.GetAsyncMouseTrigger();
}
#endif
/// <summary>Get for OnMoveAsync.</summary>
public static AsyncMoveTrigger GetAsyncMoveTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncMoveTrigger>(gameObject);
}
/// <summary>Get for OnMoveAsync.</summary>
public static AsyncMoveTrigger GetAsyncMoveTrigger(this Component component)
{
return component.gameObject.GetAsyncMoveTrigger();
}
/// <summary>Get for OnParticleCollisionAsync | OnParticleTriggerAsync.</summary>
public static AsyncParticleTrigger GetAsyncParticleTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncParticleTrigger>(gameObject);
}
/// <summary>Get for OnParticleCollisionAsync | OnParticleTriggerAsync.</summary>
public static AsyncParticleTrigger GetAsyncParticleTrigger(this Component component)
{
return component.gameObject.GetAsyncParticleTrigger();
}
/// <summary>Get for OnPointerClickAsync.</summary>
public static AsyncPointerClickTrigger GetAsyncPointerClickTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncPointerClickTrigger>(gameObject);
}
/// <summary>Get for OnPointerClickAsync.</summary>
public static AsyncPointerClickTrigger GetAsyncPointerClickTrigger(this Component component)
{
return component.gameObject.GetAsyncPointerClickTrigger();
}
/// <summary>Get for OnPointerDownAsync.</summary>
public static AsyncPointerDownTrigger GetAsyncPointerDownTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncPointerDownTrigger>(gameObject);
}
/// <summary>Get for OnPointerDownAsync.</summary>
public static AsyncPointerDownTrigger GetAsyncPointerDownTrigger(this Component component)
{
return component.gameObject.GetAsyncPointerDownTrigger();
}
/// <summary>Get for OnPointerEnterAsync.</summary>
public static AsyncPointerEnterTrigger GetAsyncPointerEnterTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncPointerEnterTrigger>(gameObject);
}
/// <summary>Get for OnPointerEnterAsync.</summary>
public static AsyncPointerEnterTrigger GetAsyncPointerEnterTrigger(this Component component)
{
return component.gameObject.GetAsyncPointerEnterTrigger();
}
/// <summary>Get for OnPointerExitAsync.</summary>
public static AsyncPointerExitTrigger GetAsyncPointerExitTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncPointerExitTrigger>(gameObject);
}
/// <summary>Get for OnPointerExitAsync.</summary>
public static AsyncPointerExitTrigger GetAsyncPointerExitTrigger(this Component component)
{
return component.gameObject.GetAsyncPointerExitTrigger();
}
/// <summary>Get for OnPointerUpAsync.</summary>
public static AsyncPointerUpTrigger GetAsyncPointerUpTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncPointerUpTrigger>(gameObject);
}
/// <summary>Get for OnPointerUpAsync.</summary>
public static AsyncPointerUpTrigger GetAsyncPointerUpTrigger(this Component component)
{
return component.gameObject.GetAsyncPointerUpTrigger();
}
/// <summary>Get for OnRectTransformDimensionsChange | OnRectTransformDimensionsChangeAsync | OnRectTransformRemoved | OnRectTransformRemovedAsync.</summary>
public static AsyncRectTransformTrigger GetAsyncRectTransformTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncRectTransformTrigger>(gameObject);
}
/// <summary>Get for OnRectTransformDimensionsChange | OnRectTransformDimensionsChangeAsync | OnRectTransformRemoved | OnRectTransformRemovedAsync.</summary>
public static AsyncRectTransformTrigger GetAsyncRectTransformTrigger(this Component component)
{
return component.gameObject.GetAsyncRectTransformTrigger();
}
/// <summary>Get for OnScrollAsync.</summary>
public static AsyncScrollTrigger GetAsyncScrollTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncScrollTrigger>(gameObject);
}
/// <summary>Get for OnScrollAsync.</summary>
public static AsyncScrollTrigger GetAsyncScrollTrigger(this Component component)
{
return component.gameObject.GetAsyncScrollTrigger();
}
/// <summary>Get for OnSelectAsync.</summary>
public static AsyncSelectTrigger GetAsyncSelectTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncSelectTrigger>(gameObject);
}
/// <summary>Get for OnSelectAsync.</summary>
public static AsyncSelectTrigger GetAsyncSelectTrigger(this Component component)
{
return component.gameObject.GetAsyncSelectTrigger();
}
/// <summary>Get for StartAsync.</summary>
public static AsyncStartTrigger GetAsyncStartTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncStartTrigger>(gameObject);
}
/// <summary>Get for StartAsync.</summary>
public static AsyncStartTrigger GetAsyncStartTrigger(this Component component)
{
return component.gameObject.GetAsyncStartTrigger();
}
/// <summary>Get for OnSubmitAsync.</summary>
public static AsyncSubmitTrigger GetAsyncSubmitTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncSubmitTrigger>(gameObject);
}
/// <summary>Get for OnSubmitAsync.</summary>
public static AsyncSubmitTrigger GetAsyncSubmitTrigger(this Component component)
{
return component.gameObject.GetAsyncSubmitTrigger();
}
/// <summary>Get for OnBeforeTransformParentChangedAsync | OnTransformParentChangedAsync | OnTransformChildrenChangedAsync.</summary>
public static AsyncTransformChangedTrigger GetAsyncTransformChangedTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncTransformChangedTrigger>(gameObject);
}
/// <summary>Get for OnBeforeTransformParentChangedAsync | OnTransformParentChangedAsync | OnTransformChildrenChangedAsync.</summary>
public static AsyncTransformChangedTrigger GetAsyncTransformChangedTrigger(this Component component)
{
return component.gameObject.GetAsyncTransformChangedTrigger();
}
/// <summary>Get for OnTriggerEnter2DAsync | OnTriggerExit2DAsync | OnTriggerStay2DAsync.</summary>
public static AsyncTrigger2DTrigger GetAsyncTrigger2DTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncTrigger2DTrigger>(gameObject);
}
/// <summary>Get for OnTriggerEnter2DAsync | OnTriggerExit2DAsync | OnTriggerStay2DAsync.</summary>
public static AsyncTrigger2DTrigger GetAsyncTrigger2DTrigger(this Component component)
{
return component.gameObject.GetAsyncTrigger2DTrigger();
}
/// <summary>Get for OnTriggerEnterAsync | OnTriggerExitAsync | OnTriggerStayAsync.</summary>
public static AsyncTriggerTrigger GetAsyncTriggerTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncTriggerTrigger>(gameObject);
}
/// <summary>Get for OnTriggerEnterAsync | OnTriggerExitAsync | OnTriggerStayAsync.</summary>
public static AsyncTriggerTrigger GetAsyncTriggerTrigger(this Component component)
{
return component.gameObject.GetAsyncTriggerTrigger();
}
/// <summary>Get for OnUpdateSelectedAsync.</summary>
public static AsyncUpdateSelectedTrigger GetAsyncUpdateSelectedTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncUpdateSelectedTrigger>(gameObject);
}
/// <summary>Get for OnUpdateSelectedAsync.</summary>
public static AsyncUpdateSelectedTrigger GetAsyncUpdateSelectedTrigger(this Component component)
{
return component.gameObject.GetAsyncUpdateSelectedTrigger();
}
/// <summary>Get for UpdateAsync.</summary>
public static AsyncUpdateTrigger GetAsyncUpdateTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncUpdateTrigger>(gameObject);
}
/// <summary>Get for UpdateAsync.</summary>
public static AsyncUpdateTrigger GetAsyncUpdateTrigger(this Component component)
{
return component.gameObject.GetAsyncUpdateTrigger();
}
/// <summary>Get for OnBecameInvisibleAsync | OnBecameVisibleAsync.</summary>
public static AsyncVisibleTrigger GetAsyncVisibleTrigger(this GameObject gameObject)
{
return GetOrAddComponent<AsyncVisibleTrigger>(gameObject);
}
/// <summary>Get for OnBecameInvisibleAsync | OnBecameVisibleAsync.</summary>
public static AsyncVisibleTrigger GetAsyncVisibleTrigger(this Component component)
{
return component.gameObject.GetAsyncVisibleTrigger();
}
}
}
#endif

View File

@@ -1,69 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncTriggerTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<Collider> onTriggerEnter;
AsyncTriggerPromiseDictionary<Collider> onTriggerEnters;
AsyncTriggerPromise<Collider> onTriggerExit;
AsyncTriggerPromiseDictionary<Collider> onTriggerExits;
AsyncTriggerPromise<Collider> onTriggerStay;
AsyncTriggerPromiseDictionary<Collider> onTriggerStays;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onTriggerEnter, onTriggerEnters, onTriggerExit, onTriggerExits, onTriggerStay, onTriggerStays);
}
void OnTriggerEnter(Collider other)
{
TrySetResult(onTriggerEnter, onTriggerEnters, other);
}
public UniTask<Collider> OnTriggerEnterAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onTriggerEnter, ref onTriggerEnters, cancellationToken);
}
void OnTriggerExit(Collider other)
{
TrySetResult(onTriggerExit, onTriggerExits, other);
}
public UniTask<Collider> OnTriggerExitAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onTriggerExit, ref onTriggerExits, cancellationToken);
}
void OnTriggerStay(Collider other)
{
TrySetResult(onTriggerStay, onTriggerStays, other);
}
public UniTask<Collider> OnTriggerStayAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onTriggerStay, ref onTriggerStays, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncUpdateSelectedTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<BaseEventData> onUpdateSelected;
AsyncTriggerPromiseDictionary<BaseEventData> onUpdateSelecteds;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onUpdateSelected, onUpdateSelecteds);
}
void OnUpdateSelected(BaseEventData eventData)
{
TrySetResult(onUpdateSelected, onUpdateSelecteds, eventData);
}
public UniTask<BaseEventData> OnUpdateSelectedAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onUpdateSelected, ref onUpdateSelecteds, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,41 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncUpdateTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<AsyncUnit> update;
AsyncTriggerPromiseDictionary<AsyncUnit> updates;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(update, updates);
}
void Update()
{
TrySetResult(update, updates, AsyncUnit.Default);
}
public UniTask UpdateAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref update, ref updates, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,55 +0,0 @@
#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;
using UnityEngine;
using UnityEngine.EventSystems;
namespace UniRx.Async.Triggers
{
[DisallowMultipleComponent]
public class AsyncVisibleTrigger : AsyncTriggerBase
{
AsyncTriggerPromise<AsyncUnit> onBecameInvisible;
AsyncTriggerPromiseDictionary<AsyncUnit> onBecameInvisibles;
AsyncTriggerPromise<AsyncUnit> onBecameVisible;
AsyncTriggerPromiseDictionary<AsyncUnit> onBecameVisibles;
protected override IEnumerable<ICancelablePromise> GetPromises()
{
return Concat(onBecameInvisible, onBecameInvisibles, onBecameVisible, onBecameVisibles);
}
void OnBecameInvisible()
{
TrySetResult(onBecameInvisible, onBecameInvisibles, AsyncUnit.Default);
}
public UniTask OnBecameInvisibleAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onBecameInvisible, ref onBecameInvisibles, cancellationToken);
}
void OnBecameVisible()
{
TrySetResult(onBecameVisible, onBecameVisibles, AsyncUnit.Default);
}
public UniTask OnBecameVisibleAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return GetOrAddPromise(ref onBecameVisible, ref onBecameVisibles, cancellationToken);
}
}
}
#endif

View File

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

View File

@@ -1,246 +0,0 @@
#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 UniRx.Async.Internal;
using UnityEngine;
namespace UniRx.Async
{
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(new YieldPromise(timing, cancellationToken));
}
public static UniTask<int> 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);
}
var source = new DelayFramePromise(delayFrameCount, delayTiming, cancellationToken);
return source.Task;
}
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 delayFrameCount. delayTimeSpan:" + delayTimeSpan);
}
return (ignoreTimeScale)
? new DelayIgnoreTimeScalePromise(delayTimeSpan, delayTiming, cancellationToken).Task
: new DelayPromise(delayTimeSpan, delayTiming, cancellationToken).Task;
}
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 delayFrameCount. delayTimeSpan:" + delayTimeSpan);
}
return (ignoreTimeScale)
? new DelayIgnoreTimeScalePromise(delayTimeSpan, delayTiming, cancellationToken).Task
: new DelayPromise(delayTimeSpan, delayTiming, cancellationToken).Task;
}
class YieldPromise : PlayerLoopReusablePromiseBase
{
public YieldPromise(PlayerLoopTiming timing, CancellationToken cancellationToken)
: base(timing, cancellationToken, 2)
{
}
protected override void OnRunningStart()
{
}
public override bool MoveNext()
{
Complete();
if (cancellationToken.IsCancellationRequested)
{
TrySetCanceled();
}
else
{
TrySetResult();
}
return false;
}
}
class DelayFramePromise : PlayerLoopReusablePromiseBase<int>
{
readonly int delayFrameCount;
int currentFrameCount;
public DelayFramePromise(int delayFrameCount, PlayerLoopTiming timing, CancellationToken cancellationToken)
: base(timing, cancellationToken, 2)
{
this.delayFrameCount = delayFrameCount;
this.currentFrameCount = 0;
}
protected override void OnRunningStart()
{
currentFrameCount = 0;
}
public override bool MoveNext()
{
if (cancellationToken.IsCancellationRequested)
{
Complete();
TrySetCanceled();
return false;
}
if (currentFrameCount == delayFrameCount)
{
Complete();
TrySetResult(currentFrameCount);
return false;
}
currentFrameCount++;
return true;
}
}
class DelayPromise : PlayerLoopReusablePromiseBase
{
readonly float delayFrameTimeSpan;
float elapsed;
public DelayPromise(TimeSpan delayFrameTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken)
: base(timing, cancellationToken, 2)
{
this.delayFrameTimeSpan = (float)delayFrameTimeSpan.TotalSeconds;
}
protected override void OnRunningStart()
{
this.elapsed = 0.0f;
}
public override bool MoveNext()
{
if (cancellationToken.IsCancellationRequested)
{
Complete();
TrySetCanceled();
return false;
}
elapsed += Time.deltaTime;
if (elapsed >= delayFrameTimeSpan)
{
Complete();
TrySetResult();
return false;
}
return true;
}
}
class DelayIgnoreTimeScalePromise : PlayerLoopReusablePromiseBase
{
readonly float delayFrameTimeSpan;
float elapsed;
public DelayIgnoreTimeScalePromise(TimeSpan delayFrameTimeSpan, PlayerLoopTiming timing, CancellationToken cancellationToken)
: base(timing, cancellationToken, 2)
{
this.delayFrameTimeSpan = (float)delayFrameTimeSpan.TotalSeconds;
}
protected override void OnRunningStart()
{
this.elapsed = 0.0f;
}
public override bool MoveNext()
{
if (cancellationToken.IsCancellationRequested)
{
Complete();
TrySetCanceled();
return false;
}
elapsed += Time.unscaledDeltaTime;
if (elapsed >= delayFrameTimeSpan)
{
Complete();
TrySetResult();
return false;
}
return true;
}
}
}
public 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 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

View File

@@ -1,121 +0,0 @@
#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 UniRx.Async
{
public partial struct UniTask
{
static readonly UniTask CanceledUniTask = new Func<UniTask>(() =>
{
var promise = new UniTaskCompletionSource<AsyncUnit>();
promise.TrySetCanceled();
promise.MarkHandled();
return new UniTask(promise);
})();
public static UniTask CompletedTask
{
get
{
return new UniTask();
}
}
public static UniTask FromException(Exception ex)
{
var promise = new UniTaskCompletionSource<AsyncUnit>();
promise.TrySetException(ex);
promise.MarkHandled();
return new UniTask(promise);
}
public static UniTask<T> FromException<T>(Exception ex)
{
var promise = new UniTaskCompletionSource<T>();
promise.TrySetException(ex);
promise.MarkHandled();
return new UniTask<T>(promise);
}
public static UniTask<T> FromResult<T>(T value)
{
return new UniTask<T>(value);
}
public static UniTask FromCanceled()
{
return CanceledUniTask;
}
public static UniTask<T> FromCanceled<T>()
{
return CanceledUniTaskCache<T>.Task;
}
public static UniTask FromCanceled(CancellationToken token)
{
var promise = new UniTaskCompletionSource<AsyncUnit>();
promise.TrySetException(new OperationCanceledException(token));
promise.MarkHandled();
return new UniTask(promise);
}
public static UniTask<T> FromCanceled<T>(CancellationToken token)
{
var promise = new UniTaskCompletionSource<T>();
promise.TrySetException(new OperationCanceledException(token));
promise.MarkHandled();
return new UniTask<T>(promise);
}
/// <summary>shorthand of new UniTask[T](Func[UniTask[T]] factory)</summary>
public static UniTask<T> Lazy<T>(Func<UniTask<T>> factory)
{
return new UniTask<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();
}
/// <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();
}
static class CanceledUniTaskCache<T>
{
public static readonly UniTask<T> Task;
static CanceledUniTaskCache()
{
var promise = new UniTaskCompletionSource<T>();
promise.TrySetCanceled();
promise.MarkHandled();
Task = new UniTask<T>(promise);
}
}
}
internal static class CompletedTasks
{
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

View File

@@ -1,176 +0,0 @@
#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 System.Threading.Tasks;
using UniRx.Async.Internal;
namespace UniRx.Async
{
public partial struct UniTask
{
/// <summary>
/// If running on mainthread, do nothing. Otherwise, same as UniTask.Yield(PlayerLoopTiming.Update).
/// </summary>
public static SwitchToMainThreadAwaitable SwitchToMainThread()
{
return new SwitchToMainThreadAwaitable();
}
public static SwitchToThreadPoolAwaitable SwitchToThreadPool()
{
return new SwitchToThreadPoolAwaitable();
}
public static SwitchToTaskPoolAwaitable SwitchToTaskPool()
{
return new SwitchToTaskPoolAwaitable();
}
public static SwitchToSynchronizationContextAwaitable SwitchToSynchronizationContext(SynchronizationContext syncContext)
{
Error.ThrowArgumentNullException(syncContext, nameof(syncContext));
return new SwitchToSynchronizationContextAwaitable(syncContext);
}
}
public struct SwitchToMainThreadAwaitable
{
public Awaiter GetAwaiter() => new Awaiter();
public struct Awaiter : ICriticalNotifyCompletion
{
public bool IsCompleted
{
get
{
var currentThreadId = System.Threading.Thread.CurrentThread.ManagedThreadId;
if (PlayerLoopHelper.MainThreadId == currentThreadId)
{
return true; // run immediate.
}
else
{
return false; // register continuation.
}
}
}
public void GetResult() { }
public void OnCompleted(Action continuation)
{
PlayerLoopHelper.AddContinuation(PlayerLoopTiming.Update, continuation);
}
public void UnsafeOnCompleted(Action continuation)
{
PlayerLoopHelper.AddContinuation(PlayerLoopTiming.Update, continuation);
}
}
}
public struct SwitchToThreadPoolAwaitable
{
public Awaiter GetAwaiter() => new Awaiter();
public struct Awaiter : ICriticalNotifyCompletion
{
static readonly WaitCallback switchToCallback = Callback;
public bool IsCompleted => false;
public void GetResult() { }
public void OnCompleted(Action continuation)
{
ThreadPool.UnsafeQueueUserWorkItem(switchToCallback, continuation);
}
public void UnsafeOnCompleted(Action continuation)
{
ThreadPool.UnsafeQueueUserWorkItem(switchToCallback, continuation);
}
static void Callback(object state)
{
var continuation = (Action)state;
continuation();
}
}
}
public struct SwitchToTaskPoolAwaitable
{
public Awaiter GetAwaiter() => new Awaiter();
public struct Awaiter : ICriticalNotifyCompletion
{
static readonly Action<object> switchToCallback = Callback;
public bool IsCompleted => false;
public void GetResult() { }
public void OnCompleted(Action continuation)
{
Task.Factory.StartNew(switchToCallback, continuation, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
}
public void UnsafeOnCompleted(Action continuation)
{
Task.Factory.StartNew(switchToCallback, continuation, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
}
static void Callback(object state)
{
var continuation = (Action)state;
continuation();
}
}
}
public struct SwitchToSynchronizationContextAwaitable
{
readonly SynchronizationContext synchronizationContext;
public SwitchToSynchronizationContextAwaitable(SynchronizationContext synchronizationContext)
{
this.synchronizationContext = synchronizationContext;
}
public Awaiter GetAwaiter() => new Awaiter(synchronizationContext);
public struct Awaiter : ICriticalNotifyCompletion
{
static readonly SendOrPostCallback switchToCallback = Callback;
readonly SynchronizationContext synchronizationContext;
public Awaiter(SynchronizationContext synchronizationContext)
{
this.synchronizationContext = synchronizationContext;
}
public bool IsCompleted => false;
public void GetResult() { }
public void OnCompleted(Action continuation)
{
synchronizationContext.Post(switchToCallback, continuation);
}
public void UnsafeOnCompleted(Action continuation)
{
synchronizationContext.Post(switchToCallback, continuation);
}
static void Callback(object state)
{
var continuation = (Action)state;
continuation();
}
}
}
}
#endif

View File

@@ -1,235 +0,0 @@
#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 UniRx.Async.Internal;
namespace UniRx.Async
{
public partial struct UniTask
{
public static UniTask WaitUntil(Func<bool> predicate, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
{
var promise = new WaitUntilPromise(predicate, timing, cancellationToken);
return promise.Task;
}
public static UniTask WaitWhile(Func<bool> predicate, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
{
var promise = new WaitWhilePromise(predicate, timing, cancellationToken);
return promise.Task;
}
public static UniTask<U> WaitUntilValueChanged<T, U>(T target, Func<T, U> monitorFunction, PlayerLoopTiming monitorTiming = PlayerLoopTiming.Update, IEqualityComparer<U> equalityComparer = null, CancellationToken cancellationToken = default(CancellationToken))
where T : class
{
var unityObject = target as UnityEngine.Object;
var isUnityObject = !object.ReferenceEquals(target, null); // don't use (unityObject == null)
return (isUnityObject)
? new WaitUntilValueChangedUnityObjectPromise<T, U>(target, monitorFunction, equalityComparer, monitorTiming, cancellationToken).Task
: new WaitUntilValueChangedStandardObjectPromise<T, U>(target, monitorFunction, equalityComparer, monitorTiming, cancellationToken).Task;
}
class WaitUntilPromise : PlayerLoopReusablePromiseBase
{
readonly Func<bool> predicate;
public WaitUntilPromise(Func<bool> predicate, PlayerLoopTiming timing, CancellationToken cancellationToken)
: base(timing, cancellationToken, 1)
{
this.predicate = predicate;
}
protected override void OnRunningStart()
{
}
public override bool MoveNext()
{
if (cancellationToken.IsCancellationRequested)
{
Complete();
TrySetCanceled();
return false;
}
bool result = default(bool);
try
{
result = predicate();
}
catch (Exception ex)
{
Complete();
TrySetException(ex);
return false;
}
if (result)
{
Complete();
TrySetResult();
return false;
}
return true;
}
}
class WaitWhilePromise : PlayerLoopReusablePromiseBase
{
readonly Func<bool> predicate;
public WaitWhilePromise(Func<bool> predicate, PlayerLoopTiming timing, CancellationToken cancellationToken)
: base(timing, cancellationToken, 1)
{
this.predicate = predicate;
}
protected override void OnRunningStart()
{
}
public override bool MoveNext()
{
if (cancellationToken.IsCancellationRequested)
{
Complete();
TrySetCanceled();
return false;
}
bool result = default(bool);
try
{
result = predicate();
}
catch (Exception ex)
{
Complete();
TrySetException(ex);
return false;
}
if (!result)
{
Complete();
TrySetResult();
return false;
}
return true;
}
}
// where T : UnityEngine.Object, can not add constraint
class WaitUntilValueChangedUnityObjectPromise<T, U> : PlayerLoopReusablePromiseBase<U>
{
readonly T target;
readonly Func<T, U> monitorFunction;
readonly IEqualityComparer<U> equalityComparer;
U currentValue;
public WaitUntilValueChangedUnityObjectPromise(T target, Func<T, U> monitorFunction, IEqualityComparer<U> equalityComparer, PlayerLoopTiming timing, CancellationToken cancellationToken)
: base(timing, cancellationToken, 1)
{
this.target = target;
this.monitorFunction = monitorFunction;
this.equalityComparer = equalityComparer ?? UnityEqualityComparer.GetDefault<U>();
this.currentValue = monitorFunction(target);
}
protected override void OnRunningStart()
{
}
public override bool MoveNext()
{
if (cancellationToken.IsCancellationRequested || target == null) // destroyed = cancel.
{
Complete();
TrySetCanceled();
return false;
}
U nextValue = default(U);
try
{
nextValue = monitorFunction(target);
if (equalityComparer.Equals(currentValue, nextValue))
{
return true;
}
}
catch (Exception ex)
{
Complete();
TrySetException(ex);
return false;
}
Complete();
currentValue = nextValue;
TrySetResult(nextValue);
return false;
}
}
class WaitUntilValueChangedStandardObjectPromise<T, U> : PlayerLoopReusablePromiseBase<U>
where T : class
{
readonly WeakReference<T> target;
readonly Func<T, U> monitorFunction;
readonly IEqualityComparer<U> equalityComparer;
U currentValue;
public WaitUntilValueChangedStandardObjectPromise(T target, Func<T, U> monitorFunction, IEqualityComparer<U> equalityComparer, PlayerLoopTiming timing, CancellationToken cancellationToken)
: base(timing, cancellationToken, 1)
{
this.target = new WeakReference<T>(target, false); // wrap in WeakReference.
this.monitorFunction = monitorFunction;
this.equalityComparer = equalityComparer ?? UnityEqualityComparer.GetDefault<U>();
this.currentValue = monitorFunction(target);
}
protected override void OnRunningStart()
{
}
public override bool MoveNext()
{
if (cancellationToken.IsCancellationRequested || !target.TryGetTarget(out var t))
{
Complete();
TrySetCanceled();
return false;
}
U nextValue = default(U);
try
{
nextValue = monitorFunction(t);
if (equalityComparer.Equals(currentValue, nextValue))
{
return true;
}
}
catch (Exception ex)
{
Complete();
TrySetException(ex);
return false;
}
Complete();
currentValue = nextValue;
TrySetResult(nextValue);
return false;
}
}
}
}
#endif

File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More