Loads of little fixes all across the emitter classes.

photonstorm · photonstorm · commit 816b228cc53e · 2017-10-23T17:11:13.000+01:00
diff --git a/v3/src/gameobjects/particles/GetValueOp.js b/v3/src/gameobjects/particles/GetValueOp.js
@@ -1,23 +1,26 @@
+var FloatBetween = require('../../math/FloatBetween');
 var GetEaseFunction = require('../../tweens/builder/GetEaseFunction');
-var GetValue = require('../../utils/object/GetValue');
 var GetFastValue = require('../../utils/object/GetFastValue');
-var FloatBetween = require('../../math/FloatBetween');
+var Wrap = require('../../math/Wrap');
 
-function hasOnEmit (def)
+function has (object, key)
 {
-    return (!!def.onEmit && typeof def.onEmit === 'function');
+    return (object.hasOwnProperty(key));
 }
 
-function hasOnUpdate (def)
+function hasBoth (object, key1, key2)
 {
-    return (!!def.onUpdate && typeof def.onUpdate === 'function');
+    return (object.hasOwnProperty(key1) && object.hasOwnProperty(key2));
 }
 
 function hasGetters (def)
 {
-    return hasOnEmit(def) || hasOnUpdate(def);
+    return (has(def, 'onEmit')) || (has(def, 'onUpdate'));
 }
 
+var steps = 0;
+var counter = 0;
+
 var GetValueOp = function (config, key, defaultValue)
 {
     var propertyValue = GetFastValue(config, key, defaultValue);
@@ -73,43 +76,61 @@ var GetValueOp = function (config, key, defaultValue)
 
         particleUpdate = propertyValue;
     }
-    else if (t === 'object' && propertyValue.hasOwnProperty('start') && propertyValue.hasOwnProperty('end'))
+    else if (t === 'object' && (has(propertyValue, 'random') || hasBoth(propertyValue, 'start', 'end') || hasBoth(propertyValue, 'min', 'max')))
     {
-        var start = propertyValue.start;
-        var end = propertyValue.end;
+        var start = (propertyValue.hasOwnProperty('start')) ? propertyValue.start : propertyValue.min;
+        var end = (propertyValue.hasOwnProperty('end')) ? propertyValue.end : propertyValue.max;
+        var isRandom = false;
 
         //  A random starting value:
 
-        //  x: { start: 100, end: 400, randomStart: true }
+        //  x: { start: 100, end: 400, random: true } OR { min: 100, max: 400, random: true } OR { random: [ 100, 400 ] }
 
-        if (propertyValue.hasOwnProperty('randomStart'))
+        if (has(propertyValue, 'random'))
         {
-            particleEmit = function ()
+            isRandom = true;
+
+            var rnd = propertyValue.random;
+
+            //  x: { random: [ 100, 400 ] } = the same as doing: x: { start: 100, end: 400, random: true }
+            if (Array.isArray(rnd))
             {
-                return FloatBetween(start, end);
-            };
-        }
-        else
-        {
-            particleEmit = function ()
+                start = rnd[0];
+                end = rnd[1];
+            }
+
+            particleEmit = function (particle, key)
             {
-                return start;
+                var data = particle.data[key];
+
+                var value = FloatBetween(start, end);
+
+                data.min = value;
+
+                return value;
             };
         }
 
-        if (propertyValue.hasOwnProperty('steps'))
+        if (has(propertyValue, 'steps'))
         {
             //  A stepped (per emit) range
 
             //  x: { start: 100, end: 400, steps: 64 }
 
             //  Increments a value stored in the emitter
 
-            particleUpdate = function (particle, key)
+            steps = propertyValue.steps;
+            counter = start;
+
+            particleEmit = function ()
             {
-                var emitter = particle.emitter;
+                var value = counter;
+
+                var i = value + ((end - start) / steps);
+
+                counter = Wrap(i, start, end);
 
-                return emitter.getNext(key);
+                return counter;
             };
         }
         else
@@ -122,12 +143,25 @@ var GetValueOp = function (config, key, defaultValue)
 
             var easeFunc = GetEaseFunction(ease);
 
+            if (!isRandom)
+            {
+                particleEmit = function (particle, key)
+                {
+                    var data = particle.data[key];
+
+                    data.min = start;
+                    data.max = end;
+
+                    return start;
+                };
+            }
+
             particleUpdate = function (particle, key, t, value)
             {
                 var data = particle.data[key];
 
-                return data.calc * easeFunc(t) + data.min;
-            }
+                return (data.max - data.min) * easeFunc(t) + data.min;
+            };
         }
     }
     else if (t === 'object' && hasGetters(propertyValue))
@@ -150,12 +184,12 @@ var GetValueOp = function (config, key, defaultValue)
         }
         */
 
-        if (hasOnEmit(propertyValue))
+        if (has(propertyValue, 'onEmit'))
         {
             particleEmit = propertyValue.onEmit;
         }
 
-        if (hasOnUpdate(propertyValue))
+        if (has(propertyValue, 'onUpdate'))
         {
             particleUpdate = propertyValue.onUpdate;
         }
diff --git a/v3/src/gameobjects/particles/Particle.js b/v3/src/gameobjects/particles/Particle.js
@@ -1,6 +1,5 @@
 var Class = require('../../utils/Class');
 var DegToRad = require('../../math/DegToRad');
-var FloatBetween = require('../../math/FloatBetween');
 
 var Particle = new Class({
 
@@ -44,10 +43,10 @@ var Particle = new Class({
         //  ease data
         this.data = {
             tint: { min: 0xffffff, max: 0xffffff, current: 0xffffff },
-            alpha: { min: 1, max: 1, calc: 0 },
-            angle: { min: 0, max: 0, calc: 0 },
-            scaleX: { min: 1, max: 1, calc: 0 },
-            scaleY: { min: 1, max: 1, calc: 0 }
+            alpha: { min: 1, max: 1 },
+            angle: { min: 0, max: 0 },
+            scaleX: { min: 1, max: 1 },
+            scaleY: { min: 1, max: 1 }
         };
     },
 
@@ -67,15 +66,15 @@ var Particle = new Class({
             emitter.zone.getRandomPoint(this);
         }
 
-        this.x += emitter.x.getNext();
-        this.y += emitter.y.getNext();
+        this.x += emitter.x.onEmit(this, 'x');
+        this.y += emitter.y.onEmit(this, 'y');
 
-        var sx = emitter.speedX.getNext();
-        var sy = emitter.speedY.getNext();
+        var sx = emitter.speedX.onEmit(this, 'speedX');
+        var sy = (emitter.speedY) ? emitter.speedY.onEmit(this, 'speedY') : sx;
 
         if (emitter.radial)
         {
-            var rad = DegToRad(emitter.emitterAngle.getNext());
+            var rad = DegToRad(emitter.emitterAngle.onEmit(this, 'angle'));
 
             this.velocityX = Math.cos(rad) * Math.abs(sx);
             this.velocityY = Math.sin(rad) * Math.abs(sy);
@@ -86,104 +85,17 @@ var Particle = new Class({
             this.velocityY = sy;
         }
 
-        this.life = emitter.lifespan.getNext();
+        this.life = emitter.lifespan.onEmit(this, 'lifespan');
         this.lifeCurrent = this.life;
 
-        //  eased values
+        this.scaleX = emitter.scaleX.onEmit(this, 'scaleX');
+        this.scaleY = (emitter.scaleY) ? emitter.scaleY.onEmit(this, 'scaleY') : this.scaleX;
 
-        var dataScaleX = this.data.scaleX;
-        var dataScaleY = this.data.scaleY;
-        var dataAngle = this.data.angle;
-        var dataAlpha = this.data.alpha;
-
-        emitter.scaleX.copyToMinMax(dataScaleX);
-        emitter.scaleY.copyToMinMax(dataScaleY);
-        emitter.particleAngle.copyToMinMax(dataAngle);
-        emitter.alpha.copyToMinMax(dataAlpha);
-
-        //  Random overrides
-
-        if (emitter.randomScaleX)
-        {
-            var randomScaleX = FloatBetween(emitter.randomScaleX[0], emitter.randomScaleX[1]);
-
-            //  If there is no current ease value set we override them both
-            if (dataScaleX.min === dataScaleX.max)
-            {
-                dataScaleX.min = randomScaleX;
-                dataScaleX.max = randomScaleX;
-            }
-            else
-            {
-                //  Otherwise we just reset the start value, so it still eases to the end value
-                dataScaleX.min = randomScaleX;
-            }
-        }
-
-        if (emitter.randomScaleY)
-        {
-            var randomScaleY = FloatBetween(emitter.randomScaleY[0], emitter.randomScaleY[1]);
-
-            //  If there is no current ease value set we override them both
-            if (dataScaleY.min === dataScaleY.max)
-            {
-                dataScaleY.min = randomScaleY;
-                dataScaleY.max = randomScaleY;
-            }
-            else
-            {
-                //  Otherwise we just reset the start value, so it still eases to the end value
-                dataScaleY.min = randomScaleY;
-            }
-        }
-
-        if (emitter.randomAngle)
-        {
-            var randomAngle = FloatBetween(emitter.randomAngle[0], emitter.randomAngle[1]);
-
-            //  If there is no current ease value set we override them both
-            if (dataAngle.min === dataAngle.max)
-            {
-                dataAngle.min = randomAngle;
-                dataAngle.max = randomAngle;
-            }
-            else
-            {
-                //  Otherwise we just reset the start value, so it still eases to the end value
-                dataAngle.min = randomAngle;
-            }
-        }
-
-        if (emitter.randomAlpha)
-        {
-            var randomAlpha = FloatBetween(emitter.randomAlpha[0], emitter.randomAlpha[1]);
-
-            //  If there is no current ease value set we override them both
-            if (dataAlpha.min === dataAlpha.max)
-            {
-                dataAlpha.min = randomAlpha;
-                dataAlpha.max = randomAlpha;
-            }
-            else
-            {
-                //  Otherwise we just reset the start value, so it still eases to the end value
-                dataAlpha.min = randomAlpha;
-            }
-        }
-
-        //  Pre-calc ease values
-        dataScaleX.calc = dataScaleX.max - dataScaleX.min;
-        dataScaleY.calc = dataScaleY.max - dataScaleY.min;
-        dataAngle.calc = dataAngle.max - dataAngle.min;
-        dataAlpha.calc = dataAlpha.max - dataAlpha.min;
+        this.angle = emitter.particleAngle.onEmit(this, 'angle');
+        this.rotation = DegToRad(this.angle);
 
-        //  Set initial values
-        this.scaleX = dataScaleX.min;
-        this.scaleY = dataScaleY.min;
-        this.angle = dataAngle.min;
-        this.rotation = DegToRad(dataAngle.min);
+        this.alpha = emitter.alpha.onEmit(this, 'alpha');
 
-        this.alpha = dataAlpha.min;
         this.color = (this.color & 0x00FFFFFF) | (((this.alpha * 0xFF) | 0) << 24);
 
         this.index = emitter.alive.length;
@@ -197,21 +109,27 @@ var Particle = new Class({
         //  How far along in life is this particle? (t = 0 to 1)
         var t = 1 - (this.lifeCurrent / this.life);
 
-        this.velocityX += (emitter.gravity.x * step);
-        this.velocityY += (emitter.gravity.y * step);
+        this.velocityX += (emitter.gravityX * step);
+        this.velocityY += (emitter.gravityY * step);
 
         this.x += this.velocityX * step;
         this.y += this.velocityY * step;
 
-        var data = this.data;
+        this.scaleX = emitter.scaleX.onUpdate(this, 'scaleX', t, this.scaleX);
 
-        this.scaleX = data.scaleX.calc * emitter.easingFunctionScale(t) + data.scaleX.min;
-        this.scaleY = data.scaleY.calc * emitter.easingFunctionScale(t) + data.scaleY.min;
+        if (emitter.scaleY)
+        {
+            this.scaleY = emitter.scaleY.onUpdate(this, 'scaleY', t, this.scaleY);
+        }
+        else
+        {
+            this.scaleY = this.scaleX;
+        }
 
-        this.angle = data.angle.calc * emitter.easingFunctionRotation(t) + data.angle.min;
+        this.angle = emitter.particleAngle.onUpdate(this, 'angle', t, this.angle);
         this.rotation = DegToRad(this.angle);
 
-        this.alpha = data.alpha.calc * emitter.easingFunctionAlpha(t) + data.alpha.min;
+        this.alpha = emitter.alpha.onUpdate(this, 'alpha', t, this.alpha);
 
         this.color = (this.color & 0x00FFFFFF) | (((this.alpha * 0xFF) | 0) << 24);
 
diff --git a/v3/src/gameobjects/particles/ParticleEmitter.js b/v3/src/gameobjects/particles/ParticleEmitter.js
