@woosh/meep-engine 3.47.0 → 3.50.0

package/src/shade/renderer/particles/graph/groups/particle_groups_geometry.d.ts

@@ -80,4 +80,64 @@ export const PARTICLE_GROUP_QUAT_ROTATE: import("../ParticleNodeGroup.js").Parti
  * @type {import("../ParticleNodeGroup.js").ParticleNodeGroup}
  */
 export const PARTICLE_GROUP_QUAT_LOOK_ROTATION: import("../ParticleNodeGroup.js").ParticleNodeGroup;
+/**
+ * Two rotations, one after the other: the turn by `b`, then the turn by `a`.
+ *
+ * The Hamilton product, `(a.w b.xyz + b.w a.xyz + a.xyz × b.xyz, a.w b.w - a.xyz · b.xyz)`, in the
+ * order the engine's `Quaternion.multiplyQuaternions(a, b)` writes it — so turning a vector by the
+ * result is turning it by `b` and then by `a`. Not commutative: swapping the inputs turns about the
+ * other frame.
+ *
+ * @type {import("../ParticleNodeGroup.js").ParticleNodeGroup}
+ */
+export const PARTICLE_GROUP_QUAT_MULTIPLY: import("../ParticleNodeGroup.js").ParticleNodeGroup;
+/**
+ * An orientation advanced by an angular velocity over a step: `quat` turned by `omega`, in radians
+ * per second about the axis it points along, for `dt` seconds.
+ *
+ * Exact for a constant `omega` at any `dt` — the step is the rotation itself,
+ * `quatFromAxisAngle(omega, |omega| dt)`, composed in front — rather than the first-order
+ * `q + dt/2 (omega, 0) q` a rigid-body solver takes. That one turns by `2 atan(|omega| dt / 2)` instead
+ * of `|omega| dt`, which a solver stepping at a fixed 1/60 never notices, and a particle does: the
+ * warm-up stretches its ticks to cover a whole pre-warm in at most
+ * {@link ../../ParticleConstants.js PARTICLE_WARMUP_MAX_TICKS} of them, 156 ms each for five seconds,
+ * where a 10 rad/s tumble would come out 15% slow. A program does not get to care what `dt` it is
+ * handed.
+ *
+ * `omega` turns in the frame the orientation is in — the world, for a FACING_WORLD emitter — which is
+ * why the step goes in front. The result is renormalised, so a tumble integrated for a minute is
+ * still a unit quaternion and `quatRotate` does not start scaling what it turns. A zero `omega` is
+ * no turn.
+ *
+ * @type {import("../ParticleNodeGroup.js").ParticleNodeGroup}
+ */
+export const PARTICLE_GROUP_QUAT_INTEGRATE: import("../ParticleNodeGroup.js").ParticleNodeGroup;
+/**
+ * A rotation drawn uniformly from all of them, from three numbers in `[0, 1)`.
+ *
+ * Shoemake's construction ("Uniform random rotations", Graphics Gems III): with `u` the first number,
+ * the quaternion is `(sqrt(1-u) sin 2πv, sqrt(1-u) cos 2πv, sqrt(u) sin 2πw, sqrt(u) cos 2πw)`. It
+ * lands on the unit sphere in four dimensions uniformly, which is what a uniform rotation is. Drawing
+ * three Euler angles uniformly is the tempting wrong one, and clusters the turns.
+ *
+ * Feed it a three-lane `random` and it is a tumbling flake's starting orientation.
+ *
+ * @type {import("../ParticleNodeGroup.js").ParticleNodeGroup}
+ */
+export const PARTICLE_GROUP_SAMPLE_ROTATION: import("../ParticleNodeGroup.js").ParticleNodeGroup;
+/**
+ * The emitter's own rotation: the turn that takes the world's axes to its node's.
+ *
+ * The VM hands an effect the node's axes rather than its rotation — `EMITTER_DIRECTION`, which is the
+ * node's forward and so its **-Z**, and `EMITTER_UP`, its +Y — and a look rotation maps **+Z** to the
+ * forward it is given. Wiring the two straight together therefore turns a sprite half a turn and
+ * shows its back. This is that wiring with the sign put right, which is the whole reason it is a
+ * group.
+ *
+ * Write it into a FACING_WORLD particle's orientation at birth and the sprite starts out lying in
+ * its emitter's XY plane, facing the emitter's +Z.
+ *
+ * @type {import("../ParticleNodeGroup.js").ParticleNodeGroup}
+ */
+export const PARTICLE_GROUP_EMITTER_ROTATION: import("../ParticleNodeGroup.js").ParticleNodeGroup;
 //# sourceMappingURL=particle_groups_geometry.d.ts.map

package/src/shade/renderer/particles/graph/groups/particle_groups_geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_groups_geometry.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/graph/groups/particle_groups_geometry.js"],"names":[],"mappings":"AAqCA;;;;;;;;;;;GAWG;AACH,mDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAsBxD;AAEL;;;;;;;;;GASG;AACH,kDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAmBxD;AAEL;;;;;;;;;;;;GAYG;AACH,2CAFU,OAAO,yBAAyB,EAAE,iBAAiB,EAAE,CAiB5D;AAEH;;;;;;;;GAQG;AACH,kDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAsBxD;AAEL;;;;;;;;;;;GAWG;AACH,yCAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAuBxD;AAEL;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CA+ExD"}
+{"version":3,"file":"particle_groups_geometry.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/graph/groups/particle_groups_geometry.js"],"names":[],"mappings":"AAsCA;;;;;;;;;;;GAWG;AACH,mDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAsBxD;AAEL;;;;;;;;;GASG;AACH,kDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAmBxD;AAEL;;;;;;;;;;;;GAYG;AACH,2CAFU,OAAO,yBAAyB,EAAE,iBAAiB,EAAE,CAiB5D;AAEH;;;;;;;;GAQG;AACH,kDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAsBxD;AAEL;;;;;;;;;;;GAWG;AACH,yCAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAuBxD;AAEL;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CA+ExD;AAEL;;;;;;;;;GASG;AACH,2CAFU,OAAO,yBAAyB,EAAE,iBAAiB,CA0BxD;AAEL;;;;;;;;;;;;;;;;;;;GAmBG;AACH,4CAFU,OAAO,yBAAyB,EAAE,iBAAiB,CA0BxD;AAEL;;;;;;;;;;;GAWG;AACH,6CAFU,OAAO,yBAAyB,EAAE,iBAAiB,CA6BxD;AAEL;;;;;;;;;;;;;GAaG;AACH,8CAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAkBxD"}

package/src/shade/renderer/particles/graph/groups/particle_groups_geometry.js

@@ -1,3 +1,4 @@
+import { VM_BUILTIN } from "../../isa/ParticleVMISA.js";
 import { ParticleGroupBuilder } from "../ParticleGroupBuilder.js";
 import {
     PARTICLE_TYPE_F32,
@@ -292,3 +293,158 @@ export const PARTICLE_GROUP_QUAT_LOOK_ROTATION = (() => {
 
     return g.build();
 })();
+
+/**
+ * Two rotations, one after the other: the turn by `b`, then the turn by `a`.
+ *
+ * The Hamilton product, `(a.w b.xyz + b.w a.xyz + a.xyz × b.xyz, a.w b.w - a.xyz · b.xyz)`, in the
+ * order the engine's `Quaternion.multiplyQuaternions(a, b)` writes it — so turning a vector by the
+ * result is turning it by `b` and then by `a`. Not commutative: swapping the inputs turns about the
+ * other frame.
+ *
+ * @type {import("../ParticleNodeGroup.js").ParticleNodeGroup}
+ */
+export const PARTICLE_GROUP_QUAT_MULTIPLY = (() => {
+    const g = new ParticleGroupBuilder({
+        name: "quatMultiply",
+        label: "Multiply Quaternions",
+        icon: "M5 12a5 5 0 1 0 10 0a5 5 0 1 0-10 0 M9 12a5 5 0 1 0 10 0a5 5 0 1 0-10 0",
+        help: "the turn by b, then the turn by a",
+        inputs: [
+            { name: "a", type: PARTICLE_TYPE_VEC4 },
+            { name: "b", type: PARTICLE_TYPE_VEC4 },
+        ],
+        outputs: [{ name: "quat", type: PARTICLE_TYPE_VEC4 }],
+    });
+
+    const av = g.swz(g.in.a, "xyz");
+    const bv = g.swz(g.in.b, "xyz");
+    const aw = g.w(g.in.a);
+    const bw = g.w(g.in.b);
+
+    const vector = g.add(g.add(g.scale(bv, aw), g.scale(av, bw)), g.cross(av, bv));
+    const scalar = g.sub(g.mul(aw, bw), g.dot(av, bv));
+
+    g.out("quat", g.vec4(g.x(vector), g.y(vector), g.z(vector), scalar));
+
+    return g.build();
+})();
+
+/**
+ * An orientation advanced by an angular velocity over a step: `quat` turned by `omega`, in radians
+ * per second about the axis it points along, for `dt` seconds.
+ *
+ * Exact for a constant `omega` at any `dt` — the step is the rotation itself,
+ * `quatFromAxisAngle(omega, |omega| dt)`, composed in front — rather than the first-order
+ * `q + dt/2 (omega, 0) q` a rigid-body solver takes. That one turns by `2 atan(|omega| dt / 2)` instead
+ * of `|omega| dt`, which a solver stepping at a fixed 1/60 never notices, and a particle does: the
+ * warm-up stretches its ticks to cover a whole pre-warm in at most
+ * {@link ../../ParticleConstants.js PARTICLE_WARMUP_MAX_TICKS} of them, 156 ms each for five seconds,
+ * where a 10 rad/s tumble would come out 15% slow. A program does not get to care what `dt` it is
+ * handed.
+ *
+ * `omega` turns in the frame the orientation is in — the world, for a FACING_WORLD emitter — which is
+ * why the step goes in front. The result is renormalised, so a tumble integrated for a minute is
+ * still a unit quaternion and `quatRotate` does not start scaling what it turns. A zero `omega` is
+ * no turn.
+ *
+ * @type {import("../ParticleNodeGroup.js").ParticleNodeGroup}
+ */
+export const PARTICLE_GROUP_QUAT_INTEGRATE = (() => {
+    const g = new ParticleGroupBuilder({
+        name: "quatIntegrate",
+        label: "Integrate Angular Velocity",
+        icon: "M12 4a8 8 0 1 1-8 8 M4 12l-2-3 M4 12l3-2 M12 12l4-4",
+        help: "an orientation turned by an angular velocity over dt",
+        inputs: [
+            { name: "quat", type: PARTICLE_TYPE_VEC4 },
+            { name: "omega", type: PARTICLE_TYPE_VEC3 },
+            { name: "dt", type: PARTICLE_TYPE_F32 },
+        ],
+        outputs: [{ name: "quat", type: PARTICLE_TYPE_VEC4 }],
+    });
+
+    const step = g.call(PARTICLE_GROUP_QUAT_FROM_AXIS_ANGLE, {
+        axis: g.in.omega,
+        angle: g.mul(g.length(g.in.omega), g.in.dt),
+    }).quat;
+
+    const turned = g.call(PARTICLE_GROUP_QUAT_MULTIPLY, { a: step, b: g.in.quat }).quat;
+
+    g.out("quat", g.normalize(turned));
+
+    return g.build();
+})();
+
+/**
+ * A rotation drawn uniformly from all of them, from three numbers in `[0, 1)`.
+ *
+ * Shoemake's construction ("Uniform random rotations", Graphics Gems III): with `u` the first number,
+ * the quaternion is `(sqrt(1-u) sin 2πv, sqrt(1-u) cos 2πv, sqrt(u) sin 2πw, sqrt(u) cos 2πw)`. It
+ * lands on the unit sphere in four dimensions uniformly, which is what a uniform rotation is. Drawing
+ * three Euler angles uniformly is the tempting wrong one, and clusters the turns.
+ *
+ * Feed it a three-lane `random` and it is a tumbling flake's starting orientation.
+ *
+ * @type {import("../ParticleNodeGroup.js").ParticleNodeGroup}
+ */
+export const PARTICLE_GROUP_SAMPLE_ROTATION = (() => {
+    const g = new ParticleGroupBuilder({
+        name: "sampleRotation",
+        label: "Sample Rotation",
+        icon: "M12 3a9 9 0 1 0 0 18a9 9 0 1 0 0-18 M7 9l5-4 5 4 M12 5v14",
+        help: "uvw in [0,1) to a rotation, uniformly over all of them",
+        inputs: [{ name: "uvw", type: PARTICLE_TYPE_VEC3 }],
+        outputs: [{ name: "quat", type: PARTICLE_TYPE_VEC4 }],
+    });
+
+    const u = g.x(g.in.uvw);
+
+    // the max guards the rounding at the ends, as the sphere samplers do
+    const first = g.sqrt(g.max(g.sub(1, u), 0));
+    const second = g.sqrt(g.max(u, 0));
+
+    const a = g.mul(g.y(g.in.uvw), g.f(TAU));
+    const b = g.mul(g.z(g.in.uvw), g.f(TAU));
+
+    g.out("quat", g.vec4(
+        g.mul(first, g.sin(a)),
+        g.mul(first, g.cos(a)),
+        g.mul(second, g.sin(b)),
+        g.mul(second, g.cos(b)),
+    ));
+
+    return g.build();
+})();
+
+/**
+ * The emitter's own rotation: the turn that takes the world's axes to its node's.
+ *
+ * The VM hands an effect the node's axes rather than its rotation — `EMITTER_DIRECTION`, which is the
+ * node's forward and so its **-Z**, and `EMITTER_UP`, its +Y — and a look rotation maps **+Z** to the
+ * forward it is given. Wiring the two straight together therefore turns a sprite half a turn and
+ * shows its back. This is that wiring with the sign put right, which is the whole reason it is a
+ * group.
+ *
+ * Write it into a FACING_WORLD particle's orientation at birth and the sprite starts out lying in
+ * its emitter's XY plane, facing the emitter's +Z.
+ *
+ * @type {import("../ParticleNodeGroup.js").ParticleNodeGroup}
+ */
+export const PARTICLE_GROUP_EMITTER_ROTATION = (() => {
+    const g = new ParticleGroupBuilder({
+        name: "emitterRotation",
+        label: "Emitter Rotation",
+        icon: "M4 20h16 M12 20V8 M12 8l-4 4 M12 8l4 4 M6 4h12",
+        help: "the emitter's own rotation, as a quaternion",
+        inputs: [],
+        outputs: [{ name: "quat", type: PARTICLE_TYPE_VEC4 }],
+    });
+
+    const forward = g.neg(g.builtin(VM_BUILTIN.EMITTER_DIRECTION));
+    const up = g.builtin(VM_BUILTIN.EMITTER_UP);
+
+    g.out("quat", g.call(PARTICLE_GROUP_QUAT_LOOK_ROTATION, { forward, up }).quat);
+
+    return g.build();
+})();

package/src/shade/renderer/particles/graph/particle_node_parameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_node_parameters.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_node_parameters.js"],"names":[],"mappings":"AA+LA;;;;;;;;;;;;;;;;;GAiBG;AACH,sDAHW,MAAM,GACJ,MAAM,CAIlB;AAwBD;;;;;;GAMG;AACH,+CAJW,MAAM,GACJ,qBAAqB,EAAE,CAcnC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,uDANW,MAAM;IAEyD,MAAM,GAArE,OAAO,6BAA6B,EAAE,cAAc;IAElD,MAAM,CAmBlB;AAED;;;;GAIG;AACH,2CAFa,MAAM;IAAC,WAAW,EAAE,OAAO,8BAA8B,EAAE,uBAAuB,CAAC;IAAC,UAAU,EAAE,qBAAqB,EAAE,CAAA;CAAC,CAAC,CAOrI;;;;sCApRS,MAAM;AApBhB;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH;IACI,0FAA0F;;IAE1F,kFAAkF;;IAElF,mFAAmF;;IAEnF,2EAA2E;;IAE3E,kEAAkE;;IAElE;;;OAGG;;IAEH;;;OAGG;;GAEJ;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;GASG;AACH,gDAFU,MAAM,EAAE,CAWf;AAEH;;;;;GAKG;AACH;QAFiB,MAAM,GAAE,MAAM;EAI7B;AAEF;;;;;GAKG;AACH;QAFiB,MAAM,GAAE,qBAAqB,EAAE;EAuF7C;;;;;;;;UAtIW,MAAM;;;;UACN,MAAM;;;;;;;;;;YAGC,MAAM;;;;;;;;YACb,OAAO;;;;kBAIP,MAAM"}
+{"version":3,"file":"particle_node_parameters.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_node_parameters.js"],"names":[],"mappings":"AAgMA;;;;;;;;;;;;;;;;;GAiBG;AACH,sDAHW,MAAM,GACJ,MAAM,CAIlB;AAwBD;;;;;;GAMG;AACH,+CAJW,MAAM,GACJ,qBAAqB,EAAE,CAcnC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,uDANW,MAAM;IAEyD,MAAM,GAArE,OAAO,6BAA6B,EAAE,cAAc;IAElD,MAAM,CAmBlB;AAED;;;;GAIG;AACH,2CAFa,MAAM;IAAC,WAAW,EAAE,OAAO,8BAA8B,EAAE,uBAAuB,CAAC;IAAC,UAAU,EAAE,qBAAqB,EAAE,CAAA;CAAC,CAAC,CAOrI;;;;sCArRS,MAAM;AApBhB;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH;IACI,0FAA0F;;IAE1F,kFAAkF;;IAElF,mFAAmF;;IAEnF,2EAA2E;;IAE3E,kEAAkE;;IAElE;;;OAGG;;IAEH;;;OAGG;;GAEJ;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;GASG;AACH,gDAFU,MAAM,EAAE,CAYf;AAEH;;;;;GAKG;AACH;QAFiB,MAAM,GAAE,MAAM;EAI7B;AAEF;;;;;GAKG;AACH;QAFiB,MAAM,GAAE,qBAAqB,EAAE;EAuF7C;;;;;;;;UAvIW,MAAM;;;;UACN,MAAM;;;;;;;;;;YAGC,MAAM;;;;;;;;YACb,OAAO;;;;kBAIP,MAAM"}

package/src/shade/renderer/particles/graph/particle_node_parameters.js

@@ -84,6 +84,7 @@ export const PARTICLE_NODES_WITHOUT_PARAMETERS = Object.freeze([
     "dot", "cross", "distance",
     "vec2", "vec3", "vec4",
     "select",
+    "wind",
 ]);
 
 /**

package/src/shade/renderer/particles/graph/particle_node_presentation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_node_presentation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_node_presentation.js"],"names":[],"mappings":"AAiUA;;;;;;;GAOG;AACH,iDAHW,MAAM,GACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAIvD;AAjSD;;;;;;;;GAQG;AACH;QAFiB,MAAM,GAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;EA8QjE"}
+{"version":3,"file":"particle_node_presentation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_node_presentation.js"],"names":[],"mappings":"AAyUA;;;;;;;GAOG;AACH,iDAHW,MAAM,GACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAIvD;AAzSD;;;;;;;;GAQG;AACH;QAFiB,MAAM,GAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;EAsRjE"}

package/src/shade/renderer/particles/graph/particle_node_presentation.js

@@ -317,6 +317,14 @@ export const PARTICLE_NODE_PRESENTATION = Object.freeze({
         icon: `M4 5h16v8H4z ${dot(6, 18, 1.8)} ${dot(12, 18, 1.8)} ${dot(18, 18, 1.8)}`,
         help: "a colour gradient looked up at t, no alpha",
     },
+
+    // --- the scene ---
+    wind: {
+        // three streamlines, the lower two curling back on themselves
+        label: "Wind",
+        icon: "M3 8h11a3 3 0 1 0-3-3 M3 12h15a3 3 0 1 1-3 3 M3 16h7",
+        help: "the scene's wind at a world position, in metres per second — still air where nothing makes any",
+    },
 });
 
 /**

package/src/shade/renderer/particles/graph_particles.d.ts

@@ -85,6 +85,8 @@
  * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
  * @param {number} params.camera graph handle of the view's camera uniform (`CAMERA_UNIFORM_STRUCT`)
  * @param {number} params.scene_database graph handle of the scene database — the emitters' nodes
+ * @param {import("../wind/GPUSceneWind.js").GPUSceneWind} params.wind the scene's published wind field,
+ *   which every pass that runs the VM binds for `SAMPLE_WIND` — still air when nothing produces wind
  * @param {object} params.gpu the persistent buffers, see {@link GPUParticleSystem}. `gpu.alive_read`
  *   is the exception: it is the previous frame's alive list and is present only when
  *   `frame.rebucket` says this frame reads one
@@ -113,10 +115,11 @@
  *   many ticks the warm-up runs and how long each is
  * @returns {ParticleSimulationHandles}
  */
-export function graph_particles_simulate({ graph, camera, scene_database, gpu, emitters, capacity, bucket_count, wide_registers, frame, }: {
+export function graph_particles_simulate({ graph, camera, scene_database, wind, gpu, emitters, capacity, bucket_count, wide_registers, frame, }: {
     graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
     camera: number;
     scene_database: number;
+    wind: import("../wind/GPUSceneWind.js").GPUSceneWind;
     gpu: object;
     emitters: {
         capacity: number;

package/src/shade/renderer/particles/graph_particles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_particles.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IA/BkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,cAAc,EAA7B,MAAM;IACS,GAAG,EAAlB,MAAM;IAGS,QAAQ;QACC,QAAQ,EAAhC,MAAM;QAEkB,WAAW,EAAnC,MAAM;;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IAEU,cAAc,EAA9B,OAAO;IAGQ,KAAK;QACC,EAAE,EAAvB,MAAM;QACe,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;QACiB,QAAQ,GAA/B,OAAO;QACc,WAAW,EAAhC,MAAM;QACe,mBAAmB,EAAxC,MAAM;QACe,YAAY,EAAjC,MAAM;QAGe,eAAe,EAApC,MAAM;QAC6D,eAAe,EAAlF,OAAO,6BAA6B,EAAE,cAAc;;IAElD,yBAAyB,CAiUrC;;;;;UAzWa,MAAM;;;;WACN,MAAM;;;;eACN,MAAM;;;;;sBACN,MAAM"}
+{"version":3,"file":"graph_particles.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IAjCkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,cAAc,EAA7B,MAAM;IACiD,IAAI,EAA3D,OAAO,yBAAyB,EAAE,YAAY;IAE/B,GAAG,EAAlB,MAAM;IAGS,QAAQ;QACC,QAAQ,EAAhC,MAAM;QAEkB,WAAW,EAAnC,MAAM;;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IAEU,cAAc,EAA9B,OAAO;IAGQ,KAAK;QACC,EAAE,EAAvB,MAAM;QACe,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;QACiB,QAAQ,GAA/B,OAAO;QACc,WAAW,EAAhC,MAAM;QACe,mBAAmB,EAAxC,MAAM;QACe,YAAY,EAAjC,MAAM;QAGe,eAAe,EAApC,MAAM;QAC6D,eAAe,EAAlF,OAAO,6BAA6B,EAAE,cAAc;;IAElD,yBAAyB,CA4UrC;;;;;UAtXa,MAAM;;;;WACN,MAAM;;;;eACN,MAAM;;;;;sBACN,MAAM"}

package/src/shade/renderer/particles/graph_particles.js

@@ -129,6 +129,8 @@ import { graph_particle_warmup } from "./warmup/graph_particle_warmup.js";
  * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
  * @param {number} params.camera graph handle of the view's camera uniform (`CAMERA_UNIFORM_STRUCT`)
  * @param {number} params.scene_database graph handle of the scene database — the emitters' nodes
+ * @param {import("../wind/GPUSceneWind.js").GPUSceneWind} params.wind the scene's published wind field,
+ *   which every pass that runs the VM binds for `SAMPLE_WIND` — still air when nothing produces wind
  * @param {object} params.gpu the persistent buffers, see {@link GPUParticleSystem}. `gpu.alive_read`
  *   is the exception: it is the previous frame's alive list and is present only when
  *   `frame.rebucket` says this frame reads one
@@ -161,6 +163,7 @@ export function graph_particles_simulate({
                                              graph,
                                              camera,
                                              scene_database,
+                                             wind,
                                              gpu,
                                              emitters,
                                              capacity,
@@ -171,6 +174,7 @@ export function graph_particles_simulate({
     assert.defined(graph, "graph");
     assert.isNonNegativeInteger(camera, "camera");
     assert.isNonNegativeInteger(scene_database, "scene_database");
+    assert.defined(wind, "wind");
     assert.isPositiveInteger(capacity, "capacity");
 
     const gr_program = graph_import_buffer(graph, gpu.program, "particles/program");
@@ -336,6 +340,9 @@ export function graph_particles_simulate({
             settings: { u_dt: frame.dt, u_time: frame.time, u_frame: frame.index, u_capacity: capacity },
         };
 
+        // Taken this frame rather than held: a producer that grows the field replaces its atlas.
+        wind.bind(bindings);
+
         const out = wide_registers
             ? graph_compute_pass({
                 graph,
@@ -374,6 +381,8 @@ export function graph_particles_simulate({
             settings: { u_dt: frame.dt, u_time: frame.time, u_frame: frame.index },
         };
 
+        wind.bind(bindings);
+
         const out = wide_registers
             ? graph_compute_pass({
                 graph,
@@ -389,6 +398,9 @@ export function graph_particles_simulate({
             });
 
         pool = out.pool; alive_write = out.alive_out; dead = out.dead; counters = out.counters;
+
+        // Threaded like emit's: the warm-up's wide passes below take the file after this one.
+        if (wide_registers) { vm_registers = out.vm_registers; }
     }
 
     // 7b. Warm-up — on a frame that registered emitters with a pre-warm, and only then: run their
@@ -401,6 +413,7 @@ export function graph_particles_simulate({
         const out = graph_particle_warmup({
             graph,
             scene_database,
+            wind,
             emitter_database,
             program: gr_program,
             pool, alive_out: alive_write, dead, counters,

package/src/shade/renderer/particles/isa/InstructionStream.d.ts

@@ -123,6 +123,19 @@ export class InstructionStream {
      * @returns {InstructionStream}
      */
     random(dst: number, width?: number): InstructionStream;
+    /**
+     * The scene's wind at a world position, m/s: three lanes of `position` in, three lanes out — four
+     * with a zero `w` if asked for.
+     *
+     * @param {number} dst
+     * @param {number|{kind: number, word: number}} position a register operand word or a literal
+     * @param {number} [width] 3 or 4
+     * @returns {InstructionStream}
+     */
+    sampleWind(dst: number, position: number | {
+        kind: number;
+        word: number;
+    }, width?: number): InstructionStream;
     /**
      * @returns {InstructionStream}
      */

package/src/shade/renderer/particles/isa/InstructionStream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InstructionStream.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/InstructionStream.js"],"names":[],"mappings":"AAkCA;;;;;;GAMG;AACH;IACI,yCAAyC;IACzC,cADW,MAAM,EAAE,EAAE,CACH;IAClB,iEAAiE;IACjE,gBADW,MAAM,CACE;IAsBnB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,SARW,MAAM,QACN,MAAM,OACN,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,OACnC,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,OACnC,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,UACnC,MAAM,GACJ,iBAAiB,CA6D7B;IAED;;;;;;OAMG;IACH,iBAHW,UAAU,MAAM,CAAC,GACf,iBAAiB,CAS7B;IAID;;;;;OAKG;IACH,SALW,MAAM,OACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;;;;OAQG;IACH,eALW,MAAM,OACN,MAAM,SACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;OAKG;IACH,eALW,MAAM,kBACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;;;;;OASG;IACH,cANW,MAAM,eACN,MAAM,mBACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAK7B;IAED;;;;;;;;OAQG;IACH,kBALW,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,eACnC,MAAM,mBACN,MAAM,GACJ,iBAAiB,CAK7B;IAED;;;;;OAKG;IACH,iBALW,MAAM,cACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;OAGG;IACH,gBAHW,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,GACjC,iBAAiB,CAI7B;IAED;;;;;;;;OAQG;IACH,YAJW,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;OAEG;IACH,QAFa,iBAAiB,CAI7B;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,WAFa,WAAW,CAWvB;;CACJ"}
+{"version":3,"file":"InstructionStream.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/InstructionStream.js"],"names":[],"mappings":"AAkCA;;;;;;GAMG;AACH;IACI,yCAAyC;IACzC,cADW,MAAM,EAAE,EAAE,CACH;IAClB,iEAAiE;IACjE,gBADW,MAAM,CACE;IAsBnB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,SARW,MAAM,QACN,MAAM,OACN,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,OACnC,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,OACnC,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,UACnC,MAAM,GACJ,iBAAiB,CA6D7B;IAED;;;;;;OAMG;IACH,iBAHW,UAAU,MAAM,CAAC,GACf,iBAAiB,CAS7B;IAID;;;;;OAKG;IACH,SALW,MAAM,OACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;;;;OAQG;IACH,eALW,MAAM,OACN,MAAM,SACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;OAKG;IACH,eALW,MAAM,kBACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;;;;;OASG;IACH,cANW,MAAM,eACN,MAAM,mBACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAK7B;IAED;;;;;;;;OAQG;IACH,kBALW,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,eACnC,MAAM,mBACN,MAAM,GACJ,iBAAiB,CAK7B;IAED;;;;;OAKG;IACH,iBALW,MAAM,cACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;OAGG;IACH,gBAHW,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,GACjC,iBAAiB,CAI7B;IAED;;;;;;;;OAQG;IACH,YAJW,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;;;;OAQG;IACH,gBALW,MAAM,YACN,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,UACnC,MAAM,GACJ,iBAAiB,CAI7B;IAED;;OAEG;IACH,QAFa,iBAAiB,CAI7B;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,WAFa,WAAW,CAWvB;;CACJ"}

package/src/shade/renderer/particles/isa/InstructionStream.js

@@ -259,6 +259,19 @@ export class InstructionStream {
         return this.emit(VM_OP.RANDOM, dst, 0, 0, 0, width);
     }
 
+    /**
+     * The scene's wind at a world position, m/s: three lanes of `position` in, three lanes out — four
+     * with a zero `w` if asked for.
+     *
+     * @param {number} dst
+     * @param {number|{kind: number, word: number}} position a register operand word or a literal
+     * @param {number} [width] 3 or 4
+     * @returns {InstructionStream}
+     */
+    sampleWind(dst, position, width = undefined) {
+        return this.emit(VM_OP.SAMPLE_WIND, dst, position, 0, 0, width);
+    }
+
     /**
      * @returns {InstructionStream}
      */

package/src/shade/renderer/particles/isa/ParticleVMISA.d.ts

@@ -373,6 +373,7 @@ export namespace VM_OP {
     let CMP_EQ: number;
     let SELECT: number;
     let RANDOM: number;
+    let SAMPLE_WIND: number;
 }
 /**
  * How an opcode reads the instruction's width field — the lane count it operates on.

package/src/shade/renderer/particles/isa/ParticleVMISA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleVMISA.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/ParticleVMISA.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"ParticleVMISA.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/ParticleVMISA.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/particles/isa/ParticleVMISA.js

@@ -211,6 +211,7 @@ export const VM_OP = {
     SELECT: 55,
 
     RANDOM: 60,
+    SAMPLE_WIND: 62,
 };
 
 /**
@@ -693,6 +694,13 @@ def(VM_OP.SELECT, "SELECT", true, R, R, R);
 // arithmetic a program writes over this draw — see ../graph/particle_graph_distributions.js.
 def(VM_OP.RANDOM, "RANDOM", true);
 
+// The scene's wind at a world position, metres per second: three lanes of position in, three lanes
+// of velocity out, read from a resource the host binds rather than computed from the operands —
+// the published wind field on the GPU (`../vm/chunk_particle_vm_wind_field.js`), a host function on
+// the CPU (`../vm/ParticleVMReference.js`). Shaped like `CROSS`: three lanes, or four with a zero
+// `w`, and never fewer, so `min_width` is a floor.
+def(VM_OP.SAMPLE_WIND, "SAMPLE_WIND", true, R, _, _, { default_width: 3, min_width: 3 });
+
 // --- packing an instruction ---------------------------------------------------------------------
 
 /**

package/src/shade/renderer/particles/optimizer/particle_program_equivalence.d.ts

@@ -117,12 +117,13 @@ export function diff_particle_programs(before: ParticleProgram, after: ParticleP
  * The contexts a program is compared in. Seeds differ so a pass that dropped or added a draw shows
  * up as a diverging RNG state rather than only as a diverging record.
  *
- * @type {Array<{name: string, builtins: number[][], rng_state: number, record: () => Uint32Array}>}
+ * @type {Array<{name: string, builtins: number[][], rng_state: number, record: () => Uint32Array, sample_wind: import("../vm/ParticleVMReference.js").ParticleVMWindSampler}>}
  */
 export const PARTICLE_ENVIRONMENTS: Array<{
     name: string;
     builtins: number[][];
     rng_state: number;
     record: () => Uint32Array;
+    sample_wind: import("../vm/ParticleVMReference.js").ParticleVMWindSampler;
 }>;
 //# sourceMappingURL=particle_program_equivalence.d.ts.map

package/src/shade/renderer/particles/optimizer/particle_program_equivalence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_program_equivalence.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_equivalence.js"],"names":[],"mappings":"AA2GA;;;;;;;;;GASG;AACH;IAN+B,KAAK,EAAzB,WAAW;IACmB,SAAS,EAAvC,YAAY,GAAC,MAAM,EAAE;IACN,cAAc,EAA7B,MAAM;IACS,WAAW,EAA1B,MAAM;IACJ;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAevE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+CAHW,WAAW,GACT;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAC,CAkEjD;AAqCD;;;;;;;;;;;;;;GAcG;AACH,qDAVW;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,SACzD;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC;IAErC,SAAS,GAA7B,MAAM;IACkD,KAAK,GAA7D;QAAC,MAAM,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAC,GAAC,IAAI;IAIxC,MAAM,GAAC,IAAI,CAuCvB;AAED;;;;;;;;;;;;;;GAcG;AACH;IARkG,MAAM,EAA7F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACS,KAAK,EAA5F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACvD,YAAY,GAAnC,MAAM,MAAM,CAAC;IACG,UAAU,GAA1B,MAAM;IAGJ,MAAM,GAAC,IAAI,CAqBvB;AAED;;;;;;;GAOG;AACH,qGAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAmBvB;AArRD;;;;;GAKG;AACH,oCAFU,MAAM;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,WAAW,CAAA;CAAC,CAAC,CAOjG"}
+{"version":3,"file":"particle_program_equivalence.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_equivalence.js"],"names":[],"mappings":"AAgIA;;;;;;;;;GASG;AACH;IAN+B,KAAK,EAAzB,WAAW;IACmB,SAAS,EAAvC,YAAY,GAAC,MAAM,EAAE;IACN,cAAc,EAA7B,MAAM;IACS,WAAW,EAA1B,MAAM;IACJ;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAgBvE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+CAHW,WAAW,GACT;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAC,CAkEjD;AAqCD;;;;;;;;;;;;;;GAcG;AACH,qDAVW;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,SACzD;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC;IAErC,SAAS,GAA7B,MAAM;IACkD,KAAK,GAA7D;QAAC,MAAM,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAC,GAAC,IAAI;IAIxC,MAAM,GAAC,IAAI,CAuCvB;AAED;;;;;;;;;;;;;;GAcG;AACH;IARkG,MAAM,EAA7F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACS,KAAK,EAA5F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACvD,YAAY,GAAnC,MAAM,MAAM,CAAC;IACG,UAAU,GAA1B,MAAM;IAGJ,MAAM,GAAC,IAAI,CAqBvB;AAED;;;;;;;GAOG;AACH,qGAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAmBvB;AAtRD;;;;;GAKG;AACH,oCAFU,MAAM;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,WAAW,CAAC;IAAC,WAAW,EAAE,OAAO,8BAA8B,EAAE,qBAAqB,CAAA;CAAC,CAAC,CAO5K"}

package/src/shade/renderer/particles/optimizer/particle_program_equivalence.js

@@ -56,7 +56,7 @@ import { PARTICLE_ZERO_ABSORBING_OPS } from "./pass_fold_constants.js";
  *
  * ## Environments
  *
- * A program reads more than its constants — record words, builtins, the RNG — and a
+ * A program reads more than its constants — record words, builtins, the RNG, the wind — and a
  * pass that mishandled any of those could still agree on a single run. {@link PARTICLE_ENVIRONMENTS}
  * varies all of them, including a record pre-filled with values a `LOAD_ATTR` can pick up.
  */
@@ -92,17 +92,38 @@ function seeded_record() {
     return record;
 }
 
+/**
+ * A wind that varies with where it is read, so a `SAMPLE_WIND` a pass moved onto another position —
+ * or onto the right position read through the wrong swizzle — lands on another velocity. Pure, as the
+ * published field is within one run: the same point is the same wind, which is what sharing two
+ * samples rests on.
+ *
+ * @type {import("../vm/ParticleVMReference.js").ParticleVMWindSampler}
+ */
+const WIND_A = (out, x, y, z) => {
+    out[0] = 0.5 * y + 1.25;
+    out[1] = z - x;
+    out[2] = -0.75 * x;
+};
+
+/** A second wind, unlike the first in every lane. @type {import("../vm/ParticleVMReference.js").ParticleVMWindSampler} */
+const WIND_B = (out, x, y, z) => {
+    out[0] = 3 * Math.sin(x);
+    out[1] = 0.25 - y * z;
+    out[2] = x + y;
+};
+
 /**
  * The contexts a program is compared in. Seeds differ so a pass that dropped or added a draw shows
  * up as a diverging RNG state rather than only as a diverging record.
  *
- * @type {Array<{name: string, builtins: number[][], rng_state: number, record: () => Uint32Array}>}
+ * @type {Array<{name: string, builtins: number[][], rng_state: number, record: () => Uint32Array, sample_wind: import("../vm/ParticleVMReference.js").ParticleVMWindSampler}>}
  */
 export const PARTICLE_ENVIRONMENTS = [
-    { name: "zeroed record, seed 1", builtins: BUILTINS_A, rng_state: 1, record: () => new Uint32Array(PARTICLE_RECORD_WORD_COUNT) },
-    { name: "seeded record, seed 1", builtins: BUILTINS_A, rng_state: 1, record: seeded_record },
-    { name: "seeded record, seed 0x9e3779b9", builtins: BUILTINS_B, rng_state: 0x9e3779b9, record: seeded_record },
-    { name: "seeded record, seed 12345", builtins: BUILTINS_B, rng_state: 12345, record: seeded_record },
+    { name: "zeroed record, seed 1", builtins: BUILTINS_A, rng_state: 1, record: () => new Uint32Array(PARTICLE_RECORD_WORD_COUNT), sample_wind: WIND_A },
+    { name: "seeded record, seed 1", builtins: BUILTINS_A, rng_state: 1, record: seeded_record, sample_wind: WIND_A },
+    { name: "seeded record, seed 0x9e3779b9", builtins: BUILTINS_B, rng_state: 0x9e3779b9, record: seeded_record, sample_wind: WIND_B },
+    { name: "seeded record, seed 12345", builtins: BUILTINS_B, rng_state: 12345, record: seeded_record, sample_wind: WIND_B },
 ];
 
 /**
@@ -125,6 +146,7 @@ export function run_particle_section({ words, constants, register_count, environ
         record,
         builtins: environment.builtins,
         rng_state: environment.rng_state,
+        sample_wind: environment.sample_wind ?? null,
     });
 
     return { record, killed: result.killed, rng_state: result.rng_state };

package/src/shade/renderer/particles/optimizer/particle_program_fuzz.js

@@ -42,7 +42,7 @@ const FUZZ_OPS = [
     VM_OP.DOT, VM_OP.CROSS, VM_OP.LENGTH, VM_OP.NORMALIZE, VM_OP.DISTANCE,
     VM_OP.CMP_LT, VM_OP.CMP_LE, VM_OP.CMP_GT, VM_OP.CMP_GE, VM_OP.CMP_EQ,
     VM_OP.SELECT, VM_OP.RANDOM, VM_OP.LOAD_CONST, VM_OP.LOAD_ATTR, VM_OP.LOAD_BUILTIN,
-    VM_OP.NOP,
+    VM_OP.SAMPLE_WIND, VM_OP.NOP,
 ];
 
 /** Values the folding pass has rules about, mixed in with arbitrary ones. */

package/src/shade/renderer/particles/optimizer/particle_vm_semantics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_vm_semantics.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_vm_semantics.js"],"names":[],"mappings":"AAkJA;;;;;;GAMG;AACH,oCAHW,MAAM,GACJ,mBAAmB,CAW/B;AAhKD;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,+CAA+C;AAC/C,2BADW,IAAI,MAAM,EAAE,mBAAmB,CAAC,CACL;;;;;;;kBA1BxB,OAAO;;;;;cAGP,OAAO;;;;;;gBAEP,OAAO;;;;;;eAGP,OAAO;;;;;;;;cAGP,OAAO;;;;;;;;;;sBAKP,OAAO"}
+{"version":3,"file":"particle_vm_semantics.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_vm_semantics.js"],"names":[],"mappings":"AAyJA;;;;;;GAMG;AACH,oCAHW,MAAM,GACJ,mBAAmB,CAW/B;AAvKD;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,+CAA+C;AAC/C,2BADW,IAAI,MAAM,EAAE,mBAAmB,CAAC,CACL;;;;;;;kBA1BxB,OAAO;;;;;cAGP,OAAO;;;;;;gBAEP,OAAO;;;;;;eAGP,OAAO;;;;;;;;cAGP,OAAO;;;;;;;;;;sBAKP,OAAO"}

package/src/shade/renderer/particles/optimizer/particle_vm_semantics.js

@@ -143,6 +143,13 @@ semantics(VM_OP.SELECT, EXACT);
 // Ordered and side-effecting: it advances the shared RNG, and its width IS the number of draws it
 // takes. Removing, duplicating, reordering or narrowing one moves every value drawn after it.
 semantics(VM_OP.RANDOM, { side_effects: true });
+// A pure read of a resource the host binds, and that is all it is. No side effects, so a dead one
+// goes. Within one run of a program the field does not change, so two at the same position are one
+// sample and the second may read the first's register — `CROSS`'s answers, for `CROSS`'s shape:
+// the lanes depend on all three of the position's, so not lanewise, and the zero fourth lane is the
+// only narrowing, which `min_width` floors at three. Never foldable: what the field holds is not
+// known when the program is compiled, so there is no constant to bake.
+semantics(VM_OP.SAMPLE_WIND, { narrowable: true, shareable: true });
 
 /**
  * What may be assumed about an opcode. An unknown one is assumed to do everything, so a new opcode

package/src/shade/renderer/particles/runtime/ParticleEmitter.d.ts

@@ -202,8 +202,8 @@ export class ParticleEmitter {
     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/shade/renderer/particles/runtime/ParticleEmitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleEmitter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/ParticleEmitter.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,sCAFU,MAAM,EAAE,CAIf;AAEH;;;;;;;;;;;;GAYG;AACH;QAFiB,MAAM,GAAE,MAAM;EAS5B;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH;IAiSI;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH;QAfwE,MAAM,EAAnE,OAAO,6BAA6B,EAAE,cAAc;QAEQ,OAAO,EAAnE,OAAO,2BAA2B,EAAE,eAAe;QAExB,QAAQ,GAAnC,UAAU,MAAM,CAAC;QACI,OAAO,GAA5B,MAAM,GAAC,IAAI;QACK,IAAI,GAApB,MAAM;QACU,UAAU,GAA1B,MAAM;QACU,OAAO,GAAvB,MAAM;QACU,KAAK,GAArB,MAAM;QACyB,MAAM;gBAA9B,MAAM,GAAC,MAAM;;QACO,QAAQ,GAAnC,UAAU,MAAM,CAAC;QACD,IAAI,GAApB,MAAM;QACJ,eAAe,CA+C3B;IApWD;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAUV;;OAEG;IACH,sBAEC;IAED;;;;OAIG;IACH,gCAIC;IAED;;;;;OAKG;IACH,QAFU,OAAO,6BAA6B,EAAE,cAAc,CAEvD;IAEP;;;;;OAKG;IACH,SAFU,OAAO,2BAA2B,EAAE,eAAe,CAErD;IAER;;;;;;;;;;;OAWG;IACH,SAFU,MAAM,GAAC,IAAI,CAEN;IAEf;;;;;;;;OAQG;IACH,MAFU,MAAM,CAEP;IAET;;;;OAIG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;OAIG;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,mBAEC;IAED;;;;;;;;;;;;OAYG;IACH;YAHkB,MAAM,GAAC,MAAM;aA2B9B;IAED;;;;;;;;;;OAUG;IACH,cAHW,eAAe,GACb,OAAO,CAsBnB;IAED;;;;;;OAMG;IACH,QAFa,MAAM,CAsBlB;IAED;;;;;;;;;;;OAWG;IACH,YAFW,eAAe,QA6BzB;IAED;;;;OAIG;IACH,SAFa,eAAe,CAQ3B;IAyEL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C"}
+{"version":3,"file":"ParticleEmitter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/ParticleEmitter.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,sCAFU,MAAM,EAAE,CAIf;AAEH;;;;;;;;;;;;GAYG;AACH;QAFiB,MAAM,GAAE,MAAM;EAS5B;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH;IAiSI;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH;QAfwE,MAAM,EAAnE,OAAO,6BAA6B,EAAE,cAAc;QAEQ,OAAO,EAAnE,OAAO,2BAA2B,EAAE,eAAe;QAExB,QAAQ,GAAnC,UAAU,MAAM,CAAC;QACI,OAAO,GAA5B,MAAM,GAAC,IAAI;QACK,IAAI,GAApB,MAAM;QACU,UAAU,GAA1B,MAAM;QACU,OAAO,GAAvB,MAAM;QACU,KAAK,GAArB,MAAM;QACyB,MAAM;gBAA9B,MAAM,GAAC,MAAM;;QACO,QAAQ,GAAnC,UAAU,MAAM,CAAC;QACD,IAAI,GAApB,MAAM;QACJ,eAAe,CA+C3B;IApWD;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAUV;;OAEG;IACH,sBAEC;IAED;;;;OAIG;IACH,gCAIC;IAED;;;;;OAKG;IACH,QAFU,OAAO,6BAA6B,EAAE,cAAc,CAEvD;IAEP;;;;;OAKG;IACH,SAFU,OAAO,2BAA2B,EAAE,eAAe,CAErD;IAER;;;;;;;;;;;OAWG;IACH,SAFU,MAAM,GAAC,IAAI,CAEN;IAEf;;;;;;;;OAQG;IACH,MAFU,MAAM,CAEP;IAET;;;;OAIG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;OAIG;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,mBAEC;IAED;;;;;;;;;;;;OAYG;IACH;YAHkB,MAAM,GAAC,MAAM;aA2B9B;IAED;;;;;;;;;;OAUG;IACH,cAHW,eAAe,GACb,OAAO,CAsBnB;IAED;;;;;;OAMG;IACH,QAFa,MAAM,CAsBlB;IAED;;;;;;;;;;;OAWG;IACH,YAFW,eAAe,QA6BzB;IAED;;;;OAIG;IACH,SAFa,eAAe,CAQ3B;IAyEL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C"}