@woosh/meep-engine 3.59.0 → 3.60.0

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

@@ -1,31 +0,0 @@
-/**
- * @type {number}
- */
-export const VGEO_BRICK_TIE: number;
-/**
- * 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;
-import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_vgeo_brick_texel.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_vgeo_brick_texel.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/chunk_vgeo_brick_texel.js"],"names":[],"mappings":"AAmBA;;GAEG;AACH,6BAFU,MAAM,CAE6E;AAE7F;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qCAFU,SAAS,CAkEhB;0BA3GuB,0CAA0C"}

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

@@ -1,113 +0,0 @@
-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

@@ -1,36 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,85 +0,0 @@
-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

@@ -1,23 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,273 +0,0 @@
-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

@@ -1,13 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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"}