@woosh/meep-engine 3.64.1 → 3.67.0

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

@@ -0,0 +1,169 @@
+import { FLUID_OBSTACLE_DESCRIPTOR } from "../../fluid/forcing/FLUID_DATABASE_SPEC.js";
+import { chunk_fluid_forcing_leaf } from "../../fluid/forcing/chunk_fluid_forcing_leaf.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 { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.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 {
+    GRASS_PRESS_FIELD_TILES,
+    GRASS_PRESS_JOBS_COMMAND,
+    GRASS_PRESS_JOBS_COUNTS,
+    GRASS_PRESS_JOBS_LISTS,
+    GRASS_PRESS_JOBS_TILES,
+    GRASS_PRESS_TILE_CANDIDATES,
+    GRASS_PRESS_TILE_CELLS,
+    GRASS_PRESS_TILE_CELLS_LOG2,
+    GRASS_PRESS_WINDOW_STRUCT,
+    GRASS_PRESS_WINDOW_TILES,
+    GRASS_PRESS_WINDOW_TILES_LOG2
+} from "./GRASS_PRESS.js";
+
+const MESH_GROUND_COVERS_TABLE = SCENE_DATABASE_SPEC.get('mesh_ground_covers');
+
+/**
+ * Threads in a workgroup of {@link shader_grass_press_mark}.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_MARK_WORKGROUP_SIZE = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("grass_press_window", GRASS_PRESS_WINDOW_STRUCT)
+    .addStorageBuffer("press_rows", WebGPUArray.from(u32))
+    .addStorageBuffer("fluid_database", WebGPUArray.from(u32))
+    .addStorageBuffer("scene_database", WebGPUArray.from(u32))
+    .addStorageBuffer("press_jobs", WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer("grass_press", WebGPUArray.from(atomic_u32), true);
+
+/**
+ * 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.from({
+    label: "Grass Press Mark",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${GRASS_PRESS_MARK_WORKGROUP_SIZE})
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let i = id.x;
+
+    if (i == 0u) {
+        // the stamp is dispatched along x alone
+        atomicStore(&press_jobs[${GRASS_PRESS_JOBS_COMMAND + 1}], 1u);
+        atomicStore(&press_jobs[${GRASS_PRESS_JOBS_COMMAND + 2}], 1u);
+    }
+
+    if (i >= grass_press_window.row_count) {
+        return;
+    }
+
+    let row = press_rows[i];
+    let record = ${FLUID_OBSTACLE_DESCRIPTOR.marshalling_method_read}(&fluid_database, row);
+
+    if (!shape_record_local_bounded(record.shape_kind)) {
+        return;
+    }
+
+    // ground of a grass surface
+    let cover_flags = ${MESH_GROUND_COVERS_TABLE.marshalling_method_read_field('flags')}(&scene_database, record.node);
+
+    if ((cover_flags & ${MESH_GROUND_COVER_FLAG_MEMBER}u) != 0u) {
+        return;
+    }
+
+    let global = ${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, record.node);
+    let box = fluid_forcing_obstacle_box(record, global, 0.0);
+
+    // the tiles the box crosses, and the window's, which are all that is marked
+    let tile_side = grass_press_window.spacing * ${GRASS_PRESS_TILE_CELLS}.0;
+
+    let window_low = grass_press_window.corner >> vec2<u32>(${GRASS_PRESS_TILE_CELLS_LOG2}u);
+    let window_high = window_low + vec2<i32>(${GRASS_PRESS_WINDOW_TILES - 1});
+
+    let low = vec2<i32>(floor(box.low.xz / tile_side));
+    let high = vec2<i32>(floor(box.high.xz / tile_side));
+
+    // the tiles it is within a cell of: a blade reads the cells about it
+    let reach = grass_press_window.spacing;
+
+    let near_low = max(vec2<i32>(floor((box.low.xz - reach) / tile_side)), window_low);
+    let near_high = min(vec2<i32>(floor((box.high.xz + reach) / tile_side)), window_high);
+
+    if (near_low.x > near_high.x || near_low.y > near_high.y) {
+        return;
+    }
+
+    // a time of zero would read as never
+    let time = max(grass_press_window.now, 1u);
+
+    for (var dz = 0; dz < ${GRASS_PRESS_WINDOW_TILES}; dz++) {
+        if (near_low.y + dz > near_high.y) {
+            break;
+        }
+
+        for (var dx = 0; dx < ${GRASS_PRESS_WINDOW_TILES}; dx++) {
+            if (near_low.x + dx > near_high.x) {
+                break;
+            }
+
+            let at = near_low + vec2<i32>(dx, dz);
+
+            // a tile's place among the window's is its coordinates wrapped by the window's side
+            let wrapped = at & vec2<i32>(${GRASS_PRESS_WINDOW_TILES - 1});
+            let tile = u32((wrapped.y << ${GRASS_PRESS_WINDOW_TILES_LOG2}u) | wrapped.x);
+
+            atomicStore(&grass_press[${GRASS_PRESS_FIELD_TILES}u + tile], time);
+
+            if (at.x < low.x || at.x > high.x || at.y < low.y || at.y > high.y) {
+                // near it, not under it
+                continue;
+            }
+
+            let listed = atomicAdd(&press_jobs[${GRASS_PRESS_JOBS_COUNTS}u + tile], 1u);
+
+            if (listed == 0u) {
+                let job = atomicAdd(&press_jobs[${GRASS_PRESS_JOBS_COMMAND}], 1u);
+
+                atomicStore(&press_jobs[${GRASS_PRESS_JOBS_TILES}u + job], tile);
+            }
+
+            if (listed < ${GRASS_PRESS_TILE_CANDIDATES}u) {
+                atomicStore(&press_jobs[${GRASS_PRESS_JOBS_LISTS}u + tile * ${GRASS_PRESS_TILE_CANDIDATES}u + listed], row);
+            }
+        }
+    }
+}
+`, [
+            GRASS_PRESS_WINDOW_STRUCT.declaration_chunk,
+            chunk_fluid_forcing_leaf,
+            FLUID_OBSTACLE_DESCRIPTOR.chunk_read,
+            TRANSFORMS_TABLE.chunk_read_field('global'),
+            MESH_GROUND_COVERS_TABLE.chunk_read_field('flags'),
+        ]),
+});

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

@@ -0,0 +1,27 @@
+/**
+ * Writes the press field under the frame's obstacles (`GRASS_PRESS.js`): a workgroup a tile that has an
+ * obstacle listed, a thread a cell of it. Dispatched with the command at the front of `press_jobs`, which
+ * {@link shader_grass_press_mark} wrote.
+ *
+ * A cell's thread walks its tile's list and asks each obstacle what it spans on the vertical line through
+ * the cell's middle (`fluid_obstacle_record_line_span`). Of those that cross the line it keeps the one
+ * that reaches lowest, and that is the cell's press for the frame: the heights of the span, the
+ * obstacle's velocity over the ground at its foot, and the clock's time. A cell no obstacle crosses is left
+ * as it is.
+ *
+ * The press is written as the latest of a new state for the cell, into the place of the state the cell had
+ * before the one it has, which the one it has now becomes. The new state's deepest press is the one the
+ * cell's state had, where that state was written by the stamp before this one
+ * (`grass_press_window.stamped`) and its deepest reaches lower than this press: the cell is still in the
+ * same contact, and has been pressed further in it. Otherwise it is this
+ * press. A cell stamped a second time at one time of the clock has its state written again in place, so
+ * the state before it stays the one before that time. A cell whose place held another cell starts with
+ * nothing.
+ *
+ * One press a cell and frame: where two obstacles stand over a cell at two heights, only the lower presses.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_press_stamp: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_grass_press_stamp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_grass_press_stamp.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/press/shader_grass_press_stamp.js"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,uCAFU,aAAa,CA2HpB;8BAlL2B,+BAA+B"}

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

@@ -0,0 +1,183 @@
+import { chunk_fluid_obstacle_record } from "../../../../engine/physics/fluid/obstacle/chunk_fluid_obstacle_record.js";
+import { FLUID_OBSTACLE_DESCRIPTOR, FLUID_OBSTACLE_PLANE_DESCRIPTOR } from "../../fluid/forcing/FLUID_DATABASE_SPEC.js";
+import { TRANSFORMS_TABLE } from "../../scene/chunk_scene_database_access.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";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_grass_press } from "./chunk_grass_press.js";
+import {
+    GRASS_PRESS_CELL_TAG,
+    GRASS_PRESS_JOBS_COUNTS,
+    GRASS_PRESS_JOBS_LISTS,
+    GRASS_PRESS_JOBS_TILES,
+    GRASS_PRESS_STATE_DEEPEST,
+    GRASS_PRESS_STATE_LATEST,
+    GRASS_PRESS_STATE_NODE,
+    GRASS_PRESS_TAG_CURRENT_SHIFT,
+    GRASS_PRESS_TILE_CANDIDATES,
+    GRASS_PRESS_TILE_CELLS,
+    GRASS_PRESS_TILE_CELLS_LOG2,
+    GRASS_PRESS_TIME,
+    GRASS_PRESS_WINDOW_STRUCT,
+    GRASS_PRESS_WINDOW_TILES,
+    GRASS_PRESS_WINDOW_TILES_LOG2,
+    GRASS_PRESS_WORDS
+} from "./GRASS_PRESS.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("grass_press_window", GRASS_PRESS_WINDOW_STRUCT)
+    .addStorageBuffer("press_jobs", WebGPUArray.from(u32))
+    .addStorageBuffer("fluid_database", WebGPUArray.from(u32))
+    .addStorageBuffer("scene_database", WebGPUArray.from(u32))
+    .addStorageBuffer("grass_press", WebGPUArray.from(u32), true);
+
+/**
+ * Writes the press field under the frame's obstacles (`GRASS_PRESS.js`): a workgroup a tile that has an
+ * obstacle listed, a thread a cell of it. Dispatched with the command at the front of `press_jobs`, which
+ * {@link shader_grass_press_mark} wrote.
+ *
+ * A cell's thread walks its tile's list and asks each obstacle what it spans on the vertical line through
+ * the cell's middle (`fluid_obstacle_record_line_span`). Of those that cross the line it keeps the one
+ * that reaches lowest, and that is the cell's press for the frame: the heights of the span, the
+ * obstacle's velocity over the ground at its foot, and the clock's time. A cell no obstacle crosses is left
+ * as it is.
+ *
+ * The press is written as the latest of a new state for the cell, into the place of the state the cell had
+ * before the one it has, which the one it has now becomes. The new state's deepest press is the one the
+ * cell's state had, where that state was written by the stamp before this one
+ * (`grass_press_window.stamped`) and its deepest reaches lower than this press: the cell is still in the
+ * same contact, and has been pressed further in it. Otherwise it is this
+ * press. A cell stamped a second time at one time of the clock has its state written again in place, so
+ * the state before it stays the one before that time. A cell whose place held another cell starts with
+ * nothing.
+ *
+ * One press a cell and frame: where two obstacles stand over a cell at two heights, only the lower presses.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_press_stamp = ComputeShader.from({
+    label: "Grass Press Stamp",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+fn shape_record_plane(index: u32) -> vec4<f32> {
+    return ${FLUID_OBSTACLE_PLANE_DESCRIPTOR.marshalling_method_read_field('plane')}(&fluid_database, index);
+}
+
+@compute @workgroup_size(${GRASS_PRESS_TILE_CELLS}, ${GRASS_PRESS_TILE_CELLS}, 1)
+fn main(
+    @builtin(workgroup_id) workgroup: vec3<u32>,
+    @builtin(local_invocation_id) local: vec3<u32>,
+) {
+    let tile = press_jobs[${GRASS_PRESS_JOBS_TILES}u + workgroup.x];
+
+    // the tile's place among the window's back to the tile it is of, the one of that place inside the window
+    let window_low = grass_press_window.corner >> vec2<u32>(${GRASS_PRESS_TILE_CELLS_LOG2}u);
+    let place = vec2<i32>(i32(tile & ${GRASS_PRESS_WINDOW_TILES - 1}u), i32(tile >> ${GRASS_PRESS_WINDOW_TILES_LOG2}u));
+
+    let world_tile = window_low + ((place - window_low) & vec2<i32>(${GRASS_PRESS_WINDOW_TILES - 1}));
+    let cell = (world_tile << vec2<u32>(${GRASS_PRESS_TILE_CELLS_LOG2}u)) + vec2<i32>(local.xy);
+
+    let middle = (vec2<f32>(cell) + vec2<f32>(0.5)) * grass_press_window.spacing;
+
+    let listed = min(press_jobs[${GRASS_PRESS_JOBS_COUNTS}u + tile], ${GRASS_PRESS_TILE_CANDIDATES}u);
+
+    var found = false;
+    var press: GrassPress;
+    var node = 0u;
+
+    for (var i = 0u; i < ${GRASS_PRESS_TILE_CANDIDATES}u; i++) {
+        if (i >= listed) {
+            break;
+        }
+
+        let row = press_jobs[${GRASS_PRESS_JOBS_LISTS}u + tile * ${GRASS_PRESS_TILE_CANDIDATES}u + i];
+        let record = ${FLUID_OBSTACLE_DESCRIPTOR.marshalling_method_read}(&fluid_database, row);
+        let global = ${TRANSFORMS_TABLE.marshalling_method_read_field('global')}(&scene_database, record.node);
+
+        // up the line from height zero, so a place along it is a height
+        let span = fluid_obstacle_record_line_span(record, global, vec3<f32>(middle.x, 0.0, middle.y), vec3<f32>(0.0, 1.0, 0.0));
+
+        if (span.x > span.y) {
+            continue;
+        }
+
+        if (found && span.x >= press.bottom) {
+            continue;
+        }
+
+        found = true;
+        node = record.node + 1u;
+
+        press.time = grass_press_window.now;
+        press.bottom = span.x;
+        press.top = span.y;
+        press.velocity = fluid_obstacle_record_wall_velocity(record, global, vec3<f32>(middle.x, span.x, middle.y)).xz;
+    }
+
+    if (!found) {
+        return;
+    }
+
+    let slot = grass_press_slot(cell);
+    let page = grass_press_page(cell);
+
+    let tag = grass_press[slot + ${GRASS_PRESS_CELL_TAG}u];
+
+    var current = tag >> ${GRASS_PRESS_TAG_CURRENT_SHIFT}u;
+
+    if ((tag & ${(2 ** GRASS_PRESS_TAG_CURRENT_SHIFT) - 1}u) != page) {
+        // the place was another cell's: this cell has held nothing. Its first state is written below
+        grass_press[grass_press_state(slot, 2u) + ${GRASS_PRESS_STATE_NODE}u] = 0u;
+
+        current = 0u;
+    }
+
+    // the state this frame's is written over, and what the cell's contact has been pressed to
+    var written = 1u;
+    var deepest = press;
+
+    if (current != 0u) {
+        let had = grass_press_state(slot, current);
+        let stamped = grass_press[had + ${GRASS_PRESS_STATE_LATEST + GRASS_PRESS_TIME}u];
+
+        // stamped at this time already: that state again. Else the one before it
+        written = select(3u - current, current, stamped == press.time);
+
+        if (stamped == press.time || stamped == grass_press_window.stamped) {
+            let kept = grass_press_read(had + ${GRASS_PRESS_STATE_DEEPEST}u);
+
+            if (kept.bottom < press.bottom) {
+                deepest = kept;
+            }
+        }
+    }
+
+    let state = grass_press_state(slot, written);
+
+    let latest_words = grass_press_pack(press);
+    let deepest_words = grass_press_pack(deepest);
+
+    grass_press[state + ${GRASS_PRESS_STATE_NODE}u] = node;
+
+    for (var w = 0u; w < ${GRASS_PRESS_WORDS}u; w++) {
+        grass_press[state + ${GRASS_PRESS_STATE_LATEST}u + w] = latest_words[w];
+        grass_press[state + ${GRASS_PRESS_STATE_DEEPEST}u + w] = deepest_words[w];
+    }
+
+    grass_press[slot + ${GRASS_PRESS_CELL_TAG}u] = page | (written << ${GRASS_PRESS_TAG_CURRENT_SHIFT}u);
+}
+`, [
+            GRASS_PRESS_WINDOW_STRUCT.declaration_chunk,
+            chunk_grass_press,
+            chunk_fluid_obstacle_record,
+            FLUID_OBSTACLE_DESCRIPTOR.chunk_read,
+            FLUID_OBSTACLE_PLANE_DESCRIPTOR.chunk_read_field('plane'),
+            TRANSFORMS_TABLE.chunk_read_field('global'),
+        ]),
+});

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

@@ -0,0 +1,193 @@
+/**
+ * Records in the directory of a pool of `slot_capacity` slots: a power of two at least twice the slots,
+ * so the table is never more than half full, and no fewer than its probe limit.
+ *
+ * @param {number} slot_capacity
+ * @returns {number}
+ */
+export function grass_directory_table_size(slot_capacity: number): number;
+/**
+ * How finely a scene's grass surfaces are sampled, and how fast.
+ */
+export class GrassSurfaceSettings {
+    /**
+     * The distance between neighbouring columns of a surface's finest level, in world units: how exactly a
+     * blade's root follows the ground, against the rays that find it and the memory that keeps it.
+     *
+     * @type {number}
+     */
+    finest_spacing: number;
+    /**
+     * The least width a blade is drawn at, in pixels of the view's render resolution. A surface's level
+     * serves the distances at which its spacing spans no more than this.
+     *
+     * @type {number}
+     */
+    narrowest_blade: number;
+    /**
+     * The least length a blade is drawn at, in pixels of the view's render resolution. No tile is asked for
+     * past the distance where its surface's tallest blade spans less.
+     *
+     * @type {number}
+     */
+    shortest_blade: number;
+    /**
+     * The most layers of tiles baked a view a frame, each a workgroup of {@link GRASS_TILE_SURFELS} columns:
+     * how fast ground a view turns towards gets its grass. A frame bakes what it was asked and no more, so
+     * this is the cost of the frame that asks most.
+     *
+     * @type {number}
+     */
+    bake_capacity: number;
+    /**
+     * How many blades a view ray may cross before the grass behind them is left out: the grass's density
+     * where it is seen at a low angle. Lower lets more ground show through.
+     * @type {number}
+     */
+    canopy_opacity: number;
+}
+/**
+ * The grass surfaces of one scene on the device: which surfaces there are, the pool their tiles' surfels
+ * are kept in, and the passes that ask for and bake the tiles a view wants (`GRASS_SURFACE.js`).
+ *
+ * A surface is named by its `transforms` row. Its members are the mesh rows whose `mesh_ground_covers`
+ * record names that row; this class is told only the surface's box and tallest blade.
+ *
+ * Each frame: {@link update} once, then {@link graph_update} for every view that draws grass.
+ */
+export class GPUGrassSurfaces {
+    /**
+     * Offer the pipelines the surfaces' passes run — see {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: PipelineEnquiry): void;
+    /**
+     * @param {GraphicsContext} graphics
+     */
+    constructor(graphics: GraphicsContext);
+    /**
+     * @type {GrassSurfaceSettings}
+     */
+    settings: GrassSurfaceSettings;
+    /**
+     * @returns {number} how many surfaces there are
+     */
+    get surface_count(): number;
+    /**
+     * @returns {number} how many slots the pool has; 0 before the first surface
+     */
+    get slot_capacity(): number;
+    /**
+     * The pool's arena: its counters, then a record a slot (`GRASS_SURFACE.js`). Null before the first
+     * surface, and replaced when the pool grows: read it when a pass runs.
+     *
+     * @returns {GPUBuffer|null}
+     */
+    get pool_buffer(): any;
+    /**
+     * The pool's directory, a `chunk_hash_table_atomic` table. Null before the first surface, and replaced
+     * when the pool grows.
+     *
+     * @returns {GPUBuffer|null}
+     */
+    get directory_buffer(): any;
+    /**
+     * The surfel atlas, a texel a column of a slot (`chunk_grass_surfel`, `grass_slot_texel`). Null before
+     * the first surface, and replaced when the pool grows.
+     *
+     * @returns {GPUTexture|null}
+     */
+    get atlas(): any;
+    /**
+     * A view of the surfel atlas for a pass to bind. Null before the first surface; ask again each frame.
+     *
+     * @returns {GPUTextureView|null}
+     */
+    get atlas_view(): any;
+    /**
+     * The most slots the pool can grow to on this device: what the surfel atlas can hold. 0 before the
+     * first surface.
+     *
+     * @returns {number}
+     */
+    get slot_capacity_limit(): number;
+    /**
+     * The list of surface records (`GRASS_SURFACE_RECORD_STRUCT`), {@link surface_count} of them. Null
+     * before the first surface, and replaced when the list grows.
+     *
+     * @returns {GPUBuffer|null}
+     */
+    get surfaces_buffer(): any;
+    /**
+     * Whether `node` is a surface here.
+     *
+     * @param {number} node a `transforms` row
+     * @returns {boolean}
+     */
+    has(node: number): boolean;
+    /**
+     * Make a surface of a `transforms` row, or change the one it is.
+     *
+     * @param {number} node the surface's `transforms` row; not the scene's root
+     * @param {ArrayLike<number>} low the least corner of a box, in the surface's frame, that holds every member
+     * @param {ArrayLike<number>} high the box's greatest corner
+     * @param {number} blade_length the tallest blade that grows on any member, world units; 0 when none grows
+     */
+    set(node: number, low: ArrayLike<number>, high: ArrayLike<number>, blade_length: number): void;
+    /**
+     * A row stops being a surface. The slots that hold its tiles stay taken until the pool has need of them.
+     *
+     * @param {number} node a `transforms` row; one that is no surface is left alone
+     */
+    remove(node: number): void;
+    /**
+     * The ground of a surface has changed inside a rectangle: a member has come, gone or moved there. Every
+     * layer of every tile the rectangle touches, of every level, is baked again, where it is, when a view
+     * next asks for it. What it costs does not depend on the rectangle's size.
+     *
+     * @param {number} node the surface's `transforms` row
+     * @param {number} low_x the rectangle, in the surface's frame
+     * @param {number} low_z
+     * @param {number} high_x
+     * @param {number} high_z
+     */
+    invalidate(node: number, low_x: number, low_z: number, high_x: number, high_z: number): void;
+    /**
+     * Begin a frame: bring the device's list of surfaces up to date, and make the pool if there is a
+     * surface and no pool yet. Call once a frame, before any view's {@link graph_update}.
+     */
+    update(): void;
+    /**
+     * What a view asks of the surfaces this frame, as the passes' immediate (`GRASS_SURFACE_VIEW_SETTINGS`):
+     * the settings, the view's focal length in pixels, the frame and the counts. `blade_capacity` is left
+     * at zero for whoever keeps a blade list.
+     *
+     * @param {GPUViewContext} view
+     * @returns {object|null} null while there is no pool, no surface, or nothing grows on any
+     */
+    view_settings(view: GPUViewContext): object | null;
+    /**
+     * Record a view's asks for tiles, and the bake of those taken: the passes of `GRASS_SURFACE.js`'s
+     * lifetime, in the frame graph. Records nothing while there is no surface.
+     *
+     * @param {object} options
+     * @param {FrameGraph} options.graph
+     * @param {GPUViewContext} options.view the view; its scene is the surfaces' scene
+     */
+    graph_update({ graph, view }: {
+        graph: FrameGraph;
+        view: GPUViewContext;
+    }): void;
+    /**
+     * Let go of everything on the device. The surfaces stay listed: the next {@link update} makes a fresh
+     * pool for them.
+     */
+    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 GraphicsContext = import("../../GraphicsContext.js").GraphicsContext;
+export type GPUViewContext = import("../../view/GPUViewContext.js").GPUViewContext;
+//# sourceMappingURL=GPUGrassSurfaces.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GPUGrassSurfaces.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/GPUGrassSurfaces.js"],"names":[],"mappings":"AAyGA;;;;;;GAMG;AACH,0DAHW,MAAM,GACJ,MAAM,CAUlB;AAED;;GAEG;AACH;IACI;;;;;OAKG;IACH,gBAFU,MAAM,CAEO;IAEvB;;;;;OAKG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;;OAKG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;;;OAMG;IACH,eAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,gBAFU,MAAM,CAEG;CACtB;AAED;;;;;;;;GAQG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAczB;IA4KD;;OAEG;IACH,sBAFW,eAAe,EAOzB;IAlLD;;OAEG;IACH,UAFU,oBAAoB,CAEQ;IAiLtC;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;OAKG;IACH,iBAEC;IAED;;;;OAIG;IACH,sBAEC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;;OAKG;IACH,UAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,UALW,MAAM,OACN,UAAU,MAAM,CAAC,QACjB,UAAU,MAAM,CAAC,gBACjB,MAAM,QAgDhB;IAED;;;;OAIG;IACH,aAFW,MAAM,QA8BhB;IAED;;;;;;;;;;OAUG;IACH,iBANW,MAAM,SACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,MAAM,QAYhB;IAyGD;;;OAGG;IACH,eAwEC;IAoPD;;;;;;;OAOG;IACH,oBAHW,cAAc,GACZ,MAAM,GAAC,IAAI,CAyBvB;IAED;;;;;;;OAOG;IACH;QAH+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;aA+KxB;IAED;;;OAGG;IACH,gBAQC;;CA2BJ;yBAzqCY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,6CAA6C,EAAE,eAAe;8BACrE,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc"}