@woosh/meep-engine 3.15.0 → 3.17.0

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

@@ -0,0 +1,313 @@
+import { assert } from "../../../core/assert.js";
+import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
+import { TextureViewDescriptor } from "../../descriptor/texture/TextureViewDescriptor.js";
+import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.js";
+import { AVBOIT_OCCUPANCY_SETTINGS_STRUCT } from "../rasterize/native/avboit/shader_avboit_occupancy.js";
+import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../STATIC_GRAPHICS_ENGINE_ASSETS.js";
+import { shader_particle_avboit_occupancy } from "./shaders/shader_particle_avboit_occupancy.js";
+import {
+    PARTICLE_AVBOIT_DRAW_PIPELINE,
+    PARTICLE_AVBOIT_DRAW_RESOURCES,
+} from "./shaders/shader_particle_avboit_draw.js";
+import {
+    PARTICLE_AVBOIT_SPLAT_PIPELINE,
+    PARTICLE_AVBOIT_SPLAT_RESOURCES,
+} from "./shaders/shader_particle_avboit_splat.js";
+
+/**
+ * The particle system's three contributions to the AVBOIT transparency pipeline — the
+ * `AVBOITSideChannel` contract, recorded into the frame graph the way the AVBOIT orchestrator
+ * records its own passes. `GPUParticleSystem` calls these with the handles its simulation produced
+ * this frame and the handles the orchestrator hands it.
+ *
+ * All three consume the alive list and the draw args the simulation left, which is what makes them
+ * GPU-driven: the draws are `drawIndirect` over the GPU's own alive count, and the occupancy walks
+ * the emitter table's pages. Nothing here knows how many particles there are.
+ *
+ * Order does not matter to any of them — the volume and the accumulators are order-independent — so
+ * the depth sort the standalone billboard draw needs is not run for this path, and its buffers are
+ * never made. That is what {@link ParticleRenderMode.AVBOIT} means.
+ */
+
+/** The accumulators' view: one mip, the one the frame draws into. */
+const COLOR_VIEW = TextureViewDescriptor.from({ mipLevelCount: 1, baseMipLevel: 0 });
+
+/** Linear and clamped on every axis — the integral texture's sampler, as the mesh draw binds it. */
+const SAMPLER_LINEAR = SamplerDescriptor.from({ magFilter: "linear" });
+
+/**
+ * Mark the depth slices the emitters' bounds spheres span (`shader_particle_avboit_occupancy`).
+ *
+ * @param {object} params
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {number} params.camera graph handle
+ * @param {ArrayLike<number>} params.cluster_parameters the frame's depth curve
+ * @param {number} params.occupancy graph handle of the occupancy bits, to add to
+ * @param {number} params.scene_database graph handle
+ * @param {number} params.emitter_database graph handle, as the simulation left it
+ * @param {number} params.emitter_group_count workgroups that walk every page group of the emitter table
+ * @returns {number} the occupancy handle after the write
+ */
+export function graph_particle_avboit_occupancy({
+                                                    graph,
+                                                    camera,
+                                                    cluster_parameters,
+                                                    occupancy,
+                                                    scene_database,
+                                                    emitter_database,
+                                                    emitter_group_count,
+                                                }) {
+    assert.isNonNegativeInteger(occupancy, "occupancy");
+    assert.isNonNegativeInteger(emitter_group_count, "emitter_group_count");
+
+    if (emitter_group_count === 0) {
+        // no emitter table pages: no rows to walk, nothing to mark
+        return occupancy;
+    }
+
+    const settings = { cluster_parameters };
+
+    function execute(data, resources, context) {
+        const encoder = context.encoder;
+
+        shader_particle_avboit_occupancy.dispatch({
+            encoder,
+            bindings: {
+                camera: resources.get(data.camera),
+                settings: encoder.allocateTransientValueBuffer(AVBOIT_OCCUPANCY_SETTINGS_STRUCT, settings, GPUBufferUsage.UNIFORM),
+                scene_database: resources.get(data.scene_database),
+                emitter_database: resources.get(data.emitter_database),
+                occupancy: resources.get(data.occupancy),
+            },
+            group_count_x: emitter_group_count,
+            group_count_y: 1,
+            group_count_z: 1,
+        });
+    }
+
+    const pass_data = {};
+    const pass = graph.add("Particle AVBOIT Occupancy", pass_data, execute);
+
+    pass_data.camera = pass.read(camera);
+    pass_data.scene_database = pass.read(scene_database);
+    pass_data.emitter_database = pass.read(emitter_database);
+    pass.read(occupancy);
+    pass_data.occupancy = pass.write(occupancy);
+
+    return pass_data.occupancy;
+}
+
+/**
+ * Splat the live particles' extinction into the voxel volume (`shader_particle_avboit_splat`).
+ *
+ * @param {object} params
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {number} params.camera graph handle
+ * @param {number} params.warp graph handle
+ * @param {{extinction: number, overflow: number, dummy: number}} params.volume the volume, to add to
+ * @param {GPUTextureView} params.atlas
+ * @param {GPUSampler} params.atlas_sampler
+ * @param {number} params.pool graph handle
+ * @param {number} params.alive graph handle of this frame's alive list
+ * @param {number} params.emitter_database graph handle
+ * @param {number} params.draw_args graph handle of the indirect draw args (six vertices, alive instances)
+ * @returns {{extinction: number, overflow: number, dummy: number}} the volume after the write
+ */
+export function graph_particle_avboit_splat({
+                                                graph,
+                                                camera,
+                                                warp,
+                                                depth_texture,
+                                                volume,
+                                                atlas,
+                                                atlas_sampler,
+                                                pool,
+                                                alive,
+                                                emitter_database,
+                                                draw_args,
+                                            }) {
+    assert.defined(volume, "volume");
+    assert.isNonNegativeInteger(warp, "warp");
+    assert.isNonNegativeInteger(depth_texture, "depth_texture");
+
+    function execute(data, resources, context) {
+        const encoder = context.encoder;
+
+        // By name, never by position: the order a shader declares its bindings in is the shader's
+        // business, and a list built here to match it binds a sampler where a texture goes the
+        // moment a binding is inserted anywhere but the end. The device rejects that, and only when
+        // the pass is first encoded on real hardware. See the layout-kind check in the spec.
+        const bindings = PARTICLE_AVBOIT_SPLAT_RESOURCES.generateBindings({
+            camera: resources.get(data.camera),
+            warp: resources.get(data.warp),
+            pool: resources.get(data.pool),
+            draw_list: resources.get(data.alive),
+            emitter_database: resources.get(data.emitter_database),
+            atlas,
+            atlas_sampler,
+            scene_depth: resources.get(data.depth).obtainView(DEFAULT_DEPTH_TEXTURE_VIEW),
+            extinction_volume: resources.get(data.extinction),
+            overflow_slice: resources.get(data.overflow),
+        }, encoder);
+
+        // the dummy target is never written; it only sizes the raster
+        const pass_encoder = encoder.constructRenderPass({
+            label: "Particle AVBOIT Splat",
+            pipeline: PARTICLE_AVBOIT_SPLAT_PIPELINE,
+            bindings,
+            colorAttachments: [{
+                view: resources.get(data.dummy).obtainView(COLOR_VIEW),
+                loadOp: "load",
+                storeOp: "discard",
+            }],
+        });
+
+        pass_encoder.drawIndirect(resources.get(data.draw_args), 0);
+        pass_encoder.end();
+    }
+
+    const pass_data = {};
+    const pass = graph.add("Particle AVBOIT Splat", pass_data, execute);
+
+    pass_data.camera = pass.read(camera);
+    pass_data.warp = pass.read(warp);
+    pass_data.depth = pass.read(depth_texture);
+    pass_data.pool = pass.read(pool);
+    pass_data.alive = pass.read(alive);
+    pass_data.emitter_database = pass.read(emitter_database);
+    pass_data.draw_args = pass.read(draw_args);
+
+    pass.read(volume.extinction);
+    pass_data.extinction = pass.write(volume.extinction);
+    pass.read(volume.overflow);
+    pass_data.overflow = pass.write(volume.overflow);
+    pass.read(volume.dummy);
+    pass_data.dummy = pass.write(volume.dummy);
+
+    return {
+        extinction: pass_data.extinction,
+        overflow: pass_data.overflow,
+        dummy: pass_data.dummy,
+    };
+}
+
+/**
+ * Draw the live particles into the four accumulators (`shader_particle_avboit_draw`).
+ *
+ * @param {object} params
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {import("../view/GPUViewContext.js").GPUViewContext} params.view_ctx
+ * @param {number} params.camera graph handle
+ * @param {number} params.depth_texture graph handle of the scene depth — tested and sampled, never written
+ * @param {number} params.warp graph handle
+ * @param {number} params.integral graph handle of the integral texture
+ * @param {number} params.volumetrics_lut graph handle
+ * @param {number} params.volumetrics_metadata graph handle
+ * @param {{color: number, norm: number, extinction: number, emission: number}} params.accumulators to add to
+ * @param {GPUTextureView} params.atlas
+ * @param {GPUSampler} params.atlas_sampler
+ * @param {number} params.pool graph handle
+ * @param {number} params.alive graph handle of this frame's alive list
+ * @param {number} params.emitter_database graph handle
+ * @param {number} params.draw_args graph handle of the indirect draw args
+ * @returns {{color: number, norm: number, extinction: number, emission: number}} the accumulators after the draw
+ */
+export function graph_particle_avboit_draw({
+                                               graph,
+                                               view_ctx,
+                                               camera,
+                                               depth_texture,
+                                               warp,
+                                               integral,
+                                               volumetrics_lut,
+                                               volumetrics_metadata,
+                                               accumulators,
+                                               atlas,
+                                               atlas_sampler,
+                                               pool,
+                                               alive,
+                                               emitter_database,
+                                               draw_args,
+                                           }) {
+    assert.defined(accumulators, "accumulators");
+    assert.isNonNegativeInteger(depth_texture, "depth_texture");
+    assert.isNonNegativeInteger(integral, "integral");
+
+    function execute(data, resources, context) {
+        const encoder = context.encoder;
+        const graphics = context.graphics;
+
+        const t_depth = resources.get(data.depth);
+        const depth_view = t_depth.obtainView(DEFAULT_DEPTH_TEXTURE_VIEW);
+
+        // by name rather than by position, for the reason the splat gives
+        const bindings = PARTICLE_AVBOIT_DRAW_RESOURCES.generateBindings({
+            camera: resources.get(data.camera),
+            view: view_ctx.uniform_buffer.buffer,
+            warp: resources.get(data.warp),
+            pool: resources.get(data.pool),
+            draw_list: resources.get(data.alive),
+            emitter_database: resources.get(data.emitter_database),
+            atlas,
+            atlas_sampler,
+            scene_depth: depth_view,
+            tIntegral: resources.get(data.integral).obtainView(),
+            sLinear: graphics.samplers.obtain(SAMPLER_LINEAR),
+            volumetrics_metadata: resources.get(data.volumetrics_metadata),
+            tVolumetrics: resources.get(data.volumetrics_lut).obtainView(),
+            tSTBN_vec3: graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3).obtainView(),
+        }, encoder);
+
+        const attachment = (handle) => ({
+            view: resources.get(handle).obtainView(COLOR_VIEW),
+            loadOp: "load",
+            storeOp: "store",
+        });
+
+        // The scene depth is the test's attachment and the soft fade's texture at once, which is
+        // allowed because the attachment is read-only.
+        const pass_encoder = encoder.constructRenderPass({
+            label: "Particle AVBOIT Draw",
+            pipeline: PARTICLE_AVBOIT_DRAW_PIPELINE,
+            bindings,
+            colorAttachments: [
+                attachment(data.color),
+                attachment(data.norm),
+                attachment(data.extinction),
+                attachment(data.emission),
+            ],
+            depthStencilAttachment: {
+                view: depth_view,
+                depthReadOnly: true,
+            },
+        });
+        pass_encoder.drawIndirect(resources.get(data.draw_args), 0);
+        pass_encoder.end();
+    }
+
+    const pass_data = {};
+    const pass = graph.add("Particle AVBOIT Draw", pass_data, execute);
+
+    pass_data.camera = pass.read(camera);
+    pass_data.depth = pass.read(depth_texture);
+    pass_data.warp = pass.read(warp);
+    pass_data.integral = pass.read(integral);
+    pass_data.volumetrics_lut = pass.read(volumetrics_lut);
+    pass_data.volumetrics_metadata = pass.read(volumetrics_metadata);
+    pass_data.pool = pass.read(pool);
+    pass_data.alive = pass.read(alive);
+    pass_data.emitter_database = pass.read(emitter_database);
+    pass_data.draw_args = pass.read(draw_args);
+
+    for (const name of ["color", "norm", "extinction", "emission"]) {
+        pass.read(accumulators[name]);
+        pass_data[name] = pass.write(accumulators[name]);
+    }
+
+    return {
+        color: pass_data.color,
+        norm: pass_data.norm,
+        extinction: pass_data.extinction,
+        emission: pass_data.emission,
+    };
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Loads the colour target, depth-tests read-only against the scene, and draws
+ * `drawIndirect(draw_args)` instances over `draw_list`.
+ *
+ * @param {object} params
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {number} params.camera graph handle of the camera uniform buffer
+ * @param {number} params.color graph handle of the colour target the billboards draw over
+ * @param {number} params.depth graph handle of the scene depth, tested against and never written
+ * @param {number} params.pool graph handle of the particle pool
+ * @param {number} params.draw_list graph handle of the slot list to draw, in draw order
+ * @param {number} params.emitter_database graph handle
+ * @param {number} params.draw_args graph handle of the indirect draw args: six vertices, one
+ *   instance per live particle, written on-GPU by this frame's build-indirect pass
+ * @param {object} params.render
+ * @param {GPUTextureView} params.render.atlas sprite atlas
+ * @param {GPUSampler} params.render.atlas_sampler
+ * @param {(color_format: string, depth_format: string) => object} params.render.obtain_pipeline
+ *   the billboard pipeline for the frame's attachment formats
+ * @returns {number} the colour handle after the draw
+ */
+export function graph_particles_billboard({ graph, camera, color, depth, pool, draw_list, emitter_database, draw_args, render }: {
+    graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    camera: number;
+    color: number;
+    depth: number;
+    pool: number;
+    draw_list: number;
+    emitter_database: number;
+    draw_args: number;
+    render: {
+        atlas: GPUTextureView;
+        atlas_sampler: GPUSampler;
+        obtain_pipeline: (color_format: string, depth_format: string) => object;
+    };
+}): number;
+//# sourceMappingURL=graph_particles_billboard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph_particles_billboard.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_billboard.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;WAhBW,OAAO,2DAA2D,EAAE,UAAU;YAC9E,MAAM;WACN,MAAM;WACN,MAAM;UACN,MAAM;eACN,MAAM;sBACN,MAAM;eACN,MAAM;;;;wCAKS,MAAM,gBAAgB,MAAM,KAAK,MAAM;;IAEpD,MAAM,CAuDlB"}

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

@@ -0,0 +1,93 @@
+import { TextureViewDescriptor } from "../../descriptor/texture/TextureViewDescriptor.js";
+import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.js";
+import { PARTICLE_BILLBOARD_RESOURCES } from "./shaders/shader_particle_render.js";
+
+/**
+ * The particle system's standalone drawing: one instanced billboard draw over a colour target with
+ * fixed-function blending, for {@link ParticleRenderMode.BILLBOARD}. The renderer's own path draws
+ * through `graph_particles_avboit.js` instead; these two files are the alternatives
+ * {@link GPUParticleSystem#execute} picks between, and both read the handles the simulation left.
+ *
+ * The draw list is a parameter rather than a buffer this file names, because what it must be is a
+ * property of the caller's blend state: premultiplied over-blending is order-dependent, so the
+ * standalone path hands in the back-to-front list `sort/graph_particle_sort.js` produced.
+ */
+
+/** The colour attachment's view: one mip, the one the frame draws into. */
+const COLOR_VIEW = TextureViewDescriptor.from({ mipLevelCount: 1, baseMipLevel: 0 });
+
+/**
+ * Loads the colour target, depth-tests read-only against the scene, and draws
+ * `drawIndirect(draw_args)` instances over `draw_list`.
+ *
+ * @param {object} params
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {number} params.camera graph handle of the camera uniform buffer
+ * @param {number} params.color graph handle of the colour target the billboards draw over
+ * @param {number} params.depth graph handle of the scene depth, tested against and never written
+ * @param {number} params.pool graph handle of the particle pool
+ * @param {number} params.draw_list graph handle of the slot list to draw, in draw order
+ * @param {number} params.emitter_database graph handle
+ * @param {number} params.draw_args graph handle of the indirect draw args: six vertices, one
+ *   instance per live particle, written on-GPU by this frame's build-indirect pass
+ * @param {object} params.render
+ * @param {GPUTextureView} params.render.atlas sprite atlas
+ * @param {GPUSampler} params.render.atlas_sampler
+ * @param {(color_format: string, depth_format: string) => object} params.render.obtain_pipeline
+ *   the billboard pipeline for the frame's attachment formats
+ * @returns {number} the colour handle after the draw
+ */
+export function graph_particles_billboard({ graph, camera, color, depth, pool, draw_list, emitter_database, draw_args, render }) {
+    const data = {};
+
+    const pass = graph.add("Particle Billboard", data, (data, resources, context) => {
+        const encoder = context.encoder;
+
+        const color_texture = resources.get(data.color);
+        const depth_texture = resources.get(data.depth);
+
+        const pipeline = render.obtain_pipeline(color_texture.descriptor.format, depth_texture.descriptor.format);
+
+        // Read by the soft-depth fade and tested against by the pass: the same view, read-only in
+        // both roles.
+        const depth_view = depth_texture.obtainView(DEFAULT_DEPTH_TEXTURE_VIEW);
+
+        const bindings = PARTICLE_BILLBOARD_RESOURCES.generateBindings({
+            camera: resources.get(data.camera),
+            pool: resources.get(data.pool),
+            draw_list: resources.get(data.draw_list),
+            emitter_database: resources.get(data.emitter_database),
+            atlas: render.atlas,
+            atlas_sampler: render.atlas_sampler,
+            scene_depth: depth_view,
+        }, encoder);
+
+        const render_pass = encoder.constructRenderPass({
+            label: "Particle Billboard",
+            pipeline,
+            bindings,
+            colorAttachments: [{
+                view: color_texture.obtainView(COLOR_VIEW),
+                loadOp: "load",
+                storeOp: "store",
+            }],
+            depthStencilAttachment: {
+                view: depth_view,
+                depthReadOnly: true,
+            },
+        });
+
+        render_pass.drawIndirect(resources.get(data.draw_args), 0);
+        render_pass.end();
+    });
+
+    data.camera = pass.read(camera);
+    data.pool = pass.read(pool);
+    data.draw_list = pass.read(draw_list);
+    data.emitter_database = pass.read(emitter_database);
+    data.draw_args = pass.read(draw_args);
+    data.depth = pass.read(depth);
+    data.color = pass.write(pass.read(color));
+
+    return data.color;
+}

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

@@ -6,72 +6,134 @@
  * registers the program touches without a separate pass.
  */
 export class InstructionStream {
-    /** @type {number[][]} */
+    /** @type {number[][]} four words each */
     instructions: number[][];
     /** @type {number} highest register index referenced, plus one */
     register_count: number;
     /**
-     * Emit a raw instruction. Validates the opcode and tracks register usage. Prefer the typed
-     * helpers below where they exist — they document the non-obvious operand packing.
+     * Emit an instruction. Validates the opcode and tracks register usage. Prefer the typed helpers
+     * below where they exist — they document the non-obvious operand packing.
+     *
+     * A source is what its slot's role in the ISA says: for a register-role slot, a register operand
+     * word — a slot index, or `vm_register(slot, pattern)` to read it through a swizzle — or a
+     * literal from `vm_immediate(value)`; for any other role, the raw value (an attribute offset, a
+     * component count, a builtin id, a curve handle, a pool index). The kinds word 0 carries follow
+     * from that, and register operands are stored in their canonical spelling.
+     *
+     * `width` is the lane count the operation spans. Left out, it is the opcode's natural width —
+     * four for the element-wise ops, three for the ones that used to be spelled `.xyz`. Opcodes
+     * whose lane count is fixed ignore it.
      *
      * @param {number} op
-     * @param {number} [dst]
-     * @param {number} [s0]
-     * @param {number} [s1]
-     * @param {number} [s2]
+     * @param {number} [dst] destination register; `0` for an opcode that writes none
+     * @param {number|{kind: number, word: number}} [s0]
+     * @param {number|{kind: number, word: number}} [s1]
+     * @param {number|{kind: number, word: number}} [s2]
+     * @param {number} [width]
      * @returns {InstructionStream} this, for chaining
      */
-    emit(op: number, dst?: number, s0?: number, s1?: number, s2?: number): InstructionStream;
+    emit(op: number, dst?: number, s0?: number | {
+        kind: number;
+        word: number;
+    }, s1?: number | {
+        kind: number;
+        word: number;
+    }, s2?: number | {
+        kind: number;
+        word: number;
+    }, width?: number): InstructionStream;
+    /**
+     * Emit an instruction that is already encoded — the optimizer's way back into a stream, where the
+     * words are re-validated and the register count re-derived from what they touch.
+     *
+     * @param {ArrayLike<number>} words the four words of a single instruction
+     * @returns {InstructionStream} this, for chaining
+     */
+    emitWords(words: ArrayLike<number>): InstructionStream;
+    /**
+     * @param {number} dst
+     * @param {number} src a register operand word
+     * @param {number} [width]
+     * @returns {InstructionStream}
+     */
+    mov(dst: number, src: number, width?: number): InstructionStream;
     /**
+     * Widen a single-lane value into `width` lanes: a copy through the `.xxxx` swizzle. The compiler
+     * emits these where a narrow value meets a wider operation.
+     *
      * @param {number} dst
-     * @param {number} src
+     * @param {number} src register slot
+     * @param {number} width
      * @returns {InstructionStream}
      */
-    mov(dst: number, src: number): InstructionStream;
+    broadcast(dst: number, src: number, width: number): InstructionStream;
     /**
      * @param {number} dst
      * @param {number} constant_index
+     * @param {number} [width]
      * @returns {InstructionStream}
      */
-    loadConst(dst: number, constant_index: number): InstructionStream;
+    loadConst(dst: number, constant_index: number, width?: number): InstructionStream;
     /**
+     * Lanes past `component_count` read as zero, which is how a narrow attribute widens into a
+     * wider operation without a second instruction.
+     *
      * @param {number} dst
      * @param {number} word_offset
      * @param {number} component_count
+     * @param {number} [width] defaults to the component count
      * @returns {InstructionStream}
      */
-    loadAttr(dst: number, word_offset: number, component_count: number): InstructionStream;
+    loadAttr(dst: number, word_offset: number, component_count: number, width?: number): InstructionStream;
     /**
-     * @param {number} src_register
+     * The width is the component count and cannot differ from it: a store writes exactly the lanes
+     * the value holds.
+     *
+     * @param {number|{kind: number, word: number}} source a register operand word or a literal
      * @param {number} word_offset
      * @param {number} component_count
      * @returns {InstructionStream}
      */
-    storeAttr(src_register: number, word_offset: number, component_count: number): InstructionStream;
+    storeAttr(source: number | {
+        kind: number;
+        word: number;
+    }, word_offset: number, component_count: number): InstructionStream;
     /**
      * @param {number} dst
      * @param {number} builtin_id
+     * @param {number} [width]
      * @returns {InstructionStream}
      */
-    loadBuiltin(dst: number, builtin_id: number): InstructionStream;
+    loadBuiltin(dst: number, builtin_id: number, width?: number): InstructionStream;
     /**
-     * @param {number} condition_register
+     * @param {number|{kind: number, word: number}} condition a register operand word or a literal, read one lane
      * @returns {InstructionStream}
      */
-    kill(condition_register: number): InstructionStream;
+    kill(condition: number | {
+        kind: number;
+        word: number;
+    }): InstructionStream;
     /**
+     * One independent uniform draw in `[0, 1)` per lane — so `width` draws off the shared RNG.
+     * Anything shaped (signed, a disk, a sphere) is arithmetic over these; see
+     * {@link ../graph/particle_graph_distributions.js} for the graph-level versions.
+     *
      * @param {number} dst
-     * @param {number} mode
+     * @param {number} [width]
      * @returns {InstructionStream}
      */
-    random(dst: number, mode: number): InstructionStream;
+    random(dst: number, width?: number): InstructionStream;
     /**
      * @param {number} dst
      * @param {number} curve_handle
-     * @param {number} t_register
+     * @param {number|{kind: number, word: number}} t a register operand word or a literal, read one lane
+     * @param {number} [width]
      * @returns {InstructionStream}
      */
-    curve(dst: number, curve_handle: number, t_register: number): InstructionStream;
+    curve(dst: number, curve_handle: number, t: 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":"AAIA;;;;;;GAMG;AACH;IACI,yBAAyB;IACzB,cADW,MAAM,EAAE,EAAE,CACH;IAClB,iEAAiE;IACjE,gBADW,MAAM,CACE;IAUnB;;;;;;;;;;OAUG;IACH,SAPW,MAAM,QACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,iBAAiB,CAsB7B;IAID;;;;OAIG;IACH,SAJW,MAAM,OACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;OAIG;IACH,eAJW,MAAM,kBACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;OAKG;IACH,cALW,MAAM,eACN,MAAM,mBACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;OAKG;IACH,wBALW,MAAM,eACN,MAAM,mBACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;OAIG;IACH,iBAJW,MAAM,cACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;OAGG;IACH,yBAHW,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;OAIG;IACH,YAJW,MAAM,QACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;OAKG;IACH,WALW,MAAM,gBACN,MAAM,cACN,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;;;;;;OAMG;IACH,WANW,MAAM,gBACN,MAAM,KACN,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"}