/// <summary>
/// adds the IEnumerator to the CoroutineManager. Coroutines get ticked before Update is called each frame.
/// </summary>
/// <returns>The coroutine.</returns>
/// <param name="enumerator">Enumerator.</param>
public ICoroutine startCoroutine(IEnumerator enumerator)
{
// find or create a CoroutineImpl
var coroutine = QuickCache <CoroutineImpl> .pop();
coroutine.prepareForReuse();
// setup the coroutine and add it
coroutine.enumerator = enumerator;
var shouldContinueCoroutine = tickCoroutine(coroutine);
// guard against empty coroutines
if (!shouldContinueCoroutine || coroutine.isDone)
{
coroutine.recycle();
QuickCache <CoroutineImpl> .push(coroutine);
return(null);
}
if (_isInUpdate)
{
_shouldRunNextFrame.Add(coroutine);
}
else
{
_unblockedCoroutines.Add(coroutine);
}
return(coroutine);
}
/// <summary>
/// adds a Particle to the emitter
/// </summary>
void addParticle()
{
// take the next particle out of the particle pool we have created and initialize it
var particle = QuickCache <Particle> .pop();
particle.initialize(_emitterConfig);
_particles.Add(particle);
}
/// <summary>
/// removes all particles from the particle emitter
/// </summary>
public void clear()
{
for (var i = 0; i < _particles.Count; i++)
{
QuickCache <Particle> .push(_particles[i]);
}
_particles.Clear();
}
/// <summary>
/// schedules a one-time or repeating timer that will call the passed in Action
/// </summary>
/// <param name="timeInSeconds">Time in seconds.</param>
/// <param name="repeats">If set to <c>true</c> repeats.</param>
/// <param name="context">Context.</param>
/// <param name="onTime">On time.</param>
internal ITimer schedule(float timeInSeconds, bool repeats, object context, Action <ITimer> onTime)
{
var timer = QuickCache <Timer> .pop();
timer.initialize(timeInSeconds, repeats, context, onTime);
_timers.Add(timer);
return(timer);
}
public static ITween <Color> colorPropertyTo(object self, string propertyName, Color to, float duration)
{
var tweenTarget = new PropertyTarget <Color>(self, propertyName);
var tween = TweenManager.cacheColorTweens ? QuickCache <ColorTween> .pop() : new ColorTween();
tween.initialize(tweenTarget, to, duration);
return(tween);
}
public static ITween <float> floatPropertyTo(object self, string propertyName, float to, float duration)
{
var tweenTarget = new PropertyTarget <float>(self, propertyName);
var tween = TweenManager.cacheFloatTweens ? QuickCache <FloatTween> .pop() : new FloatTween();
tween.initialize(tweenTarget, to, duration);
return(tween);
}
public override void recycleSelf()
{
base.recycleSelf();
if (_shouldRecycleTween && TweenManager.cacheFloatTweens)
{
QuickCache <FloatTween> .push(this);
}
}
public static ITween <Vector3> vector3PropertyTo(object self, string propertyName, Vector3 to, float duration)
{
var tweenTarget = new PropertyTarget <Vector3>(self, propertyName);
var tween = TweenManager.cacheVector3Tweens ? QuickCache <Vector3Tween> .pop() : new Vector3Tween();
tween.initialize(tweenTarget, to, duration);
return(tween);
}
public static ITween <Quaternion> quaternionPropertyTo(object self, string propertyName, Quaternion to, float duration)
{
var tweenTarget = new PropertyTarget <Quaternion>(self, propertyName);
var tween = TweenManager.cacheQuaternionTweens ? QuickCache <QuaternionTween> .pop() : new QuaternionTween();
tween.initialize(tweenTarget, to, duration);
return(tween);
}
public void update()
{
if (_isPaused)
{
return;
}
// if the emitter is active and the emission rate is greater than zero then emit particles
if (_active && _emitterConfig.emissionRate > 0)
{
var rate = 1.0f / _emitterConfig.emissionRate;
if (_particles.Count < _emitterConfig.maxParticles)
{
_emitCounter += Time.deltaTime;
}
while (_emitting && _particles.Count < _emitterConfig.maxParticles && _emitCounter > rate)
{
addParticle();
_emitCounter -= rate;
}
_elapsedTime += Time.deltaTime;
if (_emitterConfig.duration != -1 && _emitterConfig.duration < _elapsedTime)
{
// when we hit our duration we dont emit any more particles
_emitting = false;
// once all our particles are done we stop the emitter
if (_particles.Count == 0)
{
stop();
}
}
}
// prep data for the particle.update method
var rootPosition = entity.transform.position + _localPosition;
// loop through all the particles updating their location and color
for (var i = _particles.Count - 1; i >= 0; i--)
{
// get the current particle and update it
var currentParticle = _particles[i];
// if update returns true that means the particle is done
if (currentParticle.update(_emitterConfig, ref collisionConfig, rootPosition))
{
QuickCache <Particle> .push(currentParticle);
_particles.RemoveAt(i);
}
}
}
public override void recycleSelf()
{
if (_shouldRecycleTween)
{
_target = null;
_nextTween = null;
_transform = null;
QuickCache <TransformVector2Tween> .push(this);
}
}
public void update()
{
_isInUpdate = true;
for (var i = 0; i < _unblockedCoroutines.Count; i++)
{
var coroutine = _unblockedCoroutines[i];
// check for stopped coroutines
if (coroutine.isDone)
{
coroutine.recycle();
QuickCache <CoroutineImpl> .push(coroutine);
continue;
}
// are we waiting for any other coroutines to finish?
if (coroutine.waitForCoroutine != null)
{
if (coroutine.waitForCoroutine.isDone)
{
coroutine.waitForCoroutine = null;
}
else
{
_shouldRunNextFrame.Add(coroutine);
continue;
}
}
// deal with timers if we have them
if (coroutine.waitTimer > 0)
{
// still has time left. decrement and run again next frame
coroutine.waitTimer -= Time.deltaTime;
_shouldRunNextFrame.Add(coroutine);
continue;
}
if (tickCoroutine(coroutine))
{
_shouldRunNextFrame.Add(coroutine);
}
}
_unblockedCoroutines.Clear();
_unblockedCoroutines.AddRange(_shouldRunNextFrame);
_shouldRunNextFrame.Clear();
_isInUpdate = false;
}
public ParticleEmitter(ParticleEmitterConfig emitterConfig, bool playOnAwake = true)
{
_emitterConfig = emitterConfig;
_playOnAwake = playOnAwake;
_particles = new List <Particle>((int)_emitterConfig.maxParticles);
QuickCache <Particle> .warmCache((int)_emitterConfig.maxParticles);
// set some sensible defaults
collisionConfig.elasticity = 0.5f;
collisionConfig.friction = 0.5f;
collisionConfig.collidesWithLayers = Physics.allLayers;
collisionConfig.gravity = _emitterConfig.gravity;
collisionConfig.lifetimeLoss = 0f;
collisionConfig.minKillSpeedSquared = float.MinValue;
collisionConfig.radiusScale = 0.8f;
initialize();
}
/// <summary>
/// ticks a coroutine. returns true if the coroutine should continue to run next frame.
/// </summary>
/// <returns><c>true</c>, if coroutine was ticked, <c>false</c> otherwise.</returns>
/// <param name="coroutine">Coroutine.</param>
bool tickCoroutine(CoroutineImpl coroutine)
{
// This coroutine has finished
if (!coroutine.enumerator.MoveNext())
{
coroutine.recycle();
QuickCache <CoroutineImpl> .push(coroutine);
return(false);
}
if (coroutine.enumerator.Current == null)
{
// yielded null. run again next frame
return(true);
}
else if (coroutine.enumerator.Current is int)
{
var wait = (int)coroutine.enumerator.Current;
coroutine.waitTimer = wait;
return(true);
}
else if (coroutine.enumerator.Current is float)
{
var wait = (float)coroutine.enumerator.Current;
coroutine.waitTimer = wait;
return(true);
}
else if (coroutine.enumerator.Current is CoroutineImpl)
{
coroutine.waitForCoroutine = coroutine.enumerator.Current as CoroutineImpl;
return(true);
}
else
{
// This coroutine yielded null, or some other value we don't understand. run it next frame.
return(true);
}
}
public static IntTween create()
{
return(TweenManager.cacheIntTweens ? QuickCache <IntTween> .pop() : new IntTween());
}
public static ColorTween create()
{
return(TweenManager.cacheColorTweens ? QuickCache <ColorTween> .pop() : new ColorTween());
}
public static RectangleTween create()
{
return(TweenManager.cacheRectTweens ? QuickCache <RectangleTween> .pop() : new RectangleTween());
}
public static FloatTween create()
{
return(TweenManager.cacheFloatTweens ? QuickCache <FloatTween> .pop() : new FloatTween());
}
public static Vector2Tween create()
{
return(TweenManager.cacheVector2Tweens ? QuickCache <Vector2Tween> .pop() : new Vector2Tween());
}
public static QuaternionTween create()
{
return(TweenManager.cacheQuaternionTweens ? QuickCache <QuaternionTween> .pop() : new QuaternionTween());
}
