melonjs 19.9.0 → 20.0.0

package/build/lang/deprecated.d.ts

@@ -25,7 +25,7 @@ export class CanvasTexture extends CanvasRenderTarget {
      * @param {number} width - the desired width of the canvas
      * @param {number} height - the desired height of the canvas
      * @param {object} attributes - The attributes to create both the canvas and context
-     * @param {boolean} [attributes.context="2d"] - the context type to be created ("2d", "webgl", "webgl2")
+     * @param {boolean} [attributes.context="2d"] - the context type to be created ("2d", "webgl" — creates a WebGL 2 context)
      * @param {boolean} [attributes.offscreenCanvas=false] - will create an offscreenCanvas if true instead of a standard canvas
      * @param {boolean} [attributes.willReadFrequently=false] - Indicates whether or not a lot of read-back operations are planned
      * @param {boolean} [attributes.antiAlias=false] - Whether to enable anti-aliasing, use false (default) for a pixelated effect.
@@ -39,9 +39,9 @@ export class CanvasTexture extends CanvasRenderTarget {
 }
 /**
  * @deprecated since 18.1.0
- * @see Batcher
+ * @see WebGLBatcher
  */
-export class Compositor extends Batcher {
+export class Compositor extends WebGLBatcher {
     /** @param {any[]} args */
     constructor(...args: any[]);
 }
@@ -63,7 +63,7 @@ export class QuadCompositor extends QuadBatcher {
 }
 export * as Math from "./../math/math.ts";
 import CanvasRenderTarget from "../video/rendertarget/canvasrendertarget.js";
-import { Batcher } from "../video/webgl/batchers/batcher.js";
+import { WebGLBatcher } from "../video/webgl/batchers/batcher.js";
 import PrimitiveBatcher from "../video/webgl/batchers/primitive_batcher.js";
 import QuadBatcher from "../video/webgl/batchers/quad_batcher.js";
 //# sourceMappingURL=deprecated.d.ts.map

package/build/lang/deprecated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deprecated.d.ts","sourceRoot":"","sources":["../../src/lang/deprecated.js"],"names":[],"mappings":"AAuJA;;;;;;;;GAQG;AACH,4CAHW,OAAO,QAsBjB;AAED;;;;;;GAMG;AACH,uCAeC;AA7LD;;;GAGG;AACH;IACC;;;;;;;;OAQG;IACH,mBARW,MAAM,UACN,MAAM,cAEd;QAA6B,OAAO;QACP,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EAIA;CACD;AA4BD;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;AAED;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;AAED;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;;+BA5F8B,6CAA6C;wBAEpD,oCAAoC;6BAC/B,8CAA8C;wBACnD,yCAAyC"}
+{"version":3,"file":"deprecated.d.ts","sourceRoot":"","sources":["../../src/lang/deprecated.js"],"names":[],"mappings":"AAuJA;;;;;;;;GAQG;AACH,4CAHW,OAAO,QAsBjB;AAED;;;;;;GAMG;AACH,uCAeC;AA7LD;;;GAGG;AACH;IACC;;;;;;;;OAQG;IACH,mBARW,MAAM,UACN,MAAM,cAEd;QAA6B,OAAO;QACP,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EAIA;CACD;AA4BD;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;AAED;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;AAED;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;;+BA3F8B,6CAA6C;6BAC/C,oCAAoC;6BACpC,8CAA8C;wBACnD,yCAAyC"}

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

@@ -26,11 +26,15 @@ export default class GLTFModel extends Container {
      * @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
+     * @param {boolean} [options.castGroundShadow] - give the parts a ground shadow; omit to inherit the application setting
+     * @param {number} [options.shadowGroundY] - world Y of the floor those shadows land on
      */
     constructor(data: object, options?: {
         scale?: number | undefined;
         rightHanded?: boolean | undefined;
         lit?: boolean | undefined;
+        castGroundShadow?: boolean | undefined;
+        shadowGroundY?: number | undefined;
     });
     _zSign: number;
     /** the node hierarchy keyed by glTF node index @ignore */

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

@@ -1 +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"}
+{"version":3,"file":"GLTFModel.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/GLTFModel.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACC;;;;;;;;OAQG;IACH,kBARW,MAAM,YAEd;QAAyB,KAAK;QACJ,WAAW;QACX,GAAG;QACH,gBAAgB;QACjB,aAAa;KACxC,EA2LA;IA/KA,eAAoD;IAepD,0DAA0D;IAC1D,YAA8B;IAC9B,gCAAgC;IAChC,YAA8B;IAC9B,4EAA4E;IAC5E,gBAAqB;IACrB,qEAAqE;IACrE,gBAAqB;IACrB;;;;;;OAMG;IACH,WAAgB;IA+FhB,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;sBA7gBqB,+BAA+B;sCAUhB,+BAA+B"}

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

@@ -1,3 +1,25 @@
+/**
+ * Fill an {@link InstancedMesh}'s records from an
+ * `EXT_mesh_gpu_instancing` node's per-instance TRS arrays.
+ *
+ * The records are written in the node's own (glTF, Y-up, right-handed)
+ * space, **verbatim** — no scene scale, no axis bridge. That is not a
+ * simplification but the consequence of where the instance transform sits
+ * in the chain the shader evaluates:
+ *
+ *     clip = projection × view × model(group) × instance × vertex
+ *
+ * The group's model matrix already carries the scene scale and the Y/Z
+ * bridge, and it is applied AFTER the instance transform — so an instance
+ * expressed in the same space as the vertices comes out placed correctly.
+ * Pre-scaling or pre-bridging the records here applies both twice (which
+ * put the first version of this forest 26× too far out, and well outside
+ * the far plane).
+ * @param {InstancedMesh} mesh - the mesh to fill
+ * @param {object} instances - `{count, translation, rotation, scale}`
+ * @ignore
+ */
+export function fillInstances(mesh: InstancedMesh, instances: object): void;
 /**
  * @classdesc
  * A loadable 3D scene parsed from a glTF / GLB asset. Instances are created
@@ -50,18 +72,30 @@ export default class GLTFScene {
      * @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(...))`.
+     * `KHR_lights_punctual` lights — directional suns, point and spot lamps
+     * (plus a soft ambient fill) — to the world as {@link Light3d}
+     * renderables, so the meshes are lit as set up in the authoring tool.
+     * Set false to keep the meshes unlit / manage lighting yourself with
+     * `world.addChild(new Light3d(...))`. Each instantiated light carries
+     * its authored name, so `world.getChildByName("Sun")` finds it for
+     * runtime tuning (day/night cycles, flicker).
+     * @param {number} [options.lightIntensityScale] - multiply each light's
+     * AUTHORED intensity by this factor instead of normalizing it to 1.
+     * glTF stores physical units — lux for suns (a Blender daylight sun is
+     * ~1000+), candela for lamps — which blow out the engine's stylized
+     * half-Lambert shading when used raw, so the default keeps every light
+     * at unit intensity and lets the app tune. With this option the
+     * authored ratios survive: e.g. `0.001` maps a 1000-lux sun to 1 while
+     * a half-strength 500-lux fill lands at 0.5.
      */
     addTo(container: Container, options?: {
         scale?: number | undefined;
         rightHanded?: boolean | undefined;
         lights?: boolean | undefined;
+        lightIntensityScale?: number | undefined;
     }): void;
     /**
-     * Add the scene's authored directional lights (plus a soft ambient fill) to
+     * Add the scene's authored lights — directional, point and spot — (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
@@ -69,10 +103,11 @@ export default class GLTFScene {
      * {@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 {number} scale - the scene's world scale (positions/ranges follow it)
      * @param {object} options - the `addTo` options (`lights` toggle)
      * @ignore
      */
-    _addLights(container: Container, zSign: number, options: object): void;
+    _addLights(container: Container, zSign: number, scale: 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
@@ -81,4 +116,5 @@ export default class GLTFScene {
      */
     destroy(): void;
 }
+import InstancedMesh from "../../renderable/instanced_mesh.js";
 //# sourceMappingURL=GLTFScene.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"GLTFScene.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/GLTFScene.js"],"names":[],"mappings":"AA6VA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oCAJW,aAAa,aACb,MAAM,QAwChB;AA7YD;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,iBAtBW,SAAS,YAEjB;QAAyB,KAAK;QACJ,WAAW;QAEX,MAAM;QAQP,mBAAmB;KAQ9C,QA4KA;IAED;;;;;;;;;;;;OAYG;IACH,sBANW,SAAS,SACT,MAAM,SACN,MAAM,WACN,MAAM,QAqEhB;IAED;;;;;OAKG;IACH,gBAAY;CACZ;0BAvVyB,oCAAoC"}

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

@@ -0,0 +1,20 @@
+/**
+ * Color-space bridge for glTF material factors.
+ *
+ * glTF 2.0 defines `pbrMetallicRoughness.baseColorFactor` in **linear** space
+ * (spec §3.9.2), while a melonJS `tint` is an 8-bit **sRGB** value — the same
+ * space as a CSS color or a texel out of a PNG. Handing the linear number
+ * straight to `tint.setColor(f * 255)` therefore displays every untextured
+ * glTF material far too light and desaturated: a linear `0.29` shows up as
+ * sRGB `0.58`, so an authored mid-green renders as pale mint.
+ *
+ * The encode below is the standard sRGB transfer function.
+ * @module level/gltf/srgb
+ */
+/**
+ * Encode one linear channel (0..1) to an 8-bit sRGB value (0..255).
+ * @param {number} c - linear channel value
+ * @returns {number} the sRGB-encoded channel, rounded to 0..255
+ */
+export function linearToSrgb8(c: number): number;
+//# sourceMappingURL=srgb.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"srgb.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/srgb.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;GAIG;AACH,iCAHW,MAAM,GACJ,MAAM,CAQlB"}

package/build/level/level.d.ts

@@ -24,6 +24,10 @@ export namespace level {
      * @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
+     * @param {boolean} [options.lights=true] - (glTF/GLB only) add the scene's authored `KHR_lights_punctual` lights (plus a soft ambient fill) as {@link Light3d} world children; each carries its authored name for `getChildByName` lookups
+     * @param {number} [options.lightIntensityScale] - (glTF/GLB only) multiply each light's authored physical intensity (lux/candela) by this factor instead of normalizing it to 1 — see {@link GLTFScene#addTo}
+     * @param {boolean} [options.castGroundShadow] - (glTF/GLB only) give this scene's meshes a ground shadow ({@link Mesh#castGroundShadow}). Overrides the application's `castGroundShadow` setting for this scene, in both directions; omit it to inherit. As a scene-wide opt-in it skips nodes with no vertical extent — a scene's ground plane is exactly that, and shadowing it with itself smears a blob across the whole floor
+     * @param {number} [options.shadowGroundY] - (glTF/GLB only) world Y of the floor those shadows land on ({@link Mesh#shadowGroundY}); omit it and each blob sits at its own object's base at full strength, which is right for a scene whose props already rest on the ground
      * @returns {boolean} true if the level was successfully loaded
      * @example
      * // the game assets to be be preloaded
@@ -50,6 +54,16 @@ export namespace level {
      * levelContainer.translate(-levelContainer.width / 2, -levelContainer.height / 2 );
      * // add it to the game world
      * app.world.addChild(levelContainer);
+     *
+     * // load a glTF/GLB scene (preloaded with type "glb") under a Camera3d:
+     * // 50 pixels per glTF unit, authored lux/candela intensities kept at
+     * // a 1/1000 scale instead of being normalized to 1
+     * me.level.load("diorama", { scale: 50, lightIntensityScale: 0.001 });
+     * // …and give every prop in it a ground shadow landing on the floor at y = 0
+     * // (the scene's own ground plane is skipped — it has no height to cast)
+     * me.level.load("diorama", { scale: 50, castGroundShadow: true, shadowGroundY: 0 });
+     * // the authored lights are world children — grab the sun for a day/night cycle
+     * const sun = app.world.getChildByName("Sun")[0];
      */
     function load(levelId: string, options?: {
         container?: any;
@@ -58,6 +72,10 @@ export namespace level {
         setViewportBounds?: boolean | undefined;
         scale?: number | undefined;
         rightHanded?: boolean | undefined;
+        lights?: boolean | undefined;
+        lightIntensityScale?: number | undefined;
+        castGroundShadow?: boolean | undefined;
+        shadowGroundY?: number | undefined;
     }): boolean;
     /**
      * return the current level id<br>
@@ -74,9 +92,9 @@ export namespace level {
      * @name getCurrentLevel
      * @memberof level
      * @public
-     * @returns {TMXTileMap}
+     * @returns {TMXTileMap|GLTFScene} the current level object (a TMXTileMap for Tiled maps, a GLTFScene for glTF/GLB scenes)
      */
-    function getCurrentLevel(): TMXTileMap;
+    function getCurrentLevel(): TMXTileMap | GLTFScene;
     /**
      * reload the current level
      * @name reload
@@ -135,4 +153,5 @@ export namespace level {
     function levelCount(): number;
 }
 import TMXTileMap from "./tiled/TMXTileMap.js";
+import GLTFScene from "./gltf/GLTFScene.js";
 //# sourceMappingURL=level.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsDG;IACH,uBAjDW,MAAM,YAEd;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;QACP,iBAAiB;QAClB,KAAK;QACJ,WAAW;QACX,MAAM;QACP,mBAAmB;QAClB,gBAAgB;QACjB,aAAa;KACtC,GAAU,OAAO,CAoEnB;IAED;;;;;;OAMG;IACH,8BAFa,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,4BAFa,UAAU,GAAC,SAAS,CAIhC;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;;uBApTqB,uBAAuB;sBADxB,qBAAqB"}

package/build/lighting/light3d.d.ts

@@ -7,13 +7,18 @@ import Renderable from "../renderable/renderable.js";
  */
 export interface Light3dOptions {
     /**
-     * light type. `"directional"` (a sun — shaded) and `"ambient"` (a flat fill
-     * added to every lit pixel) are used today; `"point"` is reserved.
+     * light type: `"directional"` (a sun), `"ambient"` (a flat fill added to
+     * every lit pixel), `"point"` (radiates from `position` with quadratic
+     * falloff over `range`) or `"spot"` (a point light confined to a cone
+     * along `direction`).
+     */
+    type?: "directional" | "ambient" | "point" | "spot";
+    /**
+     * world-space direction the light travels along (directional lights,
+     * and the cone axis of spot lights).
      */
-    type?: "directional" | "ambient" | "point";
-    /** world-space direction the light travels along (directional lights). */
     direction?: [number, number, number];
-    /** world-space position (point lights — reserved for a future release). */
+    /** world-space position (point and spot lights). */
     position?: [number, number, number];
     /**
      * light color — a {@link Color}, a CSS color string, or an `[r, g, b]`
@@ -22,6 +27,23 @@ export interface Light3dOptions {
     color?: Color | string | [number, number, number];
     /** scalar multiplier on the light's contribution. Defaults to `1`. */
     intensity?: number;
+    /**
+     * falloff distance in world units (point and spot lights): the light
+     * fades quadratically from full strength at its position to zero at
+     * `range` — the same stylized model as {@link Light2d}'s radius, not a
+     * physical inverse-square. Defaults to `1000`.
+     */
+    range?: number;
+    /**
+     * spot cone: angle (radians) from the axis where the light is at full
+     * strength. Defaults to `0`.
+     */
+    innerConeAngle?: number;
+    /**
+     * spot cone: angle (radians) from the axis where the light reaches
+     * zero, fading smoothly from `innerConeAngle`. Defaults to `π/4`.
+     */
+    outerConeAngle?: number;
 }
 /**
  * A 3D light source for the mesh lighting path — the 3D counterpart of
@@ -30,15 +52,20 @@ export interface Light3dOptions {
  * with the active {@link Stage}, so any lit mesh in that scene is shaded by it.
  * Remove it from the world to turn it off. A light draws nothing itself.
  *
- * Two types are used today:
+ * Four types are shaded:
  * - **`"directional"`** — a sun: a world-space `direction`, no falloff. Shaded
  *   via half-Lambert diffuse.
  * - **`"ambient"`** — a flat fill added to every lit pixel (the dark side of a
  *   mesh never goes fully black). `direction` / `position` are ignored.
+ * - **`"point"`** — radiates from `position`, fading quadratically to zero at
+ *   `range` (the same stylized falloff as {@link Light2d}'s radius).
+ * - **`"spot"`** — a point light confined to a cone along `direction`, at
+ *   full strength inside `innerConeAngle` and fading smoothly to zero at
+ *   `outerConeAngle`.
  *
- * `"point"` is reserved for a future release. Fields are public and mutable, so
- * a light can be animated at runtime (e.g. a day/night cycle rotating
- * `direction`, or fading `intensity`).
+ * Fields are public and mutable, so a light can be animated at runtime
+ * (e.g. a day/night cycle rotating `direction`, a flickering torch fading
+ * `intensity`, a searchlight sweeping its cone).
  * @category Lighting
  * @example
  * import { Light3d } from "melonjs";
@@ -48,20 +75,41 @@ export interface Light3dOptions {
  * app.world.addChild(sun);
  * app.world.addChild(new Light3d({ type: "ambient", intensity: 0.3 }));
  *
+ * // a street lamp pool and a searchlight cone
+ * app.world.addChild(new Light3d({
+ *     type: "point", position: [120, -40, 60], color: "#ffb45e", range: 300,
+ * }));
+ * app.world.addChild(new Light3d({
+ *     type: "spot", position: [0, -200, 0], direction: [0, 1, 0],
+ *     range: 800, innerConeAngle: 0.2, outerConeAngle: 0.45,
+ * }));
+ *
  * // animate the sun in-game (direction is the way light travels)
  * sun.direction.set(Math.sin(t), 1, Math.cos(t)).normalize();
  */
 export declare class Light3d extends Renderable {
-    /** `"directional"` / `"ambient"` (shaded) or `"point"` (reserved). */
-    type: "directional" | "ambient" | "point";
-    /** world-space travel direction (directional lights); kept normalized. */
+    /** `"directional"`, `"ambient"`, `"point"` or `"spot"`. */
+    type: "directional" | "ambient" | "point" | "spot";
+    /**
+     * world-space travel direction (directional lights, spot cone axis);
+     * kept normalized.
+     */
     direction: Vector3d;
-    /** world-space position (point lights — reserved). */
+    /** world-space position (point and spot lights). */
     position: Vector3d;
     /** the light color. */
     color: Color;
     /** scalar multiplier on the light's contribution. */
     intensity: number;
+    /**
+     * falloff distance in world units (point/spot) — full strength at the
+     * position, zero at `range`.
+     */
+    range: number;
+    /** spot cone inner angle (radians) — full strength inside it. */
+    innerConeAngle: number;
+    /** spot cone outer angle (radians) — zero beyond it. */
+    outerConeAngle: number;
     /**
      * @param [options] - see {@link Light3dOptions}
      */

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

@@ -1 +1 @@
-{"version":3,"file":"light3d.d.ts","sourceRoot":"","sources":["../../src/lighting/light3d.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,UAAU,MAAM,6BAA6B,CAAC;AAGrD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B;;;OAGG;IACH,IAAI,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,OAAO,CAAC;IAC3C,0EAA0E;IAC1E,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,OAAQ,SAAQ,UAAU;IACtC,sEAAsE;IAC7D,IAAI,EAAE,aAAa,GAAG,SAAS,GAAG,OAAO,CAAC;IACnD,0EAA0E;IAC1E,SAAS,EAAE,QAAQ,CAAC;IACpB,sDAAsD;IACtD,QAAQ,EAAE,QAAQ,CAAC;IACnB,uBAAuB;IACvB,KAAK,EAAE,KAAK,CAAC;IACb,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;gBACS,OAAO,GAAE,cAAmB;IAgDxC;;;;OAIG;IACM,eAAe;IAIxB;;;OAGG;IACM,iBAAiB;IAI1B;;;OAGG;IACM,IAAI;CACb"}
+{"version":3,"file":"light3d.d.ts","sourceRoot":"","sources":["../../src/lighting/light3d.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,UAAU,MAAM,6BAA6B,CAAC;AAGrD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B;;;;;OAKG;IACH,IAAI,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;IACpD;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,oDAAoD;IACpD,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBAAa,OAAQ,SAAQ,UAAU;IACtC,2DAA2D;IAClD,IAAI,EAAE,aAAa,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC;IAC5D;;;OAGG;IACH,SAAS,EAAE,QAAQ,CAAC;IACpB,oDAAoD;IACpD,QAAQ,EAAE,QAAQ,CAAC;IACnB,uBAAuB;IACvB,KAAK,EAAE,KAAK,CAAC;IACb,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,cAAc,EAAE,MAAM,CAAC;IACvB,wDAAwD;IACxD,cAAc,EAAE,MAAM,CAAC;IAEvB;;OAEG;gBACS,OAAO,GAAE,cAAmB;IAmDxC;;;;OAIG;IACM,eAAe;IAIxB;;;OAGG;IACM,iBAAiB;IAI1B;;;OAGG;IACM,IAAI;CACb"}

package/build/loader/loader.d.ts

@@ -32,7 +32,7 @@ export function setOptions(options: {
  * @name setBaseURL
  * @memberof loader
  * @public
- * @param {string} type  - "*", "audio", "video", "binary", "image", "json", "js", "tmx", "tsx", "fontface", "aseprite", "shader"
+ * @param {string} type  - "*", "audio", "video", "binary", "image", "json", "js", "tmx", "tsx", "fontface", "aseprite", "shader", "obj", "mtl", "gltf", "glb"
  * @param {string} [url="./"] - default base URL
  * @example
  * // change the base URL relative address for audio assets
@@ -47,7 +47,7 @@ export function setBaseURL(type: string, url?: string): void;
  * @typedef {object} Asset
  * @memberof loader
  * @property {string} name - name of the asset
- * @property {string} type  - the type of the asset ("audio"|"binary"|"image"|"json"|"js"|"tmx"|"tmj"|"tsx"|"tsj"|"fontface"|"video"|"aseprite"|"shader")
+ * @property {string} type  - the type of the asset ("audio"|"binary"|"image"|"json"|"js"|"tmx"|"tmj"|"tsx"|"tsj"|"fontface"|"video"|"aseprite"|"shader"|"obj"|"mtl"|"gltf"|"glb")
  * @property {string|string[]} [src]  - path and/or file name of the resource (for audio assets only the path is required).
  * For image assets, an array of sources can be provided as a fallback chain (e.g. compressed texture formats by priority, with a PNG fallback).
  * The loader will try each source in order and use the first one that loads successfully.
@@ -88,6 +88,14 @@ export function setBaseURL(type: string, url?: string): void;
  *   { name: "'kenpixel'", type: "fontface",  src: "data/font/kenvector_future.woff2" }
  *   // video resources
  *   {name: "intro", type: "video",  src: "data/video/"}
+ *   // 3D assets: Wavefront OBJ model + MTL material library
+ *   {name: "ship",  type: "obj", src: "data/models/ship.obj"}
+ *   {name: "ship",  type: "mtl", src: "data/models/ship.mtl"}
+ *   // glTF / GLB scene (auto-registers with the level director)
+ *   {name: "diorama", type: "glb", src: "data/scenes/diorama.glb"}
+ *   // shader assets: an effect body, or a complete dual-backend program
+ *   {name: "flash", type: "shader", src: "shaders/flash.frag"}
+ *   {name: "toon",  type: "shader", src: {vertex: "shaders/toon.vert", fragment: "shaders/toon.frag", wgsl: "shaders/toon.wgsl"}}
  */
 /**
  * specify a parser/preload function for the given asset type
@@ -292,21 +300,24 @@ export function getJSON(elt: string): JSON;
  *     // data.uvs — Float32Array of u,v texture coordinates
  *     // data.indices — Uint16Array of triangle vertex indices
  *     // data.vertexCount — number of unique vertices
+ *     // data.groups — usemtl material groups ({materialName, start, count} index ranges)
  * });
  */
 export function getOBJ(elt: string): object;
 /**
  * a parsed glTF/GLB scene descriptor, as returned by {@link loader.getGLTF}
  * @typedef {object} GLTFData
- * @property {object[]} nodes - one entry per mesh primitive (accumulated `world` transform, `vertices`, `normals`, `uvs`, `indices`, `vertexCount`, decoded baseColor `image`, `doubleSided`)
+ * @property {object[]} nodes - one entry per mesh primitive: accumulated `world` transform, `vertices`, `normals`, `uvs`, `indices`, `vertexCount`, decoded baseColor `image` (or `null`), `baseColorFactor`, per-vertex `colors`, sampler-derived `textureRepeat`/`textureFilter`, `alphaCutoff`, `emissive`, `unlit` (KHR_materials_unlit), `doubleSided`, and the source node `name`
  * @property {Array<{world: number[], type?: string, perspective?: {yfov?: number, aspectRatio?: number, znear?: number, zfar?: number}, orthographic?: object}>} cameras - glTF cameras, each with its `world` transform + the glTF camera parameters (`perspective` for perspective cameras, `orthographic` otherwise)
- * @property {object[]} lights - parsed `KHR_lights_punctual` lights (`type`, `color`, `intensity`, `range`, world-space `direction`/`position`, `name`)
+ * @property {object[]} lights - parsed `KHR_lights_punctual` lights (`type`, `color`, `intensity`, `range`, `innerConeAngle`/`outerConeAngle` for spots, world-space `direction`/`position`, `name`)
  * @property {{min: number[], max: number[]}} bounds - world-space scene bounds in glTF units
+ * @property {object[]} graph - the full node graph (every node's TRS/matrix + children), for custom traversal
+ * @property {object[]} animations - parsed node animations (consumed by `GLTFModel` playback)
  */
 /**
  * return the parsed glTF/GLB scene descriptor for the given asset name.
  *
- * The descriptor is `{ nodes, cameras, lights, bounds }`:
+ * The descriptor is `{ nodes, cameras, lights, bounds, graph, animations }`:
  * - `nodes` — one entry per mesh primitive, each carrying its accumulated
  *   `world` transform (16 floats, column-major), `vertices`, `normals`,
  *   `uvs`, `indices`, `vertexCount`, a decoded baseColor `image` (or `null`),
@@ -314,8 +325,10 @@ export function getOBJ(elt: string): object;
  * - `cameras` — glTF cameras, each with its `world` transform + perspective
  *   parameters.
  * - `lights` — parsed `KHR_lights_punctual` lights (`type`, `color`,
- *   `intensity`, world-space `direction`/`position`); empty without the
- *   extension. The level director instantiates directional ones automatically.
+ *   `intensity`, `range`, spot cone angles, world-space
+ *   `direction`/`position`, `name`); empty without the extension. The
+ *   level director instantiates directional, point and spot lights
+ *   automatically (see {@link level.load} options).
  * - `bounds` — world-space `{ min, max }` (glTF units), handy for framing.
  *
  * Most code never needs this: a preloaded glTF/GLB auto-registers with the
@@ -359,18 +372,21 @@ export function getGLTF(elt: string): GLTFData | null;
  * is reset to `false`, so it is auto-destroyed with the renderable it is
  * assigned to, like any hand-constructed effect.
  *
- * A shader asset declared as a **`{vertex, fragment}` program pair** (see
- * the example) compiles into a raw {@link GLShader} instead — the type the
- * advanced paths take directly (a `Mesh` custom shader,
+ * A shader asset declared as a **complete program** — a
+ * `{vertex, fragment}` GLSL pair and/or a full `wgsl` module (see the
+ * example) — compiles into a raw {@link GLShader} instead, carrying one
+ * realization per GPU backend (`isWebGL` / `isWebGPU`): the type the
+ * hosted paths take directly (a `Mesh` custom shader,
  * `renderer.customShader`, a custom batcher). Same shared-instance
  * semantics, and `GLShader.clone()` likewise yields a caller-owned copy.
  *
- * Shader assets are WebGL-only: under the Canvas renderer a fragment-body
- * asset returns an inert `ShaderEffect` stub (same behavior as constructing
- * one directly), and a program-pair asset returns `null` (a raw GL program
- * has no canvas analog). Note that shader assets require `video.init()` to
- * have been called — an inherent precondition of the preload flow, since
- * the loading screen itself needs the renderer.
+ * Degradation is never fatal: a fragment-body asset without a body in the
+ * active renderer's language (or on Canvas) is an inert `ShaderEffect`
+ * stub, and a complete-program asset without a realization for the active
+ * backend is an inert `GLShader` — assigning either just keeps the
+ * built-in rendering. Note that shader assets require an initialized
+ * Application (`await app.init()`) — an inherent precondition of the
+ * preload flow, since the loading screen itself needs the renderer.
  * @memberof loader
  * @param {string} elt - name of the shader asset (as specified in the preload list)
  * @returns {ShaderEffect|GLShader|null} the shared, precompiled shader, or `null` if not found
@@ -384,18 +400,21 @@ export function getGLTF(elt: string): GLTFData | null;
  *         uniform float uIntensity;
  *         vec4 apply(vec4 color, vec2 uv) { return mix(color, vec4(1.0), uIntensity); }
  *     ` },
- *     // or a complete {vertex, fragment} program pair → a raw GLShader
+ *     // or a complete program — a {vertex, fragment} GLSL pair and/or a
+ *     // full WGSL module → one GLShader carrying both realizations; the
+ *     // active renderer hosts the one it speaks
  *     { name: "toonMesh", type: "shader", src: {
  *         vertex: "shaders/toon.vert",
  *         fragment: "shaders/toon.frag",
+ *         wgsl: "shaders/toon.wgsl",
  *     } },
  * ], () => {
  *     // one shared program — same uniform state for every user
  *     mySprite.shader = me.loader.getShader("waterRipple");
  *     // private copy with its own uniforms (caller-owned, shared = false)
  *     boss.shader = me.loader.getShader("flash").clone();
- *     // a program pair comes back as a GLShader, e.g. for a custom Mesh shader
- *     renderer.drawMesh(myMesh, { shader: me.loader.getShader("toonMesh") });
+ *     // a complete program hosts on a mesh, replacing the built-in shading
+ *     myMesh.shader = me.loader.getShader("toonMesh");
  * });
  */
 export function getShader(elt: string): ShaderEffect | GLShader | null;
@@ -425,6 +444,7 @@ export function getShader(elt: string): ShaderEffect | GLShader | null;
  *     const materials = me.loader.getMTL("fox");
  *     // materials["colormap"].Kd — [r, g, b] diffuse color (0-1 range)
  *     // materials["colormap"].d — opacity (0-1)
+ *     // materials["colormap"].Ke — [r, g, b] emissive color (glow, applied as Mesh.emissive)
  *     // materials["colormap"].map_Kd — resolved texture URL
  * });
  */
@@ -538,7 +558,7 @@ export type Asset = object;
  */
 export type GLTFData = {
     /**
-     * - one entry per mesh primitive (accumulated `world` transform, `vertices`, `normals`, `uvs`, `indices`, `vertexCount`, decoded baseColor `image`, `doubleSided`)
+     * - one entry per mesh primitive: accumulated `world` transform, `vertices`, `normals`, `uvs`, `indices`, `vertexCount`, decoded baseColor `image` (or `null`), `baseColorFactor`, per-vertex `colors`, sampler-derived `textureRepeat`/`textureFilter`, `alphaCutoff`, `emissive`, `unlit` (KHR_materials_unlit), `doubleSided`, and the source node `name`
      */
     nodes: object[];
     /**
@@ -556,7 +576,7 @@ export type GLTFData = {
         orthographic?: object;
     }>;
     /**
-     * - parsed `KHR_lights_punctual` lights (`type`, `color`, `intensity`, `range`, world-space `direction`/`position`, `name`)
+     * - parsed `KHR_lights_punctual` lights (`type`, `color`, `intensity`, `range`, `innerConeAngle`/`outerConeAngle` for spots, world-space `direction`/`position`, `name`)
      */
     lights: object[];
     /**
@@ -566,5 +586,13 @@ export type GLTFData = {
         min: number[];
         max: number[];
     };
+    /**
+     * - the full node graph (every node's TRS/matrix + children), for custom traversal
+     */
+    graph: object[];
+    /**
+     * - parsed node animations (consumed by `GLTFModel` playback)
+     */
+    animations: object[];
 };
 //# sourceMappingURL=loader.d.ts.map

package/build/loader/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/loader/loader.js"],"names":[],"mappings":"AAuFA;;;GAGG;AACH,mDAEC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,oCAdG;IAAyB,WAAW;IACV,OAAO;IACP,eAAe;CACzC,QAqBF;AAED;;;;;;;;;;;;;;GAcG;AACH,iCATW,MAAM,QACN,MAAM,QAyBhB;AAqID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,gCAnBW,MAAM,4BA6BhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,gCAhDW,KAAK,EAAE,2CAEP,OAAO,GACL,OAAO,CAAC,IAAI,CAAC,CAoFzB;AAED;;;;;;;;;;;;;;;IAeI;AACJ,4BAbW,MAAM,QAqChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,4BAhCW,KAAK,0CAGH,MAAM,GAAC,OAAO,CAAC,IAAI,CAAC,CAqGhC;AAED;;;;;;;GAOG;AACH,8BALW,KAAK,GACH,OAAO,CA6HnB;AAED;;;;;GAKG;AACH,kCAyGC;AAED;;;;;;GAMG;AACH,4BAJW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;GAMG;AACH,+BAJW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;GAMG;AACH,gCAJW,MAAM,GACJ,gBAAgB,GAAC,eAAe,GAAC,IAAI,CAWjD;AAED;;;;;;GAMG;AACH,6BAJW,MAAM,GACJ,IAAI,CAUhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4BA1BW,MAAM,GACJ,MAAM,CAgClB;AAED;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,6BAhBW,MAAM,GACJ,QAAQ,GAAC,IAAI,CAqBzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,+BA1BW,MAAM,GACJ,YAAY,GAAC,QAAQ,GAAC,IAAI,CA+BtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,4BA1BW,MAAM,GACJ,MAAM,CA+BlB;AAED;;;;;;GAMG;AACH,8BAJW,MAAM,GACJ,gBAAgB,CAU5B;AAED;;;;;;GAMG;AACH,6BAJW,MAAM,GACJ,QAAQ,CAUpB;AAzlCD;;;GAGG;AAGH,2BAAwB;AAExB;;GAEG;AACH;;EAA0B;AAE1B;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAbU,MAAM,CAaO;AAEvB;;;;;;;;;;;;;;;;GAgBG;AACH,4BAbU,OAAO,CAakB;AA0EnC;;;;;;;;;GASG;AACH,4BAAkB;AAElB;;;;;;;;;;;GAWG;AACH,gCAAsB;AAEtB;;;;;;;;;;GAUG;AACH,6BAAmB;;;;oBAgGN,MAAM;;;;;;;;WAiqBL,MAAM,EAAE;;;;aACR,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE;YAAC,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,WAAW,CAAC,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAC,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;;;;YAClJ,MAAM,EAAE;;;;YACR;QAAC,GAAG,EAAE,MAAM,EAAE,CAAC;QAAC,GAAG,EAAE,MAAM,EAAE,CAAA;KAAC"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/loader/loader.js"],"names":[],"mappings":"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"}

package/build/loader/parsers/gltf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/gltf.js"],"names":[],"mappings":"AAyCA;;;;;GAKG;AACH,sCAJW,WAAW,GACT;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAAA;CAAE,CAkCpD;AAmED;;;;GAIG;AACH,+EAgCC;AAqCD;;;;;;;;;;GAUG;AACH,oCAPW,MAAM,EAAE,eACR,MAAM,EAAE,YACR,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,EAAE,CAoCpB;AAED;;;;;;;GAOG;AACH,wCANW,MAAM,EAAE,YACR,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,EAAE,CAKpB;AAED,6EAA6E;AAC7E,gDASC;AAiED;;;;;GAKG;AACH,kEAWC;AAED,oFAAoF;AACpF,oDAEC;AAuED;;;;;;;;;;GAUG;AACH,uCATW,WAAW,YACX,MAAM,aAGN,MAAM,GAEJ,OAAO,CAAC,MAAM,CAAC,CA+X3B;AAED;;;;;;;;GAQG;AACH,kCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CA6BlB"}
+{"version":3,"file":"gltf.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/gltf.js"],"names":[],"mappings":"AA0CA;;;;;GAKG;AACH,sCAJW,WAAW,GACT;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAAA;CAAE,CAkCpD;AAmED;;;;GAIG;AACH,+EAgCC;AA0KD;;;;;;;;;;GAUG;AACH,oCAPW,MAAM,EAAE,eACR,MAAM,EAAE,YACR,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,EAAE,CAoCpB;AAED;;;;;;;GAOG;AACH,wCANW,MAAM,EAAE,YACR,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,EAAE,CAKpB;AAED,6EAA6E;AAC7E,gDASC;AAiED;;;;;GAKG;AACH,kEAWC;AAED,oFAAoF;AACpF,oDAEC;AA8HD;;;;;;;;;;GAUG;AACH,uCATW,WAAW,YACX,MAAM,aAGN,MAAM,GAEJ,OAAO,CAAC,MAAM,CAAC,CAqa3B;AAED;;;;;;;;GAQG;AACH,kCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CA6BlB"}

package/build/loader/parsers/mtl.d.ts

@@ -1,3 +1,21 @@
+/**
+ * Parse a Wavefront MTL file into material data.
+ * Supports: `newmtl`, `Kd` (diffuse color), `Ke` (emissive color), `Ks`/`Ns`
+ * (specular color and exponent), `Pr`/`Pm` (the PBR roughness/metalness
+ * extension, approximated onto the specular terms when `Ks`/`Ns` are absent),
+ * `map_Kd` (diffuse texture), `map_d` (alpha map), `d`/`Tr`
+ * (opacity/transparency).
+ *
+ * Limitations:
+ * - Ambient (`Ka`), optical density (`Ni`) and illumination model (`illum`) are parsed but ignored
+ * - Normal maps (`map_bump`, `bump`), specular maps (`map_Ks`), and other texture maps are not supported
+ *
+ * @param {string} text - raw MTL file contents
+ * @param {string} basePath - base URL path for resolving texture references
+ * @returns {object} map of material names to their properties
+ * @ignore
+ */
+export function parseMTL(text: string, basePath: string): object;
 /**
  * Parse/preload a Wavefront MTL material file.
  * @param {loader.Asset} data - asset data

package/build/loader/parsers/mtl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mtl.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/mtl.js"],"names":[],"mappings":"AAgJA;;;;;;;;GAQG;AACH,iCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAuElB"}
+{"version":3,"file":"mtl.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/mtl.js"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;;GAgBG;AACH,+BALW,MAAM,YACN,MAAM,GACJ,MAAM,CAkJlB;AAED;;;;;;;;GAQG;AACH,iCAPW,MAAM,CAAC,KAAK,oDAGZ,MAAM,GACJ,MAAM,CAwElB"}