melonjs 10.6.1 → 10.8.0

package/src/particles/particle.js

@@ -1,103 +1,111 @@
-import Vector2d from "./../math/vector2.js";
+import pool from "./../system/pooling.js";
 import timer from "./../system/timer.js";
 import { randomFloat, clamp } from "./../math/math.js";
 import Renderable from "./../renderable/renderable.js";
 
-
 /**
  * @classdesc
  * Single Particle Object.
- * @class Particle
  * @augments Renderable
- * @param {ParticleEmitter} particle emitter
  */
 class Particle extends Renderable {
     /**
-     * @ignore
+     * @param {ParticleEmitter} emitter the particle emitter
      */
     constructor(emitter) {
         // Call the super constructor
         super(
             emitter.getRandomPointX(),
             emitter.getRandomPointY(),
-            emitter.image.width,
-            emitter.image.height
+            emitter.settings.image.width,
+            emitter.settings.image.height
         );
-
-        // particle velocity
-        this.vel = new Vector2d();
         this.onResetEvent(emitter, true);
     }
 
+    /**
+     * @ignore
+     */
     onResetEvent(emitter, newInstance = false) {
         if (newInstance === false) {
-            super.onResetEvent(
+            this.pos.set(
                 emitter.getRandomPointX(),
-                emitter.getRandomPointY(),
-                emitter.image.width,
-                emitter.image.height
+                emitter.getRandomPointY()
             );
+            this.resize(
+                emitter.settings.image.width,
+                emitter.settings.image.height
+            );
+            this.currentTransform.identity();
+        } else {
+            // particle velocity
+            this.vel = pool.pull("Vector2d");
         }
 
+        this.image = emitter.settings.image;
+
         // Particle will always update
         this.alwaysUpdate = true;
 
-        // Cache the image reference
-        this.image = emitter.image;
+        if (typeof emitter.settings.tint === "string") {
+            this.tint.parseCSS(emitter.settings.tint);
+        }
+
+        if (emitter.settings.textureAdditive === true) {
+            this.blendMode = "additive";
+        }
+
+        if (emitter.settings.blendMode !== "normal") {
+            this.blendMode = emitter.settings.blendMode;
+        }
 
         // Set the start particle Angle and Speed as defined in emitter
-        var angle = emitter.angle + ((emitter.angleVariation > 0) ? (randomFloat(0, 2) - 1) * emitter.angleVariation : 0);
-        var speed = emitter.speed + ((emitter.speedVariation > 0) ? (randomFloat(0, 2) - 1) * emitter.speedVariation : 0);
+        var angle = emitter.settings.angle + ((emitter.settings.angleVariation > 0) ? (randomFloat(0, 2) - 1) * emitter.settings.angleVariation : 0);
+        var speed = emitter.settings.speed + ((emitter.settings.speedVariation > 0) ? (randomFloat(0, 2) - 1) * emitter.settings.speedVariation : 0);
 
         // Set the start particle Velocity
         this.vel.set(speed * Math.cos(angle), -speed * Math.sin(angle));
 
         // Set the start particle Time of Life as defined in emitter
-        this.life = randomFloat(emitter.minLife, emitter.maxLife);
+        this.life = randomFloat(emitter.settings.minLife, emitter.settings.maxLife);
         this.startLife = this.life;
 
         // Set the start and end particle Scale as defined in emitter
         // clamp the values as minimum and maximum scales range
         this.startScale = clamp(
-            randomFloat(emitter.minStartScale, emitter.maxStartScale),
-            emitter.minStartScale,
-            emitter.maxStartScale
+            randomFloat(emitter.settings.minStartScale, emitter.settings.maxStartScale),
+            emitter.settings.minStartScale,
+            emitter.settings.maxStartScale
         );
         this.endScale = clamp(
-            randomFloat(emitter.minEndScale, emitter.maxEndScale),
-            emitter.minEndScale,
-            emitter.maxEndScale
+            randomFloat(emitter.settings.minEndScale, emitter.settings.maxEndScale),
+            emitter.settings.minEndScale,
+            emitter.settings.maxEndScale
         );
 
         // Set the particle Gravity and Wind (horizontal gravity) as defined in emitter
-        this.gravity = emitter.gravity;
-        this.wind = emitter.wind;
+        this.gravity = emitter.settings.gravity;
+        this.wind = emitter.settings.wind;
 
         // Set if the particle update the rotation in accordance the trajectory
-        this.followTrajectory = emitter.followTrajectory;
+        this.followTrajectory = emitter.settings.followTrajectory;
 
         // Set if the particle update only in Viewport
-        this.onlyInViewport = emitter.onlyInViewport;
-
-        // Set the particle Z Order
-        this.pos.z = emitter.z;
+        this.onlyInViewport = emitter.settings.onlyInViewport;
 
         // cache inverse of the expected delta time
         this._deltaInv = timer.maxfps / 1000;
 
         // Set the start particle rotation as defined in emitter
         // if the particle not follow trajectory
-        if (!emitter.followTrajectory) {
-            this.angle = randomFloat(emitter.minRotation, emitter.maxRotation);
+        if (!emitter.settings.followTrajectory) {
+            this.angle = randomFloat(emitter.settings.minRotation, emitter.settings.maxRotation);
         }
     }
 
     /**
      * Update the Particle <br>
      * This is automatically called by the game manager {@link game}
-     * @name update
-     * @memberof Particle
-     * @function
      * @ignore
      * @param {number} dt time since the last update in milliseconds
      */
@@ -108,6 +116,11 @@ class Particle extends Renderable {
         // Decrease particle life
         this.life = this.life > dt ? this.life - dt : 0;
 
+        if (this.life <= 0) {
+            this.ancestor.removeChild(this);
+            return false;
+        }
+
         // Calculate the particle Age Ratio
         var ageRatio = this.life / this.startLife;
 
@@ -142,23 +155,10 @@ class Particle extends Renderable {
             this.pos.x, this.pos.y, 1
         ).rotate(angle);
 
-        // Return true if the particle is not dead yet
-        return (this.inViewport || !this.onlyInViewport) && (this.life > 0);
-    }
-
-    /**
-     * @ignore
-     */
-    preDraw(renderer) {
-
-        // restore is called in postDraw
-        renderer.save();
-
-        // particle alpha value
-        renderer.setGlobalAlpha(renderer.globalAlpha() * this.alpha);
+        // mark as dirty if the particle is not dead yet
+        this.isDirty = this.inViewport || !this.onlyInViewport;
 
-        // translate to the defined anchor point and scale it
-        renderer.transform(this.currentTransform);
+        return super.update(dt);
     }
 
     /**

package/src/particles/settings.js

@@ -0,0 +1,310 @@
+/**
+ * ParticleEmitterSettings contains the default settings for ParticleEmitter
+ * @see ParticleEmitter
+ * @namespace ParticleEmitterSettings
+ */
+const ParticleEmitterSettings = {
+    /**
+     * Width of the particle spawn area.
+     * @type {number}
+     * @name width
+     * @memberof ParticleEmitterSettings
+     * @default 1
+     */
+    width : 1,
+
+    /**
+     * Height of the particle spawn area
+     * @public
+     * @type {number}
+     * @name height
+     * @memberof ParticleEmitterSettings
+     * @default 1
+     */
+    height : 1,
+
+    /**
+     * image used for particles texture
+     * (by default melonJS will create an white 8x8 texture image)
+     * @public
+     * @type {HTMLCanvasElement}
+     * @name image
+     * @memberof ParticleEmitterSettings
+     * @default undefined
+     * @see ParticleEmitterSettings.textureSize
+     */
+    image : undefined,
+
+    /**
+     * default texture size used for particles if no image is specified
+     * (by default melonJS will create an white 8x8 texture image)
+     * @public
+     * @type {number}
+     * @name textureSize
+     * @memberof ParticleEmitterSettings
+     * @default 8
+     * @see ParticleEmitterSettings.image
+     */
+    textureSize : 8,
+
+    /**
+     * tint to be applied to particles
+     * @public
+     * @type {string}
+     * @name tint
+     * @memberof ParticleEmitterSettings
+     * @default "#fff"
+     */
+    tint : "#fff",
+
+    /**
+     * Total number of particles in the emitter
+     * @public
+     * @type {number}
+     * @name totalParticles
+     * @default 50
+     * @memberof ParticleEmitterSettings
+     */
+    totalParticles : 50,
+
+    /**
+     * Start angle for particle launch in Radians
+     * @public
+     * @type {number}
+     * @name angle
+     * @default Math.PI / 2
+     * @memberof ParticleEmitterSettings
+     */
+    angle : Math.PI / 2,
+
+    /**
+     * Variation in the start angle for particle launch in Radians.
+     * @public
+     * @type {number}
+     * @name angleVariation
+     * @default 0
+     * @memberof ParticleEmitterSettings
+     */
+    angleVariation : 0,
+
+    /**
+     * Minimum time each particle lives once it is emitted in ms.
+     * @public
+     * @type {number}
+     * @name minLife
+     * @default 1000
+     * @memberof ParticleEmitterSettings
+     */
+    minLife : 1000,
+
+    /**
+     * Maximum time each particle lives once it is emitted in ms.
+     * @public
+     * @type {number}
+     * @name maxLife
+     * @default 3000
+     * @memberof ParticleEmitterSettings
+     */
+    maxLife : 3000,
+
+    /**
+     * Start speed of particles.<br>
+     * @public
+     * @type {number}
+     * @name speed
+     * @default 2
+     * @memberof ParticleEmitterSettings
+     */
+    speed : 2,
+
+    /**
+     * Variation in the start speed of particles
+     * @public
+     * @type {number}
+     * @name speedVariation
+     * @default 1
+     * @memberof ParticleEmitterSettings
+     */
+    speedVariation : 1,
+
+    /**
+     * Minimum start rotation for particles sprites in Radians
+     * @public
+     * @type {number}
+     * @name minRotation
+     * @default 0
+     * @memberof ParticleEmitterSettings
+     */
+    minRotation : 0,
+
+    /**
+     * Maximum start rotation for particles sprites in Radians
+     * @public
+     * @type {number}
+     * @name maxRotation
+     * @default 0
+     * @memberof ParticleEmitterSettings
+     */
+    maxRotation : 0,
+
+    /**
+     * Minimum start scale ratio for particles (1 = no scaling)
+     * @public
+     * @type {number}
+     * @name minStartScale
+     * @default 1
+     * @memberof ParticleEmitterSettings
+     */
+    minStartScale : 1,
+
+    /**
+     * Maximum start scale ratio for particles (1 = no scaling)
+     * @public
+     * @type {number}
+     * @name maxStartScale
+     * @default 1
+     * @memberof ParticleEmitterSettings
+     */
+    maxStartScale : 1,
+
+    /**
+     * Minimum end scale ratio for particles
+     * @public
+     * @type {number}
+     * @name minEndScale
+     * @default 0
+     * @memberof ParticleEmitterSettings
+     */
+    minEndScale : 0,
+
+    /**
+     * Maximum end scale ratio for particles
+     * @public
+     * @type {number}
+     * @name maxEndScale
+     * @default 0
+     * @memberof ParticleEmitterSettings
+     */
+    maxEndScale : 0,
+
+    /**
+     * Vertical force (Gravity) for each particle
+     * @public
+     * @type {number}
+     * @name gravity
+     * @default 0
+     * @memberof ParticleEmitterSettings
+     * @see game.world.gravity
+     */
+    gravity : 0,
+
+    /**
+     * Horizontal force (like a Wind) for each particle
+     * @public
+     * @type {number}
+     * @name wind
+     * @default 0
+     * @memberof ParticleEmitterSettings
+     */
+    wind : 0,
+
+    /**
+     * Update the rotation of particle in accordance the particle trajectory.<br>
+     * The particle sprite should aim at zero angle (draw from left to right).<br>
+     * Override the particle minRotation and maxRotation.<br>
+     * @public
+     * @type {boolean}
+     * @name followTrajectory
+     * @default false
+     * @memberof ParticleEmitterSettings
+     */
+    followTrajectory : false,
+
+    /**
+     * Enable the Texture Additive by composite operation ("additive" blendMode)
+     * @public
+     * @type {boolean}
+     * @name textureAdditive
+     * @default false
+     * @memberof ParticleEmitterSettings
+     * @see ParticleEmitterSettings.blendMode
+     */
+    textureAdditive : false,
+
+    /**
+     * the blend mode to be applied when rendering particles.
+     * (note: this will superseed the `textureAdditive` setting if different than "normal")
+     * @public
+     * @type {string}
+     * @name blendMode
+     * @default normal
+     * @memberof ParticleEmitterSettings
+     * @see CanvasRenderer#setBlendMode
+     * @see WebGLRenderer#setBlendMode
+     */
+    blendMode : "normal",
+
+    /**
+     * Update particles only in the viewport, remove it when out of viewport.
+     * @public
+     * @type {boolean}
+     * @name onlyInViewport
+     * @default true
+     * @memberof ParticleEmitterSettings
+     */
+    onlyInViewport : true,
+
+    /**
+     * Render particles in screen space.
+     * @public
+     * @type {boolean}
+     * @name floating
+     * @default false
+     * @memberof ParticleEmitterSettings
+     */
+    floating : false,
+
+    /**
+     * Maximum number of particles launched each time in this emitter (used only if emitter is Stream).
+     * @public
+     * @type {number}
+     * @name maxParticles
+     * @default 10
+     * @memberof ParticleEmitterSettings
+     */
+    maxParticles : 10,
+
+    /**
+     * How often a particle is emitted in ms (used only if emitter is a Stream).
+     * @public
+     * @type {number}
+     * @name frequency
+     * @default 100
+     * @memberof ParticleEmitterSettings
+     */
+    frequency : 100,
+
+    /**
+     * Duration that the emitter releases particles in ms (used only if emitter is Stream).
+     * After this period, the emitter stop the launch of particles.
+     * @public
+     * @type {number}
+     * @name duration
+     * @default Infinity
+     * @memberof ParticleEmitterSettings
+     */
+    duration : Infinity,
+
+    /**
+     * Skip n frames after updating the particle system once.
+     * This can be used to reduce the performance impact of emitters with many particles.
+     * @public
+     * @type {number}
+     * @name framesToSkip
+     * @default 0
+     * @memberof ParticleEmitterSettings
+     */
+    framesToSkip : 0
+};
+
+export default ParticleEmitterSettings;

package/src/physics/body.js

@@ -1,8 +1,8 @@
-import Vector2d from "./../math/vector2.js";
 import Rect from "./../geometries/rectangle.js";
 import Ellipse from "./../geometries/ellipse.js";
 import Polygon from "./../geometries/poly.js";
 import Bounds from "./bounds.js";
+import pool from "./../system/pooling.js";
 import collision from "./collision.js";
 import * as arrayUtil from "./../utils/array.js";
 import timer from "./../system/timer.js";
@@ -37,7 +37,7 @@ class Body {
              * @public
              * @type {Bounds}
              */
-            this.bounds = new Bounds();
+            this.bounds = pool.pull("Bounds");
         }
 
         if (typeof this.shapes === "undefined") {
@@ -71,55 +71,54 @@ class Body {
          */
         this.collisionType = collision.types.ENEMY_OBJECT;
 
-        /**
-         * body velocity
-         * @public
-         * @type {Vector2d}
-         * @default <0,0>
-         */
         if (typeof this.vel === "undefined") {
-            this.vel = new Vector2d();
+            /**
+             * body velocity
+             * @public
+             * @type {Vector2d}
+             * @default <0,0>
+             */
+            this.vel = pool.pull("Vector2d");
         }
         this.vel.set(0, 0);
 
-        /**
-         * body force or acceleration (automatically) applied to the body.
-         * when defining a force, user should also define a max velocity
-         * @public
-         * @type {Vector2d}
-         * @default <0,0>
-         * @see Body.setMaxVelocity
-         * @example
-         * // define a default maximum acceleration, initial force and friction
-         * this.body.force.set(0, 0);
-         * this.body.friction.set(0.4, 0);
-         * this.body.setMaxVelocity(3, 15);
-         *
-         * // apply a postive or negative force when pressing left of right key
-         * update(dt) {
-         *     if (me.input.isKeyPressed("left"))    {
-         *          this.body.force.x = -this.body.maxVel.x;
-         *      } else if (me.input.isKeyPressed("right")) {
-         *         this.body.force.x = this.body.maxVel.x;
-         *     } else {
-         *         this.body.force.x = 0;
-         *     }
-         * }
-         */
         if (typeof this.force === "undefined") {
-            this.force = new Vector2d();
+            /**
+             * body force or acceleration (automatically) applied to the body.
+             * when defining a force, user should also define a max velocity
+             * @public
+             * @type {Vector2d}
+             * @default <0,0>
+             * @see Body.setMaxVelocity
+             * @example
+             * // define a default maximum acceleration, initial force and friction
+             * this.body.force.set(0, 0);
+             * this.body.friction.set(0.4, 0);
+             * this.body.setMaxVelocity(3, 15);
+             *
+             * // apply a postive or negative force when pressing left of right key
+             * update(dt) {
+             *     if (me.input.isKeyPressed("left"))    {
+             *          this.body.force.x = -this.body.maxVel.x;
+             *      } else if (me.input.isKeyPressed("right")) {
+             *         this.body.force.x = this.body.maxVel.x;
+             *     } else {
+             *         this.body.force.x = 0;
+             *     }
+             * }
+             */
+            this.force = pool.pull("Vector2d");
         }
         this.force.set(0, 0);
 
-
-        /**
-         * body friction
-         * @public
-         * @type {Vector2d}
-         * @default <0,0>
-         */
         if (typeof this.friction === "undefined") {
-            this.friction = new Vector2d();
+            /**
+             * body friction
+             * @public
+             * @type {Vector2d}
+             * @default <0,0>
+             */
+            this.friction = pool.pull("Vector2d");
         }
         this.friction.set(0, 0);
 
@@ -140,14 +139,14 @@ class Body {
          */
         this.mass = 1;
 
-        /**
-         * max velocity (to limit body velocity)
-         * @public
-         * @type {Vector2d}
-         * @default <490,490>
-         */
         if (typeof this.maxVel === "undefined") {
-            this.maxVel = new Vector2d();
+            /**
+             * max velocity (to limit body velocity)
+             * @public
+             * @type {Vector2d}
+             * @default <490,490>
+             */
+            this.maxVel = pool.pull("Vector2d");
         }
         // cap by default to half the default gravity force
         this.maxVel.set(490, 490);
@@ -297,7 +296,7 @@ class Body {
             polygon.setShape(0, 0, vertices);
         } else {
             // this will replace any other non polygon shape type if defined
-            this.shapes[index] = new Polygon(0, 0, vertices);
+            this.shapes[index] = pool.pull("Polygon", 0, 0, vertices);
         }
 
         // update the body bounds to take in account the new vertices
@@ -686,11 +685,28 @@ class Body {
      * @ignore
      */
     destroy() {
+        // push back instance into object pool
+        pool.push(this.bounds);
+        pool.push(this.vel);
+        pool.push(this.force);
+        pool.push(this.friction);
+        pool.push(this.maxVel);
+        this.shapes.forEach((shape) => {
+            pool.push(shape);
+        });
+
+        // set to undefined
         this.onBodyUpdate = undefined;
         this.ancestor = undefined;
         this.bounds = undefined;
-        this.setStatic(false);
+        this.vel = undefined;
+        this.force = undefined;
+        this.friction = undefined;
+        this.maxVel = undefined;
         this.shapes.length = 0;
+
+        // reset some variable to default
+        this.setStatic(false);
     }
 };