public void Free(T pInstance)
{
#if DISABLE_POOLING
pInstance.Destroy();
#else
Debugger.Assert(_iCursor + 1 < _nMaxSize, "Object pool exceed max size! Do you free an object that is not managed by FastPool?");
Debugger.Assert(pInstance != null);
Debugger.DebugSection(() =>
{
foreach(T element in this)
{
Debugger.Assert(element != pInstance
, "Object already in pool, cannot FreeInstance it twice! Object is: " + element);
}
});
if (_iCursor + 1 >= _arrObjectSlots.Length)
{
_incressSlots();
}
_iCursor++;
_arrObjectSlots[_iCursor] = pInstance;
#endif
}
internal void _AddToQueue(Coroutine pCoroutine)
{
Debugger.DebugSection(() =>
{
if (pCoroutine._bPooled)
{
Debugger.Assert(pCoroutine.state == CoroutineState.InUse);
}
else
{
Debugger.Assert(pCoroutine.state == CoroutineState.Stopped);
}
});
Debugger.Assert(!_IsCoroutineInQueue(pCoroutine));
pCoroutine._bInQueue = true;
if (_InUpdating)
{
__arrAddedCoroutines.Add(pCoroutine);
}
else
{
_arrCoroutines.Add(pCoroutine);
}
}
public void Free(T pInstance)
{
#if DISABLE_POOLING
pInstance.Destroy();
#else
Debugger.Assert(_nPoolSize <= _nMaxSize, "Object pool exceed max size! Do you free an object that is not managed by ObjectPool?");
Debugger.Assert(pInstance != null);
Debugger.DebugSection(() =>
{
foreach (T element in this)
{
Debugger.Assert(element != pInstance
, "Object already in pool, cannot FreeInstance it twice! Object is: " + element);
}
});
_objectQueue.AddToBack(pInstance);
#endif
}
/// Return value indicate whether this coroutine is dead.
internal bool _Update(float fTime)
{
bool bIsDead = false;
try
{
if (_onUpdate != null && state == CoroutineState.Running)
{
_onUpdate(_pCurrentInstruction);
}
}
catch (Exception e)
{
_HandleException(new CoroutineException(e, this));
bIsDead = true;
}
bool bIsComplete = false;
if (_state < CoroutineState.Running)
{
if (_state == CoroutineState.Paused)
{
return(false);
}
else if (_state == CoroutineState.Stopped)
{
bIsComplete = true;
}
else if (_state == CoroutineState.Disposed)
{
/// Occurred when a manual coroutine is Removed.
return(true);
}
else
{
Debugger.Assert(false);
}
}
try
{
_pCoroutineMgr._CoEnterLogStack.Push(this);
if (bIsComplete)
{
if (!__bIsManualStopped)
{
__doComplete();
}
return(true);
}
///-------------------
bIsDead = false;
Debugger.Assert(_pCurrentInstruction != null);
Debugger.DebugSection(() =>
{
if (_pCurrentInstruction.GetInstructionType() == YieldInstructionType.Coroutine)
{
var coroutine = _pCurrentInstruction as Coroutine;
Debugger.ConditionalAssert(coroutine._bPooled, coroutine.state != CoroutineState.Freed);
}
});
if (_pCurrentInstruction.GetInstructionType() == YieldInstructionType.ReturnValue)
{
bIsDead = true;
_ReturnValue pReturnValue = _pCurrentInstruction as _ReturnValue;
__doComplete(pReturnValue.returnValue);
}
else
{
_pCurrentInstruction.Update(fTime);
if (_pCurrentInstruction.IsDone())
{
if (_onYieldDone != null)
{
_onYieldDone(_pCurrentInstruction);
}
if (state != CoroutineState.Stopped)
{
Debugger.Assert(_pCurrentInstruction != null);
_pCurrentInstruction.Stop();
if (!_pCoroutineFunc.MoveNext())
{
_pCurrentInstruction.DecRef();
_pCurrentInstruction = null;
bIsDead = true;
__doComplete();
}
else
{
if (_state != CoroutineState.Stopped)
{
Debugger.Assert(_state != CoroutineState.Freed && _state != CoroutineState.Disposed);
Debugger.Assert(_pCoroutineFunc != null, "Coroutine function is null but still in update, you may be operated on a dead coroutine!!!");
/// Why defRef here? Because MoveNext() may cause current instruction
_pCurrentInstruction.DecRef();
_pCurrentInstruction = _pCoroutineFunc.Current as IYieldInstruction;
if (_pCurrentInstruction == null)
{
throw new UnsupportedYieldInstruction();
}
_pCurrentInstruction.Start(fTime);
_pCurrentInstruction.IncRef();
}
}
}
}
}
}
catch (Exception e)
{
Debugger.Assert(!(e is CoroutineException));
_HandleException(new CoroutineException(e, this));
bIsDead = true;
}
finally
{
Debugger.Assert(_pCoroutineMgr._CoEnterLogStack.Peek() == this);
_pCoroutineMgr._CoEnterLogStack.Pop();
}
return(bIsDead);
}