melonjs 17.4.0 → 18.0.0

package/dist/types/application/settings.d.ts

@@ -1,106 +0,0 @@
-/**
- * Application & Renderer Settings definition.
- */
-export type ApplicationSettings = {
-    /**
-     * - the DOM parent element to hold the canvas in the HTML file
-     */
-    parent?: string | HTMLElement | undefined;
-    /**
-     * - an existing canvas element to use as the renderer target (by default melonJS will create its own canvas based on given parameters)
-     */
-    canvas?: HTMLCanvasElement | undefined;
-    /**
-     * - renderer to use (CANVAS, WEBGL, AUTO), or a custom renderer class
-     */
-    renderer?: number | Renderer | undefined;
-    /**
-     * - enable scaling of the canvas ('auto' for automatic scaling)
-     */
-    scale?: string | number | undefined;
-    /**
-     * - screen scaling modes : <br>
-     * - <i><b>`fit`</b></i> : Letterboxed; content is scaled to design aspect ratio <br>
-     * <center><img src="images/scale-fit.png"/></center><br>
-     * - <i><b>`fill-min`</b></i> : Canvas is resized to fit minimum design resolution; content is scaled to design aspect ratio <br>
-     * <center><img src="images/scale-fill-min.png"/></center><br>
-     * - <i><b>`fill-max`</b></i> : Canvas is resized to fit maximum design resolution; content is scaled to design aspect ratio <br>
-     * <center><img src="images/scale-fill-max.png"/></center><br>
-     * - <i><b>`flex`</b><</i> : Canvas width & height is resized to fit; content is scaled to design aspect ratio <br>
-     * <center><img src="images/scale-flex.png"/></center><br>
-     * - <i><b>`flex-width`</b></i> : Canvas width is resized to fit; content is scaled to design aspect ratio <br>
-     * <center><img src="images/scale-flex-width.png"/></center><br>
-     * - <i><b>`flex-height`</b></i> : Canvas height is resized to fit; content is scaled to design aspect ratio <br>
-     * <center><img src="images/scale-flex-height.png"/></center><br>
-     * - <i><b>`stretch`</b></i> : Canvas is resized to fit; content is scaled to screen aspect ratio <br>
-     * <center><img src="images/scale-stretch.png"/></center>
-     */
-    scaleMethod?: "flex" | "fit" | "fill-min" | "fill-max" | "flex-width" | "flex-height" | "stretch" | undefined;
-    /**
-     * - the HTML Element to be used as the reference target when using automatic scaling (by default melonJS will use the parent container of the div element containing the canvas)
-     */
-    scaleTarget?: string | HTMLElement | undefined;
-    /**
-     * - if true the renderer will only use WebGL 1
-     */
-    preferWebGL1?: boolean | undefined;
-    /**
-     * - ~Experimental~ the default method to sort object on the z axis in WebGL
-     */
-    depthTest?: "sorting" | "z-buffer" | undefined;
-    /**
-     * - a hint to the user agent indicating what configuration of GPU is suitable for the WebGL context. To be noted that Safari and Chrome (since version 80) both default to "low-power" to save battery life and improve the user experience on these dual-GPU machines.
-     */
-    powerPreference?: "default" | "high-performance" | "low-power" | undefined;
-    /**
-     * - whether to allow transparent pixels in the front buffer (screen).
-     */
-    transparent?: boolean | undefined;
-    /**
-     * - whether to enable or not video scaling interpolation
-     */
-    antiAlias?: boolean | undefined;
-    /**
-     * - whether to display melonJS version and basic device information in the console
-     */
-    consoleHeader?: boolean | undefined;
-    /**
-     * - The actual width of the canvas with scaling applied
-     */
-    zoomX?: number | undefined;
-    /**
-     * - The actual height of the canvas with scaling applied
-     */
-    zoomY?: number | undefined;
-    /**
-     * - a custom compositor class (WebGL only)
-     */
-    compositor?: any;
-    /**
-     * - the physic system to use (default: "builtin", or "none" to disable builtin physic)
-     */
-    physic?: string | undefined;
-};
-export namespace ApplicationSettings {
-    let parent: undefined;
-    let canvas: undefined;
-    let renderer: number;
-    let autoScale: boolean;
-    let scale: number;
-    let scaleMethod: string;
-    let scaleTarget: undefined;
-    let preferWebGL1: boolean;
-    let depthTest: string;
-    let powerPreference: string;
-    let transparent: boolean;
-    let antiAlias: boolean;
-    let consoleHeader: boolean;
-    let premultipliedAlpha: boolean;
-    let blendMode: string;
-    let physic: string;
-    let failIfMajorPerformanceCaveat: boolean;
-    let subPixel: boolean;
-    let verbose: boolean;
-    let legacy: boolean;
-}
-import type Renderer from "./../video/renderer.js";

package/dist/types/const.d.ts

@@ -1,21 +0,0 @@
-/**
- * constant to select the HTML5 Canvas renderer
- * @type {number}
- * @static
- * @see Application
- */
-export const CANVAS: number;
-/**
- * constant to select select the WebGL renderer
- * @type {number}
- * @static
- * @see Application
- */
-export const WEBGL: number;
-/**
- * constant to auto-select the renderer (Attempt WebGL first, with fallback to Canvas)
- * @static
- * @type {number}
- * @see Application
- */
-export const AUTO: number;

package/dist/types/geometries/ellipse.d.ts

@@ -1,138 +0,0 @@
-/**
- * additional import for TypeScript
- * @import Vector2d from "./../math/vector2.js";
- * @import ObservableVector2d from "./../math/observable_vector2.js";
- * @import Matrix2d from "./../math/matrix2.js";
- * @import Bounds from "./../physics/bounds.js";
- */
-/**
- * @classdesc
- * an ellipse Object
- */
-export default class Ellipse {
-    /**
-     * @param {number} x - the center x coordinate of the ellipse
-     * @param {number} y - the center y coordinate of the ellipse
-     * @param {number} w - width (diameter) of the ellipse
-     * @param {number} h - height (diameter) of the ellipse
-     */
-    constructor(x: number, y: number, w: number, h: number);
-    /**
-     * the center coordinates of the ellipse
-     * @public
-     * @type {Vector2d}
-     */
-    public pos: Vector2d;
-    /**
-     * The bounding rectangle for this shape
-     * @private
-     */
-    private _bounds;
-    /**
-     * Maximum radius of the ellipse
-     * @public
-     * @type {number}
-     */
-    public radius: number;
-    /**
-     * Pre-scaled radius vector for ellipse
-     * @public
-     * @type {Vector2d}
-     */
-    public radiusV: Vector2d;
-    /**
-     * Radius squared, for pythagorean theorom
-     * @public
-     * @type {Vector2d}
-     */
-    public radiusSq: Vector2d;
-    /**
-     * x/y scaling ratio for ellipse
-     * @public
-     * @type {Vector2d}
-     */
-    public ratio: Vector2d;
-    /**
-     * the shape type (used internally)
-     * @type {string}
-     * @default "Ellipse"
-     */
-    type: string;
-    /** @ignore */
-    onResetEvent(x: any, y: any, w: any, h: any): void;
-    /**
-     * set new value to the Ellipse shape
-     * @param {number} x - the center x coordinate of the ellipse
-     * @param {number} y - the center y coordinate of the ellipse
-     * @param {number} w - width (diameter) of the ellipse
-     * @param {number} h - height (diameter) of the ellipse
-     * @returns {Ellipse} this instance for objecf chaining
-     */
-    setShape(x: number, y: number, w: number, h: number): Ellipse;
-    /**
-     * Rotate this Ellipse (counter-clockwise) by the specified angle (in radians).
-     * @param {number} angle - The angle to rotate (in radians)
-     * @param {Vector2d|ObservableVector2d} [v] - an optional point to rotate around
-     * @returns {Ellipse} Reference to this object for method chaining
-     */
-    rotate(angle: number, v?: Vector2d | ObservableVector2d | undefined): Ellipse;
-    /**
-     * Scale this Ellipse by the specified scalar.
-     * @param {number} x - the scale factor along the x-axis
-     * @param {number} [y=x] - the scale factor along the y-axis
-     * @returns {Ellipse} Reference to this object for method chaining
-     */
-    scale(x: number, y?: number | undefined): Ellipse;
-    /**
-     * Scale this Ellipse by the specified vector.
-     * @param {Vector2d} v
-     * @returns {Ellipse} Reference to this object for method chaining
-     */
-    scaleV(v: Vector2d): Ellipse;
-    /**
-     * apply the given transformation matrix to this ellipse
-     * @param {Matrix2d} matrix - the transformation matrix
-     * @returns {Ellipse} Reference to this object for method chaining
-     */
-    transform(matrix: Matrix2d): Ellipse;
-    /**
-     * translate the circle/ellipse by the specified offset
-     * @param {number|Vector2d} x -  x coordinate or a vector point to translate by
-     * @param {number} [y] - y offset
-     * @returns {Ellipse} this ellipse
-     * @example
-     * ellipse.translate(10, 10);
-     * // or
-     * ellipse.translate(myVector2d);
-     */
-    translate(...args: any[]): Ellipse;
-    /**
-     * check if this circle/ellipse contains the specified point
-     * @param {number|Vector2d} x -  x coordinate or a vector point to check
-     * @param {number} [y] -  y coordinate
-     * @returns {boolean} true if contains
-     * @example
-     * if (circle.contains(10, 10)) {
-     *   // do something
-     * }
-     * // or
-     * if (circle.contains(myVector2d)) {
-     *  // do something
-     * }
-     */
-    contains(...args: any[]): boolean;
-    /**
-     * returns the bounding box for this shape, the smallest Rectangle object completely containing this shape.
-     * @returns {Bounds} this shape bounding box Rectangle object
-     */
-    getBounds(): Bounds;
-    /**
-     * clone this Ellipse
-     * @returns {Ellipse} new Ellipse
-     */
-    clone(): Ellipse;
-}
-import type Vector2d from "./../math/vector2.js";
-import type ObservableVector2d from "./../math/observable_vector2.js";
-import type Matrix2d from "./../math/matrix2.js";
-import type Bounds from "./../physics/bounds.js";

package/dist/types/geometries/line.d.ts

@@ -1,15 +0,0 @@
-/**
- * additional import for TypeScript
- * @import Vector2d from "./../math/vector2d.js";
- */
-/**
- * @classdesc
- * a line segment Object
- * @augments Polygon
- * @param {number} x - origin point of the Line
- * @param {number} y - origin point of the Line
- * @param {Vector2d[]} points - array of vectors defining the Line
- */
-export default class Line extends Polygon {
-}
-import Polygon from "./poly.js";

package/dist/types/geometries/point.d.ts

@@ -1,50 +0,0 @@
-/**
- * additional import for TypeScript
- * @import Vector2d from "./../math/vector2.js";
- **/
-/**
- * @classdesc
- * represents a point in a 2d space
- */
-export default class Point {
-    constructor(x?: number, y?: number);
-    /**
-     * the position of the point on the horizontal axis
-     * @type {number}
-     * @default 0
-     */
-    x: number;
-    /**
-     * the position of the point on the vertical axis
-     * @type {number}
-     * @default 0
-     */
-    y: number;
-    /**
-     * the shape type (used internally)
-     * @type {string}
-     * @default "Point"
-     */
-    type: string;
-    /** @ignore */
-    onResetEvent(x?: number, y?: number): void;
-    /**
-     * set the Point x and y properties to the given values
-     * @param {number} x
-     * @param {number} y
-     * @returns {Point} Reference to this object for method chaining
-     */
-    set(x?: number, y?: number): Point;
-    /**
-     * return true if this point is equal to the given point
-     * @param {number|Point|Vector2d} x
-     * @param {number} [y]
-     * @returns {boolean}
-     */
-    equals(...args: any[]): boolean;
-    /**
-     * clone this Point
-     * @returns {Point} new Point
-     */
-    clone(): Point;
-}

package/dist/types/geometries/poly.d.ts

@@ -1,186 +0,0 @@
-/**
- * additional import for TypeScript
- * @import Vector2d from "./../math/vector2.js";
- * @import ObservableVector2d from "./../math/observable_vector2.js";
- * @import Matrix2d from "./../math/matrix2.js";
- * @import Bounds from "./../physics/bounds.js";
- */
-/**
- * @classdesc
- * a polygon Object.<br>
- * Please do note that melonJS implements a simple Axis-Aligned Boxes collision algorithm, which requires all polygons used for collision to be convex with all vertices defined with clockwise winding.
- * A polygon is convex when all line segments connecting two points in the interior do not cross any edge of the polygon
- * (which means that all angles are less than 180 degrees), as described here below : <br>
- * <center><img src="images/convex_polygon.png"/></center><br>
- * A polygon's `winding` is clockwise if its vertices (points) are declared turning to the right. The image above shows COUNTERCLOCKWISE winding.
- */
-export default class Polygon {
-    /**
-     * @param {number} [x=0] - origin point of the Polygon
-     * @param {number} [y=0] - origin point of the Polygon
-     * @param {Vector2d[]} points - array of vector defining the Polygon
-     */
-    constructor(x?: number | undefined, y?: number | undefined, points: Vector2d[]);
-    /**
-     * origin point of the Polygon
-     * @type {Vector2d}
-     */
-    pos: Vector2d;
-    /**
-     * Array of points defining the Polygon <br>
-     * Note: If you manually change `points`, you **must** call `recalc`afterwards so that the changes get applied correctly.
-     * @type {Vector2d[]}
-     */
-    points: Vector2d[];
-    /**
-     * The edges here are the direction of the `n`th edge of the polygon, relative to
-     * the `n`th point. If you want to draw a given edge from the edge value, you must
-     * first translate to the position of the starting point.
-     * @ignore
-     */
-    edges: any[];
-    /**
-     * a list of indices for all vertices composing this polygon (@see earcut)
-     * @ignore
-     */
-    indices: any[];
-    /**
-     * The normals here are the direction of the normal for the `n`th edge of the polygon, relative
-     * to the position of the `n`th point. If you want to draw an edge normal, you must first
-     * translate to the position of the starting point.
-     * @ignore
-     */
-    normals: any[];
-    /**
-     * the shape type (used internally)
-     * @type {string}
-     * @default "Polygon"
-     */
-    type: string;
-    /** @ignore */
-    onResetEvent(x: any, y: any, points: any): void;
-    /**
-     * set new value to the Polygon
-     * @param {number} x - position of the Polygon
-     * @param {number} y - position of the Polygon
-     * @param {Vector2d[]|number[]} points - array of vector or vertice defining the Polygon
-     * @returns {Polygon} this instance for objecf chaining
-     */
-    setShape(x: number, y: number, points: Vector2d[] | number[]): Polygon;
-    /**
-     * set the vertices defining this Polygon
-     * @param {Vector2d[]} vertices - array of vector or vertice defining the Polygon
-     * @returns {Polygon} this instance for objecf chaining
-     */
-    setVertices(vertices: Vector2d[]): Polygon;
-    /**
-     * apply the given transformation matrix to this Polygon
-     * @param {Matrix2d} m - the transformation matrix
-     * @returns {Polygon} Reference to this object for method chaining
-     */
-    transform(m: Matrix2d): Polygon;
-    /**
-     * apply an isometric projection to this shape
-     * @returns {Polygon} Reference to this object for method chaining
-     */
-    toIso(): Polygon;
-    /**
-     * apply a 2d projection to this shapen
-     * @returns {Polygon} Reference to this object for method chaining
-     */
-    to2d(): Polygon;
-    /**
-     * Rotate this Polygon (counter-clockwise) by the specified angle (in radians).
-     * @param {number} angle - The angle to rotate (in radians)
-     * @param {Vector2d|ObservableVector2d} [v] - an optional point to rotate around
-     * @returns {Polygon} Reference to this object for method chaining
-     */
-    rotate(angle: number, v?: Vector2d | ObservableVector2d | undefined): Polygon;
-    /**
-     * Scale this Polygon by the given scalar.
-     * @param {number} x
-     * @param {number} [y=x]
-     * @returns {Polygon} Reference to this object for method chaining
-     */
-    scale(x: number, y?: number | undefined): Polygon;
-    /**
-     * Scale this Polygon by the given vector
-     * @param {Vector2d} v
-     * @returns {Polygon} Reference to this object for method chaining
-     */
-    scaleV(v: Vector2d): Polygon;
-    /**
-     * Computes the calculated collision polygon.
-     * This **must** be called if the `points` array, `angle`, or `offset` is modified manually.
-     * @returns {Polygon} Reference to this object for method chaining
-     */
-    recalc(): Polygon;
-    /**
-     * returns a list of indices for all triangles defined in this polygon
-     * @returns {Array.<number>} an array of vertex indices for all triangles forming this polygon.
-     */
-    getIndices(): Array<number>;
-    /**
-     * Returns true if the vertices composing this polygon form a convex shape (vertices must be in clockwise order).
-     * @returns {boolean} true if the vertices are convex, false if not, null if not computable
-     */
-    isConvex(): boolean;
-    /**
-     * translate the Polygon by the specified offset
-     * @param {number|Vector2d} x -  x offset or a vector point to translate by
-     * @param {number} [y] - y offset
-     * @returns {Polygon} Reference to this object for method chaining
-     * @example
-     * polygon.translate(10, 10);
-     * // or
-     * polygon.translate(myVector2d);
-     */
-    translate(...args: any[]): Polygon;
-    /**
-     * Shifts the Polygon to the given position vector.
-     * @param {number|Vector2d} x -  x coordinate or a vector point to shift to
-     * @param {number} [y]
-     * @example
-     * polygon.shift(10, 10);
-     * // or
-     * polygon.shift(myVector2d);
-     */
-    shift(...args: any[]): void;
-    /**
-     * Returns true if the polygon contains the given point. <br>
-     * (Note: it is highly recommended to first do a hit test on the corresponding <br>
-     *  bounding rect, as the function can be highly consuming with complex shapes)
-     * @param {number|Vector2d} x -  x coordinate or a vector point to check
-     * @param {number} [y] - y coordinate
-     * @returns {boolean} True if the polygon contain the point, otherwise false
-     * @example
-     * if (polygon.contains(10, 10)) {
-     *   // do something
-     * }
-     * // or
-     * if (polygon.contains(myVector2d)) {
-     *   // do something
-     * }
-     */
-    contains(...args: any[]): boolean;
-    /**
-     * returns the bounding box for this shape, the smallest Rectangle object completely containing this shape.
-     * @returns {Bounds} this shape bounding box Rectangle object
-     */
-    getBounds(): Bounds;
-    _bounds: object | undefined;
-    /**
-     * update the bounding box for this shape.
-     * @returns {Bounds} this shape bounding box Rectangle object
-     */
-    updateBounds(): Bounds;
-    /**
-     * clone this Polygon
-     * @returns {Polygon} new Polygon
-     */
-    clone(): Polygon;
-}
-import type Vector2d from "./../math/vector2.js";
-import type Matrix2d from "./../math/matrix2.js";
-import type ObservableVector2d from "./../math/observable_vector2.js";
-import type Bounds from "./../physics/bounds.js";

package/dist/types/geometries/rectangle.d.ts

@@ -1,135 +0,0 @@
-/**
- * additional import for TypeScript
- * @import Vector2d from "./../math/vector2.js";
- **/
-/**
- * @classdesc
- * a rectangle Object
- * @augments Polygon
- */
-export default 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: number, y: number, w: number, h: number);
-    /** @ignore */
-    onResetEvent(x: any, y: any, w: any, h: any): void;
-    /**
-     * 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: number, y: number, w: number | Vector2d[], h?: number | undefined, ...args: any[]): Rect;
-    /**
-     * left coordinate of the Rectangle
-     * @type {number}
-     */
-    get left(): number;
-    /**
-     * right coordinate of the Rectangle
-     * @type {number}
-     */
-    get right(): number;
-    /**
-     * top coordinate of the Rectangle
-     * @type {number}
-     */
-    get top(): number;
-    /**
-     * bottom coordinate of the Rectangle
-     * @type {number}
-     */
-    get bottom(): number;
-    set width(value: number);
-    /**
-     * width of the Rectangle
-     * @type {number}
-     */
-    get width(): number;
-    set height(value: number);
-    /**
-     * height of the Rectangle
-     * @type {number}
-     */
-    get height(): number;
-    set centerX(value: number);
-    /**
-     * absolute center of this rectangle on the horizontal axis
-     * @type {number}
-     */
-    get centerX(): number;
-    set centerY(value: number);
-    /**
-     * absolute center of this rectangle on the vertical axis
-     * @type {number}
-     */
-    get centerY(): number;
-    /**
-     * 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: number, y: number): Rect;
-    /**
-     * 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: number, h: number): Rect;
-    /**
-     * 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: number, y?: number | undefined): Rect;
-    /**
-     * clone this rectangle
-     * @returns {Rect} new rectangle
-     */
-    clone(): Rect;
-    /**
-     * copy the position and size of the given rectangle into this one
-     * @param {Rect} rect - Source rectangle
-     * @returns {Rect} new rectangle
-     */
-    copy(rect: Rect): Rect;
-    /**
-     * merge this rectangle with another one
-     * @param {Rect} rect - other rectangle to union with
-     * @returns {Rect} the union(ed) rectangle
-     */
-    union(rect: Rect): Rect;
-    /**
-     * check if this rectangle is intersecting with the specified one
-     * @param {Rect} rect
-     * @returns {boolean} true if overlaps
-     */
-    overlaps(rect: Rect): boolean;
-    /**
-     * check if this rectangle is identical to the specified one
-     * @param {Rect} rect
-     * @returns {boolean} true if equals
-     */
-    equals(rect: Rect): boolean;
-    /**
-     * 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(): boolean;
-    /**
-     * Returns a polygon whose edges are the same as this box.
-     * @returns {Polygon} a new Polygon that represents this rectangle.
-     */
-    toPolygon(): Polygon;
-}
-import Polygon from "./poly.js";
-import type Vector2d from "./../math/vector2.js";