@woosh/meep-engine 3.49.0 → 3.50.0

package/src/shade/renderer/fluid/query/GPUFluidQueries.js

@@ -0,0 +1,709 @@
+import { assert } from "../../../../core/assert.js";
+import { GPUDatabase } from "../../buffer/table/GPUDatabase.js";
+import { GPUDatabaseReadback } from "../../buffer/table/GPUDatabaseReadback.js";
+import { GPUReadbackStatus } from "../../buffer/table/GPUReadbackStatus.js";
+import { gpu_table_gather_shader } from "../../buffer/table/gpu_table_gather_shader.js";
+import { generate_record_writer } from "../../buffer/table/serde/generate_record_writer.js";
+import { WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION } from "../../gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
+import {
+    FLUID_QUERY_DATABASE_INITIAL_SIZE,
+    FLUID_QUERY_DATABASE_SPEC,
+    FLUID_QUERY_SAMPLE_DESCRIPTOR,
+    FLUID_QUERY_SAMPLE_STRUCT,
+    FLUID_QUERY_SAMPLE_TABLE,
+    FLUID_QUERY_STRUCT,
+    FLUID_QUERY_TABLE
+} from "./FLUID_QUERY_DATABASE_SPEC.js";
+import {
+    FLUID_QUERY_GATHER_ENTRY_WORDS,
+    FLUID_QUERY_GATHER_WORKGROUP_SIZE,
+    shader_fluid_query_gather
+} from "./shader_fluid_query_gather.js";
+
+/**
+ * @typedef {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
+ * @typedef {import("../../wind/GPUSceneWind.js").GPUSceneWind} GPUSceneWind
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+
+/**
+ * Floats a lattice sample lands as in a request's target: the wind's `x, y, z`, then 0.
+ * @type {number}
+ */
+export const FLUID_QUERY_SAMPLE_FLOATS = 4;
+
+const QUERY_WRITER = generate_record_writer(FLUID_QUERY_STRUCT);
+const SAMPLE_WRITER = generate_record_writer(FLUID_QUERY_SAMPLE_STRUCT);
+
+/** Bytes of a sample row, read back whole. */
+const SAMPLE_BYTES = FLUID_QUERY_SAMPLE_DESCRIPTOR.packed_element_size_bytes;
+
+/** Invocations a row of a gather dispatch holds along x. */
+const ROW_WIDTH = WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION * FLUID_QUERY_GATHER_WORKGROUP_SIZE;
+
+/** Entries every per-request list starts with, doubling. */
+const INITIAL_CAPACITY = 16;
+
+/*
+ Words of an in-flight request, FLIGHT_WORDS a request.
+*/
+const F_HANDLE = 0;
+const F_TAG = 1;
+const F_QUERY_ROW = 2;
+const F_FIRST_SAMPLE = 3;
+const F_SAMPLE_COUNT = 4;
+const F_SLOT = 5;
+const F_SLOT_OFFSET = 6;
+const F_TARGET_OFFSET = 7;
+const FLIGHT_WORDS = 8;
+
+/**
+ * A frame's lattices land here, back to back, before they are copied into the targets their
+ * requests named: the frame's requests are then one run of the readback's image and one copy out of
+ * the mapping, instead of a view made per request. Pooled, and in use until every request of its
+ * frame has settled.
+ */
+class StagingSlot {
+    /** @type {Float32Array} */
+    floats = new Float32Array(0);
+
+    /** @type {Uint8Array} */
+    bytes = new Uint8Array(0);
+
+    /** Requests of the slot's frame not yet settled. */
+    live = 0;
+}
+
+/**
+ * @param {Uint32Array|Float64Array|Uint8Array} array
+ * @param {number} length
+ * @returns {Uint32Array|Float64Array|Uint8Array} `array`, or a copy of it at least `length` long
+ */
+function fit(array, length) {
+    if (array.length >= length) {
+        return array;
+    }
+
+    const grown = new array.constructor(Math.max(length, 2 * array.length));
+
+    grown.set(array);
+
+    return grown;
+}
+
+/**
+ * # The GPU fluid read API, on the device
+ *
+ * GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md §12: lattices of the published wind field, read back to
+ * the CPU. The device half of `GPUFluidSystem#request`; the system keeps the handles and statuses
+ * its callers read, and hands each request in here tagged with its handle.
+ *
+ * ## A frame
+ *
+ *     request(box, counts, target, target_offset, tag)   ×n, at FrameStart, before
+ *     record({ graph, wind })                            the frame's requests become rows and a pass
+ *     ...
+ *     apply()                                            at the system's apply point, once a frame:
+ *     settled_tag(i), settled_status(i)                    what settled, for i < settled_count
+ *
+ * - **Rows.** {@link record} makes each request a `fluid_query` row and a run of `fluid_query_sample`
+ *   rows, one a lattice point ({@link FLUID_QUERY_DATABASE_SPEC}), and asks the readback for the run
+ *   (`GPUDatabaseReadback#request_run`, all or nothing).
+ * - **The pass**, recorded after the frame's publish of the wind field: the database's upload, then
+ *   the gather (`shader_fluid_query_gather`), which evaluates `wind_field_sample` at every lattice
+ *   point into the runs, then `readback.encode` — right after the gather, in the same pass.
+ * - **Delivery** is the readback's: in order, a batch a frame, at most `max_in_flight` (4) batches
+ *   in flight, a frame's requests past it dropped with a status. A delivered lattice is copied into
+ *   its target at {@link apply}; a delivered or dropped request's rows are freed there.
+ *
+ * Nothing is allocated per request at steady state: requests and their rows are integer stores into
+ * retained arrays and tables, a frame's lattices share one pooled staging array, and the pass reuses
+ * its record and bindings.
+ */
+export class GPUFluidQueries {
+
+    /**
+     * Offer the pipelines the read API dispatches — see {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        GPUDatabase.enquirePipelines(enquiry);
+        enquiry.compute.push(shader_fluid_query_gather.pipeline);
+        // a frame of many requests crosses the readback's gather threshold
+        enquiry.compute.push(gpu_table_gather_shader.pipeline);
+    }
+
+    /** @type {GPUDatabase} */
+    #database;
+
+    /** @type {GPUDatabaseReadback} */
+    #readback;
+
+    /** The sample table's readback handle. */
+    #samples;
+
+    /** @type {import("../../buffer/table/GPUTypedTable.js").GPUTypedTable} */
+    #query_table;
+
+    /** @type {import("../../buffer/table/GPUTypedTable.js").GPUTypedTable} */
+    #sample_table;
+
+    /** The staging record a request's row is written from. */
+    #query_record = {
+        low: new Float32Array(3),
+        first_sample: 0,
+        high: new Float32Array(3),
+        count_x: 0,
+        count_y: 0,
+        count_z: 0,
+    };
+
+    /** What a sample row holds until the gather writes it. */
+    #empty_sample = { velocity: new Float32Array(4) };
+
+    /*
+     Requests asked for and not yet recorded.
+    */
+    #asked_box = new Float64Array(6 * INITIAL_CAPACITY);
+    #asked_counts = new Uint32Array(3 * INITIAL_CAPACITY);
+    #asked_offsets = new Uint32Array(INITIAL_CAPACITY);
+    #asked_tags = new Uint32Array(INITIAL_CAPACITY);
+    /** @type {(Float32Array|null)[]} */
+    #asked_targets = [];
+    #asked_count = 0;
+
+    /*
+     Requests recorded and not yet settled, in the order they were recorded: FLIGHT_WORDS words each,
+     and the target beside them.
+    */
+    #flight = new Uint32Array(FLIGHT_WORDS * INITIAL_CAPACITY);
+    /** @type {(Float32Array|null)[]} */
+    #flight_targets = [];
+    #flight_count = 0;
+
+    /*
+     What the last apply settled, in the order the requests were recorded.
+    */
+    #settled_tags = new Uint32Array(INITIAL_CAPACITY);
+    #settled_status = new Uint8Array(INITIAL_CAPACITY);
+    #settled_count = 0;
+
+    /** @type {StagingSlot[]} */
+    #slots = [];
+
+    /** Pass records not in a graph. */
+    #free_passes = [];
+
+    /** The gather's settings, rewritten for every dispatch. */
+    #settings = { query_count: 0, sample_count: 0, row_width: ROW_WIDTH };
+
+    /** Bindings of the gather, rebound for every dispatch. */
+    #dispatch = {
+        encoder: null,
+        thread_count_x: 0,
+        thread_count_y: 1,
+        thread_count_z: 1,
+        bindings: { settings: null, database: null, list: null, wind_field: null, wind_field_atlas: null },
+    };
+
+    #destroyed = false;
+
+    /**
+     * @param {object} options
+     * @param {GPUDevice} options.device
+     */
+    constructor({ device }) {
+        assert.defined(device, 'device');
+
+        this.#database = new GPUDatabase({
+            device,
+            definition: FLUID_QUERY_DATABASE_SPEC,
+            label: 'Fluid / query',
+            initial_data_size_bytes: FLUID_QUERY_DATABASE_INITIAL_SIZE,
+        });
+
+        // its own, not the database's `readback`: the database's is applied and encoded by its
+        // update, which runs before the gather has written the rows
+        this.#readback = new GPUDatabaseReadback({
+            database: this.#database,
+            device,
+            label: 'Fluid / query / readback',
+        });
+
+        this.#samples = this.#readback.table(FLUID_QUERY_SAMPLE_TABLE);
+
+        this.#query_table = this.#database.get(FLUID_QUERY_TABLE);
+        this.#sample_table = this.#database.get(FLUID_QUERY_SAMPLE_TABLE);
+
+        // Every row is freed a frame or two after it was taken, so the occupancy's high bit falls and
+        // rises frame after frame: left to shrink, it reallocated its words on the way down and
+        // again on the way up (~70 bytes a request, measured). Its working set is a few frames of
+        // requests; it keeps it.
+        this.#query_table.occupancy.preventShrink();
+        this.#sample_table.occupancy.preventShrink();
+    }
+
+    /**
+     * The read API's database. For inspection.
+     * @returns {GPUDatabase}
+     */
+    get database() {
+        return this.#database;
+    }
+
+    /**
+     * The readback the lattices travel through: its `in_flight_count`, `delivered_count`,
+     * `dropped_count` and `stalled_count`. For inspection.
+     * @returns {GPUDatabaseReadback}
+     */
+    get readback() {
+        return this.#readback;
+    }
+
+    /**
+     * Requests holding rows: recorded and not yet delivered or dropped.
+     * @returns {number}
+     */
+    get in_flight_count() {
+        return this.#flight_count;
+    }
+
+    /**
+     * Rows of `fluid_query`: one per request in flight.
+     * @returns {number}
+     */
+    get query_count() {
+        return this.#query_table.count;
+    }
+
+    /**
+     * Rows of `fluid_query_sample`: the lattice points of every request in flight.
+     * @returns {number}
+     */
+    get sample_count() {
+        return this.#sample_table.count;
+    }
+
+    /**
+     * Requests the last {@link apply} (or {@link destroy}) settled.
+     * @returns {number}
+     */
+    get settled_count() {
+        return this.#settled_count;
+    }
+
+    /**
+     * @param {number} index below {@link settled_count}
+     * @returns {number} the tag the settled request was asked with
+     */
+    settled_tag(index) {
+        return this.#settled_tags[index];
+    }
+
+    /**
+     * @param {number} index below {@link settled_count}
+     * @returns {number} a {@link GPUReadbackStatus}: `Delivered`, its lattice now in its target, or
+     *   `Dropped`
+     */
+    settled_status(index) {
+        return this.#settled_status[index];
+    }
+
+    /**
+     * Ask for the lattice of `counts` samples over a box, for the frame {@link record} records next.
+     * Its samples land in `target` from `target_offset`, {@link FLUID_QUERY_SAMPLE_FLOATS} floats a
+     * point, x fastest, at the {@link apply} that settles it Delivered.
+     *
+     * @param {number} min_x world metres
+     * @param {number} min_y
+     * @param {number} min_z
+     * @param {number} max_x
+     * @param {number} max_y
+     * @param {number} max_z
+     * @param {number} count_x samples along x, at least 1
+     * @param {number} count_y
+     * @param {number} count_z
+     * @param {Float32Array} target
+     * @param {number} target_offset in floats
+     * @param {number} tag the caller's, a u32, reported back when the request settles
+     */
+    request(min_x, min_y, min_z, max_x, max_y, max_z, count_x, count_y, count_z, target, target_offset, tag) {
+        assert.notOk(this.#destroyed, 'destroyed');
+
+        const i = this.#asked_count;
+
+        if (6 * (i + 1) > this.#asked_box.length) {
+            this.#asked_box = fit(this.#asked_box, 6 * (i + 1));
+            this.#asked_counts = fit(this.#asked_counts, 3 * (i + 1));
+            this.#asked_offsets = fit(this.#asked_offsets, i + 1);
+            this.#asked_tags = fit(this.#asked_tags, i + 1);
+        }
+
+        const box = this.#asked_box;
+
+        box[6 * i] = min_x;
+        box[6 * i + 1] = min_y;
+        box[6 * i + 2] = min_z;
+        box[6 * i + 3] = max_x;
+        box[6 * i + 4] = max_y;
+        box[6 * i + 5] = max_z;
+
+        const counts = this.#asked_counts;
+
+        counts[3 * i] = count_x;
+        counts[3 * i + 1] = count_y;
+        counts[3 * i + 2] = count_z;
+
+        this.#asked_offsets[i] = target_offset;
+        this.#asked_tags[i] = tag;
+        this.#asked_targets[i] = target;
+
+        this.#asked_count = i + 1;
+    }
+
+    /**
+     * A staging slot free to take `floats` floats.
+     *
+     * @param {number} floats
+     * @returns {number} its index
+     */
+    #take_slot(floats) {
+        const slots = this.#slots;
+
+        let index = -1;
+
+        for (let i = 0; i < slots.length; i++) {
+            if (slots[i].live !== 0) {
+                continue;
+            }
+
+            if (slots[i].floats.length >= floats) {
+                index = i;
+                break;
+            }
+
+            if (index === -1) {
+                index = i;
+            }
+        }
+
+        if (index === -1) {
+            index = slots.length;
+            slots.push(new StagingSlot());
+        }
+
+        const slot = slots[index];
+
+        if (slot.floats.length < floats) {
+            slot.floats = new Float32Array(Math.max(floats, 2 * slot.floats.length));
+            slot.bytes = new Uint8Array(slot.floats.buffer);
+        }
+
+        return index;
+    }
+
+    /**
+     * Make the frame's requests rows and record their pass into `graph`: the database's upload, the
+     * gather, and the readback's encode. After the frame's publish of `wind`, which the gather reads.
+     * Nothing is recorded with no request asked since the last call.
+     *
+     * @param {object} options
+     * @param {FrameGraph} options.graph
+     * @param {GPUSceneWind} options.wind the scene's published wind field
+     * @returns {boolean} whether a pass was recorded
+     */
+    record({ graph, wind }) {
+        assert.notOk(this.#destroyed, 'destroyed');
+        assert.defined(graph, 'graph');
+        assert.defined(wind, 'wind');
+
+        const count = this.#asked_count;
+
+        if (count === 0) {
+            return false;
+        }
+
+        const counts = this.#asked_counts;
+
+        let total = 0;
+
+        for (let i = 0; i < count; i++) {
+            total += counts[3 * i] * counts[3 * i + 1] * counts[3 * i + 2];
+        }
+
+        const slot_index = this.#take_slot(FLUID_QUERY_SAMPLE_FLOATS * total);
+        const slot = this.#slots[slot_index];
+
+        const pass = this.#free_passes.pop() ?? { queries: this, wind: null, list: new Uint32Array(0), query_count: 0, sample_count: 0 };
+
+        pass.list = fit(pass.list, FLUID_QUERY_GATHER_ENTRY_WORDS * count);
+
+        const flight_end = this.#flight_count + count;
+
+        this.#flight = fit(this.#flight, FLIGHT_WORDS * flight_end);
+
+        const box = this.#asked_box;
+        const record = this.#query_record;
+        const query_table = this.#query_table;
+        const sample_table = this.#sample_table;
+        const readback = this.#readback;
+        const list = pass.list;
+        const flight = this.#flight;
+
+        let first_of_frame = 0;
+
+        for (let i = 0; i < count; i++) {
+            const count_x = counts[3 * i];
+            const count_y = counts[3 * i + 1];
+            const count_z = counts[3 * i + 2];
+
+            const samples = count_x * count_y * count_z;
+
+            const first_sample = sample_table.add_run_filled(samples, this.#empty_sample, SAMPLE_WRITER);
+
+            record.low[0] = box[6 * i];
+            record.low[1] = box[6 * i + 1];
+            record.low[2] = box[6 * i + 2];
+            record.high[0] = box[6 * i + 3];
+            record.high[1] = box[6 * i + 4];
+            record.high[2] = box[6 * i + 5];
+            record.first_sample = first_sample;
+            record.count_x = count_x;
+            record.count_y = count_y;
+            record.count_z = count_z;
+
+            const query_row = query_table.add_record(record, QUERY_WRITER);
+
+            const handle = readback.request_run(this.#samples, first_sample, samples, 0, SAMPLE_BYTES, slot.bytes, first_of_frame * SAMPLE_BYTES);
+
+            const f = this.#flight_count * FLIGHT_WORDS;
+
+            flight[f + F_HANDLE] = handle;
+            flight[f + F_TAG] = this.#asked_tags[i];
+            flight[f + F_QUERY_ROW] = query_row;
+            flight[f + F_FIRST_SAMPLE] = first_sample;
+            flight[f + F_SAMPLE_COUNT] = samples;
+            flight[f + F_SLOT] = slot_index;
+            flight[f + F_SLOT_OFFSET] = FLUID_QUERY_SAMPLE_FLOATS * first_of_frame;
+            flight[f + F_TARGET_OFFSET] = this.#asked_offsets[i];
+
+            this.#flight_targets[this.#flight_count] = this.#asked_targets[i];
+            this.#flight_count++;
+
+            this.#asked_targets[i] = null;
+
+            list[FLUID_QUERY_GATHER_ENTRY_WORDS * i] = query_row;
+            list[FLUID_QUERY_GATHER_ENTRY_WORDS * i + 1] = first_of_frame;
+
+            first_of_frame += samples;
+        }
+
+        slot.live += count;
+
+        this.#asked_count = 0;
+
+        pass.wind = wind;
+        pass.query_count = count;
+        pass.sample_count = total;
+
+        // it uploads the database and writes the readback's buffers, none of them the graph's
+        graph.add('Fluid / query / gather', pass, GPUFluidQueries.#execute).make_side_effect();
+
+        return true;
+    }
+
+    /**
+     * @param {object} pass
+     * @param {import("../../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
+     * @param {{encoder: import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
+     */
+    static #execute(pass, resources, context) {
+        const queries = pass.queries;
+
+        try {
+            if (!queries.#destroyed) {
+                queries.#encode(context.encoder, pass);
+            }
+        } finally {
+            pass.wind = null;
+            queries.#free_passes.push(pass);
+        }
+    }
+
+    /**
+     * @param {import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} encoder
+     * @param {object} pass
+     */
+    #encode(encoder, pass) {
+        const database = this.#database;
+
+        // the rows first: the gather reads the requests and writes their runs
+        if (database.has_pending_upload) {
+            database.update(encoder);
+        }
+
+        const settings = this.#settings;
+        const sample_count = pass.sample_count;
+
+        settings.query_count = pass.query_count;
+        settings.sample_count = sample_count;
+
+        const dispatch = this.#dispatch;
+        const b = dispatch.bindings;
+
+        b.settings = settings;
+        b.database = database.buffer;
+        b.list = encoder.allocateTransientBufferAndLoad(pass.list.buffer, GPUBufferUsage.STORAGE, 0, 4 * FLUID_QUERY_GATHER_ENTRY_WORDS * pass.query_count);
+
+        pass.wind.bind(b);
+
+        dispatch.encoder = encoder;
+        dispatch.thread_count_x = sample_count < ROW_WIDTH ? sample_count : ROW_WIDTH;
+        dispatch.thread_count_y = Math.ceil(sample_count / ROW_WIDTH);
+
+        shader_fluid_query_gather.dispatchThreads(dispatch);
+
+        dispatch.encoder = null;
+        b.settings = b.database = b.list = b.wind_field = b.wind_field_atlas = null;
+
+        // right after the gather: the copy reads what it wrote
+        this.#readback.encode(encoder);
+    }
+
+    /**
+     * The apply point, once a frame (`GPUFluidSystem#update`): the readback delivers every batch
+     * whose mapping has landed, oldest first, and starts the maps of the frames submitted since.
+     * What settled is reported in {@link settled_count}: a delivered lattice copied into its target,
+     * a dropped one leaving its target as it was; either way its rows are freed.
+     */
+    apply() {
+        this.#settled_count = 0;
+
+        if (this.#destroyed) {
+            return;
+        }
+
+        // a frame's requests the pipeline refused were dropped at its encode, and the readback
+        // recycles their handles at the apply that follows: settle them before it does
+        this.#settle();
+
+        this.#readback.apply();
+
+        this.#settle();
+    }
+
+    /**
+     * Settle every request in flight whose handle the readback has answered, keeping the rest in
+     * order.
+     */
+    #settle() {
+        const status = this.#readback.status;
+        const flight = this.#flight;
+        const targets = this.#flight_targets;
+        const slots = this.#slots;
+        const count = this.#flight_count;
+
+        let kept = 0;
+
+        for (let i = 0; i < count; i++) {
+            const f = i * FLIGHT_WORDS;
+            const outcome = status[flight[f + F_HANDLE]];
+
+            if (outcome !== GPUReadbackStatus.Delivered && outcome !== GPUReadbackStatus.Dropped) {
+                if (kept !== i) {
+                    flight.copyWithin(kept * FLIGHT_WORDS, f, f + FLIGHT_WORDS);
+                    targets[kept] = targets[i];
+                }
+
+                kept++;
+
+                continue;
+            }
+
+            const samples = flight[f + F_SAMPLE_COUNT];
+            const slot = slots[flight[f + F_SLOT]];
+
+            if (outcome === GPUReadbackStatus.Delivered) {
+                const source = slot.floats;
+                const target = targets[i];
+                const from = flight[f + F_SLOT_OFFSET];
+                const to = flight[f + F_TARGET_OFFSET];
+                const length = FLUID_QUERY_SAMPLE_FLOATS * samples;
+
+                for (let k = 0; k < length; k++) {
+                    target[to + k] = source[from + k];
+                }
+            }
+
+            this.#push_settled(flight[f + F_TAG], outcome);
+
+            this.#query_table.remove(flight[f + F_QUERY_ROW]);
+
+            const first = flight[f + F_FIRST_SAMPLE];
+            const sample_table = this.#sample_table;
+
+            for (let k = 0; k < samples; k++) {
+                sample_table.remove(first + k);
+            }
+
+            slot.live--;
+        }
+
+        for (let i = kept; i < count; i++) {
+            targets[i] = null;
+        }
+
+        this.#flight_count = kept;
+    }
+
+    /**
+     * @param {number} tag
+     * @param {number} status
+     */
+    #push_settled(tag, status) {
+        const i = this.#settled_count;
+
+        if (i === this.#settled_tags.length) {
+            this.#settled_tags = fit(this.#settled_tags, i + 1);
+            this.#settled_status = fit(this.#settled_status, i + 1);
+        }
+
+        this.#settled_tags[i] = tag;
+        this.#settled_status[i] = status;
+
+        this.#settled_count = i + 1;
+    }
+
+    /**
+     * Release the database and the readback, discarding any mapping still out. Every request asked
+     * or in flight settles `Dropped`, reported in {@link settled_count} as an {@link apply} would.
+     * Passes recorded into a graph that has not run yet encode nothing. Safe to call twice.
+     */
+    destroy() {
+        if (this.#destroyed) {
+            return;
+        }
+
+        this.#destroyed = true;
+        this.#settled_count = 0;
+
+        const flight = this.#flight;
+
+        for (let i = 0; i < this.#flight_count; i++) {
+            this.#push_settled(flight[i * FLIGHT_WORDS + F_TAG], GPUReadbackStatus.Dropped);
+            this.#flight_targets[i] = null;
+        }
+
+        for (let i = 0; i < this.#asked_count; i++) {
+            this.#push_settled(this.#asked_tags[i], GPUReadbackStatus.Dropped);
+            this.#asked_targets[i] = null;
+        }
+
+        this.#flight_count = 0;
+        this.#asked_count = 0;
+
+        this.#readback.destroy();
+        this.#database.destroy();
+    }
+}