@woosh/meep-engine 3.57.0 → 3.59.0

package/src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/chunk_vgeo_brick_texel.js

@@ -0,0 +1,113 @@
+import { MESH_SDF_BAND_VOXELS, MESH_SDF_BRICK_VOXELS } from "../../../../geometry/sdf/MESH_SDF.js";
+import { F32_MAX_DEFINITION } from "../../../../shader/chunk/math/F32_MAX_DEFINITION.js";
+import {
+    chunk_triangle_closest_point_to_point_barycentric
+} from "../../../../shader/chunk/sdf/chunk_triangle_closest_point_to_point_barycentric.js";
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+import { VGEO_BRICK_TRIANGLE_STRUCT } from "./chunk_vgeo_brick_triangle.js";
+
+/*
+ How far apart, relative, two squared distances may lie and still be one point's. Two triangles that share the
+ nearest point, an edge or a corner, compute it apart by their rounding. In the cell's own space a coordinate is at
+ most the cell and the band from texel 0; a closest point is three f32 roundings of that off, and two of them twice
+ that apart. Half a step of the encoding from the surface, that is the relative difference below, four times over;
+ nearer the surface than that, a texel's sign moves its byte by at most a step.
+*/
+const COORDINATE_VOXELS = MESH_SDF_BRICK_VOXELS + MESH_SDF_BAND_VOXELS;
+const CLOSEST_POINT_ROUNDING_VOXELS = 3 * 2 ** -24 * COORDINATE_VOXELS;
+const HALF_STEP_VOXELS = (2 * MESH_SDF_BAND_VOXELS / 255) / 2;
+
+/**
+ * @type {number}
+ */
+export const VGEO_BRICK_TIE = 4 * 2 * (2 * CLOSEST_POINT_ROUNDING_VOXELS) / HALF_STEP_VOXELS;
+
+/**
+ * A world brick texel's distance from the triangles of a taken cell's cut (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md
+ * §7.8), signed by the nearest triangle's side, and the row it came from.
+ *
+ * ```wgsl
+ * struct VGeoBrickTexel { distance: f32, row: u32 } // F32_MAX and 0 with no triangle within the band
+ * fn vgeo_brick_texel(p: vec3<f32>, count: u32, band: f32) -> VGeoBrickTexel
+ * ```
+ *
+ * `p` is in the triangles' space, the cell's own. The triangles come through a seam the enclosing shader defines,
+ * as the mesh provider's instances do: `fn vgeo_brick_triangle_at(i: u32) -> VGeoBrickTriangle`. The provider's
+ * kernel answers from workgroup memory; a test, from a buffer.
+ *
+ * Only what lies within `band` is told apart: past it a byte saturates, and a texel no triangle comes within is
+ * unsigned, which is positive (§7.8). The nearest triangle decides the sign. Of triangles as near, by
+ * {@link VGEO_BRICK_TIE}, which is a point they share, an edge or a corner, the one whose normal lies most along the
+ * texel's offset from that point decides: where faces meet at an angle, the face the texel stands over. A
+ * triangle with no sides, a material drawn on both, signs positive.
+ *
+ * Per texel: at most `count` reach tests, and a closest point for each triangle the test lets through, which is
+ * one that might come nearer than the nearest so far.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_vgeo_brick_texel = CodeChunk.from(
+    //language=WGSL
+    `
+const VGEO_BRICK_TIE = ${VGEO_BRICK_TIE};
+
+struct VGeoBrickTexel {
+    distance: f32,
+    row: u32,
+}
+
+fn vgeo_brick_texel(p: vec3<f32>, count: u32, band: f32) -> VGeoBrickTexel {
+    var nearest = band * band;
+
+    // the deciding triangle's cos² between its normal and the offset; above any, so the first decides by distance
+    var facing = 2.0;
+    var side = 1.0;
+    var row = 0u;
+    var found = false;
+
+    for (var i = 0u; i < count; i++) {
+        let t = vgeo_brick_triangle_at(i);
+
+        // the whole triangle lies within its reach of a: none of it nearer than this
+        let gap = max(distance(p, t.a) - t.reach, 0.0);
+
+        if (gap * gap >= nearest * (1.0 + VGEO_BRICK_TIE)) {
+            continue;
+        }
+
+        let uv = triangle_closest_point_to_point_barycentric(p, t.a, t.b, t.c);
+        let offset = p - (t.a * uv.x + t.b * uv.y + t.c * (1.0 - uv.x - uv.y));
+        let squared = dot(offset, offset);
+
+        if (squared >= nearest * (1.0 + VGEO_BRICK_TIE)) {
+            continue;
+        }
+
+        let normal = cross(t.b - t.a, t.c - t.a);
+        let along = dot(offset, normal);
+        let scale = squared * dot(normal, normal);
+
+        // 0 for a triangle seen edge-on, or with no area
+        let cos2 = select(0.0, along * along / scale, scale > 0.0);
+
+        if (squared < nearest * (1.0 - VGEO_BRICK_TIE) || cos2 > facing) {
+            facing = cos2;
+            side = select(1.0, select(-1.0, 1.0, along >= 0.0), t.sided != 0u);
+            row = t.row;
+            found = true;
+        }
+
+        nearest = min(nearest, squared);
+    }
+
+    if (!found) {
+        return VGeoBrickTexel(F32_MAX, 0u);
+    }
+
+    return VGeoBrickTexel(side * sqrt(nearest), row);
+}
+`, [
+    F32_MAX_DEFINITION,
+    VGEO_BRICK_TRIANGLE_STRUCT.declaration_chunk,
+    chunk_triangle_closest_point_to_point_barycentric,
+]);

package/src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/chunk_vgeo_brick_triangle.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A triangle of a taken cell's cut as the distance pass holds it (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8), 48
+ * bytes: its corners in the cell's own space, wound so that `(b - a) × (c - a)` points out of the surface; `reach`,
+ * how far from `a` its farther corner lies, which bounds the whole triangle; its `meshes` row; and `sided`, 0 for a
+ * material drawn on both sides, which has no inside to sign.
+ * @type {WebGPUStruct}
+ */
+export const VGEO_BRICK_TRIANGLE_STRUCT: WebGPUStruct;
+/**
+ * A triangle of a cluster in a taken cell's cut, for the distance pass (§7.8):
+ *
+ * ```wgsl
+ * fn vgeo_brick_triangle_reaches(pair_base: u32, positions: TrianglePositions) -> bool
+ * fn vgeo_brick_triangle(
+ *     positions: TrianglePositions, global: mat4x4<f32>, origin: vec3<f32>, reversed: bool, sided: bool, row: u32
+ * ) -> VGeoBrickTriangle
+ * ```
+ *
+ * `vgeo_brick_triangle_reaches` is the pass's cull, in the instance's own space: the triangle's box meets its
+ * pair's, the cell grown by the band. A triangle outside it lies farther than the band from every texel, where a
+ * texel's byte saturates, so it could change no byte.
+ *
+ * `vgeo_brick_triangle` places one. Its corners go into the world by `global`, less `origin`, the cell's texel 0,
+ * so that a texel's arithmetic runs on numbers the size of the cell; the translation is taken less `origin` first,
+ * so a cell far from the world's origin keeps that precision. `reversed`, where the instance mirrors or its
+ * material draws the back (`triangle_winding_is_reversed`), swaps b and c, so the normal points out of the surface
+ * the instance draws.
+ *
+ * Requires the importing shader to declare `instances`, the pair records.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_vgeo_brick_triangle: CodeChunk;
+import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_vgeo_brick_triangle.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/chunk_vgeo_brick_triangle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_vgeo_brick_triangle.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/chunk_vgeo_brick_triangle.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,yCAFU,YAAY,CASE;AAExB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wCAFU,SAAS,CAwChB;6BAjF0B,yCAAyC;0BAF5C,0CAA0C"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/chunk_vgeo_brick_triangle.js

@@ -0,0 +1,85 @@
+import { TRIANGLE_POSITIONS_STRUCT } from "../../../../shader/chunk/geometry/triangle/TRIANGLE_POSITIONS_STRUCT.js";
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+import { f32, u32, vec3f } from "../../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../../shader/type/WebGPUStruct.js";
+import { chunk_vgeo_brick_box } from "./chunk_vgeo_brick_box.js";
+
+/**
+ * A triangle of a taken cell's cut as the distance pass holds it (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8), 48
+ * bytes: its corners in the cell's own space, wound so that `(b - a) × (c - a)` points out of the surface; `reach`,
+ * how far from `a` its farther corner lies, which bounds the whole triangle; its `meshes` row; and `sided`, 0 for a
+ * material drawn on both sides, which has no inside to sign.
+ * @type {WebGPUStruct}
+ */
+export const VGEO_BRICK_TRIANGLE_STRUCT = WebGPUStruct.from({
+    a: vec3f,
+    row: u32,
+    b: vec3f,
+    reach: f32,
+    c: vec3f,
+    sided: u32,
+}, 'VGeoBrickTriangle');
+
+/**
+ * A triangle of a cluster in a taken cell's cut, for the distance pass (§7.8):
+ *
+ * ```wgsl
+ * fn vgeo_brick_triangle_reaches(pair_base: u32, positions: TrianglePositions) -> bool
+ * fn vgeo_brick_triangle(
+ *     positions: TrianglePositions, global: mat4x4<f32>, origin: vec3<f32>, reversed: bool, sided: bool, row: u32
+ * ) -> VGeoBrickTriangle
+ * ```
+ *
+ * `vgeo_brick_triangle_reaches` is the pass's cull, in the instance's own space: the triangle's box meets its
+ * pair's, the cell grown by the band. A triangle outside it lies farther than the band from every texel, where a
+ * texel's byte saturates, so it could change no byte.
+ *
+ * `vgeo_brick_triangle` places one. Its corners go into the world by `global`, less `origin`, the cell's texel 0,
+ * so that a texel's arithmetic runs on numbers the size of the cell; the translation is taken less `origin` first,
+ * so a cell far from the world's origin keeps that precision. `reversed`, where the instance mirrors or its
+ * material draws the back (`triangle_winding_is_reversed`), swaps b and c, so the normal points out of the surface
+ * the instance draws.
+ *
+ * Requires the importing shader to declare `instances`, the pair records.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_vgeo_brick_triangle = CodeChunk.from(
+    //language=WGSL
+    `
+fn vgeo_brick_triangle_reaches(pair_base: u32, positions: ${TRIANGLE_POSITIONS_STRUCT.wgsl_ref}) -> bool {
+    let lower = min(min(positions.a, positions.b), positions.c);
+    let upper = max(max(positions.a, positions.b), positions.c);
+
+    return !(any(upper < vgeo_brick_box_lower(pair_base)) || any(lower > vgeo_brick_box_upper(pair_base)));
+}
+
+fn vgeo_brick_triangle(
+    positions: ${TRIANGLE_POSITIONS_STRUCT.wgsl_ref},
+    global: mat4x4<f32>,
+    origin: vec3<f32>,
+    reversed: bool,
+    sided: bool,
+    row: u32,
+) -> ${VGEO_BRICK_TRIANGLE_STRUCT.wgsl_ref} {
+    let linear = mat3x3<f32>(global[0].xyz, global[1].xyz, global[2].xyz);
+    let offset = global[3].xyz - origin;
+
+    let a = linear * positions.a + offset;
+    let b = linear * positions.b + offset;
+    let c = linear * positions.c + offset;
+
+    return ${VGEO_BRICK_TRIANGLE_STRUCT.wgsl_ref}(
+        a,
+        row,
+        select(b, c, reversed),
+        sqrt(max(dot(b - a, b - a), dot(c - a, c - a))),
+        select(c, b, reversed),
+        select(0u, 1u, sided),
+    );
+}
+`, [
+    TRIANGLE_POSITIONS_STRUCT.declaration_chunk,
+    VGEO_BRICK_TRIANGLE_STRUCT.declaration_chunk,
+    chunk_vgeo_brick_box,
+]);

package/src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/shader_vgeo_brick_distance.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The vgeo provider's distances (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8): a workgroup a taken cell the box cut
+ * put a cluster on the list of, dispatched by their count (`vgeo_brick_filled`), so the cells without virtual
+ * geometry cost nothing here.
+ *
+ * **Triangles.** A lane a triangle of as many of the list's clusters at a time as the lanes hold whole. A triangle
+ * whose box misses its pair's, the cell grown by the band in the instance's space, is skipped
+ * (`vgeo_brick_triangle_reaches`); the rest go into workgroup memory placed in the cell's own space and wound out
+ * of the surface their instance draws (`vgeo_brick_triangle`), up to {@link VGEO_BRICK_CELL_TRIANGLES}. Past it
+ * they are dropped and counted. A cell none comes near writes nothing.
+ *
+ * **512 texels**, shared out evenly, each `vgeo_brick_texel`: the distance to the nearest triangle within the band,
+ * signed by its side, and its row.
+ *
+ * **The merge.** The provider's bytes meet in workgroup memory, then a lane a staged word takes each byte's least
+ * (contracts 1 and 2), and a lane an object cell writes the provider's row where its nearest texel is nearer than
+ * the staged minimum from before the merge; ties keep the staged object (contract 3).
+ *
+ * @type {ComputeShader}
+ */
+export const shader_vgeo_brick_distance: ComputeShader;
+import { ComputeShader } from "../../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_vgeo_brick_distance.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/shader_vgeo_brick_distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_vgeo_brick_distance.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/shader_vgeo_brick_distance.js"],"names":[],"mappings":"AAwPA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yCAFU,aAAa,CAMpB;8BAhQ2B,qCAAqC"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/shader_vgeo_brick_distance.js

@@ -0,0 +1,273 @@
+import { MESH_SDF_BRICK_TEXEL_COUNT, MESH_SDF_BRICK_TEXELS } from "../../../../geometry/sdf/MESH_SDF.js";
+import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../../../../geometry/GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
+import { MESHLET_METADATA_STRUCT } from "../../../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+import { VGEO_MAX_CLUSTER_TRIANGLE_COUNT } from "../../../../geometry/virtual/format/cluster/VGEO_MAX_CLUSTER_TRIANGLE_COUNT.js";
+import { VGEO_INSTANCE_OFFSET } from "../../../../geometry/virtual/runtime/layout/VGEO_INSTANCE_OFFSET.js";
+import { VGEO_INSTANCE_WORDS } from "../../../../geometry/virtual/runtime/layout/VGEO_INSTANCE_WORDS.js";
+import { MATERIAL_METADATA_STRUCT } from "../../../../material/MATERIAL_METADATA_STRUCT.js";
+import { ShadeDrawSide } from "../../../../material/ShadeDrawSide.js";
+import { chunk_triangle_winding_is_reversed } from "../../../../rasterize/chunk_triangle_winding_is_reversed.js";
+import { chunk_scene_database_access } from "../../../../scene/chunk_scene_database_access.js";
+import { CLIPMAP_LEVEL_ARRAY } from "../../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
+import {
+    chunk_read_meshlet_triangle_positions
+} from "../../../../shader/chunk/geometry/meshlet/chunk_read_meshlet_triangle_positions.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 { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { atomic_u32, u32 } from "../../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../../shader/type/WebGPUArray.js";
+import { BRICK_OBJECT_CELLS, BRICK_OBJECT_CELLS_PER_AXIS } from "../BRICK_CLIPMAP.js";
+import { COLLECTION_U32_STRUCT_READ } from "../../../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { COLLECTION_U32_STRUCT_WRITE } from "../../../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
+import { BRICK_STAGING_RESOURCE, chunk_brick_clipmap } from "../chunk_brick_clipmap.js";
+import { chunk_brick_object } from "../chunk_brick_object.js";
+import { chunk_brick_provider_cell } from "../chunk_brick_provider.js";
+import { chunk_vgeo_brick_texel } from "./chunk_vgeo_brick_texel.js";
+import { chunk_vgeo_brick_triangle, VGEO_BRICK_TRIANGLE_STRUCT } from "./chunk_vgeo_brick_triangle.js";
+import {
+    VGEO_BRICK_CELL_CLUSTERS,
+    VGEO_BRICK_CELL_OFFSET,
+    VGEO_BRICK_CELL_TRIANGLES,
+    VGEO_BRICK_CELL_WORDS,
+    VGEO_BRICK_DISTANCE_WORKGROUP_SIZE,
+    VGEO_BRICK_SETTINGS,
+    VGEO_BRICK_STATISTIC_TRIANGLES_DROPPED,
+    VGEO_BRICK_STATISTIC_WAITS_DROPPED,
+    VGEO_BRICK_WAIT_WORDS
+} from "./VGEO_BRICK.js";
+
+const CLUSTERS_PER_STEP = VGEO_BRICK_DISTANCE_WORKGROUP_SIZE / VGEO_MAX_CLUSTER_TRIANGLE_COUNT;
+const TEXELS_PER_LANE = MESH_SDF_BRICK_TEXEL_COUNT / VGEO_BRICK_DISTANCE_WORKGROUP_SIZE;
+const T = MESH_SDF_BRICK_TEXELS;
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", VGEO_BRICK_SETTINGS);
+
+resources.createGroup()
+    .add(BRICK_STAGING_RESOURCE)
+    .addUniform("brick_levels", CLIPMAP_LEVEL_ARRAY)
+    .addStorageBuffer("vgeo_brick_statistics", WebGPUArray.from(atomic_u32), true);
+
+resources.createGroup()
+    // the taken cells a cluster went onto the list of, and their lists, as the cut left them
+    .addStorageBuffer("vgeo_brick_filled", COLLECTION_U32_STRUCT_READ)
+    .addStorageBuffer("vgeo_brick_cells", WebGPUArray.from(u32))
+    // the pair records
+    .addStorageBuffer("instances", WebGPUArray.from(u32))
+    .addStorageBuffer("scene_database", WebGPUArray.from(u32))
+    .addStorageBuffer("materials", WebGPUArray.from(MATERIAL_METADATA_STRUCT))
+    .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT))
+    .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE)
+    // the cells waiting to be built again, `VGEO_BRICK_WAIT_WORDS` each: the next frame's
+    .addStorageBuffer("vgeo_brick_waiting", COLLECTION_U32_STRUCT_WRITE, true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const VGEO_BRICK_CELL_TRIANGLES = ${VGEO_BRICK_CELL_TRIANGLES}u;
+
+var<workgroup> cell_count: u32;
+
+/** the cut's triangles that come within the band, as the lanes found them, and their count, past the array too */
+var<workgroup> triangles: array<${VGEO_BRICK_TRIANGLE_STRUCT.wgsl_ref}, VGEO_BRICK_CELL_TRIANGLES>;
+var<workgroup> triangle_count: atomic<u32>;
+var<workgroup> triangle_total: u32;
+
+/** the provider's bytes, as the staging packs them; per object cell, its nearest texel's key and its staged minimum */
+var<workgroup> texel_bytes: array<atomic<u32>, BRICK_STAGING_DISTANCE_WORDS>;
+var<workgroup> object_best: array<atomic<u32>, ${BRICK_OBJECT_CELLS}u>;
+var<workgroup> object_staged: array<atomic<u32>, ${BRICK_OBJECT_CELLS}u>;
+
+fn vgeo_brick_triangle_at(i: u32) -> ${VGEO_BRICK_TRIANGLE_STRUCT.wgsl_ref} {
+    return triangles[i];
+}
+
+/** texel \`t\`'s object cell: x fastest, then y, then z, a cell 2³ texels */
+fn vgeo_brick_object_of(t: u32) -> u32 {
+    let x = t % ${T}u;
+    let y = (t / ${T}u) % ${T}u;
+    let z = t / ${T * T}u;
+
+    return (x / 2u) + ${BRICK_OBJECT_CELLS_PER_AXIS}u * ((y / 2u) + ${BRICK_OBJECT_CELLS_PER_AXIS}u * (z / 2u));
+}
+
+@compute @workgroup_size(${VGEO_BRICK_DISTANCE_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let index = folded_workgroup_index(workgroup_id);
+
+    if (lane == 0u) {
+        cell_count = vgeo_brick_filled.count;
+    }
+
+    // a folded dispatch's tail leaves whole
+    if (index >= workgroupUniformLoad(&cell_count)) {
+        return;
+    }
+
+    let build = vgeo_brick_filled.elements[index];
+    let list = build * ${VGEO_BRICK_CELL_WORDS}u;
+    let key = vgeo_brick_cells[list + ${VGEO_BRICK_CELL_OFFSET.KEY}u];
+
+    let at = brick_provider_cell(key, settings.resolution);
+    let clusters = min(vgeo_brick_cells[list + ${VGEO_BRICK_CELL_OFFSET.COUNT}u], ${VGEO_BRICK_CELL_CLUSTERS}u);
+
+    // a cell built with a stand-in waits to be built again, on the list the next frame's wait reads
+    if (lane == 0u && vgeo_brick_cells[list + ${VGEO_BRICK_CELL_OFFSET.WAITS}u] > 0u) {
+        let wait = atomicAdd(&vgeo_brick_waiting.count, 1u);
+
+        if (wait < settings.wait_capacity) {
+            // the header keeps the cell as a waiting cell's words
+            for (var w = 0u; w < ${VGEO_BRICK_WAIT_WORDS}u; w++) {
+                vgeo_brick_waiting.elements[${VGEO_BRICK_WAIT_WORDS}u * wait + w] = vgeo_brick_cells[list + ${VGEO_BRICK_CELL_OFFSET.WAIT}u + w];
+            }
+        } else {
+            atomicAdd(&vgeo_brick_statistics[${VGEO_BRICK_STATISTIC_WAITS_DROPPED}u], 1u);
+        }
+    }
+
+    // ----- the cut's triangles that come within the band: a lane a triangle, of ${CLUSTERS_PER_STEP} clusters at a time -----
+
+    let member = lane % ${VGEO_MAX_CLUSTER_TRIANGLE_COUNT}u;
+
+    for (var k = lane / ${VGEO_MAX_CLUSTER_TRIANGLE_COUNT}u; k < clusters; k += ${CLUSTERS_PER_STEP}u) {
+        let entry = list + ${VGEO_BRICK_CELL_OFFSET.ENTRIES}u + 2u * k;
+        let pair_base = vgeo_brick_cells[entry] * ${VGEO_INSTANCE_WORDS}u;
+        let meshlet = vgeo_brick_cells[entry + 1u];
+
+        if (member >= meshlet_metadata[meshlet].primitive_count) {
+            continue;
+        }
+
+        let positions = read_meshlet_triangle_positions(meshlet, member);
+
+        if (!vgeo_brick_triangle_reaches(pair_base, positions)) {
+            continue;
+        }
+
+        let row = instances[pair_base + ${VGEO_INSTANCE_OFFSET.MESH_INDEX}u];
+        let mesh = scene_read_mesh(&scene_database, row);
+        let node = scene_read_node(&scene_database, mesh.node);
+        let side = materials[mesh.material].draw_side;
+
+        let slot = atomicAdd(&triangle_count, 1u);
+
+        if (slot < VGEO_BRICK_CELL_TRIANGLES) {
+            triangles[slot] = vgeo_brick_triangle(
+                positions, node.global, at.corner,
+                triangle_winding_is_reversed(node, side), side != ${ShadeDrawSide.Double}u,
+                row
+            );
+        }
+    }
+
+    workgroupBarrier();
+
+    if (lane == 0u) {
+        let total = atomicLoad(&triangle_count);
+
+        triangle_total = total;
+
+        if (total > VGEO_BRICK_CELL_TRIANGLES) {
+            atomicAdd(&vgeo_brick_statistics[${VGEO_BRICK_STATISTIC_TRIANGLES_DROPPED}u], total - VGEO_BRICK_CELL_TRIANGLES);
+        }
+    }
+
+    let count = min(workgroupUniformLoad(&triangle_total), VGEO_BRICK_CELL_TRIANGLES);
+
+    // no triangle of the cut comes near the cell: a provider with nothing in a cell writes nothing
+    if (count == 0u) {
+        return;
+    }
+
+    // ----- the texels, ${TEXELS_PER_LANE} a lane, in the cell's own space: texel 0 at its corner -----
+
+    for (var h = 0u; h < ${TEXELS_PER_LANE}u; h++) {
+        let t = lane + h * ${VGEO_BRICK_DISTANCE_WORKGROUP_SIZE}u;
+        let p = vec3<f32>(f32(t % ${T}u), f32((t / ${T}u) % ${T}u), f32(t / ${T * T}u)) * at.voxel;
+
+        let texel = vgeo_brick_texel(p, count, at.band);
+        let byte = brick_encode(texel.distance, at.band);
+
+        atomicOr(&texel_bytes[t / 4u], byte << (8u * (t % 4u)));
+        atomicMax(&object_best[vgeo_brick_object_of(t)], brick_object_key(byte, texel.row));
+    }
+
+    workgroupBarrier();
+
+    // ----- contracts 1 and 2: a lane a staged word, each byte the least of the staged and the provider's -----
+
+    if (lane < BRICK_STAGING_DISTANCE_WORDS) {
+        let word = build * BRICK_STAGING_WORDS + lane;
+        let staged = brick_staging[word];
+        let provided = atomicLoad(&texel_bytes[lane]);
+
+        var merged = 0u;
+
+        for (var b = 0u; b < 4u; b++) {
+            let shift = 8u * b;
+            let s = (staged >> shift) & 0xffu;
+
+            merged |= min(s, (provided >> shift) & 0xffu) << shift;
+
+            // contract 3 weighs the staged minimum from before this provider's merge
+            atomicMax(&object_staged[vgeo_brick_object_of(4u * lane + b)], 255u - s);
+        }
+
+        brick_staging[word] = merged;
+    }
+
+    workgroupBarrier();
+
+    // ----- contract 3: a lane an object cell, the provider's row where its nearest texel is nearer than the staged -----
+
+    if (lane < ${BRICK_OBJECT_CELLS}u) {
+        let nearest = atomicLoad(&object_best[lane]);
+
+        if (brick_object_key_byte(nearest) < 255u - atomicLoad(&object_staged[lane])) {
+            brick_staging[build * BRICK_STAGING_WORDS + BRICK_STAGING_DISTANCE_WORDS + lane] = brick_object_key_row(nearest);
+        }
+    }
+}
+`, [
+    chunk_brick_clipmap,
+    chunk_brick_provider_cell,
+    chunk_brick_object,
+    chunk_folded_workgroup_index,
+    chunk_scene_database_access,
+    chunk_triangle_winding_is_reversed,
+    chunk_read_meshlet_triangle_positions,
+    chunk_vgeo_brick_triangle,
+    chunk_vgeo_brick_texel,
+]);
+
+/**
+ * The vgeo provider's distances (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8): a workgroup a taken cell the box cut
+ * put a cluster on the list of, dispatched by their count (`vgeo_brick_filled`), so the cells without virtual
+ * geometry cost nothing here.
+ *
+ * **Triangles.** A lane a triangle of as many of the list's clusters at a time as the lanes hold whole. A triangle
+ * whose box misses its pair's, the cell grown by the band in the instance's space, is skipped
+ * (`vgeo_brick_triangle_reaches`); the rest go into workgroup memory placed in the cell's own space and wound out
+ * of the surface their instance draws (`vgeo_brick_triangle`), up to {@link VGEO_BRICK_CELL_TRIANGLES}. Past it
+ * they are dropped and counted. A cell none comes near writes nothing.
+ *
+ * **512 texels**, shared out evenly, each `vgeo_brick_texel`: the distance to the nearest triangle within the band,
+ * signed by its side, and its row.
+ *
+ * **The merge.** The provider's bytes meet in workgroup memory, then a lane a staged word takes each byte's least
+ * (contracts 1 and 2), and a lane an object cell writes the provider's row where its nearest texel is nearer than
+ * the staged minimum from before the merge; ties keep the staged object (contract 3).
+ *
+ * @type {ComputeShader}
+ */
+export const shader_vgeo_brick_distance = ComputeShader.from({
+    label: "Brick Clipmap VGeo Distance",
+    resources,
+    body,
+});

package/src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/shader_vgeo_brick_gather.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The vgeo provider's gather (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8): a 64-lane workgroup a taken cell,
+ * dispatched by take. A cooperative TLAS query with the cell grown by the cascade's band, every leaf filtered by
+ * `vgeo_brick_accept`, and a pair record for each candidate (`vgeo_brick_pair`): the instance cut at a world error
+ * under half the cascade's voxel, within the cell grown by the band. The records and their claim widths are a cut's
+ * collect, so the camera cut's scan, seed and descent run them. Pairs past the records' capacity, and what the query
+ * itself dropped, are counted.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_vgeo_brick_gather: ComputeShader;
+import { ComputeShader } from "../../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_vgeo_brick_gather.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/shader_vgeo_brick_gather.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_vgeo_brick_gather.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/shader_vgeo_brick_gather.js"],"names":[],"mappings":"AAwIA;;;;;;;;;GASG;AACH,uCAFU,aAAa,CAMpB;8BA3I2B,qCAAqC"}