fix(geometry): scale SAT triangle-plane epsilon by normal magnitude (#646)

* fix(geometry): scale SAT triangle-plane epsilon by normal magnitude

Wall outer faces sitting f32-coplanar with the opening box's max-axis
face survived the void cut on Smiley-West (issue #584) because the
SAT triangle-plane separation test used a fixed `1e-6` epsilon while
its operands (`triangle_offset`, `box_projection`) both scale with
`|triangle_normal|` ~= 2 * triangle_area. For a 2.0 m x 2.6 m wall
face, |triangle_normal| ~= 5.2, so the projection-space gap from a
~3e-7 m physical offset (the f32 -> f64 round-trip slop between the
wall mesh and the f64 opening box) becomes ~1.7e-6 in projection
units -- larger than the fixed 1e-6 -- and `triangle_intersects_box`
incorrectly reported the face as separated. The clipper then skipped
those triangles and the wall stayed uncut.

Fix: multiply SAT_EPSILON by `max(|triangle_normal|, 1.0)` for the
triangle-plane test only. The box-axis tests (T1) and edge-cross
tests (T3) continue to use the fixed epsilon since they project onto
unit-length axes.

Also harden T1/T3 with the same `+/- SAT_EPSILON` slack the prior
agent added (was already in this branch's working diff) so all three
SAT separation tests remain consistent.

Repro coverage:

* `tests/production_void_path_test.rs::smiley_584_all_host_walls_have_holes`
  exercises every host wall in AC-20-Smiley-West-10-Bldg.ifc through
  the production `process_element_with_voids` path, builds the
  `void_index` from `IfcRelVoidsElement` exactly as
  `process_geometry_batch` does, and ray-casts a 3x3 grid through
  each opening footprint along the wall thickness axis. Pre-fix:
  4/190 walls (#49545, #50281, #61905, #87842) returned 9 hits each
  -- fully solid. Post-fix: 0/190.
* `door_604_wall_55_has_a_hole` covers issue #604's regression case.
* `smiley_584_wall_0nqvcw_has_holes` covers the user-reported wall
  GUID `0NQVcwUgj2fup5UuFaDTfC` with two balcony openings.

The door.ifc fixture is committed so CI can run without an external
fetch; AC-20-Smiley-West-10-Bldg.ifc is fetched on demand via
`pnpm fixtures` and the test skips if missing.

Closes #584.

* chore(wasm): rebuild artifacts with SAT triangle-plane epsilon fix

Picks up the void-cut correctness fix from the previous commit so
production gets the un-cut wall fix without waiting for a new
release. Both single-thread and threaded bundles rebuilt at -O3.

Author: louistrue

Cargo.lock

@@ -607,6 +607,22 @@ export class IfcAPI {
    * multiple loads with different files.
    */
   setEntityIndex(ids: Uint32Array, starts: Uint32Array, lengths: Uint32Array): void;
+  /**
+   * Toggle the "render multilayer walls as a single solid" mode (issue #540).
+   *
+   * When `enabled` is `true`, every subsequent `parseMeshes*` call will
+   * suppress geometry emission for `IfcBuildingElementPart` entities whose
+   * `IfcRelAggregates` parent wall is sliceable (has an
+   * `IfcMaterialLayerSetUsage`) AND has its own `Representation`. The
+   * parent wall keeps its per-layer sub-mesh colouring, so the visual
+   * result is the same as the layered render but with one mesh per wall
+   * instead of one per layer part — much cheaper for both CPU and GPU.
+   *
+   * Default is `false`. Pass `true` before calling `parseMeshes`,
+   * `parseMeshesSubset`, `parseMeshesAsync`, `parseMeshesInstanced`, or
+   * `parseMeshesInstancedAsync`.
+   */
+  setMergeLayers(enabled: boolean): void;
   /**
    * Clear the cached entity index (call between loads when reusing
    * the same `IfcAPI` instance — e.g. the parser worker keeps one
@@ -1245,6 +1261,7 @@ export interface InitOutput {
   readonly ifcapi_scanGeometryEntitiesFast: (a: number, b: number, c: number) => number;
   readonly ifcapi_scanRelevantEntitiesFastBytes: (a: number, b: number, c: number) => number;
   readonly ifcapi_setEntityIndex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly ifcapi_setMergeLayers: (a: number, b: number) => void;
   readonly ifcapi_version: (a: number, b: number) => void;
   readonly instancedata_color: (a: number, b: number) => void;
   readonly instancedata_expressId: (a: number) => number;
@@ -1357,9 +1374,9 @@ export interface InitOutput {
   readonly wbg_rayon_poolbuilder_numThreads: (a: number) => number;
   readonly wbg_rayon_poolbuilder_receiver: (a: number) => number;
   readonly wbg_rayon_start_worker: (a: number) => void;
-  readonly __wasm_bindgen_func_elem_1092: (a: number, b: number, c: number) => void;
-  readonly __wasm_bindgen_func_elem_1091: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_1363: (a: number, b: number, c: number, d: number) => void;
+  readonly __wasm_bindgen_func_elem_1102: (a: number, b: number, c: number) => void;
+  readonly __wasm_bindgen_func_elem_1101: (a: number, b: number) => void;
+  readonly __wasm_bindgen_func_elem_1373: (a: number, b: number, c: number, d: number) => void;
   readonly memory: WebAssembly.Memory;
   readonly __wbindgen_export: (a: number) => void;
   readonly __wbindgen_export2: (a: number, b: number, c: number) => void;

packages/wasm-threaded/pkg/ifc-lite.d.ts

@@ -223,12 +223,12 @@ if (cachedTextEncoder) {
 
 let WASM_VECTOR_LEN = 0;
 
-function __wasm_bindgen_func_elem_1092(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_1092(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_1102(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_1102(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_1363(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_1363(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_1373(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_1373(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const GeoReferenceJsFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -1793,6 +1793,25 @@ export class IfcAPI {
         const len2 = WASM_VECTOR_LEN;
         wasm.ifcapi_setEntityIndex(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
     }
+    /**
+     * Toggle the "render multilayer walls as a single solid" mode (issue #540).
+     *
+     * When `enabled` is `true`, every subsequent `parseMeshes*` call will
+     * suppress geometry emission for `IfcBuildingElementPart` entities whose
+     * `IfcRelAggregates` parent wall is sliceable (has an
+     * `IfcMaterialLayerSetUsage`) AND has its own `Representation`. The
+     * parent wall keeps its per-layer sub-mesh colouring, so the visual
+     * result is the same as the layered render but with one mesh per wall
+     * instead of one per layer part — much cheaper for both CPU and GPU.
+     *
+     * Default is `false`. Pass `true` before calling `parseMeshes`,
+     * `parseMeshesSubset`, `parseMeshesAsync`, `parseMeshesInstanced`, or
+     * `parseMeshesInstancedAsync`.
+     * @param {boolean} enabled
+     */
+    setMergeLayers(enabled) {
+        wasm.ifcapi_setMergeLayers(this.__wbg_ptr, enabled);
+    }
     /**
      * Clear the cached entity index (call between loads when reusing
      * the same `IfcAPI` instance — e.g. the parser worker keeps one
@@ -3440,7 +3459,7 @@ function __wbg_get_imports(memory) {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_1363(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_1373(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -3572,26 +3591,26 @@ function __wbg_get_imports(memory) {
     imports.wbg.__wbg_warn_6e567d0d926ff881 = function(arg0) {
         console.warn(getObject(arg0));
     };
+    imports.wbg.__wbindgen_cast_14f34dd6042f46b7 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 167, function: Function { arguments: [Externref], shim_idx: 168, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1101, __wasm_bindgen_func_elem_1102);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_cast_42c169aabd4aa5c0 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 167, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 168, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1101, __wasm_bindgen_func_elem_1102);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
         // Cast intrinsic for `U64 -> Externref`.
         const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_62423eba93f4d670 = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 166, function: Function { arguments: [Externref], shim_idx: 167, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1091, __wasm_bindgen_func_elem_1092);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_cast_98c349af0503c7f4 = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 166, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 167, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1091, __wasm_bindgen_func_elem_1092);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
         // Cast intrinsic for `F64 -> Externref`.
         const ret = arg0;

packages/wasm-threaded/pkg/ifc-lite.js

@@ -113,6 +113,7 @@ export const ifcapi_scanEntityIndexShard: (a: number, b: number, c: number, d: n
 export const ifcapi_scanGeometryEntitiesFast: (a: number, b: number, c: number) => number;
 export const ifcapi_scanRelevantEntitiesFastBytes: (a: number, b: number, c: number) => number;
 export const ifcapi_setEntityIndex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const ifcapi_setMergeLayers: (a: number, b: number) => void;
 export const ifcapi_version: (a: number, b: number) => void;
 export const instancedata_color: (a: number, b: number) => void;
 export const instancedata_expressId: (a: number) => number;
@@ -225,9 +226,9 @@ export const wbg_rayon_poolbuilder_build: (a: number) => void;
 export const wbg_rayon_poolbuilder_numThreads: (a: number) => number;
 export const wbg_rayon_poolbuilder_receiver: (a: number) => number;
 export const wbg_rayon_start_worker: (a: number) => void;
-export const __wasm_bindgen_func_elem_1092: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_1091: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_1363: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_1102: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_1101: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_1373: (a: number, b: number, c: number, d: number) => void;
 export const memory: WebAssembly.Memory;
 export const __wbindgen_export: (a: number) => void;
 export const __wbindgen_export2: (a: number, b: number, c: number) => void;

packages/wasm-threaded/pkg/ifc-lite_bg.wasm

@@ -5,7 +5,7 @@
     "IFC-Lite Contributors"
   ],
   "description": "WebAssembly bindings for IFC-Lite",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "license": "MPL-2.0",
   "repository": {
     "type": "git",

packages/wasm-threaded/pkg/ifc-lite_bg.wasm.d.ts

@@ -5,7 +5,7 @@
     "IFC-Lite Contributors"
   ],
   "description": "WebAssembly bindings for IFC-Lite",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "license": "MPL-2.0",
   "repository": {
     "type": "git",

packages/wasm-threaded/pkg/package.json

@@ -1799,7 +1799,21 @@ impl GeometryRouter {
     }
 
     /// Test if a triangle intersects an axis-aligned bounding box using Separating Axis Theorem (SAT)
-    /// Returns true if triangle and box intersect, false if they are separated
+    /// Returns true if triangle and box intersect, false if they are separated.
+    ///
+    /// All separation tests use a small `SAT_EPSILON` slack so that a triangle
+    /// **lying exactly on a box face** (e.g. an extruded wall's outer face
+    /// that is coplanar with the opening AABB's `max.x` face after the opening
+    /// has been extended through the wall thickness) is reported as
+    /// intersecting and gets routed into the actual clipping path. Without
+    /// this slack, FP rounding can produce a tiny gap (the wall mesh is
+    /// stored in f32 and re-promoted to f64 here, while the opening box is
+    /// computed in pure f64) that the strict `<` reads as a separation — and
+    /// the wall's outer face survives un-clipped, leaving the wall solid
+    /// around its opening (issue #584 / Smiley-West balconies, follow-up:
+    /// the per-axis 1e-6 epsilon was correct for the box-axis tests but
+    /// undersized for the triangle-plane test, which uses an un-normalized
+    /// `triangle_normal` whose magnitude scales with triangle area).
     fn triangle_intersects_box(
         &self,
         v0: &Point3<f64>,
@@ -1810,6 +1824,13 @@ impl GeometryRouter {
     ) -> bool {
         use nalgebra::Vector3;
 
+        /// Float slack for SAT separation tests (1 micrometre at the IFC's
+        /// length unit). Big enough to absorb double-precision rounding
+        /// (`v.z - box_center.z` vs `(box_max.z - box_min.z) * 0.5`) on
+        /// box-coplanar triangles, small enough to not pull genuinely
+        /// separated triangles into the clipper.
+        const SAT_EPSILON: f64 = 1e-6;
+
         // Box center and half-extents
         let box_center = Point3::new(
             (box_min.x + box_max.x) * 0.5,
@@ -1850,7 +1871,7 @@ impl GeometryRouter {
             let tri_max = p0.max(p1).max(p2);
             let box_extent = box_half_extents[axis_idx];
 
-            if tri_max < -box_extent || tri_min > box_extent {
+            if tri_max < -box_extent - SAT_EPSILON || tri_min > box_extent + SAT_EPSILON {
                 return false; // Separated on this axis
             }
         }
@@ -1871,7 +1892,21 @@ impl GeometryRouter {
             box_projection += box_half_extents[i] * triangle_normal.dot(&axis).abs();
         }
 
-        if triangle_offset.abs() > box_projection {
+        // Normalize the per-axis epsilon by the triangle-normal magnitude.
+        //
+        // `triangle_normal` is the un-normalized cross product `e0 × e2`, so
+        // `|triangle_normal| ≈ 2 * triangle_area`. Both `triangle_offset` and
+        // `box_projection` scale linearly with that magnitude, but the
+        // physical-space rounding error a "near-coplanar" face needs to absorb
+        // does NOT scale with triangle area. Without scaling SAT_EPSILON, a
+        // tall/wide wall face sitting ~3e-7 m outside the opening box (well
+        // within the f32 → f64 round-trip slop introduced by the mesh
+        // pipeline) becomes a separation gap of ~1.7e-6 in projection units,
+        // which a fixed 1e-6 epsilon misses — leaving the wall's outer face
+        // un-clipped (Smiley-West uncut walls, follow-up to #584).
+        let normal_magnitude = triangle_normal.norm();
+        let t2_epsilon = SAT_EPSILON * normal_magnitude.max(1.0);
+        if triangle_offset.abs() > box_projection + t2_epsilon {
             return false; // Separated by triangle plane
         }
 
@@ -1909,7 +1944,9 @@ impl GeometryRouter {
                         box_half_extents[i] * axis_normalized.dot(&box_axis_vec).abs();
                 }
 
-                if tri_max < -box_projection || tri_min > box_projection {
+                if tri_max < -box_projection - SAT_EPSILON
+                    || tri_min > box_projection + SAT_EPSILON
+                {
                     return false; // Separated on this axis
                 }
             }