@woosh/meep-engine 3.40.0 → 3.42.0

package/src/shade/renderer/scene/optimization/geometry/internal/neighbourhood_anchor_index.js

@@ -0,0 +1,124 @@
+import { array_quick_sort_by_lookup_uint } from "../../../../../../core/collection/array/array_quick_sort_by_lookup_uint.js";
+
+/**
+ * Words per anchor in the array {@link neighbourhood_anchor_index} returns.
+ * @type {number}
+ */
+export const ANCHOR_STRIDE = 4;
+
+/**
+ * Pair up triangles whose {@link face_neighbourhood_hash} values are equal, within a geometry or across
+ * two: each pair is a place where a copy may sit, for growth to confirm or throw out.
+ *
+ * Within one hash, every triangle is paired with the first, in input order (geometry, then triangle) -
+ * not every triangle with every other. A copy that matches the first is found from it, and one that
+ * does not still gets the first's canonical piece by another anchor; pairing them all only repeats
+ * growth that the first pair already did. On Sponza through scene_optimize's meshlet round trip,
+ * pairing them all grew 172k times against 41k, and shared fewer triangles: 144.5k against 145.8k.
+ *
+ * A hash shared by more than `seed_budget` triangles keeps the first `seed_budget` of them, so a
+ * featureless region repeated thousands of times does not swamp what follows.
+ *
+ * @param {Uint32Array[]} hash_streams one per geometry, one hash per triangle
+ * @param {number} seed_budget most triangles kept per hash, >= 2
+ * @returns {Uint32Array} {@link ANCHOR_STRIDE} words per anchor: a geometry, a triangle of it, b geometry,
+ * a triangle of it. The `a` side is the earlier of the two in input order.
+ */
+export function neighbourhood_anchor_index(hash_streams, seed_budget) {
+    let total = 0;
+
+    for (const stream of hash_streams) {
+        total += stream.length;
+    }
+
+    // every triangle of every geometry, numbered in input order
+    const hash = new Uint32Array(total);
+    const geometry_of = new Uint32Array(total);
+    const offset_of = new Uint32Array(hash_streams.length);
+
+    let cursor = 0;
+
+    for (let g = 0; g < hash_streams.length; g++) {
+        const stream = hash_streams[g];
+
+        offset_of[g] = cursor;
+        hash.set(stream, cursor);
+        geometry_of.fill(g, cursor, cursor + stream.length);
+
+        cursor += stream.length;
+    }
+
+    const order = new Uint32Array(total);
+
+    for (let i = 0; i < total; i++) {
+        order[i] = i;
+    }
+
+    array_quick_sort_by_lookup_uint(order, hash, 0, total - 1);
+
+    /*
+     Each shared hash's triangles, filed under the first of them in input order: where its run starts in
+     `order`, and how many of the run are kept. -1 for a triangle that is first of no run.
+    */
+    const run_of_first = new Int32Array(total).fill(-1);
+    const kept_of_first = new Uint32Array(total);
+
+    let anchor_count = 0;
+
+    for (let run_start = 0; run_start < total;) {
+        let run_end = run_start + 1;
+
+        while (run_end < total && hash[order[run_end]] === hash[order[run_start]]) {
+            run_end++;
+        }
+
+        if (run_end - run_start > 1) {
+            // the sort leaves equal hashes in no particular order; input order decides who is first and who is kept
+            order.subarray(run_start, run_end).sort();
+
+            const kept = Math.min(run_end - run_start, seed_budget);
+
+            run_of_first[order[run_start]] = run_start;
+            kept_of_first[order[run_start]] = kept;
+
+            anchor_count += kept - 1;
+        }
+
+        run_start = run_end;
+    }
+
+    /*
+     Emitted in input order of each run's first triangle, so growth meets the anchors geometry by geometry,
+     triangle by triangle. Growth claims the triangles it covers and later anchors inside them are skipped,
+     so the order decides which matches are grown: in the order the sort left the hashes, Sponza through
+     scene_optimize's meshlet round trip shared 125.7k triangles, against 145.8k in this one.
+    */
+    const anchors = new Uint32Array(anchor_count * ANCHOR_STRIDE);
+
+    let written = 0;
+
+    for (let first = 0; first < total; first++) {
+        const run_start = run_of_first[first];
+
+        if (run_start === -1) {
+            continue;
+        }
+
+        const first_geometry = geometry_of[first];
+        const first_triangle = first - offset_of[first_geometry];
+
+        const kept = kept_of_first[first];
+
+        for (let i = 1; i < kept; i++) {
+            const other = order[run_start + i];
+            const other_geometry = geometry_of[other];
+
+            anchors[written++] = first_geometry;
+            anchors[written++] = first_triangle;
+            anchors[written++] = other_geometry;
+            anchors[written++] = other - offset_of[other_geometry];
+        }
+    }
+
+    return anchors;
+}

package/src/shade/renderer/scene/optimization/geometry/internal/seed_correspondence_from_face_pair.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Lay triangle `face_b` of B on triangle `face_a` of A corner to corner, keeping the winding: corner `k`
+ * of A on corner `(k + offset) % 3` of B. Writes the three pairs into `out` (vertex of A → vertex of B)
+ * when every pair carries equal attributes.
+ *
+ * A triangle lies on another in three ways that keep the winding. Attributes usually rule out two; where
+ * they leave more than one, the caller grows from each in turn and lets positions decide.
+ *
+ * @param {Map<number, number>} out cleared first; left empty when the offset does not fit
+ * @param {import("./vertex_attributes_equal.js").VertexAttributePairs} attributes
+ * @param {BinaryTopology} topology_a
+ * @param {BinaryTopology} topology_b
+ * @param {number} face_a
+ * @param {number} face_b
+ * @param {number} offset 0, 1 or 2
+ * @returns {boolean} whether `out` holds a correspondence
+ */
+export function seed_correspondence_from_face_pair(out: Map<number, number>, attributes: import("./vertex_attributes_equal.js").VertexAttributePairs, topology_a: BinaryTopology, topology_b: BinaryTopology, face_a: number, face_b: number, offset: number): boolean;
+//# sourceMappingURL=seed_correspondence_from_face_pair.d.ts.map

package/src/shade/renderer/scene/optimization/geometry/internal/seed_correspondence_from_face_pair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed_correspondence_from_face_pair.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/seed_correspondence_from_face_pair.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;GAgBG;AACH,wDATW,IAAI,MAAM,EAAE,MAAM,CAAC,cACnB,OAAO,8BAA8B,EAAE,oBAAoB,kEAG3D,MAAM,UACN,MAAM,UACN,MAAM,GACJ,OAAO,CA0BnB"}

package/src/shade/renderer/scene/optimization/geometry/internal/seed_correspondence_from_face_pair.js

@@ -0,0 +1,48 @@
+import { bt_face_read_triangle_vertices } from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_face_read_triangle.js";
+import { vertex_attributes_match } from "./vertex_attributes_equal.js";
+
+const a_corners = [0, 0, 0];
+const b_corners = [0, 0, 0];
+
+/**
+ * Lay triangle `face_b` of B on triangle `face_a` of A corner to corner, keeping the winding: corner `k`
+ * of A on corner `(k + offset) % 3` of B. Writes the three pairs into `out` (vertex of A → vertex of B)
+ * when every pair carries equal attributes.
+ *
+ * A triangle lies on another in three ways that keep the winding. Attributes usually rule out two; where
+ * they leave more than one, the caller grows from each in turn and lets positions decide.
+ *
+ * @param {Map<number, number>} out cleared first; left empty when the offset does not fit
+ * @param {import("./vertex_attributes_equal.js").VertexAttributePairs} attributes
+ * @param {BinaryTopology} topology_a
+ * @param {BinaryTopology} topology_b
+ * @param {number} face_a
+ * @param {number} face_b
+ * @param {number} offset 0, 1 or 2
+ * @returns {boolean} whether `out` holds a correspondence
+ */
+export function seed_correspondence_from_face_pair(
+    out,
+    attributes,
+    topology_a, topology_b,
+    face_a, face_b,
+    offset
+) {
+    out.clear();
+
+    if (!bt_face_read_triangle_vertices(a_corners, topology_a, face_a)) return false;
+    if (!bt_face_read_triangle_vertices(b_corners, topology_b, face_b)) return false;
+
+    for (let k = 0; k < 3; k++) {
+        if (!vertex_attributes_match(attributes, a_corners[k], b_corners[(k + offset) % 3])) {
+            return false;
+        }
+    }
+
+    for (let k = 0; k < 3; k++) {
+        out.set(a_corners[k], b_corners[(k + offset) % 3]);
+    }
+
+    // a triangle with a repeated vertex has fewer than three to fit a transform to
+    return out.size === 3;
+}

package/src/shade/renderer/scene/rows/GPUSceneRows.d.ts

@@ -42,7 +42,8 @@ export function entity_of_row(row: number): number;
  * **Change flow is mark, then flush.** The systems that place entities listen to the dataset's
  * change events and {@link mark_local} or {@link mark_world}; nothing is read at mark time. The
  * flush, in `GPUSceneContext.build`, reads each marked entity's components once, consults
- * `GPUStateAuthority` then, writes the ranges the CPU owns, and clears the list. A world mark on
+ * `GPUStateAuthority` then, writes the ranges the CPU owns — and an offset the GPU has just taken,
+ * once ({@link mark_handover}) — and clears the list. A world mark on
  * an attached entity whose parent has a row writes nothing: its local offset and its parent are
  * unchanged, and the GPU composes the rest. That is what stops a root's move from costing a row
  * per descendant.
@@ -155,6 +156,21 @@ export class GPUSceneRows {
      * @param {number} entity
      */
     mark_local(entity: number): void;
+    /**
+     * The entity's offset passes to the GPU as it stands: a clip binds it for the first time, or a
+     * CPU writer that held it has let go and a clip still bound has it back. The next flush writes
+     * the offset into the row once more, though `GPUStateAuthority` already says the GPU writes it.
+     *
+     * The bit is granted at that moment, and the flush runs later, in the frame's build, and reads
+     * the bit then. So whatever was written since the last flush — an offset announced in the frame
+     * the clip binds; a holder's last step, or an offset it captured and put back — would never
+     * reach the row: the axes no bound clip keys would keep the previous pose on the GPU, while the
+     * CPU twin reads the offset. The axes a clip keys are rewritten by the resolve, which runs after
+     * the flush.
+     *
+     * @param {number} entity
+     */
+    mark_handover(entity: number): void;
     /**
      * The entity's world transform changed. For an entity the GPU composes under a parent row this
      * is nothing to write; for one carrying its world pose it is the row's contents.

package/src/shade/renderer/scene/rows/GPUSceneRows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneRows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/rows/GPUSceneRows.js"],"names":[],"mappings":"AAcA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH,sCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAoID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IA2II;;;;;;;;;OASG;IACH;QAR2C,OAAO,EAAvC,sBAAsB;QACC,UAAU;QACV,MAAM;QACD,UAAU,EAAtC,kBAAkB;QACU,SAAS,EAArC,kBAAkB;QACyB,IAAI,EAA/C,iCAAiC;QACW,QAAQ,QAAxC,sBAAsB;OAmB5C;IAED;;OAEG;IACH,iGAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,oBAA8B;IAE9B;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,8BAHoB,MAAM,QAAE,eAAe,QAAE,aAAa,QAAE,OAAO,KAAG,IAAI,QASzE;IAED;;;;;;;;;OASG;IACH,6BAHW,KAAK,GACH,OAAO,CAyBnB;IAED;;;;;;;;;;OAUG;IACH,gBAFW,MAAM,QAuChB;IAED;;;;;;;;OAQG;IACH,gBAFW,MAAM,QA0BhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,2EAOC;IAED;;;;OAIG;IACH,gCAEC;IAqCD;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,YACN,eAAe,YACf,aAAa,YACb,OAAO,QAgDjB;IAED;;;;;OAKG;IACH,oBAFW,MAAM,QAUhB;IAwCD;;;;OAIG;IACH,SAFa,MAAM,CAsDlB;IAyMD;;;;OAIG;IACH;;;;;;;;OAQG;IACH,4BAHW,MAAM,kBACG,MAAM,KAAG,IAAI,QAiBhC;IAyGD;;;;;OAKG;IACH,gBAUC;;CACJ;qCA1nCY,OAAO,kDAAkD,EAAE,sBAAsB;;iCAEjF,OAAO,sCAAsC,EAAE,kBAAkB;iCACjE,OAAO,sCAAsC,EAAE,kBAAkB;gDACjE,OAAO,yCAAyC,EAAE,iCAAiC;qCACnF,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,mCAAmC,EAAE,eAAe;4BAC3D,OAAO,iCAAiC,EAAE,aAAa;oBACvD,OAAO,wCAAwC,EAAE,KAAK"}
+{"version":3,"file":"GPUSceneRows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/rows/GPUSceneRows.js"],"names":[],"mappings":"AAcA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH,sCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AA0ID;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IA2II;;;;;;;;;OASG;IACH;QAR2C,OAAO,EAAvC,sBAAsB;QACC,UAAU;QACV,MAAM;QACD,UAAU,EAAtC,kBAAkB;QACU,SAAS,EAArC,kBAAkB;QACyB,IAAI,EAA/C,iCAAiC;QACW,QAAQ,QAAxC,sBAAsB;OAmB5C;IAED;;OAEG;IACH,iGAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,oBAA8B;IAE9B;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,8BAHoB,MAAM,QAAE,eAAe,QAAE,aAAa,QAAE,OAAO,KAAG,IAAI,QASzE;IAED;;;;;;;;;OASG;IACH,6BAHW,KAAK,GACH,OAAO,CAyBnB;IAED;;;;;;;;;;OAUG;IACH,gBAFW,MAAM,QAuChB;IAED;;;;;;;;OAQG;IACH,gBAFW,MAAM,QA0BhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;;;;;;;;;OAaG;IACH,sBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,2EAOC;IAED;;;;OAIG;IACH,gCAEC;IAqCD;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,YACN,eAAe,YACf,aAAa,YACb,OAAO,QAgDjB;IAED;;;;;OAKG;IACH,oBAFW,MAAM,QAUhB;IAwCD;;;;OAIG;IACH,SAFa,MAAM,CAsDlB;IA0MD;;;;OAIG;IACH;;;;;;;;OAQG;IACH,4BAHW,MAAM,kBACG,MAAM,KAAG,IAAI,QAiBhC;IAyGD;;;;;OAKG;IACH,gBAUC;;CACJ;qCAppCY,OAAO,kDAAkD,EAAE,sBAAsB;;iCAEjF,OAAO,sCAAsC,EAAE,kBAAkB;iCACjE,OAAO,sCAAsC,EAAE,kBAAkB;gDACjE,OAAO,yCAAyC,EAAE,iCAAiC;qCACnF,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,mCAAmC,EAAE,eAAe;4BAC3D,OAAO,iCAAiC,EAAE,aAAa;oBACvD,OAAO,wCAAwC,EAAE,KAAK"}

package/src/shade/renderer/scene/rows/GPUSceneRows.js

@@ -57,6 +57,12 @@ const MARK_LOCAL = 1;
 const MARK_WORLD = 2;
 const MARK_MESH = 4;
 
+/**
+ * The offset goes to the row although the GPU writes it now — see {@link GPUSceneRows#mark_handover}.
+ * Always carried with {@link MARK_LOCAL}.
+ */
+const MARK_HANDOVER = 8;
+
 /**
  * Staging for one `transforms` row, reused across every write. `global` and `prev_global` are read
  * only on a row's first write.
@@ -193,7 +199,8 @@ class MeshEntry {
  * **Change flow is mark, then flush.** The systems that place entities listen to the dataset's
  * change events and {@link mark_local} or {@link mark_world}; nothing is read at mark time. The
  * flush, in `GPUSceneContext.build`, reads each marked entity's components once, consults
- * `GPUStateAuthority` then, writes the ranges the CPU owns, and clears the list. A world mark on
+ * `GPUStateAuthority` then, writes the ranges the CPU owns — and an offset the GPU has just taken,
+ * once ({@link mark_handover}) — and clears the list. A world mark on
  * an attached entity whose parent has a row writes nothing: its local offset and its parent are
  * unchanged, and the GPU composes the rest. That is what stops a root's move from costing a row
  * per descendant.
@@ -564,6 +571,24 @@ export class GPUSceneRows {
         this.#mark(entity, MARK_LOCAL);
     }
 
+    /**
+     * The entity's offset passes to the GPU as it stands: a clip binds it for the first time, or a
+     * CPU writer that held it has let go and a clip still bound has it back. The next flush writes
+     * the offset into the row once more, though `GPUStateAuthority` already says the GPU writes it.
+     *
+     * The bit is granted at that moment, and the flush runs later, in the frame's build, and reads
+     * the bit then. So whatever was written since the last flush — an offset announced in the frame
+     * the clip binds; a holder's last step, or an offset it captured and put back — would never
+     * reach the row: the axes no bound clip keys would keep the previous pose on the GPU, while the
+     * CPU twin reads the offset. The axes a clip keys are rewritten by the resolve, which runs after
+     * the flush.
+     *
+     * @param {number} entity
+     */
+    mark_handover(entity) {
+        this.#mark(entity, MARK_LOCAL | MARK_HANDOVER);
+    }
+
     /**
      * The entity's world transform changed. For an entity the GPU composes under a parent row this
      * is nothing to write; for one carrying its world pose it is the row's contents.
@@ -845,10 +870,11 @@ export class GPUSceneRows {
 
         const parent_changed = this.#parent_row[entity] !== parent_row;
 
-        if ((flags & GPUStateAuthorityFlags.TransformAttachment) !== 0) {
+        if ((flags & GPUStateAuthorityFlags.TransformAttachment) !== 0 && (why & MARK_HANDOVER) === 0) {
             // The GPU writes this row's TRS — a clip, a pose the CPU never sees — and a CPU that
             // wrote it too would race what the animation just resolved. The parent row is still
-            // this side's, and changes only when the parent's own row comes or goes.
+            // this side's, and changes only when the parent's own row comes or goes. A hand-over
+            // is the one write past the bit: the offset as the GPU takes it.
             if (!parent_changed) {
                 return 0;
             }

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128_inverse.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Unnormalized inverse discrete Fourier transform of 128 complex values, in place:
+ * `x[m] = Σₙ X[n] · e^{+2πi·n·m/128}`.
+ *
+ * Radix-2 decimation in time over a private array: a bit-reversal permutation, then seven butterfly
+ * stages of 64 butterflies each — 448 in all, a fixed budget. One invocation transforms one line, so a
+ * kernel built on it needs no workgroup memory and no barriers.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fft128_inverse: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_fft128_inverse.d.ts.map

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128_inverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_fft128_inverse.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/fft/chunk_fft128_inverse.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,mCAFU,SAAS,CA8BU;0BAzCH,gCAAgC"}

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128_inverse.js

@@ -0,0 +1,42 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_complex_multiply } from "../complex/chunk_complex_multiply.js";
+
+/**
+ * Unnormalized inverse discrete Fourier transform of 128 complex values, in place:
+ * `x[m] = Σₙ X[n] · e^{+2πi·n·m/128}`.
+ *
+ * Radix-2 decimation in time over a private array: a bit-reversal permutation, then seven butterfly
+ * stages of 64 butterflies each — 448 in all, a fixed budget. One invocation transforms one line, so a
+ * kernel built on it needs no workgroup memory and no barriers.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fft128_inverse = CodeChunk.from(
+    //language=WGSL
+    `
+fn fft128_inverse(data: ptr<function, array<vec2<f32>, 128>>) {
+    for (var i = 0u; i < 128u; i++) {
+        let j = reverseBits(i) >> 25u;
+        if (j > i) {
+            let swap = (*data)[i];
+            (*data)[i] = (*data)[j];
+            (*data)[j] = swap;
+        }
+    }
+    for (var stage = 0u; stage < 7u; stage++) {
+        let span = 1u << stage;
+        // e^{+iπ·offset/span}: the inverse transform's twiddle for a butterfly over 2·span values
+        let turn = 3.14159265358979 / f32(span);
+        for (var k = 0u; k < 64u; k++) {
+            let offset = k & (span - 1u);
+            let i = ((k >> stage) << (stage + 1u)) + offset;
+            let j = i + span;
+            let angle = turn * f32(offset);
+            let t = complex_multiply(vec2<f32>(cos(angle), sin(angle)), (*data)[j]);
+            let u = (*data)[i];
+            (*data)[i] = u + t;
+            (*data)[j] = u - t;
+        }
+    }
+}
+`, [chunk_complex_multiply]);

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128x4_inverse_workgroup.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Four unnormalized inverse discrete Fourier transforms of 128 complex values, cooperatively by a workgroup of
+ * 256 invocations: `x[m] = Σₙ X[n] · e^{+2πi·n·m/128}` for each of the four lines of `fft128x4_lines`.
+ *
+ * The caller writes each line's input in bit-reversed order (`X[n]` at `reverseBits(n) >> 25`), calls
+ * `fft128x4_inverse(lane)` from every invocation in uniform control flow, and reads the output in natural order.
+ * Radix-2 decimation in time: seven stages, each invocation one butterfly of one line a stage, a barrier
+ * between stages. The values live in 4 KiB of workgroup memory instead of a private array per invocation, which
+ * a 128-point line spills to local memory.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fft128x4_inverse_workgroup: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_fft128x4_inverse_workgroup.d.ts.map

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128x4_inverse_workgroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_fft128x4_inverse_workgroup.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/fft/chunk_fft128x4_inverse_workgroup.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,+CAFU,SAAS,CAyBU;0BAtCH,gCAAgC"}

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128x4_inverse_workgroup.js

@@ -0,0 +1,39 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_complex_multiply } from "../complex/chunk_complex_multiply.js";
+
+/**
+ * Four unnormalized inverse discrete Fourier transforms of 128 complex values, cooperatively by a workgroup of
+ * 256 invocations: `x[m] = Σₙ X[n] · e^{+2πi·n·m/128}` for each of the four lines of `fft128x4_lines`.
+ *
+ * The caller writes each line's input in bit-reversed order (`X[n]` at `reverseBits(n) >> 25`), calls
+ * `fft128x4_inverse(lane)` from every invocation in uniform control flow, and reads the output in natural order.
+ * Radix-2 decimation in time: seven stages, each invocation one butterfly of one line a stage, a barrier
+ * between stages. The values live in 4 KiB of workgroup memory instead of a private array per invocation, which
+ * a 128-point line spills to local memory.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fft128x4_inverse_workgroup = CodeChunk.from(
+    //language=WGSL
+    `
+var<workgroup> fft128x4_lines: array<vec2<f32>, 512>;
+
+fn fft128x4_inverse(lane: u32) {
+    let line = (lane >> 6u) << 7u;
+    let k = lane & 63u;
+    for (var stage = 0u; stage < 7u; stage++) {
+        workgroupBarrier();
+        let span = 1u << stage;
+        let offset = k & (span - 1u);
+        let i = line + ((k >> stage) << (stage + 1u)) + offset;
+        let j = i + span;
+        // e^{+iπ·offset/span}: the inverse transform's twiddle for a butterfly over 2·span values
+        let angle = 3.14159265358979 / f32(span) * f32(offset);
+        let t = complex_multiply(vec2<f32>(cos(angle), sin(angle)), fft128x4_lines[j]);
+        let u = fft128x4_lines[i];
+        fft128x4_lines[i] = u + t;
+        fft128x4_lines[j] = u - t;
+    }
+    workgroupBarrier();
+}
+`, [chunk_complex_multiply]);

package/src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShaderResourceSetDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.js"],"names":[],"mappings":"AAuIA;IAoBI;;OAEG;IACH;cAFoB,MAAM;cAAQ,UAAU;MAI3C;IAED;;;;;OAKG;IACH,4BAMC;IAED;;;;;;;;;;;;OAYG;IACH,mBALW,MAAM,SACN,UAAU,GAAC,MAAM,GAEf,IAAI,CAoDhB;IAED;;;OAGG;IACH,8CAEC;IAGD;;;OAGG;IACH,6CAEC;IAaD;;;;OAIG;IACH;;;;;;;;;;;OAWG;IACH,sBAHW,MAAM,GACJ,OAAO,CAInB;IAED,+FAYC;IAED;;;;;;OAMG;IACH;QAJ4B,KAAK,GAAtB,MAAM;QACW,KAAK,GAAtB,MAAM;QACJ,6BAA6B,CAsBzC;IAED;;;;OAIG;IACH,gBAHW,6BAA6B,GAC3B,OAAO,CAQnB;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAW/B;IAED;;OAEG;IACH,oCAFa,wBAAwB,CAiBpC;IAED;;;OAGG;IACH,yBAFY,EAAE,EAAE,CAcf;IAED;;;;OAIG;IACH,8BAHW,iBAAe,MAAM,GACnB,wBAAwB,CAMpC;IAED;;;;;OAKG;IACH,qCAHW,sBAAsB,GACpB,oBAAoB,EAAE,CAgBlC;IAED;;;OAGG;IACH,qBAFY,SAAS,CAwGpB;IAED;;;;;;;;;;;;;;;OAeG;IACH,iCAHW,YAAY,GACV,OAAO,CAwFnB;;CACJ;;eA2BS,SAAS,2BAA2B,CAAC;;2BA1oBlC,OAAO,yCAAyC,EAAE,YAAY;qCAC9D,OAAO,2CAA2C,EAAE,sBAAsB;yBAC1E,OAAO,uBAAuB,EAAE,UAAU;8CALT,oCAAoC;yCAZzC,0DAA0D;0BAIzE,0BAA0B"}
+{"version":3,"file":"ShaderResourceSetDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.js"],"names":[],"mappings":"AAyIA;IAoBI;;OAEG;IACH;cAFoB,MAAM;cAAQ,UAAU;MAI3C;IAED;;;;;OAKG;IACH,4BAMC;IAED;;;;;;;;;;;;OAYG;IACH,mBALW,MAAM,SACN,UAAU,GAAC,MAAM,GAEf,IAAI,CAoDhB;IAED;;;OAGG;IACH,8CAEC;IAGD;;;OAGG;IACH,6CAEC;IAaD;;;;OAIG;IACH;;;;;;;;;;;OAWG;IACH,sBAHW,MAAM,GACJ,OAAO,CAInB;IAED,+FAYC;IAED;;;;;;OAMG;IACH;QAJ4B,KAAK,GAAtB,MAAM;QACW,KAAK,GAAtB,MAAM;QACJ,6BAA6B,CAsBzC;IAED;;;;OAIG;IACH,gBAHW,6BAA6B,GAC3B,OAAO,CAQnB;IAED;;;OAGG;IACH,qBAFW,iBAAe,MAAM,QAW/B;IAED;;OAEG;IACH,oCAFa,wBAAwB,CAiBpC;IAED;;;OAGG;IACH,yBAFY,EAAE,EAAE,CAcf;IAED;;;;OAIG;IACH,8BAHW,iBAAe,MAAM,GACnB,wBAAwB,CAMpC;IAED;;;;;OAKG;IACH,qCAHW,sBAAsB,GACpB,oBAAoB,EAAE,CAgBlC;IAED;;;OAGG;IACH,qBAFY,SAAS,CAwGpB;IAED;;;;;;;;;;;;;;;OAeG;IACH,iCAHW,YAAY,GACV,OAAO,CAwFnB;;CACJ;;eA2BS,SAAS,2BAA2B,CAAC;;2BA5oBlC,OAAO,yCAAyC,EAAE,YAAY;qCAC9D,OAAO,2CAA2C,EAAE,sBAAsB;yBAC1E,OAAO,uBAAuB,EAAE,UAAU;8CALT,oCAAoC;yCAZzC,0DAA0D;0BAIzE,0BAA0B"}

package/src/shade/renderer/shader/resource/ShaderResourceSetDescriptor.js

@@ -83,6 +83,8 @@ function gen_type_storage_texture(member) {
 
     if (member.viewDimension === "2d") {
         proper_type = "texture_storage_2d"
+    } else if (member.viewDimension === "2d-array") {
+        proper_type = "texture_storage_2d_array";
     } else if (member.viewDimension === "3d") {
         proper_type = "texture_storage_3d";
     } else {

package/src/shade/renderer/water/GPUWaterRenderer.d.ts

@@ -23,6 +23,21 @@ export class GPUWaterRenderer {
      * @type {import("./medium/GPUWaterBodies.js").GPUWaterBodies|null}
      */
     bodies: import("./medium/GPUWaterBodies.js").GPUWaterBodies | null;
+    /**
+     * What the lattice's per-frame lists may hold (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3). Grown from
+     * each view's totals, read back a frame or two later; a frame over a budget drops its tail until then.
+     */
+    lod_budgets: {
+        candidates: number;
+        interior: number;
+        boundary: number;
+        patches: number;
+    };
+    /**
+     * The lists' totals as the last read back frame needed them: candidates, interior cells, boundary cells, triangles
+     * drawn as themselves, patches.
+     */
+    lod_totals: Uint32Array;
     avboit_is_empty(view: any): boolean;
     /** Optional single-pixel readback on the next rendered water frame. No per-frame readback. */
     request_probe(uv: any): Promise<any>;

package/src/shade/renderer/water/GPUWaterRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAmBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAC7B;;;;OAIG;IACH,QAFU,OAAO,4BAA4B,EAAE,cAAc,GAAC,IAAI,CAEpD;IAQd,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBAKC;IAED;;;;;;;;;;;;;;;;MAyIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA4BJ"}
+{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAqBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAC7B;;;;OAIG;IACH,QAFU,OAAO,4BAA4B,EAAE,cAAc,GAAC,IAAI,CAEpD;IAOd;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;MAgJC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA4BJ"}