melonjs 19.1.0 → 19.3.0

package/build/renderable/light2d.d.ts

@@ -1,18 +1,57 @@
+/**
+ * additional import for TypeScript
+ * @import {Color} from "./../math/color.ts";
+ * @import {Ellipse} from "./../geometries/ellipse.ts";
+ * @import Renderer from "./../video/renderer.js";
+ */
 /**
  * A 2D point light.
- * Note: this is a very experimental and work in progress feature, that provides a simple spot light effect.
- * The light effect is best rendered in WebGL, as they are few limitations when using the Canvas Renderer
- * (multiple lights are not supported, alpha component of the ambient light is ignored)
+ *
+ * Light2d carries the *properties* of a light (color, radii, intensity,
+ * height, flags, position) and asks the active renderer to render it
+ * via `renderer.drawLight(this)`. The renderer picks the right machinery:
+ *
+ * - **WebGL**: a single quad through a shared procedural radial-falloff
+ *   fragment shader (`RadialGradientEffect`). One shader is reused across
+ *   every Light2d on the renderer; no per-light texture is allocated.
+ * - **Canvas**: a small `Gradient` config object (cached per-light in a
+ *   `WeakMap` and rebuilt only when radii / color / intensity change),
+ *   rasterized via `Gradient.toCanvas()` on every draw into a single
+ *   shared `CanvasRenderTarget`, then composited with `drawImage`. The
+ *   per-light cache holds only the gradient stops, not the bitmap — the
+ *   render target is one-per-engine.
+ *
+ * Light2d itself is renderer-agnostic — no shader knowledge, no canvas
+ * allocation, no renderer reference held.
  * @see stage.lights
  */
 export default class Light2d extends Renderable {
     /**
-     * @param {number} x - The horizontal position of the light.
-     * @param {number} y - The vertical position of the light.
+     * Create a 2D point light.
+     *
+     * A `Light2d` is a first-class world Renderable: add it to a container
+     * with `app.world.addChild(light)` (or any sub-container, including a
+     * `Sprite`, so the light follows the parent via its transform). On
+     * activation, the light auto-registers with the active `Stage`'s
+     * lighting set so the ambient overlay (`Stage.ambientLight`) cuts a
+     * hole at the light's visible area, and a radial gradient from the
+     * given `color` (full intensity at center → fully transparent at the
+     * radius) is composited additively on top — producing a soft spot
+     * light. Rendering happens inside each `Camera2d`'s post-effect FBO
+     * bracket so any camera shader (vignette, color-matrix, scanlines,
+     * etc.) wraps the lighting output.
+     *
+     * Set `radiusY` to a different value than `radiusX` for a stretched
+     * (elliptical) light. The `intensity` parameter scales the gradient's
+     * inner alpha; the `Stage.ambientLight` color and alpha control how
+     * dark the unlit areas are. Use `light.blendMode` to override the
+     * default additive blend if needed.
+     * @param {number} x - The horizontal position of the light's center (matches `Ellipse(x, y, w, h)` conventions).
+     * @param {number} y - The vertical position of the light's center.
      * @param {number} radiusX - The horizontal radius of the light.
      * @param {number} [radiusY=radiusX] - The vertical radius of the light.
-     * @param {Color|string} [color="#FFF"] - the color of the light
-     * @param {number} [intensity=0.7] - The intensity of the light.
+     * @param {Color|string} [color="#FFF"] - The color of the light at full intensity.
+     * @param {number} [intensity=0.7] - The peak alpha of the radial gradient at the light's center (0–1).
      */
     constructor(x: number, y: number, radiusX: number, radiusY?: number, color?: Color | string, intensity?: number);
     /**
@@ -39,25 +78,98 @@ export default class Light2d extends Renderable {
     intensity: number;
     /** @ignore */
     visibleArea: Ellipse;
-    /** @ignore */
-    texture: CanvasRenderTarget;
     /**
-     * returns a geometry representing the visible area of this light
+     * When `true`, this light acts as a pure illumination source —
+     * the gradient texture isn't drawn. The light still feeds the
+     * `Stage` ambient-cutout pass and the WebGL lit-sprite
+     * pipeline's per-frame uniforms, so normal-mapped sprites still
+     * get shaded by it. Use this for SpriteIlluminator-style demos
+     * where the light should be invisible (only its effect on
+     * normal-mapped surfaces is what you want to see).
+     *
+     * Default `false`, preserving the legacy "soft glowing spot"
+     * behavior.
+     * @type {boolean}
+     * @default false
+     */
+    illuminationOnly: boolean;
+    /**
+     * Light height above the sprite plane (Z axis), in the same
+     * units as `radiusX`/`radiusY`. Used by the WebGL lit-sprite
+     * pipeline as the Z component of the light direction in the
+     * `dot(normal, lightDir)` calculation: a low height makes the
+     * lighting graze across the surface (long visible shadows on
+     * normal-map detail), a high height makes it head-on (more
+     * uniform brightness on the lit hemisphere).
+     *
+     * Default is `max(radiusX, radiusY) * 0.075` — a balanced look
+     * at the asset's native scale that prevents lights at the
+     * sprite's center from producing degenerate flat shading.
+     *
+     * Named `lightHeight` (not just `height`) to avoid colliding
+     * with the bbox-height getter Light2d inherits from `Rect`.
+     * @type {number}
+     */
+    lightHeight: number;
+    /**
+     * Set new radii for this light.
+     *
+     * Updates `radiusX`/`radiusY` and the underlying bbox (via
+     * `Renderable.resize(width, height)`) so `getBounds()` and
+     * `getVisibleArea()` — which feed the ambient-cutout pass — track the
+     * new size. The Canvas renderer's gradient cache auto-invalidates on
+     * next draw via its property comparison; the WebGL procedural shader
+     * adapts to the new dimensions automatically.
+     *
+     * Named `setRadii` (not `resize`) so it does not shadow
+     * `Renderable.resize(width, height)` — code that operates on a
+     * generic `Renderable` and calls `.resize(w, h)` keeps working when
+     * the instance happens to be a `Light2d`.
+     * @param {number} radiusX - new horizontal radius
+     * @param {number} [radiusY=radiusX] - new vertical radius
+     */
+    setRadii(radiusX: number, radiusY?: number): void;
+    /**
+     * returns a geometry representing the visible area of this light, in
+     * world-space coordinates (so it aligns with the rendered gradient
+     * regardless of camera scroll or container parenting).
      * @returns {Ellipse} the light visible mask
      */
     getVisibleArea(): Ellipse;
     /**
      * update function
-     * @param {number} dt - time since the last update in milliseconds.
      * @returns {boolean} true if dirty
      */
     update(): boolean;
     /**
-     * draw this Light2d (automatically called by melonJS)
-     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer instance
-     * @param {Camera2d} [viewport] - the viewport to (re)draw
+     * preDraw this Light2d (automatically called by melonJS)
+     * @param {Renderer} renderer - a renderer instance
+     */
+    preDraw(renderer: Renderer): void;
+    /**
+     * draw this Light2d (automatically called by melonJS).
+     *
+     * Delegates to `renderer.drawLight(this)` — each renderer picks its
+     * own implementation (procedural shader on WebGL; cached `Gradient`
+     * rasterized into a shared `CanvasRenderTarget` on Canvas). Light2d
+     * itself doesn't know which path is used.
+     * @param {Renderer} renderer - a renderer instance
+     */
+    draw(renderer: Renderer): void;
+    /**
+     * Auto-register this light with the active Stage's lighting set when
+     * added to a container. The Stage uses that set to build the ambient
+     * overlay cutouts; rendering the light itself is handled normally as
+     * part of the world tree walk.
+     * @ignore
+     */
+    onActivateEvent(): void;
+    /**
+     * Auto-deregister this light from the active Stage's lighting set when
+     * removed from a container.
+     * @ignore
      */
-    draw(renderer: CanvasRenderer | WebGLRenderer): void;
+    onDeactivateEvent(): void;
     /**
      * Destroy function<br>
      * @ignore
@@ -67,7 +179,5 @@ export default class Light2d extends Renderable {
 import Renderable from "./renderable.js";
 import type { Color } from "./../math/color.ts";
 import type { Ellipse } from "./../geometries/ellipse.ts";
-import CanvasRenderTarget from "../video/rendertarget/canvasrendertarget.js";
-import type CanvasRenderer from "./../video/canvas/canvas_renderer.js";
-import type WebGLRenderer from "./../video/webgl/webgl_renderer.js";
+import type Renderer from "./../video/renderer.js";
 //# sourceMappingURL=light2d.d.ts.map

package/build/renderable/light2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"light2d.d.ts","sourceRoot":"","sources":["../../src/renderable/light2d.js"],"names":[],"mappings":"AA0EA;;;;;;GAMG;AACH;IACC;;;;;;;OAOG;IACH,eAPW,MAAM,KACN,MAAM,WACN,MAAM,YACN,MAAM,UACN,KAAK,GAAC,MAAM,cACZ,MAAM,EAgEhB;IAnDA;;;;OAIG;IACH,OAHU,KAAK,CAG6B;IAE5C;;;OAGG;IACH,SAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,SAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,WAHU,MAAM,CAGU;IAW1B,cAAc;IACd,qBAKC;IAED,cAAc;IACd,4BAEE;IAOH;;;OAGG;IACH,kBAFa,OAAO,CASnB;IAED;;;;OAIG;IACH,UAFa,OAAO,CAInB;IAaD;;;;OAIG;IACH,eAHW,cAAc,GAAC,aAAa,QAStC;IAED;;;OAGG;IACH,gBASC;CACD;uBAlNsB,iBAAiB;2BAIhB,oBAAoB;6BAClB,4BAA4B;+BANvB,6CAA6C;gCAO7C,sCAAsC;+BACvC,oCAAoC"}
+{"version":3,"file":"light2d.d.ts","sourceRoot":"","sources":["../../src/renderable/light2d.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,eAPW,MAAM,KACN,MAAM,WACN,MAAM,YACN,MAAM,UACN,KAAK,GAAC,MAAM,cACZ,MAAM,EAiGhB;IAlFA;;;;OAIG;IACH,OAHU,KAAK,CAG6B;IAE5C;;;OAGG;IACH,SAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,SAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,WAHU,MAAM,CAGU;IAa1B,cAAc;IACd,qBAKC;IAKD;;;;;;;;;;;;;OAaG;IACH,kBAHU,OAAO,CAGY;IAE7B;;;;;;;;;;;;;;;;OAgBG;IACH,aAFU,MAAM,CAEqC;IAiCtD;;;;;;;;;;;;;;;;OAgBG;IACH,kBAHW,MAAM,YACN,MAAM,QAMhB;IAED;;;;;OAKG;IACH,kBAFa,OAAO,CAOnB;IAED;;;OAGG;IACH,UAFa,OAAO,CAInB;IAED;;;OAGG;IACH,kBAFW,QAAQ,QAKlB;IAED;;;;;;;;OAQG;IACH,eAFW,QAAQ,QAOlB;IAED;;;;;;OAMG;IACH,wBAKC;IAED;;;;OAIG;IACH,0BAKC;IAED;;;OAGG;IACH,gBAQC;CACD;uBArSsB,iBAAiB;2BAIhB,oBAAoB;6BAClB,4BAA4B;0BAC7B,wBAAwB"}

package/build/renderable/renderable.d.ts

@@ -185,45 +185,26 @@ export default class Renderable extends Rect {
      */
     mask: Rect | RoundRect | Polygon | Line | Ellipse;
     /**
-     * an optional shader, to be used instead of the default built-in one, when drawing this renderable (WebGL only).
-     * Use {@link ShaderEffect} for a custom fragment `apply()` function,
-     * or one of the built-in effect presets:
-     * - {@link FlashEffect} — flash the sprite with a solid color (hit feedback)
-     * - {@link OutlineEffect} — colored outline around the sprite (selection, hover)
-     * - {@link GlowEffect} — soft colored glow around the sprite (power-ups, magic)
-     * - {@link DesaturateEffect} — partial or full grayscale (disabled, death)
-     * - {@link PixelateEffect} — progressive pixelation (teleport, retro)
-     * - {@link BlurEffect} — box blur (defocus, backdrop)
-     * - {@link ChromaticAberrationEffect} — RGB channel offset (impact, glitch)
-     * - {@link DissolveEffect} — noise-based dissolve (death, spawn)
-     * - {@link DropShadowEffect} — offset shadow beneath the sprite
-     * - {@link ScanlineEffect} — horizontal scanlines with optional CRT curvature and vignette
-     * - {@link TintPulseEffect} — pulsing color overlay (poison, freeze, fire)
-     * - {@link WaveEffect} — sine wave distortion (underwater, heat haze)
-     * - {@link InvertEffect} — color inversion (negative image, X-ray)
-     * - {@link SepiaEffect} — warm vintage photo tone
-     * - {@link HologramEffect} — flickering holographic projection (sci-fi)
-     *
-     * Use {@link GLShader} for full control over vertex and fragment shaders.
+     * the list of post-processing shader effects applied to this renderable (WebGL only).
+     * Effects are applied in order. Use {@link addPostEffect}, {@link getPostEffect},
+     * and {@link removePostEffect} to manage effects, or assign directly.
      * In Canvas mode, this property is ignored.
-     * @type {GLShader|ShaderEffect}
-     * @default undefined
-     * @example
-     * // apply a built-in effect
-     * mySprite.shader = new FlashEffect(renderer, { intensity: 1.0 });
+     * @type {Array<GLShader|ShaderEffect>}
+     * @default []
      * @example
-     * // custom shader effect
-     * mySprite.shader = new ShaderEffect(renderer, `
-     *     vec4 apply(vec4 color, vec2 uv) {
-     *         float gray = dot(color.rgb, vec3(0.299, 0.587, 0.114));
-     *         return vec4(vec3(gray), color.a);
-     *     }
-     * `);
+     * // add effects via helper methods
+     * mySprite.addPostEffect(new DesaturateEffect(renderer));
+     * mySprite.addPostEffect(new VignetteEffect(renderer));
      * @example
-     * // to remove a custom shader
-     * mySprite.shader = undefined;
+     * // assign directly
+     * mySprite.postEffects = [new SepiaEffect(renderer), new VignetteEffect(renderer)];
      */
-    shader: GLShader | ShaderEffect;
+    postEffects: Array<GLShader | ShaderEffect>;
+    /**
+     * whether this renderable manages its own FBO lifecycle (e.g. Camera2d)
+     * @ignore
+     */
+    _postEffectManaged: boolean;
     /**
      * the blend mode to be applied to this renderable (see renderer setBlendMode for available blend mode)
      * @type {string}
@@ -313,6 +294,44 @@ export default class Renderable extends Rect {
      * @default false
      */
     get inViewport(): boolean;
+    set shader(value: GLShader | ShaderEffect | undefined);
+    /**
+     * @deprecated since 19.2.0 — use {@link addPostEffect} / {@link getPostEffect} / {@link removePostEffect} instead
+     * @type {GLShader|ShaderEffect|undefined}
+     */
+    get shader(): GLShader | ShaderEffect | undefined;
+    /**
+     * Add a post-processing shader effect to this renderable.
+     * @param {GLShader|ShaderEffect} effect - the effect to add
+     * @returns {GLShader|ShaderEffect} the added effect
+     * @example
+     * mySprite.addPostEffect(new DesaturateEffect(renderer));
+     */
+    addPostEffect(effect: GLShader | ShaderEffect): GLShader | ShaderEffect;
+    /**
+     * Get post-processing shader effects.
+     * When called with a class, returns the first effect matching the given class.
+     * When called without arguments, returns the full effects array.
+     * @param {Function} [effectClass] - the effect class to search for
+     * @returns {GLShader|ShaderEffect|Array|undefined} the matching effect, the effects array, or undefined
+     * @example
+     * const desat = sprite.getPostEffect(DesaturateEffect);
+     * const allEffects = sprite.getPostEffect();
+     */
+    getPostEffect(effectClass?: Function): GLShader | ShaderEffect | any[] | undefined;
+    /**
+     * Remove all post-processing shader effects.
+     * @example
+     * sprite.clearPostEffects();
+     */
+    clearPostEffects(): void;
+    /**
+     * Remove a specific post-processing shader effect.
+     * @param {GLShader|ShaderEffect} effect - the effect to remove
+     * @example
+     * sprite.removePostEffect(effect);
+     */
+    removePostEffect(effect: GLShader | ShaderEffect): void;
     /**
      * returns true if this renderable is flipped on the horizontal axis
      * @public

package/build/renderable/renderable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderable.d.ts","sourceRoot":"","sources":["../../src/renderable/renderable.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;IAaI;AAEJ;;;GAGG;AACH;IAkBG,iBAAmB;IAGpB;;;;;;;;;;OAUG;IACH,aAHU,eAAe,CAMvB;IAGD;;;;;;;OAOG;IACH,kBAFU,QAAQ,CAEoB;IAIvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,MAlCU,IAAI,CAkCO;IAErB;;;;;OAKG;IACH,MAFU,MAAM,CAEK;IAErB;;;;;;;;;;OAUG;IACH,6BAAmC;IAEnC;;;;OAIG;IACH,cAHU,OAAO,CAGQ;IAEzB;;;;OAIG;IACH,kBAHU,OAAO,CAGY;IAE7B;;;;OAIG;IACH,cAHU,OAAO,CAGQ;IAEzB;;;;;OAKG;IACH,UAHU,OAAO,CAGI;IAErB;;;;;;;OAOG;IACH,qBAHU,OAAO,CAGe;IAEhC;;;;;;;;;;;;;;;;OAgBG;IACH,eAdU,OAAO,CAcQ;IAEzB;;;;;;;OAOG;IACH,OAHU,MAAM,CAGA;IAEhB;;;;OAIG;IACH,UAHU,SAAS,GAAC,MAAM,CAGD;IAEzB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAlBU,IAAI,GAAC,SAAS,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,CAkBxB;IAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,QAjBU,QAAQ,GAAC,YAAY,CAiBR;IAEvB;;;;;;OAMG;IACH,WALU,MAAM,CAKS;IAEzB;;;;OAIG;IACH,MAHU,MAAM,CAGF;IAEd;;;OAGG;IACH,sBAAwB;IAExB;;;;OAIG;IACH,aAHU,OAAO,CAGM;IASvB;;;OAGG;IACH,oDAAwB;IAExB;;;OAGG;IACH;;;MAGC;IAED;;;OAGG;IACH,qBAAwB;IAExB;;;OAGG;IACH,gBAA2B;IAE3B;;;OAGG;IACH,mCAA8C;IAM/C;;;OAGG;IACH,iBAFY,WAAW,CAQtB;IAED;;;;OAIG;IACH,kBAFU,OAAO,CAOhB;IAeD,gBAXU,KAAK,EAcd;IAhBD;;;;;;;;;OASG;IACH,YARU,KAAK,CAUd;IAaD,iBALU,MAAM,EAQf;IAVD;;;OAGG;IACH,aAFU,MAAM,CAIf;IAcD,sBANU,OAAO,EAahB;IAfD;;;;OAIG;IACH,kBAHU,OAAO,CAKhB;IAUD;;;;;OAKG;IACH,yBAFU,OAAO,CAIhB;IAED;;;;;OAKG;IACH,yBAFU,OAAO,CAIhB;IAED;;;OAGG;IACH,aAFa,MAAM,CAalB;IAED;;;OAGG;IACH,cAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAWhB;IAED;;;;;OAKG;IACH,aAHW,OAAO,GACL,UAAU,CAMtB;IAED;;;;;OAKG;IACH,aAHW,OAAO,GACL,UAAU,CAMtB;IAED;;;;;OAKG;IACH,aAHW,QAAQ,GAAC,QAAQ,GACf,UAAU,CAOtB;IAED;;;;OAIG;IACH,gBAHW,UAAU,GAAC,QAAQ,GAAC,QAAQ,GAC1B,MAAM,CAkBlB;IAED;;;;OAIG;IACH,mBAHW,UAAU,GAAC,QAAQ,GAAC,QAAQ,GAC1B,MAAM,CAkBlB;IAED;;;;OAIG;IACH,eAHW,UAAU,GAAC,QAAQ,GAAC,QAAQ,GAC1B,UAAU,CAgBtB;IAED;;;;;;;OAOG;IACH,cAJW,MAAM,MACN,QAAQ,GACN,UAAU,CAStB;IAED;;;;;;;;;;OAUG;IACH,SALW,MAAM,MACN,MAAM,MACN,MAAM,GACJ,UAAU,CAOtB;IAED;;;;OAIG;IACH,UAHW,QAAQ,GACN,UAAU,CAKtB;IAED;;;;;;OAMG;IACH,aALW,MAAM,MACN,MAAM,MACN,MAAM,GACJ,UAAU,CAOtB;IAED;;;;OAIG;IAEH,WAJW,MAAM,GACJ,OAAO,CAKnB;IAED;;;;OAIG;IACH,wBAHW,OAAO,GACL,MAAM,CAwClB;IAED;;;OAGG;IACH,uBAFa,QAAQ,CAYpB;IAED;;;;;;OAMG;IACH,kBAFW,cAAc,GAAC,aAAa,QAmDtC;IAED;;;;;;;;;;;;OAYG;IAEH,eAJW,cAAc,GAAC,aAAa,aAC5B,QAAQ,QAKlB;IAED;;;;;OAKG;IACH,mBAFW,cAAc,GAAC,aAAa,QAqBtC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAfa,OAAO,CAiBnB;IAED;;;OAGG;IACH,8BAyDC;IAED;;;OAGG;IACH,uBAEC;CACD;qBAj5BoB,8BAA8B;gCADnB,kCAAkC;yBAKzC,qBAAqB;iBAG7B,sBAAsB;2BAQb,gBAAgB;wBADnB,oBAAoB;+BAKf,8BAA8B;6BADhC,0BAA0B;0BAF7B,yBAAyB;6BACtB,4BAA4B;6BAG1B,iCAAiC;gCAC9B,sCAAsC;+BACvC,oCAAoC"}
+{"version":3,"file":"renderable.d.ts","sourceRoot":"","sources":["../../src/renderable/renderable.js"],"names":[],"mappings":"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"}

package/build/renderable/sprite.d.ts

@@ -1,8 +1,7 @@
 /**
  * additional import for TypeScript
  * @import {Vector2d} from "../math/vector2d.js";
- * @import CanvasRenderer from "./../video/canvas/canvas_renderer.js";
- * @import WebGLRenderer from "./../video/webgl/webgl_renderer.js";
+ * @import Renderer from "./../video/renderer.js";
  */
 /**
  * An object to display a fixed or animated sprite on screen.
@@ -22,6 +21,7 @@ export default class Sprite extends Renderable {
      * @param {number} [settings.flipX] - flip the sprite on the horizontal axis
      * @param {number} [settings.flipY] - flip the sprite on the vertical axis
      * @param {Vector2d} [settings.anchorPoint={x:0.5, y:0.5}] - Anchor point to draw the frame at (defaults to the center of the frame).
+     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap|string} [settings.normalMap] - optional normal-map texture used for per-pixel lighting (SpriteIlluminator-style). Same layout/UVs as `settings.image`. When omitted (default), the sprite renders unlit and pays no extra cost. Ignored by the Canvas renderer. Note: `HTMLVideoElement` is intentionally not supported — normal maps encode static surface directions in RGB, and the engine caches the GL texture per image reference (a video would freeze on frame 0).
      * @example
      * // create a single sprite from a standalone image, with anchor in the center
      * let sprite = new me.Sprite(0, 0, {
@@ -61,6 +61,7 @@ export default class Sprite extends Renderable {
         flipX?: number | undefined;
         flipY?: number | undefined;
         anchorPoint?: Vector2d | undefined;
+        normalMap?: string | ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | undefined;
     });
     /**
      * @type {boolean}
@@ -95,6 +96,12 @@ export default class Sprite extends Renderable {
      * @type {TextureAtlas}
      */
     source: TextureAtlas;
+    /**
+     * backing field for the `normalMap` accessor — see the getter/setter
+     * defined on the class for the public API and validation rules.
+     * @ignore
+     */
+    _normalMap: ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | null;
     anim: {};
     resetAnim: Function | (() => Sprite) | undefined;
     current: {
@@ -127,6 +134,19 @@ export default class Sprite extends Renderable {
      * @ignore
      */
     removeStatePauseListener: (() => void) | undefined;
+    set normalMap(value: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap | null);
+    /**
+     * The optional normal-map image paired with this sprite's color
+     * texture (SpriteIlluminator workflow). When set, the WebGL
+     * renderer's lit pipeline samples this texture for per-pixel
+     * lighting using `Stage._activeLights`. `null` when unlit.
+     * Setting any non-image value (or anything without numeric
+     * `width`/`height`) throws — assign `null` to clear.
+     *
+     * Silently ignored by the Canvas renderer.
+     * @type {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap|null}
+     */
+    get normalMap(): HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap | null;
     atlasIndices: any;
     /**
      * return the flickering state of the object
@@ -271,12 +291,25 @@ export default class Sprite extends Renderable {
      * @returns {number} if using number indices. Returns {object} containing frame data if using texture atlas
      */
     getAnimationFrameObjectByIndex(id: number): number;
+    /**
+     * Prepare the rendering context before drawing this sprite (automatically called by melonJS).
+     * Extends `Renderable.preDraw` to publish this sprite's `normalMap` (if any)
+     * on the renderer so the WebGL lit pipeline can pair it with the next
+     * `drawImage` call. Cleared back in `postDraw`.
+     * @param {Renderer} renderer - a renderer instance
+     */
+    preDraw(renderer: Renderer): void;
+    /**
+     * restore the rendering context after drawing this sprite (automatically called by melonJS).
+     * @param {Renderer} renderer - a renderer instance
+     */
+    postDraw(renderer: Renderer): void;
     /**
      * draw this sprite (automatically called by melonJS)
-     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer instance
+     * @param {Renderer} renderer - a renderer instance
      * @param {Camera2d} [viewport] - the viewport to (re)draw
      */
-    draw(renderer: CanvasRenderer | WebGLRenderer): void;
+    draw(renderer: Renderer): void;
     /**
      * Destroy function<br>
      * @ignore
@@ -286,7 +319,6 @@ export default class Sprite extends Renderable {
 import Renderable from "./renderable.js";
 import type { Vector2d } from "../math/vector2d.js";
 import { TextureAtlas } from "./../video/texture/atlas.js";
-import type CanvasRenderer from "./../video/canvas/canvas_renderer.js";
-import type WebGLRenderer from "./../video/webgl/webgl_renderer.js";
+import type Renderer from "./../video/renderer.js";
 import { Color } from "../math/color.ts";
 //# sourceMappingURL=sprite.d.ts.map

package/build/renderable/sprite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sprite.d.ts","sourceRoot":"","sources":["../../src/renderable/sprite.js"],"names":[],"mappings":"AAWA;;;;;GAKG;AAEH;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,eAzCW,MAAM,KACN,MAAM,YAEd;QAA0G,KAAK,EAAvG,gBAAgB,GAAC,iBAAiB,GAAC,gBAAgB,GAAC,YAAY,GAAC,eAAe,GAAC,MAAM;QACrE,IAAI;QACJ,MAAM;QACN,UAAU;QACV,WAAW;QACL,IAAI;QACV,KAAK;QACL,KAAK;QACH,WAAW;KACvC,EAiQF;IAhOA;;;OAGG;IACH,gBAHU,OAAO,CAGU;IAE3B;;;;OAIG;IACH,gBAHU,MAAM,CAGS;IAEzB;;;;OAIG;IACH,QAHU,QAAQ,CAGkB;IAEpC;;;;OAIG;IACH,SAHU,OAAO,CAGG;IAEpB;;;;OAIG;IAGH;;;OAGG;IACH,QAFU,YAAY,CAEJ;IAGlB,SAAc;IAGd,iDAA0B;IAI1B;;;;;;;;;MAgBC;IAGD,WAAW;IAEX;;;OAGG;IACH;;;;;MAKC;IAKA,WAAqC;IACrC,kBAAkC;IAiCjC,WAG8C;IAC9C,YAGgD;IAOhD;;;OAGG;IACH,mDAEE;IA8BH,kBAAyC;IA2D3C;;;OAGG;IACH,gBAFa,OAAO,CAInB;IAED;;OAEG;IACH,aAEC;IAED;;OAEG;IACH,cAEC;IAED;;;;;;;;;;;OAWG;IACH,kBAVW,MAAM,wBAEJ,MAAM,CAoBlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,mBAzBW,MAAM,SACN,MAAM,EAAE,GAAC,MAAM,EAAE,GAAC,MAAM,EAAE,mBAC1B,MAAM,GACJ,MAAM,CAuFlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,0BAlCW,MAAM,cACN,MAAM,WAAS,gBACf,OAAO,GACL,MAAM,CA0DlB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;;;;OAQG;IACH,yBAPW,MAAM,GACJ,OAAO,CAQnB;IAED;;;;;;;;OAQG;IACH,kBANW,MAAM,GACJ,MAAM,CAoDlB;IAED;;;;;;;OAOG;IACH,0BANW,MAAM,GACJ,MAAM,CAUlB;IAED;;;OAGG;IACH,4BAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;IAyED;;;;OAIG;IACH,eAHW,cAAc,GAAC,aAAa,QAuDtC;IAED;;;OAGG;IACH,gBAWC;CACD;uBA9vBsB,iBAAiB;8BAOb,qBAAqB;6BARnB,6BAA6B;gCAS3B,sCAAsC;+BACvC,oCAAoC;sBAb5C,kBAAkB"}
+{"version":3,"file":"sprite.d.ts","sourceRoot":"","sources":["../../src/renderable/sprite.js"],"names":[],"mappings":"AAWA;;;;GAIG;AAEH;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACH,eA1CW,MAAM,KACN,MAAM,YAEd;QAA0G,KAAK,EAAvG,gBAAgB,GAAC,iBAAiB,GAAC,gBAAgB,GAAC,YAAY,GAAC,eAAe,GAAC,MAAM;QACrE,IAAI;QACJ,MAAM;QACN,UAAU;QACV,WAAW;QACL,IAAI;QACV,KAAK;QACL,KAAK;QACH,WAAW;QACkD,SAAS;KAClG,EA6SF;IA5QA;;;OAGG;IACH,gBAHU,OAAO,CAGU;IAE3B;;;;OAIG;IACH,gBAHU,MAAM,CAGS;IAEzB;;;;OAIG;IACH,QAHU,QAAQ,CAGkB;IAEpC;;;;OAIG;IACH,SAHU,OAAO,CAGG;IAEpB;;;;OAIG;IAGH;;;OAGG;IACH,QAFU,YAAY,CAEJ;IAElB;;;;OAIG;IACH,wFAAsB;IAGtB,SAAc;IAGd,iDAA0B;IAI1B;;;;;;;;;MAgBC;IAGD,WAAW;IAEX;;;OAGG;IACH;;;;;MAKC;IAKA,WAAqC;IACrC,kBAAkC;IAiCjC,WAG8C;IAC9C,YAGgD;IAOhD;;;OAGG;IACH,mDAEE;IA4IL,qBALU,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAAC,IAAI,EA+B5E;IAxCD;;;;;;;;;;OAUG;IACH,iBAFU,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAAC,IAAI,CAI5E;IAxEC,kBAAyC;IAqG3C;;;OAGG;IACH,gBAFa,OAAO,CAInB;IAED;;OAEG;IACH,aAEC;IAED;;OAEG;IACH,cAEC;IAED;;;;;;;;;;;OAWG;IACH,kBAVW,MAAM,wBAEJ,MAAM,CAoBlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,mBAzBW,MAAM,SACN,MAAM,EAAE,GAAC,MAAM,EAAE,GAAC,MAAM,EAAE,mBAC1B,MAAM,GACJ,MAAM,CAuFlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,0BAlCW,MAAM,cACN,MAAM,WAAS,gBACf,OAAO,GACL,MAAM,CA0DlB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;;;;OAQG;IACH,yBAPW,MAAM,GACJ,OAAO,CAQnB;IAED;;;;;;;;OAQG;IACH,kBANW,MAAM,GACJ,MAAM,CAoDlB;IAED;;;;;;;OAOG;IACH,0BANW,MAAM,GACJ,MAAM,CAUlB;IAED;;;OAGG;IACH,4BAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;IAyED;;;;;;OAMG;IACH,kBAFW,QAAQ,QAWlB;IAED;;;OAGG;IACH,mBAFW,QAAQ,QAQlB;IAED;;;;OAIG;IACH,eAHW,QAAQ,QAuDlB;IAED;;;OAGG;IACH,gBAeC;CACD;uBAt3BsB,iBAAiB;8BAOb,qBAAqB;6BARnB,6BAA6B;0BASjC,wBAAwB;sBAZ3B,kBAAkB"}

package/build/renderable/text/bitmaptext.d.ts

@@ -19,13 +19,13 @@ export default class BitmapText extends Renderable {
      * @param {number} [settings.wordWrapWidth] - the maximum length in CSS pixel for a single segment of text
      * @param {(string|string[])} [settings.text] - a string, or an array of strings
      * @example
-     * // Use me.loader.preload or me.loader.load to load assets
-     * me.loader.preload([
-     *     { name: "arial", type: "binary" src: "data/font/arial.fnt" },
-     *     { name: "arial", type: "image" src: "data/font/arial.png" },
+     * // Use loader.preload or loader.load to load assets
+     * loader.preload([
+     *     { name: "arial", type: "binary", src: "data/font/arial.fnt" },
+     *     { name: "arial", type: "image", src: "data/font/arial.png" },
      * ])
      * // Then create an instance of your bitmap font:
-     * let myFont = new me.BitmapText(x, y, {font:"arial", text:"Hello"});
+     * let myFont = new BitmapText(x, y, {font:"arial", text:"Hello"});
      * // two possibilities for using "myFont"
      * // either call the draw function from your Renderable draw function
      * myFont.draw(renderer, "Hello!", 0, 0);
@@ -105,6 +105,10 @@ export default class BitmapText extends Renderable {
      * @see Renderable#tint
      */
     public get fillStyle(): Color;
+    /**
+     * @ignore
+     */
+    _visibleCharacters: number;
     metrics: TextMetrics;
     /**
      * change the font settings
@@ -119,6 +123,30 @@ export default class BitmapText extends Renderable {
      * @returns {BitmapText} this object for chaining
      */
     setText(value?: number | string | string[]): BitmapText;
+    public set visibleCharacters(value: number);
+    /**
+     * the number of characters to display (use -1 to show all).
+     * Useful for typewriter effects combined with Tween.
+     * @public
+     * @type {number}
+     * @default -1
+     * @see BitmapText#visibleRatio
+     * @example
+     * // show only the first 5 characters
+     * bitmapText.visibleCharacters = 5;
+     * // typewriter effect
+     * bitmapText.visibleCharacters = 0;
+     * new Tween(bitmapText).to({ visibleRatio: 1.0 }, { duration: 2000 }).start();
+     */
+    public get visibleCharacters(): number;
+    public set visibleRatio(value: number);
+    /**
+     * the ratio of visible characters (0.0 to 1.0).
+     * Setting this automatically updates {@link visibleCharacters}.
+     * @public
+     * @type {number}
+     */
+    public get visibleRatio(): number;
     /**
      * change the font display size
      * @param {number} scale - ratio

package/build/renderable/text/bitmaptext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bitmaptext.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/bitmaptext.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,eA5BW,MAAM,KACN,MAAM,YAEd;QAA+B,IAAI,EAA3B,MAAM,8DAAM;QACM,QAAQ;QACR,IAAI;QACE,SAAS;QACf,SAAS;QACT,SAAS;QACT,YAAY;QACZ,UAAU;QACR,WAAW;QACb,aAAa;QACF,IAAI;KACzC,EAsHF;IApGA;;;;;;OAMG;IACH,kBAHU,MAAM,CAG6B;IAE7C;;;;;;OAMG;IACH,qBAHU,MAAM,CAGkC;IAElD;;;;;;OAMG;IACH,mBAHU,MAAM,CAG4B;IAE5C;;;;;;OAMG;IACH,sBAHU,MAAM,CAGiC;IAEjD;;;OAGG;IACH,cAAe;IAEf;;;OAGG;IACH,kBAA2C;IAE3C;;;OAGG;IACH,kBAG2B;IAG1B;;;OAGG;IAEH,iBAAgE;IAgJlE,4BANU,KAAK,EAad;IAhBD;;;;;OAKG;IACH,wBAHU,KAAK,CAKd;IAnHA,qBAAoC;IAWrC;;;;;OAKG;IACH,eAJW,MAAM,UACN,MAAM,GACJ,UAAU,CAWtB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GACpB,UAAU,CAqBtB;IAyED;;;;OAIG;IACH,cAHW,MAAM,GACJ,UAAU,CAYtB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,WAAW,CAIvB;IAED;;;OAGG;IACH,eAFW,cAAc,GAAC,aAAa,QAwFtC;IAED;;;OAGG;IACH,gBAQC;CACD;uBArYsB,kBAAkB;sBAFnB,qBAAqB;wBAInB,kBAAkB"}
+{"version":3,"file":"bitmaptext.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/bitmaptext.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,eA5BW,MAAM,KACN,MAAM,YAEd;QAA+B,IAAI,EAA3B,MAAM,8DAAM;QACM,QAAQ;QACR,IAAI;QACE,SAAS;QACf,SAAS;QACT,SAAS;QACT,YAAY;QACZ,UAAU;QACR,WAAW;QACb,aAAa;QACF,IAAI;KACzC,EA2HF;IAzGA;;;;;;OAMG;IACH,kBAHU,MAAM,CAG6B;IAE7C;;;;;;OAMG;IACH,qBAHU,MAAM,CAGkC;IAElD;;;;;;OAMG;IACH,mBAHU,MAAM,CAG4B;IAE5C;;;;;;OAMG;IACH,sBAHU,MAAM,CAGiC;IAEjD;;;OAGG;IACH,cAAe;IAEf;;;OAGG;IACH,kBAA2C;IAE3C;;;OAGG;IACH,kBAG2B;IAG1B;;;OAGG;IAEH,iBAAgE;IA0MlE,4BANU,KAAK,EAad;IAhBD;;;;;OAKG;IACH,wBAHU,KAAK,CAKd;IA9KA;;OAEG;IACH,2BAA4B;IAG5B,qBAAoC;IAWrC;;;;;OAKG;IACH,eAJW,MAAM,UACN,MAAM,GACJ,UAAU,CAWtB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GACpB,UAAU,CAqBtB;IAoBD,oCAdU,MAAM,EAmBf;IAvBD;;;;;;;;;;;;;OAaG;IACH,gCAVU,MAAM,CAYf;IAyBD,+BAZU,MAAM,EAsBf;IA1BD;;;;;OAKG;IACH,2BAFU,MAAM,CAUf;IAqFD;;;;OAIG;IACH,cAHW,MAAM,GACJ,UAAU,CAYtB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,WAAW,CAIvB;IAED;;;OAGG;IACH,eAFW,cAAc,GAAC,aAAa,QAmGtC;IAED;;;OAGG;IACH,gBAQC;CACD;uBA1csB,kBAAkB;sBAFnB,qBAAqB;wBAInB,kBAAkB"}

package/build/renderable/text/text.d.ts

@@ -19,7 +19,7 @@ export default class Text extends Renderable {
      * @param {number} [settings.wordWrapWidth] - the maximum length in CSS pixel for a single segment of text
      * @param {(string|string[])} [settings.text=""] - a string, or an array of strings
      * @example
-     * let font = new me.Text(0, 0, {font: "Arial", size: 8, fillStyle: this.color});
+     * let font = new Text(0, 0, {font: "Arial", size: 8, fillStyle: this.color});
      */
     constructor(x: number, y: number, settings: {
         font: string;
@@ -94,6 +94,10 @@ export default class Text extends Renderable {
     /** @ignore */
     onResetEvent(x: any, y: any, settings: any): void;
     canvasTexture: CanvasRenderTarget | undefined;
+    /**
+     * @ignore
+     */
+    _visibleCharacters: any;
     metrics: TextMetrics | undefined;
     /**
      * make the font bold
@@ -122,6 +126,28 @@ export default class Text extends Renderable {
      * @returns {Text} this object for chaining
      */
     setText(value?: number | string | string[]): Text;
+    public set visibleCharacters(value: number);
+    /**
+     * the number of characters to display (use -1 to show all).
+     * Useful for typewriter effects combined with Tween.
+     * @public
+     * @type {number}
+     * @default -1
+     * @see Text#visibleRatio
+     * @example
+     * // typewriter effect
+     * text.visibleCharacters = 0;
+     * new Tween(text).to({ visibleRatio: 1.0 }, { duration: 2000 }).start();
+     */
+    public get visibleCharacters(): number;
+    public set visibleRatio(value: number);
+    /**
+     * the ratio of visible characters (0.0 to 1.0).
+     * Setting this automatically updates {@link visibleCharacters}.
+     * @public
+     * @type {number}
+     */
+    public get visibleRatio(): number;
     /**
      * measure the given text size in pixels
      * @param {string} [text] - the text to be measured

package/build/renderable/text/text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/text.js"],"names":[],"mappings":"AAmBA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;OAiBG;IACH,eAjBW,MAAM,KACN,MAAM,YAEd;QAAyB,IAAI,EAArB,MAAM;QACkB,IAAI,EAA5B,MAAM,GAAC,MAAM;QACW,SAAS;QACT,WAAW;QACjB,SAAS;QACT,SAAS;QACT,YAAY;QACZ,UAAU;QACR,WAAW;QACb,aAAa;QACF,IAAI;KACzC,EA2EF;IApEA;;;;OAIG;IACH,WAHU,KAAK,CAGwB;IAEvC;;;;OAIG;IACH,aAHU,KAAK,CAG0B;IAEzC;;;;OAIG;IACH,WAHU,MAAM,CAGE;IAElB;;;;;OAKG;IACH,WAHU,MAAM,CAGO;IAEvB;;;;;OAKG;IACH,cAHU,MAAM,CAGS;IAEzB;;;;;OAKG;IACH,YAHU,MAAM,CAGK;IAErB;;;;;OAKG;IACH,eAHU,MAAM,CAGO;IAEvB;;;;OAIG;IACH,UAHU,MAAM,CAGE;IAElB;;;OAGG;IACH,cAAe;IAMhB,cAAc;IACd,kDAqEC;IATA,8CAEE;IAGF,iCAAoC;IAMrC;;;OAGG;IACH,QAFa,IAAI,CAWhB;IAJC,UAA+B;IAMjC;;;OAGG;IACH,UAFa,IAAI,CAWhB;IAED;;;;;;;;OAQG;IACH,cAPW,MAAM,SACN,MAAM,GAAC,MAAM,GACX,IAAI,CAiChB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GACpB,IAAI,CAyDhB;IAqDD;;;;OAIG;IACH,mBAHW,MAAM,GACJ,WAAW,CAIvB;IAED;;;OAGG;IACH,eAFW,cAAc,GAAC,aAAa,QAetC;IAED;;OAEG;IACH,4EAiBC;IAED;;;OAGG;IACH,gBAUC;CACD;uBA/asB,kBAAkB;sBAHR,qBAAqB;+BAEvB,gDAAgD;wBAEvD,kBAAkB"}
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/text.js"],"names":[],"mappings":"AAmBA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;OAiBG;IACH,eAjBW,MAAM,KACN,MAAM,YAEd;QAAyB,IAAI,EAArB,MAAM;QACkB,IAAI,EAA5B,MAAM,GAAC,MAAM;QACW,SAAS;QACT,WAAW;QACjB,SAAS;QACT,SAAS;QACT,YAAY;QACZ,UAAU;QACR,WAAW;QACb,aAAa;QACF,IAAI;KACzC,EA2EF;IApEA;;;;OAIG;IACH,WAHU,KAAK,CAGwB;IAEvC;;;;OAIG;IACH,aAHU,KAAK,CAG0B;IAEzC;;;;OAIG;IACH,WAHU,MAAM,CAGE;IAElB;;;;;OAKG;IACH,WAHU,MAAM,CAGO;IAEvB;;;;;OAKG;IACH,cAHU,MAAM,CAGS;IAEzB;;;;;OAKG;IACH,YAHU,MAAM,CAGK;IAErB;;;;;OAKG;IACH,eAHU,MAAM,CAGO;IAEvB;;;;OAIG;IACH,UAHU,MAAM,CAGE;IAElB;;;OAGG;IACH,cAAe;IAMhB,cAAc;IACd,kDA0EC;IAdA,8CAEE;IAEF;;OAEG;IACH,wBAA4B;IAG5B,iCAAoC;IAMrC;;;OAGG;IACH,QAFa,IAAI,CAWhB;IAJC,UAA+B;IAMjC;;;OAGG;IACH,UAFa,IAAI,CAWhB;IAED;;;;;;;;OAQG;IACH,cAPW,MAAM,SACN,MAAM,GAAC,MAAM,GACX,IAAI,CAiChB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GACpB,IAAI,CAyDhB;IAkBD,oCAZU,MAAM,EAiBf;IArBD;;;;;;;;;;;OAWG;IACH,gCARU,MAAM,CAUf;IAyBD,+BAZU,MAAM,EAsBf;IA1BD;;;;;OAKG;IACH,2BAFU,MAAM,CAUf;IAiED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,WAAW,CAIvB;IAED;;;OAGG;IACH,eAFW,cAAc,GAAC,aAAa,QA2BtC;IAED;;OAEG;IACH,4EA6BC;IAED;;;OAGG;IACH,gBAUC;CACD;uBA/fsB,kBAAkB;sBAHR,qBAAqB;+BAEvB,gDAAgD;wBAEvD,kBAAkB"}

package/build/renderable/trigger.d.ts

@@ -3,7 +3,8 @@
  * @import ResponseObject from "./../physics/response.js";
  */
 /**
- * trigger an event when colliding with another object
+ * Trigger an event when colliding with another object.
+ * Supports both fade and mask-based transitions when loading a new level.
  * @category Game Objects
  */
 export default class Trigger extends Renderable {
@@ -14,8 +15,10 @@ export default class Trigger extends Renderable {
      * @param {number} [settings.width] - width of the trigger area
      * @param {number} [settings.height] - height of the trigger area
      * @param {Rect[]|Polygon[]|Line[]|Ellipse[]} [settings.shapes] - collision shape(s) that will trigger the event
-     * @param {string} [settings.duration] - Fade duration (in ms)
-     * @param {string|Color} [settings.color] - Fade color
+     * @param {number} [settings.duration] - Transition duration (in ms)
+     * @param {string|Color} [settings.color] - Transition color (also accepts legacy `fade` property)
+     * @param {string} [settings.transition="fade"] - Transition type: "fade" for a color fade, "mask" for a shape-based mask transition
+     * @param {Ellipse|Polygon} [settings.shape] - Mask shape for "mask" transition type (e.g. an Ellipse for iris, a Polygon for diamond/star)
      * @param {string} [settings.event="level"] - the type of event to trigger (only "level" supported for now)
      * @param {string} [settings.to] - level to load if level trigger
      * @param {string|Container} [settings.container] - Target container. See {@link level.load}
@@ -23,21 +26,45 @@ export default class Trigger extends Renderable {
      * @param {boolean} [settings.flatten] - Flatten all objects into the target container. See {@link level.load}
      * @param {boolean} [settings.setViewportBounds] - Resize the viewport to match the level. See {@link level.load}
      * @example
-     * world.addChild(new me.Trigger(
-     *     x, y, {
-     *         shapes: [new me.Rect(0, 0, 100, 100)],
-     *         "duration" : 250,
-     *         "color" : "#000",
-     *         "to" : "mymap2"
-     *     }
-     * ));
+     * // fade transition (default)
+     * world.addChild(new Trigger(x, y, {
+     *     shapes: [new Rect(0, 0, 100, 100)],
+     *     color: "#000",
+     *     duration: 250,
+     *     to: "mymap2",
+     * }));
+     * @example
+     * // mask transition with iris (ellipse) shape
+     * world.addChild(new Trigger(x, y, {
+     *     shapes: [new Rect(0, 0, 100, 100)],
+     *     transition: "mask",
+     *     shape: new Ellipse(0, 0, 1, 1),
+     *     color: "#000",
+     *     duration: 500,
+     *     to: "mymap2",
+     * }));
+     * @example
+     * // mask transition with diamond polygon
+     * world.addChild(new Trigger(x, y, {
+     *     shapes: [new Rect(0, 0, 100, 100)],
+     *     transition: "mask",
+     *     shape: new Polygon(0, 0, [
+     *         { x: 0, y: -1 }, { x: 1, y: 0 },
+     *         { x: 0, y: 1 }, { x: -1, y: 0 },
+     *     ]),
+     *     color: "#000",
+     *     duration: 400,
+     *     to: "mymap2",
+     * }));
      */
     constructor(x: number, y: number, settings: {
         width?: number | undefined;
         height?: number | undefined;
         shapes?: Rect[] | Polygon[] | Line[] | Ellipse[] | undefined;
-        duration?: string | undefined;
+        duration?: number | undefined;
         color?: string | Color;
+        transition?: string | undefined;
+        shape?: Ellipse | Polygon;
         event?: string | undefined;
         to?: string | undefined;
         container?: string | Container;
@@ -45,8 +72,10 @@ export default class Trigger extends Renderable {
         flatten?: boolean | undefined;
         setViewportBounds?: boolean | undefined;
     });
-    fade: any;
-    duration: string | undefined;
+    color: any;
+    duration: number | undefined;
+    transition: string;
+    transitionShape: any;
     fading: boolean;
     type: any;
     id: any;
@@ -62,11 +91,7 @@ export default class Trigger extends Renderable {
         event: string;
     };
     /**
-     * @ignore
-     */
-    onFadeComplete(): void;
-    /**
-     * trigger this event
+     * Trigger this event. Override in subclasses to customize behavior.
      * @protected
      */
     protected triggerEvent(): void;