@woosh/meep-engine 3.47.0 → 3.50.0

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_space_linear_ray.js

@@ -0,0 +1,319 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_get_view_space_depth } from "../depth/chunk_get_view_space_depth.js";
+import { chunk_v3_matrix4_project } from "../geometry/vec3/chunk_v3_matrix4_project.js";
+import { chunk_ndc_to_uv } from "../texture/chunk_ndc_to_uv.js";
+import { chunk_get_bilinear_filter_texel } from "../texture/sample/chunk_get_bilinear_filter_texel.js";
+import { chunk_interpolate_bilinear_f32 } from "../texture/sample/chunk_interpolate_bilinear_f32.js";
+
+/**
+ * Most linear steps one march takes, whatever it asks for. With bisection, the work of one thread is
+ * bounded by 4 depth reads × (this + {@link SCREEN_SPACE_LINEAR_RAY_BISECTION_LIMIT} + 1).
+ * @type {number}
+ */
+export const SCREEN_SPACE_LINEAR_RAY_STEP_LIMIT = 64;
+
+/**
+ * Most bisection steps refining a hit.
+ * @type {number}
+ */
+export const SCREEN_SPACE_LINEAR_RAY_BISECTION_LIMIT = 8;
+
+/**
+ * A linear ray march against the depth buffer: a port of Tomasz Stachowiak's `raymarch.hlsl`
+ * (https://gist.github.com/h3r2tic/9c8356bdaefbe80b1a22ae0aaee192db, MIT or Apache 2.0), the march
+ * Bevy uses for contact shadows, SSR and SSGI. One routine for any screen-space trace that wants a
+ * first hit along a segment.
+ *
+ * **Where the accuracy comes from.**
+ * - The segment is clipped to the view frustum in NDC before marching, so every step lands on screen.
+ * - Steps are linear in NDC, where a straight 3D line stays straight and device depth is affine along it,
+ *   so the ray's depth at a step is exact. There is never more than one step per pixel.
+ * - Each step reads the depth buffer both point-sampled and bilinear, and claims occlusion only when the ray
+ *   is behind both. Point samples alone make a surface of stacked bricks that self-shadows; bilinear alone
+ *   shrink-wraps a continuous surface over every silhouette. Each rejects the other's false hits.
+ * - Depth is compared as view distance (`get_view_space_depth`), so the thickness is in world units.
+ *
+ * **How it is configured** (`ScreenSpaceLinearRay`, from `screen_space_linear_ray_new`):
+ * - `linear_steps`: capped at {@link SCREEN_SPACE_LINEAR_RAY_STEP_LIMIT}, and at the segment's length in pixels.
+ * - `linear_march_exponent`: 1 for equal steps; above 1 packs them toward the start.
+ * - `bisection_steps` and `use_secant`: refine a hit's position, for a trace that samples colour there.
+ * - `jitter`: the first step's fraction of a step, in (0, 1]; 1 is none.
+ * - `depth_thickness`: how deep behind a depth sample still counts as inside it, view-space units.
+ * - `march_behind_surfaces`: carry on past a surface the ray has gone further behind than the thickness,
+ *   for shadows; it misses surfaces unless `depth_thickness` ≥ the segment's length / `linear_steps`.
+ * - `use_sloppy_march`: point samples only.
+ *
+ * The result's `t` runs over the clipped segment, start to end: the hit, or the furthest the march got.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_screen_space_linear_ray = CodeChunk.from(
+    //language=WGSL
+    `
+const SCREEN_SPACE_LINEAR_RAY_STEP_LIMIT = ${SCREEN_SPACE_LINEAR_RAY_STEP_LIMIT}u;
+const SCREEN_SPACE_LINEAR_RAY_BISECTION_LIMIT = ${SCREEN_SPACE_LINEAR_RAY_BISECTION_LIMIT}u;
+
+struct ScreenSpaceLinearRay {
+    // NDC, after the divide: xy in [-1, 1], z the device depth
+    start_ndc: vec3<f32>,
+    end_ndc: vec3<f32>,
+    linear_steps: u32,
+    linear_march_exponent: f32,
+    bisection_steps: u32,
+    use_secant: bool,
+    jitter: f32,
+    depth_thickness: f32,
+    march_behind_surfaces: bool,
+    use_sloppy_march: bool,
+}
+
+struct ScreenSpaceLinearRayHit {
+    hit: bool,
+    // the hit, or on a miss the furthest the march got, from 0 at start_ndc to 1 at end_ndc
+    t: f32,
+    uv: vec2<f32>,
+    // how far behind the depth buffer the hit point is, view-space units; on a miss, undefined
+    penetration: f32,
+    // ditto, as a fraction of depth_thickness
+    penetration_fraction: f32,
+    // linear steps taken
+    steps: u32,
+}
+
+// one step's comparison against the depth buffer
+struct ScreenSpaceLinearRaySample {
+    // how far in front of the further of the two depth reads the ray is: negative behind both
+    distance: f32,
+    // false where the ray has gone deeper behind the nearer read than the thickness, marching behind
+    valid: bool,
+    // how far behind the nearer of the two reads the ray is
+    penetration: f32,
+}
+
+fn screen_space_linear_ray_new(start_ndc: vec3<f32>) -> ScreenSpaceLinearRay {
+    var ray: ScreenSpaceLinearRay;
+
+    ray.start_ndc = start_ndc;
+    ray.end_ndc = start_ndc;
+    ray.linear_steps = 4u;
+    ray.linear_march_exponent = 1.0;
+    ray.bisection_steps = 0u;
+    ray.use_secant = false;
+    ray.jitter = 1.0;
+    ray.depth_thickness = 1.0;
+    ray.march_behind_surfaces = false;
+    ray.use_sloppy_march = false;
+
+    return ray;
+}
+
+/**
+ * Point the ray along a clip-space direction from its start, clipping both ends to the view frustum.
+ * \`infinite\` extends it to the frustum's edge.
+ */
+fn screen_space_linear_ray_clip(ray: ptr<function, ScreenSpaceLinearRay>, direction_clip: vec4<f32>, infinite: bool) {
+    var end_clip = vec4<f32>((*ray).start_ndc, 1.0) + direction_clip;
+
+    // the divide, keeping clear of zero for a ray heading straight at the eye
+    end_clip /= select(-1.0, 1.0, end_clip.w >= 0.0) * max(1e-10, abs(end_clip.w));
+
+    // the start, onto the frustum
+    var delta = end_clip.xyz - (*ray).start_ndc;
+    let near_edge = select(vec3<f32>(-1.0, -1.0, 0.0), vec3<f32>(1.0, 1.0, 1.0), delta < vec3<f32>(0.0));
+    let to_near_edge = (near_edge - (*ray).start_ndc) / delta;
+
+    (*ray).start_ndc += delta * max(0.0, max(to_near_edge.x, to_near_edge.y));
+
+    // the end, onto the frustum
+    delta = end_clip.xyz - (*ray).start_ndc;
+    let far_edge = select(vec3<f32>(-1.0, -1.0, 0.0), vec3<f32>(1.0, 1.0, 1.0), delta >= vec3<f32>(0.0));
+    let to_far_edge = (far_edge - (*ray).start_ndc) / delta;
+    let nearest_far_edge = min(min(to_far_edge.x, to_far_edge.y), to_far_edge.z);
+
+    delta *= select(min(1.0, nearest_far_edge), nearest_far_edge, infinite);
+
+    (*ray).end_ndc = (*ray).start_ndc + delta;
+}
+
+/**
+ * March to an NDC point, clipped to the frustum.
+ */
+fn screen_space_linear_ray_to_ndc(ray: ptr<function, ScreenSpaceLinearRay>, end_ndc: vec3<f32>) {
+    let direction = vec4<f32>(end_ndc - (*ray).start_ndc, 0.0) * sign(end_ndc.z);
+
+    screen_space_linear_ray_clip(ray, direction, false);
+}
+
+/**
+ * March to a world-space point, clipped to the frustum.
+ */
+fn screen_space_linear_ray_to_world(ray: ptr<function, ScreenSpaceLinearRay>, end_ws: vec3<f32>, view_projection: mat4x4<f32>) {
+    screen_space_linear_ray_to_ndc(ray, v3_matrix4_project(end_ws, view_projection));
+}
+
+/**
+ * March toward a world-space direction, to the frustum's edge.
+ */
+fn screen_space_linear_ray_to_world_direction(ray: ptr<function, ScreenSpaceLinearRay>, direction_ws: vec3<f32>, view_projection: mat4x4<f32>) {
+    screen_space_linear_ray_clip(ray, view_projection * vec4<f32>(direction_ws, 0.0), true);
+}
+
+fn screen_space_linear_ray_sample(
+    ray: ptr<function, ScreenSpaceLinearRay>,
+    depth: texture_2d<f32>,
+    size: vec2<f32>,
+    camera: ${CAMERA_UNIFORM_STRUCT.wgsl_ref},
+    point_ndc: vec3<f32>,
+) -> ScreenSpaceLinearRaySample {
+    let uv = ndc_to_uv(point_ndc.xy);
+
+    let ray_depth = get_view_space_depth(point_ndc.z, camera);
+
+    // the four texels around the point, clamped to the edge; the nearest of them is the point sample
+    let footprint = get_bilinear_filter_texel(uv * size - 0.5);
+    let base = vec2<i32>(footprint.origin);
+    let last = vec2<i32>(size) - 1;
+
+    let d00 = textureLoad(depth, clamp(base, vec2<i32>(0), last), 0).r;
+    let d10 = textureLoad(depth, clamp(base + vec2<i32>(1, 0), vec2<i32>(0), last), 0).r;
+    let d01 = textureLoad(depth, clamp(base + vec2<i32>(0, 1), vec2<i32>(0), last), 0).r;
+    let d11 = textureLoad(depth, clamp(base + vec2<i32>(1, 1), vec2<i32>(0), last), 0).r;
+
+    let right = footprint.weights.x >= 0.5;
+    let nearest = select(select(d00, d10, right), select(d01, d11, right), footprint.weights.y >= 0.5);
+
+    let unfiltered_depth = get_view_space_depth(nearest, camera);
+    var linear_depth = get_view_space_depth(interpolate_bilinear_f32(vec4<f32>(d00, d10, d01, d11), footprint.weights), camera);
+
+    if ((*ray).use_sloppy_march) {
+        linear_depth = unfiltered_depth;
+    }
+
+    // relative, so it scales with the depth it pads
+    const BIAS = 0.000002;
+
+    var result: ScreenSpaceLinearRaySample;
+
+    result.distance = max(linear_depth, unfiltered_depth) * (1.0 + BIAS) - ray_depth;
+    result.penetration = ray_depth - min(linear_depth, unfiltered_depth);
+    result.valid = !(*ray).march_behind_surfaces || result.penetration < (*ray).depth_thickness;
+
+    return result;
+}
+
+fn screen_space_linear_ray_occludes(s: ScreenSpaceLinearRaySample) -> bool {
+    return s.distance < 0.0 && s.valid;
+}
+
+/**
+ * March the ray against \`depth\`, a device-depth buffer under \`camera\`'s projection.
+ */
+fn screen_space_linear_ray_march(
+    ray: ptr<function, ScreenSpaceLinearRay>,
+    depth: texture_2d<f32>,
+    camera: ${CAMERA_UNIFORM_STRUCT.wgsl_ref},
+) -> ScreenSpaceLinearRayHit {
+    let size = vec2<f32>(textureDimensions(depth));
+
+    let start = (*ray).start_ndc;
+    let direction = (*ray).end_ndc - start;
+
+    let start_uv = ndc_to_uv(start.xy);
+    let end_uv = ndc_to_uv((*ray).end_ndc.xy);
+
+    // never more than one step per pixel, nor more than the limit; two at least
+    let length_px = length((end_uv - start_uv) * size);
+    let step_count = max(2u, min(min((*ray).linear_steps, SCREEN_SPACE_LINEAR_RAY_STEP_LIMIT), u32(floor(length_px))));
+
+    var min_t = 0.0;
+    var max_t = 1.0;
+
+    var min_sample = ScreenSpaceLinearRaySample(0.0, false, 0.0);
+    var max_sample = ScreenSpaceLinearRaySample(0.0, false, 0.0);
+
+    var intersected = false;
+
+    var result: ScreenSpaceLinearRayHit;
+
+    result.hit = false;
+    result.steps = 0u;
+
+    // linear search for the first step behind both depth reads
+    for (var step = 0u; step < step_count; step++) {
+        let candidate_t = pow((f32(step) + (*ray).jitter) / f32(step_count), (*ray).linear_march_exponent);
+        let candidate = screen_space_linear_ray_sample(ray, depth, size, camera, start + direction * candidate_t);
+
+        result.steps = step + 1u;
+
+        if (screen_space_linear_ray_occludes(candidate)) {
+            max_t = candidate_t;
+            max_sample = candidate;
+            intersected = true;
+            break;
+        }
+
+        min_t = candidate_t;
+        min_sample = candidate;
+    }
+
+    var hit_t = min_t;
+    var hit_sample = min_sample;
+
+    if (intersected) {
+        // narrow [min_t, max_t] around the crossing
+        let bisection_steps = min((*ray).bisection_steps, SCREEN_SPACE_LINEAR_RAY_BISECTION_LIMIT);
+
+        for (var i = 0u; i < bisection_steps; i++) {
+            let mid_t = (min_t + max_t) * 0.5;
+            let candidate = screen_space_linear_ray_sample(ray, depth, size, camera, start + direction * mid_t);
+
+            if (screen_space_linear_ray_occludes(candidate)) {
+                max_t = mid_t;
+                max_sample = candidate;
+            } else {
+                min_t = mid_t;
+                min_sample = candidate;
+            }
+        }
+
+        hit_t = max_t;
+        hit_sample = max_sample;
+
+        if ((*ray).use_secant) {
+            // where the line through the bracket's two distances crosses zero; kept only if it is closer
+            let mid_t = mix(min_t, max_t, min_sample.distance / (min_sample.distance - max_sample.distance));
+            let candidate = screen_space_linear_ray_sample(ray, depth, size, camera, start + direction * mid_t);
+
+            if (abs(candidate.distance) < min_sample.distance * 0.9 && candidate.valid) {
+                hit_t = mid_t;
+                hit_sample = candidate;
+            }
+        }
+    }
+
+    result.t = hit_t;
+    result.uv = mix(start_uv, end_uv, hit_t);
+
+    let thickness = (*ray).depth_thickness;
+
+    if (intersected && hit_sample.penetration < thickness && hit_sample.distance < thickness) {
+        result.hit = true;
+        result.penetration = hit_sample.penetration;
+        result.penetration_fraction = hit_sample.penetration / thickness;
+    } else {
+        // the furthest the march got clear
+        result.t = min_t;
+        result.uv = mix(start_uv, end_uv, min_t);
+    }
+
+    return result;
+}
+`, [
+        chunk_v3_matrix4_project,
+        chunk_ndc_to_uv,
+        chunk_get_view_space_depth,
+        chunk_get_bilinear_filter_texel,
+        chunk_interpolate_bilinear_f32,
+    ]
+);

package/src/shade/renderer/shader/chunk/sdf/chunk_scene_sdf_raymarch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_scene_sdf_raymarch.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_scene_sdf_raymarch.js"],"names":[],"mappings":"AAoBA,iDAiGE;0BAjHwB,6BAA6B"}
+{"version":3,"file":"chunk_scene_sdf_raymarch.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_scene_sdf_raymarch.js"],"names":[],"mappings":"AAkBA,iDAiGE;0BAjHwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/sdf/chunk_scene_sdf_raymarch.js

@@ -1,7 +1,5 @@
-import {
-        chunk_sdf_slot_index_to_texture_offset
-} from "../../../geometry/sdf/chunk_sdf_slot_index_to_texture_offset.js";
 import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
+import { chunk_tile_atlas_slot_origin } from "../../../texture/atlas/chunk_tile_atlas_slot_origin.js";
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { BVH_NULL_NODE_DEFINITION } from "../bvh/BVH_NULL_NODE_DEFINITION.js";
 import { BVH_TRAVERSAL_STACK_SIZE } from "../bvh/BVH_TRAVERSAL_STACK_SIZE.js";
@@ -75,7 +73,7 @@ fn scene_sdf_raymarch(ray:${RAY_STRUCT.wgsl_ref}) -> f32{
 
             // normalize position
 
-            let offset = sdf_slot_index_to_texture_offset(mesh.geometry, settings.sdf_atlas_resolution)*settings.sdf_tile_resolution;
+            let offset = tile_atlas_slot_origin(mesh.geometry, settings.sdf_atlas_resolution.xy, vec3(settings.sdf_tile_resolution));
             let geometry_distance = sdf_raymarch(geometry_ray, texture_sdf,  offset,  vec3(settings.sdf_tile_resolution));
 
             // move point to world-space
@@ -107,7 +105,7 @@ fn scene_sdf_raymarch(ray:${RAY_STRUCT.wgsl_ref}) -> f32{
         chunk_mat4_inverse,
         chunk_aabb3_distance_to_ray,
         chunk_aabb3_unsigned_distance_to_point,
-        chunk_sdf_slot_index_to_texture_offset,
+        chunk_tile_atlas_slot_origin,
         chunk_sdf_texture_region_sample_linear_uv,
         chunk_array_to_aabb3,
         chunk_ray_transform_m4,

package/src/shade/renderer/shader/chunk/sdf/chunk_sdf3_box.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Signed distance from a point to a box centred at the origin of its own frame, spanning
+ * `±half_extents` on each axis: negative inside. Inigo Quilez's exact box field, with
+ * `q = |p| − half_extents`:
+ *
+ *     d(p) = ‖max(q, 0)‖ + min(max(qx, qy, qz), 0)
+ *
+ * The WGSL twin of `sdf3_box` (`core/geom/3d/shape/sdf/sdf3_box.js`), same frame and same
+ * parameters. A box given by its corners re-centres first: `aabb3_signed_distance_to_point`.
+ *
+ * @see https://iquilezles.org/articles/distfunctions/
+ * @type {CodeChunk}
+ */
+export const chunk_sdf3_box: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sdf3_box.d.ts.map

package/src/shade/renderer/shader/chunk/sdf/chunk_sdf3_box.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sdf3_box.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_sdf3_box.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,6BAFU,SAAS,CAajB;0BA3BwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/sdf/chunk_sdf3_box.js

@@ -0,0 +1,28 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_max_v3 } from "../geometry/vec3/chunk_max_v3.js";
+
+/**
+ * Signed distance from a point to a box centred at the origin of its own frame, spanning
+ * `±half_extents` on each axis: negative inside. Inigo Quilez's exact box field, with
+ * `q = |p| − half_extents`:
+ *
+ *     d(p) = ‖max(q, 0)‖ + min(max(qx, qy, qz), 0)
+ *
+ * The WGSL twin of `sdf3_box` (`core/geom/3d/shape/sdf/sdf3_box.js`), same frame and same
+ * parameters. A box given by its corners re-centres first: `aabb3_signed_distance_to_point`.
+ *
+ * @see https://iquilezles.org/articles/distfunctions/
+ * @type {CodeChunk}
+ */
+export const chunk_sdf3_box = CodeChunk.from(
+    //language=WGSL
+    `
+fn sdf3_box(p: vec3<f32>, half_extents: vec3<f32>) -> f32 {
+    let q = abs(p) - half_extents;
+
+    return length(max(q, vec3(0.0))) + min(max_v3(q), 0.0);
+}
+    `, [
+        chunk_max_v3
+    ]
+);

package/src/shade/renderer/shader/chunk/sdf/chunk_sdf3_capsule.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Signed distance from a point to a capsule about the **Y axis** of its own frame: negative inside.
+ * The capsule is a segment of length `height`, so `±height/2`, swept by a sphere of `radius`; its
+ * total extent along Y is `height + 2·radius`.
+ *
+ *     d(p) = ‖p − c(p)‖ − r,   c(p) = (0, clamp(y, −h/2, +h/2), 0)
+ *
+ * Collapsing Y onto the segment turns the capsule into a sphere about the nearest point on it, with
+ * no branch on which cap.
+ *
+ * The WGSL twin of `sdf3_capsule` (`core/geom/3d/shape/sdf/sdf3_capsule.js`), same frame and same
+ * parameters: `CapsuleShape3D`'s.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sdf3_capsule: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sdf3_capsule.d.ts.map

package/src/shade/renderer/shader/chunk/sdf/chunk_sdf3_capsule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sdf3_capsule.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_sdf3_capsule.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,iCAFU,SAAS,CAcjB;0BA7BwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/sdf/chunk_sdf3_capsule.js

@@ -0,0 +1,30 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Signed distance from a point to a capsule about the **Y axis** of its own frame: negative inside.
+ * The capsule is a segment of length `height`, so `±height/2`, swept by a sphere of `radius`; its
+ * total extent along Y is `height + 2·radius`.
+ *
+ *     d(p) = ‖p − c(p)‖ − r,   c(p) = (0, clamp(y, −h/2, +h/2), 0)
+ *
+ * Collapsing Y onto the segment turns the capsule into a sphere about the nearest point on it, with
+ * no branch on which cap.
+ *
+ * The WGSL twin of `sdf3_capsule` (`core/geom/3d/shape/sdf/sdf3_capsule.js`), same frame and same
+ * parameters: `CapsuleShape3D`'s.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sdf3_capsule = CodeChunk.from(
+    //language=WGSL
+    `
+fn sdf3_capsule(p: vec3<f32>, radius: f32, height: f32) -> f32 {
+    let half_height = height * 0.5;
+
+    // the offset from the nearest point on the segment: Y beyond the segment's end, if any
+    let offset = vec3(p.x, p.y - clamp(p.y, -half_height, half_height), p.z);
+
+    return length(offset) - radius;
+}
+    `
+);

package/src/shade/renderer/shader/chunk/sdf/chunk_sdf3_cylinder.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Signed distance from a point to a capped cylinder about the **Y axis** of its own frame: negative
+ * inside. `radius` across and `height` tall, so the flat caps sit at `±height/2`. Inigo Quilez's
+ * capped-cylinder field, with the radial and axial distances named:
+ *
+ *     dr = ‖(x, z)‖ − r          distance outside the infinite cylinder
+ *     da = |y| − h/2             distance outside the slab
+ *     d  = ‖max(dr, 0), max(da, 0)‖ + min(max(dr, da), 0)
+ *
+ * The WGSL twin of `sdf3_cylinder` (`core/geom/3d/shape/sdf/sdf3_cylinder.js`), same frame and same
+ * parameters.
+ *
+ * @see https://iquilezles.org/articles/distfunctions/
+ * @type {CodeChunk}
+ */
+export const chunk_sdf3_cylinder: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sdf3_cylinder.d.ts.map

package/src/shade/renderer/shader/chunk/sdf/chunk_sdf3_cylinder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sdf3_cylinder.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_sdf3_cylinder.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,kCAFU,SAAS,CAYjB;0BA3BwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/sdf/chunk_sdf3_cylinder.js

@@ -0,0 +1,28 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Signed distance from a point to a capped cylinder about the **Y axis** of its own frame: negative
+ * inside. `radius` across and `height` tall, so the flat caps sit at `±height/2`. Inigo Quilez's
+ * capped-cylinder field, with the radial and axial distances named:
+ *
+ *     dr = ‖(x, z)‖ − r          distance outside the infinite cylinder
+ *     da = |y| − h/2             distance outside the slab
+ *     d  = ‖max(dr, 0), max(da, 0)‖ + min(max(dr, da), 0)
+ *
+ * The WGSL twin of `sdf3_cylinder` (`core/geom/3d/shape/sdf/sdf3_cylinder.js`), same frame and same
+ * parameters.
+ *
+ * @see https://iquilezles.org/articles/distfunctions/
+ * @type {CodeChunk}
+ */
+export const chunk_sdf3_cylinder = CodeChunk.from(
+    //language=WGSL
+    `
+fn sdf3_cylinder(p: vec3<f32>, radius: f32, height: f32) -> f32 {
+    let radial = length(p.xz) - radius;
+    let axial = abs(p.y) - height * 0.5;
+
+    return length(max(vec2(radial, axial), vec2(0.0))) + min(max(radial, axial), 0.0);
+}
+    `
+);

package/src/shade/renderer/shader/chunk/sdf/chunk_sdf3_sphere.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Signed distance from a point to a sphere of `radius` centred at the origin of its own frame:
+ * negative inside.
+ *
+ *     d(p) = ‖p‖ − r
+ *
+ * The WGSL twin of `sdf3_sphere` (`core/geom/3d/shape/sdf/sdf3_sphere.js`).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sdf3_sphere: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sdf3_sphere.d.ts.map

package/src/shade/renderer/shader/chunk/sdf/chunk_sdf3_sphere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sdf3_sphere.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_sdf3_sphere.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,gCAFU,SAAS,CASjB;0BAnBwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/sdf/chunk_sdf3_sphere.js

@@ -0,0 +1,20 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Signed distance from a point to a sphere of `radius` centred at the origin of its own frame:
+ * negative inside.
+ *
+ *     d(p) = ‖p‖ − r
+ *
+ * The WGSL twin of `sdf3_sphere` (`core/geom/3d/shape/sdf/sdf3_sphere.js`).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sdf3_sphere = CodeChunk.from(
+    //language=WGSL
+    `
+fn sdf3_sphere(p: vec3<f32>, radius: f32) -> f32 {
+    return length(p) - radius;
+}
+    `
+);

package/src/shade/renderer/shader/chunk/sdf/chunk_sdf_texture_region_sample_linear_uv.d.ts

@@ -1,3 +1,10 @@
+/**
+ * A geometry's distance at uv in its tile of the SDF atlas: a corner-aligned trilinear tap, uv 0
+ * the centre of the tile's first texel and uv 1 the centre of its last. uv outside [0, 1] reads the
+ * tile's edge, so a caller that wants the distance past the tile adds its distance to the box after
+ * sampling. The far corner of the tap is clamped to the tile, so no read reaches a neighbour.
+ * @type {CodeChunk}
+ */
 export const chunk_sdf_texture_region_sample_linear_uv: CodeChunk;
 export const chunk_sdf_texture_region_sample_linear_uv_hardware: CodeChunk;
 import { CodeChunk } from "../../compiler/CodeChunk.js";

package/src/shade/renderer/shader/chunk/sdf/chunk_sdf_texture_region_sample_linear_uv.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sdf_texture_region_sample_linear_uv.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_sdf_texture_region_sample_linear_uv.js"],"names":[],"mappings":"AAKA,kEAmDE;AAGF,2EA0BE;0BArFwB,6BAA6B"}
+{"version":3,"file":"chunk_sdf_texture_region_sample_linear_uv.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_sdf_texture_region_sample_linear_uv.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,wDAFU,SAAS,CAmBjB;AAGF,2EA0BE;0BA5DwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/sdf/chunk_sdf_texture_region_sample_linear_uv.js

@@ -1,8 +1,17 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
-import { chunk_interpolate_bilinear_f32 } from "../texture/sample/chunk_interpolate_bilinear_f32.js";
-import { chunk_uv3_distance_to_bounds } from "./chunk_uv3_distance_to_bounds.js";
+import {
+    chunk_texture3d_trilinear_corners_corner_aligned,
+    chunk_texture3d_trilinear_interpolate
+} from "../texture/sample/chunk_texture3d_trilinear_corners.js";
 
 
+/**
+ * A geometry's distance at uv in its tile of the SDF atlas: a corner-aligned trilinear tap, uv 0
+ * the centre of the tile's first texel and uv 1 the centre of its last. uv outside [0, 1] reads the
+ * tile's edge, so a caller that wants the distance past the tile adds its distance to the box after
+ * sampling. The far corner of the tap is clamped to the tile, so no read reaches a neighbour.
+ * @type {CodeChunk}
+ */
 export const chunk_sdf_texture_region_sample_linear_uv = CodeChunk.from(
     //language=WGSL
     `
@@ -12,47 +21,13 @@ fn sdf_texture_region_sample_linear_uv(
     region_size: vec3<u32>,
     uv:vec3<f32>
 ) -> f32{
-    // UV might be outside of the sampling range of 0...1
-    // to get the correct result, we compute distance to the box bounds and then add it with the appropriate sign after sampling
-    
-    let uv_saturated = saturate(uv);
-
-    let max_texel = region_size - 1u;
-    
-    // get texel coordinates
-    let local_texel = uv_saturated * vec3<f32>(max_texel);
-    let texel_fraction = fract(local_texel);
-             
-    let p000 = vec3<u32>(local_texel);
-    let p100 = vec3(min(p000.x+1u, max_texel.x), p000.y, p000.z);
-    let p010 = vec3(p000.x, min(p000.y + 1u, max_texel.y), p000.z);
-    let p001 = vec3(p000.x, p000.y, min(p000.z + 1u, max_texel.z));
-    
-    let p110 = vec3(p100.x, p010.y, p000.z);
-    let p111 = vec3(p100.x, p010.y, p001.z);
-    let p101 = vec3(p100.x, p000.y, p001.z);
-    let p011 = vec3(p000.x, p010.y, p001.z);
-    
-    let t000 = textureLoad(texture_sdf, region_offset + p000, 0).r;
-    let t100 = textureLoad(texture_sdf, region_offset + p100, 0).r;
-    let t010 = textureLoad(texture_sdf, region_offset + p010, 0).r;
-    let t110 = textureLoad(texture_sdf, region_offset + p110, 0).r;
-    
-    let t001 = textureLoad(texture_sdf, region_offset + p001, 0).r;
-    let t101 = textureLoad(texture_sdf, region_offset + p101, 0).r;
-    let t011 = textureLoad(texture_sdf, region_offset + p011, 0).r;
-    let t111 = textureLoad(texture_sdf, region_offset + p111, 0).r;
-    
-    let z0 = interpolate_bilinear_f32(vec4(t000,t100, t010, t110), texel_fraction.xy);
-    let z1 = interpolate_bilinear_f32(vec4(t001,t101, t011, t111), texel_fraction.xy);
-    
-    let sampled_distance = mix(z0, z1, texel_fraction.z);
-    
-    return sampled_distance;
+    return texture3d_trilinear_interpolate(
+        texture3d_trilinear_corners_corner_aligned(texture_sdf, region_offset, region_size, uv)
+    );
 }
   `, [
-        chunk_interpolate_bilinear_f32,
-        chunk_uv3_distance_to_bounds,
+        chunk_texture3d_trilinear_corners_corner_aligned,
+        chunk_texture3d_trilinear_interpolate,
     ]
 );
 

package/src/shade/renderer/shader/chunk/sdf/chunk_shape_record_kind.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Core's `ShapeRecordKind` values and `SHAPE_RECORD_HULL_PLANE_LIMIT` as WGSL constants, the one
+ * declaration every shape-record chunk shares (`chunk_shape_record_signed_distance`,
+ * `chunk_shape_record_local_bounds`), so a shader may include several of them.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_shape_record_kind: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_shape_record_kind.d.ts.map

package/src/shade/renderer/shader/chunk/sdf/chunk_shape_record_kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_shape_record_kind.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_shape_record_kind.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,sCAFU,SAAS,CAcjB;0BArBwB,6BAA6B"}