melonjs 20.3.0 → 20.5.0

package/build/renderable/mesh.d.ts

@@ -1,69 +1,8 @@
-/**
- * A renderable object for displaying textured triangle meshes.
- * Supports loading from Wavefront OBJ models (via `loader.preload` with type "obj")
- * or from raw geometry data (vertices, uvs, indices).
- * Includes a built-in perspective projection and supports 3D transforms
- * through the standard Renderable API (`rotate`, `scale`, `translate`).
- * Works on both GPU backends — WebGL 2 and WebGPU, with hardware depth
- * testing — and on the Canvas renderer via the CPU-projected 2D-camera
- * path (painter's algorithm, no depth buffer).
- *
- * **Retained rendering** — under a {@link Camera3d} on a GPU backend
- * (`renderer.supportsRetainedMesh`), the mesh's model-space geometry is
- * uploaded to GPU buffers **once** and every frame just draws it by
- * reference: placement, camera, tint, alpha and emissive all ride
- * per-draw uniforms, so moving, rotating, scaling or re-tinting a mesh
- * never re-uploads geometry (near-zero per-frame allocation). Editing
- * the geometry itself in place is still possible — signal it with
- * {@link Mesh#needsUpdate} and the GPU copy refreshes on the next draw.
- * Under a 2D camera (or on Canvas) the mesh instead re-projects its
- * vertices on the CPU each frame — same API, the camera and backend
- * decide the path.
- *
- * **Pivot — transforms are applied about the mesh's local origin `(0, 0, 0)`,
- * NOT a normalized anchor point.** Unlike a {@link Sprite} (whose
- * {@link Renderable#anchorPoint} recenters a `width`×`height` box), a mesh has
- * real vertex coordinates, so rotation and scale pivot around the model origin
- * the geometry is authored against — the standard convention for 3D meshes.
- * Place the origin where you want the pivot at authoring time (or nest the
- * mesh under a transformed parent to pivot elsewhere). Consequently, on the
- * `Camera3d` world-space path the mesh opts out of the anchor offset entirely
- * (see {@link Renderable#applyAnchorTransform}); the legacy 2D path still
- * honors `anchorPoint` for backward compatibility. Subclasses that bake the
- * anchor into their vertex data instead (e.g. {@link Sprite3d}, via the
- * internal `_anchorBaked` flag) opt out on **both** paths — for those, the
- * vertex bake is the single anchoring mechanism.
- * @category Game Objects
- */
 export default class Mesh extends Renderable {
     /**
      * @param {number} x - the x screen position of the mesh object
      * @param {number} y - the y screen position of the mesh object
-     * @param {object} settings - Configuration parameters for the Mesh object
-     * @param {string} [settings.model] - name of a preloaded OBJ model (via loader.preload with type "obj"). Vertex normals come with it — authored `vn` when the file has them, generated from face geometry when it does not — so an OBJ model can be `lit`.
-     * @param {Float32Array|number[]} [settings.vertices] - vertex positions as x,y,z triplets (alternative to settings.model)
-     * @param {Float32Array|number[]} [settings.uvs] - texture coordinates as u,v pairs (alternative to settings.model)
-     * @param {Uint16Array|number[]} [settings.indices] - triangle vertex indices (alternative to settings.model)
-     * @param {HTMLImageElement|TextureAtlas|string} [settings.texture] - the texture to apply (image name, HTMLImageElement, or TextureAtlas). If omitted and settings.material is provided, the texture is resolved from the MTL material's map_Kd. Passing this pins ONE binding over the whole model, which on a multi-material model suppresses the per-material texture split — see {@link Mesh#textureGroups}.
-     * @param {string} [settings.material] - name of a preloaded MTL material (via loader.preload with type "mtl"). When provided, the diffuse texture (map_Kd), tint color (Kd), and opacity (d) are automatically applied. On a multi-material model each material's own `map_Kd` is bound for its own slice of the geometry (#1573) and each `Kd` is baked per-vertex, so one `Mesh` renders the whole model.
-     * @param {number} settings.width - display width in pixels. With normalization on (the default) the model is scaled to fit this size; with `normalize: false` this is the uniform pixels-per-unit scale applied to the raw geometry.
-     * @param {number} [settings.height] - display height in pixels (normalized models only; ignored when `normalize: false`)
-     * @param {boolean} [settings.cullBackFaces=true] - enable backface culling
-     * @param {boolean} [settings.normalize=true] - fit the source geometry into a `[-0.5, 0.5]` unit cube before scaling, so `width`/`height` behave like a Sprite. Set `false` to keep the geometry's real-world coordinates — required when several meshes share one coordinate space (e.g. nodes of an imported glTF scene) so their relative scale and layout are preserved.
-     * @param {number} [settings.scale] - world-space scale (pixels per source unit) for the Camera3d path; defaults to `width`. Set this when `width`/`height` describe the renderable's world bounds (frustum culling) rather than the geometry scale — see {@link Mesh#meshScale}.
-     * @param {boolean} [settings.rightHanded=false] - treat the source as right-handed (Y-up, e.g. glTF) under the `Camera3d` world path. The default Y-up→Y-down bridge negates Y only (a reflection, which mirrors the scene left/right); `true` negates Y **and** Z (a rotation) so chirality is preserved and the result matches the authoring tool. See {@link Mesh#rightHanded}.
-     * @param {string} [settings.textureRepeat] - texture wrap mode (`"repeat"` / `"repeat-x"` / `"repeat-y"` / `"no-repeat"`) this mesh samples its texture with (per-mesh — it does not modify the shared texture, so other meshes/sprites using the same image are unaffected). Use `"repeat"` when the geometry's UVs fall outside the `[0, 1]` range and rely on the texture tiling (e.g. glTF assets, whose default sampler wrap is REPEAT) — otherwise the texture clamps to its edge texels and looks flat. Ignored for the white-pixel fallback. Note: REPEAT on a non-power-of-two texture requires WebGL 2.
-     * @param {string} [settings.textureFilter] - texture magnification filter (`"nearest"` for crisp pixel-art upscaling, `"linear"` for smooth) applied to the resolved texture. Omit to keep the renderer's global `antiAlias` default. On the mesh path, linear filtering also samples a generated mip chain with trilinear minification and 4× anisotropy (distant geometry stops shimmering) — `"nearest"` opts out, keeping crisp pixel-art models on hard level-0 sampling. GPU backends only (ignored by the Canvas renderer).
-     * @param {number} [settings.alphaCutoff=0] - alpha cutout threshold. Fragments whose final alpha is below this value are discarded (hard-edged cutout — foliage, fences, decals — with no blending or sorting). `0` disables the cutout. Set automatically by the glTF loader from a material's `alphaMode: "MASK"`. GPU mesh path only (WebGL and WebGPU; the Canvas renderer ignores it).
-     * @param {number[]|Float32Array} [settings.emissive] - emissive (self-illumination) color `[r, g, b]` (0..1, may exceed 1 for HDR glow) added on top of the lit/unlit color so the surface glows regardless of scene lights (neon, lava, screens). Omit / all-zero for no emission. Set automatically by the glTF loader (`emissiveFactor`) and OBJ loader (MTL `Ke`). GPU mesh path only (WebGL and WebGPU; the Canvas renderer ignores it).
-     * @param {boolean} [settings.lit=false] - shade this mesh with the scene's {@link Light3d} lights (the lit mesh pipeline) instead of rendering fullbright. Set automatically by the glTF importer when the scene carries a directional, point or spot light. With `lit` on and no lights present the batcher uploads a white ambient, so the result is indistinguishable from unlit.
-     * @param {number[]|Float32Array} [settings.normals] - per-vertex normals for the lit path. An explicit value wins over the ones an OBJ or glTF source supplies; omit it and they are taken from the model (or generated).
-     * @param {number[]|Float32Array} [settings.specular] - specular color `[r, g, b]` (0..1) for the lit path. Set by the OBJ loader from MTL `Ks`, and derived from glTF metallic/roughness.
-     * @param {number} [settings.shininess=0] - specular exponent for the lit path (MTL `Ns`). `0` for a fully diffuse surface.
-     * @param {string|TextureAtlas|HTMLImageElement} [settings.alphaMap] - per-texel opacity map, sampled in addition to the diffuse texture (MTL `map_d`).
-     * @param {boolean} [settings.castGroundShadow] - give this mesh a blob ground shadow, overriding the application's `castGroundShadow` setting in both directions. Omit to inherit. Needs a GPU backend and a `Camera3d`.
-     * @param {number} [settings.shadowGroundY] - world Y of the floor the shadow lands on. Omit and the blob sits at the object's own base at full strength; set it and the blob shrinks and fades as the object rises. Render space is Y-down, so the floor is a **greater** Y than the object above it.
-     * @param {number} [settings.shadowOpacity=0.45] - opacity of the shadow directly beneath the object, before any height fade.
+     * @param {MeshSettings} settings - Configuration parameters for the Mesh object
      * @example
      * // create from OBJ + MTL (texture auto-resolved from material)
      * let mesh = new me.Mesh(0, 0, {
@@ -109,32 +48,7 @@ export default class Mesh extends Renderable {
      * // 2D rotation (Z axis, same as Sprite)
      * mesh.rotate(Math.PI / 4);
      */
-    constructor(x: number, y: number, settings: {
-        model?: string | undefined;
-        vertices?: number[] | Float32Array<ArrayBufferLike> | undefined;
-        uvs?: number[] | Float32Array<ArrayBufferLike> | undefined;
-        indices?: number[] | Uint16Array<ArrayBufferLike> | undefined;
-        texture?: string | HTMLImageElement | TextureAtlas | undefined;
-        material?: string | undefined;
-        width: number;
-        height?: number | undefined;
-        cullBackFaces?: boolean | undefined;
-        normalize?: boolean | undefined;
-        scale?: number | undefined;
-        rightHanded?: boolean | undefined;
-        textureRepeat?: string | undefined;
-        textureFilter?: string | undefined;
-        alphaCutoff?: number | undefined;
-        emissive?: number[] | Float32Array<ArrayBufferLike> | undefined;
-        lit?: boolean | undefined;
-        normals?: number[] | Float32Array<ArrayBufferLike> | undefined;
-        specular?: number[] | Float32Array<ArrayBufferLike> | undefined;
-        shininess?: number | undefined;
-        alphaMap?: string | HTMLImageElement | TextureAtlas | undefined;
-        castGroundShadow?: boolean | undefined;
-        shadowGroundY?: number | undefined;
-        shadowOpacity?: number | undefined;
-    });
+    constructor(x: number, y: number, settings: MeshSettings);
     /**
      * the original (untransformed) vertex positions as x,y,z triplets
      * @type {Float32Array}
@@ -150,7 +64,6 @@ export default class Mesh extends Renderable {
      * @type {number}
      */
     vertexCount: number;
-    _indicesOriginal: number[];
     /**
      * the projected vertex positions.
      *
@@ -174,6 +87,17 @@ export default class Mesh extends Renderable {
      * @type {Float32Array|undefined}
      */
     originalNormals: Float32Array | undefined;
+    /**
+     * world-space normals for the current draw, recomputed from
+     * {@link Mesh#originalNormals} along the Camera3d path. Empty (zero) when
+     * the mesh has no source normals — the shader then ignores lighting.
+     *
+     * Carries the same caveat as {@link Mesh#vertices}: the WebGL
+     * `Camera3d` path rotates normals on the GPU and leaves this array
+     * untouched.
+     * @type {Float32Array}
+     */
+    normals: Float32Array;
     /**
      * Whether this mesh is lit by the active stage's {@link Light3d} lights.
      * When `true` it renders through the lit mesh batcher (diffuse shading
@@ -268,6 +192,102 @@ export default class Mesh extends Renderable {
      * @see Mesh#shadowGroundY
      */
     castGroundShadow: boolean | undefined;
+    /**
+     * Whether this mesh is affected by the camera's distance fog
+     * ({@link Camera3d#setFog}).
+     *
+     * Left **unset** (`undefined`, the default) the mesh fogs whenever the
+     * camera drawing it has fog — which for a scene that never enables fog
+     * means never. Set it to `false` and this mesh is never fogged, however
+     * far away it is: the escape hatch for something that has to stay
+     * readable at any distance, such as an objective marker or a waypoint.
+     * `true` is accepted for symmetry and behaves as the default.
+     *
+     * It exempts the **mesh**, not the ground shadow it casts. A blob is a
+     * mark on the floor and fogs with the floor it lies on — one staying
+     * crisp under an object whose surroundings had dissolved would read as
+     * a fault rather than as emphasis. The blob quad is also shared by
+     * every caster in the scene, so it carries no per-object state to read.
+     *
+     * Emissive surfaces fog too — light travelling through fog is
+     * attenuated like anything else — so a neon sign that should punch
+     * through wants `fog: false` rather than a brighter emissive.
+     * @type {boolean|undefined}
+     * @default undefined
+     * @see Camera3d#setFog
+     * @example
+     * // the world fogs; this waypoint stays readable at any distance
+     * camera.setFog({ near: 1200, far: 7000 });
+     *
+     * const marker = new Mesh(0, 0, {
+     *   ...beaconGeometry,
+     *   emissive: [1, 0.6, 0],
+     *   fog: false,
+     * });
+     * // or afterwards, on anything already built
+     * marker.fog = false;
+     */
+    fog: boolean | undefined;
+    /**
+     * Whether this mesh draws in the **transparent pass** — blended,
+     * back-to-front, writing no depth — instead of the opaque one.
+     *
+     * Left **unset** (`undefined`, the default) the mesh goes transparent
+     * whenever the draw resolves to fractional alpha, so `setOpacity(0.5)`
+     * simply fades it. That is the useful default because the opaque path
+     * writes premultiplied colour with blending off: a faded mesh comes out
+     * *darkened toward black* rather than see-through, which is a defect
+     * rather than a contract — the fully transparent end of the same range
+     * used to paint an opaque black silhouette until it was fixed.
+     *
+     * Set it **`true`** when the transparency lives in the TEXTURE rather
+     * than in the opacity — a soft-edged glow, smoke, a glTF material with
+     * `alphaMode: "BLEND"`. The automatic check reads the draw's alpha and
+     * cannot see into the texture. The glTF loader does not set this for
+     * you: one loaded mesh can merge several materials, and this flag
+     * routes the whole mesh, so a `"BLEND"` material sharing geometry with
+     * an opaque one would drag the opaque half into the transparent pass.
+     * Note that `alphaCutoff` discards texels before blending sees them, so
+     * a soft edge needs a low cutoff (see {@link Sprite3d}, which lowers
+     * its default for exactly this). The cutoff thresholds the MATERIAL's
+     * alpha, not the drawn alpha, so a fading cutout mesh keeps its shape
+     * rather than disappearing at its own threshold.
+     *
+     * The pass composites premultiplied, which is what the mesh vertex
+     * stage always emits. A texture uploaded with straight alpha and drawn
+     * with `transparent: true` therefore reads slightly bright at its soft
+     * texels; upload it premultiplied (the default) and it is exact.
+     *
+     * {@link Renderable#blendMode} is honoured per entry, with one limit:
+     * the advanced modes (`"overlay"`, `"difference"`, and the rest that
+     * need a compositing pass) fall back to `"normal"` here on both
+     * backends, since the pass rasterizes directly into the target.
+     *
+     * Set it **`false`** to keep a mesh in the opaque pass however it is
+     * faded — it will darken rather than fade, and it will keep writing
+     * depth.
+     *
+     * Sorting is **per object**, by distance from the camera, so two
+     * intersecting or mutually enclosing transparent meshes may pop as the
+     * camera moves; split them, or accept it. Needs a GPU backend and a
+     * {@link Camera3d} — the 2D-camera path is unaffected.
+     * @type {boolean|undefined}
+     * @default undefined
+     * @see Renderable#blendMode
+     * @example
+     * // a ghost that fades in — nothing else needed
+     * ghost.setOpacity(0.4);
+     *
+     * // a glow that blends at full opacity, and additively
+     * const glow = new Mesh(0, 0, {
+     *   ...quad,
+     *   texture: glowTexture,
+     *   transparent: true,
+     *   blendMode: "additive",
+     *   alphaCutoff: 0,
+     * });
+     */
+    transparent: boolean | undefined;
     /**
      * World Y of the floor the shadow lands on, or `undefined` (the
      * default) to mean "this object is standing on the ground" — the
@@ -293,17 +313,6 @@ export default class Mesh extends Renderable {
      * @default 0.45
      */
     shadowOpacity: number;
-    /**
-     * Cached horizontal half-extent used to size the shadow, resolved on
-     * first shadowed draw. Cached because the alternative is a
-     * `getBounds3d()` per frame per shadow, which re-bounds every source
-     * vertex through the model matrix.
-     * @ignore
-     */
-    _shadowHalfX: number;
-    _shadowHalfZ: number;
-    _shadowGeomVersion: number;
-    _shadowHasHeight: boolean;
     /**
      * whether to cull back-facing triangles
      * @type {boolean}
@@ -377,9 +386,15 @@ export default class Mesh extends Renderable {
      * material has its own dedup scope in the OBJ parser), so
      * every vertex belongs to exactly one material group and
      * carries that group's color unambiguously.
-     * @type {Uint32Array}
+     *
+     * This is also what `settings.vertexColors` and
+     * {@link Mesh#setVertexColor} populate, so procedural geometry
+     * can carry a gradient a per-object `tint` cannot express.
+     * `undefined` when every vertex is plain white.
+     * @type {Uint32Array|undefined}
+     * @see Mesh#setVertexColor
      */
-    vertexColors: Uint32Array;
+    vertexColors: Uint32Array | undefined;
     texture: any;
     /**
      * Index ranges that each need their own diffuse texture bound, for a
@@ -430,23 +445,6 @@ export default class Mesh extends Renderable {
      * @type {Matrix3d}
      */
     projectionMatrix: Matrix3d;
-    /** @ignore */
-    _anchorBaked: boolean;
-    /** @ignore */
-    _hullPoints: Vector2d[];
-    /** @ignore */
-    _hullPolygon: Polygon | null;
-    /** @ignore */
-    _geometryVersion: number;
-    /**
-     * Project all vertices through projectionMatrix × currentTransform
-     * and store the results in `this.vertices`.
-     * @param {number} [offsetX=0] - x offset added to each projected vertex
-     * @param {number} [offsetY=0] - y offset added to each projected vertex
-     * @param {number} [zScale=0] - scale factor for Z output (0 = skip Z, 1000 = depth buffer range)
-     * @ignore
-     */
-    _projectVertices(offsetX?: number, offsetY?: number, zScale?: number): void;
     /**
      * Signal that this mesh's geometry itself has changed — its vertices, UVs,
      * indices, normals or per-vertex colours were edited in place.
@@ -463,80 +461,29 @@ export default class Mesh extends Renderable {
      */
     set needsUpdate(value: any);
     /**
-     * Compose this mesh's placement into a single matrix: where its model-space
-     * geometry sits in the world.
-     *
-     * This is the matrix form of {@link Mesh#_projectVerticesWorld} — the same
-     * transform, scale and axis bridge, expressed once instead of applied to
-     * every vertex:
-     *
-     *   `translate(pos, depth) · scale(s, -s, ±s) · currentTransform`
-     *
-     * The Y negation bridges Y-up geometry to the engine's Y-down world; Z is
-     * negated too for right-handed (glTF) sources, which makes the bridge a
-     * rotation rather than a reflection and so preserves triangle winding.
-     * @returns {Matrix3d} the mesh's model matrix (reused instance)
-     * @ignore
-     */
-    _composeModelMatrix(): Matrix3d;
-    /** @ignore */
-    _modelMatrix: Matrix3d | undefined;
-    /**
-     * Project vertices into **world space** for the Camera3d render path.
-     * Bypasses {@link Mesh#projectionMatrix} (the self-contained
-     * perspective that's meaningful only under Camera2d) and emits
-     * vertices that the active 3D camera then projects via its own
-     * view + projection matrices, the same way it does for Sprites.
-     *
-     * Per-vertex math: `currentTransform × originalVertex`, then a uniform
-     * scale by `this.width`, the Y-up→Y-down bridge (negate Y, and also Z when
-     * {@link Mesh#rightHanded} is set so the bridge is a rotation rather than a
-     * mirror), and a translate to `(offsetX, offsetY, offsetZ)`.
-     *
-     * @param {number} offsetX - world X to place the mesh center at
-     * @param {number} offsetY - world Y to place the mesh center at
-     * @param {number} offsetZ - world Z to place the mesh center at
-     * @ignore
-     */
-    _projectVerticesWorld(offsetX: number, offsetY: number, offsetZ: number): void;
-    /**
-     * Project {@link Mesh#originalNormals} into world space for lit shading,
-     * storing the result in {@link Mesh#normals}. Applies the rotation/scale of
-     * {@link Renderable#currentTransform} (no translation), the same Y-down /
-     * `rightHanded` Y/Z bridge as {@link Mesh#_projectVerticesWorld}, then
-     * renormalizes. No-op when the mesh has no source normals.
-     *
-     * Note: uses the transform's rotation/scale columns directly rather than
-     * the inverse-transpose, so normals are exact under rotation + uniform
-     * scale (the common case); a strongly non-uniform scale would skew them
-     * slightly — acceptable for the diffuse lighting path.
-     * @ignore
-     */
-    _projectNormalsWorld(): void;
-    /**
-     * Build the winding-reversed indices buffer used by the Camera3d
-     * world-space path. Called once, lazily, the first time the mesh
-     * draws under Camera3d. Why: the world-space path Y-flips vertices
-     * on output (a reflection, det = -1), which inverts triangle
-     * winding in screen space. Without the swap, `cullBackFaces: true`
-     * would end up culling the front faces and the model would look
-     * hollow.
-     *
-     * Both buffers are kept alive — `_indicesOriginal` is the original
-     * OBJ-shared (or user-supplied) winding, `_indicesReversed` is the
-     * Camera3d-flipped copy. `draw()` swaps `this.indices` between them
-     * each frame based on the active camera, so a Mesh that was first
-     * drawn under Camera3d and later re-parented to a Camera2d stage
-     * (e.g. a level transition into a 2D minigame) gets its original
-     * winding back and stays correctly oriented under
-     * `cullBackFaces: true`.
-     * @param {boolean} [needsReversedIndices=true] - build the winding-reversed index copy. `false` on the retained path, which corrects winding with `frontFace` and would otherwise duplicate the index array for nothing.
-     * @ignore
-     */
-    _setupWorldSpace(needsReversedIndices?: boolean): void;
-    _indicesReversed: any;
-    _worldSpace: boolean | undefined;
-    _useWorldSpace: boolean | undefined;
+     * Set one vertex's colour, multiplied into {@link Mesh#tint}.
+     *
+     * The mesh starts carrying per-vertex colour on the first call — every
+     * other vertex is white until coloured, so a mesh built without
+     * `settings.vertexColors` looks unchanged until you touch it.
+     *
+     * Out-of-range indices are ignored rather than throwing, matching
+     * {@link InstancedMesh#setInstanceColor}.
+     *
+     * Bumps {@link Mesh#needsUpdate} for you: the retained `Camera3d` path
+     * uploads geometry once and compares the version, so a colour written
+     * without it would apply on the immediate path and silently not on the
+     * retained one.
+     * @param {number} index - the vertex to colour
+     * @param {Color} color - the vertex colour
+     * @example
+     * // fade a procedural terrain toward the sky with distance
+     * for (let i = 0; i < mesh.vertexCount; i++) {
+     *     const t = Math.min(1, mesh.originalVertices[i * 3 + 2] / 6000);
+     *     mesh.setVertexColor(i, haze.copy(ground).lerp(sky, t));
+     * }
+     */
+    setVertexColor(index: number, color: Color): void;
     /**
      * The mesh's world-space 3D axis-aligned bounding box. This is the 3D analog
      * of {@link Renderable#getBounds} (which returns a flat 2D box from
@@ -552,39 +499,6 @@ export default class Mesh extends Renderable {
      * @returns {AABB3d} the world-space bounding box (reused instance)
      */
     getBounds3d(): AABB3d;
-    /** @ignore */
-    _bounds3d: AABB3d | undefined;
-    /**
-     * Whether this mesh casts a ground shadow on this draw (#1515).
-     *
-     * Precedence, most specific first: the mesh's own `castGroundShadow`, then
-     * the application's `castGroundShadow` setting. A per-mesh value is an
-     * explicit instruction and is obeyed as given; the application default is a
-     * blanket one, so it skips meshes with no vertical extent — which is what a
-     * ground plane is, and a flat plane lying on the floor has nothing to cast.
-     * Read off the renderer rather than the global application instance, the
-     * same way the `textureFilter` default is.
-     * @param {WebGLRenderer|WebGPURenderer} renderer - the active renderer
-     * @returns {boolean} true if a shadow should be drawn
-     * @ignore
-     */
-    _castsGroundShadow(renderer: WebGLRenderer | WebGPURenderer): boolean;
-    /**
-     * Measure the model-space footprint the blob is built from, and whether the
-     * geometry has any height at all — once per geometry version.
-     * @ignore
-     */
-    _measureShadowFootprint(): void;
-    /**
-     * Draw this mesh's ground shadow: the shared blob quad, flattened onto the
-     * ground plane beneath the object (#1515).
-     *
-     * The quad is shared by every shadow in the scene and its geometry is
-     * uploaded once, so this is one draw and no allocation.
-     * @param {WebGLRenderer} renderer - the active renderer
-     * @ignore
-     */
-    _drawGroundShadow(renderer: WebGLRenderer): void;
     /**
      * Render the mesh at its current state (transforms, projection, tint) to an offscreen canvas.
      * The returned canvas can be used with `renderer.drawImage()`, as a `Sprite` image source,
@@ -608,13 +522,124 @@ export default class Mesh extends Renderable {
      * const sprite = new me.Sprite(100, 100, { image: bitmap });
      */
     toImageBitmap(): Promise<ImageBitmap>;
+}
+/**
+ * Everything {@link Mesh} takes.
+ *
+ * Split out of the constructor's own `@param` list so a subclass that
+ * forwards these wholesale — {@link InstancedMesh} does — can say so in its
+ * type, instead of restating 27 entries that would then drift apart.
+ */
+export type MeshSettings = {
     /**
-     * Release this mesh's GPU-resident geometry, if a renderer is holding any,
-     * then destroy the renderable.
-     * @ignore
+     * - name of a preloaded OBJ model (via loader.preload with type "obj"). Vertex normals come with it — authored `vn` when the file has them, generated from face geometry when it does not — so an OBJ model can be `lit`.
      */
-    destroy(): void;
-}
+    model?: string;
+    /**
+     * - vertex positions as x,y,z triplets (alternative to `model`)
+     */
+    vertices?: Float32Array | number[];
+    /**
+     * - texture coordinates as u,v pairs (alternative to `model`)
+     */
+    uvs?: Float32Array | number[];
+    /**
+     * - triangle vertex indices (alternative to `model`). A `Uint32Array` is preserved as-is for meshes past 65535 vertices — which is what the glTF parser emits for them — while a plain array is materialized as `Uint16Array`
+     */
+    indices?: Uint16Array | Uint32Array | number[];
+    /**
+     * - the texture to apply (image name, HTMLImageElement, or TextureAtlas). If omitted and settings.material is provided, the texture is resolved from the MTL material's map_Kd. Passing this pins ONE binding over the whole model, which on a multi-material model suppresses the per-material texture split — see {@link Mesh#textureGroups}.
+     */
+    texture?: HTMLImageElement | HTMLCanvasElement | Texture2d | TextureAtlas | string;
+    /**
+     * - name of a preloaded MTL material (via loader.preload with type "mtl"). When provided, the diffuse texture (map_Kd), tint color (Kd), and opacity (d) are automatically applied. On a multi-material model each material's own `map_Kd` is bound for its own slice of the geometry (#1573) and each `Kd` is baked per-vertex, so one `Mesh` renders the whole model.
+     */
+    material?: string;
+    /**
+     * - display width in pixels. With normalization on (the default) the model is scaled to fit this size; with `normalize: false` this is the uniform pixels-per-unit scale applied to the raw geometry. With `normalize: false` and an explicit `scale`, an omitted `width`/`height` is derived from the GEOMETRY's own extent, the way a Sprite takes its size from its frame — a mesh that reports no extent misleads frustum culling, pointer picking and the physics broadphase alike.
+     */
+    width: number;
+    /**
+     * - display height in pixels (normalized models only; ignored when `normalize: false`)
+     */
+    height?: number;
+    /**
+     * - enable backface culling
+     */
+    cullBackFaces?: boolean;
+    /**
+     * - fit the source geometry into a `[-0.5, 0.5]` unit cube before scaling, so `width`/`height` behave like a Sprite. Set `false` to keep the geometry's real-world coordinates — required when several meshes share one coordinate space (e.g. nodes of an imported glTF scene) so their relative scale and layout are preserved.
+     */
+    normalize?: boolean;
+    /**
+     * - world-space scale (pixels per source unit) for the Camera3d path; defaults to `width`. Set this when `width`/`height` describe the renderable's world bounds (frustum culling) rather than the geometry scale — see {@link Mesh#meshScale}.
+     */
+    scale?: number;
+    /**
+     * - treat the source as right-handed (Y-up, e.g. glTF) under the `Camera3d` world path. The default Y-up→Y-down bridge negates Y only (a reflection, which mirrors the scene left/right); `true` negates Y **and** Z (a rotation) so chirality is preserved and the result matches the authoring tool. See {@link Mesh#rightHanded}.
+     */
+    rightHanded?: boolean;
+    /**
+     * - texture wrap mode (`"repeat"` / `"repeat-x"` / `"repeat-y"` / `"no-repeat"`) this mesh samples its texture with (per-mesh — it does not modify the shared texture, so other meshes/sprites using the same image are unaffected). Use `"repeat"` when the geometry's UVs fall outside the `[0, 1]` range and rely on the texture tiling (e.g. glTF assets, whose default sampler wrap is REPEAT) — otherwise the texture clamps to its edge texels and looks flat. Ignored for the white-pixel fallback. Note: REPEAT on a non-power-of-two texture requires WebGL 2.
+     */
+    textureRepeat?: string;
+    /**
+     * - texture magnification filter (`"nearest"` for crisp pixel-art upscaling, `"linear"` for smooth) applied to the resolved texture. Omit to keep the renderer's global `antiAlias` default. On the mesh path, linear filtering also samples a generated mip chain with trilinear minification and 4× anisotropy (distant geometry stops shimmering) — `"nearest"` opts out, keeping crisp pixel-art models on hard level-0 sampling. GPU backends only (ignored by the Canvas renderer).
+     */
+    textureFilter?: string;
+    /**
+     * - alpha cutout threshold. Fragments whose final alpha is below this value are discarded (hard-edged cutout — foliage, fences, decals — with no blending or sorting). `0` disables the cutout. Set automatically by the glTF loader from a material's `alphaMode: "MASK"`. GPU mesh path only (WebGL and WebGPU; the Canvas renderer ignores it).
+     */
+    alphaCutoff?: number;
+    /**
+     * - emissive (self-illumination) color `[r, g, b]` (0..1, may exceed 1 for HDR glow) added on top of the lit/unlit color so the surface glows regardless of scene lights (neon, lava, screens). Omit / all-zero for no emission. Set automatically by the glTF loader (`emissiveFactor`) and OBJ loader (MTL `Ke`). GPU mesh path only (WebGL and WebGPU; the Canvas renderer ignores it).
+     */
+    emissive?: number[] | Float32Array;
+    /**
+     * - shade this mesh with the scene's {@link Light3d} lights (the lit mesh pipeline) instead of rendering fullbright. Set automatically by the glTF importer when the scene carries a directional, point or spot light. With `lit` on and no lights present the batcher uploads a white ambient, so the result is indistinguishable from unlit.
+     */
+    lit?: boolean;
+    /**
+     * - per-vertex colour, one entry per vertex, multiplied into {@link Mesh#tint}. Either packed RGBA8 (`Uint32Array`, the form the batchers read — no conversion) or one {@link Color} per vertex. Omit for plain white. Lets a single mesh carry a gradient — fading a terrain toward the sky with distance, darkening a crease — which a per-object `tint` cannot express. An explicit value wins over the colours a multi-material OBJ bakes from its MTL.
+     */
+    vertexColors?: Uint32Array | Color[] | number[];
+    /**
+     * - per-vertex normals for the lit path. An explicit value wins over the ones an OBJ or glTF source supplies; omit it and they are taken from the model, or generated from the geometry when the mesh is `lit`. Generated normals average per vertex where faces share vertices (smooth shading) and equal the face normal where they do not (flat shading) — the geometry decides, not a flag.
+     */
+    normals?: number[] | Float32Array;
+    /**
+     * - specular color `[r, g, b]` (0..1) for the lit path. Set by the OBJ loader from MTL `Ks`, and derived from glTF metallic/roughness.
+     */
+    specular?: number[] | Float32Array;
+    /**
+     * - specular exponent for the lit path (MTL `Ns`). `0` for a fully diffuse surface.
+     */
+    shininess?: number;
+    /**
+     * - per-texel opacity map, sampled in addition to the diffuse texture (MTL `map_d`).
+     */
+    alphaMap?: string | TextureAtlas | HTMLImageElement;
+    /**
+     * - give this mesh a blob ground shadow, overriding the application's `castGroundShadow` setting in both directions. Omit to inherit. Needs a GPU backend and a `Camera3d`.
+     */
+    castGroundShadow?: boolean;
+    /**
+     * - draw in the transparent pass (blended, back-to-front, no depth write). Omit and a mesh goes transparent whenever its draw alpha is fractional; `true` for soft-alpha textures; `false` to stay opaque however faded
+     */
+    transparent?: boolean;
+    /**
+     * - set `false` to exempt this mesh from the camera's distance fog ({@link Camera3d#setFog}); omit to fog whenever the camera does
+     */
+    fog?: boolean;
+    /**
+     * - world Y of the floor the shadow lands on. Omit and the blob sits at the object's own base at full strength; set it and the blob shrinks and fades as the object rises. Render space is Y-down, so the floor is a **greater** Y than the object above it.
+     */
+    shadowGroundY?: number;
+    /**
+     * - opacity of the shadow directly beneath the object, before any height fade.
+     */
+    shadowOpacity?: number;
+};
 import Renderable from "./renderable.js";
 import { TextureAtlas } from "./../video/texture/atlas.js";
 import { Color } from "../math/color.ts";
@@ -623,4 +648,5 @@ import { Vector2d } from "../math/vector2d.ts";
 import { Polygon } from "../geometries/polygon.ts";
 import { AABB3d } from "../physics/broadphase/aabb3d.ts";
 import type WebGLRenderer from "./../video/webgl/webgl_renderer.js";
+import Texture2d from "./../video/texture/texture2d.ts";
 //# sourceMappingURL=mesh.d.ts.map

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

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

package/build/renderable/nineslicesprite.d.ts

@@ -65,10 +65,6 @@ export default class NineSliceSprite extends Sprite {
     nss_height: number;
     insetx: number | undefined;
     insety: number | undefined;
-    /**
-     * @ignore
-     */
-    draw(renderer: any): void;
 }
 import Sprite from "./sprite.js";
 import type { TextureAtlas } from "./../video/texture/atlas.js";

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

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