@woosh/meep-engine 3.64.1 → 3.67.0

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

@@ -0,0 +1,85 @@
+import { chunk_decode_vertex_normal } from "../../shader/chunk/geometry/normal/chunk_decode_vertex_normal.js";
+import { chunk_encode_vertex_normal } from "../../shader/chunk/geometry/normal/chunk_encode_vertex_normal.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_grass_column_cross } from "./chunk_grass_column_cross.js";
+
+/**
+ * Texture format of a surfel: four words, one texel.
+ * @type {GPUTextureFormat}
+ */
+export const GRASS_SURFEL_FORMAT = "rgba32uint";
+
+/**
+ * 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.from(
+    //language=WGSL
+    `
+struct GrassSurfel {
+    height: f32,
+    normal: vec3<f32>,
+    member: u32,
+    clear_height: f32,
+    density: f32,
+}
+
+fn grass_surfel_pack(surfel: GrassSurfel) -> vec4<u32> {
+    let clear_height = pack2x16float(vec2<f32>(surfel.clear_height, 0.0)) & 0xFFFFu;
+    let density = u32(saturate(surfel.density) * 65535.0 + 0.5);
+
+    return vec4<u32>(
+        bitcast<u32>(surfel.height),
+        encode_vertex_normal(surfel.normal),
+        surfel.member,
+        clear_height | (density << 16u),
+    );
+}
+
+fn grass_surfel_unpack(texel: vec4<u32>) -> GrassSurfel {
+    var surfel: GrassSurfel;
+
+    surfel.height = bitcast<f32>(texel.x);
+    surfel.normal = decode_vertex_normal(texel.y);
+    surfel.member = texel.z;
+    surfel.clear_height = unpack2x16float(texel.w & 0xFFFFu).x;
+    surfel.density = f32(texel.w >> 16u) / 65535.0;
+
+    return surfel;
+}
+
+fn grass_surfel_exists(texel: vec4<u32>) -> bool {
+    return texel.z != 0u;
+}
+`, [
+        chunk_encode_vertex_normal,
+        chunk_decode_vertex_normal,
+        // GRASS_CLEAR_HEIGHT_OPEN
+        chunk_grass_column_cross,
+    ]
+);

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

@@ -0,0 +1,25 @@
+/**
+ * Where the columns of a grass surface's tiles are: in the surface's frame, and in the surfel atlas.
+ * `GRASS_SURFACE.js` says what a level, a tile and a slot are.
+ *
+ * ```wgsl
+ * fn grass_level_spacing(finest_spacing: f32, level: u32) -> f32
+ * fn grass_tile_column_position(tile: vec2<i32>, column: vec2<u32>, spacing: f32) -> vec2<f32>
+ * fn grass_tile_of_position(position: vec2<f32>, spacing: f32) -> vec2<i32>
+ * fn grass_slot_texel(slot: u32, column: vec2<u32>, atlas_width: u32) -> vec2<u32>
+ * ```
+ *
+ * - `grass_level_spacing`: the distance between neighbouring columns of a level, `finest_spacing * 2^level`,
+ *   exactly.
+ * - `grass_tile_column_position`: the frame's `(x, z)` of a column's centre. `tile` is in tiles of the
+ *   level, `column` in `[0, GRASS_TILE_COLUMNS)` on each axis, `spacing` the level's.
+ * - `grass_tile_of_position`: the tile of a level whose square holds the frame's `(x, z)`; a point on an
+ *   edge belongs to the tile on its far side.
+ * - `grass_slot_texel`: the atlas texel of a column of a slot. The atlas is a `GPUTileAtlas2D`, whose
+ *   tiles run in rows as wide as the texture: `atlas_width` is `textureDimensions(atlas).x`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_tile: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_grass_tile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_grass_tile.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/chunk_grass_tile.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,+BAFU,SAAS,CA2BjB;0BAnDwB,oCAAoC"}

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

@@ -0,0 +1,52 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_index_to_grid2d } from "../../shader/chunk/grid/chunk_index_to_grid2d.js";
+import { GRASS_TILE_COLUMNS } from "./GRASS_SURFACE.js";
+
+/**
+ * Where the columns of a grass surface's tiles are: in the surface's frame, and in the surfel atlas.
+ * `GRASS_SURFACE.js` says what a level, a tile and a slot are.
+ *
+ * ```wgsl
+ * fn grass_level_spacing(finest_spacing: f32, level: u32) -> f32
+ * fn grass_tile_column_position(tile: vec2<i32>, column: vec2<u32>, spacing: f32) -> vec2<f32>
+ * fn grass_tile_of_position(position: vec2<f32>, spacing: f32) -> vec2<i32>
+ * fn grass_slot_texel(slot: u32, column: vec2<u32>, atlas_width: u32) -> vec2<u32>
+ * ```
+ *
+ * - `grass_level_spacing`: the distance between neighbouring columns of a level, `finest_spacing * 2^level`,
+ *   exactly.
+ * - `grass_tile_column_position`: the frame's `(x, z)` of a column's centre. `tile` is in tiles of the
+ *   level, `column` in `[0, GRASS_TILE_COLUMNS)` on each axis, `spacing` the level's.
+ * - `grass_tile_of_position`: the tile of a level whose square holds the frame's `(x, z)`; a point on an
+ *   edge belongs to the tile on its far side.
+ * - `grass_slot_texel`: the atlas texel of a column of a slot. The atlas is a `GPUTileAtlas2D`, whose
+ *   tiles run in rows as wide as the texture: `atlas_width` is `textureDimensions(atlas).x`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_tile = CodeChunk.from(
+    //language=WGSL
+    `
+const GRASS_TILE_COLUMNS: u32 = ${GRASS_TILE_COLUMNS}u;
+
+fn grass_level_spacing(finest_spacing: f32, level: u32) -> f32 {
+    return ldexp(finest_spacing, i32(level));
+}
+
+fn grass_tile_column_position(tile: vec2<i32>, column: vec2<u32>, spacing: f32) -> vec2<f32> {
+    let lattice = tile * i32(GRASS_TILE_COLUMNS) + vec2<i32>(column);
+
+    return (vec2<f32>(lattice) + 0.5) * spacing;
+}
+
+fn grass_tile_of_position(position: vec2<f32>, spacing: f32) -> vec2<i32> {
+    return vec2<i32>(floor(position / (spacing * f32(GRASS_TILE_COLUMNS))));
+}
+
+fn grass_slot_texel(slot: u32, column: vec2<u32>, atlas_width: u32) -> vec2<u32> {
+    return index_to_grid2d(slot, atlas_width / GRASS_TILE_COLUMNS) * GRASS_TILE_COLUMNS + column;
+}
+`, [
+        chunk_index_to_grid2d,
+    ]
+);

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

@@ -0,0 +1,23 @@
+/**
+ * Threads in a workgroup of {@link shader_grass_directory_fill}.
+ *
+ * @type {number}
+ */
+export const GRASS_DIRECTORY_FILL_WORKGROUP_SIZE: number;
+/**
+ * Lists every slot the pool has taken in an empty directory, a thread a slot: the directory made again,
+ * for a table that has grown, or one whose removed records are to be cleared out.
+ *
+ * `grass_directory` holds no record on entry: its count zero, its table's size set, its records empty. A
+ * slot that is pending, baked or stale is listed under its layer's key. One the table has no room for
+ * within the key's probes becomes an orphan, as one the asks could not list does, and the next retire
+ * frees it.
+ *
+ * No find or removal shares the dispatch. Dispatch
+ * `ceil(slot_capacity / GRASS_DIRECTORY_FILL_WORKGROUP_SIZE)` groups.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_directory_fill: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_grass_directory_fill.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_grass_directory_fill.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/shader_grass_directory_fill.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,kDAFU,MAAM,CAEsC;AAWtD;;;;;;;;;;;;;GAaG;AACH,0CAFU,aAAa,CA0CpB;8BArF2B,+BAA+B"}

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

@@ -0,0 +1,87 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { chunk_grass_directory } from "./chunk_grass_directory.js";
+import {
+    GRASS_SLOT_LEVEL_LAYER,
+    GRASS_SLOT_STATE,
+    GRASS_SLOT_STATE_FREE,
+    GRASS_SLOT_STATE_ORPHAN,
+    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";
+
+/**
+ * Threads in a workgroup of {@link shader_grass_directory_fill}.
+ *
+ * @type {number}
+ */
+export const GRASS_DIRECTORY_FILL_WORKGROUP_SIZE = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+
+// slots in the pool
+resources.setImmediate("slot_capacity", u32);
+
+resources.createGroup()
+    .add(GRASS_POOL_RESOURCE)
+    .add(GRASS_DIRECTORY_RESOURCE);
+
+/**
+ * Lists every slot the pool has taken in an empty directory, a thread a slot: the directory made again,
+ * for a table that has grown, or one whose removed records are to be cleared out.
+ *
+ * `grass_directory` holds no record on entry: its count zero, its table's size set, its records empty. A
+ * slot that is pending, baked or stale is listed under its layer's key. One the table has no room for
+ * within the key's probes becomes an orphan, as one the asks could not list does, and the next retire
+ * frees it.
+ *
+ * No find or removal shares the dispatch. Dispatch
+ * `ceil(slot_capacity / GRASS_DIRECTORY_FILL_WORKGROUP_SIZE)` groups.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_directory_fill = ComputeShader.from({
+    label: "Grass Directory Fill",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${GRASS_DIRECTORY_FILL_WORKGROUP_SIZE})
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let slot = id.x;
+
+    if (slot >= slot_capacity) {
+        return;
+    }
+
+    let record = grass_slot_record(slot);
+    let state = atomicLoad(&grass_pool[record + ${GRASS_SLOT_STATE}u]);
+
+    if (state == ${GRASS_SLOT_STATE_FREE}u || state == ${GRASS_SLOT_STATE_ORPHAN}u) {
+        return;
+    }
+
+    let tile = vec2<i32>(
+        bitcast<i32>(atomicLoad(&grass_pool[record + ${GRASS_SLOT_TILE_X}u])),
+        bitcast<i32>(atomicLoad(&grass_pool[record + ${GRASS_SLOT_TILE_Z}u])),
+    );
+
+    let listed = grass_directory_insert(
+        atomicLoad(&grass_pool[record + ${GRASS_SLOT_SURFACE}u]),
+        atomicLoad(&grass_pool[record + ${GRASS_SLOT_LEVEL_LAYER}u]),
+        tile,
+        slot,
+    );
+
+    if (!listed) {
+        atomicStore(&grass_pool[record + ${GRASS_SLOT_STATE}u], ${GRASS_SLOT_STATE_ORPHAN}u);
+    }
+}
+`, [
+            chunk_grass_directory,
+        ]),
+});

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

@@ -0,0 +1,43 @@
+/**
+ * The scene database's `mesh_ground_covers` table.
+ */
+export const MESH_GROUND_COVERS_TABLE: import("../../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor;
+/**
+ * The bake's immediate.
+ *
+ * - `finest_spacing`: the distance between neighbouring columns of level 0, in world units.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_SURFACE_BAKE_SETTINGS: WebGPUStruct;
+/**
+ * Bakes one layer of one tile of a grass surface a workgroup: a thread a column, which walks down the
+ * column through the surface's members and writes the surfel of the layer's ground, or none.
+ *
+ * `grass_jobs` lists the slots to bake. Workgroup `j` of the folded dispatch (`folded_workgroup_index`)
+ * bakes slot `grass_jobs.elements[j]`; a workgroup past `grass_jobs.count`, or whose place holds
+ * `GRASS_SLOT_NONE`, does nothing. The slot's record, in the pool's arena `grass_pool`, names its surface,
+ * level, layer and tile (`GRASS_SURFACE.js`).
+ *
+ * **The column.** A ray from above the scene to below it, along the up axis of the surface's frame
+ * (`grass_surface_frame`), through the column's centre. It crosses at most `GRASS_COLUMN_CROSSINGS` faces, nearest first, each found by
+ * `ray_query_nearest_among`: only instances whose `mesh_ground_covers` record names the surface are
+ * entered, each as the geometry its record names. `grass_column_cross` decides which crossings are ground.
+ *
+ * **What a thread writes.** Its column's texel of the slot: the surfel of the `layer`-th ground from the top,
+ * or zeros when the column has no such ground. And into the slot's record, shared with every thread of the
+ * workgroup: the most ground any column met (`GRASS_SLOT_LAYER_COUNT`, a maximum) and how many columns wrote a
+ * surfel (`GRASS_SLOT_SURFEL_COUNT`, a sum). Both words must be zero when the workgroup starts. One thread
+ * marks the record baked and counts the bake in the pool's `GRASS_POOL_BAKED`; a pass that reads the slot's
+ * surfels comes after the bake's.
+ *
+ * **A surfel.** Height along the frame's up axis and the face's normal, both in the frame; the member's
+ * `meshes` row; the open air over it; and its painted density, the red of the member's vertex colour at the
+ * hit.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_surface_bake: ComputeShader;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_grass_surface_bake.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_grass_surface_bake.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/shader_grass_surface_bake.js"],"names":[],"mappings":"AAyCA;;GAEG;AACH,uHAAsF;AAEtF;;;;;;GAMG;AACH,0CAFU,YAAY,CAIS;AAa/B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wCAFU,aAAa,CA2KpB;6BAxP0B,mCAAmC;8BAHlC,+BAA+B"}

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

@@ -0,0 +1,265 @@
+import { sr_create_group_RTX } from "../../geometry/sr_create_group_RTX.js";
+import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { TRANSFORMS_TABLE } from "../../scene/chunk_scene_database_access.js";
+import { MESH_GROUND_COVER_FLAG_MEMBER } from "../../scene/MESH_GROUND_COVER_STRUCT.js";
+import { SCENE_DATABASE_SPEC } from "../../scene/SCENE_DATABASE_SPEC.js";
+import { BVH_NULL_NODE_DEFINITION } from "../../shader/chunk/bvh/BVH_NULL_NODE_DEFINITION.js";
+import { chunk_geometry_read_triangle_vertices } from "../../shader/chunk/geometry/format/chunk_geometry_read_triangle_vertices.js";
+import { chunk_compute_normal_matrix_from_m4 } from "../../shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js";
+import { chunk_offset_ray } from "../../shader/chunk/geometry/ray/chunk_offset_ray.js";
+import { chunk_ray_query_nearest_among } from "../../shader/chunk/geometry/ray/chunk_ray_query_nearest_among.js";
+import { RAY_STRUCT } from "../../shader/chunk/geometry/ray/RAY_STRUCT.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { chunk_grass_column_cross } from "./chunk_grass_column_cross.js";
+import { chunk_grass_slot } from "./chunk_grass_slot.js";
+import { chunk_grass_surface_frame } from "./chunk_grass_surface_frame.js";
+import { chunk_grass_surfel, GRASS_SURFEL_FORMAT } from "./chunk_grass_surfel.js";
+import { chunk_grass_tile } from "./chunk_grass_tile.js";
+import {
+    GRASS_COLUMN_CROSSINGS,
+    GRASS_POOL_BAKED,
+    GRASS_SLOT_HEIGHT_MAX,
+    GRASS_SLOT_HEIGHT_MIN,
+    GRASS_SLOT_LAYER_COUNT,
+    GRASS_SLOT_LEVEL_LAYER,
+    GRASS_SLOT_NORMAL_SPREAD,
+    GRASS_SLOT_STATE,
+    GRASS_SLOT_STATE_BAKED,
+    GRASS_SLOT_SURFACE,
+    GRASS_SLOT_SURFEL_COUNT,
+    GRASS_SLOT_TILE_X,
+    GRASS_SLOT_TILE_Z,
+    GRASS_TILE_COLUMNS,
+    GRASS_TILE_SURFELS
+} from "./GRASS_SURFACE.js";
+import { GRASS_POOL_RESOURCE } from "./GRASS_SURFACE_VIEW.js";
+
+/**
+ * The scene database's `mesh_ground_covers` table.
+ */
+export const MESH_GROUND_COVERS_TABLE = SCENE_DATABASE_SPEC.get('mesh_ground_covers');
+
+/**
+ * The bake's immediate.
+ *
+ * - `finest_spacing`: the distance between neighbouring columns of level 0, in world units.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_SURFACE_BAKE_SETTINGS = WebGPUStruct.from({
+    finest_spacing: f32,
+}, "GrassSurfaceBakeSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", GRASS_SURFACE_BAKE_SETTINGS);
+
+sr_create_group_RTX(resources);
+
+resources.createGroup()
+    .addStorageBuffer("grass_jobs", COLLECTION_U32_STRUCT_READ)
+    .add(GRASS_POOL_RESOURCE)
+    .addStorageTexture("grass_surfels", GRASS_SURFEL_FORMAT, "2d", "write-only");
+
+/**
+ * Bakes one layer of one tile of a grass surface a workgroup: a thread a column, which walks down the
+ * column through the surface's members and writes the surfel of the layer's ground, or none.
+ *
+ * `grass_jobs` lists the slots to bake. Workgroup `j` of the folded dispatch (`folded_workgroup_index`)
+ * bakes slot `grass_jobs.elements[j]`; a workgroup past `grass_jobs.count`, or whose place holds
+ * `GRASS_SLOT_NONE`, does nothing. The slot's record, in the pool's arena `grass_pool`, names its surface,
+ * level, layer and tile (`GRASS_SURFACE.js`).
+ *
+ * **The column.** A ray from above the scene to below it, along the up axis of the surface's frame
+ * (`grass_surface_frame`), through the column's centre. It crosses at most `GRASS_COLUMN_CROSSINGS` faces, nearest first, each found by
+ * `ray_query_nearest_among`: only instances whose `mesh_ground_covers` record names the surface are
+ * entered, each as the geometry its record names. `grass_column_cross` decides which crossings are ground.
+ *
+ * **What a thread writes.** Its column's texel of the slot: the surfel of the `layer`-th ground from the top,
+ * or zeros when the column has no such ground. And into the slot's record, shared with every thread of the
+ * workgroup: the most ground any column met (`GRASS_SLOT_LAYER_COUNT`, a maximum) and how many columns wrote a
+ * surfel (`GRASS_SLOT_SURFEL_COUNT`, a sum). Both words must be zero when the workgroup starts. One thread
+ * marks the record baked and counts the bake in the pool's `GRASS_POOL_BAKED`; a pass that reads the slot's
+ * surfels comes after the bake's.
+ *
+ * **A surfel.** Height along the frame's up axis and the face's normal, both in the frame; the member's
+ * `meshes` row; the open air over it; and its painted density, the red of the member's vertex colour at the
+ * hit.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_surface_bake = ComputeShader.from({
+    label: "Grass Surface Bake",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+// the surface the invocation's column belongs to, for the query's hook
+var<private> grass_bake_surface: u32;
+
+fn ray_query_among_geometry(mesh: u32) -> u32 {
+    let cover = ${MESH_GROUND_COVERS_TABLE.marshalling_method_read}(&scene_database, mesh);
+
+    if ((cover.flags & ${MESH_GROUND_COVER_FLAG_MEMBER}u) == 0u || cover.surface != grass_bake_surface) {
+        return RAY_QUERY_AMONG_PASS;
+    }
+
+    return cover.geometry;
+}
+
+@compute @workgroup_size(${GRASS_TILE_SURFELS})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let job = folded_workgroup_index(workgroup_id);
+
+    if (job >= grass_jobs.count) {
+        return;
+    }
+
+    let slot = grass_jobs.elements[job];
+
+    if (slot == GRASS_SLOT_NONE) {
+        return;
+    }
+
+    let record = grass_slot_record(slot);
+
+    let surface = atomicLoad(&grass_pool[record + ${GRASS_SLOT_SURFACE}u]);
+    let level_layer = atomicLoad(&grass_pool[record + ${GRASS_SLOT_LEVEL_LAYER}u]);
+    let level = level_layer & 0xFFu;
+    let layer = (level_layer >> 8u) & 0xFFu;
+    let tile = vec2<i32>(
+        bitcast<i32>(atomicLoad(&grass_pool[record + ${GRASS_SLOT_TILE_X}u])),
+        bitcast<i32>(atomicLoad(&grass_pool[record + ${GRASS_SLOT_TILE_Z}u])),
+    );
+
+    let column = vec2<u32>(lane % ${GRASS_TILE_COLUMNS}u, lane / ${GRASS_TILE_COLUMNS}u);
+    let spacing = grass_level_spacing(settings.finest_spacing, level);
+    let place = grass_tile_column_position(tile, column, spacing);
+
+    var texel = vec4<u32>(0u);
+    var kept = 0u;
+
+    // the surfel's height, and how far its normal is from the frame's up axis
+    var found = vec2<f32>(0.0);
+
+    if (tlas.root != BVH_NULL_NODE) {
+        grass_bake_surface = surface;
+
+        let frame = grass_surface_frame(${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, surface));
+        let up = frame[1].xyz;
+
+        // the scene's reach along the frame's up axis: its box's centre, and the box's half extent along it
+        let bounds = tlas.nodes[tlas.root].bounds;
+        let low = vec3<f32>(bounds[0], bounds[1], bounds[2]);
+        let high = vec3<f32>(bounds[3], bounds[4], bounds[5]);
+        let half_reach = dot(0.5 * (high - low), abs(up));
+        let top = dot(0.5 * (high + low), up) + half_reach;
+
+        // the walk starts clear of the scene's top, so its highest face is a crossing like any other
+        let margin = max(half_reach, 1.0) / 1024.0;
+
+        let foot = (frame * vec4<f32>(place.x, 0.0, place.y, 1.0)).xyz;
+
+        var ray: ${RAY_STRUCT.wgsl_ref};
+        ray.direction = -up;
+        ray.origin = foot + up * (top - dot(foot, up) + margin);
+        ray.tmax = 2.0 * (half_reach + margin);
+
+        var walk = grass_column_begin();
+
+        for (var i = 0u; i < ${GRASS_COLUMN_CROSSINGS}u; i++) {
+            let hit = ray_query_nearest_among(ray);
+
+            if (hit.t < 0.0) {
+                break;
+            }
+
+            let position = ray.origin + ray.direction * hit.t;
+
+            let member = ${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, hit.instance);
+            let triangle = geometry_read_triangle_vertices(geometries[hit.geometry], hit.triangle);
+
+            let face = cross(triangle.b.position - triangle.a.position, triangle.c.position - triangle.a.position);
+            let normal = normalize(compute_normal_matrix_from_m4(member) * face);
+
+            let height = grass_world_to_frame(frame, position).y;
+
+            let crossing = grass_column_cross(walk, height, dot(normal, up) > 0.0);
+
+            walk = crossing.walk;
+
+            if (crossing.keep) {
+                if (kept == layer) {
+                    let lambda = vec3<f32>(1.0 - hit.barycentrics.x - hit.barycentrics.y, hit.barycentrics.x, hit.barycentrics.y);
+
+                    var surfel: GrassSurfel;
+                    surfel.height = height;
+                    surfel.normal = grass_world_direction_to_frame(frame, normal);
+                    surfel.member = hit.instance;
+                    surfel.clear_height = crossing.clear_height;
+                    surfel.density = dot(lambda, vec3<f32>(triangle.a.color.r, triangle.b.color.r, triangle.c.color.r));
+
+                    texel = grass_surfel_pack(surfel);
+
+                    found = vec2<f32>(height, length(surfel.normal - vec3<f32>(0.0, 1.0, 0.0)));
+                }
+
+                kept++;
+            }
+
+            // on past the face
+            ray.origin = offset_ray(position, ray.direction);
+            ray.tmax -= hit.t;
+
+            if (ray.tmax <= 0.0) {
+                break;
+            }
+        }
+    }
+
+    textureStore(grass_surfels, grass_slot_texel(slot, column, textureDimensions(grass_surfels).x), texel);
+
+    atomicMax(&grass_pool[record + ${GRASS_SLOT_LAYER_COUNT}u], kept);
+
+    if (grass_surfel_exists(texel)) {
+        atomicAdd(&grass_pool[record + ${GRASS_SLOT_SURFEL_COUNT}u], 1u);
+
+        let key = grass_height_key(found.x);
+
+        atomicMin(&grass_pool[record + ${GRASS_SLOT_HEIGHT_MIN}u], key);
+        atomicMax(&grass_pool[record + ${GRASS_SLOT_HEIGHT_MAX}u], key);
+
+        // the bits of a float at or above zero order as it does
+        atomicMax(&grass_pool[record + ${GRASS_SLOT_NORMAL_SPREAD}u], bitcast<u32>(found.y));
+    }
+
+    if (lane == 0u) {
+        atomicStore(&grass_pool[record + ${GRASS_SLOT_STATE}u], ${GRASS_SLOT_STATE_BAKED}u);
+        atomicAdd(&grass_pool[${GRASS_POOL_BAKED}u], 1u);
+    }
+}
+`, [
+            BVH_NULL_NODE_DEFINITION,
+            RAY_STRUCT.declaration_chunk,
+            chunk_folded_workgroup_index,
+            chunk_compute_normal_matrix_from_m4,
+            chunk_geometry_read_triangle_vertices,
+            chunk_offset_ray,
+            chunk_ray_query_nearest_among,
+            chunk_grass_column_cross,
+            chunk_grass_slot,
+            chunk_grass_surface_frame,
+            chunk_grass_surfel,
+            chunk_grass_tile,
+            MESH_GROUND_COVERS_TABLE.chunk_read,
+            TRANSFORMS_TABLE.chunk_read_field('global'),
+        ]),
+});

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

@@ -0,0 +1,13 @@
+/**
+ * One thread, between the asks for a frame's tiles ({@link shader_grass_surface_want}) and their bake
+ * ({@link shader_grass_surface_bake}), which runs a workgroup a place of the bake list.
+ *
+ * The asks leave the list's count at how many places were asked for, which can pass the places there are.
+ * This writes the count the bake reads, the places taken, and the bake's folded dispatch
+ * (`folded_dispatch`) of that many workgroups. A pass never writes the command it is dispatched through.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_surface_bake_command: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_grass_surface_bake_command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_grass_surface_bake_command.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/shader_grass_surface_bake_command.js"],"names":[],"mappings":"AAiBA;;;;;;;;;GASG;AACH,gDAFU,aAAa,CAuBpB;8BA5C2B,+BAA+B"}

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

@@ -0,0 +1,49 @@
+import { COLLECTION_U32_STRUCT_WRITE } from "../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
+import { chunk_folded_dispatch } from "../../gpu_primitive/indirect/chunk_folded_dispatch.js";
+import { STRUCT_DISPATCH_COMPUTE_COMMAND } from "../../gpu_primitive/indirect/STRUCT_DISPATCH_COMPUTE_COMMAND.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// how many places the frame's bake list has
+resources.setImmediate("job_capacity", u32);
+
+resources.createGroup()
+    .addStorageBuffer("grass_jobs", COLLECTION_U32_STRUCT_WRITE, true)
+    .addStorageBuffer("command", STRUCT_DISPATCH_COMPUTE_COMMAND, true);
+
+/**
+ * One thread, between the asks for a frame's tiles ({@link shader_grass_surface_want}) and their bake
+ * ({@link shader_grass_surface_bake}), which runs a workgroup a place of the bake list.
+ *
+ * The asks leave the list's count at how many places were asked for, which can pass the places there are.
+ * This writes the count the bake reads, the places taken, and the bake's folded dispatch
+ * (`folded_dispatch`) of that many workgroups. A pass never writes the command it is dispatched through.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_surface_bake_command = ComputeShader.from({
+    label: "Grass Surface Bake Command",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(1)
+fn main() {
+    let taken = min(atomicLoad(&grass_jobs.count), job_capacity);
+
+    atomicStore(&grass_jobs.count, taken);
+
+    let folded = folded_dispatch(taken);
+
+    command.workgroupCountX = folded.x;
+    command.workgroupCountY = folded.y;
+    command.workgroupCountZ = folded.z;
+}
+`, [
+            chunk_folded_dispatch,
+        ]),
+});