@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/material/standard/SHADING_MATERIAL_RESOURCE_GROUP.js

@@ -1,7 +1,31 @@
 import { GPUShaderStage } from "../../../descriptor/GPUShaderStage.js";
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
 import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
 import { MATERIAL_METADATA_STRUCT } from "../MATERIAL_METADATA_STRUCT.js";
 
+/**
+ * The standard material's uniform.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MATERIAL_INFO_RESOURCE = ShaderResourceDescriptor.uniform("material_info", MATERIAL_METADATA_STRUCT);
+
+/** @type {ShaderResourceDescriptor} */
+export const MATERIAL_DIFFUSE_TEXTURE_RESOURCE = ShaderResourceDescriptor.texture("texture_diffuse", "float");
+/** @type {ShaderResourceDescriptor} */
+export const MATERIAL_DIFFUSE_SAMPLER_RESOURCE = ShaderResourceDescriptor.sampler("texture_diffuse_sampler");
+/** @type {ShaderResourceDescriptor} */
+export const MATERIAL_NORMAL_TEXTURE_RESOURCE = ShaderResourceDescriptor.texture("texture_normal", "float");
+/** @type {ShaderResourceDescriptor} */
+export const MATERIAL_NORMAL_SAMPLER_RESOURCE = ShaderResourceDescriptor.sampler("texture_normal_sampler");
+/** @type {ShaderResourceDescriptor} */
+export const MATERIAL_ORM_TEXTURE_RESOURCE = ShaderResourceDescriptor.texture("texture_orm", "float");
+/** @type {ShaderResourceDescriptor} */
+export const MATERIAL_ORM_SAMPLER_RESOURCE = ShaderResourceDescriptor.sampler("texture_orm_sampler");
+/** @type {ShaderResourceDescriptor} */
+export const MATERIAL_EMISSIVE_TEXTURE_RESOURCE = ShaderResourceDescriptor.texture("texture_emissive", "float");
+/** @type {ShaderResourceDescriptor} */
+export const MATERIAL_EMISSIVE_SAMPLER_RESOURCE = ShaderResourceDescriptor.sampler("texture_emissive_sampler");
+
 /**
  * Group 0 of the standard material template: its uniform and its four textures.
  *
@@ -16,14 +40,14 @@ export const SHADING_MATERIAL_RESOURCE_GROUP = new ShaderResourceGroupDescriptor
 
 SHADING_MATERIAL_RESOURCE_GROUP.label = "Material";
 
-SHADING_MATERIAL_RESOURCE_GROUP.addUniform("material_info", MATERIAL_METADATA_STRUCT)
-    .addTexture("texture_diffuse", "float")
-    .addSampler("texture_diffuse_sampler")
-    .addTexture("texture_normal", "float")
-    .addSampler("texture_normal_sampler")
-    .addTexture("texture_orm", "float")
-    .addSampler("texture_orm_sampler")
-    .addTexture("texture_emissive", "float")
-    .addSampler("texture_emissive_sampler")
+SHADING_MATERIAL_RESOURCE_GROUP.add(MATERIAL_INFO_RESOURCE)
+    .add(MATERIAL_DIFFUSE_TEXTURE_RESOURCE)
+    .add(MATERIAL_DIFFUSE_SAMPLER_RESOURCE)
+    .add(MATERIAL_NORMAL_TEXTURE_RESOURCE)
+    .add(MATERIAL_NORMAL_SAMPLER_RESOURCE)
+    .add(MATERIAL_ORM_TEXTURE_RESOURCE)
+    .add(MATERIAL_ORM_SAMPLER_RESOURCE)
+    .add(MATERIAL_EMISSIVE_TEXTURE_RESOURCE)
+    .add(MATERIAL_EMISSIVE_SAMPLER_RESOURCE)
 
 SHADING_MATERIAL_RESOURCE_GROUP.addVisibility(GPUShaderStage.FRAGMENT);

package/src/shade/renderer/particles/DESIGN.md

@@ -156,6 +156,12 @@ wide-register variants bind nine, which is the one place the system spends past
 still inside the ten the engine demands of an adapter. `particle_shaders_wgsl_validity.spec` pins
 the count for every pass.
 
+Every pass that runs the VM — emit, simulate, their wide variants and the warm-up's advance — also
+binds the scene's published wind field (`../wind/`, `GPUSceneWind.bind`, per frame): one uniform, one
+3-D texture and a sampler, and no storage buffer, so it costs none of the eight. It is bound with or
+without a producer; with none it reads still air. `graph_particles_wind.spec` holds every one of
+those passes to it.
+
 ### The VM (`ParticleVM`)
 
 Register machine, emulator-safe (bounded instruction loop + big `switch`, no subgroup ops, no
@@ -182,6 +188,12 @@ recursion, no data-dependent jumps — conditionals are predicated via CMP/SELEC
 - Builtins (`LOAD_BUILTIN`): DT, EMITTER_AGE, EMITTER_POSITION, EMITTER_DIRECTION, EMITTER_UP,
   PARTICLE_INDEX, SPAWN_FRACTION, TIME … assembled per-invocation by the host shader. The emitter's
   position and axes are its node's `global` out of the scene database.
+- `SAMPLE_WIND dst, position` (GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §13): the scene's wind at a
+  world position, m/s — three lanes in, three out (a fourth, if asked for, is zero). The one opcode
+  that reads a resource the host binds: the interpreter calls `particle_vm_sample_wind`, which every
+  particle host defines over the published wind field (`vm/chunk_particle_vm_wind_field.js`), and the
+  JS reference calls its `sample_wind` host function — still air when a host passes none. To the
+  optimizer it is a pure read: removable, shareable within a run, narrowable to three, never folded.
 
 #### Two interpreters
 
@@ -230,8 +242,9 @@ A core `NodeGraph` holds particle nodes (ports + parameters) for INIT and UPDATE
 
 Standard node library: constants, attribute get/set, arithmetic/vector/math, random (uniform/sphere/
 disk/cone), authored curves and RGB/RGBA gradients, noise (curl), integrate, gravity, emit-shapes,
-compare/select, kill-if. Curves and gradients expand into graph nodes that emit ordinary VM
-arithmetic; no animation-table binding or sampling opcode is needed.
+compare/select, kill-if, and `wind` (a world position in, the scene's wind there out: `SAMPLE_WIND`).
+Curves and gradients expand into graph nodes that emit ordinary VM arithmetic; no animation-table
+binding or sampling opcode is needed.
 
 ### Emitters run at entities' rows
 
@@ -730,6 +743,7 @@ src/shade/renderer/particles/
   vm/chunk_particle_vm.js            WGSL interpreter CodeChunk (parity target)
   vm/chunk_particle_vm_registers_fast.js  register file in var<private> — the interpreter that runs
   vm/chunk_particle_vm_registers_wide.js  register file in storage — the fallback
+  vm/chunk_particle_vm_wind_field.js  the VM's wind read, off the scene's published wind field
   shaders/chunk_particle_simulate_step.js one particle's simulate, shared by both simulate shaders
   shaders/chunk_particle_emit_step.js     one newborn's emit, shared by both emit shaders
   graph/ParticleNodeDescription.js   node type base (ports + lowering)

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

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

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

@@ -498,6 +498,9 @@ export class GPUParticleSystem {
             graph,
             camera,
             scene_database,
+            // The scene's wind, which every VM pass binds for `SAMPLE_WIND`. The scene context always
+            // has one; nothing here knows or asks what produces it.
+            wind: this.scene_context.wind,
             gpu: buffers,
             emitters,
             capacity: this.capacity,

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

@@ -1 +1 @@
-{"version":3,"file":"ParticleNodeRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleNodeRegistry.js"],"names":[],"mappings":"AA+qBA;;;;;;;GAOG;AACH,8CAFa,uBAAuB,EAAE,CAIrC;AAED;;;;;GAKG;AACH,oDAJW,MAAM,GACJ,uBAAuB,CAWnC;AA1qBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;GASG;AACH,kCAFU,QAAQ,CAE2C;AAE7D;;;GAGG;AACH,wCAFU,MAAM,CAE+B;AAE/C;;GAEG;AACH,qCAFU,YAAY,CAEmC;wCAhEjB,8BAA8B;yBAZ7C,oDAAoD;6BAFhD,wDAAwD"}
+{"version":3,"file":"ParticleNodeRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleNodeRegistry.js"],"names":[],"mappings":"AA2rBA;;;;;;;GAOG;AACH,8CAFa,uBAAuB,EAAE,CAIrC;AAED;;;;;GAKG;AACH,oDAJW,MAAM,GACJ,uBAAuB,CAWnC;AAtrBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;GASG;AACH,kCAFU,QAAQ,CAE2C;AAE7D;;;GAGG;AACH,wCAFU,MAAM,CAE+B;AAE/C;;GAEG;AACH,qCAFU,YAAY,CAEmC;wCAhEjB,8BAA8B;yBAZ7C,oDAAoD;6BAFhD,wDAAwD"}

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

@@ -90,14 +90,14 @@ for (const type of PARTICLE_ALL_VALUE_TYPES) {
  *
  * IDs are handed out in declaration order rather than by {@link NodeDescription}'s global counter,
  * so they do not drift with unrelated node usage elsewhere in the engine. Appending new node types
- * at the end of the library is therefore safe. Removed types leave their IDs unused so existing
- * serialized graphs retain the same IDs for every remaining type.
+ * at the end of the library is therefore safe. Removed types leave their IDs unused so existing
+ * serialized graphs retain the same IDs for every remaining type.
  *
  * @type {Map<string, ParticleNodeDescription>}
  */
-const descriptions_by_name = new Map();
-
-let next_description_id = 0;
+const descriptions_by_name = new Map();
+
+let next_description_id = 0;
 
 /**
  * @param {string} name
@@ -125,7 +125,7 @@ function define(name, inputs, emit, {
     const description = new ParticleNodeDescription();
 
     description.name = name;
-    description.id = next_description_id++;
+    description.id = next_description_id++;
 
     // what an author reads is decided in one table, away from the lowering; see
     // ./particle_node_presentation.js
@@ -574,8 +574,8 @@ define("compare", ["a", "b"], (s, c) => {
 }, MASK_RESULT);
 define("select", ["a", "b", "condition"], (s, c) => s.emit(VM_OP.SELECT, c.out, c.in("a"), c.in("b"), c.in("condition"), c.width), blend_controlled_by("condition"));
 
-// ID 39 belonged to the removed animation-table sampler. Keep it unused.
-next_description_id++;
+// ID 39 belonged to the removed animation-table sampler. Keep it unused.
+next_description_id++;
 
 // --- semantic sources ---
 // Appended rather than filed with the other sources, because a node type's id is its position in
@@ -661,7 +661,7 @@ function expanding(name, inputs, output, body) {
     return description;
 }
 
-// One authored curve, written into the program as arithmetic.
+// One authored curve, written into the program as arithmetic.
 expanding(
     "curveLiteral",
     [{ name: "t", type: PARTICLE_TYPE_F32 }],
@@ -685,6 +685,18 @@ expanding(
     (g, parameters) => roll_out_particle_gradient(g, g.in.t, parameters.stops, PARTICLE_TYPE_VEC3.components)
 );
 
+// --- the scene ---
+// Appended, for the reason `color` is: an id is a position in this file.
+//
+// The scene's wind at a world position, m/s: `SAMPLE_WIND`, which reads the field the host binds — on
+// the GPU the scene's published wind, still air when nothing produces any. Three lanes in and three
+// out whatever arrives, like `cross`. What an effect does with it is the effect's business: drift the
+// position by it, relax the velocity toward it, lean a flame.
+define("wind", ["position"], (s, c) => s.emit(VM_OP.SAMPLE_WIND, c.out, c.in("position"), 0, 0, c.width), {
+    infer_types: () => ({ output: PARTICLE_TYPE_VEC3, inputs: { position: PARTICLE_TYPE_VEC3 } }),
+    operation_width: () => 3,
+});
+
 /**
  * Every node type in the library, in declaration order.
  *

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/shaders/shader_particle_avboit_draw.js

@@ -25,7 +25,7 @@ import { chunk_particle_lighting } from "./chunk_particle_lighting.js";
 /**
  * The particles' AVBOIT draw: the billboard quads at internal resolution, depth-tested against the
  * opaque scene, into the four accumulators the transparent meshes draw into
- * (`avboit_draw_fragment_body`). The particle counterpart of `shader_avboit_draw_ibl`.
+ * (`avboit_draw_fragment_body`). The particle counterpart of `shader_avboit_draw`.
  *
  * Per fragment: the atlas sample times the particle colour, the soft-depth fade against the scene
  * depth, lighting for an emitter flagged `EMITTER_FLAG.LIGHTING` (`chunk_particle_lighting`: the

package/src/shade/renderer/particles/shaders/shader_particle_emit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,kDAA8E;AAE9E;;;;;;;;GAQG;AACH,4BAFU,YAAY,CAOK;AA2D3B,iDAIG;6BAhH0B,mCAAmC;8BAIlC,+BAA+B"}
+{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,kDAA8E;AAE9E;;;;;;;;GAQG;AACH,4BAFU,YAAY,CAOK;AA4D3B,iDAIG;6BAnH0B,mCAAmC;8BAIlC,+BAA+B"}

package/src/shade/renderer/particles/shaders/shader_particle_emit.js

@@ -9,6 +9,8 @@ import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
 import { chunk_particle_vm_registers_fast } from "../vm/chunk_particle_vm_registers_fast.js";
+import { chunk_particle_vm_wind_field } from "../vm/chunk_particle_vm_wind_field.js";
+import { wind_field_add_resources } from "../../wind/wind_field_add_resources.js";
 import { chunk_particle_emit_step } from "./chunk_particle_emit_step.js";
 
 /**
@@ -55,7 +57,7 @@ const resources = new ShaderResourceSetDescriptor();
 
 resources.setImmediate('settings', EMIT_SETTINGS);
 
-resources.createGroup()
+wind_field_add_resources(resources.createGroup()
     .addStorageBuffer("scene_database", WebGPUArray.u32, false)
     .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
     .addStorageBuffer("program", WebGPUArray.u32, false)
@@ -63,7 +65,7 @@ resources.createGroup()
     .addStorageBuffer("pool", WebGPUArray.u32, true)
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true));
 
 const body = CodeChunk.from(
     /* language=wgsl */
@@ -106,6 +108,7 @@ fn main(
     chunk_grid3d_to_index,
     chunk_particle_emit_step,
     chunk_particle_vm_registers_fast,
+    chunk_particle_vm_wind_field,
 ]);
 
 export const shader_particle_emit = ComputeShader.from({

package/src/shade/renderer/particles/shaders/shader_particle_emit_wide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_emit_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit_wide.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;GAIG;AACH,iDAFU,MAAM,CAGiD;AAgEjE,sDAIG;8BA5G2B,+BAA+B"}
+{"version":3,"file":"shader_particle_emit_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit_wide.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;GAIG;AACH,iDAFU,MAAM,CAGiD;AAiEjE,sDAIG;8BA/G2B,+BAA+B"}