@woosh/meep-engine 3.68.0 → 3.70.0

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -9,7 +9,8 @@
  * {@link FluidComponent}: the collider's shape — posed rigidly at the
  * transform's position/rotation via {@link PosedShape3D} — is sampled at the
  * centre of every fluid cell inside its world AABB, and cells whose signed
- * distance is `<= obstacle.inflation` become solid. The fluid then treats
+ * distance is `<= obstacle.inflation` become solid. A porous obstacle (`FluidObstacle.drag` above 0)
+ * is the GPU fluid's alone and is left out here. The fluid then treats
  * those cells exactly like hand-authored walls: faces pinned, pressure
  * Neumann, traces clipped.
  *
@@ -66,11 +67,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#500@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#504@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#500@#clear_field"(fluid: FluidComponent): void;
+    static "__#504@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -82,7 +83,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#500@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#504@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -102,7 +103,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#500@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#504@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof FluidObstacle> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof FluidComponent>)[];

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FluidObstacleSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/FluidObstacleSystem.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH;IAuHI;;OAEG;IACH,sCAFW,cAAc,QAIxB;IAED;;OAEG;IACH,oCAFW,cAAc,QAOxB;IAED;;;;;;;;;;OAUG;IACH,iCANW,cAAc,SACd,YAAY,QACZ,YAAY,aACZ,MAAM,SACN,YAAY,QAiDtB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,4CATW,cAAc,SACd,YAAY,QACZ,YAAY,aACZ,MAAM,SACN,YAAY,OACZ,MAAM,OACN,MAAM,OACN,MAAM,QAqEhB;;IAxRD,uCAA+B;IAE/B,6QAOE;;CAgRL;uBAlWsB,wBAAwB;8BAKjB,oBAAoB;4BAJtB,uCAAuC;4CAFvB,uDAAuD;yBAG1E,uBAAuB;0BACtB,wBAAwB;+BACnB,qBAAqB;6BAPvB,gDAAgD"}
+{"version":3,"file":"FluidObstacleSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/FluidObstacleSystem.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH;IAiII;;OAEG;IACH,sCAFW,cAAc,QAIxB;IAED;;OAEG;IACH,oCAFW,cAAc,QAOxB;IAED;;;;;;;;;;OAUG;IACH,iCANW,cAAc,SACd,YAAY,QACZ,YAAY,aACZ,MAAM,SACN,YAAY,QAiDtB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,4CATW,cAAc,SACd,YAAY,QACZ,YAAY,aACZ,MAAM,SACN,YAAY,OACZ,MAAM,OACN,MAAM,OACN,MAAM,QAqEhB;;IAlSD,uCAA+B;IAE/B,6QAOE;;CA0RL;uBA7WsB,wBAAwB;8BAKjB,oBAAoB;4BAJtB,uCAAuC;4CAFvB,uDAAuD;yBAG1E,uBAAuB;0BACtB,wBAAwB;+BACnB,qBAAqB;6BAPvB,gDAAgD"}

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.js

@@ -19,7 +19,8 @@ import { FluidObstacle } from "./FluidObstacle.js";
  * {@link FluidComponent}: the collider's shape — posed rigidly at the
  * transform's position/rotation via {@link PosedShape3D} — is sampled at the
  * centre of every fluid cell inside its world AABB, and cells whose signed
- * distance is `<= obstacle.inflation` become solid. The fluid then treats
+ * distance is `<= obstacle.inflation` become solid. A porous obstacle (`FluidObstacle.drag` above 0)
+ * is the GPU fluid's alone and is left out here. The fluid then treats
  * those cells exactly like hand-authored walls: faces pinned, pressure
  * Neumann, traces clipped.
  *
@@ -119,8 +120,10 @@ export class FluidObstacleSystem extends System {
         // With no obstacles the system must not touch any mask — fields with
         // hand-authored solids keep them.
         let obstacle_count = 0;
-        ecd.traverseEntities([FluidObstacle, Collider, RigidBody, Transform64], function () {
-            obstacle_count++;
+        ecd.traverseEntities([FluidObstacle, Collider, RigidBody, Transform64], function (obstacle) {
+            if (obstacle.drag === 0) {
+                obstacle_count++;
+            }
         });
         if (obstacle_count === 0) {
             return;
@@ -136,6 +139,10 @@ export class FluidObstacleSystem extends System {
         const point = this.#point;
 
         ecd.traverseEntities([FluidObstacle, Collider, RigidBody, Transform64], function (obstacle, collider, body, transform) {
+            if (obstacle.drag !== 0) {
+                return;
+            }
+
             posed.setup_components(
         collider.shape,
         transform.translation_x, transform.translation_y, transform.translation_z,
@@ -161,6 +168,10 @@ export class FluidObstacleSystem extends System {
         // (and pulls) the surrounding fluid. The source is the solver's own
         // linearVelocity, NOT a pose delta — teleports stamp nothing.
         ecd.traverseEntities([FluidObstacle, Collider, RigidBody, Transform64], function (obstacle, collider, body, transform) {
+            if (obstacle.drag !== 0) {
+                return;
+            }
+
             const lv = body.linearVelocity;
             const vx = lv[0];
             const vy = lv[1];

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

@@ -53,7 +53,7 @@ export class AbstractFluidEffector {
      * The per-tick hook: called by {@link FluidEffectorsSystem} exactly once per fixed
      * step for every effector, with or without a `Transform64` on its entity, after
      * {@link syncFromTransform} and before any fluid system applies it. Default: no-op.
-     * Effectors whose state evolves with time on their own (a gust's phases) override
+     * Effectors whose state evolves with time on their own override
      * this to advance it; `apply` then reads that state, and every field stepped this
      * tick sees the same.
      *

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

@@ -60,7 +60,7 @@ export class AbstractFluidEffector {
      * The per-tick hook: called by {@link FluidEffectorsSystem} exactly once per fixed
      * step for every effector, with or without a `Transform64` on its entity, after
      * {@link syncFromTransform} and before any fluid system applies it. Default: no-op.
-     * Effectors whose state evolves with time on their own (a gust's phases) override
+     * Effectors whose state evolves with time on their own override
      * this to advance it; `apply` then reads that state, and every field stepped this
      * tick sees the same.
      *

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

@@ -4,7 +4,7 @@
  *
  *     dv/dt = force + drag · (wind − v)
  *
- * plus a gust carried on top of the wind.
+ * with turbulence carried on top of the wind.
  *
  * One effector covers the whole family of "push everything" behaviours —
  * pick the regime by which fields you set:
@@ -28,9 +28,9 @@
  *     is the solver-level stability knob that exists even when no effectors
  *     are wired.)
  *
- *   - **`gust`** — weather on top of the wind: three sinusoids per axis, bounded
- *     by `gust` per axis, which the air carries rather than relaxes toward. See
- *     {@link gust}.
+ *   - **`turbulence_intensity`** — weather on top of the wind: a field of eddies, the
+ *     wind's speed times the intensity in rms, carried along by the wind. See
+ *     {@link turbulence_intensity}.
  *
  * `wind` only enters through the drag term — with `drag = 0` it is inert by
  * construction (the model degenerates to dv/dt = force).
@@ -38,20 +38,21 @@
  * ## The far field
  *
  * In a scene, globals act through {@link FluidEffectorsSystem}: once a tick it folds
- * every global into one far field — `D = Σ drag`, the drag-weighted mean of the
- * winds, the sum of the gusts and the sum of the forces — and integrates
- * `v_far = u + g`, where `u` relaxes toward the mean wind at `D` and `g` is the summed
- * gust, unfiltered. {@link FluidSystem} and {@link WorkerFluidSystem} then bring every
- * field to that far field once a step through the atmosphere identity
- * (`fluid_apply_atmosphere`), so several globals act as one, whatever order they are
- * in. A global has no `apply` of its own: it acts only through the far field, and
+ * every global into one far field — `D = Σ drag`, the drag-weighted means of the
+ * winds, of the turbulence intensities and of the length scales, and the sum of the
+ * forces — and integrates `u`, the far field's mean, toward the mean wind at `D`. The
+ * far field is `u` plus its turbulence, `σ = intensity · |u|` in rms, carried by `u`.
+ * {@link FluidSystem} and {@link WorkerFluidSystem} then bring every field to the mean
+ * once a step through the atmosphere identity (`fluid_apply_atmosphere`); the GPU fluid
+ * brings every cascade to the whole far field, turbulence and all. Several globals act
+ * as one, whatever order they are in. A global has no `apply` of its own: it acts only through the far field, and
  * `FluidSimulator#step` refuses one handed to it in its effector list.
  *
  * `force` is not part of the far field: it is a term inside CPU fields, applied exactly
  * in the same step.
  *
- * All quantities are WORLD-space: `force` in units/s², `wind` and `gust` in units/s,
- * `drag` in 1/s. The `world_to_grid` matrix's linear part converts the vectors per
+ * All quantities are WORLD-space: `force` in units/s², `wind` in units/s, `drag` in
+ * 1/s, `turbulence_length` in units. The `world_to_grid` matrix's linear part converts the vectors per
  * field, so one instance produces the same world-space atmosphere on fields of any
  * `cell_size` — gravity stays gravity.
  *
@@ -84,49 +85,34 @@ export class GlobalFluidEffector extends AbstractFluidEffector {
      */
     drag: number;
     /**
-     * Peak gust speed on top of the wind, WORLD units per second: a bound, `|g| ≤ gust`
-     * on every axis, since the component amplitudes 4/7, 2/7 and 1/7 sum to one. Cloth reads it
-     * through the far field (`ClothGPUFluidWind`, `ClothFluidWind`); the gust cloth once kept
-     * itself had this meaning, unchanged.
+     * Turbulence intensity, `σ_u / |U|`: the rms of the far field's eddies on each axis, as a share
+     * of the far field's mean speed `|U|`. 0, the default, is no turbulence. Over grass and crops
+     * the near-ground wind measures 0.15 to 0.2; MIL-F-8785C's low-altitude model gives 0.19 at
+     * 20 ft.
      *
-     * Per axis the gust is three sinusoids at 1, 2.41 and 5.83 times the base
-     * frequency `1 / gust_period`, the axes a third of a turn apart, so it turns as
-     * well as pulses:
-     *
-     *     g_axis = gust · Σ_k a_k · sin(2π·phase_k + (k+1)·φ_axis)
-     *
-     * The air carries the gust; it does not relax toward it, so `drag` does not filter
-     * it. `0` (default) is no gust.
+     * The eddies are isotropic von Kármán turbulence, frozen and carried by the mean wind
+     * (Taylor's hypothesis), from one repeating tile (`FLUID_TURBULENCE_TILE_RESOLUTION`). The
+     * fluid then shapes them: the ground's shear stretches them into streaks, a canopy's drag
+     * rolls them up. Read through `GPUFluidSystem#far_field_at`; `far_field` is the mean.
      *
      * @type {number}
      */
-    gust: number;
+    turbulence_intensity: number;
     /**
-     * Period of the gust's slowest component, seconds. Four is a breeze that
-     * arrives and leaves a few times a minute; a fraction of a second is a flutter.
-     * A value that is not positive reads as 1.
+     * The turbulence's length scale `L`, WORLD units, > 0: the von Kármán spectrum's, whose most
+     * energetic wavelength is about `4.05·L` and whose longitudinal integral scale is `0.747·L`.
+     * The tile repeats every `16·L` across and `4·L` up, and holds wavelengths down to `L/4`.
      *
-     * The phases are integrated in {@link advance}, not computed from a clock, so
-     * editing the period changes how fast the gust moves from now on and never makes
-     * it jump.
+     * The default, 58.6 m, is MIL-F-8785C's low-altitude integral scale at 20 ft (43.8 m),
+     * divided by 0.747. Smaller scales reach down to a canopy's own eddies at the cost of a
+     * shorter repeat.
      *
-     * @type {number}
-     */
-    gust_period: number;
-    /**
-     * The gust's three phases, in turns, each in `[0, 1)`: state, advanced once a tick
-     * by {@link advance}. Written by hand only to restore a saved gust.
+     * Changing it rescales the eddies about the world's origin, so the air there jumps; it is a
+     * property of a scene's weather, set once.
      *
-     * @type {Float64Array}
-     */
-    gust_phase: Float64Array;
-    /**
-     * The gust at the current phases, WORLD units per second.
-     *
-     * @param {Float64Array|number[]} out written at 0..2
-     * @returns {Float64Array|number[]} `out`
+     * @type {number}
      */
-    compute_gust(out: Float64Array | number[]): Float64Array | number[];
+    turbulence_length: number;
 }
 export namespace GlobalFluidEffector {
     let typeName: string;

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

@@ -1 +1 @@
-{"version":3,"file":"GlobalFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/GlobalFluidEffector.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH;IAEI;;;;;OAKG;IACH,OAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEhB;IAElB;;;;;OAKG;IACH,MAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEjB;IAEjB;;;;;;;OAOG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;;;;;;;;;;;OAgBG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;;;;;OAUG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,YAFU,YAAY,CAEW;IAsBjC;;;;;OAKG;IACH,kBAHW,YAAY,GAAC,MAAM,EAAE,GACnB,YAAY,GAAC,MAAM,EAAE,CAoCjC;CAqEJ;;kBAIS,MAAM;;sCAxQsB,4BAA4B"}
+{"version":3,"file":"GlobalFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/GlobalFluidEffector.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH;IAEI;;;;;OAKG;IACH,OAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEhB;IAElB;;;;;OAKG;IACH,MAFU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAEjB;IAEjB;;;;;;;OAOG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;;;;;;;OAYG;IACH,sBAFU,MAAM,CAES;IAEzB;;;;;;;;;;;;;OAaG;IACH,mBAFU,MAAM,CAES;CAyD5B;;kBAIS,MAAM;;sCAtLsB,4BAA4B"}

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

@@ -8,7 +8,7 @@ import { AbstractFluidEffector } from "./AbstractFluidEffector.js";
  *
  *     dv/dt = force + drag · (wind − v)
  *
- * plus a gust carried on top of the wind.
+ * with turbulence carried on top of the wind.
  *
  * One effector covers the whole family of "push everything" behaviours —
  * pick the regime by which fields you set:
@@ -32,9 +32,9 @@ import { AbstractFluidEffector } from "./AbstractFluidEffector.js";
  *     is the solver-level stability knob that exists even when no effectors
  *     are wired.)
  *
- *   - **`gust`** — weather on top of the wind: three sinusoids per axis, bounded
- *     by `gust` per axis, which the air carries rather than relaxes toward. See
- *     {@link gust}.
+ *   - **`turbulence_intensity`** — weather on top of the wind: a field of eddies, the
+ *     wind's speed times the intensity in rms, carried along by the wind. See
+ *     {@link turbulence_intensity}.
  *
  * `wind` only enters through the drag term — with `drag = 0` it is inert by
  * construction (the model degenerates to dv/dt = force).
@@ -42,20 +42,21 @@ import { AbstractFluidEffector } from "./AbstractFluidEffector.js";
  * ## The far field
  *
  * In a scene, globals act through {@link FluidEffectorsSystem}: once a tick it folds
- * every global into one far field — `D = Σ drag`, the drag-weighted mean of the
- * winds, the sum of the gusts and the sum of the forces — and integrates
- * `v_far = u + g`, where `u` relaxes toward the mean wind at `D` and `g` is the summed
- * gust, unfiltered. {@link FluidSystem} and {@link WorkerFluidSystem} then bring every
- * field to that far field once a step through the atmosphere identity
- * (`fluid_apply_atmosphere`), so several globals act as one, whatever order they are
- * in. A global has no `apply` of its own: it acts only through the far field, and
+ * every global into one far field — `D = Σ drag`, the drag-weighted means of the
+ * winds, of the turbulence intensities and of the length scales, and the sum of the
+ * forces — and integrates `u`, the far field's mean, toward the mean wind at `D`. The
+ * far field is `u` plus its turbulence, `σ = intensity · |u|` in rms, carried by `u`.
+ * {@link FluidSystem} and {@link WorkerFluidSystem} then bring every field to the mean
+ * once a step through the atmosphere identity (`fluid_apply_atmosphere`); the GPU fluid
+ * brings every cascade to the whole far field, turbulence and all. Several globals act
+ * as one, whatever order they are in. A global has no `apply` of its own: it acts only through the far field, and
  * `FluidSimulator#step` refuses one handed to it in its effector list.
  *
  * `force` is not part of the far field: it is a term inside CPU fields, applied exactly
  * in the same step.
  *
- * All quantities are WORLD-space: `force` in units/s², `wind` and `gust` in units/s,
- * `drag` in 1/s. The `world_to_grid` matrix's linear part converts the vectors per
+ * All quantities are WORLD-space: `force` in units/s², `wind` in units/s, `drag` in
+ * 1/s, `turbulence_length` in units. The `world_to_grid` matrix's linear part converts the vectors per
  * field, so one instance produces the same world-space atmosphere on fields of any
  * `cell_size` — gravity stays gravity.
  *
@@ -92,110 +93,38 @@ export class GlobalFluidEffector extends AbstractFluidEffector {
     drag = 0;
 
     /**
-     * Peak gust speed on top of the wind, WORLD units per second: a bound, `|g| ≤ gust`
-     * on every axis, since the component amplitudes 4/7, 2/7 and 1/7 sum to one. Cloth reads it
-     * through the far field (`ClothGPUFluidWind`, `ClothFluidWind`); the gust cloth once kept
-     * itself had this meaning, unchanged.
+     * Turbulence intensity, `σ_u / |U|`: the rms of the far field's eddies on each axis, as a share
+     * of the far field's mean speed `|U|`. 0, the default, is no turbulence. Over grass and crops
+     * the near-ground wind measures 0.15 to 0.2; MIL-F-8785C's low-altitude model gives 0.19 at
+     * 20 ft.
      *
-     * Per axis the gust is three sinusoids at 1, 2.41 and 5.83 times the base
-     * frequency `1 / gust_period`, the axes a third of a turn apart, so it turns as
-     * well as pulses:
-     *
-     *     g_axis = gust · Σ_k a_k · sin(2π·phase_k + (k+1)·φ_axis)
-     *
-     * The air carries the gust; it does not relax toward it, so `drag` does not filter
-     * it. `0` (default) is no gust.
+     * The eddies are isotropic von Kármán turbulence, frozen and carried by the mean wind
+     * (Taylor's hypothesis), from one repeating tile (`FLUID_TURBULENCE_TILE_RESOLUTION`). The
+     * fluid then shapes them: the ground's shear stretches them into streaks, a canopy's drag
+     * rolls them up. Read through `GPUFluidSystem#far_field_at`; `far_field` is the mean.
      *
      * @type {number}
      */
-    gust = 0;
+    turbulence_intensity = 0;
 
     /**
-     * Period of the gust's slowest component, seconds. Four is a breeze that
-     * arrives and leaves a few times a minute; a fraction of a second is a flutter.
-     * A value that is not positive reads as 1.
+     * The turbulence's length scale `L`, WORLD units, > 0: the von Kármán spectrum's, whose most
+     * energetic wavelength is about `4.05·L` and whose longitudinal integral scale is `0.747·L`.
+     * The tile repeats every `16·L` across and `4·L` up, and holds wavelengths down to `L/4`.
      *
-     * The phases are integrated in {@link advance}, not computed from a clock, so
-     * editing the period changes how fast the gust moves from now on and never makes
-     * it jump.
-     *
-     * @type {number}
-     */
-    gust_period = 4;
-
-    /**
-     * The gust's three phases, in turns, each in `[0, 1)`: state, advanced once a tick
-     * by {@link advance}. Written by hand only to restore a saved gust.
+     * The default, 58.6 m, is MIL-F-8785C's low-altitude integral scale at 20 ft (43.8 m),
+     * divided by 0.747. Smaller scales reach down to a canopy's own eddies at the cost of a
+     * shorter repeat.
      *
-     * @type {Float64Array}
-     */
-    gust_phase = new Float64Array(3);
-
-    /**
-     * Advance the gust's phases by `dt`: `phase_k ← frac(phase_k + dt·rate_k / gust_period)`.
-     * {@link FluidEffectorsSystem} calls it exactly once a tick.
+     * Changing it rescales the eddies about the world's origin, so the air there jumps; it is a
+     * property of a scene's weather, set once.
      *
-     * @param {number} dt seconds
-     */
-    advance(dt) {
-        const period = this.gust_period > 0 ? this.gust_period : 1;
-
-        const phase = this.gust_phase;
-
-        const p0 = phase[0] + dt * RATE_0 / period;
-        const p1 = phase[1] + dt * RATE_1 / period;
-        const p2 = phase[2] + dt * RATE_2 / period;
-
-        phase[0] = p0 - Math.floor(p0);
-        phase[1] = p1 - Math.floor(p1);
-        phase[2] = p2 - Math.floor(p2);
-    }
-
-    /**
-     * The gust at the current phases, WORLD units per second.
-     *
-     * @param {Float64Array|number[]} out written at 0..2
-     * @returns {Float64Array|number[]} `out`
+     * @type {number}
      */
-    compute_gust(out) {
-        const gust = this.gust;
-
-        if (gust === 0) {
-            out[0] = 0;
-            out[1] = 0;
-            out[2] = 0;
-
-            return out;
-        }
-
-        const phase = this.gust_phase;
-
-        const a0 = TAU * phase[0];
-        const a1 = TAU * phase[1];
-        const a2 = TAU * phase[2];
-
-        out[0] = gust * (
-            AMPLITUDE_0 * Math.sin(a0 + AXIS_PHASE_X)
-            + AMPLITUDE_1 * Math.sin(a1 + AXIS_PHASE_X * 2)
-            + AMPLITUDE_2 * Math.sin(a2 + AXIS_PHASE_X * 3)
-        );
-        out[1] = gust * (
-            AMPLITUDE_0 * Math.sin(a0 + AXIS_PHASE_Y)
-            + AMPLITUDE_1 * Math.sin(a1 + AXIS_PHASE_Y * 2)
-            + AMPLITUDE_2 * Math.sin(a2 + AXIS_PHASE_Y * 3)
-        );
-        out[2] = gust * (
-            AMPLITUDE_0 * Math.sin(a0 + AXIS_PHASE_Z)
-            + AMPLITUDE_1 * Math.sin(a1 + AXIS_PHASE_Z * 2)
-            + AMPLITUDE_2 * Math.sin(a2 + AXIS_PHASE_Z * 3)
-        );
-
-        return out;
-    }
+    turbulence_length = 58.6;
 
     /**
-     * Every field, the gust's phases included: two globals are equal when they make the
-     * same air from now on.
+     * Every field: two globals are equal when they make the same air.
      *
      * @param {AbstractFluidEffector} other
      * @return {boolean}
@@ -214,11 +143,8 @@ export class GlobalFluidEffector extends AbstractFluidEffector {
             && this.wind[0] === other.wind[0]
             && this.wind[1] === other.wind[1]
             && this.wind[2] === other.wind[2]
-            && this.gust === other.gust
-            && this.gust_period === other.gust_period
-            && this.gust_phase[0] === other.gust_phase[0]
-            && this.gust_phase[1] === other.gust_phase[1]
-            && this.gust_phase[2] === other.gust_phase[2];
+            && this.turbulence_intensity === other.turbulence_intensity
+            && this.turbulence_length === other.turbulence_length;
     }
 
     /**
@@ -238,17 +164,9 @@ export class GlobalFluidEffector extends AbstractFluidEffector {
             hash_mix3(
                 computeHashFloat(this.wind[2]),
                 computeHashFloat(this.drag),
-                computeHashFloat(this.gust)
+                computeHashFloat(this.turbulence_intensity)
             ),
-            hash_mix3(
-                computeHashFloat(this.gust_period),
-                computeHashFloat(this.gust_phase[0]),
-                hash_mix3(
-                    computeHashFloat(this.gust_phase[1]),
-                    computeHashFloat(this.gust_phase[2]),
-                    0
-                )
-            )
+            computeHashFloat(this.turbulence_length)
         );
     }
 
@@ -267,59 +185,3 @@ export class GlobalFluidEffector extends AbstractFluidEffector {
  * @type {string}
  */
 GlobalFluidEffector.typeName = "GlobalFluidEffector";
-
-/**
- * @type {number}
- */
-const TAU = 2 * Math.PI;
-
-/**
- * Component rates, as multiples of the base frequency `1 / gust_period`: mutually
- * irrational enough that the sum does not visibly repeat.
- * @type {number}
- */
-const RATE_0 = 1;
-
-/**
- * @type {number}
- */
-const RATE_1 = 2.41;
-
-/**
- * @type {number}
- */
-const RATE_2 = 5.83;
-
-/**
- * Component amplitudes. They sum to exactly one, which is what makes
- * {@link GlobalFluidEffector#gust} a bound rather than a scale.
- * @type {number}
- */
-const AMPLITUDE_0 = 4 / 7;
-
-/**
- * @type {number}
- */
-const AMPLITUDE_1 = 2 / 7;
-
-/**
- * @type {number}
- */
-const AMPLITUDE_2 = 1 / 7;
-
-/**
- * Per-axis phase offsets φ_axis, thirds of a turn; component k takes `(k+1)·φ_axis`,
- * so the axes stay apart at every rate.
- * @type {number}
- */
-const AXIS_PHASE_X = 0;
-
-/**
- * @type {number}
- */
-const AXIS_PHASE_Y = 2 * Math.PI / 3;
-
-/**
- * @type {number}
- */
-const AXIS_PHASE_Z = 4 * Math.PI / 3;

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

@@ -1,17 +1,14 @@
 /**
- * Binary serialization for {@link GlobalFluidEffector}: `force`, `wind`, `drag`, `gust`,
- * `gust_period`, and the gust's three phases, every one an f64.
+ * Binary serialization for {@link GlobalFluidEffector}: `force`, `wind`, `drag`,
+ * `turbulence_intensity` and `turbulence_length`, every one an f64.
  *
- * The phases are state, and they are written so that a save resumes the gust where it was:
- * a loaded global advanced from the load makes the same air, to the bit, as the saved one
- * advanced from the save. Written as f64 for that reason; a phase rounded to f32 would put the
- * gust a 1e-7 turn off.
+ * ## Version 1
  *
- * ## Version 0, and no upgrader
- *
- * A first version has no predecessor stream to upgrade from. Adding a field is a bump to 1 plus
- * an upgrader that writes the field's pre-upgrade default, and the spec's exact byte count is
- * what makes forgetting the bump fail rather than shift every component after this one.
+ * Version 0 carried a gust (`gust`, `gust_period` and three phases) where version 1 carries the
+ * turbulence; {@link GlobalFluidEffectorSerializationUpgrader_0_1} reads a version-0 stream as
+ * version 1, the gust dropped (it has no turbulence equivalent) and no turbulence. A host that
+ * loads version-0 saves registers it beside this adapter. The spec's exact byte count is what makes
+ * a field added without a bump fail rather than shift every component after this one.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026

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

@@ -1 +1 @@
-{"version":3,"file":"GlobalFluidEffectorSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/GlobalFluidEffectorSerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH;;IAEI,kCAA4B;IAG5B;;;OAGG;IACH,uCAFW,mBAAmB,QAmB7B;IAED;;;OAGG;IACH,yCAFW,mBAAmB,QAmB7B;CACJ;gDAvE+C,gEAAgE;oCAC5E,0BAA0B"}
+{"version":3,"file":"GlobalFluidEffectorSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/GlobalFluidEffectorSerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH;;IAEI,kCAA4B;IAG5B;;;OAGG;IACH,uCAFW,mBAAmB,QAe7B;IAED;;;OAGG;IACH,yCAFW,mBAAmB,QAe7B;CACJ;gDA5D+C,gEAAgE;oCAC5E,0BAA0B"}

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

@@ -2,19 +2,16 @@ import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/Bin
 import { GlobalFluidEffector } from "./GlobalFluidEffector.js";
 
 /**
- * Binary serialization for {@link GlobalFluidEffector}: `force`, `wind`, `drag`, `gust`,
- * `gust_period`, and the gust's three phases, every one an f64.
+ * Binary serialization for {@link GlobalFluidEffector}: `force`, `wind`, `drag`,
+ * `turbulence_intensity` and `turbulence_length`, every one an f64.
  *
- * The phases are state, and they are written so that a save resumes the gust where it was:
- * a loaded global advanced from the load makes the same air, to the bit, as the saved one
- * advanced from the save. Written as f64 for that reason; a phase rounded to f32 would put the
- * gust a 1e-7 turn off.
+ * ## Version 1
  *
- * ## Version 0, and no upgrader
- *
- * A first version has no predecessor stream to upgrade from. Adding a field is a bump to 1 plus
- * an upgrader that writes the field's pre-upgrade default, and the spec's exact byte count is
- * what makes forgetting the bump fail rather than shift every component after this one.
+ * Version 0 carried a gust (`gust`, `gust_period` and three phases) where version 1 carries the
+ * turbulence; {@link GlobalFluidEffectorSerializationUpgrader_0_1} reads a version-0 stream as
+ * version 1, the gust dropped (it has no turbulence equivalent) and no turbulence. A host that
+ * loads version-0 saves registers it beside this adapter. The spec's exact byte count is what makes
+ * a field added without a bump fail rather than shift every component after this one.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -22,7 +19,7 @@ import { GlobalFluidEffector } from "./GlobalFluidEffector.js";
 export class GlobalFluidEffectorSerializationAdapter extends BinaryClassSerializationAdapter {
 
     klass = GlobalFluidEffector;
-    version = 0;
+    version = 1;
 
     /**
      * @param {BinaryBuffer} buffer
@@ -39,12 +36,8 @@ export class GlobalFluidEffectorSerializationAdapter extends BinaryClassSerializ
 
         buffer.writeFloat64(value.drag);
 
-        buffer.writeFloat64(value.gust);
-        buffer.writeFloat64(value.gust_period);
-
-        buffer.writeFloat64(value.gust_phase[0]);
-        buffer.writeFloat64(value.gust_phase[1]);
-        buffer.writeFloat64(value.gust_phase[2]);
+        buffer.writeFloat64(value.turbulence_intensity);
+        buffer.writeFloat64(value.turbulence_length);
     }
 
     /**
@@ -62,11 +55,7 @@ export class GlobalFluidEffectorSerializationAdapter extends BinaryClassSerializ
 
         value.drag = buffer.readFloat64();
 
-        value.gust = buffer.readFloat64();
-        value.gust_period = buffer.readFloat64();
-
-        value.gust_phase[0] = buffer.readFloat64();
-        value.gust_phase[1] = buffer.readFloat64();
-        value.gust_phase[2] = buffer.readFloat64();
+        value.turbulence_intensity = buffer.readFloat64();
+        value.turbulence_length = buffer.readFloat64();
     }
 }