@woosh/meep-engine 3.57.0 → 3.58.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/global_illumination/brick4/cpu/brick4_bake_ao.js

@@ -4,7 +4,7 @@ import { sh3_basis_at } from "../../../../../core/geom/3d/sphere/harmonics/sh3_b
 import { sh3_vector_accumulate } from "../../../../../core/geom/3d/sphere/harmonics/sh3_vector_accumulate.js";
 import { sphere_fibonacci_point } from "../../../../../core/geom/3d/sphere/sphere_fibonacci_point.js";
 import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
-import { vector_scale_array } from "../../../../../core/geom/vec/vector_scale_array.js";
+import { vector_scale_offset } from "../../../../../core/geom/vec/vector_scale_offset.js";
 import { clamp01 } from "../../../../../core/math/clamp01.js";
 import { brick4_extract_probe_locations } from "./brick4_extract_probe_locations.js";
 
@@ -96,7 +96,7 @@ export function brick4_bake_ao(brick4, bvh, ao_distance = 4) {
 
         const normalization_weight = (4 * Math.PI) / AO_SAMPLE_COUNT;
 
-        vector_scale_array(probe, 0, probe, 0, 27, normalization_weight);
+        vector_scale_offset(probe, 0, probe, 0, 27, normalization_weight);
 
 
         array_copy(probe, 0, probe_data, i * 27, 27);

package/src/shade/renderer/global_illumination/lpv/bake/GPULightProbeVolumeRenderer.js

@@ -1,7 +1,7 @@
 import { assert } from "../../../../../core/assert.js";
 import { UINT32_MAX } from "../../../../../core/binary/UINT32_MAX.js";
 import LineBuilder from "../../../../../core/codegen/LineBuilder.js";
-import { randomPointOnSphere } from "../../../../../core/geom/random/randomPointOnSphere.js";
+import { random_point_on_sphere } from "../../../../../core/geom/random/random_point_on_sphere.js";
 import { clamp } from "../../../../../core/math/clamp.js";
 import { randomIntegerBetween } from "../../../../../core/math/random/randomIntegerBetween.js";
 import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
@@ -276,7 +276,7 @@ export class GPULightProbeVolumeRenderer {
 
         const direction = new Float32Array(3);
 
-        randomPointOnSphere(this.#random, direction, 0);
+        random_point_on_sphere(this.#random, direction, 0);
 
         const bake_uniform = command_ctx.allocateTransientValueBuffer(PROBE_BAKE_UNIFORMS_STRUCT, {
             direction,

package/src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.d.ts

@@ -15,6 +15,4 @@ export function lpv_visualise_probes({ scene_context, colors_enabled, probe_size
     probe_size?: number;
     bounds?: AABB3;
 }): void;
-export { sh3_sample_irradiance_by_direction };
-import { sh3_sample_irradiance_by_direction } from "../../../../core/geom/3d/sphere/harmonics/sh3_sample_irradiance_by_direction.js";
 //# sourceMappingURL=lpv_visualise_probes.d.ts.map

package/src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lpv_visualise_probes.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.js"],"names":[],"mappings":"AA0MA;;;;;;;;;;GAUG;AACH;IARoC,aAAa;IAEpB,cAAc,GAAhC,OAAO;IACU,UAAU,GAA3B,MAAM;IACU,MAAM;SAiEhC;;mDA7PM,iFAAiF"}
+{"version":3,"file":"lpv_visualise_probes.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.js"],"names":[],"mappings":"AAgMA;;;;;;;;;;GAUG;AACH;IARoC,aAAa;IAEpB,cAAc,GAAhC,OAAO;IACU,UAAU,GAA3B,MAAM;IACU,MAAM;SAiEhC"}

package/src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.js

@@ -17,9 +17,9 @@ import { Sampler2D } from "../../../../engine/graphics/texture/sampler/Sampler2D
 import { ColorSpace } from "../../texture/ColorSpace.js";
 import { Attribute } from "../../geometry/Attribute.js";
 import { make_octahedron_geometry } from "../../geometry/primitives/make_octahedron_geometry.js";
-import {
-    sh3_sample_irradiance_by_direction
-} from "../../../../core/geom/3d/sphere/harmonics/sh3_sample_irradiance_by_direction.js";
+import {
+    sh3_sample_irradiance_by_direction
+} from "../../../../core/geom/3d/sphere/harmonics/sh3_sample_irradiance_by_direction.js";
 import { StandardAttributes } from "../../geometry/StandardAttributes.js";
 import { StandardShadeMaterial } from "../../material/StandardShadeMaterial.js";
 import { place_primitive } from "../../scene/rows/place_primitive.js";
@@ -30,16 +30,6 @@ import { TextureWrapType } from "../../texture/TextureWrapType.js";
 import { BLACK_PIXEL_TEXTURE } from "../../texture/util/BLACK_PIXEL_TEXTURE.js";
 import { WHITE_PIXEL_TEXTURE } from "../../texture/util/WHITE_PIXEL_TEXTURE.js";
 
-/**
- * Re-exported from `core`, where the one implementation lives.
- *
- * This file used to carry a copy, with the all-positive signs — shadowing the `core` function, which
- * negated the odd-m terms because it was ported from three.js. The core one is in the project's
- * convention now, so there is nothing left to shadow. The export is kept because it is published
- * surface.
- */
-export { sh3_sample_irradiance_by_direction };
-
 const sh3_grace_cathedral = [
     0.7953949, 0.4405923, 0.5459412,
     0.3981450, 0.3526911, 0.6097158,