fix(geometry): IfcBooleanClippingResult on walls with voids (#635) (#648)

Author: louistrue

.changeset/issue-635-boolean-clipping-result.md

@@ -0,0 +1,13 @@
+---
+"@ifc-lite/wasm": patch
+---
+
+Fix `IfcBooleanClippingResult` on walls clipped by `IfcPolygonalBoundedHalfSpace` (issue #635).
+
+Three related fixes that together restore correct geometry on walls whose body is a chained `IfcBooleanClippingResult`:
+
+1. **Round-window voids reach the post-clip mesh.** The `IfcOpeningElement` cut path now runs against the boolean-clipped wall mesh rather than the un-clipped extrusion, so windows and doors are subtracted from the actual visible wall body.
+2. **Polygonal-bounded half-space orientation.** The cutter prism is built by extruding the polygon along Position's Z-axis (per the IFC spec) instead of along the slope plane normal — gable walls #60012 and #67828 in AC20-FZK-Haus now narrow to a peak and span the full wall length at the bottom (was: inverted, point-down).
+3. **Chained polygonal half-space clips compose correctly.** When two `IfcPolygonalBoundedHalfSpace` cuts are stacked (one per gable side), the cutter prisms are now MERGED into a single mesh and applied in ONE BSP CSG op. Previously the first cut's output exceeded `MAX_CSG_POLYGONS_PER_MESH`, causing the second cut to silently drop and leaving a flat horizontal cap at the gable apex.
+
+Round-window opening profiles are also simplified before triangulation so AC20-style 36-segment circles fit under the CSG polygon budget instead of falling back to a square hole. CSG kernel diagnostics (`take_failures`) now surface every silent skip — including the `PolygonalBoundedHalfSpaceFallback` path — so callers can warn on geometry loss.

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

@@ -3594,11 +3594,6 @@ function __wbg_get_imports(memory) {
     imports.wbg.__wbg_warn_6e567d0d926ff881 = function(arg0) {
         console.warn(getObject(arg0));
     };
-    imports.wbg.__wbindgen_cast_059fe8fea69d1ac8 = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 182, function: Function { arguments: [Externref], shim_idx: 183, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1161, __wasm_bindgen_func_elem_1162);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);
@@ -3609,8 +3604,13 @@ function __wbg_get_imports(memory) {
         const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_8408bf1a4d6b6c8b = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 182, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 183, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    imports.wbg.__wbindgen_cast_5981c93f1c3e6401 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 181, function: Function { arguments: [Externref], shim_idx: 182, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1161, __wasm_bindgen_func_elem_1162);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_cast_c66ca3e1e2ec9281 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 181, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 182, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
         const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1161, __wasm_bindgen_func_elem_1162);
         return addHeapObject(ret);
     };

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

@@ -3375,8 +3375,8 @@ function __wbg_get_imports() {
         const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_a7f9b7b12781c1bc = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 169, function: Function { arguments: [Externref], shim_idx: 170, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    imports.wbg.__wbindgen_cast_87cdb333eb97349f = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 168, function: Function { arguments: [Externref], shim_idx: 169, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
         const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1251, __wasm_bindgen_func_elem_1252);
         return addHeapObject(ret);
     };

packages/wasm/pkg/.npmignore

@@ -113,10 +113,17 @@ impl Triangle {
 
 /// Maximum polygon count for either operand in a csgrs boolean operation.
 ///
-/// Rectangular solids are 12 triangles, so this still allows the simple box-like
-/// boolean cases we expect while avoiding the complex BSP trees that can overflow
-/// the browser's native call stack in WASM.
-const MAX_CSG_POLYGONS_PER_MESH: usize = 24;
+/// Rectangular solids are 12 triangles. A 16-segment circular prism — the
+/// downsampled form of a round-window opening (issue #635) — is 60
+/// triangles, and AC20-FZK-Haus packs two such prisms (outer + recessed)
+/// into a single opening element, totalling ~120 triangles for the cut.
+/// This budget accommodates that combined opening and the wall mesh
+/// without letting the BSP tree explode: 128 is the upper bound past
+/// which BSP CSG performance starts to degrade noticeably and the WASM
+/// browser stack is at risk.
+///
+/// Do NOT raise this above 128.
+const MAX_CSG_POLYGONS_PER_MESH: usize = 128;
 /// Maximum combined polygon count for CSG operations.
 const MAX_CSG_POLYGONS: usize = MAX_CSG_POLYGONS_PER_MESH * 2;
 
@@ -748,6 +755,48 @@ impl ClippingProcessor {
                         );
                         return Ok(host_mesh.clone());
                     }
+                    // Defensive: Manifold has been observed (Linux x86_64 CI,
+                    // AC20-FZK-Haus gable walls #60012/#67828) to return an
+                    // implausibly small result — e.g. 1 triangle from a
+                    // 12-triangle box host clipped by a polygonal-bounded
+                    // half-space prism that does NOT fully contain the host.
+                    // macOS aarch64 produces the expected pentagon on the
+                    // same input, so this is a cross-platform Manifold
+                    // determinism issue. When we detect a clearly-truncated
+                    // result, re-run the same op through the legacy BSP
+                    // path and keep whichever output looks like a real
+                    // clip. See `looks_degenerate` for the heuristic.
+                    if Self::manifold_result_looks_degenerate(host_mesh, &result) {
+                        let host_tris = host_mesh.indices.len() / 3;
+                        let result_tris = result.indices.len() / 3;
+                        eprintln!(
+                            "[manifold-csg] difference result looks degenerate \
+                             (host {} tris -> result {} tris); retrying via BSP fallback",
+                            host_tris, result_tris,
+                        );
+                        if let Some(bsp_result) = self.try_bsp_difference(host_mesh, opening_mesh) {
+                            if !Self::manifold_result_looks_degenerate(host_mesh, &bsp_result) {
+                                self.record_failure(
+                                    BoolOp::Difference,
+                                    BoolFailureReason::ManifoldOutputDegenerate {
+                                        host_tris,
+                                        result_tris,
+                                    },
+                                );
+                                return Ok(bsp_result);
+                            }
+                        }
+                        // BSP also failed or produced suspicious output —
+                        // record but keep Manifold's result (better than
+                        // un-cut, in many cases).
+                        self.record_failure(
+                            BoolOp::Difference,
+                            BoolFailureReason::ManifoldOutputDegenerate {
+                                host_tris,
+                                result_tris,
+                            },
+                        );
+                    }
                     return Ok(result);
                 }
                 Err(reason) => {
@@ -1271,6 +1320,71 @@ impl ClippingProcessor {
         }
     }
 
+    /// Heuristic: does this look like a botched CSG difference?
+    ///
+    /// Detects the Linux-specific Manifold pathology where a wall body
+    /// clipped by an `IfcPolygonalBoundedHalfSpace` prism collapses to a
+    /// near-empty result (e.g. 1 triangle from a 12-triangle host box).
+    /// macOS aarch64 produces the full pentagon on identical input, so
+    /// this is a kernel-determinism issue, not a malformed cutter.
+    ///
+    /// Rules:
+    ///  * An empty result is a legit outcome (cutter contains host) —
+    ///    NOT degenerate.
+    ///  * A closed-volume result needs at least 4 triangles. Anything
+    ///    below that is structurally broken.
+    ///  * For hosts with >= 12 triangles (typical IFC solid input), the
+    ///    output should retain at least 25 % of the host's triangle
+    ///    count when the cutter is partial.
+    #[cfg_attr(not(feature = "manifold-csg"), allow(dead_code))]
+    fn manifold_result_looks_degenerate(host: &Mesh, result: &Mesh) -> bool {
+        let result_tris = result.indices.len() / 3;
+        if result_tris == 0 {
+            return false;
+        }
+        if result_tris < 4 {
+            return true;
+        }
+        let host_tris = host.indices.len() / 3;
+        if host_tris >= 12 && result_tris * 4 < host_tris {
+            return true;
+        }
+        false
+    }
+
+    /// Run `host - opening` through the legacy in-tree BSP CSG kernel.
+    /// Returns `None` if the BSP path can't accept the inputs (operands
+    /// past the per-mesh polygon cap, degenerate polygon extraction,
+    /// etc.) — caller falls back to keeping the Manifold output.
+    ///
+    /// Used as a safety net under `manifold-csg` when Manifold's output
+    /// looks structurally broken (see [`Self::manifold_result_looks_degenerate`]).
+    /// The BSP path is more deterministic across OS/arch combos at the
+    /// cost of a hard 128-polygon-per-mesh cap.
+    #[cfg_attr(not(feature = "manifold-csg"), allow(dead_code))]
+    fn try_bsp_difference(&self, host_mesh: &Mesh, opening_mesh: &Mesh) -> Option<Mesh> {
+        let host_polys = Self::mesh_to_polygons(host_mesh);
+        let opening_polys = Self::mesh_to_polygons(opening_mesh);
+        if host_polys.is_empty() || opening_polys.is_empty() {
+            return None;
+        }
+        if !Self::can_run_csg_operation(host_polys.len(), opening_polys.len()) {
+            return None;
+        }
+        let result_polys = crate::bsp_csg::difference(host_polys, opening_polys);
+        match Self::polygons_to_mesh(&result_polys) {
+            Ok(mesh) => {
+                let cleaned = Self::remove_degenerate_triangles(&mesh, host_mesh);
+                if cleaned.is_empty() {
+                    None
+                } else {
+                    Some(cleaned)
+                }
+            }
+            Err(_) => None,
+        }
+    }
+
     /// Validate mesh for common issues
     fn validate_mesh(&self, mesh: &Mesh) -> bool {
         // Check for NaN/Inf in positions
@@ -1589,15 +1703,19 @@ mod tests {
 
     #[test]
     fn test_csg_operation_guard_rejects_complex_operands() {
+        // Build a mesh with > MAX_CSG_POLYGONS_PER_MESH triangles. A box is 12
+        // tris, so 12 stacked boxes = 144 tris, comfortably above the
+        // 128-poly budget set for issue #635 round-window CSG support.
         let box_mesh = aabb_to_mesh(Point3::new(0.0, 0.0, 0.0), Point3::new(1.0, 1.0, 1.0));
         let mut complex_mesh = Mesh::new();
-        complex_mesh.merge(&box_mesh);
-        complex_mesh.merge(&box_mesh);
-        complex_mesh.merge(&box_mesh);
+        for _ in 0..12 {
+            complex_mesh.merge(&box_mesh);
+        }
 
         let polys_complex = ClippingProcessor::mesh_to_polygons(&complex_mesh);
         let polys_box = ClippingProcessor::mesh_to_polygons(&box_mesh);
 
+        assert!(polys_complex.len() > MAX_CSG_POLYGONS_PER_MESH);
         assert!(!ClippingProcessor::can_run_csg_operation(polys_complex.len(), polys_box.len()));
     }
 }

packages/wasm/pkg/ifc-lite.js

@@ -98,6 +98,18 @@ pub enum BoolFailureReason {
     PolygonalBoundedHalfSpaceFallback,
     /// `IfcBooleanResult` operator string didn't match any known op.
     UnknownBooleanOperator(String),
+    /// Manifold's `difference` returned output that is implausibly small
+    /// relative to the host (e.g. 1 triangle from a 12-triangle box host
+    /// when the cutter does not fully contain the host). Observed on
+    /// Linux x86_64 for the AC20-FZK-Haus gable walls; macOS aarch64 on
+    /// the same input produces the expected pentagon. The caller logged
+    /// this and re-ran the same op through the legacy BSP path; the
+    /// retained output (Manifold or BSP) depends on which one looked
+    /// sane.
+    ManifoldOutputDegenerate {
+        host_tris: usize,
+        result_tris: usize,
+    },
     /// Catch-all for kernel-specific errors. Free-form because the legacy BSP
     /// returns `String` errors and Manifold (Sprint 2) will return its own.
     KernelError(String),
@@ -125,6 +137,13 @@ impl fmt::Display for BoolFailureReason {
             BoolFailureReason::UnknownBooleanOperator(op) => {
                 write!(f, "unknown IfcBooleanResult operator '{op}'")
             }
+            BoolFailureReason::ManifoldOutputDegenerate {
+                host_tris,
+                result_tris,
+            } => write!(
+                f,
+                "Manifold difference returned implausibly small result ({result_tris} triangles from {host_tris}-triangle host) — fell back to BSP"
+            ),
             BoolFailureReason::KernelError(msg) => write!(f, "kernel error: {msg}"),
         }
     }