@woosh/meep-engine 3.40.0 → 3.42.0

package/src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.js

@@ -6,13 +6,14 @@ import { Transform64 } from "../../../../../engine/ecs/transform/Transform64.js"
 import { StandardAttributes } from "../../../geometry/StandardAttributes.js";
 import { anchor_grow_topological } from "./internal/anchor_grow_topological.js";
 import { cover_greedy } from "./internal/cover_greedy.js";
+import { face_neighbourhood_hash } from "./internal/face_neighbourhood_hash.js";
 import { geometry_extract_subset } from "./internal/geometry_extract_subset.js";
 import { geometry_to_topology } from "./internal/geometry_to_topology.js";
 import { GLOBAL_RESIDUAL_THRESHOLD_FRACTION, match_refit_and_validate } from "./internal/match_refit_validate.js";
 import { match_validate_topology } from "./internal/match_validate_topology.js";
-import { rolling_hash_anchor_index } from "./internal/rolling_hash_anchor_index.js";
-import { seed_correspondence_from_window } from "./internal/seed_correspondence_from_window.js";
-import { triangle_fingerprint_stream } from "./internal/triangle_fingerprint_stream.js";
+import { ANCHOR_STRIDE, neighbourhood_anchor_index } from "./internal/neighbourhood_anchor_index.js";
+import { seed_correspondence_from_face_pair } from "./internal/seed_correspondence_from_face_pair.js";
+import { vertex_attribute_pairs } from "./internal/vertex_attributes_equal.js";
 
 /**
  * @typedef GeometryDeduplicateOptions
@@ -23,9 +24,20 @@ import { triangle_fingerprint_stream } from "./internal/triangle_fingerprint_str
  *                                          own tolerance ≈ `min(diag_a, diag_b) * 1e-4`.
  *                                          When provided, the per-pair derivation is
  *                                          clamped to this value (the tighter wins).
- * @property {number} [seed_budget=256]     Max occurrences kept per rolling-hash bucket
+ * @property {number} [seed_budget=256]     Max triangles kept per neighbourhood hash
  */
 
+/**
+ * Edge-steps of neighbourhood each triangle's anchor hash takes in ({@link face_neighbourhood_hash}).
+ * Fewer make a hash that more unrelated triangles share, and more growth spent finding that out; more
+ * keep a triangle from anchoring unless the piece around it is that much wider, and thin pieces go
+ * unfound. Measured on Sponza through scene_optimize's meshlet round trip, triangles shared and time
+ * taken (single runs on a busy machine): 2 rounds 147.3k in 6.5 s, 3 rounds 145.8k in 5.2 s, 4 rounds
+ * 144.8k in 3.6 s, 6 rounds 136.4k in 2.6 s.
+ * @type {number}
+ */
+const NEIGHBOURHOOD_ROUNDS = 3;
+
 /**
  * Relative tolerance for the per-anchor `position_epsilon` derivation.
  * The smaller of the two paired geometries' bounding-box diagonals is multiplied
@@ -94,12 +106,14 @@ export function geometry_deduplicate({
     // loop can derive a per-pair tolerance without recomputing bounds.
     const geom_diagonals = compute_geometry_diagonals(unique_geoms);
 
-    // ────────────────────── Stage B: fingerprints ──────────────────────
-    let streams = unique_geoms.map(g => triangle_fingerprint_stream(g));
+    // ──────────────────── Stage B: neighbourhood hashes ────────────────────
+    // Keyed on the triangles around each triangle, not on its place in the index stream: a meshlet build
+    // orders a turned copy's triangles differently from the original's, and no run of them survives.
+    let hashes = unique_geoms.map(g => face_neighbourhood_hash(g, NEIGHBOURHOOD_ROUNDS));
 
-    // ────────────────── Stage C: rolling-hash anchors ──────────────────
-    const anchors = rolling_hash_anchor_index(streams, min_primitives, seed_budget);
-    streams = null; // fingerprint streams aren't needed past this point — let GC reclaim
+    // ────────────────────── Stage C: anchors ──────────────────────
+    const anchors = neighbourhood_anchor_index(hashes, seed_budget);
+    hashes = null; // the hashes aren't needed past this point — let GC reclaim
 
     // ────────────────────── Stage D: grow each anchor ──────────────────────
     /** @type {Map<number, BinaryTopology>} */
@@ -118,79 +132,52 @@ export function geometry_deduplicate({
     /** Per-geom faces already covered by an accepted grown match. */
     const grown_face_set_per_geom = new Map();
 
-    for (const anchor of anchors) {
-        const a_grown = get_or_create_set(grown_face_set_per_geom, anchor.a_geom);
-        const b_grown = get_or_create_set(grown_face_set_per_geom, anchor.b_geom);
+    /** @type {Map<number, number>} an anchor's seed, rewritten per attempt; growth works on a copy */
+    const seed = new Map();
 
-        if (a_grown.has(anchor.a_start) && b_grown.has(anchor.b_start)) continue;
-        if (anchor.a_geom === anchor.b_geom && anchor.a_start === anchor.b_start) continue;
+    for (let i = 0; i < anchors.length; i += ANCHOR_STRIDE) {
+        const a_index = anchors[i];
+        const a_face = anchors[i + 1];
+        const b_index = anchors[i + 2];
+        const b_face = anchors[i + 3];
 
-        const a_geom = unique_geoms[anchor.a_geom];
-        const b_geom = unique_geoms[anchor.b_geom];
-        const topology_a = get_topology(anchor.a_geom);
-        const topology_b = get_topology(anchor.b_geom);
+        const a_grown = get_or_create_set(grown_face_set_per_geom, a_index);
+        const b_grown = get_or_create_set(grown_face_set_per_geom, b_index);
 
-        const seed = seed_correspondence_from_window(
-            a_geom, b_geom,
-            topology_a, topology_b,
-            anchor.a_start, anchor.b_start,
-            min_primitives
-        );
-        if (seed === null) continue;
+        if (a_grown.has(a_face) && b_grown.has(b_face)) continue;
+
+        const topology_a = get_topology(a_index);
+        const topology_b = get_topology(b_index);
+        const attributes = vertex_attribute_pairs(unique_geoms[a_index], unique_geoms[b_index]);
 
         const pair_epsilon = derive_pair_epsilon(
-            geom_diagonals[anchor.a_geom],
-            geom_diagonals[anchor.b_geom],
+            geom_diagonals[a_index],
+            geom_diagonals[b_index],
             position_epsilon
         );
 
-        const grown = anchor_grow_topological({
-            geometry_a: a_geom,
-            geometry_b: b_geom,
-            topology_a, topology_b,
-            initial_vertex_correspondence: seed.vertex_correspondence,
-            seed_face_a: seed.seed_face_a,
-            seed_face_b: seed.seed_face_b,
-            position_epsilon: pair_epsilon,
-        });
-        if (grown === null) continue;
-        if (grown.faces_a.length < min_primitives) continue;
-
-        const matched_set_a = new Set(grown.faces_a);
-        if (!match_validate_topology(
-            topology_a, topology_b,
-            matched_set_a, grown.face_correspondence, grown.vertex_correspondence
-        )) {
-            continue;
-        }
+        // the anchor pairs two triangles; which corner lies on which is for attributes, then positions, to say
+        for (let offset = 0; offset < 3; offset++) {
+            if (!seed_correspondence_from_face_pair(seed, attributes, topology_a, topology_b, a_face, b_face, offset)) {
+                continue;
+            }
+
+            const match = grow_validated_match(
+                unique_geoms, a_index, b_index,
+                topology_a, topology_b,
+                seed, a_face, b_face,
+                pair_epsilon, min_primitives
+            );
 
-        // Global post-grow residual check: the per-face check inside growth
-        // uses the incrementally-refit transform, so cumulative drift can
-        // smuggle past-acceptable faces through while the final fit produces
-        // worse residuals elsewhere. Refit on all correspondences and reject
-        // if any vertex deviates by more than a fraction of pair_epsilon.
-        const validation = match_refit_and_validate({
-            geometry_a: a_geom,
-            geometry_b: b_geom,
-            vertex_correspondence: grown.vertex_correspondence,
-            transform: grown.transform,
-            threshold: pair_epsilon * GLOBAL_RESIDUAL_THRESHOLD_FRACTION,
-        });
-        if (!validation.valid) {
-            continue;
-        }
+            if (match === null) continue;
+
+            for (const f of match.faces_a) a_grown.add(f);
+            for (const f of match.faces_b) b_grown.add(f);
+
+            matches.push(match);
 
-        for (const f of grown.faces_a) a_grown.add(f);
-        for (const f of grown.faces_b) b_grown.add(f);
-
-        matches.push({
-            a_geom: anchor.a_geom,
-            b_geom: anchor.b_geom,
-            faces_a: grown.faces_a,
-            faces_b: grown.faces_b,
-            transform: grown.transform,
-            max_residual: validation.max_residual,
-        });
+            break;
+        }
     }
 
     // ────────────────────── Stage E: greedy cover ──────────────────────
@@ -267,6 +254,76 @@ export function geometry_deduplicate({
     return result;
 }
 
+/**
+ * Grow a match out from a seeded triangle pair, and keep it only if it covers at least `min_primitives`
+ * triangles, its connectivity is the same on both sides, and one transform fitted to all of it still
+ * places every vertex within tolerance.
+ *
+ * @param {Geometry[]} unique_geoms
+ * @param {number} a_geom index of A in `unique_geoms`
+ * @param {number} b_geom index of B in `unique_geoms`
+ * @param {BinaryTopology} topology_a
+ * @param {BinaryTopology} topology_b
+ * @param {Map<number, number>} seed vertex of A → vertex of B, for the seed triangles' corners
+ * @param {number} seed_face_a
+ * @param {number} seed_face_b
+ * @param {number} pair_epsilon
+ * @param {number} min_primitives
+ * @returns {import("./internal/cover_greedy.js").GrownMatchRecord|null}
+ */
+function grow_validated_match(
+    unique_geoms, a_geom, b_geom,
+    topology_a, topology_b,
+    seed, seed_face_a, seed_face_b,
+    pair_epsilon, min_primitives
+) {
+    const geometry_a = unique_geoms[a_geom];
+    const geometry_b = unique_geoms[b_geom];
+
+    const grown = anchor_grow_topological({
+        geometry_a,
+        geometry_b,
+        topology_a, topology_b,
+        initial_vertex_correspondence: seed,
+        seed_face_a,
+        seed_face_b,
+        position_epsilon: pair_epsilon,
+    });
+    if (grown === null) return null;
+    if (grown.faces_a.length < min_primitives) return null;
+
+    const matched_set_a = new Set(grown.faces_a);
+    if (!match_validate_topology(
+        topology_a, topology_b,
+        matched_set_a, grown.face_correspondence, grown.vertex_correspondence
+    )) {
+        return null;
+    }
+
+    // Global post-grow residual check: the per-face check inside growth
+    // uses the incrementally-refit transform, so cumulative drift can
+    // smuggle past-acceptable faces through while the final fit produces
+    // worse residuals elsewhere. Refit on all correspondences and reject
+    // if any vertex deviates by more than a fraction of pair_epsilon.
+    const validation = match_refit_and_validate({
+        geometry_a,
+        geometry_b,
+        vertex_correspondence: grown.vertex_correspondence,
+        transform: grown.transform,
+        threshold: pair_epsilon * GLOBAL_RESIDUAL_THRESHOLD_FRACTION,
+    });
+    if (!validation.valid) return null;
+
+    return {
+        a_geom,
+        b_geom,
+        faces_a: grown.faces_a,
+        faces_b: grown.faces_b,
+        transform: grown.transform,
+        max_residual: validation.max_residual,
+    };
+}
+
 /**
  * Bounding-box diagonal length per unique geometry, in input order.
  *
@@ -429,7 +486,12 @@ function match_transform_to_meep_transform(mt, piece_stats, max_residual) {
         if (delta > OVERSCALE_MAX_FRACTION) delta = OVERSCALE_MAX_FRACTION;
     }
 
-    if (delta === 0) return t;
+    if (delta === 0) {
+        // The solver writes components only, so the clone's matrix was never composed. An exact fit (a half
+        // turn, say) leaves no residual to boost, and still owes the matrix its rotation and scale.
+        t.updateMatrix();
+        return t;
+    }
 
     const boost = 1 + delta;
     t.setScale(t.scale_x * boost, t.scale_y * boost, t.scale_z * boost);

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

@@ -31,6 +31,13 @@
  *   - faces_b not yet claimed as instance or canonical anywhere
  *   - faces_a not yet claimed as instance anywhere (we allow them to keep
  *     serving as canonical for additional matches)
+ *   - within one geometry, faces_b sharing no face with faces_a: the piece is
+ *     drawn at the canonical's place and again at the instance's, so a shared
+ *     face would be drawn twice (a symmetric part matched onto itself)
+ *   - a new canonical face-set sharing no face with one already chosen in its
+ *     geometry: every piece of a geometry is drawn at the geometry's own place,
+ *     so two overlapping pieces draw the overlap twice. The same set exactly
+ *     is not new, and its piece is reused.
  *
  * @param {GrownMatchRecord[]} matches
  * @param {number} min_primitives  Drop matches smaller than this — they go to leftover

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

@@ -1 +1 @@
-{"version":3,"file":"cover_greedy.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/cover_greedy.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;GAMG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;GAWG;AACH,sCAJW,gBAAgB,EAAE,kBAClB,MAAM,GACJ,aAAa,EAAE,CA2F3B;;;;;YAhIa,MAAM;;;;YACN,MAAM;aACN,MAAM,EAAE;aACR,MAAM,EAAE;eACR,OAAO,uDAAuD,EAAE,WAAW;;;;;;kBAC3E,MAAM;;;YAON,MAAM;aACN,MAAM,EAAE;eACR,OAAO,uDAAuD,EAAE,WAAW;kBAC3E,MAAM;;;;;;wBAKN,MAAM;;;;YACN,MAAM;;;;qBACN,MAAM,EAAE;;;;eACR,qBAAqB,EAAE"}
+{"version":3,"file":"cover_greedy.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/cover_greedy.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;GAMG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,sCAJW,gBAAgB,EAAE,kBAClB,MAAM,GACJ,aAAa,EAAE,CAwG3B;;;;;YApJa,MAAM;;;;YACN,MAAM;aACN,MAAM,EAAE;aACR,MAAM,EAAE;eACR,OAAO,uDAAuD,EAAE,WAAW;;;;;;kBAC3E,MAAM;;;YAON,MAAM;aACN,MAAM,EAAE;eACR,OAAO,uDAAuD,EAAE,WAAW;kBAC3E,MAAM;;;;;;wBAKN,MAAM;;;;YACN,MAAM;;;;qBACN,MAAM,EAAE;;;;eACR,qBAAqB,EAAE"}

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

@@ -34,6 +34,13 @@
  *   - faces_b not yet claimed as instance or canonical anywhere
  *   - faces_a not yet claimed as instance anywhere (we allow them to keep
  *     serving as canonical for additional matches)
+ *   - within one geometry, faces_b sharing no face with faces_a: the piece is
+ *     drawn at the canonical's place and again at the instance's, so a shared
+ *     face would be drawn twice (a symmetric part matched onto itself)
+ *   - a new canonical face-set sharing no face with one already chosen in its
+ *     geometry: every piece of a geometry is drawn at the geometry's own place,
+ *     so two overlapping pieces draw the overlap twice. The same set exactly
+ *     is not new, and its piece is reused.
  *
  * @param {GrownMatchRecord[]} matches
  * @param {number} min_primitives  Drop matches smaller than this — they go to leftover
@@ -92,6 +99,9 @@ export function cover_greedy(matches, min_primitives) {
         }
         if (conflict) continue;
 
+        // (3) within one geometry, the two sides must not share a face
+        if (match.a_geom === match.b_geom && face_sets_intersect(match.faces_a, match.faces_b)) continue;
+
         // Accept. If another match has chosen this exact canonical face-set,
         // reuse the piece. Group candidates by a cheap hash, then deep-compare
         // on hash collision.
@@ -99,6 +109,17 @@ export function cover_greedy(matches, min_primitives) {
         let decision = find_decision(decisions_by_canonical.get(canonical_hash), match.a_geom, match.faces_a);
 
         if (decision === undefined) {
+            // (4) a new canonical face-set must not share a face with one already chosen
+            const a_canonical_set = get_or_create(claimed_as_canonical, match.a_geom);
+
+            for (const f of match.faces_a) {
+                if (a_canonical_set.has(f)) {
+                    conflict = true;
+                    break;
+                }
+            }
+            if (conflict) continue;
+
             decision = {
                 canonical_piece_id: next_piece_id++,
                 a_geom: match.a_geom,
@@ -113,7 +134,6 @@ export function cover_greedy(matches, min_primitives) {
             bucket.push(decision);
             decisions.push(decision);
 
-            const a_canonical_set = get_or_create(claimed_as_canonical, match.a_geom);
             for (const f of match.faces_a) a_canonical_set.add(f);
         }
 
@@ -173,3 +193,11 @@ function face_sets_equal(a, b) {
     }
     return true;
 }
+
+function face_sets_intersect(a, b) {
+    const seen = new Set(a);
+    for (const f of b) {
+        if (seen.has(f)) return true;
+    }
+    return false;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * 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: Geometry, rounds: number): Uint32Array;
+//# sourceMappingURL=face_neighbourhood_hash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"face_neighbourhood_hash.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/face_neighbourhood_hash.js"],"names":[],"mappings":"AAkGA;;;;;;;;;;;;;;;;GAgBG;AACH,oEAHW,MAAM,GACJ,WAAW,CAqDvB"}

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"}