melonjs 20.7.0 → 20.9.0

package/build/renderable/renderable.d.ts

@@ -1,3 +1,4 @@
+
 /**
  * A base class for renderable objects.
  * @category Game Objects
@@ -158,6 +159,10 @@ export default class Renderable extends Rect {
     alwaysUpdate: boolean;
     /**
      * Whether to update this object when the game is paused.
+     *
+     * On a container it covers everything under it: a child steps through
+     * a pause on its own opt-in or on one from any container above it, so
+     * a pause menu flags itself once and its nested labels follow.
      * @type {boolean}
      * @default false
      */
@@ -315,6 +320,36 @@ export default class Renderable extends Rect {
      * @default true
      */
     isKinematic: boolean;
+    /**
+     * whether a single post effect on this renderable needs an offscreen
+     * capture instead of the renderer's shader-swap fast path.
+     *
+     * One effect is normally applied by drawing the renderable with the
+     * effect's own program rather than capturing and post-processing it,
+     * which costs no render target. That is only equivalent when everything
+     * the renderable draws is a textured quad. `fillRect` and the shape
+     * dispatch go through a batcher that never looks at that shader, so a
+     * single effect on a renderable that draws with primitives silently
+     * does nothing. Set this and the capture is used instead, at the cost
+     * of a render target while the effect is active.
+     *
+     * Two or more effects always capture, so this only ever changes the
+     * single-effect case.
+     * @type {boolean}
+     * @default false
+     * @example
+     * class Bar extends Renderable {
+     *     constructor(x, y, w, h) {
+     *         super(x, y, w, h);
+     *         // this draws itself with primitives, not as a sprite
+     *         this.postEffectNeedsCapture = true;
+     *     }
+     *     draw(renderer) {
+     *         renderer.fillRect(this.pos.x, this.pos.y, this.width, this.height);
+     *     }
+     * }
+     */
+    postEffectNeedsCapture: boolean;
     /**
      * returns the parent application (or game) to which this renderable is attached to
      * @return {Application} the parent application or undefined if not attached to any container/app
@@ -326,7 +361,15 @@ export default class Renderable extends Rect {
      * @type {boolean}
      */
     get isFloating(): boolean;
-    set tint(value: Color);
+    /**
+     * Takes a {@link Color} to copy, or a CSS colour string.
+     *
+     * It COPIES rather than holds, so a caller that goes on mutating what it
+     * passed does not steer this renderable's tint by accident. What the
+     * getter hands back is always a `Color`, whichever form went in.
+     * @param {Color|string} value - the colour to tint with
+     */
+    set tint(value: Color | string);
     /**
      * define a tint for this renderable. a (255, 255, 255) r, g, b value will remove the tint effect.
      * @type {Color}
@@ -338,12 +381,62 @@ export default class Renderable extends Rect {
      * this.tint.setColor(255, 255, 255);
      */
     get tint(): Color;
+    /**
+     * Tint this renderable, chainably.
+     *
+     * Exactly {@link Renderable#tint}'s own setter, returning the renderable
+     * so it can be chained with the other `set*` methods. It exists because
+     * `tint` is a live {@link Color}, so reaching for it means choosing
+     * between `setColor` (0 to 255), `setFloat` (0 to 1), `parseCSS`,
+     * `setHSL` and `setLinear` — and picking the wrong one is silent, it just
+     * renders the wrong colour.
+     *
+     * Deliberately sRGB only. A LINEAR value, which in practice means a glTF
+     * `baseColorFactor` or `emissiveFactor`, stays an explicit
+     * `tint.setLinear(...)` so the conversion is never silent; for a mesh
+     * built from an asset, pass {@link Mesh#baseColorFactor} as a setting and
+     * the loader's value is applied for you.
+     * @param {Color|string} value - a `Color` to copy, or a CSS colour string
+     * @returns {this} this renderable, for chaining
+     * @example
+     * sprite.setTint("#ff8800");
+     * // the same on any renderable, mesh included
+     * mesh.setTint(theme.accent).setOpacity(0.5);
+     * // remove a tint
+     * sprite.setTint("#ffffff");
+     */
+    setTint(value: Color | string): this;
     set depth(value: number);
     /**
      * the depth of this renderable on the z axis
      * @type {number}
      */
     get depth(): number;
+    /**
+     * Move this renderable, optionally in three dimensions.
+     *
+     * `pos` holds an `ObservableVector3d`, but the geometry this class
+     * inherits from declares it as a 2D vector, so from TypeScript
+     * `pos.set(x, y)` takes two arguments and silently writes a zero z.
+     * Anything with a depth then drops to the near plane. Reaching past that
+     * previously meant a double cast or assigning `pos.x`, `pos.y` and
+     * `depth` by hand, which is why that pattern is written out dozens of
+     * times across the examples.
+     *
+     * **Omitting `z` leaves the depth exactly as it was**, rather than
+     * zeroing it. That is the whole difference from `pos.set(x, y)`, and it
+     * is what makes this safe to call on a 2D sprite that happens to sit at
+     * a depth, or on a `Camera2d`, without having to know whether it does.
+     * @param {number} x - the new x position
+     * @param {number} y - the new y position
+     * @param {number} [z] - the new depth; left untouched when omitted
+     * @returns {this} this renderable, for chaining
+     * @example
+     * sprite.setPosition(120, 64);        // 2D: depth unchanged
+     * mesh.setPosition(0, -20, 140);      // 3D
+     * camera.setPosition(0, 0, -300).lookAt(player);
+     */
+    setPosition(x: number, y: number, z?: number): this;
     set inViewport(value: boolean);
     /**
      * Whether the renderable object is visible and within the viewport
@@ -403,11 +496,6 @@ export default class Renderable extends Rect {
      * @type {boolean}
      */
     public get isFlippedY(): boolean;
-    /**
-     * returns the bounding box for this renderable
-     * @returns {Bounds} bounding box Rectangle object
-     */
-    getBounds(): Bounds;
     /**
      * get the renderable alpha channel value<br>
      *
@@ -439,9 +527,9 @@ export default class Renderable extends Rect {
      * multiply the renderable currentTransform with the given matrix
      * @see Renderable#currentTransform
      * @param {Matrix2d|Matrix3d} m - the transformation matrix
-     * @returns {Renderable} Reference to this object for method chaining
+     * @returns {this} Reference to this object for method chaining
      */
-    transform(m: Matrix2d | Matrix3d): Renderable;
+    transform(m: Matrix2d | Matrix3d): this;
     /**
      * return the angle to the specified target
      * @param {Renderable|Vector2d|Vector3d} target
@@ -466,9 +554,9 @@ export default class Renderable extends Rect {
      * When called with an angle and a Vector3d axis, rotates around that axis in 3D.
      * @param {number} angle - The angle to rotate (in radians)
      * @param {Vector3d} [v] - the axis to rotate around (defaults to Z axis for 2D)
-     * @returns {Renderable} Reference to this object for method chaining
+     * @returns {this} Reference to this object for method chaining
      */
-    rotate(angle: number, v?: Vector3d): Renderable;
+    rotate(angle: number, v?: Vector3d): this;
     /**
      * scale the renderable around his anchor point.  Scaling actually applies changes
      * to the currentTransform member which is used by the renderer to scale the object
@@ -478,23 +566,23 @@ export default class Renderable extends Rect {
      * @param {number} x - a number representing the abscissa of the scaling vector.
      * @param {number} [y=x] - a number representing the ordinate of the scaling vector.
      * @param {number} [z=1] - a number representing the depth of the scaling vector.
-     * @returns {Renderable} Reference to this object for method chaining
+     * @returns {this} Reference to this object for method chaining
      */
-    scale(x: number, y?: number, z?: number): Renderable;
+    scale(x: number, y?: number, z?: number): this;
     /**
      * scale the renderable around his anchor point
      * @param {Vector2d} v - scaling vector
-     * @returns {Renderable} Reference to this object for method chaining
+     * @returns {this} Reference to this object for method chaining
      */
-    scaleV(v: Vector2d): Renderable;
+    scaleV(v: Vector2d): this;
     /**
      * Translate the renderable by the specified offset.
-     * @param {number} x - x offset
-     * @param {number} [y=0] - y offset
-     * @param {number} [z=0] - z offset
-     * @returns {Renderable} Reference to this object for method chaining
+     * @param {number|Vector2d|Vector3d} x - x offset, or a vector to translate by
+     * @param {number} [y=0] - y offset, ignored when the first argument is a vector
+     * @param {number} [z=0] - z offset, ignored when the first argument is a vector
+     * @returns {this} Reference to this object for method chaining
      */
-    translate(x: number, y?: number, z?: number): Renderable;
+    translate(x: number | Vector2d | Vector3d, y?: number, z?: number): this;
     /**
      * update function (automatically called by melonJS).
      * @param {number} dt - time since the last update in milliseconds.
@@ -618,9 +706,9 @@ export default class Renderable extends Rect {
      * This will apply any defined transforms, anchor point, tint or blend mode and translate the context accordingly to this renderable position.
      * @see Renderable#draw
      * @see Renderable#postDraw
-     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
+     * @param {Renderer} renderer - a renderer object
      */
-    preDraw(renderer: CanvasRenderer | WebGLRenderer): void;
+    preDraw(renderer: Renderer): void;
     /**
      * Draw this renderable (automatically called by melonJS).
      * All draw operations for renderable are made respectively
@@ -634,17 +722,22 @@ export default class Renderable extends Rect {
      * `(0, 0)` places the shape at the container's origin instead.
      * @see Renderable#preDraw
      * @see Renderable#postDraw
-     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer instance
-     * @param {Camera2d} [viewport] - the viewport to (re)draw
+     * @param {Renderer} renderer - a renderer instance
+     * @param {Camera2d|Container} [viewport] - the frame this draw happens in:
+     * the camera drawing it, or -- when a camera is itself the renderable being
+     * drawn -- the container it draws. `Camera2d#draw` takes the second, and
+     * declaring only the first here meant a camera was not assignable to the
+     * `Renderable` it extends, which cascaded into every signature mentioning
+     * either of them
      */
-    draw(renderer: CanvasRenderer | WebGLRenderer, viewport?: Camera2d): void;
+    draw(renderer: Renderer, viewport?: Camera2d | Container): void;
     /**
      * restore the rendering context after drawing (automatically called by melonJS).
      * @see Renderable#preDraw
      * @see Renderable#draw
-     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
+     * @param {Renderer} renderer - a renderer object
      */
-    postDraw(renderer: CanvasRenderer | WebGLRenderer): void;
+    postDraw(renderer: Renderer): void;
     /**
      * Legacy collision callback — fires every frame this renderable body is
      * overlapping another body. Kept for backward compatibility with code
@@ -714,13 +807,21 @@ export default class Renderable extends Rect {
 import { Rect } from "./../geometries/rectangle.ts";
 import { ObservablePoint } from "../geometries/observablePoint.ts";
 import { Matrix3d } from "../math/matrix3d.ts";
+import type { PhysicsBody } from "../physics/adapter.ts";
 import type Container from "./container.js";
 import type Entity from "./entity/entity.js";
 import type { RoundRect } from "./../geometries/roundrect.ts";
 import type { Polygon } from "../geometries/polygon.ts";
 import type { Line } from "./../geometries/line.ts";
 import type { Ellipse } from "./../geometries/ellipse.ts";
+import type GLShader from "../video/webgl/glshader.js";
+import type ShaderEffect from "../video/effects/shadereffect.js";
+import type { Vector3d } from "../math/vector3d.ts";
+import type { Color } from "../math/color.ts";
 import type Application from "./../application/application.ts";
-import type CanvasRenderer from "./../video/canvas/canvas_renderer.js";
-import type WebGLRenderer from "./../video/webgl/webgl_renderer.js";
+import type { Matrix2d } from "../math/matrix2d.ts";
+import type { Vector2d } from "../math/vector2d.ts";
+import type { Bounds } from "../physics/bounds.ts";
+import type Renderer from "../video/renderer.js";
+import type Camera2d from "../camera/camera2d.ts";
 //# sourceMappingURL=renderable.d.ts.map

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/sprite.d.ts

@@ -1,7 +1,9 @@
 /**
  * additional import for TypeScript
- * @import {Vector2d} from "../math/vector2d.js";
+ * @import {TextureAtlas} from "./../video/texture/atlas.js";
+ * @import {Vector2d} from "../math/vector2d.ts";
  * @import Renderer from "./../video/renderer.js";
+ * @import {CompressedImage} from "../loader/parsers/compressed_textures/compressed_image.js";
  */
 /**
  * An object to display a fixed or animated sprite on screen.
@@ -143,10 +145,8 @@ export default class Sprite extends Renderable {
      * axe.shininess = 0;
      */
     shininess: number;
-    image: any;
+    image: HTMLVideoElement | import("./../video/texture/texture2d.ts").Texture2dSource | CompressedImage;
     textureAtlas: any;
-    width: any;
-    height: any;
     set animationpause(value: boolean);
     /**
      * pause the frame animation, freezing the current frame.
@@ -374,19 +374,6 @@ export default class Sprite extends Renderable {
      * @returns {number} current animation frame index
      */
     getCurrentAnimationFrame(): number;
-    /**
-     * Prepare the rendering context before drawing this sprite (automatically called by melonJS).
-     * Extends `Renderable.preDraw` to publish this sprite's `normalMap` (if any)
-     * on the renderer so the WebGL lit pipeline can pair it with the next
-     * `drawImage` call. Cleared back in `postDraw`.
-     * @param {Renderer} renderer - a renderer instance
-     */
-    preDraw(renderer: Renderer): void;
-    /**
-     * restore the rendering context after drawing this sprite (automatically called by melonJS).
-     * @param {Renderer} renderer - a renderer instance
-     */
-    postDraw(renderer: Renderer): void;
     /**
      * draw this sprite (automatically called by melonJS)
      * @param {Renderer} renderer - a renderer instance
@@ -394,9 +381,9 @@ export default class Sprite extends Renderable {
     draw(renderer: Renderer): void;
 }
 import Renderable from "./renderable.js";
-import FrameAnimation from "./frameAnimation.js";
-import type { Vector2d } from "../math/vector2d.js";
-import { TextureAtlas } from "./../video/texture/atlas.js";
+import type { Vector2d } from "../math/vector2d.ts";
+import type { TextureAtlas } from "./../video/texture/atlas.js";
+import type { CompressedImage } from "../loader/parsers/compressed_textures/compressed_image.js";
 import type Renderer from "./../video/renderer.js";
 import Texture2d from "./../video/texture/texture2d.ts";
 import { Color } from "../math/color.ts";

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

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

package/build/renderable/sprite3d.d.ts

@@ -96,9 +96,19 @@ export default class Sprite3d extends 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 {number} [settings.shadowScale=1] - multiplier for the ground shadow's footprint; non-positive or non-finite values hide the shadow
+     * @param {number} [settings.shadowOffset=0] - how far to slide the shadow along its direction, in multiples of the blob's own radius; needs the floor named, by `shadowGroundY` or `shadowGroundPoint` (see {@link Mesh#shadowOffset})
+     * @param {number} [settings.shadowStretch=1] - how much longer the blob is along its direction, clamped to 3
+     * @param {number} [settings.shadowDirectionX=0] - x of the ground direction the shadow is cast along
+     * @param {number} [settings.shadowDirectionZ=0] - z of the ground direction the shadow is cast along
+     * @param {number[]|Vector3d} [settings.shadowGroundNormal] - the UP normal of the floor the shadow lands on; needs the floor named, by `shadowGroundY` or `shadowGroundPoint` (see {@link Mesh#shadowGroundNormal})
+     * @param {number[]|Vector3d} [settings.shadowGroundPoint] - the point on the floor the blob lands on, for ground that is not flat; supersedes `shadowGroundY` (see {@link Mesh#shadowGroundPoint})
+     * @param {number[]|Float32Array} [settings.baseColorFactor] - the material's base colour as a LINEAR triple, applied as the tint (see {@link Mesh#baseColorFactor})
+     * @param {Light3d} [settings.shadowLight] - a {@link Light3d} to take that direction from instead
      * @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 {boolean} [settings.depthTest=true] - whether geometry in front of this sprite hides it. `false` draws it over whatever is already there, for a glow or an overlay with no surface to be occluded ON — a flat billboard left depth tested is cut along a hard straight line wherever nearer geometry crosses it. Separate from the depth WRITE the transparent pass turns off on its own. See {@link Mesh#depthTest}.
      * @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: {
@@ -114,16 +124,26 @@ export default class Sprite3d extends Mesh {
         anchorPoint?: string | Vector2d | {
             x: number;
             y: number;
-        };
+        } | undefined;
         flipX?: boolean | undefined;
         flipY?: boolean | undefined;
         lit?: boolean | undefined;
         emissive?: number[] | Float32Array<ArrayBufferLike> | undefined;
         shadowGroundY?: number | undefined;
         shadowOpacity?: number | undefined;
+        shadowScale?: number | undefined;
+        shadowOffset?: number | undefined;
+        shadowStretch?: number | undefined;
+        shadowDirectionX?: number | undefined;
+        shadowDirectionZ?: number | undefined;
+        shadowGroundNormal?: number[] | Vector3d | undefined;
+        shadowGroundPoint?: number[] | Vector3d | undefined;
+        baseColorFactor?: number[] | Float32Array<ArrayBufferLike> | undefined;
+        shadowLight?: any;
         castGroundShadow?: boolean | undefined;
         fog?: boolean | undefined;
         transparent?: boolean | undefined;
+        depthTest?: boolean | undefined;
         alphaCutoff?: number | undefined;
     });
     /**
@@ -142,11 +162,14 @@ export default class Sprite3d extends Mesh {
      *
      * **Only applies under a `Camera3d`**; ignored on the 2D path.
      *
-     * Note: while billboarding, orientation comes from the camera, so the
-     * renderable's `currentTransform` (`rotate()` / `scale()` / parent-container
-     * transforms) and `meshScale` are **not** applied — only `pos` / `depth`,
-     * `flipX` / `flipY`, and the quad's authored size. With billboarding `false`
-     * the standard {@link Mesh} world transform applies as usual.
+     * Note: while billboarding, **orientation** comes from the camera, so an
+     * in-plane `rotate()` has no effect (a card that faces the camera has no
+     * free rotation left to give) — use `billboard: false` and orient the quad
+     * yourself for a streak or an exhaust. Everything that is not an
+     * orientation still applies: `pos` / `depth`, `flipX` / `flipY`, the quad's
+     * authored size, and `scale()` / {@link Mesh#meshScale}, which size the
+     * card in its own plane. With billboarding `false` the standard
+     * {@link Mesh} world transform applies as usual.
      * @type {boolean|string}
      * @default false
      */
@@ -218,14 +241,6 @@ export default class Sprite3d extends Mesh {
      * @returns {Sprite3d} Reference to this object for method chaining
      */
     flipY(flip?: boolean): Sprite3d;
-    /**
-     * @returns {boolean} true if the sprite is mirrored horizontally.
-     */
-    isFlippedX(): boolean;
-    /**
-     * @returns {boolean} true if the sprite is mirrored vertically.
-     */
-    isFlippedY(): boolean;
     /**
      * Play (and optionally switch to) an animation, identical to {@link Sprite#play}.
      * @param {string} [name] - animation id to play; omit to resume
@@ -270,7 +285,7 @@ export default class Sprite3d extends Mesh {
     getCurrentAnimationFrame(): number;
 }
 import Mesh from "./mesh.js";
-import FrameAnimation from "./frameAnimation.js";
-import Camera3d from "../camera/camera3d.ts";
 import Texture2d from "../video/texture/texture2d.ts";
+import type { Vector2d } from "../math/vector2d.ts";
+import { Vector3d } from "../math/vector3d.ts";
 //# sourceMappingURL=sprite3d.d.ts.map

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

@@ -1,3 +1,12 @@
+/**
+ * additional import for TypeScript
+ * @import CanvasRenderer from "../../video/canvas/canvas_renderer.js";
+ * @import {Vector2d} from "../../math/vector2d.ts";
+ * @import WebGLRenderer from "../../video/webgl/webgl_renderer.js";
+ * @import {Bounds} from "../../physics/bounds.ts";
+ * @import Renderer from "../../video/renderer.js";
+ * @import {GlyphEffect, GlyphEffectContext, GlyphEffectOutput} from "./glypheffect.ts";
+ */
 /**
  * a bitmap font object.
  *
@@ -22,6 +31,7 @@ export default class BitmapText 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 pixel for a single segment of text
+     * @param {GlyphEffect|null} [settings.glyphEffect=null] - a per-glyph offset and tint callback
      * @param {(string|string[])} [settings.text] - a string, or an array of strings
      * @example
      * // Load the BMFont descriptor as a "binary" asset and its page as an "image".
@@ -51,8 +61,9 @@ export default class BitmapText extends Renderable {
         anchorPoint?: string | Vector2d | {
             x: number;
             y: number;
-        };
+        } | undefined;
         wordWrapWidth?: number | undefined;
+        glyphEffect?: GlyphEffect | null | undefined;
         text?: string | string[] | undefined;
     });
     /**
@@ -128,6 +139,61 @@ export default class BitmapText extends Renderable {
      */
     public get fillStyle(): Color;
     metrics: TextMetrics;
+    set glyphEffect(effect: GlyphEffect | null);
+    /**
+     * A per-glyph offset and multiplicative tint callback, or `null` to disable.
+     * The output and context are reused: do not retain them. Offsets start at
+     * zero and tint at opaque white on each call. Time advances through update,
+     * so drawing through multiple cameras does not advance the animation.
+     * Effects change drawing only: metrics, wrapping and bounds stay unchanged.
+     * Keep the measured text in view: effects do not extend the culling bounds.
+     * WebGL and WebGPU retain batching: the tint rides the per-vertex colour,
+     * so a whole animated line is still one draw call. Canvas realizes each
+     * DISTINCT tint as a cached, tinted copy of the entire font page, and that
+     * cache is unbounded for the life of the renderer, so a colour driven by
+     * `ctx.time` costs a font-page canvas per frame there. On Canvas, keep the
+     * palette finite or vary only the offsets.
+     *
+     * While an effect is set the renderable reports itself as changed every
+     * frame, since whether the callback reads `ctx.time` cannot be known.
+     *
+     * Two things decide whether a travelling effect reads as motion. Take the
+     * phase from `ctx.x` rather than `ctx.index`: a per-glyph step advances
+     * the wave as far across a narrow glyph as a wide one, so its wavelength
+     * changes with whatever the line spells. And round the offsets if the
+     * frame is upscaled, since they are applied unchanged and a fractional
+     * destination under nearest sampling makes the glyph's own pixels uneven,
+     * differently each frame.
+     * @type {GlyphEffect|null}
+     * @example
+     * // A wave travelling along the line, four pixels deep, about a 1.3s
+     * // cycle, with a wavelength of roughly ten times the font size.
+     * title.glyphEffect = (out, ctx) => {
+     *     out.offsetY = Math.round(Math.sin(ctx.time * 0.005 + ctx.x * 0.02) * 4);
+     * };
+     *
+     * // One hit, ringing down to nothing. A shake throws each glyph somewhere
+     * // unrelated to its neighbours; a sine would move the line as one body.
+     * // `ctx.time` counts from the moment the effect is ASSIGNED, so attach
+     * // this on the frame the hit lands, not when the label was built.
+     * const angle = (i, tick) => {
+     *     const h = Math.sin(i * 127.1 + tick * 311.7) * 43758.5453;
+     *     return (h - Math.floor(h)) * Math.PI * 2;
+     * };
+     * banner.glyphEffect = (out, ctx) => {
+     *     const left = 1 - ctx.time / 650;
+     *     if (left <= 0) return;               // settled; `out` is already zeroed
+     *     const amp = 3 * left * left;         // decays on the square
+     *     const tick = (ctx.time / 1000) * 24; // a new direction 24 times a second
+     *     const held = Math.floor(tick);
+     *     const k = tick - held;
+     *     const a = angle(ctx.index, held);
+     *     const b = angle(ctx.index, held + 1);
+     *     out.offsetX = Math.round((Math.sin(a) + (Math.sin(b) - Math.sin(a)) * k) * amp);
+     *     out.offsetY = Math.round((Math.cos(a) + (Math.cos(b) - Math.cos(a)) * k) * amp);
+     * };
+     */
+    get glyphEffect(): GlyphEffect | null;
     /**
      * change the font settings
      * @param {string} textAlign - ("left", "center", "right")
@@ -141,6 +207,8 @@ export default class BitmapText extends Renderable {
      * @returns {BitmapText} this object for chaining
      */
     setText(value?: number | string | string[]): BitmapText;
+    /** @inheritdoc */
+    update(dt: any): boolean;
     public set visibleCharacters(value: number);
     /**
      * the number of characters to display (use -1 to show all).
@@ -169,14 +237,14 @@ export default class BitmapText extends Renderable {
      * change the font display size
      * @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
+     * @returns {this} 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;
+    resize(scale: number): this;
     /**
      * measure the given text size in pixels
      * @param {string} [text]
@@ -189,11 +257,14 @@ export default class BitmapText extends Renderable {
     measureText(text?: string): TextMetrics;
     /**
      * draw the bitmap font
-     * @param {CanvasRenderer|WebGLRenderer} renderer - Reference to the destination renderer instance
+     * @param {Renderer} renderer - Reference to the destination renderer instance
      */
-    draw(renderer: CanvasRenderer | WebGLRenderer): void;
+    draw(renderer: Renderer): void;
 }
 import Renderable from "../renderable.js";
 import { Color } from "../../math/color.ts";
 import TextMetrics from "./textmetrics.js";
+import type { GlyphEffect } from "./glypheffect.ts";
+import type Renderer from "../../video/renderer.js";
+import type { Vector2d } from "../../math/vector2d.ts";
 //# sourceMappingURL=bitmaptext.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"bitmaptext.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/bitmaptext.js"],"names":[],"mappings":"AAQA;;;;;;;;GAQG;AACH;;;;;;;;;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,YAAY;QACZ,UAAU;QACmB,WAAW;eAAvC,MAAM;eAAG,MAAM;;QAChB,aAAa;QACH,WAAW;QACV,IAAI;KACzC,EAiJF;IA5HA;;;;;;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;IAsUlE,4BAlBU,KAAK,EAyBd;IAjCD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,wBAfU,KAAK,CAiBd;IAtSA;;;OAGG;IACH,2BAA4B;IAG5B,qBAAoC;IAOpC,wCAAwC;IACxC,qBAAwB;IACxB,eAAe;IACf,yBAAyB;IACzB;;;;OAIG;IACH,0BAAkC;IA8GnC,wBAjCU,WAAW,GAAC,IAAI,EAoDzB;IA5ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDG;IACH,mBA7BU,WAAW,GAAC,IAAI,CA+BzB;IArGD;;;;;OAKG;IACH,eAJW,MAAM,UACN,MAAM,GACJ,UAAU,CAWtB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GACpB,UAAU,CAwBtB;IAgFD,kBAAkB;IAClB,yBAMC;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,IAAI,CAiBhB;IAED;;;;;;;;OAQG;IACH,mBAPW,MAAM,GACJ,WAAW,CAQvB;IAED;;;OAGG;IACH,eAFW,QAAQ,QA6GlB;IAED;;;;;;;;;;OAUG;IACH,yBA0CC;IAED;;;;OAIG;IACH,gBAUC;CACD;uBAxqBsB,kBAAkB;sBAHnB,qBAAqB;wBAKnB,kBAAkB;iCAS2B,kBAAkB;0BAD9D,yBAAyB;8BAHvB,wBAAwB"}

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

@@ -1,4 +1,3 @@
-import Glyph from "./glyph.ts";
 /**
  * a bitmap font data object — parses the AngelCode BMFont format in both its
  * text (`.fnt`) and XML serialisations (the flavour is auto-detected).
@@ -14,11 +13,8 @@ export default class BitmapTextData {
     descent: number;
     glyphMinTop: number;
     glyphMaxBottom: number;
-    glyphs: {
-        [key: number]: Glyph;
-    };
     constructor(data: string);
     parse(fontData: string): void;
 }
-export declare const bitmapTextDataPool: import("../../system/pool.ts").Pool<BitmapTextData, [fontData: string]>;
+export declare const bitmapTextDataPool: import("../../index.ts").Pool<BitmapTextData, [fontData: string]>;
 //# sourceMappingURL=bitmaptextdata.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bitmaptextdata.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/bitmaptextdata.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,YAAY,CAAC;AAiF/B;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,cAAc;IAClC,MAAM,EAAE,MAAM,CAAK;IACnB,QAAQ,EAAE,MAAM,CAAK;IACrB,SAAS,EAAE,MAAM,CAAK;IACtB,OAAO,EAAE,MAAM,CAAK;IACpB,UAAU,EAAE,MAAM,CAAK;IACvB,SAAS,EAAE,MAAM,CAAK;IACtB,OAAO,EAAE,MAAM,CAAK;IACpB,WAAW,EAAE,MAAM,CAAK;IACxB,cAAc,EAAE,MAAM,CAAK;IAC3B,MAAM,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAA;KAAE,CAAM;gBAE1B,IAAI,EAAE,MAAM;IAIxB,KAAK,CAAC,QAAQ,EAAE,MAAM;CAkMtB;AAED,eAAO,MAAM,kBAAkB,yEAY7B,CAAC"}
+{"version":3,"file":"bitmaptextdata.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/bitmaptextdata.ts"],"names":[],"mappings":"AAkFA;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,cAAc;IAClC,MAAM,EAAE,MAAM,CAAK;IACnB,QAAQ,EAAE,MAAM,CAAK;IACrB,SAAS,EAAE,MAAM,CAAK;IACtB,OAAO,EAAE,MAAM,CAAK;IACpB,UAAU,EAAE,MAAM,CAAK;IACvB,SAAS,EAAE,MAAM,CAAK;IACtB,OAAO,EAAE,MAAM,CAAK;IACpB,WAAW,EAAE,MAAM,CAAK;IACxB,cAAc,EAAE,MAAM,CAAK;gBAYf,IAAI,EAAE,MAAM;IAIxB,KAAK,CAAC,QAAQ,EAAE,MAAM;CAkMtB;AAED,eAAO,MAAM,kBAAkB,mEAY7B,CAAC"}