melonjs 14.4.0 → 14.5.0

package/dist/types/video/webgl/compositors/webgl_compositor.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @classdesc
+ * A WebGL Compositor object. This class handles all of the WebGL state<br>
+ * Pushes texture regions or shape geometry into WebGL buffers, automatically flushes to GPU
+ * @augments Compositor
+ */
+export default class WebGLCompositor extends Compositor {
+    currentTextureUnit: any;
+    boundTextures: any[] | undefined;
+    primitiveShader: GLShader | undefined;
+    quadShader: GLShader | undefined;
+    vertexBuffer: VertexArrayBuffer | undefined;
+    /**
+     * Create a WebGL texture from an image
+     * @param {number} unit - Destination texture unit
+     * @param {Image|HTMLCanvasElement|ImageData|Uint8Array[]|Float32Array[]} image - Source image
+     * @param {number} filter - gl.LINEAR or gl.NEAREST
+     * @param {string} [repeat="no-repeat"] - Image repeat behavior (see {@link ImageLayer#repeat})
+     * @param {number} [w] - Source image width (Only use with UInt8Array[] or Float32Array[] source image)
+     * @param {number} [h] - Source image height (Only use with UInt8Array[] or Float32Array[] source image)
+     * @param {number} [b] - Source image border (Only use with UInt8Array[] or Float32Array[] source image)
+     * @param {boolean} [premultipliedAlpha=true] - Multiplies the alpha channel into the other color channels
+     * @param {boolean} [mipmap=true] - Whether mipmap levels should be generated for this texture
+     * @returns {WebGLTexture} a WebGL texture
+     */
+    createTexture2D(unit: number, image: (new (width?: number | undefined, height?: number | undefined) => HTMLImageElement) | HTMLCanvasElement | ImageData | Uint8Array[] | Float32Array[], filter: number, repeat?: string | undefined, w?: number | undefined, h?: number | undefined, b?: number | undefined, premultipliedAlpha?: boolean | undefined, mipmap?: boolean | undefined): WebGLTexture;
+    /**
+     * delete the given WebGL texture
+     * @param {WebGLTexture} [texture] - a WebGL texture to delete
+     * @param {number} [unit] - Texture unit to delete
+     */
+    deleteTexture2D(texture?: WebGLTexture | undefined): void;
+    /**
+     * returns the WebGL texture associated to the given texture unit
+     * @param {number} unit - Texture unit to which a texture is bound
+     * @returns {WebGLTexture} texture a WebGL texture
+     */
+    getTexture2D(unit: number): WebGLTexture;
+    /**
+     * assign the given WebGL texture to the current batch
+     * @param {WebGLTexture} texture - a WebGL texture
+     * @param {number} unit - Texture unit to which the given texture is bound
+     */
+    bindTexture2D(texture: WebGLTexture, unit: number): void;
+    /**
+     * unbind the given WebGL texture, forcing it to be reuploaded
+     * @param {WebGLTexture} [texture] - a WebGL texture
+     * @param {number} [unit] - a WebGL texture
+     * @returns {number} unit the unit number that was associated with the given texture
+     */
+    unbindTexture2D(texture?: WebGLTexture | undefined, unit?: number | undefined): number;
+    /**
+     * @ignore
+     */
+    uploadTexture(texture: any, w: any, h: any, b: any, force?: boolean): any;
+    /**
+     * Select the shader to use for compositing
+     * @see GLShader
+     * @param {GLShader} shader - a reference to a GLShader instance
+     */
+    useShader(shader: GLShader): void;
+    /**
+     * Add a textured quad
+     * @param {TextureAtlas} texture - Source texture atlas
+     * @param {number} x - Destination x-coordinate
+     * @param {number} y - Destination y-coordinate
+     * @param {number} w - Destination width
+     * @param {number} h - Destination height
+     * @param {number} u0 - Texture UV (u0) value.
+     * @param {number} v0 - Texture UV (v0) value.
+     * @param {number} u1 - Texture UV (u1) value.
+     * @param {number} v1 - Texture UV (v1) value.
+     * @param {number} tint - tint color to be applied to the texture in UINT32 (argb) format
+     */
+    addQuad(texture: TextureAtlas, x: number, y: number, w: number, h: number, u0: number, v0: number, u1: number, v1: number, tint: number): void;
+    /**
+     * Draw an array of vertices
+     * @param {GLenum} mode - primitive type to render (gl.POINTS, gl.LINE_STRIP, gl.LINE_LOOP, gl.LINES, gl.TRIANGLE_STRIP, gl.TRIANGLE_FAN, gl.TRIANGLES)
+     * @param {Point[]} verts - an array of vertices
+     * @param {number} [vertexCount=verts.length] - amount of points defined in the points array
+     */
+    drawVertices(mode: GLenum, verts: Point[], vertexCount?: number | undefined): void;
+}
+import Compositor from "./compositor.js";
+import GLShader from "../glshader.js";
+import VertexArrayBuffer from "../buffer/vertex.js";

package/dist/types/video/webgl/webgl_compositor.d.ts

@@ -151,10 +151,10 @@ export default class WebGLCompositor {
     /**
      * Draw an array of vertices
      * @param {GLenum} mode - primitive type to render (gl.POINTS, gl.LINE_STRIP, gl.LINE_LOOP, gl.LINES, gl.TRIANGLE_STRIP, gl.TRIANGLE_FAN, gl.TRIANGLES)
-     * @param {Vector2d[]} verts - vertices
+     * @param {Point[]} verts - an array of vertices
      * @param {number} [vertexCount=verts.length] - amount of points defined in the points array
      */
-    drawVertices(mode: GLenum, verts: Vector2d[], vertexCount?: number | undefined): void;
+    drawVertices(mode: GLenum, verts: Point[], vertexCount?: number | undefined): void;
     /**
      * Clear the frame buffer
      * @param {number} [alpha = 0.0] - the alpha value used when clearing the framebuffer
@@ -171,4 +171,3 @@ export default class WebGLCompositor {
 }
 import GLShader from "./glshader.js";
 import VertexArrayBuffer from "./buffer/vertex.js";
-import Vector2d from "./../../math/vector2.js";

package/dist/types/video/webgl/webgl_renderer.d.ts

@@ -423,7 +423,7 @@ export default class WebGLRenderer extends Renderer {
 }
 import Renderer from "./../renderer.js";
 import Matrix2d from "./../../math/matrix2.js";
-import WebGLCompositor from "./webgl_compositor.js";
+import WebGLCompositor from "./compositors/webgl_compositor.js";
 import TextureCache from "./../texture/cache.js";
 import { TextureAtlas } from "./../texture/atlas.js";
 import Color from "./../../math/color.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "melonjs",
-  "version": "14.4.0",
+  "version": "14.5.0",
   "description": "melonJS Game Engine",
   "homepage": "http://www.melonjs.org/",
   "type": "module",
@@ -53,7 +53,7 @@
   ],
   "dependencies": {
     "@teppeis/multimaps": "^2.0.0",
-    "core-js": "^3.27.1",
+    "core-js": "^3.27.2",
     "earcut": "2.2.4",
     "eventemitter3": "^5.0.0",
     "howler": "2.2.3"
@@ -61,36 +61,37 @@
   "devDependencies": {
     "@babel/eslint-parser": "^7.19.1",
     "@babel/plugin-syntax-import-assertions": "^7.20.0",
-    "@fastify/static": "^6.6.0",
+    "@fastify/static": "^6.9.0",
     "@melonjs/webdoc-theme": "^1.1.1",
-    "@rollup/plugin-commonjs": "^24.0.0",
-    "@rollup/plugin-image": "^3.0.1",
+    "@rollup/plugin-commonjs": "^24.0.1",
+    "@rollup/plugin-image": "^3.0.2",
     "@rollup/plugin-node-resolve": "^15.0.1",
     "@rollup/plugin-replace": "^5.0.2",
     "@types/offscreencanvas": "^2019.7.0",
     "@webdoc/cli": "^2.2.0",
-    "chromedriver": "^108.0.0",
+    "chromedriver": "^110.0.0",
     "cross-env": "^7.0.3",
     "del-cli": "^5.0.0",
-    "eslint": "^8.31.0",
-    "eslint-plugin-jsdoc": "^39.6.4",
-    "expect": "^29.3.1",
+    "eslint": "^8.34.0",
+    "eslint-plugin-jsdoc": "^40.0.0",
+    "expect": "^29.4.2",
     "expect-mocha-image-snapshot": "^3.0.1",
-    "fastify": "^4.11.0",
+    "fastify": "^4.13.0",
     "mocha": "^10.2.0",
     "npm-self-link": "^1.1.7",
-    "puppeteer": "^19.5.0",
-    "rollup": "^3.9.1",
+    "puppeteer": "^19.6.3",
+    "rollup": "^3.15.0",
     "rollup-plugin-bundle-size": "^1.0.3",
     "rollup-plugin-string": "^3.0.0",
-    "terser": "^5.16.1",
-    "typescript": "^4.9.4"
+    "terser": "^5.16.3",
+    "typescript": "^4.9.5"
   },
   "scripts": {
     "build": "npm run lint && rollup -c --silent",
+    "build:cd": "npm run lint && rollup -c --failAfterWarnings",
     "dist": " npm run build && mkdirp dist && cp -fR build/*.* dist/ && npm run types",
     "lint": "eslint src/** rollup.config.mjs",
-    "pretest": "cp -f ./build/melonjs.module.js ./tests/browser/public/lib",
+    "pretest": "mkdirp tests/browser/public/lib && cp -f build/melonjs.module.js tests/browser/public/lib",
     "test": "npm run test-node && mocha ./tests/browser/spec/*.js --reporter spec --bail --timeout 10000",
     "test-node": "node build/melonjs.module.js",
     "doc-prod": "mkdirp docs && webdoc --quiet --site-root melonJS/docs -R README.md",

package/src/audio/audio.js

@@ -1,7 +1,7 @@
 // external import
 import {Howl, Howler} from "howler";
 import {clamp} from "./../math/math.js";
-import loader from "./../loader/loader.js";
+import { nocache, withCredentials} from "./../loader/settings.js";
 import { isDataUrl } from "./../utils/string.js";
 
 /**
@@ -154,7 +154,7 @@ export function load(sound, html5, onload_cb, onerror_cb) {
         urls.push(sound.src);
     } else {
         for (var i = 0; i < audioExts.length; i++) {
-            urls.push(sound.src + sound.name + "." + audioExts[i] + loader.nocache);
+            urls.push(sound.src + sound.name + "." + audioExts[i] + nocache);
         }
     }
 
@@ -162,7 +162,7 @@ export function load(sound, html5, onload_cb, onerror_cb) {
         src : urls,
         volume : Howler.volume(),
         html5 : html5 === true,
-        xhrWithCredentials : loader.withCredentials,
+        xhrWithCredentials : withCredentials,
         /**
          * @ignore
          */

package/src/entity/entity.js

@@ -53,10 +53,10 @@ import Body from "./../physics/body.js";
 
         // Update anchorPoint
         if (settings.anchorPoint) {
-            this.anchorPoint.set(settings.anchorPoint.x, settings.anchorPoint.y);
+            this.anchorPoint.setMuted(settings.anchorPoint.x, settings.anchorPoint.y);
         } else {
             // for backward compatibility
-            this.anchorPoint.set(0, 0);
+            this.anchorPoint.setMuted(0, 0);
         }
 
         // set the sprite name if specified
@@ -140,6 +140,7 @@ import Body from "./../physics/body.js";
         if (value instanceof Renderable) {
             this.children[0] = value;
             this.children[0].ancestor = this;
+            this.updateBounds();
         } else {
             throw new Error(value + "should extend me.Renderable");
         }
@@ -154,17 +155,50 @@ import Body from "./../physics/body.js";
     }
 
     /**
-     * update the bounds position when the body is modified
+     * update the bounding box for this entity.
+     * @param {boolean} [absolute=true] - update the bounds size and position in (world) absolute coordinates
+     * @returns {Bounds} this entity bounding box Rectangle object
+     */
+    updateBounds(absolute = true) {
+        var bounds = this.getBounds();
+
+        bounds.clear();
+        bounds.addFrame(
+            0,
+            0,
+            this.width,
+            this.height
+        );
+
+        // add each renderable bounds
+        if (this.children && this.children.length > 0) {
+            bounds.addBounds(this.children[0].getBounds());
+        }
+
+        if (this.body) {
+            bounds.addBounds(this.body.getBounds());
+        }
+
+        if (absolute === true) {
+            bounds.centerOn(this.pos.x + bounds.x + bounds.width / 2,  this.pos.y + bounds.y + bounds.height / 2);
+             if (typeof this.ancestor !== "undefined" && typeof this.ancestor.addChild === "function" && this.floating !== true) {
+                 bounds.translate(this.ancestor.getAbsolutePosition());
+             }
+
+        }
+
+        return bounds;
+    }
+
+    /**
+     * update the bounds when the body is modified
      * @ignore
      * @name onBodyUpdate
      * @memberof Entity
      * @param {Body} body - the body whose bounds to update
      */
-    onBodyUpdate(body) {
-        // update the entity bounds to include the body bounds
-        this.getBounds().addBounds(body.getBounds(), true);
-        // update the bounds pos
-        this.updateBoundsPos(this.pos.x, this.pos.y);
+    onBodyUpdate() {
+        this.updateBounds();
     }
 
     preDraw(renderer) {

package/src/geometries/ellipse.js

@@ -126,8 +126,7 @@ import pool from "./../system/pooling.js";
      * @param {number} [y=x]
      * @returns {Ellipse} Reference to this object for method chaining
      */
-    scale(x, y) {
-        y = typeof (y) !== "undefined" ? y : x;
+    scale(x, y = x) {
         return this.setShape(
             this.pos.x,
             this.pos.y,

package/src/geometries/path2d.js

@@ -10,20 +10,14 @@ import earcut from "earcut";
     constructor() {
         /**
          * the points defining the current path
-         * @public
-         * @type {Vector2d[]}
-         * @name points
-         * @memberof Path2D#
+         * @type {Point[]}
          */
         this.points = [];
 
         /**
          * space between interpolated points for quadratic and bezier curve approx. in pixels.
-         * @public
          * @type {number}
-         * @name arcResolution
          * @default 5
-         * @memberof Path2D#
          */
         this.arcResolution = 5;
 
@@ -33,8 +27,6 @@ import earcut from "earcut";
 
     /**
      * begin a new path
-     * @name beginPath
-     * @memberof Path2D
      */
     beginPath() {
         // empty the cache and recycle all vectors
@@ -48,21 +40,17 @@ import earcut from "earcut";
      * causes the point of the pen to move back to the start of the current path.
      * It tries to draw a straight line from the current point to the start.
      * If the shape has already been closed or has only one point, this function does nothing.
-     * @name closePath
-     * @memberof Path2D
      */
     closePath() {
         var points = this.points;
         if (points.length > 1 && !points[points.length-1].equals(points[0])) {
-            points.push(pool.pull("Vector2d", points[0].x, points[0].y));
+            points.push(pool.pull("Point", points[0].x, points[0].y));
         }
     }
 
     /**
      * triangulate the shape defined by this path into an array of triangles
-     * @name triangulatePath
-     * @memberof Path2D
-     * @returns {Vector2d[]}
+     * @returns {Point[]}
      */
     triangulatePath() {
         var i = 0;
@@ -70,13 +58,15 @@ import earcut from "earcut";
         var vertices = this.vertices;
         var indices = earcut(points.flatMap(p => [p.x, p.y]));
 
+        // pre-allocate vertices if necessary
+        while (vertices.length < indices.length) {
+            vertices.push(pool.pull("Point"));
+        }
+
         // calculate all vertices
         for (i = 0; i < indices.length; i++ ) {
-            if (typeof vertices[i] === "undefined") {
-                // increase cache buffer if necessary
-                vertices[i] = pool.pull("Vector2d");
-            }
-            vertices[i].set(points[indices[i]].x, points[indices[i]].y);
+            var point = points[indices[i]];
+            vertices[i].set(point.x, point.y);
         }
 
         // recycle overhead from a previous triangulation
@@ -90,31 +80,25 @@ import earcut from "earcut";
 
     /**
      * moves the starting point of the current path to the (x, y) coordinates.
-     * @name moveTo
-     * @memberof Path2D
      * @param {number} x - the x-axis (horizontal) coordinate of the point.
      * @param {number} y - the y-axis (vertical) coordinate of the point.
      */
     moveTo(x, y) {
-      this.points.push(pool.pull("Vector2d", x, y));
+      this.points.push(pool.pull("Point", x, y));
     }
 
     /**
      * connects the last point in the current patch to the (x, y) coordinates with a straight line.
-     * @name lineTo
-     * @memberof Path2D
      * @param {number} x - the x-axis coordinate of the line's end point.
      * @param {number} y - the y-axis coordinate of the line's end point.
      */
     lineTo(x, y) {
-        this.points.push(pool.pull("Vector2d", x, y));
+        this.points.push(pool.pull("Point", x, y));
     }
 
     /**
      * adds an arc to the current path which is centered at (x, y) position with the given radius,
      * starting at startAngle and ending at endAngle going in the given direction by counterclockwise (defaulting to clockwise).
-     * @name arc
-     * @memberof Path2D
      * @param {number} x - the horizontal coordinate of the arc's center.
      * @param {number} y - the vertical coordinate of the arc's center.
      * @param {number} radius - the arc's radius. Must be positive.
@@ -154,16 +138,14 @@ import earcut from "earcut";
 
         var angle = startAngle;
         for (var j = 0; j < nr_of_interpolation_points; j++) {
-            points.push(pool.pull("Vector2d", x + radius * Math.cos(angle), y + radius * Math.sin(angle)));
+            points.push(pool.pull("Point", x + radius * Math.cos(angle), y + radius * Math.sin(angle)));
             angle += direction * dangle;
         }
-        points.push(pool.pull("Vector2d", x + radius * Math.cos(endAngle), y + radius * Math.sin(endAngle)));
+        points.push(pool.pull("Point", x + radius * Math.cos(endAngle), y + radius * Math.sin(endAngle)));
     }
 
     /**
      * adds a circular arc to the path with the given control points and radius, connected to the previous point by a straight line.
-     * @name arcTo
-     * @memberof Path2D
      * @param {number} x1 - the x-axis coordinate of the first control point.
      * @param {number} y1 - the y-axis coordinate of the first control point.
      * @param {number} x2 - the x-axis coordinate of the second control point.
@@ -192,7 +174,7 @@ import earcut from "earcut";
         var tangent_point1 =  [x1 + a[0] * adj_l, y1 + a[1] * adj_l];
         var tangent_point2 =  [x1 + b[0] * adj_l, y1 + b[1] * adj_l];
 
-        points.push(pool.pull("Vector2d", tangent_point1[0], tangent_point1[1]));
+        points.push(pool.pull("Point", tangent_point1[0], tangent_point1[1]));
 
         var bisec = [(a[0] + b[0]) / 2.0, (a[1] + b[1]) / 2.0];
         var bisec_l = Math.sqrt(Math.pow(bisec[0], 2) + Math.pow(bisec[1], 2));
@@ -210,8 +192,6 @@ import earcut from "earcut";
     /**
      * adds an elliptical arc to the path which is centered at (x, y) position with the radii radiusX and radiusY
      * starting at startAngle and ending at endAngle going in the given direction by counterclockwise.
-     * @name ellipse
-     * @memberof Path2D
      * @param {number} x - the x-axis (horizontal) coordinate of the ellipse's center.
      * @param {number} y - the  y-axis (vertical) coordinate of the ellipse's center.
      * @param {number} radiusX - the ellipse's major-axis radius. Must be non-negative.
@@ -259,18 +239,16 @@ import earcut from "earcut";
             var _y1 = radiusY * Math.sin(angle);
             var _x2 = x + _x1 * cos_rotation - _y1 * sin_rotation;
             var _y2 = y + _x1 * sin_rotation + _y1 * cos_rotation;
-            points.push(pool.pull("Vector2d", _x2, _y2));
+            points.push(pool.pull("Point", _x2, _y2));
             angle += direction * dangle;
         }
         //var x1 = radiusX * Math.cos(endAngle);
         //var y1 = radiusY * Math.sin(endAngle);
-        //points.push(pool.pull("Vector2d", x + x1 * cos_rotation - y1 * sin_rotation, y + x1 * sin_rotation + y1 * cos_rotation));
+        //points.push(pool.pull("Point", x + x1 * cos_rotation - y1 * sin_rotation, y + x1 * sin_rotation + y1 * cos_rotation));
     }
 
     /**
      * creates a path for a rectangle at position (x, y) with a size that is determined by width and height.
-     * @name rect
-     * @memberof Path2D
      * @param {number} x - the x-axis coordinate of the rectangle's starting point.
      * @param {number} y - the y-axis coordinate of the rectangle's starting point.
      * @param {number} width - the rectangle's width. Positive values are to the right, and negative to the left.
@@ -286,8 +264,6 @@ import earcut from "earcut";
 
     /**
      * adds an rounded rectangle to the current path.
-     * @name roundRect
-     * @memberof Path2D
      * @param {number} x - the x-axis coordinate of the rectangle's starting point.
      * @param {number} y - the y-axis coordinate of the rectangle's starting point.
      * @param {number} width - the rectangle's width. Positive values are to the right, and negative to the left.

package/src/geometries/point.js

@@ -6,7 +6,6 @@
     constructor(x = 0, y = 0) {
         /**
          * the position of the point on the horizontal axis
-         * @public
          * @type {Number}
          * @default 0
          */
@@ -14,7 +13,6 @@
 
         /**
          * the position of the point on the vertical axis
-         * @public
          * @type {Number}
          * @default 0
          */
@@ -48,8 +46,6 @@
      */
     /**
      * return true if this point is equal to the given values
-     * @name equals
-     * @memberof Point
      * @param {number} x
      * @param {number} y
      * @returns {boolean}
@@ -70,7 +66,6 @@
 
     /**
      * clone this Point
-     * @name clone
      * @returns {Point} new Point
      */
     clone() {

package/src/geometries/poly.js

@@ -200,9 +200,7 @@ import pool from "./../system/pooling.js";
      * @param {number} [y=x]
      * @returns {Polygon} Reference to this object for method chaining
      */
-    scale(x, y) {
-        y = typeof (y) !== "undefined" ? y : x;
-
+    scale(x, y = x) {
         var points = this.points;
         var len = points.length;
         for (var i = 0; i < len; i++) {
@@ -458,7 +456,6 @@ import pool from "./../system/pooling.js";
 
     /**
      * update the bounding box for this shape.
-     * @ignore
      * @name updateBounds
      * @memberof Polygon
      * @returns {Bounds} this shape bounding box Rectangle object

package/src/geometries/rectangle.js

@@ -77,7 +77,7 @@ import Polygon from "./poly.js";
      */
     get right() {
         var w = this.width;
-        return (this.pos.x + w) || w;
+        return (this.left + w) || w;
     }
 
     /**
@@ -100,7 +100,7 @@ import Polygon from "./poly.js";
      */
     get bottom() {
         var h = this.height;
-        return (this.pos.y + h) || h;
+        return (this.top + h) || h;
     }
 
     /**
@@ -144,13 +144,15 @@ import Polygon from "./poly.js";
      */
     get centerX() {
         if (isFinite(this.width)) {
-            return this.pos.x + (this.width / 2);
+            return this.left + (this.width / 2);
         } else {
             return this.width;
         }
     }
     set centerX (value) {
         this.pos.x = value - (this.width / 2);
+        this.recalc();
+        this.updateBounds();
     }
 
     /**
@@ -162,13 +164,15 @@ import Polygon from "./poly.js";
      */
     get centerY() {
         if (isFinite(this.height)) {
-            return this.pos.y + (this.height / 2);
+            return this.top + (this.height / 2);
         } else {
             return this.height;
         }
     }
     set centerY(value) {
         this.pos.y = value - (this.height / 2);
+        this.recalc();
+        this.updateBounds();
     }
 
     /**
@@ -220,7 +224,7 @@ import Polygon from "./poly.js";
      * @returns {Rect} new rectangle
      */
     clone() {
-        return new Rect(this.pos.x, this.pos.y, this.width, this.height);
+        return new Rect(this.left, this.top, this.width, this.height);
     }
 
     /**
@@ -231,7 +235,7 @@ import Polygon from "./poly.js";
      * @returns {Rect} new rectangle
      */
     copy(rect) {
-        return this.setShape(rect.pos.x, rect.pos.y, rect.width, rect.height);
+        return this.setShape(rect.left, rect.top, rect.width, rect.height);
     }
 
     /**
@@ -348,7 +352,7 @@ import Polygon from "./poly.js";
      * @returns {boolean} false if all coordinates are positive or negative Infinity or NaN; otherwise, true.
      */
     isFinite() {
-        return (isFinite(this.pos.x) && isFinite(this.pos.y) && isFinite(this.width) && isFinite(this.height));
+        return (isFinite(this.left) && isFinite(this.top) && isFinite(this.width) && isFinite(this.height));
     }
 
     /**
@@ -359,7 +363,7 @@ import Polygon from "./poly.js";
      */
     toPolygon() {
         return pool.pull("Polygon",
-            this.pos.x, this.pos.y, this.points
+            this.left, this.top, this.points
         );
     }
 }

package/src/index.js

@@ -20,7 +20,7 @@ import Body from "./physics/body.js";
 import Bounds from "./physics/bounds.js";
 import Tween from "./tweens/tween.js";
 import GLShader from "./video/webgl/glshader.js";
-import WebGLCompositor from "./video/webgl/webgl_compositor.js";
+import WebGLCompositor from "./video/webgl/compositors/webgl_compositor.js";
 import Renderer from "./video/renderer.js";
 import WebGLRenderer from "./video/webgl/webgl_renderer.js";
 import CanvasRenderer from "./video/canvas/canvas_renderer.js";
@@ -67,7 +67,7 @@ import * as audio from "./audio/audio.js";
 import collision from "./physics/collision.js";
 import * as event from "./system/event.js";
 import * as device from "./system/device.js";
-import loader from "./loader/loader.js";
+import * as loader from "./loader/loader.js";
 import * as Math from "./math/math.js";
 import utils from "./utils/utils.js";
 import * as input from "./input/input.js";

package/src/input/gamepad.js

@@ -55,23 +55,17 @@ var leadingZeroRE = /^0+/;
  * @ignore
  */
 function addMapping(id, mapping) {
-    var expanded_id = id.replace(vendorProductRE, (_, a, b) => {
-        return (
-            "000".slice(a.length - 1) + a + "-" +
-            "000".slice(b.length - 1) + b + "-"
-        );
-    });
-    var sparse_id = id.replace(vendorProductRE, (_, a, b) => {
-        return (
-            a.replace(leadingZeroRE, "") + "-" +
-            b.replace(leadingZeroRE, "") + "-"
-        );
-    });
+    var expanded_id = id.replace(vendorProductRE, (_, a, b) =>
+        "000".slice(a.length - 1) + a + "-" +
+        "000".slice(b.length - 1) + b + "-"
+    );
+    var sparse_id = id.replace(vendorProductRE, (_, a, b) =>
+        a.replace(leadingZeroRE, "") + "-" +
+        b.replace(leadingZeroRE, "") + "-"
+    );
 
     // Normalize optional parameters
-    mapping.analog = mapping.analog || mapping.buttons.map(() => {
-        return -1;
-    });
+    mapping.analog = mapping.analog || mapping.buttons.map(() => -1);
     mapping.normalize_fn = mapping.normalize_fn || function (value) { return value; };
 
     remap.set(expanded_id, mapping);