melonjs 10.7.1 → 10.10.0

package/src/system/pooling.js

@@ -1,7 +1,5 @@
-var objectClass = {};
-var instance_counter = 0;
-
 /**
+ * @classdesc
  * This object is used for object pooling - a technique that might speed up your game if used properly.<br>
  * If some of your classes will be instantiated and removed a lot at a time, it is a
  * good idea to add the class to this object pool. A separate pool for that class
@@ -12,172 +10,181 @@ var instance_counter = 0;
  * which means, that on level loading the engine will try to instantiate every object
  * found in the map, based on the user defined name in each Object Properties<br>
  * <img src="images/object_properties.png"/><br>
- * @namespace pool
+ * @see {@link pool} a default global instance of ObjectPool
  */
+class ObjectPool {
 
-/**
- * register an object to the pool. <br>
- * Pooling must be set to true if more than one such objects will be created. <br>
- * (Note: for an object to be poolable, it must implements a `onResetEvent` method)
- * @function pool.register
- * @param {string} className as defined in the Name field of the Object Properties (in Tiled)
- * @param {object} classObj corresponding Class to be instantiated
- * @param {boolean} [recycling=false] enables object recycling for the specified class
- * @example
- * // implement CherryEntity
- * class CherryEntity extends Spritesheet {
- *    onResetEvent() {
- *        // reset object mutable properties
- *        this.lifeBar = 100;
- *    }
- * };
- * // add our users defined entities in the object pool and enable object recycling
- * me.pool.register("cherryentity", CherryEntity, true);
- */
-export function register(className, classObj, recycling = false) {
-     if (typeof (classObj) !== "undefined") {
-         objectClass[className] = {
-             "class" : classObj,
-             "pool" : (recycling ? [] : undefined)
-         };
-     } else {
-         throw new Error("Cannot register object '" + className + "', invalid class");
+    constructor() {
+        this.objectClass = {};
+        this.instance_counter = 0;
+    }
+
+    /**
+     * register an object to the pool. <br>
+     * Pooling must be set to true if more than one such objects will be created. <br>
+     * (Note: for an object to be poolable, it must implements a `onResetEvent` method)
+     * @param {string} className as defined in the Name field of the Object Properties (in Tiled)
+     * @param {object} classObj corresponding Class to be instantiated
+     * @param {boolean} [recycling=false] enables object recycling for the specified class
+     * @example
+     * // implement CherryEntity
+     * class CherryEntity extends Spritesheet {
+     *    onResetEvent() {
+     *        // reset object mutable properties
+     *        this.lifeBar = 100;
+     *    }
+     * };
+     * // add our users defined entities in the object pool and enable object recycling
+     * me.pool.register("cherryentity", CherryEntity, true);
+     */
+    register(className, classObj, recycling = false) {
+         if (typeof (classObj) !== "undefined") {
+             this.objectClass[className] = {
+                 "class" : classObj,
+                 "pool" : (recycling ? [] : undefined)
+             };
+         } else {
+             throw new Error("Cannot register object '" + className + "', invalid class");
+         }
      }
- };
 
-/**
- * Pull a new instance of the requested object (if added into the object pool)
- * @function pool.pull
- * @param {string} name as used in {@link pool.register}
- * @param {object} [...arguments] arguments to be passed when instantiating/reinitializing the object
- * @returns {object} the instance of the requested object
- * @example
- * me.pool.register("bullet", BulletEntity, true);
- * me.pool.register("enemy", EnemyEntity, true);
- * // ...
- * // when we need to manually create a new bullet:
- * var bullet = me.pool.pull("bullet", x, y, direction);
- * // ...
- * // params aren't a fixed number
- * // when we need new enemy we can add more params, that the object construct requires:
- * var enemy = me.pool.pull("enemy", x, y, direction, speed, power, life);
- * // ...
- * // when we want to destroy existing object, the remove
- * // function will ensure the object can then be reallocated later
- * me.game.world.removeChild(enemy);
- * me.game.world.removeChild(bullet);
- */
-export function pull(name) {
-    var args = new Array(arguments.length);
-    for (var i = 0; i < arguments.length; i++) {
-        args[i] = arguments[i];
-    }
-    var className = objectClass[name];
-    if (className) {
-        var proto = className["class"],
-            poolArray = className.pool,
-            obj;
+    /**
+     * Pull a new instance of the requested object (if added into the object pool)
+     * @param {string} name as used in {@link pool.register}
+     * @param {object} [...arguments] arguments to be passed when instantiating/reinitializing the object
+     * @returns {object} the instance of the requested object
+     * @example
+     * me.pool.register("bullet", BulletEntity, true);
+     * me.pool.register("enemy", EnemyEntity, true);
+     * // ...
+     * // when we need to manually create a new bullet:
+     * var bullet = me.pool.pull("bullet", x, y, direction);
+     * // ...
+     * // params aren't a fixed number
+     * // when we need new enemy we can add more params, that the object construct requires:
+     * var enemy = me.pool.pull("enemy", x, y, direction, speed, power, life);
+     * // ...
+     * // when we want to destroy existing object, the remove
+     * // function will ensure the object can then be reallocated later
+     * me.game.world.removeChild(enemy);
+     * me.game.world.removeChild(bullet);
+     */
+    pull(name) {
+        var args = new Array(arguments.length);
+        for (var i = 0; i < arguments.length; i++) {
+            args[i] = arguments[i];
+        }
+        var className = this.objectClass[name];
+        if (className) {
+            var proto = className["class"],
+                poolArray = className.pool,
+                obj;
 
-        if (poolArray && ((obj = poolArray.pop()))) {
-            // pull an existing instance from the pool
-            args.shift();
-            // call the object onResetEvent function if defined
-            if (typeof(obj.onResetEvent) === "function") {
-                obj.onResetEvent.apply(obj, args);
+            if (poolArray && ((obj = poolArray.pop()))) {
+                // pull an existing instance from the pool
+                args.shift();
+                // call the object onResetEvent function if defined
+                if (typeof(obj.onResetEvent) === "function") {
+                    obj.onResetEvent.apply(obj, args);
+                }
+                this.instance_counter--;
             }
-            instance_counter--;
-        }
-        else {
-            // create a new instance
-            args[0] = proto;
-            obj = new (proto.bind.apply(proto, args))();
-            if (poolArray) {
-                obj.className = name;
+            else {
+                // create a new instance
+                args[0] = proto;
+                obj = new (proto.bind.apply(proto, args))();
+                if (poolArray) {
+                    obj.className = name;
+                }
             }
+            return obj;
         }
-        return obj;
+        throw new Error("Cannot instantiate object of type '" + name + "'");
     }
-    throw new Error("Cannot instantiate object of type '" + name + "'");
-};
 
-/**
- * purge the object pool from any inactive object <br>
- * Object pooling must be enabled for this function to work<br>
- * note: this will trigger the garbage collector
- * @function pool.purge
- */
-export function purge() {
-    for (var className in objectClass) {
-        if (objectClass[className]) {
-            objectClass[className].pool = [];
+    /**
+     * purge the object pool from any inactive object <br>
+     * Object pooling must be enabled for this function to work<br>
+     * note: this will trigger the garbage collector
+     */
+    purge() {
+        for (var className in this.objectClass) {
+            if (this.objectClass[className]) {
+                this.objectClass[className].pool = [];
+            }
         }
+        this.instance_counter = 0;
     }
-    instance_counter = 0;
-};
 
-/**
- * Push back an object instance into the object pool <br>
- * Object pooling for the object class must be enabled,
- * and object must have been instantiated using {@link pool#pull},
- * otherwise this function won't work
- * @function pool.push
- * @throws will throw an error if the object cannot be recycled
- * @param {object} obj instance to be recycled
- * @param {boolean} [throwOnError=true] throw an exception if the object cannot be recycled
- * @returns {boolean} true if the object was successfully recycled in the object pool
- */
-export function push(obj, throwOnError = true) {
-    if (!poolable(obj)) {
-        if (throwOnError === true ) {
-            throw new Error("me.pool: object " + obj + " cannot be recycled");
-        } else {
-            return false;
+    /**
+     * Push back an object instance into the object pool <br>
+     * Object pooling for the object class must be enabled,
+     * and object must have been instantiated using {@link pool#pull},
+     * otherwise this function won't work
+     * @throws will throw an error if the object cannot be recycled
+     * @param {object} obj instance to be recycled
+     * @param {boolean} [throwOnError=true] throw an exception if the object cannot be recycled
+     * @returns {boolean} true if the object was successfully recycled in the object pool
+     */
+    push(obj, throwOnError = true) {
+        if (!this.poolable(obj)) {
+            if (throwOnError === true ) {
+                throw new Error("me.pool: object " + obj + " cannot be recycled");
+            } else {
+                return false;
+            }
         }
-    }
 
-    // store back the object instance for later recycling
-    objectClass[obj.className].pool.push(obj);
-    instance_counter++;
+        // store back the object instance for later recycling
+        this.objectClass[obj.className].pool.push(obj);
+        this.instance_counter++;
 
-    return true;
-};
+        return true;
+    }
 
-/**
- * Check if an object with the provided name is registered
- * @function pool.exists
- * @param {string} name of the registered object class
- * @returns {boolean} true if the classname is registered
- */
-export function exists(name) {
-    return name in objectClass;
-};
+    /**
+     * Check if an object with the provided name is registered
+     * @param {string} name of the registered object class
+     * @returns {boolean} true if the classname is registered
+     */
+    exists(name) {
+        return name in this.objectClass;
+    };
 
-/**
- * Check if an object is poolable
- * (was properly registered with the recycling feature enable)
- * @function pool.poolable
- * @see pool.register
- * @param {object} obj object to be checked
- * @returns {boolean} true if the object is poolable
- * @example
- * if (!me.pool.poolable(myCherryEntity)) {
- *     // object was not properly registered
- * }
- */
-export function poolable(obj) {
-    var className = obj.className;
-    return (typeof className !== "undefined") &&
-            (typeof obj.onResetEvent === "function") &&
-            (className in objectClass) &&
-            (objectClass[className].pool !== "undefined");
+    /**
+     * Check if an object is poolable
+     * (was properly registered with the recycling feature enable)
+     * @see register
+     * @param {object} obj object to be checked
+     * @returns {boolean} true if the object is poolable
+     * @example
+     * if (!me.pool.poolable(myCherryEntity)) {
+     *     // object was not properly registered
+     * }
+     */
+    poolable(obj) {
+        var className = obj.className;
+        return (typeof className !== "undefined") &&
+                (typeof obj.onResetEvent === "function") &&
+                (className in this.objectClass) &&
+                (this.objectClass[className].pool !== "undefined");
+
+    }
 
+    /**
+     * returns the amount of object instance currently in the pool
+     * @returns {number} amount of object instance
+     */
+    getInstanceCount() {
+        return this.instance_counter;
+    }
 };
 
 /**
- * returns the amount of object instance currently in the pool
- * @function pool.getInstanceCount
- * @returns {number} amount of object instance
+ * a default global object pool instance
+ * @public
+ * @type {ObjectPool}
  */
-export function getInstanceCount() {
-    return instance_counter;
-};
+var pool = new ObjectPool();
+
+export default pool;

package/src/text/bitmaptext.js

@@ -1,6 +1,6 @@
 import Color from "./../math/color.js";
 import * as stringUtil from "./../utils/string.js";
-import * as pool from "./../system/pooling.js";
+import pool from "./../system/pooling.js";
 import loader from "./../loader/loader.js";
 import Renderable from "./../renderable/renderable.js";
 import TextMetrics from "./textmetrics.js";

package/src/text/text.js

@@ -1,8 +1,8 @@
 import Color from "./../math/color.js";
 import WebGLRenderer from "./../video/webgl/webgl_renderer.js";
-import { renderer as globalRenderer, createCanvas } from "./../video/video.js";
+import { renderer as globalRenderer } from "./../video/video.js";
 import { trimRight } from "./../utils/string.js";
-import * as pool from "./../system/pooling.js";
+import pool from "./../system/pooling.js";
 import Renderable from "./../renderable/renderable.js";
 import { nextPowerOfTwo } from "./../math/math.js";
 import setContextStyle from "./textstyle.js";
@@ -23,7 +23,7 @@ var toPX = [12, 24, 0.75, 1];
 // return a valid 2d context for Text rendering/styling
 var getContext2d = function (renderer, text) {
     if (text.offScreenCanvas === true) {
-        return text.context;
+        return text.canvasTexture.context;
     } else {
         return renderer.getFontContext();
     }
@@ -190,8 +190,7 @@ class Text extends Renderable {
 
         if (settings.offScreenCanvas === true) {
             this.offScreenCanvas = true;
-            this.canvas = createCanvas(2, 2, true);
-            this.context = this.canvas.getContext("2d");
+            this.canvasTexture = pool.pull("CanvasTexture", 2, 2, true);
         }
 
         // instance to text metrics functions
@@ -206,10 +205,9 @@ class Text extends Renderable {
         // free the canvas and potential corresponding texture when deactivated
         if (this.offScreenCanvas === true) {
             globalRenderer.currentCompositor.deleteTexture2D(globalRenderer.currentCompositor.getTexture2D(this.glTextureUnit));
-            globalRenderer.cache.delete(this.canvas);
-            this.canvas.width = this.canvas.height = 0;
-            this.context = undefined;
-            this.canvas = undefined;
+            globalRenderer.cache.delete(this.canvasTexture.canvas);
+            pool.push(this.canvasTexture);
+            this.canvasTexture = undefined;
             this.glTextureUnit = undefined;
         }
     }
@@ -307,7 +305,7 @@ class Text extends Renderable {
 
             if (globalRenderer instanceof WebGLRenderer) {
                 // invalidate the previous corresponding texture so that it can reuploaded once changed
-                this.glTextureUnit = globalRenderer.cache.getUnit(globalRenderer.cache.get(this.canvas));
+                this.glTextureUnit = globalRenderer.cache.getUnit(globalRenderer.cache.get(this.canvasTexture.canvas));
                 globalRenderer.currentCompositor.unbindTexture2D(null, this.glTextureUnit);
 
                 if (globalRenderer.WebGLVersion === 1) {
@@ -318,14 +316,12 @@ class Text extends Renderable {
             }
 
             // resize the cache canvas if necessary
-            if (this.canvas.width < width || this.canvas.height < height) {
-                this.canvas.width = width;
-                this.canvas.height = height;
-                // resizing the canvas will automatically clear its content
-            } else {
-                this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);
+            if (this.canvasTexture.width < width || this.canvasTexture.height < height) {
+                this.canvasTexture.resize(width, height);
             }
-            this._drawFont(this.context, this._text,  this.pos.x - this.metrics.x, this.pos.y - this.metrics.y, false);
+
+            this.canvasTexture.clear();
+            this._drawFont(this.canvasTexture.context, this._text,  this.pos.x - this.metrics.x, this.pos.y - this.metrics.y, false);
         }
 
         this.isDirty = true;
@@ -389,7 +385,7 @@ class Text extends Renderable {
 
         // draw the text
         if (this.offScreenCanvas === true) {
-            renderer.drawImage(this.canvas, x, y);
+            renderer.drawImage(this.canvasTexture.canvas, x, y);
         } else {
             renderer.drawFont(this._drawFont(renderer.getFontContext(), this._text, x, y, stroke));
         }

package/src/utils/utils.js

@@ -120,14 +120,14 @@ var utils = {
             // never cache if a url is passed as parameter
             var index = url.indexOf("#");
             if (index !== -1) {
-                url = url.substr(index, url.length);
+                url = url.slice(index, url.length);
             } else {
                 return hash;
             }
         }
 
         // parse the url
-        url.substr(1).split("&").filter(function (value) {
+        url.slice(1).split("&").filter(function (value) {
             return (value !== "");
         }).forEach(function (value) {
             var kv = value.split("=");