@ifc-lite/wasm 1.14.2 → 1.14.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/README.md +5 -3
  2. package/package.json +1 -1
  3. package/pkg/ifc-lite.d.ts +981 -1049
  4. package/pkg/ifc-lite.js +1452 -1445
  5. package/pkg/ifc-lite_bg.wasm +0 -0
package/pkg/ifc-lite.d.ts CHANGED
@@ -1,888 +1,820 @@
1
1
  /* tslint:disable */
2
2
  /* eslint-disable */
3
3
 
4
- /**
5
- * Georeferencing information exposed to JavaScript
6
- */
7
4
  export class GeoReferenceJs {
8
- private constructor();
9
- free(): void;
10
- [Symbol.dispose](): void;
11
- /**
12
- * Transform local coordinates to map coordinates
13
- */
14
- localToMap(x: number, y: number, z: number): Float64Array;
15
- /**
16
- * Transform map coordinates to local coordinates
17
- */
18
- mapToLocal(e: number, n: number, h: number): Float64Array;
19
- /**
20
- * Get 4x4 transformation matrix (column-major for WebGL)
21
- */
22
- toMatrix(): Float64Array;
23
- /**
24
- * Get CRS name
25
- */
26
- readonly crsName: string | undefined;
27
- /**
28
- * Get rotation angle in radians
29
- */
30
- readonly rotation: number;
31
- /**
32
- * Eastings (X offset)
33
- */
34
- eastings: number;
35
- /**
36
- * Northings (Y offset)
37
- */
38
- northings: number;
39
- /**
40
- * Orthogonal height (Z offset)
41
- */
42
- orthogonal_height: number;
43
- /**
44
- * Scale factor
45
- */
46
- scale: number;
47
- /**
48
- * X-axis abscissa (cos of rotation)
49
- */
50
- x_axis_abscissa: number;
51
- /**
52
- * X-axis ordinate (sin of rotation)
53
- */
54
- x_axis_ordinate: number;
5
+ private constructor();
6
+ free(): void;
7
+ [Symbol.dispose](): void;
8
+ /**
9
+ * Transform local coordinates to map coordinates
10
+ */
11
+ localToMap(x: number, y: number, z: number): Float64Array;
12
+ /**
13
+ * Transform map coordinates to local coordinates
14
+ */
15
+ mapToLocal(e: number, n: number, h: number): Float64Array;
16
+ /**
17
+ * Get 4x4 transformation matrix (column-major for WebGL)
18
+ */
19
+ toMatrix(): Float64Array;
20
+ /**
21
+ * Eastings (X offset)
22
+ */
23
+ eastings: number;
24
+ /**
25
+ * Northings (Y offset)
26
+ */
27
+ northings: number;
28
+ /**
29
+ * Orthogonal height (Z offset)
30
+ */
31
+ orthogonal_height: number;
32
+ /**
33
+ * X-axis abscissa (cos of rotation)
34
+ */
35
+ x_axis_abscissa: number;
36
+ /**
37
+ * X-axis ordinate (sin of rotation)
38
+ */
39
+ x_axis_ordinate: number;
40
+ /**
41
+ * Scale factor
42
+ */
43
+ scale: number;
44
+ /**
45
+ * Get CRS name
46
+ */
47
+ readonly crsName: string | undefined;
48
+ /**
49
+ * Get rotation angle in radians
50
+ */
51
+ readonly rotation: number;
55
52
  }
56
53
 
57
- /**
58
- * GPU-ready geometry stored in WASM linear memory
59
- *
60
- * Data layout:
61
- * - vertex_data: Interleaved [px, py, pz, nx, ny, nz, ...] (6 floats per vertex)
62
- * - indices: Triangle indices [i0, i1, i2, ...]
63
- * - mesh_metadata: Per-mesh metadata for draw calls
64
- *
65
- * All coordinates are pre-converted from IFC Z-up to WebGL Y-up
66
- */
67
54
  export class GpuGeometry {
68
- free(): void;
69
- [Symbol.dispose](): void;
70
- /**
71
- * Get IFC type name by index
72
- */
73
- getIfcTypeName(index: number): string | undefined;
74
- /**
75
- * Get metadata for a specific mesh
76
- */
77
- getMeshMetadata(index: number): GpuMeshMetadata | undefined;
78
- /**
79
- * Create a new empty GPU geometry container
80
- */
81
- constructor();
82
- /**
83
- * Set the RTC (Relative To Center) offset applied to coordinates
84
- */
85
- set_rtc_offset(x: number, y: number, z: number): void;
86
- /**
87
- * Check if RTC offset is active (non-zero)
88
- */
89
- readonly hasRtcOffset: boolean;
90
- /**
91
- * Get byte length of indices (for GPU buffer creation)
92
- */
93
- readonly indicesByteLength: number;
94
- /**
95
- * Get length of indices array (in u32 elements)
96
- */
97
- readonly indicesLen: number;
98
- /**
99
- * Get pointer to indices array for zero-copy view
100
- */
101
- readonly indicesPtr: number;
102
- /**
103
- * Check if geometry is empty
104
- */
105
- readonly isEmpty: boolean;
106
- /**
107
- * Get number of meshes in this geometry batch
108
- */
109
- readonly meshCount: number;
110
- /**
111
- * Get X component of RTC offset
112
- */
113
- readonly rtcOffsetX: number;
114
- /**
115
- * Get Y component of RTC offset
116
- */
117
- readonly rtcOffsetY: number;
118
- /**
119
- * Get Z component of RTC offset
120
- */
121
- readonly rtcOffsetZ: number;
122
- /**
123
- * Get total triangle count
124
- */
125
- readonly totalTriangleCount: number;
126
- /**
127
- * Get total vertex count
128
- */
129
- readonly totalVertexCount: number;
130
- /**
131
- * Get byte length of vertex data (for GPU buffer creation)
132
- */
133
- readonly vertexDataByteLength: number;
134
- /**
135
- * Get length of vertex data array (in f32 elements, not bytes)
136
- */
137
- readonly vertexDataLen: number;
138
- /**
139
- * Get pointer to vertex data for zero-copy view
140
- *
141
- * SAFETY: View is only valid until next WASM allocation!
142
- * Create view, upload to GPU, then discard view immediately.
143
- */
144
- readonly vertexDataPtr: number;
55
+ free(): void;
56
+ [Symbol.dispose](): void;
57
+ /**
58
+ * Set the RTC (Relative To Center) offset applied to coordinates
59
+ */
60
+ set_rtc_offset(x: number, y: number, z: number): void;
61
+ /**
62
+ * Get IFC type name by index
63
+ */
64
+ getIfcTypeName(index: number): string | undefined;
65
+ /**
66
+ * Get metadata for a specific mesh
67
+ */
68
+ getMeshMetadata(index: number): GpuMeshMetadata | undefined;
69
+ /**
70
+ * Create a new empty GPU geometry container
71
+ */
72
+ constructor();
73
+ /**
74
+ * Get number of meshes in this geometry batch
75
+ */
76
+ readonly meshCount: number;
77
+ /**
78
+ * Get length of indices array (in u32 elements)
79
+ */
80
+ readonly indicesLen: number;
81
+ /**
82
+ * Get pointer to indices array for zero-copy view
83
+ */
84
+ readonly indicesPtr: number;
85
+ /**
86
+ * Get X component of RTC offset
87
+ */
88
+ readonly rtcOffsetX: number;
89
+ /**
90
+ * Get Y component of RTC offset
91
+ */
92
+ readonly rtcOffsetY: number;
93
+ /**
94
+ * Get Z component of RTC offset
95
+ */
96
+ readonly rtcOffsetZ: number;
97
+ /**
98
+ * Check if RTC offset is active (non-zero)
99
+ */
100
+ readonly hasRtcOffset: boolean;
101
+ /**
102
+ * Get length of vertex data array (in f32 elements, not bytes)
103
+ */
104
+ readonly vertexDataLen: number;
105
+ /**
106
+ * Get pointer to vertex data for zero-copy view
107
+ *
108
+ * SAFETY: View is only valid until next WASM allocation!
109
+ * Create view, upload to GPU, then discard view immediately.
110
+ */
111
+ readonly vertexDataPtr: number;
112
+ /**
113
+ * Get total vertex count
114
+ */
115
+ readonly totalVertexCount: number;
116
+ /**
117
+ * Get byte length of indices (for GPU buffer creation)
118
+ */
119
+ readonly indicesByteLength: number;
120
+ /**
121
+ * Get total triangle count
122
+ */
123
+ readonly totalTriangleCount: number;
124
+ /**
125
+ * Get byte length of vertex data (for GPU buffer creation)
126
+ */
127
+ readonly vertexDataByteLength: number;
128
+ /**
129
+ * Check if geometry is empty
130
+ */
131
+ readonly isEmpty: boolean;
145
132
  }
146
133
 
147
- /**
148
- * GPU-ready instanced geometry for efficient rendering of repeated shapes
149
- *
150
- * Data layout:
151
- * - vertex_data: Interleaved [px, py, pz, nx, ny, nz, ...] (shared geometry)
152
- * - indices: Triangle indices (shared geometry)
153
- * - instance_data: [transform (16 floats) + color (4 floats)] per instance = 20 floats
154
- */
155
134
  export class GpuInstancedGeometry {
156
- free(): void;
157
- [Symbol.dispose](): void;
158
- /**
159
- * Create new instanced geometry
160
- */
161
- constructor(geometry_id: bigint);
162
- readonly geometryId: bigint;
163
- readonly indicesByteLength: number;
164
- readonly indicesLen: number;
165
- readonly indicesPtr: number;
166
- readonly instanceCount: number;
167
- readonly instanceDataByteLength: number;
168
- readonly instanceDataLen: number;
169
- readonly instanceDataPtr: number;
170
- readonly instanceExpressIdsPtr: number;
171
- readonly triangleCount: number;
172
- readonly vertexCount: number;
173
- readonly vertexDataByteLength: number;
174
- readonly vertexDataLen: number;
175
- readonly vertexDataPtr: number;
135
+ free(): void;
136
+ [Symbol.dispose](): void;
137
+ /**
138
+ * Create new instanced geometry
139
+ */
140
+ constructor(geometry_id: bigint);
141
+ readonly geometryId: bigint;
142
+ readonly indicesLen: number;
143
+ readonly indicesPtr: number;
144
+ readonly vertexCount: number;
145
+ readonly instanceCount: number;
146
+ readonly triangleCount: number;
147
+ readonly vertexDataLen: number;
148
+ readonly vertexDataPtr: number;
149
+ readonly instanceDataLen: number;
150
+ readonly instanceDataPtr: number;
151
+ readonly indicesByteLength: number;
152
+ readonly vertexDataByteLength: number;
153
+ readonly instanceExpressIdsPtr: number;
154
+ readonly instanceDataByteLength: number;
176
155
  }
177
156
 
178
- /**
179
- * Collection of GPU-ready instanced geometries
180
- */
181
157
  export class GpuInstancedGeometryCollection {
182
- free(): void;
183
- [Symbol.dispose](): void;
184
- get(index: number): GpuInstancedGeometry | undefined;
185
- /**
186
- * Get geometry by index with zero-copy access
187
- * Returns a reference that provides pointer access
188
- */
189
- getRef(index: number): GpuInstancedGeometryRef | undefined;
190
- constructor();
191
- readonly length: number;
158
+ free(): void;
159
+ [Symbol.dispose](): void;
160
+ get(index: number): GpuInstancedGeometry | undefined;
161
+ constructor();
162
+ /**
163
+ * Get geometry by index with pointer access over owned buffers.
164
+ * This avoids exposing references tied to collection lifetime.
165
+ */
166
+ getRef(index: number): GpuInstancedGeometryRef | undefined;
167
+ readonly length: number;
192
168
  }
193
169
 
194
- /**
195
- * Reference to geometry in collection for zero-copy access
196
- * This avoids cloning when accessing geometry data
197
- */
198
170
  export class GpuInstancedGeometryRef {
199
- private constructor();
200
- free(): void;
201
- [Symbol.dispose](): void;
202
- readonly geometryId: bigint;
203
- readonly indicesByteLength: number;
204
- readonly indicesLen: number;
205
- readonly indicesPtr: number;
206
- readonly instanceCount: number;
207
- readonly instanceDataByteLength: number;
208
- readonly instanceDataLen: number;
209
- readonly instanceDataPtr: number;
210
- readonly instanceExpressIdsPtr: number;
211
- readonly vertexDataByteLength: number;
212
- readonly vertexDataLen: number;
213
- readonly vertexDataPtr: number;
171
+ private constructor();
172
+ free(): void;
173
+ [Symbol.dispose](): void;
174
+ readonly geometryId: bigint;
175
+ readonly indicesLen: number;
176
+ readonly indicesPtr: number;
177
+ readonly instanceCount: number;
178
+ readonly vertexDataLen: number;
179
+ readonly vertexDataPtr: number;
180
+ readonly instanceDataLen: number;
181
+ readonly instanceDataPtr: number;
182
+ readonly indicesByteLength: number;
183
+ readonly vertexDataByteLength: number;
184
+ readonly instanceExpressIdsPtr: number;
185
+ readonly instanceDataByteLength: number;
214
186
  }
215
187
 
216
- /**
217
- * Metadata for a single mesh within the GPU geometry buffer
218
- */
219
188
  export class GpuMeshMetadata {
220
- private constructor();
221
- free(): void;
222
- [Symbol.dispose](): void;
223
- readonly color: Float32Array;
224
- readonly expressId: number;
225
- readonly ifcTypeIdx: number;
226
- readonly indexCount: number;
227
- readonly indexOffset: number;
228
- readonly vertexCount: number;
229
- readonly vertexOffset: number;
189
+ private constructor();
190
+ free(): void;
191
+ [Symbol.dispose](): void;
192
+ readonly expressId: number;
193
+ readonly indexCount: number;
194
+ readonly ifcTypeIdx: number;
195
+ readonly indexOffset: number;
196
+ readonly vertexCount: number;
197
+ readonly vertexOffset: number;
198
+ readonly color: Float32Array;
230
199
  }
231
200
 
232
- /**
233
- * Main IFC-Lite API
234
- */
235
201
  export class IfcAPI {
236
- free(): void;
237
- [Symbol.dispose](): void;
238
- /**
239
- * Debug: Test processing entity #953 (FacetedBrep wall)
240
- */
241
- debugProcessEntity953(content: string): string;
242
- /**
243
- * Debug: Test processing a single wall
244
- */
245
- debugProcessFirstWall(content: string): string;
246
- /**
247
- * Extract georeferencing information from IFC content
248
- * Returns null if no georeferencing is present
249
- *
250
- * Example:
251
- * ```javascript
252
- * const api = new IfcAPI();
253
- * const georef = api.getGeoReference(ifcData);
254
- * if (georef) {
255
- * console.log('CRS:', georef.crsName);
256
- * const [e, n, h] = georef.localToMap(10, 20, 5);
257
- * }
258
- * ```
259
- */
260
- getGeoReference(content: string): GeoReferenceJs | undefined;
261
- /**
262
- * Get WASM memory for zero-copy access
263
- */
264
- getMemory(): any;
265
- /**
266
- * Create and initialize the IFC API
267
- */
268
- constructor();
269
- /**
270
- * Parse IFC file (traditional - waits for completion)
271
- *
272
- * Example:
273
- * ```javascript
274
- * const api = new IfcAPI();
275
- * const result = await api.parse(ifcData);
276
- * console.log('Entities:', result.entityCount);
277
- * ```
278
- */
279
- parse(content: string): Promise<any>;
280
- /**
281
- * Parse IFC file and return individual meshes with express IDs and colors
282
- * This matches the MeshData[] format expected by the viewer
283
- *
284
- * Example:
285
- * ```javascript
286
- * const api = new IfcAPI();
287
- * const collection = api.parseMeshes(ifcData);
288
- * for (let i = 0; i < collection.length; i++) {
289
- * const mesh = collection.get(i);
290
- * console.log('Express ID:', mesh.expressId);
291
- * console.log('Positions:', mesh.positions);
292
- * console.log('Color:', mesh.color);
293
- * }
294
- * ```
295
- */
296
- parseMeshes(content: string): MeshCollection;
297
- /**
298
- * Parse IFC file with streaming mesh batches for progressive rendering
299
- * Calls the callback with batches of meshes, yielding to browser between batches
300
- *
301
- * Options:
302
- * - `batchSize`: Number of meshes per batch (default: 25)
303
- * - `onBatch(meshes, progress)`: Called for each batch of meshes
304
- * - `onRtcOffset({x, y, z, hasRtc})`: Called early with RTC offset for camera/world setup
305
- * - `onColorUpdate(Map<id, color>)`: Called with style updates after initial render
306
- * - `onComplete(stats)`: Called when parsing completes with stats including rtcOffset
307
- *
308
- * Example:
309
- * ```javascript
310
- * const api = new IfcAPI();
311
- * await api.parseMeshesAsync(ifcData, {
312
- * batchSize: 100,
313
- * onRtcOffset: (rtc) => {
314
- * if (rtc.hasRtc) {
315
- * // Model uses large coordinates - adjust camera/world origin
316
- * viewer.setWorldOffset(rtc.x, rtc.y, rtc.z);
317
- * }
318
- * },
319
- * onBatch: (meshes, progress) => {
320
- * for (const mesh of meshes) {
321
- * scene.add(createThreeMesh(mesh));
322
- * }
323
- * console.log(`Progress: ${progress.percent}%`);
324
- * },
325
- * onComplete: (stats) => {
326
- * console.log(`Done! ${stats.totalMeshes} meshes`);
327
- * // stats.rtcOffset also available here: {x, y, z, hasRtc}
328
- * }
329
- * });
330
- * ```
331
- */
332
- parseMeshesAsync(content: string, options: any): Promise<any>;
333
- /**
334
- * Parse IFC file and return instanced geometry grouped by geometry hash
335
- * This reduces draw calls by grouping identical geometries with different transforms
336
- *
337
- * Example:
338
- * ```javascript
339
- * const api = new IfcAPI();
340
- * const collection = api.parseMeshesInstanced(ifcData);
341
- * for (let i = 0; i < collection.length; i++) {
342
- * const geometry = collection.get(i);
343
- * console.log('Geometry ID:', geometry.geometryId);
344
- * console.log('Instances:', geometry.instanceCount);
345
- * for (let j = 0; j < geometry.instanceCount; j++) {
346
- * const inst = geometry.getInstance(j);
347
- * console.log(' Express ID:', inst.expressId);
348
- * console.log(' Transform:', inst.transform);
349
- * }
350
- * }
351
- * ```
352
- */
353
- parseMeshesInstanced(content: string): InstancedMeshCollection;
354
- /**
355
- * Parse IFC file with streaming instanced geometry batches for progressive rendering
356
- * Groups identical geometries and yields batches of InstancedGeometry
357
- * Uses fast-first-frame streaming: simple geometry (walls, slabs) first
358
- *
359
- * Example:
360
- * ```javascript
361
- * const api = new IfcAPI();
362
- * await api.parseMeshesInstancedAsync(ifcData, {
363
- * batchSize: 25, // Number of unique geometries per batch
364
- * onBatch: (geometries, progress) => {
365
- * for (const geom of geometries) {
366
- * renderer.addInstancedGeometry(geom);
367
- * }
368
- * },
369
- * onComplete: (stats) => {
370
- * console.log(`Done! ${stats.totalGeometries} unique geometries, ${stats.totalInstances} instances`);
371
- * }
372
- * });
373
- * ```
374
- */
375
- parseMeshesInstancedAsync(content: string, options: any): Promise<any>;
376
- /**
377
- * Parse IFC file and return mesh with RTC offset for large coordinates
378
- * This handles georeferenced models by shifting to centroid
379
- *
380
- * Example:
381
- * ```javascript
382
- * const api = new IfcAPI();
383
- * const result = api.parseMeshesWithRtc(ifcData);
384
- * const rtcOffset = result.rtcOffset;
385
- * const meshes = result.meshes;
386
- *
387
- * // Convert local coords back to world:
388
- * if (rtcOffset.isSignificant()) {
389
- * const [wx, wy, wz] = rtcOffset.toWorld(localX, localY, localZ);
390
- * }
391
- * ```
392
- */
393
- parseMeshesWithRtc(content: string): MeshCollectionWithRtc;
394
- /**
395
- * Parse IFC file with streaming events
396
- * Calls the callback function for each parse event
397
- *
398
- * Example:
399
- * ```javascript
400
- * const api = new IfcAPI();
401
- * await api.parseStreaming(ifcData, (event) => {
402
- * console.log('Event:', event);
403
- * });
404
- * ```
405
- */
406
- parseStreaming(content: string, callback: Function): Promise<any>;
407
- /**
408
- * Parse IFC file and extract symbolic representations (Plan, Annotation, FootPrint)
409
- * These are 2D curves used for architectural drawings instead of sectioning 3D geometry
410
- *
411
- * Example:
412
- * ```javascript
413
- * const api = new IfcAPI();
414
- * const symbols = api.parseSymbolicRepresentations(ifcData);
415
- * console.log('Found', symbols.totalCount, 'symbolic items');
416
- * for (let i = 0; i < symbols.polylineCount; i++) {
417
- * const polyline = symbols.getPolyline(i);
418
- * console.log('Polyline for', polyline.ifcType, ':', polyline.points);
419
- * }
420
- * ```
421
- */
422
- parseSymbolicRepresentations(content: string): SymbolicRepresentationCollection;
423
- /**
424
- * Parse IFC file and return GPU-ready geometry for zero-copy upload
425
- *
426
- * This method generates geometry that is:
427
- * - Pre-interleaved (position + normal per vertex)
428
- * - Coordinate-converted (Z-up to Y-up)
429
- * - Ready for direct GPU upload via pointer access
430
- *
431
- * Example:
432
- * ```javascript
433
- * const api = new IfcAPI();
434
- * const gpuGeom = api.parseToGpuGeometry(ifcData);
435
- *
436
- * // Get WASM memory for zero-copy views
437
- * const memory = api.getMemory();
438
- *
439
- * // Create views directly into WASM memory (NO COPY!)
440
- * const vertexView = new Float32Array(
441
- * memory.buffer,
442
- * gpuGeom.vertexDataPtr,
443
- * gpuGeom.vertexDataLen
444
- * );
445
- * const indexView = new Uint32Array(
446
- * memory.buffer,
447
- * gpuGeom.indicesPtr,
448
- * gpuGeom.indicesLen
449
- * );
450
- *
451
- * // Upload directly to GPU (single copy: WASM → GPU)
452
- * device.queue.writeBuffer(vertexBuffer, 0, vertexView);
453
- * device.queue.writeBuffer(indexBuffer, 0, indexView);
454
- *
455
- * // Free when done
456
- * gpuGeom.free();
457
- * ```
458
- */
459
- parseToGpuGeometry(content: string): GpuGeometry;
460
- /**
461
- * Parse IFC file with streaming GPU-ready geometry batches
462
- *
463
- * Yields batches of GPU-ready geometry for progressive rendering with zero-copy upload.
464
- * Uses fast-first-frame streaming: simple geometry (walls, slabs) first.
465
- *
466
- * Example:
467
- * ```javascript
468
- * const api = new IfcAPI();
469
- * const memory = api.getMemory();
470
- *
471
- * await api.parseToGpuGeometryAsync(ifcData, {
472
- * batchSize: 25,
473
- * onBatch: (gpuGeom, progress) => {
474
- * // Create zero-copy views
475
- * const vertexView = new Float32Array(
476
- * memory.buffer,
477
- * gpuGeom.vertexDataPtr,
478
- * gpuGeom.vertexDataLen
479
- * );
480
- *
481
- * // Upload to GPU
482
- * device.queue.writeBuffer(vertexBuffer, 0, vertexView);
483
- *
484
- * // IMPORTANT: Free immediately after upload!
485
- * gpuGeom.free();
486
- * },
487
- * onComplete: (stats) => {
488
- * console.log(`Done! ${stats.totalMeshes} meshes`);
489
- * }
490
- * });
491
- * ```
492
- */
493
- parseToGpuGeometryAsync(content: string, options: any): Promise<any>;
494
- /**
495
- * Parse IFC file to GPU-ready instanced geometry for zero-copy upload
496
- *
497
- * Groups identical geometries by hash for efficient GPU instancing.
498
- * Returns a collection of instanced geometries with pointer access.
499
- */
500
- parseToGpuInstancedGeometry(content: string): GpuInstancedGeometryCollection;
501
- /**
502
- * Parse IFC file with zero-copy mesh data
503
- * Maximum performance - returns mesh with direct memory access
504
- *
505
- * Example:
506
- * ```javascript
507
- * const api = new IfcAPI();
508
- * const mesh = await api.parseZeroCopy(ifcData);
509
- *
510
- * // Create TypedArray views (NO COPYING!)
511
- * const memory = await api.getMemory();
512
- * const positions = new Float32Array(
513
- * memory.buffer,
514
- * mesh.positions_ptr,
515
- * mesh.positions_len
516
- * );
517
- *
518
- * // Upload directly to GPU
519
- * gl.bufferData(gl.ARRAY_BUFFER, positions, gl.STATIC_DRAW);
520
- * ```
521
- */
522
- parseZeroCopy(content: string): ZeroCopyMesh;
523
- /**
524
- * Fast entity scanning using SIMD-accelerated Rust scanner
525
- * Returns array of entity references for data model parsing
526
- * Much faster than TypeScript byte-by-byte scanning (5-10x speedup)
527
- */
528
- scanEntitiesFast(content: string): any;
529
- /**
530
- * Fast entity scanning from raw bytes (avoids TextDecoder.decode on JS side).
531
- * Accepts Uint8Array directly — saves ~2-5s for 487MB files by skipping
532
- * JS string creation and UTF-16→UTF-8 conversion.
533
- */
534
- scanEntitiesFastBytes(data: Uint8Array): any;
535
- /**
536
- * Fast geometry-only entity scanning
537
- * Scans only entities that have geometry, skipping 99% of non-geometry entities
538
- * Returns array of geometry entity references for parallel processing
539
- * Much faster than scanning all entities (3x speedup for large files)
540
- */
541
- scanGeometryEntitiesFast(content: string): any;
542
- /**
543
- * Check if API is initialized
544
- */
545
- readonly is_ready: boolean;
546
- /**
547
- * Get version string
548
- */
549
- readonly version: string;
202
+ free(): void;
203
+ [Symbol.dispose](): void;
204
+ /**
205
+ * Parse IFC file and return individual meshes with express IDs and colors
206
+ * This matches the MeshData[] format expected by the viewer
207
+ *
208
+ * Example:
209
+ * ```javascript
210
+ * const api = new IfcAPI();
211
+ * const collection = api.parseMeshes(ifcData);
212
+ * for (let i = 0; i < collection.length; i++) {
213
+ * const mesh = collection.get(i);
214
+ * console.log('Express ID:', mesh.expressId);
215
+ * console.log('Positions:', mesh.positions);
216
+ * console.log('Color:', mesh.color);
217
+ * }
218
+ * ```
219
+ */
220
+ parseMeshes(content: string): MeshCollection;
221
+ /**
222
+ * Parse IFC file with streaming mesh batches for progressive rendering
223
+ * Calls the callback with batches of meshes, yielding to browser between batches
224
+ *
225
+ * Options:
226
+ * - `batchSize`: Number of meshes per batch (default: 25)
227
+ * - `onBatch(meshes, progress)`: Called for each batch of meshes
228
+ * - `onRtcOffset({x, y, z, hasRtc})`: Called early with RTC offset for camera/world setup
229
+ * - `onColorUpdate(Map<id, color>)`: Called with style updates after initial render
230
+ * - `onComplete(stats)`: Called when parsing completes with stats including rtcOffset
231
+ *
232
+ * Example:
233
+ * ```javascript
234
+ * const api = new IfcAPI();
235
+ * await api.parseMeshesAsync(ifcData, {
236
+ * batchSize: 100,
237
+ * onRtcOffset: (rtc) => {
238
+ * if (rtc.hasRtc) {
239
+ * // Model uses large coordinates - adjust camera/world origin
240
+ * viewer.setWorldOffset(rtc.x, rtc.y, rtc.z);
241
+ * }
242
+ * },
243
+ * onBatch: (meshes, progress) => {
244
+ * for (const mesh of meshes) {
245
+ * scene.add(createThreeMesh(mesh));
246
+ * }
247
+ * console.log(`Progress: ${progress.percent}%`);
248
+ * },
249
+ * onComplete: (stats) => {
250
+ * console.log(`Done! ${stats.totalMeshes} meshes`);
251
+ * // stats.rtcOffset also available here: {x, y, z, hasRtc}
252
+ * }
253
+ * });
254
+ * ```
255
+ */
256
+ parseMeshesAsync(content: string, options: any): Promise<any>;
257
+ /**
258
+ * Parse IFC file and return GPU-ready geometry for zero-copy upload
259
+ *
260
+ * This method generates geometry that is:
261
+ * - Pre-interleaved (position + normal per vertex)
262
+ * - Coordinate-converted (Z-up to Y-up)
263
+ * - Ready for direct GPU upload via pointer access
264
+ *
265
+ * Example:
266
+ * ```javascript
267
+ * const api = new IfcAPI();
268
+ * const gpuGeom = api.parseToGpuGeometry(ifcData);
269
+ *
270
+ * // Get WASM memory for zero-copy views
271
+ * const memory = api.getMemory();
272
+ *
273
+ * // Create views directly into WASM memory (NO COPY!)
274
+ * const vertexView = new Float32Array(
275
+ * memory.buffer,
276
+ * gpuGeom.vertexDataPtr,
277
+ * gpuGeom.vertexDataLen
278
+ * );
279
+ * const indexView = new Uint32Array(
280
+ * memory.buffer,
281
+ * gpuGeom.indicesPtr,
282
+ * gpuGeom.indicesLen
283
+ * );
284
+ *
285
+ * // Upload directly to GPU (single copy: WASM → GPU)
286
+ * device.queue.writeBuffer(vertexBuffer, 0, vertexView);
287
+ * device.queue.writeBuffer(indexBuffer, 0, indexView);
288
+ *
289
+ * // Free when done
290
+ * gpuGeom.free();
291
+ * ```
292
+ */
293
+ parseToGpuGeometry(content: string): GpuGeometry;
294
+ /**
295
+ * Parse IFC file and return instanced geometry grouped by geometry hash
296
+ * This reduces draw calls by grouping identical geometries with different transforms
297
+ *
298
+ * Example:
299
+ * ```javascript
300
+ * const api = new IfcAPI();
301
+ * const collection = api.parseMeshesInstanced(ifcData);
302
+ * for (let i = 0; i < collection.length; i++) {
303
+ * const geometry = collection.get(i);
304
+ * console.log('Geometry ID:', geometry.geometryId);
305
+ * console.log('Instances:', geometry.instanceCount);
306
+ * for (let j = 0; j < geometry.instanceCount; j++) {
307
+ * const inst = geometry.getInstance(j);
308
+ * console.log(' Express ID:', inst.expressId);
309
+ * console.log(' Transform:', inst.transform);
310
+ * }
311
+ * }
312
+ * ```
313
+ */
314
+ parseMeshesInstanced(content: string): InstancedMeshCollection;
315
+ /**
316
+ * Parse IFC file with streaming GPU-ready geometry batches
317
+ *
318
+ * Yields batches of GPU-ready geometry for progressive rendering with zero-copy upload.
319
+ * Uses fast-first-frame streaming: simple geometry (walls, slabs) first.
320
+ *
321
+ * Example:
322
+ * ```javascript
323
+ * const api = new IfcAPI();
324
+ * const memory = api.getMemory();
325
+ *
326
+ * await api.parseToGpuGeometryAsync(ifcData, {
327
+ * batchSize: 25,
328
+ * onBatch: (gpuGeom, progress) => {
329
+ * // Create zero-copy views
330
+ * const vertexView = new Float32Array(
331
+ * memory.buffer,
332
+ * gpuGeom.vertexDataPtr,
333
+ * gpuGeom.vertexDataLen
334
+ * );
335
+ *
336
+ * // Upload to GPU
337
+ * device.queue.writeBuffer(vertexBuffer, 0, vertexView);
338
+ *
339
+ * // IMPORTANT: Free immediately after upload!
340
+ * gpuGeom.free();
341
+ * },
342
+ * onComplete: (stats) => {
343
+ * console.log(`Done! ${stats.totalMeshes} meshes`);
344
+ * }
345
+ * });
346
+ * ```
347
+ */
348
+ parseToGpuGeometryAsync(content: string, options: any): Promise<any>;
349
+ /**
350
+ * Parse IFC file with streaming instanced geometry batches for progressive rendering
351
+ * Groups identical geometries and yields batches of InstancedGeometry
352
+ * Uses fast-first-frame streaming: simple geometry (walls, slabs) first
353
+ *
354
+ * Example:
355
+ * ```javascript
356
+ * const api = new IfcAPI();
357
+ * await api.parseMeshesInstancedAsync(ifcData, {
358
+ * batchSize: 25, // Number of unique geometries per batch
359
+ * onBatch: (geometries, progress) => {
360
+ * for (const geom of geometries) {
361
+ * renderer.addInstancedGeometry(geom);
362
+ * }
363
+ * },
364
+ * onComplete: (stats) => {
365
+ * console.log(`Done! ${stats.totalGeometries} unique geometries, ${stats.totalInstances} instances`);
366
+ * }
367
+ * });
368
+ * ```
369
+ */
370
+ parseMeshesInstancedAsync(content: string, options: any): Promise<any>;
371
+ /**
372
+ * Parse IFC file to GPU-ready instanced geometry for zero-copy upload
373
+ *
374
+ * Groups identical geometries by hash for efficient GPU instancing.
375
+ * Returns a collection of instanced geometries with pointer access.
376
+ */
377
+ parseToGpuInstancedGeometry(content: string): GpuInstancedGeometryCollection;
378
+ /**
379
+ * Parse IFC file with zero-copy mesh data
380
+ * Maximum performance - returns mesh with direct memory access
381
+ *
382
+ * Example:
383
+ * ```javascript
384
+ * const api = new IfcAPI();
385
+ * const mesh = await api.parseZeroCopy(ifcData);
386
+ *
387
+ * // Create TypedArray views (NO COPYING!)
388
+ * const memory = await api.getMemory();
389
+ * const positions = new Float32Array(
390
+ * memory.buffer,
391
+ * mesh.positions_ptr,
392
+ * mesh.positions_len
393
+ * );
394
+ *
395
+ * // Upload directly to GPU
396
+ * gl.bufferData(gl.ARRAY_BUFFER, positions, gl.STATIC_DRAW);
397
+ * ```
398
+ */
399
+ parseZeroCopy(content: string): ZeroCopyMesh;
400
+ /**
401
+ * Debug: Test processing entity #953 (FacetedBrep wall)
402
+ */
403
+ debugProcessEntity953(content: string): string;
404
+ /**
405
+ * Debug: Test processing a single wall
406
+ */
407
+ debugProcessFirstWall(content: string): string;
408
+ /**
409
+ * Extract georeferencing information from IFC content
410
+ * Returns null if no georeferencing is present
411
+ *
412
+ * Example:
413
+ * ```javascript
414
+ * const api = new IfcAPI();
415
+ * const georef = api.getGeoReference(ifcData);
416
+ * if (georef) {
417
+ * console.log('CRS:', georef.crsName);
418
+ * const [e, n, h] = georef.localToMap(10, 20, 5);
419
+ * }
420
+ * ```
421
+ */
422
+ getGeoReference(content: string): GeoReferenceJs | undefined;
423
+ /**
424
+ * Parse IFC file and return mesh with RTC offset for large coordinates
425
+ * This handles georeferenced models by shifting to centroid
426
+ *
427
+ * Example:
428
+ * ```javascript
429
+ * const api = new IfcAPI();
430
+ * const result = api.parseMeshesWithRtc(ifcData);
431
+ * const rtcOffset = result.rtcOffset;
432
+ * const meshes = result.meshes;
433
+ *
434
+ * // Convert local coords back to world:
435
+ * if (rtcOffset.isSignificant()) {
436
+ * const [wx, wy, wz] = rtcOffset.toWorld(localX, localY, localZ);
437
+ * }
438
+ * ```
439
+ */
440
+ parseMeshesWithRtc(content: string): MeshCollectionWithRtc;
441
+ /**
442
+ * Parse IFC file with streaming events
443
+ * Calls the callback function for each parse event
444
+ *
445
+ * Example:
446
+ * ```javascript
447
+ * const api = new IfcAPI();
448
+ * await api.parseStreaming(ifcData, (event) => {
449
+ * console.log('Event:', event);
450
+ * });
451
+ * ```
452
+ */
453
+ parseStreaming(content: string, callback: Function): Promise<any>;
454
+ /**
455
+ * Fast entity scanning using SIMD-accelerated Rust scanner
456
+ * Returns array of entity references for data model parsing
457
+ * Much faster than TypeScript byte-by-byte scanning (5-10x speedup)
458
+ */
459
+ scanEntitiesFast(content: string): any;
460
+ /**
461
+ * Fast entity scanning from raw bytes (avoids TextDecoder.decode on JS side).
462
+ * Accepts Uint8Array directly — saves ~2-5s for 487MB files by skipping
463
+ * JS string creation and UTF-16→UTF-8 conversion.
464
+ */
465
+ scanEntitiesFastBytes(data: Uint8Array): any;
466
+ /**
467
+ * Fast geometry-only entity scanning
468
+ * Scans only entities that have geometry, skipping 99% of non-geometry entities
469
+ * Returns array of geometry entity references for parallel processing
470
+ * Much faster than scanning all entities (3x speedup for large files)
471
+ */
472
+ scanGeometryEntitiesFast(content: string): any;
473
+ /**
474
+ * Parse IFC file (traditional - waits for completion)
475
+ *
476
+ * Example:
477
+ * ```javascript
478
+ * const api = new IfcAPI();
479
+ * const result = await api.parse(ifcData);
480
+ * console.log('Entities:', result.entityCount);
481
+ * ```
482
+ */
483
+ parse(content: string): Promise<any>;
484
+ /**
485
+ * Get WASM memory for zero-copy access
486
+ */
487
+ getMemory(): any;
488
+ /**
489
+ * Create and initialize the IFC API
490
+ */
491
+ constructor();
492
+ /**
493
+ * Parse IFC file and extract symbolic representations (Plan, Annotation, FootPrint)
494
+ * These are 2D curves used for architectural drawings instead of sectioning 3D geometry
495
+ *
496
+ * Example:
497
+ * ```javascript
498
+ * const api = new IfcAPI();
499
+ * const symbols = api.parseSymbolicRepresentations(ifcData);
500
+ * console.log('Found', symbols.totalCount, 'symbolic items');
501
+ * for (let i = 0; i < symbols.polylineCount; i++) {
502
+ * const polyline = symbols.getPolyline(i);
503
+ * console.log('Polyline for', polyline.ifcType, ':', polyline.points);
504
+ * }
505
+ * ```
506
+ */
507
+ parseSymbolicRepresentations(content: string): SymbolicRepresentationCollection;
508
+ /**
509
+ * Get version string
510
+ */
511
+ readonly version: string;
512
+ /**
513
+ * Check if API is initialized
514
+ */
515
+ readonly is_ready: boolean;
550
516
  }
551
517
 
552
- /**
553
- * Instance data for instanced rendering
554
- */
555
518
  export class InstanceData {
556
- private constructor();
557
- free(): void;
558
- [Symbol.dispose](): void;
559
- readonly color: Float32Array;
560
- readonly expressId: number;
561
- readonly transform: Float32Array;
519
+ private constructor();
520
+ free(): void;
521
+ [Symbol.dispose](): void;
522
+ readonly expressId: number;
523
+ readonly color: Float32Array;
524
+ readonly transform: Float32Array;
562
525
  }
563
526
 
564
- /**
565
- * Instanced geometry - one geometry definition with multiple instances
566
- */
567
527
  export class InstancedGeometry {
568
- private constructor();
569
- free(): void;
570
- [Symbol.dispose](): void;
571
- get_instance(index: number): InstanceData | undefined;
572
- readonly geometryId: bigint;
573
- readonly indices: Uint32Array;
574
- readonly instance_count: number;
575
- readonly normals: Float32Array;
576
- readonly positions: Float32Array;
528
+ private constructor();
529
+ free(): void;
530
+ [Symbol.dispose](): void;
531
+ get_instance(index: number): InstanceData | undefined;
532
+ readonly geometryId: bigint;
533
+ readonly instance_count: number;
534
+ readonly indices: Uint32Array;
535
+ readonly normals: Float32Array;
536
+ readonly positions: Float32Array;
577
537
  }
578
538
 
579
- /**
580
- * Collection of instanced geometries
581
- */
582
539
  export class InstancedMeshCollection {
583
- private constructor();
584
- free(): void;
585
- [Symbol.dispose](): void;
586
- get(index: number): InstancedGeometry | undefined;
587
- readonly length: number;
588
- readonly totalGeometries: number;
589
- readonly totalInstances: number;
540
+ private constructor();
541
+ free(): void;
542
+ [Symbol.dispose](): void;
543
+ get(index: number): InstancedGeometry | undefined;
544
+ readonly totalInstances: number;
545
+ readonly totalGeometries: number;
546
+ readonly length: number;
590
547
  }
591
548
 
592
- /**
593
- * Collection of mesh data for returning multiple meshes
594
- */
595
549
  export class MeshCollection {
596
- private constructor();
597
- free(): void;
598
- [Symbol.dispose](): void;
599
- /**
600
- * Get mesh at index
601
- */
602
- get(index: number): MeshDataJs | undefined;
603
- /**
604
- * Check if RTC offset is significant (>10km)
605
- */
606
- hasRtcOffset(): boolean;
607
- /**
608
- * Convert local coordinates to world coordinates
609
- * Use this to convert mesh positions back to original IFC coordinates
610
- */
611
- localToWorld(x: number, y: number, z: number): Float64Array;
612
- /**
613
- * Get building rotation angle in radians (from IfcSite placement)
614
- * Returns None if no rotation was detected
615
- */
616
- readonly buildingRotation: number | undefined;
617
- /**
618
- * Get number of meshes
619
- */
620
- readonly length: number;
621
- /**
622
- * Get RTC offset X (for converting local coords back to world coords)
623
- * Add this to local X coordinates to get world X coordinates
624
- */
625
- readonly rtcOffsetX: number;
626
- /**
627
- * Get RTC offset Y
628
- */
629
- readonly rtcOffsetY: number;
630
- /**
631
- * Get RTC offset Z
632
- */
633
- readonly rtcOffsetZ: number;
634
- /**
635
- * Get total triangle count across all meshes
636
- */
637
- readonly totalTriangles: number;
638
- /**
639
- * Get total vertex count across all meshes
640
- */
641
- readonly totalVertices: number;
550
+ private constructor();
551
+ free(): void;
552
+ [Symbol.dispose](): void;
553
+ /**
554
+ * Check if RTC offset is significant (>10km)
555
+ */
556
+ hasRtcOffset(): boolean;
557
+ /**
558
+ * Convert local coordinates to world coordinates
559
+ * Use this to convert mesh positions back to original IFC coordinates
560
+ */
561
+ localToWorld(x: number, y: number, z: number): Float64Array;
562
+ /**
563
+ * Get mesh at index
564
+ */
565
+ get(index: number): MeshDataJs | undefined;
566
+ /**
567
+ * Get RTC offset X (for converting local coords back to world coords)
568
+ * Add this to local X coordinates to get world X coordinates
569
+ */
570
+ readonly rtcOffsetX: number;
571
+ /**
572
+ * Get RTC offset Y
573
+ */
574
+ readonly rtcOffsetY: number;
575
+ /**
576
+ * Get RTC offset Z
577
+ */
578
+ readonly rtcOffsetZ: number;
579
+ /**
580
+ * Get total vertex count across all meshes
581
+ */
582
+ readonly totalVertices: number;
583
+ /**
584
+ * Get total triangle count across all meshes
585
+ */
586
+ readonly totalTriangles: number;
587
+ /**
588
+ * Get building rotation angle in radians (from IfcSite placement)
589
+ * Returns None if no rotation was detected
590
+ */
591
+ readonly buildingRotation: number | undefined;
592
+ /**
593
+ * Get number of meshes
594
+ */
595
+ readonly length: number;
642
596
  }
643
597
 
644
- /**
645
- * Mesh collection with RTC offset for large coordinates
646
- */
647
598
  export class MeshCollectionWithRtc {
648
- private constructor();
649
- free(): void;
650
- [Symbol.dispose](): void;
651
- /**
652
- * Get mesh at index
653
- */
654
- get(index: number): MeshDataJs | undefined;
655
- /**
656
- * Get number of meshes
657
- */
658
- readonly length: number;
659
- /**
660
- * Get the mesh collection
661
- */
662
- readonly meshes: MeshCollection;
663
- /**
664
- * Get the RTC offset
665
- */
666
- readonly rtcOffset: RtcOffsetJs;
599
+ private constructor();
600
+ free(): void;
601
+ [Symbol.dispose](): void;
602
+ /**
603
+ * Get mesh at index
604
+ */
605
+ get(index: number): MeshDataJs | undefined;
606
+ /**
607
+ * Get the RTC offset
608
+ */
609
+ readonly rtcOffset: RtcOffsetJs;
610
+ /**
611
+ * Get number of meshes
612
+ */
613
+ readonly length: number;
614
+ /**
615
+ * Get the mesh collection
616
+ */
617
+ readonly meshes: MeshCollection;
667
618
  }
668
619
 
669
- /**
670
- * Individual mesh data with express ID and color (matches MeshData interface)
671
- */
672
620
  export class MeshDataJs {
673
- private constructor();
674
- free(): void;
675
- [Symbol.dispose](): void;
676
- /**
677
- * Get color as [r, g, b, a] array
678
- */
679
- readonly color: Float32Array;
680
- /**
681
- * Get express ID
682
- */
683
- readonly expressId: number;
684
- /**
685
- * Get IFC type name (e.g., "IfcWall", "IfcSpace")
686
- */
687
- readonly ifcType: string;
688
- /**
689
- * Get indices as Uint32Array (copy to JS)
690
- */
691
- readonly indices: Uint32Array;
692
- /**
693
- * Get normals as Float32Array (copy to JS)
694
- */
695
- readonly normals: Float32Array;
696
- /**
697
- * Get positions as Float32Array (copy to JS)
698
- */
699
- readonly positions: Float32Array;
700
- /**
701
- * Get triangle count
702
- */
703
- readonly triangleCount: number;
704
- /**
705
- * Get vertex count
706
- */
707
- readonly vertexCount: number;
621
+ private constructor();
622
+ free(): void;
623
+ [Symbol.dispose](): void;
624
+ /**
625
+ * Get express ID
626
+ */
627
+ readonly expressId: number;
628
+ /**
629
+ * Get vertex count
630
+ */
631
+ readonly vertexCount: number;
632
+ /**
633
+ * Get triangle count
634
+ */
635
+ readonly triangleCount: number;
636
+ /**
637
+ * Get color as [r, g, b, a] array
638
+ */
639
+ readonly color: Float32Array;
640
+ /**
641
+ * Get indices as Uint32Array (copy to JS)
642
+ */
643
+ readonly indices: Uint32Array;
644
+ /**
645
+ * Get normals as Float32Array (copy to JS)
646
+ */
647
+ readonly normals: Float32Array;
648
+ /**
649
+ * Get IFC type name (e.g., "IfcWall", "IfcSpace")
650
+ */
651
+ readonly ifcType: string;
652
+ /**
653
+ * Get positions as Float32Array (copy to JS)
654
+ */
655
+ readonly positions: Float32Array;
708
656
  }
709
657
 
710
- /**
711
- * RTC offset information exposed to JavaScript
712
- */
713
658
  export class RtcOffsetJs {
714
- private constructor();
715
- free(): void;
716
- [Symbol.dispose](): void;
717
- /**
718
- * Check if offset is significant (>10km)
719
- */
720
- isSignificant(): boolean;
721
- /**
722
- * Convert local coordinates to world coordinates
723
- */
724
- toWorld(x: number, y: number, z: number): Float64Array;
725
- /**
726
- * X offset (subtracted from positions)
727
- */
728
- x: number;
729
- /**
730
- * Y offset
731
- */
732
- y: number;
733
- /**
734
- * Z offset
735
- */
736
- z: number;
659
+ private constructor();
660
+ free(): void;
661
+ [Symbol.dispose](): void;
662
+ /**
663
+ * Check if offset is significant (>10km)
664
+ */
665
+ isSignificant(): boolean;
666
+ /**
667
+ * Convert local coordinates to world coordinates
668
+ */
669
+ toWorld(x: number, y: number, z: number): Float64Array;
670
+ /**
671
+ * X offset (subtracted from positions)
672
+ */
673
+ x: number;
674
+ /**
675
+ * Y offset
676
+ */
677
+ y: number;
678
+ /**
679
+ * Z offset
680
+ */
681
+ z: number;
737
682
  }
738
683
 
739
- /**
740
- * A 2D circle/arc for symbolic representations
741
- */
742
684
  export class SymbolicCircle {
743
- private constructor();
744
- free(): void;
745
- [Symbol.dispose](): void;
746
- readonly centerX: number;
747
- readonly centerY: number;
748
- readonly endAngle: number;
749
- readonly expressId: number;
750
- readonly ifcType: string;
751
- /**
752
- * Check if this is a full circle
753
- */
754
- readonly isFullCircle: boolean;
755
- readonly radius: number;
756
- readonly repIdentifier: string;
757
- readonly startAngle: number;
685
+ private constructor();
686
+ free(): void;
687
+ [Symbol.dispose](): void;
688
+ readonly expressId: number;
689
+ readonly startAngle: number;
690
+ /**
691
+ * Check if this is a full circle
692
+ */
693
+ readonly isFullCircle: boolean;
694
+ readonly repIdentifier: string;
695
+ readonly radius: number;
696
+ readonly centerX: number;
697
+ readonly centerY: number;
698
+ readonly ifcType: string;
699
+ readonly endAngle: number;
758
700
  }
759
701
 
760
- /**
761
- * A single 2D polyline for symbolic representations (Plan, Annotation, FootPrint)
762
- * Points are stored as [x1, y1, x2, y2, ...] in 2D coordinates
763
- */
764
702
  export class SymbolicPolyline {
765
- private constructor();
766
- free(): void;
767
- [Symbol.dispose](): void;
768
- /**
769
- * Get express ID of the parent element
770
- */
771
- readonly expressId: number;
772
- /**
773
- * Get IFC type name (e.g., "IfcDoor", "IfcWindow")
774
- */
775
- readonly ifcType: string;
776
- /**
777
- * Check if this is a closed loop
778
- */
779
- readonly isClosed: boolean;
780
- /**
781
- * Get number of points
782
- */
783
- readonly pointCount: number;
784
- /**
785
- * Get 2D points as Float32Array [x1, y1, x2, y2, ...]
786
- */
787
- readonly points: Float32Array;
788
- /**
789
- * Get representation identifier ("Plan", "Annotation", "FootPrint", "Axis")
790
- */
791
- readonly repIdentifier: string;
703
+ private constructor();
704
+ free(): void;
705
+ [Symbol.dispose](): void;
706
+ /**
707
+ * Get express ID of the parent element
708
+ */
709
+ readonly expressId: number;
710
+ /**
711
+ * Get number of points
712
+ */
713
+ readonly pointCount: number;
714
+ /**
715
+ * Get representation identifier ("Plan", "Annotation", "FootPrint", "Axis")
716
+ */
717
+ readonly repIdentifier: string;
718
+ /**
719
+ * Get 2D points as Float32Array [x1, y1, x2, y2, ...]
720
+ */
721
+ readonly points: Float32Array;
722
+ /**
723
+ * Get IFC type name (e.g., "IfcDoor", "IfcWindow")
724
+ */
725
+ readonly ifcType: string;
726
+ /**
727
+ * Check if this is a closed loop
728
+ */
729
+ readonly isClosed: boolean;
792
730
  }
793
731
 
794
- /**
795
- * Collection of symbolic representations for an IFC model
796
- */
797
732
  export class SymbolicRepresentationCollection {
798
- private constructor();
799
- free(): void;
800
- [Symbol.dispose](): void;
801
- /**
802
- * Get circle at index
803
- */
804
- getCircle(index: number): SymbolicCircle | undefined;
805
- /**
806
- * Get all express IDs that have symbolic representations
807
- */
808
- getExpressIds(): Uint32Array;
809
- /**
810
- * Get polyline at index
811
- */
812
- getPolyline(index: number): SymbolicPolyline | undefined;
813
- /**
814
- * Get number of circles/arcs
815
- */
816
- readonly circleCount: number;
817
- /**
818
- * Check if collection is empty
819
- */
820
- readonly isEmpty: boolean;
821
- /**
822
- * Get number of polylines
823
- */
824
- readonly polylineCount: number;
825
- /**
826
- * Get total count of all symbolic items
827
- */
828
- readonly totalCount: number;
733
+ private constructor();
734
+ free(): void;
735
+ [Symbol.dispose](): void;
736
+ /**
737
+ * Get circle at index
738
+ */
739
+ getCircle(index: number): SymbolicCircle | undefined;
740
+ /**
741
+ * Get polyline at index
742
+ */
743
+ getPolyline(index: number): SymbolicPolyline | undefined;
744
+ /**
745
+ * Get all express IDs that have symbolic representations
746
+ */
747
+ getExpressIds(): Uint32Array;
748
+ /**
749
+ * Get total count of all symbolic items
750
+ */
751
+ readonly totalCount: number;
752
+ /**
753
+ * Get number of circles/arcs
754
+ */
755
+ readonly circleCount: number;
756
+ /**
757
+ * Get number of polylines
758
+ */
759
+ readonly polylineCount: number;
760
+ /**
761
+ * Check if collection is empty
762
+ */
763
+ readonly isEmpty: boolean;
829
764
  }
830
765
 
831
- /**
832
- * Zero-copy mesh that exposes pointers to WASM memory
833
- */
834
766
  export class ZeroCopyMesh {
835
- free(): void;
836
- [Symbol.dispose](): void;
837
- /**
838
- * Get bounding box maximum point
839
- */
840
- bounds_max(): Float32Array;
841
- /**
842
- * Get bounding box minimum point
843
- */
844
- bounds_min(): Float32Array;
845
- /**
846
- * Create a new zero-copy mesh from a Mesh
847
- */
848
- constructor();
849
- /**
850
- * Get length of indices array
851
- */
852
- readonly indices_len: number;
853
- /**
854
- * Get pointer to indices array
855
- */
856
- readonly indices_ptr: number;
857
- /**
858
- * Check if mesh is empty
859
- */
860
- readonly is_empty: boolean;
861
- /**
862
- * Get length of normals array
863
- */
864
- readonly normals_len: number;
865
- /**
866
- * Get pointer to normals array
867
- */
868
- readonly normals_ptr: number;
869
- /**
870
- * Get length of positions array (in f32 elements, not bytes)
871
- */
872
- readonly positions_len: number;
873
- /**
874
- * Get pointer to positions array
875
- * JavaScript can create Float32Array view: new Float32Array(memory.buffer, ptr, length)
876
- */
877
- readonly positions_ptr: number;
878
- /**
879
- * Get triangle count
880
- */
881
- readonly triangle_count: number;
882
- /**
883
- * Get vertex count
884
- */
885
- readonly vertex_count: number;
767
+ free(): void;
768
+ [Symbol.dispose](): void;
769
+ /**
770
+ * Get bounding box maximum point
771
+ */
772
+ bounds_max(): Float32Array;
773
+ /**
774
+ * Get bounding box minimum point
775
+ */
776
+ bounds_min(): Float32Array;
777
+ /**
778
+ * Create a new zero-copy mesh from a Mesh
779
+ */
780
+ constructor();
781
+ /**
782
+ * Get length of indices array
783
+ */
784
+ readonly indices_len: number;
785
+ /**
786
+ * Get pointer to indices array
787
+ */
788
+ readonly indices_ptr: number;
789
+ /**
790
+ * Get length of normals array
791
+ */
792
+ readonly normals_len: number;
793
+ /**
794
+ * Get pointer to normals array
795
+ */
796
+ readonly normals_ptr: number;
797
+ /**
798
+ * Get vertex count
799
+ */
800
+ readonly vertex_count: number;
801
+ /**
802
+ * Get length of positions array (in f32 elements, not bytes)
803
+ */
804
+ readonly positions_len: number;
805
+ /**
806
+ * Get pointer to positions array
807
+ * JavaScript can create Float32Array view: new Float32Array(memory.buffer, ptr, length)
808
+ */
809
+ readonly positions_ptr: number;
810
+ /**
811
+ * Get triangle count
812
+ */
813
+ readonly triangle_count: number;
814
+ /**
815
+ * Check if mesh is empty
816
+ */
817
+ readonly is_empty: boolean;
886
818
  }
887
819
 
888
820
  /**
@@ -916,231 +848,231 @@ export function version(): string;
916
848
  export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
917
849
 
918
850
  export interface InitOutput {
919
- readonly memory: WebAssembly.Memory;
920
- readonly __wbg_georeferencejs_free: (a: number, b: number) => void;
921
- readonly __wbg_get_georeferencejs_eastings: (a: number) => number;
922
- readonly __wbg_get_georeferencejs_northings: (a: number) => number;
923
- readonly __wbg_get_georeferencejs_orthogonal_height: (a: number) => number;
924
- readonly __wbg_get_georeferencejs_scale: (a: number) => number;
925
- readonly __wbg_get_georeferencejs_x_axis_abscissa: (a: number) => number;
926
- readonly __wbg_get_georeferencejs_x_axis_ordinate: (a: number) => number;
927
- readonly __wbg_gpugeometry_free: (a: number, b: number) => void;
928
- readonly __wbg_gpuinstancedgeometry_free: (a: number, b: number) => void;
929
- readonly __wbg_gpuinstancedgeometrycollection_free: (a: number, b: number) => void;
930
- readonly __wbg_gpuinstancedgeometryref_free: (a: number, b: number) => void;
931
- readonly __wbg_gpumeshmetadata_free: (a: number, b: number) => void;
932
- readonly __wbg_ifcapi_free: (a: number, b: number) => void;
933
- readonly __wbg_instancedata_free: (a: number, b: number) => void;
934
- readonly __wbg_instancedgeometry_free: (a: number, b: number) => void;
935
- readonly __wbg_instancedmeshcollection_free: (a: number, b: number) => void;
936
- readonly __wbg_meshcollection_free: (a: number, b: number) => void;
937
- readonly __wbg_meshcollectionwithrtc_free: (a: number, b: number) => void;
938
- readonly __wbg_meshdatajs_free: (a: number, b: number) => void;
939
- readonly __wbg_rtcoffsetjs_free: (a: number, b: number) => void;
940
- readonly __wbg_set_georeferencejs_eastings: (a: number, b: number) => void;
941
- readonly __wbg_set_georeferencejs_northings: (a: number, b: number) => void;
942
- readonly __wbg_set_georeferencejs_orthogonal_height: (a: number, b: number) => void;
943
- readonly __wbg_set_georeferencejs_scale: (a: number, b: number) => void;
944
- readonly __wbg_set_georeferencejs_x_axis_abscissa: (a: number, b: number) => void;
945
- readonly __wbg_set_georeferencejs_x_axis_ordinate: (a: number, b: number) => void;
946
- readonly __wbg_symboliccircle_free: (a: number, b: number) => void;
947
- readonly __wbg_symbolicpolyline_free: (a: number, b: number) => void;
948
- readonly __wbg_symbolicrepresentationcollection_free: (a: number, b: number) => void;
949
- readonly __wbg_zerocopymesh_free: (a: number, b: number) => void;
950
- readonly georeferencejs_crsName: (a: number, b: number) => void;
951
- readonly georeferencejs_localToMap: (a: number, b: number, c: number, d: number, e: number) => void;
952
- readonly georeferencejs_mapToLocal: (a: number, b: number, c: number, d: number, e: number) => void;
953
- readonly georeferencejs_rotation: (a: number) => number;
954
- readonly georeferencejs_toMatrix: (a: number, b: number) => void;
955
- readonly gpugeometry_getIfcTypeName: (a: number, b: number, c: number) => void;
956
- readonly gpugeometry_getMeshMetadata: (a: number, b: number) => number;
957
- readonly gpugeometry_hasRtcOffset: (a: number) => number;
958
- readonly gpugeometry_indicesByteLength: (a: number) => number;
959
- readonly gpugeometry_indicesLen: (a: number) => number;
960
- readonly gpugeometry_indicesPtr: (a: number) => number;
961
- readonly gpugeometry_isEmpty: (a: number) => number;
962
- readonly gpugeometry_meshCount: (a: number) => number;
963
- readonly gpugeometry_new: () => number;
964
- readonly gpugeometry_rtcOffsetX: (a: number) => number;
965
- readonly gpugeometry_rtcOffsetY: (a: number) => number;
966
- readonly gpugeometry_rtcOffsetZ: (a: number) => number;
967
- readonly gpugeometry_set_rtc_offset: (a: number, b: number, c: number, d: number) => void;
968
- readonly gpugeometry_totalTriangleCount: (a: number) => number;
969
- readonly gpugeometry_totalVertexCount: (a: number) => number;
970
- readonly gpugeometry_vertexDataByteLength: (a: number) => number;
971
- readonly gpugeometry_vertexDataLen: (a: number) => number;
972
- readonly gpugeometry_vertexDataPtr: (a: number) => number;
973
- readonly gpuinstancedgeometry_geometryId: (a: number) => bigint;
974
- readonly gpuinstancedgeometry_indicesByteLength: (a: number) => number;
975
- readonly gpuinstancedgeometry_indicesLen: (a: number) => number;
976
- readonly gpuinstancedgeometry_indicesPtr: (a: number) => number;
977
- readonly gpuinstancedgeometry_instanceCount: (a: number) => number;
978
- readonly gpuinstancedgeometry_instanceDataByteLength: (a: number) => number;
979
- readonly gpuinstancedgeometry_instanceDataLen: (a: number) => number;
980
- readonly gpuinstancedgeometry_instanceDataPtr: (a: number) => number;
981
- readonly gpuinstancedgeometry_instanceExpressIdsPtr: (a: number) => number;
982
- readonly gpuinstancedgeometry_new: (a: bigint) => number;
983
- readonly gpuinstancedgeometry_triangleCount: (a: number) => number;
984
- readonly gpuinstancedgeometry_vertexCount: (a: number) => number;
985
- readonly gpuinstancedgeometry_vertexDataByteLength: (a: number) => number;
986
- readonly gpuinstancedgeometry_vertexDataLen: (a: number) => number;
987
- readonly gpuinstancedgeometry_vertexDataPtr: (a: number) => number;
988
- readonly gpuinstancedgeometrycollection_get: (a: number, b: number) => number;
989
- readonly gpuinstancedgeometrycollection_getRef: (a: number, b: number) => number;
990
- readonly gpuinstancedgeometrycollection_length: (a: number) => number;
991
- readonly gpuinstancedgeometrycollection_new: () => number;
992
- readonly gpuinstancedgeometryref_geometryId: (a: number) => bigint;
993
- readonly gpuinstancedgeometryref_indicesByteLength: (a: number) => number;
994
- readonly gpuinstancedgeometryref_indicesLen: (a: number) => number;
995
- readonly gpuinstancedgeometryref_indicesPtr: (a: number) => number;
996
- readonly gpuinstancedgeometryref_instanceCount: (a: number) => number;
997
- readonly gpuinstancedgeometryref_instanceDataByteLength: (a: number) => number;
998
- readonly gpuinstancedgeometryref_instanceDataLen: (a: number) => number;
999
- readonly gpuinstancedgeometryref_instanceDataPtr: (a: number) => number;
1000
- readonly gpuinstancedgeometryref_instanceExpressIdsPtr: (a: number) => number;
1001
- readonly gpuinstancedgeometryref_vertexDataByteLength: (a: number) => number;
1002
- readonly gpuinstancedgeometryref_vertexDataLen: (a: number) => number;
1003
- readonly gpuinstancedgeometryref_vertexDataPtr: (a: number) => number;
1004
- readonly gpumeshmetadata_color: (a: number, b: number) => void;
1005
- readonly gpumeshmetadata_expressId: (a: number) => number;
1006
- readonly gpumeshmetadata_ifcTypeIdx: (a: number) => number;
1007
- readonly gpumeshmetadata_indexCount: (a: number) => number;
1008
- readonly gpumeshmetadata_indexOffset: (a: number) => number;
1009
- readonly gpumeshmetadata_vertexCount: (a: number) => number;
1010
- readonly gpumeshmetadata_vertexOffset: (a: number) => number;
1011
- readonly ifcapi_debugProcessEntity953: (a: number, b: number, c: number, d: number) => void;
1012
- readonly ifcapi_debugProcessFirstWall: (a: number, b: number, c: number, d: number) => void;
1013
- readonly ifcapi_getGeoReference: (a: number, b: number, c: number) => number;
1014
- readonly ifcapi_getMemory: (a: number) => number;
1015
- readonly ifcapi_is_ready: (a: number) => number;
1016
- readonly ifcapi_new: () => number;
1017
- readonly ifcapi_parse: (a: number, b: number, c: number) => number;
1018
- readonly ifcapi_parseMeshes: (a: number, b: number, c: number) => number;
1019
- readonly ifcapi_parseMeshesAsync: (a: number, b: number, c: number, d: number) => number;
1020
- readonly ifcapi_parseMeshesInstanced: (a: number, b: number, c: number) => number;
1021
- readonly ifcapi_parseMeshesInstancedAsync: (a: number, b: number, c: number, d: number) => number;
1022
- readonly ifcapi_parseMeshesWithRtc: (a: number, b: number, c: number) => number;
1023
- readonly ifcapi_parseStreaming: (a: number, b: number, c: number, d: number) => number;
1024
- readonly ifcapi_parseSymbolicRepresentations: (a: number, b: number, c: number) => number;
1025
- readonly ifcapi_parseToGpuGeometry: (a: number, b: number, c: number) => number;
1026
- readonly ifcapi_parseToGpuGeometryAsync: (a: number, b: number, c: number, d: number) => number;
1027
- readonly ifcapi_parseToGpuInstancedGeometry: (a: number, b: number, c: number) => number;
1028
- readonly ifcapi_parseZeroCopy: (a: number, b: number, c: number) => number;
1029
- readonly ifcapi_scanEntitiesFast: (a: number, b: number, c: number) => number;
1030
- readonly ifcapi_scanEntitiesFastBytes: (a: number, b: number, c: number) => number;
1031
- readonly ifcapi_scanGeometryEntitiesFast: (a: number, b: number, c: number) => number;
1032
- readonly ifcapi_version: (a: number, b: number) => void;
1033
- readonly instancedata_color: (a: number, b: number) => void;
1034
- readonly instancedata_expressId: (a: number) => number;
1035
- readonly instancedata_transform: (a: number) => number;
1036
- readonly instancedgeometry_get_instance: (a: number, b: number) => number;
1037
- readonly instancedgeometry_indices: (a: number) => number;
1038
- readonly instancedgeometry_instance_count: (a: number) => number;
1039
- readonly instancedgeometry_normals: (a: number) => number;
1040
- readonly instancedgeometry_positions: (a: number) => number;
1041
- readonly instancedmeshcollection_get: (a: number, b: number) => number;
1042
- readonly instancedmeshcollection_totalInstances: (a: number) => number;
1043
- readonly meshcollection_buildingRotation: (a: number, b: number) => void;
1044
- readonly meshcollection_get: (a: number, b: number) => number;
1045
- readonly meshcollection_hasRtcOffset: (a: number) => number;
1046
- readonly meshcollection_length: (a: number) => number;
1047
- readonly meshcollection_localToWorld: (a: number, b: number, c: number, d: number, e: number) => void;
1048
- readonly meshcollection_rtcOffsetY: (a: number) => number;
1049
- readonly meshcollection_rtcOffsetZ: (a: number) => number;
1050
- readonly meshcollection_totalTriangles: (a: number) => number;
1051
- readonly meshcollection_totalVertices: (a: number) => number;
1052
- readonly meshcollectionwithrtc_get: (a: number, b: number) => number;
1053
- readonly meshcollectionwithrtc_meshes: (a: number) => number;
1054
- readonly meshcollectionwithrtc_rtcOffset: (a: number) => number;
1055
- readonly meshdatajs_color: (a: number, b: number) => void;
1056
- readonly meshdatajs_expressId: (a: number) => number;
1057
- readonly meshdatajs_ifcType: (a: number, b: number) => void;
1058
- readonly meshdatajs_indices: (a: number) => number;
1059
- readonly meshdatajs_normals: (a: number) => number;
1060
- readonly meshdatajs_positions: (a: number) => number;
1061
- readonly meshdatajs_triangleCount: (a: number) => number;
1062
- readonly meshdatajs_vertexCount: (a: number) => number;
1063
- readonly rtcoffsetjs_isSignificant: (a: number) => number;
1064
- readonly rtcoffsetjs_toWorld: (a: number, b: number, c: number, d: number, e: number) => void;
1065
- readonly symboliccircle_centerX: (a: number) => number;
1066
- readonly symboliccircle_centerY: (a: number) => number;
1067
- readonly symboliccircle_endAngle: (a: number) => number;
1068
- readonly symboliccircle_ifcType: (a: number, b: number) => void;
1069
- readonly symboliccircle_isFullCircle: (a: number) => number;
1070
- readonly symboliccircle_radius: (a: number) => number;
1071
- readonly symboliccircle_repIdentifier: (a: number, b: number) => void;
1072
- readonly symboliccircle_startAngle: (a: number) => number;
1073
- readonly symbolicpolyline_expressId: (a: number) => number;
1074
- readonly symbolicpolyline_ifcType: (a: number, b: number) => void;
1075
- readonly symbolicpolyline_isClosed: (a: number) => number;
1076
- readonly symbolicpolyline_pointCount: (a: number) => number;
1077
- readonly symbolicpolyline_points: (a: number) => number;
1078
- readonly symbolicpolyline_repIdentifier: (a: number, b: number) => void;
1079
- readonly symbolicrepresentationcollection_circleCount: (a: number) => number;
1080
- readonly symbolicrepresentationcollection_getCircle: (a: number, b: number) => number;
1081
- readonly symbolicrepresentationcollection_getExpressIds: (a: number, b: number) => void;
1082
- readonly symbolicrepresentationcollection_getPolyline: (a: number, b: number) => number;
1083
- readonly symbolicrepresentationcollection_isEmpty: (a: number) => number;
1084
- readonly symbolicrepresentationcollection_polylineCount: (a: number) => number;
1085
- readonly symbolicrepresentationcollection_totalCount: (a: number) => number;
1086
- readonly version: (a: number) => void;
1087
- readonly zerocopymesh_bounds_max: (a: number, b: number) => void;
1088
- readonly zerocopymesh_bounds_min: (a: number, b: number) => void;
1089
- readonly zerocopymesh_is_empty: (a: number) => number;
1090
- readonly zerocopymesh_new: () => number;
1091
- readonly zerocopymesh_normals_len: (a: number) => number;
1092
- readonly zerocopymesh_positions_len: (a: number) => number;
1093
- readonly zerocopymesh_positions_ptr: (a: number) => number;
1094
- readonly zerocopymesh_vertex_count: (a: number) => number;
1095
- readonly init: () => void;
1096
- readonly instancedmeshcollection_length: (a: number) => number;
1097
- readonly instancedmeshcollection_totalGeometries: (a: number) => number;
1098
- readonly meshcollectionwithrtc_length: (a: number) => number;
1099
- readonly zerocopymesh_indices_len: (a: number) => number;
1100
- readonly __wbg_get_rtcoffsetjs_x: (a: number) => number;
1101
- readonly __wbg_get_rtcoffsetjs_y: (a: number) => number;
1102
- readonly __wbg_get_rtcoffsetjs_z: (a: number) => number;
1103
- readonly __wbg_set_rtcoffsetjs_x: (a: number, b: number) => void;
1104
- readonly __wbg_set_rtcoffsetjs_y: (a: number, b: number) => void;
1105
- readonly __wbg_set_rtcoffsetjs_z: (a: number, b: number) => void;
1106
- readonly instancedgeometry_geometryId: (a: number) => bigint;
1107
- readonly meshcollection_rtcOffsetX: (a: number) => number;
1108
- readonly symboliccircle_expressId: (a: number) => number;
1109
- readonly zerocopymesh_triangle_count: (a: number) => number;
1110
- readonly zerocopymesh_indices_ptr: (a: number) => number;
1111
- readonly zerocopymesh_normals_ptr: (a: number) => number;
1112
- readonly get_memory: () => number;
1113
- readonly __wasm_bindgen_func_elem_1032: (a: number, b: number) => void;
1114
- readonly __wasm_bindgen_func_elem_480: (a: number, b: number) => void;
1115
- readonly __wasm_bindgen_func_elem_1037: (a: number, b: number, c: number, d: number) => void;
1116
- readonly __wasm_bindgen_func_elem_1070: (a: number, b: number, c: number, d: number) => void;
1117
- readonly __wasm_bindgen_func_elem_484: (a: number, b: number) => void;
1118
- readonly __wbindgen_export: (a: number) => void;
1119
- readonly __wbindgen_export2: (a: number, b: number, c: number) => void;
1120
- readonly __wbindgen_export3: (a: number, b: number) => number;
1121
- readonly __wbindgen_export4: (a: number, b: number, c: number, d: number) => number;
1122
- readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
1123
- readonly __wbindgen_start: () => void;
851
+ readonly memory: WebAssembly.Memory;
852
+ readonly __wbg_georeferencejs_free: (a: number, b: number) => void;
853
+ readonly __wbg_get_georeferencejs_eastings: (a: number) => number;
854
+ readonly __wbg_get_georeferencejs_northings: (a: number) => number;
855
+ readonly __wbg_get_georeferencejs_orthogonal_height: (a: number) => number;
856
+ readonly __wbg_get_georeferencejs_scale: (a: number) => number;
857
+ readonly __wbg_get_georeferencejs_x_axis_abscissa: (a: number) => number;
858
+ readonly __wbg_get_georeferencejs_x_axis_ordinate: (a: number) => number;
859
+ readonly __wbg_gpugeometry_free: (a: number, b: number) => void;
860
+ readonly __wbg_gpuinstancedgeometry_free: (a: number, b: number) => void;
861
+ readonly __wbg_gpuinstancedgeometrycollection_free: (a: number, b: number) => void;
862
+ readonly __wbg_gpumeshmetadata_free: (a: number, b: number) => void;
863
+ readonly __wbg_ifcapi_free: (a: number, b: number) => void;
864
+ readonly __wbg_instancedata_free: (a: number, b: number) => void;
865
+ readonly __wbg_instancedgeometry_free: (a: number, b: number) => void;
866
+ readonly __wbg_instancedmeshcollection_free: (a: number, b: number) => void;
867
+ readonly __wbg_meshcollection_free: (a: number, b: number) => void;
868
+ readonly __wbg_meshcollectionwithrtc_free: (a: number, b: number) => void;
869
+ readonly __wbg_meshdatajs_free: (a: number, b: number) => void;
870
+ readonly __wbg_rtcoffsetjs_free: (a: number, b: number) => void;
871
+ readonly __wbg_set_georeferencejs_eastings: (a: number, b: number) => void;
872
+ readonly __wbg_set_georeferencejs_northings: (a: number, b: number) => void;
873
+ readonly __wbg_set_georeferencejs_orthogonal_height: (a: number, b: number) => void;
874
+ readonly __wbg_set_georeferencejs_scale: (a: number, b: number) => void;
875
+ readonly __wbg_set_georeferencejs_x_axis_abscissa: (a: number, b: number) => void;
876
+ readonly __wbg_set_georeferencejs_x_axis_ordinate: (a: number, b: number) => void;
877
+ readonly __wbg_symboliccircle_free: (a: number, b: number) => void;
878
+ readonly __wbg_symbolicpolyline_free: (a: number, b: number) => void;
879
+ readonly __wbg_symbolicrepresentationcollection_free: (a: number, b: number) => void;
880
+ readonly __wbg_zerocopymesh_free: (a: number, b: number) => void;
881
+ readonly georeferencejs_crsName: (a: number, b: number) => void;
882
+ readonly georeferencejs_localToMap: (a: number, b: number, c: number, d: number, e: number) => void;
883
+ readonly georeferencejs_mapToLocal: (a: number, b: number, c: number, d: number, e: number) => void;
884
+ readonly georeferencejs_rotation: (a: number) => number;
885
+ readonly georeferencejs_toMatrix: (a: number, b: number) => void;
886
+ readonly gpugeometry_getIfcTypeName: (a: number, b: number, c: number) => void;
887
+ readonly gpugeometry_getMeshMetadata: (a: number, b: number) => number;
888
+ readonly gpugeometry_hasRtcOffset: (a: number) => number;
889
+ readonly gpugeometry_indicesByteLength: (a: number) => number;
890
+ readonly gpugeometry_indicesLen: (a: number) => number;
891
+ readonly gpugeometry_indicesPtr: (a: number) => number;
892
+ readonly gpugeometry_isEmpty: (a: number) => number;
893
+ readonly gpugeometry_meshCount: (a: number) => number;
894
+ readonly gpugeometry_new: () => number;
895
+ readonly gpugeometry_rtcOffsetX: (a: number) => number;
896
+ readonly gpugeometry_rtcOffsetY: (a: number) => number;
897
+ readonly gpugeometry_rtcOffsetZ: (a: number) => number;
898
+ readonly gpugeometry_set_rtc_offset: (a: number, b: number, c: number, d: number) => void;
899
+ readonly gpugeometry_totalTriangleCount: (a: number) => number;
900
+ readonly gpugeometry_totalVertexCount: (a: number) => number;
901
+ readonly gpugeometry_vertexDataByteLength: (a: number) => number;
902
+ readonly gpugeometry_vertexDataLen: (a: number) => number;
903
+ readonly gpugeometry_vertexDataPtr: (a: number) => number;
904
+ readonly gpuinstancedgeometry_geometryId: (a: number) => bigint;
905
+ readonly gpuinstancedgeometry_indicesByteLength: (a: number) => number;
906
+ readonly gpuinstancedgeometry_indicesLen: (a: number) => number;
907
+ readonly gpuinstancedgeometry_indicesPtr: (a: number) => number;
908
+ readonly gpuinstancedgeometry_instanceCount: (a: number) => number;
909
+ readonly gpuinstancedgeometry_instanceDataByteLength: (a: number) => number;
910
+ readonly gpuinstancedgeometry_instanceDataLen: (a: number) => number;
911
+ readonly gpuinstancedgeometry_instanceDataPtr: (a: number) => number;
912
+ readonly gpuinstancedgeometry_instanceExpressIdsPtr: (a: number) => number;
913
+ readonly gpuinstancedgeometry_new: (a: bigint) => number;
914
+ readonly gpuinstancedgeometry_triangleCount: (a: number) => number;
915
+ readonly gpuinstancedgeometry_vertexCount: (a: number) => number;
916
+ readonly gpuinstancedgeometry_vertexDataByteLength: (a: number) => number;
917
+ readonly gpuinstancedgeometry_vertexDataLen: (a: number) => number;
918
+ readonly gpuinstancedgeometry_vertexDataPtr: (a: number) => number;
919
+ readonly gpuinstancedgeometrycollection_get: (a: number, b: number) => number;
920
+ readonly gpuinstancedgeometrycollection_length: (a: number) => number;
921
+ readonly gpuinstancedgeometrycollection_new: () => number;
922
+ readonly gpumeshmetadata_color: (a: number, b: number) => void;
923
+ readonly gpumeshmetadata_expressId: (a: number) => number;
924
+ readonly gpumeshmetadata_ifcTypeIdx: (a: number) => number;
925
+ readonly gpumeshmetadata_indexCount: (a: number) => number;
926
+ readonly gpumeshmetadata_indexOffset: (a: number) => number;
927
+ readonly gpumeshmetadata_vertexCount: (a: number) => number;
928
+ readonly gpumeshmetadata_vertexOffset: (a: number) => number;
929
+ readonly ifcapi_debugProcessEntity953: (a: number, b: number, c: number, d: number) => void;
930
+ readonly ifcapi_debugProcessFirstWall: (a: number, b: number, c: number, d: number) => void;
931
+ readonly ifcapi_getGeoReference: (a: number, b: number, c: number) => number;
932
+ readonly ifcapi_getMemory: (a: number) => number;
933
+ readonly ifcapi_is_ready: (a: number) => number;
934
+ readonly ifcapi_new: () => number;
935
+ readonly ifcapi_parse: (a: number, b: number, c: number) => number;
936
+ readonly ifcapi_parseMeshes: (a: number, b: number, c: number) => number;
937
+ readonly ifcapi_parseMeshesAsync: (a: number, b: number, c: number, d: number) => number;
938
+ readonly ifcapi_parseMeshesInstanced: (a: number, b: number, c: number) => number;
939
+ readonly ifcapi_parseMeshesInstancedAsync: (a: number, b: number, c: number, d: number) => number;
940
+ readonly ifcapi_parseMeshesWithRtc: (a: number, b: number, c: number) => number;
941
+ readonly ifcapi_parseStreaming: (a: number, b: number, c: number, d: number) => number;
942
+ readonly ifcapi_parseSymbolicRepresentations: (a: number, b: number, c: number) => number;
943
+ readonly ifcapi_parseToGpuGeometry: (a: number, b: number, c: number) => number;
944
+ readonly ifcapi_parseToGpuGeometryAsync: (a: number, b: number, c: number, d: number) => number;
945
+ readonly ifcapi_parseToGpuInstancedGeometry: (a: number, b: number, c: number) => number;
946
+ readonly ifcapi_parseZeroCopy: (a: number, b: number, c: number) => number;
947
+ readonly ifcapi_scanEntitiesFast: (a: number, b: number, c: number) => number;
948
+ readonly ifcapi_scanEntitiesFastBytes: (a: number, b: number, c: number) => number;
949
+ readonly ifcapi_scanGeometryEntitiesFast: (a: number, b: number, c: number) => number;
950
+ readonly ifcapi_version: (a: number, b: number) => void;
951
+ readonly instancedata_color: (a: number, b: number) => void;
952
+ readonly instancedata_expressId: (a: number) => number;
953
+ readonly instancedata_transform: (a: number) => number;
954
+ readonly instancedgeometry_get_instance: (a: number, b: number) => number;
955
+ readonly instancedgeometry_indices: (a: number) => number;
956
+ readonly instancedgeometry_instance_count: (a: number) => number;
957
+ readonly instancedgeometry_normals: (a: number) => number;
958
+ readonly instancedgeometry_positions: (a: number) => number;
959
+ readonly instancedmeshcollection_get: (a: number, b: number) => number;
960
+ readonly instancedmeshcollection_totalInstances: (a: number) => number;
961
+ readonly meshcollection_buildingRotation: (a: number, b: number) => void;
962
+ readonly meshcollection_get: (a: number, b: number) => number;
963
+ readonly meshcollection_hasRtcOffset: (a: number) => number;
964
+ readonly meshcollection_length: (a: number) => number;
965
+ readonly meshcollection_localToWorld: (a: number, b: number, c: number, d: number, e: number) => void;
966
+ readonly meshcollection_rtcOffsetY: (a: number) => number;
967
+ readonly meshcollection_rtcOffsetZ: (a: number) => number;
968
+ readonly meshcollection_totalTriangles: (a: number) => number;
969
+ readonly meshcollection_totalVertices: (a: number) => number;
970
+ readonly meshcollectionwithrtc_get: (a: number, b: number) => number;
971
+ readonly meshcollectionwithrtc_meshes: (a: number) => number;
972
+ readonly meshcollectionwithrtc_rtcOffset: (a: number) => number;
973
+ readonly meshdatajs_color: (a: number, b: number) => void;
974
+ readonly meshdatajs_expressId: (a: number) => number;
975
+ readonly meshdatajs_ifcType: (a: number, b: number) => void;
976
+ readonly meshdatajs_indices: (a: number) => number;
977
+ readonly meshdatajs_normals: (a: number) => number;
978
+ readonly meshdatajs_positions: (a: number) => number;
979
+ readonly meshdatajs_triangleCount: (a: number) => number;
980
+ readonly meshdatajs_vertexCount: (a: number) => number;
981
+ readonly rtcoffsetjs_isSignificant: (a: number) => number;
982
+ readonly rtcoffsetjs_toWorld: (a: number, b: number, c: number, d: number, e: number) => void;
983
+ readonly symboliccircle_centerX: (a: number) => number;
984
+ readonly symboliccircle_centerY: (a: number) => number;
985
+ readonly symboliccircle_endAngle: (a: number) => number;
986
+ readonly symboliccircle_ifcType: (a: number, b: number) => void;
987
+ readonly symboliccircle_isFullCircle: (a: number) => number;
988
+ readonly symboliccircle_radius: (a: number) => number;
989
+ readonly symboliccircle_repIdentifier: (a: number, b: number) => void;
990
+ readonly symboliccircle_startAngle: (a: number) => number;
991
+ readonly symbolicpolyline_expressId: (a: number) => number;
992
+ readonly symbolicpolyline_ifcType: (a: number, b: number) => void;
993
+ readonly symbolicpolyline_isClosed: (a: number) => number;
994
+ readonly symbolicpolyline_pointCount: (a: number) => number;
995
+ readonly symbolicpolyline_points: (a: number) => number;
996
+ readonly symbolicpolyline_repIdentifier: (a: number, b: number) => void;
997
+ readonly symbolicrepresentationcollection_circleCount: (a: number) => number;
998
+ readonly symbolicrepresentationcollection_getCircle: (a: number, b: number) => number;
999
+ readonly symbolicrepresentationcollection_getExpressIds: (a: number, b: number) => void;
1000
+ readonly symbolicrepresentationcollection_getPolyline: (a: number, b: number) => number;
1001
+ readonly symbolicrepresentationcollection_isEmpty: (a: number) => number;
1002
+ readonly symbolicrepresentationcollection_polylineCount: (a: number) => number;
1003
+ readonly symbolicrepresentationcollection_totalCount: (a: number) => number;
1004
+ readonly version: (a: number) => void;
1005
+ readonly zerocopymesh_bounds_max: (a: number, b: number) => void;
1006
+ readonly zerocopymesh_bounds_min: (a: number, b: number) => void;
1007
+ readonly zerocopymesh_is_empty: (a: number) => number;
1008
+ readonly zerocopymesh_new: () => number;
1009
+ readonly zerocopymesh_normals_len: (a: number) => number;
1010
+ readonly zerocopymesh_positions_len: (a: number) => number;
1011
+ readonly zerocopymesh_positions_ptr: (a: number) => number;
1012
+ readonly zerocopymesh_vertex_count: (a: number) => number;
1013
+ readonly init: () => void;
1014
+ readonly gpuinstancedgeometryref_indicesLen: (a: number) => number;
1015
+ readonly gpuinstancedgeometryref_instanceCount: (a: number) => number;
1016
+ readonly gpuinstancedgeometryref_instanceDataLen: (a: number) => number;
1017
+ readonly gpuinstancedgeometryref_vertexDataLen: (a: number) => number;
1018
+ readonly instancedmeshcollection_length: (a: number) => number;
1019
+ readonly instancedmeshcollection_totalGeometries: (a: number) => number;
1020
+ readonly meshcollectionwithrtc_length: (a: number) => number;
1021
+ readonly zerocopymesh_indices_len: (a: number) => number;
1022
+ readonly __wbg_set_rtcoffsetjs_x: (a: number, b: number) => void;
1023
+ readonly __wbg_set_rtcoffsetjs_y: (a: number, b: number) => void;
1024
+ readonly __wbg_set_rtcoffsetjs_z: (a: number, b: number) => void;
1025
+ readonly zerocopymesh_triangle_count: (a: number) => number;
1026
+ readonly get_memory: () => number;
1027
+ readonly gpuinstancedgeometryref_indicesPtr: (a: number) => number;
1028
+ readonly gpuinstancedgeometryref_instanceDataPtr: (a: number) => number;
1029
+ readonly gpuinstancedgeometryref_instanceExpressIdsPtr: (a: number) => number;
1030
+ readonly gpuinstancedgeometryref_vertexDataPtr: (a: number) => number;
1031
+ readonly zerocopymesh_indices_ptr: (a: number) => number;
1032
+ readonly zerocopymesh_normals_ptr: (a: number) => number;
1033
+ readonly gpuinstancedgeometrycollection_getRef: (a: number, b: number) => number;
1034
+ readonly __wbg_get_rtcoffsetjs_x: (a: number) => number;
1035
+ readonly __wbg_get_rtcoffsetjs_y: (a: number) => number;
1036
+ readonly __wbg_get_rtcoffsetjs_z: (a: number) => number;
1037
+ readonly gpuinstancedgeometryref_indicesByteLength: (a: number) => number;
1038
+ readonly gpuinstancedgeometryref_instanceDataByteLength: (a: number) => number;
1039
+ readonly gpuinstancedgeometryref_vertexDataByteLength: (a: number) => number;
1040
+ readonly gpuinstancedgeometryref_geometryId: (a: number) => bigint;
1041
+ readonly instancedgeometry_geometryId: (a: number) => bigint;
1042
+ readonly meshcollection_rtcOffsetX: (a: number) => number;
1043
+ readonly symboliccircle_expressId: (a: number) => number;
1044
+ readonly __wbg_gpuinstancedgeometryref_free: (a: number, b: number) => void;
1045
+ readonly __wasm_bindgen_func_elem_1021: (a: number, b: number, c: number) => void;
1046
+ readonly __wasm_bindgen_func_elem_1019: (a: number, b: number) => void;
1047
+ readonly __wasm_bindgen_func_elem_469: (a: number, b: number) => void;
1048
+ readonly __wasm_bindgen_func_elem_467: (a: number, b: number) => void;
1049
+ readonly __wasm_bindgen_func_elem_1052: (a: number, b: number, c: number, d: number) => void;
1050
+ readonly __wbindgen_export: (a: number) => void;
1051
+ readonly __wbindgen_export2: (a: number, b: number, c: number) => void;
1052
+ readonly __wbindgen_export3: (a: number, b: number) => number;
1053
+ readonly __wbindgen_export4: (a: number, b: number, c: number, d: number) => number;
1054
+ readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
1055
+ readonly __wbindgen_start: () => void;
1124
1056
  }
1125
1057
 
1126
1058
  export type SyncInitInput = BufferSource | WebAssembly.Module;
1127
1059
 
1128
1060
  /**
1129
- * Instantiates the given `module`, which can either be bytes or
1130
- * a precompiled `WebAssembly.Module`.
1131
- *
1132
- * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
1133
- *
1134
- * @returns {InitOutput}
1135
- */
1061
+ * Instantiates the given `module`, which can either be bytes or
1062
+ * a precompiled `WebAssembly.Module`.
1063
+ *
1064
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
1065
+ *
1066
+ * @returns {InitOutput}
1067
+ */
1136
1068
  export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
1137
1069
 
1138
1070
  /**
1139
- * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
1140
- * for everything else, calls `WebAssembly.instantiate` directly.
1141
- *
1142
- * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
1143
- *
1144
- * @returns {Promise<InitOutput>}
1145
- */
1071
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
1072
+ * for everything else, calls `WebAssembly.instantiate` directly.
1073
+ *
1074
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
1075
+ *
1076
+ * @returns {Promise<InitOutput>}
1077
+ */
1146
1078
  export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;