melonjs 20.7.0 → 20.9.0

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

@@ -0,0 +1,44 @@
+import type { Color } from "../../math/color.ts";
+/** Mutable per-glyph output, reset before each call. Do not retain it. */
+export interface GlyphEffectOutput {
+    /**
+     * Horizontal offset in drawing pixels, after font scaling.
+     *
+     * Added to the glyph's destination as given, with no rounding. On an
+     * upscaled low-resolution frame, round it: a fractional destination under
+     * nearest sampling makes the glyph's own pixels come out uneven, and
+     * differently so each frame, which reads as a shimmer rather than motion.
+     */
+    offsetX: number;
+    /**
+     * Vertical offset in drawing pixels, after font scaling. Rounds like
+     * {@link GlyphEffectOutput.offsetX}.
+     */
+    offsetY: number;
+    /** Multiplicative tint; reset to opaque white before each call. */
+    readonly tint: Color;
+}
+/** Reused per-glyph context. Read its values during the callback only. */
+export interface GlyphEffectContext {
+    /** UTF-16 character index across drawn lines, excluding line breaks. */
+    index: number;
+    /** The UTF-16 character represented by this glyph. */
+    char: string;
+    /** The BMFont character code. */
+    code: number;
+    /** Elapsed update time in milliseconds while the effect is enabled. */
+    time: number;
+    /**
+     * Unmodified glyph destination coordinates, after alignment and scaling.
+     *
+     * The natural phase source for a travelling effect: deriving it from
+     * {@link GlyphEffectContext.index} instead advances the wave as far across
+     * a narrow glyph as a wide one, so its wavelength changes with whatever
+     * the line spells.
+     */
+    x: number;
+    y: number;
+}
+/** Modify the reused output to offset or tint a BitmapText glyph. */
+export type GlyphEffect = (out: GlyphEffectOutput, context: GlyphEffectContext) => void;
+//# sourceMappingURL=glypheffect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"glypheffect.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/glypheffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,0EAA0E;AAC1E,MAAM,WAAW,iBAAiB;IACjC;;;;;;;OAOG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;CACrB;AAED,0EAA0E;AAC1E,MAAM,WAAW,kBAAkB;IAClC,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;OAOG;IACH,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,qEAAqE;AACrE,MAAM,MAAM,WAAW,GAAG,CACzB,GAAG,EAAE,iBAAiB,EACtB,OAAO,EAAE,kBAAkB,KACvB,IAAI,CAAC"}

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

@@ -89,7 +89,7 @@ export default class Text extends Renderable {
         anchorPoint?: string | Vector2d | {
             x: number;
             y: number;
-        };
+        } | undefined;
         wordWrapWidth?: number | undefined;
         bold?: boolean | undefined;
         italic?: boolean | undefined;
@@ -257,13 +257,32 @@ export default class Text extends Renderable {
     measureText(text?: string): TextMetrics;
     /**
      * draw a text at the specified coord
-     * @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;
 }
+/**
+ * A pool of reusable {@link Text} instances.
+ *
+ * Text is worth recycling: each one owns a canvas-backed measurement cache and
+ * a colour, so a scene that spawns damage numbers or score popups churns
+ * meaningfully without one. Reachable as `getPool("text")`.
+ *
+ * `release` it yourself when the text is finished, as the particle and tween
+ * pools require. A label this pool built is the exception: it carries the pool
+ * it came from, so removing it from a container releases it back rather than
+ * destroying it. Pass `keepalive` to `removeChild()` to keep holding one.
+ * @example
+ * const label = getPool("text").get(x, y, { font: "Arial", size: 12, text: "+10" });
+ * // ... later
+ * getPool("text").release(label);
+ */
+export const textPool: import("../../index.ts").Pool<Text, [x: unknown, y: unknown, settings: unknown]>;
 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";
+import type Renderer from "../../video/renderer.js";
+import type { Vector2d } from "../../math/vector2d.ts";
 //# sourceMappingURL=text.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/text.js"],"names":[],"mappings":"AAwCA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6DG;IACH,eA7DW,MAAM,KACN,MAAM,YAEd;QAAyB,IAAI,EAArB,MAAM;QACkB,IAAI,EAA5B,MAAM,GAAC,MAAM;QACoB,SAAS;QACvB,eAAe;QACV,WAAW;QACjB,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;QACZ,IAAI;QACJ,MAAM;QACI,IAAI;KACzC,EAsHF;IAtEA;;;;OAIG;IACH,WAHU,KAAK,CAGwB;IAEvC;;;;OAIG;IACH,aAHU,KAAK,CAG0B;IAEzC;;;;OAIG;IACH,WAHU,MAAM,CAGE;IAElB;;;;;OAKG;IACH,WAHU,MAAM,CAGO;IAEvB;;;;;OAKG;IACH,cAHU,MAAM,CAGS;IAEzB;;;;;OAKG;IACH,YAHU,MAAM,CAGK;IAErB;;;;;OAKG;IACH,eAHU,MAAM,CAGO;IAEvB;;;;OAIG;IACH,UAHU,MAAM,CAGE;IAElB;;;;;OAKG;IACH,cAAe;IAMhB;;;OAGG;IACH,kDAgIC;IA3HA;;;;;;;;;;;;;;;;OAgBG;IACH,cARU,QAAQ,GAAC,SAAS,CAQC;IAE7B;;;;;;;;;;;;;;OAcG;IACH,qCAA2B;IA0E3B,8CAEE;IAEF;;;OAGG;IACH,wBAA4B;IAG5B,iCAAoC;IAMrC;;;OAGG;IACH,QAFa,IAAI,CAWhB;IAJC,UAA+B;IAMjC;;;OAGG;IACH,UAFa,IAAI,CAWhB;IAED;;;;;;;;OAQG;IACH,cAPW,MAAM,SACN,MAAM,GAAC,MAAM,GACX,IAAI,CAwChB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GACpB,IAAI,CAkFhB;IAkBD,oCAZU,MAAM,EAiBf;IArBD;;;;;;;;;;;OAWG;IACH,gCARU,MAAM,CAUf;IAkCD,+BAlBU,MAAM,EA4Bf;IAnCD;;;;;;;;;;;;;;OAcG;IACH,2BARU,MAAM,CAgBf;IAiED;;;;;;;;;;;;OAYG;IACH,mBAXW,MAAM,GACJ,WAAW,CAYvB;IAED;;;OAGG;IACH,eAFW,cAAc,GAAC,aAAa,QA0CtC;IAED;;;OAGG;IACH,4EA+GC;IAED;;;;OAIG;IACH,gBAWC;CACD;uBAzxBsB,kBAAkB;sBALR,qBAAqB;yBAC7B,yBAAyB;+BAEnB,gDAAgD;wBAGvD,kBAAkB"}
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/text.js"],"names":[],"mappings":"AAiDA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6DG;IACH,eA7DW,MAAM,KACN,MAAM,YAEd;QAAyB,IAAI,EAArB,MAAM;QACkB,IAAI,EAA5B,MAAM,GAAC,MAAM;QACoB,SAAS;QACvB,eAAe;QACV,WAAW;QACjB,SAAS;QACT,SAAS;QACT,YAAY;QACZ,UAAU;QACmB,WAAW;eAAvC,MAAM;eAAG,MAAM;;QAChB,aAAa;QACZ,IAAI;QACJ,MAAM;QACI,IAAI;KACzC,EAsHF;IAtEA;;;;OAIG;IACH,WAHU,KAAK,CAGwB;IAEvC;;;;OAIG;IACH,aAHU,KAAK,CAG0B;IAEzC;;;;OAIG;IACH,WAHU,MAAM,CAGE;IAElB;;;;;OAKG;IACH,WAHU,MAAM,CAGO;IAEvB;;;;;OAKG;IACH,cAHU,MAAM,CAGS;IAEzB;;;;;OAKG;IACH,YAHU,MAAM,CAGK;IAErB;;;;;OAKG;IACH,eAHU,MAAM,CAGO;IAEvB;;;;OAIG;IACH,UAHU,MAAM,CAGE;IAElB;;;;;OAKG;IACH,cAAe;IAMhB;;;OAGG;IACH,kDA8KC;IAjJA;;;;;;;;;;;;;;;;OAgBG;IACH,cARU,QAAQ,GAAC,SAAS,CAQC;IAE7B;;;;;;;;;;;;;;OAcG;IACH,qCAA2B;IA4F1B,8CAEE;IAGH;;;OAGG;IACH,wBAA4B;IAK3B,iCAAoC;IAOtC;;;OAGG;IACH,QAFa,IAAI,CAWhB;IAJC,UAA+B;IAMjC;;;OAGG;IACH,UAFa,IAAI,CAWhB;IAED;;;;;;;;OAQG;IACH,cAPW,MAAM,SACN,MAAM,GAAC,MAAM,GACX,IAAI,CAwChB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GACpB,IAAI,CAkFhB;IAkBD,oCAZU,MAAM,EAiBf;IArBD;;;;;;;;;;;OAWG;IACH,gCARU,MAAM,CAUf;IAkCD,+BAlBU,MAAM,EA4Bf;IAnCD;;;;;;;;;;;;;;OAcG;IACH,2BARU,MAAM,CAgBf;IAiED;;;;;;;;;;;;OAYG;IACH,mBAXW,MAAM,GACJ,WAAW,CAYvB;IAED;;;OAGG;IACH,eAFW,QAAQ,QA0ClB;IAED;;;OAGG;IACH,4EA+GC;IAED;;;;OAIG;IACH,gBAWC;CACD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wGAQG;uBAz2B8C,kBAAkB;sBANlC,qBAAqB;yBAE7B,yBAAyB;+BAEnB,gDAAgD;wBAGvD,kBAAkB;0BASjB,yBAAyB;8BAHvB,wBAAwB"}

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

@@ -46,5 +46,7 @@ declare class TextMetrics extends Bounds {
     wordWrap(text: string | string[], width: number, context?: CanvasRenderingContext2D): string[];
 }
 import { Bounds } from "../../physics/bounds.ts";
+import type Renderable from "../renderable.js";
 import Text from "./text.js";
+import type BitmapText from "./bitmaptext.js";
 //# sourceMappingURL=textmetrics.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"textmetrics.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/textmetrics.js"],"names":[],"mappings":";AA0BA;;GAEG;AACH;IACC;;OAEG;IACH,sBAFW,IAAI,GAAC,UAAU,EAczB;IARA;;;;OAIG;IACH,UAHU,UAAU,CAGI;IAKzB;;;OAGG;IACH,cAFa,MAAM,CAalB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,YACN,wBAAwB,GACtB,MAAM,CA4BlB;IAED;;;;;OAKG;IACH,kBAJW,MAAM,YACN,wBAAwB,GACtB,WAAW,CAiHvB;IA/EA,iCAAqB;IACrB,mCAAuB;IAmCvB,8BAAkB;IAClB,iCAAqB;IA4CtB;;;;;;;;;;;;;;;OAeG;IACH,gBAJa,WAAW,CAoBvB;IAED;;;;;;OAMG;IACH,eALW,MAAM,GAAC,MAAM,EAAE,SACf,MAAM,YACN,wBAAwB,GACtB,MAAM,EAAE,CAyCpB;CACD;uBA1SsB,yBAAyB;iBAC/B,WAAW"}
+{"version":3,"file":"textmetrics.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/textmetrics.js"],"names":[],"mappings":";AA+BA;;GAEG;AACH;IACC;;OAEG;IACH,sBAFW,IAAI,GAAC,UAAU,EAczB;IARA;;;;OAIG;IACH,UAHU,UAAU,CAGI;IAKzB;;;OAGG;IACH,cAFa,MAAM,CAalB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,YACN,wBAAwB,GACtB,MAAM,CA4BlB;IAED;;;;;OAKG;IACH,kBAJW,MAAM,YACN,wBAAwB,GACtB,WAAW,CAiHvB;IA/EA,iCAAqB;IACrB,mCAAuB;IAmCvB,8BAAkB;IAClB,iCAAqB;IA4CtB;;;;;;;;;;;;;;;OAeG;IACH,gBAJa,WAAW,CAoBvB;IAED;;;;;;OAMG;IACH,eALW,MAAM,GAAC,MAAM,EAAE,SACf,MAAM,YACN,wBAAwB,GACtB,MAAM,EAAE,CAyCpB;CACD;uBA/SsB,yBAAyB;4BAOrB,kBAAkB;iBAN5B,WAAW;4BAKD,iBAAiB"}

package/build/renderable/trail.d.ts

@@ -86,6 +86,5 @@ export default class Trail extends Renderable {
 }
 import Renderable from "./renderable.js";
 import type { Vector2d } from "../math/vector2d.ts";
-import { Gradient } from "../video/gradient.js";
 import type { Color } from "../math/color.ts";
 //# sourceMappingURL=trail.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"trail.d.ts","sourceRoot":"","sources":["../../src/renderable/trail.js"],"names":[],"mappings":"AAMA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IACC;;;;;;;;;;;;OAYG;IACH,sBAXG;QAAsC,MAAM;QACnB,MAAM;QACN,QAAQ;QACR,WAAW;QACX,KAAK;QACH,UAAU;QACN,KAAK;QACkC,QAAQ;iBAAlD,MAAM;mBAAS,KAAK,GAAC,MAAM;;QAC9B,OAAO;QACP,SAAS;KACpC,EAuDA;IAnDA,uCAAuC;IACvC,QADW,UAAU,GAAC,QAAQ,GAAC,IAAI,CACC;IACpC,qBAAqB;IACrB,WADW,MAAM,CACoB;IACrC,qBAAqB;IACrB,UADW,MAAM,CACsB;IACvC,qBAAqB;IACrB,aADW,MAAM,CAC0B;IAG3C,uBAAuB;IACvB,YADW,MAAM,EAAE,CAIT;IAEV;;;OAGG;IACH,oBAA6C;IAC7C;;;OAGG;IACH,eAAiB;IACjB;;;OAGG;IACH,qBAAoC;IACpC;;;OAGG;IACH;;;MAAyB;IACzB;;;OAGG;IACH;;;MAAyB;IAa1B;;;;OAIG;IACH,YAHW,MAAM,KACN,MAAM,QAehB;IAED;;;OAGG;IACH,yBAsBC;IAED;;;OAGG;IACH,0BAiDC;IAED,6BAA6B;IAC7B,cAEC;IAED;;;;;;OAMG;IACH,wBALW,MAAM,GACJ,QAAQ,CAiCpB;IAED;;;OAGG;IACH,gBAMC;CACD;uBA5QsB,iBAAiB;8BAIb,qBAAqB;yBALvB,sBAAsB;2BAIvB,kBAAkB"}
+{"version":3,"file":"trail.d.ts","sourceRoot":"","sources":["../../src/renderable/trail.js"],"names":[],"mappings":"AAMA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IACC;;;;;;;;;;;;OAYG;IACH,sBAXG;QAAsC,MAAM;QACnB,MAAM;QACN,QAAQ;QACR,WAAW;QACX,KAAK;QACH,UAAU;QACN,KAAK;QACkC,QAAQ;iBAAlD,MAAM;mBAAS,KAAK,GAAC,MAAM;;QAC9B,OAAO;QACP,SAAS;KACpC,EA6DA;IAzDA,uCAAuC;IACvC,QADW,UAAU,GAAC,QAAQ,GAAC,IAAI,CACC;IACpC,qBAAqB;IACrB,WADW,MAAM,CACoB;IACrC,qBAAqB;IACrB,UADW,MAAM,CACsB;IACvC,qBAAqB;IACrB,aADW,MAAM,CAC0B;IAG3C,uBAAuB;IACvB,YADW,MAAM,EAAE,CAIT;IAYV,kBAA6C;IAC7C;;;OAGG;IACH,eAAiB;IACjB;;;OAGG;IACH,qBAAoC;IACpC;;;OAGG;IACH;;;MAAyB;IACzB;;;OAGG;IACH;;;MAAyB;IAa1B;;;;OAIG;IACH,YAHW,MAAM,KACN,MAAM,QAehB;IAED;;;OAGG;IACH,yBAsBC;IAED;;;OAGG;IACH,0BAiDC;IAED,6BAA6B;IAC7B,cAEC;IAED;;;;;;OAMG;IACH,wBALW,MAAM,GACJ,MAAM,CAOlB;IAED;;;OAGG;IACH,gBAMC;CACD;uBAxPsB,iBAAiB;8BAIb,qBAAqB;2BADxB,kBAAkB"}

package/build/renderable/trail3d.d.ts

@@ -0,0 +1,174 @@
+/**
+ * A fading, tapering ribbon that recedes properly into a 3D scene.
+ *
+ * The 3D sibling of {@link Trail}, and a separate class for the same reason
+ * {@link Sprite3d} is separate from {@link Sprite}: the two draw through
+ * different tiers. A `Trail` emits its ribbon as 2D paths, which carry one
+ * depth for the whole renderable and a width measured in the screen plane, so
+ * it cannot narrow along its own length or lie on a surface. This one builds
+ * a real camera-facing strip and hands it to the mesh pipeline.
+ *
+ * It is a {@link Mesh}, so everything a mesh can do it can do: a post effect
+ * reaches it, `tint` multiplies it, it sorts into the transparent pass, and
+ * fog applies. It is also **cheaper to draw than a 2D trail** — one indexed
+ * draw call rather than one filled path per segment.
+ *
+ * Needs a {@link Camera3d}. Under a 2D camera it draws nothing and says so
+ * once, because the alternative is geometry projected twice.
+ * @augments Mesh
+ * @category Game Objects
+ * @example
+ * // an exhaust streak behind a craft
+ * const exhaust = new Trail3d(0, 0, {
+ *     target: ship,
+ *     width: 6,
+ *     lifetime: 260,
+ *     gradient: ["#eaffff", "#2ea8ff", "#2ea8ff00"],
+ * });
+ * exhaust.blendMode = "additive";
+ * app.world.addChild(exhaust);
+ * @example
+ * // a tyre mark lying in the ground plane: not camera-facing, so it keeps
+ * // the orientation it is given
+ * const skid = new Trail3d(0, 0, {
+ *     target: car,
+ *     width: 12,
+ *     billboard: false,
+ *     ribbonNormal: [0, -1, 0],   // world up
+ *     color: "#1a1a1a",
+ * });
+ * @example
+ * // manual mode, for a path the game computes itself
+ * const arc = new Trail3d(0, 0, { width: 4, lifetime: 400 });
+ * app.world.addChild(arc);
+ * // each frame while the spell travels
+ * arc.addPoint(bolt.pos.x, bolt.pos.y, bolt.pos.z);
+ * @see {@link Trail} for the 2D one
+ */
+export default class Trail3d extends Mesh {
+    /**
+     * @param {number} x - the ribbon's initial anchor, world units. Only seeds
+     * the cull bounds: once there are points, the anchor follows them.
+     * @param {number} y - as `x`
+     * @param {object} [settings] - trail options
+     * @param {Renderable|Vector3d} [settings.target] - auto-follow target
+     * @param {number} [settings.length=20] - max number of points. **Fixed at
+     * construction**: the geometry is sized once, so this cannot grow later,
+     * and assigning {@link Trail3d#maxPoints} throws. A fractional value is
+     * truncated.
+     * @param {number} [settings.lifetime=500] - point lifetime in ms
+     * @param {number} [settings.minDistance=4] - min world distance between samples
+     * @param {number} [settings.width=10] - max ribbon width in world units
+     * @param {number[]} [settings.widthCurve=[1, 0]] - width multiplier curve (0=head, 1=tail)
+     * @param {Color|string} [settings.color="#ffffff"] - single colour, faded out along the ribbon. Ignored if `gradient` is set.
+     * @param {(Color|string|{pos: number, color: Color|string})[]} [settings.gradient] - colour gradient. Overrides `color`.
+     * @param {boolean|string} [settings.billboard="spherical"] - `false` (use `ribbonNormal`), `true` / `"cylindrical"` (faces the camera but stays upright), or `"spherical"` (faces the camera on all axes)
+     * @param {Vector3d|number[]} [settings.ribbonNormal] - the facing used when `billboard` is `false`; defaults to world up
+     * @param {number} [settings.opacity=1.0] - opacity (0.0–1.0)
+     * @param {string} [settings.blendMode="normal"] - blend mode
+     * @param {boolean} [settings.depthTest=true] - whether the ribbon is depth tested
+     * @throws {Error} when `length` is not a finite number. Silence there is
+     * worse than it sounds: `NaN` sizes every buffer to zero and makes the
+     * capacity test always false, so the ribbon never renders and the point
+     * list grows without bound.
+     */
+    constructor(x: number, y: number, settings?: {
+        target?: Vector3d | Renderable | undefined;
+        length?: number | undefined;
+        lifetime?: number | undefined;
+        minDistance?: number | undefined;
+        width?: number | undefined;
+        widthCurve?: number[] | undefined;
+        color?: string | Color | undefined;
+        gradient?: (string | Color | {
+            pos: number;
+            color: Color | string;
+        })[] | undefined;
+        billboard?: string | boolean | undefined;
+        ribbonNormal?: number[] | Vector3d | undefined;
+        opacity?: number | undefined;
+        blendMode?: string | undefined;
+        depthTest?: boolean | undefined;
+    });
+    /**
+     * what the ribbon follows, sampled once per update
+     * @type {Renderable|Vector3d|null}
+     */
+    target: Renderable | Vector3d | null;
+    /** @type {number} */
+    lifetime: number;
+    /** @type {number} */
+    minDistance: number;
+    /** @type {number[]} */
+    widthCurve: number[];
+    billboard: string | boolean;
+    set ribbonNormal(value: Vector3d);
+    /**
+     * The facing used when {@link Trail3d#billboard} is `false`.
+     *
+     * Accepts a {@link Vector3d} or a `[x, y, z]` array and holds a normalized
+     * copy, so a caller that keeps mutating the array it passed is not
+     * steering this ribbon by accident. A zero-length value falls back to
+     * world up rather than dividing by it.
+     * @type {Vector3d}
+     * @default (0, -1, 0)
+     */
+    get ribbonNormal(): Vector3d;
+    castGroundShadow: boolean;
+    set maxPoints(_value: number);
+    /**
+     * How many points the ribbon can hold.
+     *
+     * Read-only: see the note on `settings.length`. Assigning throws rather
+     * than silently doing nothing, because the alternative is a ribbon that
+     * quietly keeps its old capacity.
+     * @type {number}
+     */
+    get maxPoints(): number;
+    /**
+     * Recolour the ribbon with a single colour, faded out along its length.
+     *
+     * A method rather than a setter, matching {@link Renderable#setTint} and
+     * {@link Renderable#setOpacity}: it allocates a gradient, so it is for a
+     * change of state rather than for every frame. {@link Renderable#tint} is
+     * the per-frame lever, and unlike on {@link Trail} it works here, because
+     * the mesh batcher multiplies it in.
+     * @param {Color|string} value - the colour
+     * @returns {Trail3d} this, for chaining
+     */
+    setColor(value: Color | string): Trail3d;
+    /**
+     * Recolour the ribbon with a gradient, in the format the constructor takes.
+     * @param {(Color|string|{pos: number, color: Color|string})[]} value - the stops
+     * @returns {Trail3d} this, for chaining
+     */
+    setGradient(value: (Color | string | {
+        pos: number;
+        color: Color | string;
+    })[]): Trail3d;
+    /**
+     * The gradient the ribbon is currently coloured by.
+     * @type {Gradient}
+     * @see {@link Trail3d#setGradient}
+     */
+    get gradient(): Gradient;
+    /**
+     * Add a point to the ribbon.
+     *
+     * Ignored when it is closer than {@link Trail3d#minDistance} to the last
+     * one, measured in three dimensions — which is what stops a ribbon flying
+     * straight at the camera from never sampling a second point.
+     * @param {number} x - x position, world units
+     * @param {number} y - y position, world units
+     * @param {number} [z=0] - z position, world units
+     */
+    addPoint(x: number, y: number, z?: number): void;
+    /** drop every point, leaving the ribbon empty */
+    clear(): void;
+}
+import Mesh from "./mesh.js";
+import type Renderable from "./renderable.js";
+import { Vector3d } from "../math/vector3d.ts";
+import type { Gradient } from "../video/gradient.js";
+import type { Color } from "../math/color.ts";
+//# sourceMappingURL=trail3d.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trail3d.d.ts","sourceRoot":"","sources":["../../src/renderable/trail3d.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,eAzBW,MAAM,KAEN,MAAM,aAEd;QAAuC,MAAM;QACnB,MAAM;QAIN,QAAQ;QACR,WAAW;QACX,KAAK;QACH,UAAU;QACN,KAAK;QACkC,QAAQ;iBAAnD,MAAM;mBAAS,KAAK,GAAC,MAAM;;QACrB,SAAS;QACN,YAAY;QACvB,OAAO;QACP,SAAS;QACR,SAAS;KACpC,EA+HF;IA1EA;;;OAGG;IACH,QAFU,UAAU,GAAC,QAAQ,GAAC,IAAI,CAEG;IACrC,qBAAqB;IACrB,UADW,MAAM,CACuB;IACxC,qBAAqB;IACrB,aADW,MAAM,CAC2B;IAG5C,uBAAuB;IACvB,YADW,MAAM,EAAE,CAIT;IAEV;;;OAGG;IACH,mBAAwB;IACxB;;;;;;;OAOG;IACH,eAAiB;IACjB,wBAAwB;IACxB,oBAA8C;IAC9C,wBAAwB;IACxB,qBAAoC;IACpC,6DAA6D;IAC7D,kCAA0C;IAC1C,wBAAwB;IACxB,wBAAqE;IACrE;;;;;;;;;;;OAWG;IACH,iBAAiB;IACjB,wBAAwB;IACxB,iBAAiB;IAEjB,4BAAkD;IAqDnD,wBAPU,QAAQ,EAiBjB;IAxBD;;;;;;;;;OASG;IACH,oBAHU,QAAQ,CAKjB;IAzCA,0BAA6B;IAuB9B,sBANU,MAAM,EAUf;IAhBD;;;;;;;OAOG;IACH,iBAFU,MAAM,CAIf;IAkCD;;;;;;;;;;OAUG;IACH,gBAHW,KAAK,GAAC,MAAM,GACV,OAAO,CAQnB;IAED;;;;OAIG;IACH,mBAHW,CAAC,KAAK,GAAC,MAAM,GAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,GAAC,MAAM,CAAA;KAAC,CAAC,EAAE,GACjD,OAAO,CAMnB;IAED;;;;OAIG;IACH,gBAHU,QAAQ,CAKjB;IAED;;;;;;;;;OASG;IACH,YAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;IAED,iDAAiD;IACjD,cAEC;IAuCD;;;;;;;;;;;;;;;OAeG;IACH,sBA2DC;IAED;;;;;;;;;;;;;;OAcG;IACH,wBALW,OAAO,GACL,MAAM,CAuBlB;IAED;;;;;;OAMG;IACH,eALW,QAAQ,aACR,QAAQ,QA6BlB;IAED;;;;;OAKG;IACH,sBAJW,QAAQ,QA2FlB;IAED;;;;;;;OAOG;IACH,kBAJa,MAAM,GAAC,IAAI,CAsCvB;IAwBD;;;;;;;OAOG;IACH,uBAJa,MAAM,CAwBlB;CAmBD;iBA/tBgB,WAAW;4BAMD,iBAAiB;yBATnB,qBAAqB;8BAQnB,sBAAsB;2BADzB,kBAAkB;0BAGjB,sBAAsB;qBAb1B,uBAAuB"}

package/build/renderable/trigger.d.ts

@@ -22,6 +22,14 @@ export default class Trigger extends Renderable {
      * @param {number} [settings.lightIntensityScale] - Scale the glTF lights' authored intensity. See {@link level.load}
      * @param {boolean} [settings.castGroundShadow] - Enable ground shadows for glTF meshes. See {@link level.load}
      * @param {number} [settings.shadowGroundY] - World Y for glTF ground shadows. See {@link level.load}
+     * @param {number} [settings.shadowOpacity] - How dark those blobs are. See {@link level.load}
+     * @param {number} [settings.shadowScale] - Blob footprint multiplier. See {@link level.load}
+     * @param {number} [settings.shadowOffset] - Slide them along the light, in blob radii. See {@link level.load}
+     * @param {number} [settings.shadowStretch] - Lengthen them along it. See {@link level.load}
+     * @param {number} [settings.shadowDirectionX] - X of the ground direction they are cast along. See {@link level.load}
+     * @param {number} [settings.shadowDirectionZ] - Z of that direction. See {@link level.load}
+     * @param {number[]|Vector3d} [settings.shadowGroundNormal] - Up normal of the floor, for a scene that is not level. See {@link level.load}
+     * @param {Light3d} [settings.shadowLight] - A light to take the shadow direction from. See {@link level.load}
      * @example
      * // fade transition (default)
      * world.addChild(new Trigger(x, y, {
@@ -59,12 +67,12 @@ export default class Trigger extends Renderable {
         height?: number | undefined;
         shapes?: Rect[] | Polygon[] | Line[] | Ellipse[] | undefined;
         duration?: number | undefined;
-        color?: string | Color;
+        color?: string | Color | undefined;
         transition?: string | undefined;
-        shape?: Ellipse | Polygon;
+        shape?: Polygon | Ellipse | undefined;
         event?: string | undefined;
         to?: string | undefined;
-        container?: string | Container;
+        container?: string | Container | undefined;
         onLoaded?: Function | undefined;
         flatten?: boolean | undefined;
         setViewportBounds?: boolean | undefined;
@@ -74,11 +82,19 @@ export default class Trigger extends Renderable {
         lightIntensityScale?: number | undefined;
         castGroundShadow?: boolean | 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;
+        shadowLight?: any;
     });
     color: any;
     duration: number | undefined;
     transition: string;
-    transitionShape: any;
+    transitionShape: Polygon | Ellipse | undefined;
     fading: boolean;
     type: any;
     id: any;
@@ -88,7 +104,7 @@ export default class Trigger extends Renderable {
     };
     bodyDef: {
         type: string;
-        shapes: Rect[];
+        shapes: undefined[] | Polygon[] | Ellipse[];
         collisionType: number;
         collisionMask: number;
         isSensor: boolean;
@@ -107,4 +123,11 @@ export default class Trigger extends Renderable {
     onCollisionStart(): void;
 }
 import Renderable from "./renderable.js";
+import type { Polygon } from "../geometries/polygon.ts";
+import type { Ellipse } from "../geometries/ellipse.ts";
+import type { Rect } from "../geometries/rectangle.ts";
+import type { Line } from "../geometries/line.ts";
+import type { Color } from "../math/color.ts";
+import type Container from "./container.js";
+import type { Vector3d } from "../math/vector3d.ts";
 //# sourceMappingURL=trigger.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"trigger.d.ts","sourceRoot":"","sources":["../../src/renderable/trigger.js"],"names":[],"mappings":"AA2DA;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsDG;IACH,eAtDW,MAAM,KACN,MAAM,YAEd;QAA0B,KAAK;QACL,MAAM;QACqB,MAAM;QACjC,QAAQ;QACF,KAAK,GAA7B,MAAM,GAAC,KAAK;QACM,UAAU;QACD,KAAK,GAAhC,OAAO,GAAC,OAAO;QACG,KAAK;QACL,EAAE;QACQ,SAAS,GAArC,MAAM,GAAC,SAAS;QACI,QAAQ;QACT,OAAO;QACP,iBAAiB;QAClB,KAAK;QACJ,WAAW;QACX,MAAM;QACP,mBAAmB;QAClB,gBAAgB;QACjB,aAAa;KACvC,EAyFF;IApDA,WAA4C;IAC5C,6BAAiC;IACjC,mBAA+C;IAC/C,qBAAqC;IACrC,gBAAmB;IAInB,UAAyB;IACzB,QAAqB;IACrB,8BAA4B;IAG5B;;MAEC;IAwBD;;;;;;MAMC;IASF;;;OAGG;IACH;;MAQC;IAED;;;OAGG;IACH,+BAwFC;IAED;;;;;OAKG;IACH,yBAIC;CACD;uBA7RsB,iBAAiB"}
+{"version":3,"file":"trigger.d.ts","sourceRoot":"","sources":["../../src/renderable/trigger.js"],"names":[],"mappings":"AAkEA;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8DG;IACH,eA9DW,MAAM,KACN,MAAM,YAEd;QAA0B,KAAK;QACL,MAAM;QACqB,MAAM;QACjC,QAAQ;QACF,KAAK;QACX,UAAU;QACD,KAAK;QACd,KAAK;QACL,EAAE;QACQ,SAAS;QACjB,QAAQ;QACT,OAAO;QACP,iBAAiB;QAClB,KAAK;QACJ,WAAW;QACX,MAAM;QACP,mBAAmB;QAClB,gBAAgB;QACjB,aAAa;QACb,aAAa;QACb,WAAW;QACX,YAAY;QACZ,aAAa;QACb,gBAAgB;QAChB,gBAAgB;QACL,kBAAkB;QAC5B,WAAW;KACtC,EAyFF;IApDA,WAA4C;IAC5C,6BAAiC;IACjC,mBAA+C;IAC/C,+CAAqC;IACrC,gBAAmB;IAInB,UAAyB;IACzB,QAAqB;IACrB,8BAA4B;IAG5B;;MAEC;IAwBD;;;;;;MAMC;IASF;;;OAGG;IACH;;MAQC;IAED;;;OAGG;IACH,+BAwFC;IAED;;;;;OAKG;IACH,yBAIC;CACD;uBA5SsB,iBAAiB;6BAUd,0BAA0B;6BAH1B,0BAA0B;0BAI7B,4BAA4B;0BAH5B,uBAAuB;2BAHtB,kBAAkB;2BAChB,gBAAgB;8BAGf,qBAAqB"}

package/build/renderable/ui/panelpaint.d.ts

@@ -0,0 +1,5 @@
+import { Color } from "../../math/color.ts";
+import type { Gradient } from "../../video/gradient.js";
+/** anything {@link Renderer#setColor} will take */
+export type Paint = Color | string | Gradient;
+//# sourceMappingURL=panelpaint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panelpaint.d.ts","sourceRoot":"","sources":["../../../src/renderable/ui/panelpaint.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAa,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGxD,mDAAmD;AACnD,MAAM,MAAM,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAC"}

package/build/renderable/ui/progressbar.d.ts

@@ -0,0 +1,192 @@
+import { on } from "../../system/event.ts";
+import type Renderer from "../../video/renderer.js";
+import Renderable from "../renderable.js";
+import Text from "../text/text.js";
+import type { Paint } from "./panelpaint.ts";
+/**
+ * The name of any event the engine knows about.
+ *
+ * Derived from `on` rather than naming the `Events` map, which is internal to
+ * the event module; this gets the same set without widening that surface.
+ */
+type EventName = Parameters<typeof on>[0];
+/** which way the fill grows */
+export type ProgressBarDirection = "left-to-right" | "right-to-left" | "top-to-bottom" | "bottom-to-top";
+/**
+ * Everything {@link ProgressBar} takes.
+ */
+export interface ProgressBarSettings {
+    /** the bar's full width, in pixels */
+    width: number;
+    /** the bar's full height, in pixels */
+    height: number;
+    /** the value that reads as empty */
+    min?: number;
+    /** the value that reads as full */
+    max?: number;
+    /** where to start */
+    value?: number;
+    /** which edge the fill grows from */
+    direction?: ProgressBarDirection;
+    /** behind the fill; `null` leaves it hollow, showing whatever is behind */
+    trackColor?: Paint | null;
+    /**
+     * the fill itself. A {@link Color} is re-read every frame, so mutating the
+     * one you passed animates the bar
+     */
+    fillColor?: Paint;
+    /** drawn around the track; `null` for none */
+    borderColor?: Paint | null;
+    /** how thick that border is */
+    borderWidth?: number;
+    /** how far the fill sits inside the track, per side */
+    padding?: number;
+    /** corner radius; `0` is square */
+    radius?: number;
+    /** called whenever the value actually moves */
+    onChange?: (value: number, ratio: number) => void;
+    /** draw a label over the bar */
+    showLabel?: boolean;
+    /** the label's font family */
+    font?: string;
+    /** the label's font size, in pixels */
+    fontSize?: number;
+    /** the label's colour */
+    labelFillStyle?: Paint;
+    /** what the label says; the default is a rounded percentage */
+    labelFormat?: (value: number, ratio: number) => string;
+    /**
+     * an event to take the value from, instead of setting it by hand.
+     *
+     * The bar subscribes for as long as it exists and unsubscribes when it is
+     * destroyed, which is the point: a subscription that outlives what it
+     * drives is a listener writing into a freed object.
+     */
+    bindEvent?: EventName;
+}
+/**
+ * A bar that shows one value between two bounds.
+ *
+ * A health bar, a shield gauge, a cooldown, a loading bar: all the same
+ * object, and the engine's own loading screen is built on this one. Set
+ * {@link ProgressBar#value} and it redraws.
+ *
+ * It draws the track, the fill, the border and the label itself, in that
+ * order, which is the point of it being ONE renderable rather than a track
+ * sprite with a fill sprite on top. Two renderables at the same place have to
+ * be told which is in front, and that question has to be answered again every
+ * time either one moves.
+ *
+ * ## The colour can follow the value
+ *
+ * `fillColor` is read at draw time rather than copied, so passing a
+ * {@link Color} you keep hold of and mutating it is all a value-driven colour
+ * takes. That is deliberately not built in, because every game wants a
+ * different rule and most want the colour somewhere else too, next to a shader
+ * uniform or a glow:
+ *
+ * ```js
+ * const full = new Color().parseCSS("#7fe0ff");
+ * const empty = new Color().parseCSS("#ff2a1e");
+ * const mixed = new Color();
+ *
+ * const shield = new ProgressBar(x, y, {
+ *     width: 190, height: 13,
+ *     trackColor: null,                          // a hollow frame
+ *     borderColor: "rgba(122, 190, 235, 0.8)",
+ *     padding: 2,
+ *     fillColor: mixed,                          // kept, not copied
+ * });
+ *
+ * // each frame
+ * mixed.copy(empty).lerp(full, hp);
+ * shield.value = hp;
+ * ```
+ *
+ * Blinking is the same story: {@link Renderable#setOpacity} already does it,
+ * on whatever clock the game is already keeping.
+ * @category UI
+ * @example
+ * // a loading bar
+ * const bar = new ProgressBar(0, 100, {
+ *     width: renderer.width, height: 4,
+ *     trackColor: "black", fillColor: "#55aa00",
+ * });
+ * event.on(event.LOADER_PROGRESS, (progress) => { bar.value = progress; });
+ * @example
+ * // a label, and a value that is not a fraction
+ * const hp = new ProgressBar(20, 20, {
+ *     width: 200, height: 24,
+ *     min: 0, max: 100, value: 100,
+ *     fillColor: "#c0392b", radius: 6,
+ *     showLabel: true,
+ *     labelFormat: (v) => `${Math.round(v)} HP`,
+ * });
+ */
+export default class ProgressBar extends Renderable {
+    /** the value that reads as empty */
+    min: number;
+    /** the value that reads as full */
+    max: number;
+    /** which edge the fill grows from */
+    direction: ProgressBarDirection;
+    /** behind the fill; `null` leaves it hollow */
+    trackColor: Paint | null;
+    /** the fill. A {@link Color} here is re-read every frame */
+    fillColor: Paint;
+    /** drawn around the track; `null` for none */
+    borderColor: Paint | null;
+    /** how thick that border is */
+    borderWidth: number;
+    /** how far the fill sits inside the track, per side */
+    padding: number;
+    /** corner radius; `0` is square */
+    radius: number;
+    /** called whenever the value actually moves */
+    onChange?: ((value: number, ratio: number) => void) | undefined;
+    /** what the label says */
+    labelFormat: (value: number, ratio: number) => string;
+    /** the label, when `showLabel` was asked for */
+    label?: Text | undefined;
+    /** the event the value is taken from, if any */
+    readonly bindEvent?: EventName | undefined;
+    private _value;
+    /**
+     * @param x - position of the bar's left edge
+     * @param y - position of its top edge
+     * @param settings - see {@link ProgressBarSettings}
+     */
+    constructor(x: number, y: number, settings: ProgressBarSettings);
+    /**
+     * Where the bar is now, between {@link ProgressBar#min} and
+     * {@link ProgressBar#max}.
+     *
+     * Writing a value outside that range clamps rather than throwing, since
+     * the usual source is a health or a timer that has just gone past its own
+     * limit. Writing the value it already has does nothing at all, so
+     * `onChange` means the value MOVED.
+     */
+    get value(): number;
+    set value(v: number);
+    /**
+     * The value as a fraction, `0` at `min` and `1` at `max`.
+     *
+     * This is what the fill is drawn from, and what a caller usually wants for
+     * anything else keyed to the same number. Read only; set
+     * {@link ProgressBar#value}.
+     */
+    get ratio(): number;
+    /**
+     * Set the value, for chaining.
+     * @param v - the new value, clamped to the bar's bounds
+     * @returns this bar
+     */
+    setValue(v: number): this;
+    /**
+     * Draw the track, the fill, the border and the label, in that order.
+     * @param renderer - the renderer to draw with
+     */
+    draw(renderer: Renderer): void;
+}
+export {};
+//# sourceMappingURL=progressbar.d.ts.map

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

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