melonjs 14.3.0 → 14.5.0

package/dist/types/physics/bounds.d.ts

@@ -4,9 +4,9 @@
  */
 export default class Bounds {
     /**
-     * @param {Vector2d[]} [vertices] - an array of me.Vector2d points
+     * @param {Vector2d[]|Point[]} [vertices] - an array of Vector2d or Point
      */
-    constructor(vertices?: Vector2d[] | undefined);
+    constructor(vertices?: Vector2d[] | Point[] | undefined);
     _center: Vector2d;
     /**
      * @ignore
@@ -22,147 +22,106 @@ export default class Bounds {
     } | undefined;
     /**
      * reset the bound
-     * @name clear
-     * @memberof Bounds
      */
     clear(): void;
     /**
      * sets the bounds to the given min and max value
-     * @name setMinMax
-     * @memberof Bounds
      * @param {number} minX
      * @param {number} minY
      * @param {number} maxX
      * @param {number} maxY
      */
     setMinMax(minX: number, minY: number, maxX: number, maxY: number): void;
-    public set x(arg: number);
+    set x(arg: number);
     /**
      * x position of the bound
-     * @public
      * @type {number}
-     * @name x
-     * @memberof Bounds
      */
-    public get x(): number;
-    public set y(arg: number);
+    get x(): number;
+    set y(arg: number);
     /**
      * y position of the bounds
-     * @public
      * @type {number}
-     * @name y
-     * @memberof Bounds
      */
-    public get y(): number;
-    public set width(arg: number);
+    get y(): number;
+    set width(arg: number);
     /**
      * width of the bounds
-     * @public
      * @type {number}
-     * @name width
-     * @memberof Bounds
      */
-    public get width(): number;
-    public set height(arg: number);
+    get width(): number;
+    set height(arg: number);
     /**
      * width of the bounds
-     * @public
      * @type {number}
-     * @name width
-     * @memberof Bounds
      */
-    public get height(): number;
+    get height(): number;
     /**
      * left coordinate of the bound
-     * @public
      * @type {number}
-     * @name left
-     * @memberof Bounds
      */
-    public get left(): number;
+    get left(): number;
     /**
      * right coordinate of the bound
-     * @public
      * @type {number}
-     * @name right
-     * @memberof Bounds
      */
-    public get right(): number;
+    get right(): number;
     /**
      * top coordinate of the bound
-     * @public
      * @type {number}
-     * @name top
-     * @memberof Bounds
      */
-    public get top(): number;
+    get top(): number;
     /**
      * bottom coordinate of the bound
-     * @public
      * @type {number}
-     * @name bottom
-     * @memberof Bounds
      */
-    public get bottom(): number;
+    get bottom(): number;
     /**
      * center position of the bound on the x axis
-     * @public
      * @type {number}
-     * @name centerX
-     * @memberof Bounds
      */
-    public get centerX(): number;
+    get centerX(): number;
     /**
      * center position of the bound on the y axis
-     * @public
      * @type {number}
-     * @name centerY
-     * @memberof Bounds
      */
-    public get centerY(): number;
+    get centerY(): number;
     /**
      * return the center position of the bound
-     * @public
      * @type {Vector2d}
-     * @name center
-     * @memberof Bounds
      */
-    public get center(): Vector2d;
+    get center(): Vector2d;
+    /**
+     * center the bounds position around the given coordinates
+     * @param {number} x - the x coordinate around which to center this bounds
+     * @param {number} y - the y coordinate around which to center this bounds
+     */
+    centerOn(x: number, y: number): Bounds;
     /**
      * Updates bounds using the given vertices
-     * @name update
-     * @memberof Bounds
-     * @param {Vector2d[]} vertices - an array of me.Vector2d points
+     * @param {Vector2d[]|Point[]} vertices - an array of Vector2d or Point
      */
-    update(vertices: Vector2d[]): void;
+    update(vertices: Vector2d[] | Point[]): void;
     /**
      * add the given vertices to the bounds definition.
-     * @name add
-     * @memberof Bounds
-     * @param {Vector2d[]} vertices - an array of me.Vector2d points
+     * @param {Vector2d[]|Point[]} vertices - an array of Vector2d or Point
      * @param {boolean} [clear=false] - either to reset the bounds before adding the new vertices
      */
-    add(vertices: Vector2d[], clear?: boolean | undefined): void;
+    add(vertices: Vector2d[] | Point[], clear?: boolean | undefined): void;
     /**
      * add the given bounds to the bounds definition.
-     * @name addBounds
-     * @memberof Bounds
      * @param {Bounds} bounds
      * @param {boolean} [clear=false] - either to reset the bounds before adding the new vertices
      */
     addBounds(bounds: Bounds, clear?: boolean | undefined): void;
     /**
      * add the given point to the bounds definition.
-     * @name addPoint
-     * @memberof Bounds
-     * @param {Vector2d|Point} point - the point to be added to the bounds
-     * @param {Matrix2d} [m] - an optional transform to apply to the given point (only if the given point is a vector)
+     * @param {Vector2d|Point} point - the vector or point to be added to the bounds
+     * @param {Matrix2d} [m] - an optional transform to apply to the given point (if the given point is a Vector2d)
      */
     addPoint(point: Vector2d | Point, m?: any): void;
     /**
      * add the given quad coordinates to this bound definition, multiplied by the given matrix
-     * @name addFrame
-     * @memberof Bounds
      * @param {number} x0 - left X coordinates of the quad
      * @param {number} y0 - top Y coordinates of the quad
      * @param {number} x1 - right X coordinates of the quad
@@ -180,8 +139,6 @@ export default class Bounds {
      */
     /**
      * Returns true if the bounds contains the given point.
-     * @name contains
-     * @memberof Bounds
      * @param {number} x
      * @param {number} y
      * @returns {boolean} True if the bounds contain the point, otherwise false
@@ -189,16 +146,12 @@ export default class Bounds {
     contains(...args: any[]): boolean;
     /**
      * Returns true if the two bounds intersect.
-     * @name overlaps
-     * @memberof Bounds
      * @param {Bounds|Rect} bounds
      * @returns {boolean} True if the bounds overlap, otherwise false
      */
     overlaps(bounds: Bounds | Rect): boolean;
     /**
      * determines whether all coordinates of this bounds are finite numbers.
-     * @name isFinite
-     * @memberof Bounds
      * @returns {boolean} false if all coordinates are positive or negative Infinity or NaN; otherwise, true.
      */
     isFinite(): boolean;
@@ -211,8 +164,6 @@ export default class Bounds {
      */
     /**
      * Translates the bounds by x on the x axis, and y on the y axis
-     * @name translate
-     * @memberof Bounds
      * @param {number} x
      * @param {number} y
      */
@@ -226,23 +177,17 @@ export default class Bounds {
      */
     /**
      * Shifts the bounds to the given x, y position.
-     * @name shift
-     * @memberof Bounds
      * @param {number} x
      * @param {number} y
      */
     shift(...args: any[]): void;
     /**
      * clone this bounds
-     * @name clone
-     * @memberof Bounds
      * @returns {Bounds}
      */
     clone(): Bounds;
     /**
      * Returns a polygon whose edges are the same as this bounds.
-     * @name toPolygon
-     * @memberof Bounds
      * @returns {Polygon} a new Polygon that represents this bounds.
      */
     toPolygon(): Polygon;

package/dist/types/renderable/container.d.ts

@@ -206,23 +206,12 @@ export default class Container extends Renderable {
      * @returns {Renderable[]} an array of renderable object
      */
     getChildren(): Renderable[];
-    /**
-     * update the bounding box for this shape.
-     * @ignore
-     * @returns {Bounds} this shape bounding box Rectangle object
-     */
-    updateBounds(forceUpdateChildBounds?: boolean): Bounds;
     /**
      * Checks if this container is root or if it's attached to the root container.
      * @private
      * @returns {boolean}
      */
     private isAttachedToRoot;
-    /**
-     * update the cointainer's bounding rect (private)
-     * @ignore
-     */
-    updateBoundsPos(newX: any, newY: any): Bounds;
     /**
      * @ignore
      */

package/dist/types/renderable/renderable.d.ts

@@ -5,16 +5,28 @@
  */
 export default class Renderable extends Rect {
     /**
-     * to identify the object as a renderable object
-     * @ignore
+     * Position of the Renderable relative to its parent container
+     * @public
+     * @type {ObservableVector3d}
      */
-    isRenderable: boolean;
+    public pos: ObservableVector3d;
     /**
-     * If true then physic collision and input events will not impact this renderable
-     * @type {boolean}
-     * @default true
+     * The anchor point is used for attachment behavior, and/or when applying transformations.<br>
+     * The coordinate system places the origin at the top left corner of the frame (0, 0) and (1, 1) means the bottom-right corner<br>
+     * <img src="images/anchor_point.png"/><br>
+     * a Renderable's anchor point defaults to (0.5,0.5), which corresponds to the center position.<br>
+     * <br>
+     * <i><b>Note:</b> Object created through Tiled will have their anchorPoint set to (0, 0) to match Tiled Level editor implementation.
+     * To specify a value through Tiled, use a json expression like `json:{"x":0.5,"y":0.5}`. </i>
+     * @type {ObservableVector2d}
+     * @default <0.5,0.5>
      */
-    isKinematic: boolean;
+    anchorPoint: ObservableVector2d;
+    /**
+     * the renderable default transformation matrix
+     * @type {Matrix2d}
+     */
+    currentTransform: Matrix2d;
     /**
      * the renderable physic body
      * @type {Body}
@@ -51,11 +63,6 @@ export default class Renderable extends Rect {
      * }
      */
     body: Body;
-    /**
-     * the renderable default transformation matrix
-     * @type {Matrix2d}
-     */
-    currentTransform: Matrix2d;
     /**
      * (G)ame (U)nique (Id)entifier" <br>
      * a GUID will be allocated for any renderable object added <br>
@@ -100,18 +107,6 @@ export default class Renderable extends Rect {
      * @default false
      */
     floating: boolean;
-    /**
-     * The anchor point is used for attachment behavior, and/or when applying transformations.<br>
-     * The coordinate system places the origin at the top left corner of the frame (0, 0) and (1, 1) means the bottom-right corner<br>
-     * <img src="images/anchor_point.png"/><br>
-     * a Renderable's anchor point defaults to (0.5,0.5), which corresponds to the center position.<br>
-     * <br>
-     * <i><b>Note:</b> Object created through Tiled will have their anchorPoint set to (0, 0) to match Tiled Level editor implementation.
-     * To specify a value through Tiled, use a json expression like `json:{"x":0.5,"y":0.5}`. </i>
-     * @type {ObservableVector2d}
-     * @default <0.5,0.5>
-     */
-    anchorPoint: ObservableVector2d;
     /**
      * When enabled, an object container will automatically apply
      * any defined transformation before calling the child draw method.
@@ -182,15 +177,20 @@ export default class Renderable extends Rect {
      */
     name: string;
     /**
-     * Position of the Renderable relative to its parent container
-     * @public
-     * @type {ObservableVector3d}
+     * to identify the object as a renderable object
+     * @ignore
      */
-    public pos: ObservableVector3d;
+    isRenderable: boolean;
+    /**
+     * If true then physic collision and input events will not impact this renderable
+     * @type {boolean}
+     * @default true
+     */
+    isKinematic: boolean;
     /**
      * when true the renderable will be redrawn during the next update cycle
      * @type {boolean}
-     * @default false
+     * @default true
      */
     isDirty: boolean;
     _flip: {
@@ -317,11 +317,17 @@ export default class Renderable extends Rect {
      * @returns {boolean} true if the renderable is dirty
      */
     update(dt: number): boolean;
+    /**
+     * update the bounding box for this shape.
+     * @param {boolean} [absolute=true] - update the bounds size and position in (world) absolute coordinates
+     * @returns {Bounds} this shape bounding box Rectangle object
+     */
+    updateBounds(absolute?: boolean | undefined): Bounds;
     /**
      * update the renderable's bounding rect (private)
      * @ignore
      */
-    updateBoundsPos(newX: any, newY: any): void;
+    updateBoundsPos(newX?: number, newY?: number): void;
     /**
      * return the renderable absolute position in the game world
      * @returns {Vector2d}
@@ -397,6 +403,6 @@ export default class Renderable extends Rect {
     onDestroyEvent(): void;
 }
 import Rect from "./../geometries/rectangle.js";
-import ObservableVector2d from "./../math/observable_vector2.js";
 import ObservableVector3d from "./../math/observable_vector3.js";
+import ObservableVector2d from "./../math/observable_vector2.js";
 import Color from "./../math/color.js";

package/dist/types/renderable/sprite.d.ts

@@ -83,7 +83,7 @@ export default class Sprite extends Renderable {
     anim: {};
     resetAnim: Function | (() => Sprite) | undefined;
     current: {
-        name: string;
+        name: undefined;
         length: number;
         offset: object;
         width: number;
@@ -234,13 +234,13 @@ export default class Sprite extends Renderable {
      * force the current animation frame index.
      * @name setAnimationFrame
      * @memberof Sprite
-     * @param {number} [idx=0] - animation frame index
+     * @param {number} [index=0] - animation frame index
      * @returns {Sprite} Reference to this object for method chaining
      * @example
      * // reset the current animation to the first frame
      * this.setAnimationFrame();
      */
-    setAnimationFrame(idx?: number | undefined): Sprite;
+    setAnimationFrame(index?: number | undefined): Sprite;
     /**
      * return the current animation frame index.
      * @name getCurrentAnimationFrame

package/dist/types/state/state.d.ts

@@ -135,7 +135,7 @@ declare namespace state {
      */
     function transition(effect: string, color: any, duration?: number | undefined): void;
     /**
-     * enable/disable transition for a specific state (by default enabled for all)
+     * enable/disable the transition to a particular state (by default enabled for all)
      * @name setTransition
      * @memberof state
      * @public

package/dist/types/system/pooling.d.ts

@@ -26,14 +26,14 @@ declare class ObjectPool {
      * @param {boolean} [recycling=false] - enables object recycling for the specified class
      * @example
      * // implement CherryEntity
-     * class CherryEntity extends Spritesheet {
+     * class Cherry extends Sprite {
      *    onResetEvent() {
      *        // reset object mutable properties
      *        this.lifeBar = 100;
      *    }
      * };
      * // add our users defined entities in the object pool and enable object recycling
-     * me.pool.register("cherryentity", CherryEntity, true);
+     * me.pool.register("cherrysprite", Cherry, true);
      */
     register(className: string, classObj: object, recycling?: boolean | undefined): void;
     /**

package/dist/types/video/renderer.d.ts

@@ -188,7 +188,7 @@ export default class Renderer {
      * @param {Rect|RoundRect|Polygon|Line|Ellipse} [mask] - the shape defining the mask to be applied
      * @param {boolean} [invert=false] - either the given shape should define what is visible (default) or the opposite
      */
-    setMask(mask?: Rect | Polygon | Ellipse | RoundRect | Line | undefined): void;
+    setMask(mask?: Polygon | Rect | Ellipse | RoundRect | Line | undefined): void;
     /**
      * disable (remove) the rendering mask set through setMask.
      * @see Renderer#setMask

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

@@ -60,6 +60,7 @@ export function init(width: number, height: number, options?: {
 export function createCanvas(width: number, height: number, returnOffscreenCanvas?: boolean | undefined): HTMLCanvasElement | OffscreenCanvas;
 /**
  * return a reference to the parent DOM element holding the main canvas
+ * @memberof video
  * @returns {HTMLElement}
  */
 export function getParent(): HTMLElement;
@@ -69,21 +70,21 @@ export function getParent(): HTMLElement;
 /**
  * Select the HTML5 Canvas renderer
  * @memberof video
- * @constant
+ * @static
  */
-export const CANVAS: 0;
+export const CANVAS: number;
 /**
  * Select the WebGL renderer
  * @memberof video
- * @constant
+ * @static
  */
-export const WEBGL: 1;
+export const WEBGL: number;
 /**
  * Auto-select the renderer (Attempt WebGL first, with fallback to Canvas)
  * @memberof video
- * @constant
+ * @static
  */
-export const AUTO: 2;
+export const AUTO: any;
 /**
  * A reference to the active Canvas or WebGL active renderer renderer
  * @memberof video

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

@@ -0,0 +1,101 @@
+/**
+ * @classdesc
+ * A base Compositor object.
+ */
+export default class Compositor {
+    /**
+     * @param {WebGLRenderer} renderer - the current WebGL renderer session
+     */
+    constructor(renderer: WebGLRenderer);
+    /**
+     * Initialize the compositor
+     * @ignore
+     */
+    init(renderer: any): void;
+    renderer: any;
+    gl: any;
+    color: any;
+    viewMatrix: any;
+    /**
+     * a reference to the active WebGL shader
+     * @type {GLShader}
+     */
+    activeShader: any;
+    /**
+     * primitive type to render (gl.POINTS, gl.LINE_STRIP, gl.LINE_LOOP, gl.LINES, gl.TRIANGLE_STRIP, gl.TRIANGLE_FAN, gl.TRIANGLES)
+     * @type {number}
+     * @default gl.TRIANGLES
+     */
+    mode: number | undefined;
+    /**
+     * an array of vertex attribute properties
+     * @see WebGLCompositor.addAttribute
+     * @type {Array}
+     */
+    attributes: any[] | undefined;
+    /**
+     * the size of a single vertex in bytes
+     * (will automatically be calculated as attributes definitions are added)
+     * @see WebGLCompositor.addAttribute
+     * @type {number}
+     */
+    vertexByteSize: number | undefined;
+    /**
+     * the size of a single vertex in floats
+     * (will automatically be calculated as attributes definitions are added)
+     * @see WebGLCompositor.addAttribute
+     * @type {number}
+     */
+    vertexSize: number | undefined;
+    /**
+     * Reset compositor internal state
+     * @ignore
+     */
+    reset(): void;
+    /**
+     * add vertex attribute property definition to the compositor
+     * @param {string} name - name of the attribute in the vertex shader
+     * @param {number} size - number of components per vertex attribute. Must be 1, 2, 3, or 4.
+     * @param {GLenum} type - data type of each component in the array
+     * @param {boolean} normalized - whether integer data values should be normalized into a certain range when being cast to a float
+     * @param {number} offset - offset in bytes of the first component in the vertex attribute array
+     */
+    addAttribute(name: string, size: number, type: GLenum, normalized: boolean, offset: number): void;
+    /**
+     * Sets the viewport
+     * @param {number} x - x position of viewport
+     * @param {number} y - y position of viewport
+     * @param {number} w - width of viewport
+     * @param {number} h - height of viewport
+     */
+    setViewport(x: number, y: number, w: number, h: number): void;
+    /**
+     * set/change the current projection matrix
+     * @param {Matrix3d} matrix
+     */
+    setProjection(matrix: Matrix3d): void;
+    /**
+     * Select the shader to use for compositing
+     * @see GLShader
+     * @param {GLShader} shader - a reference to a GLShader instance
+     */
+    useShader(shader: GLShader): void;
+    /**
+     * Flush batched texture operations to the GPU
+     * @param {number} [mode=gl.TRIANGLES] - the GL drawing mode
+     */
+    flush(mode?: number | undefined): void;
+    /**
+     * Clear the frame buffer
+     * @param {number} [alpha = 0.0] - the alpha value used when clearing the framebuffer
+     */
+    clear(alpha?: number | undefined): void;
+    /**
+     * Specify the color values used when clearing color buffers. The values are clamped between 0 and 1.
+     * @param {number} [r = 0] - the red color value used when the color buffers are cleared
+     * @param {number} [g = 0] - the green color value used when the color buffers are cleared
+     * @param {number} [b = 0] - the blue color value used when the color buffers are cleared
+     * @param {number} [a = 0] - the alpha color value used when the color buffers are cleared
+     */
+    clearColor(r?: number | undefined, g?: number | undefined, b?: number | undefined, a?: number | undefined): void;
+}

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";