@ifc-lite/wasm 2.0.0 → 2.1.1

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -1,6 +1,40 @@
 /* tslint:disable */
 /* eslint-disable */
 
+export class ClashRunResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly a: Uint32Array;
+  readonly b: Uint32Array;
+  readonly bounds: Float64Array;
+  readonly points: Float64Array;
+  readonly status: Uint8Array;
+  readonly distance: Float64Array;
+}
+
+export class ClashSession {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor();
+  /**
+   * Ingest N elements from flat arenas.
+   *
+   * - `positions`: concatenated per-element vertex coords (x,y,z,...)
+   * - `pos_ranges`: 2 per element = [float_offset, float_len]
+   * - `indices`: concatenated per-element LOCAL (0-based) triangle indices
+   * - `idx_ranges`: 2 per element = [idx_offset, idx_len]
+   * - `aabbs`: 6 per element = [minx,miny,minz,maxx,maxy,maxz]
+   */
+  ingest(positions: Float32Array, pos_ranges: Uint32Array, indices: Uint32Array, idx_ranges: Uint32Array, aabbs: Float32Array): void;
+  /**
+   * Run one rule. `group_a`/`group_b` are GLOBAL element indices; an empty
+   * `group_b` means a self-clash within `group_a`. `mode`: 0 = hard,
+   * 1 = clearance. Records carry GLOBAL element indices.
+   */
+  runRule(group_a: Uint32Array, group_b: Uint32Array, mode: number, tolerance: number, clearance: number, report_touch: boolean): ClashRunResult;
+}
+
 export class IfcAPI {
   free(): void;
   [Symbol.dispose](): void;
@@ -48,6 +82,17 @@ export class IfcAPI {
    *   `{ type: "complete", totalJobs }`
    */
   buildPrePassStreaming(data: Uint8Array, on_event: Function, chunk_size: number): any;
+  /**
+   * Parse the file and return every `IfcAlignment` directrix as a flat
+   * `Float32Array` of 3D line-list vertices `[x0,y0,z0, x1,y1,z1, …]` in
+   * the renderer's Y-up world space (RTC-subtracted, metres). Consecutive
+   * samples form line segments. Feed straight to
+   * `renderer.uploadAnnotationLines3D(...)`.
+   *
+   * Returns an empty array when the file has no alignments (or none with a
+   * resolvable Axis curve), so the caller can clear the overlay cheaply.
+   */
+  parseAlignmentLines(content: string): Float32Array;
   /**
    * Extract raw profile polygons from all building elements with `IfcExtrudedAreaSolid`
    * representations.
@@ -542,6 +587,8 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
+  readonly __wbg_clashrunresult_free: (a: number, b: number) => void;
+  readonly __wbg_clashsession_free: (a: number, b: number) => void;
   readonly __wbg_ifcapi_free: (a: number, b: number) => void;
   readonly __wbg_meshcollection_free: (a: number, b: number) => void;
   readonly __wbg_meshdatajs_free: (a: number, b: number) => void;
@@ -552,6 +599,15 @@ export interface InitOutput {
   readonly __wbg_symbolicpolyline_free: (a: number, b: number) => void;
   readonly __wbg_symbolicrepresentationcollection_free: (a: number, b: number) => void;
   readonly __wbg_symbolictext_free: (a: number, b: number) => void;
+  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_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;
+  readonly clashsession_new: () => number;
+  readonly clashsession_runRule: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
   readonly ifcapi_buildPrePassFast: (a: number, b: number, c: number) => number;
   readonly ifcapi_buildPrePassOnce: (a: number, b: number, c: number) => number;
   readonly ifcapi_buildPrePassStreaming: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
@@ -561,6 +617,7 @@ export interface InitOutput {
   readonly ifcapi_is_ready: (a: number) => number;
   readonly ifcapi_new: () => number;
   readonly ifcapi_parse: (a: number, b: number, c: number) => number;
+  readonly ifcapi_parseAlignmentLines: (a: number, b: number, c: number) => number;
   readonly ifcapi_parseStreaming: (a: number, b: number, c: number, d: number) => number;
   readonly ifcapi_parseSymbolicRepresentations: (a: number, b: number, c: number) => number;
   readonly ifcapi_processGeometryBatch: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number) => number;
@@ -665,9 +722,9 @@ export interface InitOutput {
   readonly symbolictext_worldY: (a: number) => number;
   readonly symbolictext_x: (a: number) => number;
   readonly symbolictext_y: (a: number) => number;
-  readonly __wasm_bindgen_func_elem_1685: (a: number, b: number, c: number) => void;
-  readonly __wasm_bindgen_func_elem_1684: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_1832: (a: number, b: number, c: number, d: number) => void;
+  readonly __wasm_bindgen_func_elem_593: (a: number, b: number, c: number) => void;
+  readonly __wasm_bindgen_func_elem_592: (a: number, b: number) => void;
+  readonly __wasm_bindgen_func_elem_627: (a: number, b: number, c: number, d: number) => void;
   readonly __wbindgen_export: (a: number) => void;
   readonly __wbindgen_export2: (a: number, b: number, c: number) => void;
   readonly __wbindgen_export3: (a: number, b: number) => number;

package/pkg/ifc-lite.js

@@ -40,6 +40,11 @@ function getArrayU32FromWasm0(ptr, len) {
     return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
 
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -146,6 +151,13 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayF32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getFloat32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
@@ -220,14 +232,22 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-function __wasm_bindgen_func_elem_1685(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_1685(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_593(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_593(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_1832(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_1832(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_627(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_627(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
+const ClashRunResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_clashrunresult_free(ptr >>> 0, 1));
+
+const ClashSessionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_clashsession_free(ptr >>> 0, 1));
+
 const IfcAPIFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ifcapi_free(ptr >>> 0, 1));
@@ -268,6 +288,197 @@ const SymbolicTextFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_symbolictext_free(ptr >>> 0, 1));
 
+/**
+ * Packed result of one rule run. Parallel arrays, one entry per clash record;
+ * `points` has 3 per record and `bounds` has 6 per record.
+ */
+export class ClashRunResult {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ClashRunResult.prototype);
+        obj.__wbg_ptr = ptr;
+        ClashRunResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ClashRunResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_clashrunresult_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    get a() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.clashrunresult_a(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_export2(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    get b() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.clashrunresult_b(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_export2(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    get bounds() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.clashrunresult_bounds(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_export2(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    get points() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.clashrunresult_points(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_export2(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get status() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.clashrunresult_status(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_export2(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    get distance() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.clashrunresult_distance(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_export2(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) ClashRunResult.prototype[Symbol.dispose] = ClashRunResult.prototype.free;
+
+/**
+ * A clash session: ingest element geometry once, then run rules repeatedly.
+ */
+export class ClashSession {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ClashSessionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_clashsession_free(ptr, 0);
+    }
+    constructor() {
+        const ret = wasm.clashsession_new();
+        this.__wbg_ptr = ret >>> 0;
+        ClashSessionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Ingest N elements from flat arenas.
+     *
+     * - `positions`: concatenated per-element vertex coords (x,y,z,...)
+     * - `pos_ranges`: 2 per element = [float_offset, float_len]
+     * - `indices`: concatenated per-element LOCAL (0-based) triangle indices
+     * - `idx_ranges`: 2 per element = [idx_offset, idx_len]
+     * - `aabbs`: 6 per element = [minx,miny,minz,maxx,maxy,maxz]
+     * @param {Float32Array} positions
+     * @param {Uint32Array} pos_ranges
+     * @param {Uint32Array} indices
+     * @param {Uint32Array} idx_ranges
+     * @param {Float32Array} aabbs
+     */
+    ingest(positions, pos_ranges, indices, idx_ranges, aabbs) {
+        const ptr0 = passArrayF32ToWasm0(positions, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(pos_ranges, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray32ToWasm0(indices, wasm.__wbindgen_export3);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray32ToWasm0(idx_ranges, wasm.__wbindgen_export3);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passArrayF32ToWasm0(aabbs, wasm.__wbindgen_export3);
+        const len4 = WASM_VECTOR_LEN;
+        wasm.clashsession_ingest(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+    }
+    /**
+     * Run one rule. `group_a`/`group_b` are GLOBAL element indices; an empty
+     * `group_b` means a self-clash within `group_a`. `mode`: 0 = hard,
+     * 1 = clearance. Records carry GLOBAL element indices.
+     * @param {Uint32Array} group_a
+     * @param {Uint32Array} group_b
+     * @param {number} mode
+     * @param {number} tolerance
+     * @param {number} clearance
+     * @param {boolean} report_touch
+     * @returns {ClashRunResult}
+     */
+    runRule(group_a, group_b, mode, tolerance, clearance, report_touch) {
+        const ptr0 = passArray32ToWasm0(group_a, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(group_b, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.clashsession_runRule(this.__wbg_ptr, ptr0, len0, ptr1, len1, mode, tolerance, clearance, report_touch);
+        return ClashRunResult.__wrap(ret);
+    }
+}
+if (Symbol.dispose) ClashSession.prototype[Symbol.dispose] = ClashSession.prototype.free;
+
 /**
  * Main IFC-Lite API
  */
@@ -391,6 +602,24 @@ export class IfcAPI {
             heap[stack_pointer++] = undefined;
         }
     }
+    /**
+     * Parse the file and return every `IfcAlignment` directrix as a flat
+     * `Float32Array` of 3D line-list vertices `[x0,y0,z0, x1,y1,z1, …]` in
+     * the renderer's Y-up world space (RTC-subtracted, metres). Consecutive
+     * samples form line segments. Feed straight to
+     * `renderer.uploadAnnotationLines3D(...)`.
+     *
+     * Returns an empty array when the file has no alignments (or none with a
+     * resolvable Axis curve), so the caller can clear the overlay cheaply.
+     * @param {string} content
+     * @returns {Float32Array}
+     */
+    parseAlignmentLines(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseAlignmentLines(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
     /**
      * Extract raw profile polygons from all building elements with `IfcExtrudedAreaSolid`
      * representations.
@@ -1932,7 +2161,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_1832(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_627(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -2037,16 +2266,16 @@ function __wbg_get_imports() {
         const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_89b0435615caf0ab = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 211, function: Function { arguments: [Externref], shim_idx: 212, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1684, __wasm_bindgen_func_elem_1685);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
         // Cast intrinsic for `F64 -> Externref`.
         const ret = arg0;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_cast_e7ad0d7b317830d5 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 56, function: Function { arguments: [Externref], shim_idx: 57, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_592, __wasm_bindgen_func_elem_593);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
         const ret = getObject(arg0);
         return addHeapObject(ret);