@woosh/meep-engine 3.69.0 → 3.70.0

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

@@ -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.
  *
  * @readonly
  * @enum {number}
@@ -37,13 +46,18 @@ export const FluidAtmosphere = {
     FORCE_Y: 9,
     FORCE_Z: 10,
     DRAG: 11,
+    TURBULENCE_OFFSET_X: 12,
+    TURBULENCE_OFFSET_Y: 13,
+    TURBULENCE_OFFSET_Z: 14,
+    TURBULENCE_SIGMA: 15,
+    TURBULENCE_LENGTH: 16,
 };
 
 /**
  * Words in an atmosphere record.
  * @type {number}
  */
-export const FLUID_ATMOSPHERE_WORDS = 12;
+export const FLUID_ATMOSPHERE_WORDS = 17;
 
 /**
  * Layout of a field's own atmosphere record, {@link FluidField#atmosphere}: the instant

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

@@ -6,8 +6,7 @@
  * Every effector class in a saved component needs its adapter in the same registry: the engine's
  * are {@link GlobalFluidEffectorSerializationAdapter}, {@link ImpulseFluidEffectorSerializationAdapter},
  * {@link WakeFluidEffectorSerializationAdapter} and {@link VortexFluidEffectorSerializationAdapter}, and
- * an effector class of your own needs a `typeName` and an adapter of its own. A global's gust phases
- * go with it, so a save resumes the gust where it was.
+ * an effector class of your own needs a `typeName` and an adapter of its own.
  *
  * Like the other physics adapters this is not in `populateEngineSerializationRegistry`; the host
  * registers it with the effector adapters.

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

@@ -1 +1 @@
-{"version":3,"file":"FluidEffectorsComponentSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/FluidEffectorsComponentSerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH;;IAEI,sCAAgC;IAGhC;;OAEG;IACH,eAFU,mCAAiC,IAAI,CAE1B;IAErB;;;OAGG;IACH,+EAEC;IAED;;;OAGG;IACH,uCAFW,uBAAuB,QAWjC;IAED;;;;;OAKG;IACH,yCAFW,uBAAuB,QAWjC;CACJ;gDAvE+C,gEAAgE;wCACxE,8BAA8B"}
+{"version":3,"file":"FluidEffectorsComponentSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/FluidEffectorsComponentSerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH;;IAEI,sCAAgC;IAGhC;;OAEG;IACH,eAFU,mCAAiC,IAAI,CAE1B;IAErB;;;OAGG;IACH,+EAEC;IAED;;;OAGG;IACH,uCAFW,uBAAuB,QAWjC;IAED;;;;;OAKG;IACH,yCAFW,uBAAuB,QAWjC;CACJ;gDAtE+C,gEAAgE;wCACxE,8BAA8B"}

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

@@ -9,8 +9,7 @@ import { FluidEffectorsComponent } from "./FluidEffectorsComponent.js";
  * Every effector class in a saved component needs its adapter in the same registry: the engine's
  * are {@link GlobalFluidEffectorSerializationAdapter}, {@link ImpulseFluidEffectorSerializationAdapter},
  * {@link WakeFluidEffectorSerializationAdapter} and {@link VortexFluidEffectorSerializationAdapter}, and
- * an effector class of your own needs a `typeName` and an adapter of its own. A global's gust phases
- * go with it, so a save resumes the gust where it was.
+ * an effector class of your own needs a `typeName` and an adapter of its own.
  *
  * Like the other physics adapters this is not in `populateEngineSerializationRegistry`; the host
  * registers it with the effector adapters.

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

@@ -11,22 +11,25 @@
  *
  *   3. the fold of every {@link GlobalFluidEffector} into one far field, integrated in f64.
  *
- * Effectors carry state across ticks — a wake's trail advances in its sync, a global's gust in
- * its advance — so this has to happen exactly once a tick however many fluid systems apply the
- * effectors. It used to be a line in each fluid system, and a scene with two of them advanced
+ * Effectors carry state across ticks — a wake's trail advances in its sync — so this has to happen
+ * exactly once a tick however many fluid systems apply the effectors. It used to be a line in each fluid system, and a scene with two of them advanced
  * every wake twice.
  *
  * ## The far field
  *
  * The globals fold into `D = Σ d` (their drags), `W = Σ (d/D)·w` (the drag-weighted mean of their
- * winds), `g = Σ gust` and `F = Σ force`. The far field is `v_far = u + g`:
+ * winds), `I = Σ (d/D)·i` and `L = Σ (d/D)·l` (of their turbulence intensities and length scales)
+ * and `F = Σ force`. The far field is `u`, its mean, plus turbulence of rms `σ = I·|u|`:
  *
  *   - `u` relaxes toward `W` exactly, `u ← W + (u − W)·e^(−D·dt)`. Only this system's first fold
  *     seeds it at `W`, so a scene that starts with its globals starts in steady state; a global
  *     that arrives later relaxes the air from where it is, at its drag. With `D = 0` — the last
  *     global gone included — nothing relaxes it and it holds. A scene that never had a global is
  *     still air; calm is authored as a global with wind 0 and a drag.
- *   - `g` is added, not drag-filtered: the air carries the authored gust.
+ *   - `I` and `L` are this tick's, and with `D = 0` hold where they were, like `u`.
+ *   - the turbulence is carried by `u`: its offset `o = ∫ u dt` is integrated exactly over each tick
+ *     along `u`'s relaxation, `W·dt + (u₀ − W)·(1 − e^(−D·dt))/D`, or `u·dt` with no drag. `o` is this
+ *     system's own and starts at 0, so a scene loaded from a save starts the eddies over.
  *   - `Λ += D·dt`, so a field brought from one instant to another keeps `e^(−ΔΛ)` of its deviation
  *     from the far field however `D` varied in between.
  *   - `F` is not part of the far field: a world-wide body force would be an unbounded downdraft at

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

@@ -1 +1 @@
-{"version":3,"file":"FluidEffectorsSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/FluidEffectorsSystem.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH;;IAEI,mIAME;IA6DF;;;;;;;;OAQG;IACH,qBAHW,YAAY,GAAC,MAAM,EAAE,UACrB,MAAM,QAQhB;;CAsKJ;uBAhTsB,wBAAwB;wCAIP,8BAA8B;4CAL1B,uDAAuD;4BAEvE,uCAAuC"}
+{"version":3,"file":"FluidEffectorsSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/FluidEffectorsSystem.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH;;IAEI,mIAME;IAyEF;;;;;;;;OAQG;IACH,qBAHW,YAAY,GAAC,MAAM,EAAE,UACrB,MAAM,QAQhB;;CAkMJ;uBA3VsB,wBAAwB;wCAIP,8BAA8B;4CAL1B,uDAAuD;4BAEvE,uCAAuC"}

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

@@ -20,22 +20,25 @@ import { fluid_sync_effectors_from_transform } from "./fluid_sync_effectors_from
  *
  *   3. the fold of every {@link GlobalFluidEffector} into one far field, integrated in f64.
  *
- * Effectors carry state across ticks — a wake's trail advances in its sync, a global's gust in
- * its advance — so this has to happen exactly once a tick however many fluid systems apply the
- * effectors. It used to be a line in each fluid system, and a scene with two of them advanced
+ * Effectors carry state across ticks — a wake's trail advances in its sync — so this has to happen
+ * exactly once a tick however many fluid systems apply the effectors. It used to be a line in each fluid system, and a scene with two of them advanced
  * every wake twice.
  *
  * ## The far field
  *
  * The globals fold into `D = Σ d` (their drags), `W = Σ (d/D)·w` (the drag-weighted mean of their
- * winds), `g = Σ gust` and `F = Σ force`. The far field is `v_far = u + g`:
+ * winds), `I = Σ (d/D)·i` and `L = Σ (d/D)·l` (of their turbulence intensities and length scales)
+ * and `F = Σ force`. The far field is `u`, its mean, plus turbulence of rms `σ = I·|u|`:
  *
  *   - `u` relaxes toward `W` exactly, `u ← W + (u − W)·e^(−D·dt)`. Only this system's first fold
  *     seeds it at `W`, so a scene that starts with its globals starts in steady state; a global
  *     that arrives later relaxes the air from where it is, at its drag. With `D = 0` — the last
  *     global gone included — nothing relaxes it and it holds. A scene that never had a global is
  *     still air; calm is authored as a global with wind 0 and a drag.
- *   - `g` is added, not drag-filtered: the air carries the authored gust.
+ *   - `I` and `L` are this tick's, and with `D = 0` hold where they were, like `u`.
+ *   - the turbulence is carried by `u`: its offset `o = ∫ u dt` is integrated exactly over each tick
+ *     along `u`'s relaxation, `W·dt + (u₀ − W)·(1 − e^(−D·dt))/D`, or `u·dt` with no drag. `o` is this
+ *     system's own and starts at 0, so a scene loaded from a save starts the eddies over.
  *   - `Λ += D·dt`, so a field brought from one instant to another keeps `e^(−ΔΛ)` of its deviation
  *     from the far field however `D` varied in between.
  *   - `F` is not part of the far field: a world-wide body force would be an unbounded downdraft at
@@ -91,10 +94,22 @@ export class FluidEffectorsSystem extends System {
     #global_count = 0;
 
     /**
-     * Scratch for one global's gust.
+     * `o`, how far `u` has carried the turbulence, WORLD units.
      * @type {Float64Array}
      */
-    #gust = new Float64Array(3);
+    #turbulence_offset = new Float64Array(3);
+
+    /**
+     * `I`, the folded turbulence intensity, held with `D = 0`.
+     * @type {number}
+     */
+    #turbulence_intensity = 0;
+
+    /**
+     * `L`, the folded length scale, held with `D = 0`; 0 before any global with drag.
+     * @type {number}
+     */
+    #turbulence_length = 0;
 
     /**
      * `u`, the far field's steady part, WORLD units per second.
@@ -207,10 +222,8 @@ export class FluidEffectorsSystem extends System {
     #fold(dt) {
         const globals = this.#globals;
         const count = this.#global_count;
-        const gust = this.#gust;
 
         let D = 0;
-        let gx = 0, gy = 0, gz = 0;
         let fx = 0, fy = 0, fz = 0;
 
         for (let i = 0; i < count; i++) {
@@ -224,19 +237,16 @@ export class FluidEffectorsSystem extends System {
             fx += force[0];
             fy += force[1];
             fz += force[2];
-
-            effector.compute_gust(gust);
-            gx += gust[0];
-            gy += gust[1];
-            gz += gust[2];
         }
 
         const steady = this.#steady;
+        const offset = this.#turbulence_offset;
 
         // With no drag (no global at all included) nothing relaxes the air: `u` holds.
         if (D > 0) {
             // Weights d/D, so one global's mean wind is its own wind exactly.
             let wx = 0, wy = 0, wz = 0;
+            let intensity = 0, length = 0;
 
             for (let i = 0; i < count; i++) {
                 const effector = globals[i];
@@ -251,11 +261,24 @@ export class FluidEffectorsSystem extends System {
                 wx += weight * wind[0];
                 wy += weight * wind[1];
                 wz += weight * wind[2];
+
+                intensity += weight * effector.turbulence_intensity;
+                length += weight * effector.turbulence_length;
             }
 
+            this.#turbulence_intensity = intensity;
+            this.#turbulence_length = length;
+
             if (this.#first_fold_done) {
                 const keep = Math.exp(-D * dt);
 
+                // ∫ u dt over the tick, along the relaxation, before u moves
+                const carried = (1 - keep) / D;
+
+                offset[0] += wx * dt + (steady[0] - wx) * carried;
+                offset[1] += wy * dt + (steady[1] - wy) * carried;
+                offset[2] += wz * dt + (steady[2] - wz) * carried;
+
                 steady[0] = wx + (steady[0] - wx) * keep;
                 steady[1] = wy + (steady[1] - wy) * keep;
                 steady[2] = wz + (steady[2] - wz) * keep;
@@ -264,7 +287,16 @@ export class FluidEffectorsSystem extends System {
                 steady[0] = wx;
                 steady[1] = wy;
                 steady[2] = wz;
+
+                offset[0] += wx * dt;
+                offset[1] += wy * dt;
+                offset[2] += wz * dt;
             }
+        } else {
+            // nothing relaxes u: it carries the turbulence as it stands
+            offset[0] += steady[0] * dt;
+            offset[1] += steady[1] * dt;
+            offset[2] += steady[2] * dt;
         }
 
         this.#first_fold_done = true;
@@ -292,9 +324,9 @@ export class FluidEffectorsSystem extends System {
         const atmosphere = this.#atmosphere;
 
         atmosphere[FluidAtmosphere.TIME] += dt;
-        atmosphere[FluidAtmosphere.VELOCITY_X] = steady[0] + gx;
-        atmosphere[FluidAtmosphere.VELOCITY_Y] = steady[1] + gy;
-        atmosphere[FluidAtmosphere.VELOCITY_Z] = steady[2] + gz;
+        atmosphere[FluidAtmosphere.VELOCITY_X] = steady[0];
+        atmosphere[FluidAtmosphere.VELOCITY_Y] = steady[1];
+        atmosphere[FluidAtmosphere.VELOCITY_Z] = steady[2];
         atmosphere[FluidAtmosphere.LAMBDA] += D * dt;
         atmosphere[FluidAtmosphere.FORCED_X] = forced[0];
         atmosphere[FluidAtmosphere.FORCED_Y] = forced[1];
@@ -303,5 +335,16 @@ export class FluidEffectorsSystem extends System {
         atmosphere[FluidAtmosphere.FORCE_Y] = fy;
         atmosphere[FluidAtmosphere.FORCE_Z] = fz;
         atmosphere[FluidAtmosphere.DRAG] = D;
+
+        // no length scale, no tile to lay out: no turbulence
+        const length = this.#turbulence_length;
+        const speed = Math.sqrt(steady[0] * steady[0] + steady[1] * steady[1] + steady[2] * steady[2]);
+        const sigma = length > 0 && this.#turbulence_intensity > 0 ? this.#turbulence_intensity * speed : 0;
+
+        atmosphere[FluidAtmosphere.TURBULENCE_OFFSET_X] = offset[0];
+        atmosphere[FluidAtmosphere.TURBULENCE_OFFSET_Y] = offset[1];
+        atmosphere[FluidAtmosphere.TURBULENCE_OFFSET_Z] = offset[2];
+        atmosphere[FluidAtmosphere.TURBULENCE_SIGMA] = sigma;
+        atmosphere[FluidAtmosphere.TURBULENCE_LENGTH] = length;
     }
 }

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"}