@woosh/meep-engine 3.39.0 → 3.41.0

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

@@ -0,0 +1,167 @@
+import { hash_mix2 } from "../../../../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../../../../core/math/hash/hash_mix3.js";
+import { lowbias32 } from "../../../../../../core/math/hash/lowbias32.js";
+import { triangle_fingerprint_stream } from "./triangle_fingerprint_stream.js";
+
+/**
+ * Stands in for the triangle across an edge that has none, or more than one: a boundary or a
+ * non-manifold edge. Any value does, so long as it is the same for every geometry.
+ * @type {number}
+ */
+const NO_NEIGHBOUR = 0x5bd1e995;
+
+/**
+ * For every triangle, the triangle across each of its three edges, where edge `k` runs from corner `k`
+ * to corner `k + 1`; -1 across a boundary edge or one shared by more than two triangles.
+ *
+ * Two triangles are neighbours when they share an edge's two vertex indices, which is how
+ * {@link geometry_to_topology} joins them too, so the triangles a hash reaches are the ones growth walks.
+ *
+ * @param {ArrayLike<number>|null} index three entries per triangle, or null for one vertex per corner
+ * @param {number} triangle_count
+ * @param {number} vertex_count
+ * @returns {Int32Array} `triangle_count * 3`
+ */
+function triangle_edge_neighbours(index, triangle_count, vertex_count) {
+    const corner_count = triangle_count * 3;
+
+    const result = new Int32Array(corner_count).fill(-1);
+
+    if (index === null) {
+        // no corner shares a vertex with another, so no edge is shared
+        return result;
+    }
+
+    // each edge filed under its lower vertex, so the two sides of an edge land in one short list
+    const start = new Uint32Array(vertex_count + 1);
+
+    for (let e = 0; e < corner_count; e++) {
+        const a = index[e];
+        const b = index[e - e % 3 + (e + 1) % 3];
+
+        start[(a < b ? a : b) + 1]++;
+    }
+
+    for (let v = 0; v < vertex_count; v++) {
+        start[v + 1] += start[v];
+    }
+
+    const cursor = start.slice(0, vertex_count);
+    const edges = new Uint32Array(corner_count);
+
+    for (let e = 0; e < corner_count; e++) {
+        const a = index[e];
+        const b = index[e - e % 3 + (e + 1) % 3];
+
+        edges[cursor[a < b ? a : b]++] = e;
+    }
+
+    for (let v = 0; v < vertex_count; v++) {
+        const end = start[v + 1];
+
+        for (let i = start[v]; i < end; i++) {
+            const e = edges[i];
+            const a = index[e];
+            const b = index[e - e % 3 + (e + 1) % 3];
+
+            if (a === b) {
+                // a degenerate triangle's collapsed edge joins nothing
+                continue;
+            }
+
+            const upper = a < b ? b : a;
+
+            let other = -1;
+            let sharing = 0;
+
+            for (let j = start[v]; j < end; j++) {
+                if (j === i) continue;
+
+                const f = edges[j];
+                const fa = index[f];
+                const fb = index[f - f % 3 + (f + 1) % 3];
+
+                if ((fa < fb ? fb : fa) === upper) {
+                    other = f;
+                    sharing++;
+                }
+            }
+
+            if (sharing === 1) {
+                result[e] = (other / 3) | 0;
+            }
+        }
+    }
+
+    return result;
+}
+
+/**
+ * One 32-bit hash per triangle that depends on the triangles within `rounds` edge-steps of it, and on
+ * nothing else: not on where any of them sits in the index stream, not on which corner a triangle's
+ * indices start at, and not on the rigid motion and uniform scale the geometry was placed with.
+ *
+ * Round 0 is the triangle's own {@link triangle_fingerprint_stream} fingerprint. Each round after that
+ * mixes in the three hashes across the triangle's edges, read in winding order and started at the
+ * smallest, so the same triangle indexed from another corner reads the same three in the same order.
+ *
+ * Two copies of a piece hash their triangles alike wherever a triangle's `rounds`-ring lies inside the
+ * piece, whatever order a meshlet build or an exporter left the triangles in. A triangle nearer the
+ * piece's edge than that sees what surrounds the piece, which differs between copies.
+ *
+ * @param {Geometry} geometry
+ * @param {number} rounds
+ * @returns {Uint32Array} one per triangle
+ */
+export function face_neighbourhood_hash(geometry, rounds) {
+    let hash = triangle_fingerprint_stream(geometry);
+
+    if (rounds === 0) {
+        return hash;
+    }
+
+    const triangle_count = hash.length;
+
+    const neighbours = triangle_edge_neighbours(
+        geometry.index !== null ? geometry.index.data : null,
+        triangle_count,
+        geometry.getVertexCount()
+    );
+
+    let next = new Uint32Array(triangle_count);
+
+    for (let round = 0; round < rounds; round++) {
+        for (let t = 0; t < triangle_count; t++) {
+            const n0 = neighbours[t * 3];
+            const n1 = neighbours[t * 3 + 1];
+            const n2 = neighbours[t * 3 + 2];
+
+            const h0 = n0 >= 0 ? hash[n0] : NO_NEIGHBOUR;
+            const h1 = n1 >= 0 ? hash[n1] : NO_NEIGHBOUR;
+            const h2 = n2 >= 0 ? hash[n2] : NO_NEIGHBOUR;
+
+            // the rotation of (h0, h1, h2) that starts at the smallest; ties go to the smaller next value
+            let x = h0, y = h1, z = h2;
+
+            if (h1 < x || (h1 === x && (h2 < y || (h2 === y && h0 < z)))) {
+                x = h1;
+                y = h2;
+                z = h0;
+            }
+
+            if (h2 < x || (h2 === x && (h0 < y || (h0 === y && h1 < z)))) {
+                x = h2;
+                y = h0;
+                z = h1;
+            }
+
+            next[t] = lowbias32(hash_mix2(hash_mix3(hash[t], x, y), z));
+        }
+
+        const swap = hash;
+        hash = next;
+        next = swap;
+    }
+
+    return hash;
+}

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

@@ -0,0 +1,25 @@
+/**
+ * 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: Uint32Array[], seed_budget: number): Uint32Array;
+/**
+ * Words per anchor in the array {@link neighbourhood_anchor_index} returns.
+ * @type {number}
+ */
+export const ANCHOR_STRIDE: number;
+//# sourceMappingURL=neighbourhood_anchor_index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"neighbourhood_anchor_index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/neighbourhood_anchor_index.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;GAiBG;AACH,yDALW,WAAW,EAAE,eACb,MAAM,GACJ,WAAW,CAoGvB;AAzHD;;;GAGG;AACH,4BAFU,MAAM,CAEe"}

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/atmosphere/phase/jd/build_lut_fog_parameters_jendersie_deon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_lut_fog_parameters_jendersie_deon.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/jd/build_lut_fog_parameters_jendersie_deon.js"],"names":[],"mappings":"AAeA;;;;;;;;;GASG;AACH,qEAPW,MAAM,iBACN,MAAM,iBACN,MAAM,GACJ,YAAY,CAoDxB;6BArE4B,wCAAwC"}
+{"version":3,"file":"build_lut_fog_parameters_jendersie_deon.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/jd/build_lut_fog_parameters_jendersie_deon.js"],"names":[],"mappings":"AAcA;;;;;;;;;GASG;AACH,qEAPW,MAAM,iBACN,MAAM,iBACN,MAAM,GACJ,YAAY,CAoDxB;6BArE4B,wCAAwC"}

package/src/shade/renderer/shader/chunk/atmosphere/phase/jd/build_lut_fog_parameters_jendersie_deon.js

@@ -1,5 +1,4 @@
 import { assert } from "../../../../../../../core/assert.js";
-import { to_half_float_uint16 } from "../../../../../../../core/binary/to_half_float_uint16.js";
 import { BinaryDataType } from "../../../../../../../core/binary/type/BinaryDataType.js";
 import { ColorSpace } from "../../../../../texture/ColorSpace.js";
 import { ShadeTexture } from "../../../../../texture/ShadeTexture.js";
@@ -33,7 +32,7 @@ export function build_lut_fog_parameters_jendersie_deon(
     const log_d_min = Math.log(min_diameter);
     const log_range = Math.log(max_diameter) - log_d_min;
 
-    const u16 = new Uint16Array(resolution * 4);
+    const f16 = new Float16Array(resolution * 4);
 
     const sample = [];
     for (let i = 0; i < resolution; i++) {
@@ -49,7 +48,7 @@ export function build_lut_fog_parameters_jendersie_deon(
         );
 
         for (let j = 0; j < 4; j++) {
-            u16[i * 4 + j] = to_half_float_uint16(sample[j]);
+            f16[i * 4 + j] = sample[j];
         }
 
         assert.greaterThanOrEqual(sample[3],0, "w_D must not be negative");
@@ -57,7 +56,7 @@ export function build_lut_fog_parameters_jendersie_deon(
     }
 
     const image = ShadeImage.fromArrayBuffer(
-        u16.buffer,
+        f16.buffer,
         4,
         BinaryDataType.Float16,
         resolution, 1, 1,
@@ -71,4 +70,4 @@ export function build_lut_fog_parameters_jendersie_deon(
     texture.dimensions = 1;
 
     return texture;
-}
+}

package/src/shade/renderer/shader/chunk/brdf/dfg/generate_dfg_texture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate_dfg_texture.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/brdf/dfg/generate_dfg_texture.js"],"names":[],"mappings":"AA8EA;;;;;GAKG;AACH;IAHoC,QAAQ;IAChB,UAAU,GAA3B,MAAM;SA2BhB"}
+{"version":3,"file":"generate_dfg_texture.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/brdf/dfg/generate_dfg_texture.js"],"names":[],"mappings":"AA0EA;;;;;GAKG;AACH;IAHoC,QAAQ;IAChB,UAAU,GAA3B,MAAM;SA2BhB"}

package/src/shade/renderer/shader/chunk/brdf/dfg/generate_dfg_texture.js

@@ -1,6 +1,5 @@
 import { BinaryBuffer } from "../../../../../../core/binary/BinaryBuffer.js";
 import { downloadAsFile } from "../../../../../../core/binary/downloadAsFile.js";
-import { to_half_float_uint16 } from "../../../../../../core/binary/to_half_float_uint16.js";
 import { BinaryDataType } from "../../../../../../core/binary/type/BinaryDataType.js";
 import { FrameGraph } from "../../../../../../engine/graphics/render/frame_graph/FrameGraph.js";
 import { ShadeGPUCommandContext } from "../../../../../device/ShadeGPUCommandContext.js";
@@ -40,10 +39,7 @@ function graph_download_texture({
             const texture_data = await texture.download();
 
             // encode to f16
-            const f16_data = new Uint16Array(texture.width * texture.height * 2);
-            for (let i = 0; i < texture_data.length; i++) {
-                f16_data[i] = to_half_float_uint16(texture_data[i]);
-            }
+            const f16_data = new Float16Array(texture_data);
 
 
             const image = ShadeImage.fromArrayBuffer(

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_importance.d.ts

@@ -0,0 +1,30 @@
+/**
+ * How far in from each edge of the screen the importance falls off, as a fraction of the screen's
+ * height (the horizontal falloff is the same distance in pixels).
+ * @type {number}
+ */
+export const SCREEN_IMPORTANCE_BORDER_FRACTION: number;
+/**
+ * Steps a pixel's importance is quantized to when it is summed with atomics: a pixel of full
+ * importance adds this much.
+ * @type {number}
+ */
+export const SCREEN_IMPORTANCE_STEPS: number;
+/**
+ * How much a pixel matters by where it is on screen: 1 over most of it, falling to 0 at the edges —
+ * the automatic exposure's metering mask, after
+ * https://www.unrealengine.com/en-US/tech-blog/how-epic-games-is-handling-auto-exposure-in-4-25 —
+ * shared by every pass that weighs pixels by their place on screen.
+ *
+ * - `screen_importance(uv, vertical_aspect, border_fraction)` — the mask, in [0, 1]; `vertical_aspect`
+ *   is the screen's height over its width, `border_fraction` the falloff's width
+ * - `screen_importance_weight(uv, vertical_aspect)` — the mask at
+ *   {@link SCREEN_IMPORTANCE_BORDER_FRACTION} as an integer for an atomic sum:
+ *   {@link SCREEN_IMPORTANCE_STEPS} at full importance, and never below 1, so that a pixel at the very
+ *   edge still counts
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_screen_importance: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_screen_importance.d.ts.map

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_importance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_screen_importance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_screen_importance.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,gDAFU,MAAM,CAEsC;AAEtD;;;;GAIG;AACH,sCAFU,MAAM,CAE0B;AAE1C;;;;;;;;;;;;;;GAcG;AACH,sCAFU,SAAS,CAwBjB;0BArDwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_importance.js

@@ -0,0 +1,54 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * How far in from each edge of the screen the importance falls off, as a fraction of the screen's
+ * height (the horizontal falloff is the same distance in pixels).
+ * @type {number}
+ */
+export const SCREEN_IMPORTANCE_BORDER_FRACTION = 0.13;
+
+/**
+ * Steps a pixel's importance is quantized to when it is summed with atomics: a pixel of full
+ * importance adds this much.
+ * @type {number}
+ */
+export const SCREEN_IMPORTANCE_STEPS = 64;
+
+/**
+ * How much a pixel matters by where it is on screen: 1 over most of it, falling to 0 at the edges —
+ * the automatic exposure's metering mask, after
+ * https://www.unrealengine.com/en-US/tech-blog/how-epic-games-is-handling-auto-exposure-in-4-25 —
+ * shared by every pass that weighs pixels by their place on screen.
+ *
+ * - `screen_importance(uv, vertical_aspect, border_fraction)` — the mask, in [0, 1]; `vertical_aspect`
+ *   is the screen's height over its width, `border_fraction` the falloff's width
+ * - `screen_importance_weight(uv, vertical_aspect)` — the mask at
+ *   {@link SCREEN_IMPORTANCE_BORDER_FRACTION} as an integer for an atomic sum:
+ *   {@link SCREEN_IMPORTANCE_STEPS} at full importance, and never below 1, so that a pixel at the very
+ *   edge still counts
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_screen_importance = CodeChunk.from(
+    //language=WGSL
+    `
+fn screen_importance(
+    uv: vec2<f32>,
+    vertical_aspect: f32,
+    border_fraction: f32
+) -> f32{
+
+    let fov = border_fraction * vec2(vertical_aspect, 1.0);
+
+    let border   = smoothstep(vec2(0.0, 0.0), fov, uv) * (1.0 - smoothstep(vec2(1.0, 1.0) - fov, vec2(1.0, 1.0), uv));
+
+    return border.x * border.y;
+}
+
+fn screen_importance_weight(uv: vec2<f32>, vertical_aspect: f32) -> u32 {
+    let importance = screen_importance(uv, vertical_aspect, ${SCREEN_IMPORTANCE_BORDER_FRACTION});
+
+    return max(1u, u32(importance * ${SCREEN_IMPORTANCE_STEPS}));
+}
+    `
+);

package/src/shade/renderer/shader/type/serde/read_gpu_typed_buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read_gpu_typed_buffer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/type/serde/read_gpu_typed_buffer.js"],"names":[],"mappings":"AAuGA;;;;GAIG;AACH,6CAHW,YAAY,yBAqDtB;AAwBD;;;;;;GAMG;AACH,8DALW,WAAW,eACX,MAAM,UACN,MAAM,GACJ,EAAE,CAsBd;6BAjN4B,4CAA4C"}
+{"version":3,"file":"read_gpu_typed_buffer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/type/serde/read_gpu_typed_buffer.js"],"names":[],"mappings":"AAwGA;;;;GAIG;AACH,6CAHW,YAAY,yBAqDtB;AAwBD;;;;;;GAMG;AACH,8DALW,WAAW,eACX,MAAM,UACN,MAAM,GACJ,EAAE,CAsBd;6BAlN4B,4CAA4C"}