@woosh/meep-engine 3.49.0 → 3.50.0

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

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

@@ -0,0 +1,24 @@
+import { SHAPE_RECORD_HULL_PLANE_LIMIT } from "../../../../../core/geom/3d/shape/record/ShapeRecord.js";
+import { ShapeRecordKind } from "../../../../../core/geom/3d/shape/record/ShapeRecordKind.js";
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * 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.from(
+    //language=WGSL
+    `
+const SHAPE_RECORD_SPHERE: u32 = ${ShapeRecordKind.Sphere}u;
+const SHAPE_RECORD_CAPSULE: u32 = ${ShapeRecordKind.Capsule}u;
+const SHAPE_RECORD_BOX: u32 = ${ShapeRecordKind.Box}u;
+const SHAPE_RECORD_CYLINDER: u32 = ${ShapeRecordKind.Cylinder}u;
+const SHAPE_RECORD_PLANE: u32 = ${ShapeRecordKind.Plane}u;
+const SHAPE_RECORD_CONVEX_HULL: u32 = ${ShapeRecordKind.ConvexHull}u;
+
+const SHAPE_RECORD_HULL_PLANE_LIMIT: u32 = ${SHAPE_RECORD_HULL_PLANE_LIMIT}u;
+`
+);

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

@@ -0,0 +1,20 @@
+/**
+ * A core shape record's box in its own local frame, ignoring pose: the WGSL twin of
+ * `shape_record_local_bounds` (`core/geom/3d/shape/record/`), branch for branch.
+ *
+ * - `shape_record_local_bounded(kind) -> bool`: whether the kind has a box at all. A plane has none:
+ *   its half-space is unbounded, and its caller bounds it some other way.
+ * - `shape_record_local_half_extents(kind, parameters) -> vec3<f32>`: the box's half extents; every
+ *   bounded kind's box is centred on the local origin. A sphere's radius on each axis; a capsule's
+ *   radius, and the radius plus half its segment along local Y; a box's half extents; a cylinder's
+ *   radius, and half its height along Y; a hull's bounding radius on each axis (the cube about the
+ *   sphere its record carries, since its planes alone do not say where its corners are). 0 for a
+ *   plane.
+ *
+ * `kind` is the record's `ShapeRecordKind` and `parameters` its `SHAPE_RECORD_PARAM_0..3`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_shape_record_local_bounds: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_shape_record_local_bounds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_shape_record_local_bounds.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_shape_record_local_bounds.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,8CAFU,SAAS,CAmCjB;0BArDwB,6BAA6B"}

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

@@ -0,0 +1,54 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_shape_record_kind } from "./chunk_shape_record_kind.js";
+
+/**
+ * A core shape record's box in its own local frame, ignoring pose: the WGSL twin of
+ * `shape_record_local_bounds` (`core/geom/3d/shape/record/`), branch for branch.
+ *
+ * - `shape_record_local_bounded(kind) -> bool`: whether the kind has a box at all. A plane has none:
+ *   its half-space is unbounded, and its caller bounds it some other way.
+ * - `shape_record_local_half_extents(kind, parameters) -> vec3<f32>`: the box's half extents; every
+ *   bounded kind's box is centred on the local origin. A sphere's radius on each axis; a capsule's
+ *   radius, and the radius plus half its segment along local Y; a box's half extents; a cylinder's
+ *   radius, and half its height along Y; a hull's bounding radius on each axis (the cube about the
+ *   sphere its record carries, since its planes alone do not say where its corners are). 0 for a
+ *   plane.
+ *
+ * `kind` is the record's `ShapeRecordKind` and `parameters` its `SHAPE_RECORD_PARAM_0..3`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_shape_record_local_bounds = CodeChunk.from(
+    //language=WGSL
+    `
+fn shape_record_local_bounded(kind: u32) -> bool {
+    return kind != SHAPE_RECORD_PLANE;
+}
+
+fn shape_record_local_half_extents(kind: u32, parameters: vec4<f32>) -> vec3<f32> {
+    if (kind == SHAPE_RECORD_SPHERE) {
+        return vec3<f32>(parameters.x);
+    }
+
+    if (kind == SHAPE_RECORD_CAPSULE) {
+        return vec3<f32>(parameters.x, parameters.x + parameters.y * 0.5, parameters.x);
+    }
+
+    if (kind == SHAPE_RECORD_BOX) {
+        return parameters.xyz;
+    }
+
+    if (kind == SHAPE_RECORD_CYLINDER) {
+        return vec3<f32>(parameters.x, parameters.y * 0.5, parameters.x);
+    }
+
+    if (kind == SHAPE_RECORD_CONVEX_HULL) {
+        return vec3<f32>(parameters.z);
+    }
+
+    return vec3<f32>(0.0);
+}
+`, [
+        chunk_shape_record_kind,
+    ]
+);

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

@@ -0,0 +1,23 @@
+/**
+ * `shape_record_signed_distance(kind, parameters, p) -> f32`: signed distance from a point to a core
+ * shape record's surface, negative inside, in the record's own local frame. `kind` is the record's
+ * `ShapeRecordKind` and `parameters` its four parameters, `SHAPE_RECORD_PARAM_0..3` as core lays
+ * them out.
+ *
+ * The WGSL twin of `shape_record_signed_distance` (`core/geom/3d/shape/record/`), branch for branch:
+ * the `sdf3_*` field each analytic kind's parameters were laid out for, a plane through
+ * `point_distance_above_plane` with `w = −offset`, and a hull as the maximum over its planes — exact
+ * inside, conservative outside near an edge or a corner (see the CPU twin's header).
+ *
+ * ## Seam
+ *
+ * A hull's planes live in a plane array the enclosing shader binds, in core's layout `(n, offset)`:
+ * the shader defines `fn shape_record_plane(index: u32) -> vec4<f32>` for any plane index a record it
+ * evaluates names. A hull reads `parameters.y` of them from `parameters.x` on, at most
+ * `SHAPE_RECORD_HULL_PLANE_LIMIT` (${SHAPE_RECORD_HULL_PLANE_LIMIT}): the loop's budget.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_shape_record_signed_distance: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_shape_record_signed_distance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_shape_record_signed_distance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_shape_record_signed_distance.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,iDAFU,SAAS,CAsDjB;0BAjFwB,6BAA6B"}

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

@@ -0,0 +1,82 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_shape_record_kind } from "./chunk_shape_record_kind.js";
+import { chunk_point_distance_above_plane } from "../geometry/plane/chunk_point_distance_above_plane.js";
+import { F32_MAX_DEFINITION } from "../math/F32_MAX_DEFINITION.js";
+import { chunk_sdf3_box } from "./chunk_sdf3_box.js";
+import { chunk_sdf3_capsule } from "./chunk_sdf3_capsule.js";
+import { chunk_sdf3_cylinder } from "./chunk_sdf3_cylinder.js";
+import { chunk_sdf3_sphere } from "./chunk_sdf3_sphere.js";
+
+/**
+ * `shape_record_signed_distance(kind, parameters, p) -> f32`: signed distance from a point to a core
+ * shape record's surface, negative inside, in the record's own local frame. `kind` is the record's
+ * `ShapeRecordKind` and `parameters` its four parameters, `SHAPE_RECORD_PARAM_0..3` as core lays
+ * them out.
+ *
+ * The WGSL twin of `shape_record_signed_distance` (`core/geom/3d/shape/record/`), branch for branch:
+ * the `sdf3_*` field each analytic kind's parameters were laid out for, a plane through
+ * `point_distance_above_plane` with `w = −offset`, and a hull as the maximum over its planes — exact
+ * inside, conservative outside near an edge or a corner (see the CPU twin's header).
+ *
+ * ## Seam
+ *
+ * A hull's planes live in a plane array the enclosing shader binds, in core's layout `(n, offset)`:
+ * the shader defines `fn shape_record_plane(index: u32) -> vec4<f32>` for any plane index a record it
+ * evaluates names. A hull reads `parameters.y` of them from `parameters.x` on, at most
+ * `SHAPE_RECORD_HULL_PLANE_LIMIT` (${SHAPE_RECORD_HULL_PLANE_LIMIT}): the loop's budget.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_shape_record_signed_distance = CodeChunk.from(
+    //language=WGSL
+    `
+fn shape_record_signed_distance(kind: u32, parameters: vec4<f32>, p: vec3<f32>) -> f32 {
+    if (kind == SHAPE_RECORD_SPHERE) {
+        return sdf3_sphere(p, parameters.x);
+    }
+
+    if (kind == SHAPE_RECORD_CAPSULE) {
+        return sdf3_capsule(p, parameters.x, parameters.y);
+    }
+
+    if (kind == SHAPE_RECORD_BOX) {
+        return sdf3_box(p, parameters.xyz);
+    }
+
+    if (kind == SHAPE_RECORD_CYLINDER) {
+        return sdf3_cylinder(p, parameters.x, parameters.y);
+    }
+
+    if (kind == SHAPE_RECORD_PLANE) {
+        // core's half-space is n·p − offset, the engine's WGSL plane n·p + w
+        return point_distance_above_plane(p, vec4<f32>(parameters.xyz, -parameters.w));
+    }
+
+    // SHAPE_RECORD_CONVEX_HULL: the maximum over its planes
+    let first = u32(parameters.x);
+    let count = u32(parameters.y);
+
+    var distance = -F32_MAX;
+
+    for (var i = 0u; i < SHAPE_RECORD_HULL_PLANE_LIMIT; i++) {
+        if (i >= count) {
+            break;
+        }
+
+        let plane = shape_record_plane(first + i);
+
+        distance = max(distance, point_distance_above_plane(p, vec4<f32>(plane.xyz, -plane.w)));
+    }
+
+    return distance;
+}
+`, [
+        chunk_shape_record_kind,
+        chunk_sdf3_sphere,
+        chunk_sdf3_capsule,
+        chunk_sdf3_box,
+        chunk_sdf3_cylinder,
+        chunk_point_distance_above_plane,
+        F32_MAX_DEFINITION,
+    ]
+);

package/src/shade/renderer/shader/chunk/spherical_harmonics/exponential/chunk_sh_exp_split_sum.d.ts

@@ -25,9 +25,10 @@
  * depends on `n·v`, which `P(r) Q(h_r)` cannot represent and the 2-D factor `B / (A + B)` carries exactly.
  *
  * `dfg` is a split-sum LUT read at `(NoV, roughness)`: `.x` the F0 scale A, `.y` the F90 bias B.
- * The engine's `tSplitSum` (`assets/textures/split_sum.bin`) weights both by `F_Hauber`'s `(1 - VoH)^4`,
- * as `chunk_integrate_brdf` does, so its `A + B` is the directional albedo to within 0.06% (against an f64
- * quadrature, 2026-10-03; held by `split_sum_asset.spec.js`). And this is single scattering:
+ * The engine's `tSplitSum` (`assets/textures/split_sum.bin`) weights both by Schlick's `(1 - VoH)^5`, the
+ * Fresnel `F_Schlick` applies in the direct lobe, as `chunk_integrate_brdf` does. Its `A + B` is the directional
+ * albedo to within 0.06% (against an f64 quadrature, 2026-10-03; held by `split_sum_asset.spec.js`), and
+ * regenerating it with Schlick's weight moved no texel's `A + B` by more than one f16 ulp. And this is single scattering:
  * `compute_indirect_specular` adds Turquin's multiple-scattering term, `1 + F0 (1 - Ess) / Ess`, which this
  * does not.
  *

package/src/shade/renderer/shader/chunk/spherical_harmonics/exponential/chunk_sh_exp_split_sum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sh_exp_split_sum.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/exponential/chunk_sh_exp_split_sum.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,oCAFU,SAAS,CAQhB;AAEH;;;;;;;;;;;;GAYG;AACH,oCAFU,SAAS,CAQhB;0BAhEuB,gCAAgC"}
+{"version":3,"file":"chunk_sh_exp_split_sum.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/exponential/chunk_sh_exp_split_sum.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,oCAFU,SAAS,CAQhB;AAEH;;;;;;;;;;;;GAYG;AACH,oCAFU,SAAS,CAQhB;0BAjEuB,gCAAgC"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/exponential/chunk_sh_exp_split_sum.js

@@ -27,9 +27,10 @@ import { CodeChunk } from "../../../compiler/CodeChunk.js";
  * depends on `n·v`, which `P(r) Q(h_r)` cannot represent and the 2-D factor `B / (A + B)` carries exactly.
  *
  * `dfg` is a split-sum LUT read at `(NoV, roughness)`: `.x` the F0 scale A, `.y` the F90 bias B.
- * The engine's `tSplitSum` (`assets/textures/split_sum.bin`) weights both by `F_Hauber`'s `(1 - VoH)^4`,
- * as `chunk_integrate_brdf` does, so its `A + B` is the directional albedo to within 0.06% (against an f64
- * quadrature, 2026-10-03; held by `split_sum_asset.spec.js`). And this is single scattering:
+ * The engine's `tSplitSum` (`assets/textures/split_sum.bin`) weights both by Schlick's `(1 - VoH)^5`, the
+ * Fresnel `F_Schlick` applies in the direct lobe, as `chunk_integrate_brdf` does. Its `A + B` is the directional
+ * albedo to within 0.06% (against an f64 quadrature, 2026-10-03; held by `split_sum_asset.spec.js`), and
+ * regenerating it with Schlick's weight moved no texel's `A + B` by more than one f16 ulp. And this is single scattering:
  * `compute_indirect_specular` adds Turquin's multiple-scattering term, `1 + F0 (1 - Ess) / Ess`, which this
  * does not.
  *

package/src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_append_slot.d.ts

@@ -0,0 +1,31 @@
+/**
+ * What {@link chunk_subgroup_append_slot} hands a lane that holds no slot: one that did not append,
+ * or one whose place fell at or past the capacity. The engine's one "no index" word, which no
+ * capacity reaches, so `slot < capacity` tests for it as well as `slot != SUBGROUP_APPEND_NONE` does.
+ *
+ * @type {number}
+ */
+export const SUBGROUP_APPEND_NONE: number;
+/**
+ * Claim a lane's slot in an append-only list, one atomic per subgroup: the subgroup counts the lanes
+ * that append, its first active lane adds that many to `count` with one `atomicAdd`, and each
+ * appending lane takes its place by its exclusive prefix over the subgroup.
+ *
+ * `fn subgroup_append_slot(count: ptr<storage, atomic<u32>, read_write>, want: bool, capacity: u32) -> u32`
+ *
+ * Returns the lane's slot, below `capacity`, or {@link SUBGROUP_APPEND_NONE}. Past `capacity` the
+ * count still rises — so whoever reads the list can tell it overflowed, and by how much — but no slot
+ * is handed out: what the list holds is only ever its first `capacity` entries, and the caller writes
+ * only into a slot it was given.
+ *
+ * Every lane of the subgroup calls it, appending or not, from subgroup-uniform control flow.
+ * The order of entries across subgroups is whatever order their atomics land in.
+ *
+ * Nothing here assumes how subgroups map onto `local_invocation_index`.
+ *
+ * @see chunk_collection_u32_append for a list of `u32`s
+ * @type {CodeChunk}
+ */
+export const chunk_subgroup_append_slot: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_subgroup_append_slot.d.ts.map

package/src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_append_slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_subgroup_append_slot.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_append_slot.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,mCAFU,MAAM,CAE+B;AAE/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yCAFU,SAAS,CA0BhB;0BAvDuB,6BAA6B"}