@ifc-lite/wasm 2.3.0 → 2.4.1

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -411,6 +411,12 @@ export class MeshDataJs {
    */
   readonly shadingColor: Float32Array | undefined;
   readonly textureWidth: number;
+  /**
+   * Geometry provenance for the viewer's Model/Types switch (#957 follow-up):
+   * 0 = occurrence, 1 = orphan type geometry (no occurrence), 2 = instanced
+   * type geometry (hidden in Model mode, shown in Types mode).
+   */
+  readonly geometryClass: number;
   readonly textureHeight: number;
   /**
    * Get triangle count
@@ -451,6 +457,30 @@ export class MeshDataJs {
   readonly positions: Float32Array;
 }
 
+export class MeshOutlineJs {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Ring `i` as a flat `[u0, v0, u1, v1, …]` array, or `undefined` if out of
+   * range. The ring is closed implicitly (connect the last point to the
+   * first).
+   */
+  contour(index: number): Float32Array | undefined;
+  /**
+   * Number of boundary rings (outer + holes).
+   */
+  readonly contourCount: number;
+  /**
+   * Element extent (max) along the cut axis, world units.
+   */
+  readonly axisMax: number;
+  /**
+   * Element extent (min) along the cut axis, world units.
+   */
+  readonly axisMin: number;
+}
+
 export class ProfileCollection {
   private constructor();
   free(): void;
@@ -679,6 +709,25 @@ export function get_memory(): any;
  */
 export function init(): void;
 
+/**
+ * Compute the winding-robust 2D footprint outline of a triangle mesh.
+ *
+ * `positions` is flat XYZ; `indices` is flat triangle indices. `axis` is
+ * 0/1/2 = x/y/z (the cut axis, WebGL Y-up). Returns `undefined` when the mesh
+ * has no triangles or projects to nothing.
+ *
+ * ```javascript
+ * const outline = meshOutline2d(positions, indices, 1, false); // axis 1 = y
+ * if (outline) {
+ *   for (let i = 0; i < outline.contourCount; i++) {
+ *     const ring = outline.contour(i); // Float32Array of [u0, v0, u1, v1, ...]
+ *   }
+ *   outline.free();
+ * }
+ * ```
+ */
+export function meshOutline2d(positions: Float32Array, indices: Uint32Array, axis: number, flipped: boolean): MeshOutlineJs | undefined;
+
 /**
  * Get the version of IFC-Lite.
  *
@@ -705,6 +754,7 @@ export interface InitOutput {
   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;
+  readonly __wbg_meshoutlinejs_free: (a: number, b: number) => void;
   readonly __wbg_profilecollection_free: (a: number, b: number) => void;
   readonly __wbg_profileentryjs_free: (a: number, b: number) => void;
   readonly __wbg_symboliccircle_free: (a: number, b: number) => void;
@@ -752,6 +802,7 @@ export interface InitOutput {
   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 meshOutline2d: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
   readonly meshcollection_buildingRotation: (a: number, b: number) => void;
   readonly meshcollection_geometryHashCount: (a: number) => number;
   readonly meshcollection_geometryHashIds: (a: number) => number;
@@ -767,6 +818,7 @@ export interface InitOutput {
   readonly meshcollection_totalVertices: (a: number) => number;
   readonly meshdatajs_color: (a: number, b: number) => void;
   readonly meshdatajs_expressId: (a: number) => number;
+  readonly meshdatajs_geometryClass: (a: number) => number;
   readonly meshdatajs_hasTexture: (a: number) => number;
   readonly meshdatajs_ifcType: (a: number, b: number) => void;
   readonly meshdatajs_indices: (a: number) => number;
@@ -781,6 +833,10 @@ export interface InitOutput {
   readonly meshdatajs_triangleCount: (a: number) => number;
   readonly meshdatajs_uvs: (a: number) => number;
   readonly meshdatajs_vertexCount: (a: number) => number;
+  readonly meshoutlinejs_axisMax: (a: number) => number;
+  readonly meshoutlinejs_axisMin: (a: number) => number;
+  readonly meshoutlinejs_contour: (a: number, b: number) => number;
+  readonly meshoutlinejs_contourCount: (a: number) => number;
   readonly profilecollection_get: (a: number, b: number) => number;
   readonly profilecollection_length: (a: number) => number;
   readonly profileentryjs_expressId: (a: number) => number;
@@ -856,9 +912,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_666: (a: number, b: number, c: number) => void;
-  readonly __wasm_bindgen_func_elem_665: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_700: (a: number, b: number, c: number, d: number) => void;
+  readonly __wasm_bindgen_func_elem_675: (a: number, b: number, c: number) => void;
+  readonly __wasm_bindgen_func_elem_674: (a: number, b: number) => void;
+  readonly __wasm_bindgen_func_elem_709: (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

@@ -245,12 +245,12 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-function __wasm_bindgen_func_elem_666(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_666(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_675(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_675(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_700(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_700(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_709(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_709(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const ClashRunResultFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -281,6 +281,10 @@ const MeshDataJsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_meshdatajs_free(ptr >>> 0, 1));
 
+const MeshOutlineJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_meshoutlinejs_free(ptr >>> 0, 1));
+
 const ProfileCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_profilecollection_free(ptr >>> 0, 1));
@@ -1306,6 +1310,16 @@ export class MeshDataJs {
         const ret = wasm.meshdatajs_textureWidth(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Geometry provenance for the viewer's Model/Types switch (#957 follow-up):
+     * 0 = occurrence, 1 = orphan type geometry (no occurrence), 2 = instanced
+     * type geometry (hidden in Model mode, shown in Types mode).
+     * @returns {number}
+     */
+    get geometryClass() {
+        const ret = wasm.meshdatajs_geometryClass(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {number}
      */
@@ -1410,6 +1424,70 @@ export class MeshDataJs {
 }
 if (Symbol.dispose) MeshDataJs.prototype[Symbol.dispose] = MeshDataJs.prototype.free;
 
+/**
+ * A mesh's projected footprint outline.
+ *
+ * Contours are closed rings in drawing 2D space (same basis as `projectTo2D`
+ * in `@ifc-lite/drawing-2d`), WITHOUT a duplicated closing vertex.
+ * `axisMin`/`axisMax` are the element's extent along the cut axis (world
+ * units, not flip-adjusted) for band classification on the TS side.
+ */
+export class MeshOutlineJs {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(MeshOutlineJs.prototype);
+        obj.__wbg_ptr = ptr;
+        MeshOutlineJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MeshOutlineJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_meshoutlinejs_free(ptr, 0);
+    }
+    /**
+     * Number of boundary rings (outer + holes).
+     * @returns {number}
+     */
+    get contourCount() {
+        const ret = wasm.meshoutlinejs_contourCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Ring `i` as a flat `[u0, v0, u1, v1, …]` array, or `undefined` if out of
+     * range. The ring is closed implicitly (connect the last point to the
+     * first).
+     * @param {number} index
+     * @returns {Float32Array | undefined}
+     */
+    contour(index) {
+        const ret = wasm.meshoutlinejs_contour(this.__wbg_ptr, index);
+        return takeObject(ret);
+    }
+    /**
+     * Element extent (max) along the cut axis, world units.
+     * @returns {number}
+     */
+    get axisMax() {
+        const ret = wasm.meshoutlinejs_axisMax(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Element extent (min) along the cut axis, world units.
+     * @returns {number}
+     */
+    get axisMin() {
+        const ret = wasm.meshoutlinejs_axisMin(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) MeshOutlineJs.prototype[Symbol.dispose] = MeshOutlineJs.prototype.free;
+
 /**
  * A collection of extracted profiles.
  */
@@ -2306,6 +2384,37 @@ export function init() {
     wasm.init();
 }
 
+/**
+ * Compute the winding-robust 2D footprint outline of a triangle mesh.
+ *
+ * `positions` is flat XYZ; `indices` is flat triangle indices. `axis` is
+ * 0/1/2 = x/y/z (the cut axis, WebGL Y-up). Returns `undefined` when the mesh
+ * has no triangles or projects to nothing.
+ *
+ * ```javascript
+ * const outline = meshOutline2d(positions, indices, 1, false); // axis 1 = y
+ * if (outline) {
+ *   for (let i = 0; i < outline.contourCount; i++) {
+ *     const ring = outline.contour(i); // Float32Array of [u0, v0, u1, v1, ...]
+ *   }
+ *   outline.free();
+ * }
+ * ```
+ * @param {Float32Array} positions
+ * @param {Uint32Array} indices
+ * @param {number} axis
+ * @param {boolean} flipped
+ * @returns {MeshOutlineJs | undefined}
+ */
+export function meshOutline2d(positions, indices, axis, flipped) {
+    const ptr0 = passArrayF32ToWasm0(positions, wasm.__wbindgen_export3);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray32ToWasm0(indices, wasm.__wbindgen_export3);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.meshOutline2d(ptr0, len0, ptr1, len1, axis, flipped);
+    return ret === 0 ? undefined : MeshOutlineJs.__wrap(ret);
+}
+
 /**
  * Get the version of IFC-Lite.
  *
@@ -2435,7 +2544,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_700(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_709(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -2540,7 +2649,7 @@ function __wbg_get_imports() {
     };
     imports.wbg.__wbindgen_cast_0093e2d96a856a3b = function(arg0, arg1) {
         // Cast intrinsic for `Closure(Closure { dtor_idx: 61, function: Function { arguments: [Externref], shim_idx: 62, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_665, __wasm_bindgen_func_elem_666);
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_674, __wasm_bindgen_func_elem_675);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {