| public static UnsafeSend ( System.Action action ) : void | ||
| action | System.Action | |
| 리턴 | void | |
private IEnumerator PeriodicAction(TimeSpan period, Action action, ICancelable cancellation)
{
if (period == TimeSpan.Zero)
{
while (true)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
MainThreadDispatcher.UnsafeSend(action);
}
yield break;
}
float elapsed = 0f;
float dt = (float)period.TotalSeconds;
while (true)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
elapsed += Time.deltaTime;
if (elapsed >= dt)
{
MainThreadDispatcher.UnsafeSend(action);
elapsed = 0f;
}
}
}
IEnumerator DelayAction(TimeSpan dueTime, Action action, ICancelable cancellation)
{
if (dueTime == TimeSpan.Zero)
{
yield return(null);
if (cancellation.IsDisposed)
{
yield break;
}
MainThreadDispatcher.UnsafeSend(action);
}
else
{
var startTime = Time.realtimeSinceStartup; // WaitForSeconds is affected in timescale, doesn't use.
var dt = (float)dueTime.TotalSeconds;
while (true)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
var elapsed = Time.realtimeSinceStartup - startTime;
if (elapsed >= dt)
{
MainThreadDispatcher.UnsafeSend(action);
break;
}
}
}
}
IEnumerator DelayAction(TimeSpan dueTime, Action action, ICancelable cancellation)
{
#if UNITY_EDITOR
if (!ScenePlaybackDetector.IsPlaying)
{
var startTime = DateTimeOffset.UtcNow;
while (true)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
var elapsed = DateTimeOffset.UtcNow - startTime;
if (elapsed >= dueTime)
{
MainThreadDispatcher.UnsafeSend(action);
break;
}
}
;
yield break;
}
#endif
if (dueTime == TimeSpan.Zero)
{
yield return(null);
if (cancellation.IsDisposed)
{
yield break;
}
MainThreadDispatcher.UnsafeSend(action);
}
else
{
var startTime = Time.realtimeSinceStartup; // this is difference
var dt = (float)dueTime.TotalSeconds;
while (true)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
var elapsed = Time.realtimeSinceStartup - startTime;
if (elapsed >= dt)
{
MainThreadDispatcher.UnsafeSend(action);
break;
}
}
}
}
private IEnumerator DelayAction(TimeSpan dueTime, Action action, ICancelable cancellation)
{
if (dueTime == TimeSpan.Zero)
{
yield return(null);
if (!cancellation.IsDisposed)
{
MainThreadDispatcher.UnsafeSend(action);
}
yield break;
}
float startTime = Time.realtimeSinceStartup;
float dt = (float)dueTime.TotalSeconds;
float elapsed;
do
{
yield return(null);
if (cancellation.IsDisposed)
{
yield break;
}
elapsed = Time.realtimeSinceStartup - startTime;
}while (!(elapsed >= dt));
MainThreadDispatcher.UnsafeSend(action);
}
IEnumerator PeriodicAction(TimeSpan period, Action action, ICancelable cancellation)
{
// zero == every frame
if (period == TimeSpan.Zero)
{
while (true)
{
yield return(null); // not immediately, run next frame
if (cancellation.IsDisposed)
{
yield break;
}
MainThreadDispatcher.UnsafeSend(action);
}
}
else
{
var seconds = (float)(period.TotalMilliseconds / 1000.0);
var yieldInstruction = new WaitForSeconds(seconds); // cache single instruction object
while (true)
{
yield return(yieldInstruction);
if (cancellation.IsDisposed)
{
yield break;
}
MainThreadDispatcher.UnsafeSend(action);
}
}
}
IEnumerator DelayAction(TimeSpan dueTime, Action action, ICancelable cancellation)
{
if (dueTime == TimeSpan.Zero)
{
yield return(null);
if (cancellation.IsDisposed)
{
yield break;
}
MainThreadDispatcher.UnsafeSend(action);
}
else
{
var elapsed = 0f;
var dt = (float)dueTime.TotalSeconds;
while (true)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
elapsed += Time.deltaTime;
if (elapsed >= dt)
{
MainThreadDispatcher.UnsafeSend(action);
break;
}
}
}
}
private IEnumerator PeriodicAction(TimeSpan period, Action action, ICancelable cancellation)
{
if (period == TimeSpan.Zero)
{
while (true)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
MainThreadDispatcher.UnsafeSend(action);
}
yield break;
}
float seconds = (float)(period.TotalMilliseconds / 1000.0);
WaitForSeconds yieldInstruction = new WaitForSeconds(seconds);
while (true)
{
yield return(yieldInstruction);
if (cancellation.IsDisposed)
{
break;
}
MainThreadDispatcher.UnsafeSend(action);
}
}
private IEnumerator ImmediateAction <T>(T state, Action <T> action, ICancelable cancellation)
{
yield return(null);
if (!cancellation.IsDisposed)
{
MainThreadDispatcher.UnsafeSend(action, state);
}
}
private IEnumerator DelayAction(TimeSpan dueTime, Action action, ICancelable cancellation)
{
if (dueTime == TimeSpan.Zero)
{
yield return(null);
}
else
{
yield return(new WaitForSeconds((float)dueTime.TotalSeconds));
}
if (!cancellation.IsDisposed)
{
MainThreadDispatcher.UnsafeSend(action);
}
}
// delay action is run in StartCoroutine
// Okay to action run synchronous and guaranteed run on MainThread
IEnumerator DelayAction(TimeSpan dueTime, Action action, ICancelable cancellation)
{
// zero == every frame
if (dueTime == TimeSpan.Zero)
{
yield return(null); // not immediately, run next frame
}
else
{
yield return(new WaitForSeconds((float)dueTime.TotalSeconds));
}
if (cancellation.IsDisposed)
{
yield break;
}
MainThreadDispatcher.UnsafeSend(action);
}
IEnumerator PeriodicAction(TimeSpan period, Action action, ICancelable cancellation)
{
// zero == every frame
if (period == TimeSpan.Zero)
{
while (true)
{
yield return(null);
if (cancellation.IsDisposed)
{
yield break;
}
MainThreadDispatcher.UnsafeSend(action);
}
}
else
{
var startTime = Time.fixedTime;
var dt = (float)period.TotalSeconds;
while (true)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
var ft = Time.fixedTime;
var elapsed = ft - startTime;
if (elapsed >= dt)
{
MainThreadDispatcher.UnsafeSend(action);
startTime = ft;
}
}
}
}
IEnumerator PeriodicAction(TimeSpan period, Action action, ICancelable cancellation)
{
// zero == every frame
if (period == TimeSpan.Zero)
{
while (true)
{
yield return(null); // not immediately, run next frame
if (cancellation.IsDisposed)
{
yield break;
}
MainThreadDispatcher.UnsafeSend(action);
}
}
else
{
var elapsed = 0f;
var dt = (float)period.TotalSeconds;
while (true)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
elapsed += Time.unscaledDeltaTime;
if (elapsed >= dt)
{
MainThreadDispatcher.UnsafeSend(action);
elapsed = 0;
}
}
}
}
IEnumerator PeriodicAction(TimeSpan period, Action action, ICancelable cancellation)
{
// zero == every frame
if (period == TimeSpan.Zero)
{
while (true)
{
yield return(null); // not immediately, run next frame
if (cancellation.IsDisposed)
{
yield break;
}
MainThreadDispatcher.UnsafeSend(action);
}
}
else
{
var startTime = Time.realtimeSinceStartup; // WaitForSeconds is affected in timescale, doesn't use.
var dt = (float)period.TotalSeconds;
while (true)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
var elapsed = Time.realtimeSinceStartup - startTime;
if (elapsed >= dt)
{
startTime = Time.realtimeSinceStartup; // set next start
MainThreadDispatcher.UnsafeSend(action);
}
}
}
}
private IEnumerator DelayAction(TimeSpan dueTime, Action action, ICancelable cancellation)
{
if (dueTime == TimeSpan.Zero)
{
yield return(null);
if (!cancellation.IsDisposed)
{
MainThreadDispatcher.UnsafeSend(action);
}
yield break;
}
if (dueTime.TotalMilliseconds % 1000.0 == 0.0)
{
yield return(new WaitForSeconds((float)dueTime.TotalSeconds));
if (!cancellation.IsDisposed)
{
MainThreadDispatcher.UnsafeSend(action);
}
yield break;
}
float startTime = Time.time;
float dt = (float)dueTime.TotalSeconds;
float elapsed;
do
{
yield return(null);
if (cancellation.IsDisposed)
{
yield break;
}
elapsed = Time.time - startTime;
}while (!(elapsed >= dt));
MainThreadDispatcher.UnsafeSend(action);
}
// delay action is run in StartCoroutine
// Okay to action run synchronous and guaranteed run on MainThread
protected virtual IEnumerator DelayAction(TimeSpan dueTime, Action action, ICancelable cancellation)
{
// zero == every frame
if (dueTime == TimeSpan.Zero)
{
yield return(null); // not immediately, run next frame
}
else
{
var startTime = Now;
do
{
var elapsed = (float)(Now - startTime).TotalSeconds;
yield return(new WaitForSeconds((float)dueTime.TotalSeconds - elapsed));
} while (Now - startTime < dueTime);
}
if (cancellation.IsDisposed)
{
yield break;
}
MainThreadDispatcher.UnsafeSend(action);
}
private IEnumerator PeriodicAction(TimeSpan period, Action action, ICancelable cancellation)
{
if (period == TimeSpan.Zero)
{
for (;;)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
MainThreadDispatcher.UnsafeSend(action);
}
yield break;
}
float startTime = Time.fixedTime;
float dt = (float)period.TotalSeconds;
for (;;)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
float ft = Time.fixedTime;
float elapsed = ft - startTime;
if (elapsed >= dt)
{
MainThreadDispatcher.UnsafeSend(action);
startTime = ft;
}
}
yield break;
}
private IEnumerator DelayAction(TimeSpan dueTime, Action action, ICancelable cancellation)
{
if (dueTime == TimeSpan.Zero)
{
yield return(null);
if (cancellation.IsDisposed)
{
yield break;
}
MainThreadDispatcher.UnsafeSend(action);
}
else
{
float startTime = Time.fixedTime;
float dt = (float)dueTime.TotalSeconds;
for (;;)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
float elapsed = Time.fixedTime - startTime;
if (elapsed >= dt)
{
goto Block_4;
}
}
goto IL_FF;
Block_4:
MainThreadDispatcher.UnsafeSend(action);
}
IL_FF:
yield break;
}
// delay action is run in StartCoroutine
// Okay to action run synchronous and guaranteed run on MainThread
IEnumerator DelayAction(TimeSpan dueTime, Action action, ICancelable cancellation)
{
if (dueTime == TimeSpan.Zero)
{
yield return(null); // not immediately, run next frame
MainThreadDispatcher.UnsafeSend(action);
}
else if (dueTime.TotalMilliseconds % 1000 == 0)
{
yield return(new WaitForSeconds((float)dueTime.TotalSeconds));
MainThreadDispatcher.UnsafeSend(action);
}
else
{
var startTime = Time.time;
var dt = (float)dueTime.TotalSeconds;
while (true)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
var elapsed = Time.time - startTime;
if (elapsed >= dt)
{
MainThreadDispatcher.UnsafeSend(action);
break;
}
}
}
}
// delay action is run in StartCoroutine
// Okay to action run synchronous and guaranteed run on MainThread
IEnumerator DelayAction(TimeSpan dueTime, Action action, ICancelable cancellation)
{
#if UNITY_EDITOR
if (!ScenePlaybackDetector.IsPlaying)
{
var startTime = DateTimeOffset.UtcNow;
while (true)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
var elapsed = DateTimeOffset.UtcNow - startTime;
if (elapsed >= dueTime)
{
MainThreadDispatcher.UnsafeSend(action);
break;
}
}
;
yield break;
}
#endif
if (dueTime == TimeSpan.Zero)
{
yield return(null); // not immediately, run next frame
if (cancellation.IsDisposed)
{
yield break;
}
MainThreadDispatcher.UnsafeSend(action);
}
else if (dueTime.TotalMilliseconds % 1000 == 0)
{
yield return(new WaitForSeconds((float)dueTime.TotalSeconds));
if (cancellation.IsDisposed)
{
yield break;
}
MainThreadDispatcher.UnsafeSend(action);
}
else
{
var startTime = Time.time;
var dt = (float)dueTime.TotalSeconds;
while (true)
{
yield return(null);
if (cancellation.IsDisposed)
{
break;
}
var elapsed = Time.time - startTime;
if (elapsed >= dt)
{
MainThreadDispatcher.UnsafeSend(action);
break;
}
}
}
}
