@woosh/meep-engine 3.68.0 → 3.70.0

package/src/engine/physics/fluid/effector/GlobalFluidEffectorSerializationUpgrader_0_1.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Reads a version-0 {@link GlobalFluidEffector} stream as version 1: `force`, `wind` and `drag` as
+ * they were; the gust (`gust`, `gust_period`, three phases), which version 1 no longer has, dropped;
+ * then no turbulence, at the default length scale.
+ *
+ * Every value an f64, in and out.
+ */
+export class GlobalFluidEffectorSerializationUpgrader_0_1 extends BinaryClassUpgrader {
+    /**
+     * @param {BinaryBuffer} source
+     * @param {BinaryBuffer} target
+     */
+    upgrade(source: BinaryBuffer, target: BinaryBuffer): void;
+}
+import { BinaryClassUpgrader } from "../../../ecs/storage/binary/BinaryClassUpgrader.js";
+//# sourceMappingURL=GlobalFluidEffectorSerializationUpgrader_0_1.d.ts.map

package/src/engine/physics/fluid/effector/GlobalFluidEffectorSerializationUpgrader_0_1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlobalFluidEffectorSerializationUpgrader_0_1.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/GlobalFluidEffectorSerializationUpgrader_0_1.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH;IAII;;;OAGG;IACH,0DAeC;CACJ;oCAlCmC,oDAAoD"}

package/src/engine/physics/fluid/effector/GlobalFluidEffectorSerializationUpgrader_0_1.js

@@ -0,0 +1,35 @@
+import { BinaryClassUpgrader } from "../../../ecs/storage/binary/BinaryClassUpgrader.js";
+import { GlobalFluidEffector } from "./GlobalFluidEffector.js";
+
+/**
+ * Reads a version-0 {@link GlobalFluidEffector} stream as version 1: `force`, `wind` and `drag` as
+ * they were; the gust (`gust`, `gust_period`, three phases), which version 1 no longer has, dropped;
+ * then no turbulence, at the default length scale.
+ *
+ * Every value an f64, in and out.
+ */
+export class GlobalFluidEffectorSerializationUpgrader_0_1 extends BinaryClassUpgrader {
+    __startVersion = 0;
+    __targetVersion = 1;
+
+    /**
+     * @param {BinaryBuffer} source
+     * @param {BinaryBuffer} target
+     */
+    upgrade(source, target) {
+        // force, wind, drag
+        for (let i = 0; i < 7; i++) {
+            target.writeFloat64(source.readFloat64());
+        }
+
+        // the gust, its period and its three phases
+        for (let i = 0; i < 5; i++) {
+            source.readFloat64();
+        }
+
+        const defaults = new GlobalFluidEffector();
+
+        target.writeFloat64(defaults.turbulence_intensity);
+        target.writeFloat64(defaults.turbulence_length);
+    }
+}

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

@@ -7,7 +7,7 @@
  *
  * Air the atmosphere alone acts on relaxes toward the far field at `D` while carrying the
  * far field's own changes, so its deviation `e = v − v_far` obeys `de/dt = −D·e` whatever
- * the gust does and however `D` varied: the step is exact over any interval, one tick or
+ * the mean does and however `D` varied: the step is exact over any interval, one tick or
  * many, and a face equal to the far field stays equal to it.
  *
  * The body force is applied exactly in the same linear step, through the forced response

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

@@ -9,7 +9,7 @@ import { FluidAtmosphere, FluidFieldAtmosphere } from "./FluidAtmosphere.js";
  *
  * Air the atmosphere alone acts on relaxes toward the far field at `D` while carrying the
  * far field's own changes, so its deviation `e = v − v_far` obeys `de/dt = −D·e` whatever
- * the gust does and however `D` varied: the step is exact over any interval, one tick or
+ * the mean does and however `D` varied: the step is exact over any interval, one tick or
  * many, and a face equal to the far field stays equal to it.
  *
  * The body force is applied exactly in the same linear step, through the forced response

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

@@ -8,7 +8,7 @@
  * of rows; one with no record of its own (a mesh, a heightmap, a scaled wrapper) is one row, its
  * oriented box (`shape_record_pack_bounding_box`), until the SDF stage. A hull's planes are rows of a
  * plane table, `vec4<f32>` each in core's `(n, offset)` layout, from `shape_parameters.x` for
- * `shape_parameters.y` planes. 80 bytes.
+ * `shape_parameters.y` planes. 96 bytes.
  *
  * Written field by field in two halves: {@link fluid_obstacle_write_gpu_shape} when the collider's
  * shape changes, {@link fluid_obstacle_write_gpu_motion} every frame, so an obstacle whose inflation
@@ -25,6 +25,14 @@
  * `fluid_obstacle_record_signed_distance` and `fluid_obstacle_record_wall_velocity`
  * (`chunk_fluid_obstacle_record`) are those, with CPU twins.
  *
+ * ## Solid or porous
+ *
+ * A record whose `drag` is 0 is **solid**: the air in it moves with the wall, and the faces of its
+ * cells are pinned. One whose `drag` is above 0 is **porous**: the air passes through it and is
+ * slowed toward the wall's velocity by `drag · |u − v| · (u − v)` a second, `u` the air's velocity
+ * and `v` the wall's (`FluidObstacle.drag`). The solid is the limit of the porous as the drag grows
+ * without bound. A porous record has no inflation: what it slows is what its surface holds.
+ *
  * @type {WebGPUStruct}
  */
 export const FLUID_OBSTACLE_RECORD_STRUCT: WebGPUStruct;

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

@@ -1 +1 @@
-{"version":3,"file":"FLUID_OBSTACLE_RECORD_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/obstacle/FLUID_OBSTACLE_RECORD_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,2CAFU,YAAY,CAmBI;6BAhDG,wDAAwD"}
+{"version":3,"file":"FLUID_OBSTACLE_RECORD_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/obstacle/FLUID_OBSTACLE_RECORD_STRUCT.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,2CAFU,YAAY,CAqBI;6BA1DG,wDAAwD"}

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

@@ -11,7 +11,7 @@ import { WebGPUStruct } from "../../../../shade/renderer/shader/type/WebGPUStruc
  * of rows; one with no record of its own (a mesh, a heightmap, a scaled wrapper) is one row, its
  * oriented box (`shape_record_pack_bounding_box`), until the SDF stage. A hull's planes are rows of a
  * plane table, `vec4<f32>` each in core's `(n, offset)` layout, from `shape_parameters.x` for
- * `shape_parameters.y` planes. 80 bytes.
+ * `shape_parameters.y` planes. 96 bytes.
  *
  * Written field by field in two halves: {@link fluid_obstacle_write_gpu_shape} when the collider's
  * shape changes, {@link fluid_obstacle_write_gpu_motion} every frame, so an obstacle whose inflation
@@ -28,6 +28,14 @@ import { WebGPUStruct } from "../../../../shade/renderer/shader/type/WebGPUStruc
  * `fluid_obstacle_record_signed_distance` and `fluid_obstacle_record_wall_velocity`
  * (`chunk_fluid_obstacle_record`) are those, with CPU twins.
  *
+ * ## Solid or porous
+ *
+ * A record whose `drag` is 0 is **solid**: the air in it moves with the wall, and the faces of its
+ * cells are pinned. One whose `drag` is above 0 is **porous**: the air passes through it and is
+ * slowed toward the wall's velocity by `drag · |u − v| · (u − v)` a second, `u` the air's velocity
+ * and `v` the wall's (`FluidObstacle.drag`). The solid is the limit of the porous as the drag grows
+ * without bound. A porous record has no inflation: what it slows is what its surface holds.
+ *
  * @type {WebGPUStruct}
  */
 export const FLUID_OBSTACLE_RECORD_STRUCT = WebGPUStruct.from({
@@ -47,4 +55,6 @@ export const FLUID_OBSTACLE_RECORD_STRUCT = WebGPUStruct.from({
     angular_velocity: vec3f,
     /** The transforms row that poses the record; `NODE3D_SCENE_ID` (0) for the world. */
     node: u32,
+    /** `FluidObstacle.drag`, 1/m: 0 for a solid, above 0 for a porous obstacle's drag. */
+    drag: f32,
 }, "FluidObstacleRecord");

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

@@ -8,6 +8,7 @@
  * @property {number} inflation metres
  * @property {Float32Array} angular_velocity `[x, y, z]`, world rad/s
  * @property {number} node the transforms row that poses the record
+ * @property {number} drag 1/m: 0 for a solid, above 0 for a porous obstacle's drag
  */
 /**
  * A staging record for one row of {@link FLUID_OBSTACLE_RECORD_STRUCT}: what
@@ -54,5 +55,9 @@ export type FluidObstacleRecord = {
      * the transforms row that poses the record
      */
     node: number;
+    /**
+     * 1/m: 0 for a solid, above 0 for a porous obstacle's drag
+     */
+    drag: number;
 };
 //# sourceMappingURL=fluid_obstacle_record_create.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fluid_obstacle_record_create.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/obstacle/fluid_obstacle_record_create.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;;;;;GAUG;AACH,gDAFa,mBAAmB,CAa/B;;;;;sBAhCa,YAAY;;;;sBACZ,YAAY;;;;gBACZ,MAAM;;;;mBACN,YAAY;;;;qBACZ,YAAY;;;;eACZ,MAAM;;;;sBACN,YAAY;;;;UACZ,MAAM"}
+{"version":3,"file":"fluid_obstacle_record_create.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/obstacle/fluid_obstacle_record_create.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;GAUG;AACH,gDAFa,mBAAmB,CAc/B;;;;;sBAlCa,YAAY;;;;sBACZ,YAAY;;;;gBACZ,MAAM;;;;mBACN,YAAY;;;;qBACZ,YAAY;;;;eACZ,MAAM;;;;sBACN,YAAY;;;;UACZ,MAAM;;;;UACN,MAAM"}

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

@@ -8,6 +8,7 @@
  * @property {number} inflation metres
  * @property {Float32Array} angular_velocity `[x, y, z]`, world rad/s
  * @property {number} node the transforms row that poses the record
+ * @property {number} drag 1/m: 0 for a solid, above 0 for a porous obstacle's drag
  */
 
 /**
@@ -31,5 +32,6 @@ export function fluid_obstacle_record_create() {
         inflation: 0,
         angular_velocity: new Float32Array(3),
         node: 0,
+        drag: 0,
     };
 }

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

@@ -39,8 +39,8 @@ export function fluid_obstacle_record_plane_count(record: FluidObstacleRecord):
  */
 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.
+ * Write the motion half of a record: the obstacle's inflation and drag 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
@@ -64,7 +64,8 @@ export function fluid_obstacle_write_gpu_motion(record: FluidObstacleRecord, obs
  * - {@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.
+ * - {@link fluid_obstacle_write_gpu_motion}: the inflation, the drag 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

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

@@ -1 +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"}
+{"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":"AAiEA;;;;;;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,CAgDnB;AAxQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;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

@@ -28,7 +28,8 @@ import { shape_record_pack_bounding_box } from "../../../../core/geom/3d/shape/r
  * - {@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.
+ * - {@link fluid_obstacle_write_gpu_motion}: the inflation, the drag 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
@@ -221,8 +222,8 @@ export function fluid_obstacle_write_gpu_shape(record, planes, plane_index, shap
 }
 
 /**
- * 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.
+ * Write the motion half of a record: the obstacle's inflation and drag 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
@@ -240,6 +241,13 @@ export function fluid_obstacle_write_gpu_motion(record, obstacle, body) {
         changed = true;
     }
 
+    const drag = Math.fround(obstacle.drag);
+
+    if (record.drag !== drag) {
+        record.drag = drag;
+        changed = true;
+    }
+
     const linear = body.linearVelocity;
     const linear_velocity = record.linear_velocity;
 

package/src/engine/physics/fluid/turbulence/FLUID_TURBULENCE_TILE.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Texels of the far field's turbulence tile on x, y and z: 128 × 32 × 128, y up.
+ *
+ * The tile repeats, so the far field's turbulence repeats every `16·L` across the wind and `4·L`
+ * up, `L` the length scale: four of the spectrum's most energetic wavelength (`≈ 4.05·L`) across,
+ * one up. 4 MiB as `rgba16float`.
+ *
+ * @type {ReadonlyArray<number>}
+ */
+export const FLUID_TURBULENCE_TILE_RESOLUTION: ReadonlyArray<number>;
+/**
+ * Texels of the turbulence tile per length scale `L`: the tile's spacing is `L/8`.
+ *
+ * The von Kármán spectrum is a function of `k·L` alone, so a tile laid out in units of `L` is the same
+ * tile for every `L`: the length scale is only how far apart its texels are in the world, and changing
+ * it regenerates nothing. Eight a length keeps the spectrum's peak (`≈ 4·L`) at 32 texels and resolves
+ * wavelengths down to `L` at 8 texels each, the fewest a trilinear read and the solver's advection
+ * carry without visible loss; shorter ones, down to the tile's Nyquist `L/4`, are in it too.
+ *
+ * @type {number}
+ */
+export const FLUID_TURBULENCE_TEXELS_PER_LENGTH: number;
+/**
+ * The seed the engine's turbulence tile is generated from: one tile, the same on every machine.
+ * @type {number}
+ */
+export const FLUID_TURBULENCE_TILE_SEED: number;
+//# sourceMappingURL=FLUID_TURBULENCE_TILE.d.ts.map

package/src/engine/physics/fluid/turbulence/FLUID_TURBULENCE_TILE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FLUID_TURBULENCE_TILE.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/turbulence/FLUID_TURBULENCE_TILE.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,+CAFU,cAAc,MAAM,CAAC,CAE+C;AAE9E;;;;;;;;;;GAUG;AACH,iDAFU,MAAM,CAEoC;AAEpD;;;GAGG;AACH,yCAFU,MAAM,CAEmC"}

package/src/engine/physics/fluid/turbulence/FLUID_TURBULENCE_TILE.js

@@ -0,0 +1,29 @@
+/**
+ * Texels of the far field's turbulence tile on x, y and z: 128 × 32 × 128, y up.
+ *
+ * The tile repeats, so the far field's turbulence repeats every `16·L` across the wind and `4·L`
+ * up, `L` the length scale: four of the spectrum's most energetic wavelength (`≈ 4.05·L`) across,
+ * one up. 4 MiB as `rgba16float`.
+ *
+ * @type {ReadonlyArray<number>}
+ */
+export const FLUID_TURBULENCE_TILE_RESOLUTION = Object.freeze([128, 32, 128]);
+
+/**
+ * Texels of the turbulence tile per length scale `L`: the tile's spacing is `L/8`.
+ *
+ * The von Kármán spectrum is a function of `k·L` alone, so a tile laid out in units of `L` is the same
+ * tile for every `L`: the length scale is only how far apart its texels are in the world, and changing
+ * it regenerates nothing. Eight a length keeps the spectrum's peak (`≈ 4·L`) at 32 texels and resolves
+ * wavelengths down to `L` at 8 texels each, the fewest a trilinear read and the solver's advection
+ * carry without visible loss; shorter ones, down to the tile's Nyquist `L/4`, are in it too.
+ *
+ * @type {number}
+ */
+export const FLUID_TURBULENCE_TEXELS_PER_LENGTH = 8;
+
+/**
+ * The seed the engine's turbulence tile is generated from: one tile, the same on every machine.
+ * @type {number}
+ */
+export const FLUID_TURBULENCE_TILE_SEED = 0x6b6172;

package/src/engine/physics/fluid/turbulence/fluid_atmosphere_velocity_at.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The far field a {@link FluidAtmosphere} record describes, at a WORLD point: its mean `u`, plus
+ * `σ·T((x − o) ⊙ S⁻¹)` when it has turbulence, `T` the engine's tile read trilinearly
+ * ({@link fluid_turbulence_tile_sample}), as every GPU reader of the far field reads it.
+ *
+ * With `σ = 0` it is `u`, and the tile is never made. Allocates nothing once the tile exists.
+ *
+ * @param {Float64Array|Float32Array|number[]} out receives `[x, y, z]`, WORLD units per second
+ * @param {Float64Array|number[]} atmosphere
+ * @param {number} offset where the record starts
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+export function fluid_atmosphere_velocity_at(out: Float64Array | Float32Array | number[], atmosphere: Float64Array | number[], offset: number, x: number, y: number, z: number): void;
+//# sourceMappingURL=fluid_atmosphere_velocity_at.d.ts.map

package/src/engine/physics/fluid/turbulence/fluid_atmosphere_velocity_at.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_atmosphere_velocity_at.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/turbulence/fluid_atmosphere_velocity_at.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,kDAPW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,YAAY,GAAC,MAAM,EAAE,UACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QA4BhB"}

package/src/engine/physics/fluid/turbulence/fluid_atmosphere_velocity_at.js

@@ -0,0 +1,49 @@
+import { FluidAtmosphere } from "../FluidAtmosphere.js";
+import { fluid_turbulence_inverse_tile_size } from "./fluid_turbulence_inverse_tile_size.js";
+import { fluid_turbulence_tile_data } from "./fluid_turbulence_tile_data.js";
+import { fluid_turbulence_tile_sample } from "./fluid_turbulence_tile_sample.js";
+
+const inverse_size = new Float64Array(3);
+const coordinate = new Float64Array(3);
+
+/**
+ * The far field a {@link FluidAtmosphere} record describes, at a WORLD point: its mean `u`, plus
+ * `σ·T((x − o) ⊙ S⁻¹)` when it has turbulence, `T` the engine's tile read trilinearly
+ * ({@link fluid_turbulence_tile_sample}), as every GPU reader of the far field reads it.
+ *
+ * With `σ = 0` it is `u`, and the tile is never made. Allocates nothing once the tile exists.
+ *
+ * @param {Float64Array|Float32Array|number[]} out receives `[x, y, z]`, WORLD units per second
+ * @param {Float64Array|number[]} atmosphere
+ * @param {number} offset where the record starts
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+export function fluid_atmosphere_velocity_at(out, atmosphere, offset, x, y, z) {
+    const sigma = atmosphere[offset + FluidAtmosphere.TURBULENCE_SIGMA];
+
+    const ux = atmosphere[offset + FluidAtmosphere.VELOCITY_X];
+    const uy = atmosphere[offset + FluidAtmosphere.VELOCITY_Y];
+    const uz = atmosphere[offset + FluidAtmosphere.VELOCITY_Z];
+
+    if (sigma === 0) {
+        out[0] = ux;
+        out[1] = uy;
+        out[2] = uz;
+
+        return;
+    }
+
+    fluid_turbulence_inverse_tile_size(inverse_size, atmosphere[offset + FluidAtmosphere.TURBULENCE_LENGTH]);
+
+    coordinate[0] = (x - atmosphere[offset + FluidAtmosphere.TURBULENCE_OFFSET_X]) * inverse_size[0];
+    coordinate[1] = (y - atmosphere[offset + FluidAtmosphere.TURBULENCE_OFFSET_Y]) * inverse_size[1];
+    coordinate[2] = (z - atmosphere[offset + FluidAtmosphere.TURBULENCE_OFFSET_Z]) * inverse_size[2];
+
+    fluid_turbulence_tile_sample(out, fluid_turbulence_tile_data(), coordinate);
+
+    out[0] = ux + sigma * out[0];
+    out[1] = uy + sigma * out[1];
+    out[2] = uz + sigma * out[2];
+}

package/src/engine/physics/fluid/turbulence/fluid_turbulence_inverse_tile_size.d.ts

@@ -0,0 +1,11 @@
+/**
+ * One over the turbulence tile's size in the world on each axis, for a length scale `L`: a world
+ * distance times it is a distance in tiles. The tile is `n·L / FLUID_TURBULENCE_TEXELS_PER_LENGTH`
+ * on an axis of `n` texels.
+ *
+ * @param {Float64Array|Float32Array|number[]} out receives x, y, z
+ * @param {number} length `L`, WORLD units, > 0
+ * @returns {Float64Array|Float32Array|number[]} `out`
+ */
+export function fluid_turbulence_inverse_tile_size(out: Float64Array | Float32Array | number[], length: number): Float64Array | Float32Array | number[];
+//# sourceMappingURL=fluid_turbulence_inverse_tile_size.d.ts.map

package/src/engine/physics/fluid/turbulence/fluid_turbulence_inverse_tile_size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_turbulence_inverse_tile_size.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/turbulence/fluid_turbulence_inverse_tile_size.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wDAJW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,UAClC,MAAM,GACJ,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,CAQ9C"}

package/src/engine/physics/fluid/turbulence/fluid_turbulence_inverse_tile_size.js

@@ -0,0 +1,18 @@
+import { FLUID_TURBULENCE_TEXELS_PER_LENGTH, FLUID_TURBULENCE_TILE_RESOLUTION } from "./FLUID_TURBULENCE_TILE.js";
+
+/**
+ * One over the turbulence tile's size in the world on each axis, for a length scale `L`: a world
+ * distance times it is a distance in tiles. The tile is `n·L / FLUID_TURBULENCE_TEXELS_PER_LENGTH`
+ * on an axis of `n` texels.
+ *
+ * @param {Float64Array|Float32Array|number[]} out receives x, y, z
+ * @param {number} length `L`, WORLD units, > 0
+ * @returns {Float64Array|Float32Array|number[]} `out`
+ */
+export function fluid_turbulence_inverse_tile_size(out, length) {
+    for (let axis = 0; axis < 3; axis++) {
+        out[axis] = FLUID_TURBULENCE_TEXELS_PER_LENGTH / (FLUID_TURBULENCE_TILE_RESOLUTION[axis] * length);
+    }
+
+    return out;
+}

package/src/engine/physics/fluid/turbulence/fluid_turbulence_tile_data.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The engine's turbulence tile and its levels ({@link fluid_turbulence_tile_generate_levels} at
+ * {@link FLUID_TURBULENCE_TILE_RESOLUTION}, {@link FLUID_TURBULENCE_TEXELS_PER_LENGTH} and
+ * {@link FLUID_TURBULENCE_TILE_SEED}, a full mip chain), every value rounded to `float16`, as the device
+ * holds it. Three values a texel, x fastest. Generated on the first call and kept: about 0.3 s and
+ * 7 MiB, once a process, and only for a scene that asks for turbulence. Never write to them.
+ *
+ * @returns {Float32Array[]}
+ */
+export function fluid_turbulence_tile_levels(): Float32Array[];
+/**
+ * The engine's turbulence tile at full resolution: level 0 of {@link fluid_turbulence_tile_levels},
+ * what a read of the far field at a point takes. Three values a texel, x fastest.
+ *
+ * @returns {Float32Array}
+ */
+export function fluid_turbulence_tile_data(): Float32Array;
+/**
+ * The tile's levels as an `rgba16float` texture's mips: four halves a texel, alpha 0, x fastest, level
+ * 0 first. Allocates the result, about 4.6 MiB, for one upload.
+ *
+ * @returns {Uint16Array[]}
+ */
+export function fluid_turbulence_tile_data_rgba16(): Uint16Array[];
+//# sourceMappingURL=fluid_turbulence_tile_data.d.ts.map

package/src/engine/physics/fluid/turbulence/fluid_turbulence_tile_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_turbulence_tile_data.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/turbulence/fluid_turbulence_tile_data.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH,gDAFa,YAAY,EAAE,CAgB1B;AAED;;;;;GAKG;AACH,8CAFa,YAAY,CAIxB;AAED;;;;;GAKG;AACH,qDAFa,WAAW,EAAE,CAezB"}

package/src/engine/physics/fluid/turbulence/fluid_turbulence_tile_data.js

@@ -0,0 +1,65 @@
+import { half_to_float_uint16 } from "../../../../core/binary/half_to_float_uint16.js";
+import { to_half_float_uint16 } from "../../../../core/binary/to_half_float_uint16.js";
+import { FLUID_TURBULENCE_TEXELS_PER_LENGTH, FLUID_TURBULENCE_TILE_RESOLUTION, FLUID_TURBULENCE_TILE_SEED } from "./FLUID_TURBULENCE_TILE.js";
+import { fluid_turbulence_tile_generate_levels } from "./fluid_turbulence_tile_generate.js";
+
+/**
+ * @type {Float32Array[]|null}
+ */
+let levels = null;
+
+/**
+ * The engine's turbulence tile and its levels ({@link fluid_turbulence_tile_generate_levels} at
+ * {@link FLUID_TURBULENCE_TILE_RESOLUTION}, {@link FLUID_TURBULENCE_TEXELS_PER_LENGTH} and
+ * {@link FLUID_TURBULENCE_TILE_SEED}, a full mip chain), every value rounded to `float16`, as the device
+ * holds it. Three values a texel, x fastest. Generated on the first call and kept: about 0.3 s and
+ * 7 MiB, once a process, and only for a scene that asks for turbulence. Never write to them.
+ *
+ * @returns {Float32Array[]}
+ */
+export function fluid_turbulence_tile_levels() {
+    if (levels === null) {
+        const generated = fluid_turbulence_tile_generate_levels(FLUID_TURBULENCE_TILE_RESOLUTION, FLUID_TURBULENCE_TEXELS_PER_LENGTH, FLUID_TURBULENCE_TILE_SEED);
+
+        for (const values of generated) {
+            for (let i = 0; i < values.length; i++) {
+                values[i] = half_to_float_uint16(to_half_float_uint16(values[i]));
+            }
+        }
+
+        levels = generated;
+    }
+
+    return levels;
+}
+
+/**
+ * The engine's turbulence tile at full resolution: level 0 of {@link fluid_turbulence_tile_levels},
+ * what a read of the far field at a point takes. Three values a texel, x fastest.
+ *
+ * @returns {Float32Array}
+ */
+export function fluid_turbulence_tile_data() {
+    return fluid_turbulence_tile_levels()[0];
+}
+
+/**
+ * The tile's levels as an `rgba16float` texture's mips: four halves a texel, alpha 0, x fastest, level
+ * 0 first. Allocates the result, about 4.6 MiB, for one upload.
+ *
+ * @returns {Uint16Array[]}
+ */
+export function fluid_turbulence_tile_data_rgba16() {
+    return fluid_turbulence_tile_levels().map(values => {
+        const count = values.length / 3;
+        const out = new Uint16Array(4 * count);
+
+        for (let i = 0; i < count; i++) {
+            out[4 * i] = to_half_float_uint16(values[3 * i]);
+            out[4 * i + 1] = to_half_float_uint16(values[3 * i + 1]);
+            out[4 * i + 2] = to_half_float_uint16(values[3 * i + 2]);
+        }
+
+        return out;
+    });
+}

package/src/engine/physics/fluid/turbulence/fluid_turbulence_tile_generate.d.ts

@@ -0,0 +1,56 @@
+/**
+ * A repeating tile of isotropic, divergence-free turbulence with the von Kármán spectrum, unit rms:
+ * the mean over the tile of each component's square, averaged over the three components, is 1.
+ * Level 0 of {@link fluid_turbulence_tile_generate_levels}.
+ *
+ * @param {ArrayLike<number>} resolution texels on x, y and z, each a power of two, 2 or more
+ * @param {number} texels_per_length texels per length scale `L`, > 0
+ * @param {number} seed
+ * @returns {Float32Array} three values a texel, `(u, v, w)`, x fastest, then y, then z
+ */
+export function fluid_turbulence_tile_generate(resolution: ArrayLike<number>, texels_per_length: number, seed: number): Float32Array;
+/**
+ * Texels of level `level` of a tile on each axis: the tile's halved `level` times, and at least 1.
+ *
+ * @param {number[]} out
+ * @param {ArrayLike<number>} resolution level 0's
+ * @param {number} level
+ * @returns {number[]} `out`
+ */
+export function fluid_turbulence_tile_level_size(out: number[], resolution: ArrayLike<number>, level: number): number[];
+/**
+ * A repeating tile of isotropic, divergence-free turbulence with the von Kármán spectrum, and its
+ * levels: level `ℓ` is the same field band-limited to what texels `2^ℓ` times as large can hold.
+ *
+ * The tile is laid out in units of the length scale `L`: `texels_per_length` texels a length. In
+ * those units the von Kármán energy spectrum is
+ *
+ *     E(k) ∝ (kL)⁴ / (1 + (kL)²)^(17/6)
+ *
+ * which rises as k⁴ from the largest scales, peaks at a wavelength of about `4.05·L`, and falls as
+ * the inertial range's k^(−5/3) below it.
+ *
+ * Spectral synthesis, Shinozuka's: each wavenumber of the tile's lattice draws a complex Gaussian
+ * vector, projects it onto the plane normal to the wavenumber, which makes the field divergence-free,
+ * and scales it by `sqrt(E(k) / (4π k²))`, an isotropic field's amplitude at a lattice point; an
+ * inverse FFT then gives the field, of which the real part is kept. The mean (`k = 0`) and the
+ * Nyquist planes are left at zero.
+ *
+ * A level keeps the wavenumbers below its own Nyquist and no others, and is the inverse FFT of those at
+ * its own texel centres: an ideal low-pass of level 0, evaluated where a sampler reads that level, so
+ * a read of level `ℓ` is level 0 with every wavelength shorter than two of its texels taken out, and
+ * nothing aliased in. Every level is scaled as level 0 is to unit rms, so a level holds the energy of
+ * its band and no more.
+ *
+ * Deterministic in `seed`, and the same level 0 whatever the level count. Allocates the levels and
+ * about 13 MB of transforms, once: this is an asset's generation, not a per-frame path.
+ *
+ * @param {ArrayLike<number>} resolution texels on x, y and z, each a power of two, 2 or more
+ * @param {number} texels_per_length texels per length scale `L`, > 0
+ * @param {number} seed
+ * @param {number} [level_count] levels to make, 1 or more; by default down to one texel on the
+ *   longest axis, a full mip chain
+ * @returns {Float32Array[]} per level, three values a texel, `(u, v, w)`, x fastest, then y, then z
+ */
+export function fluid_turbulence_tile_generate_levels(resolution: ArrayLike<number>, texels_per_length: number, seed: number, level_count?: number): Float32Array[];
+//# sourceMappingURL=fluid_turbulence_tile_generate.d.ts.map

package/src/engine/physics/fluid/turbulence/fluid_turbulence_tile_generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluid_turbulence_tile_generate.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/turbulence/fluid_turbulence_tile_generate.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,2DALW,UAAU,MAAM,CAAC,qBACjB,MAAM,QACN,MAAM,GACJ,YAAY,CAIxB;AAED;;;;;;;GAOG;AACH,sDALW,MAAM,EAAE,cACR,UAAU,MAAM,CAAC,SACjB,MAAM,GACJ,MAAM,EAAE,CAQpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,kEAPW,UAAU,MAAM,CAAC,qBACjB,MAAM,QACN,MAAM,gBACN,MAAM,GAEJ,YAAY,EAAE,CA2L1B"}