@woosh/meep-engine 3.61.1 → 3.61.3

package/src/shade/renderer/global_illumination/probe_clipmap/material/chunk_brick_material.js

@@ -0,0 +1,142 @@
+import { MESH_SDF_BRICK_TEXELS } from "../../../geometry/sdf/MESH_SDF.js";
+import {
+    chunk_surface_material_pick,
+    chunk_surface_material_read
+} from "../../../geometry/sdf/surface/chunk_surface_material_read.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { chunk_tile_atlas_slot_origin } from "../../../texture/atlas/chunk_tile_atlas_slot_origin.js";
+import { BRICK_TRACE_HIT_VOXELS, chunk_brick_clipmap_sample } from "../brick/chunk_brick_clipmap_trace.js";
+
+/*
+ The material of the brick clipmap's surfaces: a tile of surface material texels (`SURFACE_MATERIAL.js`)
+ for every brick, on the lattice the slot's field uses, a texture a plane of `GPUBrickMaterial`'s atlas
+ whose slots are the brick atlas's.
+*/
+
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_MATERIAL_ALBEDO_RESOURCE = ShaderResourceDescriptor.texture("brick_material_albedo_codes", "uint", "3d");
+
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_MATERIAL_METAL_ROUGH_RESOURCE = ShaderResourceDescriptor.texture("brick_material_metal_rough_codes", "uint", "3d");
+
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_MATERIAL_EMISSIVE_RESOURCE = ShaderResourceDescriptor.texture("brick_material_emissive_codes", "uint", "3d");
+
+/**
+ * Where a reader stands among a slot's material texels, and which of them hold the surface it is on
+ * (`surface_material_corners`), the albedo plane saying which hold a material
+ * (`surface_material_present`):
+ *
+ * ```wgsl
+ * fn brick_material_tile(slot: u32) -> vec3<u32>
+ * fn brick_material_corners(slot: u32, local: vec3<f32>, normal: vec3<f32>) -> SurfaceMaterialCorners
+ * ```
+ *
+ * `brick_material_tile` is the slot's tile's origin in the planes. `local` is a point by the surface in
+ * voxels from the cell's corner, a hit's position, and `normal` the field's normal there. Surfaces
+ * within {@link BRICK_TRACE_HIT_VOXELS} of each other are one: a ray stands on a surface from anywhere
+ * that far out of it, so it cannot tell closer ones apart.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_material_corners = CodeChunk.from(
+    //language=WGSL
+    `
+fn brick_material_tile(slot: u32) -> vec3<u32> {
+    let t = ${MESH_SDF_BRICK_TEXELS}u;
+
+    return tile_atlas_slot_origin(slot, textureDimensions(brick_material_albedo_codes, 0).xy / t, vec3<u32>(t));
+}
+
+fn brick_material_corners(slot: u32, local: vec3<f32>, normal: vec3<f32>) -> SurfaceMaterialCorners {
+    let point = surface_material_point(local, brick_clipmap_sample(slot, local, 1.0), normal);
+    let present = surface_material_present(brick_material_albedo_codes, brick_material_tile(slot) + surface_material_base(point));
+
+    return surface_material_corners(brick_atlas, brick_clipmap_slot_texel(slot), point, present, normal, ${BRICK_TRACE_HIT_VOXELS});
+}
+`, [
+        chunk_surface_material_read,
+        chunk_brick_clipmap_sample,
+        chunk_tile_atlas_slot_origin,
+    ]);
+
+chunk_brick_material_corners.requireResource(BRICK_MATERIAL_ALBEDO_RESOURCE);
+
+/**
+ * What a hit's light takes from the brick material, its diffuse albedo and its emissive
+ * (`surface_material_surface`):
+ *
+ * ```wgsl
+ * fn brick_material_surface(slot: u32, local: vec3<f32>, normal: vec3<f32>) -> SurfaceMaterialSurface
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_material_surface = CodeChunk.from(
+    //language=WGSL
+    `
+fn brick_material_surface(slot: u32, local: vec3<f32>, normal: vec3<f32>) -> SurfaceMaterialSurface {
+    return surface_material_surface(brick_atlas, brick_material_albedo_codes, brick_material_emissive_codes, brick_material_tile(slot), brick_material_corners(slot, local, normal));
+}
+`, [
+        chunk_brick_material_corners,
+        chunk_surface_material_read,
+    ]);
+
+chunk_brick_material_surface.requireResource(BRICK_MATERIAL_EMISSIVE_RESOURCE);
+
+/**
+ * What a hit's light takes from one texel of the brick material, drawn by `u` in [0, 1) in proportion
+ * to its weight in {@link chunk_brick_material_surface}'s blend (`surface_material_pick`): the blend on
+ * average, over the reads a probe's rays make:
+ *
+ * ```wgsl
+ * fn brick_material_surface_pick(slot: u32, local: vec3<f32>, normal: vec3<f32>, u: f32) -> SurfaceMaterialSurface
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_material_surface_pick = CodeChunk.from(
+    //language=WGSL
+    `
+fn brick_material_surface_pick(slot: u32, local: vec3<f32>, normal: vec3<f32>, u: f32) -> SurfaceMaterialSurface {
+    let corners = brick_material_corners(slot, local, normal);
+
+    return surface_material_surface_at(brick_material_albedo_codes, brick_material_emissive_codes, brick_material_tile(slot), corners, surface_material_pick(brick_atlas, corners, u));
+}
+`, [
+        chunk_brick_material_corners,
+        chunk_surface_material_pick,
+    ]);
+
+chunk_brick_material_surface_pick.requireResource(BRICK_MATERIAL_EMISSIVE_RESOURCE);
+
+/**
+ * A hit's metalness and roughness from the brick material (`surface_material_metal_rough`), over the
+ * texels {@link chunk_brick_material_surface} takes:
+ *
+ * ```wgsl
+ * fn brick_material_metal_rough(slot: u32, local: vec3<f32>, normal: vec3<f32>) -> SurfaceMaterialMetalRough
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_material_metal_rough = CodeChunk.from(
+    //language=WGSL
+    `
+fn brick_material_metal_rough(slot: u32, local: vec3<f32>, normal: vec3<f32>) -> SurfaceMaterialMetalRough {
+    return surface_material_metal_rough(brick_atlas, brick_material_metal_rough_codes, brick_material_tile(slot), brick_material_corners(slot, local, normal));
+}
+`, [
+        chunk_brick_material_corners,
+        chunk_surface_material_read,
+    ]);
+
+chunk_brick_material_metal_rough.requireResource(BRICK_MATERIAL_METAL_ROUGH_RESOURCE);

package/src/shade/renderer/global_illumination/probe_clipmap/material/chunk_brick_material_cell.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Texels of a brick: 8³.
+ * @type {number}
+ */
+export const BRICK_MATERIAL_TEXELS: number;
+/**
+ * A brick's texel from its index:
+ *
+ * ```wgsl
+ * fn brick_material_texel(index: u32) -> vec3<u32> // index t.x + 8 (t.y + 8 t.z)
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_material_texel: CodeChunk;
+/**
+ * The taken cell a thread of the texel dispatch works on:
+ *
+ * ```wgsl
+ * fn brick_material_cell_entry(build: u32, ring_capacity: u32, resolution: u32) -> BrickMaterialCellEntry
+ * ```
+ *
+ * Build slot `build`'s key, and its brick map entry as store left it: a slot, or a cell with none.
+ *
+ * Requires the importing shader to declare `brick_take`, `brick_ring` and `brick_levels`, as
+ * `chunk_brick_provider` does.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_material_cell: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_brick_material_cell.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/material/chunk_brick_material_cell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_brick_material_cell.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/material/chunk_brick_material_cell.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,oCAFU,MAAM,CAEgD;AAEhE;;;;;;;;GAQG;AACH,yCAFU,SAAS,CAQhB;AAEH;;;;;;;;;;;;;GAaG;AACH,wCAFU,SAAS,CA0BZ;0BAlEmB,uCAAuC"}

package/src/shade/renderer/global_illumination/probe_clipmap/material/chunk_brick_material_cell.js

@@ -0,0 +1,70 @@
+import { MESH_SDF_BRICK_TEXELS } from "../../../geometry/sdf/MESH_SDF.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_brick_clipmap } from "../brick/chunk_brick_clipmap.js";
+import { BRICK_MAP_TEXTURE_RESOURCE } from "../brick/chunk_brick_clipmap_trace.js";
+import { chunk_brick_provider } from "../brick/chunk_brick_provider.js";
+
+/**
+ * Texels of a brick: 8³.
+ * @type {number}
+ */
+export const BRICK_MATERIAL_TEXELS = MESH_SDF_BRICK_TEXELS ** 3;
+
+/**
+ * A brick's texel from its index:
+ *
+ * ```wgsl
+ * fn brick_material_texel(index: u32) -> vec3<u32> // index t.x + 8 (t.y + 8 t.z)
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_material_texel = CodeChunk.from(
+    //language=WGSL
+    `
+fn brick_material_texel(index: u32) -> vec3<u32> {
+    return vec3<u32>(index % ${MESH_SDF_BRICK_TEXELS}u, (index / ${MESH_SDF_BRICK_TEXELS}u) % ${MESH_SDF_BRICK_TEXELS}u, index / ${MESH_SDF_BRICK_TEXELS ** 2}u);
+}
+`);
+
+/**
+ * The taken cell a thread of the texel dispatch works on:
+ *
+ * ```wgsl
+ * fn brick_material_cell_entry(build: u32, ring_capacity: u32, resolution: u32) -> BrickMaterialCellEntry
+ * ```
+ *
+ * Build slot `build`'s key, and its brick map entry as store left it: a slot, or a cell with none.
+ *
+ * Requires the importing shader to declare `brick_take`, `brick_ring` and `brick_levels`, as
+ * `chunk_brick_provider` does.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_material_cell = CodeChunk.from(
+    //language=WGSL
+    `
+struct BrickMaterialCellEntry {
+    key: u32,
+    entry: u32,
+}
+
+fn brick_material_cell_entry(build: u32, ring_capacity: u32, resolution: u32) -> BrickMaterialCellEntry {
+    var out: BrickMaterialCellEntry;
+
+    out.key = brick_provider_key(build, ring_capacity);
+    out.entry = textureLoad(
+        brick_map,
+        brick_clipmap_map_texel(brick_clipmap_key_cascade(out.key, resolution), brick_clipmap_key_storage(out.key, resolution), resolution),
+        0
+    ).x;
+
+    return out;
+}
+`, [
+        chunk_brick_clipmap,
+        chunk_brick_provider,
+        chunk_brick_material_texel,
+    ]);
+
+chunk_brick_material_cell.requireResource(BRICK_MAP_TEXTURE_RESOURCE);

package/src/shade/renderer/global_illumination/probe_clipmap/material/chunk_brick_material_store.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_MATERIAL_ALBEDO_STORE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_MATERIAL_METAL_ROUGH_STORE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_MATERIAL_EMISSIVE_STORE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * A texel's material written into its slot's planes (`chunk_brick_material.js`), through
+ * `surface_material_store`:
+ *
+ * ```wgsl
+ * fn brick_material_atlas_texel(slot: u32, texel: vec3<u32>) -> vec3<u32>
+ * fn brick_material_store(at: vec3<u32>, fitted: SurfaceMaterialFitted) // a fit that covered nothing clears
+ * fn brick_material_clear(at: vec3<u32>)                                 // no material: 0 in every plane
+ * ```
+ *
+ * `at` is the texel in the material atlas, `brick_material_atlas_texel` of the slot and the texel.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_material_store: CodeChunk;
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_brick_material_store.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/material/chunk_brick_material_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_brick_material_store.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/material/chunk_brick_material_store.js"],"names":[],"mappings":"AAYA;;GAEG;AACH,mDAFU,wBAAwB,CAIhC;AAEF;;GAEG;AACH,wDAFU,wBAAwB,CAIhC;AAEF;;GAEG;AACH,qDAFU,wBAAwB,CAIhC;AAEF;;;;;;;;;;;;;GAaG;AACH,yCAFU,SAAS,CAqBZ;yCAzDkC,sDAAsD;0BADrE,uCAAuC"}

package/src/shade/renderer/global_illumination/probe_clipmap/material/chunk_brick_material_store.js

@@ -0,0 +1,71 @@
+import { MESH_SDF_BRICK_TEXELS } from "../../../geometry/sdf/MESH_SDF.js";
+import { chunk_surface_material_store } from "../../../geometry/sdf/surface/chunk_surface_material_store.js";
+import {
+    SURFACE_MATERIAL_ALBEDO_PLANE,
+    SURFACE_MATERIAL_EMISSIVE_PLANE,
+    SURFACE_MATERIAL_FORMATS,
+    SURFACE_MATERIAL_METAL_ROUGH_PLANE
+} from "../../../geometry/sdf/surface/SURFACE_MATERIAL.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { chunk_tile_atlas_slot_origin } from "../../../texture/atlas/chunk_tile_atlas_slot_origin.js";
+
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_MATERIAL_ALBEDO_STORE_RESOURCE = ShaderResourceDescriptor.storageTexture(
+    "brick_material_albedo_store", SURFACE_MATERIAL_FORMATS[SURFACE_MATERIAL_ALBEDO_PLANE], "3d", "write-only"
+);
+
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_MATERIAL_METAL_ROUGH_STORE_RESOURCE = ShaderResourceDescriptor.storageTexture(
+    "brick_material_metal_rough_store", SURFACE_MATERIAL_FORMATS[SURFACE_MATERIAL_METAL_ROUGH_PLANE], "3d", "write-only"
+);
+
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_MATERIAL_EMISSIVE_STORE_RESOURCE = ShaderResourceDescriptor.storageTexture(
+    "brick_material_emissive_store", SURFACE_MATERIAL_FORMATS[SURFACE_MATERIAL_EMISSIVE_PLANE], "3d", "write-only"
+);
+
+/**
+ * A texel's material written into its slot's planes (`chunk_brick_material.js`), through
+ * `surface_material_store`:
+ *
+ * ```wgsl
+ * fn brick_material_atlas_texel(slot: u32, texel: vec3<u32>) -> vec3<u32>
+ * fn brick_material_store(at: vec3<u32>, fitted: SurfaceMaterialFitted) // a fit that covered nothing clears
+ * fn brick_material_clear(at: vec3<u32>)                                 // no material: 0 in every plane
+ * ```
+ *
+ * `at` is the texel in the material atlas, `brick_material_atlas_texel` of the slot and the texel.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_material_store = CodeChunk.from(
+    //language=WGSL
+    `
+fn brick_material_atlas_texel(slot: u32, texel: vec3<u32>) -> vec3<u32> {
+    let t = ${MESH_SDF_BRICK_TEXELS}u;
+
+    return tile_atlas_slot_origin(slot, textureDimensions(brick_material_albedo_store).xy / t, vec3<u32>(t)) + texel;
+}
+
+fn brick_material_clear(at: vec3<u32>) {
+    surface_material_clear(brick_material_albedo_store, brick_material_metal_rough_store, brick_material_emissive_store, at);
+}
+
+fn brick_material_store(at: vec3<u32>, fitted: SurfaceMaterialFitted) {
+    surface_material_store(brick_material_albedo_store, brick_material_metal_rough_store, brick_material_emissive_store, at, fitted);
+}
+`, [
+        chunk_tile_atlas_slot_origin,
+        chunk_surface_material_store,
+    ]);
+
+chunk_brick_material_store.requireResource(BRICK_MATERIAL_ALBEDO_STORE_RESOURCE);
+chunk_brick_material_store.requireResource(BRICK_MATERIAL_METAL_ROUGH_STORE_RESOURCE);
+chunk_brick_material_store.requireResource(BRICK_MATERIAL_EMISSIVE_STORE_RESOURCE);

package/src/shade/renderer/global_illumination/probe_clipmap/material/shader_brick_material_gather.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @type {WebGPUStruct}
+ */
+export const BRICK_MATERIAL_GATHER_SETTINGS: WebGPUStruct;
+/**
+ * The brick material of the frame's taken cells, gathered from the Model Surface Caches: a thread a
+ * texel, dispatched through `BRICK_TAKE_TEXEL_DISPATCH` after store and the providers' merge. A cell
+ * store left without a slot does nothing.
+ *
+ * Every texel of a cell with a slot is cleared to no material, since the slot may have held another
+ * cell's. A texel whose nearest surface point is under its tent, |d|·|n|∞ < 1 voxel of the field's
+ * distance d and normal n there, takes its material from the surface it holds: the `meshes` row the
+ * providers left it (`BRICK_STAGING_SURFACE_WORDS`, contract 8), that row's (geometry, material) pair's
+ * cache (`mesh_surface_rows`), read at the texel moved into the geometry's space, at the level of its
+ * field the mesh provider sampled its distance from (`mesh_brick_instance`), surfaces within
+ * {@link BRICK_TRACE_HIT_VOXELS} of the nearest one blended (`mesh_surface_sample`). A row with no cache
+ * resident, and a point the cache holds nothing at, leave the texel without material.
+ *
+ * Reads the caches, the fields and the scene's transforms: no ray, no BLAS, no material table.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_brick_material_gather: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_brick_material_gather.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/material/shader_brick_material_gather.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_brick_material_gather.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/material/shader_brick_material_gather.js"],"names":[],"mappings":"AA0CA;;GAEG;AACH,6CAFU,YAAY,CAOY;AAmClC;;;;;;;;;;;;;;;;;GAiBG;AACH,2CAFU,aAAa,CA0EpB;6BA1J0B,sCAAsC;8BALrC,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/material/shader_brick_material_gather.js

@@ -0,0 +1,176 @@
+import { GPU_DATABASE_NULL } from "../../../buffer/table/GPU_DATABASE_NULL.js";
+import { MESH_SDF_BRICK_TEXEL_COUNT } from "../../../geometry/sdf/MESH_SDF.js";
+import {
+    MESH_SDF_ATLAS_RESOURCE,
+    MESH_SDF_HEADERS_RESOURCE,
+    MESH_SDF_INDIRECTION_RESOURCE,
+    MESH_SDF_SAMPLER_RESOURCE
+} from "../../../geometry/sdf/MESH_SDF_RESOURCES.js";
+import { chunk_mesh_surface_sample } from "../../../geometry/sdf/surface/chunk_mesh_surface_sample.js";
+import {
+    MESH_SURFACE_DATA_RESOURCE,
+    MESH_SURFACE_RECORDS_RESOURCE,
+    MESH_SURFACE_ROWS_RESOURCE
+} from "../../../geometry/sdf/surface/MESH_SURFACE_RESOURCES.js";
+import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { BRICK_THREAD_WORKGROUP_SIZE } from "../brick/BRICK_CLIPMAP.js";
+import { BRICK_RING_RESOURCE, BRICK_TAKE_RESOURCE } from "../brick/chunk_brick_clipmap.js";
+import {
+    BRICK_ATLAS_TEXTURE_RESOURCE,
+    BRICK_LEVELS_RESOURCE,
+    BRICK_MAP_TEXTURE_RESOURCE,
+    BRICK_SAMPLER_RESOURCE,
+    BRICK_TRACE_HIT_VOXELS,
+    chunk_brick_clipmap_sample
+} from "../brick/chunk_brick_clipmap_trace.js";
+import { chunk_brick_provider } from "../brick/chunk_brick_provider.js";
+import { chunk_mesh_brick_instance } from "../brick/mesh/chunk_mesh_brick_instance.js";
+import { chunk_brick_material_cell, chunk_brick_material_texel } from "./chunk_brick_material_cell.js";
+import {
+    BRICK_MATERIAL_ALBEDO_STORE_RESOURCE,
+    BRICK_MATERIAL_EMISSIVE_STORE_RESOURCE,
+    BRICK_MATERIAL_METAL_ROUGH_STORE_RESOURCE,
+    chunk_brick_material_store
+} from "./chunk_brick_material_store.js";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const BRICK_MATERIAL_GATHER_SETTINGS = WebGPUStruct.from({
+    /** keys `brick_ring` holds, a power of two */
+    ring_capacity: u32,
+    /** cells a cascade's window has a side */
+    resolution: u32,
+}, "BrickMaterialGatherSettings");
+
+/**
+ * The taken cells' staging as the gather reads it, after the providers and the store
+ * (`BRICK_STAGING_RESOURCE`).
+ * @type {ShaderResourceDescriptor}
+ */
+const BRICK_STAGING_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("brick_staging", WebGPUArray.u32);
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", BRICK_MATERIAL_GATHER_SETTINGS);
+
+resources.createGroup()
+    .add(BRICK_LEVELS_RESOURCE)
+    .add(BRICK_MAP_TEXTURE_RESOURCE)
+    .add(BRICK_ATLAS_TEXTURE_RESOURCE)
+    .add(BRICK_SAMPLER_RESOURCE)
+    .add(BRICK_TAKE_RESOURCE)
+    .add(BRICK_RING_RESOURCE)
+    .add(BRICK_STAGING_READ_RESOURCE)
+    .add(BRICK_MATERIAL_ALBEDO_STORE_RESOURCE)
+    .add(BRICK_MATERIAL_METAL_ROUGH_STORE_RESOURCE)
+    .add(BRICK_MATERIAL_EMISSIVE_STORE_RESOURCE);
+
+resources.createGroup()
+    .addStorageBuffer("scene_database", WebGPUArray.from(u32))
+    .add(MESH_SDF_HEADERS_RESOURCE)
+    .add(MESH_SDF_INDIRECTION_RESOURCE)
+    .add(MESH_SDF_ATLAS_RESOURCE)
+    .add(MESH_SDF_SAMPLER_RESOURCE)
+    .add(MESH_SURFACE_RECORDS_RESOURCE)
+    .add(MESH_SURFACE_ROWS_RESOURCE)
+    .add(MESH_SURFACE_DATA_RESOURCE);
+
+/**
+ * The brick material of the frame's taken cells, gathered from the Model Surface Caches: a thread a
+ * texel, dispatched through `BRICK_TAKE_TEXEL_DISPATCH` after store and the providers' merge. A cell
+ * store left without a slot does nothing.
+ *
+ * Every texel of a cell with a slot is cleared to no material, since the slot may have held another
+ * cell's. A texel whose nearest surface point is under its tent, |d|·|n|∞ < 1 voxel of the field's
+ * distance d and normal n there, takes its material from the surface it holds: the `meshes` row the
+ * providers left it (`BRICK_STAGING_SURFACE_WORDS`, contract 8), that row's (geometry, material) pair's
+ * cache (`mesh_surface_rows`), read at the texel moved into the geometry's space, at the level of its
+ * field the mesh provider sampled its distance from (`mesh_brick_instance`), surfaces within
+ * {@link BRICK_TRACE_HIT_VOXELS} of the nearest one blended (`mesh_surface_sample`). A row with no cache
+ * resident, and a point the cache holds nothing at, leave the texel without material.
+ *
+ * Reads the caches, the fields and the scene's transforms: no ray, no BLAS, no material table.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_brick_material_gather = ComputeShader.from({
+    label: "Brick Material Gather",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${BRICK_THREAD_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let thread = folded_workgroup_index(workgroup_id) * ${BRICK_THREAD_WORKGROUP_SIZE}u + lane;
+    let build = thread / ${MESH_SDF_BRICK_TEXEL_COUNT}u;
+    let index = thread % ${MESH_SDF_BRICK_TEXEL_COUNT}u;
+
+    if (build >= brick_take[BRICK_TAKE_COUNT]) {
+        return;
+    }
+
+    let taken = brick_material_cell_entry(build, settings.ring_capacity, settings.resolution);
+
+    if (!brick_clipmap_entry_holds_slot(taken.entry)) {
+        return;
+    }
+
+    let t = brick_material_texel(index);
+    let at = brick_material_atlas_texel(taken.entry, t);
+
+    brick_material_clear(at);
+
+    // in voxels: a voxel of 1
+    let local = vec3<f32>(t);
+    let d = brick_clipmap_sample(taken.entry, local, 1.0);
+    let n = brick_clipmap_normal(taken.entry, local);
+
+    if (!(any(n != vec3<f32>(0.0)) && abs(d) * max(max(abs(n.x), abs(n.y)), abs(n.z)) < 1.0)) {
+        return;
+    }
+
+    let row = brick_staging[build * BRICK_STAGING_WORDS + BRICK_STAGING_SURFACE_WORDS + index];
+
+    if (row == 0u) {
+        return;
+    }
+
+    let cache = mesh_surface_rows[row];
+
+    if (cache == ${GPU_DATABASE_NULL}u) {
+        return;
+    }
+
+    let cell = brick_provider_cell(taken.key, settings.resolution);
+    let p = vec4<f32>(cell.corner + local * cell.voxel, 1.0);
+    let instance = mesh_brick_instance(row, cell.voxel);
+    let q = vec3<f32>(dot(instance.to_local_0, p), dot(instance.to_local_1, p), dot(instance.to_local_2, p));
+
+    let seen = mesh_surface_sample(mesh_surface_records[cache], mesh_sdf_headers[instance.geometry], instance.level, q, ${BRICK_TRACE_HIT_VOXELS});
+
+    if (seen.found) {
+        brick_material_store(at, SurfaceMaterialFitted(true, seen.albedo, seen.metal_rough, seen.emissive));
+    }
+}
+`, [
+            chunk_folded_workgroup_index,
+            chunk_brick_material_cell,
+            chunk_brick_material_texel,
+            chunk_brick_material_store,
+            chunk_brick_clipmap_sample,
+            chunk_brick_provider,
+            chunk_mesh_brick_instance,
+            chunk_mesh_surface_sample,
+        ]),
+});

package/src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.d.ts

@@ -13,7 +13,7 @@
  *   stacked along z: the slot of the point's probe, or none. Allocated whole, since the lattice follows
  *   from the structure alone.
  * - a slot each: a state of two words, the kind and updates and then where relocation moved it
- *   (`PROBE_CLIPMAP.js`), a 48-byte record (`PROBE_RECORD_STRUCT`), an octahedral radiance tile of
+ *   (`PROBE_CLIPMAP.js`), a 64-byte record (`PROBE_RECORD_STRUCT`), an octahedral radiance tile of
  *   {@link radiance_resolution}² texels and a depth-moment tile of {@link depth_resolution}², in two 2-D
  *   tile atlases. The depth tile has a one-texel skirt, which the pick's bilinear tap reads; the radiance
  *   tile has one where {@link radiance_skirt}, for the specular's tap, and none where nothing samples it.
@@ -23,7 +23,10 @@
  *   of the frame's updates, at most U = ⌊ray_budget / rays_per_probe⌋.
  *
  * **A frame's windows** ({@link place}, {@link place_within}): around the anchor, coarsest first, each a
- * parent cell inside its parent; or another clipmap's.
+ * parent cell inside its parent; or another clipmap's. Readers and wants choose a point's cascade by
+ * selection boxes centred on the anchor itself, `PROBE_SELECTION_INSET` short of half a window (§9.1,
+ * "Selection"): the windows move a step at a time, the boxes with the anchor, so the blend between
+ * cascades moves as the anchor does.
  *
  * **A frame's lifetime** ({@link graph_update}, §8.3, §8.5): retire frees the probes whose points left
  * their windows and those the last frame's schedule evicted, the wants mark the cages they read, admit
@@ -58,7 +61,9 @@ export class GPUProbeClipmap {
      *        the record's cascade field, {@link PROBE_RECORD_CASCADE_SHIFT}
      * @param {number} options.resolution a power of two, at most 1024: the order's Morton code takes 10 bits
      *        an axis; the indirection's height, resolution · cascade_count, at most the device's
-     *        `maxTextureDimension3D`
+     *        `maxTextureDimension3D`; past twice {@link PROBE_SELECTION_INSET}, so a selection box holds points;
+     *        and with more than one cascade, from 8, so the nesting never holds a window further from the anchor
+     *        than the inset allows (§9.1, "Selection")
      * @param {number} options.spacing metres
      * @param {number} options.radiance_resolution a power of two from 2, which the update's bit-reversed
      *        walk of the texels needs
@@ -186,8 +191,8 @@ export class GPUProbeClipmap {
      */
     built_for(settings: ProbeClipmapSettings): boolean;
     /**
-     * Place the windows around the anchor, coarsest first, each a parent cell inside its parent, for the
-     * frame's {@link graph_update}.
+     * Place the windows around the anchor, coarsest first, each a parent cell inside its parent, and the
+     * selection boxes on the anchor, for the frame's {@link graph_update}.
      *
      * @param {number} x the anchor, world metres
      * @param {number} y
@@ -198,7 +203,8 @@ export class GPUProbeClipmap {
      * Take another clipmap's windows, as {@link place} last placed them, at 2^k this clipmap's lattice
      * (WORLD_PROBE_CACHE_SCOPE_2026_11_01.md §1.2): the same cascades, each the other's window and spacing over
      * 2^k, its corner 2^k the other's, so every point of the other's lattice is one of this clipmap's and the
-     * two scroll together. k is the ratio of the resolutions, a power of two from 2.
+     * two scroll together. k is the ratio of the resolutions, a power of two from 2. The selection boxes are the
+     * other's too: the same anchor, the same half side in metres.
      *
      * @param {GPUProbeClipmap} clipmap placed this frame
      */
@@ -211,7 +217,6 @@ export class GPUProbeClipmap {
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {ProbeClipmapWants} options.wants who wants the frame's probes
-     * @param {*} options.stbn the 2-channel spatio-temporal blue noise, `STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2`
      * @param {number} options.response_frames frames over which a re-sampled neighbour's history goes stale, τ
      * @param {number} options.ray_budget rays a frame
      * @param {number} options.rays_per_probe rays an update, R: the frame updates ⌊ray_budget / R⌋ probes at most
@@ -220,8 +225,9 @@ export class GPUProbeClipmap {
      * @param {number} options.bricks the graph handle of the brick clipmap's last write this frame, which
      *   the update orders after
      * @param {import("../../../scene/GPUSceneContext.js").GPUSceneContext} options.scene the scene the rays
-     *   light and shade: its lights, its environment, its rows and their geometry caches' cards
-     * @param {GPUBuffer} options.card_rows the row → card set table, a word a `meshes` row
+     *   light: its lights and its environment
+     * @param {{write_bindings: function(Object): Object}} options.material what binds the brick material's planes
+     *   for the shade (`GPUBrickMaterial#write_bindings`): the material the bricks carry
      * @param {boolean} options.history_resampling whether each update re-samples its neighbours' histories, adding
      *   what they have seen to its rays (`shader_probe_clipmap_resample`); never where the radiance has no skirt
      * @param {boolean} options.ray_resampling whether each update re-samples one neighbour's rays of the frame,
@@ -230,18 +236,22 @@ export class GPUProbeClipmap {
      *   bricks' cascades, which the hits' local lights come from
      * @param {GPUProbeClipmap} options.bounce_first the clipmap a hit takes its next bounce from first
      * @param {GPUProbeClipmap} options.bounce_fallback the clipmap it takes it from where the first has no probe
+     * @param {number} options.exposure the graph handle of the factor the display multiplies radiance by ahead of its
+     *   tone curve, a single f32, as the last frame was shown: the exposure the probes' estimators state their
+     *   thresholds in
      */
-    graph_update({ graph, wants, stbn, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, card_rows, history_resampling, ray_resampling, clusters, bounce_first, bounce_fallback }: {
+    graph_update({ graph, wants, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, material, history_resampling, ray_resampling, clusters, bounce_first, bounce_fallback, exposure }: {
         graph: FrameGraph;
         wants: ProbeClipmapWants;
-        stbn: any;
         response_frames: number;
         ray_budget: number;
         rays_per_probe: number;
         brick_clipmap: import("../brick/GPUBrickClipmap.js").GPUBrickClipmap;
         bricks: number;
         scene: import("../../../scene/GPUSceneContext.js").GPUSceneContext;
-        card_rows: GPUBuffer;
+        material: {
+            write_bindings: (arg0: any) => any;
+        };
         history_resampling: boolean;
         ray_resampling: boolean;
         clusters: {
@@ -250,6 +260,7 @@ export class GPUProbeClipmap {
         };
         bounce_first: GPUProbeClipmap;
         bounce_fallback: GPUProbeClipmap;
+        exposure: number;
     }): void;
     destroy(): void;
     #private;