melonjs 20.7.0 → 20.8.0

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;
+        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,10 @@ 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";
 //# 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":"AAiEA;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,GAA/C,MAAM,EAAE,GAAC,QAAQ;QACE,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;uBA3SsB,iBAAiB;6BASd,0BAA0B;6BAF1B,0BAA0B;0BAG7B,4BAA4B;0BAF5B,uBAAuB;2BAHtB,kBAAkB;2BAChB,gBAAgB"}

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

@@ -0,0 +1,194 @@
+import { Color } from "../../math/color.ts";
+import { on } from "../../system/event.ts";
+import type { Gradient } from "../../video/gradient.js";
+import type Renderer from "../../video/renderer.js";
+import Renderable from "../renderable.js";
+import Text from "../text/text.js";
+/**
+ * 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];
+/** anything {@link Renderer#setColor} will take */
+type Paint = Color | string | Gradient;
+/** 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;
+    /**
+     * @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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"}

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

@@ -4,7 +4,36 @@ import Container from "../container.js";
 /**
  * This is a basic clickable and draggable container which you can use in your game UI.
  * Use this for example if you want to display a panel that contains text, images or other UI elements.
+ *
+ * Regions under the pointer are asked in the order they are drawn, topmost
+ * first, and the walk carries on downwards until a handler returns `false`. An
+ * element that can overlap another one is therefore not opaque until it says
+ * so: by default a widget it covers still answers clicks and still lights up on
+ * hover. {@link UIBaseElement#onClick}, {@link UIBaseElement#onRelease} and
+ * {@link UIBaseElement#onOver} each consume by returning `false`.
  * @category UI
+ * @example
+ * // a panel that is opaque to the pointer and comes to the front when picked
+ * class Panel extends UIBaseElement {
+ *     onClick() {
+ *         this.ancestor.moveToTop(this);
+ *         return false;
+ *     }
+ *     // the frame the pointer crosses in
+ *     onOver() {
+ *         return false;
+ *     }
+ *     // and every frame after that, when the pointer is already inside and
+ *     // `onOver` no longer fires
+ *     onActivateEvent() {
+ *         super.onActivateEvent();
+ *         me.input.registerPointerEvent("pointermove", this, () => false);
+ *     }
+ *     onDeactivateEvent() {
+ *         me.input.releasePointerEvent("pointermove", this);
+ *         super.onDeactivateEvent();
+ *     }
+ * }
  */
 export default class UIBaseElement extends Container {
     /**
@@ -65,12 +94,28 @@ export default class UIBaseElement extends Container {
      */
     onMove(_event?: Pointer): void;
     /**
-     * function called when the pointer is over the object
+     * function called when the pointer is over the object.
+     *
+     * Fires once, on the frame the pointer crosses into the element. To stay
+     * opaque for as long as the pointer rests on it, an element also wants a
+     * `"pointermove"` callback registered through
+     * {@link input.registerPointerEvent} returning `false`, since by then the
+     * pointer is already inside and this no longer runs.
      * @param _event - the event object
+     * @returns return false if we need to stop propagating the event, so that an
+     * element covered by this one does not also light up on hover
      */
-    onOver(_event?: Pointer): void;
+    onOver(_event?: Pointer): boolean | void;
     /**
-     * function called when the pointer is leaving the object area
+     * function called when the pointer is leaving the object area.
+     *
+     * Fires when the pointer leaves the element's bounds, and also when it is
+     * still inside them but something drawn above has consumed the move, since
+     * the pointer is then over that instead.
+     *
+     * Unlike {@link UIBaseElement#onOver} this one cannot consume the event, on
+     * purpose: an element that suppressed its own leave would stay in its hover
+     * state after the pointer had gone.
      * @param _event - the event object
      */
     onOut(_event?: Pointer): void;

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

@@ -1 +1 @@
-{"version":3,"file":"uibaseelement.d.ts","sourceRoot":"","sources":["../../../src/renderable/ui/uibaseelement.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,OAAO,MAAM,0BAA0B,CAAC;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAIvD,OAAO,SAAS,MAAM,iBAAiB,CAAC;AAExC;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,SAAS;IACnD;;;;;OAKG;IACM,QAAQ,UAAQ;IAEzB;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAC;IAEpB;;;OAGG;IACH,KAAK,EAAE,OAAO,CAAC;IAEf;;;OAGG;IACH,QAAQ,EAAE,OAAO,CAAC;IAGlB,WAAW,EAAE,MAAM,CAAC;IAGpB,UAAU,EAAE,QAAQ,GAAG,SAAS,CAAC;IAEjC;;;;;OAKG;gBACS,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM;IA+CxD;;;;OAIG;IAEH,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IAuClC;;;OAGG;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;IAI9B;;;OAGG;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;IAuB9B;;;OAGG;IAEH,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;IAmB7B;;;;OAIG;IAEH,SAAS,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IAkBpC;;;OAGG;IACH,MAAM,IAAI,IAAI;CA4Dd"}
+{"version":3,"file":"uibaseelement.d.ts","sourceRoot":"","sources":["../../../src/renderable/ui/uibaseelement.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,OAAO,MAAM,0BAA0B,CAAC;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAIvD,OAAO,SAAS,MAAM,iBAAiB,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,SAAS;IACnD;;;;;OAKG;IACM,QAAQ,UAAQ;IAEzB;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAC;IAEpB;;;OAGG;IACH,KAAK,EAAE,OAAO,CAAC;IAEf;;;OAGG;IACH,QAAQ,EAAE,OAAO,CAAC;IAGlB,WAAW,EAAE,MAAM,CAAC;IAGpB,UAAU,EAAE,QAAQ,GAAG,SAAS,CAAC;IAEjC;;;;;OAKG;gBACS,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM;IA+CxD;;;;OAIG;IAEH,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IAuClC;;;OAGG;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;IAI9B;;;;;;;;;;;OAWG;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI;IAuBxC;;;;;;;;;;;OAWG;IAEH,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;IAmB7B;;;;OAIG;IAEH,SAAS,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IAkBpC;;;OAGG;IACH,MAAM,IAAI,IAAI;CA4Dd"}

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

@@ -74,12 +74,28 @@ export default class UISpriteElement extends Sprite {
      */
     onClick(_event?: Pointer): boolean;
     /**
-     * function called when the pointer is over the object
+     * function called when the pointer is over the object.
+     *
+     * Fires once, on the frame the pointer crosses into the element. To stay
+     * opaque for as long as the pointer rests on it, an element also wants a
+     * `"pointermove"` callback registered through
+     * {@link input.registerPointerEvent} returning `false`, since by then the
+     * pointer is already inside and this no longer runs.
      * @param _event - the event object
+     * @returns return false if we need to stop propagating the event, so that an
+     * element covered by this one does not also light up on hover
      */
-    onOver(_event?: Pointer): void;
+    onOver(_event?: Pointer): boolean | void;
     /**
-     * function called when the pointer is leaving the object area
+     * function called when the pointer is leaving the object area.
+     *
+     * Fires when the pointer leaves the element's bounds, and also when it is
+     * still inside them but something drawn above has consumed the move, since
+     * the pointer is then over that instead.
+     *
+     * Unlike {@link UISpriteElement#onOver} this one cannot consume the event, on
+     * purpose: an element that suppressed its own leave would stay in its hover
+     * state after the pointer had gone.
      * @param _event - the event object
      */
     onOut(_event?: Pointer): void;

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

@@ -1 +1 @@
-{"version":3,"file":"uispriteelement.d.ts","sourceRoot":"","sources":["../../../src/renderable/ui/uispriteelement.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,OAAO,MAAM,0BAA0B,CAAC;AAEpD,OAAO,MAAM,MAAM,gBAAgB,CAAC;AAEpC;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,MAAM;IAClD;;;;;OAKG;IACM,QAAQ,UAAQ;IAEzB;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAC;IAEpB;;;OAGG;IACH,KAAK,EAAE,OAAO,CAAC;IAGf,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;gBAEF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE;QAAE,KAAK,EAAE,GAAG,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE;IAyC7C;;;;OAIG;IAEH,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IAelC;;;OAGG;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;IAgB9B;;;OAGG;IAEH,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;IAmB7B;;;;OAIG;IAEH,SAAS,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IAkBpC;;;OAGG;IACH,MAAM,IAAI,IAAI;CAyCd"}
+{"version":3,"file":"uispriteelement.d.ts","sourceRoot":"","sources":["../../../src/renderable/ui/uispriteelement.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,OAAO,MAAM,0BAA0B,CAAC;AAEpD,OAAO,MAAM,MAAM,gBAAgB,CAAC;AAEpC;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,MAAM;IAClD;;;;;OAKG;IACM,QAAQ,UAAQ;IAEzB;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAC;IAEpB;;;OAGG;IACH,KAAK,EAAE,OAAO,CAAC;IAGf,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;gBAEF,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,EAAE;QAAE,KAAK,EAAE,GAAG,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE;IAyC7C;;;;OAIG;IAEH,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IAelC;;;;;;;;;;;OAWG;IAEH,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI;IAgBxC;;;;;;;;;;;OAWG;IAEH,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI;IAmB7B;;;;OAIG;IAEH,SAAS,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IAkBpC;;;OAGG;IACH,MAAM,IAAI,IAAI;CAyCd"}

package/build/system/legacy_pool.d.ts

@@ -76,7 +76,7 @@ declare class ObjectPool {
     /**
      * Pull a new instance of the requested object (if added into the object pool)
      * @param {string} name - as used in {@link pool.register}
-     * @param {...*} [args] - arguments to be passed when instantiating/reinitializing the object
+     * @param {...*} args - arguments to be passed when instantiating/reinitializing the object
      * @returns {object} the instance of the requested object
      * @example
      * me.pool.register("bullet", BulletEntity, true);
@@ -94,7 +94,7 @@ declare class ObjectPool {
      * app.world.removeChild(enemy);
      * app.world.removeChild(bullet);
      */
-    pull(name: string, ...args?: any[]): object;
+    pull(name: string, ...args: any[]): object;
     /**
      * purge the object pool from any inactive object <br>
      * Object pooling must be enabled for this function to work<br>

package/build/system/legacy_pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"legacy_pool.d.ts","sourceRoot":"","sources":["../../src/system/legacy_pool.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,kEAEC;;AAmND;;;;;;;;;;;;;;GAcG;AACH,+BAA8B;AAhO9B;;;;;;;;;;;;GAYG;AACH;IAEE,gBAAqB;IACrB,yBAAyB;IAEzB;;;;;;;;;;;;;;OAcG;IACH,mBARU,OAAO,CAQY;IAG9B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,oBAhBW,MAAM,YACN,MAAM,cACN,OAAO,QAsCjB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,WAnBW,MAAM,YACH,GAAC,EAAA,GACF,MAAM,CAsClB;IAED;;;;OAIG;IACH,cAOC;IAED;;;;;;;;;OASG;IACH,UAJW,MAAM,iBACN,OAAO,GACL,OAAO,CAgBnB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;OAUG;IACH,cAPW,MAAM,GACJ,OAAO,CAcnB;IAED;;;OAGG;IACH,oBAFa,MAAM,CAIlB;CACD"}
+{"version":3,"file":"legacy_pool.d.ts","sourceRoot":"","sources":["../../src/system/legacy_pool.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,kEAEC;;AAmND;;;;;;;;;;;;;;GAcG;AACH,+BAA8B;AAhO9B;;;;;;;;;;;;GAYG;AACH;IAEE,gBAAqB;IACrB,yBAAyB;IAEzB;;;;;;;;;;;;;;OAcG;IACH,mBARU,OAAO,CAQY;IAG9B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,oBAhBW,MAAM,YACN,MAAM,cACN,OAAO,QAsCjB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,WAnBW,MAAM,WACH,GAAC,EAAA,GACF,MAAM,CAsClB;IAED;;;;OAIG;IACH,cAOC;IAED;;;;;;;;;OASG;IACH,UAJW,MAAM,iBACN,OAAO,GACL,OAAO,CAgBnB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;OAUG;IACH,cAPW,MAAM,GACJ,OAAO,CAcnB;IAED;;;OAGG;IACH,oBAFa,MAAM,CAIlB;CACD"}

package/build/system/pool.d.ts

@@ -12,6 +12,16 @@ export interface CreatePoolOptions<T, A extends unknown[]> {
     reset?: Reset<A>;
     release?: Release;
 }
+/**
+ * Register a pool instance to the pool registry.
+ *
+ * Public because `pool.js` re-exports it. Marked internal it was stripped
+ * from the declarations while that re-export kept naming it, which left the
+ * public `pool` module exporting something no longer declared.
+ * @param key - the name this pool is reachable by
+ * @param pool - the pool instance to register under it
+ */
+export declare const registerPool: (key: string, pool: Pool<any, any[]>) => void;
 export declare const createPool: <T, A extends unknown[]>(options: (...args: A) => CreatePoolOptions<T, A>) => Pool<T, A>;
 export {};
 //# sourceMappingURL=pool.d.ts.map

package/build/system/pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../../src/system/pool.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,IAAI,CAAC,CAAC,EAAE,CAAC,SAAS,OAAO,EAAE;IAC3C,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC;IACnB,OAAO,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC;IACzB,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,MAAM,CAAC;IACf,IAAI,IAAI,MAAM,CAAC;CACf;AAED,KAAK,KAAK,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;AACrE,KAAK,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;AAExC,MAAM,WAAW,iBAAiB,CAAC,CAAC,EAAE,CAAC,SAAS,OAAO,EAAE;IACxD,QAAQ,EAAE,CAAC,CAAC;IACZ,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAoBD,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,SAAS,OAAO,EAAE,EAChD,SAAS,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,KAC9C,IAAI,CAAC,CAAC,EAAE,CAAC,CA2DX,CAAC"}
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../../src/system/pool.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,IAAI,CAAC,CAAC,EAAE,CAAC,SAAS,OAAO,EAAE;IAC3C,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC;IACnB,OAAO,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC;IACzB,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,IAAI,MAAM,CAAC;IACf,IAAI,IAAI,MAAM,CAAC;CACf;AAED,KAAK,KAAK,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;AACrE,KAAK,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;AAExC,MAAM,WAAW,iBAAiB,CAAC,CAAC,EAAE,CAAC,SAAS,OAAO,EAAE;IACxD,QAAQ,EAAE,CAAC,CAAC;IACZ,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAKD;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,EAAE,MAAM,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,SAE/D,CAAC;AAQF,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,SAAS,OAAO,EAAE,EAChD,SAAS,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,KAC9C,IAAI,CAAC,CAAC,EAAE,CAAC,CA0EX,CAAC"}

package/build/tweens/tween.d.ts

@@ -1,5 +1,21 @@
 import { EasingFunction } from "./easing.js";
 import { InterpolationFunction } from "./interpolation.js";
+/**
+ * Called once when a tween starts, with `this` bound to the tweened object.
+ * @see Tween#onStart
+ */
+export type OnStartCallback<T> = (this: T) => void;
+/**
+ * Called on every tween step with the eased progress in `[0, 1]`, and `this`
+ * bound to the tweened object.
+ * @see Tween#onUpdate
+ */
+export type OnUpdateCallback<T> = (this: T, value: number) => void;
+/**
+ * Called once when a tween finishes, with `this` bound to the tweened object.
+ * @see Tween#onComplete
+ */
+export type OnCompleteCallback<T> = (this: T) => void;
 /**
  * A tweening engine for smoothly interpolating object properties over time.
  * Based on <a href="https://github.com/sole/Tween.js">tween.js</a> with
@@ -140,12 +156,43 @@ export default class Tween {
     onComplete(onCompleteCallback: OnCompleteCallback<object>): this;
     /**
      * Available easing functions, accessed via `Tween.Easing`.
-     * Each family provides `In`, `Out`, and `InOut` variants.
-     * @see {@link Easing} for the full list
+     *
+     * Eleven families, each providing `In`, `Out` and `InOut`. `In` applies the
+     * curve at the start, `Out` at the end, and `InOut` at both. `Out` is what
+     * most UI wants: the value arrives decisively rather than creeping in.
+     *
+     * | family | shape | reach for it when |
+     * | --- | --- | --- |
+     * | `Linear.None` | no curve at all | the value IS the progress, e.g. a loading bar |
+     * | `Quadratic` `Cubic` `Quartic` `Quintic` | progressively sharper power curves | general motion; higher powers start slower and finish harder |
+     * | `Sinusoidal` | gentlest of all | a drift or a breath that should not call attention |
+     * | `Exponential` | extreme, near-instant at one end | something that snaps |
+     * | `Circular` | hard, like the quarter of a circle | a mechanical slide |
+     * | `Back` | **overshoots past the target and settles back** | impact: a stamp, a button press, anything that should land rather than arrive |
+     * | `Elastic` | overshoots repeatedly, oscillating | springy, cartoon motion |
+     * | `Bounce` | lands and bounces, settling | something falling onto a surface |
+     *
+     * `Back` and `Elastic` overshoot, so the value LEAVES the range between
+     * your start and end: clamp anything that cannot take it, an opacity or a
+     * colour channel in particular. Note the direction of the overshoot follows
+     * the direction of travel, so a value tweened DOWN to its target overshoots
+     * below it.
+     * @see https://easings.net/ for a visual reference of every curve
      * @example
      * me.Tween.Easing.Quadratic.InOut
      * me.Tween.Easing.Bounce.Out
      * me.Tween.Easing.Elastic.In
+     * @example
+     * // a stamp: scale falls to 1 and springs through it
+     * const driver = { scale: 5 };
+     * new me.Tween(driver)
+     *     .to({ scale: 1 }, { duration: 420 })
+     *     .easing(me.Tween.Easing.Back.Out)
+     *     .onUpdate(() => {
+     *         label.currentTransform.identity();
+     *         label.scale(driver.scale);
+     *     })
+     *     .start();
      */
     static get Easing(): {
         Linear: {

package/build/tweens/tween.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tween.d.ts","sourceRoot":"","sources":["../../src/tweens/tween.ts"],"names":[],"mappings":"AAWA,OAAO,EAAU,cAAc,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAiB,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAuB1E;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,OAAO,OAAO,KAAK;IAqHzB;;;OAGG;IACH,YAAY,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,gBAAgB,EAAE,OAAO,CAAC;IAE1B;;OAEG;gBACS,MAAM,EAAE,MAAM;IA+I1B;;;;;;;;;;;;;OAaG;IACH,EAAE,CACD,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,OAAO,CAAC,EAAE;QACT,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC9B,MAAM,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;QACpC,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;QAC3B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC5B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QACjC,aAAa,CAAC,EAAE,qBAAqB,GAAG,SAAS,CAAC;QAClD,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;KAChC;IAkCF;;;;OAIG;IACH,KAAK,CAAC,IAAI,SAAkB;IA4C5B;;;OAGG;IACH,IAAI;IAKJ;;;;OAIG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM;IAKpB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM;IAKpB;;;;OAIG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM;IAK1B;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,OAAO;IAKlB;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,cAAc;IAK7B;;;;OAIG;IACH,aAAa,CAAC,aAAa,EAAE,qBAAqB;IAKlD;;;;OAIG;IACH,KAAK,CAAC,GAAG,MAAM,EAAE,KAAK,EAAE;IAKxB;;;;OAIG;IACH,OAAO,CAAC,eAAe,EAAE,eAAe,CAAC,MAAM,CAAC;IAKhD;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,MAAM,CAAC;IAKnD;;;;OAIG;IACH,UAAU,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,MAAM,CAAC;IA0HzD;;;;;;;;OAQG;IACH,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEhB;IAED;;;;;;;OAOG;IACH,MAAM,KAAK,aAAa;;;;MAEvB;CACD;AAED,eAAO,MAAM,SAAS,wDASpB,CAAC"}
+{"version":3,"file":"tween.d.ts","sourceRoot":"","sources":["../../src/tweens/tween.ts"],"names":[],"mappings":"AAWA,OAAO,EAAU,cAAc,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAiB,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAO1E;;;GAGG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;AACnD;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;AACnE;;;GAGG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,OAAO,OAAO,KAAK;IAqHzB;;;OAGG;IACH,YAAY,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,gBAAgB,EAAE,OAAO,CAAC;IAE1B;;OAEG;gBACS,MAAM,EAAE,MAAM;IA+I1B;;;;;;;;;;;;;OAaG;IACH,EAAE,CACD,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,OAAO,CAAC,EAAE;QACT,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC9B,MAAM,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;QACpC,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;QAC3B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC5B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QACjC,aAAa,CAAC,EAAE,qBAAqB,GAAG,SAAS,CAAC;QAClD,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;KAChC;IAkCF;;;;OAIG;IACH,KAAK,CAAC,IAAI,SAAkB;IA4C5B;;;OAGG;IACH,IAAI;IAKJ;;;;OAIG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM;IAKpB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM;IAKpB;;;;OAIG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM;IAK1B;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,OAAO;IAKlB;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,cAAc;IAK7B;;;;OAIG;IACH,aAAa,CAAC,aAAa,EAAE,qBAAqB;IAKlD;;;;OAIG;IACH,KAAK,CAAC,GAAG,MAAM,EAAE,KAAK,EAAE;IAKxB;;;;OAIG;IACH,OAAO,CAAC,eAAe,EAAE,eAAe,CAAC,MAAM,CAAC;IAKhD;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,MAAM,CAAC;IAKnD;;;;OAIG;IACH,UAAU,CAAC,kBAAkB,EAAE,kBAAkB,CAAC,MAAM,CAAC;IA0HzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACH,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEhB;IAED;;;;;;;OAOG;IACH,MAAM,KAAK,aAAa;;;;MAEvB;CACD;AAED,eAAO,MAAM,SAAS,wDASpB,CAAC"}

package/build/video/canvas/canvas_renderer.d.ts

@@ -8,21 +8,45 @@
  * @import {Matrix2d} from "../../math/matrix2d.ts";
  * @import {Bounds} from "../../physics/bounds.ts";
  * @import {default as Texture2d} from "../texture/texture2d.ts";
+ * @import {Matrix3d} from "../../math/matrix3d.ts";
+ * @import Mesh from "../../renderable/mesh.js";
+ * @import {ApplicationSettings} from "../../application/settings.ts";
+ * @import {Box3d} from "../../geometries/box3d.ts";
+ * @import {Sphere} from "../../geometries/sphere.ts";
  */
 /**
  * a canvas renderer object
  * @category Rendering
  */
 export default class CanvasRenderer extends Renderer {
-    cache: TextureCache;
     onGameReset: () => void;
     /**
-     * set/change the current projection matrix.
-     * In Canvas mode, this applies the ortho projection as a canvas 2D transform
-     * (translate + scale) to map world coordinates to screen coordinates.
-     * @param {Matrix3d} matrix - the new projection matrix
+     * Capture the current frame into a {@link Texture2d} — the Canvas-renderer
+     * counterpart of {@link WebGLRenderer#toFrameTexture}, keeping the
+     * `toDataURL` / `toBlob` / `toImageBitmap` family renderer-complete. Backed
+     * by an offscreen `<canvas>` copy of the drawing buffer (Canvas rendering is
+     * immediate, so no flush is needed). Custom shaders don't run under the
+     * Canvas renderer, so the result is a plain drawable for CPU-side reuse
+     * rather than a live shader input.
+     * @param {object} [options]
+     * @param {Texture2d|null} [options.target] - controls the destination: omit
+     *   for the shared renderer slot (default); pass a capture previously
+     *   returned by this method to refresh it in place; pass `null` to mint a
+     *   fresh, caller-owned capture (mirrors {@link WebGLRenderer#toFrameTexture})
+     * @param {Bounds|{x: number, y: number, width: number, height: number}} [options.region] - capture
+     *   only this sub-region (canvas pixels, top-left origin). A {@link Bounds}
+     *   (or any `{x, y, width, height}`); from a {@link Rect} pass `rect.getBounds()`.
+     * @returns {Texture2d} a texture holding the captured frame
      */
-    setProjection(matrix: Matrix3d): void;
+    toFrameTexture(options?: {
+        target?: Texture2d | null | undefined;
+        region?: Bounds | {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        } | undefined;
+    }): Texture2d;
     /**
      * set the current blend mode for this renderer. <br>
      * This renderer supports every mode below except `"none"`: <br>
@@ -195,17 +219,6 @@ export default class CanvasRenderer extends Renderer {
      * @param {number} radii - The corner radius.
      */
     roundRect(x: number, y: number, width: number, height: number, radii: number): void;
-    /**
-     * stroke the given shape or the current defined path
-     * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds} [shape] - a shape object to stroke
-     * @param {boolean} [fill=false] - fill the shape with the current color if true
-     */
-    stroke(shape?: Rect | RoundRect | Polygon | Line | Ellipse | Bounds, fill?: boolean): void;
-    /**
-     * fill the given shape or the current defined path
-     * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds} [shape] - a shape object to fill
-     */
-    fill(shape?: Rect | RoundRect | Polygon | Line | Ellipse | Bounds): void;
     /**
      * add a straight line from the current point to the start of the current sub-path. If the shape has already been closed or has only one point, this function does nothing
      */
@@ -317,13 +330,11 @@ export default class CanvasRenderer extends Renderer {
     transform(a: Matrix2d | Matrix3d | number, b?: number, c?: number, d?: number, e?: number, f?: number): void;
 }
 import Renderer from "./../renderer.js";
-import TextureCache from "./../texture/cache.js";
+import type { default as Texture2d } from "../texture/texture2d.ts";
+import type { Bounds } from "../../physics/bounds.ts";
 import { Color } from "./../../math/color.ts";
-import type { Rect } from "./../../geometries/rectangle.ts";
-import type { RoundRect } from "./../../geometries/roundrect.ts";
+import type Mesh from "../../renderable/mesh.js";
 import type { Polygon } from "../../geometries/polygon.ts";
-import type { Line } from "./../../geometries/line.ts";
-import type { Ellipse } from "./../../geometries/ellipse.ts";
-import type { Bounds } from "../../physics/bounds.ts";
 import type { Matrix2d } from "../../math/matrix2d.ts";
+import type { Matrix3d } from "../../math/matrix3d.ts";
 //# sourceMappingURL=canvas_renderer.d.ts.map

package/build/video/canvas/canvas_renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canvas_renderer.d.ts","sourceRoot":"","sources":["../../../src/video/canvas/canvas_renderer.js"],"names":[],"mappings":"AAcA;;;;;;;;;;GAUG;AAEH;;;GAGG;AACH;IAiBE,oBAAmC;IAiCnC,wBAEC;IAyBD;;;OAGG;IACH,8CAA4B;IAyE1B;;;OAGG;IACH,mBAA0B;IA6B7B;;;;;OAKG;IACH,sBAFW,QAAQ,QAclB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,oBAHW,MAAM,GACJ,MAAM,CA2ClB;IAWD;;;;OAIG;IACH,mBAHW,KAAK,GAAC,MAAM,WACZ,OAAO,QAajB;IAED;;;;;;OAMG;IACH,aALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAIhB;IAED;;;;;;;;;;;OAWG;IACH,qBAVW,gBAAgB,GAAC,eAAe,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,WAAW,GAAC,eAAe,GAAC,UAAU,WAC1G,MAAM,GACJ,aAAa,CAezB;IAiID;;;;;;;;OAQG;IACH,qBAPW,aAAa,KACb,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAFW,IAAI,QAwOd;IA1LE;;;OAGG;IACH,kEAAyD;IACzD;;;OAGG;IACH,uFAA2D;IAa5D;;;OAGG;IACH,oDAAkD;IAkKpD;;;;;;;;;;;;;;;OAeG;IACH,kBAEC;IAED;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAIhB;IAED;;OAEG;IACH,6BAEC;IAED;;;;;;OAMG;IACH,sBALW,MAAM,OACN,MAAM,KACN,MAAM,KACN,MAAM,QAIhB;IAED;;;;;;;;OAQG;IACH,oBAPW,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,KACN,MAAM,KACN,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,UANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,QAIhB;IAED;;;;;;OAMG;IACH,QALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,aANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,SACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,eAHW,IAAI,GAAC,SAAS,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,GAAC,MAAM,SAC1C,OAAO,QAoCjB;IAED;;;OAGG;IACH,aAFW,IAAI,GAAC,SAAS,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,GAAC,MAAM,QAIpD;IAED;;OAEG;IACH,kBAEC;IAED;;;;;;;;;OASG;IACH,aARW,MAAM,KACN,MAAM,UACN,MAAM,SACN,MAAM,OACN,MAAM,kBACN,OAAO,SACP,OAAO,QAcjB;IAED;;;;;;;;OAQG;IACH,WAPW,MAAM,KACN,MAAM,UACN,MAAM,SACN,MAAM,OACN,MAAM,kBACN,OAAO,QAIjB;IAsDD;;;;;;OAMG;IACH,iBALW,MAAM,UACN,MAAM,QACN,MAAM,QACN,MAAM,QAIhB;IAmBD;;;;OAIG;IACH,oBAHW,OAAO,SACP,OAAO,QAyBjB;IAED;;;OAGG;IACH,kBAFW,OAAO,QAIjB;IA+BD;;;;;;;;OAQG;IACH,mBAPW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,MAAM,SACN,OAAO,QAYjB;IAED;;;;;;;OAOG;IACH,iBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,eAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,aAHW,MAAM,KACN,MAAM,QAIhB;IA+GD;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IA6BD;;;OAGG;IACH,oBAXU,MAAM,EAcf;IAjBD;;;;;OAKG;IACH,gBAHU,MAAM,CAKf;IAWD;;;;;;;;;OASG;IACH,gBAPW,QAAQ,GAAC,QAAQ,GAAC,MAAM,MACxB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAKhB;IAED;;;;;;;;;OASG;IACH,aAPW,QAAQ,GAAC,QAAQ,GAAC,MAAM,MACxB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA+BhB;IA8GC;;;OAGG;IACH,2CAAkC;CAgGpC;qBA1iDoB,kBAAkB;yBACd,uBAAuB;sBAX1B,uBAAuB;0BAgBtB,iCAAiC;+BAC5B,iCAAiC;6BACnC,6BAA6B;0BAChC,4BAA4B;6BACzB,+BAA+B;4BAEhC,yBAAyB;8BADvB,wBAAwB"}
+{"version":3,"file":"canvas_renderer.d.ts","sourceRoot":"","sources":["../../../src/video/canvas/canvas_renderer.js"],"names":[],"mappings":"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"}

package/build/video/effects/blendEffect.d.ts

@@ -1,3 +1,2 @@
 export const wgslFragment: "\nstruct BlendUniforms {\n\tuBlendMode : f32,\n};\n@group(3) @binding(0) var<uniform> fx : BlendUniforms;\n@group(3) @binding(1) var backdrop : texture_2d<f32>;\n@group(3) @binding(2) var backdrop_sampler : sampler;\n\n// HardLight(Cb, Cs) \u2014 also the kernel for Overlay, which the W3C spec\n// defines as HardLight with the arguments swapped\nfn ME_hardLight(b : vec3f, s : vec3f) -> vec3f {\n\tlet lo = 2.0 * b * s;\n\tlet hi = 1.0 - 2.0 * (1.0 - b) * (1.0 - s);\n\treturn mix(lo, hi, step(vec3f(0.5), s));\n}\n\nfn ME_softLight(b : vec3f, s : vec3f) -> vec3f {\n\tlet d = mix(((16.0 * b - 12.0) * b + 4.0) * b, sqrt(b), step(vec3f(0.25), b));\n\tlet lo = b - (1.0 - 2.0 * s) * b * (1.0 - b);\n\tlet hi = b + (2.0 * s - 1.0) * (d - b);\n\treturn mix(lo, hi, step(vec3f(0.5), s));\n}\n\n// Cb == 0 wins over Cs == 1, so it is applied last\nfn ME_colorDodge(b : vec3f, s : vec3f) -> vec3f {\n\tvar r = min(vec3f(1.0), b / max(1.0 - s, vec3f(1e-4)));\n\tr = mix(r, vec3f(1.0), step(vec3f(1.0), s));\n\treturn mix(r, vec3f(0.0), step(b, vec3f(0.0)));\n}\n\n// Cb == 1 wins over Cs == 0, so it is applied last\nfn ME_colorBurn(b : vec3f, s : vec3f) -> vec3f {\n\tvar r = 1.0 - min(vec3f(1.0), (1.0 - b) / max(s, vec3f(1e-4)));\n\tr = mix(r, vec3f(0.0), step(s, vec3f(0.0)));\n\treturn mix(r, vec3f(1.0), step(vec3f(1.0), b));\n}\n\nfn ME_blend(b : vec3f, s : vec3f) -> vec3f {\n\tif (fx.uBlendMode < 0.5) { return abs(b - s); }\n\tif (fx.uBlendMode < 1.5) { return ME_hardLight(s, b); }\n\tif (fx.uBlendMode < 2.5) { return ME_hardLight(b, s); }\n\tif (fx.uBlendMode < 3.5) { return ME_colorDodge(b, s); }\n\tif (fx.uBlendMode < 4.5) { return ME_colorBurn(b, s); }\n\tif (fx.uBlendMode < 5.5) { return ME_softLight(b, s); }\n\tif (fx.uBlendMode < 6.5) { return min(b, s); }\n\treturn max(b, s);\n}\n\nfn apply(color : vec4f, uv : vec2f) -> vec4f {\n\t// sampled BEFORE any branch, so plain textureSampleLevel is safe here\n\tlet Cb = textureSampleLevel(backdrop, backdrop_sampler, screen_uv, 0.0).rgb;\n\tlet a = color.a;\n\tlet Cs = color.rgb / max(a, 1e-4);\n\tlet B = clamp(ME_blend(Cb, Cs), vec3f(0.0), vec3f(1.0));\n\treturn vec4f(a * B, a);\n}\n";
-import ShaderEffect from "./shadereffect.js";
 //# sourceMappingURL=blendEffect.d.ts.map