@woosh/meep-engine 3.39.0 → 3.41.0

package/src/shade/renderer/rasterize/RasterizationJob.d.ts

@@ -6,8 +6,7 @@ export class RasterizationJob {
     pipeline_type: number;
     /**
      * Side-to-cullMode lookup applied per material bucket. Default {@link CullPolicy.Standard}
-     * matches main-pass culling. Shadow callers set {@link CullPolicy.Reversed} so the back
-     * face of sided geometry is what gets written into the shadow map.
+     * matches main-pass culling, which shadow casters use too.
      * @type {Readonly<Record<number, GPUCullMode>>}
      */
     cull_policy: Readonly<Record<number, GPUCullMode>>;

package/src/shade/renderer/rasterize/RasterizationJob.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RasterizationJob.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/rasterize/RasterizationJob.js"],"names":[],"mappings":";;;;AAcA;IACI,sBAAmD;IAEnD;;;;;OAKG;IACH,aAFU,SAAS,OAAO,MAAM,cAAc,CAAC,CAEb;IAElC;;OAEG;IACH,kCAAW;IACX;;;;OAIG;IACH,0CAAiB;IAEjB;;OAEG;IACH,4BAAa;IAEb;;;OAGG;IACH,UAFU,MAAM,EAAE,CAEV;IAER;;OAEG;IACH,yBAAQ;IAER;;;OAGG;IACH,gBAAyB;IAEzB;;;OAGG;IACH,sBAA+B;CAClC"}
+{"version":3,"file":"RasterizationJob.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/rasterize/RasterizationJob.js"],"names":[],"mappings":";;;;AAcA;IACI,sBAAmD;IAEnD;;;;OAIG;IACH,aAFU,SAAS,OAAO,MAAM,cAAc,CAAC,CAEb;IAElC;;OAEG;IACH,kCAAW;IACX;;;;OAIG;IACH,0CAAiB;IAEjB;;OAEG;IACH,4BAAa;IAEb;;;OAGG;IACH,UAFU,MAAM,EAAE,CAEV;IAER;;OAEG;IACH,yBAAQ;IAER;;;OAGG;IACH,gBAAyB;IAEzB;;;OAGG;IACH,sBAA+B;CAClC"}

package/src/shade/renderer/rasterize/RasterizationJob.js

@@ -17,8 +17,7 @@ export class RasterizationJob {
 
     /**
      * Side-to-cullMode lookup applied per material bucket. Default {@link CullPolicy.Standard}
-     * matches main-pass culling. Shadow callers set {@link CullPolicy.Reversed} so the back
-     * face of sided geometry is what gets written into the shadow map.
+     * matches main-pass culling, which shadow casters use too.
      * @type {Readonly<Record<number, GPUCullMode>>}
      */
     cull_policy = CullPolicy.Standard;

package/src/shade/renderer/rasterize/bucket/construct_primitive_state.d.ts

@@ -16,12 +16,11 @@ export function construct_primitive_state(draw_mode: ShadeDrawMode, side: ShadeD
  *
  *  - `Standard` is the main-pass mapping: a one-sided material renders the face its winding
  *    presents (cull back), `Double` renders both.
- *  - `Reversed` culls the other way, so the *back* face is what gets drawn. This is the
- *    standard "back-face shadow casting" / "front-face culling for shadow casters"
- *    technique — shadow callers select this policy so the surface written into the shadow
- *    map sits behind the lit surface, eliminating self-shadow acne on the lit side and
- *    keeping shadow casting consistent with the user's view of one-sided geometry.
- *    `Double` has no opposite and stays at `none`.
+ *  - `Reversed` culls the other way, so the *back* face is what gets drawn — "back-face
+ *    shadow casting". Shadow casters do not use it: they cull as the main view does, and the
+ *    shared rasterizer slope bias keeps acne off; back faces on top of that bias left a gap of
+ *    a shadow texel or so where a caster meets the ground. `Double` has no opposite and stays
+ *    at `none`.
  */
 export type CullPolicy = Readonly<Record<number, GPUCullMode>>;
 export namespace CullPolicy {

package/src/shade/renderer/rasterize/bucket/construct_primitive_state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"construct_primitive_state.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/construct_primitive_state.js"],"names":[],"mappings":"AA4DA;;;;;;GAMG;AACH,qDALW,aAAa,QACb,aAAa,gBACb,SAAS,OAAO,MAAM,cAAc,CAAC,GACnC,cAAc,CA2B1B;;;;;;;;;;;;;;;;;;yBA5DS,SAAS,OAAO,MAAM,cAAc,CAAC;;;;;;;;;AAe/C;;;;;;;GAOG;AACH,yCAFU,cAAc,aAAa,CAAC,CAKnC;8BAzD2B,iCAAiC;8BACjC,iCAAiC;+BAFhC,uDAAuD"}
+{"version":3,"file":"construct_primitive_state.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/construct_primitive_state.js"],"names":[],"mappings":"AA2DA;;;;;;GAMG;AACH,qDALW,aAAa,QACb,aAAa,gBACb,SAAS,OAAO,MAAM,cAAc,CAAC,GACnC,cAAc,CA2B1B;;;;;;;;;;;;;;;;;yBA5DS,SAAS,OAAO,MAAM,cAAc,CAAC;;;;;;;;;AAe/C;;;;;;;GAOG;AACH,yCAFU,cAAc,aAAa,CAAC,CAKnC;8BAxD2B,iCAAiC;8BACjC,iCAAiC;+BAFhC,uDAAuD"}

package/src/shade/renderer/rasterize/bucket/construct_primitive_state.js

@@ -23,12 +23,11 @@ const lut_topology = {
  *
  *  - `Standard` is the main-pass mapping: a one-sided material renders the face its winding
  *    presents (cull back), `Double` renders both.
- *  - `Reversed` culls the other way, so the *back* face is what gets drawn. This is the
- *    standard "back-face shadow casting" / "front-face culling for shadow casters"
- *    technique — shadow callers select this policy so the surface written into the shadow
- *    map sits behind the lit surface, eliminating self-shadow acne on the lit side and
- *    keeping shadow casting consistent with the user's view of one-sided geometry.
- *    `Double` has no opposite and stays at `none`.
+ *  - `Reversed` culls the other way, so the *back* face is what gets drawn — "back-face
+ *    shadow casting". Shadow casters do not use it: they cull as the main view does, and the
+ *    shared rasterizer slope bias keeps acne off; back faces on top of that bias left a gap of
+ *    a shadow texel or so where a caster meets the ground. `Double` has no opposite and stays
+ *    at `none`.
  *
  * @enum {Readonly<Record<number, GPUCullMode>>}
  */

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.d.ts

@@ -128,10 +128,10 @@ export type AVBOITSideChannel = {
         emission: number;
     };
     /**
-     * whether the channel would add nothing this frame;
+     * whether the channel would add nothing for this view;
      * asked before the orchestrator records, and a channel that answers `true` is not asked for
      * anything else in that frame.
      */
-    avboit_is_empty?: () => boolean;
+    avboit_is_empty?: (view: import("../../../view/GPUViewContext.js").GPUViewContext) => boolean;
 };
 //# sourceMappingURL=AVBOITSideChannel.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,sBAA4B,EAAE,OAAO,uCAAuC,EAAE,yBAAyB,CAAC;KACrG,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAKtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAU9D,MAAM,OAAO"}
+{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,sBAA4B,EAAE,OAAO,uCAAuC,EAAE,yBAAyB,CAAC;KACrG,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAKtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAU9D,CAAC,IAAI,EAAE,OAAO,iCAAiC,EAAE,cAAc,KAAK,OAAO"}

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js

@@ -86,7 +86,7 @@
  *     (`chunk_volumetrics_irradiance_sh`), for a channel whose fragments are lit: the renderer's
  *     indirect lighting, whichever mode it runs, and the scene's lights, shadowed and attenuated by
  *     the fog, written by the pass that lights the fog.
- * @property {() => boolean} [avboit_is_empty] whether the channel would add nothing this frame;
+ * @property {(view: import("../../../view/GPUViewContext.js").GPUViewContext) => boolean} [avboit_is_empty] whether the channel would add nothing for this view;
  *     asked before the orchestrator records, and a channel that answers `true` is not asked for
  *     anything else in that frame.
  */

package/src/shade/renderer/scene/SCENE_DATABASE_SPEC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SCENE_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SCENE_DATABASE_SPEC.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wDAOG;sCAlBmC,0CAA0C"}
+{"version":3,"file":"SCENE_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SCENE_DATABASE_SPEC.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,wDASG;sCAtBmC,0CAA0C"}

package/src/shade/renderer/scene/SCENE_DATABASE_SPEC.js

@@ -2,6 +2,8 @@ import { GPUDatabaseDefinition } from "../buffer/table/GPUDatabaseDefinition.js"
 import { MESH_INSTANCE_METADATA_STRUCT } from "./MESH_INSTANCE_METADATA_STRUCT.js";
 import { NODE3D_STRUCT } from "./NODE3D_STRUCT.js";
 import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "../volumetrics/PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
+import { WATER_BODY_STRUCT } from "../water/medium/WATER_BODIES_STRUCT.js";
+import { WATER_WAVE_RECORD_STRUCT } from "../water/surface/WATER_WAVE_RECORD_STRUCT.js";
 
 /**
  * Schema for the scene's GPU-resident records — meshes and the
@@ -16,8 +18,17 @@ export const SCENE_DATABASE_SPEC = GPUDatabaseDefinition.from({
     // GPUSceneVolumetrics whenever their version moves; read by the froxel volumetrics and by the
     // ray passes through chunk_participating_media_volumes_iterate
     participating_media_volumes: PARTICIPATING_MEDIA_VOLUME_STRUCT,
+    water_bodies: WATER_BODY_STRUCT,
+    water_waves: WATER_WAVE_RECORD_STRUCT,
 });
 
+SCENE_DATABASE_SPEC.add_link({ table: 'water_bodies', field: 'node', target_database: SCENE_DATABASE_SPEC,
+    target_table: 'transforms', nullable: false, owning: false });
+SCENE_DATABASE_SPEC.add_link({ table: 'water_bodies', field: 'wave', target_database: SCENE_DATABASE_SPEC,
+    target_table: 'water_waves', nullable: true, owning: true });
+SCENE_DATABASE_SPEC.add_link({ table: 'water_waves', field: 'node', target_database: SCENE_DATABASE_SPEC,
+    target_table: 'transforms', nullable: false, owning: false });
+
 // A mesh's transform. A mesh row and its transforms row are the same row — the entity's, one on —
 // so this word always names its own index, and it is declared as the link it is.
 SCENE_DATABASE_SPEC.add_link({

package/src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.d.ts

@@ -37,7 +37,7 @@ export type GeometryDeduplicateOptions = {
      */
     position_epsilon?: number;
     /**
-     * Max occurrences kept per rolling-hash bucket
+     * Max triangles kept per neighbourhood hash
      */
     seed_budget?: number;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"geometry_deduplicate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;GAUG;AACH,qGAHW,0BAA0B,GACxB,cAAc,CAAC,WAAW,WAAW,EAAE,CAAC,CAqNpD;;;;;gBA8Ea,MAAM;gBACN,MAAM;gBACN,MAAM;;;;YACN,MAAM;;;gBA1UN,UAAU;;;;qBACV,MAAM;;;;;;;;uBACN,MAAM;;;;kBAKN,MAAM;;4BArBQ,oDAAoD"}
+{"version":3,"file":"geometry_deduplicate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.js"],"names":[],"mappings":"AAyDA;;;;;;;;;;GAUG;AACH,qGAHW,0BAA0B,GACxB,cAAc,CAAC,WAAW,WAAW,EAAE,CAAC,CA4LpD;;;;;gBAoJa,MAAM;gBACN,MAAM;gBACN,MAAM;;;;YACN,MAAM;;;gBAlYN,UAAU;;;;qBACV,MAAM;;;;;;;;uBACN,MAAM;;;;kBAKN,MAAM;;4BAtBQ,oDAAoD"}

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