@ifc-lite/wasm 3.0.13 → 3.0.15

package/README.md

@@ -101,7 +101,7 @@ This package ships the bindings only. The Rust source lives in [`rust/wasm-bindi
 
 ## API
 
-See the [WASM API Reference](https://ltplus-ag.github.io/ifc-lite/api/wasm/).
+See the [WASM API Reference](https://ifclite.dev/docs/api/wasm/).
 
 ## License
 

package/package.json

@@ -5,7 +5,7 @@
     "IFC-Lite Contributors"
   ],
   "description": "WebAssembly bindings for IFC-Lite",
-  "version": "3.0.13",
+  "version": "3.0.15",
   "license": "MPL-2.0",
   "repository": {
     "type": "git",
@@ -39,7 +39,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "homepage": "https://ltplus-ag.github.io/ifc-lite/",
+  "homepage": "https://ifclite.dev/docs/",
   "bugs": "https://github.com/LTplus-AG/ifc-lite/issues",
   "scripts": {
     "build": "node ../../scripts/run-build-wasm.mjs",

package/pkg/ifc-lite.d.ts

@@ -93,6 +93,9 @@ export class IfcAPI {
    * `true` ⇒ lit (the default), `false` ⇒ flat `KHR_materials_unlit` (the
    * historical look — #1321). Optional at the boundary so older 5-arg callers
    * keep lit-by-default behaviour.
+   * `emissive` self-illuminates each material at its base colour (core glTF
+   * `emissiveFactor`) so renderers without ambient/IBL — Google Earth — don't
+   * render the model near-black (#1427); omitted or `false` ⇒ off.
    *
    * Fails CLOSED: when the visible mesh set is empty this throws an `Error`
    * whose message starts with `NO_RENDER_GEOMETRY`, instead of returning a
@@ -100,14 +103,22 @@ export class IfcAPI {
    * CLI/MCP wrappers; making the boundary itself refuse means SDK/viewer/
    * direct callers inherit it too (the TS guards stay as defense-in-depth).
    */
-  exportGlb(content: Uint8Array, include_metadata: boolean, hidden: Uint32Array, isolated: Uint32Array, hidden_types_csv: string, lit?: boolean | null): Uint8Array;
+  exportGlb(content: Uint8Array, include_metadata: boolean, hidden: Uint32Array, isolated: Uint32Array, hidden_types_csv: string, lit?: boolean | null, emissive?: boolean | null): Uint8Array;
   /**
    * Package an already-produced **GLB** + georeference into a **KMZ** (`Uint8Array`)
    * for Google Earth: a ZIP of `doc.kml` (a `<Model>` placed at `latitude`/`longitude`/
    * `altitude`) + `model.glb`. `x_axis_abscissa`/`x_axis_ordinate` are the
    * `IfcMapConversion` grid-north components; pass both as `undefined` for heading 0.
+   *
+   * `altitude_mode` selects the KML vertical placement: `"clampToGround"`
+   * (the default when omitted) rests the model on the terrain, ignoring
+   * `altitude`; `"absolute"` places the origin at `altitude` metres MSL.
+   * Google Earth's terrain already encodes the site elevation, so clamping
+   * keeps a wrong/zero/double-counted OrthogonalHeight from floating the
+   * model into the sky (#1427); absolute is offered for models whose
+   * OrthogonalHeight is a true MSL elevation the user wants honoured.
    */
-  exportKmz(glb: Uint8Array, latitude: number, longitude: number, altitude: number, x_axis_abscissa: number | null | undefined, x_axis_ordinate: number | null | undefined, name: string): Uint8Array;
+  exportKmz(glb: Uint8Array, latitude: number, longitude: number, altitude: number, x_axis_abscissa: number | null | undefined, x_axis_ordinate: number | null | undefined, name: string, altitude_mode?: string | null): Uint8Array;
   /**
    * Assemble a **GLB** from already-produced meshes (the viewer's `MeshData`, flattened)
    * — no re-meshing. Per mesh `i`: `vertex_counts[i]` verts + `index_counts[i]` indices
@@ -115,7 +126,20 @@ export class IfcAPI {
    * RGBA per mesh, `origins` xyz per mesh, `express_ids` labels each mesh (indices are
    * per-mesh local). The caller passes exactly the meshes it wants emitted.
    */
-  exportGlbFromMeshes(positions: Float32Array, normals: Float32Array, indices: Uint32Array, vertex_counts: Uint32Array, index_counts: Uint32Array, colors: Float32Array, origins: Float64Array, express_ids: Uint32Array, include_metadata: boolean, lit?: boolean | null): Uint8Array;
+  exportGlbFromMeshes(positions: Float32Array, normals: Float32Array, indices: Uint32Array, vertex_counts: Uint32Array, index_counts: Uint32Array, colors: Float32Array, origins: Float64Array, express_ids: Uint32Array, include_metadata: boolean, lit?: boolean | null, emissive?: boolean | null): Uint8Array;
+  /**
+   * Build a Google-Earth-ready **KMZ** (`Uint8Array`) straight from the viewer's
+   * already-produced meshes — the working path (#1427). The model is embedded as
+   * **COLLADA** (`model.dae`), the only `<Model>` format Google Earth loads (a GLB
+   * raises "Unsupported element: Model"), with emission-lit double-sided materials
+   * placement. Mesh arrays match `exportGlbFromMeshes`;
+   * `latitude`/`longitude`/`altitude` + `x_axis_abscissa`/`x_axis_ordinate`
+   * (grid-north, `undefined` ⇒ heading 0) place + orient the model.
+   * `altitude_mode` (`"clampToGround"` default ⇒ rest on terrain, ignoring
+   * `altitude`; `"absolute"` ⇒ place at `altitude` metres MSL) selects the
+   * KML vertical placement (#1427).
+   */
+  exportKmzFromMeshes(positions: Float32Array, normals: Float32Array, indices: Uint32Array, vertex_counts: Uint32Array, index_counts: Uint32Array, colors: Float32Array, origins: Float64Array, latitude: number, longitude: number, altitude: number, x_axis_abscissa: number | null | undefined, x_axis_ordinate: number | null | undefined, name: string, altitude_mode?: string | null): Uint8Array;
   /**
    * Export the render geometry in `content` as Wavefront **OBJ** UTF-8 bytes.
    *
@@ -360,13 +384,14 @@ export class IfcAPI {
    * even though the pre-pass worker built the same index minutes
    * earlier.
    *
-   * Building an `FxHashMap` from the three input slices costs ~1 s on
-   * 14 M entries — about 4–5× faster than re-scanning the file. After
-   * this call, the next `processGeometryBatch` skips the lazy build
-   * branch and reuses the populated cache by `Arc::clone()`.
+   * Builds a compact [`ColumnarEntityIndex`] from the three input slices
+   * (sorted `u32` columns + binary search) instead of a per-worker
+   * `FxHashMap` — ~229 MB vs ~436 MB on a 19.1 M-entity model (#1682).
+   * [`ColumnarEntityIndex::from_columns`] verifies the id ordering once
+   * (O(n)) and only argsorts if the producer did not emit sorted columns.
    *
-   * `lengths[i]` is the byte length of entity `ids[i]`, so the cache
-   * stores `(start, start + length)` to match the existing tuple layout.
+   * `lengths[i]` is the byte length of entity `ids[i]`, so lookup returns
+   * `(start, start + length)` to match the existing `(start, end)` layout.
    *
    * Idempotent in the sense that repeated calls REPLACE the cache —
    * supports the parser-worker pattern of reusing one IfcAPI across
@@ -1217,13 +1242,14 @@ export interface InitOutput {
   readonly ifcapi_clearPrePassCache: (a: number) => void;
   readonly ifcapi_diagnoseGeometry: (a: number, b: number, c: number) => number;
   readonly ifcapi_exportCsv: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
-  readonly ifcapi_exportGlb: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => void;
-  readonly ifcapi_exportGlbFromMeshes: (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) => void;
+  readonly ifcapi_exportGlb: (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) => void;
+  readonly ifcapi_exportGlbFromMeshes: (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, u: number) => void;
   readonly ifcapi_exportHbjson: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
   readonly ifcapi_exportIfcx: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
   readonly ifcapi_exportJson: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
   readonly ifcapi_exportJsonld: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
-  readonly ifcapi_exportKmz: (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) => void;
+  readonly ifcapi_exportKmz: (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) => void;
+  readonly ifcapi_exportKmzFromMeshes: (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, u: number, v: number, w: number, x: number, y: number, z: number, a1: number) => void;
   readonly ifcapi_exportMerged: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
   readonly ifcapi_exportObj: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
   readonly ifcapi_exportStep: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;

package/pkg/ifc-lite.js

@@ -639,6 +639,9 @@ export class IfcAPI {
      * `true` ⇒ lit (the default), `false` ⇒ flat `KHR_materials_unlit` (the
      * historical look — #1321). Optional at the boundary so older 5-arg callers
      * keep lit-by-default behaviour.
+     * `emissive` self-illuminates each material at its base colour (core glTF
+     * `emissiveFactor`) so renderers without ambient/IBL — Google Earth — don't
+     * render the model near-black (#1427); omitted or `false` ⇒ off.
      *
      * Fails CLOSED: when the visible mesh set is empty this throws an `Error`
      * whose message starts with `NO_RENDER_GEOMETRY`, instead of returning a
@@ -651,9 +654,10 @@ export class IfcAPI {
      * @param {Uint32Array} isolated
      * @param {string} hidden_types_csv
      * @param {boolean | null} [lit]
+     * @param {boolean | null} [emissive]
      * @returns {Uint8Array}
      */
-    exportGlb(content, include_metadata, hidden, isolated, hidden_types_csv, lit) {
+    exportGlb(content, include_metadata, hidden, isolated, hidden_types_csv, lit, emissive) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export);
@@ -664,7 +668,7 @@ export class IfcAPI {
             const len2 = WASM_VECTOR_LEN;
             const ptr3 = passStringToWasm0(hidden_types_csv, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len3 = WASM_VECTOR_LEN;
-            wasm.ifcapi_exportGlb(retptr, this.__wbg_ptr, ptr0, len0, include_metadata, ptr1, len1, ptr2, len2, ptr3, len3, isLikeNone(lit) ? 0xFFFFFF : lit ? 1 : 0);
+            wasm.ifcapi_exportGlb(retptr, this.__wbg_ptr, ptr0, len0, include_metadata, ptr1, len1, ptr2, len2, ptr3, len3, isLikeNone(lit) ? 0xFFFFFF : lit ? 1 : 0, isLikeNone(emissive) ? 0xFFFFFF : emissive ? 1 : 0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -684,6 +688,14 @@ export class IfcAPI {
      * for Google Earth: a ZIP of `doc.kml` (a `<Model>` placed at `latitude`/`longitude`/
      * `altitude`) + `model.glb`. `x_axis_abscissa`/`x_axis_ordinate` are the
      * `IfcMapConversion` grid-north components; pass both as `undefined` for heading 0.
+     *
+     * `altitude_mode` selects the KML vertical placement: `"clampToGround"`
+     * (the default when omitted) rests the model on the terrain, ignoring
+     * `altitude`; `"absolute"` places the origin at `altitude` metres MSL.
+     * Google Earth's terrain already encodes the site elevation, so clamping
+     * keeps a wrong/zero/double-counted OrthogonalHeight from floating the
+     * model into the sky (#1427); absolute is offered for models whose
+     * OrthogonalHeight is a true MSL elevation the user wants honoured.
      * @param {Uint8Array} glb
      * @param {number} latitude
      * @param {number} longitude
@@ -691,21 +703,24 @@ export class IfcAPI {
      * @param {number | null | undefined} x_axis_abscissa
      * @param {number | null | undefined} x_axis_ordinate
      * @param {string} name
+     * @param {string | null} [altitude_mode]
      * @returns {Uint8Array}
      */
-    exportKmz(glb, latitude, longitude, altitude, x_axis_abscissa, x_axis_ordinate, name) {
+    exportKmz(glb, latitude, longitude, altitude, x_axis_abscissa, x_axis_ordinate, name, altitude_mode) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passArray8ToWasm0(glb, wasm.__wbindgen_export);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len1 = WASM_VECTOR_LEN;
-            wasm.ifcapi_exportKmz(retptr, this.__wbg_ptr, ptr0, len0, latitude, longitude, altitude, !isLikeNone(x_axis_abscissa), isLikeNone(x_axis_abscissa) ? 0 : x_axis_abscissa, !isLikeNone(x_axis_ordinate), isLikeNone(x_axis_ordinate) ? 0 : x_axis_ordinate, ptr1, len1);
+            var ptr2 = isLikeNone(altitude_mode) ? 0 : passStringToWasm0(altitude_mode, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len2 = WASM_VECTOR_LEN;
+            wasm.ifcapi_exportKmz(retptr, this.__wbg_ptr, ptr0, len0, latitude, longitude, altitude, !isLikeNone(x_axis_abscissa), isLikeNone(x_axis_abscissa) ? 0 : x_axis_abscissa, !isLikeNone(x_axis_ordinate), isLikeNone(x_axis_ordinate) ? 0 : x_axis_ordinate, ptr1, len1, ptr2, len2);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var v3 = getArrayU8FromWasm0(r0, r1).slice();
+            var v4 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_export4(r0, r1 * 1, 1);
-            return v3;
+            return v4;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -726,9 +741,10 @@ export class IfcAPI {
      * @param {Uint32Array} express_ids
      * @param {boolean} include_metadata
      * @param {boolean | null} [lit]
+     * @param {boolean | null} [emissive]
      * @returns {Uint8Array}
      */
-    exportGlbFromMeshes(positions, normals, indices, vertex_counts, index_counts, colors, origins, express_ids, include_metadata, lit) {
+    exportGlbFromMeshes(positions, normals, indices, vertex_counts, index_counts, colors, origins, express_ids, include_metadata, lit, emissive) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passArrayF32ToWasm0(positions, wasm.__wbindgen_export);
@@ -747,7 +763,7 @@ export class IfcAPI {
             const len6 = WASM_VECTOR_LEN;
             const ptr7 = passArray32ToWasm0(express_ids, wasm.__wbindgen_export);
             const len7 = WASM_VECTOR_LEN;
-            wasm.ifcapi_exportGlbFromMeshes(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, include_metadata, isLikeNone(lit) ? 0xFFFFFF : lit ? 1 : 0);
+            wasm.ifcapi_exportGlbFromMeshes(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, include_metadata, isLikeNone(lit) ? 0xFFFFFF : lit ? 1 : 0, isLikeNone(emissive) ? 0xFFFFFF : emissive ? 1 : 0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var v9 = getArrayU8FromWasm0(r0, r1).slice();
@@ -757,6 +773,64 @@ export class IfcAPI {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Build a Google-Earth-ready **KMZ** (`Uint8Array`) straight from the viewer's
+     * already-produced meshes — the working path (#1427). The model is embedded as
+     * **COLLADA** (`model.dae`), the only `<Model>` format Google Earth loads (a GLB
+     * raises "Unsupported element: Model"), with emission-lit double-sided materials
+     * placement. Mesh arrays match `exportGlbFromMeshes`;
+     * `latitude`/`longitude`/`altitude` + `x_axis_abscissa`/`x_axis_ordinate`
+     * (grid-north, `undefined` ⇒ heading 0) place + orient the model.
+     * `altitude_mode` (`"clampToGround"` default ⇒ rest on terrain, ignoring
+     * `altitude`; `"absolute"` ⇒ place at `altitude` metres MSL) selects the
+     * KML vertical placement (#1427).
+     * @param {Float32Array} positions
+     * @param {Float32Array} normals
+     * @param {Uint32Array} indices
+     * @param {Uint32Array} vertex_counts
+     * @param {Uint32Array} index_counts
+     * @param {Float32Array} colors
+     * @param {Float64Array} origins
+     * @param {number} latitude
+     * @param {number} longitude
+     * @param {number} altitude
+     * @param {number | null | undefined} x_axis_abscissa
+     * @param {number | null | undefined} x_axis_ordinate
+     * @param {string} name
+     * @param {string | null} [altitude_mode]
+     * @returns {Uint8Array}
+     */
+    exportKmzFromMeshes(positions, normals, indices, vertex_counts, index_counts, colors, origins, latitude, longitude, altitude, x_axis_abscissa, x_axis_ordinate, name, altitude_mode) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF32ToWasm0(positions, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF32ToWasm0(normals, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray32ToWasm0(indices, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArray32ToWasm0(vertex_counts, wasm.__wbindgen_export);
+            const len3 = WASM_VECTOR_LEN;
+            const ptr4 = passArray32ToWasm0(index_counts, wasm.__wbindgen_export);
+            const len4 = WASM_VECTOR_LEN;
+            const ptr5 = passArrayF32ToWasm0(colors, wasm.__wbindgen_export);
+            const len5 = WASM_VECTOR_LEN;
+            const ptr6 = passArrayF64ToWasm0(origins, wasm.__wbindgen_export);
+            const len6 = WASM_VECTOR_LEN;
+            const ptr7 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len7 = WASM_VECTOR_LEN;
+            var ptr8 = isLikeNone(altitude_mode) ? 0 : passStringToWasm0(altitude_mode, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len8 = WASM_VECTOR_LEN;
+            wasm.ifcapi_exportKmzFromMeshes(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, latitude, longitude, altitude, !isLikeNone(x_axis_abscissa), isLikeNone(x_axis_abscissa) ? 0 : x_axis_abscissa, !isLikeNone(x_axis_ordinate), isLikeNone(x_axis_ordinate) ? 0 : x_axis_ordinate, ptr7, len7, ptr8, len8);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v10 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v10;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Export the render geometry in `content` as Wavefront **OBJ** UTF-8 bytes.
      *
@@ -1452,13 +1526,14 @@ export class IfcAPI {
      * even though the pre-pass worker built the same index minutes
      * earlier.
      *
-     * Building an `FxHashMap` from the three input slices costs ~1 s on
-     * 14 M entries — about 4–5× faster than re-scanning the file. After
-     * this call, the next `processGeometryBatch` skips the lazy build
-     * branch and reuses the populated cache by `Arc::clone()`.
+     * Builds a compact [`ColumnarEntityIndex`] from the three input slices
+     * (sorted `u32` columns + binary search) instead of a per-worker
+     * `FxHashMap` — ~229 MB vs ~436 MB on a 19.1 M-entity model (#1682).
+     * [`ColumnarEntityIndex::from_columns`] verifies the id ordering once
+     * (O(n)) and only argsorts if the producer did not emit sorted columns.
      *
-     * `lengths[i]` is the byte length of entity `ids[i]`, so the cache
-     * stores `(start, start + length)` to match the existing tuple layout.
+     * `lengths[i]` is the byte length of entity `ids[i]`, so lookup returns
+     * `(start, start + length)` to match the existing `(start, end)` layout.
      *
      * Idempotent in the sense that repeated calls REPLACE the cache —
      * supports the parser-worker pattern of reusing one IfcAPI across