melonjs 20.6.0 → 20.8.0

package/build/renderable/renderable.d.ts

@@ -17,6 +17,16 @@ export default class Renderable extends Rect {
      * `"center"`, `"top"`, `"bottom"`, `"left"`, `"right"`, `"top-left"`, `"top-right"`,
      * `"bottom-left"`, `"bottom-right"` on every renderable that consumes it
      * (Sprite, Entity, Collectable, ImageLayer, Text, BitmapText, Sprite3d and subclasses).
+     * <br>
+     * <i><b>Note:</b> a body's collision shapes are measured from the same frame this
+     * places the renderable in, so a shape of `Rect(0, 0, width, height)` covers the
+     * renderable whatever the anchor is (since 20.7; before that shapes were measured
+     * from `pos` regardless, and a non-corner anchor collided where it was not drawn).
+     * A shape's own `pos` still offsets it inside that frame. A renderable that has
+     * cleared {@link Renderable#applyAnchorTransform} takes no offset at all, on the
+     * drawing or on its shapes. Note also that the adapters read the anchor when the
+     * body is created, so changing it afterwards moves the drawing but not an
+     * already-built body.</i>
      * @type {ObservablePoint}
      * @default <0.5,0.5>
      */
@@ -88,9 +98,37 @@ export default class Renderable extends Rect {
      * Typical fields: `type` (`"static"`/`"dynamic"`/`"kinematic"`),
      * `shapes`, `collisionType`, `collisionMask`, `restitution`,
      * `frictionAir`, `density`, `gravityScale`, `isSensor`,
-     * `maxVelocity`, `fixedRotation`. See {@link BodyDefinition}.
+     * `maxVelocity`, `fixedRotation`. See {@link BodyDefinitionInit}.
+
+     *
+     * `shapes` is normally a list of collision shapes, but it can also
+     * name a collision shape file preloaded as JSON, paired with `id`
+     * naming the body to read out of it. The file is resolved before any
+     * adapter sees the definition, so the same one works unchanged on
+     * every backend.
      * @type {object|undefined}
      * @default undefined
+     * @example
+     * // a shape authored in code
+     * this.bodyDef = {
+     *     type: "dynamic",
+     *     shapes: [new me.Rect(0, 0, this.width, this.height)],
+     * };
+     *
+     * @example
+     * // shapes drawn in a physics-shape editor, preloaded as JSON with
+     * // { name: "shapes", type: "json", src: "data/physics/shapes.json" }
+     * this.bodyDef = { type: "dynamic", shapes: "shapes", id: "hotdog" };
+     *
+     * // the density, friction and bounce the shapes were authored with
+     * // come with them, unless the definition states otherwise (each is
+     * // honoured by whichever backends support it):
+     * this.bodyDef = {
+     *     type: "dynamic",
+     *     shapes: "shapes",
+     *     id: "hotdog",
+     *     restitution: 0.9, // wins over whatever the file carries
+     * };
      */
     bodyDef: object | undefined;
     /**
@@ -277,6 +315,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
@@ -306,6 +374,31 @@ export default class Renderable extends Rect {
      * @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 {Renderable} 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): Renderable;
     set inViewport(value: boolean);
     /**
      * Whether the renderable object is visible and within the viewport
@@ -365,11 +458,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>
      *
@@ -401,9 +489,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
@@ -428,9 +516,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
@@ -440,23 +528,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.
@@ -580,9 +668,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
@@ -596,17 +684,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
@@ -676,13 +769,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,8 @@
 /**
  * additional import for TypeScript
- * @import {Vector2d} from "../math/vector2d.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.
@@ -22,6 +23,8 @@ export default class Sprite extends Renderable {
      * @param {number} [settings.flipY] - flip the sprite on the vertical axis
      * @param {string|Vector2d|{x:number,y:number}} [settings.anchorPoint={x:0.5, y:0.5}] - Anchor point to draw the frame at (defaults to the center of the frame). Also accepts the named presets `"center"`, `"top"`, `"bottom"`, `"left"`, `"right"`, `"top-left"`, `"top-right"`, `"bottom-left"`, `"bottom-right"`. For spritesheet atlases the anchor also becomes the cached atlas's per-frame pivot (see {@link TextureAtlas}).
      * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap|Texture2d|string} [settings.normalMap] - optional normal-map texture used for per-pixel lighting (SpriteIlluminator-style). Same layout/UVs as `settings.image`. When omitted (default), the sprite renders unlit and pays no extra cost. Ignored by the Canvas renderer. Note: `HTMLVideoElement` is intentionally not supported — normal maps encode static surface directions in RGB, and the engine caches the GL texture per image reference (a video would freeze on frame 0).
+     * @param {object} [settings.bodyDef] - declarative, adapter-portable body definition, applied when this sprite is added to a container. Its `shapes` may name a collision shape file preloaded as JSON, paired with `id`. See {@link Renderable#bodyDef} and {@link BodyDefinitionInit}
+     * @param {number} [settings.shininess=0] - specular exponent: how tight this sprite's highlight is, or 0 for none. Needs a `normalMap` — see {@link Sprite#shininess}
      * @example
      * // create a single sprite from a standalone image, with anchor in the center
      * let sprite = new me.Sprite(0, 0, {
@@ -65,6 +68,8 @@ export default class Sprite extends Renderable {
             y: number;
         } | undefined;
         normalMap?: string | ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | Texture2d | undefined;
+        bodyDef?: object | undefined;
+        shininess?: number | undefined;
     });
     /**
      * global offset for the position to draw from on the source image.
@@ -88,10 +93,59 @@ export default class Sprite extends Renderable {
      * @type {TextureAtlas}
      */
     source: TextureAtlas;
-    image: any;
+    /**
+     * How tight this sprite's specular highlight is, or `0` (the default)
+     * for none.
+     *
+     * A normal map tells the light which way each texel FACES, which gives
+     * a sprite shape; this decides whether it also SHINES. The highlight
+     * only appears where a texel happens to reflect a light toward the
+     * screen, so it slides across the surface as the light moves, rather
+     * than the whole sprite merely brightening — the difference between
+     * armour that glints as you walk past and armour that is just lit.
+     *
+     * Low values give a broad sheen (worn metal, wet stone), high values a
+     * tight glint (polished steel, glass). Gated on the exponent exactly
+     * as MTL `Ns` and {@link Mesh#shininess} are, so `0` means "matte"
+     * however bright the scene is, and every existing sprite is unchanged.
+     *
+     * **Needs a `normalMap`**: with no surface directions there is nothing
+     * to reflect, and the sprite stays matte whatever this is set to. The
+     * normal map's ALPHA channel masks it per texel, so one sprite can
+     * have a shiny blade and a matte leather grip; a normal map with no
+     * alpha detail (the usual case) shines uniformly.
+     *
+     * Ignored by the Canvas renderer.
+     * @type {number}
+     * @default 0
+     * @see [Normal Map example](https://melonjs.github.io/melonJS/examples/#/normal-map) — three orbs across the
+     * exponent's range, on a normal-mapped wall, lit by two moving lights
+     * @example
+     * // a polished blade: the highlight slides across it as a torch
+     * // moves past, instead of the sprite merely brightening
+     * const sword = new Sprite(x, y, {
+     *     image: "sword",
+     *     normalMap: "sword_n",
+     *     shininess: 64,       // a tight, metallic glint
+     * });
+     * @example
+     * // masked per texel: the normal map's ALPHA channel decides where
+     * // the sprite is glossy, so one sprite can be a shiny blade with a
+     * // matte leather grip. 255 = fully reflective, 0 = dead matte.
+     * const nm = document.createElement("canvas");
+     * // ...draw the normals into RGB, the gloss mask into A...
+     * const axe = new Sprite(x, y, {
+     *     image: "axe",
+     *     normalMap: nm,
+     *     shininess: 96,
+     * });
+     * @example
+     * // matte again at runtime
+     * axe.shininess = 0;
+     */
+    shininess: number;
+    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.
@@ -110,6 +164,23 @@ export default class Sprite extends Renderable {
      *
      * Silently ignored by the Canvas renderer.
      * @type {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap|null}
+     * @see {@link Sprite#shininess} to add a specular highlight on top
+     * @see [Normal Map example](https://melonjs.github.io/melonJS/examples/#/normal-map)
+     * @see [SpriteIlluminator example](https://melonjs.github.io/melonJS/examples/#/sprite-illuminator)
+     * @example
+     * // the sidecar pattern: one `_n` image beside each diffuse image
+     * await loader.preload([
+     *     { name: "hero",   type: "image", src: "data/img/hero.png" },
+     *     { name: "hero_n", type: "image", src: "data/img/hero_n.png" },
+     * ]);
+     * const hero = new Sprite(x, y, { image: "hero", normalMap: "hero_n" });
+     *
+     * // ...or assigned later, from any image-like source
+     * hero.normalMap = loader.getImage("hero_n");
+     *
+     * // an atlas can carry one for every region it packs, which a Sprite
+     * // built from that atlas picks up in preference to its own setting
+     * const atlas = new TextureAtlas(json, image, { normalMap });
      */
     get normalMap(): HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap | null;
     atlasIndices: any;
@@ -302,19 +373,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
@@ -322,9 +380,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 type { Vector2d } from "../math/vector2d.ts";
 import { 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":"AAcA;;;;;GAKG;AAEH;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,eA5CW,MAAM,KACN,MAAM,YAEd;QAAoH,KAAK,EAAjH,gBAAgB,GAAC,iBAAiB,GAAC,gBAAgB,GAAC,SAAS,GAAC,YAAY,GAAC,eAAe,GAAC,MAAM;QAC/E,IAAI;QACJ,MAAM;QACN,UAAU;QACV,WAAW;QACL,IAAI;QACV,KAAK;QACL,KAAK;QACwB,WAAW;eAAvC,MAAM;eAAG,MAAM;;QACyD,SAAS;QAClF,OAAO;QACP,SAAS;KACnC,EAmZF;IAnWA;;;OAGG;IACH,2BAEE;IAEF;;;;OAIG;IACH,QAHU,QAAQ,CAGkB;IAEpC;;;;OAIG;IACH,SAHU,OAAO,CAGG;IAEpB;;;;OAIG;IAGH;;;OAGG;IACH,QAFU,YAAY,CAEJ;IAElB;;;;;OAKG;IACH,wFAAsB;IAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiDG;IACH,WA3BU,MAAM,CA2BE;IAElB;;;;OAIG;IACH;;;;;MAKC;IAKA,sGAAqC;IACrC,kBAAkC;IAqSpC,0BANU,OAAO,EAQhB;IAVD;;;;OAIG;IACH,sBAHU,OAAO,CAKhB;IA9OE;;;;OAIG;IACH,mDAEE;IAYF;;;OAGG;IACH,2CAAgC;IAS9B;;;OAGG;IACH,uBAAmE;IA8OxE,qBAtBU,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAAC,IAAI,EAqD5E;IA9DD;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,iBAnBU,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAAC,IAAI,CAqB5E;IA5IC,kBAAyC;IA2D3C;;;OAGG;IACH,YAFU,MAAM,CAIf;IAED;;;OAGG;IACH,eAFU,MAAM,CAIf;IASD,cALU,MAAM,EAOf;IATD;;;OAGG;IACH,UAFU,MAAM,CAIf;IAaD,0BANU,MAAM,EAQf;IAVD;;;;OAIG;IACH,sBAHU,MAAM,CAKf;IAiFD;;;OAGG;IACH,gBAFa,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,YATW,MAAM,YACN,MAAM,cAAU,MAAM,GACpB,MAAM,CAclB;IAED;;;;OAIG;IACH,SAFa,MAAM,CAKlB;IAED;;;;OAIG;IACH,QAFa,MAAM,CAelB;IAED;;;;;;;;;;;OAWG;IACH,kBAVW,MAAM,wBAEJ,MAAM,CAoBlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,mBAzBW,MAAM,SACN,MAAM,EAAE,GAAC,MAAM,EAAE,GAAC,MAAM,EAAE,mBAC1B,MAAM,GACJ,MAAM,CAwBlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,0BAlCW,MAAM,cACN,MAAM,cAAU,MAAM,gBACtB,OAAO,GACL,MAAM,CAkClB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,GACJ,MAAM,CASlB;IAED;;;;;;;;OAQG;IACH,yBAPW,MAAM,GACJ,OAAO,CAQnB;IAED;;;;;;;;OAQG;IACH,qBANa,MAAM,EAAE,CAQpB;IAED;;;;;;;;OAQG;IACH,kBANW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;OAOG;IACH,oBAJW,MAAM,QA2ChB;IAED;;;;;;;OAOG;IACH,0BANW,MAAM,GACJ,MAAM,CAQlB;IAED;;;OAGG;IACH,4BAFa,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;IAwFD;;;OAGG;IACH,eAFW,QAAQ,QAsDlB;IAED;;;;OAIG;IACH,gBAyBC;CACD;uBAngCsB,iBAAiB;2BADb,qBAAqB;8BAQrB,qBAAqB;6BAXnB,6BAA6B;qCAaxB,2DAA2D;0BADpE,wBAAwB;sBAX3B,iCAAiC;sBAJjC,kBAAkB"}

package/build/renderable/sprite3d.d.ts

@@ -96,9 +96,17 @@ 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 `shadowGroundY` (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 `shadowGroundY` (see {@link Mesh#shadowGroundNormal})
+     * @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 +122,24 @@ 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;
+        shadowLight?: any;
         castGroundShadow?: boolean | undefined;
         fog?: boolean | undefined;
         transparent?: boolean | undefined;
+        depthTest?: boolean | undefined;
         alphaCutoff?: number | undefined;
     });
     /**
@@ -142,11 +158,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 +237,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 +281,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,11 @@
+/**
+ * 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";
+ */
 /**
  * a bitmap font object.
  *
@@ -51,7 +59,7 @@ export default class BitmapText extends Renderable {
         anchorPoint?: string | Vector2d | {
             x: number;
             y: number;
-        };
+        } | undefined;
         wordWrapWidth?: number | undefined;
         text?: string | string[] | undefined;
     });
@@ -189,11 +197,13 @@ 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 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;;;;;;;GAOG;AACH;;;;;;;;;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;eAAvC,MAAM;eAAG,MAAM;;QAChB,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,QAAQ,QAmGlB;IAED;;;;OAIG;IACH,gBAQC;CACD;uBAhgBsB,kBAAkB;sBAHnB,qBAAqB;wBAKnB,kBAAkB;0BAQjB,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,9 +13,6 @@ export default class BitmapTextData {
     descent: number;
     glyphMinTop: number;
     glyphMaxBottom: number;
-    glyphs: {
-        [key: number]: Glyph;
-    };
     constructor(data: string);
     parse(fontData: string): void;
 }

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,yEAY7B,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,15 @@ 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;
 }
 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