@woosh/meep-engine 3.61.2 → 3.62.0

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

@@ -0,0 +1,193 @@
+import { assert } from "../../../../../core/assert.js";
+import { MESH_SDF_BRICK_TEXELS } from "../../../geometry/sdf/MESH_SDF.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 { GPUTileAtlas3D } from "../../../texture/atlas/GPUTileAtlas3D.js";
+import { BRICK_TAKE_TEXEL_DISPATCH } from "../brick/BRICK_CLIPMAP.js";
+import { shader_brick_material_gather } from "./shader_brick_material_gather.js";
+
+/**
+ * @typedef {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
+ * @typedef {import("../brick/GPUBrickClipmap.js").BrickProviderContext} BrickProviderContext
+ */
+
+/**
+ * Tiles of the material atlas along x and y; it grows in layers of these, as the brick atlas does.
+ * @type {number}
+ */
+const BRICK_MATERIAL_SLOTS_XY = 16;
+
+/**
+ * The brick clipmap's surface material (`chunk_brick_material.js`): a texel of material a texel of
+ * every brick, gathered from the Model Surface Caches of the surfaces the brick's texels hold when the
+ * brick is built.
+ *
+ * **Storage**: a {@link GPUTileAtlas3D} of the planes `SURFACE_MATERIAL_FORMATS` lists, 8³ a tile, a tile
+ * for each of the brick clipmap's slots, at the slot's index: it reserves the clipmap's capacity at
+ * every build, so it grows when the clipmap does. Readers bind its planes through
+ * {@link write_bindings}.
+ *
+ * **A frame**: the brick clipmap runs it after its store ({@link graph_write_material}), over the
+ * cells the frame took: the gather (`shader_brick_material_gather`) clears their texels and gives each
+ * that holds a surface the material of that surface's cache, through {@link surface_rows}. It reads the
+ * caches, the fields and the transforms the mesh provider read: no ray, no BLAS, no material table.
+ *
+ * A cell that is not rebuilt keeps its material: a cache baked again reaches the bricks through its
+ * rows being invalidated (`ProbeClipmapSceneHolds`).
+ */
+export class GPUBrickMaterial {
+    /** @type {GPUDevice} */
+    #device;
+
+    /** @type {GPUTileAtlas3D} */
+    #atlas;
+
+    /** @type {BrickProviderContext|null} */
+    #context = null;
+
+    #data = { take: -1, staging: -1, state: -1 };
+
+    #settings = { ring_capacity: 0, resolution: 0 };
+
+    #bindings = {};
+
+    #destroyed = false;
+
+    /**
+     * The row → Model Surface Cache table the gather finds a texel's cache in, a word a `meshes` row
+     * (`ProbeClipmapSceneHolds#surface_rows_buffer`). Replaced when it grows: set it each frame.
+     * @type {GPUBuffer|null}
+     */
+    surface_rows = null;
+
+    /**
+     * @param {GPUDevice} device
+     * @param {object} options
+     * @param {number} options.capacity slots to start with: the brick clipmap's
+     */
+    constructor(device, { capacity }) {
+        assert.defined(device, 'device');
+        assert.isPositiveInteger(capacity, 'capacity');
+
+        this.#device = device;
+
+        this.#atlas = new GPUTileAtlas3D({
+            device,
+            formats: [...SURFACE_MATERIAL_FORMATS],
+            content_size: [MESH_SDF_BRICK_TEXELS, MESH_SDF_BRICK_TEXELS, MESH_SDF_BRICK_TEXELS],
+            border: 0,
+            slots_x: BRICK_MATERIAL_SLOTS_XY,
+            slots_y: BRICK_MATERIAL_SLOTS_XY,
+            capacity,
+            // loaded by the hits' readers, stored into by the gather
+            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING,
+            label: 'Probe clipmap / brick material',
+        });
+
+        this.#atlas.reserve(capacity);
+    }
+
+    /**
+     * @returns {GPUTileAtlas3D}
+     */
+    get atlas() {
+        return this.#atlas;
+    }
+
+    /**
+     * Put what the material's readers (`chunk_brick_material.js`) take into their bindings, under the
+     * names they take. The planes are replaced when the capacity grows: take them each frame.
+     *
+     * @param {Object} bindings
+     * @returns {Object} bindings
+     */
+    write_bindings(bindings) {
+        bindings.brick_material_albedo_codes = this.#atlas.texture_at(SURFACE_MATERIAL_ALBEDO_PLANE).obtainView();
+        bindings.brick_material_metal_rough_codes = this.#atlas.texture_at(SURFACE_MATERIAL_METAL_ROUGH_PLANE).obtainView();
+        bindings.brick_material_emissive_codes = this.#atlas.texture_at(SURFACE_MATERIAL_EMISSIVE_PLANE).obtainView();
+
+        return bindings;
+    }
+
+    /**
+     * Record the gather of the frame's taken cells, after the brick clipmap's store: `GPUBrickClipmap`
+     * calls it from its build with the build's context, the store's state handle in it, and its handle
+     * is replaced with this pass's, which the bricks' readers come after.
+     *
+     * @param {FrameGraph} graph
+     * @param {BrickProviderContext} context
+     */
+    graph_write_material(graph, context) {
+        assert.notOk(this.#destroyed, 'destroyed');
+        assert.defined(context.clipmap, 'context.clipmap');
+        assert.defined(context.scene, 'context.scene');
+        assert.notNull(this.surface_rows, 'surface_rows');
+
+        // a tile for each of the clipmap's slots, however it has grown
+        this.#atlas.reserve(context.clipmap.capacity);
+
+        const data = this.#data;
+        const pass = graph.add("Brick Clipmap Material", data, this.#execute);
+
+        data.take = pass.read(context.take);
+        data.staging = pass.read(context.staging);
+        data.state = pass.write(context.state);
+
+        pass.make_side_effect();
+
+        context.state = data.state;
+
+        this.#context = context;
+    }
+
+    #execute = (data, resources, context) => {
+        const frame = this.#context;
+        const scene = frame.scene;
+        const sdf = scene.geometries.sdf;
+        const b = this.#bindings;
+
+        const take = resources.get(data.take);
+
+        frame.clipmap.write_bindings(b);
+        sdf.write_bindings(b);
+        sdf.surfaces.write_bindings(b);
+
+        b.brick_take = take;
+        b.brick_ring = frame.ring;
+        b.brick_staging = resources.get(data.staging);
+        b.brick_material_albedo_store = this.#atlas.texture_at(SURFACE_MATERIAL_ALBEDO_PLANE).obtainView();
+        b.brick_material_metal_rough_store = this.#atlas.texture_at(SURFACE_MATERIAL_METAL_ROUGH_PLANE).obtainView();
+        b.brick_material_emissive_store = this.#atlas.texture_at(SURFACE_MATERIAL_EMISSIVE_PLANE).obtainView();
+
+        // the instances the mesh provider read, and the row → cache table
+        b.scene_database = scene.scene_database_buffer;
+        b.mesh_surface_rows = this.surface_rows;
+
+        const settings = this.#settings;
+
+        settings.ring_capacity = frame.ring_capacity;
+        settings.resolution = frame.resolution;
+        b.settings = settings;
+
+        shader_brick_material_gather.dispatchIndirect({
+            encoder: context.encoder,
+            bindings: b,
+            command: take,
+            command_offset: 4 * BRICK_TAKE_TEXEL_DISPATCH,
+        });
+    };
+
+    destroy() {
+        if (this.#destroyed) {
+            return;
+        }
+
+        this.#destroyed = true;
+
+        this.#atlas.destroy();
+    }
+}

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

@@ -0,0 +1,67 @@
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_MATERIAL_ALBEDO_RESOURCE: ShaderResourceDescriptor;
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_MATERIAL_METAL_ROUGH_RESOURCE: ShaderResourceDescriptor;
+/**
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_MATERIAL_EMISSIVE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_brick_material.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_brick_material.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/material/chunk_brick_material.js"],"names":[],"mappings":"AAgBA;;GAEG;AACH,6CAFU,wBAAwB,CAE0F;AAE5H;;GAEG;AACH,kDAFU,wBAAwB,CAEoG;AAEtI;;GAEG;AACH,+CAFU,wBAAwB,CAE8F;AAEhI;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,SAAS,CAqBZ;AAIP;;;;;;;;;GASG;AACH,2CAFU,SAAS,CAWZ;AAIP;;;;;;;;;;GAUG;AACH,gDAFU,SAAS,CAaZ;AAIP;;;;;;;;;GASG;AACH,+CAFU,SAAS,CAWZ;yCArIkC,sDAAsD;0BADrE,uCAAuC"}

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"}