@woosh/meep-engine 3.57.0 → 3.58.0

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/MeshSDFBrickProvider.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @typedef {import("../GPUBrickClipmap.js").BrickProviderContext} BrickProviderContext
+ * @typedef {import("../../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
+ */
+/**
+ * The world's bricks from the meshes' cached fields (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7): a
+ * {@link BrickProvider} like any plugin, registered first. Per taken cell, the instances in the SDF
+ * world whose boxes reach it, each sampled at the level of its field that suits the cascade, merged
+ * into the staging by the minimum of the bytes, with the nearest instance's row as each 2³ cell's
+ * object.
+ *
+ * It reads the view's scene through the context: the TLAS over the mesh rows, the scene database and
+ * the geometry caches. A cell's instances past {@link MESH_BRICK_INSTANCE_LIMIT} are dropped; they and
+ * whatever the gather itself dropped are counted in {@link statistics}.
+ */
+export class MeshSDFBrickProvider {
+    /**
+     * @param {GPUDevice} device
+     */
+    constructor(device: GPUDevice);
+    /**
+     * @returns {GPUBuffer}
+     */
+    get statistics(): GPUBuffer;
+    /**
+     * @param {FrameGraph} graph
+     * @param {BrickProviderContext} context
+     */
+    graph_write_bricks(graph: FrameGraph, context: BrickProviderContext): void;
+    destroy(): void;
+    #private;
+}
+export type BrickProviderContext = import("../GPUBrickClipmap.js").BrickProviderContext;
+export type FrameGraph = import("../../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+//# sourceMappingURL=MeshSDFBrickProvider.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/MeshSDFBrickProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MeshSDFBrickProvider.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/MeshSDFBrickProvider.js"],"names":[],"mappings":"AAKA;;;GAGG;AAEH;;;;;;;;;;GAUG;AACH;IAuBI;;OAEG;IACH,+BAUC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,0BAHW,UAAU,WACV,oBAAoB,QAgB9B;IA+BD,gBAOC;;CACJ;mCArHY,OAAO,uBAAuB,EAAE,oBAAoB;yBACpD,OAAO,oEAAoE,EAAE,UAAU"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/MeshSDFBrickProvider.js

@@ -0,0 +1,124 @@
+import { assert } from "../../../../../../core/assert.js";
+import { BufferDescriptor } from "../../../../../descriptor/buffer/BufferDescriptor.js";
+import { BRICK_TAKE_CELL_DISPATCH } from "../BRICK_CLIPMAP.js";
+import { MESH_BRICK_STATISTIC_WORDS, shader_mesh_brick_provider } from "./shader_mesh_brick_provider.js";
+
+/**
+ * @typedef {import("../GPUBrickClipmap.js").BrickProviderContext} BrickProviderContext
+ * @typedef {import("../../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
+ */
+
+/**
+ * The world's bricks from the meshes' cached fields (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7): a
+ * {@link BrickProvider} like any plugin, registered first. Per taken cell, the instances in the SDF
+ * world whose boxes reach it, each sampled at the level of its field that suits the cascade, merged
+ * into the staging by the minimum of the bytes, with the nearest instance's row as each 2³ cell's
+ * object.
+ *
+ * It reads the view's scene through the context: the TLAS over the mesh rows, the scene database and
+ * the geometry caches. A cell's instances past {@link MESH_BRICK_INSTANCE_LIMIT} are dropped; they and
+ * whatever the gather itself dropped are counted in {@link statistics}.
+ */
+export class MeshSDFBrickProvider {
+    /** @type {GPUDevice} */
+    #device;
+
+    /**
+     * Counts that accumulate: instances dropped past the limit, candidates and subtrees the gather
+     * dropped (`shader_mesh_brick_provider.js`).
+     * @type {GPUBuffer}
+     */
+    #statistics;
+
+    #settings = { ring_capacity: 0, resolution: 0 };
+    #bindings = {};
+    #data = { take: -1, staging: -1 };
+
+    /**
+     * The context of the frame being recorded, as its pass executes.
+     * @type {BrickProviderContext|null}
+     */
+    #context = null;
+
+    #destroyed = false;
+
+    /**
+     * @param {GPUDevice} device
+     */
+    constructor(device) {
+        assert.defined(device, 'device');
+
+        this.#device = device;
+
+        this.#statistics = device.createBuffer(BufferDescriptor.fromJSON({
+            label: 'Probe clipmap / mesh brick statistics',
+            size: 4 * MESH_BRICK_STATISTIC_WORDS,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+        }));
+    }
+
+    /**
+     * @returns {GPUBuffer}
+     */
+    get statistics() {
+        return this.#statistics;
+    }
+
+    /**
+     * @param {FrameGraph} graph
+     * @param {BrickProviderContext} context
+     */
+    graph_write_bricks(graph, context) {
+        assert.notOk(this.#destroyed, 'destroyed');
+        assert.defined(context.scene, 'context.scene');
+
+        const data = this.#data;
+        const pass = graph.add("Brick Clipmap Mesh Provider", data, this.#execute);
+
+        data.take = pass.read(context.take);
+        data.staging = pass.write(context.staging);
+
+        // the next provider and the store come after this one's merge
+        context.staging = data.staging;
+
+        this.#context = context;
+    }
+
+    #execute = (data, resources, execution) => {
+        const context = this.#context;
+        const scene = context.scene;
+        const take = resources.get(data.take);
+
+        const settings = this.#settings;
+
+        settings.ring_capacity = context.ring_capacity;
+        settings.resolution = context.resolution;
+
+        const b = scene.geometries.sdf.write_bindings(this.#bindings);
+
+        b.settings = settings;
+        b.brick_take = take;
+        b.brick_ring = context.ring;
+        b.brick_staging = resources.get(data.staging);
+        b.brick_levels = context.levels;
+        b.mesh_brick_statistics = this.#statistics;
+        b.tlas = scene.tlas.buffer;
+        b.scene_database = scene.scene_database_buffer;
+
+        shader_mesh_brick_provider.dispatchIndirect({
+            encoder: execution.encoder,
+            bindings: b,
+            command: take,
+            command_offset: 4 * BRICK_TAKE_CELL_DISPATCH,
+        });
+    };
+
+    destroy() {
+        if (this.#destroyed) {
+            return;
+        }
+
+        this.#destroyed = true;
+        this.#statistics.destroy();
+    }
+}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_instance.d.ts

@@ -0,0 +1,29 @@
+/**
+ * What the mesh provider asks of a `meshes` row (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7), on the
+ * scene database and the geometry caches' headers:
+ *
+ * ```wgsl
+ * fn mesh_brick_accept(row: u32, bounds: array<f32, 6>, voxel: f32) -> bool
+ * fn mesh_brick_instance(row: u32, voxel: f32) -> MeshBrickInstance
+ * ```
+ *
+ * `mesh_brick_accept` is the gather's leaf filter, with `bounds` the row's world box and `voxel` the
+ * cascade's: the row is in the SDF world, its geometry's field is resident (a skinned clone's through
+ * its source's, the hook), and its box is at least half a voxel across. A virtual geometry has no
+ * header, so it is not resident and is the vgeo provider's (§7.8). Under the cull an instance is out
+ * of the cascade, emissive or not: the half-voxel hit would make it a lamp a voxel wide, 4 m at
+ * cascade 5.
+ *
+ * `mesh_brick_instance` makes the instance the texels sample: the inverse of its transform, its box,
+ * its smallest axis scale, and the coarsest level of its field no coarser than the cascade,
+ * `clamp(floor(log2(voxel / (sigma · v))), 0, levels - 1)`. Inside the clamp the level's voxel is
+ * within a factor of two of the cascade's and its band reaches past half the cascade's; at the clamps
+ * an instance scaled past the cascade samples level 0, and a small one far away its one-brick level.
+ *
+ * Reads `scene_database` and `mesh_sdf_headers`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_brick_instance: CodeChunk;
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mesh_brick_instance.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mesh_brick_instance.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_instance.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wCAFU,SAAS,CA8DZ;0BAzFmB,0CAA0C"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_instance.js

@@ -0,0 +1,97 @@
+import { chunk_mesh_sdf } from "../../../../geometry/sdf/chunk_mesh_sdf.js";
+import { MESH_SDF_HEADERS_RESOURCE } from "../../../../geometry/sdf/MESH_SDF_RESOURCES.js";
+import { chunk_scene_database_access } from "../../../../scene/chunk_scene_database_access.js";
+import { MESH_FLAG_SDF_WORLD } from "../../../../scene/MESH_INSTANCE_METADATA_STRUCT.js";
+import { chunk_mat4_inverse } from "../../../../shader/chunk/geometry/mat4/chunk_mat4_inverse.js";
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+import { MESH_BRICK_INSTANCE_STRUCT } from "./MESH_BRICK_INSTANCE_STRUCT.js";
+
+/**
+ * What the mesh provider asks of a `meshes` row (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7), on the
+ * scene database and the geometry caches' headers:
+ *
+ * ```wgsl
+ * fn mesh_brick_accept(row: u32, bounds: array<f32, 6>, voxel: f32) -> bool
+ * fn mesh_brick_instance(row: u32, voxel: f32) -> MeshBrickInstance
+ * ```
+ *
+ * `mesh_brick_accept` is the gather's leaf filter, with `bounds` the row's world box and `voxel` the
+ * cascade's: the row is in the SDF world, its geometry's field is resident (a skinned clone's through
+ * its source's, the hook), and its box is at least half a voxel across. A virtual geometry has no
+ * header, so it is not resident and is the vgeo provider's (§7.8). Under the cull an instance is out
+ * of the cascade, emissive or not: the half-voxel hit would make it a lamp a voxel wide, 4 m at
+ * cascade 5.
+ *
+ * `mesh_brick_instance` makes the instance the texels sample: the inverse of its transform, its box,
+ * its smallest axis scale, and the coarsest level of its field no coarser than the cascade,
+ * `clamp(floor(log2(voxel / (sigma · v))), 0, levels - 1)`. Inside the clamp the level's voxel is
+ * within a factor of two of the cascade's and its band reaches past half the cascade's; at the clamps
+ * an instance scaled past the cascade samples level 0, and a small one far away its one-brick level.
+ *
+ * Reads `scene_database` and `mesh_sdf_headers`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_brick_instance = CodeChunk.from(
+    //language=WGSL
+    `
+fn mesh_brick_header_index(geometry: u32) -> u32 {
+    if (mesh_sdf_headers[geometry].state == MESH_SDF_STATE_ALIAS) {
+        return mesh_sdf_headers[geometry].source;
+    }
+
+    return geometry;
+}
+
+fn mesh_brick_accept(row: u32, bounds: array<f32, 6>, voxel: f32) -> bool {
+    let mesh = scene_read_mesh(&scene_database, row);
+
+    if ((mesh.flags & ${MESH_FLAG_SDF_WORLD}u) == 0u) {
+        return false;
+    }
+
+    // the resolution cull
+    let diagonal = length(vec3<f32>(bounds[3] - bounds[0], bounds[4] - bounds[1], bounds[5] - bounds[2]));
+
+    if (diagonal < 0.5 * voxel) {
+        return false;
+    }
+
+    return mesh_sdf_headers[mesh_brick_header_index(mesh.geometry)].state == MESH_SDF_STATE_RESIDENT;
+}
+
+fn mesh_brick_instance(row: u32, voxel: f32) -> ${MESH_BRICK_INSTANCE_STRUCT.wgsl_ref} {
+    let mesh = scene_read_mesh(&scene_database, row);
+    let global = scene_read_node(&scene_database, mesh.node).global;
+    let to_local = mat4_inverse(global);
+
+    var instance: ${MESH_BRICK_INSTANCE_STRUCT.wgsl_ref};
+
+    // rows of the inverse, so a point is three dot products away from the geometry's space
+    instance.to_local_0 = vec4<f32>(to_local[0].x, to_local[1].x, to_local[2].x, to_local[3].x);
+    instance.to_local_1 = vec4<f32>(to_local[0].y, to_local[1].y, to_local[2].y, to_local[3].y);
+    instance.to_local_2 = vec4<f32>(to_local[0].z, to_local[1].z, to_local[2].z, to_local[3].z);
+
+    instance.box_min = vec3<f32>(mesh.bounding_box[0], mesh.bounding_box[1], mesh.bounding_box[2]);
+    instance.box_max = vec3<f32>(mesh.bounding_box[3], mesh.bounding_box[4], mesh.bounding_box[5]);
+
+    instance.sigma = min(length(global[0].xyz), min(length(global[1].xyz), length(global[2].xyz)));
+
+    let geometry = mesh_brick_header_index(mesh.geometry);
+    let header = mesh_sdf_headers[geometry];
+    let level = floor(log2(voxel / (instance.sigma * header.voxel)));
+
+    instance.level = u32(clamp(level, 0.0, f32(header.level_count - 1u)));
+    instance.geometry = geometry;
+    instance.row = row;
+
+    return instance;
+}
+`, [
+        chunk_mesh_sdf,
+        chunk_scene_database_access,
+        chunk_mat4_inverse,
+        MESH_BRICK_INSTANCE_STRUCT.declaration_chunk,
+    ]);
+
+chunk_mesh_brick_instance.requireResource(MESH_SDF_HEADERS_RESOURCE);

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_object.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A world texel's byte and a texel's bid to be its object cell's object
+ * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.2, §7.6):
+ *
+ * ```wgsl
+ * fn mesh_brick_encode(distance: f32, band: f32) -> u32     // saturate(d / 2R + 0.5), in a byte
+ * fn mesh_brick_object_key(byte: u32, row: u32) -> u32      // larger for a nearer texel
+ * fn mesh_brick_object_key_byte(key: u32) -> u32
+ * fn mesh_brick_object_key_row(key: u32) -> u32
+ * ```
+ *
+ * A key is the complement of the byte in its high eight bits and the row in its low 24, so the
+ * largest of a cell's keys, which workgroup atomics can take, is its nearest texel, and among equally
+ * near ones the lowest row: the same object whatever order the lanes ran in. A row past the 24 bits
+ * cannot be named and bids as row 0, no object.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_brick_object: CodeChunk;
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mesh_brick_object.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mesh_brick_object.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_object.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,sCAFU,SAAS,CAsBhB;0BAzCuB,0CAA0C"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_object.js

@@ -0,0 +1,42 @@
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+import { MESH_BRICK_ROW_LIMIT } from "./MESH_BRICK_INSTANCE_STRUCT.js";
+
+/**
+ * A world texel's byte and a texel's bid to be its object cell's object
+ * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.2, §7.6):
+ *
+ * ```wgsl
+ * fn mesh_brick_encode(distance: f32, band: f32) -> u32     // saturate(d / 2R + 0.5), in a byte
+ * fn mesh_brick_object_key(byte: u32, row: u32) -> u32      // larger for a nearer texel
+ * fn mesh_brick_object_key_byte(key: u32) -> u32
+ * fn mesh_brick_object_key_row(key: u32) -> u32
+ * ```
+ *
+ * A key is the complement of the byte in its high eight bits and the row in its low 24, so the
+ * largest of a cell's keys, which workgroup atomics can take, is its nearest texel, and among equally
+ * near ones the lowest row: the same object whatever order the lanes ran in. A row past the 24 bits
+ * cannot be named and bids as row 0, no object.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_brick_object = CodeChunk.from(
+    //language=WGSL
+    `
+fn mesh_brick_encode(distance: f32, band: f32) -> u32 {
+    return u32(round(saturate(distance / (2.0 * band) + 0.5) * 255.0));
+}
+
+fn mesh_brick_object_key(byte: u32, row: u32) -> u32 {
+    let named = select(0u, row, row < ${MESH_BRICK_ROW_LIMIT}u);
+
+    return ~((byte << 24u) | named);
+}
+
+fn mesh_brick_object_key_byte(key: u32) -> u32 {
+    return (~key) >> 24u;
+}
+
+fn mesh_brick_object_key_row(key: u32) -> u32 {
+    return (~key) & ${MESH_BRICK_ROW_LIMIT - 1}u;
+}
+`);

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_texel.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A world brick texel's distance from the mesh provider's instances (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md
+ * §7.7): the minimum over them of `sigma · mesh_sdf_sample(header, level, M⁻¹·p)`, and the row it
+ * came from.
+ *
+ * ```wgsl
+ * struct MeshBrickTexel { distance: f32, row: u32 } // F32_MAX and 0 with no instance
+ * fn mesh_brick_texel(p: vec3<f32>, count: u32) -> MeshBrickTexel
+ * ```
+ *
+ * The instances come through a seam the enclosing shader defines, as the cooperative query's tree
+ * does: `fn mesh_brick_instance_at(i: u32) -> MeshBrickInstance`. The provider's kernel answers from
+ * workgroup memory; a test, from a buffer.
+ *
+ * The box test is UE's early-out: an instance whose box lies farther than the running minimum, or
+ * than the surface when the minimum is inside one, cannot give less, and is not sampled. At coarse
+ * cascades most instances are only this test. Per texel: at most `count` box tests, and one
+ * transform, one indirection load and one tap an instance the test lets through. No triangle is read.
+ *
+ * Reads `mesh_sdf_headers` and what `mesh_sdf_sample` reads.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_brick_texel: CodeChunk;
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mesh_brick_texel.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_texel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mesh_brick_texel.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_texel.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qCAFU,SAAS,CA2CZ;0BAnEmB,0CAA0C"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/chunk_mesh_brick_texel.js

@@ -0,0 +1,73 @@
+import { chunk_mesh_sdf_sample } from "../../../../geometry/sdf/chunk_mesh_sdf_sample.js";
+import { MESH_SDF_HEADERS_RESOURCE } from "../../../../geometry/sdf/MESH_SDF_RESOURCES.js";
+import { F32_MAX_DEFINITION } from "../../../../shader/chunk/math/F32_MAX_DEFINITION.js";
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+import { MESH_BRICK_INSTANCE_STRUCT } from "./MESH_BRICK_INSTANCE_STRUCT.js";
+
+/**
+ * A world brick texel's distance from the mesh provider's instances (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md
+ * §7.7): the minimum over them of `sigma · mesh_sdf_sample(header, level, M⁻¹·p)`, and the row it
+ * came from.
+ *
+ * ```wgsl
+ * struct MeshBrickTexel { distance: f32, row: u32 } // F32_MAX and 0 with no instance
+ * fn mesh_brick_texel(p: vec3<f32>, count: u32) -> MeshBrickTexel
+ * ```
+ *
+ * The instances come through a seam the enclosing shader defines, as the cooperative query's tree
+ * does: `fn mesh_brick_instance_at(i: u32) -> MeshBrickInstance`. The provider's kernel answers from
+ * workgroup memory; a test, from a buffer.
+ *
+ * The box test is UE's early-out: an instance whose box lies farther than the running minimum, or
+ * than the surface when the minimum is inside one, cannot give less, and is not sampled. At coarse
+ * cascades most instances are only this test. Per texel: at most `count` box tests, and one
+ * transform, one indirection load and one tap an instance the test lets through. No triangle is read.
+ *
+ * Reads `mesh_sdf_headers` and what `mesh_sdf_sample` reads.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_brick_texel = CodeChunk.from(
+    //language=WGSL
+    `
+struct MeshBrickTexel {
+    distance: f32,
+    row: u32,
+}
+
+fn mesh_brick_texel(p: vec3<f32>, count: u32) -> MeshBrickTexel {
+    var best: MeshBrickTexel;
+
+    best.distance = F32_MAX;
+    best.row = 0u;
+
+    for (var i = 0u; i < count; i++) {
+        let instance = mesh_brick_instance_at(i);
+
+        // the box's distance: 0 inside it, where an instance's surface can still lie nearer
+        let outside = max(max(instance.box_min - p, p - instance.box_max), vec3<f32>(0.0));
+
+        if (length(outside) > max(best.distance, 0.0)) {
+            continue;
+        }
+
+        let position = vec4<f32>(p, 1.0);
+        let local = vec3<f32>(dot(instance.to_local_0, position), dot(instance.to_local_1, position), dot(instance.to_local_2, position));
+
+        let distance = instance.sigma * mesh_sdf_sample(mesh_sdf_headers[instance.geometry], instance.level, local);
+
+        if (distance < best.distance) {
+            best.distance = distance;
+            best.row = instance.row;
+        }
+    }
+
+    return best;
+}
+`, [
+        F32_MAX_DEFINITION,
+        chunk_mesh_sdf_sample,
+        MESH_BRICK_INSTANCE_STRUCT.declaration_chunk,
+    ]);
+
+chunk_mesh_brick_texel.requireResource(MESH_SDF_HEADERS_RESOURCE);

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_provider.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Words of the mesh provider's statistics, every one an atomic that accumulates.
+ */
+export const MESH_BRICK_STATISTIC_INSTANCES_DROPPED: 0;
+export const MESH_BRICK_STATISTIC_CANDIDATES_DROPPED: 1;
+export const MESH_BRICK_STATISTIC_NODES_DROPPED: 2;
+export const MESH_BRICK_STATISTIC_WORDS: 4;
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_BRICK_PROVIDER_SETTINGS: WebGPUStruct;
+/**
+ * The mesh provider's pass (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7): a 64-lane workgroup a taken
+ * cell, dispatched by take.
+ *
+ * **Gather.** A cooperative TLAS query with the cell grown by the cascade's band, every leaf filtered
+ * by `mesh_brick_accept`: in the SDF world, resident, at least half a voxel across. Up to
+ * {@link MESH_BRICK_INSTANCE_LIMIT} instances, a lane each, go into workgroup memory; past it they are
+ * dropped and counted, as are candidates and subtrees the query itself dropped.
+ *
+ * **512 texels, eight a lane**, each `mesh_brick_texel`: the minimum over the instances of their
+ * sampled distance, and its row. A lane merges its texels into its two staging words, which no other
+ * thread touches (contract 1), as the byte minimum (contract 2).
+ *
+ * **Objects** (contract 3): per 2³-texel cell, the provider's row at its own nearest texel replaces the
+ * staged object when the provider's cell minimum is below the staged one from before the merge; ties
+ * keep the staged object. A cell's four lanes fold their texels in through workgroup atomics, and the
+ * last of them decides, so that no lane waits on another.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_brick_provider: ComputeShader;
+import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_mesh_brick_provider.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_mesh_brick_provider.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/mesh/shader_mesh_brick_provider.js"],"names":[],"mappings":"AAkCA;;GAEG;AACH,uDAAwD;AACxD,wDAAyD;AACzD,mDAAoD;AACpD,2CAA4C;AAE5C;;GAEG;AACH,2CAFU,YAAY,CAOU;AA4KhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yCAFU,aAAa,CAMpB;6BAjO0B,yCAAyC;8BAJxC,qCAAqC"}