@woosh/meep-engine 3.64.0 → 3.65.0

package/src/shade/renderer/grass/press/GRASS_PRESS.js

@@ -0,0 +1,217 @@
+import { f32, u32, vec2i } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * The press field: where obstacles have pressed grass down, kept on the device.
+ *
+ * The ground is cut into square **cells** over the world's x and z, `spacing` metres a side. An obstacle
+ * over a cell leaves a **press** in it: the heights the obstacle spans on the vertical line through the
+ * cell's middle, its velocity over the ground there, and when. A blade leans as far as a press leaves it no
+ * room to stand, and from the press's time on stands back up (`chunk_grass_press`). Nothing sweeps the
+ * field: a cell is written only while an obstacle is over it.
+ *
+ * **A cell remembers two presses**, which together are its **state**: the *latest*, and the *deepest* of
+ * the contact the latest is part of, a contact being the stamps of the field, one after another, in which
+ * something is over the cell. Both are needed. Whatever rolls or steps over a cell leaves it rim last, so the latest
+ * press of a contact is too high to hold anything down; and whatever comes down on a cell and then lingers
+ * above it holds the grass as low as it lingers long after how low it first came has been stood back up
+ * from. A blade is held by whichever of the two holds it further.
+ *
+ * It is exact for something that comes down on a cell and goes. Where it lingers higher than it has been
+ * and then goes, what is remembered is how low it first came and how it left, not how it lingered.
+ *
+ * **A cell keeps the state it had before its last stamp** beside the one it has, so that a blade can be
+ * drawn as it was a frame ago: for a cell stamped this frame that is the other state, and for any other
+ * cell the one it has.
+ *
+ * The field holds the cells of a **window**, `GRASS_PRESS_WINDOW_CELLS` a side, about a view. A cell has
+ * one place in the field wherever the window is, its coordinates wrapped by the window's side, and a
+ * place says which cell it holds, so a place the window has moved away from and come back to with
+ * another cell is never read as that cell's. The window's side, a tile's and the tiles' count are powers
+ * of two, so that wrapping is a mask.
+ *
+ * Each frame the obstacles over the window are listed by the **tiles** they stand over
+ * (`shader_grass_press_mark`), `GRASS_PRESS_TILE_CELLS` cells a side, and every cell of every tile that
+ * has an obstacle is written by a thread of its own (`shader_grass_press_stamp`).
+ *
+ * **A tile remembers when an obstacle was last near it**, one word, at the front of the field. Most grass
+ * is nowhere near a press, and a blade whose tile was last near an obstacle too long ago for any press to
+ * still show reads that word and none of its cells.
+ *
+ * Times are 32-bit ticks of the press's clock: a press is read rightly for 2³¹ ticks after it was made,
+ * 24 days.
+ *
+ * What is ground of a grass surface presses nothing: the grass on it stands on it, and other obstacles
+ * stand on it too. An obstacle that stands in for ground and is not to flatten the grass about it is made
+ * a member of the surface.
+ */
+
+/**
+ * Cells along a tile's side, as a power of two.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_TILE_CELLS_LOG2 = 4;
+
+/**
+ * Cells along a tile's side.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_TILE_CELLS = 1 << GRASS_PRESS_TILE_CELLS_LOG2;
+
+/**
+ * Tiles along the window's side, as a power of two.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_WINDOW_TILES_LOG2 = 4;
+
+/**
+ * Tiles along the window's side.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_WINDOW_TILES = 1 << GRASS_PRESS_WINDOW_TILES_LOG2;
+
+/**
+ * Cells along the window's side, as a power of two.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_WINDOW_CELLS_LOG2 = GRASS_PRESS_TILE_CELLS_LOG2 + GRASS_PRESS_WINDOW_TILES_LOG2;
+
+/**
+ * Cells along the window's side.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_WINDOW_CELLS = 1 << GRASS_PRESS_WINDOW_CELLS_LOG2;
+
+/**
+ * Obstacles a tile lists at most: what a cell's thread walks. A tile more obstacles stand over is
+ * pressed by the first that many to list themselves.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_TILE_CANDIDATES = 16;
+
+/**
+ * Steps of the press's clock in a second.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_TICKS_PER_SECOND = 1024;
+
+/**
+ * Words a press takes.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_WORDS = 4;
+
+/** Press word: when, in ticks of the press's clock. */
+export const GRASS_PRESS_TIME = 0;
+
+/** Press word: the lowest height of the obstacle on the cell's line, the bits of a `f32`. */
+export const GRASS_PRESS_BOTTOM = 1;
+
+/** Press word: the highest, the bits of a `f32`. */
+export const GRASS_PRESS_TOP = 2;
+
+/** Press word: the obstacle's velocity along x and along z at the foot of its span, two half floats. */
+export const GRASS_PRESS_VELOCITY = 3;
+
+/**
+ * Words a state takes: whose press the latest is, the latest, and the deepest of its contact.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_STATE_WORDS = 1 + 2 * GRASS_PRESS_WORDS;
+
+/** State word: the `transforms` row of the latest press's obstacle, plus one; 0 for a state that holds nothing. */
+export const GRASS_PRESS_STATE_NODE = 0;
+
+/** State word: the first of the latest press's. */
+export const GRASS_PRESS_STATE_LATEST = 1;
+
+/** State word: the first of the deepest press's. */
+export const GRASS_PRESS_STATE_DEEPEST = GRASS_PRESS_STATE_LATEST + GRASS_PRESS_WORDS;
+
+/**
+ * Words a cell takes in the field: its tag, and its two states.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_CELL_WORDS = 1 + 2 * GRASS_PRESS_STATE_WORDS;
+
+/**
+ * Cell word: the cell's tag. Its low {@link GRASS_PRESS_TAG_CURRENT_SHIFT} bits say which cell this is,
+ * `grass_press_page`; the bits above which state is the cell's, 1 or 2, the other being the one it had
+ * before its last stamp, or 0 for a cell nothing has pressed.
+ */
+export const GRASS_PRESS_CELL_TAG = 0;
+
+/**
+ * Where in a cell's tag the number of its state is: above the page.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_TAG_CURRENT_SHIFT = 30;
+
+/** Cell word: the first of state 1's; state 2's follow. */
+export const GRASS_PRESS_CELL_STATES = 1;
+
+/**
+ * Field word: the first of the window's tiles' words, one a tile, by the tile's place among the window's.
+ * The clock's time when an obstacle last stood within a cell of the tile; 0 for never, a time of 0 being
+ * written as 1.
+ */
+export const GRASS_PRESS_FIELD_TILES = 0;
+
+/** Field word: the first of the cells'. */
+export const GRASS_PRESS_FIELD_CELLS = GRASS_PRESS_FIELD_TILES + GRASS_PRESS_WINDOW_TILES ** 2;
+
+/**
+ * Words in the field.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_FIELD_WORDS = GRASS_PRESS_FIELD_CELLS + GRASS_PRESS_WINDOW_CELLS ** 2 * GRASS_PRESS_CELL_WORDS;
+
+/**
+ * Words of the frame's tile jobs (`shader_grass_press_mark` writes them, `shader_grass_press_stamp` reads
+ * them): the stamp's indirect dispatch, three words and one unused; then for each of the window's tiles how
+ * many obstacles listed themselves; then the tiles that have any, in the order they were first listed;
+ * then each tile's list, `GRASS_PRESS_TILE_CANDIDATES` rows of the fluid's obstacle table.
+ */
+export const GRASS_PRESS_JOBS_COMMAND = 0;
+
+export const GRASS_PRESS_JOBS_COUNTS = 4;
+
+export const GRASS_PRESS_JOBS_TILES = GRASS_PRESS_JOBS_COUNTS + GRASS_PRESS_WINDOW_TILES ** 2;
+
+export const GRASS_PRESS_JOBS_LISTS = GRASS_PRESS_JOBS_TILES + GRASS_PRESS_WINDOW_TILES ** 2;
+
+export const GRASS_PRESS_JOBS_WORDS = GRASS_PRESS_JOBS_LISTS + GRASS_PRESS_WINDOW_TILES ** 2 * GRASS_PRESS_TILE_CANDIDATES;
+
+/**
+ * The press field's window and clock, as every pass that touches the field reads them.
+ *
+ * - `corner`: the window's first cell along x and along z, a multiple of `GRASS_PRESS_TILE_CELLS`.
+ * - `spacing`: a cell's side in metres. Zero while there is no field: nothing is pressed.
+ * - `now`, `previous`: the press's clock at this frame and at the frame before, in ticks.
+ * - `stamped`: the clock when the field was stamped the time before this one. It is `previous` where
+ *   every frame of the clock stamps, and earlier where frames went by unstamped.
+ * - `row_count`: obstacle rows the frame lists, for the pass that marks tiles.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_PRESS_WINDOW_STRUCT = WebGPUStruct.from({
+    corner: vec2i,
+    spacing: f32,
+    now: u32,
+    previous: u32,
+    stamped: u32,
+    row_count: u32,
+}, "GrassPressWindow");

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

@@ -0,0 +1,65 @@
+/**
+ * The press field (`GRASS_PRESS.js`) as a shader reads it: a cell's place, a press, and what the presses
+ * about a blade push it by.
+ *
+ * ```wgsl
+ * struct GrassPress {
+ *     time: u32,              // when, in ticks
+ *     bottom: f32,            // the heights the obstacle spans on the cell's line, in the world
+ *     top: f32,
+ *     velocity: vec2<f32>,    // the obstacle's, along the world's x and z, m/s
+ * }
+ *
+ * struct GrassPressPush {
+ *     now: vec3<f32>,
+ *     before: vec3<f32>,
+ * }
+ *
+ * fn grass_press_cell(position_xz: vec2<f32>, spacing: f32) -> vec2<i32>
+ * fn grass_press_slot(cell: vec2<i32>) -> u32
+ * fn grass_press_page(cell: vec2<i32>) -> u32
+ * fn grass_press_tile(cell: vec2<i32>) -> u32
+ * fn grass_press_state(slot: u32, which: u32) -> u32
+ * fn grass_press_pack(press: GrassPress) -> array<u32, 4>
+ * fn grass_press_read(at: u32) -> GrassPress
+ * fn grass_press_held(press: GrassPress, ticks: u32, root_height: f32, blade_length: f32, recovery: f32) -> f32
+ * fn grass_press_pushed(position: vec3<f32>, blade_length: f32, recovery: f32, frame: mat4x4<f32>, least: f32) -> GrassPressPush
+ * ```
+ *
+ * Reads `grass_press`, the field as `array<u32>`, and `grass_press_window`
+ * (`GRASS_PRESS_WINDOW_STRUCT`), which the enclosing shader binds.
+ *
+ * **A cell's place.** `grass_press_cell` is the cell a point of ground is in; `grass_press_slot` the
+ * first word of the cell's place in the field, its coordinates wrapped by the window's side;
+ * `grass_press_page` which of the cells that share the place it is, the low bits of the tag a place
+ * holds; `grass_press_state` the first word of a place's state 1 or 2; `grass_press_tile` the place
+ * of the cell's tile among the window's, which is where in the field the tile's word is.
+ *
+ * **How far a press holds a blade over** (`grass_press_held`), as an angle from upright: not at all,
+ * unless the obstacle's span and the blade's share height: its top above the blade's root and its bottom
+ * under the blade's tip as it stands, `blade_length` over `root_height`. Otherwise until the blade's
+ * top is under the obstacle, `acos(clear / length)`, `clear` the room between root and obstacle; and
+ * from the press's time on the blade stands back up, what is left of the angle falling by `e` every
+ * `recovery` seconds. A press later than `ticks` has not happened yet and holds nothing.
+ *
+ * **What a blade is pushed by** (`grass_press_pushed`), now and a frame ago. A cell holds the blade by
+ * whichever of its state's two presses holds it further, and the blade is held by the four cells about its
+ * place, each weighed by how near its middle is, so that a press's edge is a ramp a cell wide. `z` of an
+ * answer is the angle the blade is held over by, the cells' angles so weighed; `xy` the velocity over the
+ * ground of what holds it, the cells' presses' weighed by how far each holds the blade, in the frame of
+ * `frame`, the blade's surface's. Which way the blade goes over is the blade's to say
+ * (`grass_blade_bend`). `position` is the blade's root in the world.
+ *
+ * `now` is at the clock's time, by the state each cell has. `before` is at the clock's previous time: by
+ * the state a cell had before its last stamp, for a cell stamped since that time, and by the state it has
+ * otherwise.
+ *
+ * `least` is the smallest angle the caller can tell from none. Where the blade's tile was last near an
+ * obstacle so long before the clock's previous time that a press that laid the blade flat then would by
+ * now hold it less than `least`, or was never near one, the answer is no push and no cell is read.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_press: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_grass_press.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_grass_press.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/press/chunk_grass_press.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,gCAFU,SAAS,CAgNjB;0BAvSwB,oCAAoC"}

package/src/shade/renderer/grass/press/chunk_grass_press.js

@@ -0,0 +1,296 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_grass_surface_frame } from "../surface/chunk_grass_surface_frame.js";
+import {
+    GRASS_PRESS_BOTTOM,
+    GRASS_PRESS_CELL_STATES,
+    GRASS_PRESS_CELL_TAG,
+    GRASS_PRESS_CELL_WORDS,
+    GRASS_PRESS_FIELD_CELLS,
+    GRASS_PRESS_FIELD_TILES,
+    GRASS_PRESS_STATE_DEEPEST,
+    GRASS_PRESS_STATE_LATEST,
+    GRASS_PRESS_STATE_NODE,
+    GRASS_PRESS_STATE_WORDS,
+    GRASS_PRESS_TAG_CURRENT_SHIFT,
+    GRASS_PRESS_TICKS_PER_SECOND,
+    GRASS_PRESS_TILE_CELLS_LOG2,
+    GRASS_PRESS_TIME,
+    GRASS_PRESS_TOP,
+    GRASS_PRESS_VELOCITY,
+    GRASS_PRESS_WINDOW_CELLS,
+    GRASS_PRESS_WINDOW_CELLS_LOG2,
+    GRASS_PRESS_WINDOW_STRUCT,
+    GRASS_PRESS_WINDOW_TILES,
+    GRASS_PRESS_WINDOW_TILES_LOG2,
+    GRASS_PRESS_WORDS
+} from "./GRASS_PRESS.js";
+
+/**
+ * The press field (`GRASS_PRESS.js`) as a shader reads it: a cell's place, a press, and what the presses
+ * about a blade push it by.
+ *
+ * ```wgsl
+ * struct GrassPress {
+ *     time: u32,              // when, in ticks
+ *     bottom: f32,            // the heights the obstacle spans on the cell's line, in the world
+ *     top: f32,
+ *     velocity: vec2<f32>,    // the obstacle's, along the world's x and z, m/s
+ * }
+ *
+ * struct GrassPressPush {
+ *     now: vec3<f32>,
+ *     before: vec3<f32>,
+ * }
+ *
+ * fn grass_press_cell(position_xz: vec2<f32>, spacing: f32) -> vec2<i32>
+ * fn grass_press_slot(cell: vec2<i32>) -> u32
+ * fn grass_press_page(cell: vec2<i32>) -> u32
+ * fn grass_press_tile(cell: vec2<i32>) -> u32
+ * fn grass_press_state(slot: u32, which: u32) -> u32
+ * fn grass_press_pack(press: GrassPress) -> array<u32, 4>
+ * fn grass_press_read(at: u32) -> GrassPress
+ * fn grass_press_held(press: GrassPress, ticks: u32, root_height: f32, blade_length: f32, recovery: f32) -> f32
+ * fn grass_press_pushed(position: vec3<f32>, blade_length: f32, recovery: f32, frame: mat4x4<f32>, least: f32) -> GrassPressPush
+ * ```
+ *
+ * Reads `grass_press`, the field as `array<u32>`, and `grass_press_window`
+ * (`GRASS_PRESS_WINDOW_STRUCT`), which the enclosing shader binds.
+ *
+ * **A cell's place.** `grass_press_cell` is the cell a point of ground is in; `grass_press_slot` the
+ * first word of the cell's place in the field, its coordinates wrapped by the window's side;
+ * `grass_press_page` which of the cells that share the place it is, the low bits of the tag a place
+ * holds; `grass_press_state` the first word of a place's state 1 or 2; `grass_press_tile` the place
+ * of the cell's tile among the window's, which is where in the field the tile's word is.
+ *
+ * **How far a press holds a blade over** (`grass_press_held`), as an angle from upright: not at all,
+ * unless the obstacle's span and the blade's share height: its top above the blade's root and its bottom
+ * under the blade's tip as it stands, `blade_length` over `root_height`. Otherwise until the blade's
+ * top is under the obstacle, `acos(clear / length)`, `clear` the room between root and obstacle; and
+ * from the press's time on the blade stands back up, what is left of the angle falling by `e` every
+ * `recovery` seconds. A press later than `ticks` has not happened yet and holds nothing.
+ *
+ * **What a blade is pushed by** (`grass_press_pushed`), now and a frame ago. A cell holds the blade by
+ * whichever of its state's two presses holds it further, and the blade is held by the four cells about its
+ * place, each weighed by how near its middle is, so that a press's edge is a ramp a cell wide. `z` of an
+ * answer is the angle the blade is held over by, the cells' angles so weighed; `xy` the velocity over the
+ * ground of what holds it, the cells' presses' weighed by how far each holds the blade, in the frame of
+ * `frame`, the blade's surface's. Which way the blade goes over is the blade's to say
+ * (`grass_blade_bend`). `position` is the blade's root in the world.
+ *
+ * `now` is at the clock's time, by the state each cell has. `before` is at the clock's previous time: by
+ * the state a cell had before its last stamp, for a cell stamped since that time, and by the state it has
+ * otherwise.
+ *
+ * `least` is the smallest angle the caller can tell from none. Where the blade's tile was last near an
+ * obstacle so long before the clock's previous time that a press that laid the blade flat then would by
+ * now hold it less than `least`, or was never near one, the answer is no push and no cell is read.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grass_press = CodeChunk.from(
+    //language=WGSL
+    `
+struct GrassPress {
+    time: u32,
+    bottom: f32,
+    top: f32,
+    velocity: vec2<f32>,
+}
+
+struct GrassPressPush {
+    now: vec3<f32>,
+    before: vec3<f32>,
+}
+
+// the most a press holds a blade over: flat
+const GRASS_PRESS_FLAT = 1.5707963267948966;
+
+fn grass_press_cell(position_xz: vec2<f32>, spacing: f32) -> vec2<i32> {
+    return vec2<i32>(floor(position_xz / spacing));
+}
+
+// a cell's coordinates within the window's side, never negative
+fn grass_press_wrapped(cell: vec2<i32>) -> vec2<i32> {
+    return cell & vec2<i32>(${GRASS_PRESS_WINDOW_CELLS - 1});
+}
+
+fn grass_press_slot(cell: vec2<i32>) -> u32 {
+    let wrapped = grass_press_wrapped(cell);
+
+    return ${GRASS_PRESS_FIELD_CELLS}u + u32(wrapped.y * ${GRASS_PRESS_WINDOW_CELLS} + wrapped.x) * ${GRASS_PRESS_CELL_WORDS}u;
+}
+
+fn grass_press_tile(cell: vec2<i32>) -> u32 {
+    let wrapped = (cell >> vec2<u32>(${GRASS_PRESS_TILE_CELLS_LOG2}u)) & vec2<i32>(${GRASS_PRESS_WINDOW_TILES - 1});
+
+    return u32((wrapped.y << ${GRASS_PRESS_WINDOW_TILES_LOG2}u) | wrapped.x);
+}
+
+fn grass_press_page(cell: vec2<i32>) -> u32 {
+    // how many window sides along each axis, half the page's bits each
+    let page = vec2<u32>(cell >> vec2<u32>(${GRASS_PRESS_WINDOW_CELLS_LOG2}u)) & vec2<u32>(${(1 << (GRASS_PRESS_TAG_CURRENT_SHIFT / 2)) - 1}u);
+
+    return page.x | (page.y << ${GRASS_PRESS_TAG_CURRENT_SHIFT / 2}u);
+}
+
+fn grass_press_state(slot: u32, which: u32) -> u32 {
+    return slot + ${GRASS_PRESS_CELL_STATES}u + (which - 1u) * ${GRASS_PRESS_STATE_WORDS}u;
+}
+
+fn grass_press_pack(press: GrassPress) -> array<u32, ${GRASS_PRESS_WORDS}> {
+    var words: array<u32, ${GRASS_PRESS_WORDS}>;
+
+    words[${GRASS_PRESS_TIME}] = press.time;
+    words[${GRASS_PRESS_BOTTOM}] = bitcast<u32>(press.bottom);
+    words[${GRASS_PRESS_TOP}] = bitcast<u32>(press.top);
+    words[${GRASS_PRESS_VELOCITY}] = pack2x16float(press.velocity);
+
+    return words;
+}
+
+fn grass_press_read(at: u32) -> GrassPress {
+    var press: GrassPress;
+
+    press.time = grass_press[at + ${GRASS_PRESS_TIME}u];
+    press.bottom = bitcast<f32>(grass_press[at + ${GRASS_PRESS_BOTTOM}u]);
+    press.top = bitcast<f32>(grass_press[at + ${GRASS_PRESS_TOP}u]);
+    press.velocity = unpack2x16float(grass_press[at + ${GRASS_PRESS_VELOCITY}u]);
+
+    return press;
+}
+
+fn grass_press_held(
+    press: GrassPress,
+    ticks: u32,
+    root_height: f32,
+    blade_length: f32,
+    recovery: f32,
+) -> f32 {
+    // wholly under the root. One wholly over the tip leaves the blade all its length, and holds it by no angle
+    if (press.top <= root_height) {
+        return 0.0;
+    }
+
+    // the clock wraps, and so does a time after it
+    let age = ticks - press.time;
+
+    if (age >= 0x80000000u) {
+        return 0.0;
+    }
+
+    // the room between root and obstacle, none where the obstacle reaches under the root
+    let clear = press.bottom - root_height;
+    let held = acos(clamp(clear / blade_length, 0.0, 1.0));
+
+    return held * exp(-f32(age) / (${GRASS_PRESS_TICKS_PER_SECOND}.0 * max(recovery, 1e-6)));
+}
+
+// what a state holds a blade by at a time: its obstacle's velocity over the ground times the angle, and the angle
+fn grass_press_state_push(state: u32, ticks: u32, root_height: f32, blade_length: f32, recovery: f32) -> vec3<f32> {
+    let latest = grass_press_read(state + ${GRASS_PRESS_STATE_LATEST}u);
+    let deepest = grass_press_read(state + ${GRASS_PRESS_STATE_DEEPEST}u);
+
+    let by_latest = grass_press_held(latest, ticks, root_height, blade_length, recovery);
+    let by_deepest = grass_press_held(deepest, ticks, root_height, blade_length, recovery);
+
+    if (by_deepest > by_latest) {
+        return vec3<f32>(deepest.velocity * by_deepest, by_deepest);
+    }
+
+    return vec3<f32>(latest.velocity * by_latest, by_latest);
+}
+
+// the obstacles' way over the ground in a frame, from a sum of velocities times angles and of angles
+fn grass_press_carried(frame: mat4x4<f32>, sum: vec3<f32>) -> vec3<f32> {
+    if (sum.z <= 0.0) {
+        return vec3<f32>(0.0);
+    }
+
+    let velocity = grass_world_direction_to_frame(frame, vec3<f32>(sum.x, 0.0, sum.y) * (1.0 / sum.z));
+
+    return vec3<f32>(velocity.xz, sum.z);
+}
+
+fn grass_press_pushed(
+    position: vec3<f32>,
+    blade_length: f32,
+    recovery: f32,
+    frame: mat4x4<f32>,
+    least: f32,
+) -> GrassPressPush {
+    var pushed: GrassPressPush;
+
+    let spacing = grass_press_window.spacing;
+
+    if (spacing <= 0.0) {
+        return pushed;
+    }
+
+    let now = grass_press_window.now;
+    let previous = grass_press_window.previous;
+
+    // when an obstacle was last within a cell of the blade's tile, which is as late as any press the blade reads
+    let touched = grass_press[${GRASS_PRESS_FIELD_TILES}u + grass_press_tile(grass_press_cell(position.xz, spacing))];
+
+    if (touched == 0u) {
+        return pushed;
+    }
+
+    // a tile touched after the clock's previous time was touched a time less than none before it, and is read
+    let since = i32(previous - touched);
+
+    if (f32(since) > ${GRASS_PRESS_TICKS_PER_SECOND}.0 * recovery * log(GRASS_PRESS_FLAT / least)) {
+        return pushed;
+    }
+
+    // the four cells whose middles are about the place
+    let place = position.xz / spacing - vec2<f32>(0.5);
+    let first = vec2<i32>(floor(place));
+    let share = place - floor(place);
+
+    var sum_now = vec3<f32>(0.0);
+    var sum_before = vec3<f32>(0.0);
+
+    for (var i = 0u; i < 4u; i++) {
+        let corner = vec2<i32>(i32(i & 1u), i32(i >> 1u));
+        let cell = first + corner;
+        let slot = grass_press_slot(cell);
+
+        // nothing has pressed most cells: one word says so
+        let tag = grass_press[slot + ${GRASS_PRESS_CELL_TAG}u];
+        let current = tag >> ${GRASS_PRESS_TAG_CURRENT_SHIFT}u;
+
+        if (current == 0u || (tag & ${(2 ** GRASS_PRESS_TAG_CURRENT_SHIFT) - 1}u) != grass_press_page(cell)) {
+            continue;
+        }
+
+        let weight = mix(1.0 - share.x, share.x, f32(corner.x)) * mix(1.0 - share.y, share.y, f32(corner.y));
+
+        let state = grass_press_state(slot, current);
+
+        sum_now += grass_press_state_push(state, now, position.y, blade_length, recovery) * weight;
+
+        // stamped since the frame before: the state it had then is the other one, if that holds anything
+        let stamped = grass_press[state + ${GRASS_PRESS_STATE_LATEST + GRASS_PRESS_TIME}u];
+
+        if ((previous - stamped) < 0x80000000u) {
+            sum_before += grass_press_state_push(state, previous, position.y, blade_length, recovery) * weight;
+        } else {
+            let other = grass_press_state(slot, 3u - current);
+
+            if (grass_press[other + ${GRASS_PRESS_STATE_NODE}u] != 0u) {
+                sum_before += grass_press_state_push(other, previous, position.y, blade_length, recovery) * weight;
+            }
+        }
+    }
+
+    pushed.now = grass_press_carried(frame, sum_now);
+    pushed.before = grass_press_carried(frame, sum_before);
+
+    return pushed;
+}
+`, [
+        GRASS_PRESS_WINDOW_STRUCT.declaration_chunk,
+        chunk_grass_surface_frame,
+    ]
+);

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

@@ -0,0 +1,31 @@
+/**
+ * Threads in a workgroup of {@link shader_grass_press_mark}.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_MARK_WORKGROUP_SIZE: number;
+/**
+ * Lists the frame's obstacles by the tiles of the press field's window they stand over
+ * (`GRASS_PRESS.js`), a thread an obstacle: element `i` of `press_rows` is a row of the fluid's obstacle
+ * table, for `i` under `grass_press_window.row_count`.
+ *
+ * An obstacle stands over the tiles its world box crosses (`fluid_forcing_obstacle_box`), as far as they
+ * are the window's. For each it takes the next place in the tile's list, if the list has one left, and
+ * the first obstacle to list itself in a tile adds the tile to the frame's tiles and one to the count
+ * of workgroups the stamp is dispatched with.
+ *
+ * It also writes the clock's time into the word of every tile of the window that its box comes within a
+ * cell of, at the front of the field, `grass_press`: the tiles whose blades read a cell it may press.
+ *
+ * Two kinds of obstacle list themselves nowhere, and so press nothing. One with no box, a half-space:
+ * there is no end to what it would press. And one whose row is ground of a grass surface (a member, by the
+ * scene's `mesh_ground_covers`): ground does not press what grows on it, and under everything that
+ * stands on it, it would be the lowest obstacle of every cell.
+ *
+ * `press_jobs` is the frame's jobs, its command and its tiles' counts zero on entry.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_press_mark: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_grass_press_mark.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_grass_press_mark.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/press/shader_grass_press_mark.js"],"names":[],"mappings":"AA0BA;;;;GAIG;AACH,8CAFU,MAAM,CAEkC;AAYlD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,sCAFU,aAAa,CAyGpB;8BAlK2B,+BAA+B"}