@woosh/meep-engine 3.49.0 → 3.50.0

package/src/engine/physics/cloth/wind/ClothGPUFluidWind.js

@@ -0,0 +1,441 @@
+import { assert } from "../../../../core/assert.js";
+import { GPUReadbackStatus } from "../../../../shade/renderer/buffer/table/GPUReadbackStatus.js";
+import { scs3d_sample_linear3_strided } from "../../../graphics/texture/3d/scs3d_sample_linear3.js";
+import { AbstractClothWind } from "./AbstractClothWind.js";
+
+/**
+ * Points a lattice takes along an axis at most: 16³ = 4,096 points, 64 KB, a cloth's padded box at
+ * the default spacing up to 7.5 m on a side. A larger cloth gets a coarser lattice rather than a
+ * larger readback.
+ * @type {number}
+ */
+export const CLOTH_GPU_FLUID_WIND_AXIS_LIMIT = 16;
+
+/** Floats a lattice point lands as: the wind's x, y, z, then 0 (`GPUFluidSystem#request`). */
+const POINT_FLOATS = 4;
+
+/** Floats of the largest lattice. */
+const LATTICE_FLOATS_LIMIT = POINT_FLOATS * CLOTH_GPU_FLUID_WIND_AXIS_LIMIT ** 3;
+
+/**
+ * What a lattice's first point holds until its request delivers: the delivery writes a 0 there (the
+ * point's fourth float), and nothing else does.
+ */
+const UNDELIVERED = Number.NaN;
+
+/**
+ * One lattice of the wind, asked for or delivered: its box, its points along each axis, and the
+ * floats `GPUFluidSystem#request` lands it in. Pooled with its floats.
+ */
+class ClothWindLattice {
+    /** world metres, min then max @type {Float64Array} */
+    box = new Float64Array(6);
+
+    /** points along x, y and z @type {Int32Array} */
+    counts = new Int32Array(3);
+
+    /** @type {Float32Array} */
+    data = new Float32Array(0);
+
+    /** The request's handle, while it is in flight. */
+    handle = -1;
+
+    /** Read by {@link ClothGPUFluidWind#varies} since the last begin: a cloth inside it is awake. */
+    matched = false;
+
+    /** Read by {@link ClothGPUFluidWind#sample} since the last begin. */
+    read = false;
+}
+
+/**
+ * @param {ClothWindLattice} lattice
+ * @param {number} min_x
+ * @param {number} min_y
+ * @param {number} min_z
+ * @param {number} max_x
+ * @param {number} max_y
+ * @param {number} max_z
+ * @returns {boolean} whether the lattice's box holds the box
+ */
+function lattice_covers(lattice, min_x, min_y, min_z, max_x, max_y, max_z) {
+    const b = lattice.box;
+
+    return min_x >= b[0] && min_y >= b[1] && min_z >= b[2]
+        && max_x <= b[3] && max_y <= b[4] && max_z <= b[5];
+}
+
+/**
+ * # The cloth's air, read off the GPU wind
+ *
+ * GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §12: the default source for a scene with the GPU wind —
+ * an adapter over `GPUFluidSystem`'s CPU read API, so cloth reads the same wind particles, water and
+ * volumetrics do: the fluid's cascades around its domain, its far field (`GlobalFluidEffector`s and
+ * their gust) everywhere else.
+ *
+ * `ClothWorld` makes one by itself while the scene has a domain and nothing was assigned to its
+ * `wind` (`ClothWorld#wind`); assigning one is the same source, made by hand:
+ *
+ * ```js
+ * cloth_system.wind = new ClothGPUFluidWind(gpu_fluid_system);
+ * ```
+ *
+ * The GPU's answer is a frame or more late, so cloth reads **lattices**: the wind on a grid over a
+ * box padded around each cloth, asked for ahead and interpolated when it lands.
+ *
+ * - **{@link begin}**, once a tick, takes the far field and swaps in the lattices delivered since the
+ *   last tick. A lattice no cloth read during the last tick is let go; one only {@link sample} read
+ *   (a sleeping cloth's wake test) is asked for again over its own box, so a banner asleep inside it
+ *   still notices a gust.
+ * - **{@link varies}** answers whether a delivered lattice covers the cloth's box — then the cloth
+ *   samples per particle — and asks for the box padded by {@link padding}, unless a request in flight
+ *   already covers it: one request at a time per cloth, a new lattice as fast as they land.
+ * - **{@link sample}** interpolates the newest delivered lattice holding the point
+ *   (`scs3d_sample_linear3_strided`, x fastest, four floats a point), or answers the far field.
+ *
+ * Before the first delivery, and wherever no lattice reaches, the air is the far field: uniform, so
+ * a cloth costs one sample.
+ *
+ * ## Clocks
+ *
+ * The far field's gust runs on the scene's clock (G2, `GlobalFluidEffector#advance`), not the
+ * cloth's age: `sample`'s `time` is not read. Lattices arrive when the GPU answers, so two runs of a
+ * scene need not read the same air (F4, accepted): the parity gate of the worker against the inline
+ * system holds for cloths registered on the same tick and for a time-invariant wind
+ * (`WorkerClothSystem.spec.js`).
+ *
+ * ## A status read late
+ *
+ * A status is readable for one frame, and `begin` runs once a tick, which a frame need not have: so
+ * a lattice is taken as delivered by its own data — the delivery writes 0 into its first point's
+ * fourth float, set to NaN when it is asked for — and as dropped when its handle has settled and that
+ * float has not changed. A handle recycled to another request in between reads as that request's,
+ * and the float still says the lattice did not land.
+ *
+ * Nothing is allocated per tick or per request at steady state: lattices are pooled with their
+ * floats.
+ */
+export class ClothGPUFluidWind extends AbstractClothWind {
+
+    /**
+     * Metres between a lattice's points, at most: `GPUFluidComponent`'s default finest cell, so a
+     * lattice resolves what the finest cascade holds and no finer. A box needing more than
+     * {@link CLOTH_GPU_FLUID_WIND_AXIS_LIMIT} points along an axis gets that many, further apart.
+     * @type {number}
+     */
+    spacing = 0.5;
+
+    /**
+     * Metres a cloth's box is grown by on every side when its lattice is asked for: how far the cloth
+     * may move before the lattice it will read lands and while it is read. A cape on a character
+     * running 5 m/s across two deliveries of about three frames at 60 Hz, 0.1 s.
+     * @type {number}
+     */
+    padding = 0.5;
+
+    /** @type {import("../../../graphics3/GPUFluidSystem.js").GPUFluidSystem} */
+    #fluid;
+
+    /** The far field this tick. */
+    #far = new Float64Array(3);
+
+    /** Delivered lattices, oldest first. @type {ClothWindLattice[]} */
+    #current = [];
+    #current_count = 0;
+
+    /** Lattices asked for and not yet delivered. @type {ClothWindLattice[]} */
+    #pending = [];
+    #pending_count = 0;
+
+    /** @type {ClothWindLattice[]} */
+    #spare = [];
+
+    /** The lattice the last read took, tried first by the next. @type {ClothWindLattice|null} */
+    #last = null;
+
+    /** A point in a lattice's index space. */
+    #position = new Float64Array(3);
+
+    /**
+     * @param {import("../../../graphics3/GPUFluidSystem.js").GPUFluidSystem} fluid the scene's GPU
+     *   fluid: its `far_field`, `request` and `status`
+     */
+    constructor(fluid) {
+        super();
+
+        assert.defined(fluid, 'fluid');
+        assert.notNull(fluid, 'fluid');
+
+        this.#fluid = fluid;
+    }
+
+    /**
+     * The GPU fluid this reads.
+     * @returns {import("../../../graphics3/GPUFluidSystem.js").GPUFluidSystem}
+     */
+    get fluid() {
+        return this.#fluid;
+    }
+
+    /**
+     * Lattices delivered and held. For inspection.
+     * @returns {number}
+     */
+    get lattice_count() {
+        return this.#current_count;
+    }
+
+    /**
+     * Lattices asked for and not yet delivered. For inspection.
+     * @returns {number}
+     */
+    get pending_count() {
+        return this.#pending_count;
+    }
+
+    /**
+     * @param {number} time not read: the gust runs on the scene clock
+     * @param {EntityComponentDataset} ecd not read
+     */
+    begin(time, ecd) {
+        const fluid = this.#fluid;
+
+        fluid.far_field(this.#far);
+
+        // the last tick's reads decide what stays
+        const current = this.#current;
+        let kept = 0;
+
+        for (let i = 0; i < this.#current_count; i++) {
+            const lattice = current[i];
+
+            if (!lattice.matched && !lattice.read) {
+                this.#spare.push(lattice);
+                continue;
+            }
+
+            if (!lattice.matched) {
+                // read only by a wake test: a sleeping cloth's, which asks for nothing itself
+                const b = lattice.box;
+
+                if (!this.#pending_covers(b[0], b[1], b[2], b[3], b[4], b[5])) {
+                    this.#ask(b[0], b[1], b[2], b[3], b[4], b[5], lattice.counts[0], lattice.counts[1], lattice.counts[2]);
+                }
+            }
+
+            lattice.matched = false;
+            lattice.read = false;
+
+            current[kept++] = lattice;
+        }
+
+        for (let i = kept; i < this.#current_count; i++) {
+            current[i] = null;
+        }
+
+        this.#current_count = kept;
+
+        // swap in what landed since
+        const status = fluid.status;
+        const pending = this.#pending;
+
+        let waiting = 0;
+
+        for (let i = 0; i < this.#pending_count; i++) {
+            const lattice = pending[i];
+
+            if (lattice.data[3] === 0) {
+                lattice.handle = -1;
+                current[this.#current_count++] = lattice;
+            } else if (status[lattice.handle] !== GPUReadbackStatus.Pending) {
+                // settled without landing: dropped, or its status went by unread
+                lattice.handle = -1;
+                this.#spare.push(lattice);
+            } else {
+                pending[waiting++] = lattice;
+            }
+        }
+
+        for (let i = waiting; i < this.#pending_count; i++) {
+            pending[i] = null;
+        }
+
+        this.#pending_count = waiting;
+
+        this.#last = null;
+    }
+
+    /**
+     * Whether a request in flight covers a box.
+     *
+     * @returns {boolean}
+     */
+    #pending_covers(min_x, min_y, min_z, max_x, max_y, max_z) {
+        const pending = this.#pending;
+
+        for (let i = 0; i < this.#pending_count; i++) {
+            if (lattice_covers(pending[i], min_x, min_y, min_z, max_x, max_y, max_z)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Ask for a lattice of `count_*` points over a box.
+     */
+    #ask(min_x, min_y, min_z, max_x, max_y, max_z, count_x, count_y, count_z) {
+        const lattice = this.#spare.length > 0 ? this.#spare.pop() : new ClothWindLattice();
+
+        const floats = POINT_FLOATS * count_x * count_y * count_z;
+
+        if (lattice.data.length < floats) {
+            // grown by doubling up to the largest lattice, so a pooled lattice settles at its size
+            lattice.data = new Float32Array(Math.min(LATTICE_FLOATS_LIMIT, Math.max(floats, 2 * lattice.data.length)));
+        }
+
+        const b = lattice.box;
+
+        b[0] = min_x;
+        b[1] = min_y;
+        b[2] = min_z;
+        b[3] = max_x;
+        b[4] = max_y;
+        b[5] = max_z;
+
+        lattice.counts[0] = count_x;
+        lattice.counts[1] = count_y;
+        lattice.counts[2] = count_z;
+
+        lattice.matched = false;
+        lattice.read = false;
+
+        lattice.data[3] = UNDELIVERED;
+
+        lattice.handle = this.#fluid.request(min_x, min_y, min_z, max_x, max_y, max_z, count_x, count_y, count_z, lattice.data, 0);
+
+        this.#pending[this.#pending_count++] = lattice;
+    }
+
+    /**
+     * Points along an axis spanning `extent` metres.
+     *
+     * @param {number} extent
+     * @returns {number}
+     */
+    #points(extent) {
+        const n = Math.ceil(extent / this.spacing) + 1;
+
+        return n < 2 ? 2 : (n > CLOTH_GPU_FLUID_WIND_AXIS_LIMIT ? CLOTH_GPU_FLUID_WIND_AXIS_LIMIT : n);
+    }
+
+    /**
+     * Whether a delivered lattice covers the box — then the cloth samples per particle. Asks for the
+     * box grown by {@link padding}, unless a request in flight covers the box already.
+     *
+     * @param {number} min_x
+     * @param {number} min_y
+     * @param {number} min_z
+     * @param {number} max_x
+     * @param {number} max_y
+     * @param {number} max_z
+     * @returns {boolean}
+     */
+    varies(min_x, min_y, min_z, max_x, max_y, max_z) {
+        if (!(min_x <= max_x && min_y <= max_y && min_z <= max_z)) {
+            // no particles: nothing to ask about
+            return false;
+        }
+
+        if (!this.#pending_covers(min_x, min_y, min_z, max_x, max_y, max_z)) {
+            const pad = this.padding;
+
+            const low_x = min_x - pad, low_y = min_y - pad, low_z = min_z - pad;
+            const high_x = max_x + pad, high_y = max_y + pad, high_z = max_z + pad;
+
+            this.#ask(
+                low_x, low_y, low_z, high_x, high_y, high_z,
+                this.#points(high_x - low_x), this.#points(high_y - low_y), this.#points(high_z - low_z)
+            );
+        }
+
+        // the newest lattice covering the box
+        const current = this.#current;
+
+        for (let i = this.#current_count - 1; i >= 0; i--) {
+            const lattice = current[i];
+
+            if (lattice_covers(lattice, min_x, min_y, min_z, max_x, max_y, max_z)) {
+                lattice.matched = true;
+                this.#last = lattice;
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * The newest delivered lattice holding the point, or null.
+     *
+     * @returns {ClothWindLattice|null}
+     */
+    #containing(x, y, z) {
+        const last = this.#last;
+
+        if (last !== null && lattice_covers(last, x, y, z, x, y, z)) {
+            return last;
+        }
+
+        const current = this.#current;
+
+        for (let i = this.#current_count - 1; i >= 0; i--) {
+            const lattice = current[i];
+
+            if (lattice_covers(lattice, x, y, z, x, y, z)) {
+                return lattice;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * The air at a world point, m/s: the newest delivered lattice holding it, interpolated, or the far
+     * field.
+     *
+     * @param {Float64Array|number[]} out
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} time not read: the gust runs on the scene clock
+     * @returns {Float64Array|number[]}
+     */
+    sample(out, x, y, z, time) {
+        const lattice = this.#containing(x, y, z);
+
+        if (lattice === null) {
+            const far = this.#far;
+
+            out[0] = far[0];
+            out[1] = far[1];
+            out[2] = far[2];
+
+            return out;
+        }
+
+        lattice.read = true;
+        this.#last = lattice;
+
+        const b = lattice.box;
+        const counts = lattice.counts;
+        const position = this.#position;
+
+        position[0] = counts[0] > 1 && b[3] > b[0] ? (x - b[0]) / (b[3] - b[0]) * (counts[0] - 1) : 0;
+        position[1] = counts[1] > 1 && b[4] > b[1] ? (y - b[1]) / (b[4] - b[1]) * (counts[1] - 1) : 0;
+        position[2] = counts[2] > 1 && b[5] > b[2] ? (z - b[2]) / (b[5] - b[2]) * (counts[2] - 1) : 0;
+
+        return scs3d_sample_linear3_strided(out, lattice.data, POINT_FLOATS, 0, counts[0], counts[1], counts[2], position, 0);
+    }
+}

package/src/engine/physics/cloth/wind/cloth_sample_air.d.ts

@@ -27,8 +27,9 @@
  *
  * ## Two costs, and only one of them scales
  *
- * A source that answers `varies() === false` — {@link ClothAmbientWind}, and
- * {@link ClothFluidWind} anywhere its fields do not reach — is sampled **once**
+ * A source that answers `varies() === false` — the far field, wherever
+ * {@link ClothFluidWind}'s fields and `ClothGPUFluidWind`'s lattices do not
+ * reach — is sampled **once**
  * for the whole cloth. What is left is a bounds scan and a fill, both linear in
  * particles with a handful of operations each, and both an order below a
  * trilinear sample. That is the case §10 calls "no fluid field in range", and it
@@ -47,8 +48,9 @@
  * @param {Float64Array} frame_rotation the cloth frame's world rotation, xyzw
  * @param {Float64Array} [centre] written with the world-space air at the cloth's
  *   own centre — what the sleep test compares against next step
- * @param {number} [time] seconds this cloth has stepped, the clock its gust is a
- *   function of — see {@link AbstractClothWind}
+ * @param {number} [time] seconds this cloth has stepped, handed to the source's
+ *   `sample` — see {@link AbstractClothWind}; the engine's sources read the
+ *   scene's clock instead
  * @returns {boolean} whether the source was sampled per particle
  */
 export function cloth_sample_air(state: ClothState, wind: AbstractClothWind, frame_translation: Float64Array, frame_rotation: Float64Array, centre?: Float64Array, time?: number): boolean;
@@ -82,9 +84,9 @@ export function cloth_sample_air(state: ClothState, wind: AbstractClothWind, fra
  * @param {Float64Array} frame_rotation
  * @param {Float64Array} previous the air last applied to this cloth, world-space
  * @param {number} threshold m/s
- * @param {number} time seconds the cloth has stepped — the clock its gust is a
- *   function of, which for a sleeping cloth is the age its *next* step would
- *   have, because it has to be asking about the air that step would feel
+ * @param {number} time seconds the cloth has stepped, handed to the source's
+ *   `sample` — for a sleeping cloth the age its *next* step would have, because
+ *   it has to be asking about the air that step would feel
  * @returns {boolean}
  */
 export function cloth_air_changed(state: ClothState, wind: AbstractClothWind, frame_translation: Float64Array, frame_rotation: Float64Array, previous: Float64Array, threshold: number, time: number): boolean;

package/src/engine/physics/cloth/wind/cloth_sample_air.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_sample_air.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/cloth_sample_air.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;;;;;;;GAaG;AACH,gGARW,YAAY,kBACZ,YAAY,WACZ,YAAY,SAEZ,MAAM,GAEJ,OAAO,CA8EnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,iGATW,YAAY,kBACZ,YAAY,YACZ,YAAY,aACZ,MAAM,QACN,MAAM,GAGJ,OAAO,CAsBnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,uEALW,YAAY,kBACZ,YAAY,OACZ,YAAY,GACV,IAAI,CA4BhB"}
+{"version":3,"file":"cloth_sample_air.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/cloth_sample_air.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH;;;;;;;;;;;;;;GAcG;AACH,gGATW,YAAY,kBACZ,YAAY,WACZ,YAAY,SAEZ,MAAM,GAGJ,OAAO,CA8EnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,iGATW,YAAY,kBACZ,YAAY,YACZ,YAAY,aACZ,MAAM,QACN,MAAM,GAGJ,OAAO,CAsBnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,uEALW,YAAY,kBACZ,YAAY,OACZ,YAAY,GACV,IAAI,CA4BhB"}

package/src/engine/physics/cloth/wind/cloth_sample_air.js

@@ -32,8 +32,9 @@ import { v3_quaternion_apply_inverse } from "../../../../core/geom/vec3/v3_quate
  *
  * ## Two costs, and only one of them scales
  *
- * A source that answers `varies() === false` — {@link ClothAmbientWind}, and
- * {@link ClothFluidWind} anywhere its fields do not reach — is sampled **once**
+ * A source that answers `varies() === false` — the far field, wherever
+ * {@link ClothFluidWind}'s fields and `ClothGPUFluidWind`'s lattices do not
+ * reach — is sampled **once**
  * for the whole cloth. What is left is a bounds scan and a fill, both linear in
  * particles with a handful of operations each, and both an order below a
  * trilinear sample. That is the case §10 calls "no fluid field in range", and it
@@ -53,8 +54,9 @@ import { v3_quaternion_apply_inverse } from "../../../../core/geom/vec3/v3_quate
  * @param {Float64Array} frame_rotation the cloth frame's world rotation, xyzw
  * @param {Float64Array} [centre] written with the world-space air at the cloth's
  *   own centre — what the sleep test compares against next step
- * @param {number} [time] seconds this cloth has stepped, the clock its gust is a
- *   function of — see {@link AbstractClothWind}
+ * @param {number} [time] seconds this cloth has stepped, handed to the source's
+ *   `sample` — see {@link AbstractClothWind}; the engine's sources read the
+ *   scene's clock instead
  * @returns {boolean} whether the source was sampled per particle
  */
 export function cloth_sample_air(state, wind, frame_translation, frame_rotation, centre = undefined, time = 0) {
@@ -165,9 +167,9 @@ export function cloth_sample_air(state, wind, frame_translation, frame_rotation,
  * @param {Float64Array} frame_rotation
  * @param {Float64Array} previous the air last applied to this cloth, world-space
  * @param {number} threshold m/s
- * @param {number} time seconds the cloth has stepped — the clock its gust is a
- *   function of, which for a sleeping cloth is the age its *next* step would
- *   have, because it has to be asking about the air that step would feel
+ * @param {number} time seconds the cloth has stepped, handed to the source's
+ *   `sample` — for a sleeping cloth the age its *next* step would have, because
+ *   it has to be asking about the air that step would feel
  * @returns {boolean}
  */
 export function cloth_air_changed(state, wind, frame_translation, frame_rotation, previous, threshold, time) {

package/src/engine/physics/ecs/ColliderObserverSystem.d.ts

@@ -23,7 +23,7 @@ export class ColliderObserverSystem extends System<any> {
      */
     constructor(physicsSystem: PhysicsSystem);
     dependencies: (typeof Transform64 | typeof Collider)[];
-    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof ParentEntity>)[];
+    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof ParentEntity>)[];
     /** @type {PhysicsSystem} */
     __physics: PhysicsSystem;
     /**

package/src/engine/physics/ecs/PhysicsSystem.d.ts

@@ -21,7 +21,7 @@
 export class PhysicsSystem extends System<any> {
     constructor();
     dependencies: (typeof Transform64 | typeof RigidBody)[];
-    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider>)[];
+    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof RigidBody>)[];
     /**
      * Body slots, the awake / sleeping sets, and generation counters.
      * @type {BodyStorage}

package/src/engine/physics/fluid/FluidAtmosphere.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Layout of an atmosphere record: the far field at one instant, with the terms a CPU
+ * fluid field applies in the same step. A `Float64Array` of
+ * {@link FLUID_ATMOSPHERE_WORDS } words, read at an offset.
+ *
+ * {@link FluidEffectorsSystem } folds every `GlobalFluidEffector` into one each tick and
+ * hands it out in WORLD units (`read_atmosphere`); a fluid system converts it into a
+ * field's grid units ({@link fluid_atmosphere_to_grid }) and brings the field to it
+ * ({@link fluid_apply_atmosphere }).
+ *
+ *   - `TIME`: seconds the effectors system has integrated, at the end of its last tick.
+ *   - `VELOCITY_*`: the far field `v_far = u + g`: `u` relaxes toward the globals'
+ *     drag-weighted mean wind at `DRAG`, and `g` is the sum of their gusts, unfiltered.
+ *   - `LAMBDA`: `Λ = ∫ D dt`, so air left to the far field over an interval keeps
+ *     `e^(−ΔΛ)` of its deviation from it, however `D` varied.
+ *   - `FORCED_*`: `P`, the velocity the summed body force has given air the atmosphere
+ *     otherwise leaves alone, integrated exactly tick by tick: `P ← F/D + (P − F/D)·e^(−D·dt)`,
+ *     or `P += F·dt` with no drag. Its own origin is arbitrary; what a field takes from it
+ *     over an interval, `P(t₁) − P(t₀)·e^(−ΔΛ)`, is the force's exact contribution however
+ *     `F` and `D` varied. Not part of the far field: a term inside CPU fields only.
+ *   - `FORCE_*`: `F`, the sum of the globals' body forces, this tick.
+ *   - `DRAG`: `D`, the sum of the globals' drags, this tick.
+ */
+export type FluidAtmosphere = number;
+export namespace FluidAtmosphere {
+    let TIME: number;
+    let VELOCITY_X: number;
+    let VELOCITY_Y: number;
+    let VELOCITY_Z: number;
+    let LAMBDA: number;
+    let FORCED_X: number;
+    let FORCED_Y: number;
+    let FORCED_Z: number;
+    let FORCE_X: number;
+    let FORCE_Y: number;
+    let FORCE_Z: number;
+    let DRAG: number;
+}
+/**
+ * Words in an atmosphere record.
+ * @type {number}
+ */
+export const FLUID_ATMOSPHERE_WORDS: number;
+/**
+ * Layout of a field's own atmosphere record, {@link FluidFieldatmosphere }: the instant
+ * the field was last brought to the far field, in the field's grid units.
+ * {@link fluid_apply_atmosphere } reads it as the start of the interval it steps across and
+ * writes the end.
+ *
+ *   - `SEEDED`: 1 once the record holds an instant, 0 for a field never stepped (or cleared).
+ *   - `TIME`, `LAMBDA`, `FORCED_*`: as {@link FluidAtmosphere }'s, at that instant.
+ *   - `VELOCITY_*`: the far field at that instant as the field stores it, rounded to f32, so
+ *     a face equal to the far field is exactly equal to it.
+ */
+export type FluidFieldAtmosphere = number;
+export namespace FluidFieldAtmosphere {
+    export let SEEDED: number;
+    let TIME_1: number;
+    export { TIME_1 as TIME };
+    let VELOCITY_X_1: number;
+    export { VELOCITY_X_1 as VELOCITY_X };
+    let VELOCITY_Y_1: number;
+    export { VELOCITY_Y_1 as VELOCITY_Y };
+    let VELOCITY_Z_1: number;
+    export { VELOCITY_Z_1 as VELOCITY_Z };
+    let LAMBDA_1: number;
+    export { LAMBDA_1 as LAMBDA };
+    let FORCED_X_1: number;
+    export { FORCED_X_1 as FORCED_X };
+    let FORCED_Y_1: number;
+    export { FORCED_Y_1 as FORCED_Y };
+    let FORCED_Z_1: number;
+    export { FORCED_Z_1 as FORCED_Z };
+}
+/**
+ * Words in a field's atmosphere record.
+ * @type {number}
+ */
+export const FLUID_FIELD_ATMOSPHERE_WORDS: number;
+//# sourceMappingURL=FluidAtmosphere.d.ts.map

package/src/engine/physics/fluid/FluidAtmosphere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FluidAtmosphere.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/FluidAtmosphere.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;8BAwBU,MAAM;;;;;;;;;;;;;;;AAiBhB;;;GAGG;AACH,qCAFU,MAAM,CAEyB;;;;;;;;;;;;mCAc/B,MAAM;;;;;;;;;;;;;;;;;;;;AAchB;;;GAGG;AACH,2CAFU,MAAM,CAE8B"}