@ifc-lite/wasm 9.0.1 → 9.1.0

package/README.md

@@ -76,6 +76,49 @@ api.clearPrePassCache();
 api.free();                           // release the API instance when done
 ```
 
+### Auxiliary geometry in the mesh frame
+
+Grid, alignment, and symbolic parsers accept the mesh pre-pass decision through
+their explicit-frame variants. `RtcFrame` coordinates are IFC Z-up metres:
+
+```typescript
+import type { IfcAPI, RtcFrame } from '@ifc-lite/wasm';
+
+declare const api: IfcAPI;
+declare const pre: ReturnType<IfcAPI['buildPrePassOnce']>;
+declare const content: string;
+
+const frame: RtcFrame = {
+  x: pre.rtcOffset?.[0] ?? 0,
+  y: pre.rtcOffset?.[1] ?? 0,
+  z: pre.rtcOffset?.[2] ?? 0,
+  needsShift: pre.needsShift,
+};
+
+const grids = api.parseGridLinesInFrame(content, frame);
+const axes = api.parseGridAxesInFrame(content, frame);
+try {
+  const alignments = api.parseAlignmentLinesInFrame(content, frame);
+  const symbols = api.parseSymbolicRepresentationsInFrame(content, frame);
+  try {
+    console.log(grids.length, axes.length, alignments.length, symbols.totalCount);
+  } finally {
+    symbols.free();
+  }
+} finally {
+  axes.free();
+}
+```
+
+`needsShift: false` means no RTC subtraction, even when the inactive coordinates
+are non-zero. “Raw IFC” here describes only that RTC step: each parser still
+applies its documented unit scaling and output-axis conversion. It is distinct
+from having no frame.
+The methods without `InFrame` remain available for standalone parsing and
+detect a frame from the whole source. That standalone choice is not guaranteed
+to match an earlier streaming sample or a federation override; reuse the exact
+pre-pass frame whenever these results accompany already-produced meshes.
+
 > Most consumers should use [`@ifc-lite/geometry`](../geometry/README.md)'s
 > `GeometryProcessor` instead — it wraps this pre-pass/job-batch flow with a
 > Web-Worker pool, RTC coordinate handling, and progressive streaming.

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -1,6 +1,16 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/** Exact browser mesh RTC frame, in IFC Z-up metres. */
+export interface RtcFrame {
+    x: number;
+    y: number;
+    z: number;
+    needsShift: boolean;
+}
+
+
+
 /**
  * The overlap solid of one clashing pair, or the reason there is none.
  */
@@ -616,12 +626,20 @@ export class IfcAPI {
      * resolvable Axis curve), so the caller can clear the overlay cheaply.
      */
     parseAlignmentLines(content: string): Float32Array;
+    /**
+     * Parse alignments in the exact RTC frame selected by the mesh pre-pass.
+     */
+    parseAlignmentLinesInFrame(content: string, frame: RtcFrame): Float32Array;
     /**
      * Parse the file and return structured per-axis data (tag + endpoints) in
      * the renderer's Y-up world space (RTC-subtracted, metres). Use this when
      * you also need the axis tags (to render grid bubbles / labels).
      */
     parseGridAxes(content: string): GridAxisCollection;
+    /**
+     * Parse structured grid axes in the exact frame selected by the mesh pre-pass.
+     */
+    parseGridAxesInFrame(content: string, frame: RtcFrame): GridAxisCollection;
     /**
      * Parse the file and return every `IfcGridAxis` as a flat `Float32Array`
      * of 3D line-list vertices `[x0,y0,z0, x1,y1,z1, …]` (one segment per
@@ -632,11 +650,19 @@ export class IfcAPI {
      * clear the overlay cheaply.
      */
     parseGridLines(content: string): Float32Array;
+    /**
+     * Parse grid line vertices in the exact frame selected by the mesh pre-pass.
+     */
+    parseGridLinesInFrame(content: string, frame: RtcFrame): Float32Array;
     /**
      * Parse IFC file and extract symbolic representations (Plan,
      * Annotation, FootPrint, Axis). These are 2D curves used for
      * architectural drawings instead of sectioning 3D geometry.
      *
+     * This standalone entry point detects an RTC frame from the whole source.
+     * Use `parseSymbolicRepresentationsInFrame` when the symbols accompany
+     * meshes produced by a streaming pre-pass or federation override.
+     *
      * Example:
      * ```javascript
      * const api = new IfcAPI();
@@ -649,6 +675,12 @@ export class IfcAPI {
      * ```
      */
     parseSymbolicRepresentations(content: string): SymbolicRepresentationCollection;
+    /**
+     * Parse symbolic representations in the exact RTC frame selected by the
+     * browser mesh pre-pass rather than detecting a second frame from the
+     * whole source.
+     */
+    parseSymbolicRepresentationsInFrame(content: string, frame: RtcFrame): SymbolicRepresentationCollection;
     /**
      * Create a calibrated image annotation through canonical native geometry.
      * Input is AnnotationPlaneRequest; output UTF-8 AnnotationPlanePlan JSON.
@@ -2147,9 +2179,13 @@ export interface InitOutput {
     readonly ifcapi_is_ready: (a: number) => number;
     readonly ifcapi_new: () => number;
     readonly ifcapi_parseAlignmentLines: (a: number, b: number, c: number) => number;
+    readonly ifcapi_parseAlignmentLinesInFrame: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly ifcapi_parseGridAxes: (a: number, b: number, c: number) => number;
+    readonly ifcapi_parseGridAxesInFrame: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly ifcapi_parseGridLines: (a: number, b: number, c: number) => number;
+    readonly ifcapi_parseGridLinesInFrame: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly ifcapi_parseSymbolicRepresentations: (a: number, b: number, c: number) => number;
+    readonly ifcapi_parseSymbolicRepresentationsInFrame: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly ifcapi_planAnnotationPlane: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly ifcapi_planAppearance: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly ifcapi_planCapturedMesh: (a: number, b: number, c: number, d: number, e: number, f: number) => void;

package/pkg/ifc-lite.js

@@ -1678,6 +1678,29 @@ export class IfcAPI {
         const ret = wasm.ifcapi_parseAlignmentLines(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
+    /**
+     * Parse alignments in the exact RTC frame selected by the mesh pre-pass.
+     * @param {string} content
+     * @param {RtcFrame} frame
+     * @returns {Float32Array}
+     */
+    parseAlignmentLinesInFrame(content, frame) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ifcapi_parseAlignmentLinesInFrame(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(frame));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Parse the file and return structured per-axis data (tag + endpoints) in
      * the renderer's Y-up world space (RTC-subtracted, metres). Use this when
@@ -1691,6 +1714,29 @@ export class IfcAPI {
         const ret = wasm.ifcapi_parseGridAxes(this.__wbg_ptr, ptr0, len0);
         return GridAxisCollection.__wrap(ret);
     }
+    /**
+     * Parse structured grid axes in the exact frame selected by the mesh pre-pass.
+     * @param {string} content
+     * @param {RtcFrame} frame
+     * @returns {GridAxisCollection}
+     */
+    parseGridAxesInFrame(content, frame) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ifcapi_parseGridAxesInFrame(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(frame));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return GridAxisCollection.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Parse the file and return every `IfcGridAxis` as a flat `Float32Array`
      * of 3D line-list vertices `[x0,y0,z0, x1,y1,z1, …]` (one segment per
@@ -1708,11 +1754,38 @@ export class IfcAPI {
         const ret = wasm.ifcapi_parseGridLines(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
+    /**
+     * Parse grid line vertices in the exact frame selected by the mesh pre-pass.
+     * @param {string} content
+     * @param {RtcFrame} frame
+     * @returns {Float32Array}
+     */
+    parseGridLinesInFrame(content, frame) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ifcapi_parseGridLinesInFrame(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(frame));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Parse IFC file and extract symbolic representations (Plan,
      * Annotation, FootPrint, Axis). These are 2D curves used for
      * architectural drawings instead of sectioning 3D geometry.
      *
+     * This standalone entry point detects an RTC frame from the whole source.
+     * Use `parseSymbolicRepresentationsInFrame` when the symbols accompany
+     * meshes produced by a streaming pre-pass or federation override.
+     *
      * Example:
      * ```javascript
      * const api = new IfcAPI();
@@ -1732,6 +1805,31 @@ export class IfcAPI {
         const ret = wasm.ifcapi_parseSymbolicRepresentations(this.__wbg_ptr, ptr0, len0);
         return SymbolicRepresentationCollection.__wrap(ret);
     }
+    /**
+     * Parse symbolic representations in the exact RTC frame selected by the
+     * browser mesh pre-pass rather than detecting a second frame from the
+     * whole source.
+     * @param {string} content
+     * @param {RtcFrame} frame
+     * @returns {SymbolicRepresentationCollection}
+     */
+    parseSymbolicRepresentationsInFrame(content, frame) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ifcapi_parseSymbolicRepresentationsInFrame(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(frame));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return SymbolicRepresentationCollection.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Create a calibrated image annotation through canonical native geometry.
      * Input is AnnotationPlaneRequest; output UTF-8 AnnotationPlanePlan JSON.
@@ -5514,6 +5612,20 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
+        __wbg___wbindgen_boolean_get_fa956cfa2d1bd751: function(arg0) {
+            const v = getObject(arg0);
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __wbg___wbindgen_is_null_ea9085d691f535d3: function(arg0) {
+            const ret = getObject(arg0) === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
+            const val = getObject(arg0);
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
         __wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
             const ret = getObject(arg0) === undefined;
             return ret;
@@ -5522,6 +5634,12 @@ function __wbg_get_imports() {
             const ret = wasm.memory;
             return addHeapObject(ret);
         },
+        __wbg___wbindgen_number_get_394265ed1e1b84ee: function(arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
         __wbg___wbindgen_string_get_b0ca35b86a603356: function(arg0, arg1) {
             const obj = getObject(arg1);
             const ret = typeof(obj) === 'string' ? obj : undefined;
@@ -5548,9 +5666,17 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
             }
         },
+        __wbg_get_78f252d074a84d0b: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
         __wbg_info_eadbe775a8e2e9eb: function(arg0) {
             console.info(getObject(arg0));
         },
+        __wbg_isArray_0677c962b281d01a: function(arg0) {
+            const ret = Array.isArray(getObject(arg0));
+            return ret;
+        },
         __wbg_new_227d7c05414eb861: function() {
             const ret = new Error();
             return addHeapObject(ret);