@woosh/meep-engine 3.61.2 → 3.62.0

package/src/shade/renderer/rasterize/standard/graph_rasterize_scene.js

@@ -3,6 +3,7 @@ import { graph_build_hzb } from "../../hiz/graph_build_hzb.js";
 import { HierarchicalZBuffer } from "../../hiz/HierarchicalZBuffer.js";
 import { ShadeDrawSide } from "../../material/ShadeDrawSide.js";
 import { graph_import_buffer } from "../../shader/graph/graph_import_buffer.js";
+import { graph_create_buffer } from "../../shader/graph/graph_create_buffer.js";
 import { graph_import_texture } from "../../shader/graph/graph_import_texture.js";
 import { graph_record_stat } from "../../util/graph_record_stat.js";
 import { enquire_mesh_frustum_cull_pipelines, graph_mesh_frustum_cull } from "../compute/graph_mesh_frustum_cull.js";
@@ -12,6 +13,7 @@ import {
     graph_meshes_classify_buckets
 } from "../expand/bucket/mesh/graph_meshes_classify_buckets.js";
 import { RasterizationCollectionType } from "../expand/RasterizationCollectionType.js";
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { graph_rasterize_meshes_alpha_tested } from "../native/graph_rasterize_meshes_alpha_tested.js";
 import { enquire_rasterize_partial_opaque_pipelines, graph_rasterize_partial_opaque } from "./graph_rasterize_partial_opaque.js";
 import {
@@ -51,8 +53,10 @@ export function enquire_rasterize_scene_pipelines(enquiry, opaque_pass, cull_pol
  * @param {FrameGraph} options.graph
  * @param {RasterizationJob} options.job
  * @param {GPUCollectionLimits} options.limits
- * @returns {{buckets: number, depth: number, color_targets: number[]}} the render buckets buffer,
- *   and the depth and colour targets as this pipeline left them
+ * @returns {{buckets: number, depth: number, color_targets: number[], visible_meshlets: number}} the render
+ *   buckets buffer, the depth and colour targets as this pipeline left them, and — when the job's passes write
+ *   visible-meshlet slots, as the visibility raster's do — the frame's visible-meshlet table, which resolves
+ *   them (-1 otherwise)
  */
 export function graph_rasterize_scene({
                                           graph,
@@ -101,6 +105,28 @@ export function graph_rasterize_scene({
         raster_color_targets[i] = graph_import_texture(graph, texture, `out_color/${i}`);
     }
 
+    /*
+     Every draw of a pass that writes visible-meshlet slots appends its meshlets to one table for the frame
+     and draws them from there, so the slot a pixel holds names its meshlet for every later reader. Sized as
+     the collections are, by what the frames before asked for, and never smaller than a meshlet collection:
+     any one list drawn into it can be that long. The table's own stat is the limits' last column, whose
+     growth is set back whenever an earlier column grows, while the collection's tracks the lists'.
+    */
+    assert.equal(job.alpha_tested_pass === undefined || job.alpha_tested_pass.visible_meshlet_slots === job.opaque_pass.visible_meshlet_slots, true, 'both passes of a job write visible-meshlet slots, or neither does');
+
+    let gr_visible_meshlets = -1;
+
+    if (job.opaque_pass.visible_meshlet_slots) {
+        gr_visible_meshlets = graph_create_buffer(graph, "visible meshlets", BufferResourceDescriptor.from(
+            Math.max(
+                limits.compute_buffer_size(RasterizationCollectionType.VisibleMeshlets),
+                limits.compute_buffer_size(RasterizationCollectionType.Meshlets),
+            ),
+            GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+            0, 16 // clear count
+        ));
+    }
+
     const gr_culled_meshes = graph_mesh_frustum_cull({
         graph,
         camera: gr_camera_current,
@@ -124,6 +150,7 @@ export function graph_rasterize_scene({
         meshlets_maybe: gr_meshlet_maybe,
         depth: gr_depth_opaque_partial,
         color_targets: gr_color_opaque_partial,
+        visible_meshlets: gr_visible_meshlets_partial,
     } = graph_rasterize_partial_opaque({
         graph,
         buckets: gr_render_buckets,
@@ -137,11 +164,13 @@ export function graph_rasterize_scene({
         viewport,
         active_buckets,
         cull_policy: job.cull_policy,
+        visible_meshlets: gr_visible_meshlets,
     });
 
 
     gr_texture_depth = gr_depth_opaque_partial;
     raster_color_targets = gr_color_opaque_partial;
+    gr_visible_meshlets = gr_visible_meshlets_partial;
 
     // build HZB of "likely visible" meshlets
     gr_texture_hzb = graph_build_hzb({
@@ -155,6 +184,7 @@ export function graph_rasterize_scene({
     const {
         depth: gr_depth_opaque_full,
         color_targets: gr_color_opaque_full,
+        visible_meshlets: gr_visible_meshlets_full,
     } = graph_rasterize_remaining_opaque({
         graph,
         limits,
@@ -169,10 +199,12 @@ export function graph_rasterize_scene({
         render_pass_descriptor: job.opaque_pass,
         viewport,
         cull_policy: job.cull_policy,
+        visible_meshlets: gr_visible_meshlets,
     });
 
     gr_texture_depth = gr_depth_opaque_full;
     raster_color_targets = gr_color_opaque_full;
+    gr_visible_meshlets = gr_visible_meshlets_full;
 
     // HZB of full opaque
     gr_texture_hzb = graph_build_hzb({
@@ -209,10 +241,12 @@ export function graph_rasterize_scene({
             raster_color_targets,
             depth: gr_texture_depth,
             hzb: gr_texture_hzb,
+            visible_meshlets: gr_visible_meshlets,
         });
 
         gr_texture_depth = alpha_tested_front.depth;
         raster_color_targets = alpha_tested_front.color_targets;
+        gr_visible_meshlets = alpha_tested_front.visible_meshlets;
 
         const alpha_tested_double = graph_rasterize_meshes_alpha_tested({
             graph,
@@ -228,10 +262,12 @@ export function graph_rasterize_scene({
             raster_color_targets,
             depth: gr_texture_depth,
             hzb: gr_texture_hzb,
+            visible_meshlets: gr_visible_meshlets,
         });
 
         gr_texture_depth = alpha_tested_double.depth;
         raster_color_targets = alpha_tested_double.color_targets;
+        gr_visible_meshlets = alpha_tested_double.visible_meshlets;
 
         if (alpha_tested_front.executed || alpha_tested_double.executed) {
 
@@ -246,6 +282,10 @@ export function graph_rasterize_scene({
         }
     }
 
+    if (gr_visible_meshlets !== -1) {
+        graph_record_stat(graph, limits.stats, RasterizationCollectionType.VisibleMeshlets, gr_visible_meshlets);
+    }
+
     graph.pop_scope();
 
     /*
@@ -261,5 +301,6 @@ export function graph_rasterize_scene({
         buckets: gr_render_buckets,
         depth: gr_texture_depth,
         color_targets: raster_color_targets,
+        visible_meshlets: gr_visible_meshlets,
     };
 }

package/src/shade/renderer/rasterize/visibility/VISIBILITY_BUFFER.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The visibility buffer's format: one `u32` a pixel, `slot << VISIBILITY_TRIANGLE_BITS | triangle`. `slot` is
+ * the pixel's meshlet's place in the frame's visible-meshlet table, which says the meshlet and the mesh row
+ * it was drawn for (`chunk_visibility_decode`); `triangle` is the triangle within that meshlet.
+ *
+ * @type {GPUTextureFormat}
+ */
+export const VISIBILITY_FORMAT: GPUTextureFormat;
+/**
+ * Bits of a visibility word that hold the triangle within its meshlet, below the slot.
+ *
+ * @type {number}
+ */
+export const VISIBILITY_TRIANGLE_BITS: number;
+/**
+ * How many slots the visible-meshlet table can hold: every value the bits above the triangle reach, less
+ * the last, which {@link VISIBILITY_NONE} takes.
+ *
+ * @type {number}
+ */
+export const VISIBLE_MESHLET_SLOT_LIMIT: number;
+/**
+ * What a pixel no surface covers holds, and what the visibility buffer is cleared to: the first word of the
+ * slot past every slot the table can hold. A 32-bit float holds it exactly, as a clear value has to be —
+ * `RenderPassColorAttachmentDescriptor` keeps one in a `Float32Array`, where every bit set would round up
+ * to 2^32.
+ *
+ * @type {number}
+ */
+export const VISIBILITY_NONE: number;
+/**
+ * Where the table's elements start, counted in meshlet definitions from the start of its buffer. The table
+ * is a meshlet collection, a count before the elements; a pass that binds the whole buffer as a bare array
+ * of definitions — as the alpha-tested raster binds its lists — finds slot `s` at `s` plus this.
+ *
+ * @type {number}
+ */
+export const VISIBLE_MESHLETS_ARRAY_OFFSET: number;
+//# sourceMappingURL=VISIBILITY_BUFFER.d.ts.map

package/src/shade/renderer/rasterize/visibility/VISIBILITY_BUFFER.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VISIBILITY_BUFFER.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/visibility/VISIBILITY_BUFFER.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,iDAA2C;AAE3C;;;;GAIG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;;;GAKG;AACH,yCAFU,MAAM,CAEmE;AAEnF;;;;;;;GAOG;AACH,8BAFU,MAAM,CAE0E;AAE1F;;;;;;GAMG;AACH,4CAFU,MAAM,CAE+G"}

package/src/shade/renderer/rasterize/visibility/VISIBILITY_BUFFER.js

@@ -0,0 +1,45 @@
+import { MESHLET_DEFINITION_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_DEFINITION_STRUCT.js";
+import { MESHLET_COLLECTION_STRUCT } from "../MESHLET_COLLECTION_STRUCT.js";
+
+/**
+ * The visibility buffer's format: one `u32` a pixel, `slot << VISIBILITY_TRIANGLE_BITS | triangle`. `slot` is
+ * the pixel's meshlet's place in the frame's visible-meshlet table, which says the meshlet and the mesh row
+ * it was drawn for (`chunk_visibility_decode`); `triangle` is the triangle within that meshlet.
+ *
+ * @type {GPUTextureFormat}
+ */
+export const VISIBILITY_FORMAT = 'r32uint';
+
+/**
+ * Bits of a visibility word that hold the triangle within its meshlet, below the slot.
+ *
+ * @type {number}
+ */
+export const VISIBILITY_TRIANGLE_BITS = 8;
+
+/**
+ * How many slots the visible-meshlet table can hold: every value the bits above the triangle reach, less
+ * the last, which {@link VISIBILITY_NONE} takes.
+ *
+ * @type {number}
+ */
+export const VISIBLE_MESHLET_SLOT_LIMIT = 2 ** (32 - VISIBILITY_TRIANGLE_BITS) - 1;
+
+/**
+ * What a pixel no surface covers holds, and what the visibility buffer is cleared to: the first word of the
+ * slot past every slot the table can hold. A 32-bit float holds it exactly, as a clear value has to be —
+ * `RenderPassColorAttachmentDescriptor` keeps one in a `Float32Array`, where every bit set would round up
+ * to 2^32.
+ *
+ * @type {number}
+ */
+export const VISIBILITY_NONE = VISIBLE_MESHLET_SLOT_LIMIT * 2 ** VISIBILITY_TRIANGLE_BITS;
+
+/**
+ * Where the table's elements start, counted in meshlet definitions from the start of its buffer. The table
+ * is a meshlet collection, a count before the elements; a pass that binds the whole buffer as a bare array
+ * of definitions — as the alpha-tested raster binds its lists — finds slot `s` at `s` plus this.
+ *
+ * @type {number}
+ */
+export const VISIBLE_MESHLETS_ARRAY_OFFSET = MESHLET_COLLECTION_STRUCT.get('elements').offset / MESHLET_DEFINITION_STRUCT.size;

package/src/shade/renderer/rasterize/visibility/chunk_visibility_decode.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The frame's visible-meshlet table: every meshlet the view's raster drew into the visibility buffer, at
+ * the slot its pixels name. A meshlet collection, read-only to the passes that resolve pixels through it.
+ *
+ * @type {ShaderResourceDescriptor}
+ */
+export const VISIBLE_MESHLETS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * What a visibility word says of its pixel ({@link VISIBILITY_FORMAT}): the scene row of the mesh, the
+ * meshlet (a global meshlet index) and the triangle within it, through the frame's visible-meshlet table,
+ * bound as `visible_meshlets`.
+ *
+ * ```wgsl
+ * const VISIBILITY_NONE: u32
+ * struct VisibilityTexel { mesh: u32, meshlet: u32, triangle: u32 }
+ * fn visibility_decode(encoded: u32) -> VisibilityTexel
+ * ```
+ *
+ * Only for a word that is not `VISIBILITY_NONE`, which no surface covers.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_visibility_decode: CodeChunk;
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_visibility_decode.d.ts.map

package/src/shade/renderer/rasterize/visibility/chunk_visibility_decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_visibility_decode.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/visibility/chunk_visibility_decode.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wCAFU,wBAAwB,CAE6F;AAE/H;;;;;;;;;;;;;;GAcG;AACH,sCAFU,SAAS,CAmBjB;yCA5CuC,mDAAmD;0BADlE,oCAAoC"}

package/src/shade/renderer/rasterize/visibility/chunk_visibility_decode.js

@@ -0,0 +1,48 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { MESHLET_COLLECTION_STRUCT } from "../MESHLET_COLLECTION_STRUCT.js";
+import { VISIBILITY_NONE, VISIBILITY_TRIANGLE_BITS } from "./VISIBILITY_BUFFER.js";
+
+/**
+ * The frame's visible-meshlet table: every meshlet the view's raster drew into the visibility buffer, at
+ * the slot its pixels name. A meshlet collection, read-only to the passes that resolve pixels through it.
+ *
+ * @type {ShaderResourceDescriptor}
+ */
+export const VISIBLE_MESHLETS_RESOURCE = ShaderResourceDescriptor.storageBuffer("visible_meshlets", MESHLET_COLLECTION_STRUCT);
+
+/**
+ * What a visibility word says of its pixel ({@link VISIBILITY_FORMAT}): the scene row of the mesh, the
+ * meshlet (a global meshlet index) and the triangle within it, through the frame's visible-meshlet table,
+ * bound as `visible_meshlets`.
+ *
+ * ```wgsl
+ * const VISIBILITY_NONE: u32
+ * struct VisibilityTexel { mesh: u32, meshlet: u32, triangle: u32 }
+ * fn visibility_decode(encoded: u32) -> VisibilityTexel
+ * ```
+ *
+ * Only for a word that is not `VISIBILITY_NONE`, which no surface covers.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_visibility_decode = CodeChunk.from(
+    //language=WGSL
+    `
+const VISIBILITY_NONE: u32 = ${VISIBILITY_NONE}u;
+
+struct VisibilityTexel {
+    mesh: u32,
+    meshlet: u32,
+    triangle: u32,
+}
+
+fn visibility_decode(encoded: u32) -> VisibilityTexel {
+    let meshlet = visible_meshlets.elements[encoded >> ${VISIBILITY_TRIANGLE_BITS}u];
+
+    return VisibilityTexel(meshlet.mesh, meshlet.index, encoded & ${2 ** VISIBILITY_TRIANGLE_BITS - 1}u);
+}
+`
+);
+
+chunk_visibility_decode.requireResource(VISIBLE_MESHLETS_RESOURCE);

package/src/shade/renderer/rasterize/visibility/shader_visible_meshlets_append.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Reserve the slots of one list in the visible-meshlet table and write the commands that use them: `draw`
+ * draws the list's meshlets from the table, `instanceCount` of them from `firstInstance`, its first slot;
+ * `copy` dispatches {@link shader_visible_meshlets_copy} over them, one invocation a meshlet.
+ *
+ * The table's count is every slot asked for, as a meshlet collection's count is: a list past the table's
+ * end draws only what fits, and the count tells the collection limits how far to grow it.
+ *
+ * One invocation.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_visible_meshlets_reserve: ComputeShader;
+/**
+ * Copy a list's reserved meshlets into the visible-meshlet table, at the slots `draw` holds
+ * ({@link shader_visible_meshlets_reserve}). Dispatched indirectly by its `copy` command.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_visible_meshlets_copy: ComputeShader;
+/**
+ * {@link shader_visible_meshlets_copy} for a list kept as a bare array whose count is held elsewhere — the
+ * alpha-tested raster's, sorted by material, whose collection the reserve counts.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_visible_meshlets_copy_array: ComputeShader;
+/**
+ * Move per-material draw commands over a sorted list onto the list's copy in the visible-meshlet table:
+ * each command's range of the list becomes the same range of the slots `draw` holds, cut to the slots the
+ * copy filled. The draws bind the table's whole buffer as a bare array of definitions, which puts slot `s`
+ * at `s + ${VISIBLE_MESHLETS_ARRAY_OFFSET}` ({@link VISIBLE_MESHLETS_ARRAY_OFFSET}).
+ *
+ * One invocation a command.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_visible_meshlets_offset_commands: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_visible_meshlets_append.d.ts.map

package/src/shade/renderer/rasterize/visibility/shader_visible_meshlets_append.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_visible_meshlets_append.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/visibility/shader_visible_meshlets_append.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;GAWG;AACH,8CAFU,aAAa,CA8BpB;AAmCH;;;;;GAKG;AACH,2CAFU,aAAa,CAMpB;AASH;;;;;GAKG;AACH,iDAFU,aAAa,CAMpB;AAQH;;;;;;;;;GASG;AACH,sDAFU,aAAa,CAuBpB;8BAnK2B,+BAA+B"}

package/src/shade/renderer/rasterize/visibility/shader_visible_meshlets_append.js

@@ -0,0 +1,172 @@
+import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "../../geometry/meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.js";
+import { MESHLET_DEFINITION_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_DEFINITION_STRUCT.js";
+import { chunk_folded_dispatch } from "../../gpu_primitive/indirect/chunk_folded_dispatch.js";
+import { STRUCT_DISPATCH_COMPUTE_COMMAND } from "../../gpu_primitive/indirect/STRUCT_DISPATCH_COMPUTE_COMMAND.js";
+import { STRUCT_UNINDEXED_DRAW_COMMAND } from "../../gpu_primitive/indirect/STRUCT_UNINDEXED_DRAW_COMMAND.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { MESHLET_COLLECTION_STRUCT } from "../MESHLET_COLLECTION_STRUCT.js";
+import { VISIBLE_MESHLET_SLOT_LIMIT, VISIBLE_MESHLETS_ARRAY_OFFSET } from "./VISIBILITY_BUFFER.js";
+
+/*
+ A draw into the visibility buffer takes its meshlets from the frame's visible-meshlet table, so that the
+ slot its pixels write names the meshlet for every later reader. Before each such draw its list is
+ appended to the table: one invocation reserves the slots, then the copy runs over the list.
+*/
+
+const reserve_resources = new ShaderResourceSetDescriptor();
+
+reserve_resources.createGroup()
+    .addStorageBuffer("input", MESHLET_COLLECTION_STRUCT)
+    .addStorageBuffer("visible_meshlets", MESHLET_COLLECTION_STRUCT, true)
+    .addStorageBuffer("draw", STRUCT_UNINDEXED_DRAW_COMMAND, true)
+    .addStorageBuffer("copy", STRUCT_DISPATCH_COMPUTE_COMMAND, true);
+
+/**
+ * Reserve the slots of one list in the visible-meshlet table and write the commands that use them: `draw`
+ * draws the list's meshlets from the table, `instanceCount` of them from `firstInstance`, its first slot;
+ * `copy` dispatches {@link shader_visible_meshlets_copy} over them, one invocation a meshlet.
+ *
+ * The table's count is every slot asked for, as a meshlet collection's count is: a list past the table's
+ * end draws only what fits, and the count tells the collection limits how far to grow it.
+ *
+ * One invocation.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_visible_meshlets_reserve = ComputeShader.from({
+    label: "Visible meshlets / reserve",
+    resources: reserve_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(1)
+fn main() {
+    let count = min(input.count, arrayLength(&input.elements));
+
+    let base = visible_meshlets.count;
+    let capacity = min(arrayLength(&visible_meshlets.elements), ${VISIBLE_MESHLET_SLOT_LIMIT}u);
+    let stored = select(0u, min(count, capacity - base), base < capacity);
+
+    visible_meshlets.count = base + count;
+
+    draw.vertexCount = ${GEOMETRY_MESHLET_TRIANGLE_LIMIT * 3}u;
+    draw.instanceCount = stored;
+    draw.firstVertex = 0u;
+    draw.firstInstance = base;
+
+    let groups = folded_dispatch((stored + ${COMPUTE_SHADER_DEFAULT_GROUP_SIZE - 1}u) / ${COMPUTE_SHADER_DEFAULT_GROUP_SIZE}u);
+
+    copy.workgroupCountX = groups.x;
+    copy.workgroupCountY = groups.y;
+    copy.workgroupCountZ = groups.z;
+}
+`, [chunk_folded_dispatch])
+});
+
+/**
+ * The copy kernels' body: `source(i)` is the list's `i`-th meshlet.
+ *
+ * @param {string} source
+ * @returns {CodeChunk}
+ */
+function copy_body(source) {
+    return CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${COMPUTE_SHADER_DEFAULT_GROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) local_index: u32,
+) {
+    let i = folded_workgroup_index(workgroup_id) * ${COMPUTE_SHADER_DEFAULT_GROUP_SIZE}u + local_index;
+
+    if (i >= draw.instanceCount) {
+        return;
+    }
+
+    visible_meshlets.elements[draw.firstInstance + i] = ${source};
+}
+`, [chunk_folded_workgroup_index]);
+}
+
+const copy_resources = new ShaderResourceSetDescriptor();
+
+copy_resources.createGroup()
+    .addStorageBuffer("draw", STRUCT_UNINDEXED_DRAW_COMMAND)
+    .addStorageBuffer("input", MESHLET_COLLECTION_STRUCT)
+    .addStorageBuffer("visible_meshlets", MESHLET_COLLECTION_STRUCT, true);
+
+/**
+ * Copy a list's reserved meshlets into the visible-meshlet table, at the slots `draw` holds
+ * ({@link shader_visible_meshlets_reserve}). Dispatched indirectly by its `copy` command.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_visible_meshlets_copy = ComputeShader.from({
+    label: "Visible meshlets / copy",
+    resources: copy_resources,
+    body: copy_body("input.elements[i]"),
+});
+
+const copy_array_resources = new ShaderResourceSetDescriptor();
+
+copy_array_resources.createGroup()
+    .addStorageBuffer("draw", STRUCT_UNINDEXED_DRAW_COMMAND)
+    .addStorageBuffer("input", WebGPUArray.from(MESHLET_DEFINITION_STRUCT))
+    .addStorageBuffer("visible_meshlets", MESHLET_COLLECTION_STRUCT, true);
+
+/**
+ * {@link shader_visible_meshlets_copy} for a list kept as a bare array whose count is held elsewhere — the
+ * alpha-tested raster's, sorted by material, whose collection the reserve counts.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_visible_meshlets_copy_array = ComputeShader.from({
+    label: "Visible meshlets / copy",
+    resources: copy_array_resources,
+    body: copy_body("input[i]"),
+});
+
+const offset_resources = new ShaderResourceSetDescriptor();
+
+offset_resources.createGroup()
+    .addStorageBuffer("draw", STRUCT_UNINDEXED_DRAW_COMMAND)
+    .addStorageBuffer("commands", WebGPUArray.from(STRUCT_UNINDEXED_DRAW_COMMAND), true);
+
+/**
+ * Move per-material draw commands over a sorted list onto the list's copy in the visible-meshlet table:
+ * each command's range of the list becomes the same range of the slots `draw` holds, cut to the slots the
+ * copy filled. The draws bind the table's whole buffer as a bare array of definitions, which puts slot `s`
+ * at `s + ${VISIBLE_MESHLETS_ARRAY_OFFSET}` ({@link VISIBLE_MESHLETS_ARRAY_OFFSET}).
+ *
+ * One invocation a command.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_visible_meshlets_offset_commands = ComputeShader.from({
+    label: "Visible meshlets / offset draw commands",
+    resources: offset_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${COMPUTE_SHADER_DEFAULT_GROUP_SIZE})
+fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
+    let k = global_id.x;
+
+    if (k >= arrayLength(&commands)) {
+        return;
+    }
+
+    let start = commands[k].firstInstance;
+    let end = min(start + commands[k].instanceCount, draw.instanceCount);
+
+    commands[k].instanceCount = select(0u, end - start, start < end);
+    commands[k].firstInstance = draw.firstInstance + start + ${VISIBLE_MESHLETS_ARRAY_OFFSET}u;
+}
+`)
+});

package/src/shade/renderer/restir/di/chunk_restir_reconstruct_surface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_restir_reconstruct_surface.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/chunk_restir_reconstruct_surface.js"],"names":[],"mappings":"AAWA;;;;;;;;;;GAUG;AACH,+CAFU,SAAS,CAqDjB;0BAhEwB,oCAAoC"}
+{"version":3,"file":"chunk_restir_reconstruct_surface.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/chunk_restir_reconstruct_surface.js"],"names":[],"mappings":"AAcA;;;;;;;;;;GAUG;AACH,+CAFU,SAAS,CAoDjB;0BA/DwB,oCAAoC"}

package/src/shade/renderer/restir/di/chunk_restir_reconstruct_surface.js

@@ -4,6 +4,9 @@ import { chunk_project_position_from_depth } from "../../shader/chunk/camera/chu
 import { chunk_get_view_space_depth } from "../../shader/chunk/depth/chunk_get_view_space_depth.js";
 import { chunk_mat4_extract_position } from "../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import { GEOMETRIC_SHADING_INFO_STRUCT } from "../../shader/chunk/material/GEOMETRIC_SHADING_INFO_STRUCT.js";
 import { MATERIAL_SHADING_INFO_STRUCT } from "../../shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js";
 import { chunk_texel_coordinate_to_uv } from "../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
@@ -47,11 +50,9 @@ fn restir_reconstruct_surface(i_coord: vec2<u32>, texture_size: vec2<u32>) -> Re
     let camera_position_ws = mat4_extract_position(camera.transform);
     let view_direction = normalize(camera_position_ws - position_ws);
 
-    let g_buffer_sample_normal = textureLoad(gBufferNormal, i_coord, 0);
-
     surface.geometry = ${GEOMETRIC_SHADING_INFO_STRUCT.wgsl_ref}(
-        decode_g_buffer_normal(g_buffer_sample_normal.xy),
-        decode_g_buffer_normal(g_buffer_sample_normal.zw),
+        decode_g_buffer_normal(textureLoad(gBufferNormal, i_coord, 0).x),
+        decode_g_buffer_face_normal(textureLoad(gBufferPBR, i_coord, 0)),
         position_ws,
         view_direction,
     );
@@ -69,6 +70,7 @@ fn restir_reconstruct_surface(i_coord: vec2<u32>, texture_size: vec2<u32>) -> Re
         chunk_project_position_from_depth,
         chunk_mat4_extract_position,
         chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_read_gBuffer_material,
     ]
 );

package/src/shade/renderer/restir/di/chunk_restir_spatial_reuse.js

@@ -81,7 +81,7 @@ fn restir_spatial_reuse(
         if (abs(neighbour_view_depth - self_view_depth) > RESTIR_SPATIAL_DEPTH_TOLERANCE * self_view_depth) {
             continue;
         }
-        let neighbour_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, neighbour_u, 0).xy);
+        let neighbour_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, neighbour_u, 0).x);
         if (dot(neighbour_normal, geometry.shading_normal) < RESTIR_SPATIAL_NORMAL_TOLERANCE) {
             continue;
         }

package/src/shade/renderer/restir/di/shader_restir_di_denoise.js

@@ -76,7 +76,7 @@ fn main(
     }
 
     let center_depth = get_view_space_depth(center_device_depth, camera);
-    let center_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, i_coord, 0).xy);
+    let center_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, i_coord, 0).x);
     let center_luma = rgb_to_luminance(center_radiance);
 
     let step = i32(step_size);
@@ -107,7 +107,7 @@ fn main(
 
         let sample_radiance = textureLoad(tInput, p, 0).rgb;
         let sample_depth = get_view_space_depth(sample_device_depth, camera);
-        let sample_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, p, 0).xy);
+        let sample_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, p, 0).x);
         let sample_luma = rgb_to_luminance(sample_radiance);
 
         let w_normal = normal_edge_stopping_weight(center_normal, sample_normal, PHI_NORMAL);

package/src/shade/renderer/scene/GPUSceneContext.d.ts

@@ -105,7 +105,7 @@ export class GPUSceneContext {
      * (REVIEW_LEDGER U1): `register` a container with {@link virtual_geometry_residency}, and every
      * page after the root arrives because a cut asked for it. The renderer opens and closes each
      * frame and schedules each reading, and {@link destroy} releases all of it; a host touches none
-     * of it. With them, the source of its geometries' caches and cards ({@link VGeoSDFProxies}): a virtual
+     * of it. With them, the source of its geometries' caches and surface caches ({@link VGeoSDFProxies}): a virtual
      * geometry whose cache is asked for stands in through its proxy.
      *
      * @param {Object} [options] passed to {@link GPUVirtualGeometryPool} and

package/src/shade/renderer/scene/GPUSceneContext.js

@@ -400,7 +400,7 @@ export class GPUSceneContext {
      * (REVIEW_LEDGER U1): `register` a container with {@link virtual_geometry_residency}, and every
      * page after the root arrives because a cut asked for it. The renderer opens and closes each
      * frame and schedules each reading, and {@link destroy} releases all of it; a host touches none
-     * of it. With them, the source of its geometries' caches and cards ({@link VGeoSDFProxies}): a virtual
+     * of it. With them, the source of its geometries' caches and surface caches ({@link VGeoSDFProxies}): a virtual
      * geometry whose cache is asked for stands in through its proxy.
      *
      * @param {Object} [options] passed to {@link GPUVirtualGeometryPool} and

package/src/shade/renderer/shader/chunk/color/sRGB/chunk_sRGBTransferEOTF.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Electro-optical transfer function (EOTF), the inverse of {@link chunk_sRGBTransferOETF}
+ *
+ * sRGB to sRGB-linear, the IEC 61966-2-1 curve an `-srgb` texture format decodes with.
+ * @see convert_channel_sRGB_to_linear the JS twin, which carries the same constants
+ */
+export const chunk_sRGBTransferEOTF: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sRGBTransferEOTF.d.ts.map

package/src/shade/renderer/shader/chunk/color/sRGB/chunk_sRGBTransferEOTF.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sRGBTransferEOTF.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/sRGB/chunk_sRGBTransferEOTF.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,+CASG;0BAjBuB,gCAAgC"}

package/src/shade/renderer/shader/chunk/color/sRGB/chunk_sRGBTransferEOTF.js

@@ -0,0 +1,18 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * Electro-optical transfer function (EOTF), the inverse of {@link chunk_sRGBTransferOETF}
+ *
+ * sRGB to sRGB-linear, the IEC 61966-2-1 curve an `-srgb` texture format decodes with.
+ * @see convert_channel_sRGB_to_linear the JS twin, which carries the same constants
+ */
+export const chunk_sRGBTransferEOTF = CodeChunk.from(
+//language=WGSL
+    `
+fn sRGBTransferEOTF( value: vec3<f32> ) -> vec3<f32> {
+    let low = value * 0.0773993808;
+    let high = pow( value * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) );
+
+    return select( low, high, value >= vec3( 0.04045 ) );
+}
+`);