@woosh/meep-engine 3.49.0 → 3.50.0

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

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

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

@@ -156,6 +156,17 @@ export class FluidField {
      * @type {Float32Array|Float16Array|null}
      */
     pressure: Float32Array | Float16Array | null;
+    /**
+     * The far field this field was last brought to, in its own grid units: a
+     * {@link FluidFieldAtmosphere} record. {@link fluid_apply_atmosphere} reads it as the
+     * start of the interval it steps the field across and writes the end, so a field that
+     * skips ticks, or steps in a worker, still meets the far field exactly. Cross-step state,
+     * like {@link pressure}; {@link clear} resets it.
+     *
+     * Safe to read. Don't mutate.
+     * @type {Float64Array|null}
+     */
+    atmosphere: Float64Array | null;
     /**
      * Allocate {@link pressure} as {@link Float16Array} instead of {@link Float32Array}.
      *
@@ -358,7 +369,7 @@ export class FluidField {
     /**
      * Strict value equality. Two fields are equal iff they have the same resolution,
      * the same set of scalar attributes (matched by name AND index), and the same
-     * buffer contents in `velocity_*`, `solid`, `pressure`, and each scalar. Pre-build
+     * buffer contents in `velocity_*`, `solid`, `pressure`, `atmosphere`, and each scalar. Pre-build
      * fields compare by resolution + attribute names only (their buffers are null).
      *
      * O(N) — walks every cell. Use {@link hash} for change-detection on hot paths.
@@ -430,7 +441,8 @@ export class FluidField {
     /**
      * Zero velocity, pressure, and all scalar attributes. Solid mask is preserved.
      * Pressure is cleared to drop the warm-start (otherwise the next step's solve
-     * begins from a stale solution that no longer matches the zero velocity).
+     * begins from a stale solution that no longer matches the zero velocity), and
+     * the {@link atmosphere} record so the next step meets the far field afresh.
      */
     clear(): void;
     #private;

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

@@ -1 +1 @@
-{"version":3,"file":"FluidField.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/FluidField.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IA2bI;;;;;;;;;OASG;IACH,wCAHW;QAAC,MAAM,EAAE,iBAAiB,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,uBAAuB,EAAE,OAAO,CAAA;KAAC,GACpG,UAAU,CAkBtB;IA7cD;;;;;;;OAOG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;;;OAIG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;;;;OAKG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;;;;;OAMG;IACH,OAFU,UAAU,GAAC,IAAI,CAEZ;IAEb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFU,UAAU,GAAC,IAAI,CAEG;IAE5B;;;;;;;OAOG;IACH,cAFU,UAAU,GAAC,IAAI,CAEL;IAEpB;;;OAGG;IACH,cAFU,UAAU,GAAC,IAAI,CAEL;IAEpB;;;OAGG;IACH,cAFU,UAAU,GAAC,IAAI,CAEL;IAEpB;;;;;;;;;;;;;;;;OAgBG;IACH,eAFU,UAAU,GAAC,IAAI,CAEJ;IAErB;;;;;;;;;;;;;OAaG;IACH,UAFU,YAAY,kBAAc,IAAI,CAExB;IAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,yBAFU,OAAO,CAEe;IAEhC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAFU,OAAO,CAEK;IAetB;;;;;;OAMG;IACH,qBAJW,MAAM,SACN,MAAM,SACN,MAAM,QAWhB;IAED;;;OAGG;IACH,iBAHY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAKnC;IAED;;;OAGG;IACH,aAHY,MAAM,CAKjB;IAED;;;;;;;;;OASG;IACH,gBAHW,MAAM,GACL,MAAM,CAejB;IAED;;;OAGG;IACH,kBAHW,MAAM,GACL,MAAM,CAIjB;IAED;;;;OAIG;IACH,oBAJW,MAAM,GACL,YAAY,GAAC,IAAI,CAM5B;IAED;;OAEG;IACH,uBAFY;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,YAAY,CAAA;KAAE,EAAE,CAIjD;IAED;;;OAGG;IACH,cAqBC;IA8GD;;OAEG;IACH,kBAFa,OAAO,CAInB;IAED;;;;;;OAMG;IACH,uBAHa;QAAC,MAAM,EAAE,iBAAiB,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,uBAAuB,EAAE,OAAO,CAAA;KAAC,CAclH;IA8BD;;;;;;OAMG;IACH,aALW,MAAM,KACN,MAAM,KACN,MAAM,GACL,MAAM,CAajB;IAED;;;;;;;;;;;;OAYG;IACH,iBAPW,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAgBhB;IAED;;;;;;;;;;OAUG;IACH,iBAPW,MAAM,KACN,MAAM,KACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QAgBhB;IAED;;;;;;OAMG;IACH,kCANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,SACN,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,cALW,MAAM,KACN,MAAM,KACN,MAAM,YACN,OAAO,QAIjB;IAED;;;;;OAKG;IACH,aALW,MAAM,KACN,MAAM,KACN,MAAM,GACL,OAAO,CAIlB;IAED;;;;;;;;;;;OAWG;IACH,oBANW,YAAY,GAAC,MAAM,EAAE,KACrB,MAAM,KACN,MAAM,KACN,MAAM,GACL,YAAY,GAAC,MAAM,EAAE,CAUhC;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACL,MAAM,CAUjB;IAED;;;;;;;;;;OAUG;IACH,cAHW,UAAU,GACT,OAAO,CAqDlB;IAED;;;;;;;;;;;OAWG;IACH,QAFY,MAAM,CAejB;IAED;;;;;;;;;;OAUG;IACH,oCAgBC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,eAJW,MAAM,WACN,MAAM,WACN,MAAM,QA0ChB;IAED;;;;OAIG;IACH,cASC;;CACJ"}
+{"version":3,"file":"FluidField.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/FluidField.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAycI;;;;;;;;;OASG;IACH,wCAHW;QAAC,MAAM,EAAE,iBAAiB,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,uBAAuB,EAAE,OAAO,CAAA;KAAC,GACpG,UAAU,CAkBtB;IA3dD;;;;;;;OAOG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;;;OAIG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;;;;OAKG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;;;;;OAMG;IACH,OAFU,UAAU,GAAC,IAAI,CAEZ;IAEb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFU,UAAU,GAAC,IAAI,CAEG;IAE5B;;;;;;;OAOG;IACH,cAFU,UAAU,GAAC,IAAI,CAEL;IAEpB;;;OAGG;IACH,cAFU,UAAU,GAAC,IAAI,CAEL;IAEpB;;;OAGG;IACH,cAFU,UAAU,GAAC,IAAI,CAEL;IAEpB;;;;;;;;;;;;;;;;OAgBG;IACH,eAFU,UAAU,GAAC,IAAI,CAEJ;IAErB;;;;;;;;;;;;;OAaG;IACH,UAFU,YAAY,kBAAc,IAAI,CAExB;IAEhB;;;;;;;;;OASG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,yBAFU,OAAO,CAEe;IAEhC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAFU,OAAO,CAEK;IAetB;;;;;;OAMG;IACH,qBAJW,MAAM,SACN,MAAM,SACN,MAAM,QAWhB;IAED;;;OAGG;IACH,iBAHY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAKnC;IAED;;;OAGG;IACH,aAHY,MAAM,CAKjB;IAED;;;;;;;;;OASG;IACH,gBAHW,MAAM,GACL,MAAM,CAejB;IAED;;;OAGG;IACH,kBAHW,MAAM,GACL,MAAM,CAIjB;IAED;;;;OAIG;IACH,oBAJW,MAAM,GACL,YAAY,GAAC,IAAI,CAM5B;IAED;;OAEG;IACH,uBAFY;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,YAAY,CAAA;KAAE,EAAE,CAIjD;IAED;;;OAGG;IACH,cAqBC;IAgHD;;OAEG;IACH,kBAFa,OAAO,CAInB;IAED;;;;;;OAMG;IACH,uBAHa;QAAC,MAAM,EAAE,iBAAiB,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,uBAAuB,EAAE,OAAO,CAAA;KAAC,CAclH;IA8BD;;;;;;OAMG;IACH,aALW,MAAM,KACN,MAAM,KACN,MAAM,GACL,MAAM,CAajB;IAED;;;;;;;;;;;;OAYG;IACH,iBAPW,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAgBhB;IAED;;;;;;;;;;OAUG;IACH,iBAPW,MAAM,KACN,MAAM,KACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QAgBhB;IAED;;;;;;OAMG;IACH,kCANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,SACN,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,cALW,MAAM,KACN,MAAM,KACN,MAAM,YACN,OAAO,QAIjB;IAED;;;;;OAKG;IACH,aALW,MAAM,KACN,MAAM,KACN,MAAM,GACL,OAAO,CAIlB;IAED;;;;;;;;;;;OAWG;IACH,oBANW,YAAY,GAAC,MAAM,EAAE,KACrB,MAAM,KACN,MAAM,KACN,MAAM,GACL,YAAY,GAAC,MAAM,EAAE,CAUhC;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACL,MAAM,CAUjB;IAED;;;;;;;;;;OAUG;IACH,cAHW,UAAU,GACT,OAAO,CAwDlB;IAED;;;;;;;;;;;OAWG;IACH,QAFY,MAAM,CAejB;IAED;;;;;;;;;;OAUG;IACH,oCAgBC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,eAJW,MAAM,WACN,MAAM,WACN,MAAM,QA0ChB;IAED;;;;;OAKG;IACH,cAUC;;CACJ"}

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

@@ -8,6 +8,7 @@ import { v3_grid_patch_edges_constant } from "./solver/v3_grid_patch_edges_const
 import { v3_grid_patch_edges_uniform } from "./solver/v3_grid_patch_edges_uniform.js";
 import { v3_grid_shift_in_place } from "./solver/v3_grid_shift_in_place.js";
 import { v3_mac_compute_face_solid } from "./solver/v3_mac_compute_face_solid.js";
+import { FLUID_FIELD_ATMOSPHERE_WORDS } from "./FluidAtmosphere.js";
 
 /**
  * 3D Eulerian grid for the fluid simulator — MAC (marker-and-cell) staggered
@@ -168,6 +169,18 @@ export class FluidField {
      */
     pressure = null;
 
+    /**
+     * The far field this field was last brought to, in its own grid units: a
+     * {@link FluidFieldAtmosphere} record. {@link fluid_apply_atmosphere} reads it as the
+     * start of the interval it steps the field across and writes the end, so a field that
+     * skips ticks, or steps in a worker, still meets the far field exactly. Cross-step state,
+     * like {@link pressure}; {@link clear} resets it.
+     *
+     * Safe to read. Don't mutate.
+     * @type {Float64Array|null}
+     */
+    atmosphere = null;
+
     /**
      * Allocate {@link pressure} as {@link Float16Array} instead of {@link Float32Array}.
      *
@@ -348,10 +361,11 @@ export class FluidField {
     /**
      * Describe every buffer this field owns, in allocation order.
      *
-     * The order matters for the shared layout: the 4-byte lattices come first,
-     * then pressure (which may be 2-byte under
-     * {@link half_precision_pressure}), then the 1-byte masks — so each view's
-     * offset lands on its own alignment with no padding in the common case.
+     * The order matters for the shared layout: the 8-byte atmosphere record
+     * comes first, then the 4-byte lattices, then pressure (which may be 2-byte
+     * under {@link half_precision_pressure}), then the 1-byte masks — so each
+     * view's offset lands on its own alignment with no padding in the common
+     * case.
      *
      * Both {@link build} and {@link fromSharedDescriptor} derive the layout from
      * this same table, which is why a descriptor only has to carry the
@@ -372,6 +386,7 @@ export class FluidField {
         const face_count_z = rx * ry * (rz + 1);
 
         const specs = [
+            { key: "atmosphere", ctor: Float64Array, length: FLUID_FIELD_ATMOSPHERE_WORDS, scalar_index: -1 },
             { key: "velocity_x", ctor: Float32Array, length: face_count_x, scalar_index: -1 },
             { key: "velocity_y", ctor: Float32Array, length: face_count_y, scalar_index: -1 },
             { key: "velocity_z", ctor: Float32Array, length: face_count_z, scalar_index: -1 }
@@ -662,7 +677,7 @@ export class FluidField {
     /**
      * Strict value equality. Two fields are equal iff they have the same resolution,
      * the same set of scalar attributes (matched by name AND index), and the same
-     * buffer contents in `velocity_*`, `solid`, `pressure`, and each scalar. Pre-build
+     * buffer contents in `velocity_*`, `solid`, `pressure`, `atmosphere`, and each scalar. Pre-build
      * fields compare by resolution + attribute names only (their buffers are null).
      *
      * O(N) — walks every cell. Use {@link hash} for change-detection on hot paths.
@@ -715,6 +730,9 @@ export class FluidField {
         if (!is_typed_array_equals(this.pressure, other.pressure)) {
             return false;
         }
+        if (!is_typed_array_equals(this.atmosphere, other.atmosphere)) {
+            return false;
+        }
         for (let i = 0; i < my_attrs.length; i++) {
             if (!is_typed_array_equals(my_attrs[i].data, other_attrs[i].data)) {
                 return false;
@@ -858,10 +876,12 @@ export class FluidField {
     /**
      * Zero velocity, pressure, and all scalar attributes. Solid mask is preserved.
      * Pressure is cleared to drop the warm-start (otherwise the next step's solve
-     * begins from a stale solution that no longer matches the zero velocity).
+     * begins from a stale solution that no longer matches the zero velocity), and
+     * the {@link atmosphere} record so the next step meets the far field afresh.
      */
     clear() {
         assert.ok(this.#built, "build() must be called before clear()");
+        this.atmosphere.fill(0);
         this.velocity_x.fill(0);
         this.velocity_y.fill(0);
         this.velocity_z.fill(0);

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

@@ -335,7 +335,11 @@ export class FluidSimulator {
      * @param {FluidField} field
      * @param {number} time_delta            seconds (or grid-cells-per-velocity-unit;
      *                                       caller defines the convention)
-     * @param {AbstractFluidEffector[]} effectors    Pass `[]` for no external forces.
+     * @param {AbstractFluidEffector[]} effectors    Pass `[]` for no external forces. No
+     *                                               `GlobalFluidEffector`: a global acts
+     *                                               through the far field, which a caller
+     *                                               brings the field to first
+     *                                               (`fluid_apply_atmosphere`).
      * @param {Float32Array|number[]} world_to_grid  Column-major 4×4 affine sending
      *                                               world-space points into this
      *                                               field's grid space. Passed through

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

@@ -1 +1 @@
-{"version":3,"file":"FluidSimulator.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/FluidSimulator.js"],"names":[],"mappings":";;;;;;;;;;;;;;;6BA2BU,MAAM;;;;;;;;;;;;;;;;;;;;;;8BAwBN,MAAM;;;;;AAOhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;;;;;;;;;GASG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;;;;;;;;;;;;;GAgBG;AACH,qCAFU,MAAM,CAE2B;AAE3C;IAEI;;;OAGG;IACH,yBAFU,MAAM,CAEY;IAE5B;;;;OAIG;IACH,+BAFU,MAAM,CAEkB;IAElC;;;;;OAKG;IACH,uBAFU,MAAM,CAEU;IAE1B;;OAEG;IACH,6BAFU,MAAM,CAEgB;IAEhC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,kBAFU,MAAM,CAEK;IAErB;;;;;;;;;;;;;;;OAeG;IACH,iBAFU,MAAM,CAEqB;IAErC;;;;;;;;;;;;;;OAcG;IACH,uBAFU,MAAM,CAEU;IAE1B;;;;;;;;;;;;;;;;OAgBG;IACH,kBAFU,MAAM,CAE8B;IAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,sBAFU,OAAO,CAEY;IAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,0BAFU,OAAO,CAEe;IAEhC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,0BAFU,MAAM,CAEgB;IAuKhC;;;;;;;;;;;;OAYG;IACH,iCALW,MAAM,SACN,MAAM,SACN,MAAM,GACL,MAAM,CAUjB;IAED;;;;;;;;;;;;OAYG;IACH,iCAGC;IAwFD;;;;;;;;;;;;;OAaG;IACH,oCAVW,MAAM,aAEN,uBAAuB,iBACvB,YAAY,GAAC,MAAM,EAAE,QAsM/B;;CACJ"}
+{"version":3,"file":"FluidSimulator.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/FluidSimulator.js"],"names":[],"mappings":";;;;;;;;;;;;;;;6BA4BU,MAAM;;;;;;;;;;;;;;;;;;;;;;8BAwBN,MAAM;;;;;AAOhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;;;;;;;;;GASG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;;;;;;;;;;;;;GAgBG;AACH,qCAFU,MAAM,CAE2B;AAE3C;IAEI;;;OAGG;IACH,yBAFU,MAAM,CAEY;IAE5B;;;;OAIG;IACH,+BAFU,MAAM,CAEkB;IAElC;;;;;OAKG;IACH,uBAFU,MAAM,CAEU;IAE1B;;OAEG;IACH,6BAFU,MAAM,CAEgB;IAEhC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,kBAFU,MAAM,CAEK;IAErB;;;;;;;;;;;;;;;OAeG;IACH,iBAFU,MAAM,CAEqB;IAErC;;;;;;;;;;;;;;OAcG;IACH,uBAFU,MAAM,CAEU;IAE1B;;;;;;;;;;;;;;;;OAgBG;IACH,kBAFU,MAAM,CAE8B;IAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,sBAFU,OAAO,CAEY;IAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,0BAFU,OAAO,CAEe;IAEhC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,0BAFU,MAAM,CAEgB;IAuKhC;;;;;;;;;;;;OAYG;IACH,iCALW,MAAM,SACN,MAAM,SACN,MAAM,GACL,MAAM,CAUjB;IAED;;;;;;;;;;;;OAYG;IACH,iCAGC;IAwFD;;;;;;;;;;;;;;;;;OAiBG;IACH,oCAdW,MAAM,aAEN,uBAAuB,iBAKvB,YAAY,GAAC,MAAM,EAAE,QA4M/B;;CACJ"}

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

@@ -1,5 +1,6 @@
 import { assert } from "../../../core/assert.js";
 import { sor_optimal_omega } from "../../../core/math/linalg/sor_optimal_omega.js";
+import { GlobalFluidEffector } from "./effector/GlobalFluidEffector.js";
 import { v3_grid_apply_diffusion } from "./solver/v3_grid_apply_diffusion.js";
 import { v3_grid_solve_pressure } from "./solver/v3_grid_solve_pressure.js";
 import { v3_grid_solve_pressure_pcg } from "./solver/v3_grid_solve_pressure_pcg.js";
@@ -629,7 +630,11 @@ export class FluidSimulator {
      * @param {FluidField} field
      * @param {number} time_delta            seconds (or grid-cells-per-velocity-unit;
      *                                       caller defines the convention)
-     * @param {AbstractFluidEffector[]} effectors    Pass `[]` for no external forces.
+     * @param {AbstractFluidEffector[]} effectors    Pass `[]` for no external forces. No
+     *                                               `GlobalFluidEffector`: a global acts
+     *                                               through the far field, which a caller
+     *                                               brings the field to first
+     *                                               (`fluid_apply_atmosphere`).
      * @param {Float32Array|number[]} world_to_grid  Column-major 4×4 affine sending
      *                                               world-space points into this
      *                                               field's grid space. Passed through
@@ -662,7 +667,13 @@ export class FluidSimulator {
 
         // 1. External forces.
         for (let i = 0; i < effectors.length; i++) {
-            effectors[i].apply(field, time_delta, world_to_grid);
+            const effector = effectors[i];
+
+            // A global has no apply: it acts through the far field FluidEffectorsSystem folds, which
+            // FluidSystem brings a field to before stepping it (fluid_apply_atmosphere).
+            assert.notOk(effector instanceof GlobalFluidEffector, 'a GlobalFluidEffector is not an effector to step with: it acts through the far field (FluidEffectorsSystem, fluid_apply_atmosphere)');
+
+            effector.apply(field, time_delta, world_to_grid);
         }
 
         // Refresh the pre-baked derived masks (cell neighbour mask, pressure