@woosh/meep-engine 3.14.6 → 3.16.0

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

@@ -0,0 +1,107 @@
+/**
+ * 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, }: {
+    graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    camera: number;
+    cluster_parameters: ArrayLike<number>;
+    occupancy: number;
+    scene_database: number;
+    emitter_database: number;
+    emitter_group_count: number;
+}): number;
+/**
+ * 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, }: {
+    graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    camera: number;
+    warp: number;
+    volume: {
+        extinction: number;
+        overflow: number;
+        dummy: number;
+    };
+    atlas: GPUTextureView;
+    atlas_sampler: GPUSampler;
+    pool: number;
+    alive: number;
+    emitter_database: number;
+    draw_args: number;
+}): {
+    extinction: number;
+    overflow: number;
+    dummy: number;
+};
+/**
+ * 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, }: {
+    graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    view_ctx: import("../view/GPUViewContext.js").GPUViewContext;
+    camera: number;
+    depth_texture: number;
+    warp: number;
+    integral: number;
+    volumetrics_lut: number;
+    volumetrics_metadata: number;
+    accumulators: {
+        color: number;
+        norm: number;
+        extinction: number;
+        emission: number;
+    };
+    atlas: GPUTextureView;
+    atlas_sampler: GPUSampler;
+    pool: number;
+    alive: number;
+    emitter_database: number;
+    draw_args: number;
+}): {
+    color: number;
+    norm: number;
+    extinction: number;
+    emission: number;
+};
+//# sourceMappingURL=graph_particles_avboit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph_particles_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_avboit.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;GAYG;AACH;IATkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACoB,kBAAkB,EAA5C,UAAU,MAAM,CAAC;IACF,SAAS,EAAxB,MAAM;IACS,cAAc,EAA7B,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,mBAAmB,EAAlC,MAAM;IACJ,MAAM,CAiDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAZkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,IAAI,EAAnB,MAAM;IACwD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IAC9B,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA8EjE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAjBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IACnB,QAAQ,EAAnE,OAAO,2BAA2B,EAAE,cAAc;IACnC,MAAM,EAArB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IACsE,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IAC5C,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAoG/E"}

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

@@ -0,0 +1,312 @@
+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 renderer needs is not run for this path.
+ */
+
+/** 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/isa/InstructionStream.d.ts

@@ -14,34 +14,61 @@ export class InstructionStream {
      * 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.
      *
+     * `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} [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, s1?: number, s2?: number, width?: number): InstructionStream;
     /**
      * @param {number} dst
      * @param {number} src
+     * @param {number} [width]
      * @returns {InstructionStream}
      */
-    mov(dst: number, src: number): InstructionStream;
+    mov(dst: number, src: number, width?: number): InstructionStream;
+    /**
+     * Widen a single-lane value into `width` lanes.
+     *
+     * A `SWIZZLE` whose every selector names lane 0 — no opcode of its own, because that is exactly
+     * what one is. The compiler emits these where a narrow value meets a wider operation, which is
+     * the broadcast the reductions and `CURVE` used to do implicitly by filling all four lanes.
+     *
+     * @param {number} dst
+     * @param {number} src
+     * @param {number} width
+     * @returns {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;
     /**
+     * The width is the component count and cannot differ from it: a store writes exactly the lanes
+     * the register holds.
+     *
      * @param {number} src_register
      * @param {number} word_offset
      * @param {number} component_count
@@ -51,27 +78,33 @@ export class 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
      * @returns {InstructionStream}
      */
     kill(condition_register: 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} [width]
      * @returns {InstructionStream}
      */
-    curve(dst: number, curve_handle: number, t_register: number): InstructionStream;
+    curve(dst: number, curve_handle: number, t_register: 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":"AAwBA;;;;;;GAMG;AACH;IACI,yBAAyB;IACzB,cADW,MAAM,EAAE,EAAE,CACH;IAClB,iEAAiE;IACjE,gBADW,MAAM,CACE;IAqBnB;;;;;;;;;;;;;;;OAeG;IACH,SARW,MAAM,QACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CA+B7B;IAID;;;;;OAKG;IACH,SALW,MAAM,OACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;;;;;;;OAWG;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,wBALW,MAAM,eACN,MAAM,mBACN,MAAM,GACJ,iBAAiB,CAK7B;IAED;;;;;OAKG;IACH,iBALW,MAAM,cACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;OAGG;IACH,yBAHW,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;;;;OAQG;IACH,YAJW,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;;OAMG;IACH,WANW,MAAM,gBACN,MAAM,cACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;OAEG;IACH,QAFa,iBAAiB,CAI7B;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,WAFa,WAAW,CAWvB;;CACJ"}