@ifc-lite/wasm 2.11.0 → 2.11.1

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -123,8 +123,11 @@ export class IfcAPI {
    */
   buildPrePassOnce(data: Uint8Array): any;
   /**
-   * Process geometry for a subset of pre-scanned entities.
-   * Takes raw bytes and pre-pass data from buildPrePassOnce.
+   * Process geometry for a subset of pre-scanned entities → flat
+   * MeshCollection. Takes raw bytes + pre-pass data from buildPrePassOnce.
+   * Thin wrapper over [`IfcAPI::produce_batch`]; converts each produced mesh
+   * to MeshDataJs (the IFC Z-up→WebGL Y-up swap + winding reversal happen
+   * there). Output is byte-for-byte what the pre-refactor method produced.
    */
   processGeometryBatch(data: Uint8Array, jobs_flat: Uint32Array, unit_scale: number, rtc_x: number, rtc_y: number, rtc_z: number, needs_shift: boolean, void_keys: Uint32Array, void_counts: Uint32Array, void_values: Uint32Array, style_ids: Uint32Array, style_colors: Uint8Array, plane_angle_to_radians?: number | null, material_element_ids?: Uint32Array | null, material_color_counts?: Uint32Array | null, material_colors_rgba?: Uint8Array | null): MeshCollection;
   /**
@@ -153,6 +156,36 @@ export class IfcAPI {
    *   `{ type: "complete", totalJobs }`
    */
   buildPrePassStreaming(data: Uint8Array, on_event: Function, chunk_size: number, disabled_type_names: string[] | null | undefined, skip_type_geometry: boolean): any;
+  /**
+   * Like [`IfcAPI::process_geometry_batch`] but collates the batch's meshes
+   * into a GPU-instancing shard (IFNS wire format) instead of a flat
+   * MeshCollection. Repeated geometry collapses to one template + per-
+   * occurrence transforms; non-instanceable meshes ride as flat singleton
+   * templates so nothing is dropped. The shard stays in the producer-native
+   * (IFC Z-up) frame — the renderer composes the constant Z-up→Y-up swap at
+   * upload. Each batch shard renders independently: affinity routing already
+   * co-locates identical geometry on one worker, so per-batch collation
+   * captures ~all the dedup and no cross-batch merge is needed. Returns empty
+   * bytes only when the batch produced zero non-empty meshes.
+   */
+  processGeometryBatchInstanced(data: Uint8Array, jobs_flat: Uint32Array, unit_scale: number, rtc_x: number, rtc_y: number, rtc_z: number, needs_shift: boolean, void_keys: Uint32Array, void_counts: Uint32Array, void_values: Uint32Array, style_ids: Uint32Array, style_colors: Uint8Array, plane_angle_to_radians?: number | null, material_element_ids?: Uint32Array | null, material_color_counts?: Uint32Array | null, material_colors_rgba?: Uint8Array | null): Uint8Array;
+  /**
+   * Produce a batch ONCE and PARTITION it (the instanced-ONLY path): opaque
+   * ordinary occurrences (colour alpha >= 0.99 AND geometry_class == 0) are
+   * collated into the instanced shard; everything else (transparent glass,
+   * type-product geometry) goes to the flat MeshCollection. Each mesh takes
+   * exactly ONE route, so produce_batch runs once (no emit-both 2× meshing)
+   * and the renderer draws opaque occurrences via instancing instead of flat.
+   * Partition mirrors the renderer gates: INSTANCED_ALPHA_CUTOFF (0.99 =
+   * OPAQUE_ALPHA_CUTOFF) for transparency, geometry_class for the Model/Types
+   * split.
+   *
+   * NOTE: the renderer must be instanced-feature-complete (picking / selection
+   * / lens overlays on instanced geometry) before the worker calls this in
+   * place of processGeometryBatch — otherwise those features break for the
+   * opaque bulk. See the instanced-only follow-ups.
+   */
+  processGeometryBatchPartitioned(data: Uint8Array, jobs_flat: Uint32Array, unit_scale: number, rtc_x: number, rtc_y: number, rtc_z: number, needs_shift: boolean, void_keys: Uint32Array, void_counts: Uint32Array, void_values: Uint32Array, style_ids: Uint32Array, style_colors: Uint8Array, plane_angle_to_radians?: number | null, material_element_ids?: Uint32Array | null, material_color_counts?: Uint32Array | null, material_colors_rgba?: Uint8Array | null): PartitionedBatch;
   /**
    * 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
@@ -568,6 +601,27 @@ export class MeshOutlineJs {
   readonly axisMin: number;
 }
 
+export class PartitionedBatch {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * The instanced IFNS shard bytes (opaque ordinary occurrences). Moves out.
+   */
+  takeShard(): Uint8Array;
+  /**
+   * The flat MeshCollection (transparent glass + type-product geometry).
+   * Moves out — call once.
+   */
+  takeMeshes(): MeshCollection | undefined;
+  /**
+   * Number of occurrences routed into the instanced shard this batch. The viewer
+   * folds this into its total mesh count so the count reflects ALL rendered
+   * geometry (flat + instanced), not just the flat MeshCollection.
+   */
+  readonly instancedOccurrences: number;
+}
+
 export class ProfileCollection {
   private constructor();
   free(): void;
@@ -983,6 +1037,7 @@ export interface InitOutput {
   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_partitionedbatch_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_spaceplatehandle_free: (a: number, b: number) => void;
@@ -1031,6 +1086,8 @@ export interface InitOutput {
   readonly ifcapi_parseGridLines: (a: number, b: number, c: 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, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number) => number;
+  readonly ifcapi_processGeometryBatchInstanced: (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, b1: number, c1: number) => void;
+  readonly ifcapi_processGeometryBatchPartitioned: (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, b1: number) => number;
   readonly ifcapi_scanEntitiesFast: (a: number, b: number, c: number) => number;
   readonly ifcapi_scanEntitiesFastBytes: (a: number, b: number, c: number) => number;
   readonly ifcapi_scanGeometryEntitiesFast: (a: number, b: number, c: number) => number;
@@ -1076,6 +1133,9 @@ export interface InitOutput {
   readonly meshoutlinejs_axisMin: (a: number) => number;
   readonly meshoutlinejs_contour: (a: number, b: number) => number;
   readonly meshoutlinejs_contourCount: (a: number) => number;
+  readonly partitionedbatch_instancedOccurrences: (a: number) => number;
+  readonly partitionedbatch_takeMeshes: (a: number) => number;
+  readonly partitionedbatch_takeShard: (a: number, b: number) => void;
   readonly profilecollection_get: (a: number, b: number) => number;
   readonly profilecollection_length: (a: number) => number;
   readonly profileentryjs_extrusionDepth: (a: number) => number;

package/pkg/ifc-lite.js

@@ -262,6 +262,10 @@ const MeshOutlineJsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_meshoutlinejs_free(ptr >>> 0, 1));
 
+const PartitionedBatchFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_partitionedbatch_free(ptr >>> 0, 1));
+
 const ProfileCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_profilecollection_free(ptr >>> 0, 1));
@@ -786,8 +790,11 @@ export class IfcAPI {
         return takeObject(ret);
     }
     /**
-     * Process geometry for a subset of pre-scanned entities.
-     * Takes raw bytes and pre-pass data from buildPrePassOnce.
+     * Process geometry for a subset of pre-scanned entities → flat
+     * MeshCollection. Takes raw bytes + pre-pass data from buildPrePassOnce.
+     * Thin wrapper over [`IfcAPI::produce_batch`]; converts each produced mesh
+     * to MeshDataJs (the IFC Z-up→WebGL Y-up swap + winding reversal happen
+     * there). Output is byte-for-byte what the pre-refactor method produced.
      * @param {Uint8Array} data
      * @param {Uint32Array} jobs_flat
      * @param {number} unit_scale
@@ -881,6 +888,125 @@ export class IfcAPI {
             heap[stack_pointer++] = undefined;
         }
     }
+    /**
+     * Like [`IfcAPI::process_geometry_batch`] but collates the batch's meshes
+     * into a GPU-instancing shard (IFNS wire format) instead of a flat
+     * MeshCollection. Repeated geometry collapses to one template + per-
+     * occurrence transforms; non-instanceable meshes ride as flat singleton
+     * templates so nothing is dropped. The shard stays in the producer-native
+     * (IFC Z-up) frame — the renderer composes the constant Z-up→Y-up swap at
+     * upload. Each batch shard renders independently: affinity routing already
+     * co-locates identical geometry on one worker, so per-batch collation
+     * captures ~all the dedup and no cross-batch merge is needed. Returns empty
+     * bytes only when the batch produced zero non-empty meshes.
+     * @param {Uint8Array} data
+     * @param {Uint32Array} jobs_flat
+     * @param {number} unit_scale
+     * @param {number} rtc_x
+     * @param {number} rtc_y
+     * @param {number} rtc_z
+     * @param {boolean} needs_shift
+     * @param {Uint32Array} void_keys
+     * @param {Uint32Array} void_counts
+     * @param {Uint32Array} void_values
+     * @param {Uint32Array} style_ids
+     * @param {Uint8Array} style_colors
+     * @param {number | null} [plane_angle_to_radians]
+     * @param {Uint32Array | null} [material_element_ids]
+     * @param {Uint32Array | null} [material_color_counts]
+     * @param {Uint8Array | null} [material_colors_rgba]
+     * @returns {Uint8Array}
+     */
+    processGeometryBatchInstanced(data, jobs_flat, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, void_keys, void_counts, void_values, style_ids, style_colors, plane_angle_to_radians, material_element_ids, material_color_counts, material_colors_rgba) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray32ToWasm0(jobs_flat, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray32ToWasm0(void_keys, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArray32ToWasm0(void_counts, wasm.__wbindgen_export);
+            const len3 = WASM_VECTOR_LEN;
+            const ptr4 = passArray32ToWasm0(void_values, wasm.__wbindgen_export);
+            const len4 = WASM_VECTOR_LEN;
+            const ptr5 = passArray32ToWasm0(style_ids, wasm.__wbindgen_export);
+            const len5 = WASM_VECTOR_LEN;
+            const ptr6 = passArray8ToWasm0(style_colors, wasm.__wbindgen_export);
+            const len6 = WASM_VECTOR_LEN;
+            var ptr7 = isLikeNone(material_element_ids) ? 0 : passArray32ToWasm0(material_element_ids, wasm.__wbindgen_export);
+            var len7 = WASM_VECTOR_LEN;
+            var ptr8 = isLikeNone(material_color_counts) ? 0 : passArray32ToWasm0(material_color_counts, wasm.__wbindgen_export);
+            var len8 = WASM_VECTOR_LEN;
+            var ptr9 = isLikeNone(material_colors_rgba) ? 0 : passArray8ToWasm0(material_colors_rgba, wasm.__wbindgen_export);
+            var len9 = WASM_VECTOR_LEN;
+            wasm.ifcapi_processGeometryBatchInstanced(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, !isLikeNone(plane_angle_to_radians), isLikeNone(plane_angle_to_radians) ? 0 : plane_angle_to_radians, ptr7, len7, ptr8, len8, ptr9, len9);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v11 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v11;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Produce a batch ONCE and PARTITION it (the instanced-ONLY path): opaque
+     * ordinary occurrences (colour alpha >= 0.99 AND geometry_class == 0) are
+     * collated into the instanced shard; everything else (transparent glass,
+     * type-product geometry) goes to the flat MeshCollection. Each mesh takes
+     * exactly ONE route, so produce_batch runs once (no emit-both 2× meshing)
+     * and the renderer draws opaque occurrences via instancing instead of flat.
+     * Partition mirrors the renderer gates: INSTANCED_ALPHA_CUTOFF (0.99 =
+     * OPAQUE_ALPHA_CUTOFF) for transparency, geometry_class for the Model/Types
+     * split.
+     *
+     * NOTE: the renderer must be instanced-feature-complete (picking / selection
+     * / lens overlays on instanced geometry) before the worker calls this in
+     * place of processGeometryBatch — otherwise those features break for the
+     * opaque bulk. See the instanced-only follow-ups.
+     * @param {Uint8Array} data
+     * @param {Uint32Array} jobs_flat
+     * @param {number} unit_scale
+     * @param {number} rtc_x
+     * @param {number} rtc_y
+     * @param {number} rtc_z
+     * @param {boolean} needs_shift
+     * @param {Uint32Array} void_keys
+     * @param {Uint32Array} void_counts
+     * @param {Uint32Array} void_values
+     * @param {Uint32Array} style_ids
+     * @param {Uint8Array} style_colors
+     * @param {number | null} [plane_angle_to_radians]
+     * @param {Uint32Array | null} [material_element_ids]
+     * @param {Uint32Array | null} [material_color_counts]
+     * @param {Uint8Array | null} [material_colors_rgba]
+     * @returns {PartitionedBatch}
+     */
+    processGeometryBatchPartitioned(data, jobs_flat, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, void_keys, void_counts, void_values, style_ids, style_colors, plane_angle_to_radians, material_element_ids, material_color_counts, material_colors_rgba) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(jobs_flat, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray32ToWasm0(void_keys, wasm.__wbindgen_export);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray32ToWasm0(void_counts, wasm.__wbindgen_export);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passArray32ToWasm0(void_values, wasm.__wbindgen_export);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passArray32ToWasm0(style_ids, wasm.__wbindgen_export);
+        const len5 = WASM_VECTOR_LEN;
+        const ptr6 = passArray8ToWasm0(style_colors, wasm.__wbindgen_export);
+        const len6 = WASM_VECTOR_LEN;
+        var ptr7 = isLikeNone(material_element_ids) ? 0 : passArray32ToWasm0(material_element_ids, wasm.__wbindgen_export);
+        var len7 = WASM_VECTOR_LEN;
+        var ptr8 = isLikeNone(material_color_counts) ? 0 : passArray32ToWasm0(material_color_counts, wasm.__wbindgen_export);
+        var len8 = WASM_VECTOR_LEN;
+        var ptr9 = isLikeNone(material_colors_rgba) ? 0 : passArray8ToWasm0(material_colors_rgba, wasm.__wbindgen_export);
+        var len9 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_processGeometryBatchPartitioned(this.__wbg_ptr, ptr0, len0, ptr1, len1, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, !isLikeNone(plane_angle_to_radians), isLikeNone(plane_angle_to_radians) ? 0 : plane_angle_to_radians, ptr7, len7, ptr8, len8, ptr9, len9);
+        return PartitionedBatch.__wrap(ret);
+    }
     /**
      * 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
@@ -1838,6 +1964,69 @@ export class MeshOutlineJs {
 }
 if (Symbol.dispose) MeshOutlineJs.prototype[Symbol.dispose] = MeshOutlineJs.prototype.free;
 
+/**
+ * Result of [`IfcAPI::process_geometry_batch_partitioned`]: the flat
+ * MeshCollection (transparent + type geometry) and the instanced IFNS shard
+ * (opaque ordinary occurrences) from ONE produce_batch. Take-once accessors so
+ * the JS side moves each out without a clone.
+ */
+export class PartitionedBatch {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PartitionedBatch.prototype);
+        obj.__wbg_ptr = ptr;
+        PartitionedBatchFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PartitionedBatchFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_partitionedbatch_free(ptr, 0);
+    }
+    /**
+     * The instanced IFNS shard bytes (opaque ordinary occurrences). Moves out.
+     * @returns {Uint8Array}
+     */
+    takeShard() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.partitionedbatch_takeShard(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_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The flat MeshCollection (transparent glass + type-product geometry).
+     * Moves out — call once.
+     * @returns {MeshCollection | undefined}
+     */
+    takeMeshes() {
+        const ret = wasm.partitionedbatch_takeMeshes(this.__wbg_ptr);
+        return ret === 0 ? undefined : MeshCollection.__wrap(ret);
+    }
+    /**
+     * Number of occurrences routed into the instanced shard this batch. The viewer
+     * folds this into its total mesh count so the count reflects ALL rendered
+     * geometry (flat + instanced), not just the flat MeshCollection.
+     * @returns {number}
+     */
+    get instancedOccurrences() {
+        const ret = wasm.partitionedbatch_instancedOccurrences(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) PartitionedBatch.prototype[Symbol.dispose] = PartitionedBatch.prototype.free;
+
 /**
  * A collection of extracted profiles.
  */