melonjs 17.3.0 → 18.0.0

package/dist/melonjs.mjs/geometries/rectangle.js

@@ -1,330 +0,0 @@
-/*!
- * melonJS Game Engine - v17.3.0
- * http://www.melonjs.org
- * melonjs is licensed under the MIT License.
- * http://www.opensource.org/licenses/mit-license
- * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
- */
-import pool from '../system/pooling.js';
-import Polygon from './poly.js';
-
-/**
- * @classdesc
- * a rectangle Object
- * @augments Polygon
- */
-class Rect extends Polygon {
-    /**
-     * @param {number} x - position of the Rectangle
-     * @param {number} y - position of the Rectangle
-     * @param {number} w - width of the rectangle
-     * @param {number} h - height of the rectangle
-     */
-    constructor(x, y, w, h) {
-        // parent constructor
-        super(x, y, [
-            pool.pull("Vector2d", 0, 0), // 0, 0
-            pool.pull("Vector2d", w, 0), // 1, 0
-            pool.pull("Vector2d", w, h), // 1, 1
-            pool.pull("Vector2d", 0, h)  // 0, 1
-        ]);
-
-        /**
-         * the shape type (used internally)
-         * @type {string}
-         * @default "Rectangle"
-         */
-        this.type = "Rectangle";
-    }
-
-    /** @ignore */
-    onResetEvent(x, y, w, h) {
-        this.setShape(x, y, w, h);
-    }
-
-    /**
-     * set new value to the rectangle shape
-     * @param {number} x - position of the Rectangle
-     * @param {number} y - position of the Rectangle
-     * @param {number|Vector2d[]} w - width of the rectangle, or an array of vector defining the rectangle
-     * @param {number} [h] - height of the rectangle, if a numeral width parameter is specified
-     * @returns {Rect} this rectangle
-     */
-    setShape(x, y, w, h) {
-        let points = w; // assume w is an array by default
-
-        this.pos.set(x, y);
-
-        if (arguments.length === 4) {
-            points = this.points;
-            points[0].set(0, 0); // 0, 0
-            points[1].set(w, 0); // 1, 0
-            points[2].set(w, h); // 1, 1
-            points[3].set(0, h); // 0, 1
-        }
-
-        this.setVertices(points);
-        return this;
-    }
-
-
-    /**
-     * left coordinate of the Rectangle
-     * @type {number}
-     */
-    get left() {
-        return this.pos.x;
-    }
-
-    /**
-     * right coordinate of the Rectangle
-     * @type {number}
-     */
-    get right() {
-        let w = this.width;
-        return (this.left + w) || w;
-    }
-
-    /**
-     * top coordinate of the Rectangle
-     * @type {number}
-     */
-    get top() {
-        return this.pos.y;
-    }
-
-    /**
-     * bottom coordinate of the Rectangle
-     * @type {number}
-     */
-    get bottom() {
-        let h = this.height;
-        return (this.top + h) || h;
-    }
-
-    /**
-     * width of the Rectangle
-     * @type {number}
-     */
-    get width() {
-        return this.points[2].x;
-    }
-    set width(value) {
-        this.points[1].x = this.points[2].x = value;
-        this.recalc();
-        this.updateBounds();
-    }
-
-    /**
-     * height of the Rectangle
-     * @type {number}
-     */
-    get height() {
-        return this.points[2].y;
-    }
-    set height(value) {
-        this.points[2].y = this.points[3].y = value;
-        this.recalc();
-        this.updateBounds();
-    }
-
-    /**
-     * absolute center of this rectangle on the horizontal axis
-     * @type {number}
-     */
-    get centerX() {
-        if (isFinite(this.width)) {
-            return this.left + (this.width / 2);
-        } else {
-            return this.width;
-        }
-    }
-    set centerX (value) {
-        this.pos.x = value - (this.width / 2);
-        this.recalc();
-        this.updateBounds();
-    }
-
-    /**
-     * absolute center of this rectangle on the vertical axis
-     * @type {number}
-     */
-    get centerY() {
-        if (isFinite(this.height)) {
-            return this.top + (this.height / 2);
-        } else {
-            return this.height;
-        }
-    }
-    set centerY(value) {
-        this.pos.y = value - (this.height / 2);
-        this.recalc();
-        this.updateBounds();
-    }
-
-    /**
-     * center the rectangle position around the given coordinates
-     * @param {number} x - the x coordinate around which to center this rectangle
-     * @param {number} y - the y coordinate around which to center this rectangle
-     * @returns {Rect} this rectangle
-     */
-    centerOn(x, y) {
-        this.centerX = x;
-        this.centerY = y;
-        return this;
-    }
-
-    /**
-     * resize the rectangle
-     * @param {number} w - new width of the rectangle
-     * @param {number} h - new height of the rectangle
-     * @returns {Rect} this rectangle
-     */
-    resize(w, h) {
-        this.width = w;
-        this.height = h;
-        return this;
-    }
-
-    /**
-     * scale the rectangle
-     * @param {number} x - a number representing the abscissa of the scaling vector.
-     * @param {number} [y=x] - a number representing the ordinate of the scaling vector.
-     * @returns {Rect} this rectangle
-     */
-    scale(x, y = x) {
-        this.width *= x;
-        this.height *= y;
-        return this;
-    }
-
-    /**
-     * clone this rectangle
-     * @returns {Rect} new rectangle
-     */
-    clone() {
-        return new Rect(this.left, this.top, this.width, this.height);
-    }
-
-    /**
-     * copy the position and size of the given rectangle into this one
-     * @param {Rect} rect - Source rectangle
-     * @returns {Rect} new rectangle
-     */
-    copy(rect) {
-        return this.setShape(rect.left, rect.top, rect.width, rect.height);
-    }
-
-    /**
-     * merge this rectangle with another one
-     * @param {Rect} rect - other rectangle to union with
-     * @returns {Rect} the union(ed) rectangle
-     */
-    union(rect) {
-        let x1 = Math.min(this.left, rect.left);
-        let y1 = Math.min(this.top, rect.top);
-
-        this.resize(
-            Math.max(this.right, rect.right) - x1,
-            Math.max(this.bottom, rect.bottom) - y1
-        );
-
-        this.pos.set(x1, y1);
-
-        return this;
-    }
-
-    /**
-     * check if this rectangle is intersecting with the specified one
-     * @param {Rect} rect
-     * @returns {boolean} true if overlaps
-     */
-    overlaps(rect) {
-        return (
-            this.left < rect.right &&
-            rect.left < this.right &&
-            this.top < rect.bottom &&
-            rect.top < this.bottom
-        );
-    }
-
-    /**
-     * Returns true if the rectangle contains the given point or rectangle
-     * @param {number|Vector2d|Rect} x -  x coordinate or a vector point, or a rectangle to test
-     * @param {number} [y] - y coordinate
-     * @returns {boolean} True if the rectangle contain the given point or rectangle, otherwise false
-     * @example
-     * if (rect.contains(10, 10)) {
-     *   // do something
-     * }
-     * // or
-     * if (rect.contains(myVector2d)) {
-     *   // do something
-     * }
-     * if (rect.contains(myRect)) {
-     *   // do something
-     * }
-     */
-    contains() {
-        let arg0 = arguments[0];
-        let _x1, _x2, _y1, _y2;
-        if (arguments.length === 2) {
-            // x, y
-            _x1 = _x2 = arg0;
-            _y1 = _y2 = arguments[1];
-        } else {
-            // only Rect based objects define a top and bottom properties
-            if (typeof arg0.bottom === "number") {
-                // me.Rect
-                _x1 = arg0.left;
-                _x2 = arg0.right;
-                _y1 = arg0.top;
-                _y2 = arg0.bottom;
-            } else {
-                // vector
-                _x1 = _x2 = arg0.x;
-                _y1 = _y2 = arg0.y;
-            }
-        }
-        return (
-            _x1 >= this.left &&
-             _x2 <= this.right &&
-             _y1 >= this.top &&
-             _y2 <= this.bottom
-        );
-    }
-
-    /**
-     * check if this rectangle is identical to the specified one
-     * @param {Rect} rect
-     * @returns {boolean} true if equals
-     */
-    equals(rect) {
-        return (
-            rect.left === this.left &&
-            rect.right === this.right &&
-            rect.top === this.top &&
-            rect.bottom === this.bottom
-        );
-    }
-
-    /**
-     * determines whether all coordinates of this rectangle are finite numbers.
-     * @returns {boolean} false if all coordinates are positive or negative Infinity or NaN; otherwise, true.
-     */
-    isFinite() {
-        return (isFinite(this.left) && isFinite(this.top) && isFinite(this.width) && isFinite(this.height));
-    }
-
-    /**
-     * Returns a polygon whose edges are the same as this box.
-     * @returns {Polygon} a new Polygon that represents this rectangle.
-     */
-    toPolygon() {
-        return pool.pull("Polygon",
-            this.left, this.top, this.points
-        );
-    }
-}
-
-export { Rect as default };

package/dist/melonjs.mjs/geometries/roundrect.js

@@ -1,165 +0,0 @@
-/*!
- * melonJS Game Engine - v17.3.0
- * http://www.melonjs.org
- * melonjs is licensed under the MIT License.
- * http://www.opensource.org/licenses/mit-license
- * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
- */
-import Rect from './rectangle.js';
-
-// https://developer.chrome.com/blog/canvas2d/#round-rect
-
-/**
- * @classdesc
- * a rectangle object with rounded corners
- * @augments Rect
- */
-class RoundRect extends Rect {
-    /**
-     * @param {number} x - position of the rounded rectangle
-     * @param {number} y - position of the rounded rectangle
-     * @param {number} width - the rectangle width
-     * @param {number} height - the rectangle height
-     * @param {number} [radius=20] - the radius of the rounded corner
-     */
-    constructor(x, y, width, height, radius = 20) {
-        // parent constructor
-        super(x, y, width, height);
-
-        /**
-         * the shape type (used internally)
-         * @type {string}
-         * @default "RoundRect"
-         */
-        this.type = "RoundRect";
-
-        // set the corner radius
-        this.radius = radius;
-    }
-
-    /** @ignore */
-    onResetEvent(x, y, w, h, radius) {
-        super.setShape(x, y, w, h);
-        this.radius = radius;
-    }
-
-
-    /**
-     * the radius of the rounded corner
-     * @type {number}
-     * @default 20
-     */
-    get radius() {
-        return this._radius;
-    }
-    set radius(value) {
-        // verify the rectangle is at least as wide and tall as the rounded corners.
-        if (this.width < 2 * value) {
-            value = this.width / 2;
-        }
-        if (this.height < 2 * value) {
-            value = this.height / 2;
-        }
-        this._radius = value;
-    }
-
-    /**
-     * copy the position, size and radius of the given rounded rectangle into this one
-     * @param {RoundRect} rrect - source rounded rectangle
-     * @returns {RoundRect} new rectangle
-     */
-    copy(rrect) {
-        super.setShape(rrect.pos.x, rrect.pos.y, rrect.width, rrect.height);
-        this.radius = rrect.radius;
-        return this;
-    }
-
-    /**
-     * Returns true if the rounded rectangle contains the given point or rectangle
-     * @param {number|Vector2d|Rect} x -  x coordinate or a vector point, or a Rect to test
-     * @param {number} [y] - y coordinate
-     * @returns {boolean} True if the rounded rectangle contain the given point or rectangle, otherwise false
-     * @example
-     * if (rect.contains(10, 10)) {
-     *   // do something
-     * }
-     * // or
-     * if (rect.contains(myVector2d)) {
-     *   // do something
-     * }
-     * if (rect.contains(myRect)) {
-     *   // do something
-     * }
-     */
-    contains() {
-        let arg0 = arguments[0];
-        let _x, _y;
-        if (arguments.length === 2) {
-            // x, y
-            _x = arg0;
-            _y = arguments[1];
-        } else {
-            if ((typeof arg0.radius === "undefined") && (typeof arg0.bottom === "number")) {
-                // it's a rect
-                return super.contains(arg0);
-            } else {
-                // else a vector or point
-                _x = arg0.x;
-                _y = arg0.y;
-            }
-        }
-
-        // check whether point is outside the bounding box
-        if (_x < this.left || _x >= this.right || _y < this.top || _y >= this.bottom) {
-            return false; // outside bounding box
-        }
-
-        // check whether point is within the bounding box minus radius
-        if ((_x >= this.left + this.radius && _x <= this.right - this.radius) || (_y >= this.top + this.radius && _y <= this.bottom - this.radius)) {
-            return true;
-        }
-
-        // check whether point is in one of the rounded corner areas
-        let tx, ty;
-        const radiusX =  Math.max(0, Math.min(this.radius, this.width / 2));
-        const radiusY =  Math.max(0, Math.min(this.radius, this.height / 2));
-
-        if (_x < this.left + radiusX && _y < this.top + radiusY) {
-            tx = _x - this.left - radiusX;
-            ty = _y - this.top - radiusY;
-        } else if (_x > this.right - radiusX && _y < this.top + radiusY) {
-            tx = _x - this.right + radiusX;
-            ty = _y - this.top - radiusY;
-        } else if (_x > this.right - radiusX && _y > this.bottom - radiusY) {
-            tx = _x - this.right + radiusX;
-            ty = _y - this.bottom + radiusY;
-        } else if (_x < this.left + radiusX && _y > this.bottom - radiusY) {
-            tx = _x - this.left - radiusX;
-            ty = _y - this.bottom + radiusY;
-        } else {
-            return false; // inside and not within the rounded corner area
-        }
-
-        // Pythagorean theorem.
-        return ((tx * tx) + (ty * ty) <= (radiusX * radiusY));
-    }
-
-    /**
-     * check if this RoundRect is identical to the specified one
-     * @param {RoundRect} rrect
-     * @returns {boolean} true if equals
-     */
-    equals(rrect) {
-        return super.equals(rrect) && this.radius === rrect.radius;
-    }
-
-    /**
-     * clone this RoundRect
-     * @returns {RoundRect} new RoundRect
-     */
-    clone() {
-        return new RoundRect(this.pos.x, this.pos.y, this.width, this.height, this.radius);
-    }
-}
-
-export { RoundRect as default };

package/dist/melonjs.mjs/geometries/toarccanvas.js

@@ -1,103 +0,0 @@
-/*!
- * melonJS Game Engine - v17.3.0
- * http://www.melonjs.org
- * melonjs is licensed under the MIT License.
- * http://www.opensource.org/licenses/mit-license
- * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
- */
-import { degToRad, pow } from '../math/math.js';
-
-function correctRadii(signedRx, signedRy, x1p, y1p) {
-    const prx = Math.abs(signedRx);
-    const pry = Math.abs(signedRy);
-
-    const A = pow(x1p) / pow(prx) + pow(y1p) / pow(pry);
-
-    const rx = A > 1 ? Math.sqrt(A) * prx : prx;
-    const ry = A > 1 ? Math.sqrt(A) * pry : pry;
-
-    return [rx, ry];
-}
-
-function mat2DotVec2([m00, m01, m10, m11], [vx, vy]) {
-    return [m00 * vx + m01 * vy, m10 * vx + m11 * vy];
-}
-
-function vec2Add([ux, uy], [vx, vy]) {
-    return [ux + vx, uy + vy];
-}
-
-function vec2Scale([a0, a1], scalar) {
-    return [a0 * scalar, a1 * scalar];
-}
-
-function vec2Dot([ux, uy], [vx, vy]) {
-    return ux * vx + uy * vy;
-}
-
-function vec2Mag([ux, uy]) {
-    return Math.sqrt(ux ** 2 + uy ** 2);
-}
-
-function vec2Angle(u, v) {
-    const [ux, uy] = u;
-    const [vx, vy] = v;
-    const sign = ux * vy - uy * vx >= 0 ? 1 : -1;
-    return sign * Math.acos(vec2Dot(u, v) / (vec2Mag(u) * vec2Mag(v)));
-}
-
-// From https://svgwg.org/svg2-draft/implnote.html#ArcConversionEndpointToCenter
-function endpointToCenterParameterization(x1, y1, x2, y2, largeArcFlag, sweepFlag, srx, sry, xAxisRotationDeg) {
-    const xAxisRotation = degToRad(xAxisRotationDeg);
-
-    const cosphi = Math.cos(xAxisRotation);
-    const sinphi = Math.sin(xAxisRotation);
-
-    const [x1p, y1p] = mat2DotVec2(
-        [cosphi, sinphi, -sinphi, cosphi],
-        [(x1 - x2) / 2, (y1 - y2) / 2]
-    );
-
-    const [rx, ry] = correctRadii(srx, sry, x1p, y1p);
-
-    const sign = largeArcFlag !== sweepFlag ? 1 : -1;
-    const n = pow(rx) * pow(ry) - pow(rx) * pow(y1p) - pow(ry) * pow(x1p);
-    const d = pow(rx) * pow(y1p) + pow(ry) * pow(x1p);
-
-    const [cxp, cyp] = vec2Scale(
-        [(rx * y1p) / ry, (-ry * x1p) / rx],
-        sign * Math.sqrt(Math.abs(n / d))
-    );
-
-    const [cx, cy] = vec2Add(
-        mat2DotVec2([cosphi, -sinphi, sinphi, cosphi], [cxp, cyp]),
-        [(x1 + x2) / 2, (y1 + y2) / 2]
-    );
-
-    const a = [(x1p - cxp) / rx, (y1p - cyp) / ry];
-    const b = [(-x1p - cxp) / rx, (-y1p - cyp) / ry];
-    const startAngle = vec2Angle([1, 0], a);
-    const deltaAngle0 = vec2Angle(a, b) % (2 * Math.PI);
-
-    const deltaAngle =
-          !sweepFlag && deltaAngle0 > 0
-              ? deltaAngle0 - 2 * Math.PI
-              : sweepFlag && deltaAngle0 < 0
-                  ? deltaAngle0 + 2 * Math.PI
-                  : deltaAngle0;
-
-    const endAngle = startAngle + deltaAngle;
-
-    return {
-        cx,
-        cy,
-        rx,
-        ry,
-        startAngle,
-        endAngle,
-        xAxisRotation,
-        anticlockwise: deltaAngle < 0
-    };
-}
-
-export { endpointToCenterParameterization };