@woosh/meep-engine 3.69.0 → 3.70.0

package/src/engine/graphics3/GPUFluidSystem.d.ts

@@ -32,11 +32,12 @@ export const GPU_FLUID_SYSTEM_TICK_CAP: number;
  * new Entity().add(new Transform64()).add(new GPUFluidComponent()).build(dataset);
  * ```
  *
- * ## The CPU half: {@link far_field}
+ * ## The CPU half: {@link far_field} and {@link far_field_at}
  *
  * The far field in m/s, synchronously, from {@link FluidEffectorsSystem}'s fold: deterministic, the
  * same headless as on a device, and still air with no `FluidEffectorsSystem`. Gameplay reads this,
- * never the fluid (§6).
+ * never the fluid (§6). `far_field` is its mean; `far_field_at` is the far field at a point, its
+ * turbulence included, as every GPU reader of the wind field takes it beyond the cascades.
  *
  * ## The CPU half: {@link request}, a lattice of the wind, asynchronously
  *
@@ -58,8 +59,8 @@ export const GPU_FLUID_SYSTEM_TICK_CAP: number;
  *   most 4 batches (a frame's requests each) in flight; a frame's requests past that are dropped,
  *   with the status. Measured latency: see the proposal (§12). Rows are freed after delivery or a
  *   drop. A device restart drops what was in flight; requests not yet recorded go to the new device.
- * - **Headless** (no scene context at the update): answered from {@link far_field} at the next
- *   {@link update}, every point the far field.
+ * - **Headless** (no scene context at the update): answered from {@link far_field_at} at the next
+ *   {@link update}, every point the far field there.
  *
  * At steady state nothing is allocated per request.
  *
@@ -168,6 +169,18 @@ export class GPUFluidSystem extends System<any> {
      * @param {Float64Array|Float32Array|number[]} out receives `[x, y, z]`
      */
     far_field(out: Float64Array | Float32Array | number[]): void;
+    /**
+     * The far field now at a world point, m/s: its mean plus its turbulence there, `u + σ·T((x − o) ⊙ S⁻¹)`,
+     * as every GPU reader of the wind field takes it where no cascade holds the point
+     * (`fluid_atmosphere_velocity_at`). Synchronous and deterministic, with or without a device; the mean
+     * alone ({@link far_field}) with no turbulence. Allocates nothing once the turbulence tile exists.
+     *
+     * @param {Float64Array|Float32Array|number[]} out receives `[x, y, z]`
+     * @param {number} x world metres
+     * @param {number} y
+     * @param {number} z
+     */
+    far_field_at(out: Float64Array | Float32Array | number[], x: number, y: number, z: number): void;
     /**
      * What became of each request, by handle: a `GPUReadbackStatus`. `Pending` from {@link request}
      * until the apply point ({@link update}) that answers it, `Delivered` (the lattice is in its

package/src/engine/graphics3/GPUFluidSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUFluidSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GPUFluidSystem.js"],"names":[],"mappings":"AAyCA;;;;;;;GAOG;AAEH;;;;;;GAMG;AACH,wCAFU,MAAM,CAE2B;AAmG3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkGG;AACH;IAEI;;;;;OAKG;IACH,iCAFW,OAAO,gDAAgD,EAAE,eAAe,QAMlF;IAyID;;;OAGG;IACH,sBAHW,OAAO,qBAAqB,EAAE,cAAc,SAC5C,OAAO,qCAAqC,EAAE,KAAK,EAU7D;IAnJD,gEAAgD;IAEhD,oOAME;IA6IF;;OAEG;IACH,iEAEC;IAED;;;;;OAKG;IACH,qBAEC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;OAKG;IACH,+BAEC;IAED;;;;;OAKG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,eAFW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,QAQ5C;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,+BAEC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,eAbW,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,UACN,YAAY,iBACZ,MAAM,GACJ,MAAM,CA+ClB;IAmMD,2CAOC;IAED,4CAaC;IA4DD;;;;OAIG;IACH,gBAJW,iBAAiB,aACjB,WAAW,UACX,MAAM,QAOhB;IAED;;;;OAIG;IACH,kBAJW,iBAAiB,aACjB,WAAW,UACX,MAAM,QAiBhB;IAqiBD;;;;;OAKG;IACH,eAFW,YAAY,QAetB;IAkKL;;;;;;;OAOG;IACH,2BAFU,OAAO,CAEwB;;CAVxC;AAYD;;;GAGG;AACH;IAII;;OAEG;IACH,oBAFW,cAAc,EAMxB;IADG,uBAAoB;CAkB3B;8BA1kDY,OAAO,+CAA+C,EAAE,eAAe;2BACvE,OAAO,gDAAgD,EAAE,YAAY;oCACrE,OAAO,oDAAoD,EAAE,qBAAqB;kCAClF,OAAO,kEAAkE,EAAE,mBAAmB;kCAC9F,OAAO,2DAA2D,EAAE,mBAAmB;8BACvF,OAAO,6CAA6C,EAAE,eAAe;uBAjC3D,kBAAkB;4BACb,iCAAiC;kCAWtD,2CAA2C;wCARV,iDAAiD;4CAf7C,iDAAiD;8BAiB/D,uCAAuC;yBAJ5C,4BAA4B;0BAC3B,6BAA6B;qCARlB,oDAAoD;gCADzD,uDAAuD;gCAE5B,qDAAqD;gCAJhF,mDAAmD"}
+{"version":3,"file":"GPUFluidSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GPUFluidSystem.js"],"names":[],"mappings":"AA0CA;;;;;;;GAOG;AAEH;;;;;;GAMG;AACH,wCAFU,MAAM,CAE2B;AAiH3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmGG;AACH;IAEI;;;;;OAKG;IACH,iCAFW,OAAO,gDAAgD,EAAE,eAAe,QAMlF;IAkJD;;;OAGG;IACH,sBAHW,OAAO,qBAAqB,EAAE,cAAc,SAC5C,OAAO,qCAAqC,EAAE,KAAK,EAU7D;IA5JD,gEAAgD;IAEhD,oOAME;IAsJF;;OAEG;IACH,iEAEC;IAED;;;;;OAKG;IACH,qBAEC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;OAKG;IACH,+BAEC;IAED;;;;;OAKG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,eAFW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,QAQ5C;IAED;;;;;;;;;;OAUG;IACH,kBALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAClC,MAAM,KACN,MAAM,KACN,MAAM,QAIhB;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,+BAEC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,eAbW,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,UACN,YAAY,iBACZ,MAAM,GACJ,MAAM,CA+ClB;IA+ND,2CAOC;IAED,4CAaC;IA4DD;;;;OAIG;IACH,gBAJW,iBAAiB,aACjB,WAAW,UACX,MAAM,QAOhB;IAED;;;;OAIG;IACH,kBAJW,iBAAiB,aACjB,WAAW,UACX,MAAM,QAiBhB;IAqiBD;;;;;OAKG;IACH,eAFW,YAAY,QAetB;IA+LL;;;;;;;OAOG;IACH,2BAFU,OAAO,CAEwB;;CAVxC;AAYD;;;GAGG;AACH;IAII;;OAEG;IACH,oBAFW,cAAc,EAMxB;IADG,uBAAoB;CAkB3B;8BA1qDY,OAAO,+CAA+C,EAAE,eAAe;2BACvE,OAAO,gDAAgD,EAAE,YAAY;oCACrE,OAAO,oDAAoD,EAAE,qBAAqB;kCAClF,OAAO,kEAAkE,EAAE,mBAAmB;kCAC9F,OAAO,2DAA2D,EAAE,mBAAmB;8BACvF,OAAO,6CAA6C,EAAE,eAAe;uBAlC3D,kBAAkB;4BACb,iCAAiC;kCAWtD,2CAA2C;wCARV,iDAAiD;4CAf7C,iDAAiD;8BAiB/D,uCAAuC;yBAJ5C,4BAA4B;0BAC3B,6BAA6B;qCARlB,oDAAoD;gCADzD,uDAAuD;gCAE5B,qDAAqD;gCAJhF,mDAAmD"}

package/src/engine/graphics3/GPUFluidSystem.js

@@ -27,6 +27,7 @@ import {
 } from "../physics/fluid/ecs/GPUFluidComponent.js";
 import { fluid_effector_record_create } from "../physics/fluid/effector/record/fluid_effector_record_create.js";
 import { FLUID_ATMOSPHERE_WORDS, FluidAtmosphere } from "../physics/fluid/FluidAtmosphere.js";
+import { fluid_atmosphere_velocity_at } from "../physics/fluid/turbulence/fluid_atmosphere_velocity_at.js";
 import { fluid_obstacle_record_create } from "../physics/fluid/obstacle/fluid_obstacle_record_create.js";
 import {
     FLUID_OBSTACLE_PLANES_CHANGED,
@@ -154,6 +155,20 @@ class ObstacleEntry {
     held = false;
 }
 
+/**
+ * Point `i` of `n` along an axis of a request's box: `mix(min, max, i / (n − 1))`, or `min` for one
+ * point, as the device's gather places it.
+ *
+ * @param {number} min
+ * @param {number} max
+ * @param {number} i
+ * @param {number} n
+ * @returns {number}
+ */
+function request_axis_point(min, max, i, n) {
+    return n > 1 ? min + (max - min) * (i / (n - 1)) : min;
+}
+
 /**
  * # The GPU wind fluid of a scene
  *
@@ -172,11 +187,12 @@ class ObstacleEntry {
  * new Entity().add(new Transform64()).add(new GPUFluidComponent()).build(dataset);
  * ```
  *
- * ## The CPU half: {@link far_field}
+ * ## The CPU half: {@link far_field} and {@link far_field_at}
  *
  * The far field in m/s, synchronously, from {@link FluidEffectorsSystem}'s fold: deterministic, the
  * same headless as on a device, and still air with no `FluidEffectorsSystem`. Gameplay reads this,
- * never the fluid (§6).
+ * never the fluid (§6). `far_field` is its mean; `far_field_at` is the far field at a point, its
+ * turbulence included, as every GPU reader of the wind field takes it beyond the cascades.
  *
  * ## The CPU half: {@link request}, a lattice of the wind, asynchronously
  *
@@ -198,8 +214,8 @@ class ObstacleEntry {
  *   most 4 batches (a frame's requests each) in flight; a frame's requests past that are dropped,
  *   with the status. Measured latency: see the proposal (§12). Rows are freed after delivery or a
  *   drop. A device restart drops what was in flight; requests not yet recorded go to the new device.
- * - **Headless** (no scene context at the update): answered from {@link far_field} at the next
- *   {@link update}, every point the far field.
+ * - **Headless** (no scene context at the update): answered from {@link far_field_at} at the next
+ *   {@link update}, every point the far field there.
  *
  * At steady state nothing is allocated per request.
  *
@@ -370,6 +386,15 @@ export class GPUFluidSystem extends System {
     #bounds = new Float64Array(6);
     #far = new Float64Array(3);
 
+    /** The turbulence `σ` last written into the wind field with no domain. */
+    #wind_sigma = 0;
+
+    /** Scratch for an atmosphere's turbulence offset. */
+    #turbulence_offset = new Float64Array(3);
+
+    /** The atmosphere a tick steps against, its turbulence carried back to the tick. */
+    #tick_atmosphere = new Float64Array(FLUID_ATMOSPHERE_WORDS);
+
     /*
      The read API: per handle, the request's box and counts, its target, and its status.
     */
@@ -478,6 +503,21 @@ export class GPUFluidSystem extends System {
         out[2] = atmosphere[FluidAtmosphere.VELOCITY_Z];
     }
 
+    /**
+     * The far field now at a world point, m/s: its mean plus its turbulence there, `u + σ·T((x − o) ⊙ S⁻¹)`,
+     * as every GPU reader of the wind field takes it where no cascade holds the point
+     * (`fluid_atmosphere_velocity_at`). Synchronous and deterministic, with or without a device; the mean
+     * alone ({@link far_field}) with no turbulence. Allocates nothing once the turbulence tile exists.
+     *
+     * @param {Float64Array|Float32Array|number[]} out receives `[x, y, z]`
+     * @param {number} x world metres
+     * @param {number} y
+     * @param {number} z
+     */
+    far_field_at(out, x, y, z) {
+        fluid_atmosphere_velocity_at(out, this.#read_atmosphere(), 0, x, y, z);
+    }
+
     /**
      * What became of each request, by handle: a `GPUReadbackStatus`. `Pending` from {@link request}
      * until the apply point ({@link update}) that answers it, `Delivered` (the lattice is in its
@@ -646,26 +686,38 @@ export class GPUFluidSystem extends System {
             return;
         }
 
-        // headless: every point the far field
+        // headless: every point the far field there, at the points the device would gather
         const far = this.#far;
-
-        this.far_field(far);
+        const atmosphere = this.#read_atmosphere();
 
         const asked = this.#asked;
         const counts = this.#request_counts;
+        const box = this.#request_box;
 
         for (let i = 0; i < this.#asked_count; i++) {
             const h = asked[i];
             const target = this.#request_targets[h];
-            const points = counts[3 * h] * counts[3 * h + 1] * counts[3 * h + 2];
+            const nx = counts[3 * h], ny = counts[3 * h + 1], nz = counts[3 * h + 2];
 
             let at = this.#request_offsets[h];
 
-            for (let p = 0; p < points; p++, at += FLUID_QUERY_SAMPLE_FLOATS) {
-                target[at] = far[0];
-                target[at + 1] = far[1];
-                target[at + 2] = far[2];
-                target[at + 3] = 0;
+            for (let k = 0; k < nz; k++) {
+                const z = request_axis_point(box[6 * h + 2], box[6 * h + 5], k, nz);
+
+                for (let j = 0; j < ny; j++) {
+                    const y = request_axis_point(box[6 * h + 1], box[6 * h + 4], j, ny);
+
+                    for (let p = 0; p < nx; p++, at += FLUID_QUERY_SAMPLE_FLOATS) {
+                        const x = request_axis_point(box[6 * h], box[6 * h + 3], p, nx);
+
+                        fluid_atmosphere_velocity_at(far, atmosphere, 0, x, y, z);
+
+                        target[at] = far[0];
+                        target[at + 1] = far[1];
+                        target[at + 2] = far[2];
+                        target[at + 3] = 0;
+                    }
+                }
             }
 
             this.#settle(h, GPUReadbackStatus.Delivered);
@@ -740,6 +792,22 @@ export class GPUFluidSystem extends System {
         this.#queries = null;
     }
 
+    /**
+     * The turbulence's offset in an atmosphere record, into {@link #turbulence_offset}.
+     *
+     * @param {Float64Array} atmosphere
+     * @returns {Float64Array}
+     */
+    #read_turbulence_offset(atmosphere) {
+        const out = this.#turbulence_offset;
+
+        out[0] = atmosphere[FluidAtmosphere.TURBULENCE_OFFSET_X];
+        out[1] = atmosphere[FluidAtmosphere.TURBULENCE_OFFSET_Y];
+        out[2] = atmosphere[FluidAtmosphere.TURBULENCE_OFFSET_Z];
+
+        return out;
+    }
+
     /**
      * The far field and its terms, into {@link #atmosphere}; still air at time 0 with no effectors
      * system.
@@ -1556,16 +1624,39 @@ export class GPUFluidSystem extends System {
             anchor[1] = transform.translation_y;
             anchor[2] = transform.translation_z;
 
+            const wind = context.wind;
+            const sigma = atmosphere[FluidAtmosphere.TURBULENCE_SIGMA];
+
+            // the tile, before any pass binds it
+            if (sigma !== 0) {
+                this.#read_turbulence_offset(atmosphere);
+                wind.set_turbulence(sigma, this.#turbulence_offset, atmosphere[FluidAtmosphere.TURBULENCE_LENGTH]);
+            }
+
+            const tick_atmosphere = this.#tick_atmosphere;
+            tick_atmosphere.set(atmosphere);
+
             for (let tick = first_tick; tick <= tick_now; tick++) {
+                // every tick steps against the far field at the end of the frame's last, its eddies
+                // carried back by the mean to where the tick left them, so a frame of several ticks
+                // advances them as one tick at a time does
+                const behind = (tick_now - tick) * dt;
+
+                tick_atmosphere[FluidAtmosphere.TURBULENCE_OFFSET_X] = atmosphere[FluidAtmosphere.TURBULENCE_OFFSET_X] - atmosphere[FluidAtmosphere.VELOCITY_X] * behind;
+                tick_atmosphere[FluidAtmosphere.TURBULENCE_OFFSET_Y] = atmosphere[FluidAtmosphere.TURBULENCE_OFFSET_Y] - atmosphere[FluidAtmosphere.VELOCITY_Y] * behind;
+                tick_atmosphere[FluidAtmosphere.TURBULENCE_OFFSET_Z] = atmosphere[FluidAtmosphere.TURBULENCE_OFFSET_Z] - atmosphere[FluidAtmosphere.VELOCITY_Z] * behind;
+
                 stack.record_tick({
                     graph,
                     tick,
                     dt,
                     anchor,
-                    atmosphere,
+                    atmosphere: tick_atmosphere,
                     atmosphere_offset: 0,
                     forcing: this.#forcing,
                     vorticity_confinement: domain.component.vorticity_confinement,
+                    // always the wind's: a cascade may still hold turbulence the far field has let go of
+                    turbulence: wind.turbulence,
                 });
             }
         }
@@ -1583,25 +1674,31 @@ export class GPUFluidSystem extends System {
     }
 
     /**
-     * With no domain, the wind field is the far field alone: written when it changes.
+     * With no domain, the wind field is the far field alone: written when it changes, which with
+     * turbulence is every frame, the mean carrying the eddies.
      *
      * @param {GPUSceneContext} context
      */
     #publish_far_field(context) {
         const far = this.#far;
         const written = this.#wind_far;
+        const atmosphere = this.#read_atmosphere();
+        const sigma = atmosphere[FluidAtmosphere.TURBULENCE_SIGMA];
 
         this.far_field(far);
 
-        if (far[0] === written[0] && far[1] === written[1] && far[2] === written[2]) {
+        if (far[0] === written[0] && far[1] === written[1] && far[2] === written[2] && sigma === 0 && this.#wind_sigma === 0) {
             return;
         }
 
         const wind = context.wind;
 
         wind.set_far_velocity(far);
+        wind.set_turbulence(sigma, this.#read_turbulence_offset(atmosphere), atmosphere[FluidAtmosphere.TURBULENCE_LENGTH]);
         wind.update();
 
+        this.#wind_sigma = sigma;
+
         written[0] = far[0];
         written[1] = far[1];
         written[2] = far[2];

package/src/engine/physics/cloth/playground/wind_main.js

@@ -34,7 +34,7 @@ import { build_wind_tunnel, place_wind_post } from "./wind_build.js";
  * scene would use. The global acts as a scene's do: `FluidEffectorsSystem` folds
  * it into the far field once a step, the field is brought to that far field
  * (`fluid_apply_atmosphere`), and the cloth reads the same far field outside the
- * volume — one wind, gust included (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md G2).
+ * volume — one wind, turbulence included (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md G2).
  * That is §10's whole argument — this engine already has something better than a
  * wind zone — put where it can be watched instead of read.
  *
@@ -56,7 +56,7 @@ import { build_wind_tunnel, place_wind_post } from "./wind_build.js";
  *   shedding street — it is a steady deficit, and the free corner moves twelve
  *   times as far per step with the post as without rather than fluttering.
  *
- * And **"far field only"** is §10's fallback: the global's wind and its gust,
+ * And **"far field only"** is §10's fallback: the global's wind and its turbulence,
  * uniform over the whole banner, read through the same interface. It costs one
  * sample for the whole cloth instead of one per particle, which the readout
  * shows as the sample time dropping by a factor of twenty-five.
@@ -245,10 +245,11 @@ function step_once() {
     tunnel.effector.wind[1] = 0;
     tunnel.effector.wind[2] = Math.cos(angle) * control.speed;
 
-    // The gust is the global's, so the far field carries it inside the volume
-    // and outside alike.
-    tunnel.effector.gust = control.gust;
-    tunnel.effector.gust_period = 1.6;
+    // The turbulence is the global's, read where the cloth hangs outside the
+    // volume; the CPU fluid inside takes the mean. The slider is its rms, and its
+    // strongest eddies (4.05·L) go by every 1.6 s.
+    tunnel.effector.turbulence_intensity = control.speed > 0 ? control.gust / control.speed : 0;
+    tunnel.effector.turbulence_length = control.speed > 0 ? control.speed * 1.6 / 4.05 : tunnel.effector.turbulence_length;
 
     // 1. The air. The far field folded, then a real fluid step brought to it,
     //    with the post's wake in it — what `FluidSystem` does for a scene.

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

@@ -30,12 +30,12 @@
  * they read the same bytes of it.
  *
  * **The clock is the scene's** (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §12,
- * G2). The far field's gust is integrated once a tick by `FluidEffectorsSystem`,
+ * G2). The far field is integrated once a tick by `FluidEffectorsSystem`,
  * so a cloth steps in the weather of the tick it is advanced on — and a worker
  * cloth is advanced from the tick its registration is acknowledged, not the tick
  * it was linked (`MEASUREMENTS.md` §39, §57). So the gate holds for cloths
  * registered on the same tick under both systems, and for any registration
- * under a time-invariant wind; under a gust, a cloth the worker registers later
+ * under a time-invariant wind; under a varying one, a cloth the worker registers later
  * steps in later weather. And the GPU wind arrives when the GPU answers, so two
  * runs of a scene need not read the same air at all: run-to-run repeatability
  * under the GPU wind is given up (F4). `MEASUREMENTS.md` §69.

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

@@ -30,12 +30,12 @@
  * they read the same bytes of it.
  *
  * **The clock is the scene's** (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §12,
- * G2). The far field's gust is integrated once a tick by `FluidEffectorsSystem`,
+ * G2). The far field is integrated once a tick by `FluidEffectorsSystem`,
  * so a cloth steps in the weather of the tick it is advanced on — and a worker
  * cloth is advanced from the tick its registration is acknowledged, not the tick
  * it was linked (`MEASUREMENTS.md` §39, §57). So the gate holds for cloths
  * registered on the same tick under both systems, and for any registration
- * under a time-invariant wind; under a gust, a cloth the worker registers later
+ * under a time-invariant wind; under a varying one, a cloth the worker registers later
  * steps in later weather. And the GPU wind arrives when the GPU answers, so two
  * runs of a scene need not read the same air at all: run-to-run repeatability
  * under the GPU wind is given up (F4). `MEASUREMENTS.md` §69.

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

@@ -15,9 +15,9 @@
  * (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §6). So this is the one source a
  * CPU-fluid scene needs rather than a thing to switch between: a banner inside
  * a wind tunnel volume reads the tunnel, the same banner carried outside reads
- * the prevailing weather and its gust, and the cloth never learns which
- * happened. The gust runs on the scene's clock (G2), so `sample`'s `time` is not
- * read.
+ * the prevailing weather and its turbulence where it hangs, and the cloth never
+ * learns which happened. The far field runs on the scene's clock (G2), so
+ * `sample`'s `time` is not read.
  *
  * ## Two units problems, and they are the reason this class exists at all
  *

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

@@ -1 +1 @@
-{"version":3,"file":"ClothFluidWind.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/ClothFluidWind.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH;IAmCI;;;;OAIG;IACH,uBAJW,OAAO,yCAAyC,EAAE,oBAAoB,EAWhF;IA7CD;;;;OAIG;IACH,oBAAY;IAEZ;;;;OAIG;IACH,qBAAwD;IAExD;;;;OAIG;IACH,qBAAkB;IAElB;;;OAGG;IACH,iBAAc;IAEd;;;OAGG;IACH,gBAAY;IAgBZ;;;OAGG;IACH,wFAEC;CAkHJ;kCArOiC,wBAAwB"}
+{"version":3,"file":"ClothFluidWind.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/ClothFluidWind.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH;IAmCI;;;;OAIG;IACH,uBAJW,OAAO,yCAAyC,EAAE,oBAAoB,EAWhF;IA7CD;;;;OAIG;IACH,oBAAY;IAEZ;;;;OAIG;IACH,qBAAwD;IAExD;;;;OAIG;IACH,qBAAkB;IAElB;;;OAGG;IACH,iBAAc;IAEd;;;OAGG;IACH,gBAAY;IAgBZ;;;OAGG;IACH,wFAEC;CA+GJ;kCAnOiC,wBAAwB"}

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

@@ -4,6 +4,7 @@ import { FluidComponent } from "../../fluid/ecs/FluidComponent.js";
 import { fluid_sample_domain_bounds } from "../../fluid/ecs/fluid_sample_domain_bounds.js";
 import { fluid_sample_velocity_world_mps } from "../../fluid/ecs/fluid_sample_velocity_world_mps.js";
 import { AbstractClothWind } from "./AbstractClothWind.js";
+import { fluid_atmosphere_velocity_at } from "../../fluid/turbulence/fluid_atmosphere_velocity_at.js";
 
 /**
  * # The air, read out of the CPU fluid simulation that is already running
@@ -22,9 +23,9 @@ import { AbstractClothWind } from "./AbstractClothWind.js";
  * (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §6). So this is the one source a
  * CPU-fluid scene needs rather than a thing to switch between: a banner inside
  * a wind tunnel volume reads the tunnel, the same banner carried outside reads
- * the prevailing weather and its gust, and the cloth never learns which
- * happened. The gust runs on the scene's clock (G2), so `sample`'s `time` is not
- * read.
+ * the prevailing weather and its turbulence where it hangs, and the cloth never
+ * learns which happened. The far field runs on the scene's clock (G2), so
+ * `sample`'s `time` is not read.
  *
  * ## Two units problems, and they are the reason this class exists at all
  *
@@ -201,7 +202,7 @@ export class ClothFluidWind extends AbstractClothWind {
      * @param {number} y
      * @param {number} z
      * @param {number} time not read: a field's velocities are a snapshot of this
-     *   tick, and the far field's gust runs on the scene clock
+     *   tick, and the far field runs on the scene clock
      * @returns {Float64Array|number[]}
      */
     sample(out, x, y, z, time) {
@@ -224,11 +225,8 @@ export class ClothFluidWind extends AbstractClothWind {
             return out;
         }
 
-        const atmosphere = this.__atmosphere;
-
-        out[0] = atmosphere[FluidAtmosphere.VELOCITY_X];
-        out[1] = atmosphere[FluidAtmosphere.VELOCITY_Y];
-        out[2] = atmosphere[FluidAtmosphere.VELOCITY_Z];
+        // the far field there, its turbulence included
+        fluid_atmosphere_velocity_at(out, this.__atmosphere, 0, x, y, z);
 
         return out;
     }

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

@@ -10,8 +10,8 @@ export const CLOTH_GPU_FLUID_WIND_AXIS_LIMIT: number;
  *
  * 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.
+ * volumetrics do: the fluid's cascades around its domain, its far field (`GlobalFluidEffector`s, their
+ * mean wind and its turbulence) 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:
@@ -23,23 +23,23 @@ export const CLOTH_GPU_FLUID_WIND_AXIS_LIMIT: number;
  * 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
+ * - **{@link begin}**, once a tick, 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.
+ *   (`scs3d_sample_linear3_strided`, x fastest, four floats a point), or answers the far field there
+ *   (`GPUFluidSystem#far_field_at`).
  *
- * Before the first delivery, and wherever no lattice reaches, the air is the far field: uniform, so
- * a cloth costs one sample.
+ * Before the first delivery, and wherever no lattice reaches, the air is the far field, which a cloth
+ * samples once: its mean, and its turbulence where the cloth asks.
  *
  * ## 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
+ * The far field runs on the scene's clock (G2, `FluidEffectorsSystem`'s fold), 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`).
@@ -58,7 +58,7 @@ export const CLOTH_GPU_FLUID_WIND_AXIS_LIMIT: number;
 export class ClothGPUFluidWind extends AbstractClothWind {
     /**
      * @param {import("../../../graphics3/GPUFluidSystem.js").GPUFluidSystem} fluid the scene's GPU
-     *   fluid: its `far_field`, `request` and `status`
+     *   fluid: its `far_field_at`, `request` and `status`
      */
     constructor(fluid: import("../../../graphics3/GPUFluidSystem.js").GPUFluidSystem);
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"ClothGPUFluidWind.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/ClothGPUFluidWind.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,8CAFU,MAAM,CAEkC;AAuDlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH;IAyCI;;;OAGG;IACH,mBAHW,OAAO,sCAAsC,EAAE,cAAc,EAUvE;IAlDD;;;;;OAKG;IACH,SAFU,MAAM,CAEF;IAEd;;;;;OAKG;IACH,SAFU,MAAM,CAEF;IAsCd;;;OAGG;IACH,2EAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,4BAEC;;CAwPJ;kCArbiC,wBAAwB"}
+{"version":3,"file":"ClothGPUFluidWind.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/wind/ClothGPUFluidWind.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,8CAFU,MAAM,CAEkC;AAuDlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH;IAuCI;;;OAGG;IACH,mBAHW,OAAO,sCAAsC,EAAE,cAAc,EAUvE;IAhDD;;;;;OAKG;IACH,SAFU,MAAM,CAEF;IAEd;;;;;OAKG;IACH,SAFU,MAAM,CAEF;IAoCd;;;OAGG;IACH,2EAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,4BAEC;;CAkPJ;kCA7aiC,wBAAwB"}

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

@@ -69,8 +69,8 @@ function lattice_covers(lattice, min_x, min_y, min_z, max_x, max_y, max_z) {
  *
  * 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.
+ * volumetrics do: the fluid's cascades around its domain, its far field (`GlobalFluidEffector`s, their
+ * mean wind and its turbulence) 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:
@@ -82,23 +82,23 @@ function lattice_covers(lattice, min_x, min_y, min_z, max_x, max_y, max_z) {
  * 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
+ * - **{@link begin}**, once a tick, 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.
+ *   (`scs3d_sample_linear3_strided`, x fastest, four floats a point), or answers the far field there
+ *   (`GPUFluidSystem#far_field_at`).
  *
- * Before the first delivery, and wherever no lattice reaches, the air is the far field: uniform, so
- * a cloth costs one sample.
+ * Before the first delivery, and wherever no lattice reaches, the air is the far field, which a cloth
+ * samples once: its mean, and its turbulence where the cloth asks.
  *
  * ## 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
+ * The far field runs on the scene's clock (G2, `FluidEffectorsSystem`'s fold), 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`).
@@ -135,8 +135,6 @@ export class ClothGPUFluidWind extends AbstractClothWind {
     /** @type {import("../../../graphics3/GPUFluidSystem.js").GPUFluidSystem} */
     #fluid;
 
-    /** The far field this tick. */
-    #far = new Float64Array(3);
 
     /** Delivered lattices, oldest first. @type {ClothWindLattice[]} */
     #current = [];
@@ -157,7 +155,7 @@ export class ClothGPUFluidWind extends AbstractClothWind {
 
     /**
      * @param {import("../../../graphics3/GPUFluidSystem.js").GPUFluidSystem} fluid the scene's GPU
-     *   fluid: its `far_field`, `request` and `status`
+     *   fluid: its `far_field_at`, `request` and `status`
      */
     constructor(fluid) {
         super();
@@ -193,14 +191,12 @@ export class ClothGPUFluidWind extends AbstractClothWind {
     }
 
     /**
-     * @param {number} time not read: the gust runs on the scene clock
+     * @param {number} time not read: the far field 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;
@@ -403,24 +399,20 @@ export class ClothGPUFluidWind extends AbstractClothWind {
 
     /**
      * The air at a world point, m/s: the newest delivered lattice holding it, interpolated, or the far
-     * field.
+     * field there (`GPUFluidSystem#far_field_at`), its turbulence included.
      *
      * @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
+     * @param {number} time not read: the far field 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];
+            this.#fluid.far_field_at(out, x, y, z);
 
             return out;
         }

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

@@ -9,8 +9,8 @@
  * ({@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.
+ *   - `VELOCITY_*`: `u`, the far field's mean: it relaxes toward the globals' drag-weighted
+ *     mean wind at `DRAG`. Where a reader takes the far field as one vector, this is it.
  *   - `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
@@ -20,6 +20,15 @@
  *     `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.
+ *   - `TURBULENCE_OFFSET_*`: `o = ∫ u dt`, how far the mean has carried the turbulence since the
+ *     first tick, WORLD units, integrated exactly tick by tick.
+ *   - `TURBULENCE_SIGMA`: `σ`, the turbulence's rms on each axis, `intensity · |u|`, WORLD units per
+ *     second; 0 is none.
+ *   - `TURBULENCE_LENGTH`: `L`, its length scale, WORLD units.
+ *
+ * The far field at a point `x` is `u + σ·T((x − o) ⊙ S⁻¹)` ({@link fluid_atmosphere_velocity_at }),
+ * `T` the unit-rms turbulence tile and `S` its size in the world for `L`. Not part of CPU fields,
+ * which take `u` alone.
  */
 export type FluidAtmosphere = number;
 export namespace FluidAtmosphere {
@@ -35,6 +44,11 @@ export namespace FluidAtmosphere {
     let FORCE_Y: number;
     let FORCE_Z: number;
     let DRAG: number;
+    let TURBULENCE_OFFSET_X: number;
+    let TURBULENCE_OFFSET_Y: number;
+    let TURBULENCE_OFFSET_Z: number;
+    let TURBULENCE_SIGMA: number;
+    let TURBULENCE_LENGTH: number;
 }
 /**
  * Words in an atmosphere record.

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

@@ -1 +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"}
+{"version":3,"file":"FluidAtmosphere.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/FluidAtmosphere.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAiCU,MAAM;;;;;;;;;;;;;;;;;;;;AAsBhB;;;GAGG;AACH,qCAFU,MAAM,CAEyB;;;;;;;;;;;;mCAc/B,MAAM;;;;;;;;;;;;;;;;;;;;AAchB;;;GAGG;AACH,2CAFU,MAAM,CAE8B"}