@woosh/meep-engine 3.64.1 → 3.65.0

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

@@ -0,0 +1,676 @@
+import { assert } from "../../../../core/assert.js";
+import { TextureViewDescriptor } from "../../../descriptor/texture/TextureViewDescriptor.js";
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
+import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
+import { graph_read_buffer } from "../../buffer/graph_read_buffer.js";
+import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../../depth/DEFAULT_DEPTH_TEXTURE_VIEW.js";
+import { GBufferTextures } from "../../extension/GBufferTextures.js";
+import { ViewTextures } from "../../extension/ViewTextures.js";
+import { INDIRECT_COMPUTE_COMMAND_DESCRIPTOR } from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
+import { view_velocity_matrices } from "../../postprocess/velocity/view_velocity_matrices.js";
+import {
+    graph_prefix_scan_csdldf,
+    prefix_scan_csdldf_output_descriptor
+} from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
+import { shader_prefix_sum_to_command } from "../../rasterize/expand/mesh/shader_prefix_sum_to_command.js";
+import { graph_create_buffer } from "../../shader/graph/graph_create_buffer.js";
+import { GPUGrassPress } from "../press/GPUGrassPress.js";
+import { GRASS_BLADE_CLOCK_STRUCT } from "./chunk_grass_blade_wind.js";
+import { grass_blade_compliance, grass_blade_frequency } from "./grass_blade_mechanics.js";
+import {
+    GRASS_BLADE_CAPACITY_LIMIT,
+    GRASS_BLADE_ID_FORMAT,
+    GRASS_BLADE_ID_NONE,
+    GRASS_BLADE_LIST_COUNT,
+    GRASS_BLADE_LIST_HEADER_WORDS,
+    GRASS_BLADE_RECORD_WORDS,
+    GRASS_CELL_WORDS,
+    GRASS_SPECIES_WORDS
+} from "./GRASS_BLADE.js";
+import { GRASS_BLADE_ID_PIPELINE, GRASS_BLADE_ID_RESOURCES } from "./grass_blade_id_draw.js";
+import { GRASS_BLADE_RESOLVE_PIPELINE, GRASS_BLADE_RESOLVE_RESOURCES } from "./grass_blade_resolve.js";
+import { shader_grass_blade_draw_args } from "./shader_grass_blade_draw_args.js";
+import { shader_grass_blade_expand } from "./shader_grass_blade_expand.js";
+import { GRASS_CELL_COUNT_WORKGROUP_SIZE, shader_grass_cell_count } from "./shader_grass_cell_count.js";
+
+/**
+ * @typedef {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ * @typedef {import("../../extension/FrameContext.js").FrameContext} FrameContext
+ * @typedef {import("../../fluid/forcing/GPUFluidForcing.js").GPUFluidForcing} GPUFluidForcing
+ * @typedef {import("../../GraphicsContext.js").GraphicsContext} GraphicsContext
+ * @typedef {import("../../view/GPUViewContext.js").GPUViewContext} GPUViewContext
+ * @typedef {import("../surface/GPUGrassSurfaces.js").GPUGrassSurfaces} GPUGrassSurfaces
+ */
+
+/**
+ * Bytes at the front of a `u32` collection: its count, padded to the elements' alignment.
+ * @type {number}
+ */
+const COLLECTION_HEADER_BYTES = 16;
+
+/**
+ * Blades the frame's list is first made with room for.
+ * @type {number}
+ */
+const INITIAL_BLADE_CAPACITY = 2 ** 17;
+
+/**
+ * Species the species list is made with room for.
+ * @type {number}
+ */
+const INITIAL_SPECIES_CAPACITY = 16;
+
+const MIP_0 = TextureViewDescriptor.from({ mipLevelCount: 1, baseMipLevel: 0 });
+
+/**
+ * Bytes of a `u32` collection with room for `count` elements.
+ *
+ * @param {number} count
+ * @returns {number}
+ */
+function collection_size(count) {
+    return COLLECTION_HEADER_BYTES + Math.max(1, Math.ceil(count / 4)) * 16;
+}
+
+/**
+ * A view's blades for the frame being recorded: the handles its draw reads.
+ */
+class BladeProduct {
+    /** @type {number} the closed blade list */
+    blades = -1;
+
+    /** @type {number} the draw's indirect arguments */
+    draw_args = -1;
+}
+
+/**
+ * Grass blades on the device: the species list, and the passes that make a view's blades each frame and
+ * draw them (`GRASS_BLADE.js`).
+ *
+ * Blades stand on the surfels {@link GPUGrassSurfaces} keeps; nothing of a blade outlives its frame.
+ *
+ * Each frame: {@link update} once; then for every view that draws grass {@link graph_generate}, after the
+ * surfaces' own passes for the view, after whatever publishes the scene's wind for the frame (the blades
+ * are bent by it), and before anything reads the scene's depth for the frame's image; and
+ * {@link graph_draw} at the frame phase where the G-buffer is written into.
+ *
+ * The blades are pushed over by the scene's fluid obstacles through {@link press}, a field this owns and
+ * stamps as part of making a view's blades.
+ */
+export class GPUGrassBlades {
+
+    /**
+     * Offer the pipelines the blades' passes run — see {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        enquiry.compute.push(shader_grass_cell_count.pipeline);
+        enquiry.compute.push(shader_grass_blade_expand.pipeline);
+        enquiry.compute.push(shader_grass_blade_draw_args.pipeline);
+        enquiry.compute.push(shader_prefix_sum_to_command.pipeline);
+        enquiry.render.push(GRASS_BLADE_ID_PIPELINE);
+        enquiry.render.push(GRASS_BLADE_RESOLVE_PIPELINE);
+
+        GPUGrassPress.enquirePipelines(enquiry);
+    }
+
+    /**
+     * Where obstacles have pressed the grass down, and its settings.
+     *
+     * @readonly
+     * @type {GPUGrassPress}
+     */
+    press;
+
+    /** @type {GPUDevice} */
+    #device;
+
+    /** @type {GPUGrassSurfaces} */
+    #surfaces;
+
+    /**
+     * The species list, a record a species, by the species' index.
+     * @type {Float32Array}
+     */
+    #species = new Float32Array(INITIAL_SPECIES_CAPACITY * GRASS_SPECIES_WORDS);
+
+    /** @type {GPUBuffer|null} the device's copy of {@link #species} */
+    #species_buffer = null;
+
+    /**
+     * Whether the device's copy is behind.
+     * @type {boolean}
+     */
+    #species_dirty = true;
+
+    /**
+     * The scene's clock as the blades' pass reads it (`GRASS_BLADE_CLOCK_STRUCT`): this frame's, then the
+     * frame before's.
+     * @type {ArrayBuffer}
+     */
+    #clock = new ArrayBuffer(GRASS_BLADE_CLOCK_STRUCT.size);
+    #clock_u32 = new Uint32Array(this.#clock);
+    #clock_f32 = new Float32Array(this.#clock);
+
+    /** @type {GPUBuffer|null} the device's copy of {@link #clock} */
+    #clock_buffer = null;
+
+    /**
+     * Seconds of the scene's clock past its whole seconds, kept in f64.
+     * @type {number}
+     */
+    #clock_fraction = 0;
+
+    /**
+     * Blades a frame's list has room for.
+     * @type {number}
+     */
+    #blade_capacity = INITIAL_BLADE_CAPACITY;
+
+    /**
+     * The most blades any view's list was asked to hold, as last read off the device.
+     * @type {number}
+     */
+    #blades_asked = 0;
+
+    /**
+     * Each view's blades for the frame being recorded, from its generation to its draw.
+     * @type {Map<GPUViewContext, BladeProduct>}
+     */
+    #products = new Map();
+
+    /**
+     * @param {GraphicsContext} graphics
+     * @param {GPUGrassSurfaces} surfaces whose surfels the blades stand on
+     */
+    constructor(graphics, surfaces) {
+        assert.defined(graphics, 'graphics');
+        assert.equal(graphics.isGraphicsContext, true, 'graphics.isGraphicsContext !== true');
+        assert.defined(surfaces, 'surfaces');
+
+        this.#device = graphics.device;
+        this.#surfaces = surfaces;
+
+        this.press = new GPUGrassPress(graphics);
+    }
+
+    /**
+     * @returns {number} blades a frame's list has room for
+     */
+    get blade_capacity() {
+        return this.#blade_capacity;
+    }
+
+    /**
+     * @returns {number} the most blades a view's list was asked to hold, as last read off the device
+     */
+    get blades_asked() {
+        return this.#blades_asked;
+    }
+
+    /**
+     * The species list on the device. Null before the first {@link update}, and replaced when it grows.
+     *
+     * @returns {GPUBuffer|null}
+     */
+    get species_buffer() {
+        return this.#species_buffer;
+    }
+
+    /**
+     * The blades' clock on the device (`GRASS_BLADE_CLOCK_STRUCT`). Null before the first {@link update}.
+     *
+     * @returns {GPUBuffer|null}
+     */
+    get clock_buffer() {
+        return this.#clock_buffer;
+    }
+
+    /**
+     * Set a species' record.
+     *
+     * @param {number} index the species' place in the list, as `mesh_ground_covers` rows name it
+     * @param {object} species
+     * @param {number} species.blade_length metres
+     * @param {number} species.blade_width metres
+     * @param {number} species.density blades a square metre
+     * @param {number} species.roughness
+     * @param {number[]} species.color_root linear rgb
+     * @param {number[]} species.color_tip linear rgb
+     * @param {number} species.length_variation how much of its length a blade can lack, 0 to 1
+     * @param {number} species.lean the most a blade leans from upright at its root, radians
+     * @param {number} species.curl the most a blade's tip turns further than its root leans, radians
+     * @param {number} species.tint how far a blade's colour strays from its species', as a share of it
+     * @param {number} species.roundness how far a blade's normal turns towards its edges
+     * @param {number} species.elastic_modulus of the blade's tissue in bending, Pa
+     * @param {number} species.blade_depth depth of the blade's section in bending, metres
+     * @param {number} species.turbulence how unsteady the wind a blade feels is, as a share of its speed
+     */
+    set_species(index, species) {
+        assert.isNonNegativeInteger(index, 'index');
+
+        if ((index + 1) * GRASS_SPECIES_WORDS > this.#species.length) {
+            const grown = new Float32Array(Math.max(this.#species.length * 2, (index + 1) * GRASS_SPECIES_WORDS));
+
+            grown.set(this.#species);
+
+            this.#species = grown;
+        }
+
+        const words = this.#species;
+        const at = index * GRASS_SPECIES_WORDS;
+
+        words[at] = species.blade_length;
+        words[at + 1] = species.blade_width;
+        words[at + 2] = species.density;
+        words[at + 3] = species.roughness;
+
+        words[at + 4] = species.color_root[0];
+        words[at + 5] = species.color_root[1];
+        words[at + 6] = species.color_root[2];
+        words[at + 7] = species.length_variation;
+
+        words[at + 8] = species.color_tip[0];
+        words[at + 9] = species.color_tip[1];
+        words[at + 10] = species.color_tip[2];
+        words[at + 11] = species.lean;
+
+        words[at + 12] = species.curl;
+        words[at + 13] = species.tint;
+        words[at + 14] = species.roundness;
+        words[at + 15] = 0;
+
+        words[at + 16] = grass_blade_compliance(species.elastic_modulus, species.blade_depth);
+        words[at + 17] = grass_blade_frequency(species.elastic_modulus, species.blade_depth);
+        words[at + 18] = species.turbulence;
+        words[at + 19] = species.recovery_time;
+
+        this.#species_dirty = true;
+    }
+
+    /**
+     * Begin a frame: move the blades' clock and the press's on, bring the device's species list up to
+     * date, and make room for the blades the last frames' lists were asked to hold. Call once a frame,
+     * before any view's {@link graph_generate}.
+     *
+     * @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');
+
+        const device = this.#device;
+
+        // what was this frame's time is the frame before's
+        this.#clock_u32[2] = this.#clock_u32[0];
+        this.#clock_f32[3] = this.#clock_f32[1];
+
+        const fraction = this.#clock_fraction + time_delta_seconds;
+        const whole = Math.floor(fraction);
+
+        this.#clock_fraction = fraction - whole;
+
+        // whole seconds wrap with the word that holds them, as the sway's integer product does
+        this.#clock_u32[0] = (this.#clock_u32[0] + whole) >>> 0;
+        this.#clock_f32[1] = this.#clock_fraction;
+
+        if (this.#clock_buffer === null) {
+            this.#clock_buffer = device.createBuffer({
+                label: "grass / blade clock",
+                size: GRASS_BLADE_CLOCK_STRUCT.size,
+                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+            });
+        }
+
+        device.queue.writeBuffer(this.#clock_buffer, 0, this.#clock);
+
+        if (this.#species_buffer === null || this.#species_buffer.size < this.#species.byteLength) {
+            this.#species_buffer?.destroy();
+
+            this.#species_buffer = device.createBuffer({
+                label: "grass / species",
+                size: this.#species.byteLength,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+            });
+
+            this.#species_dirty = true;
+        }
+
+        if (this.#species_dirty) {
+            this.#species_dirty = false;
+
+            device.queue.writeBuffer(this.#species_buffer, 0, this.#species);
+        }
+
+        // a list that was asked for more than it holds doubles until it holds what was asked
+        while (this.#blades_asked > this.#blade_capacity && this.#blade_capacity < GRASS_BLADE_CAPACITY_LIMIT) {
+            this.#blade_capacity = Math.min(this.#blade_capacity * 2, GRASS_BLADE_CAPACITY_LIMIT);
+        }
+
+        this.press.update(time_delta_seconds);
+
+        this.#products.clear();
+    }
+
+    /**
+     * Record the passes that make a view's blades: stamp the press field, count the cells, sum, and make
+     * the blades the counts allow. Records nothing while nothing grows.
+     *
+     * @param {object} options
+     * @param {FrameGraph} options.graph
+     * @param {GPUViewContext} options.view the view; its scene is the surfaces' scene
+     * @param {GPUFluidForcing|null} [options.forcing] the scene's GPU fluid forcing, whose obstacles press
+     *        the blades; none press without it
+     */
+    graph_generate({ graph, view, forcing = null }) {
+        assert.defined(graph, 'graph');
+        assert.defined(view, 'view');
+
+        const surfaces = this.#surfaces;
+        const settings = surfaces.view_settings(view);
+
+        if (settings === null || this.#species_buffer === null) {
+            return;
+        }
+
+        const blade_capacity = this.#blade_capacity;
+
+        settings.blade_capacity = blade_capacity;
+
+        const slot_capacity = settings.slot_capacity;
+        const scene = view.scene;
+        const camera = view.camera;
+
+        const press_field = this.press.graph_stamp({ graph, view, forcing });
+
+        graph.push_scope("grass blades");
+
+        const cell_data = {};
+
+        const cell_pass = graph.add("count cells", cell_data, (data, resources, context) => {
+            shader_grass_cell_count.dispatch({
+                encoder: context.encoder,
+                group_count_x: Math.ceil(slot_capacity / GRASS_CELL_COUNT_WORKGROUP_SIZE),
+                bindings: {
+                    settings,
+                    camera: camera.gpu_buffer,
+                    scene_database: scene.scene_database_buffer,
+                    grass_pool: surfaces.pool_buffer,
+                    grass_directory: surfaces.directory_buffer,
+                    grass_cell_counts: resources.get(data.counts),
+                    grass_cells: resources.get(data.cells),
+                },
+            });
+        });
+
+        cell_data.counts = cell_pass.create("cell counts", BufferResourceDescriptor.from(
+            collection_size(slot_capacity),
+            GPUBufferUsage.STORAGE,
+            // the count, which thread 0 writes
+            0, COLLECTION_HEADER_BYTES,
+        ));
+
+        cell_data.cells = cell_pass.create("cells", BufferResourceDescriptor.from(
+            slot_capacity * GRASS_CELL_WORDS * 4,
+            GPUBufferUsage.STORAGE,
+        ));
+
+        const sums = graph_prefix_scan_csdldf({
+            graph,
+            input: cell_data.counts,
+            output: graph_create_buffer(graph, "cell offsets", prefix_scan_csdldf_output_descriptor(slot_capacity)),
+            element_max_count: slot_capacity,
+        });
+
+        const command_data = {};
+
+        const command_pass = graph.add("make blade command", command_data, (data, resources, context) => {
+            shader_prefix_sum_to_command.dispatch({
+                encoder: context.encoder,
+                bindings: {
+                    prefix_sums: resources.get(data.prefix_sums),
+                    command: resources.get(data.command),
+                },
+            });
+        });
+
+        command_data.prefix_sums = command_pass.read(sums);
+        command_data.command = command_pass.create("blade command", INDIRECT_COMPUTE_COMMAND_DESCRIPTOR);
+
+        const expand_data = {};
+
+        const expand_pass = graph.add("make blades", expand_data, (data, resources, context) => {
+            const bindings = {
+                settings,
+                camera: camera.gpu_buffer,
+                scene_database: scene.scene_database_buffer,
+                prefix_sums: resources.get(data.prefix_sums),
+                grass_cells: resources.get(data.cells),
+                grass_species: this.#species_buffer,
+                grass_surfels: surfaces.atlas_view,
+                grass_blades: resources.get(data.blades),
+                grass_clock: this.#clock_buffer,
+                grass_press: resources.get(data.press),
+            };
+
+            this.press.bind(bindings);
+
+            // the wind as it is and as the frame before read it
+            scene.wind.bind_history(bindings);
+
+            shader_grass_blade_expand.dispatchIndirect({
+                encoder: context.encoder,
+                command: resources.get(data.command),
+                bindings,
+            });
+        });
+
+        expand_data.command = expand_pass.read(command_data.command);
+        expand_data.prefix_sums = expand_pass.read(sums);
+        expand_data.cells = expand_pass.read(cell_data.cells);
+        expand_data.press = expand_pass.read(press_field);
+        expand_data.blades = expand_pass.create("blade list", BufferResourceDescriptor.from(
+            (GRASS_BLADE_LIST_HEADER_WORDS + blade_capacity * GRASS_BLADE_RECORD_WORDS) * 4,
+            // read back for its count
+            GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+            // the count, which the blades raise from zero
+            0, GRASS_BLADE_LIST_HEADER_WORDS * 4,
+        ));
+
+        const args_data = {};
+
+        const args_pass = graph.add("make blade draw", args_data, (data, resources, context) => {
+            shader_grass_blade_draw_args.dispatch({
+                encoder: context.encoder,
+                bindings: {
+                    settings,
+                    grass_blades: resources.get(data.blades),
+                    draw_args: resources.get(data.draw_args),
+                },
+            });
+        });
+
+        args_data.blades = args_pass.write(args_pass.read(expand_data.blades));
+        args_data.draw_args = args_pass.create("blade draw arguments", BufferResourceDescriptor.from(
+            16,
+            GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT,
+        ));
+
+        graph.pop_scope();
+
+        const product = new BladeProduct();
+
+        product.blades = args_data.blades;
+        product.draw_args = args_data.draw_args;
+
+        this.#products.set(view, product);
+
+        // how many blades asked for a place: a list too small for them is made larger from the next frame
+        graph_read_buffer({ graph, buffer: args_data.blades, offset: GRASS_BLADE_LIST_COUNT * 4, size: 4 })
+            .then(reference => {
+                try {
+                    this.#blades_asked = Math.max(this.#blades_asked, new Uint32Array(reference.getValue())[0]);
+                } finally {
+                    reference.release();
+                }
+            })
+            .catch(() => {
+                // a reading lost to a timeout or a lost device: a later frame's carries it
+            });
+    }
+
+    /**
+     * Record a view's blade draw: its blades into the blade id target under the scene's depth, then the
+     * G-buffer's surface, the visibility word and the velocity under every pixel a blade covers. Publishes
+     * the depth, the G-buffer targets, the visibility buffer and the velocity buffer it wrote. Records nothing for a view {@link graph_generate} made no blades for this frame.
+     *
+     * @param {FrameContext} frame at the phase where the G-buffer is written into
+     */
+    graph_draw(frame) {
+        const view = frame.view;
+        const product = this.#products.get(view);
+
+        if (product === undefined) {
+            return;
+        }
+
+        this.#products.delete(view);
+
+        const graph = frame.graph;
+        const scene = view.scene;
+        const camera = view.camera;
+
+        const view_textures = frame.get(ViewTextures);
+        const gbuffer = frame.get(GBufferTextures);
+
+        graph.push_scope("grass blades");
+
+        const id_data = {};
+
+        const id_pass = graph.add("draw blade ids", id_data, (data, resources, context) => {
+            const encoder = context.encoder;
+
+            const bindings = GRASS_BLADE_ID_RESOURCES.generateBindings({
+                camera: camera.gpu_buffer,
+                scene_database: scene.scene_database_buffer,
+                grass_blades: resources.get(data.blades),
+            }, encoder);
+
+            const pass = encoder.constructRenderPass({
+                label: "Grass Blade Ids",
+                pipeline: GRASS_BLADE_ID_PIPELINE,
+                bindings,
+                colorAttachments: [{
+                    view: resources.get(data.ids).obtainView(MIP_0),
+                    loadOp: "clear",
+                    clearValue: [GRASS_BLADE_ID_NONE, 0, 0, 0],
+                    storeOp: "store",
+                }],
+                depthStencilAttachment: {
+                    view: resources.get(data.depth).obtainView(DEFAULT_DEPTH_TEXTURE_VIEW),
+                    // the scene's depth is what blades are hidden by, and what they then hide
+                    depthLoadOp: "load",
+                    depthStoreOp: "store",
+                },
+            });
+
+            pass.drawIndirect(resources.get(data.draw_args), 0);
+            pass.end();
+        });
+
+        id_data.blades = id_pass.read(product.blades);
+        id_data.draw_args = id_pass.read(product.draw_args);
+        id_data.depth = id_pass.write(view_textures.depth);
+        id_data.ids = id_pass.create("blade ids", TextureResourceDescriptor.from({
+            format: GRASS_BLADE_ID_FORMAT,
+            resolution: frame.resolution,
+            usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
+        }));
+
+        view_textures.depth = id_data.depth;
+
+        const resolve_data = {};
+
+        const inverse_view_projection = new Float32Array(16);
+        const view_projection_previous = new Float32Array(16);
+
+        view_velocity_matrices(view, inverse_view_projection, view_projection_previous);
+
+        const resolve_pass = graph.add("resolve blades", resolve_data, (data, resources, context) => {
+            const encoder = context.encoder;
+
+            const bindings = GRASS_BLADE_RESOLVE_RESOURCES.generateBindings({
+                camera: camera.gpu_buffer,
+                scene_database: scene.scene_database_buffer,
+                grass_blades: resources.get(data.blades),
+                grass_species: this.#species_buffer,
+                grass_ids: resources.get(data.ids).obtainView(MIP_0),
+                scene_depth: resources.get(data.depth).obtainView(DEFAULT_DEPTH_TEXTURE_VIEW),
+                inverse_view_projection: encoder.allocateTransientBufferAndLoad(inverse_view_projection.buffer, GPUBufferUsage.UNIFORM),
+                view_projection_previous: encoder.allocateTransientBufferAndLoad(view_projection_previous.buffer, GPUBufferUsage.UNIFORM),
+            }, encoder);
+
+            const attachment = handle => ({
+                view: resources.get(handle).obtainView(MIP_0),
+                // every pixel no blade covers keeps what the scene left there
+                loadOp: "load",
+                storeOp: "store",
+            });
+
+            const pass = encoder.constructRenderPass({
+                label: "Grass Blade Resolve",
+                pipeline: GRASS_BLADE_RESOLVE_PIPELINE,
+                bindings,
+                colorAttachments: [
+                    attachment(data.pbr),
+                    attachment(data.normal),
+                    attachment(data.albedo),
+                    attachment(data.emissive),
+                    attachment(data.visibility),
+                    attachment(data.velocity),
+                ],
+            });
+
+            pass.draw(3);
+            pass.end();
+        });
+
+        resolve_data.blades = resolve_pass.read(product.blades);
+        resolve_data.ids = resolve_pass.read(id_data.ids);
+        resolve_data.depth = resolve_pass.read(id_data.depth);
+
+        // in place: the written handles are what the record hands on
+        resolve_data.pbr = resolve_pass.write(gbuffer.pbr);
+        resolve_data.normal = resolve_pass.write(gbuffer.normal);
+        resolve_data.albedo = resolve_pass.write(gbuffer.albedo);
+        resolve_data.emissive = resolve_pass.write(gbuffer.emissive);
+
+        gbuffer.pbr = resolve_data.pbr;
+        gbuffer.normal = resolve_data.normal;
+        gbuffer.albedo = resolve_data.albedo;
+        gbuffer.emissive = resolve_data.emissive;
+
+        resolve_data.visibility = resolve_pass.write(view_textures.visibility);
+        resolve_data.velocity = resolve_pass.write(view_textures.velocity);
+
+        view_textures.visibility = resolve_data.visibility;
+        view_textures.velocity = resolve_data.velocity;
+
+        graph.pop_scope();
+    }
+
+    /**
+     * Let go of everything on the device. The species stay listed.
+     */
+    destroy() {
+        this.#species_buffer?.destroy();
+        this.#species_buffer = null;
+        this.#species_dirty = true;
+        this.#clock_buffer?.destroy();
+        this.#clock_buffer = null;
+        this.press.destroy();
+        this.#products.clear();
+    }
+}