melonjs 10.6.1 → 10.8.0

package/dist/melonjs.module.d.ts

@@ -233,9 +233,45 @@ export class Body {
      * body.collisionType = me.collision.types.PLAYER_OBJECT;
      */
     public collisionType: number;
-    vel: Vector2d;
-    force: Vector2d;
-    friction: Vector2d;
+    /**
+     * body velocity
+     * @public
+     * @type {Vector2d}
+     * @default <0,0>
+     */
+    public vel: Vector2d;
+    /**
+     * body force or acceleration (automatically) applied to the body.
+     * when defining a force, user should also define a max velocity
+     * @public
+     * @type {Vector2d}
+     * @default <0,0>
+     * @see Body.setMaxVelocity
+     * @example
+     * // define a default maximum acceleration, initial force and friction
+     * this.body.force.set(0, 0);
+     * this.body.friction.set(0.4, 0);
+     * this.body.setMaxVelocity(3, 15);
+     *
+     * // apply a postive or negative force when pressing left of right key
+     * update(dt) {
+     *     if (me.input.isKeyPressed("left"))    {
+     *          this.body.force.x = -this.body.maxVel.x;
+     *      } else if (me.input.isKeyPressed("right")) {
+     *         this.body.force.x = this.body.maxVel.x;
+     *     } else {
+     *         this.body.force.x = 0;
+     *     }
+     * }
+     */
+    public force: Vector2d;
+    /**
+     * body friction
+     * @public
+     * @type {Vector2d}
+     * @default <0,0>
+     */
+    public friction: Vector2d;
     /**
      * the body bouciness level when colliding with other solid bodies :
      * a value of 0 will not bounce, a value of 1 will fully rebound.
@@ -251,7 +287,13 @@ export class Body {
      * @default 1
      */
     public mass: number;
-    maxVel: Vector2d;
+    /**
+     * max velocity (to limit body velocity)
+     * @public
+     * @type {Vector2d}
+     * @default <490,490>
+     */
+    public maxVel: Vector2d;
     /**
      * Either this body is a static body or not.
      * A static body is completely fixed and can never change position or angle.
@@ -484,6 +526,7 @@ declare class Bounds$1 {
      * @param {Vector2d[]} [vertices] an array of me.Vector2d points
      */
     constructor(vertices?: Vector2d[]);
+    _center: Vector2d;
     /**
      * @ignore
      */
@@ -496,7 +539,6 @@ declare class Bounds$1 {
         x: number;
         y: number;
     };
-    _center: Vector2d;
     /**
      * reset the bound
      * @name clear
@@ -1085,7 +1127,7 @@ export class CanvasRenderer extends Renderer {
      * <img src="images/normal-blendmode.png" width="510"/> <br>
      * - "multiply" : the pixels of the top layer are multiplied with the corresponding pixel of the bottom layer. A darker picture is the result. <br>
      * <img src="images/multiply-blendmode.png" width="510"/> <br>
-     * - "lighter" : where both content overlap the color is determined by adding color values. <br>
+     * - "additive or lighter" : where both content overlap the color is determined by adding color values. <br>
      * <img src="images/lighter-blendmode.png" width="510"/> <br>
      * - "screen" : The pixels are inverted, multiplied, and inverted again. A lighter picture is the result (opposite of multiply) <br>
      * <img src="images/screen-blendmode.png" width="510"/> <br>
@@ -1093,7 +1135,7 @@ export class CanvasRenderer extends Renderer {
      * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation
      * @memberof CanvasRenderer.prototype
      * @function
-     * @param {string} [mode="normal"] blend mode : "normal", "multiply", "lighter, "screen"
+     * @param {string} [mode="normal"] blend mode : "normal", "multiply", "lighter, "additive", "screen"
      * @param {CanvasRenderingContext2D} [context]
      */
     setBlendMode(mode?: string, context?: CanvasRenderingContext2D): void;
@@ -1288,6 +1330,31 @@ export class CanvasRenderer extends Renderer {
      * @param {number} height
      */
     fillRect(x: number, y: number, width: number, height: number): void;
+    /**
+     * Stroke a rounded rectangle at the specified coordinates
+     * @name strokeRoundRect
+     * @memberof CanvasRenderer.prototype
+     * @function
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {number} radius
+     * @param {boolean} [fill=false] also fill the shape with the current color if true
+     */
+    strokeRoundRect(x: number, y: number, width: number, height: number, radius: number, fill?: boolean): void;
+    /**
+     * Draw a rounded filled rectangle at the specified coordinates
+     * @name fillRoundRect
+     * @memberof CanvasRenderer.prototype
+     * @function
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @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
@@ -1342,13 +1409,21 @@ export class CanvasRenderer extends Renderer {
      */
     setColor(color: Color | string): void;
     /**
-     * Set the global alpha on the canvas context
+     * Set the global alpha
      * @name setGlobalAlpha
      * @memberof CanvasRenderer.prototype
      * @function
      * @param {number} alpha 0.0 to 1.0 values accepted.
      */
     setGlobalAlpha(alpha: number): void;
+    /**
+     * Return the global alpha
+     * @name getGlobalAlpha
+     * @memberof CanvasRenderer.prototype
+     * @function
+     * @returns {number} global alpha value
+     */
+    getGlobalAlpha(): number;
     /**
      * Set the line width on the context
      * @name setLineWidth
@@ -2246,7 +2321,7 @@ export class Ellipse {
      * @public
      * @type {Vector2d}
      * @name pos
-     * @memberof Ellipse#
+     * @memberof Ellipse.prototype
      */
     public pos: Vector2d;
     /**
@@ -2259,7 +2334,7 @@ export class Ellipse {
      * @public
      * @type {number}
      * @name radius
-     * @memberof Ellipse
+     * @memberof Ellipse.prototype
      */
     public radius: number;
     /**
@@ -2267,7 +2342,7 @@ export class Ellipse {
      * @public
      * @type {Vector2d}
      * @name radiusV
-     * @memberof Ellipse#
+     * @memberof Ellipse.prototype
      */
     public radiusV: Vector2d;
     /**
@@ -2275,7 +2350,7 @@ export class Ellipse {
      * @public
      * @type {Vector2d}
      * @name radiusSq
-     * @memberof Ellipse#
+     * @memberof Ellipse.prototype
      */
     public radiusSq: Vector2d;
     /**
@@ -2283,7 +2358,7 @@ export class Ellipse {
      * @public
      * @type {Vector2d}
      * @name ratio
-     * @memberof Ellipse#
+     * @memberof Ellipse.prototype
      */
     public ratio: Vector2d;
     shapeType: string;
@@ -2610,6 +2685,16 @@ export class GLShader {
      * myShader.setUniform("uProjectionMatrix", this.projectionMatrix);
      */
     setUniform(name: string, value: object | Float32Array): void;
+    /**
+     * activate the given vertex attribute for this shader
+     * @name setVertexAttributes
+     * @memberof GLShader
+     * @function
+     * @param {WebGLRenderingContext} gl the current WebGL rendering context
+     * @param {object[]} attributes an array of vertex attributes
+     * @param {number} vertexByteSize the size of a single vertex in bytes
+     */
+    setVertexAttributes(gl: WebGLRenderingContext, attributes: object[], vertexByteSize: number): void;
     /**
      * destroy this shader objects resources (program, attributes, uniforms)
      * @name destroy
@@ -4053,17 +4138,18 @@ export class ObservableVector3d extends Vector3d {
 /**
  * @classdesc
  * Single Particle Object.
- * @class Particle
  * @augments Renderable
- * @param {ParticleEmitter} particle emitter
  */
 export class Particle extends Renderable {
+    /**
+     * @param {ParticleEmitter} emitter the particle emitter
+     */
+    constructor(emitter: ParticleEmitter);
     /**
      * @ignore
      */
-    constructor(emitter: any);
-    vel: Vector2d;
     onResetEvent(emitter: any, newInstance?: boolean): void;
+    vel: any;
     image: any;
     life: any;
     startLife: any;
@@ -4075,50 +4161,604 @@ export class Particle extends Renderable {
     onlyInViewport: any;
     _deltaInv: number;
     angle: number;
-    /**
-     * @ignore
-     */
-    preDraw(renderer: any): void;
     /**
      * @ignore
      */
     draw(renderer: any): void;
 }
 /**
+ * @classdesc
  * Particle Emitter Object.
- * @class
- * @augments Rect
- * @param {number} x x-position of the particle emitter
- * @param {number} y y-position of the particle emitter
- * @param {object} settings An object containing the settings for the particle emitter. See {@link ParticleEmitterSettings}
- * @example
- * // Create a basic emitter at position 100, 100
- * var emitter = new me.ParticleEmitter(100, 100);
- *
- * // Adjust the emitter properties
- * emitter.totalParticles = 200;
- * emitter.minLife = 1000;
- * emitter.maxLife = 3000;
- * emitter.z = 10;
- *
- * // Add the emitter to the game world
- * me.game.world.addChild(emitter);
- *
- * // Launch all particles one time and stop, like a explosion
- * emitter.burstParticles();
- *
- * // Launch constantly the particles, like a fountain
- * emitter.streamParticles();
- *
- * // At the end, remove emitter from the game world
- * // call this in onDestroyEvent function
- * me.game.world.removeChild(emitter);
+ * @augments Container
  */
-export class ParticleEmitter extends Rect {
+export class ParticleEmitter extends Container {
     /**
-     * @ignore
+     * @param {number} x x position of the particle emitter
+     * @param {number} y y position of the particle emitter
+     * @param {ParticleEmitterSettings} [settings=ParticleEmitterSettings] the settings for the particle emitter.
+     * @example
+     * // Create a particle emitter at position 100, 100
+     * var emitter = new ParticleEmitter(100, 100, {
+     *     width: 16,
+     *     height : 16,
+     *     tint: "#f00",
+     *     totalParticles: 32,
+     *     angle: 0,
+     *     angleVariation: 6.283185307179586,
+     *     maxLife: 5,
+     *     speed: 3
+     * });
+     *
+     * // Add the emitter to the game world
+     * me.game.world.addChild(emitter);
+     *
+     * // Launch all particles one time and stop, like a explosion
+     * emitter.burstParticles();
+     *
+     * // Launch constantly the particles, like a fountain
+     * emitter.streamParticles();
+     *
+     * // At the end, remove emitter from the game world
+     * // call this in onDestroyEvent function
+     * me.game.world.removeChild(emitter);
      */
-    constructor(x: any, y: any, settings: any);
+    constructor(x: number, y: number, settings?: {
+        /**
+         * Width of the particle spawn area.
+         * @type {number}
+         * @name width
+         * @memberof ParticleEmitterSettings
+         * @default 1
+         */
+        width: number;
+        /**
+         * Height of the particle spawn area
+         * @public
+         * @type {number}
+         * @name height
+         * @memberof ParticleEmitterSettings
+         * @default 1
+         */
+        height: number;
+        /**
+         * image used for particles texture
+         * (by default melonJS will create an white 8x8 texture image)
+         * @public
+         * @type {HTMLCanvasElement}
+         * @name image
+         * @memberof ParticleEmitterSettings
+         * @default undefined
+         * @see ParticleEmitterSettings.textureSize
+         */
+        image: HTMLCanvasElement;
+        /**
+         * default texture size used for particles if no image is specified
+         * (by default melonJS will create an white 8x8 texture image)
+         * @public
+         * @type {number}
+         * @name textureSize
+         * @memberof ParticleEmitterSettings
+         * @default 8
+         * @see ParticleEmitterSettings.image
+         */
+        textureSize: number;
+        /**
+         * tint to be applied to particles
+         * @public
+         * @type {string}
+         * @name tint
+         * @memberof ParticleEmitterSettings
+         * @default "#fff"
+         */
+        tint: string;
+        /**
+         * Total number of particles in the emitter
+         * @public
+         * @type {number}
+         * @name totalParticles
+         * @default 50
+         * @memberof ParticleEmitterSettings
+         */
+        totalParticles: number;
+        /**
+         * Start angle for particle launch in Radians
+         * @public
+         * @type {number}
+         * @name angle
+         * @default Math.PI / 2
+         * @memberof ParticleEmitterSettings
+         */
+        angle: number;
+        /**
+         * Variation in the start angle for particle launch in Radians.
+         * @public
+         * @type {number}
+         * @name angleVariation
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        angleVariation: number;
+        /**
+         * Minimum time each particle lives once it is emitted in ms.
+         * @public
+         * @type {number}
+         * @name minLife
+         * @default 1000
+         * @memberof ParticleEmitterSettings
+         */
+        minLife: number;
+        /**
+         * Maximum time each particle lives once it is emitted in ms.
+         * @public
+         * @type {number}
+         * @name maxLife
+         * @default 3000
+         * @memberof ParticleEmitterSettings
+         */
+        maxLife: number;
+        /**
+         * Start speed of particles.<br>
+         * @public
+         * @type {number}
+         * @name speed
+         * @default 2
+         * @memberof ParticleEmitterSettings
+         */
+        speed: number;
+        /**
+         * Variation in the start speed of particles
+         * @public
+         * @type {number}
+         * @name speedVariation
+         * @default 1
+         * @memberof ParticleEmitterSettings
+         */
+        speedVariation: number;
+        /**
+         * Minimum start rotation for particles sprites in Radians
+         * @public
+         * @type {number}
+         * @name minRotation
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        minRotation: number;
+        /**
+         * Maximum start rotation for particles sprites in Radians
+         * @public
+         * @type {number}
+         * @name maxRotation
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        maxRotation: number;
+        /**
+         * Minimum start scale ratio for particles (1 = no scaling)
+         * @public
+         * @type {number}
+         * @name minStartScale
+         * @default 1
+         * @memberof ParticleEmitterSettings
+         */
+        minStartScale: number;
+        /**
+         * Maximum start scale ratio for particles (1 = no scaling)
+         * @public
+         * @type {number}
+         * @name maxStartScale
+         * @default 1
+         * @memberof ParticleEmitterSettings
+         */
+        maxStartScale: number;
+        /**
+         * Minimum end scale ratio for particles
+         * @public
+         * @type {number}
+         * @name minEndScale
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        minEndScale: number;
+        /**
+         * Maximum end scale ratio for particles
+         * @public
+         * @type {number}
+         * @name maxEndScale
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        maxEndScale: number;
+        /**
+         * Vertical force (Gravity) for each particle
+         * @public
+         * @type {number}
+         * @name gravity
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         * @see game.world.gravity
+         */
+        gravity: number;
+        /**
+         * Horizontal force (like a Wind) for each particle
+         * @public
+         * @type {number}
+         * @name wind
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        wind: number;
+        /**
+         * Update the rotation of particle in accordance the particle trajectory.<br>
+         * The particle sprite should aim at zero angle (draw from left to right).<br>
+         * Override the particle minRotation and maxRotation.<br>
+         * @public
+         * @type {boolean}
+         * @name followTrajectory
+         * @default false
+         * @memberof ParticleEmitterSettings
+         */
+        followTrajectory: boolean;
+        /**
+         * Enable the Texture Additive by composite operation ("additive" blendMode)
+         * @public
+         * @type {boolean}
+         * @name textureAdditive
+         * @default false
+         * @memberof ParticleEmitterSettings
+         * @see ParticleEmitterSettings.blendMode
+         */
+        textureAdditive: boolean;
+        /**
+         * the blend mode to be applied when rendering particles.
+         * (note: this will superseed the `textureAdditive` setting if different than "normal")
+         * @public
+         * @type {string}
+         * @name blendMode
+         * @default normal
+         * @memberof ParticleEmitterSettings
+         * @see CanvasRenderer#setBlendMode
+         * @see WebGLRenderer#setBlendMode
+         */
+        blendMode: string;
+        /**
+         * Update particles only in the viewport, remove it when out of viewport.
+         * @public
+         * @type {boolean}
+         * @name onlyInViewport
+         * @default true
+         * @memberof ParticleEmitterSettings
+         */
+        onlyInViewport: boolean;
+        /**
+         * Render particles in screen space.
+         * @public
+         * @type {boolean}
+         * @name floating
+         * @default false
+         * @memberof ParticleEmitterSettings
+         */
+        floating: boolean;
+        /**
+         * Maximum number of particles launched each time in this emitter (used only if emitter is Stream).
+         * @public
+         * @type {number}
+         * @name maxParticles
+         * @default 10
+         * @memberof ParticleEmitterSettings
+         */
+        maxParticles: number;
+        /**
+         * How often a particle is emitted in ms (used only if emitter is a Stream).
+         * @public
+         * @type {number}
+         * @name frequency
+         * @default 100
+         * @memberof ParticleEmitterSettings
+         */
+        frequency: number;
+        /**
+         * Duration that the emitter releases particles in ms (used only if emitter is Stream).
+         * After this period, the emitter stop the launch of particles.
+         * @public
+         * @type {number}
+         * @name duration
+         * @default Infinity
+         * @memberof ParticleEmitterSettings
+         */
+        duration: number;
+        /**
+         * Skip n frames after updating the particle system once.
+         * This can be used to reduce the performance impact of emitters with many particles.
+         * @public
+         * @type {number}
+         * @name framesToSkip
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        framesToSkip: number;
+    });
+    /**
+     * the current (active) emitter settings
+     * @public
+     * @type {ParticleEmitterSettings}
+     * @name settings
+     * @memberof ParticleEmitter
+     */
+    public settings: {
+        /**
+         * Width of the particle spawn area.
+         * @type {number}
+         * @name width
+         * @memberof ParticleEmitterSettings
+         * @default 1
+         */
+        width: number;
+        /**
+         * Height of the particle spawn area
+         * @public
+         * @type {number}
+         * @name height
+         * @memberof ParticleEmitterSettings
+         * @default 1
+         */
+        height: number;
+        /**
+         * image used for particles texture
+         * (by default melonJS will create an white 8x8 texture image)
+         * @public
+         * @type {HTMLCanvasElement}
+         * @name image
+         * @memberof ParticleEmitterSettings
+         * @default undefined
+         * @see ParticleEmitterSettings.textureSize
+         */
+        image: HTMLCanvasElement;
+        /**
+         * default texture size used for particles if no image is specified
+         * (by default melonJS will create an white 8x8 texture image)
+         * @public
+         * @type {number}
+         * @name textureSize
+         * @memberof ParticleEmitterSettings
+         * @default 8
+         * @see ParticleEmitterSettings.image
+         */
+        textureSize: number;
+        /**
+         * tint to be applied to particles
+         * @public
+         * @type {string}
+         * @name tint
+         * @memberof ParticleEmitterSettings
+         * @default "#fff"
+         */
+        tint: string;
+        /**
+         * Total number of particles in the emitter
+         * @public
+         * @type {number}
+         * @name totalParticles
+         * @default 50
+         * @memberof ParticleEmitterSettings
+         */
+        totalParticles: number;
+        /**
+         * Start angle for particle launch in Radians
+         * @public
+         * @type {number}
+         * @name angle
+         * @default Math.PI / 2
+         * @memberof ParticleEmitterSettings
+         */
+        angle: number;
+        /**
+         * Variation in the start angle for particle launch in Radians.
+         * @public
+         * @type {number}
+         * @name angleVariation
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        angleVariation: number;
+        /**
+         * Minimum time each particle lives once it is emitted in ms.
+         * @public
+         * @type {number}
+         * @name minLife
+         * @default 1000
+         * @memberof ParticleEmitterSettings
+         */
+        minLife: number;
+        /**
+         * Maximum time each particle lives once it is emitted in ms.
+         * @public
+         * @type {number}
+         * @name maxLife
+         * @default 3000
+         * @memberof ParticleEmitterSettings
+         */
+        maxLife: number;
+        /**
+         * Start speed of particles.<br>
+         * @public
+         * @type {number}
+         * @name speed
+         * @default 2
+         * @memberof ParticleEmitterSettings
+         */
+        speed: number;
+        /**
+         * Variation in the start speed of particles
+         * @public
+         * @type {number}
+         * @name speedVariation
+         * @default 1
+         * @memberof ParticleEmitterSettings
+         */
+        speedVariation: number;
+        /**
+         * Minimum start rotation for particles sprites in Radians
+         * @public
+         * @type {number}
+         * @name minRotation
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        minRotation: number;
+        /**
+         * Maximum start rotation for particles sprites in Radians
+         * @public
+         * @type {number}
+         * @name maxRotation
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        maxRotation: number;
+        /**
+         * Minimum start scale ratio for particles (1 = no scaling)
+         * @public
+         * @type {number}
+         * @name minStartScale
+         * @default 1
+         * @memberof ParticleEmitterSettings
+         */
+        minStartScale: number;
+        /**
+         * Maximum start scale ratio for particles (1 = no scaling)
+         * @public
+         * @type {number}
+         * @name maxStartScale
+         * @default 1
+         * @memberof ParticleEmitterSettings
+         */
+        maxStartScale: number;
+        /**
+         * Minimum end scale ratio for particles
+         * @public
+         * @type {number}
+         * @name minEndScale
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        minEndScale: number;
+        /**
+         * Maximum end scale ratio for particles
+         * @public
+         * @type {number}
+         * @name maxEndScale
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        maxEndScale: number;
+        /**
+         * Vertical force (Gravity) for each particle
+         * @public
+         * @type {number}
+         * @name gravity
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         * @see game.world.gravity
+         */
+        gravity: number;
+        /**
+         * Horizontal force (like a Wind) for each particle
+         * @public
+         * @type {number}
+         * @name wind
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        wind: number;
+        /**
+         * Update the rotation of particle in accordance the particle trajectory.<br>
+         * The particle sprite should aim at zero angle (draw from left to right).<br>
+         * Override the particle minRotation and maxRotation.<br>
+         * @public
+         * @type {boolean}
+         * @name followTrajectory
+         * @default false
+         * @memberof ParticleEmitterSettings
+         */
+        followTrajectory: boolean;
+        /**
+         * Enable the Texture Additive by composite operation ("additive" blendMode)
+         * @public
+         * @type {boolean}
+         * @name textureAdditive
+         * @default false
+         * @memberof ParticleEmitterSettings
+         * @see ParticleEmitterSettings.blendMode
+         */
+        textureAdditive: boolean;
+        /**
+         * the blend mode to be applied when rendering particles.
+         * (note: this will superseed the `textureAdditive` setting if different than "normal")
+         * @public
+         * @type {string}
+         * @name blendMode
+         * @default normal
+         * @memberof ParticleEmitterSettings
+         * @see CanvasRenderer#setBlendMode
+         * @see WebGLRenderer#setBlendMode
+         */
+        blendMode: string;
+        /**
+         * Update particles only in the viewport, remove it when out of viewport.
+         * @public
+         * @type {boolean}
+         * @name onlyInViewport
+         * @default true
+         * @memberof ParticleEmitterSettings
+         */
+        onlyInViewport: boolean;
+        /**
+         * Render particles in screen space.
+         * @public
+         * @type {boolean}
+         * @name floating
+         * @default false
+         * @memberof ParticleEmitterSettings
+         */
+        floating: boolean;
+        /**
+         * Maximum number of particles launched each time in this emitter (used only if emitter is Stream).
+         * @public
+         * @type {number}
+         * @name maxParticles
+         * @default 10
+         * @memberof ParticleEmitterSettings
+         */
+        maxParticles: number;
+        /**
+         * How often a particle is emitted in ms (used only if emitter is a Stream).
+         * @public
+         * @type {number}
+         * @name frequency
+         * @default 100
+         * @memberof ParticleEmitterSettings
+         */
+        frequency: number;
+        /**
+         * Duration that the emitter releases particles in ms (used only if emitter is Stream).
+         * After this period, the emitter stop the launch of particles.
+         * @public
+         * @type {number}
+         * @name duration
+         * @default Infinity
+         * @memberof ParticleEmitterSettings
+         */
+        duration: number;
+        /**
+         * Skip n frames after updating the particle system once.
+         * This can be used to reduce the performance impact of emitters with many particles.
+         * @public
+         * @type {number}
+         * @name framesToSkip
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        framesToSkip: number;
+    };
     /** @ignore */
     _stream: boolean;
     /** @ignore */
@@ -4127,95 +4767,316 @@ export class ParticleEmitter extends Rect {
     _durationTimer: number;
     /** @ignore */
     _enabled: boolean;
-    alwaysUpdate: boolean;
-    autoSort: boolean;
-    container: ParticleContainer;
-    /**
-     * @ignore
-     */
-    set z(arg: number);
-    /**
-     * @ignore
-     */
-    get z(): number;
-    set floating(arg: boolean);
-    /**
-     * Floating property for particles, value is forwarded to the particle container <br>
-     * @type {boolean}
-     * @name floating
-     * @memberof ParticleEmitter
-     */
-    get floating(): boolean;
-    /**
-     * @ignore
-     */
-    onActivateEvent(): void;
-    /**
-     * @ignore
-     */
-    onDeactivateEvent(): void;
+    _updateCount: number;
+    _dt: number;
     /**
-     * @ignore
+     * Reset the emitter with particle emitter settings.
+     * @param {ParticleEmitterSettings} settings [optional] object with emitter settings. See {@link ParticleEmitterSettings}
      */
-    destroy(): void;
+    reset(settings?: {
+        /**
+         * Width of the particle spawn area.
+         * @type {number}
+         * @name width
+         * @memberof ParticleEmitterSettings
+         * @default 1
+         */
+        width: number;
+        /**
+         * Height of the particle spawn area
+         * @public
+         * @type {number}
+         * @name height
+         * @memberof ParticleEmitterSettings
+         * @default 1
+         */
+        height: number;
+        /**
+         * image used for particles texture
+         * (by default melonJS will create an white 8x8 texture image)
+         * @public
+         * @type {HTMLCanvasElement}
+         * @name image
+         * @memberof ParticleEmitterSettings
+         * @default undefined
+         * @see ParticleEmitterSettings.textureSize
+         */
+        image: HTMLCanvasElement;
+        /**
+         * default texture size used for particles if no image is specified
+         * (by default melonJS will create an white 8x8 texture image)
+         * @public
+         * @type {number}
+         * @name textureSize
+         * @memberof ParticleEmitterSettings
+         * @default 8
+         * @see ParticleEmitterSettings.image
+         */
+        textureSize: number;
+        /**
+         * tint to be applied to particles
+         * @public
+         * @type {string}
+         * @name tint
+         * @memberof ParticleEmitterSettings
+         * @default "#fff"
+         */
+        tint: string;
+        /**
+         * Total number of particles in the emitter
+         * @public
+         * @type {number}
+         * @name totalParticles
+         * @default 50
+         * @memberof ParticleEmitterSettings
+         */
+        totalParticles: number;
+        /**
+         * Start angle for particle launch in Radians
+         * @public
+         * @type {number}
+         * @name angle
+         * @default Math.PI / 2
+         * @memberof ParticleEmitterSettings
+         */
+        angle: number;
+        /**
+         * Variation in the start angle for particle launch in Radians.
+         * @public
+         * @type {number}
+         * @name angleVariation
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        angleVariation: number;
+        /**
+         * Minimum time each particle lives once it is emitted in ms.
+         * @public
+         * @type {number}
+         * @name minLife
+         * @default 1000
+         * @memberof ParticleEmitterSettings
+         */
+        minLife: number;
+        /**
+         * Maximum time each particle lives once it is emitted in ms.
+         * @public
+         * @type {number}
+         * @name maxLife
+         * @default 3000
+         * @memberof ParticleEmitterSettings
+         */
+        maxLife: number;
+        /**
+         * Start speed of particles.<br>
+         * @public
+         * @type {number}
+         * @name speed
+         * @default 2
+         * @memberof ParticleEmitterSettings
+         */
+        speed: number;
+        /**
+         * Variation in the start speed of particles
+         * @public
+         * @type {number}
+         * @name speedVariation
+         * @default 1
+         * @memberof ParticleEmitterSettings
+         */
+        speedVariation: number;
+        /**
+         * Minimum start rotation for particles sprites in Radians
+         * @public
+         * @type {number}
+         * @name minRotation
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        minRotation: number;
+        /**
+         * Maximum start rotation for particles sprites in Radians
+         * @public
+         * @type {number}
+         * @name maxRotation
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        maxRotation: number;
+        /**
+         * Minimum start scale ratio for particles (1 = no scaling)
+         * @public
+         * @type {number}
+         * @name minStartScale
+         * @default 1
+         * @memberof ParticleEmitterSettings
+         */
+        minStartScale: number;
+        /**
+         * Maximum start scale ratio for particles (1 = no scaling)
+         * @public
+         * @type {number}
+         * @name maxStartScale
+         * @default 1
+         * @memberof ParticleEmitterSettings
+         */
+        maxStartScale: number;
+        /**
+         * Minimum end scale ratio for particles
+         * @public
+         * @type {number}
+         * @name minEndScale
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        minEndScale: number;
+        /**
+         * Maximum end scale ratio for particles
+         * @public
+         * @type {number}
+         * @name maxEndScale
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        maxEndScale: number;
+        /**
+         * Vertical force (Gravity) for each particle
+         * @public
+         * @type {number}
+         * @name gravity
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         * @see game.world.gravity
+         */
+        gravity: number;
+        /**
+         * Horizontal force (like a Wind) for each particle
+         * @public
+         * @type {number}
+         * @name wind
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        wind: number;
+        /**
+         * Update the rotation of particle in accordance the particle trajectory.<br>
+         * The particle sprite should aim at zero angle (draw from left to right).<br>
+         * Override the particle minRotation and maxRotation.<br>
+         * @public
+         * @type {boolean}
+         * @name followTrajectory
+         * @default false
+         * @memberof ParticleEmitterSettings
+         */
+        followTrajectory: boolean;
+        /**
+         * Enable the Texture Additive by composite operation ("additive" blendMode)
+         * @public
+         * @type {boolean}
+         * @name textureAdditive
+         * @default false
+         * @memberof ParticleEmitterSettings
+         * @see ParticleEmitterSettings.blendMode
+         */
+        textureAdditive: boolean;
+        /**
+         * the blend mode to be applied when rendering particles.
+         * (note: this will superseed the `textureAdditive` setting if different than "normal")
+         * @public
+         * @type {string}
+         * @name blendMode
+         * @default normal
+         * @memberof ParticleEmitterSettings
+         * @see CanvasRenderer#setBlendMode
+         * @see WebGLRenderer#setBlendMode
+         */
+        blendMode: string;
+        /**
+         * Update particles only in the viewport, remove it when out of viewport.
+         * @public
+         * @type {boolean}
+         * @name onlyInViewport
+         * @default true
+         * @memberof ParticleEmitterSettings
+         */
+        onlyInViewport: boolean;
+        /**
+         * Render particles in screen space.
+         * @public
+         * @type {boolean}
+         * @name floating
+         * @default false
+         * @memberof ParticleEmitterSettings
+         */
+        floating: boolean;
+        /**
+         * Maximum number of particles launched each time in this emitter (used only if emitter is Stream).
+         * @public
+         * @type {number}
+         * @name maxParticles
+         * @default 10
+         * @memberof ParticleEmitterSettings
+         */
+        maxParticles: number;
+        /**
+         * How often a particle is emitted in ms (used only if emitter is a Stream).
+         * @public
+         * @type {number}
+         * @name frequency
+         * @default 100
+         * @memberof ParticleEmitterSettings
+         */
+        frequency: number;
+        /**
+         * Duration that the emitter releases particles in ms (used only if emitter is Stream).
+         * After this period, the emitter stop the launch of particles.
+         * @public
+         * @type {number}
+         * @name duration
+         * @default Infinity
+         * @memberof ParticleEmitterSettings
+         */
+        duration: number;
+        /**
+         * Skip n frames after updating the particle system once.
+         * This can be used to reduce the performance impact of emitters with many particles.
+         * @public
+         * @type {number}
+         * @name framesToSkip
+         * @default 0
+         * @memberof ParticleEmitterSettings
+         */
+        framesToSkip: number;
+    }): void;
     /**
-     * returns a random point inside the bounds x axis of this emitter
-     * @name getRandomPointX
-     * @memberof ParticleEmitter
-     * @function
+     * returns a random point on the x axis within the bounds of this emitter
      * @returns {number}
      */
     getRandomPointX(): number;
     /**
-     * returns a random point inside the bounds y axis of this emitter
-     * @name getRandomPointY
-     * @memberof ParticleEmitter
-     * @function
+     * returns a random point on the y axis within the bounds this emitter
      * @returns {number}
      */
     getRandomPointY(): number;
-    /**
-     * Reset the emitter with default values.<br>
-     * @function
-     * @param {object} settings [optional] object with emitter settings. See {@link ParticleEmitterSettings}
-     * @name reset
-     * @memberof ParticleEmitter
-     */
-    reset(settings: object): void;
     /** @ignore */
     addParticles(count: any): void;
     /**
-     * Emitter is of type stream and is launching particles <br>
-     * @function
+     * Emitter is of type stream and is launching particles
      * @returns {boolean} Emitter is Stream and is launching particles
-     * @name isRunning
-     * @memberof ParticleEmitter
      */
     isRunning(): boolean;
     /**
-     * Launch particles from emitter constantly <br>
-     * Particles example: Fountains
+     * Launch particles from emitter constantly (e.g. for stream)
      * @param {number} duration [optional] time that the emitter releases particles in ms
-     * @function
-     * @name streamParticles
-     * @memberof ParticleEmitter
      */
     streamParticles(duration: number): void;
-    frequency: any;
     /**
-     * Stop the emitter from generating new particles (used only if emitter is Stream) <br>
-     * @function
-     * @name stopStream
-     * @memberof ParticleEmitter
+     * Stop the emitter from generating new particles (used only if emitter is Stream)
      */
     stopStream(): void;
     /**
-     * Launch all particles from emitter and stop <br>
-     * Particles example: Explosions <br>
+     * Launch all particles from emitter and stop (e.g. for explosion)
      * @param {number} total [optional] number of particles to launch
-     * @function
-     * @name burstParticles
-     * @memberof ParticleEmitter
      */
     burstParticles(total: number): void;
     /**
@@ -4224,32 +5085,35 @@ export class ParticleEmitter extends Rect {
     update(dt: any): boolean;
 }
 export namespace ParticleEmitterSettings {
-    export const width: number;
-    export const height: number;
-    export { pixel as image };
-    export const totalParticles: number;
-    export const angle: number;
-    export const angleVariation: number;
-    export const minLife: number;
-    export const maxLife: number;
-    export const speed: number;
-    export const speedVariation: number;
-    export const minRotation: number;
-    export const maxRotation: number;
-    export const minStartScale: number;
-    export const maxStartScale: number;
-    export const minEndScale: number;
-    export const maxEndScale: number;
-    export const gravity: number;
-    export const wind: number;
-    export const followTrajectory: boolean;
-    export const textureAdditive: boolean;
-    export const onlyInViewport: boolean;
-    export const floating: boolean;
-    export const maxParticles: number;
-    export const frequency: number;
-    export const duration: number;
-    export const framesToSkip: number;
+    const width: number;
+    const height: number;
+    const image: HTMLCanvasElement;
+    const textureSize: number;
+    const tint: string;
+    const totalParticles: number;
+    const angle: number;
+    const angleVariation: number;
+    const minLife: number;
+    const maxLife: number;
+    const speed: number;
+    const speedVariation: number;
+    const minRotation: number;
+    const maxRotation: number;
+    const minStartScale: number;
+    const maxStartScale: number;
+    const minEndScale: number;
+    const maxEndScale: number;
+    const gravity: number;
+    const wind: number;
+    const followTrajectory: boolean;
+    const textureAdditive: boolean;
+    const blendMode: string;
+    const onlyInViewport: boolean;
+    const floating: boolean;
+    const maxParticles: number;
+    const frequency: number;
+    const duration: number;
+    const framesToSkip: number;
 }
 /**
  * @classdesc
@@ -4541,7 +5405,7 @@ export class Polygon {
      * @public
      * @type {Vector2d}
      * @name pos
-     * @memberof Polygon#
+     * @memberof Polygon.prototype
      */
     public pos: Vector2d;
     /**
@@ -4549,7 +5413,7 @@ export class Polygon {
      * @ignore
      * @type {Bounds}
      * @name _bounds
-     * @memberof Polygon#
+     * @memberof Polygon.prototype
      */
     _bounds: Bounds;
     /**
@@ -4558,7 +5422,7 @@ export class Polygon {
      * @public
      * @type {Vector2d[]}
      * @name points
-     * @memberof Polygon#
+     * @memberof Polygon.prototype
      */
     public points: Vector2d[];
     /**
@@ -4703,14 +5567,14 @@ export class Polygon {
     /**
      * Shifts the Polygon to the given position vector.
      * @name shift
-     * @memberof Polygon
+     * @memberof Polygon.prototype
      * @function
      * @param {Vector2d} position
      */
     /**
      * Shifts the Polygon to the given x, y position.
      * @name shift
-     * @memberof Polygon
+     * @memberof Polygon.prototype
      * @function
      * @param {number} x
      * @param {number} y
@@ -4880,7 +5744,7 @@ export class Rect extends Polygon {
      * @public
      * @type {number}
      * @name left
-     * @memberof Rect
+     * @memberof Rect.prototype
      */
     public get left(): number;
     /**
@@ -4888,7 +5752,7 @@ export class Rect extends Polygon {
      * @public
      * @type {number}
      * @name right
-     * @memberof Rect
+     * @memberof Rect.prototype
      */
     public get right(): number;
     /**
@@ -4896,7 +5760,7 @@ export class Rect extends Polygon {
      * @public
      * @type {number}
      * @name top
-     * @memberof Rect
+     * @memberof Rect.prototype
      */
     public get top(): number;
     /**
@@ -4904,7 +5768,7 @@ export class Rect extends Polygon {
      * @public
      * @type {number}
      * @name bottom
-     * @memberof Rect
+     * @memberof Rect.prototype
      */
     public get bottom(): number;
     public set width(arg: number);
@@ -4913,7 +5777,7 @@ export class Rect extends Polygon {
      * @public
      * @type {number}
      * @name width
-     * @memberof Rect
+     * @memberof Rect.prototype
      */
     public get width(): number;
     public set height(arg: number);
@@ -4922,7 +5786,7 @@ export class Rect extends Polygon {
      * @public
      * @type {number}
      * @name height
-     * @memberof Rect
+     * @memberof Rect.prototype
      */
     public get height(): number;
     public set centerX(arg: number);
@@ -4931,7 +5795,7 @@ export class Rect extends Polygon {
      * @public
      * @type {number}
      * @name centerX
-     * @memberof Rect
+     * @memberof Rect.prototype
      */
     public get centerX(): number;
     public set centerY(arg: number);
@@ -4940,9 +5804,19 @@ export class Rect extends Polygon {
      * @public
      * @type {number}
      * @name centerY
-     * @memberof Rect
+     * @memberof Rect.prototype
      */
     public get centerY(): number;
+    /**
+     * center the rectangle position around the given coordinates
+     * @name centerOn
+     * @memberof Rect.prototype
+     * @function
+     * @param {number} x the x coordinate around which to center this rectangle
+     * @param {number} x the y coordinate around which to center this rectangle
+     * @returns {Rect} this rectangle
+     */
+    centerOn(x: number, y: any): Rect;
     /**
      * resize the rectangle
      * @name resize
@@ -5597,11 +6471,18 @@ export class Renderer {
     /**
      * true if the current rendering context is valid
      * @name isContextValid
-     * @memberof Renderer
+     * @memberof Renderer#
      * @default true
      * type {boolean}
      */
     isContextValid: boolean;
+    /**
+     * The Path2D instance used by the renderer to draw primitives
+     * @name path2D
+     * @type {Path2D}
+     * @memberof Renderer#
+     */
+    path2D: Path2D;
     /**
      * @ignore
      */
@@ -5747,10 +6628,18 @@ export class Renderer {
      * @name stroke
      * @memberof Renderer.prototype
      * @function
-     * @param {Rect|Polygon|Line|Ellipse} shape a shape object to stroke
+     * @param {Rect|RoundRect|Polygon|Line|Ellipse} shape a shape object to stroke
      * @param {boolean} [fill=false] fill the shape with the current color if true
      */
-    stroke(shape: Rect | Polygon | Line | Ellipse, fill?: boolean): void;
+    stroke(shape: Rect | RoundRect | Polygon | Line | Ellipse, fill?: boolean): void;
+    /**
+     * fill the given shape
+     * @name fill
+     * @memberof Renderer.prototype
+     * @function
+     * @param {Rect|Polygon|Line|Ellipse} shape a shape object to fill
+     */
+    fill(shape: Rect | Polygon | Line | Ellipse): void;
     /**
      * tint the given image or canvas using the given color
      * @name tint
@@ -5762,14 +6651,6 @@ export class Renderer {
      * @returns {HTMLCanvasElement|OffscreenCanvas} a new canvas element representing the tinted image
      */
     tint(src: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas, color: Color | string, mode?: string): HTMLCanvasElement | OffscreenCanvas;
-    /**
-     * fill the given shape
-     * @name fill
-     * @memberof Renderer.prototype
-     * @function
-     * @param {Rect|Polygon|Line|Ellipse} shape a shape object to fill
-     */
-    fill(shape: Rect | Polygon | Line | Ellipse): void;
     /**
      * A mask limits rendering elements to the shape and position of the given mask object.
      * So, if the renderable is larger than the mask, only the intersecting part of the renderable will be visible.
@@ -5811,6 +6692,42 @@ export class Renderer {
     drawFont(): void;
     get Texture(): typeof TextureAtlas;
 }
+/**
+ * @classdesc
+ * a rectangle object with rounded corners
+ * @augments Rect
+ */
+export 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: number, y: number, width: number, height: number, radius?: number);
+    public set radius(arg: number);
+    /**
+     * the radius of the rounded corner
+     * @public
+     * @type {number}
+     * @default 20
+     * @name radius
+     * @memberof RoundRect.prototype
+     */
+    public get radius(): number;
+    /** @ignore */
+    onResetEvent(x: any, y: any, w: any, h: any, radius: any): void;
+    _radius: number;
+    /**
+     * clone this RoundRect
+     * @name clone
+     * @memberof RoundRect.prototype
+     * @function
+     * @returns {RoundRect} new RoundRect
+     */
+    clone(): RoundRect;
+}
 /**
  * @classdesc
  * An object to display a fixed or animated sprite on screen.
@@ -5898,7 +6815,7 @@ export class Sprite extends Renderable {
     current: {
         name: string;
         length: number;
-        offset: Vector2d;
+        offset: any;
         width: number;
         height: number;
         angle: number;
@@ -6110,11 +7027,11 @@ export class Stage {
      * Cameras will be renderered based on this order defined in this list.
      * Only the "default" camera will be resized when the window or canvas is resized.
      * @public
-     * @type {Map}
+     * @type {Map<Camera2d>}
      * @name cameras
      * @memberof Stage
      */
-    public cameras: Map<any, any>;
+    public cameras: Map<Camera2d, any>;
     /**
      * The given constructor options
      * @public
@@ -8564,7 +9481,7 @@ export class WebGLRenderer extends Renderer {
     /**
      * The WebGL version used by this renderer (1 or 2)
      * @name WebGLVersion
-     * @memberof WebGLRenderer
+     * @memberof WebGLRenderer#
      * @type {number}
      * @default 1
      * @readonly
@@ -8573,7 +9490,7 @@ export class WebGLRenderer extends Renderer {
     /**
      * The vendor string of the underlying graphics driver.
      * @name GPUVendor
-     * @memberof WebGLRenderer
+     * @memberof WebGLRenderer#
      * @type {string}
      * @default null
      * @readonly
@@ -8582,7 +9499,7 @@ export class WebGLRenderer extends Renderer {
     /**
      * The renderer string of the underlying graphics driver.
      * @name GPURenderer
-     * @memberof WebGLRenderer
+     * @memberof WebGLRenderer#
      * @type {string}
      * @default null
      * @readonly
@@ -8591,7 +9508,7 @@ export class WebGLRenderer extends Renderer {
     /**
      * The WebGL context
      * @name gl
-     * @memberof WebGLRenderer
+     * @memberof WebGLRenderer#
      * type {WebGLRenderingContext}
      */
     context: WebGLRenderingContext;
@@ -8599,7 +9516,7 @@ export class WebGLRenderer extends Renderer {
     /**
      * Maximum number of texture unit supported under the current context
      * @name maxTextures
-     * @memberof WebGLRenderer
+     * @memberof WebGLRenderer#
      * @type {number}
      * @readonly
      */
@@ -8620,10 +9537,6 @@ export class WebGLRenderer extends Renderer {
      * @ignore
      */
     _blendStack: any[];
-    /**
-     * @ignore
-     */
-    _glPoints: Vector2d[];
     /**
      * The current transformation matrix used for transformations on the overall scene
      * @name currentTransform
@@ -8641,10 +9554,10 @@ export class WebGLRenderer extends Renderer {
     /**
      * The list of active compositors
      * @name compositors
-     * @type {Map}
+     * @type {Map<WebGLCompositor>}
      * @memberof WebGLRenderer#
      */
-    compositors: Map<any, any>;
+    compositors: Map<WebGLCompositor, any>;
     cache: TextureCache;
     /**
      * set the active compositor for this renderer
@@ -8791,7 +9704,7 @@ export class WebGLRenderer extends Renderer {
      * <img src="images/normal-blendmode.png" width="510"/> <br>
      * - "multiply" : the pixels of the top layer are multiplied with the corresponding pixel of the bottom layer. A darker picture is the result. <br>
      * <img src="images/multiply-blendmode.png" width="510"/> <br>
-     * - "lighter" : where both content overlap the color is determined by adding color values. <br>
+     * - "additive or lighter" : where both content overlap the color is determined by adding color values. <br>
      * <img src="images/lighter-blendmode.png" width="510"/> <br>
      * - "screen" : The pixels are inverted, multiplied, and inverted again. A lighter picture is the result (opposite of multiply) <br>
      * <img src="images/screen-blendmode.png" width="510"/> <br>
@@ -8799,7 +9712,7 @@ export class WebGLRenderer extends Renderer {
      * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation
      * @memberof WebGLRenderer.prototype
      * @function
-     * @param {string} [mode="normal"] blend mode : "normal", "multiply", "lighter", "screen"
+     * @param {string} [mode="normal"] blend mode : "normal", "multiply", "lighter", "additive", "screen"
      * @param {WebGLRenderingContext} [gl]
      */
     setBlendMode(mode?: string, gl?: WebGLRenderingContext): void;
@@ -8853,6 +9766,14 @@ export class WebGLRenderer extends Renderer {
      * @param {number} alpha 0.0 to 1.0 values accepted.
      */
     setGlobalAlpha(alpha: number): void;
+    /**
+     * Return the global alpha
+     * @name getGlobalAlpha
+     * @memberof WebGLRenderer.prototype
+     * @function
+     * @returns {number} global alpha value
+     */
+    getGlobalAlpha(): number;
     /**
      * Set the current fill & stroke style color.
      * By default, or upon reset, the value is set to #000000.
@@ -8896,7 +9817,7 @@ export class WebGLRenderer extends Renderer {
      * @param {number} end end angle in radians
      * @param {boolean} [antiClockwise=false] draw arc anti-clockwise
      */
-    fillArc(x: number, y: number, radius: number, start: number, end: number): void;
+    fillArc(x: number, y: number, radius: number, start: number, end: number, antiClockwise?: boolean): void;
     /**
      * Stroke an ellipse at the specified coordinates with given radius
      * @name strokeEllipse
@@ -8982,6 +9903,31 @@ export class WebGLRenderer extends Renderer {
      * @param {number} height
      */
     fillRect(x: number, y: number, width: number, height: number): void;
+    /**
+     * Stroke a rounded rectangle at the specified coordinates
+     * @name strokeRoundRect
+     * @memberof WebGLRenderer.prototype
+     * @function
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {number} radius
+     * @param {boolean} [fill=false] also fill the shape with the current color if true
+     */
+    strokeRoundRect(x: number, y: number, width: number, height: number, radius: number, fill?: boolean): void;
+    /**
+     * Draw a rounded filled rectangle at the specified coordinates
+     * @name fillRoundRect
+     * @memberof WebGLRenderer.prototype
+     * @function
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {number} radius
+     */
+    fillRoundRect(x: number, y: number, width: number, height: number, radius: number): void;
     /**
      * Reset (overrides) the renderer transformation matrix to the
      * identity one, and then apply the given transformation matrix.
@@ -9075,9 +10021,9 @@ export class World extends Container {
      * @name bodies
      * @memberof World
      * @public
-     * @type {Set}
+     * @type {Set<Body>}
      */
-    public bodies: Set<any>;
+    public bodies: Set<Body>;
     /**
      * the instance of the game world quadtree used for broadphase
      * @name broadphase
@@ -9158,7 +10104,7 @@ declare namespace device$1 {
     namespace turnOnPointerLock { }
     namespace turnOffPointerLock { }
 }
-export var event: Readonly<{
+declare var event$1: Readonly<{
     __proto__: any;
     BOOT: string;
     STATE_PAUSE: string;
@@ -9191,8 +10137,8 @@ export var event: Readonly<{
     WINDOW_ONORIENTATION_CHANGE: string;
     WINDOW_ONSCROLL: string;
     VIEWPORT_ONCHANGE: string;
-    WEBGL_ONCONTEXT_LOST: string;
-    WEBGL_ONCONTEXT_RESTORED: string;
+    ONCONTEXT_LOST: string;
+    ONCONTEXT_RESTORED: string;
     emit: typeof emit;
     on: typeof on;
     once: typeof once;
@@ -10165,16 +11111,12 @@ export var plugin: any;
  * @namespace plugins
  */
 export var plugins: {};
-declare var pooling: Readonly<{
-    __proto__: any;
-    register: typeof register;
-    pull: typeof pull;
-    purge: typeof purge;
-    push: typeof push;
-    exists: typeof exists;
-    poolable: typeof poolable;
-    getInstanceCount: typeof getInstanceCount;
-}>;
+/**
+ * a default global object pool instance
+ * @public
+ * @type {ObjectPool}
+ */
+declare var pool$1: ObjectPool;
 export namespace save {
     /**
      * Add new keys to localStorage and set them to the given default values if they do not exist
@@ -10829,6 +11771,7 @@ declare class Bounds {
      * @param {Vector2d[]} [vertices] an array of me.Vector2d points
      */
     constructor(vertices?: Vector2d[]);
+    _center: Vector2d;
     /**
      * @ignore
      */
@@ -10841,7 +11784,6 @@ declare class Bounds {
         x: number;
         y: number;
     };
-    _center: Vector2d;
     /**
      * reset the bound
      * @name clear
@@ -11259,29 +12201,135 @@ declare function round(num: number, dec?: number): number;
 declare function toBeCloseTo(expected: number, actual: number, precision?: number): boolean;
 /**
  * @classdesc
- * Particle Container Object.
- * @class ParticleContainer
- * @augments Container
- * @param {ParticleEmitter} emitter the emitter which owns this container
+ * a simplified path2d implementation, supporting only one path
  */
-declare class ParticleContainer extends Container {
+declare class Path2D {
     /**
-     * @ignore
+     * the points defining the current path
+     * @public
+     * @type {Vector2d[]}
+     * @name points
+     * @memberof Path2D#
      */
-    constructor(emitter: any);
-    _updateCount: number;
-    _dt: number;
-    _emitter: any;
+    public points: Vector2d[];
     /**
-     * @ignore
+     * space between interpolated points for quadratic and bezier curve approx. in pixels.
+     * @public
+     * @type {number}
+     * @name arcResolution
+     * @default 5
+     * @memberof Path2D#
      */
-    update(dt: any): boolean;
+    public arcResolution: number;
+    vertices: any[];
     /**
-     * @ignore
+     * begin a new path
+     * @name beginPath
+     * @memberof Path2D.prototype
+     * @function
      */
-    draw(renderer: any, rect: any): void;
+    beginPath(): void;
+    /**
+     * 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.prototype
+     * @function
+     */
+    closePath(): void;
+    /**
+     * triangulate the shape defined by this path into an array of triangles
+     * @name triangulatePath
+     * @memberof Path2D.prototype
+     * @function
+     * @returns {Vector2d[]}
+     */
+    triangulatePath(): Vector2d[];
+    /**
+     * moves the starting point of the current path to the (x, y) coordinates.
+     * @name moveTo
+     * @memberof Path2D.prototype
+     * @function
+     * @param {number} x the x-axis (horizontal) coordinate of the point.
+     * @param {number} y the y-axis (vertical) coordinate of the point.
+     */
+    moveTo(x: number, y: number): void;
+    /**
+     * connects the last point in the current patch to the (x, y) coordinates with a straight line.
+     * @name lineTo
+     * @memberof Path2D.prototype
+     * @function
+     * @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: number, y: number): void;
+    /**
+     * 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.prototype
+     * @function
+     * @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.
+     * @param {number} startAngle the angle at which the arc starts in radians, measured from the positive x-axis.
+     * @param {number} endAngle the angle at which the arc ends in radians, measured from the positive x-axis.
+     * @param {boolean} [anticlockwise=false] an optional boolean value. If true, draws the arc counter-clockwise between the start and end angles.
+     */
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
+    /**
+     * 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.prototype
+     * @function
+     * @param {number} x the x-axis coordinate of the first control point.
+     * @param {number} y the y-axis coordinate of the first control point.
+     * @param {number} x the x-axis coordinate of the second control point.
+     * @param {number} y the y-axis coordinate of the second control point.
+     * @param {number} radius the arc's radius. Must be positive.
+     */
+    arcTo(x1: any, y1: any, x2: any, y2: any, radius: number): void;
+    /**
+     * 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.prototype
+     * @function
+     * @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.
+     * @param {number} radiusY the ellipse's minor-axis radius. Must be non-negative.
+     * @param {number} rotation the rotation of the ellipse, expressed in radians.
+     * @param {number} startAngle the angle at which the ellipse starts, measured clockwise from the positive x-axis and expressed in radians.
+     * @param {number} endAngle the angle at which the ellipse ends, measured clockwise from the positive x-axis and expressed in radians.
+     * @param {boolean} [anticlockwise=false] an optional boolean value which, if true, draws the ellipse counterclockwise (anticlockwise).
+     */
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
+    /**
+     * creates a path for a rectangle at position (x, y) with a size that is determined by width and height.
+     * @name rect
+     * @memberof Path2D.prototype
+     * @function
+     * @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.
+     * @param {number} height the rectangle's height. Positive values are down, and negative are up.
+     */
+    rect(x: number, y: number, width: number, height: number): void;
+    /**
+     * adds an rounded rectangle to the current path.
+     * @name roundRect
+     * @memberof Path2D.prototype
+     * @function
+     * @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.
+     * @param {number} height the rectangle's height. Positive values are down, and negative are up.
+     * @param {number} radius the arc's radius to draw the borders. Must be positive.
+     */
+    roundRect(x: number, y: number, width: number, height: number, radius: number): void;
 }
-declare var pixel: HTMLCanvasElement | OffscreenCanvas;
 /**
  * @classdesc
  * a Vertex Buffer object
@@ -11825,7 +12873,6 @@ declare function releaseAllPointerEvents(region: Rect | Polygon | Line | Ellipse
  * @memberof input
  * @public
  * @function
- * @param {Function} [success] callback if the request is successful
  * @returns {boolean} return true if the request was successfully submitted
  * @example
  * // register on the pointer lock change event
@@ -12002,6 +13049,7 @@ declare function setGamepadDeadzone(value: number): void;
  */
 declare function addMapping(id: any, mapping: any): void;
 /**
+ * @classdesc
  * This object is used for object pooling - a technique that might speed up your game if used properly.<br>
  * If some of your classes will be instantiated and removed a lot at a time, it is a
  * good idea to add the class to this object pool. A separate pool for that class
@@ -12012,96 +13060,93 @@ declare function addMapping(id: any, mapping: any): void;
  * which means, that on level loading the engine will try to instantiate every object
  * found in the map, based on the user defined name in each Object Properties<br>
  * <img src="images/object_properties.png"/><br>
- * @namespace pool
- */
-/**
- * register an object to the pool. <br>
- * Pooling must be set to true if more than one such objects will be created. <br>
- * (Note: for an object to be poolable, it must implements a `onResetEvent` method)
- * @function pool.register
- * @param {string} className as defined in the Name field of the Object Properties (in Tiled)
- * @param {object} classObj corresponding Class to be instantiated
- * @param {boolean} [recycling=false] enables object recycling for the specified class
- * @example
- * // implement CherryEntity
- * class CherryEntity extends Spritesheet {
- *    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);
- */
-declare function register(className: string, classObj: object, recycling?: boolean): void;
-/**
- * Pull a new instance of the requested object (if added into the object pool)
- * @function pool.pull
- * @param {string} name as used in {@link pool.register}
- * @param {object} [...arguments] arguments to be passed when instantiating/reinitializing the object
- * @returns {object} the instance of the requested object
- * @example
- * me.pool.register("bullet", BulletEntity, true);
- * me.pool.register("enemy", EnemyEntity, true);
- * // ...
- * // when we need to manually create a new bullet:
- * var bullet = me.pool.pull("bullet", x, y, direction);
- * // ...
- * // params aren't a fixed number
- * // when we need new enemy we can add more params, that the object construct requires:
- * var enemy = me.pool.pull("enemy", x, y, direction, speed, power, life);
- * // ...
- * // when we want to destroy existing object, the remove
- * // function will ensure the object can then be reallocated later
- * me.game.world.removeChild(enemy);
- * me.game.world.removeChild(bullet);
- */
-declare function pull(name: string, ...args: any[]): object;
-/**
- * purge the object pool from any inactive object <br>
- * Object pooling must be enabled for this function to work<br>
- * note: this will trigger the garbage collector
- * @function pool.purge
- */
-declare function purge(): void;
-/**
- * Push back an object instance into the object pool <br>
- * Object pooling for the object class must be enabled,
- * and object must have been instantiated using {@link pool#pull},
- * otherwise this function won't work
- * @function pool.push
- * @throws will throw an error if the object cannot be recycled
- * @param {object} obj instance to be recycled
- * @param {boolean} [throwOnError=true] throw an exception if the object cannot be recycled
- * @returns {boolean} true if the object was successfully recycled in the object pool
- */
-declare function push(obj: object, throwOnError?: boolean): boolean;
-/**
- * Check if an object with the provided name is registered
- * @function pool.exists
- * @param {string} name of the registered object class
- * @returns {boolean} true if the classname is registered
- */
-declare function exists(name: string): boolean;
-/**
- * Check if an object is poolable
- * (was properly registered with the recycling feature enable)
- * @function pool.poolable
- * @see pool.register
- * @param {object} obj object to be checked
- * @returns {boolean} true if the object is poolable
- * @example
- * if (!me.pool.poolable(myCherryEntity)) {
- *     // object was not properly registered
- * }
- */
-declare function poolable(obj: object): boolean;
-/**
- * returns the amount of object instance currently in the pool
- * @function pool.getInstanceCount
- * @returns {number} amount of object instance
- */
-declare function getInstanceCount(): number;
+ * @see {@link pool} a default global instance of ObjectPool
+ */
+declare class ObjectPool {
+    objectClass: {};
+    instance_counter: number;
+    /**
+     * register an object to the pool. <br>
+     * Pooling must be set to true if more than one such objects will be created. <br>
+     * (Note: for an object to be poolable, it must implements a `onResetEvent` method)
+     * @param {string} className as defined in the Name field of the Object Properties (in Tiled)
+     * @param {object} classObj corresponding Class to be instantiated
+     * @param {boolean} [recycling=false] enables object recycling for the specified class
+     * @example
+     * // implement CherryEntity
+     * class CherryEntity extends Spritesheet {
+     *    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);
+     */
+    register(className: string, classObj: object, recycling?: boolean): void;
+    /**
+     * Pull a new instance of the requested object (if added into the object pool)
+     * @param {string} name as used in {@link pool.register}
+     * @param {object} [...arguments] arguments to be passed when instantiating/reinitializing the object
+     * @returns {object} the instance of the requested object
+     * @example
+     * me.pool.register("bullet", BulletEntity, true);
+     * me.pool.register("enemy", EnemyEntity, true);
+     * // ...
+     * // when we need to manually create a new bullet:
+     * var bullet = me.pool.pull("bullet", x, y, direction);
+     * // ...
+     * // params aren't a fixed number
+     * // when we need new enemy we can add more params, that the object construct requires:
+     * var enemy = me.pool.pull("enemy", x, y, direction, speed, power, life);
+     * // ...
+     * // when we want to destroy existing object, the remove
+     * // function will ensure the object can then be reallocated later
+     * me.game.world.removeChild(enemy);
+     * me.game.world.removeChild(bullet);
+     */
+    pull(name: string, ...args: any[]): object;
+    /**
+     * purge the object pool from any inactive object <br>
+     * Object pooling must be enabled for this function to work<br>
+     * note: this will trigger the garbage collector
+     */
+    purge(): void;
+    /**
+     * Push back an object instance into the object pool <br>
+     * Object pooling for the object class must be enabled,
+     * and object must have been instantiated using {@link pool#pull},
+     * otherwise this function won't work
+     * @throws will throw an error if the object cannot be recycled
+     * @param {object} obj instance to be recycled
+     * @param {boolean} [throwOnError=true] throw an exception if the object cannot be recycled
+     * @returns {boolean} true if the object was successfully recycled in the object pool
+     */
+    push(obj: object, throwOnError?: boolean): boolean;
+    /**
+     * Check if an object with the provided name is registered
+     * @param {string} name of the registered object class
+     * @returns {boolean} true if the classname is registered
+     */
+    exists(name: string): boolean;
+    /**
+     * Check if an object is poolable
+     * (was properly registered with the recycling feature enable)
+     * @see register
+     * @param {object} obj object to be checked
+     * @returns {boolean} true if the object is poolable
+     * @example
+     * if (!me.pool.poolable(myCherryEntity)) {
+     *     // object was not properly registered
+     * }
+     */
+    poolable(obj: object): boolean;
+    /**
+     * returns the amount of object instance currently in the pool
+     * @returns {number} amount of object instance
+     */
+    getInstanceCount(): number;
+}
 declare var agentUtils: Readonly<{
     __proto__: any;
     prefixed: typeof prefixed;
@@ -12217,7 +13262,7 @@ declare function scale(x: number, y: number): void;
  * @name prefixed
  * @function
  * @param {string} name Property name
- * @param {object} [obj=window] Object or element reference to access
+ * @param {object} [obj=globalThis] Object or element reference to access
  * @returns {string} Value of property
  * @memberof utils.agent
  */
@@ -12229,7 +13274,7 @@ declare function prefixed(name: string, obj?: object): string;
  * @function
  * @param {string} name Property name
  * @param {string} value Property value
- * @param {object} [obj=window] Object or element reference to access
+ * @param {object} [obj=globalThis] Object or element reference to access
  * @returns {boolean} true if one of the vendor-prefixed property was found
  * @memberof utils.agent
  */
@@ -12394,4 +13439,4 @@ declare function defer(func: Function, thisArg: object, ...args: any[]): number;
  * @returns {Function} the function that will be throttled
  */
 declare function throttle(fn: Function, delay: number, no_trailing: any): Function;
-export { Bounds$1 as Bounds, math as Math, device$1 as device, pooling as pool, timer$1 as timer };
+export { Bounds$1 as Bounds, math as Math, device$1 as device, event$1 as event, pool$1 as pool, timer$1 as timer };