@woosh/meep-engine 3.64.1 → 3.65.0

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

@@ -0,0 +1,62 @@
+/**
+ * A rectangle of a grass surface whose ground has changed.
+ *
+ * - `surface`: the surface's `transforms` row.
+ * - `low_x`, `low_z`, `high_x`, `high_z`: the rectangle on the x and z of the surface's frame; low is not
+ *   past high.
+ *
+ * 20 bytes: five words.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_INVALIDATION_STRUCT: WebGPUStruct;
+/**
+ * Words in a {@link GRASS_INVALIDATION_STRUCT}.
+ *
+ * @type {number}
+ */
+export const GRASS_INVALIDATION_WORDS: number;
+/**
+ * Threads in a workgroup of {@link shader_grass_surface_invalidate}, along the dispatch's x.
+ *
+ * @type {number}
+ */
+export const GRASS_SURFACE_INVALIDATE_WORKGROUP_SIZE: number;
+/**
+ * Records a thread of {@link shader_grass_surface_invalidate} reads: the dispatch's y counts runs of this
+ * many.
+ *
+ * @type {number}
+ */
+export const GRASS_SURFACE_INVALIDATE_RUN: number;
+/**
+ * The pass's immediate.
+ *
+ * - `finest_spacing`: the spacing of level 0's columns.
+ * - `record_count`: how many records `grass_invalidations` holds.
+ * - `slot_capacity`: slots in the pool.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_SURFACE_INVALIDATE_SETTINGS: WebGPUStruct;
+/**
+ * Marks stale the baked slots whose tiles lie on ground that has changed: the rectangles in
+ * `grass_invalidations`.
+ *
+ * Thread `(x, y)` is slot `x` against the records `[y * GRASS_SURFACE_INVALIDATE_RUN, (y + 1) *
+ * GRASS_SURFACE_INVALIDATE_RUN)`. A slot that is baked, and whose tile's square touches a rectangle of its
+ * own surface among them, is marked stale: it reads as it was, and is baked again when a view next asks for
+ * it ({@link shader_grass_surface_want}). A square and a rectangle that share only an edge touch. Slots
+ * that are free, pending or stale already read no record, so the pass costs by the baked slots and the
+ * records, whatever area the rectangles cover.
+ *
+ * Dispatch `ceil(slot_capacity / GRASS_SURFACE_INVALIDATE_WORKGROUP_SIZE)` groups along x and
+ * `ceil(record_count / GRASS_SURFACE_INVALIDATE_RUN)` along y; threads past either count do nothing. Runs
+ * before the frame's asks.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_surface_invalidate: ComputeShader;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_grass_surface_invalidate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_grass_surface_invalidate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/shader_grass_surface_invalidate.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;GAUG;AACH,wCAFU,YAAY,CAQE;AAExB;;;;GAIG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;;GAIG;AACH,sDAFU,MAAM,CAE0C;AAE1D;;;;;GAKG;AACH,2CAFU,MAAM,CAE+B;AAE/C;;;;;;;;GAQG;AACH,gDAFU,YAAY,CAMe;AAUrC;;;;;;;;;;;;;;;;GAgBG;AACH,8CAFU,aAAa,CA+DpB;6BA5J0B,mCAAmC;8BAJlC,+BAA+B"}

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

@@ -0,0 +1,162 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { f32, 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_grass_slot } from "./chunk_grass_slot.js";
+import { chunk_grass_tile } from "./chunk_grass_tile.js";
+import {
+    GRASS_SLOT_LEVEL_LAYER,
+    GRASS_SLOT_STATE,
+    GRASS_SLOT_STATE_BAKED,
+    GRASS_SLOT_STATE_STALE,
+    GRASS_SLOT_SURFACE,
+    GRASS_SLOT_TILE_X,
+    GRASS_SLOT_TILE_Z
+} from "./GRASS_SURFACE.js";
+import { GRASS_POOL_RESOURCE } from "./GRASS_SURFACE_VIEW.js";
+
+/**
+ * A rectangle of a grass surface whose ground has changed.
+ *
+ * - `surface`: the surface's `transforms` row.
+ * - `low_x`, `low_z`, `high_x`, `high_z`: the rectangle on the x and z of the surface's frame; low is not
+ *   past high.
+ *
+ * 20 bytes: five words.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_INVALIDATION_STRUCT = WebGPUStruct.from({
+    surface: u32,
+    low_x: f32,
+    low_z: f32,
+    high_x: f32,
+    high_z: f32,
+}, "GrassInvalidation");
+
+/**
+ * Words in a {@link GRASS_INVALIDATION_STRUCT}.
+ *
+ * @type {number}
+ */
+export const GRASS_INVALIDATION_WORDS = 5;
+
+/**
+ * Threads in a workgroup of {@link shader_grass_surface_invalidate}, along the dispatch's x.
+ *
+ * @type {number}
+ */
+export const GRASS_SURFACE_INVALIDATE_WORKGROUP_SIZE = 64;
+
+/**
+ * Records a thread of {@link shader_grass_surface_invalidate} reads: the dispatch's y counts runs of this
+ * many.
+ *
+ * @type {number}
+ */
+export const GRASS_SURFACE_INVALIDATE_RUN = 64;
+
+/**
+ * The pass's immediate.
+ *
+ * - `finest_spacing`: the spacing of level 0's columns.
+ * - `record_count`: how many records `grass_invalidations` holds.
+ * - `slot_capacity`: slots in the pool.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_SURFACE_INVALIDATE_SETTINGS = WebGPUStruct.from({
+    finest_spacing: f32,
+    record_count: u32,
+    slot_capacity: u32,
+}, "GrassSurfaceInvalidateSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", GRASS_SURFACE_INVALIDATE_SETTINGS);
+
+resources.createGroup()
+    .addStorageBuffer("grass_invalidations", WebGPUArray.from(GRASS_INVALIDATION_STRUCT))
+    .add(GRASS_POOL_RESOURCE);
+
+/**
+ * Marks stale the baked slots whose tiles lie on ground that has changed: the rectangles in
+ * `grass_invalidations`.
+ *
+ * Thread `(x, y)` is slot `x` against the records `[y * GRASS_SURFACE_INVALIDATE_RUN, (y + 1) *
+ * GRASS_SURFACE_INVALIDATE_RUN)`. A slot that is baked, and whose tile's square touches a rectangle of its
+ * own surface among them, is marked stale: it reads as it was, and is baked again when a view next asks for
+ * it ({@link shader_grass_surface_want}). A square and a rectangle that share only an edge touch. Slots
+ * that are free, pending or stale already read no record, so the pass costs by the baked slots and the
+ * records, whatever area the rectangles cover.
+ *
+ * Dispatch `ceil(slot_capacity / GRASS_SURFACE_INVALIDATE_WORKGROUP_SIZE)` groups along x and
+ * `ceil(record_count / GRASS_SURFACE_INVALIDATE_RUN)` along y; threads past either count do nothing. Runs
+ * before the frame's asks.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_surface_invalidate = ComputeShader.from({
+    label: "Grass Surface Invalidate",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${GRASS_SURFACE_INVALIDATE_WORKGROUP_SIZE})
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let slot = id.x;
+
+    if (slot >= settings.slot_capacity) {
+        return;
+    }
+
+    let record = grass_slot_record(slot);
+    let state = record + ${GRASS_SLOT_STATE}u;
+
+    if (atomicLoad(&grass_pool[state]) != ${GRASS_SLOT_STATE_BAKED}u) {
+        return;
+    }
+
+    let surface = atomicLoad(&grass_pool[record + ${GRASS_SLOT_SURFACE}u]);
+    let level = atomicLoad(&grass_pool[record + ${GRASS_SLOT_LEVEL_LAYER}u]) & 0xffu;
+
+    let tile = vec2<i32>(
+        bitcast<i32>(atomicLoad(&grass_pool[record + ${GRASS_SLOT_TILE_X}u])),
+        bitcast<i32>(atomicLoad(&grass_pool[record + ${GRASS_SLOT_TILE_Z}u])),
+    );
+
+    // the tile's square on the frame's x and z
+    let edge = grass_level_spacing(settings.finest_spacing, level) * f32(GRASS_TILE_COLUMNS);
+
+    let low = vec2<f32>(tile) * edge;
+    let high = low + edge;
+
+    let first = id.y * ${GRASS_SURFACE_INVALIDATE_RUN}u;
+
+    for (var i = 0u; i < ${GRASS_SURFACE_INVALIDATE_RUN}u; i++) {
+        let at = first + i;
+
+        if (at >= settings.record_count) {
+            break;
+        }
+
+        let change = grass_invalidations[at];
+
+        if (change.surface != surface) {
+            continue;
+        }
+
+        if (change.low_x <= high.x && change.low_z <= high.y && change.high_x >= low.x && change.high_z >= low.y) {
+            atomicStore(&grass_pool[state], ${GRASS_SLOT_STATE_STALE}u);
+
+            return;
+        }
+    }
+}
+`, [
+            chunk_grass_slot,
+            chunk_grass_tile,
+        ]),
+});

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

@@ -0,0 +1,40 @@
+/**
+ * Threads in a workgroup of {@link shader_grass_surface_retire}.
+ *
+ * @type {number}
+ */
+export const GRASS_SURFACE_RETIRE_WORKGROUP_SIZE: number;
+/**
+ * The pass's immediate.
+ *
+ * - `frame`: the frame, as the asks stamp it.
+ * - `slot_capacity`: slots in the pool.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_SURFACE_RETIRE_SETTINGS: WebGPUStruct;
+/**
+ * Gives slots back to the grass surfaces' pool, a thread a slot: once a frame, before any view asks.
+ *
+ * - A slot the directory never listed (`GRASS_SLOT_STATE_ORPHAN`) is freed.
+ * - A baked or stale slot no view asked for this frame or the one before can be evicted. It is, when the
+ *   plan the last frame's schedule left asks for it ({@link shader_grass_surface_schedule},
+ *   `chunk_age_eviction`): its record leaves the directory, the pool's count of removals rises, its state
+ *   goes to free and it is pushed on the free stack. One the plan does not ask for is counted into its
+ *   age's bucket, from `GRASS_POOL_AGES`, for the frame's schedule.
+ * - A pending slot, and one a view asked for this frame or the last, is left as it is.
+ *
+ * Eviction follows the pressure on the slots, not a time: a plan asks for nothing while the free slots
+ * cover what views need, and a tile nothing looks at keeps its surfels until then.
+ *
+ * Every push to the free stack and every removal from the directory is here; the pops, finds and inserts
+ * are the asks', in other dispatches. Dispatch `ceil(slot_capacity / GRASS_SURFACE_RETIRE_WORKGROUP_SIZE)`
+ * groups: the pool's capacity follows what views hold, so a thread a slot is a thread a tile in use, to
+ * within the pool's growth.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_surface_retire: ComputeShader;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_grass_surface_retire.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_grass_surface_retire.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/shader_grass_surface_retire.js"],"names":[],"mappings":"AA6BA;;;;GAIG;AACH,kDAFU,MAAM,CAEsC;AAEtD;;;;;;;GAOG;AACH,4CAFU,YAAY,CAKW;AAWjC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,0CAFU,aAAa,CA6EpB;6BAnJ0B,mCAAmC;8BAJlC,+BAA+B"}

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

@@ -0,0 +1,155 @@
+import { chunk_age_eviction } from "../../gpu_primitive/age_eviction/chunk_age_eviction.js";
+import { chunk_slot_stack } from "../../gpu_primitive/slot_stack/chunk_slot_stack.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 { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { chunk_grass_directory } from "./chunk_grass_directory.js";
+import {
+    GRASS_POOL_AGES,
+    GRASS_POOL_EVICT_BUCKETS,
+    GRASS_POOL_EVICT_REMAINING,
+    GRASS_POOL_EVICTED,
+    GRASS_POOL_FREE_COUNT,
+    GRASS_POOL_REMOVED,
+    GRASS_SLOT_LEVEL_LAYER,
+    GRASS_SLOT_STATE,
+    GRASS_SLOT_STATE_BAKED,
+    GRASS_SLOT_STATE_FREE,
+    GRASS_SLOT_STATE_ORPHAN,
+    GRASS_SLOT_STATE_STALE,
+    GRASS_SLOT_SURFACE,
+    GRASS_SLOT_TILE_X,
+    GRASS_SLOT_TILE_Z,
+    GRASS_SLOT_WANTED_FRAME
+} from "./GRASS_SURFACE.js";
+import { GRASS_DIRECTORY_RESOURCE, GRASS_POOL_RESOURCE } from "./GRASS_SURFACE_VIEW.js";
+
+/**
+ * Threads in a workgroup of {@link shader_grass_surface_retire}.
+ *
+ * @type {number}
+ */
+export const GRASS_SURFACE_RETIRE_WORKGROUP_SIZE = 64;
+
+/**
+ * The pass's immediate.
+ *
+ * - `frame`: the frame, as the asks stamp it.
+ * - `slot_capacity`: slots in the pool.
+ *
+ * @type {WebGPUStruct}
+ */
+export const GRASS_SURFACE_RETIRE_SETTINGS = WebGPUStruct.from({
+    frame: u32,
+    slot_capacity: u32,
+}, "GrassSurfaceRetireSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", GRASS_SURFACE_RETIRE_SETTINGS);
+
+resources.createGroup()
+    .add(GRASS_POOL_RESOURCE)
+    .add(GRASS_DIRECTORY_RESOURCE)
+    .addStorageBuffer("grass_free", WebGPUArray.u32, true);
+
+/**
+ * Gives slots back to the grass surfaces' pool, a thread a slot: once a frame, before any view asks.
+ *
+ * - A slot the directory never listed (`GRASS_SLOT_STATE_ORPHAN`) is freed.
+ * - A baked or stale slot no view asked for this frame or the one before can be evicted. It is, when the
+ *   plan the last frame's schedule left asks for it ({@link shader_grass_surface_schedule},
+ *   `chunk_age_eviction`): its record leaves the directory, the pool's count of removals rises, its state
+ *   goes to free and it is pushed on the free stack. One the plan does not ask for is counted into its
+ *   age's bucket, from `GRASS_POOL_AGES`, for the frame's schedule.
+ * - A pending slot, and one a view asked for this frame or the last, is left as it is.
+ *
+ * Eviction follows the pressure on the slots, not a time: a plan asks for nothing while the free slots
+ * cover what views need, and a tile nothing looks at keeps its surfels until then.
+ *
+ * Every push to the free stack and every removal from the directory is here; the pops, finds and inserts
+ * are the asks', in other dispatches. Dispatch `ceil(slot_capacity / GRASS_SURFACE_RETIRE_WORKGROUP_SIZE)`
+ * groups: the pool's capacity follows what views hold, so a thread a slot is a thread a tile in use, to
+ * within the pool's growth.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_surface_retire = ComputeShader.from({
+    label: "Grass Surface Retire",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${GRASS_SURFACE_RETIRE_WORKGROUP_SIZE})
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let slot = id.x;
+
+    if (slot >= settings.slot_capacity) {
+        return;
+    }
+
+    let record = grass_slot_record(slot);
+    let state = atomicLoad(&grass_pool[record + ${GRASS_SLOT_STATE}u]);
+
+    if (state != ${GRASS_SLOT_STATE_ORPHAN}u) {
+        if (state != ${GRASS_SLOT_STATE_BAKED}u && state != ${GRASS_SLOT_STATE_STALE}u) {
+            return;
+        }
+
+        let wanted_frame = atomicLoad(&grass_pool[record + ${GRASS_SLOT_WANTED_FRAME}u]);
+
+        // not asked for the frame before: wanted_frame < frame − 1, which does not wrap at the first frame
+        if (wanted_frame + 1u >= settings.frame) {
+            return;
+        }
+
+        let age = settings.frame - wanted_frame;
+
+        // the bucket the last frame's schedule counted it in, a frame younger
+        let counted = age_eviction_bucket(age - 1u);
+
+        let buckets = atomicLoad(&grass_pool[${GRASS_POOL_EVICT_BUCKETS}u]);
+        let remaining = atomicLoad(&grass_pool[${GRASS_POOL_EVICT_REMAINING}u]);
+
+        var evicted = age_eviction_whole(counted, buckets);
+
+        if (age_eviction_partial(counted, buckets) && remaining > 0u) {
+            evicted = atomicAdd(&grass_pool[${GRASS_POOL_EVICTED}u], 1u) < remaining;
+        }
+
+        if (!evicted) {
+            atomicAdd(&grass_pool[${GRASS_POOL_AGES}u + age_eviction_bucket(age)], 1u);
+
+            return;
+        }
+
+        let tile = vec2<i32>(
+            bitcast<i32>(atomicLoad(&grass_pool[record + ${GRASS_SLOT_TILE_X}u])),
+            bitcast<i32>(atomicLoad(&grass_pool[record + ${GRASS_SLOT_TILE_Z}u])),
+        );
+
+        let removed = grass_directory_remove(
+            atomicLoad(&grass_pool[record + ${GRASS_SLOT_SURFACE}u]),
+            atomicLoad(&grass_pool[record + ${GRASS_SLOT_LEVEL_LAYER}u]),
+            tile,
+            slot,
+        );
+
+        if (removed) {
+            atomicAdd(&grass_pool[${GRASS_POOL_REMOVED}u], 1u);
+        }
+    }
+
+    atomicStore(&grass_pool[record + ${GRASS_SLOT_STATE}u], ${GRASS_SLOT_STATE_FREE}u);
+
+    slot_stack_push(&grass_pool[${GRASS_POOL_FREE_COUNT}u], &grass_free, slot);
+}
+`, [
+            chunk_grass_directory,
+            chunk_slot_stack,
+            chunk_age_eviction,
+        ]),
+});

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

@@ -0,0 +1,19 @@
+/**
+ * Plans the next frame's eviction from the grass surfaces' pool: one thread, once a frame, after the
+ * frame's retire and its first view's asks.
+ *
+ * The pool is short by as many slots as its free ones fall below `slack`. The plan frees that many of
+ * the slots retire counted as evictable, the longest unasked first (`age_eviction_plan` over
+ * `GRASS_POOL_AGES`, emptied by it), and is left in `GRASS_POOL_EVICT_BUCKETS` and
+ * `GRASS_POOL_EVICT_REMAINING` for the next retire, with `GRASS_POOL_EVICTED` at zero. With `slack`
+ * slots free it asks for nothing.
+ *
+ * `slack` is the bake's places a frame, across its views: a layer is taken a slot only with a place in
+ * the bake, so no more slots than that are taken in a frame, and with that many free an ask starves only
+ * when the slots in use fill the pool.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_surface_schedule: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_grass_surface_schedule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_grass_surface_schedule.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/shader_grass_surface_schedule.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;GAeG;AACH,4CAFU,aAAa,CAqBpB;8BAvD2B,+BAA+B"}

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

@@ -0,0 +1,58 @@
+import { chunk_age_eviction } from "../../gpu_primitive/age_eviction/chunk_age_eviction.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 {
+    GRASS_POOL_AGES,
+    GRASS_POOL_EVICT_BUCKETS,
+    GRASS_POOL_EVICT_REMAINING,
+    GRASS_POOL_EVICTED,
+    GRASS_POOL_FREE_COUNT
+} from "./GRASS_SURFACE.js";
+import { GRASS_POOL_RESOURCE } from "./GRASS_SURFACE_VIEW.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// free slots the pool is to have when the next frame's asks begin
+resources.setImmediate("slack", u32);
+
+resources.createGroup()
+    .add(GRASS_POOL_RESOURCE);
+
+/**
+ * Plans the next frame's eviction from the grass surfaces' pool: one thread, once a frame, after the
+ * frame's retire and its first view's asks.
+ *
+ * The pool is short by as many slots as its free ones fall below `slack`. The plan frees that many of
+ * the slots retire counted as evictable, the longest unasked first (`age_eviction_plan` over
+ * `GRASS_POOL_AGES`, emptied by it), and is left in `GRASS_POOL_EVICT_BUCKETS` and
+ * `GRASS_POOL_EVICT_REMAINING` for the next retire, with `GRASS_POOL_EVICTED` at zero. With `slack`
+ * slots free it asks for nothing.
+ *
+ * `slack` is the bake's places a frame, across its views: a layer is taken a slot only with a place in
+ * the bake, so no more slots than that are taken in a frame, and with that many free an ask starves only
+ * when the slots in use fill the pool.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_surface_schedule = ComputeShader.from({
+    label: "Grass Surface Schedule",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(1)
+fn main() {
+    let free = atomicLoad(&grass_pool[${GRASS_POOL_FREE_COUNT}u]);
+
+    let plan = age_eviction_plan(&grass_pool, ${GRASS_POOL_AGES}u, select(0u, slack - free, slack > free));
+
+    atomicStore(&grass_pool[${GRASS_POOL_EVICT_BUCKETS}u], plan.x);
+    atomicStore(&grass_pool[${GRASS_POOL_EVICT_REMAINING}u], plan.y);
+    atomicStore(&grass_pool[${GRASS_POOL_EVICTED}u], 0u);
+}
+`, [
+            chunk_age_eviction,
+        ]),
+});

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

@@ -0,0 +1,30 @@
+/**
+ * Asks for the tiles of the grass surfaces a view wants, a thread a tile of a window
+ * ({@link shader_grass_surface_window_count}, whose counts, summed, are `prefix_sums`).
+ *
+ * A thread finds its level of its surface from the sums and its tile from its place among that window's
+ * threads. A tile outside its level's ring (`grass_tile_wanted`) or outside the view's frustum is not
+ * wanted, and the thread ends.
+ *
+ * **A wanted tile's layers.** Layer 0 always; and once layer 0 is baked, the layers past it that its record
+ * counts. For each:
+ *
+ * - held by a slot (`grass_directory_find`): the slot's record is stamped with the frame. A stale slot also
+ *   takes a place in the frame's bake list, with what a bake gathers into its record reset, and keeps its
+ *   state: it reads as it was until the bake has run;
+ * - not held: the thread takes a place in the frame's bake list (`grass_jobs`, at most `job_capacity`
+ *   places, a count that keeps rising past them) and a slot off the free stack, writes the slot's record
+ *   for the layer, pending, and lists it in the directory. With the bake list full the layer waits for a
+ *   later frame. With no slot free the place holds `GRASS_SLOT_NONE` and the pool's starved count rises.
+ *   A slot the directory has no room for is marked an orphan and its place holds `GRASS_SLOT_NONE`.
+ *
+ * Every thread's layers are its own, so no two threads of a dispatch ask for the same one; two views ask
+ * in two dispatches, and the second finds what the first took.
+ *
+ * Dispatched through `shader_prefix_sum_to_command`'s folded command.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_grass_surface_want: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_grass_surface_want.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_grass_surface_want.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/surface/shader_grass_surface_want.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wCAFU,aAAa,CAsKpB;8BA9O2B,+BAA+B"}