@woosh/meep-engine 3.64.0 → 3.65.0

package/src/shade/renderer/scene/MESH_GROUND_COVER_STRUCT.js

@@ -0,0 +1,58 @@
+import { f32, u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+
+/**
+ * A mesh row's membership of a grass surface: which surface it is ground of, what a column of that
+ * surface traces to find it, and what grows on it.
+ *
+ * A record of the scene database's `mesh_ground_covers` table, which shares the `meshes` table's index
+ * space: a row's ground cover is at the row's own index.
+ *
+ * **`flags` says what holds.** A row nothing has written, and a row on a page the table has never
+ * allocated, both read as a record of zeros, so zero flags is "not ground of any surface" and the other
+ * fields are read only when {@link MESH_GROUND_COVER_FLAG_MEMBER} is set.
+ */
+export const MESH_GROUND_COVER_STRUCT = WebGPUStruct.from({
+    /**
+     * {@link MESH_GROUND_COVER_FLAG_MEMBER}, {@link MESH_GROUND_COVER_FLAG_GROWS}.
+     */
+    flags: u32,
+
+    /**
+     * The `transforms` row of the grass surface the mesh is a member of: the surface's frame.
+     */
+    surface: u32,
+
+    /**
+     * The geometry a column traces for this member. The mesh's own, or a stand-in's for a geometry
+     * that cannot be ray traced itself.
+     */
+    geometry: u32,
+
+    /**
+     * Index of the species that grows on the member. Read only when
+     * {@link MESH_GROUND_COVER_FLAG_GROWS} is set.
+     */
+    species: u32,
+
+    /**
+     * Scale on the member's painted density, 0 to 1.
+     */
+    density: f32,
+}, "MeshGroundCover").pack();
+
+/**
+ * The row is a member of the surface its record names. Its faces are ground of that surface: they
+ * hold surfels, and they hide the ground of other members under them.
+ *
+ * @type {number}
+ */
+export const MESH_GROUND_COVER_FLAG_MEMBER = 1;
+
+/**
+ * Something grows on the member, and its record's `species` holds. A member without it only hides
+ * ground.
+ *
+ * @type {number}
+ */
+export const MESH_GROUND_COVER_FLAG_GROWS = 2;

package/src/shade/renderer/scene/SCENE_DATABASE_SPEC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SCENE_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SCENE_DATABASE_SPEC.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,wDAYG;sCA1BmC,0CAA0C"}
+{"version":3,"file":"SCENE_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SCENE_DATABASE_SPEC.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,wDAkBG;sCAlCmC,0CAA0C"}

package/src/shade/renderer/scene/SCENE_DATABASE_SPEC.js

@@ -1,4 +1,6 @@
 import { GPUDatabaseDefinition } from "../buffer/table/GPUDatabaseDefinition.js";
+import { GRASS_SURFACE_PARAMS_STRUCT } from "./GRASS_SURFACE_PARAMS_STRUCT.js";
+import { MESH_GROUND_COVER_STRUCT } from "./MESH_GROUND_COVER_STRUCT.js";
 import { MESH_INSTANCE_METADATA_STRUCT } from "./MESH_INSTANCE_METADATA_STRUCT.js";
 import { MESH_OUTLINE_STRUCT } from "./MESH_OUTLINE_STRUCT.js";
 import { NODE3D_STRUCT } from "./NODE3D_STRUCT.js";
@@ -24,6 +26,12 @@ export const SCENE_DATABASE_SPEC = GPUDatabaseDefinition.from({
     // which outline specs a mesh row is drawn with, at the row's own index; written by OutlineSystem
     // when a row's specs change, read by the outline classify pass
     mesh_outlines: MESH_OUTLINE_STRUCT,
+    // which grass surface a mesh row is ground of, at the row's own index; written by GrassSurfaceSystem
+    // when a membership changes, read by the grass surface bake and by the blades that stand on it
+    mesh_ground_covers: MESH_GROUND_COVER_STRUCT,
+    // what grows on a grass surface, at the surface's own row; written by GrassSurfaceSystem, read by
+    // the passes that count and make its blades
+    grass_surface_params: GRASS_SURFACE_PARAMS_STRUCT,
 });
 
 SCENE_DATABASE_SPEC.add_link({ table: 'water_bodies', field: 'node', target_database: SCENE_DATABASE_SPEC,

package/src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.d.ts

@@ -8,8 +8,16 @@
  * fn multiscale_mean_seed(sample: vec3f) -> MultiscaleMean
  * fn multiscale_mean_add(e: MultiscaleMean, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool, exposure: f32) -> MultiscaleMean
  * fn multiscale_mean_deviation_floor(short_mean: vec3f, exposure: f32) -> vec3f
+ * fn multiscale_mean_catch_up(relative: f32, inconsistency: f32, reduction: f32) -> f32
+ * fn multiscale_mean_blend_reduction(level: f32) -> f32
+ * const MULTISCALE_MEAN_REDUCTION_BLEND: f32
  * ```
  *
+ * `multiscale_mean_catch_up` and `multiscale_mean_blend_reduction` are the long mean's decision alone, for an
+ * estimator over a quantity the caller keeps the means of itself: `relative` the means' gap over the deviation,
+ * `inconsistency` its smoothed history, `reduction` the blend reduction as it stood before this sample, and `level`
+ * the short mean over the deviation. The reduction follows `level`'s by `MULTISCALE_MEAN_REDUCTION_BLEND` a sample.
+ *
  * `MultiscaleMean` is {@link MULTISCALE_MEAN_STRUCT}.
  *
  * - **Exposure**: the factor the display multiplies the samples by ahead of its tone curve, Unreal Engine's

package/src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_multiscale_mean.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,oCAFU,SAAS,CAuDZ;0BAhHmB,6BAA6B"}
+{"version":3,"file":"chunk_multiscale_mean.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,oCAFU,SAAS,CAiEZ;0BAlImB,6BAA6B"}

package/src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.js

@@ -16,8 +16,16 @@ const EXPOSURE_MAX = '1.70141183e38';
  * fn multiscale_mean_seed(sample: vec3f) -> MultiscaleMean
  * fn multiscale_mean_add(e: MultiscaleMean, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool, exposure: f32) -> MultiscaleMean
  * fn multiscale_mean_deviation_floor(short_mean: vec3f, exposure: f32) -> vec3f
+ * fn multiscale_mean_catch_up(relative: f32, inconsistency: f32, reduction: f32) -> f32
+ * fn multiscale_mean_blend_reduction(level: f32) -> f32
+ * const MULTISCALE_MEAN_REDUCTION_BLEND: f32
  * ```
  *
+ * `multiscale_mean_catch_up` and `multiscale_mean_blend_reduction` are the long mean's decision alone, for an
+ * estimator over a quantity the caller keeps the means of itself: `relative` the means' gap over the deviation,
+ * `inconsistency` its smoothed history, `reduction` the blend reduction as it stood before this sample, and `level`
+ * the short mean over the deviation. The reduction follows `level`'s by `MULTISCALE_MEAN_REDUCTION_BLEND` a sample.
+ *
  * `MultiscaleMean` is {@link MULTISCALE_MEAN_STRUCT}.
  *
  * - **Exposure**: the factor the display multiplies the samples by ahead of its tone curve, Unreal Engine's
@@ -79,6 +87,16 @@ fn multiscale_mean_deviation_floor(short_mean: vec3f, exposure: f32) -> vec3f {
     return max(vec3f(sqrt(1e-5) / multiscale_mean_exposure(exposure)), max(abs(short_mean) * exp2(-10.0), vec3f(exp2(-24.0))));
 }
 
+const MULTISCALE_MEAN_REDUCTION_BLEND: f32 = 0.1;
+
+fn multiscale_mean_catch_up(relative: f32, inconsistency: f32, reduction: f32) -> f32 {
+    return clamp(smoothstep(0.0, 1.0, relative * max(0.02, inconsistency - 0.2)), 1.0 / 256.0, 1.0) * reduction;
+}
+
+fn multiscale_mean_blend_reduction(level: f32) -> f32 {
+    return clamp(0.5 * level, 1.0 / 32.0, 1.0);
+}
+
 fn multiscale_mean_add(e: ${MULTISCALE_MEAN_STRUCT.wgsl_ref}, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool, exposure: f32) -> ${MULTISCALE_MEAN_STRUCT.wgsl_ref} {
     var y = sample;
 
@@ -95,15 +113,15 @@ fn multiscale_mean_add(e: ${MULTISCALE_MEAN_STRUCT.wgsl_ref}, sample: vec3f, sho
 
     let relative = rgb_to_luminance(abs(e.mean - short_mean) / deviation);
     let inconsistency = mix(e.inconsistency, relative, short_blend);
-    let reduction = clamp(rgb_to_luminance(0.5 * short_mean / deviation), 1.0 / 32.0, 1.0);
+    let reduction = multiscale_mean_blend_reduction(rgb_to_luminance(short_mean / deviation));
 
-    let catch_up = clamp(smoothstep(0.0, 1.0, relative * max(0.02, inconsistency - 0.2)), 1.0 / 256.0, 1.0) * e.reduction;
+    let catch_up = multiscale_mean_catch_up(relative, inconsistency, e.reduction);
 
     return ${MULTISCALE_MEAN_STRUCT.make({
         mean: 'mix(e.mean, y, max(saturate(catch_up), mean_blend_min))',
         short_mean: 'short_mean',
         variance: 'variance',
-        reduction: 'mix(e.reduction, reduction, 0.1)',
+        reduction: 'mix(e.reduction, reduction, MULTISCALE_MEAN_REDUCTION_BLEND)',
         inconsistency: 'inconsistency',
     })};
 }

package/src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_nearest_among.d.ts

@@ -0,0 +1,37 @@
+/**
+ * What {@link chunk_ray_query_nearest_among}'s hook answers for an instance the ray passes by: the
+ * engine's one "no index" word, which no geometry reaches.
+ *
+ * @type {number}
+ */
+export const RAY_QUERY_AMONG_PASS: number;
+/**
+ * The nearest hit of a ray among the scene's instances the enclosing shader chooses, each traced as the
+ * geometry that shader names for it.
+ *
+ * ```wgsl
+ * fn ray_query_nearest_among(ray: Ray) -> RayHitInfo
+ * ```
+ *
+ * The walk over the scene's TLAS is `ray_query_nearest`'s. An instance the ray's reach meets is put to the
+ * hook before its geometry is entered, so an instance the hook passes by costs its box test and the hook,
+ * and none of its triangles.
+ *
+ * A hit holds the world distance in `t` (negative for a miss), the instance's `meshes` row in `instance`,
+ * the geometry that was traced in `geometry`, and `triangle` and `barycentrics` in that geometry.
+ *
+ * ## The seam: one function the enclosing shader defines
+ *
+ * - `fn ray_query_among_geometry(mesh: u32) -> u32` is asked about the instance at `meshes` row `mesh`,
+ *   and answers with the geometry to trace for it, or `RAY_QUERY_AMONG_PASS` to pass it by. An instance
+ *   traced as a geometry other than its own (a stand-in) is traced under the instance's own transform.
+ *
+ * The enclosing shader binds what `ray_query_nearest` reads: `tlas`, `scene_database` and the BLAS
+ * buffers. The ray's direction is unit length. The TLAS must hold a tree: an empty one
+ * (`tlas.root == BVH_NULL_NODE`) is the caller's to turn away.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_ray_query_nearest_among: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_ray_query_nearest_among.d.ts.map

package/src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_nearest_among.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_ray_query_nearest_among.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_nearest_among.js"],"names":[],"mappings":"AAYA;;;;;GAKG;AACH,mCAFU,MAAM,CAE+B;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,4CAFU,SAAS,CAsGjB;0BAjJwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/ray/chunk_ray_query_nearest_among.js

@@ -0,0 +1,148 @@
+import { UINT32_MAX } from "../../../../../../core/binary/UINT32_MAX.js";
+import { TRANSFORMS_TABLE } from "../../../../scene/chunk_scene_database_access.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";
+import { chunk_aabb3_intersects_ray } from "../aabb3/chunk_aabb3_intersects_ray.js";
+import { chunk_mat4_inverse } from "../mat4/chunk_mat4_inverse.js";
+import { chunk_ray_query_blas_nearest } from "./chunk_ray_query_blas_nearest.js";
+import { chunk_ray_transform_m4 } from "./chunk_ray_transform_m4.js";
+import { RAY_HIT_INFO } from "./RAY_HIT_INFO.js";
+import { RAY_STRUCT } from "./RAY_STRUCT.js";
+
+/**
+ * What {@link chunk_ray_query_nearest_among}'s hook answers for an instance the ray passes by: the
+ * engine's one "no index" word, which no geometry reaches.
+ *
+ * @type {number}
+ */
+export const RAY_QUERY_AMONG_PASS = UINT32_MAX;
+
+/**
+ * The nearest hit of a ray among the scene's instances the enclosing shader chooses, each traced as the
+ * geometry that shader names for it.
+ *
+ * ```wgsl
+ * fn ray_query_nearest_among(ray: Ray) -> RayHitInfo
+ * ```
+ *
+ * The walk over the scene's TLAS is `ray_query_nearest`'s. An instance the ray's reach meets is put to the
+ * hook before its geometry is entered, so an instance the hook passes by costs its box test and the hook,
+ * and none of its triangles.
+ *
+ * A hit holds the world distance in `t` (negative for a miss), the instance's `meshes` row in `instance`,
+ * the geometry that was traced in `geometry`, and `triangle` and `barycentrics` in that geometry.
+ *
+ * ## The seam: one function the enclosing shader defines
+ *
+ * - `fn ray_query_among_geometry(mesh: u32) -> u32` is asked about the instance at `meshes` row `mesh`,
+ *   and answers with the geometry to trace for it, or `RAY_QUERY_AMONG_PASS` to pass it by. An instance
+ *   traced as a geometry other than its own (a stand-in) is traced under the instance's own transform.
+ *
+ * The enclosing shader binds what `ray_query_nearest` reads: `tlas`, `scene_database` and the BLAS
+ * buffers. The ray's direction is unit length. The TLAS must hold a tree: an empty one
+ * (`tlas.root == BVH_NULL_NODE`) is the caller's to turn away.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_ray_query_nearest_among = CodeChunk.from(
+    //language=WGSL
+    `
+const RAY_QUERY_AMONG_PASS: u32 = ${RAY_QUERY_AMONG_PASS}u;
+
+fn ray_query_nearest_among(
+    ray: ${RAY_STRUCT.wgsl_ref},
+) -> ${RAY_HIT_INFO.wgsl_ref} {
+    var stack = array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>();
+
+    var node_index = tlas.root;
+    var pointer = 1u;
+
+    let direction_rcp = 1.0 / ray.direction;
+
+    var best_hit: ${RAY_HIT_INFO.wgsl_ref};
+    best_hit.t = -1.0;
+
+    var global_ray = ray;
+
+    for (; pointer > 0u && pointer <= ${BVH_TRAVERSAL_STACK_SIZE}u;) {
+
+        let node = tlas.nodes[node_index];
+
+        if (!aabb3_intersects_ray(node.bounds, global_ray.origin, direction_rcp, global_ray.tmax)) {
+            pointer--;
+            node_index = stack[pointer];
+
+            continue;
+        }
+
+        let child_1 = node.child_1;
+        let child_2 = node.child_2;
+
+        if (child_1 != BVH_NULL_NODE) {
+            // an inner node
+            node_index = child_1;
+
+            stack[pointer] = child_2;
+
+            pointer++;
+
+            continue;
+        }
+
+        pointer--;
+        node_index = stack[pointer];
+
+        // a leaf: child_2 is the instance's meshes row
+        let mesh_id = child_2;
+
+        let geometry_id = ray_query_among_geometry(mesh_id);
+
+        if (geometry_id == RAY_QUERY_AMONG_PASS) {
+            continue;
+        }
+
+        // a mesh row and its transforms row are the same row
+        let global = ${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, mesh_id);
+
+        let local_ray = ray_transform_m4(global_ray, mat4_inverse(global));
+
+        let hit = ray_query_blas_nearest(local_ray, geometry_id, &stack, pointer);
+
+        if (hit.t < 0.0) {
+            continue;
+        }
+
+        let local_hit_position = local_ray.origin + local_ray.direction * hit.t;
+
+        let global_hit_position = global * vec4(local_hit_position, 1.0);
+
+        let reach = distance(global_ray.origin, global_hit_position.xyz / global_hit_position.w);
+
+        if (reach >= global_ray.tmax) {
+            continue;
+        }
+
+        global_ray.tmax = reach;
+
+        best_hit = hit;
+
+        best_hit.t = reach;
+        best_hit.instance = mesh_id;
+        best_hit.geometry = geometry_id;
+    }
+
+    return best_hit;
+}
+`,
+    [
+        RAY_STRUCT.declaration_chunk,
+        RAY_HIT_INFO.declaration_chunk,
+        BVH_NULL_NODE_DEFINITION,
+        chunk_ray_transform_m4,
+        chunk_aabb3_intersects_ray,
+        chunk_ray_query_blas_nearest,
+        chunk_mat4_inverse,
+        TRANSFORMS_TABLE.chunk_read_field('global'),
+    ]
+);

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

@@ -0,0 +1,20 @@
+/**
+ * `shape_record_line_span(kind, parameters, origin, direction) -> vec2<f32>`: the part of a line a core
+ * shape record holds, in the record's own local frame. The line is `origin + t · direction`,
+ * `direction` unit; the answer is the `t` it enters the shape at and the `t` it leaves at. A line that
+ * misses answers a span whose first is greater than its second. Every kind is convex, so the part is
+ * one span; a half-space's is open on one side, to `±F32_MAX`, and so may a hull's be.
+ *
+ * `kind` and `parameters` are as `shape_record_signed_distance` takes them, and the span is where that
+ * distance is at most zero along the line.
+ *
+ * ## Seam
+ *
+ * A hull's planes come through `shape_record_plane(index)`, which the enclosing shader defines (see
+ * `chunk_shape_record_signed_distance`); at most `SHAPE_RECORD_HULL_PLANE_LIMIT` of them are read.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_shape_record_line_span: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_shape_record_line_span.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_shape_record_line_span.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/sdf/chunk_shape_record_line_span.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,SAAS,CAqJjB;0BAxKwB,6BAA6B"}

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

@@ -0,0 +1,169 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { F32_MAX_DEFINITION } from "../math/F32_MAX_DEFINITION.js";
+import { chunk_shape_record_kind } from "./chunk_shape_record_kind.js";
+
+/**
+ * `shape_record_line_span(kind, parameters, origin, direction) -> vec2<f32>`: the part of a line a core
+ * shape record holds, in the record's own local frame. The line is `origin + t · direction`,
+ * `direction` unit; the answer is the `t` it enters the shape at and the `t` it leaves at. A line that
+ * misses answers a span whose first is greater than its second. Every kind is convex, so the part is
+ * one span; a half-space's is open on one side, to `±F32_MAX`, and so may a hull's be.
+ *
+ * `kind` and `parameters` are as `shape_record_signed_distance` takes them, and the span is where that
+ * distance is at most zero along the line.
+ *
+ * ## Seam
+ *
+ * A hull's planes come through `shape_record_plane(index)`, which the enclosing shader defines (see
+ * `chunk_shape_record_signed_distance`); at most `SHAPE_RECORD_HULL_PLANE_LIMIT` of them are read.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_shape_record_line_span = CodeChunk.from(
+    //language=WGSL
+    `
+const SHAPE_RECORD_LINE_MISS = vec2<f32>(F32_MAX, -F32_MAX);
+
+// two spans' common part
+fn shape_record_span_meet(a: vec2<f32>, b: vec2<f32>) -> vec2<f32> {
+    return vec2<f32>(max(a.x, b.x), min(a.y, b.y));
+}
+
+// the least span that holds both of two spans, either of which may be a miss
+fn shape_record_span_join(a: vec2<f32>, b: vec2<f32>) -> vec2<f32> {
+    if (a.x > a.y) {
+        return b;
+    }
+
+    if (b.x > b.y) {
+        return a;
+    }
+
+    return vec2<f32>(min(a.x, b.x), max(a.y, b.y));
+}
+
+// where o + t·d is at most half from zero, along one axis
+fn shape_record_line_slab(o: f32, d: f32, half: f32) -> vec2<f32> {
+    if (d == 0.0) {
+        if (abs(o) <= half) {
+            return vec2<f32>(-F32_MAX, F32_MAX);
+        }
+
+        return SHAPE_RECORD_LINE_MISS;
+    }
+
+    let a = (-half - o) / d;
+    let b = (half - o) / d;
+
+    return vec2<f32>(min(a, b), max(a, b));
+}
+
+// where n·(o + t·d) is at most offset
+fn shape_record_line_half_space(o: vec3<f32>, d: vec3<f32>, plane: vec4<f32>) -> vec2<f32> {
+    let slope = dot(plane.xyz, d);
+    let height = dot(plane.xyz, o) - plane.w;
+
+    if (slope == 0.0) {
+        if (height <= 0.0) {
+            return vec2<f32>(-F32_MAX, F32_MAX);
+        }
+
+        return SHAPE_RECORD_LINE_MISS;
+    }
+
+    let t = -height / slope;
+
+    if (slope > 0.0) {
+        return vec2<f32>(-F32_MAX, t);
+    }
+
+    return vec2<f32>(t, F32_MAX);
+}
+
+// where o + t·d is within radius of the origin, o and d of any dimension's worth: |d|² is a, o·d is b
+fn shape_record_line_round(a: f32, b: f32, c: f32) -> vec2<f32> {
+    if (a == 0.0) {
+        if (c <= 0.0) {
+            return vec2<f32>(-F32_MAX, F32_MAX);
+        }
+
+        return SHAPE_RECORD_LINE_MISS;
+    }
+
+    let discriminant = b * b - a * c;
+
+    if (discriminant < 0.0) {
+        return SHAPE_RECORD_LINE_MISS;
+    }
+
+    let root = sqrt(discriminant);
+
+    return vec2<f32>((-b - root) / a, (-b + root) / a);
+}
+
+fn shape_record_line_sphere(o: vec3<f32>, d: vec3<f32>, radius: f32) -> vec2<f32> {
+    return shape_record_line_round(dot(d, d), dot(o, d), dot(o, o) - radius * radius);
+}
+
+// a cylinder about Y, of a radius and a height, centred on the origin
+fn shape_record_line_cylinder(o: vec3<f32>, d: vec3<f32>, radius: f32, height: f32) -> vec2<f32> {
+    let around = shape_record_line_round(dot(d.xz, d.xz), dot(o.xz, d.xz), dot(o.xz, o.xz) - radius * radius);
+
+    return shape_record_span_meet(around, shape_record_line_slab(o.y, d.y, height * 0.5));
+}
+
+fn shape_record_line_span(kind: u32, parameters: vec4<f32>, origin: vec3<f32>, direction: vec3<f32>) -> vec2<f32> {
+    if (kind == SHAPE_RECORD_SPHERE) {
+        return shape_record_line_sphere(origin, direction, parameters.x);
+    }
+
+    if (kind == SHAPE_RECORD_CAPSULE) {
+        // a cylinder with a ball on each end: convex, so the line's part is the span over the three
+        let end = vec3<f32>(0.0, parameters.y * 0.5, 0.0);
+
+        var span = shape_record_line_cylinder(origin, direction, parameters.x, parameters.y);
+
+        span = shape_record_span_join(span, shape_record_line_sphere(origin - end, direction, parameters.x));
+        span = shape_record_span_join(span, shape_record_line_sphere(origin + end, direction, parameters.x));
+
+        return span;
+    }
+
+    if (kind == SHAPE_RECORD_BOX) {
+        var span = shape_record_line_slab(origin.x, direction.x, parameters.x);
+
+        span = shape_record_span_meet(span, shape_record_line_slab(origin.y, direction.y, parameters.y));
+        span = shape_record_span_meet(span, shape_record_line_slab(origin.z, direction.z, parameters.z));
+
+        return span;
+    }
+
+    if (kind == SHAPE_RECORD_CYLINDER) {
+        return shape_record_line_cylinder(origin, direction, parameters.x, parameters.y);
+    }
+
+    if (kind == SHAPE_RECORD_PLANE) {
+        return shape_record_line_half_space(origin, direction, parameters);
+    }
+
+    // SHAPE_RECORD_CONVEX_HULL: what every one of its planes leaves
+    let first = u32(parameters.x);
+    let count = u32(parameters.y);
+
+    var span = vec2<f32>(-F32_MAX, F32_MAX);
+
+    for (var i = 0u; i < SHAPE_RECORD_HULL_PLANE_LIMIT; i++) {
+        if (i >= count) {
+            break;
+        }
+
+        span = shape_record_span_meet(span, shape_record_line_half_space(origin, direction, shape_record_plane(first + i)));
+    }
+
+    return span;
+}
+`, [
+        chunk_shape_record_kind,
+        F32_MAX_DEFINITION,
+    ]
+);

package/src/shade/renderer/texture/atlas/chunk_tile_atlas_slot_origin.d.ts

@@ -16,5 +16,23 @@
  * @type {CodeChunk}
  */
 export const chunk_tile_atlas_slot_origin: CodeChunk;
+/**
+ * {@link chunk_tile_atlas_slot_origin} for a footprint of powers of two, given as shifts: what a reader
+ * on a hot path takes. `shift` is `tile_atlas_slot_shift(slots_x, slots_y)`, which the host passes in
+ * immediate data, so a slot is placed with masks and shifts alone, neither a texture query nor a
+ * divide in front of the fetch it addresses.
+ *
+ * Measured on the brick clipmap's trace (probe and camera rays, RTX 4090 and an RDNA2 iGPU,
+ * 2026-11-11), against the footprint from `textureDimensions` and `index_to_grid3d`: 6-7% faster on
+ * the 4090, 9.5-15% on the iGPU. The same shifts from a uniform measure the same.
+ *
+ * ```wgsl
+ * fn tile_atlas_slot_origin_shift(slot: u32, shift: u32, tile_size: vec3<u32>) -> vec3<u32>
+ * ```
+ *
+ * @see tile_atlas_slot_shift
+ * @type {CodeChunk}
+ */
+export const chunk_tile_atlas_slot_origin_shift: CodeChunk;
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_tile_atlas_slot_origin.d.ts.map

package/src/shade/renderer/texture/atlas/chunk_tile_atlas_slot_origin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_tile_atlas_slot_origin.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/atlas/chunk_tile_atlas_slot_origin.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,SAAS,CAWjB;0BA5BwB,oCAAoC"}
+{"version":3,"file":"chunk_tile_atlas_slot_origin.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/atlas/chunk_tile_atlas_slot_origin.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,SAAS,CAWjB;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,iDAFU,SAAS,CAWhB;0BAxDuB,oCAAoC"}

package/src/shade/renderer/texture/atlas/chunk_tile_atlas_slot_origin.js

@@ -28,3 +28,31 @@ fn tile_atlas_slot_origin(slot: u32, slots: vec2<u32>, tile_size: vec3<u32>) ->
         chunk_index_to_grid3d,
     ]
 );
+
+/**
+ * {@link chunk_tile_atlas_slot_origin} for a footprint of powers of two, given as shifts: what a reader
+ * on a hot path takes. `shift` is `tile_atlas_slot_shift(slots_x, slots_y)`, which the host passes in
+ * immediate data, so a slot is placed with masks and shifts alone, neither a texture query nor a
+ * divide in front of the fetch it addresses.
+ *
+ * Measured on the brick clipmap's trace (probe and camera rays, RTX 4090 and an RDNA2 iGPU,
+ * 2026-11-11), against the footprint from `textureDimensions` and `index_to_grid3d`: 6-7% faster on
+ * the 4090, 9.5-15% on the iGPU. The same shifts from a uniform measure the same.
+ *
+ * ```wgsl
+ * fn tile_atlas_slot_origin_shift(slot: u32, shift: u32, tile_size: vec3<u32>) -> vec3<u32>
+ * ```
+ *
+ * @see tile_atlas_slot_shift
+ * @type {CodeChunk}
+ */
+export const chunk_tile_atlas_slot_origin_shift = CodeChunk.from(
+    //language=WGSL
+    `
+fn tile_atlas_slot_origin_shift(slot: u32, shift: u32, tile_size: vec3<u32>) -> vec3<u32> {
+    let sx = shift & 0xffffu;
+    let sy = shift >> 16u;
+
+    return vec3<u32>(slot & ((1u << sx) - 1u), (slot >> sx) & ((1u << sy) - 1u), slot >> (sx + sy)) * tile_size;
+}
+`);

package/src/shade/renderer/texture/atlas/tile_atlas_slot_shift.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A {@link GPUTileAtlas3D}'s footprint as `tile_atlas_slot_origin_shift` takes it: `log2 slots_x` in the
+ * low 16 bits, `log2 slots_y` in the high 16, one `u32` for a shader's immediate data.
+ *
+ * An atlas whose footprint starts at powers of two keeps them: a widen doubles a side, capped at a
+ * power of two of tiles for a power-of-two tile under a power-of-two `maxTextureDimension3D`.
+ *
+ * @param {number} slots_x tiles along x, a power of two
+ * @param {number} slots_y tiles along y, a power of two
+ * @returns {number}
+ */
+export function tile_atlas_slot_shift(slots_x: number, slots_y: number): number;
+//# sourceMappingURL=tile_atlas_slot_shift.d.ts.map

package/src/shade/renderer/texture/atlas/tile_atlas_slot_shift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile_atlas_slot_shift.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/texture/atlas/tile_atlas_slot_shift.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,+CAJW,MAAM,WACN,MAAM,GACJ,MAAM,CASlB"}

package/src/shade/renderer/texture/atlas/tile_atlas_slot_shift.js

@@ -0,0 +1,22 @@
+import { assert } from "../../../../core/assert.js";
+import { isPowerOfTwo } from "../../../../core/math/isPowerOfTwo.js";
+
+/**
+ * A {@link GPUTileAtlas3D}'s footprint as `tile_atlas_slot_origin_shift` takes it: `log2 slots_x` in the
+ * low 16 bits, `log2 slots_y` in the high 16, one `u32` for a shader's immediate data.
+ *
+ * An atlas whose footprint starts at powers of two keeps them: a widen doubles a side, capped at a
+ * power of two of tiles for a power-of-two tile under a power-of-two `maxTextureDimension3D`.
+ *
+ * @param {number} slots_x tiles along x, a power of two
+ * @param {number} slots_y tiles along y, a power of two
+ * @returns {number}
+ */
+export function tile_atlas_slot_shift(slots_x, slots_y) {
+    assert.isPositiveInteger(slots_x, 'slots_x');
+    assert.isPositiveInteger(slots_y, 'slots_y');
+    assert.ok(isPowerOfTwo(slots_x), `slots_x ${slots_x} must be a power of two`);
+    assert.ok(isPowerOfTwo(slots_y), `slots_y ${slots_y} must be a power of two`);
+
+    return (31 - Math.clz32(slots_x)) | ((31 - Math.clz32(slots_y)) << 16);
+}

package/src/shade/renderer/water/GPUWaterRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAsBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAmB7B;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;;;MA2IC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CAyBJ;gCAzX+B,uCAAuC"}
+{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAsBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAmB7B;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;;;MA+IC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CAyBJ;gCA7X+B,uCAAuC"}