melonjs 19.9.1 → 20.0.0

package/build/physics/builtin/sat3d.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Check whether two axis-aligned 3D boxes collide.
+ *
+ * This is the only narrowphase in the engine that can produce a **Z**
+ * pushback. The separating-axis set of two AABBs is just the three world axes,
+ * so there is no projection loop: penetration on each axis is
+ * `(halfA + halfB) - |centerDelta|`, a non-positive value on any axis means
+ * separated, and the minimum translation vector is the axis with the smallest
+ * positive penetration.
+ *
+ * The MTV is a single axis, so exactly one of `overlapN.x`, `overlapN.y` and
+ * `overlapNZ` comes back non-zero — see {@link ResponseObject#overlapNZ}. When
+ * that axis is Z the 2D fields stay at zero, which is what makes a legacy 2D
+ * `onCollision` handler safely inert on a depth-only contact rather than
+ * wrong.
+ * @ignore
+ * @param {Renderable} a - a reference to the object A.
+ * @param {Box3d} boxA - a reference to the object A Box3d to be tested
+ * @param {Renderable} b - a reference to the object B.
+ * @param {Box3d} boxB - a reference to the object B Box3d to be tested
+ * @param {object} [response] - Response object that will be populated if they intersect.
+ * @returns {boolean} true if they intersect, false if they don't.
+ */
+export function testBox3dBox3d(a: Renderable, boxA: Box3d, b: Renderable, boxB: Box3d, response?: object): boolean;
+/**
+ * Check whether a {@link Box3d} collides with a planar shape.
+ *
+ * The planar shape is treated as **unbounded along Z** — an infinitely
+ * extruded prism of its own outline — so the pair reduces to the ordinary 2D
+ * test between the box's XY footprint and that outline, and the box's z can
+ * never make it miss. See {@link Box3d} for why that is the compatible
+ * reading: it is what keeps an existing 2D game's world shapes colliding
+ * unchanged the moment one `Box3d` body is introduced.
+ *
+ * `overlapZ` is left at `0` by construction, since neither participant has a
+ * finite depth to resolve against.
+ * @ignore
+ */
+export function testBox3dPolygon(a: any, boxA: any, b: any, polyB: any, response: any): boolean;
+/**
+ * Planar-shape-first form of {@link testBox3dPolygon}.
+ * @ignore
+ */
+export function testPolygonBox3d(a: any, polyA: any, b: any, boxB: any, response: any): boolean;
+/**
+ * {@link Box3d} against an {@link Ellipse}, with the ellipse unbounded along
+ * Z. See {@link testBox3dPolygon}.
+ * @ignore
+ */
+export function testBox3dEllipse(a: any, boxA: any, b: any, ellipseB: any, response: any): boolean;
+/**
+ * {@link Ellipse} against a {@link Box3d}, with the ellipse unbounded along
+ * Z. See {@link testBox3dPolygon}.
+ * @ignore
+ */
+export function testEllipseBox3d(a: any, ellipseA: any, b: any, boxB: any, response: any): boolean;
+import type Renderable from "../../renderable/renderable.js";
+import type { Box3d } from "../../geometries/box3d.ts";
+//# sourceMappingURL=sat3d.d.ts.map

package/build/physics/builtin/sat3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sat3d.d.ts","sourceRoot":"","sources":["../../../src/physics/builtin/sat3d.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,kCAPW,UAAU,QACV,KAAK,KACL,UAAU,QACV,KAAK,aACL,MAAM,GACJ,OAAO,CA6EnB;AAED;;;;;;;;;;;;;GAaG;AACH,gGAEC;AAED;;;GAGG;AACH,gGAEC;AAED;;;;GAIG;AACH,mGAEC;AAED;;;;GAIG;AACH,mGAEC;4BAtK0B,gCAAgC;2BAHnC,2BAA2B"}

package/build/physics/response.d.ts

@@ -23,6 +23,14 @@ export type ResponseObject = {
      * The shortest colliding axis (unit-vector)
      */
     overlapN: Vector2d;
+    /**
+     * The Z component of the shortest colliding axis, as a unit scalar (`-1`, `0` or `1`). Always `0` for a collision between planar shapes
+     */
+    overlapNZ: number;
+    /**
+     * The Z component of the overlap vector (i.e. `overlapNZ * overlap`). Always `0` for a collision between planar shapes
+     */
+    overlapZ: number;
     /**
      * Whether the first object is entirely inside the second
      */
@@ -48,6 +56,8 @@ export type ResponseObject = {
  * @property {number} overlap Magnitude of the overlap on the shortest colliding axis
  * @property {Vector2d} overlapV The overlap vector (i.e. `overlapN.scale(overlap, overlap)`). If this vector is subtracted from the position of a, a and b will no longer be colliding
  * @property {Vector2d} overlapN The shortest colliding axis (unit-vector)
+ * @property {number} overlapNZ The Z component of the shortest colliding axis, as a unit scalar (`-1`, `0` or `1`). Always `0` for a collision between planar shapes
+ * @property {number} overlapZ The Z component of the overlap vector (i.e. `overlapNZ * overlap`). Always `0` for a collision between planar shapes
  * @property {boolean} aInB Whether the first object is entirely inside the second
  * @property {boolean} bInA Whether the second object is entirely inside the first
  * @property {number} indexShapeA The index of the colliding shape for the object a body
@@ -58,10 +68,32 @@ declare class ResponseObject {
     b: any;
     overlapN: Vector2d;
     overlapV: Vector2d;
+    /**
+     * Z half of the minimum translation axis.
+     *
+     * Z arrives as **scalars beside** `overlapN` / `overlapV` rather than
+     * by widening them to {@link Vector3d}, because `Vector3d` is not a
+     * subclass of {@link Vector2d} — retyping them would break every
+     * existing consumer of a 2D collision response.
+     *
+     * The minimum translation axis is a single axis, so at most one of
+     * `overlapN.x`, `overlapN.y` and `overlapNZ` is ever non-zero. The 2D
+     * invariant `overlapV = overlapN * overlap` therefore extends
+     * unchanged as `overlapZ = overlapNZ * overlap`, and a collision
+     * resolved along Z leaves `overlapN` / `overlapV` at zero — a legacy
+     * 2D handler reading them applies no push, which is correct, because
+     * there is no 2D push to apply.
+     *
+     * Only ever non-zero when both shapes are a {@link Box3d}; every
+     * planar shape pair leaves these at `0`.
+     */
+    overlapNZ: number;
+    overlapZ: number;
     aInB: boolean;
     bInA: boolean;
     indexShapeA: number;
     indexShapeB: number;
+    isTriggerContact: boolean;
     overlap: number;
     /**
      * Set some values of the response back to their defaults. <br>

package/build/physics/response.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../src/physics/response.js"],"names":[],"mappings":";;;;;;;;OAKc,UAAU;;;;OACV,UAAU;;;;aACV,MAAM;;;;cACN,QAAQ;;;;cACR,QAAQ;;;;UACR,OAAO;;;;UACP,OAAO;;;;iBACP,MAAM;;;;iBACN,MAAM;;AAXpB;;;;;;;;;;;;GAYG;AACH;IAEE,OAAa;IACb,OAAa;IACb,mBAA8B;IAC9B,mBAA8B;IAC9B,cAAgB;IAChB,cAAgB;IAChB,oBAAqB;IACrB,oBAAqB;IACrB,gBAA+B;IAGhC;;;;;;;;OAQG;IACH,gBAFa,MAAM,CASlB;CACD;yBA7CwB,qBAAqB"}
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../src/physics/response.js"],"names":[],"mappings":";;;;;;;;OAKc,UAAU;;;;OACV,UAAU;;;;aACV,MAAM;;;;cACN,QAAQ;;;;cACR,QAAQ;;;;eACR,MAAM;;;;cACN,MAAM;;;;UACN,OAAO;;;;UACP,OAAO;;;;iBACP,MAAM;;;;iBACN,MAAM;;AAbpB;;;;;;;;;;;;;;GAcG;AACH;IAEE,OAAa;IACb,OAAa;IACb,mBAA8B;IAC9B,mBAA8B;IAC9B;;;;;;;;;;;;;;;;;;OAkBG;IACH,kBAAkB;IAClB,iBAAiB;IACjB,cAAgB;IAChB,cAAgB;IAChB,oBAAqB;IACrB,oBAAqB;IACrB,0BAA6B;IAC7B,gBAA+B;IAGhC;;;;;;;;OAQG;IACH,gBAFa,MAAM,CAelB;CACD;yBA3EwB,qBAAqB"}

package/build/physics/world.d.ts

@@ -100,6 +100,7 @@ export default class World extends Container {
      * @type {import("./broadphase/broadphase.ts").Broadphase}
      */
     broadphase: import("./broadphase/broadphase.ts").Broadphase;
+    onLevelLoaded: () => void;
     /**
      * Active physics bodies in this simulation. Backed by the active
      * adapter; mutating this set directly is no longer the recommended

package/build/physics/world.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/physics/world.js"],"names":[],"mappings":"AA6BA;;;GAGG;AACH;IACC;;;;;;OAMG;IACH,gBANW,MAAM,MACN,MAAM,UACN,MAAM,WACN,MAAM,YACN,cAAc,EAkIxB;IAhHA;;;OAGG;IACH,KAFU,WAAW,CAED;IAEpB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QANU,MAAM,CAMO;IAEvB;;;;;OAKG;IACH,YAAa;IAEb;;;;;;;OAOG;IACH,WAHU,OAAO,CAGK;IAEtB;;;;;;;;;;;;;;OAcG;IACH,YAHU,OAAO,CAGK;IAEtB;;;;;;OAMG;IACH,SAFU,cAAc,CAEsB;IAG9C;;;;;;;;;;;;;;;OAeG;IACH,YAFU,OAAO,4BAA4B,EAAE,UAAU,CAEjB;IA2CzC;;;;;;;;;;;OAWG;IACH,cAFa,GAAG,CAAC,IAAI,CAAC,CAOrB;IASD,eALa,QAAQ,EAOpB;IATD;;;OAGG;IACH,eAFa,QAAQ,CAIpB;IAKD;;;;OAIG;IACH,gBAFa,QAAQ,GAAG,SAAS,CAIhC;IAsCD;;;;;;;OAOG;IACH,cAHW,IAAI,GACF,KAAK,CASjB;IAED;;;;;OAKG;IACH,iBAHW,IAAI,GACF,KAAK,CASjB;IAED;;;;;OAKG;IACH,yBAIC;IAuBD;;;OAGG;IACH,SAFW,MAAM,QAWhB;CACD;sBA5VqB,4BAA4B;6BAYtB,iCAAiC;oCAI1B,cAAc;sBAH5B,mBAAmB;8BAEX,qBAAqB;0BADzB,uBAAuB"}
+{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/physics/world.js"],"names":[],"mappings":"AA8BA;;;GAGG;AACH;IACC;;;;;;OAMG;IACH,gBANW,MAAM,MACN,MAAM,UACN,MAAM,WACN,MAAM,YACN,cAAc,EAuIxB;IArHA;;;OAGG;IACH,KAFU,WAAW,CAED;IAEpB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QANU,MAAM,CAMO;IAEvB;;;;;OAKG;IACH,YAAa;IAEb;;;;;;;OAOG;IACH,WAHU,OAAO,CAGK;IAEtB;;;;;;;;;;;;;;OAcG;IACH,YAHU,OAAO,CAGK;IAEtB;;;;;;OAMG;IACH,SAFU,cAAc,CAEsB;IAG9C;;;;;;;;;;;;;;;OAeG;IACH,YAFU,OAAO,4BAA4B,EAAE,UAAU,CAEjB;IAcxC,0BAMC;IA2CF;;;;;;;;;;;OAWG;IACH,cAFa,GAAG,CAAC,IAAI,CAAC,CAOrB;IASD,eALa,QAAQ,EAOpB;IATD;;;OAGG;IACH,eAFa,QAAQ,CAIpB;IAKD;;;;OAIG;IACH,gBAFa,QAAQ,GAAG,SAAS,CAIhC;IAsCD;;;;;;;OAOG;IACH,cAHW,IAAI,GACF,KAAK,CASjB;IAED;;;;;OAKG;IACH,iBAHW,IAAI,GACF,KAAK,CASjB;IAED;;;;;OAKG;IACH,yBAIC;IAuBD;;;OAGG;IACH,SAFW,MAAM,QAWhB;CACD;sBAjXqB,4BAA4B;6BAatB,iCAAiC;oCAI1B,cAAc;sBAH5B,mBAAmB;8BAEX,qBAAqB;0BADzB,uBAAuB"}

package/build/renderable/container.d.ts

@@ -104,6 +104,7 @@ export default class Container extends Renderable {
      * this.backgroundColor.setColor(255, 0, 0);
      */
     backgroundColor: Color;
+    onCanvasResize: (() => void) | undefined;
     set sortOn(value: "x" | "y" | "z" | "depth");
     /**
      * The property of the child object that should be used to sort on

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

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

package/build/renderable/groundshadow.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Bake (once) a radial alpha ramp: opaque white at the centre, fading to
+ * fully transparent at the rim.
+ *
+ * White rather than black because the colour comes from the draw tint — that
+ * way the same bake serves a black shadow, a tinted one, or a coloured pool
+ * of light, and nothing has to be re-baked to change it.
+ * @returns {HTMLCanvasElement|OffscreenCanvas} the shared falloff canvas
+ * @ignore
+ */
+export function getShadowFalloff(): HTMLCanvasElement | OffscreenCanvas;
+/**
+ * Drop the shared bake. Only the tests need this — the canvas is CPU-side and
+ * costs 64 KB, so an application never has a reason to release it.
+ * @ignore
+ */
+export function resetShadowFalloff(): void;
+/**
+ * Whether a mesh's geometry has any vertical extent at all.
+ *
+ * The test a **blanket** opt-in needs: a ground shadow says "this object is
+ * standing above the floor", and a flat plane lying in the floor is the floor.
+ * Shadowing it with itself smears a blob the size of the whole ground across
+ * it, which is what a scene-wide `castGroundShadow` would otherwise do to
+ * every glTF scene that ships one. A per-object opt-in bypasses this — that
+ * one is an explicit instruction.
+ *
+ * Deliberately model-space and unrotated: the caller asks about the geometry,
+ * not about where it currently sits.
+ * @param {Float32Array} vertices - model-space vertex positions (x, y, z)
+ * @param {number} vertexCount - how many vertices to read
+ * @returns {boolean} true when the geometry is not flat in Y
+ * @ignore
+ */
+export function hasVerticalExtent(vertices: Float32Array, vertexCount: number): boolean;
+/**
+ * Borrow the shadow quad for a renderer, building it on first use.
+ *
+ * Cached **on the renderer**, not at module level, for two reasons: a `Mesh`
+ * resolves its texture through the active renderer's texture cache, so a
+ * module-level one would bind itself to whichever application happened to
+ * construct it first; and hanging it off the renderer means it dies with the
+ * renderer instead of outliving it.
+ *
+ * Two are kept — lit and unlit — so the shadow can be drawn through whichever
+ * mesh batcher its owner is already using. Sharing one unlit quad between lit
+ * owners would force a `litMesh → mesh → litMesh` batcher transition per
+ * shadowed object, each costing a bind/unbind pair and a flush: far more than
+ * the single draw the shadow is supposed to be.
+ *
+ * Retained geometry is keyed per mesh object, so one quad uploads once and
+ * every shadow in the scene redraws it at a different matrix for free.
+ * @param {object} renderer - the active renderer
+ * @param {boolean} lit - whether the owning mesh draws lit
+ * @param {Function} MeshClass - the `Mesh` constructor (passed in to avoid a
+ * circular import: `Mesh` owns the shadow, not the other way round)
+ * @returns {object} the shared shadow quad for that tier
+ * @ignore
+ */
+export function getShadowQuad(renderer: object, lit: boolean, MeshClass: Function): object;
+/**
+ * The blob quad an `InstancedMesh` draws from — sized to the prototype's own
+ * footprint (#1515).
+ *
+ * The shared quad is a unit square, and the instanced vertex stage scales it by
+ * each record's horizontal scale alone. That silently assumes the prototype
+ * geometry is exactly 1 unit across, which is true of almost nothing: glTF
+ * meshes load with `normalize: false` and keep their authored size, so a tree
+ * 3 units wide got a blob sized for a 1-unit tree. It also skipped the contact
+ * spread and the minor-axis floor the per-object tier applies, so the SAME
+ * asset drew a different shadow depending on whether it was instanced.
+ *
+ * Baking the extents into four vertices fixes it with no shader change and no
+ * per-draw uniform: retained geometry is keyed per mesh object, so this uploads
+ * once per `InstancedMesh` and is redrawn for free.
+ * @param {object} mesh - the InstancedMesh casting the shadows
+ * @param {Function} MeshClass - the `Mesh` constructor (avoids a circular import)
+ * @param {number} halfX - model-space half-extent along X, spread applied
+ * @param {number} halfZ - model-space half-extent along Z, spread applied
+ * @param {number} version - the prototype's geometry version
+ * @returns {object} the quad to draw this scatter's blobs from
+ * @ignore
+ */
+export function getInstancedShadowQuad(mesh: object, MeshClass: Function, halfX: number, halfZ: number, version: number): object;
+/**
+ * Release the shadow quads a renderer built, if any. Called from renderer
+ * teardown so the retained GPU geometry goes with it.
+ * @param {object} renderer - the renderer being torn down
+ * @ignore
+ */
+export function releaseShadowQuads(renderer: object): void;
+//# sourceMappingURL=groundshadow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"groundshadow.d.ts","sourceRoot":"","sources":["../../src/renderable/groundshadow.js"],"names":[],"mappings":"AAyCA;;;;;;;;;GASG;AACH,oCAHa,iBAAiB,GAAC,eAAe,CAsC7C;AAED;;;;GAIG;AACH,2CAEC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,4CALW,YAAY,eACZ,MAAM,GACJ,OAAO,CA8BnB;AAiBD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wCAPW,MAAM,OACN,OAAO,wBAGL,MAAM,CAiClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6CARW,MAAM,8BAEN,MAAM,SACN,MAAM,WACN,MAAM,GACJ,MAAM,CAsClB;AAED;;;;;GAKG;AACH,6CAHW,MAAM,QAUhB"}

package/build/renderable/instanced_mesh.d.ts

@@ -0,0 +1,286 @@
+/**
+ * A {@link Mesh} drawn many times from one copy of its geometry.
+ *
+ * Ordinary meshes pay for every repeat: a forest of five thousand trees is
+ * five thousand geometries on the GPU, each re-uploaded when it changes. An
+ * `InstancedMesh` uploads the geometry **once** and stamps out copies from a
+ * small per-instance record, so cost scales with the number of instances
+ * rather than with `instances × vertices`, and the whole thing draws in a
+ * single call.
+ *
+ * Every `Mesh` setting works unchanged — `model` + `material` from an OBJ,
+ * raw `vertices`/`uvs`/`indices`, `lit`, `cullBackFaces`, `rightHanded`,
+ * `tint`, `textureRepeat`, the lot. What an instanced mesh adds is the
+ * instance buffer:
+ *
+ * - a **transform** per instance, always present;
+ * - a **colour** per instance, when `instanceColors` is declared, multiplied
+ *   into the mesh tint;
+ * - an opaque **`vec4`** per instance, when `instanceData` is declared. The
+ *   built-in lit shading reads its `rgb` as emissive; a custom
+ *   {@link Mesh#shader} may read it as a wind phase, an atlas offset, a
+ *   random seed — whatever the shader wants.
+ *
+ * The mesh's own position, rotation and scale keep their ordinary meaning and
+ * act as the **group** transform: moving an `InstancedMesh` moves every
+ * instance with one uniform write and re-uploads nothing.
+ *
+ * Requires a GPU backend (`renderer.supportsInstancing`). Under the Canvas
+ * renderer the instances are drawn one at a time through the ordinary CPU
+ * mesh path — correct, but without any of the benefit.
+ * @augments Mesh
+ * @category Rendering
+ * @example
+ * const forest = new me.InstancedMesh(0, 0, {
+ *     model: "tree",
+ *     material: "tree",
+ *     width: 64,
+ *     lit: true,
+ *     instanceCount: 5000,     // pre-allocate
+ *     instanceColors: true,
+ *     instanceData: true,
+ * });
+ *
+ * const placement = new me.Matrix3d();   // one scratch — zero allocation
+ * for (let i = 0; i < forest.instanceCount; i++) {
+ *     placement.identity().translate(x, y, z).scale(s);
+ *     forest.setInstance(i, placement);
+ *     forest.setInstanceColor(i, autumnTint);
+ *     forest.setInstanceData(i, windPhase, seed, 0, 0);
+ * }
+ *
+ * // draw only the nearest 1200 — no re-upload, just a smaller draw
+ * forest.visibleInstanceCount = 1200;
+ * app.world.addChild(forest, 10);
+ */
+export default class InstancedMesh extends Mesh {
+    /**
+     * @param {number} x - the x coordinate of the group origin
+     * @param {number} y - the y coordinate of the group origin
+     * @param {object} settings - every {@link Mesh} setting, plus those below
+     * @param {number} [settings.instanceCount=0] - number of instances to pre-allocate. Instances start at the group origin (identity transform) until placed; `addInstance` grows past this.
+     * @param {boolean} [settings.instanceColors=false] - give each instance its own colour (16 bytes per instance), multiplied into the mesh tint
+     * @param {boolean} [settings.instanceData=false] - give each instance an opaque `vec4` (16 bytes per instance). Read as emissive by the built-in lit shading, or as anything at all by a custom mesh shader.
+     */
+    constructor(x: number, y: number, settings: {
+        instanceCount?: number | undefined;
+        instanceColors?: boolean | undefined;
+        instanceData?: boolean | undefined;
+    });
+    /**
+     * How this mesh's per-instance records are laid out — record width and
+     * the offset of each opt-in slot. Consumed by the batchers to describe
+     * the instance vertex buffer.
+     * @type {object}
+     * @ignore
+     */
+    instanceLayout: object;
+    /**
+     * The packed instance records, `instanceLayout.floats` per instance.
+     * Editable in place for bulk updates — announce those with
+     * {@link InstancedMesh#needsInstanceUpdate} or
+     * {@link InstancedMesh#markInstancesDirty}, since writing here bypasses
+     * the setters that track the dirty range.
+     * @type {Float32Array}
+     */
+    instanceBuffer: Float32Array;
+    /**
+     * bumped whenever the buffer is reallocated, so a renderer holding a
+     * GPU copy knows its capacity assumption is stale
+     * @type {number}
+     * @ignore
+     */
+    _instanceVersion: number;
+    /** @ignore */
+    _instanceRevision: number;
+    /** @ignore */
+    _spanFromRevision: number;
+    /** @ignore */
+    _dirtyFirst: number;
+    /** @ignore */
+    _dirtyLast: number;
+    /** @ignore */
+    _instanceCount: number;
+    /** @ignore */
+    _visibleInstanceCount: number;
+    /** @ignore */
+    _cullRevision: number;
+    set instanceCount(count: number);
+    /**
+     * How many instances this mesh holds.
+     *
+     * Growing pre-allocates the new records as identity transforms (an
+     * unplaced instance sits at the group origin rather than collapsing onto
+     * a zero matrix); shrinking keeps the allocation, so a count that
+     * oscillates does not thrash it.
+     * @type {number}
+     */
+    get instanceCount(): number;
+    set visibleInstanceCount(count: number);
+    /**
+     * How many instances are actually drawn, counted from the first.
+     *
+     * The cheap culling and level-of-detail knob: sort the instances by
+     * distance once, then draw fewer of them by moving this single number —
+     * no re-upload, no rebuild. Defaults to every instance (`-1`).
+     * @type {number}
+     * @example
+     * forest.visibleInstanceCount = playerIsIndoors ? 0 : 1200;
+     */
+    get visibleInstanceCount(): number;
+    /**
+     * Append an instance, growing the buffer as needed.
+     * @param {Matrix3d} [transform] - where this instance sits, relative to the group. Defaults to the group origin.
+     * @param {object} [options] - optional per-instance slots
+     * @param {Color} [options.color] - instance colour (requires `instanceColors`)
+     * @param {number[]} [options.data] - four numbers for the custom slot (requires `instanceData`)
+     * @returns {number} the new instance's index
+     */
+    addInstance(transform?: Matrix3d, options?: {
+        color?: any;
+        data?: number[] | undefined;
+    }): number;
+    /**
+     * Remove an instance by moving the last one into its place.
+     *
+     * Swapping is what keeps this O(1) instead of shifting every record after
+     * the hole — but it means **indices are not stable across a removal**: the
+     * instance that was last now answers to `index`. Callers holding indices
+     * must re-read them, or avoid removal in favour of
+     * {@link InstancedMesh#visibleInstanceCount}.
+     * @param {number} index - the instance to remove
+     */
+    removeInstance(index: number): void;
+    /**
+     * Place one instance.
+     * @param {number} index - the instance to place
+     * @param {Matrix3d} transform - where it sits, relative to the group
+     */
+    setInstance(index: number, transform: Matrix3d): void;
+    /**
+     * Read one instance's transform back.
+     * @param {number} index - the instance to read
+     * @param {Matrix3d} [out] - matrix to write into; a new one is allocated when omitted
+     * @returns {Matrix3d|undefined} the transform, or `undefined` for an out-of-range index
+     */
+    getInstance(index: number, out?: Matrix3d): Matrix3d | undefined;
+    /**
+     * Set one instance's colour, multiplied into the mesh tint.
+     * @param {number} index - the instance to colour
+     * @param {Color} color - the instance colour
+     */
+    setInstanceColor(index: number, color: Color): void;
+    /**
+     * Set one instance's custom `vec4`.
+     * @param {number} index - the instance to write
+     * @param {number} x - first component (emissive red, under the built-in lit shading)
+     * @param {number} y - second component
+     * @param {number} z - third component
+     * @param {number} [w=0] - fourth component
+     */
+    setInstanceData(index: number, x: number, y: number, z: number, w?: number): void;
+    /**
+     * Announce that a span of instances was edited directly through
+     * {@link InstancedMesh#instanceBuffer}, so the next draw re-uploads it.
+     * The per-instance setters do this themselves.
+     * @param {number} first - first instance changed
+     * @param {number} count - how many
+     */
+    markInstancesDirty(first: number, count: number): void;
+    /**
+     * Announce that the whole instance buffer was edited in place. The
+     * instancing counterpart of {@link Mesh#needsUpdate} — and, like it, a
+     * signal rather than a state, so it is write-only.
+     * @type {boolean}
+     * @example
+     * forest.instanceBuffer.set(myRecords);
+     * forest.needsInstanceUpdate = true;
+     */
+    set needsInstanceUpdate(value: any);
+    /**
+     * The dirty span, in floats, as `[first, lastExclusive)`. Empty when
+     * nothing changed since the last upload.
+     * @returns {number[]} the span
+     * @ignore
+     */
+    dirtyRange(): number[];
+    /**
+     * What one GPU buffer must upload to catch up, given the revision it last
+     * reached. Replaces a shared "clear the dirty flag" step, which the first
+     * consumer would drain out from under the second.
+     * @param {number} uploadedRevision - the revision that buffer holds
+     * @returns {object} `{first, count, full, revision}` — float span, or `full`
+     * @ignore
+     */
+    instanceUpload(uploadedRevision: number): object;
+    /**
+     * Called by the batcher once the dirty span has been uploaded.
+     * @ignore
+     */
+    clearInstanceDirty(): void;
+    /**
+     * The world-space bounding box of every instance, so the whole group
+     * frustum-culls as one object.
+     *
+     * Bounds the prototype geometry through each instance transform and then
+     * through the group placement — correct before the first draw, like the
+     * base implementation, and independent of what any draw left behind.
+     * @returns {AABB3d} the union of all instance bounds (reused instance)
+     */
+    /**
+     * Resize the renderable's own 2D bounds box so it encloses every
+     * instance.
+     *
+     * This is what makes the group frustum-cull correctly. `Camera3d.isVisible`
+     * tests a sphere derived from `getBounds()` — the flat width/height box —
+     * **not** {@link InstancedMesh#getBounds3d}. Left at the prototype's size,
+     * a forest scattered over thousands of units presents a box a few tens of
+     * pixels across at the group origin: pan the camera just past that origin
+     * and every instance disappears at once, while still on screen.
+     * @ignore
+     */
+    _refreshCullVolume(): any;
+    _cullRadius: number | undefined;
+    /**
+     * Draw the instanced mesh. Under a GPU backend this is one instanced
+     * draw call; the Canvas renderer has no instancing, so each instance is
+     * drawn through the ordinary mesh path instead.
+     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer instance
+     * @param {Camera2d} [viewport] - the camera rendering this frame
+     */
+    draw(renderer: CanvasRenderer | WebGLRenderer, viewport?: Camera2d): void;
+    /**
+     * Fallback for renderers without instancing (Canvas): walk the instances
+     * and draw the prototype once per instance, composing the group and
+     * instance transforms by hand. Correct, and as slow as the uninstanced
+     * scene it replaces — the point is that a scene authored for instancing
+     * still renders everywhere.
+     * @param {CanvasRenderer} renderer - a renderer instance
+     * @param {Camera2d} [viewport] - the camera rendering this frame
+     * @ignore
+     */
+    _drawInstancesIndividually(renderer: CanvasRenderer, viewport?: Camera2d): void;
+    /**
+     * Release the instance records along with the mesh.
+     * @ignore
+     */
+    /**
+     * Draw a ground shadow for every visible instance — one call for the whole
+     * set, over the instance buffer the mesh itself just drew from (#1515).
+     *
+     * The group matrix is passed with its Y basis column zeroed and its
+     * translation Y set to the ground, so whatever Y the shadow vertex stage
+     * produces is flattened onto the floor. That is what lets the ground
+     * height reach the shader without a new uniform.
+     *
+     * One ground height serves the whole set — flat terrain. Per-instance
+     * ground height would have to ride the `instanceData` slot, which the
+     * built-in shading already reads as emissive.
+     * @param {WebGLRenderer} renderer - the active renderer
+     * @ignore
+     */
+    _drawInstancedGroundShadow(renderer: WebGLRenderer): void;
+}
+import Mesh from "./mesh.js";
+import { Matrix3d } from "../math/matrix3d.ts";
+//# sourceMappingURL=instanced_mesh.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instanced_mesh.d.ts","sourceRoot":"","sources":["../../src/renderable/instanced_mesh.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH;IACC;;;;;;;OAOG;IACH,eAPW,MAAM,KACN,MAAM,YAEd;QAA0B,aAAa;QACZ,cAAc;QACd,YAAY;KACzC,EAiEA;IA7DA;;;;;;OAMG;IACH,gBAHU,MAAM,CAMf;IAED;;;;;;;OAOG;IACH,gBAFU,YAAY,CAEmB;IAEzC;;;;;OAKG;IACH,kBAHU,MAAM,CAGS;IAUzB,cAAc;IACd,0BAA0B;IAG1B,cAAc;IACd,0BAA0B;IAE1B,cAAc;IACd,oBAA2B;IAC3B,cAAc;IACd,mBAAmB;IAEnB,cAAc;IACd,uBAAuB;IACvB,cAAc;IACd,8BAA+B;IAE/B,cAAc;IACd,sBAAuB;IAoBxB,yBANU,MAAM,EAgDf;IAvDD;;;;;;;;OAQG;IACH,qBAFU,MAAM,CAIf;IA8DD,gCAVU,MAAM,EAiBf;IAvBD;;;;;;;;;OASG;IACH,4BAJU,MAAM,CAQf;IAWD;;;;;;;OAOG;IACH,wBANW,QAAQ,YAEhB;QAAwB,KAAK;QACF,IAAI;KAC/B,GAAU,MAAM,CAqBlB;IAED;;;;;;;;;OASG;IACH,sBAFW,MAAM,QAiBhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,aACN,QAAQ,QAYlB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,QACN,QAAQ,GACN,QAAQ,GAAC,SAAS,CAW9B;IAED;;;;OAIG;IACH,wBAHW,MAAM,SACN,KAAK,QAaf;IAED;;;;;;;OAOG;IACH,uBANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,QAahB;IAED;;;;;;OAMG;IACH,0BAHW,MAAM,SACN,MAAM,QAyBhB;IAED;;;;;;;;OAQG;IAEH,oCAIC;IAED;;;;;OAKG;IACH,cAHa,MAAM,EAAE,CAYpB;IAED;;;;;;;OAOG;IACH,iCAJW,MAAM,GACJ,MAAM,CAclB;IAED;;;OAGG;IACH,2BAIC;IAED;;;;;;;;OAQG;IACH;;;;;;;;;;;OAWG;IACH,0BA8BC;IAVC,gCAAsC;IAkDxC;;;;;;OAMG;IACH,eAHW,cAAc,GAAC,aAAa,aAC5B,QAAQ,QA6BlB;IAED;;;;;;;;;OASG;IACH,qCAJW,cAAc,aACd,QAAQ,QA6BlB;IAED;;;OAGG;IACH;;;;;;;;;;;;;;OAcG;IACH,qCAHW,aAAa,QAqEvB;CAOD;iBAlsBgB,WAAW;yBATH,qBAAqB"}