@woosh/meep-engine 3.47.0 → 3.50.0

package/src/engine/physics/fluid/obstacle/fluid_obstacle_record_create.js

@@ -0,0 +1,35 @@
+/**
+ * @typedef {object} FluidObstacleRecord
+ * @property {Float32Array} shape_parameters `[p0, p1, p2, p3]`, the core shape record's parameters
+ * @property {Float32Array} pose_translation `[x, y, z]`, the record's frame in the collider's
+ * @property {number} shape_kind a `ShapeRecordKind`
+ * @property {Float32Array} pose_rotation `[x, y, z, w]`, the record's frame in the collider's
+ * @property {Float32Array} linear_velocity `[x, y, z]`, world m/s
+ * @property {number} inflation metres
+ * @property {Float32Array} angular_velocity `[x, y, z]`, world rad/s
+ * @property {number} node the transforms row that poses the record
+ */
+
+/**
+ * A staging record for one row of {@link FLUID_OBSTACLE_RECORD_STRUCT}: what
+ * {@link fluid_obstacle_write_gpu_shape} and {@link fluid_obstacle_write_gpu_motion} assign into and
+ * `generate_record_writer` reads. A sphere
+ * of radius 0 at the identity, not moving, at the world root.
+ *
+ * Vector fields are `Float32Array`s and scalars hold f32 values, so a record compares as the GPU
+ * holds it. Retain one per row; this allocates.
+ *
+ * @returns {FluidObstacleRecord}
+ */
+export function fluid_obstacle_record_create() {
+    return {
+        shape_parameters: new Float32Array(4),
+        pose_translation: new Float32Array(3),
+        shape_kind: 0,
+        pose_rotation: Float32Array.of(0, 0, 0, 1),
+        linear_velocity: new Float32Array(3),
+        inflation: 0,
+        angular_velocity: new Float32Array(3),
+        node: 0,
+    };
+}

package/src/engine/physics/fluid/obstacle/fluid_obstacle_record_evaluate.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Signed distance from a world point to a fluid obstacle record's surface, negative inside, under its
+ * node's world matrix: the CPU twin of `fluid_obstacle_record_signed_distance`
+ * (`chunk_fluid_obstacle_record`), which a GPU solid test reads. The point is solid when this is at
+ * most `record.inflation`.
+ *
+ * The node poses the record rigidly, as the narrowphase and the CPU fluid pose a collider: its
+ * translation, and its matrix's rotation with each column normalised, scale ignored. Then the record's
+ * own pose within the collider, then core's `shape_record_signed_distance`.
+ *
+ * @param {FluidObstacleRecord} record
+ * @param {Float32Array|Float64Array} planes the plane array a hull record names
+ * @param {Float32Array|Float64Array|number[]} global the node's world matrix, column-major
+ * @param {number} x world
+ * @param {number} y
+ * @param {number} z
+ * @returns {number}
+ */
+export function fluid_obstacle_record_signed_distance(record: FluidObstacleRecord, planes: Float32Array | Float64Array, global: Float32Array | Float64Array | number[], x: number, y: number, z: number): number;
+/**
+ * The velocity of a fluid obstacle's wall at a world point: `rigid_velocity_at_point(v, ω, t, x)`,
+ * `t` the node's translation, which the body's velocity is at and its spin is about. The CPU twin of
+ * `fluid_obstacle_record_wall_velocity` (`chunk_fluid_obstacle_record`).
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[x, y, z]`, m/s
+ * @param {number} out_offset
+ * @param {FluidObstacleRecord} record
+ * @param {Float32Array|Float64Array|number[]} global the node's world matrix, column-major
+ * @param {number} x world
+ * @param {number} y
+ * @param {number} z
+ */
+export function fluid_obstacle_record_wall_velocity(out: Float32Array | Float64Array | number[], out_offset: number, record: FluidObstacleRecord, global: Float32Array | Float64Array | number[], x: number, y: number, z: number): void;
+//# sourceMappingURL=fluid_obstacle_record_evaluate.d.ts.map

package/src/engine/physics/fluid/obstacle/fluid_obstacle_record_evaluate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_obstacle_record_evaluate.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/obstacle/fluid_obstacle_record_evaluate.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,2FAPW,YAAY,GAAC,YAAY,UACzB,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAClC,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAkClB;AAED;;;;;;;;;;;;GAYG;AACH,yDARW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,uCAEN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAClC,MAAM,KACN,MAAM,KACN,MAAM,QAahB"}

package/src/engine/physics/fluid/obstacle/fluid_obstacle_record_evaluate.js

@@ -0,0 +1,90 @@
+import { pose3_apply_inverse_point_array } from "../../../../core/geom/3d/pose/pose3_apply_inverse_point_array.js";
+import { SHAPE_RECORD_KIND, SHAPE_RECORD_PARAM_0, SHAPE_RECORD_STRIDE } from "../../../../core/geom/3d/shape/record/ShapeRecord.js";
+import { shape_record_signed_distance } from "../../../../core/geom/3d/shape/record/shape_record_signed_distance.js";
+import { rigid_velocity_at_point } from "../../../../core/math/physics/kinematics/rigid_velocity_at_point.js";
+
+/**
+ * Signed distance from a world point to a fluid obstacle record's surface, negative inside, under its
+ * node's world matrix: the CPU twin of `fluid_obstacle_record_signed_distance`
+ * (`chunk_fluid_obstacle_record`), which a GPU solid test reads. The point is solid when this is at
+ * most `record.inflation`.
+ *
+ * The node poses the record rigidly, as the narrowphase and the CPU fluid pose a collider: its
+ * translation, and its matrix's rotation with each column normalised, scale ignored. Then the record's
+ * own pose within the collider, then core's `shape_record_signed_distance`.
+ *
+ * @param {FluidObstacleRecord} record
+ * @param {Float32Array|Float64Array} planes the plane array a hull record names
+ * @param {Float32Array|Float64Array|number[]} global the node's world matrix, column-major
+ * @param {number} x world
+ * @param {number} y
+ * @param {number} z
+ * @returns {number}
+ */
+export function fluid_obstacle_record_signed_distance(record, planes, global, x, y, z) {
+    const g = global;
+
+    const d_x = x - g[12];
+    const d_y = y - g[13];
+    const d_z = z - g[14];
+
+    const inverse_0 = 1 / Math.sqrt(g[0] * g[0] + g[1] * g[1] + g[2] * g[2]);
+    const inverse_1 = 1 / Math.sqrt(g[4] * g[4] + g[5] * g[5] + g[6] * g[6]);
+    const inverse_2 = 1 / Math.sqrt(g[8] * g[8] + g[9] * g[9] + g[10] * g[10]);
+
+    // Rᵀ·(x − t), R the normalised columns
+    const node = NODE_POINT;
+
+    node[0] = (g[0] * d_x + g[1] * d_y + g[2] * d_z) * inverse_0;
+    node[1] = (g[4] * d_x + g[5] * d_y + g[6] * d_z) * inverse_1;
+    node[2] = (g[8] * d_x + g[9] * d_y + g[10] * d_z) * inverse_2;
+
+    const local = LOCAL_POINT;
+
+    pose3_apply_inverse_point_array(local, 0, record.pose_translation, 0, record.pose_rotation, 0, node, 0);
+
+    const shape = SHAPE_RECORD;
+    const parameters = record.shape_parameters;
+
+    shape[SHAPE_RECORD_KIND] = record.shape_kind;
+    shape[SHAPE_RECORD_PARAM_0] = parameters[0];
+    shape[SHAPE_RECORD_PARAM_0 + 1] = parameters[1];
+    shape[SHAPE_RECORD_PARAM_0 + 2] = parameters[2];
+    shape[SHAPE_RECORD_PARAM_0 + 3] = parameters[3];
+
+    return shape_record_signed_distance(shape, 0, planes, local[0], local[1], local[2]);
+}
+
+/**
+ * The velocity of a fluid obstacle's wall at a world point: `rigid_velocity_at_point(v, ω, t, x)`,
+ * `t` the node's translation, which the body's velocity is at and its spin is about. The CPU twin of
+ * `fluid_obstacle_record_wall_velocity` (`chunk_fluid_obstacle_record`).
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[x, y, z]`, m/s
+ * @param {number} out_offset
+ * @param {FluidObstacleRecord} record
+ * @param {Float32Array|Float64Array|number[]} global the node's world matrix, column-major
+ * @param {number} x world
+ * @param {number} y
+ * @param {number} z
+ */
+export function fluid_obstacle_record_wall_velocity(out, out_offset, record, global, x, y, z) {
+    const v = record.linear_velocity;
+    const w = record.angular_velocity;
+
+    rigid_velocity_at_point(
+        out, out_offset,
+        v[0], v[1], v[2],
+        w[0], w[1], w[2],
+        global[12], global[13], global[14],
+        x, y, z
+    );
+}
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const NODE_POINT = new Float64Array(3);
+const LOCAL_POINT = new Float64Array(3);
+const SHAPE_RECORD = new Float64Array(SHAPE_RECORD_STRIDE);

package/src/engine/physics/fluid/obstacle/fluid_obstacle_record_extent.d.ts

@@ -0,0 +1,17 @@
+/**
+ * How wide a GPU fluid obstacle record is, metres: its local box's widest edge grown by the inflation
+ * on both sides, `2·(max(half extents) + inflation)`, or `Infinity` for an unbounded kind (a plane).
+ *
+ * It is the record's own, so it holds whatever pose the record's node takes: a turned box keeps the
+ * extent of its longest edge. At the identity pose it is the widest edge of the obstacle's world box
+ * before the forcing's + side dilation (`fluid_forcing_obstacle_box`).
+ *
+ * The GPU fluid's resolution cull reads it (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §10): an obstacle
+ * at least half a cell of a cascade wide is one that cascade resolves, and the brick queries of a
+ * cascade search a tree of only those (`GPUFluidForcing`).
+ *
+ * @param {import("./fluid_obstacle_record_create.js").FluidObstacleRecord} record
+ * @returns {number}
+ */
+export function fluid_obstacle_record_extent(record: import("./fluid_obstacle_record_create.js").FluidObstacleRecord): number;
+//# sourceMappingURL=fluid_obstacle_record_extent.d.ts.map

package/src/engine/physics/fluid/obstacle/fluid_obstacle_record_extent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_obstacle_record_extent.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/obstacle/fluid_obstacle_record_extent.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AACH,qDAHW,OAAO,mCAAmC,EAAE,mBAAmB,GAC7D,MAAM,CAkBlB"}

package/src/engine/physics/fluid/obstacle/fluid_obstacle_record_extent.js

@@ -0,0 +1,44 @@
+import { SHAPE_RECORD_KIND, SHAPE_RECORD_PARAM_0, SHAPE_RECORD_STRIDE } from "../../../../core/geom/3d/shape/record/ShapeRecord.js";
+import { shape_record_local_bounds } from "../../../../core/geom/3d/shape/record/shape_record_local_bounds.js";
+
+/**
+ * A core shape record laid out for {@link shape_record_local_bounds}.
+ * @type {Float64Array}
+ */
+const SCRATCH_RECORD = new Float64Array(SHAPE_RECORD_STRIDE);
+
+/** The local box {@link shape_record_local_bounds} writes. */
+const SCRATCH_BOUNDS = new Float64Array(6);
+
+/**
+ * How wide a GPU fluid obstacle record is, metres: its local box's widest edge grown by the inflation
+ * on both sides, `2·(max(half extents) + inflation)`, or `Infinity` for an unbounded kind (a plane).
+ *
+ * It is the record's own, so it holds whatever pose the record's node takes: a turned box keeps the
+ * extent of its longest edge. At the identity pose it is the widest edge of the obstacle's world box
+ * before the forcing's + side dilation (`fluid_forcing_obstacle_box`).
+ *
+ * The GPU fluid's resolution cull reads it (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §10): an obstacle
+ * at least half a cell of a cascade wide is one that cascade resolves, and the brick queries of a
+ * cascade search a tree of only those (`GPUFluidForcing`).
+ *
+ * @param {import("./fluid_obstacle_record_create.js").FluidObstacleRecord} record
+ * @returns {number}
+ */
+export function fluid_obstacle_record_extent(record) {
+    SCRATCH_RECORD[SHAPE_RECORD_KIND] = record.shape_kind;
+
+    const parameters = record.shape_parameters;
+
+    for (let i = 0; i < 4; i++) {
+        SCRATCH_RECORD[SHAPE_RECORD_PARAM_0 + i] = parameters[i];
+    }
+
+    if (!shape_record_local_bounds(SCRATCH_BOUNDS, SCRATCH_RECORD, 0)) {
+        return Infinity;
+    }
+
+    const widest = Math.max(SCRATCH_BOUNDS[3], SCRATCH_BOUNDS[4], SCRATCH_BOUNDS[5]);
+
+    return 2 * (widest + record.inflation);
+}

package/src/engine/physics/fluid/obstacle/fluid_obstacle_write_gpu_record.d.ts

@@ -0,0 +1,98 @@
+/**
+ * How many records a collider's shape packs into: its core run, or 1 for its oriented box, or 0 for a
+ * shape with neither (an unbounded one with no record, such as a plane under a scaling wrapper).
+ *
+ * @param {AbstractShape3D} shape
+ * @returns {number}
+ */
+export function fluid_obstacle_record_count(shape: AbstractShape3D): number;
+/**
+ * How many hull planes a collider's whole run holds: the plane run a caller reserves for it.
+ *
+ * @param {AbstractShape3D} shape
+ * @returns {number}
+ */
+export function fluid_obstacle_plane_count(shape: AbstractShape3D): number;
+/**
+ * How many planes of the plane array a written record names: its hull's count, 0 for every other
+ * kind. What a caller advances its plane cursor by.
+ *
+ * @param {FluidObstacleRecord} record
+ * @returns {number}
+ */
+export function fluid_obstacle_record_plane_count(record: FluidObstacleRecord): number;
+/**
+ * Write the shape half of record `element` of a collider's shape into a staging record: the core
+ * shape record and its pose within the collider, and a hull's planes into `planes` from plane
+ * `plane_index`, comparing every value as it is assigned.
+ *
+ * PRECONDITION: `element < fluid_obstacle_record_count(shape)`, and `planes` has room for the
+ * record's planes from `plane_index` on. `record.node` is the caller's and is not written.
+ *
+ * @param {FluidObstacleRecord} record
+ * @param {Float32Array} planes the plane array, four floats per plane `(nx, ny, nz, offset)`
+ * @param {number} plane_index the first plane this record's hull may write, in planes
+ * @param {AbstractShape3D} shape the collider's
+ * @param {number} element which record of the shape's run, from 0
+ * @returns {number} {@link FLUID_OBSTACLE_RECORD_CHANGED} and {@link FLUID_OBSTACLE_PLANES_CHANGED},
+ *   or'd; 0 when nothing changed
+ */
+export function fluid_obstacle_write_gpu_shape(record: FluidObstacleRecord, planes: Float32Array, plane_index: number, shape: AbstractShape3D, element: number): number;
+/**
+ * Write the motion half of a record: the obstacle's inflation and its body's linear and angular
+ * velocity, comparing each as it is assigned. Every record of a collider's run takes the same.
+ * Allocates nothing.
+ *
+ * @param {FluidObstacleRecord} record
+ * @param {FluidObstacle} obstacle
+ * @param {RigidBody} body
+ * @returns {boolean} whether any field changed
+ */
+export function fluid_obstacle_write_gpu_motion(record: FluidObstacleRecord, obstacle: FluidObstacle, body: RigidBody): boolean;
+/**
+ * # A `FluidObstacle` → GPU fluid obstacle records
+ *
+ * An obstacle's collider packs through core's shape record (`shape_record_pack`), as cloth's colliders
+ * do: one record per primitive of a rigid wrapper or a union, each with its pose within the collider,
+ * and a hull's planes into the caller's plane array. A collider with no record of its own (a mesh, a
+ * heightmap, a scaled wrapper, a hull past {@link SHAPE_RECORD_HULL_PLANE_LIMIT} planes, a union
+ * holding one) packs as its oriented box, `shape_record_pack_bounding_box` (§10, until the SDF
+ * stage). Beside the shape go the obstacle's inflation and its body's linear and angular velocity.
+ *
+ * A record is written in two halves, each comparing every field while it assigns it, as f32:
+ *
+ * - {@link fluid_obstacle_write_gpu_shape}: the shape record, its pose within the collider and a
+ *   hull's planes. A collider's shape is shared and never mutated, so it changes only when the
+ *   collider is handed another shape object, which is when a caller writes this half, and on link;
+ * - {@link fluid_obstacle_write_gpu_motion}: the inflation and the body's velocities, every frame.
+ *
+ * So an obstacle whose inflation and motion have not changed (a static wall, a sleeping body) writes
+ * nothing, and its pose is its node's. A caller links a collider as
+ *
+ *     const n = fluid_obstacle_record_count(collider.shape);
+ *     // a plane run of fluid_obstacle_plane_count(collider.shape) planes, from `first`
+ *     for (let i = 0, cursor = first; i < n; i++) {
+ *         fluid_obstacle_write_gpu_shape(records[i], planes, cursor, collider.shape, i);
+ *         fluid_obstacle_write_gpu_motion(records[i], obstacle, body);
+ *         cursor += fluid_obstacle_record_plane_count(records[i]);
+ *     }
+ *
+ * Writing element `i` of a union of `n` leaves walks the union from its start, O(n), core's price for
+ * one call shape. The motion half allocates nothing; the shape half allocates what core's pack does
+ * (a box's half extents are read through `Vector3` getters, 64 B a box measured), which is why it is
+ * the half that runs only when the shape changes.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * {@link fluid_obstacle_write_gpu_shape}'s answer: a field of the record changed.
+ * @type {number}
+ */
+export const FLUID_OBSTACLE_RECORD_CHANGED: number;
+/**
+ * {@link fluid_obstacle_write_gpu_shape}'s answer: a hull plane the record names changed.
+ * @type {number}
+ */
+export const FLUID_OBSTACLE_PLANES_CHANGED: number;
+//# sourceMappingURL=fluid_obstacle_write_gpu_record.d.ts.map

package/src/engine/physics/fluid/obstacle/fluid_obstacle_write_gpu_record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_obstacle_write_gpu_record.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/obstacle/fluid_obstacle_write_gpu_record.js"],"names":[],"mappings":"AAgEA;;;;;;GAMG;AACH,qEAFa,MAAM,CAUlB;AAED;;;;;GAKG;AACH,oEAFa,MAAM,CAclB;AAED;;;;;;GAMG;AACH,gFAFa,MAAM,CAOlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,oFAPW,YAAY,eACZ,MAAM,mCAEN,MAAM,GACJ,MAAM,CA4FlB;AAED;;;;;;;;;GASG;AACH,wHAFa,OAAO,CAyCnB;AAhQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH;;;GAGG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,4CAFU,MAAM,CAE+B"}

package/src/engine/physics/fluid/obstacle/fluid_obstacle_write_gpu_record.js

@@ -0,0 +1,281 @@
+import { assert } from "../../../../core/assert.js";
+import {
+    SHAPE_RECORD_HULL_PLANE_LIMIT,
+    SHAPE_RECORD_KIND,
+    SHAPE_RECORD_PARAM_0,
+    SHAPE_RECORD_POSE_STRIDE,
+    SHAPE_RECORD_STRIDE
+} from "../../../../core/geom/3d/shape/record/ShapeRecord.js";
+import {
+    shape_record_count,
+    shape_record_pack,
+    shape_record_plane_count
+} from "../../../../core/geom/3d/shape/record/shape_record_pack.js";
+import { shape_record_pack_bounding_box } from "../../../../core/geom/3d/shape/record/shape_record_pack_bounding_box.js";
+
+/**
+ * # A `FluidObstacle` → GPU fluid obstacle records
+ *
+ * An obstacle's collider packs through core's shape record (`shape_record_pack`), as cloth's colliders
+ * do: one record per primitive of a rigid wrapper or a union, each with its pose within the collider,
+ * and a hull's planes into the caller's plane array. A collider with no record of its own (a mesh, a
+ * heightmap, a scaled wrapper, a hull past {@link SHAPE_RECORD_HULL_PLANE_LIMIT} planes, a union
+ * holding one) packs as its oriented box, `shape_record_pack_bounding_box` (§10, until the SDF
+ * stage). Beside the shape go the obstacle's inflation and its body's linear and angular velocity.
+ *
+ * A record is written in two halves, each comparing every field while it assigns it, as f32:
+ *
+ * - {@link fluid_obstacle_write_gpu_shape}: the shape record, its pose within the collider and a
+ *   hull's planes. A collider's shape is shared and never mutated, so it changes only when the
+ *   collider is handed another shape object, which is when a caller writes this half, and on link;
+ * - {@link fluid_obstacle_write_gpu_motion}: the inflation and the body's velocities, every frame.
+ *
+ * So an obstacle whose inflation and motion have not changed (a static wall, a sleeping body) writes
+ * nothing, and its pose is its node's. A caller links a collider as
+ *
+ *     const n = fluid_obstacle_record_count(collider.shape);
+ *     // a plane run of fluid_obstacle_plane_count(collider.shape) planes, from `first`
+ *     for (let i = 0, cursor = first; i < n; i++) {
+ *         fluid_obstacle_write_gpu_shape(records[i], planes, cursor, collider.shape, i);
+ *         fluid_obstacle_write_gpu_motion(records[i], obstacle, body);
+ *         cursor += fluid_obstacle_record_plane_count(records[i]);
+ *     }
+ *
+ * Writing element `i` of a union of `n` leaves walks the union from its start, O(n), core's price for
+ * one call shape. The motion half allocates nothing; the shape half allocates what core's pack does
+ * (a box's half extents are read through `Vector3` getters, 64 B a box measured), which is why it is
+ * the half that runs only when the shape changes.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * {@link fluid_obstacle_write_gpu_shape}'s answer: a field of the record changed.
+ * @type {number}
+ */
+export const FLUID_OBSTACLE_RECORD_CHANGED = 1;
+
+/**
+ * {@link fluid_obstacle_write_gpu_shape}'s answer: a hull plane the record names changed.
+ * @type {number}
+ */
+export const FLUID_OBSTACLE_PLANES_CHANGED = 2;
+
+/**
+ * How many records a collider's shape packs into: its core run, or 1 for its oriented box, or 0 for a
+ * shape with neither (an unbounded one with no record, such as a plane under a scaling wrapper).
+ *
+ * @param {AbstractShape3D} shape
+ * @returns {number}
+ */
+export function fluid_obstacle_record_count(shape) {
+    const count = shape_record_count(shape);
+
+    if (count > 0) {
+        return count;
+    }
+
+    return shape_record_pack_bounding_box(SCRATCH_RECORD, 0, SCRATCH_POSE, 0, shape) ? 1 : 0;
+}
+
+/**
+ * How many hull planes a collider's whole run holds: the plane run a caller reserves for it.
+ *
+ * @param {AbstractShape3D} shape
+ * @returns {number}
+ */
+export function fluid_obstacle_plane_count(shape) {
+    const count = shape_record_count(shape);
+
+    let planes = 0;
+
+    for (let i = 0; i < count; i++) {
+        shape_record_pack(SCRATCH_RECORD, 0, SCRATCH_POSE, 0, SCRATCH_PLANES, 0, shape, i);
+
+        planes += shape_record_plane_count(SCRATCH_RECORD, 0);
+    }
+
+    return planes;
+}
+
+/**
+ * How many planes of the plane array a written record names: its hull's count, 0 for every other
+ * kind. What a caller advances its plane cursor by.
+ *
+ * @param {FluidObstacleRecord} record
+ * @returns {number}
+ */
+export function fluid_obstacle_record_plane_count(record) {
+    SCRATCH_RECORD[SHAPE_RECORD_KIND] = record.shape_kind;
+    SCRATCH_RECORD[SHAPE_RECORD_PARAM_0 + 1] = record.shape_parameters[1];
+
+    return shape_record_plane_count(SCRATCH_RECORD, 0);
+}
+
+/**
+ * Write the shape half of record `element` of a collider's shape into a staging record: the core
+ * shape record and its pose within the collider, and a hull's planes into `planes` from plane
+ * `plane_index`, comparing every value as it is assigned.
+ *
+ * PRECONDITION: `element < fluid_obstacle_record_count(shape)`, and `planes` has room for the
+ * record's planes from `plane_index` on. `record.node` is the caller's and is not written.
+ *
+ * @param {FluidObstacleRecord} record
+ * @param {Float32Array} planes the plane array, four floats per plane `(nx, ny, nz, offset)`
+ * @param {number} plane_index the first plane this record's hull may write, in planes
+ * @param {AbstractShape3D} shape the collider's
+ * @param {number} element which record of the shape's run, from 0
+ * @returns {number} {@link FLUID_OBSTACLE_RECORD_CHANGED} and {@link FLUID_OBSTACLE_PLANES_CHANGED},
+ *   or'd; 0 when nothing changed
+ */
+export function fluid_obstacle_write_gpu_shape(record, planes, plane_index, shape, element) {
+    const shape_record = SCRATCH_RECORD;
+    const pose = SCRATCH_POSE;
+
+    if (shape_record_count(shape) > 0) {
+        const packed = shape_record_pack(shape_record, 0, pose, 0, SCRATCH_PLANES, 0, shape, element);
+
+        assert.ok(packed, 'element is past the collider\'s run');
+    } else {
+        assert.equal(element, 0, 'a collider packed as its oriented box is one record');
+
+        const packed = shape_record_pack_bounding_box(shape_record, 0, pose, 0, shape);
+
+        assert.ok(packed, 'the collider has neither a record nor a bounded box');
+    }
+
+    let changed = 0;
+
+    // A hull's planes went to the scratch from 0; they are the caller's from plane_index on, and the
+    // record names them there.
+    const plane_count = shape_record_plane_count(shape_record, 0);
+
+    if (plane_count > 0) {
+        shape_record[SHAPE_RECORD_PARAM_0] = plane_index;
+
+        const source = SCRATCH_PLANES;
+        const base = plane_index * 4;
+
+        for (let i = 0; i < plane_count * 4; i++) {
+            const value = Math.fround(source[i]);
+
+            if (planes[base + i] !== value) {
+                planes[base + i] = value;
+                changed |= FLUID_OBSTACLE_PLANES_CHANGED;
+            }
+        }
+    }
+
+    const kind = shape_record[SHAPE_RECORD_KIND];
+
+    if (record.shape_kind !== kind) {
+        record.shape_kind = kind;
+        changed |= FLUID_OBSTACLE_RECORD_CHANGED;
+    }
+
+    const parameters = record.shape_parameters;
+
+    const p0 = Math.fround(shape_record[SHAPE_RECORD_PARAM_0]);
+    const p1 = Math.fround(shape_record[SHAPE_RECORD_PARAM_0 + 1]);
+    const p2 = Math.fround(shape_record[SHAPE_RECORD_PARAM_0 + 2]);
+    const p3 = Math.fround(shape_record[SHAPE_RECORD_PARAM_0 + 3]);
+
+    if (parameters[0] !== p0 || parameters[1] !== p1 || parameters[2] !== p2 || parameters[3] !== p3) {
+        parameters[0] = p0;
+        parameters[1] = p1;
+        parameters[2] = p2;
+        parameters[3] = p3;
+        changed |= FLUID_OBSTACLE_RECORD_CHANGED;
+    }
+
+    const translation = record.pose_translation;
+
+    const t_x = Math.fround(pose[0]);
+    const t_y = Math.fround(pose[1]);
+    const t_z = Math.fround(pose[2]);
+
+    if (translation[0] !== t_x || translation[1] !== t_y || translation[2] !== t_z) {
+        translation[0] = t_x;
+        translation[1] = t_y;
+        translation[2] = t_z;
+        changed |= FLUID_OBSTACLE_RECORD_CHANGED;
+    }
+
+    const rotation = record.pose_rotation;
+
+    const q_x = Math.fround(pose[3]);
+    const q_y = Math.fround(pose[4]);
+    const q_z = Math.fround(pose[5]);
+    const q_w = Math.fround(pose[6]);
+
+    if (rotation[0] !== q_x || rotation[1] !== q_y || rotation[2] !== q_z || rotation[3] !== q_w) {
+        rotation[0] = q_x;
+        rotation[1] = q_y;
+        rotation[2] = q_z;
+        rotation[3] = q_w;
+        changed |= FLUID_OBSTACLE_RECORD_CHANGED;
+    }
+
+    return changed;
+}
+
+/**
+ * Write the motion half of a record: the obstacle's inflation and its body's linear and angular
+ * velocity, comparing each as it is assigned. Every record of a collider's run takes the same.
+ * Allocates nothing.
+ *
+ * @param {FluidObstacleRecord} record
+ * @param {FluidObstacle} obstacle
+ * @param {RigidBody} body
+ * @returns {boolean} whether any field changed
+ */
+export function fluid_obstacle_write_gpu_motion(record, obstacle, body) {
+    let changed = false;
+
+    const inflation = Math.fround(obstacle.inflation);
+
+    if (record.inflation !== inflation) {
+        record.inflation = inflation;
+        changed = true;
+    }
+
+    const linear = body.linearVelocity;
+    const linear_velocity = record.linear_velocity;
+
+    const v_x = Math.fround(linear[0]);
+    const v_y = Math.fround(linear[1]);
+    const v_z = Math.fround(linear[2]);
+
+    if (linear_velocity[0] !== v_x || linear_velocity[1] !== v_y || linear_velocity[2] !== v_z) {
+        linear_velocity[0] = v_x;
+        linear_velocity[1] = v_y;
+        linear_velocity[2] = v_z;
+        changed = true;
+    }
+
+    const angular = body.angularVelocity;
+    const angular_velocity = record.angular_velocity;
+
+    const w_x = Math.fround(angular[0]);
+    const w_y = Math.fround(angular[1]);
+    const w_z = Math.fround(angular[2]);
+
+    if (angular_velocity[0] !== w_x || angular_velocity[1] !== w_y || angular_velocity[2] !== w_z) {
+        angular_velocity[0] = w_x;
+        angular_velocity[1] = w_y;
+        angular_velocity[2] = w_z;
+        changed = true;
+    }
+
+    return changed;
+}
+
+/**
+ * One packed record, its pose, and a hull's planes from 0, before they are compared into the caller's.
+ * @type {Float64Array}
+ * @private
+ */
+const SCRATCH_RECORD = new Float64Array(SHAPE_RECORD_STRIDE);
+const SCRATCH_POSE = new Float64Array(SHAPE_RECORD_POSE_STRIDE);
+const SCRATCH_PLANES = new Float64Array(SHAPE_RECORD_HULL_PLANE_LIMIT * 4);

package/src/engine/physics/fluid/prototype.js

@@ -10,6 +10,7 @@ import { BehaviorComponent } from "../../intelligence/behavior/ecs/BehaviorCompo
 import { BehaviorSystem } from "../../intelligence/behavior/ecs/BehaviorSystem.js";
 import { FluidComponent } from "./ecs/FluidComponent.js";
 import { FluidEffectorsComponent } from "./ecs/FluidEffectorsComponent.js";
+import { FluidEffectorsSystem } from "./ecs/FluidEffectorsSystem.js";
 import { FluidSystem } from "./ecs/FluidSystem.js";
 import { GlobalFluidEffector } from "./effector/GlobalFluidEffector.js";
 import { ImpulseFluidEffector } from "./effector/ImpulseFluidEffector.js";
@@ -121,6 +122,7 @@ harness.initialize({
     configuration(config, engine) {
         config.addSystem(new GUIElementSystem(engine.gameView, engine));
         config.addSystem(new BehaviorSystem(engine));
+        config.addSystem(new FluidEffectorsSystem());
         config.addSystem(new FluidSystem());
     }
 }).then(main);

package/src/engine/physics/narrowphase/rigid_subject_pose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rigid_subject_pose.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/rigid_subject_pose.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wCAZW,OAAO,oCAAoC,EAAE,WAAW,SACxD,OAAO,gDAAgD,EAAE,eAAe,MACxE,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAsBnB"}
+{"version":3,"file":"rigid_subject_pose.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/rigid_subject_pose.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wCAZW,OAAO,oCAAoC,EAAE,WAAW,SACxD,OAAO,gDAAgD,EAAE,eAAe,MACxE,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAsBnB"}