melonjs 10.7.1 → 10.8.0

package/src/video/webgl/utils/uniforms.js

@@ -0,0 +1,87 @@
+
+/**
+ * Hash map of GLSL data types to WebGL Uniform methods
+ * @ignore
+ */
+const fnHash = {
+    "bool"      : "1i",
+    "int"       : "1i",
+    "float"     : "1f",
+    "vec2"      : "2fv",
+    "vec3"      : "3fv",
+    "vec4"      : "4fv",
+    "bvec2"     : "2iv",
+    "bvec3"     : "3iv",
+    "bvec4"     : "4iv",
+    "ivec2"     : "2iv",
+    "ivec3"     : "3iv",
+    "ivec4"     : "4iv",
+    "mat2"      : "Matrix2fv",
+    "mat3"      : "Matrix3fv",
+    "mat4"      : "Matrix4fv",
+    "sampler2D" : "1i"
+};
+
+/**
+ * @ignore
+ */
+export function extractUniforms(gl, shader) {
+    var uniforms = {},
+        uniRx = /uniform\s+(\w+)\s+(\w+)/g,
+        uniformsData = {},
+        descriptor = {},
+        locations = {},
+        match;
+
+    // Detect all uniform names and types
+    [ shader.vertex, shader.fragment ].forEach(function (shader) {
+        while ((match = uniRx.exec(shader))) {
+            uniformsData[match[2]] = match[1];
+        }
+    });
+
+    // Get uniform references
+    Object.keys(uniformsData).forEach(function (name) {
+        var type = uniformsData[name];
+        locations[name] = gl.getUniformLocation(shader.program, name);
+
+        descriptor[name] = {
+            "get" : (function (name) {
+                /**
+                 * A getter for the uniform location
+                 * @ignore
+                 */
+                return function () {
+                    return locations[name];
+                };
+            })(name),
+            "set" : (function (name, type, fn) {
+                if (type.indexOf("mat") === 0) {
+                    /**
+                     * A generic setter for uniform matrices
+                     * @ignore
+                     */
+                    return function (val) {
+                        gl[fn](locations[name], false, val);
+                    };
+                }
+                else {
+                    /**
+                     * A generic setter for uniform vectors
+                     * @ignore
+                     */
+                    return function (val) {
+                        var fnv = fn;
+                        if (val.length && fn.substr(-1) !== "v") {
+                            fnv += "v";
+                        }
+                        gl[fnv](locations[name], val);
+                    };
+                }
+            })(name, type, "uniform" + fnHash[type])
+        };
+    });
+    Object.defineProperties(uniforms, descriptor);
+
+    return uniforms;
+};

package/src/video/webgl/webgl_compositor.js

@@ -384,20 +384,7 @@ class WebGLCompositor {
             this.activeShader = shader;
             this.activeShader.bind();
             this.activeShader.setUniform("uProjectionMatrix", this.renderer.projectionMatrix);
-
-            // set the vertex attributes
-            for (var index = 0; index < this.attributes.length; ++index) {
-                var gl = this.gl;
-                var element = this.attributes[index];
-                var location = this.activeShader.getAttribLocation(element.name);
-
-                if (location !== -1) {
-                    gl.enableVertexAttribArray(location);
-                    gl.vertexAttribPointer(location, element.size, element.type, element.normalized, this.vertexByteSize, element.offset);
-                } else {
-                    gl.disableVertexAttribArray(index);
-                }
-            }
+            this.activeShader.setVertexAttributes(this.gl, this.attributes, this.vertexByteSize);
         }
     }
 

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();
@@ -721,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.
@@ -759,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());
         }
     }
 
@@ -802,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);
     }
 
     /**
@@ -845,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());
         }
     }
 
@@ -881,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);
     }
 
     /**
@@ -916,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);
     }
 
 
@@ -948,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);
     }
 
     /**
@@ -977,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);
     }
 
     /**
@@ -1009,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());
         }
     }
 
@@ -1036,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);
     }
 
     /**