@woosh/meep-engine 3.57.0 → 3.59.0

package/src/shade/renderer/geometry/sdf/chunk_mesh_sdf.js

@@ -0,0 +1,112 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import {
+    MESH_SDF_BAND_VOXELS,
+    MESH_SDF_BRICK_TEXELS,
+    MESH_SDF_BRICK_VOXELS,
+    MESH_SDF_EMPTY,
+    MESH_SDF_EMPTY_INSIDE,
+    MeshSDFState
+} from "./MESH_SDF.js";
+import { MESH_SDF_STRUCT } from "./MESH_SDF_STRUCT.js";
+
+/**
+ * The arithmetic of a geometry's sparse distance field on the device — {@link MeshSDFLayout}'s, and
+ * the encoding of a texel — over a {@link MESH_SDF_STRUCT} passed by value. Pure: nothing here reads a
+ * binding.
+ *
+ * ```wgsl
+ * fn mesh_sdf_level_bricks(header: MeshSDF, level: u32) -> vec3<u32>
+ * fn mesh_sdf_level_offset(header: MeshSDF, level: u32) -> u32   // the level's first entry
+ * fn mesh_sdf_level_voxel(header: MeshSDF, level: u32) -> f32
+ * fn mesh_sdf_brick_of(header: MeshSDF, brick: u32) -> vec4<u32> // level, then x, y, z
+ * fn mesh_sdf_brick_corner(header: MeshSDF, brick: vec4<u32>) -> vec3<f32> // texel 0's point
+ * fn mesh_sdf_encode(distance: f32, voxel: f32) -> f32           // saturate(d / 2R + 0.5)
+ * fn mesh_sdf_decode(encoded: f32, voxel: f32) -> f32
+ * fn mesh_sdf_entry_holds_slot(entry: u32) -> bool               // not EMPTY, on either side
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf = CodeChunk.from(
+    //language=WGSL
+    `
+const MESH_SDF_BRICK_VOXELS = ${MESH_SDF_BRICK_VOXELS}u;
+const MESH_SDF_BRICK_TEXELS = ${MESH_SDF_BRICK_TEXELS}u;
+const MESH_SDF_BAND_VOXELS = ${MESH_SDF_BAND_VOXELS}.0;
+const MESH_SDF_EMPTY = ${MESH_SDF_EMPTY}u;
+const MESH_SDF_EMPTY_INSIDE = ${MESH_SDF_EMPTY_INSIDE}u;
+const MESH_SDF_STATE_NONE = ${MeshSDFState.None}u;
+const MESH_SDF_STATE_BAKING = ${MeshSDFState.Baking}u;
+const MESH_SDF_STATE_RESIDENT = ${MeshSDFState.Resident}u;
+const MESH_SDF_STATE_ALIAS = ${MeshSDFState.Alias}u;
+
+fn mesh_sdf_level_bricks(header: ${MESH_SDF_STRUCT.wgsl_ref}, level: u32) -> vec3<u32> {
+    let step = (1u << level) - 1u;
+
+    return (header.bricks + vec3<u32>(step)) >> vec3<u32>(level);
+}
+
+fn mesh_sdf_level_offset(header: ${MESH_SDF_STRUCT.wgsl_ref}, level: u32) -> u32 {
+    var offset = header.indirection;
+
+    // at most the level count, six at the default cap
+    for (var k = 0u; k < level; k++) {
+        let bricks = mesh_sdf_level_bricks(header, k);
+
+        offset += bricks.x * bricks.y * bricks.z;
+    }
+
+    return offset;
+}
+
+fn mesh_sdf_level_voxel(header: ${MESH_SDF_STRUCT.wgsl_ref}, level: u32) -> f32 {
+    return header.voxel * f32(1u << level);
+}
+
+fn mesh_sdf_brick_of(header: ${MESH_SDF_STRUCT.wgsl_ref}, brick: u32) -> vec4<u32> {
+    var rest = brick;
+    var level = 0u;
+
+    for (; level + 1u < header.level_count; level++) {
+        let bricks = mesh_sdf_level_bricks(header, level);
+        let count = bricks.x * bricks.y * bricks.z;
+
+        if (rest < count) {
+            break;
+        }
+
+        rest -= count;
+    }
+
+    let bricks = mesh_sdf_level_bricks(header, level);
+
+    let x = rest % bricks.x;
+    let y = (rest / bricks.x) % bricks.y;
+    let z = rest / (bricks.x * bricks.y);
+
+    return vec4<u32>(level, x, y, z);
+}
+
+fn mesh_sdf_brick_corner(header: ${MESH_SDF_STRUCT.wgsl_ref}, brick: vec4<u32>) -> vec3<f32> {
+    // texel t of a brick sits on its voxel corner t, and bricks overlap by one texel
+    return header.origin + vec3<f32>(brick.yzw * MESH_SDF_BRICK_VOXELS) * mesh_sdf_level_voxel(header, brick.x);
+}
+
+fn mesh_sdf_encode(distance: f32, voxel: f32) -> f32 {
+    let band = MESH_SDF_BAND_VOXELS * voxel;
+
+    return saturate(distance / (2.0 * band) + 0.5);
+}
+
+fn mesh_sdf_decode(encoded: f32, voxel: f32) -> f32 {
+    let band = MESH_SDF_BAND_VOXELS * voxel;
+
+    return 2.0 * band * (encoded - 0.5);
+}
+
+fn mesh_sdf_entry_holds_slot(entry: u32) -> bool {
+    return entry < MESH_SDF_EMPTY;
+}
+`, [
+        MESH_SDF_STRUCT.declaration_chunk,
+    ]);

package/src/shade/renderer/geometry/sdf/chunk_mesh_sdf_normal.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The surface normal of a geometry's field at a point, in its local space: the field's gradient by
+ * Quilez's tetrahedron of four samples, half a voxel of the level across, so it follows the field at
+ * the resolution the field has.
+ *
+ * ```wgsl
+ * fn mesh_sdf_normal(header: MeshSDF, level: u32, p: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * @see https://iquilezles.org/articles/normalsSDF/
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_normal: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mesh_sdf_normal.d.ts.map

package/src/shade/renderer/geometry/sdf/chunk_mesh_sdf_normal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mesh_sdf_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/chunk_mesh_sdf_normal.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,oCAFU,SAAS,CAmBZ;0BAjCmB,oCAAoC"}

package/src/shade/renderer/geometry/sdf/chunk_mesh_sdf_normal.js

@@ -0,0 +1,34 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_mesh_sdf_sample } from "./chunk_mesh_sdf_sample.js";
+import { MESH_SDF_STRUCT } from "./MESH_SDF_STRUCT.js";
+
+/**
+ * The surface normal of a geometry's field at a point, in its local space: the field's gradient by
+ * Quilez's tetrahedron of four samples, half a voxel of the level across, so it follows the field at
+ * the resolution the field has.
+ *
+ * ```wgsl
+ * fn mesh_sdf_normal(header: MeshSDF, level: u32, p: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * @see https://iquilezles.org/articles/normalsSDF/
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_normal = CodeChunk.from(
+    //language=WGSL
+    `
+fn mesh_sdf_normal(header: ${MESH_SDF_STRUCT.wgsl_ref}, level: u32, p: vec3<f32>) -> vec3<f32> {
+    let h = 0.5 * mesh_sdf_level_voxel(header, level);
+    let k = vec2<f32>(1.0, -1.0);
+
+    return normalize(
+        k.xyy * mesh_sdf_sample(header, level, p + k.xyy * h)
+        + k.yyx * mesh_sdf_sample(header, level, p + k.yyx * h)
+        + k.yxy * mesh_sdf_sample(header, level, p + k.yxy * h)
+        + k.xxx * mesh_sdf_sample(header, level, p + k.xxx * h)
+    );
+}
+`, [
+        MESH_SDF_STRUCT.declaration_chunk,
+        chunk_mesh_sdf_sample,
+    ]);

package/src/shade/renderer/geometry/sdf/chunk_mesh_sdf_raymarch.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The first hit of a ray in a geometry's local space against its field at one level: the ray's own
+ * parameter `t`, so a ray carried into local space by a transform keeps the `t` it had outside, or
+ * `-1` for a miss within `ray.tmax`.
+ *
+ * A hit is a sample within half a voxel of the level; every other step is at least that long, so the
+ * march always moves. It starts where the ray enters the grid box and ends where it leaves.
+ *
+ * ```wgsl
+ * fn mesh_sdf_raymarch(header: MeshSDF, level: u32, ray: Ray) -> f32
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_raymarch: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mesh_sdf_raymarch.d.ts.map

package/src/shade/renderer/geometry/sdf/chunk_mesh_sdf_raymarch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mesh_sdf_raymarch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/chunk_mesh_sdf_raymarch.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;GAaG;AACH,sCAFU,SAAS,CAsCZ;0BA7DmB,oCAAoC"}

package/src/shade/renderer/geometry/sdf/chunk_mesh_sdf_raymarch.js

@@ -0,0 +1,64 @@
+import { chunk_aabb3_distance_to_ray_v2 } from "../../shader/chunk/geometry/aabb3/chunk_aabb3_distance_to_ray_v2.js";
+import { RAY_STRUCT } from "../../shader/chunk/geometry/ray/RAY_STRUCT.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_mesh_sdf_sample } from "./chunk_mesh_sdf_sample.js";
+import { MESH_SDF_STRUCT } from "./MESH_SDF_STRUCT.js";
+
+/**
+ * Steps a ray takes at most. Away from the surface a step is the band, four voxels, so a ray crosses
+ * the cap's 126 voxels in about 32 steps and has as many again to close on what it hits.
+ * @type {number}
+ */
+const MAX_STEPS = 64;
+
+/**
+ * The first hit of a ray in a geometry's local space against its field at one level: the ray's own
+ * parameter `t`, so a ray carried into local space by a transform keeps the `t` it had outside, or
+ * `-1` for a miss within `ray.tmax`.
+ *
+ * A hit is a sample within half a voxel of the level; every other step is at least that long, so the
+ * march always moves. It starts where the ray enters the grid box and ends where it leaves.
+ *
+ * ```wgsl
+ * fn mesh_sdf_raymarch(header: MeshSDF, level: u32, ray: Ray) -> f32
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_raymarch = CodeChunk.from(
+    //language=WGSL
+    `
+fn mesh_sdf_raymarch(header: ${MESH_SDF_STRUCT.wgsl_ref}, level: u32, ray: ${RAY_STRUCT.wgsl_ref}) -> f32 {
+    let grid_min = header.origin;
+    let grid_max = header.origin + vec3<f32>(header.bricks) * (f32(MESH_SDF_BRICK_VOXELS) * header.voxel);
+
+    let span = aabb3_distance_to_ray(grid_min, grid_max, ray.origin, ray.direction);
+    let t_end = min(span.y, ray.tmax);
+
+    if (span.y <= 0.0 || span.x > t_end) {
+        return -1.0;
+    }
+
+    // distances are local lengths; t is the ray's parameter
+    let speed = length(ray.direction);
+    let threshold = 0.5 * mesh_sdf_level_voxel(header, level);
+
+    var t = max(span.x, 0.0);
+
+    for (var i = 0; i < ${MAX_STEPS} && t <= t_end; i++) {
+        let distance = mesh_sdf_sample(header, level, ray.origin + t * ray.direction);
+
+        if (distance < threshold) {
+            return t;
+        }
+
+        t += distance / speed;
+    }
+
+    return -1.0;
+}
+`, [
+        RAY_STRUCT.declaration_chunk,
+        chunk_aabb3_distance_to_ray_v2,
+        chunk_mesh_sdf_sample,
+    ]);

package/src/shade/renderer/geometry/sdf/chunk_mesh_sdf_sample.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A geometry's header as its readers take it: an alias is followed once, so a skinned clone reads
+ * its source's field. Reads `mesh_sdf_headers`.
+ *
+ * ```wgsl
+ * fn mesh_sdf_header(geometry: u32) -> MeshSDF
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_header: CodeChunk;
+/**
+ * The signed distance a resident geometry's field gives at a point of its local space, at one level
+ * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7):
+ *
+ * - outside the grid box, the distance to the box plus level 0's band R. A lower bound: the surface
+ *   lies inside the bounds, and the bounds lie at least R inside the box;
+ * - in an EMPTY brick, the level's band on the brick's side of the surface, `±R`: no surface is
+ *   within it, so a line out of a solid meets one surface, its own;
+ * - in a stored brick, one hardware trilinear tap of the atlas, which never leaves the brick.
+ *
+ * Reads `mesh_sdf_indirection`, `mesh_sdf_atlas` and `mesh_sdf_sampler`.
+ *
+ * ```wgsl
+ * fn mesh_sdf_sample(header: MeshSDF, level: u32, position: vec3<f32>) -> f32
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_sample: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mesh_sdf_sample.d.ts.map

package/src/shade/renderer/geometry/sdf/chunk_mesh_sdf_sample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mesh_sdf_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/chunk_mesh_sdf_sample.js"],"names":[],"mappings":"AAWA;;;;;;;;;GASG;AACH,oCAFU,SAAS,CAgBZ;AAIP;;;;;;;;;;;;;;;;;GAiBG;AACH,oCAFU,SAAS,CA4CZ;0BAnGmB,oCAAoC"}

package/src/shade/renderer/geometry/sdf/chunk_mesh_sdf_sample.js

@@ -0,0 +1,104 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_tile_atlas_slot_origin } from "../../texture/atlas/chunk_tile_atlas_slot_origin.js";
+import { chunk_mesh_sdf } from "./chunk_mesh_sdf.js";
+import {
+    MESH_SDF_ATLAS_RESOURCE,
+    MESH_SDF_HEADERS_RESOURCE,
+    MESH_SDF_INDIRECTION_RESOURCE,
+    MESH_SDF_SAMPLER_RESOURCE
+} from "./MESH_SDF_RESOURCES.js";
+import { MESH_SDF_STRUCT } from "./MESH_SDF_STRUCT.js";
+
+/**
+ * A geometry's header as its readers take it: an alias is followed once, so a skinned clone reads
+ * its source's field. Reads `mesh_sdf_headers`.
+ *
+ * ```wgsl
+ * fn mesh_sdf_header(geometry: u32) -> MeshSDF
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_header = CodeChunk.from(
+    //language=WGSL
+    `
+fn mesh_sdf_header(geometry: u32) -> ${MESH_SDF_STRUCT.wgsl_ref} {
+    var header = mesh_sdf_headers[geometry];
+
+    if (header.state == MESH_SDF_STATE_ALIAS) {
+        header = mesh_sdf_headers[header.source];
+    }
+
+    return header;
+}
+`, [
+        chunk_mesh_sdf,
+    ]);
+
+chunk_mesh_sdf_header.requireResource(MESH_SDF_HEADERS_RESOURCE);
+
+/**
+ * The signed distance a resident geometry's field gives at a point of its local space, at one level
+ * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.7):
+ *
+ * - outside the grid box, the distance to the box plus level 0's band R. A lower bound: the surface
+ *   lies inside the bounds, and the bounds lie at least R inside the box;
+ * - in an EMPTY brick, the level's band on the brick's side of the surface, `±R`: no surface is
+ *   within it, so a line out of a solid meets one surface, its own;
+ * - in a stored brick, one hardware trilinear tap of the atlas, which never leaves the brick.
+ *
+ * Reads `mesh_sdf_indirection`, `mesh_sdf_atlas` and `mesh_sdf_sampler`.
+ *
+ * ```wgsl
+ * fn mesh_sdf_sample(header: MeshSDF, level: u32, position: vec3<f32>) -> f32
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_sample = CodeChunk.from(
+    //language=WGSL
+    `
+fn mesh_sdf_sample(header: ${MESH_SDF_STRUCT.wgsl_ref}, level: u32, position: vec3<f32>) -> f32 {
+    let grid_min = header.origin;
+    let grid_max = header.origin + vec3<f32>(header.bricks) * (f32(MESH_SDF_BRICK_VOXELS) * header.voxel);
+
+    let outside = max(max(grid_min - position, position - grid_max), vec3<f32>(0.0));
+
+    if (any(outside > vec3<f32>(0.0))) {
+        return length(outside) + MESH_SDF_BAND_VOXELS * header.voxel;
+    }
+
+    let voxel = mesh_sdf_level_voxel(header, level);
+    let bricks = mesh_sdf_level_bricks(header, level);
+
+    // the brick holding the point, in the level's voxels; a point on the grid's far face is in the
+    // last brick
+    let voxels = (position - grid_min) / voxel;
+    let brick = min(vec3<u32>(voxels / f32(MESH_SDF_BRICK_VOXELS)), bricks - vec3<u32>(1u));
+
+    let entry = mesh_sdf_indirection[mesh_sdf_level_offset(header, level) + brick.x + bricks.x * (brick.y + bricks.y * brick.z)];
+
+    if (!mesh_sdf_entry_holds_slot(entry)) {
+        return select(1.0, -1.0, entry == MESH_SDF_EMPTY_INSIDE) * MESH_SDF_BAND_VOXELS * voxel;
+    }
+
+    let atlas_size = textureDimensions(mesh_sdf_atlas, 0);
+    let slots = atlas_size / MESH_SDF_BRICK_TEXELS;
+    let corner = tile_atlas_slot_origin(entry, slots.xy, vec3<u32>(MESH_SDF_BRICK_TEXELS));
+
+    // texel t of the brick sits on its corner voxel t: the tap's centre is half a texel past it
+    let within = clamp(voxels - vec3<f32>(brick * MESH_SDF_BRICK_VOXELS), vec3<f32>(0.0), vec3<f32>(f32(MESH_SDF_BRICK_VOXELS)));
+    let uvw = (vec3<f32>(corner) + 0.5 + within) / vec3<f32>(atlas_size);
+
+    let encoded = textureSampleLevel(mesh_sdf_atlas, mesh_sdf_sampler, uvw, 0.0).r;
+
+    return mesh_sdf_decode(encoded, voxel);
+}
+`, [
+        chunk_mesh_sdf,
+        chunk_tile_atlas_slot_origin,
+    ]);
+
+chunk_mesh_sdf_sample.requireResource(MESH_SDF_INDIRECTION_RESOURCE);
+chunk_mesh_sdf_sample.requireResource(MESH_SDF_ATLAS_RESOURCE);
+chunk_mesh_sdf_sample.requireResource(MESH_SDF_SAMPLER_RESOURCE);

package/src/shade/renderer/geometry/sdf/shader_sdf_visualize.d.ts

@@ -16,4 +16,6 @@ export function graph_draw_sdf_normals({ graph, view, input_depth, input_normals
     input_normals: number;
     input_viz_mesh: number;
 }): number;
+export const shader_sdf_visualize: ImageShader;
+import { ImageShader } from "../../shader/ImageShader.js";
 //# sourceMappingURL=shader_sdf_visualize.d.ts.map

package/src/shade/renderer/geometry/sdf/shader_sdf_visualize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_sdf_visualize.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/shader_sdf_visualize.js"],"names":[],"mappings":"AAmKA;;;;;;;;;;GAUG;AACH;IAR+B,KAAK;IACD,IAAI;IACZ,WAAW,EAA3B,MAAM;IACU,aAAa,EAA7B,MAAM;IACU,cAAc,EAA9B,MAAM;IAEJ,MAAM,CAsGlB"}
+{"version":3,"file":"shader_sdf_visualize.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/shader_sdf_visualize.js"],"names":[],"mappings":"AA4JA;;;;;;;;;;GAUG;AACH;IAR+B,KAAK;IACD,IAAI;IACZ,WAAW,EAA3B,MAAM;IACU,aAAa,EAA7B,MAAM;IACU,cAAc,EAA9B,MAAM;IAEJ,MAAM,CAmGlB;AAvHD,+CASG;4BApIyB,6BAA6B"}

package/src/shade/renderer/geometry/sdf/shader_sdf_visualize.js

@@ -3,6 +3,12 @@ import { current_time_in_seconds } from "../../../../core/time/current_time_in_s
 import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
 import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import {
+    MESH_SDF_ATLAS_RESOURCE,
+    MESH_SDF_HEADERS_RESOURCE,
+    MESH_SDF_INDIRECTION_RESOURCE,
+    MESH_SDF_SAMPLER_RESOURCE
+} from "./MESH_SDF_RESOURCES.js";
 import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
 import { DEPTH_BACKGROUND_VALUE } from "../../depth/DEPTH_BACKGROUND_VALUE.js";
 import { BVH2_NODE_STRUCT } from "../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
@@ -29,7 +35,10 @@ const resources = new ShaderResourceSetDescriptor();
 resources.setImmediate("settings", SDF_DRAW_SETTINGS_STRUCT);
 
 resources.createGroup()
-    .addTexture("texture_sdf", "unfilterable-float", "3d")
+    .add(MESH_SDF_HEADERS_RESOURCE)
+    .add(MESH_SDF_INDIRECTION_RESOURCE)
+    .add(MESH_SDF_ATLAS_RESOURCE)
+    .add(MESH_SDF_SAMPLER_RESOURCE)
     .addTexture("gBufferDepth")
     .addTexture("gBufferNormals", "uint")
     .addTexture("vizBufferMesh", "uint")
@@ -65,22 +74,6 @@ fn main(
  
     let coord_i = vec2<u32>(coord.xy);
     
-//    const SLICE_ZOOM = 8;
-//    if(all(coord_i < vec2(settings.sdf_tile_resolution*SLICE_ZOOM))){
-//        let geometry_id = 18u;
-//        let geometry = geometries[geometry_id];
-//        let bounds = array_to_aabb3(geometry.bounding_box);
-//        let scale = 1.0 / max(0.001, min_v3(bounds.max - bounds.min));
-//    
-//        let sdf_uv = (vec3(vec2(vec2f(coord_i)/SLICE_ZOOM), settings.slice * f32(settings.sdf_tile_resolution - 1u)) + 0.5) / f32(settings.sdf_tile_resolution);
-//   
-//        let offset = tile_atlas_slot_origin(geometry_id, settings.sdf_atlas_resolution.xy, vec3(settings.sdf_tile_resolution));
-//        let geometry_distance = sdf_texture_region_sample_linear_uv(texture_sdf,  offset,  vec3(settings.sdf_tile_resolution), sdf_uv);
-//        return vec4(select(vec3(geometry_distance*scale, 0.0, 0.0), vec3(0.0, 0.0, geometry_distance*scale), geometry_distance >= 0), 1.0);
-////        return vec4(vec3( geometry_distance ), 1.0);
-////        return vec4(sdf_uv, 1.0);
-//    }
-    
     let depth = textureLoad(
         gBufferDepth,
         coord_i,
@@ -150,7 +143,7 @@ fn main(
 );
 
 
-const shader_sdf_visualize = new ImageShader({
+export const shader_sdf_visualize = new ImageShader({
     descriptor: ShaderDescriptor.from({
         label: 'SDF Visualize',
         resources,
@@ -217,8 +210,6 @@ export function graph_draw_sdf_normals({
         const viz_mesh = resources.get(data.viz_mesh);
 
         const buffer_settings = {
-            sdf_tile_resolution: sdf.tile_resolution,
-            sdf_atlas_resolution: sdf.atlas_resolution_in_tiles,
             slice: pingpong(current_time_in_seconds() / 5, 1),
         };
 
@@ -230,9 +221,8 @@ export function graph_draw_sdf_normals({
 
         shader_sdf_visualize.draw({
             encoder,
-            bindings: {
+            bindings: sdf.write_bindings({
                 settings: buffer_settings,
-                texture_sdf: sdf.texture.obtainView(),
                 gBufferDepth: depth.obtainView(),
                 gBufferNormals: normals.obtainView(),
                 vizBufferMesh: viz_mesh.obtainView(),
@@ -244,7 +234,7 @@ export function graph_draw_sdf_normals({
                 // debug
                 blas_data: blas.buffer_data,
                 blas_lookup: blas.buffer_metadata,
-            },
+            }),
             colorAttachments: [
                 {
                     loadOp: "clear",

package/src/shade/renderer/geometry/util/geometry_compute_surface_area.js

@@ -1,4 +1,4 @@
-import { compute_triangle_area_3d } from "../../../../core/geom/3d/triangle/compute_triangle_area_3d.js";
+import { tri3_area } from "../../../../core/geom/3d/triangle/tri3_area.js";
 import { StandardAttributes } from "../StandardAttributes.js";
 
 /**
@@ -20,7 +20,7 @@ export function geometry_compute_surface_area(geometry) {
         const b = index[i + 1];
         const c = index[i + 2];
 
-        result += compute_triangle_area_3d(
+        result += tri3_area(
             p[a * 3],
             p[a * 3 + 1],
             p[a * 3 + 2],

package/src/shade/renderer/geometry/util/geometry_estimate_uv_aspect.js

@@ -1,5 +1,5 @@
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
-import { compute_triangle_area_3d } from "../../../../core/geom/3d/triangle/compute_triangle_area_3d.js";
+import { tri3_area } from "../../../../core/geom/3d/triangle/tri3_area.js";
 import { compute_uv_aspect_ratio } from "../compute_uv_aspect_ratio.js";
 
 /**
@@ -37,7 +37,7 @@ export function geometry_estimate_uv_aspect(uv, position, index, index_count) {
             ...triangle_uvs,
         );
 
-        const triangle_area = compute_triangle_area_3d(
+        const triangle_area = tri3_area(
             ...triangle_positions,
         );
 

package/src/shade/renderer/geometry/util/geometry_simplify_redundant_topology.js

@@ -1,4 +1,4 @@
-import { v3_array_normalize } from "../../../../core/geom/vec3/v3_array_normalize.js";
+import { v3_normalize_array } from "../../../../core/geom/vec3/v3_normalize_array.js";
 import { v3_cross_array } from "../../../../core/geom/vec3/v3_cross_array.js";
 import { v3_dot } from "../../../../core/geom/vec3/v3_dot.js";
 import { Attribute } from "../Attribute.js";
@@ -133,7 +133,7 @@ function compute_face_normal(position_data, indices, triangle_id, out, out_offse
     scratch_edge2[0] = p2x - p0x; scratch_edge2[1] = p2y - p0y; scratch_edge2[2] = p2z - p0z;
 
     v3_cross_array(out, out_offset, scratch_edge1, 0, scratch_edge2, 0);
-    v3_array_normalize(out, out_offset, out, out_offset);
+    v3_normalize_array(out, out_offset, out, out_offset);
 }
 
 /**

package/src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.d.ts

@@ -17,7 +17,8 @@
  *
  * **Every view that cuts takes a slot** (§2.4): its own counters, its own want slice and its own
  * stamp tag, so one view's list running out cannot silence another's, and a reading can say which
- * view needed more wavefronts. The view the frame is opened for is slot 0.
+ * view needed more wavefronts. The view the frame is opened for is slot 0. A slot's taker is any
+ * {@link VGeoFeedbackConsumer}, a view's cut or a cut that is not a view's.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -165,17 +166,17 @@ export class GPUVirtualGeometryRuntime {
         view: VGeoViewCut;
     }): void;
     /**
-     * This frame's slot for a view, taking the next one the first time the view cuts in the frame.
+     * This frame's slot for a consumer, taking the next one the first time it cuts in the frame.
      *
-     * A view past the slots the frame was laid out for shares the last one — never slot 0, which is
-     * the frame's own view's — and the next frame is laid out with room for it. A shared slot's
-     * counters are the sum of its views', so its reading lands on each of them but escalates none
-     * (see `VGeoFeedbackLoop`).
+     * A consumer past the slots the frame was laid out for shares the last one — never slot 0, which
+     * is the frame's own view's — and the next frame is laid out with room for it. A shared slot's
+     * counters are the sum of its consumers', so its reading lands on each of them, told it was
+     * shared (see `VGeoFeedbackLoop`).
      *
-     * @param {VGeoViewCut} view
+     * @param {VGeoFeedbackConsumer} view
      * @returns {number}
      */
-    slot_of(view: VGeoViewCut): number;
+    slot_of(view: VGeoFeedbackConsumer): number;
     /**
      * The tag a slot's view writes into the want stamps, unique to that view in this frame and never
      * zero — see `VGEO_CUT_PARAMS_STRUCT.frame_tag`.
@@ -185,12 +186,22 @@ export class GPUVirtualGeometryRuntime {
      */
     frame_tag_of(slot: number): number;
     /**
-     * This frame's views, by slot — what a reading of this frame's feedback is about. A copy, since
-     * the reading lands frames later and the table is rebuilt every frame.
+     * Fill the fields of a cut's `VGEO_CUT_PARAMS_STRUCT` that are the frame's and its slot's rather
+     * than the cut's own: the arena's stride, where the frame's touch bits and the slot's counters and
+     * wants are, and the slot's stamp tag.
      *
-     * @returns {VGeoViewCut[][]}
+     * @param {Object} params written in place
+     * @param {number} slot this frame's, from {@link slot_of}
+     * @returns {Object} params
      */
-    frame_slots(): VGeoViewCut[][];
+    fill_slot_params(params: any, slot: number): any;
+    /**
+     * This frame's consumers, by slot — what a reading of this frame's feedback is about. A copy,
+     * since the reading lands frames later and the table is rebuilt every frame.
+     *
+     * @returns {VGeoFeedbackConsumer[][]}
+     */
+    frame_slots(): VGeoFeedbackConsumer[][];
     /**
      * The feedback buffer as a resource of `graph`, at the version that graph last wrote.
      *
@@ -267,4 +278,15 @@ export class GPUVirtualGeometryRuntime {
 export type GPUVirtualGeometryPool = import("./GPUVirtualGeometryPool.js").GPUVirtualGeometryPool;
 export type VGeoViewCut = import("./VGeoViewCut.js").VGeoViewCut;
 export type FrameGraph = import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+/**
+ * What takes a slot of a frame's feedback ({@link GPUVirtualGeometryRuntimeslot_of }): a cut that writes its
+ * counters and its wants there, and reads its counters back when the reading lands.
+ */
+export type VGeoFeedbackConsumer = {
+    /**
+     * the reading,
+     * where its slot's counters start in it, whether another consumer shared the slot, and the runtime
+     */
+    read_feedback: (arg0: Uint32Array, arg1: number, arg2: boolean, arg3: GPUVirtualGeometryRuntime) => void;
+};
 //# sourceMappingURL=GPUVirtualGeometryRuntime.d.ts.map

package/src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUVirtualGeometryRuntime.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAmHI;;;;;;;;;;;;;;;OAeG;IACH;QAd2C,IAAI,EAApC,sBAAsB;QACL,aAAa,GAA9B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QAEW,mBAAmB,GAApC,MAAM;QAEW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QAEW,qBAAqB,GAAtC,MAAM;QACW,aAAa,GAA9B,MAAM;OAgFhB;IA3KD;;;;OAIG;IACH,KAFU,MAAM,CAER;IAER;;OAEG;IACH,cAFU,OAAO,CAEG;IAmKpB;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;;OAIG;IACH,gCAEC;IAWD;;;;;;OAMG;IACH,iCAKC;IArBD;;;;OAIG;IACH,4BAEC;IAgBD;;;;OAIG;IACH,0BAEC;IAED;;;;OAIG;IACH,yDAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;OAEG;IACH;;;;;;;;MAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH;QAHgC,IAAI,EAAzB,WAAW;QACT,IAAI,CAqChB;IAwBD;;;;;;;;;;OAUG;IACH,cAHW,WAAW,GACT,MAAM,CA0BlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,eAFa,WAAW,EAAE,EAAE,CAI3B;IAED;;;;;;;;;OASG;IACH,mBAHW,UAAU,GACR,MAAM,CAkClB;IAED;;;;;;;;;;;;OAYG;IACH,wBAJW,UAAU,UACV,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAJ2B,iBAAiB,EAAjC,MAAM;QACU,gBAAgB,EAAhC,MAAM;QACJ,IAAI,CAgBhB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,aAFa,IAAI,CAKhB;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAOhB;;CACJ;qCA3nBY,OAAO,6BAA6B,EAAE,sBAAsB;0BAC5D,OAAO,kBAAkB,EAAE,WAAW;yBACtC,OAAO,iEAAiE,EAAE,UAAU"}
+{"version":3,"file":"GPUVirtualGeometryRuntime.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAmHI;;;;;;;;;;;;;;;OAeG;IACH;QAd2C,IAAI,EAApC,sBAAsB;QACL,aAAa,GAA9B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QAEW,mBAAmB,GAApC,MAAM;QAEW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QAEW,qBAAqB,GAAtC,MAAM;QACW,aAAa,GAA9B,MAAM;OAgFhB;IA3KD;;;;OAIG;IACH,KAFU,MAAM,CAER;IAER;;OAEG;IACH,cAFU,OAAO,CAEG;IAmKpB;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;;OAIG;IACH,gCAEC;IAWD;;;;;;OAMG;IACH,iCAKC;IArBD;;;;OAIG;IACH,4BAEC;IAgBD;;;;OAIG;IACH,0BAEC;IAED;;;;OAIG;IACH,yDAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;OAEG;IACH;;;;;;;;MAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH;QAHgC,IAAI,EAAzB,WAAW;QACT,IAAI,CAqChB;IAwBD;;;;;;;;;;OAUG;IACH,cAHW,oBAAoB,GAClB,MAAM,CA0BlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,oCAHW,MAAM,OAkBhB;IAED;;;;;OAKG;IACH,eAFa,oBAAoB,EAAE,EAAE,CAIpC;IAED;;;;;;;;;OASG;IACH,mBAHW,UAAU,GACR,MAAM,CAkClB;IAED;;;;;;;;;;;;OAYG;IACH,wBAJW,UAAU,UACV,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAJ2B,iBAAiB,EAAjC,MAAM;QACU,gBAAgB,EAAhC,MAAM;QACJ,IAAI,CAgBhB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,aAFa,IAAI,CAKhB;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAOhB;;CACJ;qCA/pBY,OAAO,6BAA6B,EAAE,sBAAsB;0BAC5D,OAAO,kBAAkB,EAAE,WAAW;yBACtC,OAAO,iEAAiE,EAAE,UAAU;;;;;;;;;;0BAQ1E,WAAW,QAAE,MAAM,QAAE,OAAO,QAAE,yBAAyB,KAAG,IAAI"}