melonjs 14.5.0 → 15.0.0

package/src/math/color.js

@@ -250,8 +250,8 @@ var cssToRGB = new Map();
         return this.glArray[3];
     }
 
-    set alpha(value) {
-        this.glArray[3] = typeof(value) === "undefined" ? 1.0 : clamp(+value, 0, 1.0);
+    set alpha(value = 1.0) {
+        this.glArray[3] = clamp(+value, 0, 1.0);
     }
 
 
@@ -534,12 +534,13 @@ var cssToRGB = new Map();
      * @returns {number}
      */
     toUint32(alpha = 1.0) {
-        var ur = this.r & 0xff;
-        var ug = this.g & 0xff;
-        var ub = this.b & 0xff;
-        var ua = (alpha * 255) & 0xff;
+        var a = this.glArray;
 
-        return (ua << 24) + (ur << 16) + (ug << 8) + ub;
+        var ur = (a[0] * 255) & 0xff;
+        var ug = (a[1] * 255) & 0xff;
+        var ub = (a[2] * 255) & 0xff;
+
+        return (((alpha * 255) & 0xff) << 24) + (ur << 16) + (ug << 8) + ub;
     }
 
     /**

package/src/polyfill/index.js

@@ -7,6 +7,4 @@ import "core-js/es/string/trim-end";
 
 // "built-in" polyfills
 import "./console.js";
-import "./performance.js";
-import "./requestAnimationFrame.js";
 import "./roundrect.js";

package/src/renderable/renderable.js

@@ -206,6 +206,13 @@ import Color from "./../math/color.js";
          */
         this.mask = undefined;
 
+        /**
+          * (Experimental) an optional shader, to be used instead of the default built-in one, when drawing this renderable (WebGL only)
+          * @type {GLShader}
+          * @default undefined
+        */
+        this.shader = undefined;
+
         /**
          * the blend mode to be applied to this renderable (see renderer setBlendMode for available blend mode)
          * @type {string}
@@ -620,9 +627,7 @@ import Color from "./../math/color.js";
          // manually update the anchor point (required for updateBoundsPos)
          this.anchorPoint.setMuted(x, y);
          // then call updateBounds
-         //this.updateBoundsPos(this.pos.x, this.pos.y);
          this.updateBounds();
-         //console.log("hello");
          this.isDirty = true;
      }
 
@@ -650,6 +655,11 @@ import Color from "./../math/color.js";
             renderer.translate(-this.pos.x, -this.pos.y);
         }
 
+        // use this renderable shader if defined
+        if (typeof this.shader === "object" && typeof renderer.gl !== "undefined") {
+            renderer.customShader = this.shader;
+        }
+
         if ((this.autoTransform === true) && (!this.currentTransform.isIdentity())) {
             // apply the renderable transformation matrix
             renderer.translate(this.pos.x, this.pos.y);
@@ -701,6 +711,12 @@ import Color from "./../math/color.js";
             renderer.clearMask();
         }
 
+        // revert to the default shader if defined
+        if (typeof this.shader === "object" && typeof renderer.gl !== "undefined") {
+            renderer.customShader = undefined;
+            //renderer.setCompositor("quad");
+        }
+
         // restore the context
         renderer.restore();
 
@@ -780,6 +796,12 @@ import Color from "./../math/color.js";
 
         // call the user defined destroy method
         this.onDestroyEvent.apply(this, arguments);
+
+        // destroy any shader object if not done by the user through onDestroyEvent()
+        if (typeof this.shader === "object") {
+            this.shader.destroy();
+            this.shader = undefined;
+        }
     }
 
     /**

package/src/renderable/ui/uitextbutton.js

@@ -24,7 +24,6 @@ import UIBaseElement from "./uibaseelement.js";
      * @param {string} [settings.backgroundColor] - The css value of a background color
      * @param {string} [settings.hoverColor] - The css value of a color to be used if the pointer hovers over the button
      * @param {string} [settings.borderStrokeColor] - The css value of a color to be used to draw the border
-     * @param {boolean} [settings.offScreenCanvas] - Weather to use an offScreen canvas or not
      * @param {string} [settings.fillStyle] - The css value of a tint color to be used to tint the text
      * @param {number} [settings.borderWidth] - Width of the button
      * @param {number} [settings.borderHeight] - Height of the button
@@ -57,7 +56,6 @@ import UIBaseElement from "./uibaseelement.js";
         settings.backgroundColor = settings.backgroundColor || "#00aa00";
         settings.hoverColor = settings.hoverColor || "#00ff00";
         settings.borderStrokeColor = settings.borderStrokeColor || "#000000";
-        settings.offScreenCanvas = settings.offScreenCanvas || false;
         settings.fillStyle = settings.fillStyle || "#ffffff";
         settings.lineWidth = settings.lineWidth || 1;
         settings.anchorPoint = settings.anchorPoint || new Vector2d(0, 0);

package/src/system/device.js

@@ -100,7 +100,7 @@ export const pointerEvent = !!globalThis.PointerEvent;
  * @readonly
  * @public
  */
-export const touch = touchEvent || pointerEvent;
+export const touch = touchEvent || (pointerEvent && globalThis.navigator.maxTouchPoints > 0);
 
 /**
  * the maximum number of simultaneous touch contact points are supported by the current device.

package/src/text/text.js

@@ -1,5 +1,4 @@
 import Color from "./../math/color.js";
-import WebGLRenderer from "./../video/webgl/webgl_renderer.js";
 import { renderer as globalRenderer } from "./../video/video.js";
 import pool from "./../system/pooling.js";
 import Renderable from "./../renderable/renderable.js";
@@ -19,18 +18,6 @@ import TextMetrics from "./textmetrics.js";
 const runits = ["ex", "em", "pt", "px"];
 const 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.canvasTexture.context;
-    } else {
-        if (typeof renderer === "undefined") {
-            renderer = globalRenderer;
-        }
-        return renderer.getFontContext();
-    }
-};
-
 /**
  * @classdesc
  * a generic system font object.
@@ -45,12 +32,11 @@ var getContext2d = function (renderer, text) {
      * @param {number|string} settings.size - size, or size + suffix (px, em, pt)
      * @param {Color|string} [settings.fillStyle="#000000"] - a CSS color value
      * @param {Color|string} [settings.strokeStyle="#000000"] - a CSS color value
-     * @param {number} [settings.lineWidth=1] - line width, in pixels, when drawing stroke
+     * @param {number} [settings.lineWidth=0] - line width, in pixels, when drawing stroke
      * @param {string} [settings.textAlign="left"] - horizontal text alignment
      * @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 {boolean} [settings.offScreenCanvas=false] - whether to draw the font to an individual "cache" texture first
      * @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
@@ -105,9 +91,9 @@ var getContext2d = function (renderer, text) {
          * sets the current line width, in pixels, when drawing stroke
          * @public
          * @type {number}
-         * @default 1
+         * @default 0
          */
-        this.lineWidth = settings.lineWidth || 1;
+        this.lineWidth = settings.lineWidth || 0;
 
         /**
          * Set the default text alignment (or justification),<br>
@@ -136,16 +122,6 @@ var getContext2d = function (renderer, text) {
          */
         this.lineHeight = settings.lineHeight || 1.0;
 
-        /**
-         * whether to draw the font to a indidividual offscreen canvas texture first <br>
-         * Note: this will improve performances when using WebGL, but will impact
-         * memory consumption as every text element will have its own canvas texture
-         * @public
-         * @type {boolean}
-         * @default false
-         */
-        this.offScreenCanvas = false;
-
         /**
          * the maximum length in CSS pixel for a single segment of text.
          * (use -1 to disable word wrapping)
@@ -192,10 +168,8 @@ var getContext2d = function (renderer, text) {
             this.italic();
         }
 
-        if (settings.offScreenCanvas === true) {
-            this.offScreenCanvas = true;
-            this.canvasTexture = pool.pull("CanvasTexture", 2, 2, { offscreenCanvas: true });
-        }
+        // the canvas Texture used to render this text
+        this.canvasTexture = pool.pull("CanvasTexture", 2, 2, { offscreenCanvas: true });
 
         // instance to text metrics functions
         this.metrics = new TextMetrics(this);
@@ -284,38 +258,38 @@ var getContext2d = function (renderer, text) {
 
         // word wrap if necessary
         if (this._text.length > 0 && this.wordWrapWidth > 0) {
-            this._text = this.metrics.wordWrap(this._text, this.wordWrapWidth, getContext2d(globalRenderer, this));
+            this._text = this.metrics.wordWrap(this._text, this.wordWrapWidth, this.canvasTexture.context);
         }
 
         // calculcate the text size and update the bounds accordingly
-        bounds.addBounds(this.metrics.measureText(this._text, getContext2d(globalRenderer, this)), true);
+        bounds.addBounds(this.metrics.measureText(this._text, this.canvasTexture.context), true);
 
         // update the offScreenCanvas texture if required
-        if (this.offScreenCanvas === true) {
-            var width = Math.ceil(this.metrics.width),
-                height = Math.ceil(this.metrics.height);
-
-            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.canvasTexture.canvas));
-                globalRenderer.currentCompositor.unbindTexture2D(null, this.glTextureUnit);
-
-                if (globalRenderer.WebGLVersion === 1) {
-                    // round size to next Pow2
-                    width = nextPowerOfTwo(this.metrics.width);
-                    height = nextPowerOfTwo(this.metrics.height);
-                }
-            }
-
-            // resize the cache canvas if necessary
-            if (this.canvasTexture.width < width || this.canvasTexture.height < height) {
-                this.canvasTexture.resize(width, height);
+        var width = Math.ceil(this.metrics.width),
+            height = Math.ceil(this.metrics.height);
+
+        if (typeof globalRenderer.gl !== "undefined") {
+            // make sure the right compositor is active
+            globalRenderer.setCompositor("quad");
+            // invalidate the previous corresponding texture so that it can reuploaded once changed
+            this.glTextureUnit = globalRenderer.cache.getUnit(globalRenderer.cache.get(this.canvasTexture.canvas));
+            globalRenderer.currentCompositor.unbindTexture2D(null, this.glTextureUnit);
+
+            if (globalRenderer.WebGLVersion === 1) {
+                // round size to next Pow2
+                width = nextPowerOfTwo(this.metrics.width);
+                height = nextPowerOfTwo(this.metrics.height);
             }
+        }
 
-            this.canvasTexture.clear();
-            this._drawFont(this.canvasTexture.context, this._text,  this.pos.x - this.metrics.x, this.pos.y - this.metrics.y, false);
+        // resize the cache canvas if necessary
+        if (this.canvasTexture.width < width || this.canvasTexture.height < height) {
+            this.canvasTexture.resize(width, height);
         }
 
+        this.canvasTexture.clear();
+        this._drawFont(this.canvasTexture.context, this._text,  this.pos.x - this.metrics.x, this.pos.y - this.metrics.y);
+
         this.isDirty = true;
 
         return this;
@@ -328,7 +302,7 @@ var getContext2d = function (renderer, text) {
      * @returns {TextMetrics} a TextMetrics object defining the dimensions of the given piece of text
      */
     measureText(renderer, text = this._text) {
-        return this.metrics.measureText(text, getContext2d(renderer, this));
+        return this.metrics.measureText(text, this.canvasTexture.context);
     }
 
 
@@ -338,9 +312,8 @@ var getContext2d = function (renderer, text) {
      * @param {string} [text]
      * @param {number} [x]
      * @param {number} [y]
-     * @param {boolean} [stroke=false] - draw stroke the the text if true
      */
-    draw(renderer, text, x = this.pos.x, y = this.pos.y, stroke = false) {
+    draw(renderer, text, x = this.pos.x, y = this.pos.y) {
         // "hacky patch" for backward compatibilty
         if (typeof this.ancestor === "undefined") {
 
@@ -354,21 +327,18 @@ var getContext2d = function (renderer, text) {
             // update text cache
             this.setText(text);
 
-            x = this.metrics.x;
-            y = this.metrics.y;
-
             // save the previous context
             renderer.save();
 
             // apply the defined alpha value
             renderer.setGlobalAlpha(renderer.globalAlpha() * this.getOpacity());
 
-        } else {
-             // added directly to an object container
-            x = this.pos.x;
-            y = this.pos.y;
         }
 
+        // adjust x,y position based on the bounding box
+        x = this.metrics.x;
+        y = this.metrics.y;
+
         // clamp to pixel grid if required
         if (renderer.settings.subPixel === false) {
             x = ~~x;
@@ -376,12 +346,7 @@ var getContext2d = function (renderer, text) {
         }
 
         // draw the text
-        if (this.offScreenCanvas === true) {
-            renderer.drawImage(this.canvasTexture.canvas, x, y);
-        } else {
-            renderer.drawFont(this._drawFont(renderer.getFontContext(), this._text, x, y, stroke));
-        }
-
+        renderer.drawImage(this.canvasTexture.canvas, x, y);
 
         // for backward compatibilty
         if (typeof this.ancestor === "undefined") {
@@ -391,28 +356,33 @@ var getContext2d = function (renderer, text) {
     }
 
     /**
-     * draw a stroke text at the specified coord, as defined <br>
-     * by the `lineWidth` and `fillStroke` properties. <br>
-     * Note : using drawStroke is not recommended for performance reasons
+     * draw a stroke text at the specified coord, as defined by the `lineWidth` and `fillStroke` properties.
+     * @deprecated since 15.0.0
      * @param {CanvasRenderer|WebGLRenderer} renderer - Reference to the destination renderer instance
      * @param {string} text
      * @param {number} x
      * @param {number} y
      */
     drawStroke(renderer, text, x, y) {
-        this.draw(renderer, text, x, y, true);
+        this.draw(renderer, text, x, y);
     }
 
     /**
      * @ignore
      */
-    _drawFont(context, text, x, y, stroke = false) {
-        setContextStyle(context, this, stroke);
+    _drawFont(context, text, x, y) {
+        setContextStyle(context, this);
 
         for (var i = 0; i < text.length; i++) {
             var string = text[i].trimEnd();
             // draw the string
-            context[stroke ? "strokeText" : "fillText"](string, x, y);
+            if (this.fillStyle.alpha > 0) {
+                context.fillText(string, x, y);
+            }
+            // stroke the text
+            if (this.lineWidth > 0 && this.strokeStyle.alpha > 0) {
+                context.strokeText(string, x, y);
+            }
             // add leading space
             y += this.metrics.lineHeight();
         }
@@ -424,15 +394,15 @@ var getContext2d = function (renderer, text) {
      * @ignore
      */
     destroy() {
-        if (this.offScreenCanvas === true) {
-            if (globalRenderer instanceof WebGLRenderer) {
-                globalRenderer.currentCompositor.deleteTexture2D(globalRenderer.currentCompositor.getTexture2D(this.glTextureUnit));
-                this.glTextureUnit = undefined;
-            }
-            globalRenderer.cache.delete(this.canvasTexture.canvas);
-            pool.push(this.canvasTexture);
-            this.canvasTexture = undefined;
+        if (typeof globalRenderer.gl !== "undefined") {
+            // make sure the right compositor is active
+            globalRenderer.setCompositor("quad");
+            globalRenderer.currentCompositor.deleteTexture2D(globalRenderer.currentCompositor.getTexture2D(this.glTextureUnit));
+            this.glTextureUnit = undefined;
         }
+        globalRenderer.cache.delete(this.canvasTexture.canvas);
+        pool.push(this.canvasTexture);
+        this.canvasTexture = undefined;
         pool.push(this.fillStyle);
         pool.push(this.strokeStyle);
         this.fillStyle = this.strokeStyle = undefined;

package/src/text/textstyle.js

@@ -2,13 +2,11 @@
  * apply the current text style to the given context
  * @ignore
  */
-export default function setContextStyle(context, style, stroke = false) {
+export default function setContextStyle(context, style) {
     context.font = style.font;
     context.fillStyle = style.fillStyle.toRGBA();
-    if (stroke === true) {
-        context.strokeStyle = style.strokeStyle.toRGBA();
-        context.lineWidth = style.lineWidth;
-    }
+    context.strokeStyle = style.strokeStyle.toRGBA();
+    context.lineWidth = style.lineWidth;
     context.textAlign = style.textAlign;
     context.textBaseline = style.textBaseline;
 }

package/src/video/canvas/canvas_renderer.js

@@ -59,6 +59,11 @@ import * as event from "./../../system/event.js";
             this.isContextValid = true;
             event.emit(event.ONCONTEXT_RESTORED, this);
         }, false );
+
+        // reset the renderer on game reset
+        event.on(event.GAME_RESET, () => {
+            this.reset();
+        });
     }
 
     /**
@@ -534,15 +539,6 @@ import * as event from "./../../system/event.js";
         this.strokePoint(x, y);
     }
 
-    /**
-     * return a reference to the font 2d Context
-     * @ignore
-     */
-    getFontContext() {
-        // in canvas mode we can directly use the 2d context
-        return this.getContext();
-    }
-
     /**
      * save the canvas context
      * @name save

package/src/video/renderer.js

@@ -115,11 +115,6 @@ import Point from "../geometries/point.js";
 
         // default uvOffset
         this.uvOffset = 0;
-
-        // reset the renderer on game reset
-        event.on(event.GAME_RESET, () => {
-            this.reset();
-        });
     }
 
     /**
@@ -412,10 +407,4 @@ import Point from "../geometries/point.js";
         // reset to default
         this.currentTint.setColor(255, 255, 255, 1.0);
     }
-
-    /**
-     * @ignore
-     */
-    drawFont(/*bounds*/) {}
-
 }

package/src/video/texture/atlas.js

@@ -1,6 +1,4 @@
 import Vector2d from "./../../math/vector2.js";
-import WebGLRenderer from "./../webgl/webgl_renderer.js";
-import TextureCache from "./../texture/cache.js";
 import Sprite from "./../../renderable/sprite.js";
 import { renderer } from "./../video.js";
 import pool from "./../../system/pooling.js";
@@ -159,11 +157,7 @@ export class TextureAtlas {
         // Add self to TextureCache if cache !== false
         if (cache !== false) {
             this.sources.forEach((source) => {
-                if (cache instanceof TextureCache) {
-                    cache.set(source, this);
-                } else {
-                    renderer.cache.set(source, this);
-                }
+                renderer.cache.set(source, this);
             });
         }
     }
@@ -388,7 +382,7 @@ export class TextureAtlas {
      */
     addUVs(atlas, name, w, h) {
         // ignore if using the Canvas Renderer
-        if (renderer instanceof WebGLRenderer) {
+        if (typeof renderer.gl !== "undefined") {
             // Source coordinates
             var s = atlas[name].offset;
             var sw = atlas[name].width;

package/src/video/webgl/buffer/vertex.js

@@ -7,18 +7,18 @@
 
  export default class VertexArrayBuffer {
 
-    constructor(vertex_size, vertex_per_quad) {
+    constructor(vertex_size, vertex_per_obj) {
         // the size of one vertex in float
         this.vertexSize = vertex_size;
-        // size of a quad in vertex
-        this.quadSize = vertex_per_quad;
+        // size of an object in vertex
+        this.objSize = vertex_per_obj;
         // the maximum number of vertices the vertex array buffer can hold
-        this.maxVertex = 256;
+        this.maxVertex = 256; // (note: this seems to be the sweet spot performance-wise when using batching)
         // the current number of vertices added to the vertex array buffer
         this.vertexCount = 0;
 
         // the actual vertex data buffer
-        this.buffer = new ArrayBuffer(this.maxVertex * this.vertexSize * this.quadSize);
+        this.buffer = new ArrayBuffer(this.maxVertex * this.vertexSize * this.objSize);
         // Float32 and Uint32 view of the vertex data array buffer
         this.bufferF32 = new Float32Array(this.buffer);
         this.bufferU32 = new Uint32Array(this.buffer);
@@ -37,7 +37,7 @@
      * return true if full
      * @ignore
      */
-    isFull(vertex = this.quadSize) {
+    isFull(vertex = this.objSize) {
          return (this.vertexCount + vertex >= this.maxVertex);
     }
 
@@ -45,14 +45,18 @@
      * resize the vertex buffer, retaining its original contents
      * @ignore
      */
-    resize() {
-        // double the vertex size
-        this.maxVertex <<= 1;
+    resize(vertexCount) {
+
+        while (vertexCount > this.maxVertex) {
+            // double the vertex size
+            this.maxVertex <<= 1;
+        }
+
         // save a reference to the previous data
         var data = this.bufferF32;
 
         // recreate ArrayBuffer and views
-        this.buffer = new ArrayBuffer(this.maxVertex * this.vertexSize * this.quadSize);
+        this.buffer = new ArrayBuffer(this.maxVertex * this.vertexSize * this.objSize);
         this.bufferF32 = new Float32Array(this.buffer);
         this.bufferU32 = new Uint32Array(this.buffer);
 
@@ -70,19 +74,19 @@
         var offset = this.vertexCount * this.vertexSize;
 
         if (this.vertexCount >= this.maxVertex) {
-            this.resize();
+            this.resize(this.vertexCount);
         }
 
-        this.bufferF32[offset + 0] = x;
-        this.bufferF32[offset + 1] = y;
+        this.bufferF32[offset] = x;
+        this.bufferF32[++offset] = y;
 
         if (typeof u !== "undefined") {
-            this.bufferF32[offset + 2] = u;
-            this.bufferF32[offset + 3] = v;
+            this.bufferF32[++offset] = u;
+            this.bufferF32[++offset] = v;
         }
 
         if (typeof tint !== "undefined") {
-            this.bufferU32[offset + 4] = tint;
+            this.bufferU32[++offset] = tint;
         }
 
         this.vertexCount++;