@woosh/meep-engine 3.64.1 → 3.65.0

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

@@ -0,0 +1,436 @@
+import { assert } from "../../../../core/assert.js";
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
+import { FLUID_OBSTACLE_TABLE } from "../../fluid/forcing/FLUID_DATABASE_SPEC.js";
+import {
+    GRASS_PRESS_FIELD_WORDS,
+    GRASS_PRESS_JOBS_COMMAND,
+    GRASS_PRESS_JOBS_TILES,
+    GRASS_PRESS_JOBS_WORDS,
+    GRASS_PRESS_TICKS_PER_SECOND,
+    GRASS_PRESS_TILE_CELLS,
+    GRASS_PRESS_WINDOW_CELLS,
+    GRASS_PRESS_WINDOW_STRUCT
+} from "./GRASS_PRESS.js";
+import { GRASS_PRESS_MARK_WORKGROUP_SIZE, shader_grass_press_mark } from "./shader_grass_press_mark.js";
+import { shader_grass_press_stamp } from "./shader_grass_press_stamp.js";
+
+/**
+ * @typedef {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ * @typedef {import("../../fluid/forcing/GPUFluidForcing.js").GPUFluidForcing} GPUFluidForcing
+ * @typedef {import("../../GraphicsContext.js").GraphicsContext} GraphicsContext
+ * @typedef {import("../../view/GPUViewContext.js").GPUViewContext} GPUViewContext
+ */
+
+/**
+ * The frame's tile jobs: the command and the tiles' counts cleared, the rest written before it is read.
+ */
+const JOBS_DESCRIPTOR = BufferResourceDescriptor.from(
+    GRASS_PRESS_JOBS_WORDS * 4,
+    GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT,
+    GRASS_PRESS_JOBS_COMMAND * 4, (GRASS_PRESS_JOBS_TILES - GRASS_PRESS_JOBS_COMMAND) * 4,
+);
+
+// words of GRASS_PRESS_WINDOW_STRUCT, from its layout
+const WINDOW_CORNER = GRASS_PRESS_WINDOW_STRUCT.get('corner').offset >>> 2;
+const WINDOW_SPACING = GRASS_PRESS_WINDOW_STRUCT.get('spacing').offset >>> 2;
+const WINDOW_NOW = GRASS_PRESS_WINDOW_STRUCT.get('now').offset >>> 2;
+const WINDOW_PREVIOUS = GRASS_PRESS_WINDOW_STRUCT.get('previous').offset >>> 2;
+const WINDOW_STAMPED = GRASS_PRESS_WINDOW_STRUCT.get('stamped').offset >>> 2;
+const WINDOW_ROW_COUNT = GRASS_PRESS_WINDOW_STRUCT.get('row_count').offset >>> 2;
+
+/**
+ * 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) {
+        enquiry.compute.push(shader_grass_press_mark.pipeline);
+        enquiry.compute.push(shader_grass_press_stamp.pipeline);
+    }
+
+    /**
+     * Whether obstacles press grass. While false nothing is stamped and nothing reads as pressed.
+     * @type {boolean}
+     */
+    enabled = true;
+
+    /**
+     * 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 = 0.125;
+
+    /** @type {GPUDevice} */
+    #device;
+
+    /** @type {GPUBuffer|null} the field */
+    #field = null;
+
+    /** @type {BufferResourceDescriptor|null} */
+    #field_descriptor = null;
+
+    /** @type {GPUBuffer|null} the window and clock, `GRASS_PRESS_WINDOW_STRUCT` */
+    #window_buffer = null;
+
+    #window = new ArrayBuffer(GRASS_PRESS_WINDOW_STRUCT.size);
+    #window_i32 = new Int32Array(this.#window);
+    #window_u32 = new Uint32Array(this.#window);
+    #window_f32 = new Float32Array(this.#window);
+
+    /**
+     * The spacing the field's cells were written at.
+     * @type {number}
+     */
+    #field_spacing = 0;
+
+    /**
+     * The obstacle table's rows, as the device holds them, and how many.
+     * @type {Uint32Array}
+     */
+    #rows = new Uint32Array(64);
+    #row_count = 0;
+
+    /** @type {GPUBuffer|null} */
+    #rows_buffer = null;
+
+    /**
+     * The forcing the rows were listed from, and its version of its sets then.
+     * @type {GPUFluidForcing|null}
+     */
+    #listed = null;
+    #listed_version = -1;
+
+    /**
+     * The graph the frame's stamp was recorded on, and the field as that graph knows it.
+     * @type {FrameGraph|null}
+     */
+    #stamped_graph = null;
+    #field_resource = -1;
+
+    /**
+     * Whether a view has been stamped for since the last {@link update}.
+     * @type {boolean}
+     */
+    #stamped = false;
+
+    /**
+     * Seconds of the clock past its whole ticks, and the ticks, wrapped to 32 bits.
+     */
+    #tick_fraction = 0;
+    #ticks = 0;
+
+    /**
+     * The clock at the last frame a view was stamped for.
+     * @type {number}
+     */
+    #stamped_ticks = 0;
+
+    /**
+     * @param {GraphicsContext} graphics
+     */
+    constructor(graphics) {
+        assert.defined(graphics, 'graphics');
+        assert.equal(graphics.isGraphicsContext, true, 'graphics.isGraphicsContext !== true');
+
+        this.#device = graphics.device;
+    }
+
+    /**
+     * The field on the device. Null before the first {@link update}, and replaced when {@link spacing}
+     * changes.
+     *
+     * @returns {GPUBuffer|null}
+     */
+    get field_buffer() {
+        return this.#field;
+    }
+
+    /**
+     * The window and clock on the device. Null before the first {@link update}.
+     *
+     * @returns {GPUBuffer|null}
+     */
+    get window_buffer() {
+        return this.#window_buffer;
+    }
+
+    /**
+     * 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) {
+        assert.isNumber(time_delta_seconds, 'time_delta_seconds');
+        assert.greaterThanOrEqual(time_delta_seconds, 0, 'time_delta_seconds');
+        assert.greaterThan(this.spacing, 0, 'spacing');
+
+        const device = this.#device;
+
+        if (this.#field === null || this.#field_spacing !== this.spacing) {
+            this.#field?.destroy();
+
+            // made zeroed: no cell holds a press
+            this.#field = device.createBuffer({
+                label: "grass / press field",
+                size: GRASS_PRESS_FIELD_WORDS * 4,
+                // copied from by whoever reads the field back off the device
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+            });
+
+            this.#field_descriptor = BufferResourceDescriptor.fromBuffer(this.#field);
+            this.#field_spacing = this.spacing;
+        }
+
+        if (this.#window_buffer === null) {
+            this.#window_buffer = device.createBuffer({
+                label: "grass / press window",
+                size: GRASS_PRESS_WINDOW_STRUCT.size,
+                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+            });
+        }
+
+        const moved = this.#tick_fraction + time_delta_seconds * GRASS_PRESS_TICKS_PER_SECOND;
+        const whole = Math.floor(moved);
+
+        this.#tick_fraction = moved - whole;
+
+        const u32 = this.#window_u32;
+
+        u32[WINDOW_PREVIOUS] = this.#ticks;
+
+        this.#ticks = (this.#ticks + whole) >>> 0;
+
+        u32[WINDOW_NOW] = this.#ticks;
+
+        this.#stamped = false;
+        this.#stamped_graph = null;
+        this.#field_resource = -1;
+    }
+
+    /**
+     * 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 }) {
+        assert.defined(graph, 'graph');
+        assert.defined(view, 'view');
+        assert.notNull(this.#field, 'field: update() comes first');
+
+        if (this.#stamped_graph === graph) {
+            return this.#field_resource;
+        }
+
+        this.#stamped_graph = graph;
+        this.#field_resource = graph.import_resource("grass press field", this.#field_descriptor, this.#field);
+
+        if (this.#stamped) {
+            // another graph of the same frame: the field as it is
+            return this.#field_resource;
+        }
+
+        this.#stamped = true;
+
+        // a contact goes on from the stamp before this one, however many frames of the clock went by unstamped
+        this.#window_u32[WINDOW_STAMPED] = this.#stamped_ticks;
+        this.#stamped_ticks = this.#ticks;
+
+        // the window: whole tiles about a point half its side ahead of the eye, as far as the view looks level
+        const eye = view.camera.camera.transform;
+        const tile_side = this.spacing * GRASS_PRESS_TILE_CELLS;
+        const half = GRASS_PRESS_WINDOW_CELLS / GRASS_PRESS_TILE_CELLS / 2;
+
+        // the way a camera looks is its third axis
+        const looks = Math.hypot(eye[8], eye[9], eye[10]);
+        const ahead = looks > 0 ? half * tile_side / looks : 0;
+
+        const i32 = this.#window_i32;
+
+        i32[WINDOW_CORNER] = (Math.floor((eye.translation_x + eye[8] * ahead) / tile_side) - half) * GRASS_PRESS_TILE_CELLS;
+        i32[WINDOW_CORNER + 1] = (Math.floor((eye.translation_z + eye[10] * ahead) / tile_side) - half) * GRASS_PRESS_TILE_CELLS;
+
+        let row_count = 0;
+
+        if (this.enabled && forcing !== null && forcing !== undefined) {
+            row_count = this.#list_rows(forcing);
+        }
+
+        this.#window_u32[WINDOW_ROW_COUNT] = row_count;
+
+        // a field that is off reads as one with no cells
+        this.#window_f32[WINDOW_SPACING] = this.enabled ? this.spacing : 0;
+
+        this.#device.queue.writeBuffer(this.#window_buffer, 0, this.#window);
+
+        if (row_count === 0) {
+            return this.#field_resource;
+        }
+
+        const scene = view.scene;
+        const database = forcing.database;
+
+        graph.push_scope("grass press");
+
+        const mark_data = {};
+
+        const mark_pass = graph.add("mark tiles", mark_data, (data, resources, context) => {
+            if (database.has_pending_upload) {
+                // rows the fluid has not sent yet: it sends them only in a frame that steps
+                database.update(context.encoder);
+            }
+
+            shader_grass_press_mark.dispatch({
+                encoder: context.encoder,
+                group_count_x: Math.ceil(row_count / GRASS_PRESS_MARK_WORKGROUP_SIZE),
+                bindings: {
+                    grass_press_window: this.#window_buffer,
+                    press_rows: this.#rows_buffer,
+                    fluid_database: database.buffer,
+                    scene_database: scene.scene_database_buffer,
+                    press_jobs: resources.get(data.jobs),
+                    grass_press: resources.get(data.field),
+                },
+            });
+        });
+
+        mark_data.jobs = mark_pass.create("press jobs", JOBS_DESCRIPTOR);
+        mark_data.field = mark_pass.write(this.#field_resource);
+
+        const stamp_data = {};
+
+        const stamp_pass = graph.add("stamp cells", stamp_data, (data, resources, context) => {
+            const jobs = resources.get(data.jobs);
+
+            shader_grass_press_stamp.dispatchIndirect({
+                encoder: context.encoder,
+                command: jobs,
+                bindings: {
+                    grass_press_window: this.#window_buffer,
+                    press_jobs: jobs,
+                    fluid_database: database.buffer,
+                    scene_database: scene.scene_database_buffer,
+                    grass_press: resources.get(data.field),
+                },
+            });
+        });
+
+        stamp_data.jobs = stamp_pass.read(mark_data.jobs);
+        // the field is not the graph's own, so the pass is kept whether or not anything reads it this frame
+        stamp_data.field = stamp_pass.write(mark_data.field);
+
+        graph.pop_scope();
+
+        this.#field_resource = stamp_data.field;
+
+        return this.#field_resource;
+    }
+
+    /**
+     * The forcing's obstacle rows, listed again and sent to the device only when its sets have changed.
+     *
+     * @param {GPUFluidForcing} forcing
+     * @returns {number} how many
+     */
+    #list_rows(forcing) {
+        if (this.#listed === forcing && this.#listed_version === forcing.sets_version) {
+            return this.#row_count;
+        }
+
+        this.#listed = forcing;
+        this.#listed_version = forcing.sets_version;
+
+        const count = forcing.obstacle_count;
+
+        this.#row_count = count;
+
+        if (count === 0) {
+            return 0;
+        }
+
+        if (this.#rows.length < count) {
+            this.#rows = new Uint32Array(Math.max(count, 2 * this.#rows.length));
+        }
+
+        const rows = this.#rows;
+        const occupancy = forcing.database.get(FLUID_OBSTACLE_TABLE).occupancy;
+
+        let n = 0;
+
+        for (let row = occupancy.nextSetBit(0); row !== -1; row = occupancy.nextSetBit(row + 1)) {
+            rows[n++] = row;
+        }
+
+        if (this.#rows_buffer === null || this.#rows_buffer.size < rows.byteLength) {
+            this.#rows_buffer?.destroy();
+
+            this.#rows_buffer = this.#device.createBuffer({
+                label: "grass / press rows",
+                size: rows.byteLength,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+            });
+        }
+
+        this.#device.queue.writeBuffer(this.#rows_buffer, 0, rows, 0, n);
+
+        return n;
+    }
+
+    /**
+     * 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) {
+        bindings.grass_press_window = this.#window_buffer;
+    }
+
+    /**
+     * Let go of everything on the device. The field's presses go with it.
+     */
+    destroy() {
+        this.#field?.destroy();
+        this.#field = null;
+        this.#field_descriptor = null;
+        this.#window_buffer?.destroy();
+        this.#window_buffer = null;
+        this.#rows_buffer?.destroy();
+        this.#rows_buffer = null;
+        this.#listed = null;
+        this.#stamped_graph = null;
+        this.#field_resource = -1;
+    }
+}

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

@@ -0,0 +1,179 @@
+/**
+ * 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: number;
+/**
+ * Cells along a tile's side.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_TILE_CELLS: number;
+/**
+ * Tiles along the window's side, as a power of two.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_WINDOW_TILES_LOG2: number;
+/**
+ * Tiles along the window's side.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_WINDOW_TILES: number;
+/**
+ * Cells along the window's side, as a power of two.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_WINDOW_CELLS_LOG2: number;
+/**
+ * Cells along the window's side.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_WINDOW_CELLS: number;
+/**
+ * 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: number;
+/**
+ * Steps of the press's clock in a second.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_TICKS_PER_SECOND: number;
+/**
+ * Words a press takes.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_WORDS: number;
+/** 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: number;
+/** 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: number;
+/**
+ * Words a cell takes in the field: its tag, and its two states.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_CELL_WORDS: number;
+/**
+ * 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: number;
+/** 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: number;
+/**
+ * Words in the field.
+ *
+ * @type {number}
+ */
+export const GRASS_PRESS_FIELD_WORDS: number;
+/**
+ * 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: number;
+export const GRASS_PRESS_JOBS_LISTS: number;
+export const GRASS_PRESS_JOBS_WORDS: number;
+/**
+ * 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;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=GRASS_PRESS.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GRASS_PRESS.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/grass/press/GRASS_PRESS.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;GAIG;AACH,0CAFU,MAAM,CAE6B;AAE7C;;;;GAIG;AACH,qCAFU,MAAM,CAEuD;AAEvE;;;;GAIG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;;GAIG;AACH,uCAFU,MAAM,CAE2D;AAE3E;;;;GAIG;AACH,4CAFU,MAAM,CAEyF;AAEzG;;;;GAIG;AACH,uCAFU,MAAM,CAE2D;AAE3E;;;;;GAKG;AACH,0CAFU,MAAM,CAE8B;AAE9C;;;;GAIG;AACH,2CAFU,MAAM,CAEiC;AAEjD;;;;GAIG;AACH,gCAFU,MAAM,CAEmB;AAEnC,uDAAuD;AACvD,iCAAkC;AAElC,6FAA6F;AAC7F,mCAAoC;AAEpC,oDAAoD;AACpD,gCAAiC;AAEjC,wGAAwG;AACxG,qCAAsC;AAEtC;;;;GAIG;AACH,sCAFU,MAAM,CAEiD;AAEjE,mHAAmH;AACnH,uCAAwC;AAExC,mDAAmD;AACnD,yCAA0C;AAE1C,oDAAoD;AACpD,+CAAsF;AAEtF;;;;GAIG;AACH,qCAFU,MAAM,CAEsD;AAEtE;;;;GAIG;AACH,qCAAsC;AAEtC;;;;GAIG;AACH,4CAFU,MAAM,CAEgC;AAEhD,2DAA2D;AAC3D,wCAAyC;AAEzC;;;;GAIG;AACH,wCAAyC;AAEzC,2CAA2C;AAC3C,6CAA+F;AAE/F;;;;GAIG;AACH,sCAFU,MAAM,CAEwG;AAExH;;;;;GAKG;AACH,yCAA0C;AAE1C,wCAAyC;AAEzC,4CAA8F;AAE9F,4CAA6F;AAE7F,4CAA2H;AAE3H;;;;;;;;;;;GAWG;AACH,wCAFU,YAAY,CASC;6BAvNM,mCAAmC"}