@woosh/meep-engine 3.64.1 → 3.65.0

package/src/shade/renderer/grass/surface/chunk_grass_column_cross.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_grass_column_cross.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/chunk_grass_column_cross.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,sCAFU,MAAM,CAE6B;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,uCAFU,SAAS,CA+CjB;0BApFwB,oCAAoC"}

package/src/shade/renderer/grass/surface/chunk_grass_column_cross.js

@@ -0,0 +1,85 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * Clear height of ground under open sky: the largest finite half float, which is how a surfel stores it.
+ * Any stored clear height at or above this means nothing stands over the surfel.
+ * @type {number}
+ */
+export const GRASS_CLEAR_HEIGHT_OPEN = 65504;
+
+/**
+ * One step of a walk down a column of a grass surface, from above the surface's members to below them.
+ *
+ * A column crosses the faces of its surface's members in order of falling height. Each crossing is either
+ * an upward face (ground a blade could stand on) or a downward one (an underside: a ceiling, the bottom of
+ * something resting there). What the column crossed just before a crossing decides what it is:
+ *
+ * - nothing: the crossing is under open sky;
+ * - a downward face: the crossing is in open air under it, and the gap between them is its clear height;
+ * - an upward face: the crossing is inside the member that face tops, where nothing grows.
+ *
+ * ```wgsl
+ * fn grass_column_begin() -> GrassColumnWalk
+ * fn grass_column_cross(walk: GrassColumnWalk, height: f32, faces_up: bool) -> GrassColumnCrossing
+ * ```
+ *
+ * `grass_column_cross` takes the walk as it stood before the crossing and answers with:
+ *
+ * - `keep`: the crossing is ground to keep, an upward face that is not inside a member;
+ * - `clear_height`: for a kept crossing, the height of open air over it, `GRASS_CLEAR_HEIGHT_OPEN` under
+ *   open sky; never negative;
+ * - `walk`: the walk after the crossing, to hand to the next one.
+ *
+ * Heights are along the surface frame's up axis and must not rise from one crossing to the next.
+ *
+ * Which way a face points is read from its winding, so ground under a one-sided sheet reads as inside it:
+ * a cave needs its ceiling modelled.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_column_cross = CodeChunk.from(
+    //language=WGSL
+    `
+const GRASS_CLEAR_HEIGHT_OPEN: f32 = ${GRASS_CLEAR_HEIGHT_OPEN}.0;
+
+// nothing crossed yet
+const GRASS_COLUMN_ABOVE_SKY: u32 = 0u;
+// the last face crossed points down: open air under it
+const GRASS_COLUMN_ABOVE_UNDERSIDE: u32 = 1u;
+// the last face crossed points up: the inside of the member it tops
+const GRASS_COLUMN_ABOVE_TOPSIDE: u32 = 2u;
+
+struct GrassColumnWalk {
+    above: u32,
+    above_height: f32,
+}
+
+struct GrassColumnCrossing {
+    keep: bool,
+    clear_height: f32,
+    walk: GrassColumnWalk,
+}
+
+fn grass_column_begin() -> GrassColumnWalk {
+    return GrassColumnWalk(GRASS_COLUMN_ABOVE_SKY, 0.0);
+}
+
+fn grass_column_cross(walk: GrassColumnWalk, height: f32, faces_up: bool) -> GrassColumnCrossing {
+    var crossing: GrassColumnCrossing;
+
+    crossing.keep = faces_up && walk.above != GRASS_COLUMN_ABOVE_TOPSIDE;
+
+    crossing.clear_height = GRASS_CLEAR_HEIGHT_OPEN;
+    if (walk.above == GRASS_COLUMN_ABOVE_UNDERSIDE) {
+        crossing.clear_height = min(max(walk.above_height - height, 0.0), GRASS_CLEAR_HEIGHT_OPEN);
+    }
+
+    crossing.walk = GrassColumnWalk(
+        select(GRASS_COLUMN_ABOVE_UNDERSIDE, GRASS_COLUMN_ABOVE_TOPSIDE, faces_up),
+        height,
+    );
+
+    return crossing;
+}
+`
+);

package/src/shade/renderer/grass/surface/chunk_grass_directory.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The directory of the grass surfaces' pool: which slot holds a given layer of a given tile.
+ *
+ * ```wgsl
+ * fn grass_tile_key(surface: u32, level_layer: u32, tile: vec2<i32>) -> u32
+ * fn grass_directory_find(surface: u32, level_layer: u32, tile: vec2<i32>) -> u32
+ * fn grass_directory_insert(surface: u32, level_layer: u32, tile: vec2<i32>, slot: u32) -> bool
+ * fn grass_directory_remove(surface: u32, level_layer: u32, tile: vec2<i32>, slot: u32) -> bool
+ * ```
+ *
+ * - `grass_tile_key`: the directory's key for a layer of a tile. A hash: different layers may share one.
+ * - `grass_directory_find`: the slot whose record names that surface, level, layer and tile, or
+ *   `GRASS_SLOT_NONE`. The key only finds candidates; the record decides.
+ * - `grass_directory_insert`: list a slot under its key. The slot's record must name the layer already.
+ *   False when the key's probe sequence has no record free, and the slot is then listed nowhere.
+ * - `grass_directory_remove`: take a slot's record out from under its layer's key. False when the
+ *   directory does not list the slot there. A removal shares a dispatch with no find or insert.
+ *
+ * `surface` is the surface's `transforms` row and `level_layer` a record's word of that name
+ * (`GRASS_SURFACE.js`).
+ *
+ * Reads `grass_pool` ({@link GRASS_POOL_RESOURCE}) and `grass_directory` ({@link GRASS_DIRECTORY_RESOURCE}). A
+ * find and an insert of the same layer must not share a dispatch.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_directory: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_grass_directory.d.ts.map

package/src/shade/renderer/grass/surface/chunk_grass_directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_grass_directory.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/chunk_grass_directory.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,oCAFU,SAAS,CAwEjB;0BA1GwB,oCAAoC"}

package/src/shade/renderer/grass/surface/chunk_grass_directory.js

@@ -0,0 +1,112 @@
+import { chunk_hash_table_atomic } from "../../gpu_primitive/hash_table/chunk_hash_table_atomic.js";
+import { chunk_hash_lowbias32 } from "../../shader/chunk/random/chunk_hash_lowbias32.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_grass_slot } from "./chunk_grass_slot.js";
+import {
+    GRASS_SLOT_LEVEL_LAYER,
+    GRASS_SLOT_SURFACE,
+    GRASS_SLOT_TILE_X,
+    GRASS_SLOT_TILE_Z
+} from "./GRASS_SURFACE.js";
+import { GRASS_DIRECTORY_RESOURCE, GRASS_POOL_RESOURCE } from "./GRASS_SURFACE_VIEW.js";
+
+/**
+ * The directory of the grass surfaces' pool: which slot holds a given layer of a given tile.
+ *
+ * ```wgsl
+ * fn grass_tile_key(surface: u32, level_layer: u32, tile: vec2<i32>) -> u32
+ * fn grass_directory_find(surface: u32, level_layer: u32, tile: vec2<i32>) -> u32
+ * fn grass_directory_insert(surface: u32, level_layer: u32, tile: vec2<i32>, slot: u32) -> bool
+ * fn grass_directory_remove(surface: u32, level_layer: u32, tile: vec2<i32>, slot: u32) -> bool
+ * ```
+ *
+ * - `grass_tile_key`: the directory's key for a layer of a tile. A hash: different layers may share one.
+ * - `grass_directory_find`: the slot whose record names that surface, level, layer and tile, or
+ *   `GRASS_SLOT_NONE`. The key only finds candidates; the record decides.
+ * - `grass_directory_insert`: list a slot under its key. The slot's record must name the layer already.
+ *   False when the key's probe sequence has no record free, and the slot is then listed nowhere.
+ * - `grass_directory_remove`: take a slot's record out from under its layer's key. False when the
+ *   directory does not list the slot there. A removal shares a dispatch with no find or insert.
+ *
+ * `surface` is the surface's `transforms` row and `level_layer` a record's word of that name
+ * (`GRASS_SURFACE.js`).
+ *
+ * Reads `grass_pool` ({@link GRASS_POOL_RESOURCE}) and `grass_directory` ({@link GRASS_DIRECTORY_RESOURCE}). A
+ * find and an insert of the same layer must not share a dispatch.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_directory = CodeChunk.from(
+    //language=WGSL
+    `
+fn grass_tile_key(surface: u32, level_layer: u32, tile: vec2<i32>) -> u32 {
+    var key = hash_lowbias32(surface ^ (level_layer * 0x9E3779B9u));
+    key = hash_lowbias32(key ^ bitcast<u32>(tile.x));
+    key = hash_lowbias32(key ^ bitcast<u32>(tile.y));
+
+    // the table's keys stay below its two reserved words
+    return key >> 1u;
+}
+
+fn grass_directory_find(surface: u32, level_layer: u32, tile: vec2<i32>) -> u32 {
+    let key = grass_tile_key(surface, level_layer, tile);
+
+    var cursor = hash_table_atomic_start(&grass_directory, 0u, key);
+
+    for (var i = 0u; i < HASH_TABLE_PROBE_LIMIT; i++) {
+        let entry = hash_table_atomic_find(&grass_directory, 0u, key, &cursor);
+
+        if (entry == HASH_TABLE_MISS) {
+            break;
+        }
+
+        // a value a racing insert of another layer has not stored yet reads as slot 0, whose record decides like any other
+        let slot = hash_table_atomic_value(&grass_directory, entry);
+
+        let record = grass_slot_record(slot);
+
+        if (atomicLoad(&grass_pool[record + ${GRASS_SLOT_SURFACE}u]) == surface
+            && atomicLoad(&grass_pool[record + ${GRASS_SLOT_LEVEL_LAYER}u]) == level_layer
+            && atomicLoad(&grass_pool[record + ${GRASS_SLOT_TILE_X}u]) == bitcast<u32>(tile.x)
+            && atomicLoad(&grass_pool[record + ${GRASS_SLOT_TILE_Z}u]) == bitcast<u32>(tile.y)) {
+            return slot;
+        }
+    }
+
+    return GRASS_SLOT_NONE;
+}
+
+fn grass_directory_insert(surface: u32, level_layer: u32, tile: vec2<i32>, slot: u32) -> bool {
+    return hash_table_atomic_insert(&grass_directory, 0u, grass_tile_key(surface, level_layer, tile), slot);
+}
+
+fn grass_directory_remove(surface: u32, level_layer: u32, tile: vec2<i32>, slot: u32) -> bool {
+    let key = grass_tile_key(surface, level_layer, tile);
+
+    var cursor = hash_table_atomic_start(&grass_directory, 0u, key);
+
+    for (var i = 0u; i < HASH_TABLE_PROBE_LIMIT; i++) {
+        let entry = hash_table_atomic_find(&grass_directory, 0u, key, &cursor);
+
+        if (entry == HASH_TABLE_MISS) {
+            break;
+        }
+
+        if (hash_table_atomic_value(&grass_directory, entry) == slot) {
+            hash_table_atomic_remove(&grass_directory, 0u, entry);
+
+            return true;
+        }
+    }
+
+    return false;
+}
+`, [
+        chunk_hash_lowbias32,
+        chunk_hash_table_atomic,
+        chunk_grass_slot,
+    ]
+);
+
+chunk_grass_directory.requireResource(GRASS_POOL_RESOURCE);
+chunk_grass_directory.requireResource(GRASS_DIRECTORY_RESOURCE);

package/src/shade/renderer/grass/surface/chunk_grass_slot.d.ts

@@ -0,0 +1,27 @@
+/**
+ * No slot: what a look-up of a tile's layer the pool does not hold answers, and what a place of the bake
+ * list holds when no slot could be taken for it.
+ *
+ * @type {number}
+ */
+export const GRASS_SLOT_NONE: number;
+/**
+ * A slot of the grass surfaces' pool, by number.
+ *
+ * ```wgsl
+ * const GRASS_SLOT_NONE: u32
+ * fn grass_slot_record(slot: u32) -> u32
+ * fn grass_height_key(height: f32) -> u32
+ * fn grass_height_of_key(key: u32) -> f32
+ * ```
+ *
+ * - `grass_slot_record`: the word of the pool's arena a slot's record starts at (`GRASS_SURFACE.js`).
+ * - `grass_height_key`: a height as a word that orders as the height does, so that an atomic minimum or
+ *   maximum of keys is one of heights. Every finite height has a key above zero and under the highest word.
+ * - `grass_height_of_key`: the height a key was made of.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_slot: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_grass_slot.d.ts.map

package/src/shade/renderer/grass/surface/chunk_grass_slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_grass_slot.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/chunk_grass_slot.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,8BAFU,MAAM,CAE+B;AAE/C;;;;;;;;;;;;;;;;GAgBG;AACH,+BAFU,SAAS,CAsBjB;0BAhDwB,oCAAoC"}

package/src/shade/renderer/grass/surface/chunk_grass_slot.js

@@ -0,0 +1,50 @@
+import { SLOT_STACK_NONE } from "../../gpu_primitive/slot_stack/chunk_slot_stack.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { GRASS_POOL_HEADER_WORDS, GRASS_SLOT_WORDS } from "./GRASS_SURFACE.js";
+
+/**
+ * No slot: what a look-up of a tile's layer the pool does not hold answers, and what a place of the bake
+ * list holds when no slot could be taken for it.
+ *
+ * @type {number}
+ */
+export const GRASS_SLOT_NONE = SLOT_STACK_NONE;
+
+/**
+ * A slot of the grass surfaces' pool, by number.
+ *
+ * ```wgsl
+ * const GRASS_SLOT_NONE: u32
+ * fn grass_slot_record(slot: u32) -> u32
+ * fn grass_height_key(height: f32) -> u32
+ * fn grass_height_of_key(key: u32) -> f32
+ * ```
+ *
+ * - `grass_slot_record`: the word of the pool's arena a slot's record starts at (`GRASS_SURFACE.js`).
+ * - `grass_height_key`: a height as a word that orders as the height does, so that an atomic minimum or
+ *   maximum of keys is one of heights. Every finite height has a key above zero and under the highest word.
+ * - `grass_height_of_key`: the height a key was made of.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_slot = CodeChunk.from(
+    //language=WGSL
+    `
+const GRASS_SLOT_NONE: u32 = ${GRASS_SLOT_NONE}u;
+
+fn grass_slot_record(slot: u32) -> u32 {
+    return ${GRASS_POOL_HEADER_WORDS}u + slot * ${GRASS_SLOT_WORDS}u;
+}
+
+fn grass_height_key(height: f32) -> u32 {
+    let bits = bitcast<u32>(height);
+
+    // a float's bits order as its magnitude: the sign bit is flipped for those at or above zero, every bit for those below
+    return bits ^ select(0x80000000u, 0xFFFFFFFFu, (bits & 0x80000000u) != 0u);
+}
+
+fn grass_height_of_key(key: u32) -> f32 {
+    return bitcast<f32>(key ^ select(0xFFFFFFFFu, 0x80000000u, (key & 0x80000000u) != 0u));
+}
+`
+);

package/src/shade/renderer/grass/surface/chunk_grass_surface_frame.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A grass surface's frame: where its `transforms` row is and how it is turned. The row's scale is not part
+ * of the frame, so a frame's units are the world's and a surface's lattice keeps its spacing whatever its
+ * entity's scale.
+ *
+ * ```wgsl
+ * fn grass_surface_frame(global: mat4x4<f32>) -> mat4x4<f32>
+ * fn grass_world_to_frame(frame: mat4x4<f32>, position: vec3<f32>) -> vec3<f32>
+ * fn grass_world_direction_to_frame(frame: mat4x4<f32>, direction: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * - `grass_surface_frame`: the frame of a row whose world matrix is `global`, frame to world. Its second
+ *   column is the frame's up axis, unit length. The matrix must not shear.
+ * - `grass_world_to_frame`: a world point in the frame.
+ * - `grass_world_direction_to_frame`: a world direction in the frame, its length kept.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_surface_frame: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_grass_surface_frame.d.ts.map

package/src/shade/renderer/grass/surface/chunk_grass_surface_frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_grass_surface_frame.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/chunk_grass_surface_frame.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,wCAFU,SAAS,CAsBjB;0BAxCwB,oCAAoC"}

package/src/shade/renderer/grass/surface/chunk_grass_surface_frame.js

@@ -0,0 +1,41 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * A grass surface's frame: where its `transforms` row is and how it is turned. The row's scale is not part
+ * of the frame, so a frame's units are the world's and a surface's lattice keeps its spacing whatever its
+ * entity's scale.
+ *
+ * ```wgsl
+ * fn grass_surface_frame(global: mat4x4<f32>) -> mat4x4<f32>
+ * fn grass_world_to_frame(frame: mat4x4<f32>, position: vec3<f32>) -> vec3<f32>
+ * fn grass_world_direction_to_frame(frame: mat4x4<f32>, direction: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * - `grass_surface_frame`: the frame of a row whose world matrix is `global`, frame to world. Its second
+ *   column is the frame's up axis, unit length. The matrix must not shear.
+ * - `grass_world_to_frame`: a world point in the frame.
+ * - `grass_world_direction_to_frame`: a world direction in the frame, its length kept.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_surface_frame = CodeChunk.from(
+    //language=WGSL
+    `
+fn grass_surface_frame(global: mat4x4<f32>) -> mat4x4<f32> {
+    return mat4x4<f32>(
+        vec4<f32>(normalize(global[0].xyz), 0.0),
+        vec4<f32>(normalize(global[1].xyz), 0.0),
+        vec4<f32>(normalize(global[2].xyz), 0.0),
+        vec4<f32>(global[3].xyz, 1.0),
+    );
+}
+
+fn grass_world_direction_to_frame(frame: mat4x4<f32>, direction: vec3<f32>) -> vec3<f32> {
+    return vec3<f32>(dot(frame[0].xyz, direction), dot(frame[1].xyz, direction), dot(frame[2].xyz, direction));
+}
+
+fn grass_world_to_frame(frame: mat4x4<f32>, position: vec3<f32>) -> vec3<f32> {
+    return grass_world_direction_to_frame(frame, position - frame[3].xyz);
+}
+`
+);

package/src/shade/renderer/grass/surface/chunk_grass_surface_window.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Which tiles of a level of a grass surface a view may want.
+ *
+ * ```wgsl
+ * fn grass_level_ring(view: GrassSurfaceViewSettings, level: u32, blade_length: f32) -> vec2<f32>
+ * fn grass_surface_window(view: GrassSurfaceViewSettings, surface: GrassSurfaceRecord, level: u32, eye: vec3<f32>) -> GrassWindow
+ * fn grass_tile_box(view: GrassSurfaceViewSettings, surface: GrassSurfaceRecord, level: u32, tile: vec2<i32>) -> GrassTileBox
+ * fn grass_tile_wanted(view: GrassSurfaceViewSettings, surface: GrassSurfaceRecord, level: u32, box: GrassTileBox, eye: vec3<f32>) -> bool
+ * ```
+ *
+ * **A level's ring.** Level `l` serves the distances from a view at which its spacing spans no more than
+ * the narrowest blade's width in pixels and the level below's spans more: from
+ * `finest_spacing * focal / narrowest_blade * 2^(l-1)` (0 for level 0) out to twice that. No level serves
+ * past the distance where a blade of `blade_length` spans `shortest_blade` pixels.
+ * `grass_level_ring` answers `(inner, outer)`; a level with no ring answers `inner >= outer`.
+ *
+ * **A level's window.** `grass_surface_window` is the block of the level's tiles that can hold a wanted
+ * one: `size` tiles from `corner` on the frame's x and z, a size of zero for none. `eye` is the view's
+ * position in the surface's frame. It is the level's reach about the eye, clipped to the surface's box, so
+ * a window is never more than `2 * focal / (narrowest_blade * GRASS_TILE_COLUMNS) + 2` tiles a side.
+ *
+ * **A tile's box.** `grass_tile_box` is where a tile's grass can be, in the frame: the tile's square cut to
+ * the surface's box, through the surface's height and a blade over it.
+ *
+ * **A wanted tile.** `grass_tile_wanted` is whether a tile of the window is in the level's ring: some of
+ * its box is nearer than the ring's outside, and some is not nearer than its inside.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_surface_window: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_grass_surface_window.d.ts.map

package/src/shade/renderer/grass/surface/chunk_grass_surface_window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_grass_surface_window.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/chunk_grass_surface_window.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,yCAFU,SAAS,CAwGjB;0BAvIwB,oCAAoC"}

package/src/shade/renderer/grass/surface/chunk_grass_surface_window.js

@@ -0,0 +1,136 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_grass_tile } from "./chunk_grass_tile.js";
+import { GRASS_SURFACE_RECORD_STRUCT, GRASS_SURFACE_VIEW_SETTINGS } from "./GRASS_SURFACE_VIEW.js";
+
+/**
+ * Which tiles of a level of a grass surface a view may want.
+ *
+ * ```wgsl
+ * fn grass_level_ring(view: GrassSurfaceViewSettings, level: u32, blade_length: f32) -> vec2<f32>
+ * fn grass_surface_window(view: GrassSurfaceViewSettings, surface: GrassSurfaceRecord, level: u32, eye: vec3<f32>) -> GrassWindow
+ * fn grass_tile_box(view: GrassSurfaceViewSettings, surface: GrassSurfaceRecord, level: u32, tile: vec2<i32>) -> GrassTileBox
+ * fn grass_tile_wanted(view: GrassSurfaceViewSettings, surface: GrassSurfaceRecord, level: u32, box: GrassTileBox, eye: vec3<f32>) -> bool
+ * ```
+ *
+ * **A level's ring.** Level `l` serves the distances from a view at which its spacing spans no more than
+ * the narrowest blade's width in pixels and the level below's spans more: from
+ * `finest_spacing * focal / narrowest_blade * 2^(l-1)` (0 for level 0) out to twice that. No level serves
+ * past the distance where a blade of `blade_length` spans `shortest_blade` pixels.
+ * `grass_level_ring` answers `(inner, outer)`; a level with no ring answers `inner >= outer`.
+ *
+ * **A level's window.** `grass_surface_window` is the block of the level's tiles that can hold a wanted
+ * one: `size` tiles from `corner` on the frame's x and z, a size of zero for none. `eye` is the view's
+ * position in the surface's frame. It is the level's reach about the eye, clipped to the surface's box, so
+ * a window is never more than `2 * focal / (narrowest_blade * GRASS_TILE_COLUMNS) + 2` tiles a side.
+ *
+ * **A tile's box.** `grass_tile_box` is where a tile's grass can be, in the frame: the tile's square cut to
+ * the surface's box, through the surface's height and a blade over it.
+ *
+ * **A wanted tile.** `grass_tile_wanted` is whether a tile of the window is in the level's ring: some of
+ * its box is nearer than the ring's outside, and some is not nearer than its inside.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_surface_window = CodeChunk.from(
+    //language=WGSL
+    `
+struct GrassWindow {
+    // the window's lowest tile on the frame's x and z, in tiles of the level
+    corner: vec2<i32>,
+    // tiles along each
+    size: vec2<u32>,
+}
+
+fn grass_level_ring(view: ${GRASS_SURFACE_VIEW_SETTINGS.wgsl_ref}, level: u32, blade_length: f32) -> vec2<f32> {
+    let finest_reach = view.finest_spacing * view.focal / view.narrowest_blade;
+    let blade_reach = blade_length * view.focal / view.shortest_blade;
+
+    let outer = min(ldexp(finest_reach, i32(level)), blade_reach);
+    let inner = select(min(ldexp(finest_reach, i32(level) - 1), blade_reach), 0.0, level == 0u);
+
+    return vec2<f32>(inner, outer);
+}
+
+fn grass_surface_window(
+    view: ${GRASS_SURFACE_VIEW_SETTINGS.wgsl_ref},
+    surface: ${GRASS_SURFACE_RECORD_STRUCT.wgsl_ref},
+    level: u32,
+    eye: vec3<f32>,
+) -> GrassWindow {
+    var window: GrassWindow;
+
+    let ring = grass_level_ring(view, level, surface.blade_length);
+
+    if (ring.x >= ring.y) {
+        return window;
+    }
+
+    // how far over or under the surface's slab the eye is
+    let clear = max(max(surface.low.y - eye.y, eye.y - (surface.high.y + surface.blade_length)), 0.0);
+
+    if (clear >= ring.y) {
+        return window;
+    }
+
+    let low = max(surface.low.xz, eye.xz - ring.y);
+    let high = min(surface.high.xz, eye.xz + ring.y);
+
+    if (low.x > high.x || low.y > high.y) {
+        return window;
+    }
+
+    let spacing = grass_level_spacing(view.finest_spacing, level);
+
+    let first = grass_tile_of_position(low, spacing);
+    let last = grass_tile_of_position(high, spacing);
+
+    window.corner = first;
+    window.size = vec2<u32>(last - first) + 1u;
+
+    return window;
+}
+
+struct GrassTileBox {
+    low: vec3<f32>,
+    high: vec3<f32>,
+}
+
+fn grass_tile_box(
+    view: ${GRASS_SURFACE_VIEW_SETTINGS.wgsl_ref},
+    surface: ${GRASS_SURFACE_RECORD_STRUCT.wgsl_ref},
+    level: u32,
+    tile: vec2<i32>,
+) -> GrassTileBox {
+    let edge = grass_level_spacing(view.finest_spacing, level) * f32(GRASS_TILE_COLUMNS);
+
+    let corner = vec2<f32>(tile) * edge;
+
+    let low = max(corner, surface.low.xz);
+    let high = min(corner + edge, surface.high.xz);
+
+    return GrassTileBox(
+        vec3<f32>(low.x, surface.low.y, low.y),
+        vec3<f32>(high.x, surface.high.y + surface.blade_length, high.y),
+    );
+}
+
+fn grass_tile_wanted(
+    view: ${GRASS_SURFACE_VIEW_SETTINGS.wgsl_ref},
+    surface: ${GRASS_SURFACE_RECORD_STRUCT.wgsl_ref},
+    level: u32,
+    box: GrassTileBox,
+    eye: vec3<f32>,
+) -> bool {
+    let ring = grass_level_ring(view, level, surface.blade_length);
+
+    let nearest = length(max(max(box.low - eye, eye - box.high), vec3<f32>(0.0)));
+    let farthest = length(max(abs(box.low - eye), abs(box.high - eye)));
+
+    return nearest < ring.y && farthest >= ring.x;
+}
+`, [
+        GRASS_SURFACE_VIEW_SETTINGS.declaration_chunk,
+        GRASS_SURFACE_RECORD_STRUCT.declaration_chunk,
+        chunk_grass_tile,
+    ]
+);

package/src/shade/renderer/grass/surface/chunk_grass_surfel.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Texture format of a surfel: four words, one texel.
+ * @type {GPUTextureFormat}
+ */
+export const GRASS_SURFEL_FORMAT: GPUTextureFormat;
+/**
+ * A surfel of a grass surface: one point of ground a blade can stand on, and what a blade needs of it.
+ *
+ * A surfel sits on a column of its surface's lattice, so where it is across the surface is its place in
+ * its tile; the record holds only where it is along the surface frame's up axis.
+ *
+ * ```wgsl
+ * struct GrassSurfel {
+ *     height: f32,          // along the surface frame's up axis, in the frame's units
+ *     normal: vec3<f32>,    // unit, in the surface's frame
+ *     member: u32,          // the meshes row of the member it lies on
+ *     clear_height: f32,    // open air over it; GRASS_CLEAR_HEIGHT_OPEN and above mean open sky
+ *     density: f32,         // painted density, 0 to 1
+ * }
+ *
+ * fn grass_surfel_pack(surfel: GrassSurfel) -> vec4<u32>
+ * fn grass_surfel_unpack(texel: vec4<u32>) -> GrassSurfel
+ * fn grass_surfel_exists(texel: vec4<u32>) -> bool
+ * ```
+ *
+ * A texel is `(height bits, normal, member, clear height | density << 16)`: the normal in the vertex-normal
+ * format, the clear height a half float, the density a 16-bit unorm. `height` and `member` round-trip
+ * exactly. A clear height must be in `[0, GRASS_CLEAR_HEIGHT_OPEN]`.
+ *
+ * Row 0 of the scene's tables is its root and never a mesh, so a member of 0 is no surfel: a cleared
+ * texel holds none, which is what `grass_surfel_exists` asks.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_surfel: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_grass_surfel.d.ts.map

package/src/shade/renderer/grass/surface/chunk_grass_surfel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_grass_surfel.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/chunk_grass_surfel.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH,mDAAgD;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,iCAFU,SAAS,CA8CjB;0BAlFwB,oCAAoC"}