melonjs 20.3.0 → 20.5.0

package/build/camera/camera2d.d.ts

@@ -5,10 +5,7 @@ import { Matrix3d } from "../math/matrix3d.ts";
 import { Vector2d } from "../math/vector2d.ts";
 import { Vector3d } from "../math/vector3d.ts";
 import { Bounds } from "./../physics/bounds.ts";
-import type Container from "./../renderable/container.js";
 import Renderable from "./../renderable/renderable.js";
-import ColorMatrixEffect from "./../video/effects/colorMatrix.js";
-import type Renderer from "./../video/renderer.js";
 import type CameraEffect from "./effects/camera_effect.ts";
 /**
  * @import Entity from "./../renderable/entity/entity.js";
@@ -108,10 +105,6 @@ export default class Camera2d extends Renderable {
      * @default 0
      */
     screenY: number;
-    /**
-     * @ignore
-     */
-    _zoom: number;
     /**
      * the world-space projection matrix for non-default cameras (offset/zoomed).
      * Maps world coordinates to the camera's screen viewport.
@@ -130,21 +123,11 @@ export default class Camera2d extends Renderable {
      * @default true
      */
     autoResize: boolean;
-    /**
-     * cached world view bounds
-     * @ignore
-     */
-    _worldView: Bounds;
     /**
      * the default camera projection matrix
      * (2d cameras use an orthographic projection by default).
      */
     projectionMatrix: Matrix3d;
-    /**
-     * the invert camera transform used to unproject points
-     * @ignore
-     */
-    invCurrentTransform: Matrix3d;
     /** offset for shake effect */
     offset: Vector2d;
     /** target to follow */
@@ -167,8 +150,6 @@ export default class Camera2d extends Renderable {
      * camera.colorMatrix.identity();
      */
     colorMatrix: ColorMatrix;
-    /** @ignore */
-    _colorMatrixEffect: ColorMatrixEffect | null;
     /** the camera deadzone */
     deadzone: Rect;
     /**
@@ -178,12 +159,6 @@ export default class Camera2d extends Renderable {
      * @param maxY - end y offset
      */
     constructor(minX: number, minY: number, maxX: number, maxY: number);
-    /** @ignore */
-    _updateProjectionMatrix(): void;
-    /** @ignore */
-    _followH(target: Vector2d | Vector3d): number;
-    /** @ignore */
-    _followV(target: Vector2d | Vector3d): number;
     /**
      * the zoom level of this camera.
      * Values less than 1 zoom out (show more of the world),
@@ -193,6 +168,34 @@ export default class Camera2d extends Renderable {
      * // zoom out to show the full level in a 180x100 minimap
      * camera.zoom = Math.min(180 / levelWidth, 100 / levelHeight);
      */
+    /**
+     * Roll this camera in the screen plane, in radians — the 2D spelling of
+     * {@link Camera3d#roll}, so a helper that banks "a camera" works on either.
+     *
+     * Absolute and idempotent: assigning the same angle twice leaves the view
+     * where it was. It is a thin accessor over the camera's own
+     * `currentTransform`, which is what {@link Renderable#rotate} writes and
+     * what `worldToLocal` / `localToWorld` already undo — so picking under a
+     * rolled 2D camera stays correct for free.
+     *
+     * A 2D camera has no pitch or yaw, so a screen-plane rotation is its only
+     * rotation; on a `Camera3d` the roll is a real view angle instead, because
+     * a 3D view is built from its three angles and never reads
+     * `currentTransform`.
+     *
+     * This OWNS the camera's `currentTransform`: the setter rebuilds it rather
+     * than composing onto it, so assigning every frame cannot drift and
+     * `roll = 0` lands back on an exact identity. (A delta-based version does
+     * neither — a banking camera would accumulate float error across thousands
+     * of frames.) The cost is that a manual `rotate()` / `scale()` on the
+     * camera itself is discarded by the next assignment; a camera has `zoom`
+     * and `shake` for those jobs, and neither touches this matrix.
+     * @default 0
+     * @example
+     * camera.roll = Math.PI / 32; // a slight dutch angle
+     */
+    get roll(): number;
+    set roll(value: number);
     get zoom(): number;
     set zoom(value: number);
     /**
@@ -279,10 +282,6 @@ export default class Camera2d extends Renderable {
      * @param y - vertical position
      */
     moveTo(x: number, y: number): void;
-    /** @ignore */
-    updateTarget(dt?: number): void;
-    /** @ignore */
-    update(dt?: number): boolean;
     /**
      * shake the camera
      * @param intensity - maximum offset that the screen can be moved
@@ -374,45 +373,6 @@ export default class Camera2d extends Renderable {
      * @returns a vector with the converted local coordinates
      */
     worldToLocal(x: number, y: number, v?: Vector2d): Vector2d;
-    /**
-     * Build and install the world + screen projections used when this
-     * camera is non-default (split-screen, picture-in-picture, etc.).
-     * Default behavior is a shifted ortho that places the camera's
-     * world view at the camera's screen-rect within the full renderer
-     * viewport. Subclasses (e.g. Camera3d) override this to install a
-     * perspective `worldProjection` instead.
-     * @ignore
-     */
-    _setupNonDefaultProjection(renderer: Renderer): void;
-    /**
-     * render the camera effects
-     * @ignore
-     */
-    drawFX(renderer: Renderer): void;
-    /**
-     * draw all objects visible in this viewport
-     * @ignore
-     */
-    draw(renderer: Renderer, container: Container): void;
-    /**
-     * Apply the world-to-camera-view transform to the container before
-     * its draw walk. Camera2d translates by `-camera.pos` (plus shake
-     * offset); Camera3d overrides this to additionally rotate by
-     * `-camera.pitch` / `-camera.yaw` in the correct order.
-     * @ignore
-     */
-    _applyContainerViewTransform(container: Container, translateX: number, translateY: number): void;
-    /**
-     * Revert the transform applied by {@link Camera2d#_applyContainerViewTransform}.
-     * Must undo each mutation in reverse order. Subclasses overriding
-     * `_applyContainerViewTransform` should override this too.
-     * @ignore
-     */
-    _revertContainerViewTransform(container: Container, translateX: number, translateY: number): void;
-    /**
-     * @ignore
-     */
-    destroy(): void;
 }
 export {};
 //# sourceMappingURL=camera2d.d.ts.map

package/build/camera/camera2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"camera2d.d.ts","sourceRoot":"","sources":["../../src/camera/camera2d.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"camera2d.d.ts","sourceRoot":"","sources":["../../src/camera/camera2d.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AACpD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAgB,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAc,MAAM,wBAAwB,CAAC;AAE5D,OAAO,UAAU,MAAM,+BAA+B,CAAC;AAcvD,OAAO,KAAK,YAAY,MAAM,4BAA4B,CAAC;AAK3D;;;;GAIG;AAEH,UAAU,QAAQ;IACjB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;CACjB;AAID;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,UAAU;IAC/C;;;;;;;OAOG;IACH,MAAM,CAAC,aAAa,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,OAAO,CAAO;IAEtD;;;;;;OAMG;IACH,IAAI,EAAE,QAAQ,CAAC;IAEf;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,YAAY,EAAE,OAAO,CAAC;IAEtB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;;;;;;OASG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC;IAEZ;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAQhB,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,eAAe,EAAE,QAAQ,CAAC;IAE1B;;;;OAIG;IACH,gBAAgB,EAAE,QAAQ,CAAC;IAE3B;;;;;OAKG;IACH,UAAU,EAAE,OAAO,CAAC;IASpB;;;OAGG;IACH,gBAAgB,EAAE,QAAQ,CAAC;IAS3B,8BAA8B;IAC9B,MAAM,EAAE,QAAQ,CAAC;IAEjB,uBAAuB;IACvB,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI,CAAC;IAEnC,2BAA2B;IAC3B,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,aAAa,EAAE,YAAY,EAAE,CAAC;IAE9B;;;;;;;;;;OAUG;IACH,WAAW,EAAE,WAAW,CAAC;IAQzB,0BAA0B;IAC1B,QAAQ,EAAE,IAAI,CAAC;IAEf;;;;;OAKG;gBACS,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAkJlE;;;;;;;;OAQG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,IAAI,CAAC,KAAK,EAAE,MAAM,EAgBrB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,IAAI,CAAC,KAAK,EAAE,MAAM,EAErB;IAED;;;;OAIG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED;;;;OAIG;IACH,IAAI,SAAS,IAAI,MAAM,CAQtB;IAED;;;;;;;OAOG;IACH,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAU/D;;;;OAIG;IACH,KAAK,CAAC,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU,GAAG,IAAI;IAkCzC;;;;;;;OAOG;IACH,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAoBvC;;;;;OAKG;IACM,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IA2B3C;;;;;;;OAOG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAQ3D;;;;;;;;;OASG;IACH,MAAM,CACL,MAAM,EAAE,UAAU,GAAG,QAAQ,GAAG,QAAQ,EACxC,IAAI,CAAC,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,MAAM,GACd,IAAI;IAyBP;;OAEG;IACH,QAAQ,IAAI,IAAI;IAKhB;;;;;;;;OAQG;IACH,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAIhC;;;;;OAKG;IACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IA6GlC;;;;;;;;;;;OAWG;IACH,KAAK,CACJ,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,MAAM,IAAI,EACvB,KAAK,CAAC,EAAE,OAAO,GACb,IAAI;IAmBP;;;;;;;;;;;;;OAaG;IACH,OAAO,CACN,KAAK,EAAE,KAAK,GAAG,MAAM,EACrB,QAAQ,GAAE,MAAa,EACvB,UAAU,CAAC,EAAE,MAAM,IAAI,GACrB,IAAI;IAWP;;;;;;;;;OASG;IACH,MAAM,CACL,KAAK,EAAE,KAAK,GAAG,MAAM,EACrB,QAAQ,GAAE,MAAa,EACvB,UAAU,CAAC,EAAE,MAAM,IAAI,GACrB,IAAI;IAWP;;;;;;OAMG;IACH,eAAe,CAAC,CAAC,SAAS,YAAY,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC;IAKrD;;;;;;OAMG;IACH,eAAe,CAAC,CAAC,SAAS,YAAY,EACrC,WAAW,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,GACpC,CAAC,GAAG,SAAS;IAMhB;;;;;;OAMG;IACH,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAQ9C;;;OAGG;IACH,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAQjC;;;;;OAKG;IACH,SAAS,CAAC,GAAG,EAAE,UAAU,EAAE,QAAQ,GAAE,OAAsB,GAAG,OAAO;IA0BrE;;;;;;OAMG;IACH,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ;IAS1D;;;;;;OAMG;IACH,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ;CAmR1D"}

package/build/camera/camera3d.d.ts

@@ -1,11 +1,11 @@
 import type { ObservableVector3d } from "../math/observableVector3d.ts";
 import { Vector2d } from "../math/vector2d.ts";
 import { Vector3d } from "../math/vector3d.ts";
-import type Container from "./../renderable/container.js";
 import type Renderable from "./../renderable/renderable.js";
-import type Renderer from "./../video/renderer.js";
 import Camera2d from "./camera2d.ts";
+import type { FogOptions } from "./fog.ts";
 import Frustum, { type FrustumOptions } from "./frustum.ts";
+export type { Fog3dState, FogMode, FogOptions } from "./fog.ts";
 /**
  * A perspective camera that extends {@link Camera2d} with a view
  * {@link Frustum} (fov / aspect / near / far) and orientation
@@ -30,9 +30,11 @@ import Frustum, { type FrustumOptions } from "./frustum.ts";
  *   farther from the camera and renders smaller. Matches melonJS's
  *   2D conventions so existing Camera2d code translates directly.
  * - **Rotations are extrinsic XY.** `pitch` (X axis, look up/down) and
- *   `yaw` (Y axis, look left/right). There is no roll: the inherited
- *   `Camera2d.rotation` is not read by the view transform or the frustum
- *   rebuild, so a screen-plane bank has no effect on a 3D camera.
+ *   `yaw` (Y axis, look left/right) and `roll` (Z axis, bank the horizon).
+ *   The view is `R(yaw) ∘ R(pitch) ∘ R(roll)` inverted; the frustum planes are
+ *   extracted from that same matrix, so culling follows a banked view. The
+ *   inherited `currentTransform` is still NOT read — `camera.rotate()` on a
+ *   3D camera does nothing, so set `roll` rather than rotating the camera.
  * - **Follow offset (PR B scope).** When a target is set,
  *   `followOffset` is applied in **world space**:
  *   `camera.pos = target.pos + followOffset`. Target-rotation-aware
@@ -93,6 +95,25 @@ export default class Camera3d extends Camera2d {
      * @default 0
      */
     yaw: number;
+    /**
+     * Z-axis rotation in radians (bank the horizon). Positive values
+     * roll the camera clockwise, so the world tilts anticlockwise —
+     * the view from a cockpit banking right.
+     *
+     * Completes the `pitch` / `yaw` / `roll` trio. Note this is NOT the
+     * inherited {@link Renderable#rotation}: a 3D camera builds its view
+     * from these three angles and never reads `currentTransform`, which
+     * is why `camera.rotate()` on a `Camera3d` is silently inert. A
+     * `Camera2d` is the other way round — it has no `roll` because a
+     * screen-plane rotation IS its only rotation, and `rotate()` already
+     * does it through `currentTransform`.
+     * @default 0
+     * @example
+     * // bank with the player's steering, as a flight game would
+     * camera.roll = (player.pos.x / PLAY_BOUND_X) * MAX_BANK;
+     */
+    get roll(): number;
+    set roll(value: number);
     /**
      * World-space offset from the followed target. When `target` is
      * set via {@link Camera2d#follow}, the camera position resolves to
@@ -158,6 +179,90 @@ export default class Camera3d extends Camera2d {
      * @returns this camera (chainable)
      */
     setClipPlanes(near: number, far: number): this;
+    /**
+     * Enable, reconfigure, or switch off distance fog for this camera.
+     *
+     * Fog fades mesh geometry toward a colour with distance, which is what
+     * stops a 3D scene reading as flat cut-outs and lets props appear at the
+     * far plane without a visible edge. It is **off until you call this**, and
+     * a scene that never does renders exactly as it did before.
+     *
+     * Two curves, chosen with `mode`:
+     *
+     * | mode | parameters | character |
+     * | --- | --- | --- |
+     * | `"linear"` (default) | `near`, `far` | you name the two distances |
+     * | `"exp2"` | `density` | clear up close, closes fast at range |
+     *
+     * Every parameter is optional, and an omitted one is **resolved live each
+     * frame** rather than captured here: distances track the camera's own clip
+     * planes and the colour tracks `renderer.backgroundColor`. That is
+     * deliberate — fog distances that silently disagreed with the clip planes
+     * after a later {@link Camera3d#setClipPlanes} call would clip geometry
+     * before it finished fading, and a fog colour that did not follow a
+     * day/night background fade would leave a band at the horizon.
+     *
+     * Fog is per camera, so a split-screen or minimap view fogs independently
+     * — and a `Camera2d` never fogs at all.
+     *
+     * `heightFalloff` adds a second falloff with altitude, so mist pools in low
+     * ground instead of hanging at every height equally. It defaults to 0,
+     * which is uniform fog — not a special case, the same integral with the
+     * dial at zero.
+     * @param options - fog settings, or `null` to switch fog off
+     * @returns this camera (chainable)
+     * @throws {Error} on an unknown `mode`, a non-finite or negative distance,
+     * `far` at or below `near`, or a density at or below zero
+     * @example
+     * // A typical outdoor scene: set the sky, size the frustum to the level,
+     * // then let fog take its distances and its colour from both.
+     * class GameStage extends Stage {
+     *   onResetEvent(app) {
+     *     app.renderer.backgroundColor.parseCSS("#cfe6f7");
+     *
+     *     const camera = app.viewport; // a Camera3d
+     *     camera.setClipPlanes(1, 9000);
+     *     // no colour passed: it tracks `backgroundColor`, so the terrain
+     *     // dissolves into the sky and props arrive without a hard edge
+     *     camera.setFog({ near: 1200, far: 7000 });
+     *   }
+     * }
+     * @example
+     * // A single density instead of two distances. Omit it and it resolves to
+     * // `2 / far`, which reads the same at any world scale.
+     * camera.setFog({ mode: "exp2", density: 0.0004 });
+     * @example
+     * // Fog that is deliberately NOT the sky — a green murk under a blue sky.
+     * // Passing a `Color` keeps it by reference, so this fog can be animated
+     * // by mutating the colour, without calling `setFog` again.
+     * const murk = new Color(90, 120, 80);
+     * camera.setFog({ far: 5000, color: murk });
+     * murk.setColor(60, 90, 55); // thickens over the next frame
+     * @example
+     * // Mist pooling in a valley: dense along the floor, thinning up the
+     * // walls so the tree line stays crisp. Render space is Y-down, so
+     * // `fogHeight` is the floor and density rises BELOW it.
+     * camera.setFog({
+     *   near: 1200,
+     *   far: 7000,
+     *   fogHeight: 0,
+     *   heightFalloff: 0.0015,
+     * });
+     * @example
+     * // Everything is optional: with nothing at all, fog spans the camera's
+     * // own clip planes in the backdrop's colour.
+     * camera.setFog({});
+     * camera.setFog(null); // and off again
+     * @see Camera3d#setClipPlanes
+     * @see Mesh#fog
+     */
+    setFog(options: FogOptions | null): this;
+    /**
+     * The fog settings as given to {@link Camera3d#setFog}, or `null` when fog
+     * is off. The omitted fields are not filled in here — they are resolved
+     * per frame against the clip planes and the renderer's background colour.
+     */
+    get fog(): FogOptions | null;
     /**
      * Write the camera's world-space orientation basis into the given vectors:
      * `right` (camera local +X), `up` (+Y), and `forward` (+Z — the direction the
@@ -189,27 +294,6 @@ export default class Camera3d extends Camera2d {
      * @returns `out`
      */
     getForward(out: Vector3d): Vector3d;
-    /**
-     * Rebuild the projection matrix from the frustum. Called by the
-     * base `Camera2d` constructor and by `resize()`. Camera3d's
-     * version replaces the ortho matrix with the frustum's perspective.
-     * @ignore
-     */
-    _updateProjectionMatrix(): void;
-    /**
-     * Override Camera2d's non-default projection setup so that a Camera3d
-     * used in split-screen / picture-in-picture still renders the world
-     * with perspective instead of falling back to a 2D ortho. The
-     * camera's perspective `projectionMatrix` is mirrored into
-     * `worldProjection`; the surrounding `clipRect` set by the base
-     * `draw()` handles confining the draw region to the camera's
-     * sub-screen rect, and the frustum's `aspect` is already in sync
-     * with the camera's width/height. `screenProjection` is left alone
-     * because it was already set up correctly in
-     * {@link Camera3d#_updateProjectionMatrix}.
-     * @ignore
-     */
-    _setupNonDefaultProjection(renderer: Renderer): void;
     /**
      * Resize the camera viewport and recompute aspect ratio.
      * @param w - new width
@@ -217,23 +301,6 @@ export default class Camera3d extends Camera2d {
      * @returns this camera
      */
     resize(w: number, h: number): this;
-    /**
-     * Apply the camera's full 3D view transform to the world container.
-     * Order: rotate first (pitch, yaw), then translate by `-camera.pos`.
-     * Post-multiplication semantics give us
-     * `currentTransform = R⁻¹ ∘ T(-pos)` — applied to a world point,
-     * this subtracts the camera position then rotates by the camera's
-     * inverse orientation, which is the standard view transform.
-     * @ignore
-     */
-    _applyContainerViewTransform(container: Container, translateX: number, translateY: number): void;
-    /**
-     * Revert {@link Camera3d#_applyContainerViewTransform} in reverse
-     * order to restore the container's `currentTransform` to its
-     * pre-camera state.
-     * @ignore
-     */
-    _revertContainerViewTransform(container: Container, translateX: number, translateY: number): void;
     /**
      * Point the camera at a world-space target by deriving pitch and
      * yaw from the direction (target − camera.pos). Roll is unaffected.
@@ -275,27 +342,6 @@ export default class Camera3d extends Camera2d {
      * @returns this camera
      */
     setFollowOffset(x: number, y: number, z: number): this;
-    /**
-     * Override Camera2d's 2D follow logic to additionally resolve
-     * `followOffset` against the target's z. When `target` is set, the
-     * camera's world position becomes `target.pos + followOffset`.
-     *
-     * **Semantic change vs Camera2d.follow:** this override **does not
-     * honor `follow_axis`, `deadzone`, or `smoothFollow` / `damping`**.
-     * Camera3d tracks its target exactly each frame because the typical
-     * 3D use case (behind-the-plane follow-cam, third-person orbit) wants
-     * 1:1 tracking with no scroll-deadzone. If you need damped or
-     * axis-constrained follow under perspective, set `target = null` and
-     * lerp `camera.pos` toward the target manually in your `update()`.
-     *
-     * **PR B scope:** `followOffset` is treated as **world-space**.
-     * Target-rotation-aware follow (where the offset rotates with the
-     * target's orientation, spring-arm style) lands when a
-     * showcase (AfterBurner's banking jet) demands it.
-     * @param dt - delta time in milliseconds (ignored — no damping)
-     * @ignore
-     */
-    updateTarget(dt?: number): void;
     /**
      * Visibility check used by `Container.update` (in turn driving
      * `Container.draw`) to skip rendering off-screen children.
@@ -347,16 +393,6 @@ export default class Camera3d extends Camera2d {
         broadphase: unknown;
         sortOn: string;
     }, out?: Renderable[]): Renderable[];
-    /**
-     * Per-frame update — extends Camera2d's behavior (target follow,
-     * camera effects) with rebuilding the frustum's six bounding
-     * planes so {@link Camera3d#isVisible} returns accurate results
-     * for the current camera state.
-     * @param dt - delta time in milliseconds
-     * @returns true if the camera's state changed
-     * @ignore
-     */
-    update(dt?: number): boolean;
     /**
      * Project a world-space point to 2D screen (canvas pixel) coordinates
      * through this camera's view + perspective projection (perspective divide
@@ -374,13 +410,5 @@ export default class Camera3d extends Camera2d {
      * @returns the screen-space pixel coordinates, or `null` if behind the camera
      */
     worldToScreen(world: Vector3d, out?: Vector2d): Vector2d | null;
-    /**
-     * Recompute the frustum's six bounding planes from the current
-     * `projectionMatrix × viewMatrix` (the world → clip matrix).
-     * Called from {@link Camera3d#update} each frame; `isVisible`
-     * then tests against the cached planes.
-     * @ignore
-     */
-    _rebuildFrustumPlanes(): void;
 }
 //# sourceMappingURL=camera3d.d.ts.map

package/build/camera/camera3d.d.ts.map

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

package/build/camera/effects/fade_effect.d.ts

@@ -34,11 +34,6 @@ export default class FadeEffect extends CameraEffect {
      * fade direction: "in" fades to the color, "out" fades from the color back to transparent
      */
     direction: "in" | "out";
-    /**
-     * target alpha value for completion check
-     * @ignore
-     */
-    _targetAlpha: number;
     /**
      * @param camera - the camera to apply the fade to
      * @param options - fade parameters

package/build/camera/effects/fade_effect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fade_effect.d.ts","sourceRoot":"","sources":["../../../src/camera/effects/fade_effect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAC;AAE/C,OAAO,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAC3C,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAE9C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,YAAY;IACnD;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,SAAS,EAAE,IAAI,GAAG,KAAK,CAAC;IAExB;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;;;;;OAOG;gBAEF,MAAM,EAAE,QAAQ,EAChB,OAAO,EAAE;QACR,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC9B,SAAS,CAAC,EAAE,IAAI,GAAG,KAAK,GAAG,SAAS,CAAC;QACrC,UAAU,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;KACtC;IA4BO,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAY7D,MAAM,IAAI,IAAI;IASd,OAAO,IAAI,IAAI;CAiBxB"}
+{"version":3,"file":"fade_effect.d.ts","sourceRoot":"","sources":["../../../src/camera/effects/fade_effect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAC;AAE/C,OAAO,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAC3C,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAE9C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,YAAY;IACnD;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,SAAS,EAAE,IAAI,GAAG,KAAK,CAAC;IASxB;;;;;;;OAOG;gBAEF,MAAM,EAAE,QAAQ,EAChB,OAAO,EAAE;QACR,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC9B,SAAS,CAAC,EAAE,IAAI,GAAG,KAAK,GAAG,SAAS,CAAC;QACrC,UAAU,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;KACtC;IA4BO,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAY7D,MAAM,IAAI,IAAI;IASd,OAAO,IAAI,IAAI;CAiBxB"}

package/build/camera/effects/mask_effect.d.ts

@@ -59,11 +59,6 @@ export default class MaskEffect extends CameraEffect {
      * optional callback when transition completes
      */
     onComplete: (() => void) | undefined;
-    /**
-     * pooled shape used for rendering (avoids per-frame allocation)
-     * @ignore
-     */
-    _maskShape: MaskShape;
     /**
      * @param camera - the camera to apply the transition to
      * @param options - transition parameters

package/build/camera/effects/mask_effect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mask_effect.d.ts","sourceRoot":"","sources":["../../../src/camera/effects/mask_effect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAe,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,OAAO,EAAe,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAC;AAE/C,OAAO,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAC3C,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAE9C,KAAK,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,YAAY;IACnD;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,KAAK,EAAE,SAAS,CAAC;IAEjB;;OAEG;IACH,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAE5B;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,SAAS,EAAE,MAAM,GAAG,QAAQ,CAAC;IAE7B;;OAEG;IACH,UAAU,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IAErC;;;OAGG;IACH,UAAU,EAAE,SAAS,CAAC;IAEtB;;;;;;;;OAQG;gBAEF,MAAM,EAAE,QAAQ,EAChB,OAAO,EAAE;QACR,KAAK,EAAE,SAAS,CAAC;QACjB,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC9B,SAAS,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;QAC1C,UAAU,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;KACtC;IA+BO,MAAM,IAAI,IAAI;IAmCd,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAwB7D,OAAO,IAAI,IAAI;CAqBxB"}
+{"version":3,"file":"mask_effect.d.ts","sourceRoot":"","sources":["../../../src/camera/effects/mask_effect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAe,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,OAAO,EAAe,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAC;AAE/C,OAAO,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAC3C,OAAO,YAAY,MAAM,oBAAoB,CAAC;AAE9C,KAAK,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,YAAY;IACnD;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,KAAK,EAAE,SAAS,CAAC;IAEjB;;OAEG;IACH,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAE5B;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,SAAS,EAAE,MAAM,GAAG,QAAQ,CAAC;IAE7B;;OAEG;IACH,UAAU,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IASrC;;;;;;;;OAQG;gBAEF,MAAM,EAAE,QAAQ,EAChB,OAAO,EAAE;QACR,KAAK,EAAE,SAAS,CAAC;QACjB,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC9B,SAAS,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;QAC1C,UAAU,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;KACtC;IA+BO,MAAM,IAAI,IAAI;IAmCd,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAwB7D,OAAO,IAAI,IAAI;CAqBxB"}

package/build/camera/fog.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Distance-fog types, in their own module so `Camera2d` can declare the
+ * resolver hook that `Camera3d` overrides without the two importing each
+ * other.
+ */
+import type { Color } from "../math/color.ts";
+/**
+ * Which curve maps distance to fog density.
+ *
+ * `"linear"` is parameterised by two distances and `"exp2"` by a single
+ * density — the two parameterisations inherited from fixed-function graphics
+ * pipelines, and still what stylised scenes want.
+ */
+export type FogMode = "linear" | "exp2";
+/**
+ * {@link Camera3d#setFog} options. Every field is optional: the defaults are
+ * resolved live each frame, so fog stays consistent with the camera and the
+ * backdrop instead of drifting out of step with them.
+ *
+ * The values you DO pass are read once, at the call. Mutating this object
+ * afterwards has no effect — and would have skipped `setFog`'s validation if it
+ * did. The one live handle is a {@link Color} passed as `color`, which is kept
+ * by reference so it can be animated; see that field.
+ */
+export interface FogOptions {
+    /**
+     * the curve mapping distance to density.
+     * @default "linear"
+     */
+    mode?: FogMode;
+    /**
+     * linear only — distance at which fog starts. Omit and it tracks the
+     * camera's own `near` clip plane.
+     */
+    near?: number;
+    /**
+     * linear only — distance at which fog fully hides the scene. Omit and it
+     * tracks the camera's own `far` clip plane, which is what keeps geometry
+     * from clipping before it has finished fading.
+     */
+    far?: number;
+    /**
+     * exp2 only — how fast the scene colour is lost with distance. Omit and it
+     * resolves to `2 / far`, leaving a few percent of the scene colour at the
+     * far plane whatever the world scale.
+     */
+    density?: number;
+    /**
+     * fog colour. Omit and it tracks `renderer.backgroundColor` live, so
+     * geometry dissolves into the backdrop with no extra work — including
+     * through a day/night fade. A {@link Color} is kept **by reference**, so
+     * mutating it animates the fog; a CSS string or `[r, g, b]` in 0..1 is
+     * parsed into a colour this camera owns.
+     */
+    color?: Color | string | [number, number, number];
+    /**
+     * World Y at which the fog is at its reference density. Only meaningful
+     * alongside a non-zero {@link FogOptions.heightFalloff}.
+     * @default 0
+     */
+    fogHeight?: number;
+    /**
+     * How fast fog density drops with altitude, so mist pools in low ground
+     * instead of filling the sky as readily as the valley floor.
+     *
+     * **Zero — the default — is uniform fog**, which is the fog that shipped
+     * without this: `exp(0)` is 1, density is the same at every altitude, and
+     * the maths collapses exactly. Raise it and density falls off above
+     * `fogHeight`, leaving ridges and sky clear while the hollows stay thick.
+     *
+     * Render space is **Y-down**, so density rises as `y` INCREASES — the
+     * opposite sign to every published height-fog formula, which assume Y-up.
+     * @default 0
+     */
+    heightFalloff?: number;
+}
+/**
+ * The resolved per-frame fog values handed to the renderer. Distances are
+ * pre-baked into the form the shaders want so neither backend divides.
+ * Hidden from the docs but deliberately kept in the emitted `.d.ts`:
+ * `camera3d.d.ts` imports this type, so removing it would leave a dangling
+ * import in the published types.
+ * @ignore
+ */
+export interface Fog3dState {
+    /** 1 = linear, 2 = exp2 (0 never reaches the renderer — null does) */
+    mode: number;
+    /** linear: distance at which fog starts */
+    near: number;
+    /** linear: 1 / (far - near) */
+    invRange: number;
+    /** exp2: density */
+    density: number;
+    /** straight (unpremultiplied) fog colour, 3 components in 0..1 */
+    color: Float32Array;
+    /**
+     * The height falloff folded into the world-up axis, expressed in VIEW
+     * space — 3 components. The shaders need the fragment's height above the
+     * camera, and the matrix they have is not the camera's view alone:
+     * `Container.draw` folds every ancestor into it, so the position the
+     * vertex stage computes is the mesh's parent space rather than the world.
+     * Dotting this against the view-space position recovers the world height
+     * difference whatever those ancestors do — scale, rotation or both — and
+     * carries the falloff with it, so the shader's exponent is one dot
+     * product. All zero when the falloff is 0, which is what makes uniform
+     * fog fall out of the same expression rather than needing a branch.
+     */
+    heightAxis: Float32Array;
+    /**
+     * The altitude term of the height integral, `exp(k * (cameraY -
+     * fogHeight))`, evaluated once per frame here rather than per vertex in
+     * the shader — both operands are camera-global. Clamped before the
+     * exponential: a camera far below the reference height would otherwise
+     * overflow it and whiten the frame. Exactly 1 when the falloff is 0.
+     */
+    heightBase: number;
+}
+//# sourceMappingURL=fog.d.ts.map

package/build/camera/fog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fog.d.ts","sourceRoot":"","sources":["../../src/camera/fog.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;AAExC;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IAC1B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IAC1B,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,kEAAkE;IAClE,KAAK,EAAE,YAAY,CAAC;IACpB;;;;;;;;;;;OAWG;IACH,UAAU,EAAE,YAAY,CAAC;IACzB;;;;;;OAMG;IACH,UAAU,EAAE,MAAM,CAAC;CACnB"}

package/build/geometries/box3d.d.ts

@@ -1,7 +1,6 @@
 import { Vector3d } from "../math/vector3d.ts";
 import { Bounds } from "../physics/bounds.ts";
 import { AABB3d } from "../physics/broadphase/aabb3d.ts";
-import { Polygon } from "./polygon.ts";
 /**
  * An axis-aligned 3D box, usable as a {@link Body} collision shape.
  *
@@ -54,22 +53,6 @@ export declare class Box3d {
      * @default "Box3d"
      */
     type: string;
-    /**
-     * 2D XY footprint, kept in sync by {@link Box3d#setShape}. This is what
-     * {@link Box3d#getBounds} hands back, so every legacy 2D consumer
-     * ({@link Body#bounds}, the broadphase pre-gate, debug draw) sees a
-     * plain rectangle and needs no 3D awareness.
-     * @ignore
-     */
-    _bounds: Bounds;
-    /**
-     * XY footprint as a {@link Polygon}, kept in sync by
-     * {@link Box3d#setShape}. The degraded `Box3d` × planar-shape tests
-     * hand this to the existing polygon SAT, so no polygon is allocated
-     * per collision test.
-     * @ignore
-     */
-    _footprint: Polygon;
     /**
      * @param x - center of the box on the horizontal axis
      * @param y - center of the box on the vertical axis
@@ -90,17 +73,6 @@ export declare class Box3d {
      * @returns this box, for chaining
      */
     setShape(x: number, y: number, z: number, width: number, height: number, depth: number): this;
-    /**
-     * Rebuild the cached XY footprint (both the {@link Bounds} and the
-     * {@link Polygon}) from the current center and half-extents.
-     *
-     * The footprint polygon's `pos` is the **min corner**, not the center,
-     * because the SAT narrowphase resolves a shape's absolute position as
-     * `renderable.pos + ancestor.getAbsolutePosition() + shape.pos` and
-     * then treats `points` as offsets from it.
-     * @ignore
-     */
-    _syncFootprint(): void;
     /**
      * width of the box
      */