melonjs 19.7.1 → 19.9.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/imagelayer.d.ts

@@ -16,7 +16,7 @@ export default class ImageLayer extends Sprite {
      * @param {number} [settings.z=0] - z-index position
      * @param {number|Vector2d} [settings.ratio=1.0] - Scrolling ratio to be applied. See {@link ImageLayer#ratio}
      * @param {"repeat"|"repeat-x"|"repeat-y"|"no-repeat"} [settings.repeat="repeat"] - define if and how an Image Layer should be repeated. See {@link ImageLayer#repeat}
-     * @param {number|Vector2d} [settings.anchorPoint=<0.0,0.0>] - Define how the image is anchored to the viewport bound. By default, its upper-left corner is anchored to the viewport bounds upper left corner.
+     * @param {number|string|Vector2d|{x:number,y:number}} [settings.anchorPoint=<0.0,0.0>] - Define how the image is anchored to the viewport bound. By default, its upper-left corner is anchored to the viewport bounds upper left corner. Also accepts the named presets `"center"`, `"top"`, `"bottom"`, `"left"`, `"right"`, `"top-left"`, `"top-right"`, `"bottom-left"`, `"bottom-right"` (anchored relative to the viewport, e.g. `"bottom"` = bottom-center of the viewport); a bare number anchors both axes.
      * @example
      * // create a repetitive background pattern on the X axis using the citycloud image asset
      * app.world.addChild(new me.ImageLayer(0, 0, {
@@ -30,7 +30,10 @@ export default class ImageLayer extends Sprite {
         z?: number | undefined;
         ratio?: number | Vector2d | undefined;
         repeat?: "repeat" | "no-repeat" | "repeat-x" | "repeat-y" | undefined;
-        anchorPoint?: number | Vector2d | undefined;
+        anchorPoint?: string | number | Vector2d | {
+            x: number;
+            y: number;
+        } | undefined;
     });
     /**
      * Define the image scrolling ratio<br>

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

@@ -1 +1 @@
-{"version":3,"file":"imagelayer.d.ts","sourceRoot":"","sources":["../../src/renderable/imagelayer.js"],"names":[],"mappings":"AAYA;;;GAGG;AAEH;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;OAgBG;IACH,eAhBW,MAAM,KACN,MAAM,YAEd;QAA4E,KAAK,EAAzE,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,MAAM;QACvC,IAAI;QACJ,CAAC;QACQ,KAAK;QACsB,MAAM;QACjC,WAAW;KAC9C,EAoDF;IAhCA;;;;;;;;;OASG;IACH,OAHU,QAAQ,CAGqB;IAuCxC,kBAPU,MAAM,EA2Bf;IAnCD;;;;;;;;;;OAUG;IACH,cAHU,MAAM,CAKf;IAGA,4BAAoB;IAGlB,6BAAoB;IACpB,6BAAoB;IAkBvB,wBAsBC;IAED;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAOhB;IAED;;;OAGG;IACH,sBAKC;IAJA,cAGC;IAGF;;;OAGG;IACH,oBA+CC;IAED;;;;;;;;;;;;;;;OAeG;IACH,6BAmBC;IAED;;;;;OAKG;IACH,yBAHW,cAAc,GAAC,aAAa,aAC5B,QAAQ,QAyElB;IAGD,0BAMC;CAWD;mBA5VkB,aAAa;8BAIL,qBAAqB"}
+{"version":3,"file":"imagelayer.d.ts","sourceRoot":"","sources":["../../src/renderable/imagelayer.js"],"names":[],"mappings":"AAaA;;;GAGG;AAEH;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;OAgBG;IACH,eAhBW,MAAM,KACN,MAAM,YAEd;QAA4E,KAAK,EAAzE,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,MAAM;QACvC,IAAI;QACJ,CAAC;QACQ,KAAK;QACsB,MAAM;QACN,WAAW;eAAvC,MAAM;eAAG,MAAM;;KACjD,EAgEF;IAlCA;;;;;;;;;OASG;IACH,OAHU,QAAQ,CAGqB;IAyCxC,kBAPU,MAAM,EA2Bf;IAnCD;;;;;;;;;;OAUG;IACH,cAHU,MAAM,CAKf;IAGA,4BAAoB;IAGlB,6BAAoB;IACpB,6BAAoB;IAkBvB,wBAsBC;IAED;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAOhB;IAED;;;OAGG;IACH,sBAKC;IAJA,cAGC;IAGF;;;OAGG;IACH,oBA+CC;IAED;;;;;;;;;;;;;;;OAeG;IACH,6BAmBC;IAED;;;;;OAKG;IACH,yBAHW,cAAc,GAAC,aAAa,aAC5B,QAAQ,QAyElB;IAGD,0BAMC;CAWD;mBAxWkB,aAAa;8BAIL,qBAAqB"}

package/build/renderable/mesh.d.ts

@@ -5,6 +5,20 @@
  * 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. Subclasses that bake the
+ * anchor into their vertex data instead (e.g. {@link Sprite3d}, via the
+ * internal `_anchorBaked` flag) opt out on **both** paths — for those, the
+ * vertex bake is the single anchoring mechanism.
  * @category Game Objects
  */
 export default class Mesh extends Renderable {
@@ -18,9 +32,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"`) this mesh samples its texture with (per-mesh — it does not modify the shared texture, so other meshes/sprites using the same image are unaffected). 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 +59,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 +95,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 +126,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
@@ -128,6 +241,25 @@ export default class Mesh extends Renderable {
      */
     vertexColors: Uint32Array;
     texture: any;
+    /**
+     * Per-mesh texture wrap mode (`"repeat"` / `"repeat-x"` / `"repeat-y"`
+     * / `"no-repeat"`), or `undefined` to sample with the texture's own
+     * wrap. Some assets author UVs outside the `[0, 1]` range and rely on
+     * the sampler repeating the texture (this is the glTF default sampler
+     * behavior); the mesh would otherwise clamp to the edge texels and
+     * look flat / untextured.
+     *
+     * Kept on the mesh and threaded to the batcher at draw time — sampler
+     * state per use, like a GL sampler object — so it never mutates the
+     * per-image `TextureAtlas` shared with every other consumer of the
+     * same image (#1503). Two meshes (or a mesh and a sprite) can point
+     * at one image with different wrap modes; the texture cache keys GL
+     * units by `(source, repeat)` so each wrap gets its own GL texture.
+     * Applied only to a real texture — never the shared white-pixel
+     * fallback, which is global and must stay `"no-repeat"`.
+     * @type {string|undefined}
+     */
+    textureRepeat: string | undefined;
     /**
      * Projection matrix applied automatically before the model transform in draw().
      * Defaults to a perspective projection (45° FOV, camera at z=-2.5) suitable for
@@ -137,6 +269,8 @@ export default class Mesh extends Renderable {
      */
     projectionMatrix: Matrix3d;
     /** @ignore */
+    _anchorBaked: boolean;
+    /** @ignore */
     _hullPoints: Vector2d[];
     /** @ignore */
     _hullPolygon: Polygon | null;
@@ -157,8 +291,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 +301,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 +335,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 +386,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":"AAmHA;;;;;;;;;;;;;;;;;;;;;;GAsBG;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,EAwbF;IAjYC;;;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;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,eAFU,MAAM,GAAC,SAAS,CAKb;IAsBb;;;;;;OAMG;IACH,kBAFU,QAAQ,CAEoB;IAqBtC,cAAc;IACd,sBAAyB;IAOzB,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;IAkI/B;;;;;;;;;;;;OAYG;IACH,YATa,iBAAiB,CAoH7B;IAED;;;;;;;OAOG;IACH,iBALa,OAAO,CAAC,WAAW,CAAC,CAOhC;CACD;uBA3hCsB,iBAAiB;sBAZlB,kBAAkB;yBACf,qBAAqB;yBACrB,qBAAqB;wBAJtB,0BAA0B;uBAU3B,iCAAiC;6BAE3B,6BAA6B"}

package/build/renderable/nineslicesprite.d.ts

@@ -1,8 +1,3 @@
-/**
- * additional import for TypeScript
- * @import {Color} from "./../math/color.ts";
- * @import { TextureAtlas } from "./../video/texture/atlas.js";
- */
 /**
  * A NineSliceSprite is similar to a Sprite, but it uses 9-slice scaling to stretch its inner area to fit the size of the Renderable,
  * by proportionally scaling a sprite by splitting it in a grid of nine parts (with only parts 1, 3, 7, 9 not being scaled). <br>
@@ -27,7 +22,7 @@ export default class NineSliceSprite extends Sprite {
      * @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 {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"`.
      * @example
      * this.panelSprite = new me.NineSliceSprite(0, 0, {
      *     image : game.texture,
@@ -49,7 +44,10 @@ export default class NineSliceSprite extends Sprite {
         tint?: string | Color | undefined;
         flipX?: number | undefined;
         flipY?: number | undefined;
-        anchorPoint?: any;
+        anchorPoint?: string | Vector2d | {
+            x: number;
+            y: number;
+        };
     });
     set width(value: number);
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"nineslicesprite.d.ts","sourceRoot":"","sources":["../../src/renderable/nineslicesprite.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;GAMG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eAxBW,MAAM,KACN,MAAM,YAEd;QAAyB,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACY,MAAM;QACN,MAAM;QACyD,KAAK,EAAtF,gBAAgB,GAAC,iBAAiB,GAAC,YAAY,GAAC,eAAe,GAAC,MAAM;QACpD,IAAI;QACJ,MAAM;QACN,UAAU;QACV,WAAW;QACL,IAAI;QACV,KAAK;QACL,KAAK;QACH,WAAW;KACvC,EA8BF;IASD,iBALU,MAAM,EAOf;IATD;;;OAGG;IACH,aAFU,MAAM,CAIf;IAYD,kBALU,MAAM,EAOf;IATD;;;OAGG;IACH,cAFU,MAAM,CAIf;IAxBA,kBAA2B;IAC3B,mBAA6B;IAE7B,2BAA6B;IAC7B,2BAA6B;IAyB9B;;OAEG;IACH,0BA4JC;CACD;mBAvPkB,aAAa;kCAKC,6BAA6B;2BADtC,oBAAoB"}
+{"version":3,"file":"nineslicesprite.d.ts","sourceRoot":"","sources":["../../src/renderable/nineslicesprite.js"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eAxBW,MAAM,KACN,MAAM,YAEd;QAAyB,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACY,MAAM;QACN,MAAM;QACyD,KAAK,EAAtF,gBAAgB,GAAC,iBAAiB,GAAC,YAAY,GAAC,eAAe,GAAC,MAAM;QACpD,IAAI;QACJ,MAAM;QACN,UAAU;QACV,WAAW;QACL,IAAI;QACV,KAAK;QACL,KAAK;QACwB,WAAW,GAA1D,MAAM,GAAC,QAAQ,GAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC;KAC3C,EA8BF;IASD,iBALU,MAAM,EAOf;IATD;;;OAGG;IACH,aAFU,MAAM,CAIf;IAYD,kBALU,MAAM,EAOf;IATD;;;OAGG;IACH,cAFU,MAAM,CAIf;IAxBA,kBAA2B;IAC3B,mBAA6B;IAE7B,2BAA6B;IAC7B,2BAA6B;IAkD9B;;OAEG;IACH,0BAyEC;CACD;mBAvMkB,aAAa;kCAKC,6BAA6B;2BADtC,oBAAoB"}

package/build/renderable/renderable.d.ts

@@ -25,7 +25,12 @@ export default class Renderable extends Rect {
      * a Renderable's anchor point defaults to (0.5,0.5), which corresponds to the center position.<br>
      * <br>
      * <i><b>Note:</b> Object created through Tiled will have their anchorPoint set to (0, 0) to match Tiled Level editor implementation.
-     * To specify a value through Tiled, use a json expression like `json:{"x":0.5,"y":0.5}`. </i>
+     * To specify a value through Tiled, use a json expression like `json:{"x":0.5,"y":0.5}`, or (since 19.9) a plain string preset such as `bottom`. </i>
+     * <br>
+     * At construction time, `settings.anchorPoint` also accepts the named presets
+     * `"center"`, `"top"`, `"bottom"`, `"left"`, `"right"`, `"top-left"`, `"top-right"`,
+     * `"bottom-left"`, `"bottom-right"` on every renderable that consumes it
+     * (Sprite, Entity, Collectable, ImageLayer, Text, BitmapText, Sprite3d and subclasses).
      * @type {ObservablePoint}
      * @default <0.5,0.5>
      */
@@ -173,6 +178,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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"}