void GoStopActualRoutine(EditorCoroutines.EditorCoroutine routine)
{
if (coroutineDict.ContainsKey(routine.routineUniqueHash))
{
coroutineOwnerDict[routine.ownerUniqueHash].Remove(routine.routineUniqueHash);
coroutineDict.Remove(routine.routineUniqueHash);
}
}
static bool MoveNext(EditorCoroutines.EditorCoroutine coroutine)
{
if (coroutine.routine.MoveNext())
{
return(Process(coroutine));
}
return(false);
}
EditorCoroutines.EditorCoroutine GoStartCoroutine(IEnumerator routine, object thisReference)
{
if (routine == null)
{
Debug.LogException(new Exception("IEnumerator is null!"), null);
}
EditorCoroutines.EditorCoroutine coroutine = CreateCoroutine(routine, thisReference);
GoStartCoroutine(coroutine);
return(coroutine);
}
// returns false if no next, returns true if OK
static bool Process(EditorCoroutines.EditorCoroutine coroutine)
{
object current = coroutine.routine.Current;
if (current == null)
{
coroutine.currentYield = new EditorCoroutines.YieldDefault();
}
else if (current is WaitForSeconds)
{
float seconds = float.Parse(GetInstanceField(typeof(WaitForSeconds), current, "m_Seconds").ToString());
coroutine.currentYield = new EditorCoroutines.YieldWaitForSeconds()
{
timeLeft = seconds
};
}
else if (current is CustomYieldInstruction)
{
coroutine.currentYield = new EditorCoroutines.YieldCustomYieldInstruction()
{
customYield = current as CustomYieldInstruction
};
}
else if (current is WWW)
{
coroutine.currentYield = new EditorCoroutines.YieldWWW {
Www = (WWW)current
};
}
else if (current is WaitForFixedUpdate || current is WaitForEndOfFrame)
{
coroutine.currentYield = new EditorCoroutines.YieldDefault();
}
else if (current is AsyncOperation)
{
coroutine.currentYield = new EditorCoroutines.YieldAsync {
asyncOperation = (AsyncOperation)current
};
}
else if (current is EditorCoroutines.EditorCoroutine)
{
coroutine.currentYield = new EditorCoroutines.YieldNestedCoroutine {
coroutine = (EditorCoroutines.EditorCoroutine)current
};
}
else
{
Debug.LogException(
new Exception("<" + coroutine.MethodName + "> yielded an unknown or unsupported type! (" + current.GetType() + ")"),
null);
coroutine.currentYield = new EditorCoroutines.YieldDefault();
}
return(true);
}
void GoStopAllCoroutines(object thisReference)
{
EditorCoroutines.EditorCoroutine coroutine = CreateCoroutine(null, thisReference);
if (coroutineOwnerDict.ContainsKey(coroutine.ownerUniqueHash))
{
foreach (var couple in coroutineOwnerDict[coroutine.ownerUniqueHash])
{
coroutineDict.Remove(couple.Value.routineUniqueHash);
}
coroutineOwnerDict.Remove(coroutine.ownerUniqueHash);
}
}
void OnUpdate()
{
float deltaTime = (float)(DateTime.Now.Subtract(previousTimeSinceStartup).TotalMilliseconds / 1000.0f);
previousTimeSinceStartup = DateTime.Now;
if (coroutineDict.Count == 0)
{
return;
}
tempCoroutineList.Clear();
foreach (var pair in coroutineDict)
{
tempCoroutineList.Add(pair.Value);
}
for (var i = tempCoroutineList.Count - 1; i >= 0; i--)
{
List <EditorCoroutines.EditorCoroutine> coroutines = tempCoroutineList[i];
for (int j = coroutines.Count - 1; j >= 0; j--)
{
EditorCoroutines.EditorCoroutine coroutine = coroutines[j];
if (!coroutine.currentYield.IsDone(deltaTime))
{
continue;
}
if (!MoveNext(coroutine))
{
coroutines.RemoveAt(j);
coroutine.currentYield = null;
coroutine.finished = true;
}
if (coroutines.Count == 0)
{
coroutineDict.Remove(coroutine.ownerUniqueHash);
}
}
}
}
void GoStartCoroutine(EditorCoroutines.EditorCoroutine coroutine)
{
if (!coroutineDict.ContainsKey(coroutine.routineUniqueHash))
{
List <EditorCoroutines.EditorCoroutine> newCoroutineList = new List <EditorCoroutines.EditorCoroutine>();
coroutineDict.Add(coroutine.routineUniqueHash, newCoroutineList);
}
coroutineDict[coroutine.routineUniqueHash].Add(coroutine);
if (!coroutineOwnerDict.ContainsKey(coroutine.ownerUniqueHash))
{
Dictionary <string, EditorCoroutines.EditorCoroutine> newCoroutineDict = new Dictionary <string, EditorCoroutines.EditorCoroutine>();
coroutineOwnerDict.Add(coroutine.ownerUniqueHash, newCoroutineDict);
}
// If the method from the same owner has been stored before, it doesn't have to be stored anymore,
// One reference is enough in order for "StopAllCoroutines" to work
if (!coroutineOwnerDict[coroutine.ownerUniqueHash].ContainsKey(coroutine.routineUniqueHash))
{
coroutineOwnerDict[coroutine.ownerUniqueHash].Add(coroutine.routineUniqueHash, coroutine);
}
MoveNext(coroutine);
}
