melonjs 20.4.0 → 20.6.0

package/build/renderable/mesh.d.ts

@@ -1,72 +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 {Uint32Array|Color[]|number[]} [settings.vertexColors] - 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.
-     * @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 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.
-     * @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 {boolean} [settings.transparent] - 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
-     * @param {boolean} [settings.fog] - set `false` to exempt this mesh from the camera's distance fog ({@link Camera3d#setFog}); omit to fog whenever the camera does
-     * @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, {
@@ -112,35 +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;
-        vertexColors?: number[] | Uint32Array<ArrayBufferLike> | Color[] | undefined;
-        normals?: number[] | Float32Array<ArrayBufferLike> | undefined;
-        specular?: number[] | Float32Array<ArrayBufferLike> | undefined;
-        shininess?: number | undefined;
-        alphaMap?: string | HTMLImageElement | TextureAtlas | undefined;
-        castGroundShadow?: boolean | undefined;
-        transparent?: boolean | undefined;
-        fog?: 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}
@@ -179,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
@@ -604,6 +523,123 @@ export default class Mesh extends Renderable {
      */
     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 = {
+    /**
+     * - 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`.
+     */
+    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";
@@ -612,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/renderable.d.ts

@@ -189,10 +189,24 @@ export default class Renderable extends Rect {
     /**
      * Define the renderable opacity<br>
      * Set to zero if you do not wish an object to be drawn
+     *
+     * Opacity **cascades**: it is multiplied with the alpha already on the
+     * renderer, so fading a {@link Container} fades everything inside it,
+     * and a child at `alpha` 0.5 inside a parent at 0.5 draws at 0.25.
+     * Each renderable keeps its own value — the composition happens at
+     * draw time, and is undone when the renderable is done.
+     *
+     * That is different from {@link Container#setChildsProperty}, which
+     * assigns a value onto the children themselves. Use `alpha` to fade a
+     * subtree, and `setChildsProperty` to change what the children are.
      * @see Renderable#setOpacity
      * @see Renderable#getOpacity
+     * @see Container#setChildsProperty
      * @type {number}
      * @default 1.0
+     * @example
+     * // fades the whole rig, parts included
+     * myModel.alpha = 0.3;
      */
     alpha: number;
     /**
@@ -358,6 +372,9 @@ export default class Renderable extends Rect {
     getBounds(): Bounds;
     /**
      * get the renderable alpha channel value<br>
+     *
+     * This is the renderable's OWN value. What it finally draws at is this
+     * multiplied by every ancestor's — see {@link Renderable#alpha}.
      * @returns {number} current opacity value between 0 and 1
      */
     getOpacity(): number;

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

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

package/build/renderable/sprite3d.d.ts

@@ -80,7 +80,7 @@ export default class Sprite3d extends Mesh {
      * @param {number} x - world x position
      * @param {number} y - world y position
      * @param {object} settings - configuration
-     * @param {HTMLImageElement|Texture2d|string} [settings.image] - the sprite texture (image name, image, or a {@link Texture2d} asset such as a {@link TextureAtlas}). Alias: `settings.texture`.
+     * @param {HTMLImageElement|HTMLCanvasElement|Texture2d|string} [settings.image] - the sprite texture (image name, image, or a {@link Texture2d} asset such as a {@link TextureAtlas}). Alias: `settings.texture`.
      * @param {number} [settings.width=settings.framewidth] - quad width in world units (pixels)
      * @param {number} [settings.height=settings.width] - quad height in world units
      * @param {number} [settings.framewidth] - width of a single frame within a spritesheet (enables frame animation)
@@ -94,10 +94,15 @@ export default class Sprite3d extends Mesh {
      * @param {boolean} [settings.flipY=false] - mirror the sprite vertically (see {@link Sprite3d#flipY})
      * @param {boolean} [settings.lit=false] - shade through the lit mesh batcher (see {@link Mesh})
      * @param {number[]|Float32Array} [settings.emissive] - emissive color (see {@link Mesh})
+     * @param {number} [settings.shadowGroundY] - world Y of the floor the blob shadow lands on. Omit and it falls back to the sprite's own base — which for a billboard moves with the camera, so a scene that knows where its floor is should say so.
+     * @param {number} [settings.shadowOpacity=0.45] - opacity of the shadow directly beneath the sprite, before any height fade
+     * @param {boolean} [settings.castGroundShadow] - give this sprite a blob ground shadow, overriding the application's `castGroundShadow` setting in both directions. Omit to inherit. Needs a GPU backend and a {@link Camera3d}.
+     * @param {boolean} [settings.fog] - set `false` to exempt this sprite from the camera's distance fog ({@link Camera3d#setFog}); omit to fog whenever the camera does. A sun or a moon wants this — everything else at that distance dissolves into the haze, and so would it.
+     * @param {boolean} [settings.transparent] - draw in the transparent pass (blended, back-to-front, no depth write) instead of the opaque one. Omit and the sprite goes transparent whenever its draw alpha is fractional; `true` for a soft-alpha sprite such as an additive glow; `false` to stay opaque however faded.
      * @param {number} [settings.alphaCutoff=0.5] - alpha cutout threshold (see {@link Mesh}). The mesh pass is opaque (no alpha blending), so this defaults to `0.5` to discard a sprite's transparent background (clean cutout silhouette, correct depth, no sorting). Set `0` for a fully-opaque quad, or tune the threshold.
      */
     constructor(x: number, y: number, settings: {
-        image?: string | HTMLImageElement | Texture2d | undefined;
+        image?: string | HTMLImageElement | HTMLCanvasElement | Texture2d | undefined;
         width?: number | undefined;
         height?: number | undefined;
         framewidth?: number | undefined;
@@ -114,6 +119,11 @@ export default class Sprite3d extends Mesh {
         flipY?: boolean | undefined;
         lit?: boolean | undefined;
         emissive?: number[] | Float32Array<ArrayBufferLike> | undefined;
+        shadowGroundY?: number | undefined;
+        shadowOpacity?: number | undefined;
+        castGroundShadow?: boolean | undefined;
+        fog?: boolean | undefined;
+        transparent?: boolean | undefined;
         alphaCutoff?: number | undefined;
     });
     /**

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

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

package/build/renderable/text/bitmaptext.d.ts

@@ -15,9 +15,8 @@ export default class BitmapText extends Renderable {
      * @param {object} settings - the text configuration
      * @param {string|Image} settings.font - a font name to identify the corresponding source image
      * @param {string} [settings.fontData=settings.font] - the bitmap font data corresponding name, or the bitmap font data itself (AngelCode BMFont, `.fnt` text or `.xml`)
-     * @param {number} [settings.size] - size a scaling ratio
-     * @param {Color|string} [settings.fillStyle] - a CSS color value used to tint the bitmapText (@see BitmapText.tint)
-     * @param {number} [settings.lineWidth=1] - line width, in pixels, when drawing stroke
+     * @param {number} [settings.size=1.0] - a scaling RATIO applied to the font's authored size, not a pixel size: `2` draws it at double. ({@link Text} takes pixels here; this one does not.)
+     * @param {Color|string} [settings.fillStyle] - a CSS color value used to tint the glyphs, see {@link Renderable#tint}
      * @param {string} [settings.textAlign="left"] - horizontal text alignment
      * @param {string} [settings.textBaseline="top"] - the text baseline
      * @param {number} [settings.lineHeight=1.0] - line spacing height
@@ -46,7 +45,6 @@ export default class BitmapText extends Renderable {
         fontData?: string | undefined;
         size?: number | undefined;
         fillStyle?: string | Color | undefined;
-        lineWidth?: number | undefined;
         textAlign?: string | undefined;
         textBaseline?: string | undefined;
         lineHeight?: number | undefined;
@@ -106,17 +104,34 @@ export default class BitmapText extends Renderable {
     private fontData;
     public set fillStyle(value: Color);
     /**
-     * defines the color used to tint the bitmap text
+     * defines the color used to tint the bitmap text.
+     *
+     * This is {@link Renderable#tint} under another name, so the same rule
+     * applies: white — `(255, 255, 255)` — is the absence of a tint, and any
+     * other colour tints away from there. A page image authored in white
+     * therefore keeps every colour available to it.
      * @public
      * @type {Color}
      * @see Renderable#tint
+     * @example
+     * // tint at construction...
+     * const score = new BitmapText(8, 8, {
+     *     font: "arial",
+     *     text: "1000",
+     *     fillStyle: "#ffd700",        // gold
+     * });
+     * app.world.addChild(score);
+     *
+     * // ...or at any point after it, from a CSS string or a Color
+     * score.fillStyle = "#ff4040";                  // flash red on damage
+     * score.fillStyle = new Color(255, 255, 255);   // back to untinted
      */
     public get fillStyle(): Color;
     metrics: TextMetrics;
     /**
      * change the font settings
      * @param {string} textAlign - ("left", "center", "right")
-     * @param {number} [scale]
+     * @param {number} [scale] - a scaling ratio, applied through {@link BitmapText#resize} when given
      * @returns {BitmapText} this object for chaining
      */
     set(textAlign: string, scale?: number): BitmapText;
@@ -152,14 +167,24 @@ export default class BitmapText extends Renderable {
     public get visibleRatio(): number;
     /**
      * change the font display size
-     * @param {number} scale - ratio
+     * @param {number} scale - a ratio against the font's authored size, NOT a
+     * pixel size: `1` is the page image at its native scale, `2` is double
      * @returns {BitmapText} this object for chaining
+     * @example
+     * // a bitmap font is pixel art — whole-number ratios stay crisp, and
+     * // fractional ones resample the page image
+     * title.resize(3);                 // three times its authored size
+     * title.set("center", 2);          // align and rescale in one call
      */
     resize(scale: number): BitmapText;
     /**
      * measure the given text size in pixels
      * @param {string} [text]
      * @returns {TextMetrics} a TextMetrics object with two properties: `width` and `height`, defining the output dimensions
+     * @example
+     * // size a panel around a label, at the label's CURRENT scale
+     * const size = label.measureText();
+     * panel.resize(size.width + 16, size.height + 16);
      */
     measureText(text?: string): TextMetrics;
     /**

package/build/renderable/text/bitmaptext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bitmaptext.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/bitmaptext.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,eA/BW,MAAM,KACN,MAAM,YAEd;QAA+B,IAAI,EAA3B,MAAM,8DAAM;QACM,QAAQ;QACR,IAAI;QACE,SAAS;QACf,SAAS;QACT,SAAS;QACT,YAAY;QACZ,UAAU;QACmB,WAAW,GAA1D,MAAM,GAAC,QAAQ,GAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC;QACjB,aAAa;QACF,IAAI;KACzC,EAqIF;IAhHA;;;;;;OAMG;IACH,kBAHU,MAAM,CAG6B;IAE7C;;;;;;OAMG;IACH,qBAHU,MAAM,CAGkC;IAElD;;;;;;OAMG;IACH,mBAHU,MAAM,CAG4B;IAE5C;;;;;;OAMG;IACH,sBAHU,MAAM,CAGiC;IAEjD;;;;;OAKG;IACH,cAAe;IAEf;;;OAGG;IACH,kBAA2C;IAE3C;;;OAGG;IACH,kBAG2B;IAG1B;;;OAGG;IAEH,iBAAgE;IAkNlE,4BANU,KAAK,EAad;IAhBD;;;;;OAKG;IACH,wBAHU,KAAK,CAKd;IAlLA;;;OAGG;IACH,2BAA4B;IAG5B,qBAAoC;IAWrC;;;;;OAKG;IACH,eAJW,MAAM,UACN,MAAM,GACJ,UAAU,CAWtB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GACpB,UAAU,CAwBtB;IAoBD,oCAdU,MAAM,EAmBf;IAvBD;;;;;;;;;;;;;OAaG;IACH,gCAVU,MAAM,CAYf;IAyBD,+BAZU,MAAM,EAsBf;IA1BD;;;;;OAKG;IACH,2BAFU,MAAM,CAUf;IAqFD;;;;OAIG;IACH,cAHW,MAAM,GACJ,UAAU,CAYtB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,WAAW,CAIvB;IAED;;;OAGG;IACH,eAFW,cAAc,GAAC,aAAa,QAmGtC;IAED;;;;OAIG;IACH,gBAQC;CACD;uBA9dsB,kBAAkB;sBAHnB,qBAAqB;wBAKnB,kBAAkB"}
+{"version":3,"file":"bitmaptext.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/bitmaptext.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,eA9BW,MAAM,KACN,MAAM,YAEd;QAA+B,IAAI,EAA3B,MAAM,8DAAM;QACM,QAAQ;QACR,IAAI;QACE,SAAS;QACf,SAAS;QACT,YAAY;QACZ,UAAU;QACmB,WAAW,GAA1D,MAAM,GAAC,QAAQ,GAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC;QACjB,aAAa;QACF,IAAI;KACzC,EAqIF;IAhHA;;;;;;OAMG;IACH,kBAHU,MAAM,CAG6B;IAE7C;;;;;;OAMG;IACH,qBAHU,MAAM,CAGkC;IAElD;;;;;;OAMG;IACH,mBAHU,MAAM,CAG4B;IAE5C;;;;;;OAMG;IACH,sBAHU,MAAM,CAGiC;IAEjD;;;;;OAKG;IACH,cAAe;IAEf;;;OAGG;IACH,kBAA2C;IAE3C;;;OAGG;IACH,kBAG2B;IAG1B;;;OAGG;IAEH,iBAAgE;IAmOlE,4BAlBU,KAAK,EAyBd;IAjCD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,wBAfU,KAAK,CAiBd;IAnMA;;;OAGG;IACH,2BAA4B;IAG5B,qBAAoC;IAWrC;;;;;OAKG;IACH,eAJW,MAAM,UACN,MAAM,GACJ,UAAU,CAWtB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GACpB,UAAU,CAwBtB;IAoBD,oCAdU,MAAM,EAmBf;IAvBD;;;;;;;;;;;;;OAaG;IACH,gCAVU,MAAM,CAYf;IAyBD,+BAZU,MAAM,EAsBf;IA1BD;;;;;OAKG;IACH,2BAFU,MAAM,CAUf;IAsGD;;;;;;;;;;OAUG;IACH,cATW,MAAM,GAEJ,UAAU,CAiBtB;IAED;;;;;;;;OAQG;IACH,mBAPW,MAAM,GACJ,WAAW,CAQvB;IAED;;;OAGG;IACH,eAFW,cAAc,GAAC,aAAa,QAmGtC;IAED;;;;OAIG;IACH,gBAQC;CACD;uBAxfsB,kBAAkB;sBAHnB,qBAAqB;wBAKnB,kBAAkB"}

package/build/renderable/text/text.d.ts

@@ -20,7 +20,8 @@ export default class Text extends Renderable {
      * @param {object} settings - the text configuration
      * @param {string} settings.font - a CSS font family: a specific name (`"Arial"`), a generic keyword (`"sans-serif"`, `"monospace"`, …), or a web font loaded via the `fontface` loader (referenced by its family name)
      * @param {number|string} settings.size - the font size: a number in pixels, or a CSS size string with a unit (`"24px"` / `"1.5em"` / `"18pt"`)
-     * @param {Color|string} [settings.fillStyle="#000000"] - a CSS color value used to fill the glyphs
+     * @param {Color|Gradient|string} [settings.fillStyle="#000000"] - a CSS color value used to fill the glyphs, or a {@link Gradient} to ramp them
+     * @param {boolean} [settings.gradientPerLine=true] - restart a gradient fill on every line; `false` spans one ramp across the whole block, as a plain canvas does
      * @param {Color|string} [settings.strokeStyle="#000000"] - a CSS color value used for the glyph outline (drawn when `lineWidth` > 0)
      * @param {number} [settings.lineWidth=0] - outline width in pixels (0 = no stroke)
      * @param {string} [settings.textAlign="left"] - horizontal text alignment ("left", "center", "right")
@@ -28,6 +29,8 @@ export default class Text extends Renderable {
      * @param {number} [settings.lineHeight=1.0] - line spacing height
      * @param {string|Vector2d|{x:number,y:number}} [settings.anchorPoint={x:0.0, y:0.0}] - anchor point to draw the text at. Also accepts the named presets `"center"`, `"top"`, `"bottom"`, `"left"`, `"right"`, `"top-left"`, `"top-right"`, `"bottom-left"`, `"bottom-right"`.
      * @param {number} [settings.wordWrapWidth] - the maximum length in CSS pixels of a line before it wraps
+     * @param {boolean} [settings.bold=false] - render the face bold, as {@link Text#bold} does
+     * @param {boolean} [settings.italic=false] - render the face italic, as {@link Text#italic} does
      * @param {(string|string[])} [settings.text=""] - a string, or an array of strings
      * @example
      * // a styled, word-wrapped, multi-line label using a generic system font
@@ -46,6 +49,23 @@ export default class Text extends Renderable {
      * label.setOpacity(0.8);           // per-object transparency
      * app.world.addChild(label);
      * @example
+     * // a gradient fill: `fillStyle` takes a Gradient as well as a colour.
+     * // Its coordinates are the label's OWN bake, so (0, 0) is the top-left of
+     * // the render box and the ramp below runs down exactly one line.
+     * const ramp = app.renderer.createLinearGradient(0, 0, 0, 32);
+     * ramp.addColorStop(0, "#fffdf0");
+     * ramp.addColorStop(1, "#ffa71d");
+     *
+     * app.world.addChild(new Text(8, 8, {
+     *     font: "sans-serif",
+     *     size: 32,
+     *     fillStyle: ramp,             // ramps the glyphs...
+     *     strokeStyle: "#000000",      // ...while the outline keeps its own colour
+     *     lineWidth: 1,
+     *     text: "GAME\nOVER",          // every line restarts the ramp by default
+     *     // gradientPerLine: false,   // ...or span ONE ramp across both lines
+     * }));
+     * @example
      * // a web font (loaded via the fontface loader) is used by its family name
      * loader.preload(
      *     [{ name: "kenpixel", type: "fontface", src: "data/font/kenvector.woff2" }],
@@ -59,7 +79,8 @@ export default class Text extends Renderable {
     constructor(x: number, y: number, settings: {
         font: string;
         size: number | string;
-        fillStyle?: string | Color | undefined;
+        fillStyle?: string | Color | Gradient | undefined;
+        gradientPerLine?: boolean | undefined;
         strokeStyle?: string | Color | undefined;
         lineWidth?: number | undefined;
         textAlign?: string | undefined;
@@ -70,6 +91,8 @@ export default class Text extends Renderable {
             y: number;
         };
         wordWrapWidth?: number | undefined;
+        bold?: boolean | undefined;
+        italic?: boolean | undefined;
         text?: string | string[] | undefined;
     });
     /**
@@ -124,6 +147,40 @@ export default class Text extends Renderable {
      * @default 10
      */
     fontSize: number;
+    /**
+     * The gradient to fill the glyphs with, when one was given instead of a
+     * colour. Built by {@link Renderer#createLinearGradient} /
+     * {@link Renderer#createRadialGradient}, and its coordinates are this
+     * label's own bake — `(0, 0)` is the top-left of the render box.
+     *
+     * Set it through `fillStyle`, the way `Renderer#setColor` takes one;
+     * this field is where it lands so the pooled `fillStyle` `Color` keeps
+     * its type, its alpha and its pooling.
+     * @type {Gradient|undefined}
+     * @default undefined
+     * @example
+     * const ramp = renderer.createLinearGradient(0, 0, 0, 24);
+     * ramp.addColorStop(0, "#fffdf0");
+     * ramp.addColorStop(1, "#f0a020");
+     * const label = new Text(x, y, { font: "Arial", size: 24, fillStyle: ramp });
+     */
+    fillGradient: Gradient | undefined;
+    /**
+     * Whether a gradient fill restarts on every line.
+     *
+     * `true` (the default) re-anchors the ramp to each line, so a
+     * multi-line label reads like one `Text` per line — which is how a HUD
+     * is usually built, and means the ramp does not have to be authored
+     * over the block height to look right.
+     *
+     * `false` spans one ramp across the whole block, which is what a plain
+     * canvas does: a `CanvasGradient` lives in the current transform's
+     * space, so lines further down sample further along it. Use it for a
+     * deliberate fade across a multi-line title.
+     * @type {boolean}
+     * @default true
+     */
+    gradientPerLine: boolean | undefined;
     canvasTexture: CanvasRenderTarget | undefined;
     metrics: TextMetrics | undefined;
     /**
@@ -170,15 +227,32 @@ export default class Text extends Renderable {
     public set visibleRatio(value: number);
     /**
      * the ratio of visible characters (0.0 to 1.0).
-     * Setting this automatically updates {@link visibleCharacters}.
+     * Setting this automatically updates {@link Text#visibleCharacters}.
+     *
+     * This is the one to tween: it is independent of how many characters the
+     * label holds, so a reveal takes the same time whatever the string is.
      * @public
      * @type {number}
+     * @default 1.0
+     * @see Text#visibleCharacters
+     * @example
+     * // reveal over two seconds, regardless of length
+     * label.visibleRatio = 0;
+     * new Tween(label).to({ visibleRatio: 1.0 }, { duration: 2000 }).start();
      */
     public get visibleRatio(): number;
     /**
      * measure the given text size in pixels
      * @param {string} [text] - the text to be measured
      * @returns {TextMetrics} a TextMetrics object defining the dimensions of the given piece of text
+     * @example
+     * // size a panel around a label
+     * const size = label.measureText();
+     * panel.resize(size.width + 16, size.height + 16);
+     *
+     * // or measure a string the label does not currently hold, to reserve
+     * // room for the widest state a counter will reach
+     * const widest = label.measureText("00:00").width;
      */
     measureText(text?: string): TextMetrics;
     /**
@@ -189,6 +263,7 @@ export default class Text extends Renderable {
 }
 import Renderable from "../renderable.js";
 import { Color } from "../../math/color.ts";
+import { Gradient } from "../../video/gradient.js";
 import CanvasRenderTarget from "../../video/rendertarget/canvasrendertarget.js";
 import TextMetrics from "./textmetrics.js";
 //# sourceMappingURL=text.d.ts.map