creativelifeform / three-nebula / 440

pending completion

Build # 440

Build Type

push

travis-ci

Committed by

rohan-deshpande

Commit Message

Added test for not setting rotation in MeshRenderer.onParticleUpdate if the target is a THREE.Sprite

Run Details

621 of 962 branches covered (64.55%)

Branch coverage included in aggregate %.

1534 of 1951 relevant lines covered (78.63%)

128.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.82

/src/emitter/Emitter.js

import {
  DEFAULT_BIND_EMITTER,
  DEFAULT_BIND_EMITTER_EVENT,
  DEFAULT_DAMPING,
  DEFAULT_EMITTER_INDEX,
  DEFAULT_EMITTER_RATE,
} from './constants';
import EventDispatcher, {
  EMITTER_DEAD,
  PARTICLE_CREATED,
  PARTICLE_DEAD,
  PARTICLE_UPDATE,
} from '../events';
import { INTEGRATION_TYPE_EULER, integrate } from '../math';
import { Util, uid } from '../utils';

import { InitializerUtil } from '../initializer';
import Particle from '../core/Particle';
import isNumber from 'lodash/isNumber';
import { EMITTER_TYPE_EMITTER as type } from './types';

/**
 * Emitters are the System engine's particle factories. They cause particles to
 * be rendered by emitting them, and store all particle initializers and behaviours.
 *
 */
export default class Emitter extends Particle {
  /**
   * Constructs an Emitter instance.
   *
   * @param {object} properties - The properties to instantiate the emitter with
   * @return void
   */
  constructor(properties) {
    super(properties);

    /**
     * @desc The class type.
     * @type {string}
     */
    this.type = type;

    /**
     * @desc The particles emitted by this emitter.
     * @type {array}
     */
    this.particles = [];

    /**
     * @desc The initializers for particles emitted by this emitter.
     * @type {array}
     */
    this.initializers = [];

    /**
     * @desc The behaviours for particles emitted by this emitter.
     * @type {array}
     */
    this.behaviours = [];

    /**
     * @desc The behaviours for the emitter.
     * @type {array}
     */
    this.emitterBehaviours = [];

    /**
     * @desc The current emit iteration.
     * @type {integer}
     */
    this.currentEmitTime = 0;

    /**
     * @desc The total number of times the emitter should emit particles.
     * @type {integer}
     */
    this.totalEmitTimes = -1;

    /**
     * @desc The friction coefficient for all particle to emit by.
     * @type {number}
     */
    this.damping = DEFAULT_DAMPING;

    /**
     * @desc Ensures that particles emitted by this emitter are positioned
     * according to the emitter's properties.
     * @type {boolean}
     */
    this.bindEmitter = DEFAULT_BIND_EMITTER;

    /**
     * @desc Determines if the emitter will dispatch internal events. Defaults
     * to false
     * @type {boolean}
     */
    this.bindEmitterEvent = DEFAULT_BIND_EMITTER_EVENT;

    /**
     * @desc The number of particles to emit per second (a [particle]/b [s])
     * @type {Rate}
     */
    this.rate = DEFAULT_EMITTER_RATE;

    /**
     * @desc Determines if the emitter is emitting particles or not.
     * @type {boolean}
     */
    this.isEmitting = false;

    /**
     * @desc The emitter's id.
     * @type {string}
     */
    this.id = `emitter-${uid()}`;
    this.cID = 0;
    this.name = 'Emitter';

    /**
     * @desc The index of the emitter as it is added to the system.
     * @type {number|undefined}
     */
    this.index = DEFAULT_EMITTER_INDEX;

    /**
     * @desc The emitter's internal event dispatcher.
     * @type {EventDispatcher}
     */
    this.eventDispatcher = new EventDispatcher();
  }

  /**
   * Proxy method for the internal event dispatcher's dispatchEvent method.
   *
   * @param {string} event - The event to dispatch
   * @param {object<Particle>} [target=this] - The event target
   */
  dispatch(event, target = this) {
    this.eventDispatcher.dispatchEvent(event, target);
  }

  /**
   * Sets the emitter rate.
   *
   * @param {Rate} rate - a rate initializer object
   * @return {Emitter}
   */
  setRate(rate) {
    this.rate = rate;

    return this;
  }

  /**
   * Sets the position of the emitter.
   *
   * @param {object} newPosition - an object the new x, y and z props
   * @return {Emitter}
   */
  setPosition(newPosition = {}) {
    const { position } = this;
    const { x = position.x, y = position.y, z = position.z } = newPosition;

    this.position.set(x, y, z);

    return this;
  }

  /**
   * Sets the rotation of the emitter.
   *
   * @param {object} newRotation - an object the new x, y and z props
   * @return {Emitter}
   */
  setRotation(newRotation = {}) {
    const { rotation } = this;
    const { x = rotation.x, y = rotation.y, z = rotation.z } = newRotation;

    this.rotation.set(x, y, z);

    return this;
  }

  /**
   * Sets the total number of times the emitter should emit particles as well as
   * the emitter's life. Also intializes the emitter rate.
   * This enables the emitter to emit particles.
   *
   * @param {number} [totalEmitTimes=Infinity] - the total number of times to emit particles
   * @param {number} [life=Infinity] - the life of this emitter in milliseconds
   * @return {Emitter}
   */
  emit(totalEmitTimes = Infinity, life = Infinity) {
    this.currentEmitTime = 0;
    this.totalEmitTimes = isNumber(totalEmitTimes) ? totalEmitTimes : Infinity;

    if (totalEmitTimes === 1) {
      this.life = totalEmitTimes;
    } else {
      this.life = isNumber(life) ? life : Infinity;
    }

    this.rate.init();
    this.isEmitting = true;

    return this;
  }

  /**
   * Experimental emit method that is designed to be called from the System.emit method.
   *
   * @return {Emitter}
   */
  experimental_emit() {
    const { isEmitting, totalEmitTimes, life } = this;

    if (!isEmitting) {
      this.currentEmitTime = 0;

      if (!totalEmitTimes) {
        this.setTotalEmitTimes(Infinity);
      }

      if (!life) {
        this.setLife(Infinity);
      }

      this.rate.init();
      this.isEmitting = true;
    }

    return this;
  }

  /**
   * Sets the total emit times for the emitter.
   *
   * @param {number} [totalEmitTimes=Infinity] - the total number of times to emit particles
   * @return {Emitter}
   */
  setTotalEmitTimes(totalEmitTimes = Infinity) {
    this.totalEmitTimes = isNumber(totalEmitTimes) ? totalEmitTimes : Infinity;

    return this;
  }

  /**
   * Sets the life of the emitter.
   *
   * @param {number} [life=Infinity] - the life of this emitter in milliseconds
   * @return {Emitter}
   */
  setLife(life = Infinity) {
    if (this.totalEmitTimes === 1) {
      this.life = this.totalEmitTimes;
    } else {
      this.life = isNumber(life) ? life : Infinity;
    }

    return this;
  }

  /**
   * Stops the emitter from emitting particles.
   *
   * @return void
   */
  stopEmit() {
    this.totalEmitTimes = -1;
    this.currentEmitTime = 0;
    this.isEmitting = false;
  }

  /**
   * Kills all of the emitter's particles.
   *
   * @return void
   */
  removeAllParticles() {
    let i = this.particles.length;

    while (i--) {
      this.particles[i].dead = true;
    }
  }

  /**
   * Adds a particle initializer to the emitter.
   * Each initializer is run on each particle when they are created.
   *
   * @param {Initializer} initializer - The initializer to add
   * @return {Emitter}
   */
  addInitializer(initializer) {
    this.initializers.push(initializer);

    return this;
  }

  /**
   * Adds multiple particle initializers to the emitter.
   *
   * @param {array<Initializer>} initializers - an array of particle initializers
   * @return {Emitter}
   */
  addInitializers(initializers) {
    let i = initializers.length;

    while (i--) {
      this.addInitializer(initializers[i]);
    }

    return this;
  }

  /**
   * Sets the emitter's particle initializers.
   *
   * @param {array<Initializer>} initializers - an array of particle initializers
   * @return {Emitter}
   */
  setInitializers(initializers) {
    this.initializers = initializers;

    return this;
  }

  /**
   * Removes an initializer from the emitter's initializers array.
   *
   * @param {Initializer} initializer - The initializer to remove
   * @return {Emitter}
   */
  removeInitializer(initializer) {
    const index = this.initializers.indexOf(initializer);

    if (index > -1) {
      this.initializers.splice(index, 1);
    }

    return this;
  }

  /**
   * Removes all initializers.
   *
   * @return {Emitter}
   */
  removeAllInitializers() {
    Util.destroyArray(this.initializers);

    return this;
  }

  /**
   * Adds a behaviour to the emitter. All emitter behaviours are added to each particle when
   * they are emitted.
   *
   * @param {Behaviour} behaviour - The behaviour to add to the emitter
   * @return {Emitter}
   */
  addBehaviour(behaviour) {
    this.behaviours.push(behaviour);

    return this;
  }

  /**
   * Adds multiple behaviours to the emitter.
   *
   * @param {array<Behaviour>} behaviours - an array of emitter behaviours
   * @return {Emitter}
   */
  addBehaviours(behaviours) {
    let i = behaviours.length;

    while (i--) {
      this.addBehaviour(behaviours[i]);
    }

    return this;
  }

  /**
   * Sets the emitter's behaviours.
   *
   * @param {array<Behaviour>} behaviours - an array of emitter behaviours
   * @return {Emitter}
   */
  setBehaviours(behaviours) {
    this.behaviours = behaviours;

    return this;
  }

  /**
   * Removes the behaviour from the emitter's behaviours array.
   *
   * @param {Behaviour} behaviour - The behaviour to remove
   * @return {Emitter}
   */
  removeBehaviour(behaviour) {
    const index = this.behaviours.indexOf(behaviour);

    if (index > -1) {
      this.behaviours.splice(index, 1);
    }

    return this;
  }

  /**
   * Removes all behaviours from the emitter.
   *
   * @return {Emitter}
   */
  removeAllBehaviours() {
    Util.destroyArray(this.behaviours);

    return this;
  }

  /**
   * Adds an emitter behaviour to the emitter.
   *
   * @param {Behaviour} behaviour - The behaviour to add to the emitter
   * @return {Emitter}
   */
  addEmitterBehaviour(behaviour) {
    this.emitterBehaviours.push(behaviour);

    behaviour.initialize(this);

    return this;
  }

  /**
   * Adds multiple behaviours to the emitter.
   *
   * @param {array<Behaviour>} behaviours - an array of emitter behaviours
   * @return {Emitter}
   */
  addEmitterBehaviours(behaviours) {
    let i = behaviours.length;

    while (i--) {
      this.addEmitterBehaviour(behaviours[i]);
    }

    return this;
  }

  /**
   * Sets the emitter's behaviours.
   *
   * @param {array<Behaviour>} behaviours - an array of emitter behaviours
   * @return {Emitter}
   */
  setEmitterBehaviours(behaviours) {
    const length = behaviours.length;

    this.emitterBehaviours = behaviours;

    for (let i = 0; i < length; i++) {
      this.emitterBehaviours[i].initialize(this);
    }

    return this;
  }

  /**
   * Removes the behaviour from the emitter's behaviours array.
   *
   * @param {Behaviour} behaviour - The behaviour to remove
   * @return {Emitter}
   */
  removeEmitterBehaviour(behaviour) {
    const index = this.emitterBehaviours.indexOf(behaviour);

    if (index > -1) {
      this.emitterBehaviours.splice(index, 1);
    }

    return this;
  }

  /**
   * Removes all behaviours from the emitter.
   *
   * @return {Emitter}
   */
  removeAllEmitterBehaviours() {
    Util.destroyArray(this.emitterBehaviours);

    return this;
  }

  /**
   * Adds the event listener for the EMITTER_DEAD event.
   *
   * @param {onEmitterDead} - The function to call when the EMITTER_DEAD is dispatched.
   * @return {Emitter}
   */
  addOnEmitterDeadEventListener(onEmitterDead) {
    this.eventDispatcher.addEventListener(`${this.id}_${EMITTER_DEAD}`, () =>
      onEmitterDead()
    );

    return this;
  }

  /**
   * Creates a particle by retreiving one from the pool and setting it up with
   * the supplied initializer and behaviour.
   *
   * @return {Emitter}
   */
  createParticle() {
    const particle = this.parent.pool.get(Particle);
    const index = this.particles.length;

    this.setupParticle(particle, index);
    this.parent && this.parent.dispatch(PARTICLE_CREATED, particle);
    this.bindEmitterEvent && this.dispatch(PARTICLE_CREATED, particle);

    return particle;
  }

  /**
   * Sets up a particle by running all initializers on it and setting its behaviours.
   * Also adds the particle to this.particles.
   *
   * @param {Particle} particle - The particle to setup
   * @return void
   */
  setupParticle(particle, index) {
    const { initializers, behaviours } = this;

    InitializerUtil.initialize(this, particle, initializers);

    particle.addBehaviours(behaviours);
    particle.parent = this;
    particle.index = index;

    this.particles.push(particle);
  }

  /**
   * Updates the emitter according to the time passed by calling the generate
   * and integrate methods. The generate method creates particles, the integrate
   * method updates existing particles.
   *
   * If the emitter age is greater than time, the emitter is killed.
   *
   * This method also indexes/deindexes particles.
   *
   * @param {number} time - System engine time
   * @return void
   */
  update(time) {
    if (!this.isEmitting) {
      return;
    }

    this.age += time;

    if (this.dead || this.age >= this.life) {
      this.destroy();
    }

    this.generate(time);
    this.integrate(time);

    let i = this.particles.length;

    while (i--) {
      const particle = this.particles[i];

      if (particle.dead) {
        this.parent && this.parent.dispatch(PARTICLE_DEAD, particle);
        this.bindEmitterEvent && this.dispatch(PARTICLE_DEAD, particle);
        this.parent.pool.expire(particle.reset());
        this.particles.splice(i, 1);
      }
    }

    this.updateEmitterBehaviours(time);
  }

  /**
   * Updates the emitter's emitter behaviours.
   *
   * @param {number} time - System engine time
   * @return void
   */
  updateEmitterBehaviours(time) {
    if (this.sleep) {
      return;
    }

    const length = this.emitterBehaviours.length;

    for (let i = 0; i < length; i++) {
      this.emitterBehaviours[i].applyBehaviour(this, time, i);
    }
  }

  /**
   * Runs the integration algorithm on the emitter and all particles.
   * Updates the particles with the timstamp passed.
   *
   * @param {number} time - System engine time
   * @return void
   */
  integrate(time) {
    const integrationType = this.parent
      ? this.parent.integrationType
      : INTEGRATION_TYPE_EULER;
    const damping = 1 - this.damping;

    integrate(this, time, damping, integrationType);

    let index = this.particles.length;

    while (index--) {
      const particle = this.particles[index];

      particle.update(time, index);
      integrate(particle, time, damping, integrationType);

      this.parent && this.parent.dispatch(PARTICLE_UPDATE, particle);
      this.bindEmitterEvent && this.dispatch(PARTICLE_UPDATE, particle);
    }
  }

  /**
   * Generates new particles.
   *
   * @param {number} time - System engine time
   * @return void
   */
  generate(time) {
    if (this.totalEmitTimes === 1) {
      let i = this.rate.getValue(99999);

      if (i > 0) {
        this.cID = i;
      }

      while (i--) {
        this.createParticle();
      }

      this.totalEmitTimes = 0;

      return;
    }

    this.currentEmitTime += time;

    if (this.currentEmitTime < this.totalEmitTimes) {
      let i = this.rate.getValue(time);

      if (i > 0) {
        this.cID = i;
      }

      while (i--) {
        this.createParticle();
      }
    }
  }

  /**
   * Kills the emitter.
   *
   * @return void
   */
  destroy() {
    this.dead = true;
    this.energy = 0;
    this.totalEmitTimes = -1;

    if (this.particles.length == 0) {
      this.isEmitting = false;
      this.removeAllInitializers();
      this.removeAllBehaviours();
      this.dispatch(`${this.id}_${EMITTER_DEAD}`);

      this.parent && this.parent.removeEmitter(this);
    }
  }
}

1	import {	1✔
2	DEFAULT_BIND_EMITTER,
3	DEFAULT_BIND_EMITTER_EVENT,
4	DEFAULT_DAMPING,
5	DEFAULT_EMITTER_INDEX,
6	DEFAULT_EMITTER_RATE,
7	} from './constants';
8	import EventDispatcher, {	1✔
9	EMITTER_DEAD,
10	PARTICLE_CREATED,
11	PARTICLE_DEAD,
12	PARTICLE_UPDATE,
13	} from '../events';
14	import { INTEGRATION_TYPE_EULER, integrate } from '../math';	1✔
15	import { Util, uid } from '../utils';	1✔
16
17	import { InitializerUtil } from '../initializer';	1✔
18	import Particle from '../core/Particle';	1✔
19	import isNumber from 'lodash/isNumber';	1✔
20	import { EMITTER_TYPE_EMITTER as type } from './types';	1✔
21
22	/**
23	* Emitters are the System engine's particle factories. They cause particles to
24	* be rendered by emitting them, and store all particle initializers and behaviours.
25	*
26	*/
27	export default class Emitter extends Particle {
28	/**
29	* Constructs an Emitter instance.
30	*
31	* @param {object} properties - The properties to instantiate the emitter with
32	* @return void
33	*/
34	constructor(properties) {	182✔
35	super(properties);	91✔
36
37	/**
38	* @desc The class type.
39	* @type {string}
40	*/
41	this.type = type;	91✔
42
43	/**
44	* @desc The particles emitted by this emitter.
45	* @type {array}
46	*/
47	this.particles = [];	91✔
48
49	/**
50	* @desc The initializers for particles emitted by this emitter.
51	* @type {array}
52	*/
53	this.initializers = [];	91✔
54
55	/**
56	* @desc The behaviours for particles emitted by this emitter.
57	* @type {array}
58	*/
59	this.behaviours = [];	91✔
60
61	/**
62	* @desc The behaviours for the emitter.
63	* @type {array}
64	*/
65	this.emitterBehaviours = [];	91✔
66
67	/**
68	* @desc The current emit iteration.
69	* @type {integer}
70	*/
71	this.currentEmitTime = 0;	91✔
72
73	/**
74	* @desc The total number of times the emitter should emit particles.
75	* @type {integer}
76	*/
77	this.totalEmitTimes = -1;	91✔
78
79	/**
80	* @desc The friction coefficient for all particle to emit by.
81	* @type {number}
82	*/
83	this.damping = DEFAULT_DAMPING;	91✔
84
85	/**
86	* @desc Ensures that particles emitted by this emitter are positioned
87	* according to the emitter's properties.
88	* @type {boolean}
89	*/
90	this.bindEmitter = DEFAULT_BIND_EMITTER;	91✔
91
92	/**
93	* @desc Determines if the emitter will dispatch internal events. Defaults
94	* to false
95	* @type {boolean}
96	*/
97	this.bindEmitterEvent = DEFAULT_BIND_EMITTER_EVENT;	91✔
98
99	/**
100	* @desc The number of particles to emit per second (a [particle]/b [s])
101	* @type {Rate}
102	*/
103	this.rate = DEFAULT_EMITTER_RATE;	91✔
104
105	/**
106	* @desc Determines if the emitter is emitting particles or not.
107	* @type {boolean}
108	*/
109	this.isEmitting = false;	91✔
110
111	/**
112	* @desc The emitter's id.
113	* @type {string}
114	*/
115	this.id = `emitter-${uid()}`;	91✔
116	this.cID = 0;	91✔
117	this.name = 'Emitter';	91✔
118
119	/**
120	* @desc The index of the emitter as it is added to the system.
121	* @type {number\|undefined}
122	*/
123	this.index = DEFAULT_EMITTER_INDEX;	91✔
124
125	/**
126	* @desc The emitter's internal event dispatcher.
127	* @type {EventDispatcher}
128	*/
129	this.eventDispatcher = new EventDispatcher();	91✔
130	}
131
132	/**
133	* Proxy method for the internal event dispatcher's dispatchEvent method.
134	*
135	* @param {string} event - The event to dispatch
136	* @param {object<Particle>} [target=this] - The event target
137	*/
138	dispatch(event, target = this) {	8✔
139	this.eventDispatcher.dispatchEvent(event, target);	8✔
140	}
141
142	/**
143	* Sets the emitter rate.
144	*
145	* @param {Rate} rate - a rate initializer object
146	* @return {Emitter}
147	*/
148	setRate(rate) {
149	this.rate = rate;	29✔
150
151	return this;	29✔
152	}
153
154	/**
155	* Sets the position of the emitter.
156	*
157	* @param {object} newPosition - an object the new x, y and z props
158	* @return {Emitter}
159	*/
160	setPosition(newPosition = {}) {	54!
161	const { position } = this;	18✔
162	const { x = position.x, y = position.y, z = position.z } = newPosition;	18!
163
164	this.position.set(x, y, z);	18✔
165
166	return this;	18✔
167	}
168
169	/**
170	* Sets the rotation of the emitter.
171	*
172	* @param {object} newRotation - an object the new x, y and z props
173	* @return {Emitter}
174	*/
175	setRotation(newRotation = {}) {	60✔
176	const { rotation } = this;	20✔
177	const { x = rotation.x, y = rotation.y, z = rotation.z } = newRotation;	20✔
178
179	this.rotation.set(x, y, z);	20✔
180
181	return this;	20✔
182	}
183
184	/**
185	* Sets the total number of times the emitter should emit particles as well as
186	* the emitter's life. Also intializes the emitter rate.
187	* This enables the emitter to emit particles.
188	*
189	* @param {number} [totalEmitTimes=Infinity] - the total number of times to emit particles
190	* @param {number} [life=Infinity] - the life of this emitter in milliseconds
191	* @return {Emitter}
192	*/
193	emit(totalEmitTimes = Infinity, life = Infinity) {	20✔
194	this.currentEmitTime = 0;	20✔
195	this.totalEmitTimes = isNumber(totalEmitTimes) ? totalEmitTimes : Infinity;	20✔
196
197	if (totalEmitTimes === 1) {	20✔
198	this.life = totalEmitTimes;	4✔
199	} else {
200	this.life = isNumber(life) ? life : Infinity;	16!
201	}
202
203	this.rate.init();	20✔
204	this.isEmitting = true;	20✔
205
206	return this;	20✔
207	}
208
209	/**
210	* Experimental emit method that is designed to be called from the System.emit method.
211	*
212	* @return {Emitter}
213	*/
214	experimental_emit() {
215	const { isEmitting, totalEmitTimes, life } = this;	6✔
216
217	if (!isEmitting) {	6✔
218	this.currentEmitTime = 0;	5✔
219
220	if (!totalEmitTimes) {	5✔
221	this.setTotalEmitTimes(Infinity);	1✔
222	}
223
224	if (!life) {	5✔
225	this.setLife(Infinity);	1✔
226	}
227
228	this.rate.init();	5✔
229	this.isEmitting = true;	5✔
230	}
231
232	return this;	6✔
233	}
234
235	/**
236	* Sets the total emit times for the emitter.
237	*
238	* @param {number} [totalEmitTimes=Infinity] - the total number of times to emit particles
239	* @return {Emitter}
240	*/
241	setTotalEmitTimes(totalEmitTimes = Infinity) {	15✔
242	this.totalEmitTimes = isNumber(totalEmitTimes) ? totalEmitTimes : Infinity;	15✔
243
244	return this;	15✔
245	}
246
247	/**
248	* Sets the life of the emitter.
249	*
250	* @param {number} [life=Infinity] - the life of this emitter in milliseconds
251	* @return {Emitter}
252	*/
253	setLife(life = Infinity) {	18✔
254	if (this.totalEmitTimes === 1) {	18✔
255	this.life = this.totalEmitTimes;	1✔
256	} else {
257	this.life = isNumber(life) ? life : Infinity;	17✔
258	}
259
260	return this;	18✔
261	}
262
263	/**
264	* Stops the emitter from emitting particles.
265	*
266	* @return void
267	*/
268	stopEmit() {
269	this.totalEmitTimes = -1;	1✔
270	this.currentEmitTime = 0;	1✔
271	this.isEmitting = false;	1✔
272	}
273
274	/**
275	* Kills all of the emitter's particles.
276	*
277	* @return void
278	*/
279	removeAllParticles() {
280	let i = this.particles.length;	1✔
281
282	while (i--) {	1✔
283	this.particles[i].dead = true;	500✔
284	}
285	}
286
287	/**
288	* Adds a particle initializer to the emitter.
289	* Each initializer is run on each particle when they are created.
290	*
291	* @param {Initializer} initializer - The initializer to add
292	* @return {Emitter}
293	*/
294	addInitializer(initializer) {
295	this.initializers.push(initializer);	9✔
296
297	return this;	9✔
298	}
299
300	/**
301	* Adds multiple particle initializers to the emitter.
302	*
303	* @param {array<Initializer>} initializers - an array of particle initializers
304	* @return {Emitter}
305	*/
306	addInitializers(initializers) {
307	let i = initializers.length;	3✔
308
309	while (i--) {	3✔
310	this.addInitializer(initializers[i]);	8✔
311	}
312
313	return this;	3✔
314	}
315
316	/**
317	* Sets the emitter's particle initializers.
318	*
319	* @param {array<Initializer>} initializers - an array of particle initializers
320	* @return {Emitter}
321	*/
322	setInitializers(initializers) {
323	this.initializers = initializers;	22✔
324
325	return this;	22✔
326	}
327
328	/**
329	* Removes an initializer from the emitter's initializers array.
330	*
331	* @param {Initializer} initializer - The initializer to remove
332	* @return {Emitter}
333	*/
334	removeInitializer(initializer) {
335	const index = this.initializers.indexOf(initializer);	1✔
336
337	if (index > -1) {	1!
338	this.initializers.splice(index, 1);	1✔
339	}
340
341	return this;	1✔
342	}
343
344	/**
345	* Removes all initializers.
346	*
347	* @return {Emitter}
348	*/
349	removeAllInitializers() {
350	Util.destroyArray(this.initializers);	7✔
351
352	return this;	7✔
353	}
354
355	/**
356	* Adds a behaviour to the emitter. All emitter behaviours are added to each particle when
357	* they are emitted.
358	*
359	* @param {Behaviour} behaviour - The behaviour to add to the emitter
360	* @return {Emitter}
361	*/
362	addBehaviour(behaviour) {
363	this.behaviours.push(behaviour);	4✔
364
365	return this;	4✔
366	}
367
368	/**
369	* Adds multiple behaviours to the emitter.
370	*
371	* @param {array<Behaviour>} behaviours - an array of emitter behaviours
372	* @return {Emitter}
373	*/
374	addBehaviours(behaviours) {
375	let i = behaviours.length;	1✔
376
377	while (i--) {	1✔
378	this.addBehaviour(behaviours[i]);	3✔
379	}
380
381	return this;	1✔
382	}
383
384	/**
385	* Sets the emitter's behaviours.
386	*
387	* @param {array<Behaviour>} behaviours - an array of emitter behaviours
388	* @return {Emitter}
389	*/
390	setBehaviours(behaviours) {
391	this.behaviours = behaviours;	25✔
392
393	return this;	25✔
394	}
395
396	/**
397	* Removes the behaviour from the emitter's behaviours array.
398	*
399	* @param {Behaviour} behaviour - The behaviour to remove
400	* @return {Emitter}
401	*/
402	removeBehaviour(behaviour) {
403	const index = this.behaviours.indexOf(behaviour);	1✔
404
405	if (index > -1) {	1!
406	this.behaviours.splice(index, 1);	1✔
407	}
408
409	return this;	1✔
410	}
411
412	/**
413	* Removes all behaviours from the emitter.
414	*
415	* @return {Emitter}
416	*/
417	removeAllBehaviours() {
418	Util.destroyArray(this.behaviours);	7✔
419
420	return this;	7✔
421	}
422
423	/**
424	* Adds an emitter behaviour to the emitter.
425	*
426	* @param {Behaviour} behaviour - The behaviour to add to the emitter
427	* @return {Emitter}
428	*/
429	addEmitterBehaviour(behaviour) {
430	this.emitterBehaviours.push(behaviour);	4✔
431
432	behaviour.initialize(this);	4✔
433
434	return this;	4✔
435	}
436
437	/**
438	* Adds multiple behaviours to the emitter.
439	*
440	* @param {array<Behaviour>} behaviours - an array of emitter behaviours
441	* @return {Emitter}
442	*/
443	addEmitterBehaviours(behaviours) {
444	let i = behaviours.length;	1✔
445
446	while (i--) {	1✔
447	this.addEmitterBehaviour(behaviours[i]);	3✔
448	}
449
450	return this;	1✔
451	}
452
453	/**
454	* Sets the emitter's behaviours.
455	*
456	* @param {array<Behaviour>} behaviours - an array of emitter behaviours
457	* @return {Emitter}
458	*/
459	setEmitterBehaviours(behaviours) {
460	const length = behaviours.length;	21✔
461
462	this.emitterBehaviours = behaviours;	21✔
463
464	for (let i = 0; i < length; i++) {	21✔
465	this.emitterBehaviours[i].initialize(this);	11✔
466	}
467
468	return this;	21✔
469	}
470
471	/**
472	* Removes the behaviour from the emitter's behaviours array.
473	*
474	* @param {Behaviour} behaviour - The behaviour to remove
475	* @return {Emitter}
476	*/
477	removeEmitterBehaviour(behaviour) {
478	const index = this.emitterBehaviours.indexOf(behaviour);	1✔
479
480	if (index > -1) {	1!
481	this.emitterBehaviours.splice(index, 1);	1✔
482	}
483
484	return this;	1✔
485	}
486
487	/**
488	* Removes all behaviours from the emitter.
489	*
490	* @return {Emitter}
491	*/
492	removeAllEmitterBehaviours() {
493	Util.destroyArray(this.emitterBehaviours);	1✔
494
495	return this;	1✔
496	}
497
498	/**
499	* Adds the event listener for the EMITTER_DEAD event.
500	*
501	* @param {onEmitterDead} - The function to call when the EMITTER_DEAD is dispatched.
502	* @return {Emitter}
503	*/
504	addOnEmitterDeadEventListener(onEmitterDead) {
505	this.eventDispatcher.addEventListener(`${this.id}_${EMITTER_DEAD}`, () =>	2✔
506	onEmitterDead()
507	);
508
509	return this;	2✔
510	}
511
512	/**
513	* Creates a particle by retreiving one from the pool and setting it up with
514	* the supplied initializer and behaviour.
515	*
516	* @return {Emitter}
517	*/
518	createParticle() {
519	const particle = this.parent.pool.get(Particle);	1,012✔
520	const index = this.particles.length;	1,012✔
521
522	this.setupParticle(particle, index);	1,012✔
523	this.parent && this.parent.dispatch(PARTICLE_CREATED, particle);	1,012✔
524	this.bindEmitterEvent && this.dispatch(PARTICLE_CREATED, particle);	1,012✔
525
526	return particle;	1,012✔
527	}
528
529	/**
530	* Sets up a particle by running all initializers on it and setting its behaviours.
531	* Also adds the particle to this.particles.
532	*
533	* @param {Particle} particle - The particle to setup
534	* @return void
535	*/
536	setupParticle(particle, index) {
537	const { initializers, behaviours } = this;	1,015✔
538
539	InitializerUtil.initialize(this, particle, initializers);	1,015✔
540
541	particle.addBehaviours(behaviours);	1,015✔
542	particle.parent = this;	1,015✔
543	particle.index = index;	1,015✔
544
545	this.particles.push(particle);	1,015✔
546	}
547
548	/**
549	* Updates the emitter according to the time passed by calling the generate
550	* and integrate methods. The generate method creates particles, the integrate
551	* method updates existing particles.
552	*
553	* If the emitter age is greater than time, the emitter is killed.
554	*
555	* This method also indexes/deindexes particles.
556	*
557	* @param {number} time - System engine time
558	* @return void
559	*/
560	update(time) {
561	if (!this.isEmitting) {	12✔
562	return;	1✔
563	}
564
565	this.age += time;	11✔
566
567	if (this.dead \|\| this.age >= this.life) {	11✔
568	this.destroy();	3✔
569	}
570
571	this.generate(time);	11✔
572	this.integrate(time);	11✔
573
574	let i = this.particles.length;	11✔
575
576	while (i--) {	11✔
577	const particle = this.particles[i];	1,033✔
578
579	if (particle.dead) {	1,033✔
580	this.parent && this.parent.dispatch(PARTICLE_DEAD, particle);	23✔
581	this.bindEmitterEvent && this.dispatch(PARTICLE_DEAD, particle);	23!
582	this.parent.pool.expire(particle.reset());	23✔
583	this.particles.splice(i, 1);	23✔
584	}
585	}
586
587	this.updateEmitterBehaviours(time);	11✔
588	}
589
590	/**
591	* Updates the emitter's emitter behaviours.
592	*
593	* @param {number} time - System engine time
594	* @return void
595	*/
596	updateEmitterBehaviours(time) {
597	if (this.sleep) {	11!
598	return;	×
599	}
600
601	const length = this.emitterBehaviours.length;	11✔
602
603	for (let i = 0; i < length; i++) {	11✔
604	this.emitterBehaviours[i].applyBehaviour(this, time, i);	1✔
605	}
606	}
607
608	/**
609	* Runs the integration algorithm on the emitter and all particles.
610	* Updates the particles with the timstamp passed.
611	*
612	* @param {number} time - System engine time
613	* @return void
614	*/
615	integrate(time) {
616	const integrationType = this.parent	14✔
617	? this.parent.integrationType	14✔
618	: INTEGRATION_TYPE_EULER;
619	const damping = 1 - this.damping;	14✔
620
621	integrate(this, time, damping, integrationType);	14✔
622
623	let index = this.particles.length;	14✔
624
625	while (index--) {	14✔
626	const particle = this.particles[index];	1,067✔
627
628	particle.update(time, index);	1,067✔
629	integrate(particle, time, damping, integrationType);	1,067✔
630
631	this.parent && this.parent.dispatch(PARTICLE_UPDATE, particle);	1,067✔
632	this.bindEmitterEvent && this.dispatch(PARTICLE_UPDATE, particle);	1,067!
633	}
634	}
635
636	/**
637	* Generates new particles.
638	*
639	* @param {number} time - System engine time
640	* @return void
641	*/
642	generate(time) {
643	if (this.totalEmitTimes === 1) {	14✔
644	let i = this.rate.getValue(99999);	1✔
645
646	if (i > 0) {	1!
647	this.cID = i;	1✔
648	}
649
650	while (i--) {	1✔
651	this.createParticle();	1✔
652	}
653
654	this.totalEmitTimes = 0;	1✔
655
656	return;	1✔
657	}
658
659	this.currentEmitTime += time;	13✔
660
661	if (this.currentEmitTime < this.totalEmitTimes) {	13✔
662	let i = this.rate.getValue(time);	4✔
663
664	if (i > 0) {	4✔
665	this.cID = i;	3✔
666	}
667
668	while (i--) {	4✔
669	this.createParticle();	1,005✔
670	}
671	}
672	}
673
674	/**
675	* Kills the emitter.
676	*
677	* @return void
678	*/
679	destroy() {
680	this.dead = true;	8✔
681	this.energy = 0;	8✔
682	this.totalEmitTimes = -1;	8✔
683
684	if (this.particles.length == 0) {	8✔
685	this.isEmitting = false;	6✔
686	this.removeAllInitializers();	6✔
687	this.removeAllBehaviours();	6✔
688	this.dispatch(`${this.id}_${EMITTER_DEAD}`);	6✔
689
690	this.parent && this.parent.removeEmitter(this);	6✔
691	}
692	}
693	}

creativelifeform / three-nebula / 440

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous