Init TEngine4.0.0

2025-08-14 16:51:28 +00:00 · 2023-10-08 15:21:33 +08:00
parent 4c8c37ffd8
commit 8c3d6308b9
3773 changed files with 49313 additions and 150734 deletions
--- a/UnityProject/Packages/UniTask/Runtime/Linq/UnityExtensions/EveryUpdate.cs
+++ b/UnityProject/Packages/UniTask/Runtime/Linq/UnityExtensions/EveryUpdate.cs
@@ -0,0 +1,77 @@
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Linq
+{
+    public static partial class UniTaskAsyncEnumerable
+    {
+        public static IUniTaskAsyncEnumerable<AsyncUnit> EveryUpdate(PlayerLoopTiming updateTiming = PlayerLoopTiming.Update)
+        {
+            return new EveryUpdate(updateTiming);
+        }
+    }
+
+    internal class EveryUpdate : IUniTaskAsyncEnumerable<AsyncUnit>
+    {
+        readonly PlayerLoopTiming updateTiming;
+
+        public EveryUpdate(PlayerLoopTiming updateTiming)
+        {
+            this.updateTiming = updateTiming;
+        }
+
+        public IUniTaskAsyncEnumerator<AsyncUnit> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new _EveryUpdate(updateTiming, cancellationToken);
+        }
+
+        class _EveryUpdate : MoveNextSource, IUniTaskAsyncEnumerator<AsyncUnit>, IPlayerLoopItem
+        {
+            readonly PlayerLoopTiming updateTiming;
+            CancellationToken cancellationToken;
+
+            bool disposed;
+
+            public _EveryUpdate(PlayerLoopTiming updateTiming, CancellationToken cancellationToken)
+            {
+                this.updateTiming = updateTiming;
+                this.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(this, 2);
+                PlayerLoopHelper.AddAction(updateTiming, this);
+            }
+
+            public AsyncUnit Current => default;
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                // return false instead of throw
+                if (disposed || cancellationToken.IsCancellationRequested) return CompletedTasks.False;
+
+                completionSource.Reset();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            public UniTask DisposeAsync()
+            {
+                if (!disposed)
+                {
+                    disposed = true;
+                    TaskTracker.RemoveTracking(this);
+                }
+                return default;
+            }
+
+            public bool MoveNext()
+            {
+                if (disposed || cancellationToken.IsCancellationRequested)
+                {
+                    completionSource.TrySetResult(false);
+                    return false;
+                }
+
+                completionSource.TrySetResult(true);
+                return true;
+            }
+        }
+    }
+}
--- a/UnityProject/Packages/UniTask/Runtime/Linq/UnityExtensions/EveryUpdate.cs.meta
+++ b/UnityProject/Packages/UniTask/Runtime/Linq/UnityExtensions/EveryUpdate.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 00520eb52e49b5b4e8d9870d6ff1aced
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/UnityProject/Packages/UniTask/Runtime/Linq/UnityExtensions/EveryValueChanged.cs
+++ b/UnityProject/Packages/UniTask/Runtime/Linq/UnityExtensions/EveryValueChanged.cs
@@ -0,0 +1,240 @@
+using Cysharp.Threading.Tasks.Internal;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Cysharp.Threading.Tasks.Linq
+{
+    public static partial class UniTaskAsyncEnumerable
+    {
+        public static IUniTaskAsyncEnumerable<TProperty> EveryValueChanged<TTarget, TProperty>(TTarget target, Func<TTarget, TProperty> propertySelector, PlayerLoopTiming monitorTiming = PlayerLoopTiming.Update, IEqualityComparer<TProperty> equalityComparer = null)
+            where TTarget : class
+        {
+            var unityObject = target as UnityEngine.Object;
+            var isUnityObject = target is UnityEngine.Object; // don't use (unityObject == null)
+
+            if (isUnityObject)
+            {
+                return new EveryValueChangedUnityObject<TTarget, TProperty>(target, propertySelector, equalityComparer ?? UnityEqualityComparer.GetDefault<TProperty>(), monitorTiming);
+            }
+            else
+            {
+                return new EveryValueChangedStandardObject<TTarget, TProperty>(target, propertySelector, equalityComparer ?? UnityEqualityComparer.GetDefault<TProperty>(), monitorTiming);
+            }
+        }
+    }
+
+    internal sealed class EveryValueChangedUnityObject<TTarget, TProperty> : IUniTaskAsyncEnumerable<TProperty>
+    {
+        readonly TTarget target;
+        readonly Func<TTarget, TProperty> propertySelector;
+        readonly IEqualityComparer<TProperty> equalityComparer;
+        readonly PlayerLoopTiming monitorTiming;
+
+        public EveryValueChangedUnityObject(TTarget target, Func<TTarget, TProperty> propertySelector, IEqualityComparer<TProperty> equalityComparer, PlayerLoopTiming monitorTiming)
+        {
+            this.target = target;
+            this.propertySelector = propertySelector;
+            this.equalityComparer = equalityComparer;
+            this.monitorTiming = monitorTiming;
+        }
+
+        public IUniTaskAsyncEnumerator<TProperty> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new _EveryValueChanged(target, propertySelector, equalityComparer, monitorTiming, cancellationToken);
+        }
+
+        sealed class _EveryValueChanged : MoveNextSource, IUniTaskAsyncEnumerator<TProperty>, IPlayerLoopItem
+        {
+            readonly TTarget target;
+            readonly UnityEngine.Object targetAsUnityObject;
+            readonly IEqualityComparer<TProperty> equalityComparer;
+            readonly Func<TTarget, TProperty> propertySelector;
+            CancellationToken cancellationToken;
+
+            bool first;
+            TProperty currentValue;
+            bool disposed;
+
+            public _EveryValueChanged(TTarget target, Func<TTarget, TProperty> propertySelector, IEqualityComparer<TProperty> equalityComparer, PlayerLoopTiming monitorTiming, CancellationToken cancellationToken)
+            {
+                this.target = target;
+                this.targetAsUnityObject = target as UnityEngine.Object;
+                this.propertySelector = propertySelector;
+                this.equalityComparer = equalityComparer;
+                this.cancellationToken = cancellationToken;
+                this.first = true;
+                TaskTracker.TrackActiveTask(this, 2);
+                PlayerLoopHelper.AddAction(monitorTiming, this);
+            }
+
+            public TProperty Current => currentValue;
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                // return false instead of throw
+                if (disposed || cancellationToken.IsCancellationRequested) return CompletedTasks.False;
+
+                if (first)
+                {
+                    first = false;
+                    if (targetAsUnityObject == null)
+                    {
+                        return CompletedTasks.False;
+                    }
+                    this.currentValue = propertySelector(target);
+                    return CompletedTasks.True;
+                }
+
+                completionSource.Reset();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            public UniTask DisposeAsync()
+            {
+                if (!disposed)
+                {
+                    disposed = true;
+                    TaskTracker.RemoveTracking(this);
+                }
+                return default;
+            }
+
+            public bool MoveNext()
+            {
+                if (disposed || cancellationToken.IsCancellationRequested || targetAsUnityObject == null) // destroyed = cancel.
+                {
+                    completionSource.TrySetResult(false);
+                    DisposeAsync().Forget();
+                    return false;
+                }
+
+                TProperty nextValue = default(TProperty);
+                try
+                {
+                    nextValue = propertySelector(target);
+                    if (equalityComparer.Equals(currentValue, nextValue))
+                    {
+                        return true;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    completionSource.TrySetException(ex);
+                    DisposeAsync().Forget();
+                    return false;
+                }
+
+                currentValue = nextValue;
+                completionSource.TrySetResult(true);
+                return true;
+            }
+        }
+    }
+
+    internal sealed class EveryValueChangedStandardObject<TTarget, TProperty> : IUniTaskAsyncEnumerable<TProperty>
+        where TTarget : class
+    {
+        readonly WeakReference<TTarget> target;
+        readonly Func<TTarget, TProperty> propertySelector;
+        readonly IEqualityComparer<TProperty> equalityComparer;
+        readonly PlayerLoopTiming monitorTiming;
+
+        public EveryValueChangedStandardObject(TTarget target, Func<TTarget, TProperty> propertySelector, IEqualityComparer<TProperty> equalityComparer, PlayerLoopTiming monitorTiming)
+        {
+            this.target = new WeakReference<TTarget>(target, false);
+            this.propertySelector = propertySelector;
+            this.equalityComparer = equalityComparer;
+            this.monitorTiming = monitorTiming;
+        }
+
+        public IUniTaskAsyncEnumerator<TProperty> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new _EveryValueChanged(target, propertySelector, equalityComparer, monitorTiming, cancellationToken);
+        }
+
+        sealed class _EveryValueChanged : MoveNextSource, IUniTaskAsyncEnumerator<TProperty>, IPlayerLoopItem
+        {
+            readonly WeakReference<TTarget> target;
+            readonly IEqualityComparer<TProperty> equalityComparer;
+            readonly Func<TTarget, TProperty> propertySelector;
+            CancellationToken cancellationToken;
+
+            bool first;
+            TProperty currentValue;
+            bool disposed;
+
+            public _EveryValueChanged(WeakReference<TTarget> target, Func<TTarget, TProperty> propertySelector, IEqualityComparer<TProperty> equalityComparer, PlayerLoopTiming monitorTiming, CancellationToken cancellationToken)
+            {
+                this.target = target;
+                this.propertySelector = propertySelector;
+                this.equalityComparer = equalityComparer;
+                this.cancellationToken = cancellationToken;
+                this.first = true;
+                TaskTracker.TrackActiveTask(this, 2);
+                PlayerLoopHelper.AddAction(monitorTiming, this);
+            }
+
+            public TProperty Current => currentValue;
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                if (disposed || cancellationToken.IsCancellationRequested) return CompletedTasks.False;
+
+                if (first)
+                {
+                    first = false;
+                    if (!target.TryGetTarget(out var t))
+                    {
+                        return CompletedTasks.False;
+                    }
+                    this.currentValue = propertySelector(t);
+                    return CompletedTasks.True;
+                }
+
+                completionSource.Reset();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            public UniTask DisposeAsync()
+            {
+                if (!disposed)
+                {
+                    disposed = true;
+                    TaskTracker.RemoveTracking(this);
+                }
+                return default;
+            }
+
+            public bool MoveNext()
+            {
+                if (disposed || cancellationToken.IsCancellationRequested || !target.TryGetTarget(out var t))
+                {
+                    completionSource.TrySetResult(false);
+                    DisposeAsync().Forget();
+                    return false;
+                }
+
+                TProperty nextValue = default(TProperty);
+                try
+                {
+                    nextValue = propertySelector(t);
+                    if (equalityComparer.Equals(currentValue, nextValue))
+                    {
+                        return true;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    completionSource.TrySetException(ex);
+                    DisposeAsync().Forget();
+                    return false;
+                }
+
+                currentValue = nextValue;
+                completionSource.TrySetResult(true);
+                return true;
+            }
+        }
+    }
+}
--- a/UnityProject/Packages/UniTask/Runtime/Linq/UnityExtensions/EveryValueChanged.cs.meta
+++ b/UnityProject/Packages/UniTask/Runtime/Linq/UnityExtensions/EveryValueChanged.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1ec39f1c41c305344854782c935ad354
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/UnityProject/Packages/UniTask/Runtime/Linq/UnityExtensions/Timer.cs
+++ b/UnityProject/Packages/UniTask/Runtime/Linq/UnityExtensions/Timer.cs
@@ -0,0 +1,312 @@
+using System;
+using System.Threading;
+using UnityEngine;
+
+namespace Cysharp.Threading.Tasks.Linq
+{
+    public static partial class UniTaskAsyncEnumerable
+    {
+        public static IUniTaskAsyncEnumerable<AsyncUnit> Timer(TimeSpan dueTime, PlayerLoopTiming updateTiming = PlayerLoopTiming.Update, bool ignoreTimeScale = false)
+        {
+            return new Timer(dueTime, null, updateTiming, ignoreTimeScale);
+        }
+
+        public static IUniTaskAsyncEnumerable<AsyncUnit> Timer(TimeSpan dueTime, TimeSpan period, PlayerLoopTiming updateTiming = PlayerLoopTiming.Update, bool ignoreTimeScale = false)
+        {
+            return new Timer(dueTime, period, updateTiming, ignoreTimeScale);
+        }
+
+        public static IUniTaskAsyncEnumerable<AsyncUnit> Interval(TimeSpan period, PlayerLoopTiming updateTiming = PlayerLoopTiming.Update, bool ignoreTimeScale = false)
+        {
+            return new Timer(period, period, updateTiming, ignoreTimeScale);
+        }
+
+        public static IUniTaskAsyncEnumerable<AsyncUnit> TimerFrame(int dueTimeFrameCount, PlayerLoopTiming updateTiming = PlayerLoopTiming.Update)
+        {
+            if (dueTimeFrameCount < 0)
+            {
+                throw new ArgumentOutOfRangeException("Delay does not allow minus delayFrameCount. dueTimeFrameCount:" + dueTimeFrameCount);
+            }
+
+            return new TimerFrame(dueTimeFrameCount, null, updateTiming);
+        }
+
+        public static IUniTaskAsyncEnumerable<AsyncUnit> TimerFrame(int dueTimeFrameCount, int periodFrameCount, PlayerLoopTiming updateTiming = PlayerLoopTiming.Update)
+        {
+            if (dueTimeFrameCount < 0)
+            {
+                throw new ArgumentOutOfRangeException("Delay does not allow minus delayFrameCount. dueTimeFrameCount:" + dueTimeFrameCount);
+            }
+            if (periodFrameCount < 0)
+            {
+                throw new ArgumentOutOfRangeException("Delay does not allow minus periodFrameCount. periodFrameCount:" + dueTimeFrameCount);
+            }
+
+            return new TimerFrame(dueTimeFrameCount, periodFrameCount, updateTiming);
+        }
+
+        public static IUniTaskAsyncEnumerable<AsyncUnit> IntervalFrame(int intervalFrameCount, PlayerLoopTiming updateTiming = PlayerLoopTiming.Update)
+        {
+            if (intervalFrameCount < 0)
+            {
+                throw new ArgumentOutOfRangeException("Delay does not allow minus intervalFrameCount. intervalFrameCount:" + intervalFrameCount);
+            }
+            return new TimerFrame(intervalFrameCount, intervalFrameCount, updateTiming);
+        }
+    }
+
+    internal class Timer : IUniTaskAsyncEnumerable<AsyncUnit>
+    {
+        readonly PlayerLoopTiming updateTiming;
+        readonly TimeSpan dueTime;
+        readonly TimeSpan? period;
+        readonly bool ignoreTimeScale;
+
+        public Timer(TimeSpan dueTime, TimeSpan? period, PlayerLoopTiming updateTiming, bool ignoreTimeScale)
+        {
+            this.updateTiming = updateTiming;
+            this.dueTime = dueTime;
+            this.period = period;
+            this.ignoreTimeScale = ignoreTimeScale;
+        }
+
+        public IUniTaskAsyncEnumerator<AsyncUnit> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new _Timer(dueTime, period, updateTiming, ignoreTimeScale, cancellationToken);
+        }
+
+        class _Timer : MoveNextSource, IUniTaskAsyncEnumerator<AsyncUnit>, IPlayerLoopItem
+        {
+            readonly float dueTime;
+            readonly float? period;
+            readonly PlayerLoopTiming updateTiming;
+            readonly bool ignoreTimeScale;
+            CancellationToken cancellationToken;
+
+            int initialFrame;
+            float elapsed;
+            bool dueTimePhase;
+            bool completed;
+            bool disposed;
+
+            public _Timer(TimeSpan dueTime, TimeSpan? period, PlayerLoopTiming updateTiming, bool ignoreTimeScale, CancellationToken cancellationToken)
+            {
+                this.dueTime = (float)dueTime.TotalSeconds;
+                this.period = (period == null) ? null : (float?)period.Value.TotalSeconds;
+
+                if (this.dueTime <= 0) this.dueTime = 0;
+                if (this.period != null)
+                {
+                    if (this.period <= 0) this.period = 1;
+                }
+
+                this.initialFrame = PlayerLoopHelper.IsMainThread ? Time.frameCount : -1;
+                this.dueTimePhase = true;
+                this.updateTiming = updateTiming;
+                this.ignoreTimeScale = ignoreTimeScale;
+                this.cancellationToken = cancellationToken;
+                TaskTracker.TrackActiveTask(this, 2);
+                PlayerLoopHelper.AddAction(updateTiming, this);
+            }
+
+            public AsyncUnit Current => default;
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                // return false instead of throw
+                if (disposed || cancellationToken.IsCancellationRequested || completed) return CompletedTasks.False;
+
+                // reset value here.
+                this.elapsed = 0;
+
+                completionSource.Reset();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            public UniTask DisposeAsync()
+            {
+                if (!disposed)
+                {
+                    disposed = true;
+                    TaskTracker.RemoveTracking(this);
+                }
+                return default;
+            }
+
+            public bool MoveNext()
+            {
+                if (disposed || cancellationToken.IsCancellationRequested)
+                {
+                    completionSource.TrySetResult(false);
+                    return false;
+                }
+
+                if (dueTimePhase)
+                {
+                    if (elapsed == 0)
+                    {
+                        // skip in initial frame.
+                        if (initialFrame == Time.frameCount)
+                        {
+                            return true;
+                        }
+                    }
+
+                    elapsed += (ignoreTimeScale) ? UnityEngine.Time.unscaledDeltaTime : UnityEngine.Time.deltaTime;
+
+                    if (elapsed >= dueTime)
+                    {
+                        dueTimePhase = false;
+                        completionSource.TrySetResult(true);
+                    }
+                }
+                else
+                {
+                    if (period == null)
+                    {
+                        completed = true;
+                        completionSource.TrySetResult(false);
+                        return false;
+                    }
+
+                    elapsed += (ignoreTimeScale) ? UnityEngine.Time.unscaledDeltaTime : UnityEngine.Time.deltaTime;
+
+                    if (elapsed >= period)
+                    {
+                        completionSource.TrySetResult(true);
+                    }
+                }
+
+                return true;
+            }
+        }
+    }
+
+    internal class TimerFrame : IUniTaskAsyncEnumerable<AsyncUnit>
+    {
+        readonly PlayerLoopTiming updateTiming;
+        readonly int dueTimeFrameCount;
+        readonly int? periodFrameCount;
+
+        public TimerFrame(int dueTimeFrameCount, int? periodFrameCount, PlayerLoopTiming updateTiming)
+        {
+            this.updateTiming = updateTiming;
+            this.dueTimeFrameCount = dueTimeFrameCount;
+            this.periodFrameCount = periodFrameCount;
+        }
+
+        public IUniTaskAsyncEnumerator<AsyncUnit> GetAsyncEnumerator(CancellationToken cancellationToken = default)
+        {
+            return new _TimerFrame(dueTimeFrameCount, periodFrameCount, updateTiming, cancellationToken);
+        }
+
+        class _TimerFrame : MoveNextSource, IUniTaskAsyncEnumerator<AsyncUnit>, IPlayerLoopItem
+        {
+            readonly int dueTimeFrameCount;
+            readonly int? periodFrameCount;
+            CancellationToken cancellationToken;
+
+            int initialFrame;
+            int currentFrame;
+            bool dueTimePhase;
+            bool completed;
+            bool disposed;
+
+            public _TimerFrame(int dueTimeFrameCount, int? periodFrameCount, PlayerLoopTiming updateTiming, CancellationToken cancellationToken)
+            {
+                if (dueTimeFrameCount <= 0) dueTimeFrameCount = 0;
+                if (periodFrameCount != null)
+                {
+                    if (periodFrameCount <= 0) periodFrameCount = 1;
+                }
+
+                this.initialFrame = PlayerLoopHelper.IsMainThread ? Time.frameCount : -1;
+                this.dueTimePhase = true;
+                this.dueTimeFrameCount = dueTimeFrameCount;
+                this.periodFrameCount = periodFrameCount;
+                this.cancellationToken = cancellationToken;
+
+                TaskTracker.TrackActiveTask(this, 2);
+                PlayerLoopHelper.AddAction(updateTiming, this);
+            }
+
+            public AsyncUnit Current => default;
+
+            public UniTask<bool> MoveNextAsync()
+            {
+                // return false instead of throw
+                if (disposed || cancellationToken.IsCancellationRequested || completed) return CompletedTasks.False;
+
+
+                // reset value here.
+                this.currentFrame = 0;
+
+                completionSource.Reset();
+                return new UniTask<bool>(this, completionSource.Version);
+            }
+
+            public UniTask DisposeAsync()
+            {
+                if (!disposed)
+                {
+                    disposed = true;
+                    TaskTracker.RemoveTracking(this);
+                }
+                return default;
+            }
+
+            public bool MoveNext()
+            {
+                if (disposed || cancellationToken.IsCancellationRequested)
+                {
+                    completionSource.TrySetResult(false);
+                    return false;
+                }
+
+                if (dueTimePhase)
+                {
+                    if (currentFrame == 0)
+                    {
+                        if (dueTimeFrameCount == 0)
+                        {
+                            dueTimePhase = false;
+                            completionSource.TrySetResult(true);
+                            return true;
+                        }
+
+                        // skip in initial frame.
+                        if (initialFrame == Time.frameCount)
+                        {
+                            return true;
+                        }
+                    }
+
+                    if (++currentFrame >= dueTimeFrameCount)
+                    {
+                        dueTimePhase = false;
+                        completionSource.TrySetResult(true);
+                    }
+                    else
+                    {
+                    }
+                }
+                else
+                {
+                    if (periodFrameCount == null)
+                    {
+                        completed = true;
+                        completionSource.TrySetResult(false);
+                        return false;
+                    }
+
+                    if (++currentFrame >= periodFrameCount)
+                    {
+                        completionSource.TrySetResult(true);
+                    }
+                }
+
+                return true;
+            }
+        }
+    }
+}
--- a/UnityProject/Packages/UniTask/Runtime/Linq/UnityExtensions/Timer.cs.meta
+++ b/UnityProject/Packages/UniTask/Runtime/Linq/UnityExtensions/Timer.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 382caacde439855418709c641e4d7b04
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: