melonjs 19.7.1 → 19.8.0

package/build/renderable/frameAnimation.d.ts

@@ -0,0 +1,154 @@
+/**
+ * additional import for TypeScript
+ * @import { TextureAtlas } from "../video/texture/atlas.js";
+ * @import { Vector2d } from "../math/vector2d.js";
+ */
+/**
+ * The shared **frame-animation engine** behind {@link Sprite} (2D) and
+ * {@link Sprite3d} (3D billboards). It *owns* the animation state — definitions,
+ * the current frame, timing, looping and chaining — everything independent of
+ * how a frame is ultimately *drawn*, and drives its host renderable through a
+ * small contract:
+ *
+ * - it reads the host's resolved texture (`host.source`, `host.textureAtlas`,
+ *   `host.atlasIndices`) to turn a frame index/name into a region;
+ * - it calls the `applyFrame(region)` callback passed to the constructor whenever
+ *   the frame changes — the host applies it to its own geometry ({@link Sprite}
+ *   swaps its source sub-texture, size and anchor; {@link Sprite3d} maps the
+ *   region onto its quad's UVs + vertices) **and marks itself dirty there**;
+ * - it fires `host.onended()` at each cycle end.
+ *
+ * The engine owns no dirty flag: a frame change flows through `applyFrame`, where
+ * the host sets its own `isDirty`. Callers read dirtiness from the host (the
+ * host's `update()` returns `super.update()` → `isDirty`).
+ *
+ * Hosts expose the public-facing state (`anim`, `current`, `animationspeed`,
+ * `animationpause`, …) as thin accessors onto this engine, so 2D and 3D frame
+ * animation share one implementation with no behavioral fork.
+ * @category Animation
+ */
+export default class FrameAnimation {
+    /**
+     * @param {object} host - the renderable this engine drives. Read for the
+     * texture it animates (`source` / `textureAtlas` / `atlasIndices`) and the
+     * mutable cycle-end callback (`onended`). These are read lazily (the texture is
+     * usually resolved after the engine is constructed), which is why they live on
+     * the host rather than being passed in. The engine does not touch `isDirty` —
+     * the host marks itself dirty inside `applyFrame`.
+     * @param {(region: object) => void} applyFrame - called whenever the frame
+     * changes, with the selected texture region; the host applies it to its own
+     * geometry (a {@link Sprite} swaps its sub-texture / size / anchor, a
+     * {@link Sprite3d} remaps its quad's UVs + vertices).
+     */
+    constructor(host: object, applyFrame: (region: object) => void);
+    /**
+     * the host renderable this engine draws through.
+     * @type {object}
+     * @ignore
+     */
+    host: object;
+    /**
+     * geometry hook invoked on every frame change (see constructor).
+     * @type {(region: object) => void}
+     * @ignore
+     */
+    _applyFrame: (region: object) => void;
+    /** defined animations, keyed by id @type {object} */
+    anim: object;
+    /** animation to chain to / completion callback on cycle end @ignore */
+    resetAnim: (() => unknown) | (() => void) | (() => boolean) | (() => void) | undefined;
+    /** current frame info @type {object} */
+    current: object;
+    /** elapsed time within the current frame, in ms @type {number} */
+    dt: number;
+    /** default frame cycling speed (ms between frames) @type {number} */
+    animationspeed: number;
+    /** pause flag — freezes the current frame @type {boolean} */
+    animationpause: boolean;
+    /** per-play speed multiplier (1 = authored speed) @ignore */
+    _animSpeed: number;
+    /** set once a `loop:false` animation has finished its single cycle @ignore */
+    _animDone: boolean;
+    /**
+     * add an animation definition (see {@link Sprite#addAnimation}).
+     * @param {string} name - animation id
+     * @param {number[]|string[]|object[]} index - frame indices / names / objects
+     * @param {number} [animationspeed] - cycling speed in ms
+     * @returns {number} number of frames added (0 if no texture atlas)
+     */
+    addAnimation(name: string, index: number[] | string[] | object[], animationspeed?: number): number;
+    /**
+     * select the active animation (see {@link Sprite#setCurrentAnimation}).
+     * @param {string} name - animation id
+     * @param {string|Function|object} [resetAnim] - loop / chain / completion behavior
+     * @param {boolean} [preserve_dt=false] - keep the elapsed-frame timer
+     * @returns {object} the host (for method chaining)
+     */
+    setCurrentAnimation(name: string, resetAnim?: string | Function | object, preserve_dt?: boolean): object;
+    /**
+     * reverse the given (or current) animation in place (see {@link Sprite#reverseAnimation}).
+     * The host marks itself dirty (this path doesn't re-apply a frame, so it's the
+     * one place a host's `reverseAnimation` wrapper sets `isDirty`).
+     * @param {string} [name] - animation id
+     */
+    reverseAnimation(name?: string): void;
+    /**
+     * @param {string} name - animation id
+     * @returns {boolean} true if `name` is the current animation
+     */
+    isCurrentAnimation(name: string): boolean;
+    /**
+     * @returns {string[]} the names of every defined animation
+     */
+    getAnimationNames(): string[];
+    /**
+     * apply a texture region as the current frame: store its geometry into
+     * `current` and hand it to the host to draw (see {@link Sprite#setRegion}).
+     * @param {object} region - the texture region object
+     * @returns {object} the host (for method chaining)
+     */
+    setRegion(region: object): object;
+    /**
+     * force the current animation frame index (see {@link Sprite#setAnimationFrame}).
+     * @param {number} [index=0] - animation frame index
+     * @returns {object} the host (for method chaining)
+     */
+    setAnimationFrame(index?: number): object;
+    /**
+     * @returns {number} the current animation frame index
+     */
+    getCurrentAnimationFrame(): number;
+    /**
+     * the frame object for the given index within the current animation.
+     * @param {number} id - the frame id
+     * @returns {object} the frame data
+     */
+    getAnimationFrameObjectByIndex(id: number): object;
+    /**
+     * clear the frame timer and the play-once "done" hold, without changing the
+     * current frame (the timer half of a stop, used by the video path which has
+     * no frame to rewind to).
+     */
+    resetTimer(): void;
+    /**
+     * reset the current animation to its first frame (the frame-animation half of
+     * {@link Sprite#stop} — the host still handles any video / pause concerns).
+     */
+    rewind(): void;
+    /**
+     * advance the frame animation by `dt` milliseconds, stepping frames, looping
+     * and chaining as configured (see {@link Sprite#update}). On a frame change the
+     * host marks itself dirty via `_applyFrame` (the engine owns no dirty flag);
+     * this returns whether a frame actually changed this tick — a finer-grained
+     * signal than the host's `isDirty` (which means "needs redraw for any reason").
+     * @param {number} dt - elapsed time since the last update, in milliseconds
+     * @returns {boolean} true if a frame changed this tick
+     */
+    update(dt: number): boolean;
+    /**
+     * release engine-held resources — returns the pooled `current.offset`
+     * Vector2d to the pool. Call from the host's `destroy()`.
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=frameAnimation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frameAnimation.d.ts","sourceRoot":"","sources":["../../src/renderable/frameAnimation.js"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACC;;;;;;;;;;;OAWG;IACH,kBAXW,MAAM,cAMN,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EA2DlC;IArDA;;;;OAIG;IACH,MAHU,MAAM,CAGA;IAEhB;;;;OAIG;IACH,aAHU,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAGL;IAE7B,qDAAqD;IACrD,MAD2C,MAAM,CACnC;IAEd,uEAAuE;IACvE,uFAA0B;IAE1B,wCAAwC;IACxC,SAD8B,MAAM,CAiBnC;IAED,kEAAkE;IAClE,IADwD,MAAM,CACnD;IAEX,qEAAqE;IACrE,gBAD2D,MAAM,CACxC;IAEzB,6DAA6D;IAC7D,gBADkD,OAAO,CAC9B;IAE3B,6DAA6D;IAC7D,mBAAmB;IAEnB,8EAA8E;IAC9E,mBAAsB;IAGvB;;;;;;OAMG;IACH,mBALW,MAAM,SACN,MAAM,EAAE,GAAC,MAAM,EAAE,GAAC,MAAM,EAAE,mBAC1B,MAAM,GACJ,MAAM,CAoElB;IAED;;;;;;OAMG;IACH,0BALW,MAAM,cACN,MAAM,cAAU,MAAM,gBACtB,OAAO,GACL,MAAM,CAuDlB;IAED;;;;;OAKG;IACH,wBAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,yBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,qBAFa,MAAM,EAAE,CAIpB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAiBlB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;OAEG;IACH,4BAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,mBAGC;IAED;;;OAGG;IACH,eAKC;IAED;;;;;;;;OAQG;IACH,WAHW,MAAM,GACJ,OAAO,CAyCnB;IAED;;;OAGG;IACH,gBAOC;CACD"}

package/build/renderable/mesh.d.ts

@@ -5,6 +5,17 @@
  * Includes a built-in perspective projection and supports 3D transforms
  * through the standard Renderable API (`rotate`, `scale`, `translate`).
  * Works on both WebGL (hardware depth testing) and Canvas (painter's algorithm) renderers.
+ *
+ * **Pivot — transforms are applied about the mesh's local origin `(0, 0, 0)`,
+ * NOT a normalized anchor point.** Unlike a {@link Sprite} (whose
+ * {@link Renderable#anchorPoint} recenters a `width`×`height` box), a mesh has
+ * real vertex coordinates, so rotation and scale pivot around the model origin
+ * the geometry is authored against — the standard convention for 3D meshes.
+ * Place the origin where you want the pivot at authoring time (or nest the
+ * mesh under a transformed parent to pivot elsewhere). Consequently, on the
+ * `Camera3d` world-space path the mesh opts out of the anchor offset entirely
+ * (see {@link Renderable#applyAnchorTransform}); the legacy 2D path still
+ * honors `anchorPoint` for backward compatibility.
  * @category Game Objects
  */
 export default class Mesh extends Renderable {
@@ -18,9 +29,16 @@ export default class Mesh extends Renderable {
      * @param {Uint16Array|number[]} [settings.indices] - triangle vertex indices (alternative to settings.model)
      * @param {HTMLImageElement|TextureAtlas|string} [settings.texture] - the texture to apply (image name, HTMLImageElement, or TextureAtlas). If omitted and settings.material is provided, the texture is resolved from the MTL material's map_Kd.
      * @param {string} [settings.material] - name of a preloaded MTL material (via loader.preload with type "mtl"). When provided, the diffuse texture (map_Kd), tint color (Kd), and opacity (d) are automatically applied.
-     * @param {number} settings.width - display width in pixels (the 3D model is normalized and scaled to fit this size)
-     * @param {number} settings.height - display height in pixels (the 3D model is normalized and scaled to fit this size)
+     * @param {number} settings.width - display width in pixels. With normalization on (the default) the model is scaled to fit this size; with `normalize: false` this is the uniform pixels-per-unit scale applied to the raw geometry.
+     * @param {number} [settings.height] - display height in pixels (normalized models only; ignored when `normalize: false`)
      * @param {boolean} [settings.cullBackFaces=true] - enable backface culling
+     * @param {boolean} [settings.normalize=true] - fit the source geometry into a `[-0.5, 0.5]` unit cube before scaling, so `width`/`height` behave like a Sprite. Set `false` to keep the geometry's real-world coordinates — required when several meshes share one coordinate space (e.g. nodes of an imported glTF scene) so their relative scale and layout are preserved.
+     * @param {number} [settings.scale] - world-space scale (pixels per source unit) for the Camera3d path; defaults to `width`. Set this when `width`/`height` describe the renderable's world bounds (frustum culling) rather than the geometry scale — see {@link Mesh#meshScale}.
+     * @param {boolean} [settings.rightHanded=false] - treat the source as right-handed (Y-up, e.g. glTF) under the `Camera3d` world path. The default Y-up→Y-down bridge negates Y only (a reflection, which mirrors the scene left/right); `true` negates Y **and** Z (a rotation) so chirality is preserved and the result matches the authoring tool. See {@link Mesh#rightHanded}.
+     * @param {string} [settings.textureRepeat] - texture wrap mode (`"repeat"` / `"repeat-x"` / `"repeat-y"` / `"no-repeat"`) applied to the resolved texture. Use `"repeat"` when the geometry's UVs fall outside the `[0, 1]` range and rely on the texture tiling (e.g. glTF assets, whose default sampler wrap is REPEAT) — otherwise the texture clamps to its edge texels and looks flat. Ignored for the white-pixel fallback. Note: REPEAT on a non-power-of-two texture requires WebGL 2.
+     * @param {string} [settings.textureFilter] - texture magnification filter (`"nearest"` for crisp pixel-art upscaling, `"linear"` for smooth) applied to the resolved texture. Omit to keep the renderer's global `antiAlias` default. WebGL only (ignored by the Canvas renderer).
+     * @param {number} [settings.alphaCutoff=0] - alpha cutout threshold. Fragments whose final alpha is below this value are discarded (hard-edged cutout — foliage, fences, decals — with no blending or sorting). `0` disables the cutout. Set automatically by the glTF loader from a material's `alphaMode: "MASK"`. WebGL mesh path only.
+     * @param {number[]|Float32Array} [settings.emissive] - emissive (self-illumination) color `[r, g, b]` (0..1, may exceed 1 for HDR glow) added on top of the lit/unlit color so the surface glows regardless of scene lights (neon, lava, screens). Omit / all-zero for no emission. Set automatically by the glTF loader (`emissiveFactor`) and OBJ loader (MTL `Ke`). WebGL mesh path only.
      * @example
      * // create from OBJ + MTL (texture auto-resolved from material)
      * let mesh = new me.Mesh(0, 0, {
@@ -38,6 +56,28 @@ export default class Mesh extends Renderable {
      *     height: 200,
      * });
      *
+     * // create from raw geometry that already carries its own world scale
+     * // (e.g. a glTF scene node) — keep real coordinates, no mirror
+     * let node = new me.Mesh(0, 0, {
+     *     vertices: positions, // Float32Array of x,y,z triplets
+     *     uvs: texcoords,      // Float32Array of u,v pairs
+     *     indices: tris,       // Uint16Array of triangle indices
+     *     texture: baseColorImage,
+     *     width: 32,           // pixels per unit
+     *     normalize: false,
+     *     rightHanded: true,
+     * });
+     *
+     * // material settings (WebGL) — usually set for you by the glTF/OBJ loader,
+     * // but available directly on a hand-built mesh too
+     * let sign = new me.Mesh(0, 0, {
+     *     vertices, uvs, indices, texture: "neon-sign",
+     *     width: 64, normalize: false,
+     *     textureFilter: "nearest",   // crisp pixel-art upscaling
+     *     alphaCutoff: 0.5,           // discard texels below 0.5 alpha (cutout)
+     *     emissive: [0.9, 0.2, 0.6],  // glow, independent of scene lights
+     * });
+     *
      * // 3D rotation using the standard rotate() API
      * mesh.rotate(Math.PI / 4, new me.Vector3d(0, 1, 0)); // rotate around Y axis
      *
@@ -52,8 +92,15 @@ export default class Mesh extends Renderable {
         texture?: string | HTMLImageElement | TextureAtlas | undefined;
         material?: string | undefined;
         width: number;
-        height: number;
+        height?: number | undefined;
         cullBackFaces?: boolean | undefined;
+        normalize?: boolean | undefined;
+        scale?: number | undefined;
+        rightHanded?: boolean | undefined;
+        textureRepeat?: string | undefined;
+        textureFilter?: string | undefined;
+        alphaCutoff?: number | undefined;
+        emissive?: number[] | Float32Array<ArrayBufferLike> | undefined;
     });
     /**
      * the original (untransformed) vertex positions as x,y,z triplets
@@ -76,12 +123,75 @@ export default class Mesh extends Renderable {
      * @type {Float32Array}
      */
     vertices: Float32Array;
+    /**
+     * the source per-vertex normals (x,y,z triplets), or `undefined` if the
+     * mesh was built without them. Supplied by the glTF loader; used for
+     * lit shading under a `Camera3d` (see {@link Light3d}).
+     * @type {Float32Array|undefined}
+     */
+    originalNormals: Float32Array | undefined;
+    /**
+     * Whether this mesh is lit by the active stage's {@link Light3d} lights.
+     * When `true` it renders through the lit mesh batcher (diffuse shading
+     * from the scene's lights, using {@link Mesh#originalNormals}); when
+     * `false` (the default) it uses the lean unlit path and pays no lighting
+     * cost. The glTF loader sets this on scene meshes when the scene has
+     * lights. Only meaningful under a `Camera3d` + WebGL.
+     * @type {boolean}
+     * @default false
+     */
+    lit: boolean;
+    /**
+     * Alpha cutout threshold. A fragment whose final alpha is below this
+     * value is discarded — a hard-edged cutout (foliage, fences, chain-link,
+     * decals) that needs no blending or back-to-front sorting. `0` (the
+     * default) disables the cutout and the mesh renders fully opaque. Set by
+     * the glTF loader from a material's `alphaMode: "MASK"` / `alphaCutoff`.
+     * WebGL mesh path only (the Canvas renderer ignores it).
+     * @type {number}
+     * @default 0
+     */
+    alphaCutoff: number;
+    /**
+     * Emissive (self-illumination) color as an `[r, g, b]` `Float32Array`
+     * (0..1, may exceed 1 for HDR glow), added on top of the lit/unlit color
+     * so the surface glows independently of the scene lights (neon, lava,
+     * screens, glowing eyes). `undefined` (the default) means no emission and
+     * keeps the mesh on the lean path. Set by the glTF loader from a material's
+     * `emissiveFactor` (× `KHR_materials_emissive_strength`) and by the OBJ
+     * loader from an MTL's `Ke`. WebGL mesh path only.
+     * @type {Float32Array|undefined}
+     */
+    emissive: Float32Array | undefined;
     /**
      * whether to cull back-facing triangles
      * @type {boolean}
      * @default true
      */
     cullBackFaces: boolean;
+    /**
+     * Treat the source geometry as right-handed (Y-up, e.g. glTF) under
+     * the Camera3d world path. The default (`false`) Y-up→Y-down bridge
+     * negates Y only — a reflection, which mirrors the scene left/right.
+     * When `true`, the bridge negates Y **and** Z (a 180° rotation about
+     * X, determinant +1) so chirality is preserved and the result matches
+     * the authoring tool (no mirror); triangle winding is left untouched
+     * since a rotation doesn't invert it.
+     * @type {boolean}
+     * @default false
+     */
+    rightHanded: boolean;
+    /**
+     * Uniform world-space scale (pixels per source unit) applied along the
+     * Camera3d world path. Defaults to `width`. Scene loaders (e.g. glTF)
+     * set this independently of `width` / `height` so those can describe
+     * the renderable's world-space bounds (used for frustum culling) while
+     * the geometry is still scaled by this factor — `width` alone can't
+     * serve both roles for a non-normalized scene mesh.
+     * @type {number}
+     * @default settings.width
+     */
+    meshScale: number;
     /**
      * Per-material submesh groups, populated when the OBJ
      * contains multiple `usemtl` directives AND a matching MTL
@@ -157,8 +267,9 @@ export default class Mesh extends Renderable {
      * view + projection matrices, the same way it does for Sprites.
      *
      * Per-vertex math: `currentTransform × originalVertex`, then a uniform
-     * scale by `this.width`, a Y-flip (OBJ Y-up → engine Y-down), and a
-     * translate to `(offsetX, offsetY, offsetZ)`.
+     * scale by `this.width`, the Y-up→Y-down bridge (negate Y, and also Z when
+     * {@link Mesh#rightHanded} is set so the bridge is a rotation rather than a
+     * mirror), and a translate to `(offsetX, offsetY, offsetZ)`.
      *
      * @param {number} offsetX - world X to place the mesh center at
      * @param {number} offsetY - world Y to place the mesh center at
@@ -166,6 +277,20 @@ export default class Mesh extends Renderable {
      * @ignore
      */
     _projectVerticesWorld(offsetX: number, offsetY: number, offsetZ: number): void;
+    /**
+     * Project {@link Mesh#originalNormals} into world space for lit shading,
+     * storing the result in {@link Mesh#normals}. Applies the rotation/scale of
+     * {@link Renderable#currentTransform} (no translation), the same Y-down /
+     * `rightHanded` Y/Z bridge as {@link Mesh#_projectVerticesWorld}, then
+     * renormalizes. No-op when the mesh has no source normals.
+     *
+     * Note: uses the transform's rotation/scale columns directly rather than
+     * the inverse-transpose, so normals are exact under rotation + uniform
+     * scale (the common case); a strongly non-uniform scale would skew them
+     * slightly — acceptable for the diffuse lighting path.
+     * @ignore
+     */
+    _projectNormalsWorld(): void;
     /**
      * Build the winding-reversed indices buffer used by the Camera3d
      * world-space path. Called once, lazily, the first time the mesh
@@ -186,9 +311,28 @@ export default class Mesh extends Renderable {
      * @ignore
      */
     _setupWorldSpace(): void;
-    _indicesReversed: Uint16Array<ArrayBuffer> | undefined;
+    _indicesReversed: any;
     _worldSpace: boolean | undefined;
     _useWorldSpace: boolean | undefined;
+    /**
+     * The mesh's world-space 3D axis-aligned bounding box, as projected by the
+     * most recent draw. This is the 3D analog of {@link Renderable#getBounds}
+     * (which returns a flat 2D box from `width`/`height` and so cannot describe
+     * a mesh's real extent).
+     *
+     * Under a `Camera3d` the mesh projects its vertices into world space every
+     * frame (see {@link Mesh#_projectVerticesWorld}), so the returned box tracks
+     * the live transform / animation. Under the 2D path the projected vertices
+     * are screen-space, so the box is only meaningful after a Camera3d draw —
+     * use {@link Renderable#getBounds} for the 2D case.
+     *
+     * The same {@link AABB3d} instance is returned each call (recomputed in
+     * place), so copy it (`.clone()`) if you need to keep it.
+     * @returns {AABB3d} the world-space bounding box (reused instance)
+     */
+    getBounds3d(): AABB3d;
+    /** @ignore */
+    _bounds3d: AABB3d | undefined;
     /**
      * Render the mesh at its current state (transforms, projection, tint) to an offscreen canvas.
      * The returned canvas can be used with `renderer.drawImage()`, as a `Sprite` image source,
@@ -218,5 +362,6 @@ import { Color } from "../math/color.ts";
 import { Matrix3d } from "../math/matrix3d.ts";
 import { Vector2d } from "../math/vector2d.ts";
 import { Polygon } from "../geometries/polygon.ts";
+import { AABB3d } from "../physics/broadphase/aabb3d.ts";
 import { TextureAtlas } from "./../video/texture/atlas.js";
 //# sourceMappingURL=mesh.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"mesh.d.ts","sourceRoot":"","sources":["../../src/renderable/mesh.js"],"names":[],"mappings":"AAgFA;;;;;;;;GAQG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,eAnCW,MAAM,KACN,MAAM,YAEd;QAA0B,KAAK;QACU,QAAQ;QACR,GAAG;QACJ,OAAO;QACS,OAAO;QACrC,QAAQ;QACT,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACa,aAAa;KACxC,EAkQF;IAjOC;;;OAGG;IACH,kBAFU,YAAY,CAEkB;IAExC;;;OAGG;IACH,KAFU,YAAY,CAEA;IAQtB;;;OAGG;IACH,aAFU,MAAM,CAEsB;IA2BvC,2BAAoC;IAGpC;;;OAGG;IACH,UAFU,YAAY,CAEgC;IAEtD;;;;OAIG;IACH,eAHU,OAAO,CAIoD;IAsBpE;;;;;;;;;;;;;;;;;OAiBG;IACH,QAHU,KAAK,CAAC;QAAC,YAAY,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QACrD,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,KAAK,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC,CAIhD;IAsBF;;;;;;;;;;;;;;;;;;OAkBG;IACH,cAFU,WAAW,CAEgC;IAgDtD,aAAiD;IAEjD;;;;;;OAMG;IACH,kBAFU,QAAQ,CAEoB;IAetC,cAAc;IACd,wBAEE;IACF,cAAc;IACd,6BAAwB;IAGzB;;;;;;;OAOG;IACH,2BALW,MAAM,YACN,MAAM,WACN,MAAM,QAiBhB;IAED;;;;;;;;;;;;;;;OAeG;IACH,+BALW,MAAM,WACN,MAAM,WACN,MAAM,QAiChB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,yBAUC;IAFA,uDAA2B;IAC3B,iCAAuB;IAoBvB,oCAAuD;IAyFxD;;;;;;;;;;;;OAYG;IACH,YATa,iBAAiB,CAoH7B;IAED;;;;;;;OAOG;IACH,iBALa,OAAO,CAAC,WAAW,CAAC,CAOhC;CACD;uBAnrBsB,iBAAiB;sBAVlB,kBAAkB;yBACf,qBAAqB;yBACrB,qBAAqB;wBAJtB,0BAA0B;6BAWrB,6BAA6B"}
+{"version":3,"file":"mesh.d.ts","sourceRoot":"","sources":["../../src/renderable/mesh.js"],"names":[],"mappings":"AAyGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgEG;IACH,eAhEW,MAAM,KACN,MAAM,YAEd;QAA0B,KAAK;QACU,QAAQ;QACR,GAAG;QACJ,OAAO;QACS,OAAO;QACrC,QAAQ;QACT,KAAK,EAAtB,MAAM;QACY,MAAM;QACL,aAAa;QACb,SAAS;QACV,KAAK;QACJ,WAAW;QACZ,aAAa;QACb,aAAa;QACb,WAAW;QACI,QAAQ;KACjD,EAoaF;IA7WC;;;OAGG;IACH,kBAFU,YAAY,CAEkB;IAExC;;;OAGG;IACH,KAFU,YAAY,CAEA;IAQtB;;;OAGG;IACH,aAFU,MAAM,CAEsB;IAmCvC,2BAAoC;IAGpC;;;OAGG;IACH,UAFU,YAAY,CAEgC;IAEtD;;;;;OAKG;IACH,iBAFU,YAAY,GAAC,SAAS,CAOnB;IAUb;;;;;;;;;OASG;IACH,KAHU,OAAO,CAGe;IAEhC;;;;;;;;;OASG;IACH,aAHU,MAAM,CAIoD;IAEpE;;;;;;;;;OASG;IACH,UAFU,YAAY,GAAC,SAAS,CAEa;IAE7C;;;;OAIG;IACH,eAHU,OAAO,CAIoD;IAErE;;;;;;;;;;OAUG;IACH,aAHU,OAAO,CAG+B;IAEhD;;;;;;;;;OASG;IACH,WAHU,MAAM,CAIiD;IAsBhE;;;;;;;;;;;;;;;;;OAiBG;IACH,QAHU,KAAK,CAAC;QAAC,YAAY,EAAE,MAAM,GAAC,IAAI,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QACrD,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,KAAK,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC,CAIhD;IAsBF;;;;;;;;;;;;;;;;;;OAkBG;IACH,cAFU,WAAW,CAEgC;IAuDtD,aAIC;IAkCD;;;;;;OAMG;IACH,kBAFU,QAAQ,CAEoB;IAoBtC,cAAc;IACd,wBAEE;IACF,cAAc;IACd,6BAAwB;IAGzB;;;;;;;OAOG;IACH,2BALW,MAAM,YACN,MAAM,WACN,MAAM,QAiBhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,+BALW,MAAM,WACN,MAAM,WACN,MAAM,QAqChB;IAED;;;;;;;;;;;;OAYG;IACH,6BA8BC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,yBAqBC;IAHC,sBAA2B;IAE5B,iCAAuB;IAoBvB,oCAAuD;IAGxD;;;;;;;;;;;;;;;OAeG;IACH,eAFa,MAAM,CAWlB;IAPC,cAAc;IACd,8BAA6B;IA4H/B;;;;;;;;;;;;OAYG;IACH,YATa,iBAAiB,CAoH7B;IAED;;;;;;;OAOG;IACH,iBALa,OAAO,CAAC,WAAW,CAAC,CAOhC;CACD;uBAr/BsB,iBAAiB;sBAXlB,kBAAkB;yBACf,qBAAqB;yBACrB,qBAAqB;wBAJtB,0BAA0B;uBAU3B,iCAAiC;6BAE3B,6BAA6B"}

package/build/renderable/renderable.d.ts

@@ -173,6 +173,28 @@ export default class Renderable extends Rect {
      * }
      */
     autoTransform: boolean;
+    /**
+     * Whether {@link Renderable#preDraw} applies the
+     * {@link Renderable#anchorPoint} offset to the renderer transform.
+     *
+     * When `true` (the default), the renderable is shifted by
+     * `-anchorPoint × (width, height)` so its anchor — not its top-left
+     * corner — aligns with its position. Correct for sprites and other 2D
+     * renderables.
+     *
+     * Set to `false` for a renderable that emits its own final world
+     * coordinates and takes its origin from geometry rather than a bounds
+     * box — e.g. a {@link Mesh} on the `Camera3d` world-space path (a 3D
+     * mesh is positioned by its transform and has no anchor). The WebGL mesh
+     * batcher reuses this same renderer transform as its **view matrix**,
+     * so applying the normalized anchor there would shift every mesh by
+     * half its OWN bounds box; because scene meshes size that box per node,
+     * props and the platforms they rest on would drift apart and overlap.
+     * @type {boolean}
+     * @default true
+     * @see Mesh#preDraw
+     */
+    applyAnchorTransform: boolean;
     /**
      * Define the renderable opacity<br>
      * Set to zero if you do not wish an object to be drawn

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

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

package/build/renderable/sprite.d.ts

@@ -63,17 +63,7 @@ export default class Sprite extends Renderable {
         anchorPoint?: Vector2d | undefined;
         normalMap?: string | ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | 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 +92,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 +106,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 +132,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 +287,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 +307,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,6 +362,7 @@ 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";

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":"AAYA;;;;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,EA4QF;IAtOA,2BAEE;IAEF;;;;OAIG;IACH,QAHU,QAAQ,CAGkB;IAEpC;;;;OAIG;IACH,SAHU,OAAO,CAGG;IAEpB;;;;OAIG;IAGH;;;OAGG;IACH,QAFU,YAAY,CAEJ;IAElB;;;;OAIG;IACH,wFAAsB;IAEtB;;;OAGG;IACH;;;;;MAKC;IAKA,WAAqC;IACrC,kBAAkC;IAiCjC,WAG8C;IAC9C,YAGgD;IA0LnD,0BANU,OAAO,EAQhB;IAVD;;;;OAIG;IACH,sBAHU,OAAO,CAKhB;IAlLE;;;OAGG;IACH,mDAEE;IA+LL,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;IA3HC,kBAAyC;IA2D3C;;;OAGG;IACH,YAFU,MAAM,CAIf;IAED;;;OAGG;IACH,eAFU,MAAM,CAIf;IASD,cALU,MAAM,EAOf;IATD;;;OAGG;IACH,UAFU,MAAM,CAIf;IAaD,0BANU,MAAM,EAQf;IAVD;;;;OAIG;IACH,sBAHU,MAAM,CAKf;IA2DD;;;OAGG;IACH,gBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,YATW,MAAM,YACN,MAAM,cAAU,MAAM,GACpB,MAAM,CAclB;IAED;;;;OAIG;IACH,SAFa,MAAM,CAKlB;IAED;;;;OAIG;IACH,QAFa,MAAM,CAelB;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,CAwBlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,0BAlCW,MAAM,cACN,MAAM,WAAS,gBACf,OAAO,GACL,MAAM,CAkClB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,GACJ,MAAM,CASlB;IAED;;;;;;;;OAQG;IACH,yBAPW,MAAM,GACJ,OAAO,CAQnB;IAED;;;;;;;;OAQG;IACH,qBANa,MAAM,EAAE,CAQpB;IAED;;;;;;;;OAQG;IACH,kBANW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;OAMG;IACH,oBAHW,MAAM,QA0ChB;IAED;;;;;;;OAOG;IACH,0BANW,MAAM,GACJ,MAAM,CAQlB;IAED;;;OAGG;IACH,4BAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;IAyCD;;;;;;OAMG;IACH,kBAFW,QAAQ,QAWlB;IAED;;;OAGG;IACH,mBAFW,QAAQ,QAQlB;IAED;;;;OAIG;IACH,eAHW,QAAQ,QAuDlB;IAED;;;OAGG;IACH,gBAiBC;CACD;uBAx0BsB,iBAAiB;2BADb,qBAAqB;8BAQrB,qBAAqB;6BATnB,6BAA6B;0BAUjC,wBAAwB;sBAb3B,kBAAkB"}