@woosh/meep-engine 3.49.0 → 3.50.0

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

@@ -7,6 +7,8 @@ import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourc
 import { PARTICLE_VM_WIDE_LAUNCH_LANES } from "../ParticleConstants.js";
 import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
 import { chunk_particle_vm_registers_wide } from "../vm/chunk_particle_vm_registers_wide.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";
 import { EMIT_SETTINGS, PARTICLE_EMIT_WORKGROUP_SIZE } from "./shader_particle_emit.js";
 
@@ -47,7 +49,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)
@@ -56,7 +58,7 @@ resources.createGroup()
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
     .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
-    .addStorageBuffer("vm_registers", WebGPUArray.from(f32), true);
+    .addStorageBuffer("vm_registers", WebGPUArray.from(f32), true));
 
 const body = CodeChunk.from(
     /* language=wgsl */
@@ -103,6 +105,7 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
 `, [
     chunk_particle_emit_step,
     chunk_particle_vm_registers_wide,
+    chunk_particle_vm_wind_field,
 ]);
 
 export const shader_particle_emit_wide = ComputeShader.from({

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

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_simulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate.js"],"names":[],"mappings":";AAuDA;;;;;GAKG;AACH,gCAFU,YAAY,CAMS;AAsD/B,qDAIG;iDApH8C,yBAAyB;6BAJ7C,mCAAmC;8BAClC,+BAA+B"}
+{"version":3,"file":"shader_particle_simulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate.js"],"names":[],"mappings":";AAyDA;;;;;GAKG;AACH,gCAFU,YAAY,CAMS;AAuD/B,qDAIG;iDAvH8C,yBAAyB;6BAJ7C,mCAAmC;8BAClC,+BAA+B"}

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

@@ -8,6 +8,8 @@ import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourc
 import { PARTICLE_SIMULATE_WORKGROUP_SIZE } from "../ParticleConstants.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_simulate_step } from "./chunk_particle_simulate_step.js";
 
 /**
@@ -69,7 +71,7 @@ const resources = new ShaderResourceSetDescriptor();
 
 resources.setImmediate('settings', SIMULATE_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)
@@ -77,7 +79,7 @@ resources.createGroup()
     .addStorageBuffer("sim_list", WebGPUArray.u32, false)
     .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 */ `
@@ -113,6 +115,7 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
 `, [
     chunk_particle_simulate_step,
     chunk_particle_vm_registers_fast,
+    chunk_particle_vm_wind_field,
 ]);
 
 body.addExtension(WebGPUExtensionType.Subgroups);

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

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_simulate_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate_wide.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;GAGG;AACH,qDAFU,MAAM,CAGqD;AA6DrE,0DAIG;8BArH2B,+BAA+B"}
+{"version":3,"file":"shader_particle_simulate_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate_wide.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;GAGG;AACH,qDAFU,MAAM,CAGqD;AA8DrE,0DAIG;8BAxH2B,+BAA+B"}

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

@@ -7,6 +7,8 @@ import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourc
 import { PARTICLE_SIMULATE_WORKGROUP_SIZE, PARTICLE_VM_WIDE_LAUNCH_LANES } from "../ParticleConstants.js";
 import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
 import { chunk_particle_vm_registers_wide } from "../vm/chunk_particle_vm_registers_wide.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_simulate_step } from "./chunk_particle_simulate_step.js";
 import { SIMULATE_SETTINGS } from "./shader_particle_simulate.js";
 
@@ -59,7 +61,7 @@ const resources = new ShaderResourceSetDescriptor();
 
 resources.setImmediate('settings', SIMULATE_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)
@@ -68,7 +70,7 @@ resources.createGroup()
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
     .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
-    .addStorageBuffer("vm_registers", WebGPUArray.from(f32), true);
+    .addStorageBuffer("vm_registers", WebGPUArray.from(f32), true));
 
 
 const body = CodeChunk.from(/* language=wgsl */ `
@@ -110,6 +112,7 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
 `, [
     chunk_particle_simulate_step,
     chunk_particle_vm_registers_wide,
+    chunk_particle_vm_wind_field,
 ]);
 
 body.addExtension(WebGPUExtensionType.Subgroups);

package/src/shade/renderer/particles/vm/ParticleVMReference.d.ts

@@ -49,17 +49,32 @@ export function u32_to_unit_f32(u: number): number;
  * @param {Uint32Array} params.record particle record words (mutated in place); attributes are f32 bits
  * @param {number[][]} [params.builtins] builtin values indexed by {@link VM_BUILTIN} id, each a 4-array
  * @param {number} [params.rng_state] initial RNG state (u32)
+ * @param {ParticleVMWindSampler|null} [params.sample_wind] how `SAMPLE_WIND` is answered; still air
+ *   when left out
  * @returns {{ killed: boolean, rng_state: number }}
  */
-export function execute_particle_vm({ words, constants, register_count, record, builtins, rng_state, }: {
+export function execute_particle_vm({ words, constants, register_count, record, builtins, rng_state, sample_wind, }: {
     words: Uint32Array;
     constants: Float32Array;
     register_count: number;
     record: Uint32Array;
     builtins?: number[][];
     rng_state?: number;
+    sample_wind?: ParticleVMWindSampler | null;
 }): {
     killed: boolean;
     rng_state: number;
 };
+/**
+ * How a CPU host answers `SAMPLE_WIND`: the wind at a world position, metres per second, written into
+ * `out[0]`, `out[1]` and `out[2]`.
+ *
+ * The opcode reads a resource the host binds, and on the GPU that is the scene's published wind field
+ * (`./chunk_particle_vm_wind_field.js`). A CPU host has no field to read; it answers what it can — a
+ * far field it was handed, typically — and a host that answers nothing reads still air. Called once
+ * per executed `SAMPLE_WIND`, with `out` a scratch of the executor's own that holds zeros on entry, so
+ * a sampler that writes nothing answers zero. It must not allocate: the editor's preview runs it for
+ * every live particle every frame.
+ */
+export type ParticleVMWindSampler = (out: Float32Array, x: number, y: number, z: number) => void;
 //# sourceMappingURL=ParticleVMReference.d.ts.map

package/src/shade/renderer/particles/vm/ParticleVMReference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleVMReference.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/vm/ParticleVMReference.js"],"names":[],"mappings":"AA4BA;;;;;;;GAOG;AACH,gCAHW,MAAM,GACJ;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAW5C;AAED;;;;;GAKG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AA8DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IAR+B,KAAK,EAAzB,WAAW;IACU,SAAS,EAA9B,YAAY;IACG,cAAc,EAA7B,MAAM;IACc,MAAM,EAA1B,WAAW;IACS,QAAQ,GAA5B,MAAM,EAAE,EAAE;IACM,SAAS,GAAzB,MAAM;IACJ;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAuVlD"}
+{"version":3,"file":"ParticleVMReference.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/vm/ParticleVMReference.js"],"names":[],"mappings":"AA4BA;;;;;;;GAOG;AACH,gCAHW,MAAM,GACJ;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAW5C;AAED;;;;;GAKG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAiFD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IAV+B,KAAK,EAAzB,WAAW;IACU,SAAS,EAA9B,YAAY;IACG,cAAc,EAA7B,MAAM;IACc,MAAM,EAA1B,WAAW;IACS,QAAQ,GAA5B,MAAM,EAAE,EAAE;IACM,SAAS,GAAzB,MAAM;IAC8B,WAAW,GAA/C,qBAAqB,GAAC,IAAI;IAExB;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAmWlD;;;;;;;;;;;;0CAlZU,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACJ,IAAI"}

package/src/shade/renderer/particles/vm/ParticleVMReference.js

@@ -89,8 +89,8 @@ for (const [op, meta] of VM_ISA) {
 const {
     ABS, ACOS, ADD, ASIN, ATAN2, CLAMP, CMP_EQ, CMP_GE, CMP_GT, CMP_LE, CMP_LT, COS, CROSS,
     DISTANCE, DIV, DOT, EXP, FLOOR, FRACT, HALT, KILL, LENGTH, LOAD_ATTR, LOAD_BUILTIN, LOAD_CONST,
-    LOG, MAD, MAX, MIN, MIX, MOV, MUL, NEG, NOP, NORMALIZE, POW, RANDOM, RSQRT, SELECT, SIN,
-    SMOOTHSTEP, SQRT, STEP, STORE_ATTR, SUB, TAN,
+    LOG, MAD, MAX, MIN, MIX, MOV, MUL, NEG, NOP, NORMALIZE, POW, RANDOM, RSQRT, SAMPLE_WIND, SELECT,
+    SIN, SMOOTHSTEP, SQRT, STEP, STORE_ATTR, SUB, TAN,
 } = VM_OP;
 const KIND_REG = VM_KIND.REG;
 const KIND_IMM = VM_KIND.IMM;
@@ -109,6 +109,25 @@ const INSTRUCTION_WORDS = PARTICLE_VM_INSTRUCTION_WORDS;
 const MAX_INSTRUCTIONS = PARTICLE_VM_MAX_INSTRUCTIONS;
 const MAX_WIDTH = VM_MAX_WIDTH;
 
+/**
+ * How a CPU host answers `SAMPLE_WIND`: the wind at a world position, metres per second, written into
+ * `out[0]`, `out[1]` and `out[2]`.
+ *
+ * The opcode reads a resource the host binds, and on the GPU that is the scene's published wind field
+ * (`./chunk_particle_vm_wind_field.js`). A CPU host has no field to read; it answers what it can — a
+ * far field it was handed, typically — and a host that answers nothing reads still air. Called once
+ * per executed `SAMPLE_WIND`, with `out` a scratch of the executor's own that holds zeros on entry, so
+ * a sampler that writes nothing answers zero. It must not allocate: the editor's preview runs it for
+ * every live particle every frame.
+ *
+ * @callback ParticleVMWindSampler
+ * @param {Float32Array} out where the three lanes go
+ * @param {number} x world position
+ * @param {number} y
+ * @param {number} z
+ * @returns {void}
+ */
+
 /** Scratch for reading a literal's bits as the `f32` they are. */
 const LITERAL_F32 = new Float32Array(1);
 
@@ -147,6 +166,8 @@ const LITERAL_U32 = new Uint32Array(LITERAL_F32.buffer);
  * @param {Uint32Array} params.record particle record words (mutated in place); attributes are f32 bits
  * @param {number[][]} [params.builtins] builtin values indexed by {@link VM_BUILTIN} id, each a 4-array
  * @param {number} [params.rng_state] initial RNG state (u32)
+ * @param {ParticleVMWindSampler|null} [params.sample_wind] how `SAMPLE_WIND` is answered; still air
+ *   when left out
  * @returns {{ killed: boolean, rng_state: number }}
  */
 export function execute_particle_vm({
@@ -156,6 +177,7 @@ export function execute_particle_vm({
     record,
     builtins = [],
     rng_state = 0,
+    sample_wind = null,
 }) {
     // Register file: one f32 per slot. A value of width w occupies w consecutive slots.
     const reg = new Float32Array(register_count);
@@ -477,6 +499,17 @@ export function execute_particle_vm({
                 for (let i = 0; i < w; i++) d[i] = draw_unit();
                 break;
 
+            // A read of what the host binds, at the position the first source names; `CROSS`'s
+            // shape, so a fourth lane, if asked for, is zero. The result goes through `d`, an
+            // `f32` scratch, so a host answering in f64 is rounded as the register file would.
+            case SAMPLE_WIND:
+                d[0] = 0;
+                d[1] = 0;
+                d[2] = 0;
+                if (sample_wind !== null) sample_wind(d, a[0], a[1], a[2]);
+                d[3] = 0;
+                break;
+
             default:
                 throw new Error(`ParticleVMReference: unhandled opcode ${op} at pc ${pc}`);
         }

package/src/shade/renderer/particles/vm/chunk_particle_vm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_particle_vm.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/vm/chunk_particle_vm.js"],"names":[],"mappings":"AA0UA;;;GAGG;AACH,gCAFU,SAAS,CAEmG;0BA7U5F,oCAAoC"}
+{"version":3,"file":"chunk_particle_vm.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/vm/chunk_particle_vm.js"],"names":[],"mappings":"AAkVA;;;GAGG;AACH,gCAFU,SAAS,CAEmG;0BArV5F,oCAAoC"}

package/src/shade/renderer/particles/vm/chunk_particle_vm.js

@@ -114,6 +114,11 @@ import { PARTICLE_VM_CONTEXT_STRUCT } from "./PARTICLE_VM_CONTEXT_STRUCT.js";
  *
  * - The enclosing shader must include exactly one register backing chunk — see above. Nothing in
  *   here declares `vm_reg_read` / `vm_reg_write`.
+ * - It must also define `particle_vm_sample_wind(position_ws : vec3<f32>) -> vec3<f32>`, which
+ *   `SAMPLE_WIND` calls: the wind at a world position, m/s. Every particle host includes
+ *   {@link ./chunk_particle_vm_wind_field.js}, which reads the scene's published wind field; a spec
+ *   running the interpreter on its own defines a stub. The same seam as the register backing: the
+ *   opcode is the VM's, what it reads is the host's.
  * - Kill flag and the builtin context are module-scope `var<private>`, as is the shared `rnd_state`
  *   the RNG runs on. Call `particle_vm_reset()` at the start of each particle, seed `rnd_state`, and
  *   populate `vm_ctx` before invoking {@link particle_vm_execute}.
@@ -317,6 +322,9 @@ fn particle_vm_execute(
                 if (w > 3u) { d.w = random(); }
             }
 
+            // The host's wind at the position in \`a\`, m/s; \`CROSS\`'s shape, a fourth lane zero.
+            case ${VM_OP.SAMPLE_WIND}u: { d = vec4<f32>(particle_vm_sample_wind(a.xyz), 0.0); }
+
             default: { lanes = 0u; }
         }
 

package/src/shade/renderer/particles/vm/chunk_particle_vm_wind_field.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The particle VM's wind: `particle_vm_sample_wind(position_ws) -> vec3<f32>`, metres per second at a
+ * world position, read from the scene's published wind field (`../../wind/`,
+ * GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §11, §13).
+ *
+ * The interpreter ({@link ./chunk_particle_vm.js}) names the function and does not define it, the way
+ * it names `vm_reg_read` and leaves the register file to a backing chunk: what a wind read IS belongs
+ * to the host, and every particle host includes this one — emit, simulate, their wide variants and the
+ * warm-up's advance. A spec that runs the interpreter on its own supplies a stub in its place.
+ *
+ * The host declares the field's bindings with `wind_field_add_resources` and fills them with
+ * `GPUSceneWind.bind`, per frame. One uniform, one 3-D texture and a sampler, and no storage buffer,
+ * so a host sitting at the storage-buffer floor pays nothing there for the wind. With no producer the
+ * field is still air, and this answers zero.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_particle_vm_wind_field: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_particle_vm_wind_field.d.ts.map

package/src/shade/renderer/particles/vm/chunk_particle_vm_wind_field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_particle_vm_wind_field.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/vm/chunk_particle_vm_wind_field.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,SAAS,CAMW;0BAxBJ,oCAAoC"}

package/src/shade/renderer/particles/vm/chunk_particle_vm_wind_field.js

@@ -0,0 +1,25 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_wind_field_sample } from "../../wind/chunk_wind_field_sample.js";
+
+/**
+ * The particle VM's wind: `particle_vm_sample_wind(position_ws) -> vec3<f32>`, metres per second at a
+ * world position, read from the scene's published wind field (`../../wind/`,
+ * GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §11, §13).
+ *
+ * The interpreter ({@link ./chunk_particle_vm.js}) names the function and does not define it, the way
+ * it names `vm_reg_read` and leaves the register file to a backing chunk: what a wind read IS belongs
+ * to the host, and every particle host includes this one — emit, simulate, their wide variants and the
+ * warm-up's advance. A spec that runs the interpreter on its own supplies a stub in its place.
+ *
+ * The host declares the field's bindings with `wind_field_add_resources` and fills them with
+ * `GPUSceneWind.bind`, per frame. One uniform, one 3-D texture and a sampler, and no storage buffer,
+ * so a host sitting at the storage-buffer floor pays nothing there for the wind. With no producer the
+ * field is still air, and this answers zero.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_particle_vm_wind_field = CodeChunk.from(/* language=wgsl */ `
+fn particle_vm_sample_wind(position_ws : vec3<f32>) -> vec3<f32> {
+    return wind_field_sample(position_ws);
+}
+`, [chunk_wind_field_sample]);

package/src/shade/renderer/particles/warmup/graph_particle_warmup.d.ts

@@ -50,6 +50,8 @@
  * @param {object} params
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
  * @param {number} params.scene_database graph handle
+ * @param {import("../../wind/GPUSceneWind.js").GPUSceneWind} params.wind the scene's wind field, which
+ *   the emit and the advance bind as the main passes do: a warmed particle reads the wind as it is now
  * @param {number} params.emitter_database graph handle, threaded: the warm-up tick writes ages
  * @param {number} params.program graph handle of the packed program buffer
  * @param {number} params.pool main pool, threaded
@@ -70,9 +72,10 @@
  * @param {number} params.frame.index
  * @returns {{pool: number, alive_out: number, dead: number, counters: number, emitter_database: number, vm_registers: number}}
  */
-export function graph_particle_warmup({ graph, scene_database, emitter_database, program, pool, alive_out, dead, counters, vm_registers, queue, queue_count, warm_capacity, capacity, emitter_capacity, schedule, wide_registers, frame, }: {
+export function graph_particle_warmup({ graph, scene_database, wind, emitter_database, program, pool, alive_out, dead, counters, vm_registers, queue, queue_count, warm_capacity, capacity, emitter_capacity, schedule, wide_registers, frame, }: {
     graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
     scene_database: number;
+    wind: import("../../wind/GPUSceneWind.js").GPUSceneWind;
     emitter_database: number;
     program: number;
     pool: number;

package/src/shade/renderer/particles/warmup/graph_particle_warmup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_particle_warmup.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/warmup/graph_particle_warmup.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH;IAtBqG,KAAK,EAA/F,OAAO,8DAA8D,EAAE,UAAU;IAClE,cAAc,EAA7B,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,OAAO,EAAtB,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,SAAS,EAAxB,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IAEY,KAAK;IACR,WAAW,EAA1B,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACgD,QAAQ,EAA9D,OAAO,sBAAsB,EAAE,cAAc;IAC7B,cAAc,EAA9B,OAAO;IACQ,KAAK;QACC,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;;IACJ;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC,CAuO7H"}
+{"version":3,"file":"graph_particle_warmup.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/warmup/graph_particle_warmup.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH;IAxBqG,KAAK,EAA/F,OAAO,8DAA8D,EAAE,UAAU;IAClE,cAAc,EAA7B,MAAM;IACoD,IAAI,EAA9D,OAAO,4BAA4B,EAAE,YAAY;IAElC,gBAAgB,EAA/B,MAAM;IACS,OAAO,EAAtB,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,SAAS,EAAxB,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IAEY,KAAK;IACR,WAAW,EAA1B,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACgD,QAAQ,EAA9D,OAAO,sBAAsB,EAAE,cAAc;IAC7B,cAAc,EAA9B,OAAO;IACQ,KAAK;QACC,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;;IACJ;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC,CA6O7H"}

package/src/shade/renderer/particles/warmup/graph_particle_warmup.js

@@ -82,6 +82,8 @@ import { warmup_remaining } from "./warmup_schedule.js";
  * @param {object} params
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
  * @param {number} params.scene_database graph handle
+ * @param {import("../../wind/GPUSceneWind.js").GPUSceneWind} params.wind the scene's wind field, which
+ *   the emit and the advance bind as the main passes do: a warmed particle reads the wind as it is now
  * @param {number} params.emitter_database graph handle, threaded: the warm-up tick writes ages
  * @param {number} params.program graph handle of the packed program buffer
  * @param {number} params.pool main pool, threaded
@@ -105,6 +107,7 @@ import { warmup_remaining } from "./warmup_schedule.js";
 export function graph_particle_warmup({
                                           graph,
                                           scene_database,
+                                          wind,
                                           emitter_database,
                                           program,
                                           pool,
@@ -122,6 +125,7 @@ export function graph_particle_warmup({
                                           frame,
                                       }) {
     assert.defined(graph, "graph");
+    assert.defined(wind, "wind");
     assert.isPositiveInteger(queue_count, "queue_count");
     assert.isPositiveInteger(warm_capacity, "warm_capacity");
     assert.isPositiveInteger(schedule.ticks, "schedule.ticks");
@@ -251,6 +255,8 @@ export function graph_particle_warmup({
                 settings: { u_dt: schedule.dt, u_time: time, u_frame: frame_index, u_capacity: warm_capacity },
             };
 
+            wind.bind(bindings);
+
             const out = wide_registers
                 ? graph_compute_pass({
                     graph,
@@ -283,6 +289,8 @@ export function graph_particle_warmup({
                 settings: { u_dt: schedule.dt, u_time: time, u_frame: frame_index },
             };
 
+            wind.bind(bindings);
+
             const out = wide_registers
                 ? graph_compute_pass({
                     graph,

package/src/shade/renderer/particles/warmup/shader_particle_warmup_advance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_warmup_advance.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/warmup/shader_particle_warmup_advance.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH,sCAFU,YAAY,CAMc;AAgBpC;;;;GAIG;AACH,kCAFU,MAAM,CA6Bd;AAEF,2DAcG;;6BArG0B,mCAAmC;8BAClC,+BAA+B;gDAOb,6BAA6B"}
+{"version":3,"file":"shader_particle_warmup_advance.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/warmup/shader_particle_warmup_advance.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH,sCAFU,YAAY,CAMc;AAgBpC;;;;GAIG;AACH,kCAFU,MAAM,CA6Bd;AAEF,2DAeG;;6BAxG0B,mCAAmC;8BAClC,+BAA+B;gDASb,6BAA6B"}

package/src/shade/renderer/particles/warmup/shader_particle_warmup_advance.js

@@ -1,106 +1,109 @@
-import { atomic_u32, f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { PARTICLE_WARMUP_LAUNCH_LANES, PARTICLE_WARMUP_WORKGROUP_SIZE } from "../ParticleConstants.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_warmup_step } from "./chunk_particle_warmup_step.js";
-import { PARTICLE_WARMUP_WORKGROUP_COUNT } from "./shader_particle_warmup.js";
-
-/**
- * The warm-up's advance pass over the fast register file: one warm-up tick of UPDATE over every
- * particle the previous tick left alive, compacting survivors into the next alive list and the dead
- * onto the transient free list.
- *
- * What the main simulate pass is to a frame, this is to a warm-up tick, and it is a shader of its
- * own rather than that pass bound to other buffers for the reasons `./chunk_particle_warmup_step.js`
- * gives: it reads the alive list directly, so it decodes per lane, and it jitters the tick per
- * particle. Nothing about it is linked into the main passes.
- *
- * A bounded launch with a grid-stride loop over the transient alive count — the wide interpreter's
- * shape — so no indirect-args pass is needed per tick and the loop's passes are all sized by
- * constants. `alive_in` is the list the previous tick built (or the emit pass of this one appended
- * to, on the pass before); `alive_out` is the other of the pair.
- *
- * @type {ComputeShader}
- */
-
-/**
- * Per-dispatch, 12 bytes, read-only. The same three numbers the main simulate takes, as a struct of
- * this pass's own rather than that pass's export: the two must be free to diverge.
- * @type {WebGPUStruct}
- */
-export const WARMUP_ADVANCE_SETTINGS = WebGPUStruct.from({
-    u_dt: f32,
-    u_time: f32,
-    u_frame: u32,
-}, "ParticleWarmupAdvanceSettings");
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.setImmediate("settings", WARMUP_ADVANCE_SETTINGS);
-
-resources.createGroup()
-    .addStorageBuffer("scene_database", WebGPUArray.u32, false)
-    .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
-    .addStorageBuffer("program", WebGPUArray.u32, false)
-    .addStorageBuffer("pool", WebGPUArray.u32, true)
-    .addStorageBuffer("alive_in", WebGPUArray.u32, false)
-    .addStorageBuffer("alive_out", WebGPUArray.u32, true)
-    .addStorageBuffer("dead", WebGPUArray.u32, true)
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
-
-/**
- * The entry point both register backings share, as WGSL text: the wide variant prepends its
- * register bind and is otherwise this.
- * @type {string}
- */
-export const WARMUP_ADVANCE_BODY = /* language=wgsl */ `
-const COUNTER_ALIVE : u32 = ${PARTICLE_COUNTER.ALIVE}u;
-const COUNTER_DEAD : u32 = ${PARTICLE_COUNTER.DEAD}u;
-const COUNTER_ALIVE_IN : u32 = ${PARTICLE_COUNTER.ALIVE_IN}u;
-const WARMUP_LAUNCH_LANES : u32 = ${PARTICLE_WARMUP_LAUNCH_LANES}u;
-
-fn particle_warmup_advance_all(lane : u32) {
-    let total = atomicLoad(&counters[COUNTER_ALIVE_IN]);
-
-    for (var i = lane; i < total; i = i + WARMUP_LAUNCH_LANES) {
-        let slot = alive_in[i];
-
-        let survived = particle_warmup_advance_one(
-            &scene_database, &emitter_database, &program, &pool,
-            slot,
-            settings.u_dt, settings.u_time, settings.u_frame,
-        );
-
-        if (survived) {
-            let a = atomicAdd(&counters[COUNTER_ALIVE], 1u);
-            alive_out[a] = slot;
-        } else {
-            let d = atomicAdd(&counters[COUNTER_DEAD], 1u);
-            dead[d] = slot;
-        }
-    }
-}
-`;
-
-export const shader_particle_warmup_advance = ComputeShader.from({
-    label: "Particle Warm-up Advance",
-    resources,
-    body: CodeChunk.from(/* language=wgsl */ `
-${WARMUP_ADVANCE_BODY}
-
-@compute @workgroup_size(${PARTICLE_WARMUP_WORKGROUP_SIZE}, 1, 1)
-fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
-    particle_warmup_advance_all(gid.x);
-}
-`, [
-        chunk_particle_warmup_step,
-        chunk_particle_vm_registers_fast,
-    ]),
-});
-
-export { PARTICLE_WARMUP_WORKGROUP_COUNT };
+import { atomic_u32, f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { PARTICLE_WARMUP_LAUNCH_LANES, PARTICLE_WARMUP_WORKGROUP_SIZE } from "../ParticleConstants.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_warmup_step } from "./chunk_particle_warmup_step.js";
+import { PARTICLE_WARMUP_WORKGROUP_COUNT } from "./shader_particle_warmup.js";
+
+/**
+ * The warm-up's advance pass over the fast register file: one warm-up tick of UPDATE over every
+ * particle the previous tick left alive, compacting survivors into the next alive list and the dead
+ * onto the transient free list.
+ *
+ * What the main simulate pass is to a frame, this is to a warm-up tick, and it is a shader of its
+ * own rather than that pass bound to other buffers for the reasons `./chunk_particle_warmup_step.js`
+ * gives: it reads the alive list directly, so it decodes per lane, and it jitters the tick per
+ * particle. Nothing about it is linked into the main passes.
+ *
+ * A bounded launch with a grid-stride loop over the transient alive count — the wide interpreter's
+ * shape — so no indirect-args pass is needed per tick and the loop's passes are all sized by
+ * constants. `alive_in` is the list the previous tick built (or the emit pass of this one appended
+ * to, on the pass before); `alive_out` is the other of the pair.
+ *
+ * @type {ComputeShader}
+ */
+
+/**
+ * Per-dispatch, 12 bytes, read-only. The same three numbers the main simulate takes, as a struct of
+ * this pass's own rather than that pass's export: the two must be free to diverge.
+ * @type {WebGPUStruct}
+ */
+export const WARMUP_ADVANCE_SETTINGS = WebGPUStruct.from({
+    u_dt: f32,
+    u_time: f32,
+    u_frame: u32,
+}, "ParticleWarmupAdvanceSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", WARMUP_ADVANCE_SETTINGS);
+
+wind_field_add_resources(resources.createGroup()
+    .addStorageBuffer("scene_database", WebGPUArray.u32, false)
+    .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
+    .addStorageBuffer("program", WebGPUArray.u32, false)
+    .addStorageBuffer("pool", WebGPUArray.u32, true)
+    .addStorageBuffer("alive_in", WebGPUArray.u32, false)
+    .addStorageBuffer("alive_out", WebGPUArray.u32, true)
+    .addStorageBuffer("dead", WebGPUArray.u32, true)
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true));
+
+/**
+ * The entry point both register backings share, as WGSL text: the wide variant prepends its
+ * register bind and is otherwise this.
+ * @type {string}
+ */
+export const WARMUP_ADVANCE_BODY = /* language=wgsl */ `
+const COUNTER_ALIVE : u32 = ${PARTICLE_COUNTER.ALIVE}u;
+const COUNTER_DEAD : u32 = ${PARTICLE_COUNTER.DEAD}u;
+const COUNTER_ALIVE_IN : u32 = ${PARTICLE_COUNTER.ALIVE_IN}u;
+const WARMUP_LAUNCH_LANES : u32 = ${PARTICLE_WARMUP_LAUNCH_LANES}u;
+
+fn particle_warmup_advance_all(lane : u32) {
+    let total = atomicLoad(&counters[COUNTER_ALIVE_IN]);
+
+    for (var i = lane; i < total; i = i + WARMUP_LAUNCH_LANES) {
+        let slot = alive_in[i];
+
+        let survived = particle_warmup_advance_one(
+            &scene_database, &emitter_database, &program, &pool,
+            slot,
+            settings.u_dt, settings.u_time, settings.u_frame,
+        );
+
+        if (survived) {
+            let a = atomicAdd(&counters[COUNTER_ALIVE], 1u);
+            alive_out[a] = slot;
+        } else {
+            let d = atomicAdd(&counters[COUNTER_DEAD], 1u);
+            dead[d] = slot;
+        }
+    }
+}
+`;
+
+export const shader_particle_warmup_advance = ComputeShader.from({
+    label: "Particle Warm-up Advance",
+    resources,
+    body: CodeChunk.from(/* language=wgsl */ `
+${WARMUP_ADVANCE_BODY}
+
+@compute @workgroup_size(${PARTICLE_WARMUP_WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    particle_warmup_advance_all(gid.x);
+}
+`, [
+        chunk_particle_warmup_step,
+        chunk_particle_vm_registers_fast,
+        chunk_particle_vm_wind_field,
+    ]),
+});
+
+export { PARTICLE_WARMUP_WORKGROUP_COUNT };

package/src/shade/renderer/particles/warmup/shader_particle_warmup_advance_wide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_warmup_advance_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/warmup/shader_particle_warmup_advance_wide.js"],"names":[],"mappings":"AAiDA,gEAkBG;8BAhE2B,+BAA+B"}
+{"version":3,"file":"shader_particle_warmup_advance_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/warmup/shader_particle_warmup_advance_wide.js"],"names":[],"mappings":"AAmDA,gEAmBG;8BAnE2B,+BAA+B"}