@ifc-lite/wasm 2.1.0 → 2.1.1

package/package.json

@@ -5,7 +5,7 @@
     "IFC-Lite Contributors"
   ],
   "description": "WebAssembly bindings for IFC-Lite",
-  "version": "2.1.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;
@@ -553,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;
@@ -563,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;
@@ -677,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_569: (a: number, b: number, c: number) => void;
-  readonly __wasm_bindgen_func_elem_568: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_603: (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_569(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_569(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_603(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_603(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
  */
@@ -1950,7 +2161,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_603(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_627(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -2062,7 +2273,7 @@ function __wbg_get_imports() {
     };
     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_568, __wasm_bindgen_func_elem_569);
+        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) {