@woosh/meep-engine 3.47.0 → 3.49.0

package/editor/particles/effect/ParticleReferenceSimulation.d.ts

@@ -94,7 +94,7 @@ export class ParticleReferenceSimulation {
      * array of objects: this runs per frame, and the preview has nothing to do with the values after
      * it has drawn them.
      *
-     * @param {function({x: number, y: number, z: number, size: number, r: number, g: number, b: number, a: number, rotation: number, frame: number})} visitor
+     * @param {function({x: number, y: number, z: number, size: number, r: number, g: number, b: number, a: number, frame: number})} visitor
      */
     forEachParticle(visitor: (arg0: {
         x: number;
@@ -105,7 +105,6 @@ export class ParticleReferenceSimulation {
         g: number;
         b: number;
         a: number;
-        rotation: number;
         frame: number;
     }) => any): void;
     #private;

package/editor/particles/effect/ParticleReferenceSimulation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleReferenceSimulation.d.ts","sourceRoot":"","sources":["../../../../editor/particles/effect/ParticleReferenceSimulation.js"],"names":[],"mappings":"AAuCA;;;;;;GAMG;AACH,wCAFU,MAAM,CAE8B;AAE9C;IAgGI;;;OAGG;IACH;QAF4B,QAAQ,GAAzB,MAAM;OAiBhB;IAjHD;;;;OAIG;IACH,MAFU,WAAW,CAEhB;IAEL;;;OAGG;IACH,OAFU,MAAM,EAAE,CAEP;IAEX;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IAEV;;;OAGG;IACH,KAFU,WAAW,CAEI;IAQzB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,MAFU,MAAM,CAEP;IAoDL;;OAEG;IACH,UAFU,MAAM,CAEQ;IAa5B;;OAEG;IACH,cAYC;IAED;;;;;;;;;;;;OAYG;IACH;QAJ0G,OAAO,EAAtG,OAAO,8DAA8D,EAAE,eAAe;QACU,MAAM,EAAtG,OAAO,gEAAgE,EAAE,cAAc;QACxE,OAAO,EAAtB,MAAM;aAsBhB;IAED;;OAEG;IACH,oBAEC;IAED;;;;OAIG;IACH,SAFW,MAAM,QAmBhB;IA0KD;;;;;;;;;OASG;IACH,gCAFoB;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,gBA6C/I;;CACJ"}
+{"version":3,"file":"ParticleReferenceSimulation.d.ts","sourceRoot":"","sources":["../../../../editor/particles/effect/ParticleReferenceSimulation.js"],"names":[],"mappings":"AAuCA;;;;;;GAMG;AACH,wCAFU,MAAM,CAE8B;AAE9C;IAgGI;;;OAGG;IACH;QAF4B,QAAQ,GAAzB,MAAM;OAiBhB;IAjHD;;;;OAIG;IACH,MAFU,WAAW,CAEhB;IAEL;;;OAGG;IACH,OAFU,MAAM,EAAE,CAEP;IAEX;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IAEV;;;OAGG;IACH,KAFU,WAAW,CAEI;IAQzB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,MAFU,MAAM,CAEP;IAoDL;;OAEG;IACH,UAFU,MAAM,CAEQ;IAa5B;;OAEG;IACH,cAYC;IAED;;;;;;;;;;;;OAYG;IACH;QAJ0G,OAAO,EAAtG,OAAO,8DAA8D,EAAE,eAAe;QACU,MAAM,EAAtG,OAAO,gEAAgE,EAAE,cAAc;QACxE,OAAO,EAAtB,MAAM;aAsBhB;IAED;;OAEG;IACH,oBAEC;IAED;;;;OAIG;IACH,SAFW,MAAM,QAmBhB;IA0KD;;;;;;;;;OASG;IACH,gCAFoB;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,gBA2C7H;;CACJ"}

package/editor/particles/effect/ParticleReferenceSimulation.js

@@ -422,7 +422,7 @@ export class ParticleReferenceSimulation {
      * array of objects: this runs per frame, and the preview has nothing to do with the values after
      * it has drawn them.
      *
-     * @param {function({x: number, y: number, z: number, size: number, r: number, g: number, b: number, a: number, rotation: number, frame: number})} visitor
+     * @param {function({x: number, y: number, z: number, size: number, r: number, g: number, b: number, a: number, frame: number})} visitor
      */
     forEachParticle(visitor) {
         if (this.#layout === null) {
@@ -441,12 +441,11 @@ export class ParticleReferenceSimulation {
         const position = offset("position");
         const size = offset("size");
         const color = offset("color");
-        const rotation = offset("rotation");
         const frame = offset("frame");
 
         const words = this.#pool_f32;
 
-        const particle = { x: 0, y: 0, z: 0, size: 1, r: 1, g: 1, b: 1, a: 1, rotation: 0, frame: 0 };
+        const particle = { x: 0, y: 0, z: 0, size: 1, r: 1, g: 1, b: 1, a: 1, frame: 0 };
 
         for (const slot of this.alive) {
             const base = slot * PARTICLE_RECORD_WORD_COUNT;
@@ -462,7 +461,6 @@ export class ParticleReferenceSimulation {
             particle.b = color === EMITTER_ATTRIBUTE_ABSENT ? 1 : words[base + color + 2];
             particle.a = color === EMITTER_ATTRIBUTE_ABSENT ? 1 : words[base + color + 3];
 
-            particle.rotation = rotation === EMITTER_ATTRIBUTE_ABSENT ? 0 : words[base + rotation];
             particle.frame = frame === EMITTER_ATTRIBUTE_ABSENT ? 0 : words[base + frame];
 
             visitor(particle);

package/editor/view/particles/effect/ParticleGraphEditorView.js

@@ -145,7 +145,7 @@ const PALETTE_CATEGORIES = [
     { name: "math", types: ["neg", "abs", "floor", "fract", "round", "ceil", "sqrt", "rsqrt", "sin", "cos", "tan", "asin", "acos", "atan2", "exp", "log"] },
     { name: "vector", types: ["vec2", "vec3", "vec4", "decompose2", "decompose3", "decompose4", "swizzle", "dot", "cross", "length", "normalize", "distance", "angleBetween2", "angleBetween3"] },
     { name: "logic", types: ["compare", "select"] },
-    { name: "rotation", types: ["quatFromAxisAngle", "quatLookRotation", "quatRotate"] },
+    { name: "rotation", types: ["quatFromAxisAngle", "quatLookRotation", "quatRotate", "quatMultiply", "quatIntegrate", "sampleRotation", "emitterRotation"] },
     { name: "sampling", types: ["sampleSphereSurface", "sampleSphereVolume"] },
     { name: "noise", types: ["simplex3", "simplex4", "curl3", "curl4", "srdnoise3", "psrdnoise3"] },
 ];

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.47.0",
+  "version": "3.49.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/engine/ecs/async/WORKER_SYSTEM_PLAN.md

@@ -189,18 +189,34 @@ and the sampling API are untouched. Two things the caller must do:
 it worker-owned between dispatch and the next join. Precisely:
 
 - Systems that touch fluid fields must run **earlier in the fixed pass** than
-  `WorkerFluidSystem`. Note this is *not* controlled by registration order:
-  `updateExecutionOrder` sorts by a score derived from `components_used`, and
-  registration order only breaks exact ties. `FluidObstacleSystem` does sort
-  first today, in both registration orders, and `WorkerFluidSystem.spec.js` pins
-  that as a standing assertion — because if the scheduler ever reorders the two,
-  the symptom is a silent data race rather than a visible failure.
+  `WorkerFluidSystem`. Note this is *not* controlled by registration order: the
+  order is derived from `components_used` (`orderSystemsByDeclaredAccess` — a
+  writer runs before a same-pass reader, and the score picks among free systems
+  and decides which member of a cycle runs first). Two systems touch the field
+  from outside the fluid step. Each is on a cycle with `WorkerFluidSystem`, so
+  the **score** puts it first, and a spec holds each there in both registration
+  orders as a standing assertion — because if the scheduler ever reorders them,
+  the symptom is a silent data race rather than a visible failure:
+  - `FluidObstacleSystem` writes solid masks. It and `WorkerFluidSystem` both read
+    and write `FluidComponent` (20 against 11 in a game-like composition);
+    `WorkerFluidSystem.spec.js` holds it first.
+  - Cloth (`ClothSystem`, `WorkerClothSystem`) reads the velocity field through
+    `ClothFluidWind`, once a tick in `ClothWorld#advance`, and declares that
+    read. It also writes the `Transform64` every fluid system reads, so the edges
+    run both ways (cloth 49 against `WorkerFluidSystem`'s 15);
+    `cloth_wind.spec.js` holds cloth first. Before the read was declared, the
+    `Transform64` edge alone ran it first: measured 2026-10-16 over all four
+    cloth × fluid pairs and a census of every `System` subclass, and declaring
+    it flipped no cloth–fluid pair. There, step `T − 1` has landed (the gate)
+    and step `T` is not yet dispatched, so cloth reads a complete field — under
+    either fluid system the one step `T − 1` left.
 - `update()`-phase and render-phase readers see a step in progress. **Today there
-  are no such readers** — the fluid package has no consumers anywhere else in the
-  codebase (verified) — so the exposure is zero, but it is a real constraint and is
-  documented on the class. The escape hatch, if a reader ever appears, is a
-  double-buffered publish slot (2× memory, one worker-side copy per step); not
-  built now because it would erase most of the zero-copy win for a hypothetical.
+  are no such readers** — cloth is the one consumer outside the fluid package, and
+  it reads inside the fixed pass, above — so the exposure is zero, but it is a real
+  constraint and is documented on the class. The escape hatch, if a reader ever
+  appears, is a double-buffered publish slot (2× memory, one worker-side copy per
+  step); not built now because it would erase most of the zero-copy win for a
+  hypothetical.
 
 ### Latency
 

package/src/engine/ecs/storage/populateEngineSerializationRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"populateEngineSerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/storage/populateEngineSerializationRegistry.js"],"names":[],"mappings":"AA8LA;;;;;;;;GAQG;AACH,iGAqHC"}
+{"version":3,"file":"populateEngineSerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/storage/populateEngineSerializationRegistry.js"],"names":[],"mappings":"AAsMA;;;;;;;;GAQG;AACH,iGAwHC"}

package/src/engine/ecs/storage/populateEngineSerializationRegistry.js

@@ -6,6 +6,10 @@ import {
 import { Tag } from "../components/Tag.js";
 import { TagSerializationAdapter } from "../components/TagSerializationAdapter.js";
 import { TagSerializationUpgrader_0_1 } from "../components/TagSerializationUpgrader_0_1.js";
+import { ParticipatingMedia } from "../../graphics3/ParticipatingMedia.js";
+import {
+    ParticipatingMediaSerializationUpgrader_0_1
+} from "../../graphics3/ParticipatingMediaSerializationUpgrader_0_1.js";
 import { FogOfWar } from "../fow/FogOfWar.js";
 import {
     FogOfWarRevealerSerializationAdapter
@@ -44,9 +48,13 @@ import {
 } from "../../graphics3/VolumetricLightMapSerializationAdapter.js";
 import { Transform } from "../transform/Transform.js";
 import { Transform64SerializationAdapter } from "../transform/Transform64SerializationAdapter.js";
+import { ParticleEffect } from "../../graphics/ecs/particles/ParticleEffect.js";
 import {
     ParticleEffectSerializationAdapter
 } from "../../graphics/ecs/particles/ParticleEffectSerializationAdapter.js";
+import {
+    ParticleEffectSerializationUpgrader_1_2
+} from "../../graphics/ecs/particles/ParticleEffectSerializationUpgrader_1_2.js";
 import { TransformSerializationAdapter } from "../transform/TransformSerializationAdapter.js";
 import { TransformSerializationUpgrader_0_1 } from "../transform/TransformSerializationUpgrader_0_1.js";
 import {
@@ -277,6 +285,7 @@ export function populateEngineSerializationRegistry(registry) {
     registry.registerUpgrader(GridPosition.typeName, new GridPositionSerializationUpdater_0_1());
     registry.registerUpgrader(Transform.typeName, new TransformSerializationUpgrader_0_1());
     registry.registerUpgrader(Tag.typeName, new TagSerializationUpgrader_0_1());
+    registry.registerUpgrader(ParticipatingMedia.typeName, new ParticipatingMediaSerializationUpgrader_0_1());
     registry.registerUpgrader(Decal.typeName, new DecalSerializationUpgrader_0_1());
 
     registry.registerUpgrader(FogOfWar.typeName, new FogOfWarSerializationUpdater_0_1());
@@ -288,6 +297,8 @@ export function populateEngineSerializationRegistry(registry) {
     registry.registerUpgrader(Path.typeName, new PathSerializationUpgrader_1_2());
     registry.registerUpgrader(Path.typeName, new PathSerializationUpgrader_2_3());
 
+    registry.registerUpgrader(ParticleEffect.typeName, new ParticleEffectSerializationUpgrader_1_2());
+
     registry.registerUpgrader(PathFollower.typeName, new PathFollowerSerializationUpgrader_0_1());
     registry.registerUpgrader(PathFollower.typeName, new PathFollowerSerializationUpgrader_1_2());
     registry.registerUpgrader(PathFollower.typeName, new PathFollowerSerializationUpgrader_2_3());

package/src/engine/graphics/ecs/particles/ParticleEffect.d.ts

@@ -188,8 +188,8 @@ export class ParticleEffect {
     render_size: number;
     /** @type {number} record word offset of rgba colour */
     render_color: number;
-    /** @type {number} record word offset of roll angle, radians */
-    render_rotation: number;
+    /** @type {number} record word offset of the orientation, a quaternion (x, y, z, w) turning the sprite inside its projection mode's frame */
+    render_orientation: number;
     /** @type {number} record word offset of flipbook frame index */
     render_frame: number;
     /** @type {number} record word offset of velocity, read by the STRETCHED projection */

package/src/engine/graphics/ecs/particles/ParticleEffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleEffect.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/particles/ParticleEffect.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH;IAoRI;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAZ2G,MAAM,GAAtG,OAAO,+DAA+D,EAAE,cAAc;QACS,OAAO,GAAtG,OAAO,6DAA6D,EAAE,eAAe;QAChE,OAAO,GAA5B,MAAM,GAAC,IAAI;QACK,IAAI,GAApB,MAAM;QACU,UAAU,GAA1B,MAAM;QACW,QAAQ,GAAzB,OAAO;QACS,OAAO,GAAvB,MAAM;QACU,KAAK,GAArB,MAAM;QACyB,MAAM;gBAA9B,MAAM,GAAC,MAAM;;QACO,QAAQ,GAAnC,UAAU,MAAM,CAAC;QACf,cAAc,CA8C1B;IAjVD;;;;;;;;;OASG;IACH,QAFU,OAAO,+DAA+D,EAAE,cAAc,GAAC,IAAI,CAEvF;IAEd;;;;;OAKG;IACH,SAFU,OAAO,6DAA6D,EAAE,eAAe,GAAC,IAAI,CAErF;IAEf;;;;;;;;;OASG;IACH,SAFU,MAAM,GAAC,IAAI,CAEN;IAEf;;;;;;;;OAQG;IACH,MAFU,MAAM,CAEP;IAET;;;;;OAKG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;;OAUG;IACH,UAFU,OAAO,CAED;IAEhB;;;;;;;;;;;;;OAaG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;;;OAKG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;OAKG;IACH,UAFU,YAAY,CAEc;IAEpC,+FAA+F;IAC/F,iBADW,MAAM,CAC0B;IAC3C,gDAAgD;IAChD,aADW,MAAM,CACsB;IACvC,uDAAuD;IACvD,cADW,MAAM,CACuB;IACxC,+DAA+D;IAC/D,iBADW,MAAM,CAC0B;IAC3C,gEAAgE;IAChE,cADW,MAAM,CACuB;IACxC,sFAAsF;IACtF,iBADW,MAAM,CAC0B;IAE3C;;;;;OAKG;IACH,mCAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH;YAJkB,MAAM,GAAC,MAAM;QAElB,cAAc,CAuC1B;IAED;;;;;;;;;OASG;IACH,cAHW,cAAc,GACZ,OAAO,CAsBnB;IAED;;;;OAIG;IACH,QAFa,MAAM,CAuBlB;IAED;;;;;;;;;OASG;IACH,YAHW,cAAc,GACZ,cAAc,CAuB1B;IAED;;OAEG;IACH,SAFa,cAAc,CAI1B;IAgFL;;;;;OAKG;IACH,2BAFU,OAAO,CAEwB;CApBxC;;kBAUS,MAAM"}
+{"version":3,"file":"ParticleEffect.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/particles/ParticleEffect.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH;IAoRI;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAZ2G,MAAM,GAAtG,OAAO,+DAA+D,EAAE,cAAc;QACS,OAAO,GAAtG,OAAO,6DAA6D,EAAE,eAAe;QAChE,OAAO,GAA5B,MAAM,GAAC,IAAI;QACK,IAAI,GAApB,MAAM;QACU,UAAU,GAA1B,MAAM;QACW,QAAQ,GAAzB,OAAO;QACS,OAAO,GAAvB,MAAM;QACU,KAAK,GAArB,MAAM;QACyB,MAAM;gBAA9B,MAAM,GAAC,MAAM;;QACO,QAAQ,GAAnC,UAAU,MAAM,CAAC;QACf,cAAc,CA8C1B;IAjVD;;;;;;;;;OASG;IACH,QAFU,OAAO,+DAA+D,EAAE,cAAc,GAAC,IAAI,CAEvF;IAEd;;;;;OAKG;IACH,SAFU,OAAO,6DAA6D,EAAE,eAAe,GAAC,IAAI,CAErF;IAEf;;;;;;;;;OASG;IACH,SAFU,MAAM,GAAC,IAAI,CAEN;IAEf;;;;;;;;OAQG;IACH,MAFU,MAAM,CAEP;IAET;;;;;OAKG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;;OAUG;IACH,UAFU,OAAO,CAED;IAEhB;;;;;;;;;;;;;OAaG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;;;OAKG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;OAKG;IACH,UAFU,YAAY,CAEc;IAEpC,+FAA+F;IAC/F,iBADW,MAAM,CAC0B;IAC3C,gDAAgD;IAChD,aADW,MAAM,CACsB;IACvC,uDAAuD;IACvD,cADW,MAAM,CACuB;IACxC,4IAA4I;IAC5I,oBADW,MAAM,CAC6B;IAC9C,gEAAgE;IAChE,cADW,MAAM,CACuB;IACxC,sFAAsF;IACtF,iBADW,MAAM,CAC0B;IAE3C;;;;;OAKG;IACH,mCAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH;YAJkB,MAAM,GAAC,MAAM;QAElB,cAAc,CAuC1B;IAED;;;;;;;;;OASG;IACH,cAHW,cAAc,GACZ,OAAO,CAsBnB;IAED;;;;OAIG;IACH,QAFa,MAAM,CAuBlB;IAED;;;;;;;;;OASG;IACH,YAHW,cAAc,GACZ,cAAc,CAuB1B;IAED;;OAEG;IACH,SAFa,cAAc,CAI1B;IAgFL;;;;;OAKG;IACH,2BAFU,OAAO,CAEwB;CApBxC;;kBAUS,MAAM"}

package/src/engine/graphics/ecs/particles/ParticleEffect.js

@@ -180,8 +180,8 @@ export class ParticleEffect {
     render_size = EMITTER_ATTRIBUTE_ABSENT;
     /** @type {number} record word offset of rgba colour */
     render_color = EMITTER_ATTRIBUTE_ABSENT;
-    /** @type {number} record word offset of roll angle, radians */
-    render_rotation = EMITTER_ATTRIBUTE_ABSENT;
+    /** @type {number} record word offset of the orientation, a quaternion (x, y, z, w) turning the sprite inside its projection mode's frame */
+    render_orientation = EMITTER_ATTRIBUTE_ABSENT;
     /** @type {number} record word offset of flipbook frame index */
     render_frame = EMITTER_ATTRIBUTE_ABSENT;
     /** @type {number} record word offset of velocity, read by the STRETCHED projection */
@@ -233,8 +233,8 @@ export class ParticleEffect {
                 case "color":
                     this.render_color = offset;
                     break;
-                case "rotation":
-                    this.render_rotation = offset;
+                case "orientation":
+                    this.render_orientation = offset;
                     break;
                 case "frame":
                     this.render_frame = offset;
@@ -276,7 +276,7 @@ export class ParticleEffect {
             && this.render_position === other.render_position
             && this.render_size === other.render_size
             && this.render_color === other.render_color
-            && this.render_rotation === other.render_rotation
+            && this.render_orientation === other.render_orientation
             && this.render_frame === other.render_frame
             && this.render_velocity === other.render_velocity
             && is_typed_array_equals(this.flipbook, other.flipbook)
@@ -292,7 +292,7 @@ export class ParticleEffect {
     hash() {
         const bindings = hash_mix3(
             hash_mix3(this.render_position, this.render_size, this.render_color),
-            hash_mix3(this.render_rotation, this.render_frame, this.render_velocity),
+            hash_mix3(this.render_orientation, this.render_frame, this.render_velocity),
             this.flags
         );
 
@@ -338,7 +338,7 @@ export class ParticleEffect {
         this.render_position = other.render_position;
         this.render_size = other.render_size;
         this.render_color = other.render_color;
-        this.render_rotation = other.render_rotation;
+        this.render_orientation = other.render_orientation;
         this.render_frame = other.render_frame;
         this.render_velocity = other.render_velocity;
 

package/src/engine/graphics/ecs/particles/ParticleEffectSerializationAdapter.d.ts

@@ -30,6 +30,14 @@
  * the program is already compared by makes the reload exact by construction rather than by an
  * engine's discretion, and it means there is one representation of the pool rather than two.
  *
+ * ## Version 2
+ *
+ * The fourth render binding is the `orientation` channel, a quaternion; in version 1 the same word
+ * was the `rotation` channel, a roll angle. A v1 save is read through
+ * {@link ./ParticleEffectSerializationUpgrader_1_2.js}, which leaves the orientation unbound: the
+ * saved bytecode writes an angle, and nothing short of recompiling its graph turns that into a
+ * program that writes a quaternion. A v1 effect that spun loads without its spin.
+ *
  * ## Nothing device-shaped is written
  *
  * There is nothing here that a device assigned: no table row, no generation, no program-heap

package/src/engine/graphics/ecs/particles/ParticleEffectSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleEffectSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/particles/ParticleEffectSerializationAdapter.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;;IAEI,6BAAuB;IAGvB;;;OAGG;IACH,uCAFW,cAAc,QAmCxB;IAED;;;OAGG;IACH,yCAFW,cAAc,QA8BxB;CACJ;gDAzH+C,gEAAgE;+BACjF,qBAAqB"}
+{"version":3,"file":"ParticleEffectSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/particles/ParticleEffectSerializationAdapter.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;;IAEI,6BAAuB;IAGvB;;;OAGG;IACH,uCAFW,cAAc,QAmCxB;IAED;;;OAGG;IACH,yCAFW,cAAc,QA8BxB;CACJ;gDAjI+C,gEAAgE;+BACjF,qBAAqB"}

package/src/engine/graphics/ecs/particles/ParticleEffectSerializationAdapter.js

@@ -35,6 +35,14 @@ import { ParticleEffect } from "./ParticleEffect.js";
  * the program is already compared by makes the reload exact by construction rather than by an
  * engine's discretion, and it means there is one representation of the pool rather than two.
  *
+ * ## Version 2
+ *
+ * The fourth render binding is the `orientation` channel, a quaternion; in version 1 the same word
+ * was the `rotation` channel, a roll angle. A v1 save is read through
+ * {@link ./ParticleEffectSerializationUpgrader_1_2.js}, which leaves the orientation unbound: the
+ * saved bytecode writes an angle, and nothing short of recompiling its graph turns that into a
+ * program that writes a quaternion. A v1 effect that spun loads without its spin.
+ *
  * ## Nothing device-shaped is written
  *
  * There is nothing here that a device assigned: no table row, no generation, no program-heap
@@ -47,7 +55,7 @@ import { ParticleEffect } from "./ParticleEffect.js";
 export class ParticleEffectSerializationAdapter extends BinaryClassSerializationAdapter {
 
     klass = ParticleEffect;
-    version = 1;
+    version = 2;
 
     /**
      * @param {BinaryBuffer} buffer
@@ -68,7 +76,7 @@ export class ParticleEffectSerializationAdapter extends BinaryClassSerialization
         buffer.writeUint32(value.render_position);
         buffer.writeUint32(value.render_size);
         buffer.writeUint32(value.render_color);
-        buffer.writeUint32(value.render_rotation);
+        buffer.writeUint32(value.render_orientation);
         buffer.writeUint32(value.render_frame);
         buffer.writeUint32(value.render_velocity);
 
@@ -107,7 +115,7 @@ export class ParticleEffectSerializationAdapter extends BinaryClassSerialization
         value.render_position = buffer.readUint32();
         value.render_size = buffer.readUint32();
         value.render_color = buffer.readUint32();
-        value.render_rotation = buffer.readUint32();
+        value.render_orientation = buffer.readUint32();
         value.render_frame = buffer.readUint32();
         value.render_velocity = buffer.readUint32();
 

package/src/engine/graphics/ecs/particles/ParticleEffectSerializationUpgrader_1_2.d.ts

@@ -0,0 +1,26 @@
+/**
+ * {@link ./ParticleEffect.js ParticleEffect} version 1 to version 2: the roll channel gave way to the
+ * orientation channel.
+ *
+ * The two versions lay out the same bytes. What changed is what the fourth render binding means: a
+ * record word holding a roll angle in v1, the first of four holding a quaternion in v2. A v1 binding
+ * cannot be carried over — read as a quaternion it would take the angle and whatever three
+ * attributes follow it — and the saved bytecode writes an angle, which no rewriting of a binding
+ * turns into a quaternion. So the binding is dropped and the effect loads unturned; recompiling its
+ * graph with an orientation is the author's move.
+ *
+ * A frozen reader of v1, field by field, rather than a call into the current adapter: the adapter
+ * will move on, and this has to keep reading what v1 wrote.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ParticleEffectSerializationUpgrader_1_2 extends BinaryClassUpgrader {
+    /**
+     * @param {BinaryBuffer} source
+     * @param {BinaryBuffer} target
+     */
+    upgrade(source: BinaryBuffer, target: BinaryBuffer): void;
+}
+import { BinaryClassUpgrader } from "../../../ecs/storage/binary/BinaryClassUpgrader.js";
+//# sourceMappingURL=ParticleEffectSerializationUpgrader_1_2.d.ts.map

package/src/engine/graphics/ecs/particles/ParticleEffectSerializationUpgrader_1_2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleEffectSerializationUpgrader_1_2.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/particles/ParticleEffectSerializationUpgrader_1_2.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH;IAII;;;OAGG;IACH,0DA+CC;CACJ;oCA3EmC,oDAAoD"}

package/src/engine/graphics/ecs/particles/ParticleEffectSerializationUpgrader_1_2.js

@@ -0,0 +1,91 @@
+import { EMITTER_ATTRIBUTE_ABSENT } from "../../../../shade/renderer/particles/data/PARTICLE_EMITTER_STRUCT.js";
+import { BinaryClassUpgrader } from "../../../ecs/storage/binary/BinaryClassUpgrader.js";
+
+/**
+ * {@link ./ParticleEffect.js ParticleEffect} version 1 to version 2: the roll channel gave way to the
+ * orientation channel.
+ *
+ * The two versions lay out the same bytes. What changed is what the fourth render binding means: a
+ * record word holding a roll angle in v1, the first of four holding a quaternion in v2. A v1 binding
+ * cannot be carried over — read as a quaternion it would take the angle and whatever three
+ * attributes follow it — and the saved bytecode writes an angle, which no rewriting of a binding
+ * turns into a quaternion. So the binding is dropped and the effect loads unturned; recompiling its
+ * graph with an orientation is the author's move.
+ *
+ * A frozen reader of v1, field by field, rather than a call into the current adapter: the adapter
+ * will move on, and this has to keep reading what v1 wrote.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ParticleEffectSerializationUpgrader_1_2 extends BinaryClassUpgrader {
+    __startVersion = 1;
+    __targetVersion = 2;
+
+    /**
+     * @param {BinaryBuffer} source
+     * @param {BinaryBuffer} target
+     */
+    upgrade(source, target) {
+        target.writeUTF8String(source.readUTF8String()); // texture
+
+        target.writeUintVar(source.readUintVar()); // seed
+        target.writeFloat32(source.readFloat32()); // spawn rate
+        target.writeFloat32(source.readFloat32()); // pre-warm
+        target.writeUint8(source.readUint8()); // emitting
+        target.writeUint32(source.readUint32()); // flags
+
+        target.writeFloat32(source.readFloat32()); // flipbook columns
+        target.writeFloat32(source.readFloat32()); // flipbook rows
+
+        target.writeUint32(source.readUint32()); // position
+        target.writeUint32(source.readUint32()); // size
+        target.writeUint32(source.readUint32()); // color
+
+        source.readUint32(); // the roll's binding, which has no orientation to become
+        target.writeUint32(EMITTER_ATTRIBUTE_ABSENT);
+
+        target.writeUint32(source.readUint32()); // frame
+        target.writeUint32(source.readUint32()); // velocity
+
+        const present = source.readUint8();
+
+        target.writeUint8(present);
+
+        if (present !== 1) {
+            return;
+        }
+
+        // the layout: attribute count, then name, component count and semantic tag of each
+        const attribute_count = source.readUintVar();
+
+        target.writeUintVar(attribute_count);
+
+        for (let i = 0; i < attribute_count; i++) {
+            target.writeUTF8String(source.readUTF8String());
+            target.writeUint8(source.readUint8());
+            target.writeUTF8String(source.readUTF8String());
+        }
+
+        // the program: register count, then INIT, UPDATE and the constant pool as word arrays
+        target.writeUint8(source.readUint8());
+
+        copy_words(source, target);
+        copy_words(source, target);
+        copy_words(source, target);
+    }
+}
+
+/**
+ * @param {BinaryBuffer} source
+ * @param {BinaryBuffer} target
+ */
+function copy_words(source, target) {
+    const length = source.readUintVar();
+    const words = new Uint32Array(length);
+
+    source.readUint32Array(words, 0, length);
+
+    target.writeUintVar(length);
+    target.writeUint32Array(words, 0, length);
+}

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,46 @@ 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.
+     * @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 +145,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 +159,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;IAuHI;;;OAGG;IACH,4BAFa,kBAAkB,CAQ9B;IA/HD;;;;;;;;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;;;OAGG;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;;wCAvUT,8DAA8D"}