@woosh/meep-engine 3.60.8 → 3.60.9

package/src/shade/renderer/material/dispatch/MaterialDispatch.js

@@ -0,0 +1,31 @@
+/**
+ * How the G-buffer pass runs each material's shader over that material's pixels of the visibility
+ * buffer. Both run the same laydown from the same shader body; they differ in what launches it.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const MaterialDispatch = Object.freeze({
+    /**
+     * The default, and the main path. A fullscreen triangle per material, masked to the material's
+     * pixels by a depth-equal test against a material-id depth buffer written from the visibility
+     * buffer first — the material-depth trick of [Doghramachi17], and Nanite's without compute
+     * materials. The rasterizer finds each material's pixels, once per material, over the whole
+     * screen.
+     */
+    Quad: 0,
+    /**
+     * **Experimental, off by default, not the main path.** It loses to {@link Quad} on high-end GPUs
+     * at every material count, because each material is its own dispatch; the measurements, and what
+     * would change that, are in `COMPUTE_MATERIAL_DISPATCH.md` beside this file.
+     *
+     * The visibility buffer is classified once into one list of 2×2 pixel quads per material,
+     * ordered by screen tile within each, and each material's shader then runs in compute over its
+     * own list, one indirect dispatch per material — the "material compute dispatch" of DOOM: The
+     * Dark Ages (Lazarek & Hammer, GPC 2025, after [McLaren22]). No pixel of another material is
+     * visited, except a quad's others, which run as a fragment quad's helper lanes would so that the
+     * laydown's one screen-space derivative, the specular anti-aliasing footprint, is the fragment
+     * path's.
+     */
+    Compute: 1,
+});

package/src/shade/renderer/material/dispatch/MaterialDispatchRecords.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @typedef {import("../../binding/BindGroupManager.js").BindGroupManager} BindGroupManager
+ */
+/**
+ * Where the compute material dispatch keeps its per-material records: one
+ * {@link MATERIAL_DISPATCH_RECORD_STRUCT} every {@link MATERIAL_DISPATCH_RECORD_STRIDE} bytes, which
+ * the GPU writes each frame and each material's dispatch then reads twice — as its indirect command,
+ * and as its group 3 — and the bind group over each material's slice.
+ *
+ * Kept across frames, so the bind groups are made once per slot rather than once per frame. Grows to
+ * the longest material list it is asked for and stays there; a record is 256 bytes.
+ */
+export class MaterialDispatchRecords {
+    /**
+     * @param {GPUDevice} device
+     * @param {BindGroupManager} bindings
+     */
+    constructor(device: GPUDevice, bindings: BindGroupManager);
+    /**
+     * @returns {GPUBuffer|null}
+     */
+    get buffer(): any;
+    /**
+     * Make room for `slot_count` records. A larger buffer replaces the old one, which is destroyed,
+     * and the bind groups over it go with it — so reserve before a frame records anything that
+     * names the buffer, never between recording and executing it.
+     *
+     * @param {number} slot_count
+     */
+    reserve(slot_count: number): void;
+    /**
+     * The group 3 of `slot`'s dispatch: its own record, as a uniform.
+     *
+     * @param {number} slot below what {@link reserve} last made room for
+     * @returns {GPUBindGroup}
+     */
+    bind_group(slot: number): GPUBindGroup;
+    destroy(): void;
+    #private;
+}
+export type BindGroupManager = import("../../binding/BindGroupManager.js").BindGroupManager;
+//# sourceMappingURL=MaterialDispatchRecords.d.ts.map

package/src/shade/renderer/material/dispatch/MaterialDispatchRecords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MaterialDispatchRecords.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/MaterialDispatchRecords.js"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;;;;;;;GAQG;AACH;IA4BI;;;OAGG;IACH,yCAFW,gBAAgB,EAK1B;IAED;;OAEG;IACH,kBAEC;IAED;;;;;;OAMG;IACH,oBAFW,MAAM,QA2BhB;IAED;;;;;OAKG;IACH,iBAHW,MAAM,gBAqBhB;IAED,gBAQC;;CACJ;+BA7HY,OAAO,mCAAmC,EAAE,gBAAgB"}

package/src/shade/renderer/material/dispatch/MaterialDispatchRecords.js

@@ -0,0 +1,132 @@
+import { assert } from "../../../../core/assert.js";
+import { BindGroupDescriptor } from "../../binding/BindGroupDescriptor.js";
+import { GBUFFER_COMPUTE_DISPATCH_LAYOUT, MATERIAL_DISPATCH_RECORD_STRUCT } from "./gbuffer_compute.js";
+import { MATERIAL_DISPATCH_RECORD_STRIDE } from "./MATERIAL_DISPATCH_CONSTANTS.js";
+
+/**
+ * @typedef {import("../../binding/BindGroupManager.js").BindGroupManager} BindGroupManager
+ */
+
+/**
+ * Where the compute material dispatch keeps its per-material records: one
+ * {@link MATERIAL_DISPATCH_RECORD_STRUCT} every {@link MATERIAL_DISPATCH_RECORD_STRIDE} bytes, which
+ * the GPU writes each frame and each material's dispatch then reads twice — as its indirect command,
+ * and as its group 3 — and the bind group over each material's slice.
+ *
+ * Kept across frames, so the bind groups are made once per slot rather than once per frame. Grows to
+ * the longest material list it is asked for and stays there; a record is 256 bytes.
+ */
+export class MaterialDispatchRecords {
+    /**
+     * @type {GPUDevice}
+     */
+    #device;
+
+    /**
+     * @type {BindGroupManager}
+     */
+    #bindings;
+
+    /**
+     * @type {GPUBuffer|null}
+     */
+    #buffer = null;
+
+    /**
+     * Records the buffer holds.
+     * @type {number}
+     */
+    #capacity = 0;
+
+    /**
+     * By slot, made on first use over the current buffer.
+     * @type {GPUBindGroup[]}
+     */
+    #bind_groups = [];
+
+    /**
+     * @param {GPUDevice} device
+     * @param {BindGroupManager} bindings
+     */
+    constructor(device, bindings) {
+        this.#device = device;
+        this.#bindings = bindings;
+    }
+
+    /**
+     * @returns {GPUBuffer|null}
+     */
+    get buffer() {
+        return this.#buffer;
+    }
+
+    /**
+     * Make room for `slot_count` records. A larger buffer replaces the old one, which is destroyed,
+     * and the bind groups over it go with it — so reserve before a frame records anything that
+     * names the buffer, never between recording and executing it.
+     *
+     * @param {number} slot_count
+     */
+    reserve(slot_count) {
+        assert.isNonNegativeInteger(slot_count, 'slot_count');
+
+        if (slot_count <= this.#capacity) {
+            return;
+        }
+
+        let capacity = Math.max(1, this.#capacity);
+
+        while (capacity < slot_count) {
+            capacity *= 2;
+        }
+
+        if (this.#buffer !== null) {
+            this.#buffer.destroy();
+        }
+
+        this.#buffer = this.#device.createBuffer({
+            label: "Material dispatch records",
+            size: capacity * MATERIAL_DISPATCH_RECORD_STRIDE,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
+        });
+
+        this.#capacity = capacity;
+        this.#bind_groups.length = 0;
+    }
+
+    /**
+     * The group 3 of `slot`'s dispatch: its own record, as a uniform.
+     *
+     * @param {number} slot below what {@link reserve} last made room for
+     * @returns {GPUBindGroup}
+     */
+    bind_group(slot) {
+        assert.lessThan(slot, this.#capacity, 'slot');
+
+        let group = this.#bind_groups[slot];
+
+        if (group === undefined) {
+            group = this.#bindings.create(BindGroupDescriptor.from(GBUFFER_COMPUTE_DISPATCH_LAYOUT, [
+                {
+                    buffer: this.#buffer,
+                    offset: slot * MATERIAL_DISPATCH_RECORD_STRIDE,
+                    size: MATERIAL_DISPATCH_RECORD_STRUCT.size,
+                }
+            ]));
+
+            this.#bind_groups[slot] = group;
+        }
+
+        return group;
+    }
+
+    destroy() {
+        if (this.#buffer !== null) {
+            this.#buffer.destroy();
+            this.#buffer = null;
+        }
+
+        this.#capacity = 0;
+        this.#bind_groups.length = 0;
+    }
+}

package/src/shade/renderer/material/dispatch/chunk_material_mesh_key.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Which (material, tile) list a mesh of the visibility buffer puts its pixels of `tile` in:
+ *
+ * ```wgsl
+ * fn material_mesh_key(mesh_index: u32, tile: u32, tile_count: u32) -> u32
+ * ```
+ *
+ * `slot * tile_count + tile`, where `slot` is the mesh's material's place in the G-buffer pass's
+ * list, looked up by material id in `material_slots` (a {@link cpu_hash_table_create} table). So the
+ * keys run material by material, tile by tile within each.
+ *
+ * {@link SUBGROUP_KEYED_APPEND_NONE} where no G-buffer material draws the pixel: no mesh there, or
+ * one whose material the pass does not draw — a transparent one, or one without a context yet.
+ *
+ * Reads `scene_database` and `material_slots`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_material_mesh_key: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_material_mesh_key.d.ts.map

package/src/shade/renderer/material/dispatch/chunk_material_mesh_key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_material_mesh_key.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/chunk_material_mesh_key.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;GAiBG;AACH,sCAFU,SAAS,CAuBhB;0BA1CuB,oCAAoC"}

package/src/shade/renderer/material/dispatch/chunk_material_mesh_key.js

@@ -0,0 +1,46 @@
+import { chunk_hash_table_get } from "../../gpu_primitive/hash_table/chunk_hash_table_get.js";
+import { VIZ_BUFFER_INVALID_MESH_VALUE } from "../../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
+import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { SUBGROUP_KEYED_APPEND_NONE } from "../../shader/chunk/subgroup/chunk_subgroup_keyed_append.js";
+
+/**
+ * Which (material, tile) list a mesh of the visibility buffer puts its pixels of `tile` in:
+ *
+ * ```wgsl
+ * fn material_mesh_key(mesh_index: u32, tile: u32, tile_count: u32) -> u32
+ * ```
+ *
+ * `slot * tile_count + tile`, where `slot` is the mesh's material's place in the G-buffer pass's
+ * list, looked up by material id in `material_slots` (a {@link cpu_hash_table_create} table). So the
+ * keys run material by material, tile by tile within each.
+ *
+ * {@link SUBGROUP_KEYED_APPEND_NONE} where no G-buffer material draws the pixel: no mesh there, or
+ * one whose material the pass does not draw — a transparent one, or one without a context yet.
+ *
+ * Reads `scene_database` and `material_slots`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_material_mesh_key = CodeChunk.from(
+    //language=WGSL
+    `
+fn material_mesh_key(mesh_index: u32, tile: u32, tile_count: u32) -> u32 {
+    if (mesh_index == ${VIZ_BUFFER_INVALID_MESH_VALUE}u) {
+        return ${SUBGROUP_KEYED_APPEND_NONE}u;
+    }
+
+    let mesh = scene_read_mesh(&scene_database, mesh_index);
+
+    let slot = hash_table_get(&material_slots, 0u, mesh.material);
+
+    if (slot == 0xFFFFFFFFu) {
+        return ${SUBGROUP_KEYED_APPEND_NONE}u;
+    }
+
+    return slot * tile_count + tile;
+}
+`, [
+    chunk_hash_table_get,
+    chunk_scene_database_access,
+]);

package/src/shade/renderer/material/dispatch/chunk_material_quad_keys.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The classification's read of one 2×2 quad of the visibility buffer.
+ *
+ * ```wgsl
+ * struct MaterialQuadKeys { keys: vec4<u32>, masks: vec4<u32> }
+ * fn material_quad_keys(quad: vec2<u32>, resolution: vec2<u32>, tiles_x: u32, tile_count: u32) -> MaterialQuadKeys
+ * ```
+ *
+ * `material_quad_keys` reads a quad of the visibility buffer and answers its distinct list keys —
+ * see {@link chunk_material_mesh_key} — in `keys.x` to `keys.w`, first to last in corner order, each
+ * with the mask of the corners it holds, as {@link chunk_material_quad_pack} packs it; past the last,
+ * {@link SUBGROUP_KEYED_APPEND_NONE} with an empty mask. A pixel outside `resolution`, or one that
+ * no material draws, is in no list and in no mask. A quad is in one tile, and its pixels are mostly
+ * one mesh, so a key is worked out once per distinct mesh.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_material_quad_keys: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_material_quad_keys.d.ts.map

package/src/shade/renderer/material/dispatch/chunk_material_quad_keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_material_quad_keys.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/chunk_material_quad_keys.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;GAgBG;AACH,uCAFU,SAAS,CAyFhB;0BA5GuB,oCAAoC"}

package/src/shade/renderer/material/dispatch/chunk_material_quad_keys.js

@@ -0,0 +1,111 @@
+import { VIZ_BUFFER_INVALID_MESH_VALUE } from "../../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
+import { SUBGROUP_KEYED_APPEND_NONE } from "../../shader/chunk/subgroup/chunk_subgroup_keyed_append.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_material_mesh_key } from "./chunk_material_mesh_key.js";
+import { MATERIAL_DISPATCH_TILE_SIZE } from "./MATERIAL_DISPATCH_CONSTANTS.js";
+
+/**
+ * The classification's read of one 2×2 quad of the visibility buffer.
+ *
+ * ```wgsl
+ * struct MaterialQuadKeys { keys: vec4<u32>, masks: vec4<u32> }
+ * fn material_quad_keys(quad: vec2<u32>, resolution: vec2<u32>, tiles_x: u32, tile_count: u32) -> MaterialQuadKeys
+ * ```
+ *
+ * `material_quad_keys` reads a quad of the visibility buffer and answers its distinct list keys —
+ * see {@link chunk_material_mesh_key} — in `keys.x` to `keys.w`, first to last in corner order, each
+ * with the mask of the corners it holds, as {@link chunk_material_quad_pack} packs it; past the last,
+ * {@link SUBGROUP_KEYED_APPEND_NONE} with an empty mask. A pixel outside `resolution`, or one that
+ * no material draws, is in no list and in no mask. A quad is in one tile, and its pixels are mostly
+ * one mesh, so a key is worked out once per distinct mesh.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_material_quad_keys = CodeChunk.from(
+    //language=WGSL
+    `
+struct MaterialQuadKeys {
+    keys: vec4<u32>,
+    masks: vec4<u32>,
+}
+
+// the mesh at a corner, or none for a corner off the view
+fn material_quad_mesh(quad: vec2<u32>, corner: vec2<u32>, resolution: vec2<u32>) -> u32 {
+    let pixel = quad * 2u + corner;
+
+    if (any(pixel >= resolution)) {
+        return ${VIZ_BUFFER_INVALID_MESH_VALUE}u;
+    }
+
+    return textureLoad(viz_buffer_mesh, vec2<i32>(pixel), 0).r;
+}
+
+// put a corner's key in its place among the distinct keys, written out rather than indexed: a
+// vector indexed by a runtime value lives in local memory
+fn material_quad_keys_add(s: ptr<function, MaterialQuadKeys>, key: u32, bit: u32) {
+    const NONE = ${SUBGROUP_KEYED_APPEND_NONE}u;
+
+    if (key == NONE) {
+        return;
+    }
+
+    if ((*s).keys.x == key || (*s).keys.x == NONE) {
+        (*s).keys.x = key;
+        (*s).masks.x |= bit;
+    } else if ((*s).keys.y == key || (*s).keys.y == NONE) {
+        (*s).keys.y = key;
+        (*s).masks.y |= bit;
+    } else if ((*s).keys.z == key || (*s).keys.z == NONE) {
+        (*s).keys.z = key;
+        (*s).masks.z |= bit;
+    } else {
+        (*s).keys.w = key;
+        (*s).masks.w |= bit;
+    }
+}
+
+fn material_quad_keys(quad: vec2<u32>, resolution: vec2<u32>, tiles_x: u32, tile_count: u32) -> MaterialQuadKeys {
+    let tile_xy = (quad * 2u) / ${MATERIAL_DISPATCH_TILE_SIZE}u;
+    let tile = tile_xy.x + tile_xy.y * tiles_x;
+
+    let m0 = material_quad_mesh(quad, vec2<u32>(0u, 0u), resolution);
+    let m1 = material_quad_mesh(quad, vec2<u32>(1u, 0u), resolution);
+    let m2 = material_quad_mesh(quad, vec2<u32>(0u, 1u), resolution);
+    let m3 = material_quad_mesh(quad, vec2<u32>(1u, 1u), resolution);
+
+    // one lookup per distinct mesh
+    let k0 = material_mesh_key(m0, tile, tile_count);
+
+    var k1 = k0;
+    if (m1 != m0) {
+        k1 = material_mesh_key(m1, tile, tile_count);
+    }
+
+    var k2 = k0;
+    if (m2 == m1) {
+        k2 = k1;
+    } else if (m2 != m0) {
+        k2 = material_mesh_key(m2, tile, tile_count);
+    }
+
+    var k3 = k0;
+    if (m3 == m2) {
+        k3 = k2;
+    } else if (m3 == m1) {
+        k3 = k1;
+    } else if (m3 != m0) {
+        k3 = material_mesh_key(m3, tile, tile_count);
+    }
+
+    var out = MaterialQuadKeys(vec4<u32>(${SUBGROUP_KEYED_APPEND_NONE}u), vec4<u32>(0u));
+
+    material_quad_keys_add(&out, k0, 1u);
+    material_quad_keys_add(&out, k1, 2u);
+    material_quad_keys_add(&out, k2, 4u);
+    material_quad_keys_add(&out, k3, 8u);
+
+    return out;
+}
+`, [
+    chunk_material_mesh_key,
+]);

package/src/shade/renderer/material/dispatch/chunk_material_quad_pack.d.ts

@@ -0,0 +1,18 @@
+/**
+ * An entry of a material's list: one 2×2 quad of pixels, and which of its four are the material's.
+ *
+ * ```wgsl
+ * struct MaterialQuad { quad: vec2<u32>, mask: u32 }
+ * fn material_quad_pack(quad: vec2<u32>, mask: u32) -> u32
+ * fn material_quad_unpack(word: u32) -> MaterialQuad
+ * ```
+ *
+ * A word holds the quad's column and row, 14 bits each — any texture a device can make — and the
+ * mask in the top 4, bit `corner` for the pixel at `corner`: 0 top left, 1 top right, 2 bottom
+ * left, 3 bottom right, which is how a quad of lanes is laid out for `quadBroadcast`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_material_quad_pack: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_material_quad_pack.d.ts.map

package/src/shade/renderer/material/dispatch/chunk_material_quad_pack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_material_quad_pack.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/chunk_material_quad_pack.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,uCAFU,SAAS,CAiBhB;0BAhCuB,oCAAoC"}

package/src/shade/renderer/material/dispatch/chunk_material_quad_pack.js

@@ -0,0 +1,33 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * An entry of a material's list: one 2×2 quad of pixels, and which of its four are the material's.
+ *
+ * ```wgsl
+ * struct MaterialQuad { quad: vec2<u32>, mask: u32 }
+ * fn material_quad_pack(quad: vec2<u32>, mask: u32) -> u32
+ * fn material_quad_unpack(word: u32) -> MaterialQuad
+ * ```
+ *
+ * A word holds the quad's column and row, 14 bits each — any texture a device can make — and the
+ * mask in the top 4, bit `corner` for the pixel at `corner`: 0 top left, 1 top right, 2 bottom
+ * left, 3 bottom right, which is how a quad of lanes is laid out for `quadBroadcast`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_material_quad_pack = CodeChunk.from(
+    //language=WGSL
+    `
+struct MaterialQuad {
+    quad: vec2<u32>,
+    mask: u32,
+}
+
+fn material_quad_pack(quad: vec2<u32>, mask: u32) -> u32 {
+    return quad.x | (quad.y << 14u) | (mask << 28u);
+}
+
+fn material_quad_unpack(word: u32) -> MaterialQuad {
+    return MaterialQuad(vec2<u32>(word & 0x3FFFu, (word >> 14u) & 0x3FFFu), word >> 28u);
+}
+`);

package/src/shade/renderer/material/dispatch/gbuffer_compute.d.ts

@@ -0,0 +1,116 @@
+/**
+ * The resource set of a compute G-buffer pipeline whose group 0 is `material_group`: the template's
+ * own group 0 and the fragment pipelines' group 2, which this code reads under the same names, and
+ * groups 1 and 3 of its own.
+ *
+ * @param {ShaderResourceGroupDescriptor} material_group
+ * @returns {ShaderResourceSetDescriptor}
+ */
+export function build_gbuffer_compute_shader_resources(material_group: ShaderResourceGroupDescriptor): ShaderResourceSetDescriptor;
+/**
+ * The compute entry of a template's G-buffer pipeline: a quad of lanes per 2×2 quad of pixels in
+ * the material's run of the list, {@link build_gbuffer_laydown} at each pixel's centre, and the
+ * result stored, for the pixels of the quad that are the material's, where the fragment dispatch's
+ * colour targets would have taken it.
+ *
+ * The quad's other pixels run the laydown as a fragment quad's helper lanes do, so the derivative
+ * the laydown takes is a fragment quad's — see {@link chunk_gbuffer_fwidth_quad}. So does the tail
+ * of the material's last workgroup, on its last quad again; every lane of a workgroup that holds any
+ * of the list runs the laydown, which keeps the quad operations in uniform control flow, and a
+ * workgroup wholly past the list leaves at once.
+ *
+ * Lanes take their places in subgroup order, through {@link chunk_subgroup_reserve_workgroup}, so a
+ * quad of places is a quad of lanes however subgroups are laid over the workgroup.
+ *
+ * Dispatched with a folded command — see {@link chunk_folded_workgroup_index} — so one material can
+ * cover more of the screen than one dispatch dimension reaches.
+ *
+ * @param {CodeChunk} surface defines `fn material_surface(s: MaterialSurfaceInput) -> MaterialSurfaceOutput`
+ * @returns {CodeChunk}
+ */
+export function build_gbuffer_compute_body(surface: CodeChunk): CodeChunk;
+/**
+ * The compute G-buffer pipeline of a template: its group 0 and surface function around the shared
+ * laydown. Every group is laid out for the compute stage, whatever stages its declaration names, so
+ * no template has to declare anything for this pipeline: a material's group 0 for it is a bind group
+ * of its own, made by the template's own hook over this layout.
+ *
+ * @param {Object} options
+ * @param {string} options.label
+ * @param {ShaderResourceGroupDescriptor} options.material_group the template's group 0
+ * @param {CodeChunk} options.surface defines `material_surface`
+ * @returns {ComputePipelineDescriptor}
+ */
+export function build_gbuffer_compute_pipeline_descriptor({ label, material_group, surface }: {
+    label: string;
+    material_group: ShaderResourceGroupDescriptor;
+    surface: CodeChunk;
+}): ComputePipelineDescriptor;
+/**
+ * What one material's compute dispatch is for: its indirect workgroup counts, which the dispatch is
+ * issued with, and the run of the pixel list it shades. Written by
+ * {@link shader_material_dispatch_commands}, one per material at
+ * {@link MATERIAL_DISPATCH_RECORD_STRIDE}, and bound to the dispatch as its own uniform.
+ *
+ * @type {WebGPUStruct}
+ */
+export const MATERIAL_DISPATCH_RECORD_STRUCT: WebGPUStruct;
+/**
+ * @typedef {import("../../../descriptor/binding/BindGroupLayoutDescriptor.js").BindGroupLayoutDescriptor} BindGroupLayoutDescriptor
+ */
+/**
+ * Group 1 of every template's compute G-buffer pipeline: what {@link build_gbuffer_laydown} reads
+ * of the visibility buffer and the view, under the names the laydown reads them by, then the quad
+ * lists the dispatch walks and the G-buffer it writes.
+ *
+ * One bind group a frame serves every template.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const g_buffer_viz_compute_resources: ShaderResourceGroupDescriptor;
+/**
+ * Group 3 of every template's compute G-buffer pipeline: the dispatch's own record. A bind group
+ * per material, over that material's slice of the record buffer, so the shader learns which run of
+ * the pixel list is its own from the one thing that differs between the dispatches.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const g_buffer_dispatch_resources: ShaderResourceGroupDescriptor;
+/**
+ * Group 1 as every compute G-buffer pipeline lays it out.
+ *
+ * @type {BindGroupLayoutDescriptor}
+ */
+export const GBUFFER_COMPUTE_VIZ_LAYOUT: BindGroupLayoutDescriptor;
+/**
+ * Group 2 as every compute G-buffer pipeline lays it out: the fragment pipelines' scene group,
+ * visible to compute.
+ *
+ * @type {BindGroupLayoutDescriptor}
+ */
+export const GBUFFER_COMPUTE_SCENE_LAYOUT: BindGroupLayoutDescriptor;
+/**
+ * Group 3 as every compute G-buffer pipeline lays it out.
+ *
+ * @type {BindGroupLayoutDescriptor}
+ */
+export const GBUFFER_COMPUTE_DISPATCH_LAYOUT: BindGroupLayoutDescriptor;
+/**
+ * `fn gbuffer_fwidth(v: vec2<f32>) -> vec2<f32>` for {@link build_gbuffer_laydown} in the compute
+ * material dispatch, whose quad of lanes is a 2×2 quad of pixels: `fwidth` taken coarse, across the
+ * quad's top row and left column. That is what a fragment's `fwidth` is on D3D12; WGSL lets a backend
+ * take it fine instead, and there the two paths' filtered roughness differs where the normal varies
+ * between a quad's rows.
+ *
+ * Called from uniform control flow, with every lane of the quad running the laydown.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_gbuffer_fwidth_quad: CodeChunk;
+export type BindGroupLayoutDescriptor = import("../../../descriptor/binding/BindGroupLayoutDescriptor.js").BindGroupLayoutDescriptor;
+import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputePipelineDescriptor } from "../../../descriptor/pipeline/compute/ComputePipelineDescriptor.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=gbuffer_compute.d.ts.map

package/src/shade/renderer/material/dispatch/gbuffer_compute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gbuffer_compute.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/dispatch/gbuffer_compute.js"],"names":[],"mappings":"AA6GA;;;;;;;GAOG;AACH,uEAHW,6BAA6B,GAC3B,2BAA2B,CAWvC;AA0BD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oDAHW,SAAS,GACP,SAAS,CAgDrB;AAED;;;;;;;;;;;GAWG;AACH;IAL2B,KAAK,EAArB,MAAM;IACiC,cAAc,EAArD,6BAA6B;IACV,OAAO,EAA1B,SAAS;IACP,yBAAyB,CAiBrC;AAlOD;;;;;;;GAOG;AACH,8CAFU,YAAY,CAcO;AAE7B;;GAEG;AAEH;;;;;;;;GAQG;AACH,6CAFU,6BAA6B,CAE2C;AAelF;;;;;;GAMG;AACH,0CAFU,6BAA6B,CAEwC;AAQ/E;;;;GAIG;AACH,yCAFU,yBAAyB,CAEgG;AAEnI;;;;;GAKG;AACH,2CAFU,yBAAyB,CAE4F;AAE/H;;;;GAIG;AACH,8CAFU,yBAAyB,CAEkG;AAqBrI;;;;;;;;;;GAUG;AACH,wCAFU,SAAS,CAWhB;wCAvGU,OAAO,0DAA0D,EAAE,yBAAyB;8CArC3D,wDAAwD;4CAC1D,sDAAsD;0BAFxE,oCAAoC;0CANpB,mEAAmE;6BAYhF,mCAAmC"}