2017-10-17 03:16:52 +00:00
|
|
|
var Class = require('../../utils/Class');
|
|
|
|
var Components = require('../components');
|
|
|
|
var Easing = require('../../math/easing');
|
|
|
|
var GetEaseFunction = require('../../tweens/builder/GetEaseFunction');
|
2017-10-17 20:32:45 +00:00
|
|
|
var MinMax2 = require('../../math/MinMax2');
|
|
|
|
var MinMax4 = require('../../math/MinMax4');
|
2017-10-17 03:16:52 +00:00
|
|
|
var Particle = require('./Particle');
|
|
|
|
var StableSort = require('../../utils/array/StableSort');
|
2017-10-18 14:18:42 +00:00
|
|
|
var GetRandomElement = require('../../utils/array/GetRandomElement');
|
2017-10-17 03:16:52 +00:00
|
|
|
|
|
|
|
var ParticleEmitter = new Class({
|
|
|
|
|
|
|
|
Mixins: [
|
|
|
|
Components.BlendMode,
|
|
|
|
Components.ScrollFactor,
|
|
|
|
Components.Visible
|
|
|
|
],
|
|
|
|
|
|
|
|
initialize:
|
|
|
|
|
|
|
|
function ParticleEmitter (manager, config)
|
|
|
|
{
|
|
|
|
if (config === undefined) { config = {}; }
|
|
|
|
|
|
|
|
this.manager = manager;
|
|
|
|
|
|
|
|
this.key = '';
|
|
|
|
|
2017-10-17 20:32:45 +00:00
|
|
|
this.particleClass = Particle;
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-19 23:54:47 +00:00
|
|
|
this.texture = manager.texture;
|
|
|
|
|
|
|
|
// Unless overriden by the config
|
|
|
|
this.defaultFrame = manager.defaultFrame;
|
|
|
|
|
|
|
|
this.frames = [ manager.defaultFrame ];
|
2017-10-18 14:18:42 +00:00
|
|
|
|
2017-10-17 03:16:52 +00:00
|
|
|
this.dead = [];
|
|
|
|
this.alive = [];
|
|
|
|
|
2017-10-17 20:32:45 +00:00
|
|
|
this.x = 0;
|
|
|
|
this.y = 0;
|
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
// A radial emitter will emit particles in all directions between angle min and max
|
|
|
|
// A point emitter will emit particles only in the direction set by the speed values
|
|
|
|
this.radial = true;
|
|
|
|
|
|
|
|
this.speed = new MinMax4();
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-17 20:32:45 +00:00
|
|
|
this.scale = new MinMax4(1);
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-18 01:26:15 +00:00
|
|
|
this.gravity = new MinMax2();
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-17 20:32:45 +00:00
|
|
|
this.alpha = new MinMax2(1);
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
this.angle = new MinMax2(0, 360);
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-17 20:32:45 +00:00
|
|
|
this.particleAngle = new MinMax2();
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-17 20:32:45 +00:00
|
|
|
// The lifespan of the particles (in ms)
|
|
|
|
this.lifespan = new MinMax2(1000);
|
2017-10-17 03:16:52 +00:00
|
|
|
|
|
|
|
this.deathCallback = null;
|
|
|
|
this.deathCallbackScope = null;
|
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
// Set to hard limit the amount of particle objects this emitter is allowed to create
|
|
|
|
this.maxParticles = 0;
|
|
|
|
|
|
|
|
// How many particles are emitted each time the emitter updates
|
2017-10-17 03:16:52 +00:00
|
|
|
this.emitCount = 1;
|
2017-10-17 20:32:45 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
// How often a particle is emitted in ms (if emitter is a constant / flow emitter)
|
|
|
|
// If emitter is an explosion emitter this value will be -1.
|
|
|
|
// Anything > -1 sets this to be a flow emitter
|
|
|
|
this.frequency = 0;
|
|
|
|
|
|
|
|
// Controls if the emitter is currently emitting particles. Already alive particles will continue to update until they expire.
|
|
|
|
this.on = true;
|
|
|
|
|
|
|
|
// Newly emitted particles are added to the top of the particle list, i.e. rendered above those already alive. Set to false to send them to the back.
|
|
|
|
this.particleBringToTop = true;
|
2017-10-17 20:32:45 +00:00
|
|
|
|
|
|
|
this.timeScale = 1;
|
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
this._counter = 0;
|
2017-10-17 20:32:45 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
// Optional Particle emission zone - must be an object that supports a `getRandomPoint` function, such as a Rectangle, Circle, Path, etc.
|
|
|
|
this.zone = null;
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-20 00:49:03 +00:00
|
|
|
this.easingFunctionAlpha = Easing.Linear;
|
|
|
|
this.easingFunctionScale = Easing.Linear;
|
|
|
|
this.easingFunctionRotation = Easing.Linear;
|
2017-10-17 03:16:52 +00:00
|
|
|
|
|
|
|
this.active = true;
|
|
|
|
},
|
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
getFrame: function ()
|
|
|
|
{
|
2017-10-19 23:54:47 +00:00
|
|
|
if (this.frames.length === 1)
|
|
|
|
{
|
|
|
|
return this.defaultFrame;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return GetRandomElement(this.frames);
|
|
|
|
}
|
2017-10-18 14:18:42 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
// Either a single frame (numeric / string based), or an array of frames to randomly pick from
|
2017-10-19 23:54:47 +00:00
|
|
|
setFrame: function (frames)
|
2017-10-17 03:16:52 +00:00
|
|
|
{
|
2017-10-19 23:54:47 +00:00
|
|
|
this.manager.setEmitterFrames(frames, this);
|
2017-10-18 14:18:42 +00:00
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
setRadial: function (value)
|
|
|
|
{
|
|
|
|
if (value === undefined) { value = true; }
|
|
|
|
|
|
|
|
this.radial = value;
|
2017-10-17 03:16:52 +00:00
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
setPosition: function (x, y)
|
|
|
|
{
|
|
|
|
this.x = x;
|
|
|
|
this.y = y;
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
setEase: function (easeName, easeParam)
|
|
|
|
{
|
|
|
|
var ease = GetEaseFunction(easeName, easeParam);
|
|
|
|
|
|
|
|
this.easingFunctionAlpha = ease;
|
|
|
|
this.easingFunctionScale = ease;
|
|
|
|
this.easingFunctionRotation = ease;
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
setAlphaEase: function (easeName, easeParam)
|
|
|
|
{
|
|
|
|
this.easingFunctionAlpha = GetEaseFunction(easeName, easeParam);
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
setScaleEase: function (easeName, easeParam)
|
|
|
|
{
|
|
|
|
this.easingFunctionScale = GetEaseFunction(easeName, easeParam);
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
setRotationEase: function (easeName, easeParam)
|
|
|
|
{
|
|
|
|
this.easingFunctionRotation = GetEaseFunction(easeName, easeParam);
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-10-17 20:32:45 +00:00
|
|
|
// Particle Emission
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
setSpeed: function (xMin, xMax, yMin, yMax)
|
2017-10-17 20:32:45 +00:00
|
|
|
{
|
2017-10-18 14:18:42 +00:00
|
|
|
this.speed.set(xMin, xMax, yMin, yMax);
|
2017-10-17 03:16:52 +00:00
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-10-17 20:32:45 +00:00
|
|
|
setScale: function (xMin, xMax, yMin, yMax)
|
2017-10-17 03:16:52 +00:00
|
|
|
{
|
2017-10-17 20:32:45 +00:00
|
|
|
this.scale.set(xMin, xMax, yMin, yMax);
|
2017-10-17 03:16:52 +00:00
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-10-18 01:26:15 +00:00
|
|
|
setGravity: function (x, y)
|
2017-10-17 03:16:52 +00:00
|
|
|
{
|
2017-10-18 01:26:15 +00:00
|
|
|
this.gravity.set(x, y);
|
2017-10-17 03:16:52 +00:00
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-10-17 20:32:45 +00:00
|
|
|
setAlpha: function (min, max)
|
2017-10-17 03:16:52 +00:00
|
|
|
{
|
2017-10-17 20:32:45 +00:00
|
|
|
this.alpha.set(min, max);
|
2017-10-17 03:16:52 +00:00
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-10-17 20:32:45 +00:00
|
|
|
setAngle: function (min, max)
|
2017-10-17 03:16:52 +00:00
|
|
|
{
|
2017-10-17 20:32:45 +00:00
|
|
|
this.angle.set(min, max);
|
2017-10-17 03:16:52 +00:00
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-10-17 20:32:45 +00:00
|
|
|
setParticleAngle: function (min, max)
|
2017-10-17 03:16:52 +00:00
|
|
|
{
|
2017-10-17 20:32:45 +00:00
|
|
|
this.particleAngle.set(min, max);
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-17 20:32:45 +00:00
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
setLifespan: function (min, max)
|
|
|
|
{
|
|
|
|
this.lifespan.set(min, max);
|
2017-10-17 03:16:52 +00:00
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-10-19 23:54:47 +00:00
|
|
|
setQuantity: function (quantity)
|
|
|
|
{
|
|
|
|
this.emitCount = quantity;
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
setFrequency: function (frequency, quantity)
|
2017-10-17 03:16:52 +00:00
|
|
|
{
|
2017-10-18 14:18:42 +00:00
|
|
|
this.frequency = frequency;
|
2017-10-19 23:54:47 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
this._counter = 0;
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-19 23:54:47 +00:00
|
|
|
if (quantity)
|
|
|
|
{
|
|
|
|
this.emitCount = quantity;
|
|
|
|
}
|
|
|
|
|
2017-10-17 03:16:52 +00:00
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
// The zone must have a function called `getRandomPoint` that takes an object and sets
|
|
|
|
// its x and y properties accordingly then returns that object
|
|
|
|
setZone: function (zone)
|
2017-10-17 03:16:52 +00:00
|
|
|
{
|
2017-10-18 14:18:42 +00:00
|
|
|
if (zone === undefined)
|
|
|
|
{
|
|
|
|
this.zone = null;
|
|
|
|
}
|
|
|
|
else if (typeof zone.getRandomPoint === 'function')
|
|
|
|
{
|
|
|
|
this.zone = zone;
|
|
|
|
}
|
2017-10-17 03:16:52 +00:00
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-10-17 20:32:45 +00:00
|
|
|
// Particle Management
|
|
|
|
|
2017-10-17 03:16:52 +00:00
|
|
|
reserve: function (particleCount)
|
|
|
|
{
|
|
|
|
var dead = this.dead;
|
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
for (var i = 0; i < particleCount; i++)
|
2017-10-17 03:16:52 +00:00
|
|
|
{
|
2017-10-18 14:18:42 +00:00
|
|
|
dead.push(new this.particleClass());
|
2017-10-17 03:16:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
getAliveParticleCount: function ()
|
|
|
|
{
|
|
|
|
return this.alive.length;
|
|
|
|
},
|
|
|
|
|
|
|
|
getDeadParticleCount: function ()
|
|
|
|
{
|
|
|
|
return this.dead.length;
|
|
|
|
},
|
|
|
|
|
|
|
|
getParticleCount: function ()
|
|
|
|
{
|
|
|
|
return this.getAliveParticleCount() + this.getDeadParticleCount();
|
|
|
|
},
|
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
atLimit: function ()
|
|
|
|
{
|
|
|
|
return (this.maxParticles > 0 && this.getParticleCount() === this.maxParticles);
|
|
|
|
},
|
|
|
|
|
2017-10-17 03:16:52 +00:00
|
|
|
onParticleDeath: function (callback, context)
|
|
|
|
{
|
|
|
|
if (callback === undefined)
|
|
|
|
{
|
|
|
|
// Clear any previously set callback
|
|
|
|
this.deathCallback = null;
|
|
|
|
this.deathCallbackScope = null;
|
|
|
|
}
|
|
|
|
else if (typeof callback === 'function')
|
|
|
|
{
|
|
|
|
this.deathCallback = callback;
|
|
|
|
|
|
|
|
if (context)
|
|
|
|
{
|
|
|
|
this.deathCallbackScope = context;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
killAll: function ()
|
|
|
|
{
|
|
|
|
var dead = this.dead;
|
|
|
|
var alive = this.alive;
|
|
|
|
|
|
|
|
while (alive.length > 0)
|
|
|
|
{
|
|
|
|
dead.push(alive.pop());
|
|
|
|
}
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
forEachAlive: function (callback, thisArg)
|
|
|
|
{
|
|
|
|
var alive = this.alive;
|
|
|
|
var length = alive.length;
|
|
|
|
|
|
|
|
for (var index = 0; index < length; ++index)
|
|
|
|
{
|
2017-10-18 14:18:42 +00:00
|
|
|
// Sends the Particle and the Emitter
|
|
|
|
callback.call(thisArg, alive[index], this);
|
2017-10-17 03:16:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
forEachDead: function (callback, thisArg)
|
|
|
|
{
|
|
|
|
var dead = this.dead;
|
|
|
|
var length = dead.length;
|
|
|
|
|
|
|
|
for (var index = 0; index < length; ++index)
|
|
|
|
{
|
2017-10-18 14:18:42 +00:00
|
|
|
// Sends the Particle and the Emitter
|
|
|
|
callback.call(thisArg, dead[index], this);
|
2017-10-17 03:16:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
start: function ()
|
|
|
|
{
|
|
|
|
this.on = true;
|
|
|
|
|
|
|
|
this._counter = 0;
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-10-17 03:16:52 +00:00
|
|
|
pause: function ()
|
|
|
|
{
|
|
|
|
this.active = false;
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
resume: function ()
|
|
|
|
{
|
|
|
|
this.active = true;
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
flow: function (frequency, count)
|
|
|
|
{
|
|
|
|
if (count === undefined) { count = 1; }
|
2017-10-17 20:32:45 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
this.frequency = frequency;
|
2017-10-17 20:32:45 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
this.emitCount = count;
|
2017-10-17 20:32:45 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
return this.start();
|
|
|
|
},
|
2017-10-17 20:32:45 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
explode: function (count, x, y)
|
2017-10-17 03:16:52 +00:00
|
|
|
{
|
2017-10-18 14:18:42 +00:00
|
|
|
this.frequency = -1;
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
return this.emit(count, x, y);
|
2017-10-17 03:16:52 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
emitAt: function (x, y, count)
|
|
|
|
{
|
2017-10-18 14:18:42 +00:00
|
|
|
return this.emit(count, x, y);
|
|
|
|
},
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
emit: function (count, x, y)
|
|
|
|
{
|
|
|
|
if (count === undefined) { count = 1; }
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
var output = [];
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
if (this.atLimit())
|
|
|
|
{
|
|
|
|
return output;
|
|
|
|
}
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
// Store emitter coordinates in-case this was a placement explode, or emitAt
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
var oldX = this.x;
|
|
|
|
var oldY = this.y;
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
if (x !== undefined)
|
|
|
|
{
|
|
|
|
this.x = x;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (y !== undefined)
|
|
|
|
{
|
|
|
|
this.y = y;
|
|
|
|
}
|
2017-10-17 03:16:52 +00:00
|
|
|
|
|
|
|
var dead = this.dead;
|
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
for (var i = 0; i < count; i++)
|
2017-10-17 03:16:52 +00:00
|
|
|
{
|
2017-10-18 14:18:42 +00:00
|
|
|
var particle;
|
|
|
|
|
2017-10-17 03:16:52 +00:00
|
|
|
if (dead.length > 0)
|
|
|
|
{
|
|
|
|
particle = dead.pop();
|
2017-10-18 14:18:42 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
particle = new this.particleClass();
|
2017-10-17 03:16:52 +00:00
|
|
|
}
|
2017-10-18 14:18:42 +00:00
|
|
|
|
|
|
|
particle.emit(this);
|
|
|
|
|
|
|
|
if (this.particleBringToTop)
|
2017-10-17 03:16:52 +00:00
|
|
|
{
|
2017-10-18 14:18:42 +00:00
|
|
|
this.alive.push(particle);
|
2017-10-17 03:16:52 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-10-18 14:18:42 +00:00
|
|
|
this.alive.unshift(particle);
|
2017-10-17 03:16:52 +00:00
|
|
|
}
|
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
output.push(particle);
|
2017-10-17 20:32:45 +00:00
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
if (this.atLimit())
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
2017-10-17 03:16:52 +00:00
|
|
|
}
|
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
this.x = oldX;
|
|
|
|
this.y = oldY;
|
|
|
|
|
|
|
|
return output;
|
2017-10-17 03:16:52 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
preUpdate: function (time, delta)
|
|
|
|
{
|
2017-10-17 20:32:45 +00:00
|
|
|
// Scale the delta
|
|
|
|
delta *= this.timeScale;
|
|
|
|
|
2017-10-18 14:18:42 +00:00
|
|
|
var step = (delta / 1000);
|
2017-10-17 03:16:52 +00:00
|
|
|
var particles = this.alive;
|
|
|
|
var length = particles.length;
|
2017-10-17 20:32:45 +00:00
|
|
|
|
|
|
|
for (var index = 0; index < length; index++)
|
2017-10-17 03:16:52 +00:00
|
|
|
{
|
|
|
|
var particle = particles[index];
|
|
|
|
|
2017-10-17 20:32:45 +00:00
|
|
|
// update returns `true` if the particle is now dead (lifeStep < 0)
|
2017-10-18 01:26:15 +00:00
|
|
|
if (particle.update(this, delta, step))
|
2017-10-17 20:32:45 +00:00
|
|
|
{
|
|
|
|
// Moves the dead particle to the end of the particles array (ready for splicing out later)
|
|
|
|
var last = particles[length - 1];
|
|
|
|
|
2017-10-17 03:16:52 +00:00
|
|
|
particles[length - 1] = particle;
|
|
|
|
particles[index] = last;
|
2017-10-18 14:18:42 +00:00
|
|
|
|
2017-10-17 03:16:52 +00:00
|
|
|
index -= 1;
|
|
|
|
length -= 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Move dead particles to the dead array
|
|
|
|
var deadLength = particles.length - length;
|
|
|
|
|
|
|
|
if (deadLength > 0)
|
|
|
|
{
|
2017-10-18 14:18:42 +00:00
|
|
|
var rip = particles.splice(particles.length - deadLength, deadLength);
|
|
|
|
|
|
|
|
var deathCallback = this.deathCallback;
|
|
|
|
var deathCallbackScope = this.deathCallbackScope;
|
|
|
|
|
|
|
|
if (deathCallback)
|
|
|
|
{
|
|
|
|
for (var i = 0; i < rip.length; i++)
|
|
|
|
{
|
|
|
|
deathCallback.call(deathCallbackScope, rip[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
this.dead.concat(rip);
|
2017-10-17 03:16:52 +00:00
|
|
|
|
|
|
|
StableSort(particles, this.indexSort);
|
|
|
|
}
|
|
|
|
|
2017-10-19 23:54:47 +00:00
|
|
|
if (!this.on)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (this.frequency === 0)
|
|
|
|
{
|
|
|
|
this.emit(this.emitCount);
|
|
|
|
}
|
|
|
|
else if (this.frequency > 0)
|
2017-10-18 14:18:42 +00:00
|
|
|
{
|
|
|
|
this._counter -= delta;
|
|
|
|
|
|
|
|
if (this._counter <= 0)
|
|
|
|
{
|
|
|
|
this.emit(this.emitCount);
|
2017-10-17 03:16:52 +00:00
|
|
|
|
2017-10-19 23:54:47 +00:00
|
|
|
// counter = frequency - remained from previous delta
|
|
|
|
this._counter = (this.frequency - Math.abs(this._counter));
|
2017-10-18 14:18:42 +00:00
|
|
|
}
|
|
|
|
}
|
2017-10-17 03:16:52 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
indexSort: function (a, b)
|
|
|
|
{
|
|
|
|
return a.index - b.index;
|
|
|
|
}
|
|
|
|
|
|
|
|
});
|
|
|
|
|
|
|
|
module.exports = ParticleEmitter;
|