melonjs 19.7.1 → 19.9.0

package/build/renderable/sprite.d.ts

@@ -12,7 +12,7 @@ export default class Sprite extends Renderable {
      * @param {number} x - the x coordinates of the sprite object
      * @param {number} y - the y coordinates of the sprite object
      * @param {object} settings - Configuration parameters for the Sprite object
-     * @param {HTMLImageElement|HTMLCanvasElement|HTMLVideoElement|TextureAtlas|CompressedImage|string} settings.image - reference to spritesheet image, a texture atlas, a video element, a compressed texture, or to a texture atlas
+     * @param {HTMLImageElement|HTMLCanvasElement|HTMLVideoElement|Texture2d|TextureAtlas|CompressedImage|string} settings.image - reference to a spritesheet image, a {@link Texture2d} asset (e.g. a {@link TextureAtlas}), a video element, a compressed texture, or a loader key
      * @param {string} [settings.name=""] - name of this object
      * @param {string} [settings.region] - region name of a specific region to use when using a texture atlas, see {@link TextureAtlas}
      * @param {number} [settings.framewidth] - Width of a single frame within the spritesheet
@@ -20,8 +20,8 @@ export default class Sprite extends Renderable {
      * @param {string|Color} [settings.tint] - a tint to be applied to this sprite
      * @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).
+     * @param {string|Vector2d|{x:number,y:number}} [settings.anchorPoint={x:0.5, y:0.5}] - Anchor point to draw the frame at (defaults to the center of the frame). Also accepts the named presets `"center"`, `"top"`, `"bottom"`, `"left"`, `"right"`, `"top-left"`, `"top-right"`, `"bottom-left"`, `"bottom-right"`. For spritesheet atlases the anchor also becomes the cached atlas's per-frame pivot (see {@link TextureAtlas}).
+     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap|Texture2d|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, {
@@ -52,7 +52,7 @@ export default class Sprite extends Renderable {
      * videoSprite.play();
      */
     constructor(x: number, y: number, settings: {
-        image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | TextureAtlas | CompressedImage | string;
+        image: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | Texture2d | TextureAtlas | CompressedImage | string;
         name?: string | undefined;
         region?: string | undefined;
         framewidth?: number | undefined;
@@ -60,20 +60,13 @@ export default class Sprite extends Renderable {
         tint?: string | Color | undefined;
         flipX?: number | undefined;
         flipY?: number | undefined;
-        anchorPoint?: Vector2d | undefined;
-        normalMap?: string | ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | undefined;
+        anchorPoint?: string | Vector2d | {
+            x: number;
+            y: number;
+        } | undefined;
+        normalMap?: string | ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | Texture2d | undefined;
     });
-    /**
-     * @type {boolean}
-     * @default false
-     */
-    animationpause: boolean;
-    /**
-     * animation cycling speed (delay between frame in ms)
-     * @type {number}
-     * @default 100
-     */
-    animationspeed: number;
+    _frameAnim: FrameAnimation;
     /**
      * global offset for the position to draw from on the source image.
      * @type {Vector2d}
@@ -102,19 +95,6 @@ export default class Sprite extends Renderable {
      * @ignore
      */
     _normalMap: ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | null;
-    anim: {};
-    resetAnim: Function | (() => Sprite) | undefined;
-    current: {
-        name: undefined;
-        length: number;
-        offset: Vector2d;
-        width: number;
-        height: number;
-        angle: number;
-        idx: number;
-        trim: null;
-    };
-    dt: number;
     /**
      * flicker settings
      * @ignore
@@ -129,6 +109,13 @@ export default class Sprite extends Renderable {
     textureAtlas: any;
     width: any;
     height: any;
+    set animationpause(value: boolean);
+    /**
+     * pause the frame animation, freezing the current frame.
+     * @type {boolean}
+     * @default false
+     */
+    get animationpause(): boolean;
     /**
      * pause the video when losing focus
      * @ignore
@@ -148,19 +135,62 @@ export default class Sprite extends Renderable {
      */
     get normalMap(): HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap | null;
     atlasIndices: any;
+    /**
+     * defined animations, keyed by id (see {@link Sprite#addAnimation}).
+     * @type {object}
+     */
+    get anim(): object;
+    /**
+     * current frame information (name / index / texture offset & size / trim).
+     * @type {object}
+     */
+    get current(): object;
+    set dt(value: number);
+    /**
+     * elapsed time within the current animation frame, in milliseconds.
+     * @type {number}
+     */
+    get dt(): number;
+    set animationspeed(value: number);
+    /**
+     * animation cycling speed (delay between frames in ms).
+     * @type {number}
+     * @default 100
+     */
+    get animationspeed(): number;
     /**
      * return the flickering state of the object
      * @returns {boolean}
      */
     isFlickering(): boolean;
     /**
-     * play or resume the current animation or video
+     * Play an animation, or resume the current animation / video. A shorthand:
+     * call with an animation id to switch to (and start) it, or with no argument
+     * to resume after {@link Sprite#pause}. Always clears the paused state. The
+     * options mirror {@link Sprite#setCurrentAnimation} and the 3D
+     * {@link GLTFModel#play}, so 2D and 3D animation share one API.
+     * @param {string} [name] - animation id to play; omit to just resume
+     * @param {string|Function|object} [options] - loop / chain / completion behavior (see {@link Sprite#setCurrentAnimation})
+     * @returns {Sprite} Reference to this object for method chaining
+     * @example
+     * sprite.play("walk");                  // switch to + play "walk"
+     * sprite.play("die", { loop: false });  // play once, hold the last frame
+     * sprite.pause();
+     * sprite.play();                        // resume
+     */
+    play(name?: string, options?: string | Function | object): Sprite;
+    /**
+     * Pause the current animation or video, freezing the current frame. Resume
+     * with {@link Sprite#play}.
+     * @returns {Sprite} Reference to this object for method chaining
      */
-    play(): void;
+    pause(): Sprite;
     /**
-     * play or resume the current animation or video
+     * Stop the current animation or video and reset it to the first frame
+     * (paused). (Use {@link Sprite#pause} instead to freeze in place.)
+     * @returns {Sprite} Reference to this object for method chaining
      */
-    pause(): void;
+    stop(): Sprite;
     /**
      * make the object flicker
      * @param {number} duration - expressed in milliseconds
@@ -260,6 +290,16 @@ export default class Sprite extends Renderable {
      * }
      */
     isCurrentAnimation(name: string): boolean;
+    /**
+     * the names of every animation defined on this sprite (via
+     * {@link Sprite#addAnimation}).
+     * @returns {string[]} the defined animation names
+     * @example
+     * sprite.addAnimation("walk", [0, 1, 2, 3]);
+     * sprite.addAnimation("idle", [4, 5]);
+     * sprite.getAnimationNames(); // ["walk", "idle"]
+     */
+    getAnimationNames(): string[];
     /**
      * change the current texture atlas region for this sprite
      * @see Texture.getRegion
@@ -270,6 +310,14 @@ export default class Sprite extends Renderable {
      * mySprite.setRegion(mytexture.getRegion("shadedDark13.png"));
      */
     setRegion(region: object): Sprite;
+    /**
+     * Apply the current frame's texture region to this sprite's geometry: swap
+     * the source sub-texture, then resolve size / anchor (honoring trimming).
+     * Invoked by the shared {@link FrameAnimation} engine via `setRegion`.
+     * @param {object} region - the texture region object
+     * @ignore
+     */
+    _applyFrame(region: object): void;
     /**
      * force the current animation frame index.
      * @param {number} [index=0] - animation frame index
@@ -317,8 +365,10 @@ export default class Sprite extends Renderable {
     destroy(): void;
 }
 import Renderable from "./renderable.js";
+import FrameAnimation from "./frameAnimation.js";
 import type { Vector2d } from "../math/vector2d.js";
 import { TextureAtlas } from "./../video/texture/atlas.js";
 import type Renderer from "./../video/renderer.js";
+import Texture2d from "./../video/texture/texture2d.ts";
 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;;;;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"}
+{"version":3,"file":"sprite.d.ts","sourceRoot":"","sources":["../../src/renderable/sprite.js"],"names":[],"mappings":"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"}

package/build/renderable/sprite3d.d.ts

@@ -0,0 +1,350 @@
+/**
+ * A textured **quad in 3D space** — the 3D counterpart of {@link Sprite},
+ * for rendering sprites under a {@link Camera3d} (the 2.5D workflow: characters,
+ * pickups, foliage, signs, particles in a 3D scene). It's a thin {@link Mesh}
+ * subclass, so it rides the same world-space mesh pipeline (depth testing,
+ * frustum culling) and supports the same material features (`lit`, `emissive`,
+ * `alphaCutoff`).
+ *
+ * Its headline feature is **billboarding** — keeping the quad facing the camera
+ * regardless of camera orientation (see {@link Sprite3d#billboard}). With
+ * billboarding off it's a fixed-orientation quad (decals, posters, ground
+ * markers).
+ *
+ * **Frame animation** is supported through the same API as {@link Sprite}
+ * ({@link Sprite3d#addAnimation}, {@link Sprite3d#setCurrentAnimation},
+ * {@link Sprite3d#play}/`pause`/`stop`) — pass `framewidth`/`frameheight` for a
+ * spritesheet, or a packed {@link TextureAtlas}, exactly as you would for a 2D
+ * `Sprite`. Both share the {@link FrameAnimation} engine, so the timing, looping
+ * and chaining behavior is identical; `Sprite3d` maps the current frame onto the
+ * quad each step — including packer **rotated** and **trimmed** regions, mapped
+ * to full parity with the 2D `Sprite`.
+ *
+ * **Camera3d only.** Like {@link Mesh}, `Sprite3d` renders through the 3D
+ * world-space path; under a 2D `Camera2d` it falls back to the mesh's
+ * self-projection and **billboarding has no effect** (a 2D scene has no camera
+ * orientation to face). Use a regular {@link Sprite} for 2D.
+ *
+ * **Anchoring.** Unlike its {@link Mesh} parent — where `anchorPoint` is inert
+ * on the 3D path and transforms pivot at the model origin — Sprite3d's
+ * `anchorPoint` is live: the anchor is baked into the quad's local vertices
+ * (never applied as a renderer transform on either camera path) and can be
+ * changed at runtime via `anchorPoint.set(...)`, which re-bakes the quad and
+ * re-derives the cull bounds. Same key, convention and centered default as
+ * the 2D {@link Sprite}, including the named presets (`"bottom"`, …).
+ * @augments Mesh
+ * @category Game Objects
+ * @example
+ * import { Application, Camera3d, Sprite3d } from "melonjs";
+ *
+ * // a 3D app (Camera3d is required for billboarding)
+ * const app = new Application(1024, 768, { cameraClass: Camera3d });
+ *
+ * // a tree that always faces the camera but stays upright (2.5D).
+ * // its texture has a transparent background — the mesh pass is opaque, so
+ * // `alphaCutoff` (default 0.5) discards those texels for a clean silhouette.
+ * const tree = new Sprite3d(0, 0, {
+ *     image: "tree",        // a preloaded image with transparency
+ *     width: 64, height: 96,
+ *     z: -200,              // 3D depth (world z)
+ *     billboard: true,      // = "cylindrical"
+ *     // alphaCutoff: 0.5,  // the default — lower it to keep softer edges,
+ *                           // or set 0 for a fully-opaque quad
+ * });
+ * app.world.addChild(tree);   // add it to the game world, like any Renderable
+ *
+ * // an animated, fully camera-facing pickup from a spritesheet, mirrored
+ * const coin = new Sprite3d(0, 0, {
+ *     image: "coins",
+ *     framewidth: 32, frameheight: 32,
+ *     width: 48, height: 48,
+ *     billboard: "spherical",
+ *     alphaCutoff: 0.5,     // cut out the transparent frame background
+ * });
+ * coin.addAnimation("spin", [0, 1, 2, 3, 4, 5]);
+ * coin.setCurrentAnimation("spin");
+ * coin.flipX();             // face the other way (mirrors the sprite)
+ * app.world.addChild(coin);
+ *
+ * // a character anchored at the feet, so `pos` sits on the ground plane
+ * // instead of at the sprite's geometric center
+ * const hero = new Sprite3d(0, 0, {
+ *     image: "hero",
+ *     width: 48, height: 64,
+ *     billboard: "cylindrical",
+ *     anchorPoint: "bottom", // == { x: 0.5, y: 1 }
+ * });
+ */
+export default class Sprite3d extends Mesh {
+    /**
+     * @param {number} x - world x position
+     * @param {number} y - world y position
+     * @param {object} settings - configuration
+     * @param {HTMLImageElement|Texture2d|string} [settings.image] - the sprite texture (image name, image, or a {@link Texture2d} asset such as a {@link TextureAtlas}). Alias: `settings.texture`.
+     * @param {number} [settings.width=settings.framewidth] - quad width in world units (pixels)
+     * @param {number} [settings.height=settings.width] - quad height in world units
+     * @param {number} [settings.framewidth] - width of a single frame within a spritesheet (enables frame animation)
+     * @param {number} [settings.frameheight] - height of a single frame within a spritesheet
+     * @param {string} [settings.region] - region name when using a texture atlas (see {@link TextureAtlas})
+     * @param {object[]} [settings.anims] - predefined animations (same shape as {@link Sprite})
+     * @param {number} [settings.z=0] - 3D depth (world z); also settable later via `.depth`
+     * @param {boolean|string} [settings.billboard=false] - billboard mode: `false` (fixed orientation), `true` / `"cylindrical"` (faces the camera but stays upright — the 2.5D default), or `"spherical"` (faces the camera on all axes). Only applies under a `Camera3d`.
+     * @param {string|Vector2d|{x:number,y:number}} [settings.anchorPoint={x:0.5,y:0.5}] - anchor of the quad relative to `pos` — same key, normalized 0..1 convention (`x`: 0 left→1 right, `y`: 0 top→1 bottom) and centered default as the 2D {@link Sprite}. Also accepts the named presets `"center"`, `"top"`, `"bottom"`, `"left"`, `"right"`, `"top-left"`, `"top-right"`, `"bottom-left"`, `"bottom-right"`. Baked into the quad's local vertices (composes with billboarding, flips, and trimmed/rotated atlas frames) — never applied as a renderer transform on either camera path. Mutable at runtime via `this.anchorPoint.set(...)` (re-bakes the quad and re-derives the cull bounds). Invalid values throw.
+     * @param {boolean} [settings.flipX=false] - mirror the sprite horizontally (see {@link Sprite3d#flipX})
+     * @param {boolean} [settings.flipY=false] - mirror the sprite vertically (see {@link Sprite3d#flipY})
+     * @param {boolean} [settings.lit=false] - shade through the lit mesh batcher (see {@link Mesh})
+     * @param {number[]|Float32Array} [settings.emissive] - emissive color (see {@link Mesh})
+     * @param {number} [settings.alphaCutoff=0.5] - alpha cutout threshold (see {@link Mesh}). The mesh pass is opaque (no alpha blending), so this defaults to `0.5` to discard a sprite's transparent background (clean cutout silhouette, correct depth, no sorting). Set `0` for a fully-opaque quad, or tune the threshold.
+     */
+    constructor(x: number, y: number, settings: {
+        image?: string | HTMLImageElement | Texture2d | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        framewidth?: number | undefined;
+        frameheight?: number | undefined;
+        region?: string | undefined;
+        anims?: object[] | undefined;
+        z?: number | undefined;
+        billboard?: string | boolean | undefined;
+        anchorPoint?: string | Vector2d | {
+            x: number;
+            y: number;
+        };
+        flipX?: boolean | undefined;
+        flipY?: boolean | undefined;
+        lit?: boolean | undefined;
+        emissive?: number[] | Float32Array<ArrayBufferLike> | undefined;
+        alphaCutoff?: number | undefined;
+    });
+    /**
+     * the quad's half-width in world units (see {@link Sprite3d#billboard}).
+     * @type {number}
+     * @ignore
+     */
+    _halfW: number;
+    /** @ignore */
+    _halfH: number;
+    /** @ignore */
+    _anchorOffsetX: number;
+    /** @ignore */
+    _anchorOffsetY: number;
+    /** @ignore */
+    _refLw: number;
+    /** @ignore */
+    _refLh: number;
+    /** @ignore */
+    _flipX: boolean;
+    /** @ignore */
+    _flipY: boolean;
+    /** @ignore */
+    _region: object | null;
+    /**
+     * a callback fired when the current animation completes a cycle.
+     * @type {Function}
+     */
+    onended: Function;
+    /** the frame-aware atlas (== this.texture) @ignore */
+    source: any;
+    /** the atlas region dictionary @ignore */
+    textureAtlas: any;
+    /** name→index map for named-region atlases @ignore */
+    atlasIndices: any;
+    /** the shared frame-animation engine @ignore */
+    _frameAnim: FrameAnimation;
+    /**
+     * Billboard mode — keeps the quad facing the active {@link Camera3d}:
+     * - `false` (default) — fixed orientation (a flat quad in the XY plane;
+     *   decals, posters, ground markers).
+     * - `true` / `"cylindrical"` — faces the camera but stays upright
+     *   (rotates only around the world up axis). The 2.5D default — trees,
+     *   characters, items.
+     * - `"spherical"` — faces the camera on all axes (particles, glints).
+     *
+     * **Only applies under a `Camera3d`**; ignored on the 2D path.
+     *
+     * Note: while billboarding, orientation comes from the camera, so the
+     * renderable's `currentTransform` (`rotate()` / `scale()` / parent-container
+     * transforms) and `meshScale` are **not** applied — only `pos` / `depth`,
+     * `flipX` / `flipY`, and the quad's authored size. With billboarding `false`
+     * the standard {@link Mesh} world transform applies as usual.
+     * @type {boolean|string}
+     * @default false
+     */
+    billboard: boolean | string;
+    /** the camera captured at draw time for the billboard projection @ignore */
+    _billboardCam: Camera3d | null;
+    /**
+     * anchorPoint changed at runtime (the ObservablePoint callback wired in
+     * the constructor): recompute the baked local offset from the live anchor
+     * and the art size, re-bake the quad, and re-derive the frustum-cull
+     * bounds. Preserves the base ObservablePoint contract (updateBounds +
+     * isDirty, see Renderable's anchorPoint callback).
+     * @ignore
+     */
+    _onAnchorChanged(): void;
+    /**
+     * defined animations, keyed by id (see {@link Sprite3d#addAnimation}).
+     * @type {object}
+     */
+    get anim(): object;
+    /**
+     * current frame information (name / index / texture offset & size / trim).
+     * @type {object}
+     */
+    get current(): object;
+    set dt(value: number);
+    /**
+     * elapsed time within the current animation frame, in milliseconds.
+     * @type {number}
+     */
+    get dt(): number;
+    set animationspeed(value: number);
+    /**
+     * animation cycling speed (delay between frames in ms).
+     * @type {number}
+     * @default 100
+     */
+    get animationspeed(): number;
+    set animationpause(value: boolean);
+    /**
+     * pause the frame animation, freezing the current frame.
+     * @type {boolean}
+     * @default false
+     */
+    get animationpause(): boolean;
+    /**
+     * Add an animation, identical to {@link Sprite#addAnimation}.
+     * @param {string} name - animation id
+     * @param {number[]|string[]|object[]} index - frame indices / names (see {@link Sprite#addAnimation})
+     * @param {number} [animationspeed] - cycling speed in ms
+     * @returns {number} number of frames added
+     */
+    addAnimation(name: string, index: number[] | string[] | object[], animationspeed?: number): number;
+    /**
+     * Select the active animation, identical to {@link Sprite#setCurrentAnimation}.
+     * @param {string} name - animation id
+     * @param {string|Function|object} [resetAnim] - loop / chain / completion behavior
+     * @param {boolean} [preserve_dt=false]
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    setCurrentAnimation(name: string, resetAnim?: string | Function | object, preserve_dt?: boolean): Sprite3d;
+    /**
+     * Reverse the given (or current) animation in place (see {@link Sprite#reverseAnimation}).
+     * @param {string} [name] - animation id
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    reverseAnimation(name?: string): Sprite3d;
+    /**
+     * Mirror the sprite horizontally (e.g. flip a character to face the other
+     * way). Unlike the 2D {@link Sprite}, the flip mirrors the quad's local
+     * geometry so it works for every billboard mode and for rotated/trimmed atlas
+     * regions alike. Takes effect immediately on the current frame.
+     * @param {boolean} [flip=true]
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    flipX(flip?: boolean): Sprite3d;
+    /**
+     * Mirror the sprite vertically. See {@link Sprite3d#flipX}.
+     * @param {boolean} [flip=true]
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    flipY(flip?: boolean): Sprite3d;
+    /**
+     * @returns {boolean} true if the sprite is mirrored horizontally.
+     */
+    isFlippedX(): boolean;
+    /**
+     * @returns {boolean} true if the sprite is mirrored vertically.
+     */
+    isFlippedY(): boolean;
+    /**
+     * Play (and optionally switch to) an animation, identical to {@link Sprite#play}.
+     * @param {string} [name] - animation id to play; omit to resume
+     * @param {string|Function|object} [options] - loop / chain / completion behavior
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    play(name?: string, options?: string | Function | object): Sprite3d;
+    /**
+     * Pause the current animation, freezing the current frame (see {@link Sprite#pause}).
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    pause(): Sprite3d;
+    /**
+     * Stop and reset the current animation to its first frame (see {@link Sprite#stop}).
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    stop(): Sprite3d;
+    /**
+     * Force the current animation frame index (see {@link Sprite#setAnimationFrame}).
+     * @param {number} [index=0] - animation frame index
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    setAnimationFrame(index?: number): Sprite3d;
+    /**
+     * Apply a texture region directly (see {@link Sprite#setRegion}).
+     * @param {object} region - typically from `texture.getRegion(name)`
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    setRegion(region: object): Sprite3d;
+    /**
+     * @param {string} name - animation id
+     * @returns {boolean} true if `name` is the current animation (see {@link Sprite#isCurrentAnimation}).
+     */
+    isCurrentAnimation(name: string): boolean;
+    /**
+     * @returns {string[]} the names of every defined animation (see {@link Sprite#getAnimationNames}).
+     */
+    getAnimationNames(): string[];
+    /**
+     * @returns {number} the current animation frame index (see {@link Sprite#getCurrentAnimationFrame}).
+     */
+    getCurrentAnimationFrame(): number;
+    /**
+     * The frame object for the given index within the current animation.
+     * @param {number} id - the frame id
+     * @returns {object} the frame data
+     * @ignore
+     */
+    getAnimationFrameObjectByIndex(id: number): object;
+    /**
+     * Apply the current frame's texture region to the quad — the geometry hook
+     * called by the shared {@link FrameAnimation} engine (the 3D counterpart of
+     * {@link Sprite}'s sub-texture / size / anchor swap). Rewrites both the quad's
+     * UVs (the atlas sub-rect, with a 90° corner permutation for packer-rotated
+     * regions) and its local vertices (the trimmed art's sub-rectangle within the
+     * logical frame, scaled into the quad's world footprint, then shifted by the
+     * anchor offset), so trimmed and rotated `TextureAtlas` regions render at
+     * full parity with the 2D `Sprite`.
+     * @param {object} region - the texture region object
+     * @ignore
+     */
+    _applyFrame(region: object): void;
+    /**
+     * Release resources (returns the engine's pooled `current.offset` to the
+     * pool), then defer to the standard mesh/renderable teardown.
+     * @ignore
+     */
+    destroy(): void;
+    /**
+     * Capture the rendering camera so {@link Sprite3d#_projectVerticesWorld} can
+     * orient the billboard toward it. Read from the per-draw `viewport` (passed
+     * by `Container.draw`), so a multi-camera stage billboards correctly against
+     * whichever camera is drawing. When no `Camera3d` viewport is supplied the
+     * billboard is inactive and the quad renders fixed-orientation.
+     * @param {CanvasRenderer|WebGLRenderer} renderer
+     * @param {Camera2d} [viewport]
+     * @ignore
+     */
+    draw(renderer: CanvasRenderer | WebGLRenderer, viewport?: Camera2d): void;
+    /**
+     * Orient the quad toward the camera when billboarding; otherwise defer to the
+     * standard {@link Mesh} world projection (a fixed-orientation quad).
+     * @ignore
+     */
+    _projectVerticesWorld(offsetX: any, offsetY: any, offsetZ: any): void;
+}
+import Mesh from "./mesh.js";
+import FrameAnimation from "./frameAnimation.js";
+import Camera3d from "../camera/camera3d.ts";
+import Texture2d from "../video/texture/texture2d.ts";
+//# sourceMappingURL=sprite3d.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sprite3d.d.ts","sourceRoot":"","sources":["../../src/renderable/sprite3d.js"],"names":[],"mappings":"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"}

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

@@ -1,5 +1,11 @@
 /**
- * a bitmap font object
+ * a bitmap font object.
+ *
+ * The font descriptor uses the AngelCode BMFont format and may be supplied in
+ * either flavour — the **text** (`.fnt`) or the **XML** form — the
+ * serialisation is auto-detected, so packs that ship an `.xml` descriptor load
+ * as-is, with no conversion step. Load the descriptor as a `binary` asset and
+ * its page image as an `image` asset, then reference both by the same name.
  * @category Text
  */
 export default class BitmapText extends Renderable {
@@ -7,29 +13,32 @@ export default class BitmapText extends Renderable {
      * @param {number} x - position of the text object
      * @param {number} y - position of the text object
      * @param {object} settings - the text configuration
-     * @param {string|Image} settings.font - a font name to identify the corresponing source image
-     * @param {string} [settings.fontData=settings.font] - the bitmap font data corresponding name, or the bitmap font data itself
+     * @param {string|Image} settings.font - a font name to identify the corresponding source image
+     * @param {string} [settings.fontData=settings.font] - the bitmap font data corresponding name, or the bitmap font data itself (AngelCode BMFont, `.fnt` text or `.xml`)
      * @param {number} [settings.size] - size a scaling ratio
      * @param {Color|string} [settings.fillStyle] - a CSS color value used to tint the bitmapText (@see BitmapText.tint)
      * @param {number} [settings.lineWidth=1] - line width, in pixels, when drawing stroke
      * @param {string} [settings.textAlign="left"] - horizontal text alignment
      * @param {string} [settings.textBaseline="top"] - the text baseline
      * @param {number} [settings.lineHeight=1.0] - line spacing height
-     * @param {Vector2d} [settings.anchorPoint={x:0.0, y:0.0}] - anchor point to draw the text at
+     * @param {string|Vector2d|{x:number,y:number}} [settings.anchorPoint={x:0.0, y:0.0}] - anchor point to draw the text at. Also accepts the named presets `"center"`, `"top"`, `"bottom"`, `"left"`, `"right"`, `"top-left"`, `"top-right"`, `"bottom-left"`, `"bottom-right"`.
      * @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 loader.preload or loader.load to load assets
+     * // Load the BMFont descriptor as a "binary" asset and its page as an "image".
+     * // Both the text (.fnt) and XML (.xml) BMFont flavours are accepted and
+     * // auto-detected, so an .xml descriptor can be used directly:
      * loader.preload([
+     *     // text (.fnt) BMFont
      *     { name: "arial", type: "binary", src: "data/font/arial.fnt" },
-     *     { name: "arial", type: "image", src: "data/font/arial.png" },
+     *     { name: "arial", type: "image",  src: "data/font/arial.png" },
+     *     // XML BMFont (exported by many bitmap-font tools) — loaded as-is
+     *     { name: "pixel", type: "binary", src: "data/font/pixel.xml" },
+     *     { name: "pixel", type: "image",  src: "data/font/pixel.png" },
      * ])
      * // Then create an instance of your bitmap font:
-     * 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);
-     * // or just add it to the world container
+     * let myFont = new BitmapText(x, y, { font: "arial", text: "Hello" });
+     * // add it to the world container
      * app.world.addChild(myFont);
      */
     constructor(x: number, y: number, settings: {
@@ -41,7 +50,10 @@ export default class BitmapText extends Renderable {
         textAlign?: string | undefined;
         textBaseline?: string | undefined;
         lineHeight?: number | undefined;
-        anchorPoint?: any;
+        anchorPoint?: string | Vector2d | {
+            x: number;
+            y: number;
+        };
         wordWrapWidth?: number | undefined;
         text?: string | string[] | undefined;
     });

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,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"}
+{"version":3,"file":"bitmaptext.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/bitmaptext.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,eA/BW,MAAM,KACN,MAAM,YAEd;QAA+B,IAAI,EAA3B,MAAM,8DAAM;QACM,QAAQ;QACR,IAAI;QACE,SAAS;QACf,SAAS;QACT,SAAS;QACT,YAAY;QACZ,UAAU;QACmB,WAAW,GAA1D,MAAM,GAAC,QAAQ,GAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC;QACjB,aAAa;QACF,IAAI;KACzC,EAkIF;IA7GA;;;;;;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;IA8MlE,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;uBAvdsB,kBAAkB;sBAHnB,qBAAqB;wBAKnB,kBAAkB"}