static public void checkPing(Action <bool> onCheckDone)
{
Debug.Log("#ping# checkPing");
CoroutineInfo info = CoroutineManager.launch(CheckConnection(onCheckDone));
info.context = "CheckInternet";
}
/// <summary>
/// A coroutine that runs a single yield instruction
/// </summary>
/// <returns>
/// The instruction coroutine.
/// </returns>
/// <param name='info'>
/// The info packet for the coroutine to run
/// </param>
IEnumerator YieldInstructionCoroutine(CoroutineInfo info)
{
info.done = false;
yield return(info.instruction);
info.done = true;
}
IEnumerator WaitUntilFinished(CoroutineInfo workerData)
{
while (!workerData.IsFinished)
{
yield return null;
}
}
public static CoroutineInfo <float> LerpFloat(MonoBehaviour mono, float b, float length)
{
CoroutineInfo <float> info = new CoroutineInfo <float>();
info.coroutine = mono.StartCoroutine(_LerpFloat(info, b, length));
return(info);
}
private IEnumerator CallMethodOnMainThread(CoroutineInfo coroutineInfo)
{
yield return(coroutineInfo.Coroutine);
coroutineInfo.finished = true;
runningActions.Remove(coroutineInfo);
}
public static Coroutine StartSafeCoroutine(this MonoBehaviour behav, IEnumerator work)
{
if (behav != null && behav.isActiveAndEnabled)
{
if (CoroutineRunnerObj != null && !CoroutineRunnerObj.activeInHierarchy)
{
Object.Destroy(CoroutineRunnerObj);
CoroutineRunnerObj = null;
}
if (!CoroutineRunnerObj)
{
CoroutineRunnerObj = new GameObject();
CoroutineRunnerObj.hideFlags = HideFlags.HideAndDontSave;
Object.DontDestroyOnLoad(CoroutineRunnerObj);
}
if (!CoroutineRunnerBehav)
{
CoroutineRunnerBehav = CoroutineRunnerObj.AddComponent <CoroutineRunnerBehav>();
}
var info = new CoroutineInfo()
{
behav = behav, work = work
};
return(info.coroutine = behav.StartCoroutine(SafeEnumerator(work, info)));
}
return(null);
}
IEnumerator WaitUntilFinished(CoroutineInfo workerData)
{
while (!workerData.IsFinished)
{
yield return(null);
}
}
public static Coroutine StartCoroutine(this IEnumerator work)
{
if (CoroutineRunnerObj != null && !CoroutineRunnerObj.activeInHierarchy)
{
Object.Destroy(CoroutineRunnerObj);
CoroutineRunnerObj = null;
}
if (!CoroutineRunnerObj)
{
CoroutineRunnerObj = new GameObject();
CoroutineRunnerObj.hideFlags = HideFlags.HideAndDontSave;
Object.DontDestroyOnLoad(CoroutineRunnerObj);
}
if (!CoroutineRunnerBehav)
{
CoroutineRunnerBehav = CoroutineRunnerObj.AddComponent <CoroutineRunnerBehav>();
}
//if (work is IDisposable)
{
var info = new CoroutineInfo()
{
behav = CoroutineRunnerBehav, work = work
};
return(info.coroutine = CoroutineRunnerBehav.StartCoroutine(SafeEnumerator(work, info)));
}
//else
//{
// return CoroutineRunnerBehav.StartCoroutine(work);
//}
}
public CoroutineInfo start(CoroutineLayerId layerId, IEnumerator scriptFunction, MonoBehaviour caller)
{
CoroutineInfo info = new CoroutineInfo(scriptFunction, caller, layers[(int)layerId]);
carrier.StartCoroutine(checker(info));
return(info);
}
/// <summary>
/// 初始化协程。
/// </summary>
/// <param name="customCoroutineCreator">自定义协程创建器，若为空则调用全局协程</param>
/// <param name="customCoroutineTeminator">自定义协程终止器，若为空则调用全局协程</param>
public void Initialization(CoroutineCreator customCoroutineCreator = null, CoroutineTeminator customCoroutineTeminator = null)
{
mCoroutineCreator = customCoroutineCreator;
mCoroutineTeminator = customCoroutineTeminator;
if (mCoroutineCreator == null)
{
mCoroutineCreator = (enumerator) => CoroutineHelper.StartCoroutine(enumerator);
}
if (mCoroutineTeminator == null)
{
mCoroutineTeminator = (enumerator) => CoroutineHelper.StopCoroutine(enumerator);
}
for (int i = 0, iMax = mCoroutinesArray.Length; i < iMax; i++)
{
var coroutineInfo = new CoroutineInfo();
coroutineInfo.Task = new Task();
coroutineInfo.Task.Init();
coroutineInfo.Task.OnTaskFinished = DetectTaskWaitCoroutine;
var coroutine = mCoroutineCreator(coroutineInfo.Task.Tick());
coroutineInfo.Coroutine = coroutine;
mCoroutinesArray[i] = coroutineInfo;
}
mIsInitialized = true;
}
public Coroutine StartPausableCoroutine(MonoBehaviour target, IEnumerator routine)
{
var r = target.StartCoroutine(routine);
var info = new CoroutineInfo(target, routine, r);
_coroutines.Add(info);
// コルーチン終了検知を追加する
StartCoroutine(AddDeleter(info));
return(r);
}
/// <summary>
/// 开启协程(全局)，协程不会因为场景切换而被终止
/// </summary>
/// <param name="cor"></param>
/// <returns></returns>
public static CoroutineHandle StartGlobalCoroutine(IEnumerator cor)
{
var newHandle = NewHandle();
var newInfo = new CoroutineInfo();
newInfo.Id = newHandle.Id;
newInfo.isGlobal = true;
newInfo.coroutine = GlobalScheduler.instance.StartCoroutine(GlobalScheduler.instance.StartNew(cor, newHandle));
_running_coroutines.Add(newInfo.Id, newInfo);
return(newHandle);
}
IEnumerator ProcessInternal(IEnumerator process)
{
var data = new CoroutineInfo()
{
CoRoutine = new CoRoutine(process),
};
_newWorkers.Add(data);
return(WaitUntilFinished(data));
}
IEnumerator ProcessInternal(IEnumerator process)
{
var data = new CoroutineInfo()
{
CoRoutine = new CoRoutine(process),
};
_newWorkers.Add(data);
return WaitUntilFinished(data);
}
/// <summary>
/// Starts coroutine If edit mode.
/// If not in edit mode throws a NotSupportedException exception.
/// </summary>
/// <param name="coroutine"> The coroutine to start. </param>
/// <returns> Yield instructions that determine when coroutine has finished. </returns>
public static WaitForStaticCoroutine StartCoroutineInEditMode(CoroutineInfo coroutine)
{
if (Application.isPlaying)
{
throw new NotSupportedException("StartCoroutineInEditMode cannot be called in play mode. Please use use StartCoroutine(IEnumerator) instead.");
}
editModeCoroutines.Add(coroutine);
HandleMoveNextForExistingCoroutinesInEditMode();
return(new WaitForStaticCoroutine(coroutine.coroutine, null));
}
private static IEnumerator _ExecuteCoroutine(CoroutineInfo c)
{
var CII = c as CoroutineInfoInternal;
yield return(CII.Coroutine);
instance.coroutines.Remove(CII.ID);
if (CII.NextCoroutine != null)
{
instance.ExecuteCoroutine(CII.NextCoroutine);
}
}
/// <summary>
/// Waits for a yield instruction
/// </summary>
/// <returns>
/// The coroutine to execute
/// </returns>
/// <param name='instruction'>
/// The instruction to run
/// </param>
IEnumerator WaitForCoroutine(YieldInstruction instruction)
{
var ci = new CoroutineInfo {
instruction = instruction, done = false
};
_behaviour.StartCoroutine(YieldInstructionCoroutine(ci));
while (!ci.done)
{
yield return(null);
}
}
public static bool CheckDeadCoroutine(CoroutineInfo info)
{
if (!info.behav)
{
if (info.work is IDisposable)
{
((IDisposable)info.work).Dispose();
info.work = null;
}
return(true);
}
return(false);
}
/// <summary>
/// 指定コルーチンを停止する。
/// 次に処理するコルーチンがあり、それを実行したい場合はisExecNextにtrueを指定する
/// </summary>
public static void Stop(CoroutineInfo c, bool isExecNext = false)
{
if (instance.coroutines.ContainsKey(c.ID))
{
var CII = c as CoroutineInfoInternal;
instance.StopCoroutine(CII.Coroutine);
instance.coroutines.Remove(c.ID);
if ((CII.NextCoroutine != null) && isExecNext)
{
instance.ExecuteCoroutine(CII.NextCoroutine);
}
}
}
IEnumerator ProcessInternal(
IEnumerator process, string statusTitle, bool isBlocking, Action <Exception> exceptionHandler)
{
var data = new CoroutineInfo()
{
CoRoutine = new CoRoutine(process),
IsBlocking = isBlocking,
StatusTitle = statusTitle,
};
_newWorkers.Add(data);
return(WaitUntilFinished(data));
}
private void Update()
{
if (queuedActions.Count > 0)
{
CoroutineInfo coroutineInfo = null;
coroutineInfo = queuedActions.Dequeue();
if (coroutineInfo != null)
{
runningActions.Add(coroutineInfo);
StartCoroutine(CallMethodOnMainThread(coroutineInfo));
}
}
}
public static IEnumerator _LerpFloat(CoroutineInfo <float> info, float b, float length)
{
float a = info.value;
for (float i = 0; i < 1f; i += Time.deltaTime / length)
{
info.value = Mathf.Lerp(a, b, i);
info.progress = i;
yield return(null);
}
info.progress = 1;
info.value = b;
}
public FunctionScope(
FunctionInfo function,
Node node,
InterpreterScope declScope,
IPythonProjectEntry declModule
)
: base(function, node, declScope) {
ReturnValue = new VariableDef();
if (Function.FunctionDefinition.IsCoroutine) {
Coroutine = new CoroutineInfo(function.ProjectState, declModule);
ReturnValue.AddTypes(function.ProjectEntry, Coroutine.SelfSet, false, declModule);
} else if (Function.FunctionDefinition.IsGenerator) {
Generator = new GeneratorInfo(function.ProjectState, declModule);
ReturnValue.AddTypes(function.ProjectEntry, Generator.SelfSet, false, declModule);
}
}
public static IEnumerator SafeEnumerator(this IEnumerator work, CoroutineInfo info)
{
RunningCoroutines.Add(info);
if (work != null)
{
CurrentCoroutine = info.coroutine;
while (work.MoveNext())
{
var result = work.Current;
CurrentCoroutine = null;
yield return(result);
CurrentCoroutine = info.coroutine;
}
}
RunningCoroutines.Remove(info);
}
private static void MiniszieRoutineList()
{
int num = 0;
while (num < routines.Count)
{
CoroutineInfo item = routines[num];
if (!item.obj.IsAlive)
{
routines.Remove(item);
}
else
{
num++;
}
}
}
void TablePanel_CoroutineSelected(object selected, int col)
{
CoTableEntry entry = selected as CoTableEntry;
if (entry == null)
{
return;
}
CoroutineInfo info = _database.GetCoroutineInfo(entry.SeqID);
if (info == null)
{
return;
}
string termTime = info.termination != null?info.termination.timestamp.ToString("0.000") : "(not yet)";
_coroutineName = string.Format("{0}", info.creation.mangledName);
_coroutineInfo = string.Format("SeqID: {0}, Created: {1:0.00}, Terminated: {2}", info.creation.seqID, info.creation.timestamp, termTime);
_coroutineStacktrace = "Stacktrace:\n\n" + info.creation.stacktrace;
StringBuilder sb = new StringBuilder(1024);
sb.AppendFormat("Executions: ({0})\n\n", info.executions.Count);
for (int i = 0; i < info.executions.Count; i++)
{
string sel = "";
var item = info.executions[i];
if (item.Key <= _selectedSnapshotTime && item.Key > _selectedSnapshotTime - CoTrackerDatabase.SnapshotInterval)
{
sel = "(in selected snapshot)";
}
sb.AppendFormat(" ({0}) timestamp: {1:0.000} duration: {2:0.000} {3}\n", i, item.Key, item.Value, sel);
if (sb.Length > 10000)
{
sb.Append("(cutting the rest off since it's too long...)");
break;
}
}
_coroutineExecutions = sb.ToString();
}
IEnumerator ProcessInternal(
IEnumerator process, bool isBlocking = true, string statusTitle = null, Action <Exception> exceptionHandler = null)
{
if (!IsBlocking && isBlocking)
{
BlockingLoadStarted();
}
var data = new CoroutineInfo()
{
CoRoutine = new CoRoutine(process),
IsBlocking = isBlocking,
ExceptionHandler = exceptionHandler,
StatusTitle = statusTitle,
};
_newWorkers.Add(data);
return(WaitUntilFinished(data));
}
void ExtractCoroutineSelectedInfo(float snapshot, CoroutineInfo info, out int selectedCnt, out float selected, out int accumCnt, out float accumTime)
{
selectedCnt = 0;
selected = 0.0f;
accumCnt = 0;
accumTime = 0.0f;
foreach (var item in info.executions)
{
if (item.Key <= snapshot)
{
if (item.Key > snapshot - SnapshotInterval)
{
selected += item.Value;
selectedCnt++;
}
accumTime += item.Value;
accumCnt++;
}
}
}
private IEnumerator CallMethodOnMainThread(CoroutineInfo coroutineInfo)
{
yield return(coroutineInfo.Coroutine);
coroutineInfo.Tcs.SetResult(true);
}
private void ExecuteCoroutine(CoroutineInfo c)
{
coroutines[c.ID] = this.StartCoroutine(_ExecuteCoroutine(c));
}
protected IEnumerator checker(CoroutineInfo info)
{
info.state = CoroutineState.START;
#if UNITY_EDITOR
if (info.caller != null)
{
Debug.Log("{{coroutine}} starting coroutine for caller : " + info.caller.name, info.caller);
}
else
{
Debug.Log("{{coroutine}} starting coroutine (no caller)");
}
#endif
while (!info.stopped && info.function.MoveNext())
{
if (info.killed)
{
info.stopped = true;
yield return(null);
}
if (info.stopped)
{
if (info.state != CoroutineState.INTERRUPT)
{
info.state = CoroutineState.INTERRUPT;
}
yield return(null);
}
while (info.paused)
{
if (info.stopped)
{
info.paused = false;
}
yield return(null);
}
if (info.skipped)
{
info.state = CoroutineState.SKIP;
while (info.function.MoveNext())
{
}
; // no yield, skipping in the same frame
}
yield return(null);
}
if (info.caller)
{
Debug.Log("{{coroutine}} coroutine for caller " + info.caller.name + " is done (killed?" + info.killed + ", stopped?" + info.stopped + ", skipped?" + info.skipped + ")", info.caller);
}
info.state = CoroutineState.DONE;
info.removeFromLayer();
history.Add(info);
if (!info.killed)
{
if (info.onEnd != null)
{
info.onEnd();
}
}
}
public void CreateSnapshot(float snapshotTime)
{
int creationCount = 0;
int executionCount = 0;
int terminationCount = 0;
float executionTime = 0.0f;
HashSet <int> curSnapshot = new HashSet <int>();
_snapshots.Add(new KeyValuePair <float, HashSet <int> >(snapshotTime, curSnapshot));
while (_activityQueue.Count > 0)
{
CoroutineActivity activity = _activityQueue.Peek();
if (activity.timestamp < _lastSnapshotTime)
{
Debug.LogErrorFormat("[CoEd] error: {0} is earlier than last snapshot, discarded. (activity_time: {1:0.000}, last_snapshot: {2:0.000})",
activity.GetType().ToString(), activity.timestamp, _lastSnapshotTime);
activity = _activityQueue.Dequeue();
continue;
}
else if (activity.timestamp >= snapshotTime)
{
// stop current activity
break;
}
activity = _activityQueue.Dequeue();
curSnapshot.Add(activity.seqID);
CoroutineInfo info;
if (!_coroutines.TryGetValue(activity.seqID, out info))
{
if (!(activity is CoroutineCreation))
{
Debug.LogErrorFormat("activity ({0}:{1}) not found (possibly CoroutineCreation missing), ignored.", activity.seqID, activity.ToString());
continue;
}
info = new CoroutineInfo();
_coroutines[activity.seqID] = info;
}
if (activity is CoroutineCreation)
{
creationCount++;
info.creation = activity as CoroutineCreation;
}
else if (activity is CoroutineExecution)
{
var exec = activity as CoroutineExecution;
executionCount++;
executionTime += exec.timeConsumed;
info.executions.Add(new KeyValuePair <float, float>(exec.timestamp, exec.timeConsumed));
}
else if (activity is CoroutineTermination)
{
terminationCount++;
info.termination = activity as CoroutineTermination;
}
}
// 这个函数一定要在 CoGraphUtil.LogData() 也就是 step 之前调用（否则 mCurrentIndex 就变到下一帧去了）
CoGraphUtil.RecordSnapshot(snapshotTime);
CoGraphUtil.LogData(CoGraphUtil.GName_Creation, creationCount);
CoGraphUtil.LogData(CoGraphUtil.GName_Termination, terminationCount);
CoGraphUtil.LogData(CoGraphUtil.GName_ExecCount, executionCount);
CoGraphUtil.LogData(CoGraphUtil.GName_ExecTime, executionTime);
}
