melonjs 13.0.0 → 13.1.0

package/dist/melonjs.module.d.ts

@@ -1049,7 +1049,6 @@ export class CanvasRenderer extends Renderer {
      * @param {number} options.width The width of the canvas without scaling
      * @param {number} options.height The height of the canvas without scaling
      * @param {HTMLCanvasElement} [options.canvas] The html canvas to draw to on screen
-     * @param {boolean} [options.doubleBuffering=false] Whether to enable double buffering
      * @param {boolean} [options.antiAlias=false] Whether to enable anti-aliasing
      * @param {boolean} [options.transparent=false] Whether to enable transparency on the canvas (performance hit when enabled)
      * @param {boolean} [options.subPixel=false] Whether to enable subpixel renderering (performance hit when enabled)
@@ -1061,7 +1060,6 @@ export class CanvasRenderer extends Renderer {
         width: number;
         height: number;
         canvas?: HTMLCanvasElement;
-        doubleBuffering?: boolean;
         antiAlias?: boolean;
         transparent?: boolean;
         subPixel?: boolean;
@@ -1070,8 +1068,6 @@ export class CanvasRenderer extends Renderer {
         zoomY?: number;
     });
     context: CanvasRenderingContext2D;
-    backBufferCanvas: HTMLCanvasElement | OffscreenCanvas;
-    backBufferContext2D: CanvasRenderingContext2D;
     cache: TextureCache;
     /**
      * Reset the canvas transform to identity
@@ -1097,12 +1093,6 @@ export class CanvasRenderer extends Renderer {
      * @param {CanvasRenderingContext2D} [context]
      */
     setBlendMode(mode?: string, context?: CanvasRenderingContext2D): void;
-    /**
-     * render the main framebuffer on screen
-     * @name flush
-     * @memberof CanvasRenderer
-     */
-    flush(): void;
     /**
      * Clears the main framebuffer with the given color
      * @name clearColor
@@ -1295,18 +1285,11 @@ export class CanvasRenderer extends Renderer {
      * @param {number} radius
      */
     fillRoundRect(x: number, y: number, width: number, height: number, radius: number): void;
-    /**
-     * return a reference to the system 2d Context
-     * @name getContext
-     * @memberof CanvasRenderer
-     * @returns {CanvasRenderingContext2D}
-     */
-    getContext(): CanvasRenderingContext2D;
     /**
      * return a reference to the font 2d Context
      * @ignore
      */
-    getFontContext(): CanvasRenderingContext2D;
+    getFontContext(): CanvasRenderingContext2D | WebGLRenderingContext;
     /**
      * save the canvas context
      * @name save
@@ -1449,34 +1432,28 @@ export class Color {
     /**
      * Color Red Component [0 .. 255]
      * @type {number}
-     * @memberof Color
      */
     get r(): number;
     set g(arg: number);
     /**
      * Color Green Component [0 .. 255]
      * @type {number}
-     * @memberof Color
      */
     get g(): number;
     set b(arg: number);
     /**
      * Color Blue Component [0 .. 255]
      * @type {number}
-     * @memberof Color
      */
     get b(): number;
     set alpha(arg: number);
     /**
      * Color Alpha Component [0.0 .. 1.0]
      * @type {number}
-     * @memberof Color
      */
     get alpha(): number;
     /**
      * Set this color to the specified value.
-     * @name setColor
-     * @memberof Color
      * @param {number} r red component [0 .. 255]
      * @param {number} g green component [0 .. 255]
      * @param {number} b blue component [0 .. 255]
@@ -1484,41 +1461,47 @@ export class Color {
      * @returns {Color} Reference to this object for method chaining
      */
     setColor(r: number, g: number, b: number, alpha?: number): Color;
+    /**
+     * set this color to the specified HSV value
+     * @param {number} h hue (a value from 0 to 1)
+     * @param {number} s saturation (a value from 0 to 1)
+     * @param {number} v value (a value from 0 to 1)
+     * @returns {Color} Reference to this object for method chaining
+     */
+    setHSV(h: number, s: number, v: number): Color;
+    /**
+     * set this color to the specified HSL value
+     * @param {number} h hue (a value from 0 to 1)
+     * @param {number} s saturation (a value from 0 to 1)
+     * @param {number} l lightness (a value from 0 to 1)
+     * @returns {Color} Reference to this object for method chaining
+     */
+    setHSL(h: number, s: number, l: number): Color;
     /**
      * Create a new copy of this color object.
-     * @name clone
-     * @memberof Color
      * @returns {Color} Reference to the newly cloned object
      */
     clone(): Color;
     /**
      * Copy a color object or CSS color into this one.
-     * @name copy
-     * @memberof Color
      * @param {Color|string} color
      * @returns {Color} Reference to this object for method chaining
      */
     copy(color: Color | string): Color;
     /**
      * Blend this color with the given one using addition.
-     * @name add
-     * @memberof Color
      * @param {Color} color
      * @returns {Color} Reference to this object for method chaining
      */
     add(color: Color): Color;
     /**
      * Darken this color value by 0..1
-     * @name darken
-     * @memberof Color
      * @param {number} scale
      * @returns {Color} Reference to this object for method chaining
      */
     darken(scale: number): Color;
     /**
      * Linearly interpolate between this color and the given one.
-     * @name lerp
-     * @memberof Color
      * @param {Color} color
      * @param {number} alpha with alpha = 0 being this color, and alpha = 1 being the given one.
      * @returns {Color} Reference to this object for method chaining
@@ -1526,16 +1509,12 @@ export class Color {
     lerp(color: Color, alpha: number): Color;
     /**
      * Lighten this color value by 0..1
-     * @name lighten
-     * @memberof Color
      * @param {number} scale
      * @returns {Color} Reference to this object for method chaining
      */
     lighten(scale: number): Color;
     /**
      * Generate random r,g,b values for this color object
-     * @name random
-     * @memberof Color
      * @param {number} [min=0] minimum value for the random range
      * @param {number} [max=255] maxmium value for the random range
      * @returns {Color} Reference to this object for method chaining
@@ -1544,8 +1523,6 @@ export class Color {
     /**
      * Return true if the r,g,b,a values of this color are equal with the
      * given one.
-     * @name equals
-     * @memberof Color
      * @param {Color} color
      * @returns {boolean}
      */
@@ -1553,16 +1530,12 @@ export class Color {
     /**
      * Parse a CSS color string and set this color to the corresponding
      * r,g,b values
-     * @name parseCSS
-     * @memberof Color
      * @param {string} cssColor
      * @returns {Color} Reference to this object for method chaining
      */
     parseCSS(cssColor: string): Color;
     /**
      * Parse an RGB or RGBA CSS color string
-     * @name parseRGB
-     * @memberof Color
      * @param {string} rgbColor
      * @returns {Color} Reference to this object for method chaining
      */
@@ -1570,8 +1543,6 @@ export class Color {
     /**
      * Parse a Hex color ("#RGB", "#RGBA" or "#RRGGBB", "#RRGGBBAA" format) and set this color to
      * the corresponding r,g,b,a values
-     * @name parseHex
-     * @memberof Color
      * @param {string} hexColor
      * @param {boolean} [argb = false] true if format is #ARGB, or #AARRGGBB (as opposed to #RGBA or #RGGBBAA)
      * @returns {Color} Reference to this object for method chaining
@@ -1579,44 +1550,32 @@ export class Color {
     parseHex(hexColor: string, argb?: boolean): Color;
     /**
      * Pack this color into a Uint32 ARGB representation
-     * @name toUint32
-     * @memberof Color
      * @param {number} [alpha=1.0] alpha value [0.0 .. 1.0]
      * @returns {number}
      */
     toUint32(alpha?: number): number;
     /**
      * return an array representation of this object
-     * @name toArray
-     * @memberof Color
      * @returns {Float32Array}
      */
     toArray(): Float32Array;
     /**
-     * Get the color in "#RRGGBB" format
-     * @name toHex
-     * @memberof Color
+     * return the color in "#RRGGBB" format
      * @returns {string}
      */
     toHex(): string;
     /**
      * Get the color in "#RRGGBBAA" format
-     * @name toHex8
-     * @memberof Color
      * @returns {string}
      */
     toHex8(alpha?: number): string;
     /**
      * Get the color in "rgb(R,G,B)" format
-     * @name toRGB
-     * @memberof Color
      * @returns {string}
      */
     toRGB(): string;
     /**
      * Get the color in "rgba(R,G,B,A)" format
-     * @name toRGBA
-     * @memberof Color
      * @param {number} [alpha=1.0] alpha value [0.0 .. 1.0]
      * @returns {string}
      */
@@ -3617,6 +3576,15 @@ export class ObservableVector2d extends Vector2d {
      * @returns {ObservableVector2d} Reference to this object for method chaining
      */
     lerp(v: Vector2d | ObservableVector2d, alpha: number): ObservableVector2d;
+    /**
+     * interpolate the position of this vector towards the given one while nsure that the distance never exceeds the given step.
+     * @name moveTowards
+     * @memberof ObservableVector2d
+     * @param {Vector2d|ObservableVector2d} target
+     * @param {number} step the maximum step per iteration (Negative values will push the vector away from the target)
+     * @returns {ObservableVector2d} Reference to this object for method chaining
+     */
+    moveTowards(target: Vector2d | ObservableVector2d, step: number): ObservableVector2d;
     /**
      * return the distance between this vector and the passed one
      * @name distance
@@ -3900,6 +3868,15 @@ export class ObservableVector3d extends Vector3d {
      * @returns {ObservableVector3d} Reference to this object for method chaining
      */
     lerp(v: Vector3d | ObservableVector3d, alpha: number): ObservableVector3d;
+    /**
+     * interpolate the position of this vector on the x and y axis towards the given one while ensure that the distance never exceeds the given step.
+     * @name moveTowards
+     * @memberof ObservableVector3d
+     * @param {Vector2d|ObservableVector2d|Vector3d|ObservableVector3d} target
+     * @param {number} step the maximum step per iteration (Negative values will push the vector away from the target)
+     * @returns {ObservableVector3d} Reference to this object for method chaining
+     */
+    moveTowards(target: Vector2d | ObservableVector2d | Vector3d | ObservableVector3d, step: number): ObservableVector3d;
     /**
      * return the distance between this vector and the passed one
      * @name distance
@@ -6152,7 +6129,6 @@ export class Renderer {
      * @param {number} options.width The width of the canvas without scaling
      * @param {number} options.height The height of the canvas without scaling
      * @param {HTMLCanvasElement} [options.canvas] The html canvas to draw to on screen
-     * @param {boolean} [options.doubleBuffering=false] Whether to enable double buffering (not applicable when using the WebGL Renderer)
      * @param {boolean} [options.antiAlias=false] Whether to enable anti-aliasing, use false (default) for a pixelated effect.
      * @param {boolean} [options.failIfMajorPerformanceCaveat=true] If true, the renderer will switch to CANVAS mode if the performances of a WebGL context would be dramatically lower than that of a native application making equivalent OpenGL calls.
      * @param {boolean} [options.transparent=false] Whether to enable transparency on the canvas (performance hit when enabled)
@@ -6166,7 +6142,6 @@ export class Renderer {
         width: number;
         height: number;
         canvas?: HTMLCanvasElement;
-        doubleBuffering?: boolean;
         antiAlias?: boolean;
         failIfMajorPerformanceCaveat?: boolean;
         transparent?: boolean;
@@ -6212,8 +6187,6 @@ export class Renderer {
      */
     currentBlendMode: string;
     canvas: any;
-    backBufferCanvas: any;
-    context: any;
     currentColor: Color;
     currentTint: Color;
     projectionMatrix: Matrix3d;
@@ -6224,6 +6197,12 @@ export class Renderer {
      * @memberof Renderer
      */
     clear(): void;
+    /**
+     * render the main framebuffer on screen
+     * @name flush
+     * @memberof Renderer
+     */
+    flush(): void;
     /**
      * Reset context state
      * @name reset
@@ -6231,27 +6210,19 @@ export class Renderer {
      */
     reset(): void;
     /**
-     * return a reference to the system canvas
+     * return a reference to the canvas which this renderer draws to
      * @name getCanvas
      * @memberof Renderer
      * @returns {HTMLCanvasElement}
      */
     getCanvas(): HTMLCanvasElement;
     /**
-     * return a reference to the screen canvas
-     * @name getScreenCanvas
-     * @memberof Renderer
-     * @returns {HTMLCanvasElement}
-     */
-    getScreenCanvas(): HTMLCanvasElement;
-    /**
-     * return a reference to the screen canvas corresponding 2d Context<br>
-     * (will return buffered context if double buffering is enabled, or a reference to the Screen Context)
-     * @name getScreenContext
+     * return a reference to this renderer canvas corresponding Context
+     * @name getContext
      * @memberof Renderer
-     * @returns {CanvasRenderingContext2D}
+     * @returns {CanvasRenderingContext2D|WebGLRenderingContext}
      */
-    getScreenContext(): CanvasRenderingContext2D;
+    getContext(): CanvasRenderingContext2D | WebGLRenderingContext;
     /**
      * returns the current blend mode for this renderer
      * @name getBlendMode
@@ -6390,6 +6361,25 @@ export class Renderer {
      */
     drawFont(): void;
     get Texture(): typeof TextureAtlas;
+    /**
+     * return a reference to the screen canvas
+     * @name getScreenCanvas
+     * @memberof Renderer
+     * @returns {HTMLCanvasElement}
+     * @deprecated since 13.1.0
+     * @see getCanvas();
+     */
+    getScreenCanvas(): HTMLCanvasElement;
+    /**
+     * return a reference to the screen canvas corresponding 2d Context<br>
+     * (will return buffered context if double buffering is enabled, or a reference to the Screen Context)
+     * @name getScreenContext
+     * @memberof Renderer
+     * @returns {CanvasRenderingContext2D}
+     * @deprecated since 13.1.0
+     * @see getContext();
+     */
+    getScreenContext(): CanvasRenderingContext2D;
 }
 /**
  * @classdesc
@@ -6997,6 +6987,14 @@ export class TMXLayer extends Renderable {
      * @name TMXLayer#renderorder
      */
     public renderorder: string;
+    /**
+     * the layer class
+     * @public
+     * @type {string}
+     * @name class
+     * @name TMXLayer#class
+     */
+    public class: string;
     name: any;
     cols: number;
     rows: number;
@@ -7328,6 +7326,13 @@ export class TMXTileMap {
      * @name TMXTileMap#tiledversion
      */
     public tiledversion: string;
+    /**
+     * The map class.
+     * @public
+     * @type {string}
+     * @name TMXTileMap#class
+     */
+    public class: string;
     tilesets: TMXTilesetGroup;
     layers: any[];
     objectGroups: any[];
@@ -7433,6 +7438,13 @@ export class TMXTileset {
      * @name TMXTileset#isCollection
      */
     public isCollection: boolean;
+    /**
+     * the tileset class
+     * @public
+     * @type {boolean}
+     * @name TMXTileset#class
+     */
+    public class: boolean;
     /**
      * Tileset animations
      * @private
@@ -8463,6 +8475,15 @@ export class Vector2d {
      * @returns {Vector2d} Reference to this object for method chaining
      */
     lerp(v: Vector2d, alpha: number): Vector2d;
+    /**
+     * interpolate the position of this vector towards the given one by the given maximum step.
+     * @name moveTowards
+     * @memberof Vector2d
+     * @param {Vector2d} target
+     * @param {number} step the maximum step per iteration (Negative values will push the vector away from the target)
+     * @returns {Vector2d} Reference to this object for method chaining
+     */
+    moveTowards(target: Vector2d, step: number): Vector2d;
     /**
      * return the distance between this vector and the passed one
      * @name distance
@@ -8786,6 +8807,15 @@ export class Vector3d {
      * @returns {Vector3d} Reference to this object for method chaining
      */
     lerp(v: Vector3d, alpha: number): Vector3d;
+    /**
+     * interpolate the position of this vector on the x and y axis towards the given one by the given maximum step.
+     * @name moveTowards
+     * @memberof Vector3d
+     * @param {Vector2d|Vector3d} target
+     * @param {number} step the maximum step per iteration (Negative values will push the vector away from the target)
+     * @returns {Vector3d} Reference to this object for method chaining
+     */
+    moveTowards(target: Vector2d | Vector3d, step: number): Vector3d;
     /**
      * return the distance between this vector and the passed one
      * @name distance
@@ -9049,7 +9079,6 @@ export class WebGLRenderer extends Renderer {
      * @param {number} options.width The width of the canvas without scaling
      * @param {number} options.height The height of the canvas without scaling
      * @param {HTMLCanvasElement} [options.canvas] The html canvas to draw to on screen
-     * @param {boolean} [options.doubleBuffering=false] Whether to enable double buffering (not applicable when using the WebGL Renderer)
      * @param {boolean} [options.antiAlias=false] Whether to enable anti-aliasing
      * @param {boolean} [options.failIfMajorPerformanceCaveat=true] If true, the renderer will switch to CANVAS mode if the performances of a WebGL context would be dramatically lower than that of a native application making equivalent OpenGL calls.
      * @param {boolean} [options.transparent=false] Whether to enable transparency on the canvas (performance hit when enabled)
@@ -9064,7 +9093,6 @@ export class WebGLRenderer extends Renderer {
         width: number;
         height: number;
         canvas?: HTMLCanvasElement;
-        doubleBuffering?: boolean;
         antiAlias?: boolean;
         failIfMajorPerformanceCaveat?: boolean;
         transparent?: boolean;
@@ -9196,12 +9224,6 @@ export class WebGLRenderer extends Renderer {
      * var basic      = renderer.createPattern(image, "no-repeat");
      */
     createPattern(image: new (width?: number, height?: number) => HTMLImageElement, repeat: string): TextureAtlas;
-    /**
-     * Flush the compositor to the frame buffer
-     * @name flush
-     * @memberof WebGLRenderer
-     */
-    flush(): void;
     /**
      * Clears the gl context with the given color.
      * @name clearColor
@@ -9258,13 +9280,6 @@ export class WebGLRenderer extends Renderer {
      * @see WebGLRenderer#createPattern
      */
     drawPattern(pattern: TextureAtlas, x: number, y: number, width: number, height: number): void;
-    /**
-     * return a reference to the screen canvas corresponding WebGL Context
-     * @name getScreenContext
-     * @memberof WebGLRenderer
-     * @returns {WebGLRenderingContext}
-     */
-    getScreenContext(): WebGLRenderingContext;
     /**
      * Returns the WebGL Context object of the given Canvas
      * @name getContextGL
@@ -12535,7 +12550,6 @@ declare var fnUtils: Readonly<{
  * @param {object} [options] The optional video/renderer parameters.<br> (see Renderer(s) documentation for further specific options)
  * @param {string|HTMLElement} [options.parent=document.body] the DOM parent element to hold the canvas in the HTML file
  * @param {number} [options.renderer=video.AUTO] renderer to use (me.video.CANVAS, me.video.WEBGL, me.video.AUTO)
- * @param {boolean} [options.doubleBuffering=false] enable/disable double buffering
  * @param {number|string} [options.scale=1.0] enable scaling of the canvas ('auto' for automatic scaling)
  * @param {string} [options.scaleMethod="fit"] screen scaling modes ('fit','fill-min','fill-max','flex','flex-width','flex-height','stretch')
  * @param {boolean} [options.preferWebGL1=false] if true the renderer will only use WebGL 1
@@ -12550,14 +12564,12 @@ declare var fnUtils: Readonly<{
  *     parent : "screen",
  *     renderer : me.video.AUTO,
  *     scale : "auto",
- *     scaleMethod : "fit",
- *     doubleBuffering : true
+ *     scaleMethod : "fit"
  * });
  */
 declare function init(width: number, height: number, options?: {
     parent?: string | HTMLElement;
     renderer?: number;
-    doubleBuffering?: boolean;
     scale?: number | string;
     scaleMethod?: string;
     preferWebGL1?: boolean;