melonjs 10.6.1 → 10.8.0

package/src/video/webgl/webgl_renderer.js

@@ -1,5 +1,4 @@
 import Color from "./../../math/color.js";
-import Vector2d from "./../../math/vector2.js";
 import Matrix2d from "./../../math/matrix2.js";
 import WebGLCompositor from "./webgl_compositor.js";
 import Renderer from "./../renderer.js";
@@ -7,8 +6,8 @@ import TextureCache from "./../texture_cache.js";
 import { TextureAtlas, createAtlas } from "./../texture.js";
 import { createCanvas, renderer } from "./../video.js";
 import * as event from "./../../system/event.js";
-import * as pool from "./../../system/pooling.js";
-import { isPowerOfTwo, nextPowerOfTwo, TAU } from "./../../math/math.js";
+import pool from "./../../system/pooling.js";
+import { isPowerOfTwo, nextPowerOfTwo } from "./../../math/math.js";
 
 
 /**
@@ -41,7 +40,7 @@ class WebGLRenderer extends Renderer {
         /**
          * The WebGL version used by this renderer (1 or 2)
          * @name WebGLVersion
-         * @memberof WebGLRenderer
+         * @memberof WebGLRenderer#
          * @type {number}
          * @default 1
          * @readonly
@@ -51,7 +50,7 @@ class WebGLRenderer extends Renderer {
         /**
          * The vendor string of the underlying graphics driver.
          * @name GPUVendor
-         * @memberof WebGLRenderer
+         * @memberof WebGLRenderer#
          * @type {string}
          * @default null
          * @readonly
@@ -61,7 +60,7 @@ class WebGLRenderer extends Renderer {
         /**
          * The renderer string of the underlying graphics driver.
          * @name GPURenderer
-         * @memberof WebGLRenderer
+         * @memberof WebGLRenderer#
          * @type {string}
          * @default null
          * @readonly
@@ -71,7 +70,7 @@ class WebGLRenderer extends Renderer {
         /**
          * The WebGL context
          * @name gl
-         * @memberof WebGLRenderer
+         * @memberof WebGLRenderer#
          * type {WebGLRenderingContext}
          */
         this.context = this.gl = this.getContextGL(this.getScreenCanvas(), options.transparent);
@@ -79,7 +78,7 @@ class WebGLRenderer extends Renderer {
         /**
          * Maximum number of texture unit supported under the current context
          * @name maxTextures
-         * @memberof WebGLRenderer
+         * @memberof WebGLRenderer#
          * @type {number}
          * @readonly
          */
@@ -105,16 +104,6 @@ class WebGLRenderer extends Renderer {
          */
         this._blendStack = [];
 
-        /**
-         * @ignore
-         */
-        this._glPoints = [
-            new Vector2d(),
-            new Vector2d(),
-            new Vector2d(),
-            new Vector2d()
-        ];
-
         /**
          * The current transformation matrix used for transformations on the overall scene
          * @name currentTransform
@@ -134,7 +123,7 @@ class WebGLRenderer extends Renderer {
         /**
          * The list of active compositors
          * @name compositors
-         * @type {Map}
+         * @type {Map<WebGLCompositor>}
          * @memberof WebGLRenderer#
          */
         this.compositors = new Map();
@@ -163,19 +152,19 @@ class WebGLRenderer extends Renderer {
         // Create a texture cache
         this.cache = new TextureCache(this.maxTextures);
 
-        // to simulate context lost and restore :
+        // to simulate context lost and restore in WebGL:
         // var ctx = me.video.renderer.context.getExtension('WEBGL_lose_context');
         // ctx.loseContext()
         this.getScreenCanvas().addEventListener("webglcontextlost", (e) => {
             e.preventDefault();
             this.isContextValid = false;
-            event.emit(event.WEBGL_ONCONTEXT_LOST, this);
+            event.emit(event.ONCONTEXT_LOST, this);
         }, false );
         // ctx.restoreContext()
         this.getScreenCanvas().addEventListener("webglcontextrestored", () => {
             this.reset();
             this.isContextValid = true;
-            event.emit(event.WEBGL_ONCONTEXT_RESTORED, this);
+            event.emit(event.ONCONTEXT_RESTORED, this);
         }, false );
     }
 
@@ -570,7 +559,7 @@ class WebGLRenderer extends Renderer {
      * <img src="images/normal-blendmode.png" width="510"/> <br>
      * - "multiply" : the pixels of the top layer are multiplied with the corresponding pixel of the bottom layer. A darker picture is the result. <br>
      * <img src="images/multiply-blendmode.png" width="510"/> <br>
-     * - "lighter" : where both content overlap the color is determined by adding color values. <br>
+     * - "additive or lighter" : where both content overlap the color is determined by adding color values. <br>
      * <img src="images/lighter-blendmode.png" width="510"/> <br>
      * - "screen" : The pixels are inverted, multiplied, and inverted again. A lighter picture is the result (opposite of multiply) <br>
      * <img src="images/screen-blendmode.png" width="510"/> <br>
@@ -578,7 +567,7 @@ class WebGLRenderer extends Renderer {
      * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation
      * @memberof WebGLRenderer.prototype
      * @function
-     * @param {string} [mode="normal"] blend mode : "normal", "multiply", "lighter", "screen"
+     * @param {string} [mode="normal"] blend mode : "normal", "multiply", "lighter", "additive", "screen"
      * @param {WebGLRenderingContext} [gl]
      */
     setBlendMode(mode = "normal", gl = this.gl) {
@@ -594,6 +583,7 @@ class WebGLRenderer extends Renderer {
                     break;
 
                 case "lighter" :
+                case "additive" :
                     gl.blendFunc(gl.ONE, gl.ONE);
                     break;
 
@@ -720,6 +710,17 @@ class WebGLRenderer extends Renderer {
         this.currentColor.alpha = alpha;
     }
 
+    /**
+     * Return the global alpha
+     * @name getGlobalAlpha
+     * @memberof WebGLRenderer.prototype
+     * @function
+     * @returns {number} global alpha value
+     */
+    getGlobalAlpha() {
+        return this.currentColor.alpha;
+    }
+
     /**
      * Set the current fill & stroke style color.
      * By default, or upon reset, the value is set to #000000.
@@ -758,34 +759,18 @@ class WebGLRenderer extends Renderer {
      * @param {boolean} [antiClockwise=false] draw arc anti-clockwise
      * @param {boolean} [fill=false]
      */
-    strokeArc(x, y, radius, start, end, antiClockwise = false, fill) {
-        if (fill === true ) {
-            this.fillArc(x, y, radius, start, end, antiClockwise);
+    strokeArc(x, y, radius, start, end, antiClockwise = false, fill = false) {
+        if (this.getGlobalAlpha() < 1 / 255) {
+            // Fast path: don't draw fully transparent
+            return;
+        }
+        this.path2D.beginPath();
+        this.path2D.arc(x, y, radius, start, end, antiClockwise);
+        if (fill === false) {
+            this.currentCompositor.drawVertices(this.gl.LINE_STRIP, this.path2D.points);
         } else {
-            // XXX to be optimzed using a specific shader
-            var points = this._glPoints;
-            var i, len = Math.floor(24 * Math.sqrt(radius * 2));
-            var theta = (end - start) / (len * 2);
-            var theta2 = theta * 2;
-            var cos_theta = Math.cos(theta);
-            var sin_theta = Math.sin(theta);
-
-            // Grow internal points buffer if necessary
-            for (i = points.length; i < len + 1; i++) {
-                points.push(new Vector2d());
-            }
-
-            // calculate and draw all segments
-            for (i = 0; i < len; i++) {
-                var angle = ((theta) + start + (theta2 * i));
-                var cos = Math.cos(angle);
-                var sin = -Math.sin(angle);
-
-                points[i].x = x + (((cos_theta * cos) + (sin_theta * sin)) * radius);
-                points[i].y = y + (((cos_theta * -sin) + (sin_theta * cos)) * radius);
-            }
-            // batch draw all lines
-            this.currentCompositor.drawVertices(this.gl.LINE_STRIP, points, len);
+            this.path2D.closePath();
+            this.currentCompositor.drawVertices(this.gl.TRIANGLES, this.path2D.triangulatePath());
         }
     }
 
@@ -801,35 +786,8 @@ class WebGLRenderer extends Renderer {
      * @param {number} end end angle in radians
      * @param {boolean} [antiClockwise=false] draw arc anti-clockwise
      */
-    fillArc(x, y, radius, start, end /*, antiClockwise = false*/) {
-        // XXX to be optimzed using a specific shader
-        var points = this._glPoints;
-        var i, index = 0;
-        var len = Math.floor(24 * Math.sqrt(radius * 2));
-        var theta = (end - start) / (len * 2);
-        var theta2 = theta * 2;
-        var cos_theta = Math.cos(theta);
-        var sin_theta = Math.sin(theta);
-
-        // Grow internal points buffer if necessary
-        for (i = points.length; i < len * 2; i++) {
-            points.push(new Vector2d());
-        }
-
-        // calculate and draw all segments
-        for (i = 0; i < len - 1; i++) {
-            var angle = ((theta) + start + (theta2 * i));
-            var cos = Math.cos(angle);
-            var sin = -Math.sin(angle);
-
-            points[index++].set(x, y);
-            points[index++].set(
-                x - (((cos_theta * cos) + (sin_theta * sin)) * radius),
-                y - (((cos_theta * -sin) + (sin_theta * cos)) * radius)
-            );
-        }
-        // batch draw all triangles
-        this.currentCompositor.drawVertices(this.gl.TRIANGLE_STRIP, points, index);
+    fillArc(x, y, radius, start, end, antiClockwise = false) {
+        this.strokeArc(x, y, radius, start, end, antiClockwise, true);
     }
 
     /**
@@ -844,28 +802,17 @@ class WebGLRenderer extends Renderer {
      * @param {boolean} [fill=false] also fill the shape with the current color if true
      */
     strokeEllipse(x, y, w, h, fill = false) {
-        if (fill === true ) {
-            this.fillEllipse(x, y, w, h);
+        if (this.getGlobalAlpha() < 1 / 255) {
+            // Fast path: don't draw fully transparent
+            return;
+        }
+        this.path2D.beginPath();
+        this.path2D.ellipse(x, y, w, h, 0, 0, 360);
+        this.path2D.closePath();
+        if (fill === false) {
+            this.currentCompositor.drawVertices(this.gl.LINE_LOOP, this.path2D.points);
         } else {
-            // XXX to be optimzed using a specific shader
-            var len = Math.floor(24 * Math.sqrt(w)) ||
-                      Math.floor(12 * Math.sqrt(w + h));
-            var segment = (TAU) / len;
-            var points = this._glPoints,
-                i;
-
-            // Grow internal points buffer if necessary
-            for (i = points.length; i < len; i++) {
-                points.push(new Vector2d());
-            }
-
-            // calculate and draw all segments
-            for (i = 0; i < len; i++) {
-                points[i].x = x + (Math.sin(segment * -i) * w);
-                points[i].y = y + (Math.cos(segment * -i) * h);
-            }
-            // batch draw all lines
-            this.currentCompositor.drawVertices(this.gl.LINE_LOOP, points, len);
+            this.currentCompositor.drawVertices(this.gl.TRIANGLES, this.path2D.triangulatePath());
         }
     }
 
@@ -880,28 +827,7 @@ class WebGLRenderer extends Renderer {
      * @param {number} h vertical radius of the ellipse
      */
     fillEllipse(x, y, w, h) {
-        // XXX to be optimzed using a specific shader
-        var len = Math.floor(24 * Math.sqrt(w)) ||
-                  Math.floor(12 * Math.sqrt(w + h));
-        var segment = (TAU) / len;
-        var points = this._glPoints;
-        var index = 0, i;
-
-        // Grow internal points buffer if necessary
-        for (i = points.length; i < (len + 1) * 2; i++) {
-            points.push(new Vector2d());
-        }
-
-        // draw all vertices vertex coordinates
-        for (i = 0; i < len + 1; i++) {
-            points[index++].set(x, y);
-            points[index++].set(
-                x + (Math.sin(segment * i) * w),
-                y + (Math.cos(segment * i) * h)
-            );
-        }
-        // batch draw all triangles
-        this.currentCompositor.drawVertices(this.gl.TRIANGLE_STRIP, points, index);
+        this.strokeEllipse(x, y, w, h, false);
     }
 
     /**
@@ -915,12 +841,14 @@ class WebGLRenderer extends Renderer {
      * @param {number} endY the end y coordinate
      */
     strokeLine(startX, startY, endX, endY) {
-        var points = this._glPoints;
-        points[0].x = startX;
-        points[0].y = startY;
-        points[1].x = endX;
-        points[1].y = endY;
-        this.currentCompositor.drawVertices(this.gl.LINE_STRIP, points, 2);
+        if (this.getGlobalAlpha() < 1 / 255) {
+            // Fast path: don't draw fully transparent
+            return;
+        }
+        this.path2D.beginPath();
+        this.path2D.moveTo(startX, startY);
+        this.path2D.lineTo(endX, endY);
+        this.currentCompositor.drawVertices(this.gl.LINE_STRIP, this.path2D.points);
     }
 
 
@@ -947,25 +875,27 @@ class WebGLRenderer extends Renderer {
      * @param {boolean} [fill=false] also fill the shape with the current color if true
      */
     strokePolygon(poly, fill = false) {
-        if (fill === true ) {
-            this.fillPolygon(poly);
+        if (this.getGlobalAlpha() < 1 / 255) {
+            // Fast path: don't draw fully transparent
+            return;
+        }
+        this.translate(poly.pos.x, poly.pos.y);
+        this.path2D.beginPath();
+        this.path2D.moveTo(poly.points[0].x, poly.points[0].y);
+        var point;
+        for (var i = 1; i < poly.points.length; i++) {
+            point = poly.points[i];
+            this.path2D.lineTo(point.x, point.y);
+        }
+        this.path2D.lineTo(poly.points[0].x, poly.points[0].y);
+        this.path2D.closePath();
+        if (fill === false) {
+            this.currentCompositor.drawVertices(this.gl.LINE_LOOP, this.path2D.points);
         } else {
-            var len = poly.points.length,
-                points = this._glPoints,
-                i;
-
-            // Grow internal points buffer if necessary
-            for (i = points.length; i < len; i++) {
-                points.push(new Vector2d());
-            }
-
-            // calculate and draw all segments
-            for (i = 0; i < len; i++) {
-                points[i].x = poly.pos.x + poly.points[i].x;
-                points[i].y = poly.pos.y + poly.points[i].y;
-            }
-            this.currentCompositor.drawVertices(this.gl.LINE_LOOP, points, len);
+            // draw all triangles
+            this.currentCompositor.drawVertices(this.gl.TRIANGLES, this.path2D.triangulatePath());
         }
+        this.translate(-poly.pos.x, -poly.pos.y);
     }
 
     /**
@@ -976,24 +906,7 @@ class WebGLRenderer extends Renderer {
      * @param {Polygon} poly the shape to draw
      */
     fillPolygon(poly) {
-        var points = poly.points;
-        var glPoints = this._glPoints;
-        var indices = poly.getIndices();
-        var x = poly.pos.x, y = poly.pos.y;
-        var i;
-
-        // Grow internal points buffer if necessary
-        for (i = glPoints.length; i < indices.length; i++) {
-            glPoints.push(new Vector2d());
-        }
-
-        // calculate all vertices
-        for (i = 0; i < indices.length; i++ ) {
-            glPoints[i].set(x + points[indices[i]].x, y + points[indices[i]].y);
-        }
-
-        // draw all triangle
-        this.currentCompositor.drawVertices(this.gl.TRIANGLES, glPoints, indices.length);
+        this.strokePolygon(poly, true);
     }
 
     /**
@@ -1008,19 +921,16 @@ class WebGLRenderer extends Renderer {
      * @param {boolean} [fill=false] also fill the shape with the current color if true
      */
     strokeRect(x, y, width, height, fill = false) {
-        if (fill === true ) {
-            this.fillRect(x, y, width, height);
+        if (this.getGlobalAlpha() < 1 / 255) {
+            // Fast path: don't draw fully transparent
+            return;
+        }
+        this.path2D.beginPath();
+        this.path2D.rect(x, y, width, height);
+        if (fill === false) {
+            this.currentCompositor.drawVertices(this.gl.LINE_LOOP, this.path2D.points);
         } else {
-            var points = this._glPoints;
-            points[0].x = x;
-            points[0].y = y;
-            points[1].x = x + width;
-            points[1].y = y;
-            points[2].x = x + width;
-            points[2].y = y + height;
-            points[3].x = x;
-            points[3].y = y + height;
-            this.currentCompositor.drawVertices(this.gl.LINE_LOOP, points, 4);
+            this.currentCompositor.drawVertices(this.gl.TRIANGLES, this.path2D.triangulatePath());
         }
     }
 
@@ -1035,16 +945,49 @@ class WebGLRenderer extends Renderer {
      * @param {number} height
      */
     fillRect(x, y, width, height) {
-        var glPoints = this._glPoints;
-        glPoints[0].x = x + width;
-        glPoints[0].y = y;
-        glPoints[1].x = x;
-        glPoints[1].y = y;
-        glPoints[2].x = x + width;
-        glPoints[2].y = y + height;
-        glPoints[3].x = x;
-        glPoints[3].y = y + height;
-        this.currentCompositor.drawVertices(this.gl.TRIANGLE_STRIP, glPoints, 4);
+        this.strokeRect(x, y, width, height, true);
+    }
+
+    /**
+     * Stroke a rounded rectangle at the specified coordinates
+     * @name strokeRoundRect
+     * @memberof WebGLRenderer.prototype
+     * @function
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {number} radius
+     * @param {boolean} [fill=false] also fill the shape with the current color if true
+     */
+    strokeRoundRect(x, y, width, height, radius, fill = false) {
+        if (this.getGlobalAlpha() < 1 / 255) {
+            // Fast path: don't draw fully transparent
+            return;
+        }
+        this.path2D.beginPath();
+        this.path2D.roundRect(x, y, width, height, radius);
+        if (fill === false) {
+            this.currentCompositor.drawVertices(this.gl.LINE_LOOP, this.path2D.points);
+        } else {
+            this.path2D.closePath();
+            this.currentCompositor.drawVertices(this.gl.TRIANGLES, this.path2D.triangulatePath());
+        }
+    }
+
+    /**
+     * Draw a rounded filled rectangle at the specified coordinates
+     * @name fillRoundRect
+     * @memberof WebGLRenderer.prototype
+     * @function
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {number} radius
+     */
+    fillRoundRect(x, y, width, height, radius) {
+        this.strokeRoundRect(x, y, width, height, radius, true);
     }
 
     /**

package/src/particles/particlecontainer.js

@@ -1,95 +0,0 @@
-import Container from "./../renderable/container.js";
-import { viewport } from "./../game.js";
-
-/**
- * @classdesc
- * Particle Container Object.
- * @class ParticleContainer
- * @augments Container
- * @param {ParticleEmitter} emitter the emitter which owns this container
- */
-
-class ParticleContainer extends Container {
-
-    /**
-     * @ignore
-     */
-    constructor(emitter) {
-        // call the super constructor
-        super(
-            viewport.pos.x,
-            viewport.pos.y,
-            viewport.width,
-            viewport.height
-        );
-
-        // don't sort the particles by z-index
-        this.autoSort = false;
-
-        // count the updates
-        this._updateCount = 0;
-
-        // internally store how much time was skipped when frames are skipped
-        this._dt = 0;
-
-        // cache the emitter for later use
-        this._emitter = emitter;
-
-        this.autoTransform = false;
-
-        this.anchorPoint.set(0, 0);
-
-        this.isKinematic = true;
-    }
-
-    /**
-     * @ignore
-     */
-    update(dt) {
-        // skip frames if necessary
-        if (++this._updateCount > this._emitter.framesToSkip) {
-            this._updateCount = 0;
-        }
-        if (this._updateCount > 0) {
-            this._dt += dt;
-            return false;
-        }
-
-        // apply skipped delta time
-        dt += this._dt;
-        this._dt = 0;
-
-        // Update particles and remove them if they are dead
-        for (var i = this.children.length - 1; i >= 0; --i) {
-            var particle = this.children[i];
-            particle.inViewport = viewport.isVisible(particle, this.floating);
-            if (!particle.update(dt)) {
-                this.removeChildNow(particle);
-            }
-        }
-        return true;
-    }
-
-    /**
-     * @ignore
-     */
-    draw(renderer, rect) {
-        if (this.children.length > 0) {
-            var context = renderer.getContext(),
-                gco;
-            // Check for additive draw
-            if (this._emitter.textureAdditive) {
-                gco = context.globalCompositeOperation;
-                context.globalCompositeOperation = "lighter";
-            }
-
-            super.draw(renderer, rect);
-
-            // Restore globalCompositeOperation
-            if (this._emitter.textureAdditive) {
-                context.globalCompositeOperation = gco;
-            }
-        }
-    }
-};
-export default ParticleContainer;