@woosh/meep-engine 3.64.1 → 3.65.0

package/src/shade/renderer/grass/blade/grass_blade_resolve.js

@@ -0,0 +1,175 @@
+import { ColorTargetState } from "../../../descriptor/pipeline/render/ColorTargetState.js";
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { CAMERA_RESOURCE } from "../../camera/CAMERA_RESOURCE.js";
+import { G_BUFFER_COLOR_TARGETS } from "../../gbuffer/G_BUFFER_COLOR_TARGETS.js";
+import { VISIBILITY_FORMAT, VISIBILITY_NONE } from "../../rasterize/visibility/VISIBILITY_BUFFER.js";
+import { TRANSFORMS_TABLE } from "../../scene/chunk_scene_database_access.js";
+import { SCENE_DATABASE_RESOURCE } from "../../scene/SCENE_DATABASE_RESOURCE.js";
+import { chunk_rgbe9995_encode } from "../../shader/chunk/color/rgbe9995/chunk_rgbe9995_encode.js";
+import { chunk_encode_g_buffer_face_normal } from "../../shader/chunk/geometry/normal/chunk_encode_g_buffer_face_normal.js";
+import { chunk_mat4_inverse } from "../../shader/chunk/geometry/mat4/chunk_mat4_inverse.js";
+import { chunk_encode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_encode_g_buffer_normal.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { vertex_full_viewport_quad } from "../../shader/fullscreen/vertex_full_viewport_quad.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { mat4x4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { chunk_grass_surface_frame } from "../surface/chunk_grass_surface_frame.js";
+import { chunk_grass_blade } from "./chunk_grass_blade.js";
+import { GRASS_BLADE_ID_ACROSS_BITS, GRASS_BLADE_ID_ALONG_BITS, GRASS_BLADE_ID_NONE } from "./GRASS_BLADE.js";
+import { GRASS_BLADE_LIST_STRUCT_READ, GRASS_SPECIES_RESOURCE } from "./shader_grass_blade_expand.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .add(CAMERA_RESOURCE)
+    .add(SCENE_DATABASE_RESOURCE)
+    .addStorageBuffer("grass_blades", GRASS_BLADE_LIST_STRUCT_READ)
+    .add(GRASS_SPECIES_RESOURCE)
+    .addTexture("grass_ids", "uint")
+    .addTexture("scene_depth")
+    .addUniform("inverse_view_projection", mat4x4f)
+    .addUniform("view_projection_previous", mat4x4f);
+
+const ALONG_STEPS = 2 ** GRASS_BLADE_ID_ALONG_BITS - 1;
+const ACROSS_STEPS = 2 ** GRASS_BLADE_ID_ACROSS_BITS - 1;
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+struct GrassResolveOutput {
+    @location(0) pbr: vec4<f32>,
+    @location(1) normal: u32,
+    @location(2) albedo: vec4<f32>,
+    @location(3) emissive: u32,
+    @location(4) visibility: u32,
+    @location(5) velocity: vec2<f32>,
+}
+
+@fragment
+fn fs_main(@builtin(position) position: vec4<f32>) -> GrassResolveOutput {
+    let id = textureLoad(grass_ids, vec2<i32>(position.xy), 0).x;
+
+    if (id == ${GRASS_BLADE_ID_NONE}u) {
+        discard;
+    }
+
+    let blade = grass_blade_unpack(grass_blades.records[(id >> ${GRASS_BLADE_ID_ALONG_BITS + GRASS_BLADE_ID_ACROSS_BITS}u) - 1u]);
+
+    let along = f32((id >> ${GRASS_BLADE_ID_ACROSS_BITS}u) & ${ALONG_STEPS}u) / ${ALONG_STEPS}.0;
+    let across = f32(id & ${ACROSS_STEPS}u) / ${ACROSS_STEPS}.0 * 2.0 - 1.0;
+
+    let species = grass_species[blade.species];
+
+    let frame = grass_surface_frame(${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, blade.surface));
+
+    // the face the view sees, rounded across the blade's width
+    let side = grass_blade_across(blade);
+
+    var face = normalize(cross(side, grass_blade_tangent(blade, along)));
+
+    let eye = grass_world_to_frame(frame, camera.transform[3].xyz);
+
+    if (dot(face, eye - grass_blade_point(blade, along)) < 0.0) {
+        face = -face;
+    }
+
+    let rounded = normalize(face + side * (across * species.more.z));
+
+    // a blade that stands for many takes their mean normal, which is the ground's, and their spread as roughness
+    let normal = normalize((frame * vec4<f32>(mix(blade.ground, rounded, blade.thinning), 0.0)).xyz);
+    let roughness = mix(1.0, species.shape.w, blade.thinning);
+
+    let tint = 1.0 + species.more.y * (f32(blade.seed) / 255.0 * 2.0 - 1.0);
+
+    var out: GrassResolveOutput;
+
+    out.pbr = vec4<f32>(0.0, roughness, encode_g_buffer_face_normal(normal));
+    out.normal = encode_g_buffer_normal(normal);
+    out.albedo = vec4<f32>(mix(species.root.rgb, species.tip.rgb, along) * tint, 1.0);
+    out.emissive = rgbe9995_encode(vec3<f32>(0.0));
+
+    // no meshlet is under a blade
+    out.visibility = ${VISIBILITY_NONE}u;
+
+    // where this point of the blade was a frame ago: on the blade as it was bent then, carried by its surface
+    let pixel = position.xy;
+    let size = vec2<f32>(textureDimensions(scene_depth));
+
+    let depth = textureLoad(scene_depth, vec2<i32>(pixel), 0).r;
+
+    let here = inverse_view_projection * vec4<f32>(pixel.x / size.x * 2.0 - 1.0, 1.0 - pixel.y / size.y * 2.0, depth, 1.0);
+
+    let global = ${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, blade.surface);
+    let global_previous = ${TRANSFORMS_TABLE.marshalling_method_read_field('prev_global')}(&scene_database, blade.surface);
+
+    let blade_before = grass_blade_previous(blade);
+    let half = 0.5 * blade.width * grass_blade_taper(along) * across;
+
+    // how far the point has moved on its surface over the frame, in the frame and then in the world
+    let moved = grass_blade_point(blade, along) + side * half
+        - grass_blade_point(blade_before, along) - grass_blade_across(blade_before) * half;
+
+    let there = here.xyz / here.w - (frame * vec4<f32>(moved, 0.0)).xyz;
+
+    let before = view_projection_previous * (global_previous * (mat4_inverse(global) * vec4<f32>(there, 1.0)));
+    let before_ndc = before.xy / before.w;
+
+    out.velocity = pixel - vec2<f32>((before_ndc.x + 1.0) * 0.5 * size.x, (1.0 - before_ndc.y) * 0.5 * size.y);
+
+    return out;
+}
+`, [
+        chunk_grass_surface_frame,
+        chunk_grass_blade,
+        chunk_encode_g_buffer_normal,
+        chunk_encode_g_buffer_face_normal,
+        chunk_rgbe9995_encode,
+        chunk_mat4_inverse,
+        TRANSFORMS_TABLE.chunk_read_field('global'),
+        TRANSFORMS_TABLE.chunk_read_field('prev_global'),
+    ]);
+
+const descriptor = ShaderDescriptor.from({ label: "Grass Blade Resolve", body, resources });
+
+/**
+ * The bindings of {@link GRASS_BLADE_RESOLVE_PIPELINE}: `camera`, `scene_database`, `grass_blades` (the
+ * list the ids were drawn from), `grass_species`, `grass_ids` (the blade id target), `scene_depth` (the
+ * depth the blades were drawn into), and the two matrices of `view_velocity_matrices`.
+ *
+ * @type {ShaderResourceSetDescriptor}
+ */
+export const GRASS_BLADE_RESOLVE_RESOURCES = resources;
+
+/**
+ * Turns the blade id target into the G-buffer's surface under every pixel a blade covers, and leaves every
+ * other pixel as it was: a full-screen triangle (three vertices) over six targets, loaded: the four
+ * G-buffer targets in `G_BUFFER_COLOR_TARGETS`' order, then the visibility buffer and the velocity buffer.
+ *
+ * A blade's pixel takes its species' colour from root to tip, tinted by the blade's own seed; the normal
+ * of the blade's face on the view's side, turned towards the edge the pixel is nearer; no metalness, no
+ * emission, and an occlusion of one. A blade drawn in place of many (`thinning` under one) moves its
+ * normal towards the ground's and its roughness towards one by as much.
+ *
+ * The pixel's visibility word becomes `VISIBILITY_NONE`: no meshlet is the surface there, and a reader that
+ * decoded the word would find the ground under the blade. Its velocity is the blade point's own, in the
+ * velocity buffer's units: where the point was a frame ago, on the blade as it was bent then
+ * (`grass_blade_previous`) and on its surface where that was.
+ *
+ * @type {RenderPipelineDescriptor}
+ */
+export const GRASS_BLADE_RESOLVE_PIPELINE = RenderPipelineDescriptor.from({
+    label: "Grass Blade Resolve",
+    layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    vertex: { module: { code: vertex_full_viewport_quad }, entryPoint: "main" },
+    fragment: {
+        module: { code: descriptor.source },
+        entryPoint: "fs_main",
+        targets: [
+            ...G_BUFFER_COLOR_TARGETS.map(target => ColorTargetState.from({ format: target.format })),
+            ColorTargetState.from({ format: VISIBILITY_FORMAT }),
+            ColorTargetState.from({ format: "rg16float" }),
+        ],
+    },
+    primitive: { topology: "triangle-list", cullMode: "none" },
+});

package/src/shade/renderer/grass/blade/shader_grass_blade_draw_args.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Closes a blade list for its draw: one thread, after {@link shader_grass_blade_expand}.
+ *
+ * Writes the draw's indirect arguments, a strip of `GRASS_BLADE_VERTICES` vertices an instance and an
+ * instance a blade the list holds, which is its count or `settings.blade_capacity` where the count passed
+ * it; and the two numbers of the view the draw needs into the list's own first words
+ * (`GRASS_BLADE_LIST_FOCAL`, `GRASS_BLADE_LIST_NARROWEST`). The list's count is left as the blades that
+ * asked for a place, for whoever sizes the list.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_blade_draw_args: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_grass_blade_draw_args.d.ts.map

package/src/shade/renderer/grass/blade/shader_grass_blade_draw_args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_grass_blade_draw_args.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/blade/shader_grass_blade_draw_args.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;GAUG;AACH,2CAFU,aAAa,CAmBpB;8BA3C2B,+BAA+B"}

package/src/shade/renderer/grass/blade/shader_grass_blade_draw_args.js

@@ -0,0 +1,45 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { GRASS_SURFACE_VIEW_SETTINGS } from "../surface/GRASS_SURFACE_VIEW.js";
+import { GRASS_BLADE_VERTICES } from "./GRASS_BLADE.js";
+import { GRASS_BLADE_LIST_STRUCT_WRITE } from "./shader_grass_blade_expand.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", GRASS_SURFACE_VIEW_SETTINGS);
+
+resources.createGroup()
+    .addStorageBuffer("grass_blades", GRASS_BLADE_LIST_STRUCT_WRITE, true)
+    .addStorageBuffer("draw_args", WebGPUArray.u32, true);
+
+/**
+ * Closes a blade list for its draw: one thread, after {@link shader_grass_blade_expand}.
+ *
+ * Writes the draw's indirect arguments, a strip of `GRASS_BLADE_VERTICES` vertices an instance and an
+ * instance a blade the list holds, which is its count or `settings.blade_capacity` where the count passed
+ * it; and the two numbers of the view the draw needs into the list's own first words
+ * (`GRASS_BLADE_LIST_FOCAL`, `GRASS_BLADE_LIST_NARROWEST`). The list's count is left as the blades that
+ * asked for a place, for whoever sizes the list.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_blade_draw_args = ComputeShader.from({
+    label: "Grass Blade Draw Args",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(1)
+fn main() {
+    grass_blades.focal = bitcast<u32>(settings.focal);
+    grass_blades.narrowest = bitcast<u32>(settings.narrowest_blade);
+
+    draw_args[0] = ${GRASS_BLADE_VERTICES}u;
+    draw_args[1] = min(atomicLoad(&grass_blades.count), settings.blade_capacity);
+    draw_args[2] = 0u;
+    draw_args[3] = 0u;
+}
+`),
+});

package/src/shade/renderer/grass/blade/shader_grass_blade_expand.d.ts

@@ -0,0 +1,61 @@
+/**
+ * A blade list as the pass that fills it sees it: `GRASS_BLADE.js` says what its first words are.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_BLADE_LIST_STRUCT_WRITE: WebGPUStruct;
+/**
+ * A blade list as the passes that read it see it.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_BLADE_LIST_STRUCT_READ: WebGPUStruct;
+/**
+ * The species list, a `GRASS_SPECIES_STRUCT` a species.
+ *
+ * @type {ShaderResourceDescriptor}
+ */
+export const GRASS_SPECIES_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Makes the blades a view is shown, a thread a blade the frame's cells counted
+ * ({@link shader_grass_cell_count}, whose counts, summed, are `prefix_sums`), and lists the ones that are
+ * there in `grass_blades`.
+ *
+ * A thread finds its cell from the sums and, from its place among the cell's threads, a point of the
+ * surface's blade lattice (`chunk_grass_population`): the cell's points in the order of their ranks. The
+ * blade stands at a place of its own inside the point's square of the lattice, on the plane of the surfel
+ * of the column it is in. It is dropped when:
+ *
+ * - its column holds no surfel, or one too steep to stand on;
+ * - the member under it grows nothing;
+ * - its distance from the view is one another level's tile makes (the cell's ring and flags);
+ * - it is so far that none of its length is drawn (`grass_blade_fade`), or it is outside the view's frustum
+ *   by more than its length;
+ * - its rank is not under the density the view is shown there (`grass_blade_density`), as a share of the
+ *   lattice's own.
+ *
+ * What is left takes a place in the list (`chunk_subgroup_append_slot`: the list's count rises past
+ * `settings.blade_capacity`, its records do not), with a length, lean, curl and facing that are the
+ * blade's own, a hash of its lattice point: the same blade is the same every frame and at every level.
+ * Its length is cut to the open air over its surfel.
+ *
+ * The blade is then bent by the scene's wind (`chunk_grass_blade_wind`), sampled half its length above
+ * its root: once as the wind is and at `grass_clock`'s time, and once as the wind was a frame ago
+ * (`chunk_wind_field_sample_previous`) and at the clock's previous time, which is the arc the record
+ * keeps as the blade's previous one. In a wind and at a clock that have not changed the two are the same.
+ *
+ * And it is pushed over by whatever has pressed the ground it stands on (`chunk_grass_press`, the field
+ * `grass_press` under `grass_press_window`): as the field holds it now, and for the previous arc as it
+ * held it a frame ago. The blade the press acts on is the one that stands, its grown length cut to the
+ * open air over its surfel.
+ *
+ * Dispatched through `shader_prefix_sum_to_command`'s folded command. `grass_blades.count` is zero on
+ * entry.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_blade_expand: ComputeShader;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_grass_blade_expand.d.ts.map

package/src/shade/renderer/grass/blade/shader_grass_blade_expand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_grass_blade_expand.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/blade/shader_grass_blade_expand.js"],"names":[],"mappings":"AA0CA;;;;GAIG;AACH,4CAFU,YAAY,CAQI;AAE1B;;;;GAIG;AACH,2CAFU,YAAY,CAQG;AAEzB;;;;GAIG;AACH,qCAFU,wBAAwB,CAEoG;AAkBtI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wCAFU,aAAa,CAoNpB;6BAlU0B,mCAAmC;yCAJvB,mDAAmD;8BAD9D,+BAA+B"}

package/src/shade/renderer/grass/blade/shader_grass_blade_expand.js

@@ -0,0 +1,340 @@
+import { CAMERA_RESOURCE } from "../../camera/CAMERA_RESOURCE.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_GROWS } from "../../scene/MESH_GROUND_COVER_STRUCT.js";
+import { SCENE_DATABASE_RESOURCE } from "../../scene/SCENE_DATABASE_RESOURCE.js";
+import { SCENE_DATABASE_SPEC } from "../../scene/SCENE_DATABASE_SPEC.js";
+import { chunk_folded_workgroup_index } from "../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { chunk_lower_bound_branchless } from "../../shader/chunk/math/chunk_lower_bound_branchless.js";
+import { chunk_hash_lowbias32 } from "../../shader/chunk/random/chunk_hash_lowbias32.js";
+import { chunk_subgroup_append_slot } from "../../shader/chunk/subgroup/chunk_subgroup_append_slot.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { atomic_u32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { chunk_wind_field_sample } from "../../wind/chunk_wind_field_sample.js";
+import { chunk_wind_field_sample_previous } from "../../wind/chunk_wind_field_sample_previous.js";
+import { wind_field_add_history_resources } from "../../wind/wind_field_add_resources.js";
+import { chunk_grass_population } from "../population/chunk_grass_population.js";
+import { chunk_grass_press } from "../press/chunk_grass_press.js";
+import { GRASS_PRESS_WINDOW_STRUCT } from "../press/GRASS_PRESS.js";
+import { chunk_grass_surface_frame } from "../surface/chunk_grass_surface_frame.js";
+import { chunk_grass_surfel } from "../surface/chunk_grass_surfel.js";
+import { chunk_grass_tile } from "../surface/chunk_grass_tile.js";
+import { GRASS_SURFACE_VIEW_SETTINGS } from "../surface/GRASS_SURFACE_VIEW.js";
+import { chunk_grass_blade } from "./chunk_grass_blade.js";
+import { chunk_grass_blade_wind, GRASS_BLADE_CLOCK_STRUCT } from "./chunk_grass_blade_wind.js";
+import {
+    GRASS_BLADE_RECORD_WORDS,
+    GRASS_CELL_CHILD_MISSING,
+    GRASS_CELL_LATTICE_SHIFT,
+    GRASS_CELL_PARENT_MISSING,
+    GRASS_CELL_STRUCT,
+    GRASS_SPECIES_STRUCT
+} from "./GRASS_BLADE.js";
+import { GRASS_TILE_COLUMNS_LOG2 } from "./shader_grass_cell_count.js";
+
+const MESH_GROUND_COVERS_TABLE = SCENE_DATABASE_SPEC.get('mesh_ground_covers');
+
+/**
+ * A blade list as the pass that fills it sees it: `GRASS_BLADE.js` says what its first words are.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_BLADE_LIST_STRUCT_WRITE = WebGPUStruct.from({
+    count: atomic_u32,
+    focal: u32,
+    narrowest: u32,
+    unused: u32,
+    records: WebGPUArray.from(WebGPUArray.from(u32, GRASS_BLADE_RECORD_WORDS)),
+}, "GrassBladeListWrite");
+
+/**
+ * A blade list as the passes that read it see it.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_BLADE_LIST_STRUCT_READ = WebGPUStruct.from({
+    count: u32,
+    focal: u32,
+    narrowest: u32,
+    unused: u32,
+    records: WebGPUArray.from(WebGPUArray.from(u32, GRASS_BLADE_RECORD_WORDS)),
+}, "GrassBladeListRead");
+
+/**
+ * The species list, a `GRASS_SPECIES_STRUCT` a species.
+ *
+ * @type {ShaderResourceDescriptor}
+ */
+export const GRASS_SPECIES_RESOURCE = ShaderResourceDescriptor.storageBuffer("grass_species", WebGPUArray.from(GRASS_SPECIES_STRUCT));
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", GRASS_SURFACE_VIEW_SETTINGS);
+
+wind_field_add_history_resources(resources.createGroup()
+    .add(CAMERA_RESOURCE)
+    .add(SCENE_DATABASE_RESOURCE)
+    .addStorageBuffer("prefix_sums", COLLECTION_U32_STRUCT_READ)
+    .addStorageBuffer("grass_cells", WebGPUArray.from(GRASS_CELL_STRUCT))
+    .add(GRASS_SPECIES_RESOURCE)
+    .addTexture("grass_surfels", "uint")
+    .addStorageBuffer("grass_blades", GRASS_BLADE_LIST_STRUCT_WRITE, true)
+    .addUniform("grass_clock", GRASS_BLADE_CLOCK_STRUCT)
+    .addStorageBuffer("grass_press", WebGPUArray.from(u32))
+    .addUniform("grass_press_window", GRASS_PRESS_WINDOW_STRUCT));
+
+/**
+ * Makes the blades a view is shown, a thread a blade the frame's cells counted
+ * ({@link shader_grass_cell_count}, whose counts, summed, are `prefix_sums`), and lists the ones that are
+ * there in `grass_blades`.
+ *
+ * A thread finds its cell from the sums and, from its place among the cell's threads, a point of the
+ * surface's blade lattice (`chunk_grass_population`): the cell's points in the order of their ranks. The
+ * blade stands at a place of its own inside the point's square of the lattice, on the plane of the surfel
+ * of the column it is in. It is dropped when:
+ *
+ * - its column holds no surfel, or one too steep to stand on;
+ * - the member under it grows nothing;
+ * - its distance from the view is one another level's tile makes (the cell's ring and flags);
+ * - it is so far that none of its length is drawn (`grass_blade_fade`), or it is outside the view's frustum
+ *   by more than its length;
+ * - its rank is not under the density the view is shown there (`grass_blade_density`), as a share of the
+ *   lattice's own.
+ *
+ * What is left takes a place in the list (`chunk_subgroup_append_slot`: the list's count rises past
+ * `settings.blade_capacity`, its records do not), with a length, lean, curl and facing that are the
+ * blade's own, a hash of its lattice point: the same blade is the same every frame and at every level.
+ * Its length is cut to the open air over its surfel.
+ *
+ * The blade is then bent by the scene's wind (`chunk_grass_blade_wind`), sampled half its length above
+ * its root: once as the wind is and at `grass_clock`'s time, and once as the wind was a frame ago
+ * (`chunk_wind_field_sample_previous`) and at the clock's previous time, which is the arc the record
+ * keeps as the blade's previous one. In a wind and at a clock that have not changed the two are the same.
+ *
+ * And it is pushed over by whatever has pressed the ground it stands on (`chunk_grass_press`, the field
+ * `grass_press` under `grass_press_window`): as the field holds it now, and for the previous arc as it
+ * held it a frame ago. The blade the press acts on is the one that stands, its grown length cut to the
+ * open air over its surfel.
+ *
+ * Dispatched through `shader_prefix_sum_to_command`'s folded command. `grass_blades.count` is zero on
+ * entry.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_blade_expand = ComputeShader.from({
+    label: "Grass Blade Expand",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+// a number in [0, 1) from a word
+fn grass_blade_unit(h: u32) -> f32 {
+    return f32(h >> 8u) / 16777216.0;
+}
+
+fn grass_blade_make(cell: ${GRASS_CELL_STRUCT.wgsl_ref}, slot: u32, place: u32, blade: ptr<function, GrassBlade>) -> bool {
+    let level = cell.level_layer & 0xFFu;
+    let layer = cell.level_layer >> 8u;
+    let lattice_bits = (cell.flags >> ${GRASS_CELL_LATTICE_SHIFT}u) & 0xFFu;
+
+    let block_level = ${GRASS_TILE_COLUMNS_LOG2}u + lattice_bits + level;
+
+    let point = grass_population_point(block_level, cell.tile, place, cell.surface);
+
+    // the blade's own numbers: of its point, its surface and its layer
+    var h = hash_lowbias32(cell.surface ^ (layer * 0x85EBCA6Bu));
+
+    h = hash_lowbias32(h ^ bitcast<u32>(point.x));
+    h = hash_lowbias32(h ^ bitcast<u32>(point.y));
+
+    let h_x = h;
+    let h_z = hash_lowbias32(h_x);
+    let h_facing = hash_lowbias32(h_z);
+    let h_lean = hash_lowbias32(h_facing);
+    let h_curl = hash_lowbias32(h_lean);
+    let h_length = hash_lowbias32(h_curl);
+
+    // a place inside the point's square of the lattice
+    let pitch = ldexp(settings.finest_spacing, -i32(lattice_bits));
+    let xz = (vec2<f32>(point) + vec2<f32>(grass_blade_unit(h_x), grass_blade_unit(h_z))) * pitch;
+
+    // the column that square lies in
+    let column = vec2<u32>((point >> vec2<u32>(lattice_bits + level)) - cell.tile * i32(GRASS_TILE_COLUMNS));
+
+    let texel = textureLoad(grass_surfels, grass_slot_texel(slot, column, textureDimensions(grass_surfels).x), 0);
+
+    if (!grass_surfel_exists(texel)) {
+        return false;
+    }
+
+    let surfel = grass_surfel_unpack(texel);
+
+    if (surfel.normal.y <= 1e-3) {
+        return false;
+    }
+
+    let cover = ${MESH_GROUND_COVERS_TABLE.marshalling_method_read}(&scene_database, surfel.member);
+
+    if ((cover.flags & ${MESH_GROUND_COVER_FLAG_GROWS}u) == 0u) {
+        return false;
+    }
+
+    // on the surfel's plane
+    let spacing = grass_level_spacing(settings.finest_spacing, level);
+    let centre = grass_tile_column_position(cell.tile, column, spacing);
+
+    let root = vec3<f32>(xz.x, surfel.height - dot(surfel.normal.xz, xz - centre) / surfel.normal.y, xz.y);
+
+    let frame = grass_surface_frame(${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, cell.surface));
+    let eye = grass_world_to_frame(frame, camera.transform[3].xyz);
+
+    let to_eye = eye - root;
+    let distance = length(to_eye);
+
+    // the level whose ring holds the distance makes the blade, or the cell in its place
+    if (distance >= cell.ring_outer && (cell.flags & ${GRASS_CELL_PARENT_MISSING}u) == 0u) {
+        return false;
+    }
+
+    let quarter = ((column.x >> ${GRASS_TILE_COLUMNS_LOG2 - 1}u) & 1u) | (((column.y >> ${GRASS_TILE_COLUMNS_LOG2 - 1}u) & 1u) << 1u);
+
+    if (distance < cell.ring_inner && (cell.flags & (${GRASS_CELL_CHILD_MISSING}u << quarter)) == 0u) {
+        return false;
+    }
+
+    let species = grass_species[cover.species];
+
+    let fade = grass_blade_fade(settings, species.shape.x, distance);
+
+    if (fade <= 0.0) {
+        return false;
+    }
+
+    // outside the frustum by more than a blade
+    let world = (frame * vec4<f32>(root, 1.0)).xyz;
+
+    for (var i = 0u; i < 6u; i++) {
+        let plane = camera.frustum[i];
+
+        if (dot(plane.xyz, world) + plane.w < -species.shape.x) {
+            return false;
+        }
+    }
+
+    let content = species.shape.z * surfel.density * cover.density;
+
+    if (content <= 0.0) {
+        return false;
+    }
+
+    let sin_elevation = dot(surfel.normal, to_eye) / max(distance, 1e-6);
+
+    let shown = grass_blade_density(settings, content, species.shape.y, species.shape.x, distance, sin_elevation, surfel.normal.y);
+
+    let lattice_side = f32(1u << lattice_bits) / settings.finest_spacing;
+    let share = shown / (lattice_side * lattice_side);
+
+    if (share < 1.0 && grass_population_rank(block_level, cell.rank, place) >= grass_population_threshold(share)) {
+        return false;
+    }
+
+    // as the blade grew, before it is cut short: what it bends and sways as
+    let grown = species.shape.x * (1.0 - species.root.w * grass_blade_unit(h_length));
+
+    let rest = GrassBladeBend(
+        grass_blade_unit(h_facing) * GRASS_BLADE_TAU,
+        species.tip.w * grass_blade_unit(h_lean),
+        species.more.x * grass_blade_unit(h_curl),
+    );
+
+    // the air half way up the blade, as it is and as it was a frame ago
+    let middle = world + frame[1].xyz * (0.5 * grown);
+
+    let wind = grass_world_direction_to_frame(frame, wind_field_sample(middle));
+    let wind_previous = grass_world_direction_to_frame(frame, wind_field_sample_previous(middle));
+
+    let frequency = species.wind.y / max(grown * grown, 1e-6);
+    let offsets = vec2<f32>(grass_blade_unit(hash_lowbias32(h_length)), grass_blade_unit(hash_lowbias32(h_length ^ 0x9E3779B9u)));
+
+    // what has pressed the ground here, on the blade as it stands
+    let standing = min(grown, surfel.clear_height);
+
+    // a push under half a step of the record's lean is no push
+    let pushed = grass_press_pushed(world, standing, species.wind.w, frame, 0.5 * GRASS_BLADE_LEAN_STEP);
+
+    let bent = grass_blade_bend(rest, grown, wind, species.wind, grass_blade_sway(frequency, grass_clock.whole, grass_clock.fraction), offsets, pushed.now);
+    let bent_previous = grass_blade_bend(rest, grown, wind_previous, species.wind, grass_blade_sway(frequency, grass_clock.previous_whole, grass_clock.previous_fraction), offsets, pushed.before);
+
+    (*blade).root = root;
+    (*blade).surface = cell.surface;
+    (*blade).species = cover.species;
+    (*blade).length = standing * fade;
+    (*blade).width = species.shape.y;
+    (*blade).facing = bent.facing;
+    (*blade).lean = bent.lean;
+    (*blade).curl = bent.curl;
+    (*blade).ground = surfel.normal;
+    (*blade).thinning = shown / content;
+    (*blade).seed = h_length >> 24u;
+    (*blade).facing_previous = bent_previous.facing;
+    (*blade).lean_previous = bent_previous.lean;
+    (*blade).curl_previous = bent_previous.curl;
+
+    return true;
+}
+
+@compute @workgroup_size(${COMPUTE_SHADER_DEFAULT_GROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let thread = folded_workgroup_index(workgroup_id) * ${COMPUTE_SHADER_DEFAULT_GROUP_SIZE}u + lane;
+
+    // the sums are inclusive: a thread belongs to the first cell whose sum is past it
+    let cells = prefix_sums.count;
+    let index = lower_bound_branchless(&prefix_sums.elements, thread + 1u, cells);
+
+    var blade: GrassBlade;
+    var made = false;
+
+    if (index < cells) {
+        var place = thread;
+
+        if (index > 0u) {
+            place -= prefix_sums.elements[index - 1u];
+        }
+
+        made = grass_blade_make(grass_cells[index], index, place, &blade);
+    }
+
+    let slot = subgroup_append_slot(&grass_blades.count, made, settings.blade_capacity);
+
+    if (slot < settings.blade_capacity) {
+        grass_blades.records[slot] = grass_blade_pack(blade);
+    }
+}
+`, [
+            GRASS_CELL_STRUCT.declaration_chunk,
+            chunk_folded_workgroup_index,
+            chunk_lower_bound_branchless,
+            chunk_hash_lowbias32,
+            chunk_subgroup_append_slot,
+            chunk_grass_population,
+            chunk_grass_surface_frame,
+            chunk_grass_surfel,
+            chunk_grass_tile,
+            chunk_grass_blade,
+            chunk_grass_blade_wind,
+            chunk_grass_press,
+            chunk_wind_field_sample,
+            chunk_wind_field_sample_previous,
+            TRANSFORMS_TABLE.chunk_read_field('global'),
+            MESH_GROUND_COVERS_TABLE.chunk_read,
+        ]),
+});