@woosh/meep-engine 3.47.0 → 3.50.0

package/src/engine/physics/fluid/effector/record/fluid_effector_record_deposit.js

@@ -0,0 +1,409 @@
+import { assert } from "../../../../../core/assert.js";
+import { line3_compute_segment_closest_point_t } from "../../../../../core/geom/3d/line/line3_compute_segment_closest_point_t.js";
+import { v3_clamp_to_cone_array } from "../../../../../core/geom/vec3/v3_clamp_to_cone.js";
+import { falloff_quadratic } from "../../../../../core/math/falloff_quadratic.js";
+import { vortex_swirl } from "../../../../../core/math/physics/fluid/vortex_swirl.js";
+import { FluidEffectorRecordKind } from "./FluidEffectorRecordKind.js";
+
+/**
+ * # A world effector record's deposit at a point
+ *
+ * The velocity one {@link FLUID_EFFECTOR_RECORD_STRUCT} record adds at a point over a step of `dt`
+ * seconds, on a lattice of `cell_size` metres, in m/s. The record is a world one: node 0, or brought
+ * there by {@link fluid_effector_record_resolve}. This is the CPU half of one record, two executors;
+ * `fluid_effector_record_deposit` (`chunk_fluid_effector_record_deposit`) is the GPU half, the same
+ * formulas in the same order, kind for kind.
+ *
+ * The kernels (§10), with `w(t) = falloff_quadratic(t)`:
+ *
+ * - **`SPHERE_PUSH`**: `|f|·dt·w(|r|/R)·v3_clamp_to_cone(r, f̂, spread)`, `r = x − position`; at spread
+ *   0, `f·dt·w`.
+ * - **`SWEPT_CAPSULE`**: `v·A·w(d/R)`, `d` the distance to the segment `[p − v·dt, p]` the source swept
+ *   this step, with `A` normalising the step's momentum to `v·strength·πR²·|v|·dt`: the volume the
+ *   source's disc swept, taking `v·strength`. So a wake's momentum per second is `|v|·v·strength·πR²`
+ *   whatever the step and the cell.
+ * - **`SWIRL`**: `vortex_swirl(x, position, axis, length, R, strength)·dt`.
+ *
+ * ## The kernel floor
+ *
+ * A kernel narrower than its lattice resolves to nothing, or to a single face that pulses as the
+ * source crosses cells. Every kernel is therefore evaluated at `R_eff = max(R, 2·cell_size)`
+ * ({@link FLUID_EFFECTOR_KERNEL_FLOOR_CELLS}), its amplitude scaled so the floored deposit carries
+ * what the unfloored one does:
+ *
+ * - a push's momentum, `∫ w(|r|/R) dV ∝ R³`: scaled `(R/R_eff)³`;
+ * - a wake's, which its normalisation already fixes: `A = strength·πR²·L / I(R_eff, L)`, the integral
+ *   of the floored kernel over its capsule `I(R, L) = πR²·(L/6 + 2R/15)`, `L = |v|·dt`;
+ * - a swirl's angular momentum about its axis (its linear momentum is zero at any radius),
+ *   `(27/4)·π·strength·R³·(L/30 + 8R/315)`: scaled by its ratio at `R` to that at `R_eff`.
+ *
+ * Above the floor every scale is exactly 1. A kernel with `R ≤ 0`, or nothing to push, deposits
+ * nothing.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * The narrowest a kernel is evaluated, in cells of the lattice it deposits onto. Two cells is the
+ * narrowest at which a `(1 − d/R)²` kernel's sum over a lattice stays within a few percent of its
+ * integral wherever its centre sits (`fluid_record_apply.spec.js` measures it).
+ *
+ * @type {number}
+ */
+export const FLUID_EFFECTOR_KERNEL_FLOOR_CELLS = 2;
+
+/*
+ A kernel prepared from a record for one step and one lattice: what the per-point evaluation reads,
+ with the floor, the step and the normalisations folded in. Slots of a Float64Array.
+ */
+const K_KIND = 0;
+/** The centre; the start of the wake's sweep; the start of the swirl's segment. */
+const K_START = 1;
+/** The end of the wake's sweep (the source) or of the swirl's segment; the centre for a push. */
+const K_END = 4;
+/** The push's peak deposit `f·dt·s`; the wake's `v·A`; the swirl's unit axis. */
+const K_VECTOR = 7;
+/** The push's cone: the unit push, then the spread, as `v3_clamp_to_cone_array` reads it. */
+const K_CONE = 10;
+const K_SPREAD = 13;
+/** The push's peak deposit length; the swirl's strength over the step, floor-scaled. */
+const K_MAGNITUDE = 14;
+/** `R_eff`. */
+const K_RADIUS = 15;
+/** The swirl's segment length. */
+const K_LENGTH = 16;
+
+/**
+ * Floats in a prepared kernel.
+ * @type {number}
+ */
+export const FLUID_EFFECTOR_KERNEL_STRIDE = 17;
+
+/**
+ * Prepare a world record's kernel for a step of `dt` on a lattice of `cell_size`.
+ *
+ * @param {Float64Array} kernel receives {@link FLUID_EFFECTOR_KERNEL_STRIDE} floats
+ * @param {FluidEffectorRecord} record a world record (node 0)
+ * @param {number} dt seconds, > 0
+ * @param {number} cell_size metres, > 0
+ * @returns {boolean} `false` when the record deposits nothing anywhere this step, and `kernel` is then
+ *   not to be evaluated
+ */
+export function fluid_effector_kernel_prepare(kernel, record, dt, cell_size) {
+    assert.greaterThan(dt, 0, 'dt');
+    assert.greaterThan(cell_size, 0, 'cell_size');
+
+    const radius = record.radius;
+
+    if (!(radius > 0)) {
+        return false;
+    }
+
+    const radius_floor = FLUID_EFFECTOR_KERNEL_FLOOR_CELLS * cell_size;
+    const radius_effective = radius > radius_floor ? radius : radius_floor;
+
+    const kind = record.kind;
+    const position = record.position;
+    const vector = record.vector;
+
+    kernel[K_KIND] = kind;
+    kernel[K_RADIUS] = radius_effective;
+
+    const p_x = position[0];
+    const p_y = position[1];
+    const p_z = position[2];
+
+    if (kind === FluidEffectorRecordKind.SPHERE_PUSH) {
+        const ratio = radius / radius_effective;
+        const amount = dt * ratio * ratio * ratio;
+
+        const v_x = vector[0] * amount;
+        const v_y = vector[1] * amount;
+        const v_z = vector[2] * amount;
+
+        const magnitude = Math.sqrt(v_x * v_x + v_y * v_y + v_z * v_z);
+
+        if (magnitude === 0) {
+            return false;
+        }
+
+        kernel[K_START] = kernel[K_END] = p_x;
+        kernel[K_START + 1] = kernel[K_END + 1] = p_y;
+        kernel[K_START + 2] = kernel[K_END + 2] = p_z;
+
+        kernel[K_VECTOR] = v_x;
+        kernel[K_VECTOR + 1] = v_y;
+        kernel[K_VECTOR + 2] = v_z;
+
+        const inverse_magnitude = 1 / magnitude;
+
+        kernel[K_CONE] = v_x * inverse_magnitude;
+        kernel[K_CONE + 1] = v_y * inverse_magnitude;
+        kernel[K_CONE + 2] = v_z * inverse_magnitude;
+        kernel[K_SPREAD] = record.parameter;
+
+        kernel[K_MAGNITUDE] = magnitude;
+        kernel[K_LENGTH] = 0;
+
+        return true;
+    }
+
+    if (kind === FluidEffectorRecordKind.SWEPT_CAPSULE) {
+        const v_x = vector[0];
+        const v_y = vector[1];
+        const v_z = vector[2];
+
+        const sweep = Math.sqrt(v_x * v_x + v_y * v_y + v_z * v_z) * dt;
+
+        if (sweep === 0) {
+            return false;
+        }
+
+        // A = strength·πR²·L / (π·R_eff²·(L/6 + 2·R_eff/15))
+        const ratio = radius / radius_effective;
+        const amplitude = record.parameter * ratio * ratio * sweep
+            / (sweep / 6 + radius_effective * (2 / 15));
+
+        if (amplitude === 0) {
+            return false;
+        }
+
+        kernel[K_START] = p_x - v_x * dt;
+        kernel[K_START + 1] = p_y - v_y * dt;
+        kernel[K_START + 2] = p_z - v_z * dt;
+
+        kernel[K_END] = p_x;
+        kernel[K_END + 1] = p_y;
+        kernel[K_END + 2] = p_z;
+
+        kernel[K_VECTOR] = v_x * amplitude;
+        kernel[K_VECTOR + 1] = v_y * amplitude;
+        kernel[K_VECTOR + 2] = v_z * amplitude;
+
+        kernel[K_MAGNITUDE] = 0;
+        kernel[K_LENGTH] = sweep;
+
+        return true;
+    }
+
+    assert.equal(kind, FluidEffectorRecordKind.SWIRL, 'kind');
+
+    const length = record.length;
+
+    assert.greaterThanOrEqual(length, 0, 'length');
+
+    // the swirl's angular momentum, ∝ R³·(L/30 + 8R/315), at R over that at R_eff
+    const ratio = radius / radius_effective;
+    const scale = ratio * ratio * ratio
+        * (length * (1 / 30) + radius * (8 / 315))
+        / (length * (1 / 30) + radius_effective * (8 / 315));
+
+    const strength = record.parameter * dt * scale;
+
+    if (strength === 0) {
+        return false;
+    }
+
+    const a_x = vector[0];
+    const a_y = vector[1];
+    const a_z = vector[2];
+
+    kernel[K_START] = p_x;
+    kernel[K_START + 1] = p_y;
+    kernel[K_START + 2] = p_z;
+
+    kernel[K_END] = p_x + a_x * length;
+    kernel[K_END + 1] = p_y + a_y * length;
+    kernel[K_END + 2] = p_z + a_z * length;
+
+    kernel[K_VECTOR] = a_x;
+    kernel[K_VECTOR + 1] = a_y;
+    kernel[K_VECTOR + 2] = a_z;
+
+    kernel[K_MAGNITUDE] = strength;
+    kernel[K_LENGTH] = length;
+
+    return true;
+}
+
+/**
+ * The world AABB a prepared kernel deposits inside: its segment, or its centre, grown by `R_eff`.
+ *
+ * @param {Float64Array|number[]} out `[x0, y0, z0, x1, y1, z1]`
+ * @param {Float64Array} kernel
+ */
+export function fluid_effector_kernel_bounds(out, kernel) {
+    const r = kernel[K_RADIUS];
+
+    for (let i = 0; i < 3; i++) {
+        const a = kernel[K_START + i];
+        const b = kernel[K_END + i];
+
+        out[i] = (a < b ? a : b) - r;
+        out[i + 3] = (a < b ? b : a) + r;
+    }
+}
+
+/**
+ * Where {@link deposit_sphere_push} hands the clamp the face's offset from the centre.
+ * @type {Float64Array}
+ */
+const scratch_offset = new Float64Array(3);
+
+/**
+ * @param {Float64Array|Float32Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float64Array} kernel
+ * @param {Float64Array|Float32Array|number[]} point
+ * @param {number} point_offset
+ */
+function deposit_sphere_push(out, out_offset, kernel, point, point_offset) {
+    const r_x = point[point_offset] - kernel[K_START];
+    const r_y = point[point_offset + 1] - kernel[K_START + 1];
+    const r_z = point[point_offset + 2] - kernel[K_START + 2];
+
+    const weight = falloff_quadratic(Math.sqrt(r_x * r_x + r_y * r_y + r_z * r_z) / kernel[K_RADIUS]);
+
+    if (weight === 0) {
+        out[out_offset] = 0;
+        out[out_offset + 1] = 0;
+        out[out_offset + 2] = 0;
+
+        return;
+    }
+
+    if (kernel[K_SPREAD] === 0) {
+        out[out_offset] = kernel[K_VECTOR] * weight;
+        out[out_offset + 1] = kernel[K_VECTOR + 1] * weight;
+        out[out_offset + 2] = kernel[K_VECTOR + 2] * weight;
+
+        return;
+    }
+
+    scratch_offset[0] = r_x;
+    scratch_offset[1] = r_y;
+    scratch_offset[2] = r_z;
+
+    v3_clamp_to_cone_array(out, out_offset, scratch_offset, 0, kernel, K_CONE);
+
+    const amount = kernel[K_MAGNITUDE] * weight;
+
+    out[out_offset] *= amount;
+    out[out_offset + 1] *= amount;
+    out[out_offset + 2] *= amount;
+}
+
+/**
+ * @param {Float64Array|Float32Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float64Array} kernel
+ * @param {Float64Array|Float32Array|number[]} point
+ * @param {number} point_offset
+ */
+function deposit_swept_capsule(out, out_offset, kernel, point, point_offset) {
+    const x_x = point[point_offset];
+    const x_y = point[point_offset + 1];
+    const x_z = point[point_offset + 2];
+
+    const a_x = kernel[K_START];
+    const a_y = kernel[K_START + 1];
+    const a_z = kernel[K_START + 2];
+
+    const b_x = kernel[K_END];
+    const b_y = kernel[K_END + 1];
+    const b_z = kernel[K_END + 2];
+
+    const t = line3_compute_segment_closest_point_t(a_x, a_y, a_z, b_x, b_y, b_z, x_x, x_y, x_z);
+
+    const d_x = x_x - ((b_x - a_x) * t + a_x);
+    const d_y = x_y - ((b_y - a_y) * t + a_y);
+    const d_z = x_z - ((b_z - a_z) * t + a_z);
+
+    const weight = falloff_quadratic(Math.sqrt(d_x * d_x + d_y * d_y + d_z * d_z) / kernel[K_RADIUS]);
+
+    out[out_offset] = kernel[K_VECTOR] * weight;
+    out[out_offset + 1] = kernel[K_VECTOR + 1] * weight;
+    out[out_offset + 2] = kernel[K_VECTOR + 2] * weight;
+}
+
+/**
+ * @param {Float64Array|Float32Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float64Array} kernel
+ * @param {Float64Array|Float32Array|number[]} point
+ * @param {number} point_offset
+ */
+function deposit_swirl(out, out_offset, kernel, point, point_offset) {
+    vortex_swirl(
+        out, out_offset,
+        point[point_offset], point[point_offset + 1], point[point_offset + 2],
+        kernel[K_START], kernel[K_START + 1], kernel[K_START + 2],
+        kernel[K_VECTOR], kernel[K_VECTOR + 1], kernel[K_VECTOR + 2],
+        kernel[K_LENGTH],
+        kernel[K_RADIUS],
+        kernel[K_MAGNITUDE]
+    );
+}
+
+/**
+ * A prepared kernel's deposit at a point, m/s, written to `out`. Zero outside its reach.
+ *
+ * Takes and gives arrays, and each kind is a small function of its own, so a loop over faces calls it
+ * without boxing a number.
+ *
+ * @param {Float64Array|Float32Array|number[]} out receives `[x, y, z]`
+ * @param {number} out_offset
+ * @param {Float64Array} kernel from {@link fluid_effector_kernel_prepare}
+ * @param {Float64Array|Float32Array|number[]} point `[x, y, z]`, world
+ * @param {number} point_offset
+ */
+export function fluid_effector_kernel_deposit(out, out_offset, kernel, point, point_offset) {
+    const kind = kernel[K_KIND];
+
+    if (kind === FluidEffectorRecordKind.SPHERE_PUSH) {
+        deposit_sphere_push(out, out_offset, kernel, point, point_offset);
+    } else if (kind === FluidEffectorRecordKind.SWEPT_CAPSULE) {
+        deposit_swept_capsule(out, out_offset, kernel, point, point_offset);
+    } else {
+        deposit_swirl(out, out_offset, kernel, point, point_offset);
+    }
+}
+
+/**
+ * The deposit at one point. For a loop over many, prepare once with
+ * {@link fluid_effector_kernel_prepare} and evaluate with {@link fluid_effector_kernel_deposit}, as
+ * {@link fluid_record_apply} does.
+ *
+ * @param {Float64Array|Float32Array|number[]} out receives `[x, y, z]`, m/s
+ * @param {number} out_offset
+ * @param {FluidEffectorRecord} record a world record (node 0)
+ * @param {number} x world
+ * @param {number} y
+ * @param {number} z
+ * @param {number} dt seconds, > 0
+ * @param {number} cell_size metres, > 0: the lattice's, for the kernel floor
+ */
+export function fluid_effector_record_deposit(out, out_offset, record, x, y, z, dt, cell_size) {
+    if (!fluid_effector_kernel_prepare(SCALAR_KERNEL, record, dt, cell_size)) {
+        out[out_offset] = 0;
+        out[out_offset + 1] = 0;
+        out[out_offset + 2] = 0;
+
+        return;
+    }
+
+    SCALAR_POINT[0] = x;
+    SCALAR_POINT[1] = y;
+    SCALAR_POINT[2] = z;
+
+    fluid_effector_kernel_deposit(out, out_offset, SCALAR_KERNEL, SCALAR_POINT, 0);
+}
+
+/**
+ * {@link fluid_effector_record_deposit}'s kernel and point.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_KERNEL = new Float64Array(FLUID_EFFECTOR_KERNEL_STRIDE);
+const SCALAR_POINT = new Float64Array(3);

package/src/engine/physics/fluid/effector/record/fluid_effector_record_resolve.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Bring an effector record to the world: the node-0 record that deposits what `record` does under
+ * its node's pose this frame. What the GPU fluid does once per record per frame from the node's
+ * transforms row, before any deposit; `fluid_effector_record_resolve`
+ * (`chunk_fluid_effector_record_resolve`) is the WGSL twin, and {@link FLUID_EFFECTOR_RECORD_STRUCT}
+ * says why the record is in its node's frame.
+ *
+ * - `position` → `global · (position, 1)`;
+ * - a swirl's axis → `normalize(global · (axis, 0))`, which for a node's local +Y is its world
+ *   rotation's +Y whatever its scale;
+ * - a wake's velocity → its own plus its node's at `position`, `((global − prev_global) · (position,
+ *   1)) · inverse_frame_dt`;
+ * - an impulse's force, a world vector, as it is; `radius`, `parameter` and `length` as they are.
+ *
+ * `out` may be `record`. A record already at node 0 resolves to itself under the identity.
+ *
+ * @param {FluidEffectorRecord} out receives the world record, `node` 0
+ * @param {FluidEffectorRecord} record
+ * @param {Float32Array|Float64Array|number[]} global the node's world matrix this frame, column-major
+ * @param {Float32Array|Float64Array|number[]} prev_global the node's world matrix last frame
+ * @param {number} inverse_frame_dt `1 / (frame_dt · fixedStepTimeScale)`, the inverse of the game
+ *   seconds between the two matrices; 0 when none passed
+ */
+export function fluid_effector_record_resolve(out: FluidEffectorRecord, record: FluidEffectorRecord, global: Float32Array | Float64Array | number[], prev_global: Float32Array | Float64Array | number[], inverse_frame_dt: number): void;
+//# sourceMappingURL=fluid_effector_record_resolve.d.ts.map

package/src/engine/physics/fluid/effector/record/fluid_effector_record_resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_effector_record_resolve.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/fluid/effector/record/fluid_effector_record_resolve.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6GALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,eAClC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,oBAClC,MAAM,QAuDhB"}

package/src/engine/physics/fluid/effector/record/fluid_effector_record_resolve.js

@@ -0,0 +1,78 @@
+import { FluidEffectorRecordKind } from "./FluidEffectorRecordKind.js";
+
+/**
+ * Bring an effector record to the world: the node-0 record that deposits what `record` does under
+ * its node's pose this frame. What the GPU fluid does once per record per frame from the node's
+ * transforms row, before any deposit; `fluid_effector_record_resolve`
+ * (`chunk_fluid_effector_record_resolve`) is the WGSL twin, and {@link FLUID_EFFECTOR_RECORD_STRUCT}
+ * says why the record is in its node's frame.
+ *
+ * - `position` → `global · (position, 1)`;
+ * - a swirl's axis → `normalize(global · (axis, 0))`, which for a node's local +Y is its world
+ *   rotation's +Y whatever its scale;
+ * - a wake's velocity → its own plus its node's at `position`, `((global − prev_global) · (position,
+ *   1)) · inverse_frame_dt`;
+ * - an impulse's force, a world vector, as it is; `radius`, `parameter` and `length` as they are.
+ *
+ * `out` may be `record`. A record already at node 0 resolves to itself under the identity.
+ *
+ * @param {FluidEffectorRecord} out receives the world record, `node` 0
+ * @param {FluidEffectorRecord} record
+ * @param {Float32Array|Float64Array|number[]} global the node's world matrix this frame, column-major
+ * @param {Float32Array|Float64Array|number[]} prev_global the node's world matrix last frame
+ * @param {number} inverse_frame_dt `1 / (frame_dt · fixedStepTimeScale)`, the inverse of the game
+ *   seconds between the two matrices; 0 when none passed
+ */
+export function fluid_effector_record_resolve(out, record, global, prev_global, inverse_frame_dt) {
+    const p_x = record.position[0];
+    const p_y = record.position[1];
+    const p_z = record.position[2];
+
+    const v_x = record.vector[0];
+    const v_y = record.vector[1];
+    const v_z = record.vector[2];
+
+    const kind = record.kind;
+
+    const g = global;
+
+    const w_x = g[0] * p_x + g[4] * p_y + g[8] * p_z + g[12];
+    const w_y = g[1] * p_x + g[5] * p_y + g[9] * p_z + g[13];
+    const w_z = g[2] * p_x + g[6] * p_y + g[10] * p_z + g[14];
+
+    if (kind === FluidEffectorRecordKind.SWEPT_CAPSULE) {
+        const q = prev_global;
+
+        const was_x = q[0] * p_x + q[4] * p_y + q[8] * p_z + q[12];
+        const was_y = q[1] * p_x + q[5] * p_y + q[9] * p_z + q[13];
+        const was_z = q[2] * p_x + q[6] * p_y + q[10] * p_z + q[14];
+
+        out.vector[0] = v_x + (w_x - was_x) * inverse_frame_dt;
+        out.vector[1] = v_y + (w_y - was_y) * inverse_frame_dt;
+        out.vector[2] = v_z + (w_z - was_z) * inverse_frame_dt;
+    } else if (kind === FluidEffectorRecordKind.SWIRL) {
+        const a_x = g[0] * v_x + g[4] * v_y + g[8] * v_z;
+        const a_y = g[1] * v_x + g[5] * v_y + g[9] * v_z;
+        const a_z = g[2] * v_x + g[6] * v_y + g[10] * v_z;
+
+        const inverse_length = 1 / Math.sqrt(a_x * a_x + a_y * a_y + a_z * a_z);
+
+        out.vector[0] = a_x * inverse_length;
+        out.vector[1] = a_y * inverse_length;
+        out.vector[2] = a_z * inverse_length;
+    } else {
+        out.vector[0] = v_x;
+        out.vector[1] = v_y;
+        out.vector[2] = v_z;
+    }
+
+    out.position[0] = w_x;
+    out.position[1] = w_y;
+    out.position[2] = w_z;
+
+    out.radius = record.radius;
+    out.parameter = record.parameter;
+    out.kind = kind;
+    out.node = 0;
+    out.length = record.length;
+}

package/src/engine/physics/fluid/effector/record/fluid_record_apply.d.ts

@@ -0,0 +1,27 @@
+/**
+ * # One effector record applied to a CPU fluid field
+ *
+ * The CPU executor of a {@link FLUID_EFFECTOR_RECORD_STRUCT} record (GPU_FLUID_CASCADES_PROPOSAL §17
+ * D12, one record and two executors; the GPU's is the forcing pass): every face of the field's three
+ * MAC lattices within the record's reach takes the record's deposit at that face's world position,
+ * {@link fluid_effector_kernel_deposit}, turned into the field's grid units. Pinned faces are skipped,
+ * as the effectors' own `apply` skips them.
+ *
+ * The field's cell size is the `world_to_grid` matrix's scale, and it sets the kernel floor: a kernel
+ * narrower than two of the field's cells is evaluated two cells wide, carrying the momentum it would
+ * have had (see `fluid_effector_record_deposit.js`).
+ *
+ * The record is a world one, node 0. One whose node is another transforms row is first brought to the
+ * world with {@link fluid_effector_record_resolve}.
+ *
+ * Allocates nothing.
+ *
+ * @param {FluidField} field
+ * @param {number} dt seconds, > 0
+ * @param {Float32Array|Float64Array|number[]} world_to_grid column-major 4×4 similarity (uniform
+ *   scale, rotation, translation) sending world points into the field's grid space, as
+ *   `fluid_build_world_to_grid` builds it
+ * @param {FluidEffectorRecord} record a world record
+ */
+export function fluid_record_apply(field: FluidField, dt: number, world_to_grid: Float32Array | Float64Array | number[], record: FluidEffectorRecord): void;
+//# sourceMappingURL=fluid_record_apply.d.ts.map

package/src/engine/physics/fluid/effector/record/fluid_record_apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_record_apply.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/physics/fluid/effector/record/fluid_record_apply.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,0DANW,MAAM,iBACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,qCA+G5C"}