@woosh/meep-engine 3.47.0 → 3.50.0

package/src/engine/graphics3/GPUParticleEmitterSystem.js

@@ -898,8 +898,8 @@ export function apply_particle_effect(emitter, effect) {
         changed = true;
     }
 
-    if (emitter.render_rotation !== effect.render_rotation) {
-        emitter.render_rotation = effect.render_rotation;
+    if (emitter.render_orientation !== effect.render_orientation) {
+        emitter.render_orientation = effect.render_orientation;
         changed = true;
     }
 

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

@@ -1 +1 @@
-{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GraphicsEngine.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IACI;;;;;OAKG;IACH,gCAEC;IAUD;;;;OAIG;IACH,yBAEC;IAmEG;;;;;;OAMG;IACH,QAFU,kBAAkB,CAEsB;IAElD;QACI;;;;;;;;WAQG;mBADO,MAAM;QAIhB;;;;;WAKG;oBADO,MAAM;QAIhB;;;;WAIG;qBADO,MAAM;QAIhB;;;;;;;WAOG;;QAGH;;;;;WAKG;;MAEN;IAID;;;;;OAKG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,UAFU,SAAS,CAEY;IAG/B;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEV;IAEtB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;OAEG;IACH,YAFU,MAAM,CAEG;IAoBvB;;;;;;;;;;;;OAYG;IACH,mDAEC;IAED;;;;;;;;OAQG;IACH,iBAFW,KAAK,QAoBf;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,6BAFW,YAAY,QAStB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBAHW,eAAe,GACb,eAAe,CAa3B;IAED;;;;;;;;;;OAUG;IACH,uBAHW,UAAU,GACR,MAAM,CAclB;IAED;;;;;;OAMG;IACH,4BAHW,eAAe,GACb,OAAO,CAgBnB;IAED;;;;;;;;;;;;;OAaG;IACH,kCAHW,iBAAiB,GACf,iBAAiB,CAqB7B;IAED;;;;;;OAMG;IACH,8BAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,qCAHW,iBAAiB,GACf,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBALW,KAAK,GACH,eAAe,GAAC,IAAI,CAehC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,yBARW,KAAK,UACL,MAAM,SACN,MAAM,UACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAwD9B;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;;;;;;OAUG;IACH,SAFa,QAAQ,IAAI,CAAC,CAuDzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAFW,iBAAiB,QAc3B;IAED;;;;;OAKG;IACH,aAiBC;IASD;;;;;;;;OAQG;IACH,8BAHW,OAAO,GAAC,OAAO,UACf,OAAO,GAAC,OAAO,QAQzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,KACN,MAAM,UACN,OAAO,aACP,OAAO,QAIjB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAyBC;IAED;;;;;;;;;OASG;IACH,4BAPW,MAAM,GAKJ,OAAO,CAoDnB;;CACJ;sBAt4BY,OAAO,4BAA4B,EAAE,OAAO;yBAC5C,OAAO,8CAA8C,EAAE,UAAU;8BACjE,OAAO,mDAAmD,EAAE,eAAe;gCAC3E,OAAO,mEAAmE,EAAE,iBAAiB;8BAC7F,OAAO,+CAA+C,EAAE,eAAe;2BACvE,OAAO,8CAA8C,EAAE,YAAY;qBACnE,OAAO,kCAAkC,EAAE,MAAM;yBAfrC,kCAAkC;mCAMxB,yBAAyB;mBAZzC,oCAAoC;wBAC/B,4BAA4B;sBAQ9B,kCAAkC;yCAJf,kDAAkD;sBAErE,qCAAqC;0BACjC,0CAA0C"}
+{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GraphicsEngine.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IACI;;;;;OAKG;IACH,gCAEC;IAUD;;;;OAIG;IACH,yBAEC;IAmEG;;;;;;OAMG;IACH,QAFU,kBAAkB,CAEsB;IAElD;QACI;;;;;;;;WAQG;mBADO,MAAM;QAIhB;;;;;WAKG;oBADO,MAAM;QAIhB;;;;WAIG;qBADO,MAAM;QAIhB;;;;;;;WAOG;;QAGH;;;;;WAKG;;MAEN;IAID;;;;;OAKG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,UAFU,SAAS,CAEY;IAG/B;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEV;IAEtB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;OAEG;IACH,YAFU,MAAM,CAEG;IAoBvB;;;;;;;;;;;;OAYG;IACH,mDAEC;IAED;;;;;;;;OAQG;IACH,iBAFW,KAAK,QAoBf;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,6BAFW,YAAY,QAStB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBAHW,eAAe,GACb,eAAe,CAa3B;IAED;;;;;;;;;;OAUG;IACH,uBAHW,UAAU,GACR,MAAM,CAclB;IAED;;;;;;OAMG;IACH,4BAHW,eAAe,GACb,OAAO,CAgBnB;IAED;;;;;;;;;;;;;OAaG;IACH,kCAHW,iBAAiB,GACf,iBAAiB,CAqB7B;IAED;;;;;;OAMG;IACH,8BAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,qCAHW,iBAAiB,GACf,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBALW,KAAK,GACH,eAAe,GAAC,IAAI,CAehC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,yBARW,KAAK,UACL,MAAM,SACN,MAAM,UACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAwD9B;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;;;;;;OAUG;IACH,SAFa,QAAQ,IAAI,CAAC,CAuDzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAFW,iBAAiB,QAc3B;IAED;;;;;OAKG;IACH,aAiBC;IASD;;;;;;;;OAQG;IACH,8BAHW,OAAO,GAAC,OAAO,UACf,OAAO,GAAC,OAAO,QAQzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,KACN,MAAM,UACN,OAAO,aACP,OAAO,QAIjB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAyBC;IAED;;;;;;;;;OASG;IACH,4BAPW,MAAM,GAKJ,OAAO,CA2DnB;;CACJ;sBA74BY,OAAO,4BAA4B,EAAE,OAAO;yBAC5C,OAAO,8CAA8C,EAAE,UAAU;8BACjE,OAAO,mDAAmD,EAAE,eAAe;gCAC3E,OAAO,mEAAmE,EAAE,iBAAiB;8BAC7F,OAAO,+CAA+C,EAAE,eAAe;2BACvE,OAAO,8CAA8C,EAAE,YAAY;qBACnE,OAAO,kCAAkC,EAAE,MAAM;yBAfrC,kCAAkC;mCAMxB,yBAAyB;mBAZzC,oCAAoC;wBAC/B,4BAA4B;sBAQ9B,kCAAkC;yCAJf,kDAAkD;sBAErE,qCAAqC;0BACjC,0CAA0C"}

package/src/engine/graphics3/GraphicsEngine.js

@@ -910,7 +910,14 @@ export class GraphicsEngine {
         const submitted = renderer.render(this.#camera, this.#scene, time_delta_seconds);
 
         this.frameIndex++;
-        this.needDraw = false;
+
+        if (submitted) {
+            // A frame the renderer held back — its pipelines still compiling, or no device — showed
+            // nothing new, so `needDraw` stays set and the next frame tries again, as it does for an
+            // empty viewport above. On-demand rendering would otherwise wait for a change that may
+            // never come.
+            this.needDraw = false;
+        }
 
         this.on.postRender.dispatch();
 

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

@@ -1,3 +1,28 @@
+/**
+ * Uniform: the noise is off, and not evaluated.
+ * @type {number}
+ */
+export const DEFAULT_NOISE_STRENGTH: number;
+/**
+ * Metres per repeat of the tile.
+ * @type {number}
+ */
+export const DEFAULT_NOISE_SCALE: number;
+/**
+ * Tile units the warp may displace by.
+ * @type {number}
+ */
+export const DEFAULT_NOISE_WARP: number;
+/**
+ * All of the scene's wind.
+ * @type {number}
+ */
+export const DEFAULT_NOISE_WIND_FACTOR: number;
+/**
+ * The engine's tile.
+ * @type {number}
+ */
+export const DEFAULT_NOISE_TEXTURE: number;
 /**
  * A box of fog, smoke, dust or cloud that an entity carries around.
  *
@@ -53,6 +78,52 @@ export class ParticipatingMedia {
      * @type {number}
      */
     fade_distance: number;
+    /**
+     * Noise on the density, [0, 1]: how far the medium goes from uniform toward the tile's value.
+     * 0 is a uniform medium and costs nothing; 1 is the tile as it is.
+     *
+     * The tile is a slot of the scene's noise atlas ({@link noise_texture}), sampled in world space
+     * and repeating every {@link noise_scale} metres, scrolled by the scene's wind and the medium's
+     * own {@link noise_velocity}, and warped by a second, slower tap of the same tile so the field
+     * changes shape as it moves. See `VOLUMETRIC_NOISE_PLAN_2026_10_15.md`.
+     *
+     * @type {number}
+     */
+    noise_strength: number;
+    /**
+     * World size of one repeat of the tile, in metres. The engine's tile holds four base features
+     * an edge, so 32 puts them 8 m apart.
+     * @type {number}
+     */
+    noise_scale: number;
+    /**
+     * How far the warp tap may displace the lookup, in tile units. 0 is one tap and a field that
+     * only slides.
+     * @type {number}
+     */
+    noise_warp: number;
+    /**
+     * The medium's own motion for the noise, metres a second along the world axes, added to the
+     * scene's wind — a draught in a corridor the wind does not reach.
+     * @type {number[]}
+     */
+    noise_velocity: number[];
+    /**
+     * How much of the scene's wind this medium feels. 1 is all of it, 0 is none.
+     *
+     * The wind is the scene's: its far field, `GPUFluidSystem.far_field`, folded into the noise's
+     * scroll by {@link ParticipatingMediaSystem}, and where the scene's fluid departs from it, the
+     * departure, which the shaders sample from the published wind field wherever they evaluate the
+     * noise. A scene without a `GPUFluidSystem` is still air.
+     *
+     * @type {number}
+     */
+    noise_wind_factor: number;
+    /**
+     * Which tile: a slot of the scene's noise atlas. 0 is the one the engine bakes.
+     * @type {number}
+     */
+    noise_texture: number;
     /**
      * @param {number} value
      */
@@ -80,6 +151,12 @@ export class ParticipatingMedia {
             radius: number;
             g: number;
         };
+        noise_strength: number;
+        noise_scale: number;
+        noise_warp: number;
+        noise_velocity: number[];
+        noise_wind_factor: number;
+        noise_texture: number;
     };
     /**
      * @param {Object} options
@@ -88,11 +165,23 @@ export class ParticipatingMedia {
      * @param {object} [options.particle_spec] omitted resets the medium to fog rather than leaving whatever
      * the component already held — a load has to determine the whole component, or an instance being
      * reused would carry the previous level's particle into the next one
+     * @param {number} [options.noise_strength] every noise field omitted is its default, for the same reason
+     * @param {number} [options.noise_scale]
+     * @param {number} [options.noise_warp]
+     * @param {number[]} [options.noise_velocity]
+     * @param {number} [options.noise_wind_factor]
+     * @param {number} [options.noise_texture]
      */
-    fromJSON({ density, fade_distance, particle_spec }: {
+    fromJSON({ density, fade_distance, particle_spec, noise_strength, noise_scale, noise_warp, noise_velocity, noise_wind_factor, noise_texture, }: {
         density?: number;
         fade_distance?: number;
         particle_spec?: object;
+        noise_strength?: number;
+        noise_scale?: number;
+        noise_warp?: number;
+        noise_velocity?: number[];
+        noise_wind_factor?: number;
+        noise_texture?: number;
     }): void;
     /**
      * **The cross-sections and the radius are left out of this on purpose.** They run to 1e-16 and

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

@@ -1 +1 @@
-{"version":3,"file":"ParticipatingMedia.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticipatingMedia.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAyEI;;;OAGG;IACH,4BAFa,kBAAkB,CAQ9B;IAjFD;;;;;;;;OAQG;IACH,SAFU,MAAM,CAEU;IAE1B;;;;;;;;OAQG;IACH,eAFU,uBAAuB,CAE8C;IAE/E;;;;;;;;OAQG;IACH,eAFU,MAAM,CAEsB;IAmBtC;;OAEG;IACH,qCAgBC;IApCD;;;;;;;;;;;;OAYG;IACH,gCAEC;IAmCD;;;;;;;;;MAaC;IAED;;;;;;;OAOG;IACH;QAN4B,OAAO,GAAxB,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;aAyBhB;IAED;;;;;;;OAOG;IACH,QAFa,MAAM,CAUlB;IAED;;;OAGG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAMnB;CACJ;;kBAIS,MAAM;;wCAlMT,8DAA8D"}
+{"version":3,"file":"ParticipatingMedia.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticipatingMedia.js"],"names":[],"mappings":"AAqBA;;;GAGG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH,kCAFU,MAAM,CAEsB;AAEtC;;;GAGG;AACH,iCAFU,MAAM,CAEsB;AAEtC;;;GAGG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;;;;;;;;;;;;;;;;GAkBG;AACH;IA6HI;;;OAGG;IACH,4BAFa,kBAAkB,CAQ9B;IArID;;;;;;;;OAQG;IACH,SAFU,MAAM,CAEU;IAE1B;;;;;;;;OAQG;IACH,eAFU,uBAAuB,CAE8C;IAE/E;;;;;;;;OAQG;IACH,eAFU,MAAM,CAEsB;IAEtC;;;;;;;;;;OAUG;IACH,gBAFU,MAAM,CAEwB;IAExC;;;;OAIG;IACH,aAFU,MAAM,CAEkB;IAElC;;;;OAIG;IACH,YAFU,MAAM,CAEgB;IAEhC;;;;OAIG;IACH,gBAFU,MAAM,EAAE,CAES;IAE3B;;;;;;;;;OASG;IACH,mBAFU,MAAM,CAE8B;IAE9C;;;OAGG;IACH,eAFU,MAAM,CAEsB;IAmBtC;;OAEG;IACH,qCAgBC;IApCD;;;;;;;;;;;;OAYG;IACH,gCAEC;IAmCD;;;;;;;;;;;;;;;MAmBC;IAED;;;;;;;;;;;;;OAaG;IACH;QAZ4B,OAAO,GAAxB,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;QAGW,cAAc,GAA/B,MAAM;QACW,WAAW,GAA5B,MAAM;QACW,UAAU,GAA3B,MAAM;QACa,cAAc,GAAjC,MAAM,EAAE;QACS,iBAAiB,GAAlC,MAAM;QACW,aAAa,GAA9B,MAAM;aAkDhB;IAED;;;;;;;OAOG;IACH,QAFa,MAAM,CAsBlB;IAED;;;OAGG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAYnB;CACJ;;kBAIS,MAAM;;wCA7UT,8DAA8D"}

package/src/engine/graphics3/ParticipatingMedia.js

@@ -1,4 +1,5 @@
 import { assert } from "../../core/assert.js";
+import { isArrayEqualStrict } from "../../core/collection/array/isArrayEqualStrict.js";
 import { hash_mix3 } from "../../core/math/hash/hash_mix3.js";
 import { rgb_to_luminance } from "../../core/color/rgb_to_luminance.js";
 import { computeHashFloat } from "../../core/primitives/numbers/computeHashFloat.js";
@@ -18,6 +19,36 @@ const DEFAULT_DENSITY = 3e7;
  */
 const DEFAULT_FADE_DISTANCE = 0.1;
 
+/**
+ * Uniform: the noise is off, and not evaluated.
+ * @type {number}
+ */
+export const DEFAULT_NOISE_STRENGTH = 0;
+
+/**
+ * Metres per repeat of the tile.
+ * @type {number}
+ */
+export const DEFAULT_NOISE_SCALE = 32;
+
+/**
+ * Tile units the warp may displace by.
+ * @type {number}
+ */
+export const DEFAULT_NOISE_WARP = 0.1;
+
+/**
+ * All of the scene's wind.
+ * @type {number}
+ */
+export const DEFAULT_NOISE_WIND_FACTOR = 1;
+
+/**
+ * The engine's tile.
+ * @type {number}
+ */
+export const DEFAULT_NOISE_TEXTURE = 0;
+
 /**
  * A box of fog, smoke, dust or cloud that an entity carries around.
  *
@@ -72,6 +103,58 @@ export class ParticipatingMedia {
      */
     fade_distance = DEFAULT_FADE_DISTANCE;
 
+    /**
+     * Noise on the density, [0, 1]: how far the medium goes from uniform toward the tile's value.
+     * 0 is a uniform medium and costs nothing; 1 is the tile as it is.
+     *
+     * The tile is a slot of the scene's noise atlas ({@link noise_texture}), sampled in world space
+     * and repeating every {@link noise_scale} metres, scrolled by the scene's wind and the medium's
+     * own {@link noise_velocity}, and warped by a second, slower tap of the same tile so the field
+     * changes shape as it moves. See `VOLUMETRIC_NOISE_PLAN_2026_10_15.md`.
+     *
+     * @type {number}
+     */
+    noise_strength = DEFAULT_NOISE_STRENGTH;
+
+    /**
+     * World size of one repeat of the tile, in metres. The engine's tile holds four base features
+     * an edge, so 32 puts them 8 m apart.
+     * @type {number}
+     */
+    noise_scale = DEFAULT_NOISE_SCALE;
+
+    /**
+     * How far the warp tap may displace the lookup, in tile units. 0 is one tap and a field that
+     * only slides.
+     * @type {number}
+     */
+    noise_warp = DEFAULT_NOISE_WARP;
+
+    /**
+     * The medium's own motion for the noise, metres a second along the world axes, added to the
+     * scene's wind — a draught in a corridor the wind does not reach.
+     * @type {number[]}
+     */
+    noise_velocity = [0, 0, 0];
+
+    /**
+     * How much of the scene's wind this medium feels. 1 is all of it, 0 is none.
+     *
+     * The wind is the scene's: its far field, `GPUFluidSystem.far_field`, folded into the noise's
+     * scroll by {@link ParticipatingMediaSystem}, and where the scene's fluid departs from it, the
+     * departure, which the shaders sample from the published wind field wherever they evaluate the
+     * noise. A scene without a `GPUFluidSystem` is still air.
+     *
+     * @type {number}
+     */
+    noise_wind_factor = DEFAULT_NOISE_WIND_FACTOR;
+
+    /**
+     * Which tile: a slot of the scene's noise atlas. 0 is the one the engine bakes.
+     * @type {number}
+     */
+    noise_texture = DEFAULT_NOISE_TEXTURE;
+
     /**
      * The medium's extinction per metre, which is {@link density} expressed in what it does rather
      * than in how many particles it took.
@@ -133,7 +216,13 @@ export class ParticipatingMedia {
                 extinction: spec.extinction.slice(),
                 radius: spec.radius,
                 g: spec.g
-            }
+            },
+            noise_strength: this.noise_strength,
+            noise_scale: this.noise_scale,
+            noise_warp: this.noise_warp,
+            noise_velocity: this.noise_velocity.slice(),
+            noise_wind_factor: this.noise_wind_factor,
+            noise_texture: this.noise_texture,
         };
     }
 
@@ -144,11 +233,23 @@ export class ParticipatingMedia {
      * @param {object} [options.particle_spec] omitted resets the medium to fog rather than leaving whatever
      * the component already held — a load has to determine the whole component, or an instance being
      * reused would carry the previous level's particle into the next one
+     * @param {number} [options.noise_strength] every noise field omitted is its default, for the same reason
+     * @param {number} [options.noise_scale]
+     * @param {number} [options.noise_warp]
+     * @param {number[]} [options.noise_velocity]
+     * @param {number} [options.noise_wind_factor]
+     * @param {number} [options.noise_texture]
      */
     fromJSON({
                  density = DEFAULT_DENSITY,
                  fade_distance = DEFAULT_FADE_DISTANCE,
-                 particle_spec
+                 particle_spec,
+                 noise_strength = DEFAULT_NOISE_STRENGTH,
+                 noise_scale = DEFAULT_NOISE_SCALE,
+                 noise_warp = DEFAULT_NOISE_WARP,
+                 noise_velocity = [0, 0, 0],
+                 noise_wind_factor = DEFAULT_NOISE_WIND_FACTOR,
+                 noise_texture = DEFAULT_NOISE_TEXTURE,
              }) {
         assert.isNumber(density, 'density');
         assert.isFinite(density, 'density');
@@ -158,9 +259,30 @@ export class ParticipatingMedia {
         assert.isFinite(fade_distance, 'fade_distance');
         assert.greaterThanOrEqual(fade_distance, 0, 'fade_distance must not be negative');
 
+        assert.isNumber(noise_strength, 'noise_strength');
+        assert.ok(noise_strength >= 0 && noise_strength <= 1, 'noise_strength must be in [0, 1]');
+        assert.isNumber(noise_scale, 'noise_scale');
+        assert.isFinite(noise_scale, 'noise_scale');
+        assert.greaterThan(noise_scale, 0, 'noise_scale must be positive');
+        assert.isNumber(noise_warp, 'noise_warp');
+        assert.isFinite(noise_warp, 'noise_warp');
+        assert.greaterThanOrEqual(noise_warp, 0, 'noise_warp must not be negative');
+        assert.isArray(noise_velocity, 'noise_velocity');
+        assert.equal(noise_velocity.length, 3, 'noise_velocity must have three components');
+        assert.isNumber(noise_wind_factor, 'noise_wind_factor');
+        assert.isFinite(noise_wind_factor, 'noise_wind_factor');
+        assert.isNonNegativeInteger(noise_texture, 'noise_texture');
+
         this.density = density;
         this.fade_distance = fade_distance;
 
+        this.noise_strength = noise_strength;
+        this.noise_scale = noise_scale;
+        this.noise_warp = noise_warp;
+        this.noise_velocity = noise_velocity.slice();
+        this.noise_wind_factor = noise_wind_factor;
+        this.noise_texture = noise_texture;
+
         if (particle_spec === undefined) {
             this.particle_spec.copy(VOLUMETRIC_PARTICLE_SPEC_FOG);
         } else {
@@ -180,9 +302,21 @@ export class ParticipatingMedia {
         const spec = this.particle_spec;
 
         return hash_mix3(
-            computeHashFloat(this.density),
-            computeHashFloat(this.fade_distance),
-            computeHashFloat(spec.g)
+            hash_mix3(
+                computeHashFloat(this.density),
+                computeHashFloat(this.fade_distance),
+                computeHashFloat(spec.g)
+            ),
+            hash_mix3(
+                computeHashFloat(this.noise_strength),
+                computeHashFloat(this.noise_scale),
+                computeHashFloat(this.noise_warp)
+            ),
+            hash_mix3(
+                computeHashFloat(this.noise_velocity[0] + 3 * this.noise_velocity[1] + 7 * this.noise_velocity[2]),
+                computeHashFloat(this.noise_wind_factor),
+                this.noise_texture
+            )
         );
     }
 
@@ -193,6 +327,12 @@ export class ParticipatingMedia {
     equals(other) {
         return this.density === other.density
             && this.fade_distance === other.fade_distance
+            && this.noise_strength === other.noise_strength
+            && this.noise_scale === other.noise_scale
+            && this.noise_warp === other.noise_warp
+            && this.noise_wind_factor === other.noise_wind_factor
+            && this.noise_texture === other.noise_texture
+            && isArrayEqualStrict(this.noise_velocity, other.noise_velocity)
             && this.particle_spec.equals(other.particle_spec);
     }
 }

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

@@ -1,5 +1,5 @@
 /**
- * Ten numbers, all of them `float64`.
+ * Eighteen numbers, all of them `float64`.
  *
  * **The width is the whole design decision here, and it is not the usual one.** Component adapters
  * around this one write `float32`, which is what the GPU reads anyway — but a participating medium
@@ -9,11 +9,15 @@
  * little. Nothing about the rendered picture would change. What would change is that
  * `ParticipatingMedia.equals` stops answering `true` across a save, and a level that reloads into
  * components which merely *look* like the ones that were saved is a level whose blueprints stop
- * matching. Ten doubles is eighty bytes; that is the price of the round trip being exact.
+ * matching. Eighteen doubles is 144 bytes; that is the price of the round trip being exact. The
+ * noise fields are doubles for the same reason even where an integer would do: one rule, one width.
  *
  * **`target_extinction` is not in the format** because it is not in the component — it is
  * {@link ParticipatingMedia.density} read through the particle spec, and both of its inputs are
  * here.
+ *
+ * Version 1 added the eight noise fields after the ten of version 0;
+ * {@link ParticipatingMediaSerializationUpgrader_0_1} fills them with the defaults on an old save.
  */
 export class ParticipatingMediaSerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();

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

@@ -1 +1 @@
-{"version":3,"file":"ParticipatingMediaSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticipatingMediaSerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH;;IAEI,iCAA2B;IAG3B;;;OAGG;IACH,uCAFW,kBAAkB,QAkB5B;IAED;;;OAGG;IACH,yCAFW,kBAAkB,QAsB5B;CACJ;gDAxE+C,0DAA0D;mCACvE,yBAAyB"}
+{"version":3,"file":"ParticipatingMediaSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticipatingMediaSerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;IACI,iCAA2B;IAG3B;;;OAGG;IACH,uCAFW,kBAAkB,QA6B5B;IAED;;;OAGG;IACH,yCAFW,kBAAkB,QAiC5B;CACJ;gDAjG+C,0DAA0D;mCACvE,yBAAyB"}

package/src/engine/graphics3/ParticipatingMediaSerializationAdapter.js

@@ -2,7 +2,7 @@ import { BinaryClassSerializationAdapter } from "../ecs/storage/binary/BinaryCla
 import { ParticipatingMedia } from "./ParticipatingMedia.js";
 
 /**
- * Ten numbers, all of them `float64`.
+ * Eighteen numbers, all of them `float64`.
  *
  * **The width is the whole design decision here, and it is not the usual one.** Component adapters
  * around this one write `float32`, which is what the GPU reads anyway — but a participating medium
@@ -12,16 +12,19 @@ import { ParticipatingMedia } from "./ParticipatingMedia.js";
  * little. Nothing about the rendered picture would change. What would change is that
  * `ParticipatingMedia.equals` stops answering `true` across a save, and a level that reloads into
  * components which merely *look* like the ones that were saved is a level whose blueprints stop
- * matching. Ten doubles is eighty bytes; that is the price of the round trip being exact.
+ * matching. Eighteen doubles is 144 bytes; that is the price of the round trip being exact. The
+ * noise fields are doubles for the same reason even where an integer would do: one rule, one width.
  *
  * **`target_extinction` is not in the format** because it is not in the component — it is
  * {@link ParticipatingMedia.density} read through the particle spec, and both of its inputs are
  * here.
+ *
+ * Version 1 added the eight noise fields after the ten of version 0;
+ * {@link ParticipatingMediaSerializationUpgrader_0_1} fills them with the defaults on an old save.
  */
 export class ParticipatingMediaSerializationAdapter extends BinaryClassSerializationAdapter {
-
     klass = ParticipatingMedia;
-    version = 0;
+    version = 1;
 
     /**
      * @param {BinaryBuffer} buffer
@@ -43,6 +46,17 @@ export class ParticipatingMediaSerializationAdapter extends BinaryClassSerializa
 
         buffer.writeFloat64(spec.radius);
         buffer.writeFloat64(spec.g);
+
+        buffer.writeFloat64(value.noise_strength);
+        buffer.writeFloat64(value.noise_scale);
+        buffer.writeFloat64(value.noise_warp);
+
+        for (let i = 0; i < 3; i++) {
+            buffer.writeFloat64(value.noise_velocity[i]);
+        }
+
+        buffer.writeFloat64(value.noise_wind_factor);
+        buffer.writeFloat64(value.noise_texture);
     }
 
     /**
@@ -69,5 +83,16 @@ export class ParticipatingMediaSerializationAdapter extends BinaryClassSerializa
 
         spec.radius = buffer.readFloat64();
         spec.g = buffer.readFloat64();
+
+        value.noise_strength = buffer.readFloat64();
+        value.noise_scale = buffer.readFloat64();
+        value.noise_warp = buffer.readFloat64();
+
+        for (let i = 0; i < 3; i++) {
+            value.noise_velocity[i] = buffer.readFloat64();
+        }
+
+        value.noise_wind_factor = buffer.readFloat64();
+        value.noise_texture = buffer.readFloat64();
     }
 }

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

@@ -0,0 +1,10 @@
+/**
+ * Version 0 held the ten numbers of the medium; version 1 appends the eight of its noise. An old
+ * save is a medium with the noise it never had, which is the component's default: off.
+ *
+ * @see ParticipatingMediaSerializationAdapter
+ */
+export class ParticipatingMediaSerializationUpgrader_0_1 extends BinaryClassUpgrader {
+}
+import { BinaryClassUpgrader } from "../ecs/storage/binary/BinaryClassUpgrader.js";
+//# sourceMappingURL=ParticipatingMediaSerializationUpgrader_0_1.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ParticipatingMediaSerializationUpgrader_0_1.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticipatingMediaSerializationUpgrader_0_1.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH;CA2BC;oCApCmC,8CAA8C"}

package/src/engine/graphics3/ParticipatingMediaSerializationUpgrader_0_1.js

@@ -0,0 +1,38 @@
+import { BinaryBuffer } from "../../core/binary/BinaryBuffer.js";
+import { BinaryClassUpgrader } from "../ecs/storage/binary/BinaryClassUpgrader.js";
+import { ParticipatingMedia } from "./ParticipatingMedia.js";
+
+/**
+ * Version 0 held the ten numbers of the medium; version 1 appends the eight of its noise. An old
+ * save is a medium with the noise it never had, which is the component's default: off.
+ *
+ * @see ParticipatingMediaSerializationAdapter
+ */
+export class ParticipatingMediaSerializationUpgrader_0_1 extends BinaryClassUpgrader {
+    __startVersion = 0;
+    __targetVersion = 1;
+
+    /**
+     * @param {BinaryBuffer} source
+     * @param {BinaryBuffer} target
+     */
+    upgrade(source, target) {
+        // density, fade distance, three of scattering, three of extinction, radius, g
+        for (let i = 0; i < 10; i++) {
+            BinaryBuffer.copyFloat64(source, target);
+        }
+
+        const defaults = new ParticipatingMedia();
+
+        target.writeFloat64(defaults.noise_strength);
+        target.writeFloat64(defaults.noise_scale);
+        target.writeFloat64(defaults.noise_warp);
+
+        for (let i = 0; i < 3; i++) {
+            target.writeFloat64(defaults.noise_velocity[i]);
+        }
+
+        target.writeFloat64(defaults.noise_wind_factor);
+        target.writeFloat64(defaults.noise_texture);
+    }
+}

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

@@ -1,31 +1,29 @@
 /**
- * Copy what the component and its transform say onto the volume Shade will render.
+ * Copy what the component and its transform say onto the volume Shade will render, field by field,
+ * comparing while assigning, and say whether anything differed — which is whether the GPU table
+ * has to be repacked.
  *
  * The particle spec is **copied, not referenced**: two entities are routinely built from the same
  * blueprint and would otherwise share one spec, so tuning one volume's particle would silently
- * retune the other's.
+ * retune the other's. The scroll and flow phases are the volume's own state and are not touched
+ * here; `noise_wind_factor` is a setting, and the shaders read it.
+ *
+ * **The transform is compared and copied by its matrix**, element by element straight off the
+ * `Transform64` — its first sixteen elements — and never through its `matrix` getter, which makes a
+ * view per read. The matrix is the entire transform the GPU is given, so this is exactly the question
+ * "would the upload differ", and it catches a transform posed by writing its matrix, which comparing
+ * position, rotation and scale would not. `fromMatrix` copies the sixteen and then decomposes them,
+ * leaving the matrix bit-identical, so the volume carries the authored matrix exactly.
  *
  * @param {ParticipatingMediaVolume} volume Shade's
  * @param {ParticipatingMedia} component meep's
  * @param {Transform64} transform where the box is
+ * @returns {boolean} whether the volume differed from what the component and transform say
  */
-export function participating_media_volume_write(volume: ParticipatingMediaVolume, component: ParticipatingMedia, transform: Transform64): void;
+export function participating_media_volume_write(volume: ParticipatingMediaVolume, component: ParticipatingMedia, transform: Transform64): boolean;
 /**
- * Whether the volume already says what the component and transform say.
- *
- * True on all but a handful of frames, which is the point of asking: a `false` here costs the whole
- * scene's volumetrics table a trip to the GPU.
- *
- * **The transform is compared by its matrix rather than by its components**, because the matrix is
- * the entire transform the GPU is given — the volume's position, rotation and scale are never read
- * on their own. That makes this exactly the question worth asking, "would the upload differ", and it
- * catches a transform posed by writing its matrix, which comparing position, rotation and scale
- * would not.
- *
- * The volume's matrix is a `Float64Array` and the component's is a `Float32Array`, and the strict
- * comparison across the two still holds: {@link participating_media_volume_write} copies the matrix
- * across element by element, and every f32 value widens to f64 exactly. It is a recomposed matrix
- * that would not compare equal, which is why the write does not recompose.
+ * Whether the volume already says what the component and transform say: the question
+ * {@link participating_media_volume_write} answers while it assigns, asked without assigning.
  *
  * @param {ParticipatingMediaVolume} volume
  * @param {ParticipatingMedia} component
@@ -54,10 +52,22 @@ export function participating_media_volume_is_current(volume: ParticipatingMedia
  * tens, so the comparison is cheaper than the signal plumbing it replaces. The price is latency: a
  * change is visible within a frame rather than instantly.
  *
- * **Nothing is uploaded unless something actually changed.** The GPU table is repacked whole
- * whenever {@link SceneVolumetrics.version} moves, so an unconditional copy every frame would
- * re-upload every volume in the scene forever. The comparison is what decides, and on almost every
- * frame it decides nothing has to happen.
+ * **Nothing is uploaded unless something actually changed**, and what is uploaded is what changed.
+ * A change to anything but the noise phases moves {@link SceneVolumetrics#version}, and the GPU
+ * table is repacked whole; a scroll of the noise moves only {@link SceneVolumetrics#noise_version},
+ * and the rows get their phase words. The comparison, made while assigning, is what decides, and on
+ * almost every frame it decides nothing but the scroll has to happen.
+ *
+ * **The wind: the far field here, the rest on the GPU.** A noisy volume scrolls with the scene's far
+ * field `v_far(t)` × `noise_wind_factor` + `noise_velocity`, folded into its phases on the host: the
+ * far field is {@link GPUFluidSystem#far_field}, the `GlobalFluidEffector`s as `FluidEffectorsSystem`
+ * folds them — synchronous and deterministic, nothing read back. Where the scene's fluid differs from
+ * its far field, the shaders that evaluate the noise sample the published wind field there and carry
+ * the noise by the difference, flow-map style, on the volume's flow clock, which the advance moves on
+ * for every volume that feels the wind (`chunk_participating_media_noise`); uniform air costs and
+ * looks as a scroll alone does. Without a `GPUFluidSystem` in the entity manager the air is still.
+ *
+ * Allocates nothing per frame.
  *
  * @see ParticipatingMedia the component
  * @see SceneVolumetrics what the volumes are handed to

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

@@ -1 +1 @@
-{"version":3,"file":"ParticipatingMediaSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticipatingMediaSystem.js"],"names":[],"mappings":"AA6IA;;;;;;;;;;GAUG;AACH,yDAJW,wBAAwB,aACxB,kBAAkB,aAClB,WAAW,QAkBrB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8DALW,wBAAwB,aACxB,kBAAkB,aAClB,WAAW,GACT,OAAO,CAOnB;AA9LD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAmBI;;;OAGG;IACH,oDASC;IA9BD,iEAAiD;IAgCjD,2CAIC;IAED,4CAIC;IAED;;;;OAIG;IACH,gBAJW,kBAAkB,aAClB,WAAW,UACX,MAAM,QAUhB;IAED;;;;OAIG;IACH,kBAJW,kBAAkB,aAClB,WAAW,UACX,MAAM,QAIhB;;CAmCJ;yCAzIwC,8DAA8D;mCAGpE,yBAAyB;4BADhC,iCAAiC;uBADtC,kBAAkB"}
+{"version":3,"file":"ParticipatingMediaSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticipatingMediaSystem.js"],"names":[],"mappings":"AAyRA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,yDALW,wBAAwB,aACxB,kBAAkB,aAClB,WAAW,GACT,OAAO,CAmDnB;AAED;;;;;;;;GAQG;AACH,8DALW,wBAAwB,aACxB,kBAAkB,aAClB,WAAW,GACT,OAAO,CAYnB;AA/UD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IA+BI;;;OAGG;IACH,oDASC;IA1CD,iEAAiD;IA4CjD,2CAIC;IAED,4CAIC;IAED;;;;OAIG;IACH,gBAJW,kBAAkB,aAClB,WAAW,UACX,MAAM,QAehB;IAED;;;;OAIG;IACH,kBAJW,kBAAkB,aAClB,WAAW,UACX,MAAM,QAIhB;;CAmHJ;yCAnRM,8DAA8D;mCAIlC,yBAAyB;4BAFL,iCAAiC;uBADjE,kBAAkB"}