@woosh/meep-engine 3.64.1 → 3.67.0

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

@@ -0,0 +1,46 @@
+/**
+ * The scene database's `grass_surface_params` table.
+ */
+export const GRASS_SURFACE_PARAMS_TABLE: import("../../buffer/table/GPUTypedTableDescriptor.js").GPUTypedTableDescriptor;
+/**
+ * Threads in a workgroup of {@link shader_grass_cell_count}.
+ *
+ * @type {number}
+ */
+export const GRASS_CELL_COUNT_WORKGROUP_SIZE: number;
+/**
+ * Lattice points along a side of a tile of level 0 of a surface with no lattice bits, as a power of two.
+ *
+ * @type {number}
+ */
+export const GRASS_TILE_COLUMNS_LOG2: number;
+/**
+ * Counts the blades each slot of the grass surfaces' pool can owe a view, a thread a slot, and writes the
+ * slot's cell (`GRASS_CELL_STRUCT`) for the threads that make them.
+ *
+ * A slot owes none unless it is baked (or stale, which reads as it was), holds a surfel, lies on a
+ * surface something grows on, and its ground, with a blade's length over it, touches the view's frustum
+ * and the distances its level serves (`grass_level_ring`).
+ *
+ * **Which level makes a blade.** A blade is made by the tile of the level whose ring holds its distance
+ * from the view. Where that tile is not baked, the baked tile a level up makes it, and where the tile a
+ * level up is not baked, the tile a level down makes the blades past its own ring: the cell's flags say
+ * which of its neighbours in level are missing, read here from the directory, so no blade is made twice
+ * and a ring's edge has no gap while a tile waits for its bake.
+ *
+ * **How many.** The cell's count is the points of its block of the surface's blade lattice
+ * (`chunk_grass_population`) whose rank is under the greatest density any blade in the cell can be shown at
+ * (`grass_blade_density`): the surface's densest species, nearest the view, at the steepest the view can
+ * look down on the slot's ground. The steepness is bounded by the eye's height over the slot's lowest
+ * ground at its nearest, and by how far the slot's normals lean (`GRASS_SLOT_NORMAL_SPREAD`). A blade's
+ * thread applies the density where the blade stands; the count only bounds it.
+ *
+ * `grass_cell_counts` is a list of `settings.slot_capacity` counts, slot `s` at `s`; its count is written
+ * by thread 0. Dispatch `ceil(slot_capacity / GRASS_CELL_COUNT_WORKGROUP_SIZE)` groups. A tile whose block
+ * is past level `GRASS_POPULATION_BLOCK_LEVEL_MAX` owes none.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_cell_count: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_grass_cell_count.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_grass_cell_count.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/blade/shader_grass_cell_count.js"],"names":[],"mappings":"AA0CA;;GAEG;AACH,yHAA0F;AAE1F;;;;GAIG;AACH,8CAFU,MAAM,CAEkC;AAElD;;;;GAIG;AACH,sCAFU,MAAM,CAEqD;AAcrE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,sCAFU,aAAa,CAqLpB;8BA/Q2B,+BAA+B"}

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

@@ -0,0 +1,280 @@
+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 { SCENE_DATABASE_RESOURCE } from "../../scene/SCENE_DATABASE_RESOURCE.js";
+import { SCENE_DATABASE_SPEC } from "../../scene/SCENE_DATABASE_SPEC.js";
+import { chunk_aabb3_from_transformed_corners } from "../../shader/chunk/geometry/aabb3/chunk_aabb3_from_transformed_corners.js";
+import { chunk_aabb3_intersects_frustum } from "../../shader/chunk/geometry/aabb3/chunk_aabb3_intersects_frustum.js";
+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 { chunk_grass_population, GRASS_POPULATION_BLOCK_LEVEL_MAX } from "../population/chunk_grass_population.js";
+import { chunk_grass_directory } from "../surface/chunk_grass_directory.js";
+import { chunk_grass_surface_frame } from "../surface/chunk_grass_surface_frame.js";
+import { chunk_grass_surface_window } from "../surface/chunk_grass_surface_window.js";
+import {
+    GRASS_SLOT_HEIGHT_MAX,
+    GRASS_SLOT_HEIGHT_MIN,
+    GRASS_SLOT_LEVEL_LAYER,
+    GRASS_SLOT_NORMAL_SPREAD,
+    GRASS_SLOT_STATE,
+    GRASS_SLOT_STATE_BAKED,
+    GRASS_SLOT_STATE_STALE,
+    GRASS_SLOT_SURFACE,
+    GRASS_SLOT_SURFEL_COUNT,
+    GRASS_SLOT_TILE_X,
+    GRASS_SLOT_TILE_Z,
+    GRASS_TILE_COLUMNS
+} from "../surface/GRASS_SURFACE.js";
+import {
+    GRASS_DIRECTORY_RESOURCE,
+    GRASS_POOL_RESOURCE,
+    GRASS_SURFACE_VIEW_SETTINGS
+} from "../surface/GRASS_SURFACE_VIEW.js";
+import { chunk_grass_blade } from "./chunk_grass_blade.js";
+import {
+    GRASS_CELL_CHILD_MISSING,
+    GRASS_CELL_LATTICE_SHIFT,
+    GRASS_CELL_PARENT_MISSING,
+    GRASS_CELL_STRUCT
+} from "./GRASS_BLADE.js";
+
+/**
+ * The scene database's `grass_surface_params` table.
+ */
+export const GRASS_SURFACE_PARAMS_TABLE = SCENE_DATABASE_SPEC.get('grass_surface_params');
+
+/**
+ * Threads in a workgroup of {@link shader_grass_cell_count}.
+ *
+ * @type {number}
+ */
+export const GRASS_CELL_COUNT_WORKGROUP_SIZE = 64;
+
+/**
+ * Lattice points along a side of a tile of level 0 of a surface with no lattice bits, as a power of two.
+ *
+ * @type {number}
+ */
+export const GRASS_TILE_COLUMNS_LOG2 = Math.log2(GRASS_TILE_COLUMNS);
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", GRASS_SURFACE_VIEW_SETTINGS);
+
+resources.createGroup()
+    .add(CAMERA_RESOURCE)
+    .add(SCENE_DATABASE_RESOURCE)
+    .add(GRASS_POOL_RESOURCE)
+    .add(GRASS_DIRECTORY_RESOURCE)
+    .addStorageBuffer("grass_cell_counts", COLLECTION_U32_STRUCT_READ, true)
+    .addStorageBuffer("grass_cells", WebGPUArray.from(GRASS_CELL_STRUCT), true);
+
+/**
+ * Counts the blades each slot of the grass surfaces' pool can owe a view, a thread a slot, and writes the
+ * slot's cell (`GRASS_CELL_STRUCT`) for the threads that make them.
+ *
+ * A slot owes none unless it is baked (or stale, which reads as it was), holds a surfel, lies on a
+ * surface something grows on, and its ground, with a blade's length over it, touches the view's frustum
+ * and the distances its level serves (`grass_level_ring`).
+ *
+ * **Which level makes a blade.** A blade is made by the tile of the level whose ring holds its distance
+ * from the view. Where that tile is not baked, the baked tile a level up makes it, and where the tile a
+ * level up is not baked, the tile a level down makes the blades past its own ring: the cell's flags say
+ * which of its neighbours in level are missing, read here from the directory, so no blade is made twice
+ * and a ring's edge has no gap while a tile waits for its bake.
+ *
+ * **How many.** The cell's count is the points of its block of the surface's blade lattice
+ * (`chunk_grass_population`) whose rank is under the greatest density any blade in the cell can be shown at
+ * (`grass_blade_density`): the surface's densest species, nearest the view, at the steepest the view can
+ * look down on the slot's ground. The steepness is bounded by the eye's height over the slot's lowest
+ * ground at its nearest, and by how far the slot's normals lean (`GRASS_SLOT_NORMAL_SPREAD`). A blade's
+ * thread applies the density where the blade stands; the count only bounds it.
+ *
+ * `grass_cell_counts` is a list of `settings.slot_capacity` counts, slot `s` at `s`; its count is written
+ * by thread 0. Dispatch `ceil(slot_capacity / GRASS_CELL_COUNT_WORKGROUP_SIZE)` groups. A tile whose block
+ * is past level `GRASS_POPULATION_BLOCK_LEVEL_MAX` owes none.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_cell_count = ComputeShader.from({
+    label: "Grass Cell Count",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+fn grass_cell_layer_baked(surface: u32, level_layer: u32, tile: vec2<i32>) -> bool {
+    let slot = grass_directory_find(surface, level_layer, tile);
+
+    if (slot == GRASS_SLOT_NONE) {
+        return false;
+    }
+
+    let state = atomicLoad(&grass_pool[grass_slot_record(slot) + ${GRASS_SLOT_STATE}u]);
+
+    return state == ${GRASS_SLOT_STATE_BAKED}u || state == ${GRASS_SLOT_STATE_STALE}u;
+}
+
+fn grass_cell_count(slot: u32, cell: ptr<function, ${GRASS_CELL_STRUCT.wgsl_ref}>) -> u32 {
+    let record = grass_slot_record(slot);
+    let state = atomicLoad(&grass_pool[record + ${GRASS_SLOT_STATE}u]);
+
+    if (state != ${GRASS_SLOT_STATE_BAKED}u && state != ${GRASS_SLOT_STATE_STALE}u) {
+        return 0u;
+    }
+
+    if (atomicLoad(&grass_pool[record + ${GRASS_SLOT_SURFEL_COUNT}u]) == 0u) {
+        return 0u;
+    }
+
+    let surface = atomicLoad(&grass_pool[record + ${GRASS_SLOT_SURFACE}u]);
+    let params = ${GRASS_SURFACE_PARAMS_TABLE.marshalling_method_read}(&scene_database, surface);
+
+    if (params.density <= 0.0 || params.blade_length <= 0.0) {
+        return 0u;
+    }
+
+    let level_layer = atomicLoad(&grass_pool[record + ${GRASS_SLOT_LEVEL_LAYER}u]);
+    let level = level_layer & 0xFFu;
+    let layer = level_layer >> 8u;
+
+    let block_level = ${GRASS_TILE_COLUMNS_LOG2}u + params.lattice_bits + level;
+
+    if (block_level > ${GRASS_POPULATION_BLOCK_LEVEL_MAX}u) {
+        return 0u;
+    }
+
+    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])),
+    );
+
+    // the slot's ground, and the grass over it, in the surface's frame
+    let edge = grass_level_spacing(settings.finest_spacing, level) * f32(GRASS_TILE_COLUMNS);
+    let corner = vec2<f32>(tile) * edge;
+
+    let ground_low = grass_height_of_key(atomicLoad(&grass_pool[record + ${GRASS_SLOT_HEIGHT_MIN}u]));
+    let ground_high = grass_height_of_key(atomicLoad(&grass_pool[record + ${GRASS_SLOT_HEIGHT_MAX}u]));
+
+    let low = vec3<f32>(corner.x, ground_low, corner.y);
+    let high = vec3<f32>(corner.x + edge, ground_high + params.blade_length, corner.y + edge);
+
+    let frame = grass_surface_frame(${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, surface));
+
+    let box = aabb3_from_transformed_corners(array<vec3<f32>, 8>(
+        vec3<f32>(low.x, low.y, low.z),
+        vec3<f32>(high.x, low.y, low.z),
+        vec3<f32>(low.x, high.y, low.z),
+        vec3<f32>(high.x, high.y, low.z),
+        vec3<f32>(low.x, low.y, high.z),
+        vec3<f32>(high.x, low.y, high.z),
+        vec3<f32>(low.x, high.y, high.z),
+        vec3<f32>(high.x, high.y, high.z),
+    ), frame);
+
+    if (!aabb3_intersects_frustum(box, camera.frustum)) {
+        return 0u;
+    }
+
+    let eye = grass_world_to_frame(frame, camera.transform[3].xyz);
+
+    let nearest = length(max(max(low - eye, eye - high), vec3<f32>(0.0)));
+    let farthest = length(max(abs(low - eye), abs(high - eye)));
+
+    // which of the cell's neighbours in level are not there to make their share
+    var flags = params.lattice_bits << ${GRASS_CELL_LATTICE_SHIFT}u;
+
+    let layer_bits = layer << 8u;
+
+    if (level + 1u >= settings.level_count || !grass_cell_layer_baked(surface, (level + 1u) | layer_bits, tile >> vec2<u32>(1u))) {
+        flags |= ${GRASS_CELL_PARENT_MISSING}u;
+    }
+
+    if (level > 0u) {
+        for (var quarter = 0u; quarter < 4u; quarter++) {
+            let child = tile * 2 + vec2<i32>(i32(quarter & 1u), i32(quarter >> 1u));
+
+            if (!grass_cell_layer_baked(surface, (level - 1u) | layer_bits, child)) {
+                flags |= ${GRASS_CELL_CHILD_MISSING}u << quarter;
+            }
+        }
+    }
+
+    // the distances it makes blades at: its ring, and its missing neighbours' share on either side
+    let ring = grass_level_ring(settings, level, params.blade_length);
+    let reach = params.blade_length * settings.focal / settings.shortest_blade;
+
+    let makes_from = select(ring.x, 0.0, (flags & ${GRASS_CELL_CHILD_MISSING * 15}u) != 0u);
+    let makes_to = select(ring.y, reach, (flags & ${GRASS_CELL_PARENT_MISSING}u) != 0u);
+
+    if (makes_from >= makes_to || nearest >= makes_to || farthest < makes_from) {
+        return 0u;
+    }
+
+    // the steepest the view can look at the slot's ground: from over its nearest edge, at its lowest or highest
+    let rise = max(abs(eye.y - ground_low), abs(eye.y - ground_high));
+    let run = length(max(max(low.xz - eye.xz, eye.xz - high.xz), vec2<f32>(0.0)));
+
+    let spread = bitcast<f32>(atomicLoad(&grass_pool[record + ${GRASS_SLOT_NORMAL_SPREAD}u]));
+
+    let sin_elevation = min(rise / max(length(vec2<f32>(rise, run)), 1e-6) + spread, 1.0);
+
+    // a normal that far from upright is at least this upright: |n - up|² = 2 - 2 n.y
+    let ground_up = max(1.0 - 0.5 * spread * spread, 0.0);
+
+    // the densest it can be shown: the least any blade is drawn at, nearest, and what covers most
+    let drawn = grass_blade_drawn_width(settings, params.blade_width_min, nearest);
+
+    let dense = grass_blade_density(settings, params.density, drawn, params.blade_length_min, nearest, sin_elevation, ground_up);
+    let covering = params.cover / drawn;
+
+    let lattice_side = f32(1u << params.lattice_bits) / settings.finest_spacing;
+
+    let share = min(dense, covering) / (lattice_side * lattice_side);
+
+    (*cell).rank = grass_population_block_rank(block_level, tile, surface);
+    (*cell).flags = flags;
+    (*cell).surface = surface;
+    (*cell).level_layer = level_layer;
+    (*cell).tile = tile;
+    (*cell).ring_inner = ring.x;
+    (*cell).ring_outer = ring.y;
+
+    if (share >= 1.0) {
+        return 1u << (2u * block_level);
+    }
+
+    return grass_population_count(block_level, (*cell).rank, grass_population_threshold(share));
+}
+
+@compute @workgroup_size(${GRASS_CELL_COUNT_WORKGROUP_SIZE})
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let slot = id.x;
+
+    if (slot == 0u) {
+        grass_cell_counts.count = settings.slot_capacity;
+    }
+
+    if (slot >= settings.slot_capacity) {
+        return;
+    }
+
+    var cell: ${GRASS_CELL_STRUCT.wgsl_ref};
+
+    grass_cell_counts.elements[slot] = grass_cell_count(slot, &cell);
+    grass_cells[slot] = cell;
+}
+`, [
+            GRASS_CELL_STRUCT.declaration_chunk,
+            chunk_aabb3_from_transformed_corners,
+            chunk_aabb3_intersects_frustum,
+            chunk_grass_surface_frame,
+            chunk_grass_surface_window,
+            chunk_grass_directory,
+            chunk_grass_population,
+            chunk_grass_blade,
+            TRANSFORMS_TABLE.chunk_read_field('global'),
+            GRASS_SURFACE_PARAMS_TABLE.chunk_read,
+        ]),
+});

package/src/shade/renderer/grass/population/chunk_grass_population.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The level of the blocks the population's order starts from: a block of level `l` is a square of `2^l`
+ * lattice points a side, and blocks of this level are ordered each on their own.
+ *
+ * A rank has two bits a level below this one, 32 in all, so no block above level
+ * {@link GRASS_POPULATION_BLOCK_LEVEL_MAX} is enumerated.
+ *
+ * @type {number}
+ */
+export const GRASS_POPULATION_ROOT_LEVEL: number;
+/**
+ * The highest level of a block {@link chunk_grass_population} enumerates: the count of a block of the root
+ * level does not fit a word.
+ *
+ * @type {number}
+ */
+export const GRASS_POPULATION_BLOCK_LEVEL_MAX: number;
+/**
+ * Which points of a lattice are populated, at any density, with no list of them kept: a fixed order of the
+ * lattice's points in which every prefix is spread evenly, and the means to walk a block's points in that
+ * order.
+ *
+ * The lattice is the integer points of a plane. A **block** of level `l` at `block` holds the points
+ * `[block * 2^l, (block + 1) * 2^l)` on each axis, and has four children of level `l - 1`. Every block puts
+ * its children in an order of its own, a hash of the block and a seed. A point's **rank** is read off the
+ * orders of the blocks that hold it: the place of the point among its parent's children is the rank's
+ * most significant two bits, the place of that parent among its own parent's the next two, up to the block
+ * of {@link GRASS_POPULATION_ROOT_LEVEL}. A point is populated at density `t`, a fraction of the lattice's
+ * own, when its rank is under `t * 2^32`.
+ *
+ * Because the first split of any block is the last thing a rank orders by, the `4^m` lowest-ranked points
+ * of a block are one in each of its blocks `m` levels down: a thinned population is a stratified one, at
+ * every density, and thinning further only removes points. A rank is the lattice's and not a block's:
+ * a point has the same rank whichever block it is reached through.
+ *
+ * ```wgsl
+ * fn grass_population_block_rank(level: u32, block: vec2<i32>, seed: u32) -> u32
+ * fn grass_population_point(level: u32, block: vec2<i32>, index: u32, seed: u32) -> vec2<i32>
+ * fn grass_population_rank(level: u32, block_rank: u32, index: u32) -> u32
+ * fn grass_population_count(level: u32, block_rank: u32, threshold: u32) -> u32
+ * fn grass_population_threshold(density: f32) -> u32
+ * ```
+ *
+ * `level` is a block's, in `[1, GRASS_POPULATION_BLOCK_LEVEL_MAX]`; `index` counts a block's points in the
+ * order of their ranks, from 0, and is under `4^level`.
+ *
+ * - `grass_population_block_rank`: the bits every rank in the block ends with, those the blocks above it
+ *   decide: `2 * (GRASS_POPULATION_ROOT_LEVEL - level)` of them.
+ * - `grass_population_point`: the lattice point that is the block's `index`-th.
+ * - `grass_population_rank`: the rank of the block's `index`-th point.
+ * - `grass_population_count`: how many of the block's points have a rank under `threshold`. They are the
+ *   indices under the count.
+ * - `grass_population_threshold`: the threshold of a density, a fraction of the lattice's. At 1 and over it
+ *   keeps all but the 256 highest ranks of the 2^32, which a `f32` cannot tell from all.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_population: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_grass_population.d.ts.map

package/src/shade/renderer/grass/population/chunk_grass_population.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_grass_population.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/population/chunk_grass_population.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,0CAFU,MAAM,CAE8B;AAE9C;;;;;GAKG;AACH,+CAFU,MAAM,CAEgE;AA2BhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,qCAFU,SAAS,CAqFjB;0BAzKwB,oCAAoC"}

package/src/shade/renderer/grass/population/chunk_grass_population.js

@@ -0,0 +1,171 @@
+import { chunk_hash_lowbias32 } from "../../shader/chunk/random/chunk_hash_lowbias32.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The level of the blocks the population's order starts from: a block of level `l` is a square of `2^l`
+ * lattice points a side, and blocks of this level are ordered each on their own.
+ *
+ * A rank has two bits a level below this one, 32 in all, so no block above level
+ * {@link GRASS_POPULATION_BLOCK_LEVEL_MAX} is enumerated.
+ *
+ * @type {number}
+ */
+export const GRASS_POPULATION_ROOT_LEVEL = 16;
+
+/**
+ * The highest level of a block {@link chunk_grass_population} enumerates: the count of a block of the root
+ * level does not fit a word.
+ *
+ * @type {number}
+ */
+export const GRASS_POPULATION_BLOCK_LEVEL_MAX = GRASS_POPULATION_ROOT_LEVEL - 1;
+
+/**
+ * Every order of four children, a child two bits: place `d` of an order is the child `(order >> 2d) & 3`.
+ *
+ * @returns {number[]} 24 bytes
+ */
+function child_orders() {
+    const out = [];
+
+    for (let a = 0; a < 4; a++) {
+        for (let b = 0; b < 4; b++) {
+            for (let c = 0; c < 4; c++) {
+                for (let d = 0; d < 4; d++) {
+                    if (new Set([a, b, c, d]).size === 4) {
+                        out.push(a | (b << 2) | (c << 4) | (d << 6));
+                    }
+                }
+            }
+        }
+    }
+
+    return out;
+}
+
+const ORDERS = child_orders();
+
+/**
+ * Which points of a lattice are populated, at any density, with no list of them kept: a fixed order of the
+ * lattice's points in which every prefix is spread evenly, and the means to walk a block's points in that
+ * order.
+ *
+ * The lattice is the integer points of a plane. A **block** of level `l` at `block` holds the points
+ * `[block * 2^l, (block + 1) * 2^l)` on each axis, and has four children of level `l - 1`. Every block puts
+ * its children in an order of its own, a hash of the block and a seed. A point's **rank** is read off the
+ * orders of the blocks that hold it: the place of the point among its parent's children is the rank's
+ * most significant two bits, the place of that parent among its own parent's the next two, up to the block
+ * of {@link GRASS_POPULATION_ROOT_LEVEL}. A point is populated at density `t`, a fraction of the lattice's
+ * own, when its rank is under `t * 2^32`.
+ *
+ * Because the first split of any block is the last thing a rank orders by, the `4^m` lowest-ranked points
+ * of a block are one in each of its blocks `m` levels down: a thinned population is a stratified one, at
+ * every density, and thinning further only removes points. A rank is the lattice's and not a block's:
+ * a point has the same rank whichever block it is reached through.
+ *
+ * ```wgsl
+ * fn grass_population_block_rank(level: u32, block: vec2<i32>, seed: u32) -> u32
+ * fn grass_population_point(level: u32, block: vec2<i32>, index: u32, seed: u32) -> vec2<i32>
+ * fn grass_population_rank(level: u32, block_rank: u32, index: u32) -> u32
+ * fn grass_population_count(level: u32, block_rank: u32, threshold: u32) -> u32
+ * fn grass_population_threshold(density: f32) -> u32
+ * ```
+ *
+ * `level` is a block's, in `[1, GRASS_POPULATION_BLOCK_LEVEL_MAX]`; `index` counts a block's points in the
+ * order of their ranks, from 0, and is under `4^level`.
+ *
+ * - `grass_population_block_rank`: the bits every rank in the block ends with, those the blocks above it
+ *   decide: `2 * (GRASS_POPULATION_ROOT_LEVEL - level)` of them.
+ * - `grass_population_point`: the lattice point that is the block's `index`-th.
+ * - `grass_population_rank`: the rank of the block's `index`-th point.
+ * - `grass_population_count`: how many of the block's points have a rank under `threshold`. They are the
+ *   indices under the count.
+ * - `grass_population_threshold`: the threshold of a density, a fraction of the lattice's. At 1 and over it
+ *   keeps all but the 256 highest ranks of the 2^32, which a `f32` cannot tell from all.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_population = CodeChunk.from(
+    //language=WGSL
+    `
+const GRASS_POPULATION_ROOT_LEVEL: u32 = ${GRASS_POPULATION_ROOT_LEVEL}u;
+
+const GRASS_POPULATION_ORDERS = array<u32, 24>(${ORDERS.map(order => order + "u").join(", ")});
+
+// the order a block puts its four children in: child (order >> 2d) & 3 is its d-th
+fn grass_population_order(level: u32, block: vec2<i32>, seed: u32) -> u32 {
+    var h = hash_lowbias32(seed ^ (level * 0x9E3779B9u));
+
+    h = hash_lowbias32(h ^ bitcast<u32>(block.x));
+    h = hash_lowbias32(h ^ bitcast<u32>(block.y));
+
+    return GRASS_POPULATION_ORDERS[h % 24u];
+}
+
+fn grass_population_block_rank(level: u32, block: vec2<i32>, seed: u32) -> u32 {
+    var rank = 0u;
+    var node = block;
+
+    // a block's place among its parent's children is the most significant of the bits the blocks above decide,
+    // its parent's place the next
+    for (var l = level; l < GRASS_POPULATION_ROOT_LEVEL; l++) {
+        let parent = node >> vec2<u32>(1u);
+        let child = u32(node.x & 1) | (u32(node.y & 1) << 1u);
+
+        let order = grass_population_order(l + 1u, parent, seed);
+
+        // the place of the child in the order
+        var place = 0u;
+
+        for (var d = 1u; d < 4u; d++) {
+            if (((order >> (2u * d)) & 3u) == child) {
+                place = d;
+            }
+        }
+
+        rank |= place << (2u * (GRASS_POPULATION_ROOT_LEVEL - 1u - l));
+
+        node = parent;
+    }
+
+    return rank;
+}
+
+fn grass_population_point(level: u32, block: vec2<i32>, index: u32, seed: u32) -> vec2<i32> {
+    var node = block;
+
+    // the index's lowest two bits choose among the block's own children, the next two among theirs
+    for (var i = 0u; i < GRASS_POPULATION_ROOT_LEVEL; i++) {
+        if (i >= level) {
+            break;
+        }
+
+        let order = grass_population_order(level - i, node, seed);
+        let child = (order >> (2u * ((index >> (2u * i)) & 3u))) & 3u;
+
+        node = node * 2 + vec2<i32>(i32(child & 1u), i32(child >> 1u));
+    }
+
+    return node;
+}
+
+fn grass_population_rank(level: u32, block_rank: u32, index: u32) -> u32 {
+    // the index's lowest two bits are the block's own split, the least significant of its own: the index as it is
+    return (index << (2u * (GRASS_POPULATION_ROOT_LEVEL - level))) | block_rank;
+}
+
+fn grass_population_count(level: u32, block_rank: u32, threshold: u32) -> u32 {
+    let shift = 2u * (GRASS_POPULATION_ROOT_LEVEL - level);
+
+    // the block's own bits under the threshold's, and one more where the threshold's own bits are met and its rest is past the block's
+    return (threshold >> shift) + u32((threshold & ((1u << shift) - 1u)) > block_rank);
+}
+
+fn grass_population_threshold(density: f32) -> u32 {
+    // the largest f32 under 1 is 2^-24 short of it
+    return u32(clamp(density, 0.0, 0.99999994) * 4294967296.0);
+}
+`, [
+        chunk_hash_lowbias32,
+    ]
+);

package/src/shade/renderer/grass/press/GPUGrassPress.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The press field on the device (`GRASS_PRESS.js`): the field, its window and clock, and the passes that
+ * write it from the scene's fluid obstacles.
+ *
+ * Each frame: {@link update} once, with the scene's clock; then {@link graph_stamp} for every view that
+ * reads the field, before the pass that reads it, which reads the resource it answers with and takes the
+ * window from {@link bind}.
+ *
+ * The obstacles are the GPU fluid's: the rows of its forcing's obstacle table, whose database the passes
+ * bind. While a scene has no fluid, or its fluid no obstacle, nothing is stamped and the field keeps what
+ * it holds.
+ *
+ * The field has one window, which follows the first view a frame stamps for. It lies where that view
+ * looks: about the eye for a view that looks straight down, and ahead of it, the eye on its near edge, for
+ * one that looks level, moved along the way the view looks over the ground by that much of half its side.
+ */
+export class GPUGrassPress {
+    /**
+     * Offer the pipelines the field's passes run — see {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: PipelineEnquiry): void;
+    /**
+     * @param {GraphicsContext} graphics
+     */
+    constructor(graphics: GraphicsContext);
+    /**
+     * Whether obstacles press grass. While false nothing is stamped and nothing reads as pressed.
+     * @type {boolean}
+     */
+    enabled: boolean;
+    /**
+     * A cell's side, metres: how fine the edge of a press is. The window is
+     * `GRASS_PRESS_WINDOW_CELLS` of them a side. Changing it empties the field.
+     * @type {number}
+     */
+    spacing: number;
+    /**
+     * The field on the device. Null before the first {@link update}, and replaced when {@link spacing}
+     * changes.
+     *
+     * @returns {GPUBuffer|null}
+     */
+    get field_buffer(): any;
+    /**
+     * The window and clock on the device. Null before the first {@link update}.
+     *
+     * @returns {GPUBuffer|null}
+     */
+    get window_buffer(): any;
+    /**
+     * Begin a frame: move the press's clock on, and make the field if there is none or its cells have
+     * another size than {@link spacing}, which leaves it with no press.
+     *
+     * @param {number} time_delta_seconds how far the scene's clock has moved since the last call
+     */
+    update(time_delta_seconds: number): void;
+    /**
+     * Record the frame's stamp, and answer with the field as a resource of `graph` for the passes that
+     * read it.
+     *
+     * The first call of a frame puts the window about its view, lists the fluid's obstacles by the
+     * window's tiles, and writes the cells under them. Later calls, other views', record nothing and
+     * answer with the same field.
+     *
+     * Nothing is stamped while the field is off, or `forcing` is null or holds no obstacle.
+     *
+     * @param {object} options
+     * @param {FrameGraph} options.graph
+     * @param {GPUViewContext} options.view the view the window follows; its scene is the obstacles' scene
+     * @param {GPUFluidForcing|null} options.forcing the scene's GPU fluid forcing, whose obstacle table is read
+     * @returns {number} the field, a resource of `graph`
+     */
+    graph_stamp({ graph, view, forcing }: {
+        graph: FrameGraph;
+        view: GPUViewContext;
+        forcing: GPUFluidForcing | null;
+    }): number;
+    /**
+     * Put the field's window and clock into a dispatch's bindings as `grass_press_window`, which
+     * `chunk_grass_press` reads. The field itself, `grass_press`, is the resource {@link graph_stamp}
+     * answered with.
+     *
+     * @param {Object} bindings
+     */
+    bind(bindings: any): void;
+    /**
+     * Let go of everything on the device. The field's presses go with it.
+     */
+    destroy(): void;
+    #private;
+}
+export type FrameGraph = import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
+export type GPUFluidForcing = import("../../fluid/forcing/GPUFluidForcing.js").GPUFluidForcing;
+export type GraphicsContext = import("../../GraphicsContext.js").GraphicsContext;
+export type GPUViewContext = import("../../view/GPUViewContext.js").GPUViewContext;
+//# sourceMappingURL=GPUGrassPress.d.ts.map

package/src/shade/renderer/grass/press/GPUGrassPress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GPUGrassPress.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/press/GPUGrassPress.js"],"names":[],"mappings":"AAyCA;;;;;;;;;;;;;;;GAeG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAKzB;IAgFD;;OAEG;IACH,sBAFW,eAAe,EAOzB;IAtFD;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf;;;;OAIG;IACH,SAFU,MAAM,CAEA;IA6EhB;;;;;OAKG;IACH,wBAEC;IAED;;;;OAIG;IACH,yBAEC;IAED;;;;;OAKG;IACH,2BAFW,MAAM,QAgDhB;IAED;;;;;;;;;;;;;;;OAeG;IACH;QAL+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,OAAO,EAArC,eAAe,GAAC,IAAI;QAClB,MAAM,CAiHlB;IAoDD;;;;;;OAMG;IACH,0BAEC;IAED;;OAEG;IACH,gBAWC;;CACJ;yBAlaY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,6CAA6C,EAAE,eAAe;8BACrE,OAAO,wCAAwC,EAAE,eAAe;8BAChE,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc"}