melonjs 19.7.1 → 19.8.0

package/build/level/gltf/GLTFModel.d.ts

@@ -0,0 +1,173 @@
+/**
+ * @classdesc
+ * A rig-driven 3D model loaded from an animated glTF/GLB asset. Unlike a static
+ * {@link GLTFScene} (which flattens each node into an independent {@link Mesh}),
+ * a `GLTFModel` keeps the node **hierarchy** intact so a parent transform
+ * carries its children — e.g. rotating a character's `torso` moves the attached
+ * `arm` and `head`. Each frame, the active animation clip is sampled, world
+ * matrices are propagated down the tree, and every part mesh's placement is
+ * re-derived.
+ *
+ * The animation API mirrors {@link Sprite} for familiarity — `setCurrentAnimation`,
+ * `isCurrentAnimation`, `getAnimationNames`, `play`/`pause`, `animationpause` —
+ * but uses the cleaner options form everywhere: `setCurrentAnimation(name, {
+ * loop, speed, onComplete, next })`. Here `animationspeed` is a **playback
+ * multiplier** (1 = authored speed), not a per-frame delay.
+ *
+ * Instances are created automatically by {@link GLTFScene} when the asset
+ * defines animation channels; you usually obtain one via `level.load(...)`
+ * rather than constructing it directly.
+ * @augments Container
+ */
+export default class GLTFModel extends Container {
+    /**
+     * @param {object} data - the parsed glTF descriptor (`{ graph, animations, bounds, ... }`)
+     * @param {object} [options]
+     * @param {number} [options.scale=1] - pixels per glTF unit (uniform scene scale)
+     * @param {boolean} [options.rightHanded=true] - glTF Y-up → engine Y-down via a rotation (no mirror)
+     * @param {boolean} [options.lit=false] - render the part meshes through the lit batcher
+     */
+    constructor(data: object, options?: {
+        scale?: number | undefined;
+        rightHanded?: boolean | undefined;
+        lit?: boolean | undefined;
+    });
+    _zSign: number;
+    /** the node hierarchy keyed by glTF node index @ignore */
+    _nodes: any;
+    /** root node indices @ignore */
+    _roots: any;
+    /** glTF node index → its part Mesh instances (one per primitive) @ignore */
+    _meshByNode: {};
+    /** glTF node index → cached rest (bind-pose) local matrix @ignore */
+    _restMatrix: {};
+    /**
+     * glTF node index → its world matrix, a persistent 16-element buffer
+     * recomputed in place every pose (a child reads its parent's buffer
+     * during the DFS, so each node needs its own). Preallocated here so the
+     * per-frame pose path allocates nothing.
+     * @ignore
+     */
+    _world: {};
+    /** name → clip `{ name, duration, channelsByNode, animatedNodes }` @ignore */
+    anim: {};
+    /**
+     * playback multiplier for the current animation (1 = authored speed).
+     * @type {number}
+     * @default 1
+     */
+    animationspeed: number;
+    /**
+     * pause/resume the current animation without losing its pose or time.
+     * @type {boolean}
+     * @default false
+     */
+    animationpause: boolean;
+    /**
+     * a callback fired each time the current animation completes a cycle.
+     * @type {Function}
+     * @default undefined
+     */
+    /** @ignore */
+    current: {
+        name: undefined;
+        time: number;
+        length: number;
+    };
+    /** loop-completion callback (built from the options) @ignore */
+    resetAnim: (() => unknown) | (() => void) | (() => boolean) | (() => void) | undefined;
+    /** set when a `loop:false` clip has finished its single cycle @ignore */
+    _animDone: boolean;
+    /**
+     * the names of every animation clip defined by the source asset.
+     * @returns {string[]}
+     * @example
+     * model.getAnimationNames(); // ["idle", "walk", "sprint", ...]
+     */
+    getAnimationNames(): string[];
+    /**
+     * return true if `name` is the currently playing animation.
+     * @param {string} name - animation clip id
+     * @returns {boolean}
+     */
+    isCurrentAnimation(name: string): boolean;
+    /**
+     * play the given animation clip. The second argument mirrors {@link Sprite}
+     * and accepts the same forms: omit to loop forever, a `string` to chain to
+     * another clip when this one ends, a `function` legacy completion callback
+     * (return `false` to hold the final pose), or an options object.
+     * @param {string} name - animation clip id (see {@link GLTFModel#getAnimationNames})
+     * @param {string|Function|AnimationOptions} [options] - loop / chain / completion behavior
+     * @param {boolean} [preserveTime=false] - keep the current playback time instead of restarting at 0
+     * @returns {GLTFModel} this, for chaining
+     * @example
+     * model.setCurrentAnimation("walk");                       // loop forever
+     * model.setCurrentAnimation("die", { loop: false });       // play once, hold last pose
+     * model.setCurrentAnimation("jump", { next: "idle" });     // jump, then idle
+     * model.setCurrentAnimation("walk", { speed: 2 });         // twice as fast
+     * model.setCurrentAnimation("emote-yes", () => spawnFx()); // legacy callback
+     */
+    setCurrentAnimation(name: string, options?: string | Function | AnimationOptions, preserveTime?: boolean): GLTFModel;
+    /**
+     * Play an animation clip, or resume the current one. A shorthand for
+     * {@link GLTFModel#setCurrentAnimation}: call with a clip name to switch to
+     * (and start) it, or with no argument to resume after {@link GLTFModel#pause}.
+     * Always clears the paused state.
+     * @param {string} [name] - clip id to play; omit to just resume
+     * @param {string|Function|AnimationOptions} [options] - loop / chain / completion behavior (see {@link GLTFModel#setCurrentAnimation})
+     * @returns {GLTFModel} this, for chaining
+     * @example
+     * model.play("walk");                  // switch to + play "walk"
+     * model.play("die", { loop: false });  // play once, hold the last pose
+     * model.pause();
+     * model.play();                        // resume
+     */
+    play(name?: string, options?: string | Function | AnimationOptions): GLTFModel;
+    /**
+     * Pause the current animation, freezing it at its current pose. Resume with
+     * {@link GLTFModel#play}.
+     * @returns {GLTFModel} this, for chaining
+     */
+    pause(): GLTFModel;
+    /**
+     * Stop playback and reset the rig to its bind/rest pose (no clip active).
+     * After this {@link GLTFModel#isCurrentAnimation} is false for every clip;
+     * call {@link GLTFModel#play} to start again. (Use {@link GLTFModel#pause}
+     * instead to freeze in place.)
+     * @returns {GLTFModel} this, for chaining
+     */
+    stop(): GLTFModel;
+    /**
+     * Sample the active clip (if any) and propagate world transforms down the
+     * node tree, writing each part mesh's placement. Nodes the current clip does
+     * not animate use their cached rest matrix.
+     * @ignore
+     */
+    _pose(): void;
+    /**
+     * DFS one node: compose its local matrix, multiply by the parent world,
+     * apply to its meshes, recurse into children.
+     * @ignore
+     */
+    _visit(idx: any, parentWorld: any, clip: any, t: any): void;
+    /**
+     * The node's local matrix: sampled TRS when the active clip animates it
+     * (starting from the rest pose, overriding only the animated components),
+     * otherwise the cached rest matrix.
+     * @returns {number[]} 16-element column-major matrix
+     * @ignore
+     */
+    _localMatrix(idx: any, clip: any, t: any): number[];
+    /**
+     * Split a node's world matrix into the renderable placement a {@link Mesh}'s
+     * Camera3d path expects: the translation (scaled, Y/Z-bridged) becomes
+     * `pos`/`depth`, the rotation+scale becomes `currentTransform` (translation
+     * zeroed). Mirrors the static {@link GLTFScene} center-split, recomputed per
+     * frame.
+     * @ignore
+     */
+    _applyWorldToMesh(mesh: any, world: any): void;
+}
+import Container from "../../renderable/container.js";
+import type { AnimationOptions } from "../../renderable/animation.ts";
+//# sourceMappingURL=GLTFModel.d.ts.map

package/build/level/gltf/GLTFModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GLTFModel.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/GLTFModel.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACC;;;;;;OAMG;IACH,kBANW,MAAM,YAEd;QAAyB,KAAK;QACJ,WAAW;QACX,GAAG;KAC/B,EAkKA;IAtJA,eAAoD;IAepD,0DAA0D;IAC1D,YAA8B;IAC9B,gCAAgC;IAChC,YAA8B;IAC9B,4EAA4E;IAC5E,gBAAqB;IACrB,qEAAqE;IACrE,gBAAqB;IACrB;;;;;;OAMG;IACH,WAAgB;IAsEhB,8EAA8E;IAC9E,SAAc;IAiBd;;;;OAIG;IACH,gBAHU,MAAM,CAGO;IAEvB;;;;OAIG;IACH,gBAHU,OAAO,CAGU;IAE3B;;;;OAIG;IAIH,cAAc;IACd;;;;MAAsD;IACtD,gEAAgE;IAChE,uFAA0B;IAC1B,yEAAyE;IACzE,mBAAsB;IAOvB;;;;;OAKG;IACH,qBAJa,MAAM,EAAE,CAMpB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;;OAeG;IACH,0BAXW,MAAM,YACN,MAAM,cAAU,gBAAgB,iBAChC,OAAO,GACL,SAAS,CAsDrB;IAED;;;;;;;;;;;;;OAaG;IACH,YATW,MAAM,YACN,MAAM,cAAU,gBAAgB,GAC9B,SAAS,CAarB;IAED;;;;OAIG;IACH,SAFa,SAAS,CAKrB;IAED;;;;;;OAMG;IACH,QAFa,SAAS,CAarB;IAyCD;;;;;OAKG;IACH,cAMC;IAED;;;;OAIG;IACH,4DAqBC;IAED;;;;;;OAMG;IACH,2CAHa,MAAM,EAAE,CAwCpB;IAED;;;;;;;OAOG;IACH,+CASC;CACD;sBA9eqB,+BAA+B;sCAMhB,+BAA+B"}

package/build/level/gltf/GLTFScene.d.ts

@@ -0,0 +1,84 @@
+/**
+ * @classdesc
+ * A loadable 3D scene parsed from a glTF / GLB asset. Instances are created
+ * and registered with the {@link level} director (usually automatically by
+ * the preloader), so a glTF scene loads with the same one-call ergonomics as
+ * a Tiled map: `level.load("myScene")`.
+ *
+ * Each glTF mesh node is instantiated as a {@link Mesh} carrying its own
+ * world transform, so the scene's relative scale and layout are preserved.
+ * View the result under a `Camera3d` for a coherent perspective.
+ */
+export default class GLTFScene {
+    /**
+     * @param {string} levelId - the glTF/GLB asset name (as preloaded)
+     */
+    constructor(levelId: string);
+    /**
+     * the level/asset name
+     * @type {string}
+     */
+    name: string;
+    /**
+     * level format discriminator used by the level director's dispatch
+     * @type {string}
+     */
+    format: string;
+    /**
+     * the parsed scene descriptor (`{ nodes, cameras, lights, bounds }`)
+     * @type {object}
+     */
+    data: object;
+    /**
+     * the world-space bounds of the scene (`{ min, max }` in glTF units), or
+     * undefined if the scene failed to load. Handy for framing a `Camera3d`.
+     * @returns {object|undefined}
+     */
+    get bounds(): object | undefined;
+    /**
+     * the cameras parsed from the glTF scene (each with a world matrix +
+     * perspective parameters), or an empty array.
+     * @returns {Array}
+     */
+    get cameras(): any[];
+    /**
+     * Instantiate every glTF mesh node as a `Mesh` in the given container.
+     * Called by the level director on `level.load(...)`.
+     * @param {Container} container - the target container (e.g. `game.world`)
+     * @param {object} [options]
+     * @param {number} [options.scale=1] - pixels per glTF unit (uniform scene scale)
+     * @param {boolean} [options.rightHanded=true] - convert glTF Y-up right-handed
+     * geometry to the engine's Y-down via a rotation (no mirror). See the wiki.
+     * @param {boolean} [options.lights=true] - add the scene's authored
+     * `KHR_lights_punctual` directional lights (plus a soft ambient fill) to the
+     * world as {@link Light3d} renderables, so the meshes are lit by the sun set
+     * up in the authoring tool. Set false to keep the meshes unlit / manage
+     * lighting yourself with `world.addChild(new Light3d(...))`.
+     */
+    addTo(container: Container, options?: {
+        scale?: number | undefined;
+        rightHanded?: boolean | undefined;
+        lights?: boolean | undefined;
+    }): void;
+    /**
+     * Add the scene's authored directional lights (plus a soft ambient fill) to
+     * the world as {@link Light3d} renderables, so the meshes are lit by the
+     * same sun set up in the authoring tool (Blender etc.). Shared by the static
+     * and animated paths. The lights are ordinary world children — the level
+     * director's `container.reset()` removes them on the next load, exactly like
+     * {@link Light2d}, so there's nothing to track or tear down here.
+     * @param {Container} container - the target container the lights are added to
+     * @param {number} zSign - the Y-up→Y-down Z bridge sign (rightHanded → -1)
+     * @param {object} options - the `addTo` options (`lights` toggle)
+     * @ignore
+     */
+    _addLights(container: Container, zSign: number, options: object): void;
+    /**
+     * Director cleanup hook (parity with `TMXTileMap.destroy`). Nothing to do —
+     * the meshes and lights are ordinary world children, removed by the
+     * director's `container.reset()` on the next load.
+     * @ignore
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=GLTFScene.d.ts.map

package/build/level/gltf/GLTFScene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GLTFScene.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/GLTFScene.js"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH;IACC;;OAEG;IACH,qBAFW,MAAM,EAkBhB;IAfA;;;OAGG;IACH,MAFU,MAAM,CAEG;IACnB;;;OAGG;IACH,QAFU,MAAM,CAEI;IACpB;;;OAGG;IACH,MAFU,MAAM,CAEY;IAG7B;;;;OAIG;IACH,cAFa,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,qBAEC;IAED;;;;;;;;;;;;;OAaG;IACH,iBAXW,SAAS,YAEjB;QAAyB,KAAK;QACJ,WAAW;QAEX,MAAM;KAKlC,QA4HA;IAED;;;;;;;;;;;OAWG;IACH,sBALW,SAAS,SACT,MAAM,WACN,MAAM,QAsChB;IAED;;;;;OAKG;IACH,gBAAY;CACZ"}

package/build/level/gltf/gltf_sampler.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Locate the keyframe interval for time `t` in the (ascending) `times` array.
+ * Clamps to the endpoints — glTF animations do not extrapolate beyond their
+ * first/last keyframe. Returns the bracketing indices and the 0..1 blend factor.
+ *
+ * The returned object is **reused** across calls (read/copy its fields
+ * immediately; don't retain the reference).
+ * @param {ArrayLike<number>} times - keyframe times, ascending
+ * @param {number} t - sample time (same units as `times`, i.e. seconds)
+ * @returns {{ i0: number, i1: number, alpha: number }} reused result object
+ * @ignore
+ */
+export function findKeyframe(times: ArrayLike<number>, t: number): {
+    i0: number;
+    i1: number;
+    alpha: number;
+};
+/**
+ * Spherical-linear interpolation between two quaternions stored in `values` at
+ * component offsets `o0` and `o1`. Picks the shortest arc (sign-flips the second
+ * quaternion when the dot is negative) and falls back to normalized-lerp for
+ * nearly-parallel inputs (where `sin(theta)` underflows). Result is normalized.
+ * @param {ArrayLike<number>} values - flat quaternion buffer (xyzw per key)
+ * @param {number} o0 - offset of the first quaternion
+ * @param {number} o1 - offset of the second quaternion
+ * @param {number} t - blend factor 0..1
+ * @param {number[]} out - 4-element [x,y,z,w] result
+ * @ignore
+ */
+export function slerpQuat(values: ArrayLike<number>, o0: number, o1: number, t: number, out: number[]): number[];
+/**
+ * Sample one animation channel at time `t`, writing `channel.stride` components
+ * into `out`. Rotation channels (stride 4) use {@link slerpQuat}; translation /
+ * scale (stride 3) use component-wise linear interpolation. `STEP` holds the
+ * lower keyframe; `CUBICSPLINE` uses the keyframe value (its tangents are
+ * ignored — a deliberate Tier-1 approximation, not full spline evaluation).
+ * @param {{times: ArrayLike<number>, values: ArrayLike<number>, stride: number, interpolation: string}} channel
+ * @param {number} t - sample time in seconds
+ * @param {number[]} out - destination, at least `channel.stride` long
+ * @returns {number[]} `out`
+ * @ignore
+ */
+export function sampleChannel(channel: {
+    times: ArrayLike<number>;
+    values: ArrayLike<number>;
+    stride: number;
+    interpolation: string;
+}, t: number, out: number[]): number[];
+//# sourceMappingURL=gltf_sampler.d.ts.map

package/build/level/gltf/gltf_sampler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf_sampler.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/gltf_sampler.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;GAWG;AACH,oCALW,SAAS,CAAC,MAAM,CAAC,KACjB,MAAM,GACJ;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAkCrD;AAED;;;;;;;;;;;GAWG;AACH,kCAPW,SAAS,CAAC,MAAM,CAAC,MACjB,MAAM,MACN,MAAM,KACN,MAAM,OACN,MAAM,EAAE,YA+ClB;AAED;;;;;;;;;;;GAWG;AACH,uCANW;IAAC,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAC,KAC5F,MAAM,OACN,MAAM,EAAE,GACN,MAAM,EAAE,CAwBpB"}

package/build/level/level.d.ts

@@ -4,7 +4,7 @@ export namespace level {
      * @name add
      * @memberof level
      * @public
-     * @param {string} format - level format (only "tmx" supported)
+     * @param {string} format - level format ("tmx" for Tiled maps, "gltf" / "glb" for 3D scenes)
      * @param {string} levelId - the level id (or name)
      * @param {Function} [callback] - a function to be called once the level is loaded
      * @returns {boolean} true if the level was loaded
@@ -20,8 +20,10 @@ export namespace level {
      * @param {object} [options] - additional optional parameters
      * @param {Container} [options.container=game.world] - container in which to load the specified level
      * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
-     * @param {boolean} [options.flatten=game.mergeGroup] - if true, flatten all objects into the given container
-     * @param {boolean} [options.setViewportBounds=true] - if true, set the viewport bounds to the map size
+     * @param {boolean} [options.flatten=game.mergeGroup] - (TMX only) if true, flatten all objects into the given container
+     * @param {boolean} [options.setViewportBounds=true] - (TMX only) if true, set the viewport bounds to the map size
+     * @param {number} [options.scale=1] - (glTF/GLB only) pixels per glTF unit applied to the whole scene
+     * @param {boolean} [options.rightHanded=true] - (glTF/GLB only) convert the right-handed (Y-up) source to the engine's Y-down via a rotation rather than a mirror
      * @returns {boolean} true if the level was successfully loaded
      * @example
      * // the game assets to be be preloaded
@@ -54,6 +56,8 @@ export namespace level {
         onLoaded?: Function | undefined;
         flatten?: boolean | undefined;
         setViewportBounds?: boolean | undefined;
+        scale?: number | undefined;
+        rightHanded?: boolean | undefined;
     }): boolean;
     /**
      * return the current level id<br>

package/build/level/level.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../src/level/level.js"],"names":[],"mappings":";IAkFC;;;;;;;;;OASG;IACH,qBALW,MAAM,WACN,MAAM,wBAEJ,OAAO,CAuBnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,uBAjCW,MAAM,YAEd;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;QACP,iBAAiB;KAC3C,GAAU,OAAO,CA8DnB;IAED;;;;;;OAMG;IACH,8BAFa,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,4BAFa,UAAU,CAItB;IAED;;;;;;;;;;OAUG;IACH,0BALG;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;KACjC,GAAU,MAAM,CAMlB;IAED;;;;;;;;;;OAUG;IACH,wBALG;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;KACjC,GAAU,OAAO,CASnB;IAED;;;;;;;;;;OAUG;IACH,4BALG;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;KACjC,GAAU,OAAO,CASnB;IAED;;;;;;OAMG;IACH,uBAFa,MAAM,CAIlB;;uBApRqB,uBAAuB"}
+{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../src/level/level.js"],"names":[],"mappings":";IA4FC;;;;;;;;;OASG;IACH,qBALW,MAAM,WACN,MAAM,wBAEJ,OAAO,CAkCnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,uBAnCW,MAAM,YAEd;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;QACP,iBAAiB;QAClB,KAAK;QACJ,WAAW;KACrC,GAAU,OAAO,CA0DnB;IAED;;;;;;OAMG;IACH,8BAFa,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,4BAFa,UAAU,CAItB;IAED;;;;;;;;;;OAUG;IACH,0BALG;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;KACjC,GAAU,MAAM,CAMlB;IAED;;;;;;;;;;OAUG;IACH,wBALG;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;KACjC,GAAU,OAAO,CASnB;IAED;;;;;;;;;;OAUG;IACH,4BALG;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;KACjC,GAAU,OAAO,CASnB;IAED;;;;;;OAMG;IACH,uBAFa,MAAM,CAIlB;;uBAtSqB,uBAAuB"}

package/build/level/tiled/TMXTileMap.d.ts

@@ -24,6 +24,11 @@ export default class TMXTileMap {
      * @type {string}
      */
     name: string;
+    /**
+     * level format discriminator used by the level director's dispatch
+     * @type {string}
+     */
+    format: string;
     /**
      * width of the tilemap in tiles
      * @type {number}

package/build/level/tiled/TMXTileMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TMXTileMap.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXTileMap.js"],"names":[],"mappings":"AAsIA;;;;GAIG;AACH;IACC;;;;;;;;OAQG;IACH,qBARW,MAAM,QACN,MAAM,EA0JhB;IAlJA;;;OAGG;IACH,aAAgB;IAEhB;;;OAGG;IACH,MAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,MAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,MAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,WAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,YAFU,MAAM,CAEkB;IAElC;;;;OAIG;IACH,UAHU,MAAM,CAGmB;IAEnC;;;;OAIG;IACH,aAHU,MAAM,CAGmB;IAEnC;;;;OAIG;IACH,OAHU,MAAM,CAGe;IAE/B;;;;OAIG;IACH,OAHU,MAAM,CAGe;IAE/B;;;;;OAKG;IACH,aAHU,MAAM,CAGmC;IAEnD;;;OAGG;IACH,SAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,cAFU,MAAM,CAE0B;IAE1C;;;OAGG;IACH,OAFU,MAAM,CAEO;IAGvB,6CAAoB;IAInB,cAAgB;IAIhB,oBAAsB;IAIvB,kBAA8C;IAG9C,iCAAmD;IAGnD,sBAAwC;IACxC,iBAAmC;IACnC,kBAAqC;IAGrC,YAAoD;IAGpD,WAA8B;IAC9B,YAAgC;IAGhC,qBAA2C;IAwB3C,qBAAwB;IAGzB;;;OAGG;IACH,eAFa,WAAW,CAUvB;IAHC,+OAAuC;IAKzC;;;OAGG;IACH,aAFa,MAAM,CAKlB;IAED;;;OAGG;IACH,gCA2DC;IAED;;;;;;;;;;;OAWG;IACH,iBATW,SAAS,YACT,OAAO,sBACP,OAAO,QA+EjB;IAED;;;;;;;;;OASG;IACH,qBAJW,OAAO,GAEL,UAAU,EAAE,CA4GxB;IAED;;;OAGG;IACH,aAFa,QAAQ,EAAE,CAMtB;IAED;;OAEG;IACH,gBAKC;CACD;4BAplB2B,sBAAsB;sBAV5B,+BAA+B;qBAOhC,eAAe"}
+{"version":3,"file":"TMXTileMap.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXTileMap.js"],"names":[],"mappings":"AAsIA;;;;GAIG;AACH;IACC;;;;;;;;OAQG;IACH,qBARW,MAAM,QACN,MAAM,EAgKhB;IAxJA;;;OAGG;IACH,aAAgB;IAEhB;;;OAGG;IACH,MAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,QAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,MAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,MAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,WAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,YAFU,MAAM,CAEkB;IAElC;;;;OAIG;IACH,UAHU,MAAM,CAGmB;IAEnC;;;;OAIG;IACH,aAHU,MAAM,CAGmB;IAEnC;;;;OAIG;IACH,OAHU,MAAM,CAGe;IAE/B;;;;OAIG;IACH,OAHU,MAAM,CAGe;IAE/B;;;;;OAKG;IACH,aAHU,MAAM,CAGmC;IAEnD;;;OAGG;IACH,SAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,cAFU,MAAM,CAE0B;IAE1C;;;OAGG;IACH,OAFU,MAAM,CAEO;IAGvB,6CAAoB;IAInB,cAAgB;IAIhB,oBAAsB;IAIvB,kBAA8C;IAG9C,iCAAmD;IAGnD,sBAAwC;IACxC,iBAAmC;IACnC,kBAAqC;IAGrC,YAAoD;IAGpD,WAA8B;IAC9B,YAAgC;IAGhC,qBAA2C;IAwB3C,qBAAwB;IAGzB;;;OAGG;IACH,eAFa,WAAW,CAUvB;IAHC,+OAAuC;IAKzC;;;OAGG;IACH,aAFa,MAAM,CAKlB;IAED;;;OAGG;IACH,gCA2DC;IAED;;;;;;;;;;;OAWG;IACH,iBATW,SAAS,YACT,OAAO,sBACP,OAAO,QA+EjB;IAED;;;;;;;;;OASG;IACH,qBAJW,OAAO,GAEL,UAAU,EAAE,CA4GxB;IAED;;;OAGG;IACH,aAFa,QAAQ,EAAE,CAMtB;IAED;;OAEG;IACH,gBAKC;CACD;4BA1lB2B,sBAAsB;sBAV5B,+BAA+B;qBAOhC,eAAe"}

package/build/{renderable → lighting}/light2d.d.ts

@@ -1,9 +1,8 @@
-/**
- * additional import for TypeScript
- * @import {Color} from "./../math/color.ts";
- * @import {Ellipse} from "./../geometries/ellipse.ts";
- * @import Renderer from "./../video/renderer.js";
- */
+import { Ellipse } from "../geometries/ellipse.ts";
+import { Color } from "../math/color.ts";
+import Renderable from "../renderable/renderable.js";
+import type CanvasRenderer from "../video/canvas/canvas_renderer.js";
+import type WebGLRenderer from "../video/webgl/webgl_renderer.js";
 /**
  * A 2D point light.
  *
@@ -23,9 +22,58 @@
  *
  * Light2d itself is renderer-agnostic — no shader knowledge, no canvas
  * allocation, no renderer reference held.
+ * @category Lighting
  * @see stage.lights
  */
 export default class Light2d extends Renderable {
+    /**
+     * the color of the light
+     * @default "#FFF"
+     */
+    color: Color;
+    /** The horizontal radius of the light */
+    radiusX: number;
+    /** The vertical radius of the light */
+    radiusY: number;
+    /**
+     * The intensity of the light
+     * @default 0.7
+     */
+    intensity: number;
+    /**
+     * the world-space geometry of the light's visible area, rewritten each
+     * frame by {@link Light2d#getVisibleArea} from transform-aware bounds.
+     * @ignore
+     */
+    visibleArea: Ellipse;
+    /**
+     * When `true`, this light acts as a pure illumination source — the
+     * gradient texture isn't drawn. The light still feeds the `Stage`
+     * ambient-cutout pass and the WebGL lit-sprite pipeline's per-frame
+     * uniforms, so normal-mapped sprites still get shaded by it. Use this for
+     * SpriteIlluminator-style demos where the light should be invisible (only
+     * its effect on normal-mapped surfaces is what you want to see).
+     *
+     * Default `false`, preserving the legacy "soft glowing spot" behavior.
+     * @default false
+     */
+    illuminationOnly: boolean;
+    /**
+     * Light height above the sprite plane (Z axis), in the same units as
+     * `radiusX`/`radiusY`. Used by the WebGL lit-sprite pipeline as the Z
+     * component of the light direction in the `dot(normal, lightDir)`
+     * calculation: a low height makes the lighting graze across the surface
+     * (long visible shadows on normal-map detail), a high height makes it
+     * head-on (more uniform brightness on the lit hemisphere).
+     *
+     * Default is `max(radiusX, radiusY) * 0.075` — a balanced look at the
+     * asset's native scale that prevents lights at the sprite's center from
+     * producing degenerate flat shading.
+     *
+     * Named `lightHeight` (not just `height`) to avoid colliding with the
+     * bbox-height getter Light2d inherits from `Rect`.
+     */
+    lightHeight: number;
     /**
      * Create a 2D point light.
      *
@@ -46,71 +94,28 @@ export default class Light2d extends Renderable {
      * inner alpha; the `Stage.ambientLight` color and alpha control how
      * dark the unlit areas are. Use `light.blendMode` to override the
      * default additive blend if needed.
-     * @param {number} x - The horizontal position of the light's center (matches `Ellipse(x, y, w, h)` conventions).
-     * @param {number} y - The vertical position of the light's center.
-     * @param {number} radiusX - The horizontal radius of the light.
-     * @param {number} [radiusY=radiusX] - The vertical radius of the light.
-     * @param {Color|string} [color="#FFF"] - The color of the light at full intensity.
-     * @param {number} [intensity=0.7] - The peak alpha of the radial gradient at the light's center (0–1).
+     * @param x - The horizontal position of the light's center (matches `Ellipse(x, y, w, h)` conventions).
+     * @param y - The vertical position of the light's center.
+     * @param radiusX - The horizontal radius of the light.
+     * @param [radiusY=radiusX] - The vertical radius of the light.
+     * @param [color="#FFF"] - The color of the light at full intensity.
+     * @param [intensity=0.7] - The peak alpha of the radial gradient at the light's center (0–1).
      */
     constructor(x: number, y: number, radiusX: number, radiusY?: number, color?: Color | string, intensity?: number);
     /**
-     * the color of the light
-     * @type {Color}
-     * @default "#FFF"
+     * the horizontal coordinate of this light's center.
+     * Overrides Rect's getter, which assumes `pos` is the bbox top-left and
+     * returns `pos.x + width/2`. Light2d uses `anchorPoint = (0.5, 0.5)`, so
+     * `pos` already IS the center.
      */
-    color: Color;
+    get centerX(): number;
+    set centerX(value: number);
     /**
-     * The horizontal radius of the light
-     * @type {number}
-     */
-    radiusX: number;
-    /**
-     * The vertical radius of the light
-     * @type {number}
-     */
-    radiusY: number;
-    /**
-     * The intensity of the light
-     * @type {number}
-     * @default 0.7
+     * the vertical coordinate of this light's center.
+     * @see Light2d#centerX
      */
-    intensity: number;
-    /** @ignore */
-    visibleArea: Ellipse;
-    /**
-     * When `true`, this light acts as a pure illumination source —
-     * the gradient texture isn't drawn. The light still feeds the
-     * `Stage` ambient-cutout pass and the WebGL lit-sprite
-     * pipeline's per-frame uniforms, so normal-mapped sprites still
-     * get shaded by it. Use this for SpriteIlluminator-style demos
-     * where the light should be invisible (only its effect on
-     * normal-mapped surfaces is what you want to see).
-     *
-     * Default `false`, preserving the legacy "soft glowing spot"
-     * behavior.
-     * @type {boolean}
-     * @default false
-     */
-    illuminationOnly: boolean;
-    /**
-     * Light height above the sprite plane (Z axis), in the same
-     * units as `radiusX`/`radiusY`. Used by the WebGL lit-sprite
-     * pipeline as the Z component of the light direction in the
-     * `dot(normal, lightDir)` calculation: a low height makes the
-     * lighting graze across the surface (long visible shadows on
-     * normal-map detail), a high height makes it head-on (more
-     * uniform brightness on the lit hemisphere).
-     *
-     * Default is `max(radiusX, radiusY) * 0.075` — a balanced look
-     * at the asset's native scale that prevents lights at the
-     * sprite's center from producing degenerate flat shading.
-     *
-     * Named `lightHeight` (not just `height`) to avoid colliding
-     * with the bbox-height getter Light2d inherits from `Rect`.
-     * @type {number}
-     */
-    lightHeight: number;
+    get centerY(): number;
+    set centerY(value: number);
     /**
      * Set new radii for this light.
      *
@@ -125,27 +130,27 @@ export default class Light2d extends Renderable {
      * `Renderable.resize(width, height)` — code that operates on a
      * generic `Renderable` and calls `.resize(w, h)` keeps working when
      * the instance happens to be a `Light2d`.
-     * @param {number} radiusX - new horizontal radius
-     * @param {number} [radiusY=radiusX] - new vertical radius
+     * @param radiusX - new horizontal radius
+     * @param [radiusY=radiusX] - new vertical radius
      */
     setRadii(radiusX: number, radiusY?: number): void;
     /**
      * returns a geometry representing the visible area of this light, in
      * world-space coordinates (so it aligns with the rendered gradient
      * regardless of camera scroll or container parenting).
-     * @returns {Ellipse} the light visible mask
+     * @returns the light visible mask
      */
     getVisibleArea(): Ellipse;
     /**
      * update function
-     * @returns {boolean} true if dirty
+     * @returns true if dirty
      */
     update(): boolean;
     /**
      * preDraw this Light2d (automatically called by melonJS)
-     * @param {Renderer} renderer - a renderer instance
+     * @param renderer - a renderer instance
      */
-    preDraw(renderer: Renderer): void;
+    preDraw(renderer: CanvasRenderer | WebGLRenderer): void;
     /**
      * draw this Light2d (automatically called by melonJS).
      *
@@ -153,9 +158,9 @@ export default class Light2d extends Renderable {
      * own implementation (procedural shader on WebGL; cached `Gradient`
      * rasterized into a shared `CanvasRenderTarget` on Canvas). Light2d
      * itself doesn't know which path is used.
-     * @param {Renderer} renderer - a renderer instance
+     * @param renderer - a renderer instance
      */
-    draw(renderer: Renderer): void;
+    draw(renderer: CanvasRenderer | WebGLRenderer): void;
     /**
      * Auto-register this light with the active Stage's lighting set when
      * added to a container. The Stage uses that set to build the ambient
@@ -171,13 +176,9 @@ export default class Light2d extends Renderable {
      */
     onDeactivateEvent(): void;
     /**
-     * Destroy function<br>
+     * Destroy function
      * @ignore
      */
     destroy(): void;
 }
-import Renderable from "./renderable.js";
-import type { Color } from "./../math/color.ts";
-import type { Ellipse } from "./../geometries/ellipse.ts";
-import type Renderer from "./../video/renderer.js";
 //# sourceMappingURL=light2d.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"light2d.d.ts","sourceRoot":"","sources":["../../src/lighting/light2d.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAe,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,KAAK,EAAa,MAAM,kBAAkB,CAAC;AACpD,OAAO,UAAU,MAAM,6BAA6B,CAAC;AAErD,OAAO,KAAK,cAAc,MAAM,oCAAoC,CAAC;AACrE,OAAO,KAAK,aAAa,MAAM,kCAAkC,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,OAAO,OAAO,OAAQ,SAAQ,UAAU;IAC9C;;;OAGG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAC;IAEhB,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;OAIG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;;;;;;;;;OAUG;IACH,gBAAgB,EAAE,OAAO,CAAC;IAE1B;;;;;;;;;;;;;;OAcG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;gBAEF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,MAAgB,EACzB,KAAK,GAAE,KAAK,GAAG,MAAe,EAC9B,SAAS,GAAE,MAAY;IAyCxB;;;;;OAKG;IACH,IAAa,OAAO,IAAI,MAAM,CAE7B;IACD,IAAa,OAAO,CAAC,KAAK,EAAE,MAAM,EAIjC;IAED;;;OAGG;IACH,IAAa,OAAO,IAAI,MAAM,CAE7B;IACD,IAAa,OAAO,CAAC,KAAK,EAAE,MAAM,EAIjC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,MAAgB;IAMnD;;;;;OAKG;IACH,cAAc,IAAI,OAAO;IAOzB;;;OAGG;IACM,MAAM,IAAI,OAAO;IAI1B;;;OAGG;IACM,OAAO,CAAC,QAAQ,EAAE,cAAc,GAAG,aAAa;IAKzD;;;;;;;;OAQG;IACM,IAAI,CAAC,QAAQ,EAAE,cAAc,GAAG,aAAa;IAOtD;;;;;;OAMG;IACM,eAAe;IAIxB;;;;OAIG;IACM,iBAAiB;IAI1B;;;OAGG;IACM,OAAO;CAOhB"}