melonjs 10.5.2 → 10.6.0

package/src/system/pooling.js

@@ -15,174 +15,169 @@ var instance_counter = 0;
  * @namespace pool
  */
 
-var pool = {
-
-    /**
-     * 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);
-     */
-     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");
-         }
-     },
+/**
+ * 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");
+     }
+ };
 
-    /**
-     * 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);
-     */
-    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)
+ * @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;
 
-            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);
-                }
-                instance_counter--;
-            }
-            else {
-                // create a new instance
-                args[0] = proto;
-                obj = new (proto.bind.apply(proto, args))();
-                if (poolArray) {
-                    obj.className = name;
-                }
+        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);
             }
-            return obj;
+            instance_counter--;
         }
-        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
-     */
-    purge() {
-        for (var className in objectClass) {
-            if (objectClass[className]) {
-                objectClass[className].pool = [];
+        else {
+            // create a new instance
+            args[0] = proto;
+            obj = new (proto.bind.apply(proto, args))();
+            if (poolArray) {
+                obj.className = name;
             }
         }
-        instance_counter = 0;
-    },
+        return obj;
+    }
+    throw new Error("Cannot instantiate object of type '" + name + "'");
+};
 
-    /**
-     * 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
-     */
-    push(obj, throwOnError = true) {
-        if (!this.poolable(obj)) {
-            if (throwOnError === true ) {
-                throw new Error("me.pool: object " + obj + " cannot be recycled");
-            } else {
-                return false;
-            }
+/**
+ * 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 = [];
         }
+    }
+    instance_counter = 0;
+};
 
-        // store back the object instance for later recycling
-        objectClass[obj.className].pool.push(obj);
-        instance_counter++;
+/**
+ * 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;
+        }
+    }
 
-        return true;
-    },
+    // store back the object instance for later recycling
+    objectClass[obj.className].pool.push(obj);
+    instance_counter++;
 
-    /**
-     * 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
-     */
-    exists(name) {
-        return name in objectClass;
-    },
+    return true;
+};
 
-    /**
-     * 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
-     * }
-     */
-    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 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 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");
 
-    /**
-     * returns the amount of object instance currently in the pool
-     * @function pool.getInstanceCount
-     * @returns {number} amount of object instance
-     */
-    getInstanceCount() {
-        return instance_counter;
-    }
 };
 
-export default pool;
+/**
+ * returns the amount of object instance currently in the pool
+ * @function pool.getInstanceCount
+ * @returns {number} amount of object instance
+ */
+export function getInstanceCount() {
+    return instance_counter;
+};

package/src/text/bitmaptext.js

@@ -1,35 +1,9 @@
 import Color from "./../math/color.js";
 import * as stringUtil from "./../utils/string.js";
-import pool from "./../system/pooling.js";
+import * as pool from "./../system/pooling.js";
 import loader from "./../loader/loader.js";
 import Renderable from "./../renderable/renderable.js";
-
-/**
- * Measures the width of a single line of text, does not account for \n
- * @ignore
- */
-var measureTextWidth = function(font, text) {
-    var characters = text.split("");
-    var width = 0;
-    var lastGlyph = null;
-    for (var i = 0; i < characters.length; i++) {
-        var ch = characters[i].charCodeAt(0);
-        var glyph = font.fontData.glyphs[ch];
-        var kerning = (lastGlyph && lastGlyph.kerning) ? lastGlyph.getKerning(ch) : 0;
-        width += (glyph.xadvance + kerning) * font.fontScale.x;
-        lastGlyph = glyph;
-    }
-
-    return width;
-};
-
-/**
- * Measures the height of a single line of text, does not account for \n
- * @ignore
- */
-var measureTextHeight = function(font) {
-    return font.fontData.capHeight * font.lineHeight * font.fontScale.y;
-};
+import TextMetrics from "./textmetrics.js";
 
 /**
  * @classdesc
@@ -50,6 +24,7 @@ class BitmapText extends Renderable {
      * @param {string} [settings.textBaseline="top"] the text baseline
      * @param {number} [settings.lineHeight=1.0] line spacing height
      * @param {Vector2d} [settings.anchorPoint={x:0.0, y:0.0}] anchor point to draw the text at
+     * @param {number} [settings.wordWrapWidth] the maximum length in CSS pixel for a single segment of text
      * @param {(string|string[])} [settings.text] a string, or an array of strings
      * @example
      * // Use me.loader.preload or me.loader.load to load assets
@@ -75,8 +50,6 @@ class BitmapText extends Renderable {
          * @public
          * @type {string}
          * @default "left"
-         * @name textAlign
-         * @memberof BitmapText
          */
         this.textAlign = settings.textAlign || "left";
 
@@ -86,8 +59,6 @@ class BitmapText extends Renderable {
          * @public
          * @type {string}
          * @default "top"
-         * @name textBaseline
-         * @memberof BitmapText
          */
         this.textBaseline = settings.textBaseline || "top";
 
@@ -97,11 +68,18 @@ class BitmapText extends Renderable {
          * @public
          * @type {number}
          * @default 1.0
-         * @name lineHeight
-         * @memberof BitmapText
          */
         this.lineHeight = settings.lineHeight || 1.0;
 
+        /**
+         * the maximum length in CSS pixel for a single segment of text.
+         * (use -1 to disable word wrapping)
+         * @public
+         * @type {number}
+         * @default -1
+         */
+        this.wordWrapWidth = settings.wordWrapWidth || -1;
+
         /**
          * the text to be displayed
          * @private
@@ -161,15 +139,15 @@ class BitmapText extends Renderable {
             this.anchorPoint.set(0, 0);
         }
 
+        // instance to text metrics functions
+        this.metrics = new TextMetrics(this);
+
         // set the text
         this.setText(settings.text);
     }
 
     /**
      * change the font settings
-     * @name set
-     * @memberof BitmapText.prototype
-     * @function
      * @param {string} textAlign ("left", "center", "right")
      * @param {number} [scale]
      * @returns {BitmapText} this object for chaining
@@ -187,17 +165,10 @@ class BitmapText extends Renderable {
 
     /**
      * change the text to be displayed
-     * @name setText
-     * @memberof BitmapText.prototype
-     * @function
      * @param {number|string|string[]} value a string, or an array of strings
      * @returns {BitmapText} this object for chaining
      */
-    setText(value) {
-        if (typeof value === "undefined") {
-            value = "";
-        }
-
+    setText(value = "") {
         if (this._text.toString() !== value.toString()) {
             if (!Array.isArray(value)) {
                 this._text = ("" + value).split("\n");
@@ -207,6 +178,12 @@ class BitmapText extends Renderable {
             this.isDirty = true;
         }
 
+        if (this._text.length > 0 && this.wordWrapWidth > 0) {
+            this._text = this.metrics.wordWrap(this._text, this.wordWrapWidth);
+        }
+
+        this.getBounds().addBounds(this.metrics.measureText(this._text), true);
+
         return this;
     }
 
@@ -214,9 +191,7 @@ class BitmapText extends Renderable {
      * defines the color used to tint the bitmap text
      * @public
      * @type {Color}
-     * @name fillStyle
      * @see Renderable#tint
-     * @memberof BitmapText
      */
     get fillStyle() {
         return this.tint;
@@ -227,14 +202,14 @@ class BitmapText extends Renderable {
 
     /**
      * change the font display size
-     * @name resize
-     * @memberof BitmapText.prototype
-     * @function
      * @param {number} scale ratio
      * @returns {BitmapText} this object for chaining
      */
     resize(scale) {
         this.fontScale.set(scale, scale);
+
+        this.getBounds().addBounds(this.metrics.measureText(this._text), true);
+
         // clear the cache text to recalculate bounds
         this.isDirty = true;
 
@@ -243,44 +218,15 @@ class BitmapText extends Renderable {
 
     /**
      * measure the given text size in pixels
-     * @name measureText
-     * @memberof BitmapText.prototype
-     * @function
      * @param {string} [text]
-     * @param {Rect} [ret] a object in which to store the text metrics
      * @returns {TextMetrics} a TextMetrics object with two properties: `width` and `height`, defining the output dimensions
      */
-    measureText(text, ret) {
-        text = text || this._text;
-
-        var stringHeight = measureTextHeight(this);
-        var textMetrics = ret || this.getBounds();
-        var strings = typeof text === "string" ? ("" + (text)).split("\n") : text;
-
-        textMetrics.height = textMetrics.width = 0;
-
-        for (var i = 0; i < strings.length; i++) {
-            textMetrics.width = Math.max(measureTextWidth(this, strings[i]), textMetrics.width);
-            textMetrics.height += stringHeight;
-        }
-        return textMetrics;
-    }
-
-    /**
-     * @ignore
-     */
-    update(/* dt */) {
-        if (this.isDirty === true) {
-            this.measureText();
-        }
-        return this.isDirty;
+    measureText(text = this._text) {
+        return this.metrics.measureText(text);
     }
 
     /**
      * draw the bitmap font
-     * @name draw
-     * @memberof BitmapText.prototype
-     * @function
      * @param {CanvasRenderer|WebGLRenderer} renderer Reference to the destination renderer instance
      * @param {string} [text]
      * @param {number} [x]
@@ -295,8 +241,6 @@ class BitmapText extends Renderable {
         if (typeof this.ancestor === "undefined") {
             // update cache
             this.setText(text);
-            // force update bounds
-            this.update(0);
             renderer.setGlobalAlpha(_alpha * this.getOpacity());
         } else {
             // added directly to an object container
@@ -305,14 +249,14 @@ class BitmapText extends Renderable {
         }
 
         var lX = x;
-        var stringHeight = measureTextHeight(this);
+        var stringHeight = this.metrics.lineHeight();
         var maxWidth = 0;
 
         for (var i = 0; i < this._text.length; i++) {
             x = lX;
             var string = stringUtil.trimRight(this._text[i]);
             // adjust x pos based on alignment value
-            var stringWidth = measureTextWidth(this, string);
+            var stringWidth = this.metrics.lineWidth(string);
             switch (this.textAlign) {
                 case "right":
                     x -= stringWidth;
@@ -403,10 +347,10 @@ class BitmapText extends Renderable {
         pool.push(this.fontData);
         this.fontData = undefined;
         this._text.length = 0;
+        this.metrics = undefined;
         super.destroy();
     }
 
 };
 
-
 export default BitmapText;