@ifc-lite/wasm 4.5.1 → 4.7.0

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -1,6 +1,84 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/**
+ * The overlap solid of one clashing pair, or the reason there is none.
+ */
+export class ClashIntersectionSolidJs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * `""` when `isSolid`, otherwise one of:
+     * - `"malformed-operand"` — any of FOUR malformations, all rejected
+     *   before the boolean runs, because computing on them would silently
+     *   drop the offending triangle (or worse) rather than report the true
+     *   operand:
+     *   1. `positionsA`/`positionsB` is not a flat `[x, y, z, …]` triple
+     *      (length not a multiple of 3);
+     *   2. `indicesA`/`indicesB` has a length that is not a multiple of 3,
+     *      so it does not describe whole triangles;
+     *   3. `indicesA`/`indicesB` references a vertex past the end of its own
+     *      operand's positions;
+     *   4. a position is **non-finite** (NaN or infinity). This one is worth
+     *      calling out to callers: a NaN coordinate is caught by neither
+     *      length check, and left alone it can be absorbed into a
+     *      normal-looking answer or corrupt a face enough to report a
+     *      genuinely overlapping pair as `"no-overlap"`. So if you are
+     *      debugging an unexpected `"no-overlap"`, check your inputs for
+     *      NaN — it surfaces here, not there.
+     * - `"empty-operand"` — an operand had no triangles.
+     * - `"no-overlap"` — the exact intersection is empty. Covers a disjoint
+     *   pair AND a *touching* pair, including any graze below the kernel's
+     *   `2^-16 m ≈ 15.26 µm` snap grid (both faces snap flush).
+     * - `"below-kernel-resolution"` — the pair overlaps, but too shallowly for
+     *   the kernel to resolve as a solid rather than a coplanar contact. See
+     *   `thicknessM` / `requiredM`.
+     * - `"budget-exhausted"` — the escalation budget tripped; the arrangement
+     *   is partial and nothing about it is trustworthy.
+     */
+    readonly degenerateReason: string;
+    /**
+     * Triangle indices into `positions / 3`.
+     */
+    readonly indices: Uint32Array;
+    /**
+     * True when a trustworthy overlap solid was produced. When false, every
+     * geometry getter is empty and `degenerateReason` says why.
+     */
+    readonly isSolid: boolean;
+    /**
+     * World-space vertex positions, flat `[x, y, z, …]`, f64.
+     *
+     * f64 rather than the f32 the rest of the mesh pipeline uses because the
+     * caller reports this solid's volume: the f32 round-trip costs ~1e-7
+     * relative, a thousand times the exactness the kernel actually delivers.
+     * Downcast to f32 at the GPU upload if the renderer wants it.
+     */
+    readonly positions: Float64Array;
+    /**
+     * For `"below-kernel-resolution"`: the depth this pair would have needed
+     * for the kernel to resolve a solid, in metres. `0` otherwise. Grows with
+     * distance from the world origin, as the kernel's own tolerance does.
+     */
+    readonly requiredM: number;
+    /**
+     * For `"below-kernel-resolution"`: the overlap's measured thinnest extent,
+     * in metres. `0` otherwise. Useful to tell the user how shallow the clash
+     * is even though no solid can be drawn.
+     */
+    readonly thicknessM: number;
+    /**
+     * Triangle count of the solid; `0` when degenerate.
+     */
+    readonly triangleCount: number;
+    /**
+     * Enclosed volume in m³. `0` when not a solid — check `isSolid` first;
+     * "no measurable overlap" and "an overlap of zero" are different claims.
+     */
+    readonly volumeM3: number;
+}
+
 /**
  * Packed result of one rule run. Parallel arrays, one entry per clash record;
  * `points` has 3 per record and `bounds` has 6 per record.
@@ -13,6 +91,7 @@ export class ClashRunResult {
     readonly b: Uint32Array;
     readonly bounds: Float64Array;
     readonly distance: Float64Array;
+    readonly distanceKind: Uint8Array;
     readonly points: Float64Array;
     readonly status: Uint8Array;
 }
@@ -1600,6 +1679,24 @@ export class ZoneSplitJs {
     readonly wholeVolume: number;
 }
 
+/**
+ * Compute the intersection solid of one clashing pair.
+ *
+ * `positionsA` / `positionsB` are flat world-space XYZ; `indicesA` /
+ * `indicesB` are flat triangle indices into their own operand.
+ *
+ * ```javascript
+ * const solid = clashIntersectionSolid(posA, idxA, posB, idxB);
+ * if (solid.isSolid) {
+ *   draw(solid.positions, solid.indices, solid.volumeM3);
+ * } else {
+ *   keepContactMarker(solid.degenerateReason); // e.g. "no-overlap"
+ * }
+ * solid.free();
+ * ```
+ */
+export function clashIntersectionSolid(positions_a: Float32Array, indices_a: Uint32Array, positions_b: Float32Array, indices_b: Uint32Array): ClashIntersectionSolidJs;
+
 /**
  * `a - b`, keeping EVERY disjoint remnant.
  *
@@ -1724,6 +1821,7 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
+    readonly __wbg_clashintersectionsolidjs_free: (a: number, b: number) => void;
     readonly __wbg_clashrunresult_free: (a: number, b: number) => void;
     readonly __wbg_clashsession_free: (a: number, b: number) => void;
     readonly __wbg_contours2d_free: (a: number, b: number) => void;
@@ -1745,10 +1843,20 @@ export interface InitOutput {
     readonly __wbg_symbolictext_free: (a: number, b: number) => void;
     readonly __wbg_zonepiecejs_free: (a: number, b: number) => void;
     readonly __wbg_zonesplitjs_free: (a: number, b: number) => void;
+    readonly clashIntersectionSolid: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+    readonly clashintersectionsolidjs_degenerateReason: (a: number, b: number) => void;
+    readonly clashintersectionsolidjs_indices: (a: number, b: number) => void;
+    readonly clashintersectionsolidjs_isSolid: (a: number) => number;
+    readonly clashintersectionsolidjs_positions: (a: number, b: number) => void;
+    readonly clashintersectionsolidjs_requiredM: (a: number) => number;
+    readonly clashintersectionsolidjs_thicknessM: (a: number) => number;
+    readonly clashintersectionsolidjs_triangleCount: (a: number) => number;
+    readonly clashintersectionsolidjs_volumeM3: (a: number) => number;
     readonly clashrunresult_a: (a: number, b: number) => void;
     readonly clashrunresult_b: (a: number, b: number) => void;
     readonly clashrunresult_bounds: (a: number, b: number) => void;
     readonly clashrunresult_distance: (a: number, b: number) => void;
+    readonly clashrunresult_distanceKind: (a: number, b: number) => void;
     readonly clashrunresult_points: (a: number, b: number) => void;
     readonly clashrunresult_status: (a: number, b: number) => void;
     readonly clashsession_ingest: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
@@ -1974,12 +2082,10 @@ export interface InitOutput {
     readonly version: (a: number) => void;
     readonly zonepiecejs_indices: (a: number) => number;
     readonly zonepiecejs_positions: (a: number) => number;
-    readonly zonepiecejs_volume: (a: number) => number;
     readonly zonepiecejs_zoneIndex: (a: number) => number;
     readonly zonesplitjs_piece: (a: number, b: number) => number;
     readonly zonesplitjs_pieceCount: (a: number) => number;
     readonly zonesplitjs_remainderFailed: (a: number) => number;
-    readonly zonesplitjs_sumErrorRel: (a: number) => number;
     readonly init: () => void;
     readonly meshoutlinejs_contourCount: (a: number) => number;
     readonly symbolicpolyline_pointCount: (a: number) => number;
@@ -1996,6 +2102,8 @@ export interface InitOutput {
     readonly symbolictext_worldY: (a: number) => number;
     readonly symbolictext_x: (a: number) => number;
     readonly symbolictext_y: (a: number) => number;
+    readonly zonepiecejs_volume: (a: number) => number;
+    readonly zonesplitjs_sumErrorRel: (a: number) => number;
     readonly zonesplitjs_wholeVolume: (a: number) => number;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;

package/pkg/ifc-lite.js

@@ -1,5 +1,159 @@
 /* @ts-self-types="./ifc-lite.d.ts" */
 
+/**
+ * The overlap solid of one clashing pair, or the reason there is none.
+ */
+export class ClashIntersectionSolidJs {
+    static __wrap(ptr) {
+        const obj = Object.create(ClashIntersectionSolidJs.prototype);
+        obj.__wbg_ptr = ptr;
+        ClashIntersectionSolidJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ClashIntersectionSolidJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_clashintersectionsolidjs_free(ptr, 0);
+    }
+    /**
+     * `""` when `isSolid`, otherwise one of:
+     * - `"malformed-operand"` — any of FOUR malformations, all rejected
+     *   before the boolean runs, because computing on them would silently
+     *   drop the offending triangle (or worse) rather than report the true
+     *   operand:
+     *   1. `positionsA`/`positionsB` is not a flat `[x, y, z, …]` triple
+     *      (length not a multiple of 3);
+     *   2. `indicesA`/`indicesB` has a length that is not a multiple of 3,
+     *      so it does not describe whole triangles;
+     *   3. `indicesA`/`indicesB` references a vertex past the end of its own
+     *      operand's positions;
+     *   4. a position is **non-finite** (NaN or infinity). This one is worth
+     *      calling out to callers: a NaN coordinate is caught by neither
+     *      length check, and left alone it can be absorbed into a
+     *      normal-looking answer or corrupt a face enough to report a
+     *      genuinely overlapping pair as `"no-overlap"`. So if you are
+     *      debugging an unexpected `"no-overlap"`, check your inputs for
+     *      NaN — it surfaces here, not there.
+     * - `"empty-operand"` — an operand had no triangles.
+     * - `"no-overlap"` — the exact intersection is empty. Covers a disjoint
+     *   pair AND a *touching* pair, including any graze below the kernel's
+     *   `2^-16 m ≈ 15.26 µm` snap grid (both faces snap flush).
+     * - `"below-kernel-resolution"` — the pair overlaps, but too shallowly for
+     *   the kernel to resolve as a solid rather than a coplanar contact. See
+     *   `thicknessM` / `requiredM`.
+     * - `"budget-exhausted"` — the escalation budget tripped; the arrangement
+     *   is partial and nothing about it is trustworthy.
+     * @returns {string}
+     */
+    get degenerateReason() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.clashintersectionsolidjs_degenerateReason(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Triangle indices into `positions / 3`.
+     * @returns {Uint32Array}
+     */
+    get indices() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.clashintersectionsolidjs_indices(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * True when a trustworthy overlap solid was produced. When false, every
+     * geometry getter is empty and `degenerateReason` says why.
+     * @returns {boolean}
+     */
+    get isSolid() {
+        const ret = wasm.clashintersectionsolidjs_isSolid(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * World-space vertex positions, flat `[x, y, z, …]`, f64.
+     *
+     * f64 rather than the f32 the rest of the mesh pipeline uses because the
+     * caller reports this solid's volume: the f32 round-trip costs ~1e-7
+     * relative, a thousand times the exactness the kernel actually delivers.
+     * Downcast to f32 at the GPU upload if the renderer wants it.
+     * @returns {Float64Array}
+     */
+    get positions() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.clashintersectionsolidjs_positions(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * For `"below-kernel-resolution"`: the depth this pair would have needed
+     * for the kernel to resolve a solid, in metres. `0` otherwise. Grows with
+     * distance from the world origin, as the kernel's own tolerance does.
+     * @returns {number}
+     */
+    get requiredM() {
+        const ret = wasm.clashintersectionsolidjs_requiredM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * For `"below-kernel-resolution"`: the overlap's measured thinnest extent,
+     * in metres. `0` otherwise. Useful to tell the user how shallow the clash
+     * is even though no solid can be drawn.
+     * @returns {number}
+     */
+    get thicknessM() {
+        const ret = wasm.clashintersectionsolidjs_thicknessM(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Triangle count of the solid; `0` when degenerate.
+     * @returns {number}
+     */
+    get triangleCount() {
+        const ret = wasm.clashintersectionsolidjs_triangleCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Enclosed volume in m³. `0` when not a solid — check `isSolid` first;
+     * "no measurable overlap" and "an overlap of zero" are different claims.
+     * @returns {number}
+     */
+    get volumeM3() {
+        const ret = wasm.clashintersectionsolidjs_volumeM3(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) ClashIntersectionSolidJs.prototype[Symbol.dispose] = ClashIntersectionSolidJs.prototype.free;
+
 /**
  * Packed result of one rule run. Parallel arrays, one entry per clash record;
  * `points` has 3 per record and `bounds` has 6 per record.
@@ -85,6 +239,22 @@ export class ClashRunResult {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * @returns {Uint8Array}
+     */
+    get distanceKind() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.clashrunresult_distanceKind(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * @returns {Float64Array}
      */
@@ -4400,6 +4570,40 @@ export class ZoneSplitJs {
 }
 if (Symbol.dispose) ZoneSplitJs.prototype[Symbol.dispose] = ZoneSplitJs.prototype.free;
 
+/**
+ * Compute the intersection solid of one clashing pair.
+ *
+ * `positionsA` / `positionsB` are flat world-space XYZ; `indicesA` /
+ * `indicesB` are flat triangle indices into their own operand.
+ *
+ * ```javascript
+ * const solid = clashIntersectionSolid(posA, idxA, posB, idxB);
+ * if (solid.isSolid) {
+ *   draw(solid.positions, solid.indices, solid.volumeM3);
+ * } else {
+ *   keepContactMarker(solid.degenerateReason); // e.g. "no-overlap"
+ * }
+ * solid.free();
+ * ```
+ * @param {Float32Array} positions_a
+ * @param {Uint32Array} indices_a
+ * @param {Float32Array} positions_b
+ * @param {Uint32Array} indices_b
+ * @returns {ClashIntersectionSolidJs}
+ */
+export function clashIntersectionSolid(positions_a, indices_a, positions_b, indices_b) {
+    const ptr0 = passArrayF32ToWasm0(positions_a, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray32ToWasm0(indices_a, wasm.__wbindgen_export);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArrayF32ToWasm0(positions_b, wasm.__wbindgen_export);
+    const len2 = WASM_VECTOR_LEN;
+    const ptr3 = passArray32ToWasm0(indices_b, wasm.__wbindgen_export);
+    const len3 = WASM_VECTOR_LEN;
+    const ret = wasm.clashIntersectionSolid(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+    return ClashIntersectionSolidJs.__wrap(ret);
+}
+
 /**
  * `a - b`, keeping EVERY disjoint remnant.
  *
@@ -4782,6 +4986,9 @@ function __wbg_get_imports() {
     };
 }
 
+const ClashIntersectionSolidJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_clashintersectionsolidjs_free(ptr, 1));
 const ClashRunResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_clashrunresult_free(ptr, 1));