@woosh/meep-engine 3.58.0 → 3.59.0

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

@@ -0,0 +1,29 @@
+/**
+ * What the vgeo provider asks of a `meshes` row (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8), on the scene database
+ * and the vgeo geometry rows:
+ *
+ * ```wgsl
+ * fn vgeo_brick_accept(row: u32, bounds: array<f32, 6>, voxel: f32) -> bool
+ * fn vgeo_brick_pair(row: u32, build: u32, lower: vec3<f32>, upper: vec3<f32>, voxel: f32, capacity: u32) -> bool
+ * ```
+ *
+ * `vgeo_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 is virtual (the mesh provider's rows are the others), and its box resolves
+ * in the cascade.
+ *
+ * `vgeo_brick_pair` writes the pair's record, a cut's instance record under `capacity`:
+ * - cut at a world error under half the voxel, at any distance: `k` is σ_max over half the voxel and the distance
+ *   weight 0, so `vg_project` is the world error over half the voxel, against a τ of 1;
+ * - within the world box [lower, upper], put in the instance's object space as the bounds of its eight corners;
+ * - for taken cell `build`.
+ *
+ * It is false where the instance's transform flattens it or the records are full, which the caller counts.
+ *
+ * Requires the importing shader to declare `scene_database`, `geometries`, `vg_geometries`, `instances` and
+ * `claim_widths`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_vgeo_brick_pair: CodeChunk;
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_vgeo_brick_pair.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_vgeo_brick_pair.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/chunk_vgeo_brick_pair.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,oCAFU,SAAS,CAyEhB;0BArGuB,0CAA0C"}

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

@@ -0,0 +1,108 @@
+import { chunk_vgeo_cut_instance } from "../../../../geometry/virtual/runtime/cut/chunk_vgeo_cut_instance.js";
+import { VGEO_GEOMETRY_ROW_NONE } from "../../../../geometry/virtual/runtime/layout/VGEO_GEOMETRY_ROW_NONE.js";
+import { VGEO_INSTANCE_OFFSET } from "../../../../geometry/virtual/runtime/layout/VGEO_INSTANCE_OFFSET.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 { chunk_brick_provider_resolves } from "../chunk_brick_provider.js";
+import { VGEO_BRICK_PAIR_BOX, VGEO_BRICK_PAIR_BUILD } from "./VGEO_BRICK.js";
+
+/**
+ * What the vgeo provider asks of a `meshes` row (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.8), on the scene database
+ * and the vgeo geometry rows:
+ *
+ * ```wgsl
+ * fn vgeo_brick_accept(row: u32, bounds: array<f32, 6>, voxel: f32) -> bool
+ * fn vgeo_brick_pair(row: u32, build: u32, lower: vec3<f32>, upper: vec3<f32>, voxel: f32, capacity: u32) -> bool
+ * ```
+ *
+ * `vgeo_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 is virtual (the mesh provider's rows are the others), and its box resolves
+ * in the cascade.
+ *
+ * `vgeo_brick_pair` writes the pair's record, a cut's instance record under `capacity`:
+ * - cut at a world error under half the voxel, at any distance: `k` is σ_max over half the voxel and the distance
+ *   weight 0, so `vg_project` is the world error over half the voxel, against a τ of 1;
+ * - within the world box [lower, upper], put in the instance's object space as the bounds of its eight corners;
+ * - for taken cell `build`.
+ *
+ * It is false where the instance's transform flattens it or the records are full, which the caller counts.
+ *
+ * Requires the importing shader to declare `scene_database`, `geometries`, `vg_geometries`, `instances` and
+ * `claim_widths`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_vgeo_brick_pair = CodeChunk.from(
+    //language=WGSL
+    `
+const VG_GEOMETRY_ROW_NONE = ${VGEO_GEOMETRY_ROW_NONE}u;
+
+fn vgeo_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;
+    }
+
+    if (geometries[mesh.geometry].vg_row == VG_GEOMETRY_ROW_NONE) {
+        return false;
+    }
+
+    return brick_provider_resolves(bounds, voxel);
+}
+
+fn vgeo_brick_pair(row: u32, build: u32, lower: vec3<f32>, upper: vec3<f32>, voxel: f32, capacity: u32) -> bool {
+    let mesh = scene_read_mesh(&scene_database, row);
+    let global = scene_read_node(&scene_database, mesh.node).global;
+
+    let stretch = vg_instance_stretch(global);
+
+    if (!(stretch.y > 0.0)) {
+        return false;
+    }
+
+    let base = vg_instance_record(row, geometries[mesh.geometry].vg_row, capacity);
+
+    if (base == VG_INSTANCE_RECORD_NONE) {
+        return false;
+    }
+
+    // no eye: at a distance weight of 0 the projection is the world error itself, wherever the pair is
+    vg_store(base, ${VGEO_INSTANCE_OFFSET.EYE}u, 0.0);
+    vg_store(base, ${VGEO_INSTANCE_OFFSET.EYE + 1}u, 0.0);
+    vg_store(base, ${VGEO_INSTANCE_OFFSET.EYE + 2}u, 0.0);
+    vg_store(base, ${VGEO_INSTANCE_OFFSET.PROJECTION_K}u, stretch.x / (0.5 * voxel));
+    vg_store(base, ${VGEO_INSTANCE_OFFSET.DISTANCE_WEIGHT}u, 0.0);
+
+    let to_object = mat4_inverse(global);
+
+    var box_lower = vec3<f32>(3.4e38);
+    var box_upper = vec3<f32>(-3.4e38);
+
+    for (var corner = 0u; corner < 8u; corner++) {
+        let world = select(lower, upper, vec3<bool>((corner & 1u) != 0u, (corner & 2u) != 0u, (corner & 4u) != 0u));
+        let object = (to_object * vec4<f32>(world, 1.0)).xyz;
+
+        box_lower = min(box_lower, object);
+        box_upper = max(box_upper, object);
+    }
+
+    vg_store(base, ${VGEO_BRICK_PAIR_BOX}u, box_lower.x);
+    vg_store(base, ${VGEO_BRICK_PAIR_BOX + 1}u, box_lower.y);
+    vg_store(base, ${VGEO_BRICK_PAIR_BOX + 2}u, box_lower.z);
+    vg_store(base, ${VGEO_BRICK_PAIR_BOX + 3}u, box_upper.x);
+    vg_store(base, ${VGEO_BRICK_PAIR_BOX + 4}u, box_upper.y);
+    vg_store(base, ${VGEO_BRICK_PAIR_BOX + 5}u, box_upper.z);
+
+    instances[base + ${VGEO_BRICK_PAIR_BUILD}u] = build;
+
+    return true;
+}
+`, [
+    chunk_scene_database_access,
+    chunk_vgeo_cut_instance,
+    chunk_mat4_inverse,
+    chunk_brick_provider_resolves,
+]);

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

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

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

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