@woosh/meep-engine 3.49.0 → 3.50.0

package/src/core/geom/clipmap/clipmap_select_finest.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The finest level of a 3-D clipmap whose window holds a point, and how far into that window's edge
+ * band the point is. The CPU twin of `chunk_clipmap_select_finest`.
+ *
+ * Levels are walked finest first; the first whose window holds the cell the point is in answers. Its
+ * edge weight is the point's distance to the window's nearest face, in the level's cells, read
+ * through a linear ramp: 0 at `band_width` cells or deeper, 1 on the face — how much a reader blends
+ * toward the next coarser source.
+ *
+ * @param {ClipmapWindowSet} windows a 3-D set
+ * @param {ArrayLike<number>} cell_sizes per level, world units on a side of its cell
+ * @param {number} x world position
+ * @param {number} y
+ * @param {number} z
+ * @param {number} band_width cells, positive
+ * @param {Float64Array|number[]} out receives the edge weight at 0; 0 when no level holds the point
+ * @returns {number} the level, or -1 when no level holds the point
+ */
+export function clipmap_select_finest(windows: ClipmapWindowSet, cell_sizes: ArrayLike<number>, x: number, y: number, z: number, band_width: number, out: Float64Array | number[]): number;
+//# sourceMappingURL=clipmap_select_finest.d.ts.map

package/src/core/geom/clipmap/clipmap_select_finest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipmap_select_finest.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/clipmap/clipmap_select_finest.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,6EARW,UAAU,MAAM,CAAC,KACjB,MAAM,KACN,MAAM,KACN,MAAM,cACN,MAAM,OACN,YAAY,GAAC,MAAM,EAAE,GACnB,MAAM,CAkClB"}

package/src/core/geom/clipmap/clipmap_select_finest.js

@@ -0,0 +1,53 @@
+import { assert } from "../../assert.js";
+
+/**
+ * The finest level of a 3-D clipmap whose window holds a point, and how far into that window's edge
+ * band the point is. The CPU twin of `chunk_clipmap_select_finest`.
+ *
+ * Levels are walked finest first; the first whose window holds the cell the point is in answers. Its
+ * edge weight is the point's distance to the window's nearest face, in the level's cells, read
+ * through a linear ramp: 0 at `band_width` cells or deeper, 1 on the face — how much a reader blends
+ * toward the next coarser source.
+ *
+ * @param {ClipmapWindowSet} windows a 3-D set
+ * @param {ArrayLike<number>} cell_sizes per level, world units on a side of its cell
+ * @param {number} x world position
+ * @param {number} y
+ * @param {number} z
+ * @param {number} band_width cells, positive
+ * @param {Float64Array|number[]} out receives the edge weight at 0; 0 when no level holds the point
+ * @returns {number} the level, or -1 when no level holds the point
+ */
+export function clipmap_select_finest(windows, cell_sizes, x, y, z, band_width, out) {
+    assert.equal(windows.dimensions, 3, 'windows.dimensions');
+    assert.greaterThan(band_width, 0, 'band_width');
+
+    const size = windows.size;
+    const level_count = windows.level_count;
+
+    for (let level = 0; level < level_count; level++) {
+        const cell_size = cell_sizes[level];
+
+        const cx = x / cell_size;
+        const cy = y / cell_size;
+        const cz = z / cell_size;
+
+        if (!windows.contains(level, Math.floor(cx), Math.floor(cy), Math.floor(cz))) {
+            continue;
+        }
+
+        const lx = cx - windows.corner(level, 0);
+        const ly = cy - windows.corner(level, 1);
+        const lz = cz - windows.corner(level, 2);
+
+        const edge = Math.min(lx, ly, lz, size[0] - lx, size[1] - ly, size[2] - lz);
+
+        out[0] = Math.min(1, Math.max(0, 1 - edge / band_width));
+
+        return level;
+    }
+
+    out[0] = 0;
+
+    return -1;
+}

package/src/core/geom/clipmap/quantize_hysteretic.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Snap a coordinate to a lattice of steps, holding the step it is at until the coordinate has gone a
+ * margin past half-way to the next one — so a coordinate dithering across the half-way point does not
+ * move the result back and forth.
+ *
+ * Holds `current` unless `|raw − current·step| > 0.5·step + hysteresis`. Past that it takes the step
+ * nearest `raw`, not the one at the threshold, so a single large move is a single re-placement. A
+ * first placement (`placed` false) has nothing to hold and takes the nearest step outright, with no
+ * hysteresis. A tie between two steps goes up, as `Math.round` takes it.
+ *
+ * Everything is in the caller's units: a fluid field's anchor passes cells with a step of 1, the
+ * virtual shadow map's depth range passes world units with a step of a quarter of its extent.
+ *
+ * @param {number} raw where the coordinate is
+ * @param {number} current the step it is held at, an integer: it sits at `current · step`
+ * @param {number} step the lattice's spacing
+ * @param {number} hysteresis the margin past half a step, not negative
+ * @param {boolean} placed false on the first placement, when `current` is not read
+ * @returns {number} the step it is held at now, an integer
+ */
+export function quantize_hysteretic(raw: number, current: number, step: number, hysteresis: number, placed: boolean): number;
+//# sourceMappingURL=quantize_hysteretic.d.ts.map

package/src/core/geom/clipmap/quantize_hysteretic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantize_hysteretic.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/clipmap/quantize_hysteretic.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yCAPW,MAAM,WACN,MAAM,QACN,MAAM,cACN,MAAM,UACN,OAAO,GACL,MAAM,CAYlB"}

package/src/core/geom/clipmap/quantize_hysteretic.js

@@ -0,0 +1,33 @@
+import { assert } from "../../assert.js";
+
+/**
+ * Snap a coordinate to a lattice of steps, holding the step it is at until the coordinate has gone a
+ * margin past half-way to the next one — so a coordinate dithering across the half-way point does not
+ * move the result back and forth.
+ *
+ * Holds `current` unless `|raw − current·step| > 0.5·step + hysteresis`. Past that it takes the step
+ * nearest `raw`, not the one at the threshold, so a single large move is a single re-placement. A
+ * first placement (`placed` false) has nothing to hold and takes the nearest step outright, with no
+ * hysteresis. A tie between two steps goes up, as `Math.round` takes it.
+ *
+ * Everything is in the caller's units: a fluid field's anchor passes cells with a step of 1, the
+ * virtual shadow map's depth range passes world units with a step of a quarter of its extent.
+ *
+ * @param {number} raw where the coordinate is
+ * @param {number} current the step it is held at, an integer: it sits at `current · step`
+ * @param {number} step the lattice's spacing
+ * @param {number} hysteresis the margin past half a step, not negative
+ * @param {boolean} placed false on the first placement, when `current` is not read
+ * @returns {number} the step it is held at now, an integer
+ */
+export function quantize_hysteretic(raw, current, step, hysteresis, placed) {
+    assert.greaterThan(step, 0, 'step');
+    assert.greaterThanOrEqual(hysteresis, 0, 'hysteresis');
+
+    // written as "move when past the threshold" so that a NaN coordinate holds where it is
+    if (!placed || Math.abs(raw - current * step) > 0.5 * step + hysteresis) {
+        return Math.round(raw / step);
+    }
+
+    return current;
+}

package/src/core/geom/clipmap/window_scroll_regions.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The cells a window exposes when its corner moves: the new window less the old, as disjoint boxes.
+ *
+ * - a slab of x for the columns the new window has and the old one does not, over the new window's
+ *   whole y and z;
+ * - then a slab of y for the rows it gained, over the x both windows share and the new window's whole z;
+ * - then, in 3-D, a slab of z for the layers it gained, over the x and the y both windows share.
+ *
+ * An axis that did not move gives no box. A move of the window's side or more on any axis keeps
+ * nothing, and gives the whole new window as one box.
+ *
+ * Over storage that wraps (a cell sits in `cell mod size`, see {@link ClipmapWindowSet}) the slots of
+ * the exposed cells are exactly the slots of the cells the window left, so the same boxes say which
+ * slots to clear and which to fill. Swap the corners to get the cells the window left instead.
+ *
+ * @param {ArrayLike<number>} old_corner the window's smallest cell before, one integer per axis
+ * @param {ArrayLike<number>} new_corner and after
+ * @param {ArrayLike<number>} size the window's side per axis, in cells
+ * @param {number} dimensions 2 or 3
+ * @param {Int32Array|number[]} out_boxes `2 · dimensions` integers a box — the smallest cell on each
+ * axis, then one past the largest on each axis — with room for `dimensions` boxes
+ * @returns {number} boxes written
+ */
+export function window_scroll_regions(old_corner: ArrayLike<number>, new_corner: ArrayLike<number>, size: ArrayLike<number>, dimensions: number, out_boxes: Int32Array | number[]): number;
+//# sourceMappingURL=window_scroll_regions.d.ts.map

package/src/core/geom/clipmap/window_scroll_regions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"window_scroll_regions.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/clipmap/window_scroll_regions.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,kDARW,UAAU,MAAM,CAAC,cACjB,UAAU,MAAM,CAAC,QACjB,UAAU,MAAM,CAAC,cACjB,MAAM,aACN,UAAU,GAAC,MAAM,EAAE,GAEjB,MAAM,CA6DlB"}

package/src/core/geom/clipmap/window_scroll_regions.js

@@ -0,0 +1,83 @@
+/**
+ * The cells a window exposes when its corner moves: the new window less the old, as disjoint boxes.
+ *
+ * - a slab of x for the columns the new window has and the old one does not, over the new window's
+ *   whole y and z;
+ * - then a slab of y for the rows it gained, over the x both windows share and the new window's whole z;
+ * - then, in 3-D, a slab of z for the layers it gained, over the x and the y both windows share.
+ *
+ * An axis that did not move gives no box. A move of the window's side or more on any axis keeps
+ * nothing, and gives the whole new window as one box.
+ *
+ * Over storage that wraps (a cell sits in `cell mod size`, see {@link ClipmapWindowSet}) the slots of
+ * the exposed cells are exactly the slots of the cells the window left, so the same boxes say which
+ * slots to clear and which to fill. Swap the corners to get the cells the window left instead.
+ *
+ * @param {ArrayLike<number>} old_corner the window's smallest cell before, one integer per axis
+ * @param {ArrayLike<number>} new_corner and after
+ * @param {ArrayLike<number>} size the window's side per axis, in cells
+ * @param {number} dimensions 2 or 3
+ * @param {Int32Array|number[]} out_boxes `2 · dimensions` integers a box — the smallest cell on each
+ * axis, then one past the largest on each axis — with room for `dimensions` boxes
+ * @returns {number} boxes written
+ */
+export function window_scroll_regions(old_corner, new_corner, size, dimensions, out_boxes) {
+    const stride = 2 * dimensions;
+
+    for (let axis = 0; axis < dimensions; axis++) {
+        if (Math.abs(new_corner[axis] - old_corner[axis]) >= size[axis]) {
+            // nothing kept: the whole new window
+            for (let a = 0; a < dimensions; a++) {
+                out_boxes[a] = new_corner[a];
+                out_boxes[dimensions + a] = new_corner[a] + size[a];
+            }
+
+            return 1;
+        }
+    }
+
+    let count = 0;
+
+    for (let axis = 0; axis < dimensions; axis++) {
+        const from = old_corner[axis];
+        const to = new_corner[axis];
+
+        if (from === to) {
+            continue;
+        }
+
+        const box = count * stride;
+
+        for (let a = 0; a < dimensions; a++) {
+            const old_a = old_corner[a];
+            const new_a = new_corner[a];
+
+            let min, max;
+
+            if (a < axis) {
+                // an axis already sliced: what both windows share on it
+                min = Math.max(old_a, new_a);
+                max = Math.min(old_a, new_a) + size[a];
+            } else if (a > axis) {
+                // an axis still to come: the whole new window on it
+                min = new_a;
+                max = new_a + size[a];
+            } else if (to > from) {
+                // moved up: gained at the top
+                min = from + size[a];
+                max = to + size[a];
+            } else {
+                // moved down: gained at the bottom
+                min = to;
+                max = from;
+            }
+
+            out_boxes[box + a] = min;
+            out_boxes[box + dimensions + a] = max;
+        }
+
+        count++;
+    }
+
+    return count;
+}

package/src/core/geom/vec3/v3_clamp_to_cone.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Clamp a direction into the cone of half-angle `spread` about `axis`: the direction of `d`, turned
+ * toward the axis just far enough that its angle to the axis is at most `spread`.
+ *
+ * It is `v3_slerp(axis, d̂, min(1, spread / θ))`, where `θ` is the angle between the axis and `d̂` by
+ * `v3_angle_stable`. That angle holds its relative precision at every angle in f32 as well as f64,
+ * where `acos` of the dot does not near 0 and π.
+ *
+ * - **Inside the cone** (`θ ≤ spread`, which is every direction once `spread` reaches π) the result
+ *   is `d̂`.
+ * - **Outside it**, the result lies on the cone's surface, in the plane of the axis and `d̂`.
+ * - **`spread` 0** collapses the cone onto the axis.
+ * - **`d` of no length** has no direction, and the result is the axis.
+ * - **`d` opposite the axis** has no plane to turn in. `v3_slerp`'s antipodal branch picks one, and the
+ *   result is at `spread` from the axis.
+ *
+ * ## Written out, not composed
+ *
+ * The angle and the slerp are `v3_angle_stable`'s and `v3_slerp`'s, branch for branch, written out in
+ * {@link v3_clamp_to_cone_array} with no call in between, and the slerp takes the angle already
+ * measured rather than `acos` of the dot (as the WGSL twin's `v3_slerp` does). Composed from the two,
+ * every clamp boxed its arguments to them, since neither inlined: 85 B a call in a stripped build,
+ * 101 B in a development one, and a fluid impulse's spread clamps once per face it touches. A loop
+ * that clamps per element calls the array form, which allocates nothing whether or not it inlines;
+ * this scalar form hands its numbers over through two retained arrays.
+ *
+ * The WGSL twin, `v3_clamp_to_cone` (`chunk_v3_clamp_to_cone`), is composed from twins of `v3_slerp`
+ * and `v3_angle_stable` that take the angle the same way, so the CPU and the device make the same
+ * choice in every case above, the antipode included. The exception is a band about 4.5e-4 rad short
+ * of opposite. There the dot is within f32's resolution of `v3_slerp`'s antipodal threshold, and the
+ * two can round to different branches.
+ *
+ * @param {number[]|Float32Array|Float64Array} out receives the unit result at `out_offset`
+ * @param {number} out_offset
+ * @param {number} d_x the direction to clamp, any length
+ * @param {number} d_y
+ * @param {number} d_z
+ * @param {number} axis_x the cone's axis, unit length
+ * @param {number} axis_y
+ * @param {number} axis_z
+ * @param {number} spread the cone's half-angle in radians, ≥ 0
+ */
+export function v3_clamp_to_cone(out: number[] | Float32Array | Float64Array, out_offset: number, d_x: number, d_y: number, d_z: number, axis_x: number, axis_y: number, axis_z: number, spread: number): void;
+/**
+ * {@link v3_clamp_to_cone} with its direction and cone read from arrays, and where its maths is: for a
+ * loop that clamps per element, where a direction handed over as three numbers, or a spread as one, is
+ * boxed into a heap object wherever V8 does not inline the call. Nothing in it calls out, so nothing is
+ * allocated whether or not it is inlined.
+ *
+ * @param {number[]|Float32Array|Float64Array} out receives the unit result at `out_offset`
+ * @param {number} out_offset
+ * @param {number[]|Float32Array|Float64Array} direction `[x, y, z]`, any length
+ * @param {number} direction_offset
+ * @param {number[]|Float32Array|Float64Array} cone `[axis_x, axis_y, axis_z, spread]`: the unit axis,
+ *   then the half-angle in radians, ≥ 0
+ * @param {number} cone_offset
+ */
+export function v3_clamp_to_cone_array(out: number[] | Float32Array | Float64Array, out_offset: number, direction: number[] | Float32Array | Float64Array, direction_offset: number, cone: number[] | Float32Array | Float64Array, cone_offset: number): void;
+//# sourceMappingURL=v3_clamp_to_cone.d.ts.map

package/src/core/geom/vec3/v3_clamp_to_cone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_clamp_to_cone.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_clamp_to_cone.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,sCAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,QAkBhB;AAED;;;;;;;;;;;;;GAaG;AACH,4CARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,oBAClC,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,eAElC,MAAM,QA4GhB"}

package/src/core/geom/vec3/v3_clamp_to_cone.js

@@ -0,0 +1,197 @@
+import { assert } from "../../assert.js";
+
+/**
+ * `v3_slerp`'s threshold for endpoints too nearly opposite to define a plane between them.
+ * @type {number}
+ */
+const ANTIPODAL_DOT = -1 + 1e-7;
+
+/**
+ * Clamp a direction into the cone of half-angle `spread` about `axis`: the direction of `d`, turned
+ * toward the axis just far enough that its angle to the axis is at most `spread`.
+ *
+ * It is `v3_slerp(axis, d̂, min(1, spread / θ))`, where `θ` is the angle between the axis and `d̂` by
+ * `v3_angle_stable`. That angle holds its relative precision at every angle in f32 as well as f64,
+ * where `acos` of the dot does not near 0 and π.
+ *
+ * - **Inside the cone** (`θ ≤ spread`, which is every direction once `spread` reaches π) the result
+ *   is `d̂`.
+ * - **Outside it**, the result lies on the cone's surface, in the plane of the axis and `d̂`.
+ * - **`spread` 0** collapses the cone onto the axis.
+ * - **`d` of no length** has no direction, and the result is the axis.
+ * - **`d` opposite the axis** has no plane to turn in. `v3_slerp`'s antipodal branch picks one, and the
+ *   result is at `spread` from the axis.
+ *
+ * ## Written out, not composed
+ *
+ * The angle and the slerp are `v3_angle_stable`'s and `v3_slerp`'s, branch for branch, written out in
+ * {@link v3_clamp_to_cone_array} with no call in between, and the slerp takes the angle already
+ * measured rather than `acos` of the dot (as the WGSL twin's `v3_slerp` does). Composed from the two,
+ * every clamp boxed its arguments to them, since neither inlined: 85 B a call in a stripped build,
+ * 101 B in a development one, and a fluid impulse's spread clamps once per face it touches. A loop
+ * that clamps per element calls the array form, which allocates nothing whether or not it inlines;
+ * this scalar form hands its numbers over through two retained arrays.
+ *
+ * The WGSL twin, `v3_clamp_to_cone` (`chunk_v3_clamp_to_cone`), is composed from twins of `v3_slerp`
+ * and `v3_angle_stable` that take the angle the same way, so the CPU and the device make the same
+ * choice in every case above, the antipode included. The exception is a band about 4.5e-4 rad short
+ * of opposite. There the dot is within f32's resolution of `v3_slerp`'s antipodal threshold, and the
+ * two can round to different branches.
+ *
+ * @param {number[]|Float32Array|Float64Array} out receives the unit result at `out_offset`
+ * @param {number} out_offset
+ * @param {number} d_x the direction to clamp, any length
+ * @param {number} d_y
+ * @param {number} d_z
+ * @param {number} axis_x the cone's axis, unit length
+ * @param {number} axis_y
+ * @param {number} axis_z
+ * @param {number} spread the cone's half-angle in radians, ≥ 0
+ */
+export function v3_clamp_to_cone(
+    out, out_offset,
+    d_x, d_y, d_z,
+    axis_x, axis_y, axis_z,
+    spread
+) {
+    SCALAR_DIRECTION[0] = d_x;
+    SCALAR_DIRECTION[1] = d_y;
+    SCALAR_DIRECTION[2] = d_z;
+
+    SCALAR_CONE[0] = axis_x;
+    SCALAR_CONE[1] = axis_y;
+    SCALAR_CONE[2] = axis_z;
+    SCALAR_CONE[3] = spread;
+
+    v3_clamp_to_cone_array(out, out_offset, SCALAR_DIRECTION, 0, SCALAR_CONE, 0);
+}
+
+/**
+ * {@link v3_clamp_to_cone} with its direction and cone read from arrays, and where its maths is: for a
+ * loop that clamps per element, where a direction handed over as three numbers, or a spread as one, is
+ * boxed into a heap object wherever V8 does not inline the call. Nothing in it calls out, so nothing is
+ * allocated whether or not it is inlined.
+ *
+ * @param {number[]|Float32Array|Float64Array} out receives the unit result at `out_offset`
+ * @param {number} out_offset
+ * @param {number[]|Float32Array|Float64Array} direction `[x, y, z]`, any length
+ * @param {number} direction_offset
+ * @param {number[]|Float32Array|Float64Array} cone `[axis_x, axis_y, axis_z, spread]`: the unit axis,
+ *   then the half-angle in radians, ≥ 0
+ * @param {number} cone_offset
+ */
+export function v3_clamp_to_cone_array(out, out_offset, direction, direction_offset, cone, cone_offset) {
+    const d_x = direction[direction_offset];
+    const d_y = direction[direction_offset + 1];
+    const d_z = direction[direction_offset + 2];
+
+    const axis_x = cone[cone_offset];
+    const axis_y = cone[cone_offset + 1];
+    const axis_z = cone[cone_offset + 2];
+    const spread = cone[cone_offset + 3];
+
+    assert.notNaN(spread, 'spread');
+    assert.greaterThanOrEqual(spread, 0, 'spread');
+
+    const d_length = Math.sqrt(d_x * d_x + d_y * d_y + d_z * d_z);
+
+    if (d_length === 0) {
+        out[out_offset] = axis_x;
+        out[out_offset + 1] = axis_y;
+        out[out_offset + 2] = axis_z;
+
+        return;
+    }
+
+    const inverse_length = 1 / d_length;
+
+    const u_x = d_x * inverse_length;
+    const u_y = d_y * inverse_length;
+    const u_z = d_z * inverse_length;
+
+    // v3_angle_stable(axis, u)
+    const c_x = axis_y * u_z - axis_z * u_y;
+    const c_y = axis_z * u_x - axis_x * u_z;
+    const c_z = axis_x * u_y - axis_y * u_x;
+
+    const dot = axis_x * u_x + axis_y * u_y + axis_z * u_z;
+
+    const theta = Math.atan2(Math.sqrt(c_x * c_x + c_y * c_y + c_z * c_z), dot);
+
+    if (theta <= spread) {
+        // inside the cone: min(1, spread / θ) is 1, and the arc ends at d̂
+        out[out_offset] = u_x;
+        out[out_offset + 1] = u_y;
+        out[out_offset + 2] = u_z;
+
+        return;
+    }
+
+    // v3_slerp(axis, u, fraction), with fraction in [0, 1) since θ > spread ≥ 0, and θ > 0
+    const fraction = spread / theta;
+
+    if (dot <= ANTIPODAL_DOT) {
+        if (fraction <= 0) {
+            out[out_offset] = axis_x;
+            out[out_offset + 1] = axis_y;
+            out[out_offset + 2] = axis_z;
+
+            return;
+        }
+
+        // the axis crossed with the principal axis it is least aligned with, which is well conditioned
+        const abs_x = Math.abs(axis_x);
+        const abs_y = Math.abs(axis_y);
+        const abs_z = Math.abs(axis_z);
+
+        let o_x, o_y, o_z;
+
+        if (abs_x <= abs_y && abs_x <= abs_z) {
+            o_x = 0;
+            o_y = -axis_z;
+            o_z = axis_y;
+        } else if (abs_y <= abs_z) {
+            o_x = -axis_z;
+            o_y = 0;
+            o_z = axis_x;
+        } else {
+            o_x = -axis_y;
+            o_y = axis_x;
+            o_z = 0;
+        }
+
+        const inverse_o_length = 1 / Math.sqrt(o_x * o_x + o_y * o_y + o_z * o_z);
+
+        o_x *= inverse_o_length;
+        o_y *= inverse_o_length;
+        o_z *= inverse_o_length;
+
+        const angle = Math.PI * fraction;
+
+        const cos_angle = Math.cos(angle);
+        const sin_angle = Math.sin(angle);
+
+        out[out_offset] = axis_x * cos_angle + o_x * sin_angle;
+        out[out_offset + 1] = axis_y * cos_angle + o_y * sin_angle;
+        out[out_offset + 2] = axis_z * cos_angle + o_z * sin_angle;
+
+        return;
+    }
+
+    const inverse_sin_theta = 1 / Math.sin(theta);
+
+    const scale_0 = Math.sin((1 - fraction) * theta) * inverse_sin_theta;
+    const scale_1 = Math.sin(fraction * theta) * inverse_sin_theta;
+
+    out[out_offset] = axis_x * scale_0 + u_x * scale_1;
+    out[out_offset + 1] = axis_y * scale_0 + u_y * scale_1;
+    out[out_offset + 2] = axis_z * scale_0 + u_z * scale_1;
+}
+
+/**
+ * The scalar form's direction and cone, packed for the array form it delegates to.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_DIRECTION = new Float64Array(3);
+const SCALAR_CONE = new Float64Array(4);

package/src/core/math/falloff_quadratic.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Quadratic falloff of a normalised distance: `(1 − t)²` inside the support, `t < 1`, and 0 from its
+ * edge on.
+ *
+ * 1 at the centre, and 0 with zero slope at the edge, so a kernel weighted by it fades out without a
+ * step. The fluid effectors' deposits (impulse, wake, swirl) share it. The WGSL twin is
+ * `falloff_quadratic` (`chunk_falloff_quadratic`).
+ *
+ * @param {number} t normalised distance, `d / R`, ≥ 0
+ * @returns {number} the weight, in [0, 1]
+ */
+export function falloff_quadratic(t: number): number;
+//# sourceMappingURL=falloff_quadratic.d.ts.map

package/src/core/math/falloff_quadratic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"falloff_quadratic.d.ts","sourceRoot":"","sources":["../../../../src/core/math/falloff_quadratic.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,qCAHW,MAAM,GACJ,MAAM,CAUlB"}

package/src/core/math/falloff_quadratic.js

@@ -0,0 +1,20 @@
+/**
+ * Quadratic falloff of a normalised distance: `(1 − t)²` inside the support, `t < 1`, and 0 from its
+ * edge on.
+ *
+ * 1 at the centre, and 0 with zero slope at the edge, so a kernel weighted by it fades out without a
+ * step. The fluid effectors' deposits (impulse, wake, swirl) share it. The WGSL twin is
+ * `falloff_quadratic` (`chunk_falloff_quadratic`).
+ *
+ * @param {number} t normalised distance, `d / R`, ≥ 0
+ * @returns {number} the weight, in [0, 1]
+ */
+export function falloff_quadratic(t) {
+    if (t < 1) {
+        const s = 1 - t;
+
+        return s * s;
+    }
+
+    return 0;
+}

package/src/core/math/physics/fluid/vortex_swirl.d.ts

@@ -0,0 +1,40 @@
+/**
+ * # Vortex swirl: the tangential push about an axis, along a segment of it
+ *
+ *     swirl(x) = strength · (27/4) · (â × r⊥)/R · (1 − d/R)²,   0 from d = R on
+ *
+ * The segment runs from `position` along the unit axis `â` for `segment_length`, ≥ 0. `r⊥ = x − c(x)`,
+ * where `c(x)` is the point on the segment closest to `x`; `d = ‖r⊥‖`; `R` is `radius`.
+ *
+ * Beside the segment `r⊥` is perpendicular to `â`, and the speed is `strength·(27/4)·s·(1 − s)²` with
+ * `s = d/R`:
+ * - zero on the axis;
+ * - `strength` at `d = R/3`, its peak;
+ * - zero at `R`, with zero slope.
+ *
+ * Past an end `r⊥` leans along `â`, and the cross product turns only its part across the axis. A
+ * segment of no length is therefore a point vortex about the axis line through `position`. The swirl
+ * is right-handed about `â`, and flipping the axis reverses it.
+ *
+ * `r⊥` is never normalised: the cross product carries its length, so the swirl vanishes on the axis
+ * instead of dividing by zero there. Finite everywhere for `R > 0`.
+ *
+ * The WGSL twin is `vortex_swirl` (`chunk_vortex_swirl`).
+ *
+ * @param {number[]|Float32Array|Float64Array} out receives the swirl velocity at `out_offset`
+ * @param {number} out_offset
+ * @param {number} x_x the point the swirl is asked at
+ * @param {number} x_y
+ * @param {number} x_z
+ * @param {number} position_x where the segment starts, on the axis
+ * @param {number} position_y
+ * @param {number} position_z
+ * @param {number} axis_x `â`, the axis the swirl turns about, unit length
+ * @param {number} axis_y
+ * @param {number} axis_z
+ * @param {number} segment_length how far the segment runs along the axis, ≥ 0
+ * @param {number} radius `R`, the swirl's reach from the segment, > 0
+ * @param {number} strength the peak speed, at `R/3`
+ */
+export function vortex_swirl(out: number[] | Float32Array | Float64Array, out_offset: number, x_x: number, x_y: number, x_z: number, position_x: number, position_y: number, position_z: number, axis_x: number, axis_y: number, axis_z: number, segment_length: number, radius: number, strength: number): void;
+//# sourceMappingURL=vortex_swirl.d.ts.map

package/src/core/math/physics/fluid/vortex_swirl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vortex_swirl.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/fluid/vortex_swirl.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,kCAfW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,kBACN,MAAM,UACN,MAAM,YACN,MAAM,QA2ChB"}