@procore/bim-webviewer-sdk 15.2.0 → 15.3.0-rc.0

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 (28) hide show
  1. package/CHANGELOG.md +19 -4
  2. package/dist/Procore.Bim.Webviewer.d.ts +749 -6
  3. package/dist/Procore.Bim.Webviewer.js +1 -1
  4. package/dist/types/src/Webviewer.d.ts +21 -5
  5. package/dist/types/src/api/analytic_events/analyticKeys.d.ts +2 -0
  6. package/dist/types/src/api/analytic_events/payloadFactories.d.ts +1 -0
  7. package/dist/types/src/components/ViewpointManager/ViewpointManager.d.ts +6 -2
  8. package/dist/types/src/controllers/RenderController.d.ts +4 -4
  9. package/dist/types/src/controllers/RenderControllerProxy.d.ts +99 -98
  10. package/dist/types/src/controllers/RenderControllerWorker.d.ts +94 -94
  11. package/dist/types/src/procoregl/HiddenNodeServices/HiddenNodeServices.d.ts +3 -1
  12. package/dist/types/src/sdk.d.ts +4 -1
  13. package/dist/types/src/types/Palette.d.ts +1 -1
  14. package/dist/types/src/types/WebviewerOptions.d.ts +28 -1
  15. package/dist/types/src/utils/ApiMetaData/ApiMetaData.d.ts +18 -12
  16. package/dist/types/src/utils/ApiMetaData/__tests__/mocks.d.ts +25 -1
  17. package/dist/types/src/utils/Error/CustomError.d.ts +3 -0
  18. package/dist/types/src/utils/Error/ErrorLogger.d.ts +12 -0
  19. package/dist/types/src/utils/Error/ExternalError.d.ts +5 -0
  20. package/dist/types/src/utils/Error/__tests__/CustomError.test.d.ts +1 -0
  21. package/dist/types/src/utils/Error/__tests__/ErrorLogger.test.d.ts +1 -0
  22. package/dist/types/src/utils/Error/__tests__/ExternalError.test.d.ts +1 -0
  23. package/dist/types/src/utils/Error/index.d.ts +3 -0
  24. package/dist/types/src/utils/Logger/BugsnagLogger.d.ts +8 -0
  25. package/dist/types/src/utils/Logger/Logger.d.ts +3 -0
  26. package/dist/types/src/utils/Logger/__tests__/BugsnagLogger.test.d.ts +1 -0
  27. package/dist/types/src/utils/Logger/index.d.ts +2 -0
  28. package/package.json +1 -1
@@ -1,3 +1,6 @@
1
+ import { Matrix4 } from 'three/src/math/Matrix4';
2
+ import { Vector3 as Vector3_2 } from 'three/src/math/Vector3';
3
+
1
4
  export declare const ACTION: {
2
5
  readonly NONE: -1;
3
6
  readonly PAN: 1;
@@ -76,6 +79,18 @@ export declare type BoundingBox = {
76
79
  min: Vector3;
77
80
  };
78
81
 
82
+ declare class BVHTree {
83
+ static maxChunkSize: number;
84
+ constructor(pwf: any);
85
+ pwf: any;
86
+ meshnodes: any;
87
+ currentIndex: number;
88
+ buildTree(): {
89
+ isComplete: boolean;
90
+ };
91
+ rollupBBox(meshnode: any): void;
92
+ }
93
+
79
94
  declare const Cache_2: {
80
95
  removeModel: (options: any) => Promise<boolean>;
81
96
  hasModel: (geometryBundle: GeometryBundle) => Promise<boolean>;
@@ -84,6 +99,11 @@ export { Cache_2 as Cache }
84
99
 
85
100
  declare type Camera = any;
86
101
 
102
+ declare type Color = {
103
+ color: string;
104
+ opacity: number;
105
+ };
106
+
87
107
  export declare type CommonOptions = {
88
108
  /**
89
109
  * Always required
@@ -131,6 +151,18 @@ export declare type CommonOptions = {
131
151
 
132
152
  export declare type CssColor = RGB | RGBA | HEX | string;
133
153
 
154
+ export declare namespace ErrorLogger {
155
+ let logger: Logger;
156
+ const init: (params: {
157
+ bugsnagConfig: {
158
+ apiKey: string;
159
+ releaseStage?: string;
160
+ };
161
+ }) => void;
162
+ const logError: <T extends Error>(error: T) => void;
163
+ const dispose: () => void;
164
+ }
165
+
134
166
  export declare type FeatureFlags = Partial<{
135
167
  enableObjectTreeSearch: boolean;
136
168
  }>;
@@ -151,10 +183,22 @@ export declare type FileExtractionModePwfV1OverrideOptions = CommonOptions & Pwf
151
183
  fileExtractionId: FileExtraction['id'];
152
184
  };
153
185
 
186
+ export declare type FileExtractionModePwfV1OverrideResource = PwfV1Bundle & {
187
+ fileExtractionId: FileExtraction['id'];
188
+ };
189
+
154
190
  export declare type FileExtractionModePwfV2OverrideOptions = CommonOptions & PwfV2Bundle & {
155
191
  fileExtractionId: FileExtraction['id'];
156
192
  };
157
193
 
194
+ export declare type FileExtractionModePwfV2OverrideResource = PwfV2Bundle & {
195
+ fileExtractionId: FileExtraction['id'];
196
+ };
197
+
198
+ export declare type FileExtractionModeResource = {
199
+ fileExtractionId: FileExtraction['id'];
200
+ };
201
+
158
202
  export declare type FileVersion = {
159
203
  id: number;
160
204
  file_id: number;
@@ -180,18 +224,258 @@ export declare type GeometryBundle = {
180
224
  manifestUrl?: GeometryFile['url'];
181
225
  };
182
226
 
227
+ declare class GeometryFactory {
228
+ private static maxArraySize;
229
+ private vbuffers;
230
+ private fbuffers;
231
+ private curVertexPos;
232
+ private curIndexPos;
233
+ private cylinderVBuffer;
234
+ private cylinderFBuffer;
235
+ protected gl: WebGL2RenderingContext;
236
+ constructor(gl: WebGL2RenderingContext);
237
+ createDataBuffer(vertexArray: Float32Array, indexArray: Uint16Array): GPUMeshData;
238
+ createCylinderBuffer(vertexArray: Float32Array, indexArray: Uint16Array): GPUMeshData;
239
+ protected newVertexBuffer(_size?: number): void;
240
+ protected newIndexBuffer(_size?: number): void;
241
+ createCylinderGeometry(_vertices: Float32Array, _faces: Uint16Array, _color: number, _opacity: number, _drawType: number): StreamedMeshGeometry;
242
+ createMeshGeometry(_vertices: Float32Array, _faces: Uint16Array, _color: number, _opacity: number, _drawType: number): StreamedMeshGeometry;
243
+ }
244
+
183
245
  export declare type GeometryFile = {
184
246
  url: string;
185
247
  };
186
248
 
249
+ declare type GPUMeshData = {
250
+ index: number;
251
+ f_byte_size: number;
252
+ vertexArrayObject: WebGLVertexArrayObject | null;
253
+ };
254
+
187
255
  export declare type HEX = `#${string}`;
188
256
 
257
+ declare class KDTree {
258
+ private MAX_CHILDREN_PER_NODE;
259
+ private root;
260
+ private tmpFrustum;
261
+ private queue;
262
+ private result;
263
+ constructor();
264
+ cullTree(cameraPosition: Vector3_2, frustumMatrix: Matrix4, detailsParam: number): {
265
+ opaques: Meshnode[];
266
+ transparents: Meshnode[];
267
+ };
268
+ buildTree(meshnodes: Meshnode[]): {
269
+ isComplete: boolean;
270
+ };
271
+ collectMeshnodes(cameraPosition: Vector3_2, detailsFactor: number): {
272
+ opaques: Meshnode[];
273
+ transparents: Meshnode[];
274
+ };
275
+ }
276
+
277
+ declare interface Logger {
278
+ logError(error: any): void;
279
+ }
280
+
281
+ declare type Manifest = {
282
+ version: string;
283
+ globalAABB: BoundingBox;
284
+ reducedGlobalAABB: BoundingBox;
285
+ meshnodeOffset: number;
286
+ numMeshnodes: number;
287
+ numMeshes: number;
288
+ numNodes: number;
289
+ globalOffset: Vector3;
290
+ };
291
+
292
+ declare type Mesh = {
293
+ [key: string]: any;
294
+ };
295
+
296
+ declare class Mesh_2 {
297
+ private pwfMesh;
298
+ constructor(pwfMesh: PWFMesh);
299
+ offset(): number;
300
+ color(): number;
301
+ opacity(): number;
302
+ drawType(): number;
303
+ numVertices(): number;
304
+ lenVertices(): number;
305
+ numFaces(): number;
306
+ lenFaces(): number;
307
+ vertices(): Float32Array;
308
+ faces(): Uint16Array;
309
+ asObject(): Record<string, unknown>;
310
+ }
311
+
312
+ declare class MeshData {
313
+ private _meshIndex;
314
+ private compressedMeshData;
315
+ private uncompressedMeshData?;
316
+ private meshGeometry?;
317
+ constructor(meshIndex: number, compressedMeshData: ArrayBuffer);
318
+ meshIndex(): number;
319
+ color(): number;
320
+ opacity(): number;
321
+ drawType(): number;
322
+ vertices(): Float32Array;
323
+ faces(): Uint16Array;
324
+ uploadToGPU(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
325
+ uploadToGPUPreFetching(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
326
+ getUncompressedMeshData(): ArrayBuffer;
327
+ }
328
+
329
+ declare class MeshGeometry {
330
+ index: number;
331
+ indexLength: number;
332
+ vertexArrayObject: WebGLVertexArrayObject | null;
333
+ color: number;
334
+ opacity: number;
335
+ drawType: number;
336
+ lastFrameId: number;
337
+ numFaces: number;
338
+ constructor(meshData: GPUMeshData, color: number, opacity: number, drawType: number);
339
+ }
340
+
341
+ declare class Meshnode {
342
+ protected pwfMeshnode: PWFMeshnode;
343
+ private hiddenValue;
344
+ private box3Value?;
345
+ private centerValue?;
346
+ private meshDataValue?;
347
+ private meshGeometriesValue?;
348
+ protected pwf: PWF;
349
+ selected: boolean;
350
+ private _parent?;
351
+ constructor(pwfMeshnode: PWFMeshnode, pwf: PWF);
352
+ offset(): number;
353
+ parentOffset(): number;
354
+ parent(): Node_2;
355
+ children(): never[];
356
+ nodeId(): number;
357
+ bbox(): Float32Array;
358
+ box3(): NonNullable<Meshnode['box3Value']>;
359
+ center(): THREE.Vector3;
360
+ matrix(): Float32Array;
361
+ group(): number;
362
+ opaque(): number;
363
+ numChild(): number;
364
+ childRefs(): Uint32Array;
365
+ isNode(): boolean;
366
+ isMeshnode(): this is Meshnode;
367
+ index(): number;
368
+ meshGeometries(): MeshGeometry[];
369
+ protected geometries(): MeshGeometry[];
370
+ private meshData;
371
+ isRoot(): boolean;
372
+ hidden(): Meshnode['hiddenValue'];
373
+ setHidden(hidden: boolean): void;
374
+ setParent(node: Node_2): void;
375
+ asObject(): MeshnodeObject;
376
+ }
377
+
378
+ declare type MeshnodeObject = {
379
+ bbox: Float32Array;
380
+ matrix: Float32Array;
381
+ numChild: number;
382
+ childRefs: Uint32Array;
383
+ meshData: Mesh[];
384
+ nodeId: number;
385
+ meshnodeIndex: number;
386
+ hidden: boolean;
387
+ type: string;
388
+ selected: boolean;
389
+ };
390
+
391
+ declare class MeshnodeServices {
392
+ private meshnodeCount;
393
+ private meshnodes;
394
+ protected pwf: PWF;
395
+ protected cachedMeshnodes: Map<number, Meshnode>;
396
+ constructor(pwfMeshnodes: PWFMeshnode[], pwf: PWF);
397
+ getMeshnodeFromIndex(index: number): Meshnode;
398
+ getMeshnode(offset: number): Meshnode;
399
+ numMeshnodes(): number;
400
+ allMeshnodes(): NonNullable<MeshnodeServices['meshnodes']>;
401
+ protected createMeshnode(pwfMeshnode: PWFMeshnode): Meshnode;
402
+ }
403
+
404
+ declare class MeshnodeServices_2 extends MeshnodeServices {
405
+ }
406
+
407
+ declare class MeshnodeServices_3 extends MeshnodeServices_2 {
408
+ protected manifest: Manifest;
409
+ constructor(_buffer: ArrayBuffer, pwf: PWF, manifest: Manifest);
410
+ numMeshnodes(): number;
411
+ globalOffset(): {
412
+ offsetX: number;
413
+ offsetY: number;
414
+ offsetZ: number;
415
+ };
416
+ }
417
+
418
+ declare class MeshServices {
419
+ protected pwf: PWF;
420
+ protected geometryFactory?: GeometryFactory;
421
+ private meshGeometryMap;
422
+ private pwfMeshes;
423
+ private pwfMeshOffsetMap;
424
+ private meshCount;
425
+ private currentIndex;
426
+ static maxChunkSize: number;
427
+ constructor(pwfMeshes: PWFMesh[], pwf: PWF);
428
+ setGeometryFactory(geometryFactory: GeometryFactory): void;
429
+ getMeshGeometryForOffsets(meshOffset: number, _meshnodeOffset: number | undefined): MeshGeometry | undefined;
430
+ meshFromOffset(offset: number): Mesh_2;
431
+ numMeshes(): number;
432
+ meshes(): PWFMesh[];
433
+ loadAllMeshGeometryToGPU(): {
434
+ isComplete: boolean;
435
+ };
436
+ private loadToGPU;
437
+ getMeshVerticesAndFaces(meshOffset: number, _meshnodeOffset: number): MeshVerticesAndFaces;
438
+ private loadMeshGeometryToGPU;
439
+ }
440
+
441
+ declare class MeshServices_2 extends MeshServices {
442
+ }
443
+
444
+ declare class MeshServices_3 extends MeshServices_2 {
445
+ protected manifest: Manifest;
446
+ constructor(_buffer: ArrayBuffer, pwf: PWF, manifest: Manifest);
447
+ }
448
+
449
+ declare type MeshVerticesAndFaces = {
450
+ meshOffset: number;
451
+ vertices: number[];
452
+ faces: number[];
453
+ };
454
+
189
455
  declare type MetricId = string;
190
456
 
191
457
  export declare type Model = {
192
458
  id: number;
193
459
  };
194
460
 
461
+ declare type ModelInitializationPayload = {
462
+ success: boolean;
463
+ start_timestamp: number;
464
+ end_timestamp: number;
465
+ total_time: number;
466
+ model_type: ModelType;
467
+ node_size?: number;
468
+ meshnode_size?: number;
469
+ num_nodes?: number;
470
+ num_meshnodes?: number;
471
+ mesh_size?: number;
472
+ num_meshes?: number;
473
+ partition_proxy_size?: number;
474
+ web_viewer_version: string;
475
+ step_failed?: string;
476
+ error_description?: string;
477
+ };
478
+
195
479
  export declare type ModelRevision = {
196
480
  id: number;
197
481
  revision: number;
@@ -203,15 +487,27 @@ export declare type ModelRevisionModePwfV1Options = CommonOptions & PwfV1Bundle
203
487
  modelRevisionId: ModelRevision['id'];
204
488
  };
205
489
 
490
+ export declare type ModelRevisionModePwfV1Resource = PwfV1Bundle & {
491
+ modelId: Model['id'];
492
+ modelRevisionId: ModelRevision['id'];
493
+ };
494
+
206
495
  export declare type ModelRevisionModePwfV2Options = CommonOptions & PwfV2Bundle & {
207
496
  modelId: Model['id'];
208
497
  modelRevisionId: ModelRevision['id'];
209
498
  };
210
499
 
500
+ export declare type ModelRevisionModePwfV2Resource = PwfV2Bundle & {
501
+ modelId: Model['id'];
502
+ modelRevisionId: ModelRevision['id'];
503
+ };
504
+
211
505
  export declare type ModelRevisionViewpoint = Viewpoint & {
212
506
  primary: boolean;
213
507
  };
214
508
 
509
+ declare type ModelType = 'standard' | 'partitioned' | undefined;
510
+
215
511
  export declare const NAV_MODE: {
216
512
  readonly DEFAULT: 0;
217
513
  readonly FLY: 1;
@@ -224,17 +520,171 @@ export declare const NAV_MODE: {
224
520
 
225
521
  export declare type NavigationMode = (typeof NAV_MODE)[keyof typeof NAV_MODE];
226
522
 
523
+ declare class Node_2 {
524
+ private pwfNode;
525
+ private pwf;
526
+ private box3Value;
527
+ isFirstObjectValue: boolean;
528
+ private _parent?;
529
+ constructor(pwfNode: PWFNode, pwf: PWF);
530
+ box3(): Node_2['box3Value'];
531
+ unionBBox(bbox: THREE.Box3): void;
532
+ isRoot(): boolean;
533
+ offset(): number;
534
+ nodeId(): number;
535
+ parentOff(): number;
536
+ setParent(node: Node_2): void;
537
+ parent(): Node_2 | undefined;
538
+ numChild(): number;
539
+ hasChildren(): boolean;
540
+ group(): number;
541
+ isSelectable(): boolean;
542
+ nodeType(): number;
543
+ childOffsets(): Uint32Array;
544
+ children(): (Node_2 | Meshnode)[];
545
+ isNode(): this is Node_2;
546
+ isMeshnode(): boolean;
547
+ isFirstObject(): boolean;
548
+ hasMeshnodeChildren(): boolean;
549
+ numMeshnodeChildren(): number;
550
+ asObject(): NodeAsObject;
551
+ }
552
+
553
+ declare type NodeAsObject = {
554
+ offset: number;
555
+ nodeId: number;
556
+ parentOff: number;
557
+ childOffsets: Uint32Array;
558
+ numChild: number;
559
+ nodeType: number;
560
+ hasChildren: boolean;
561
+ hasMeshnodeChildren: boolean;
562
+ bbox: NodeBoundingBox;
563
+ type: string;
564
+ parentId: number | undefined;
565
+ children: number[];
566
+ };
567
+
227
568
  export declare type NodeBoundingBox = {
228
569
  min: number[];
229
570
  max: number[];
230
571
  };
231
572
 
573
+ declare type NodeId = ReturnType<Node_2['nodeId']>;
574
+
575
+ declare class NodeServices {
576
+ private nodes;
577
+ private nodeIdToOffsetMap;
578
+ private pwf;
579
+ protected meshnodeOffPointerValue: number;
580
+ private stack;
581
+ private queue;
582
+ static maxChunkSize: number;
583
+ private _numFirstObjects;
584
+ nodesOffset: number;
585
+ private _pwfRootNode;
586
+ private _numNodes;
587
+ private _pwfNodeOffsetMap;
588
+ private _rootNode?;
589
+ constructor(pwfNodes: PWFNode[], meshnodeOffPointer: number, pwf: PWF);
590
+ nodeFromOffset(offset: number): Node_2;
591
+ buildNodes(): {
592
+ nodes: NodeServices['nodes'];
593
+ isComplete: boolean;
594
+ };
595
+ root(): Node_2;
596
+ getNode(offset: number): Node_2 | Meshnode;
597
+ getNodeById(id: number): Node_2;
598
+ hasNode(id: number): boolean;
599
+ breadthFirstTraversal(callback: (n: Node_2 | Meshnode) => void): {
600
+ isComplete: boolean;
601
+ };
602
+ private buildNodesRecursively;
603
+ private buildChildren;
604
+ meshnodeOffPointer(): NonNullable<NodeServices['meshnodeOffPointerValue']>;
605
+ findFirstObject(meshnode: Meshnode): Node_2;
606
+ numNodes(): number;
607
+ allNodes(): Node_2[];
608
+ numFirstObjects(): number;
609
+ }
610
+
611
+ declare class NodeServices_2 extends NodeServices {
612
+ }
613
+
614
+ declare class NodeServices_3 extends NodeServices_2 {
615
+ protected manifest: Manifest;
616
+ constructor(_buffer: ArrayBuffer, pwf: PWF, manifest: Manifest);
617
+ meshnodeOffPointer(): NonNullable<NodeServices_3['meshnodeOffPointerValue']>;
618
+ }
619
+
232
620
  export declare type ObjectFilter = {
233
621
  filterField: FilterField;
234
622
  filterValue: string;
235
623
  };
236
624
 
237
- export declare type Options = FileExtractionModePwfV2OverrideOptions | FileExtractionModePwfV1OverrideOptions | FileExtractionModeOptions | ModelRevisionModePwfV2Options | ModelRevisionModePwfV1Options;
625
+ export declare type Options = FileExtractionModePwfV2OverrideOptions | FileExtractionModePwfV1OverrideOptions | FileExtractionModeOptions | ModelRevisionModePwfV2Options | ModelRevisionModePwfV1Options | ResourceOptions;
626
+
627
+ declare type Palette = {
628
+ default?: Color;
629
+ xray?: Color;
630
+ selected?: Color;
631
+ };
632
+
633
+ export declare type PaletteParams = {
634
+ palette: Palette;
635
+ objectIds: NodeId[];
636
+ };
637
+
638
+ declare class Partition {
639
+ private pwfPartition;
640
+ constructor(pwfPartition: PWFPartition);
641
+ partitionId(): number;
642
+ meshData(): MeshData[];
643
+ }
644
+
645
+ declare class PartitionProxy {
646
+ static projectId: number;
647
+ static baseUrl: string;
648
+ private pwfPartitionProxy;
649
+ static numberOfPartitions: number;
650
+ static numberOfPartitionsLoaded: number;
651
+ static currentNumberOfDownloading: number;
652
+ static prefetchingPartitions: boolean;
653
+ loadedToGPU: boolean;
654
+ isLoading: boolean;
655
+ private _meshnodes;
656
+ private static partitionsLoaded;
657
+ static initCompletePayload: ModelInitializationPayload;
658
+ static renderReadyParams: {
659
+ offsetWidth: number;
660
+ offsetHeight: number;
661
+ offsetTop: number;
662
+ offsetLeft: number;
663
+ };
664
+ private _byteLength?;
665
+ private _compressedByteLength?;
666
+ static Stats: {
667
+ PartitionsLoaded: number;
668
+ MeshesLoaded: number;
669
+ VerticesLoaded: number;
670
+ FacesLoaded: number;
671
+ };
672
+ constructor(pwfPartitionProxy: PWFPartitionProxy);
673
+ partitionId(): number;
674
+ partitionUrl(): string;
675
+ meshnodeOffsets(): Uint32Array;
676
+ meshnodes(): StreamedMeshnode[];
677
+ setMeshnodes(meshnodes: StreamedMeshnode[]): void;
678
+ loadPartitionData(callbackFn: (partition: Partition) => void): Promise<void>;
679
+ loadPartition(factory: StreamedGeometryFactory): Promise<void>;
680
+ size(): {
681
+ compressed: number;
682
+ size: number;
683
+ };
684
+ static processPartitionProxiesAB(partitionProxiesAB: Uint8Array, callback: (partitionProxy: PartitionProxy) => void): void;
685
+ static getPartitionProxies(partitionProxiesAB: ArrayBuffer): PWFPartitionProxy[];
686
+ getContentOfPartitionUrl(): string;
687
+ }
238
688
 
239
689
  declare type Point = {
240
690
  position: {
@@ -282,6 +732,202 @@ export declare type PublicNode = {
282
732
  children: number[];
283
733
  };
284
734
 
735
+ declare class PWF {
736
+ static timeSince(time: any): string;
737
+ static isPartitionProxiesAB(meshAB: any): boolean;
738
+ constructor(params: any);
739
+ meshnodeOffPointerValue: number;
740
+ globalOffsetValue: {
741
+ offsetX: number;
742
+ offsetY: number;
743
+ offsetZ: number;
744
+ };
745
+ sceneGraphName: any;
746
+ isLogging: any;
747
+ locale: any;
748
+ downloadMetaData: any;
749
+ streaming: boolean;
750
+ nodeServices: NodeServices | null;
751
+ meshnodeServices: StreamedMeshnodeServices | MeshnodeServices | null;
752
+ meshServices: StreamedMeshServices | MeshServices | null;
753
+ sceneGraph: WASMTree | KDTree | null;
754
+ bvhTree: BVHTree | null;
755
+ measureSet: any[];
756
+ _gl: any;
757
+ manifest: any;
758
+ _numMeshnodes: number;
759
+ loadPWFVersion(version: any): void;
760
+ version: typeof V1 | typeof V2 | undefined;
761
+ setArrayBuffers(nodeAB: any, meshnodeAB: any, meshAB: any): void;
762
+ setStandardModelBuffers(nodeAB: any, meshnodeAB: any, meshAB: any): void;
763
+ nodeAB: any;
764
+ meshnodeAB: any;
765
+ meshAB: any;
766
+ detailsParams: {
767
+ [key: string]: any;
768
+ } | undefined;
769
+ setPartitionedModelBuffers(nodeAB: any, meshnodeAB: any, partitionProxiesAB: any): void;
770
+ partitionProxiesAB: ArrayBuffer | undefined;
771
+ computeDetailsValues(): number[];
772
+ getNumPartitions(): number;
773
+ initPwfParser(): void;
774
+ pwfModelParser: PWFModelParser | undefined;
775
+ _numMeshes: number | undefined;
776
+ pwfModel: {
777
+ nodes: never[];
778
+ meshnodes: never[];
779
+ meshes: never[];
780
+ } | undefined;
781
+ parsePwfNodes(): {
782
+ isComplete: boolean;
783
+ };
784
+ parsePwfMeshnodes(): {
785
+ isComplete: boolean;
786
+ };
787
+ parsePwfMeshes(): void;
788
+ initMeshServices(): void;
789
+ initNodeServices(): void;
790
+ initMeshnodeServices(): void;
791
+ initNodeTree(): {
792
+ nodes: {
793
+ [key: string]: Node_2 | Meshnode;
794
+ };
795
+ isComplete: boolean;
796
+ };
797
+ initNodeTreeBoundingBoxes(): {
798
+ isComplete: boolean;
799
+ };
800
+ meshnodes: null;
801
+ initSceneGraph(sceneGraphName: any): {
802
+ isComplete: boolean;
803
+ };
804
+ sceneGraphFactory(impl: any): WASMTree | KDTree;
805
+ allMeshnodes(): Meshnode[];
806
+ rebuildSceneGraph(lessRelevantMeshnodes: any): void;
807
+ getNodeServices(): NodeServices | null;
808
+ getSceneGraph(): WASMTree | KDTree | null;
809
+ getMeshnodeFromIndex(index: any): Meshnode;
810
+ getParentNodeIds(nodeId: any): any[];
811
+ getSubtreeNodeIds(nodeId: any): any[];
812
+ getSubtreeMeshnodeIndex(nodeId: any): any[];
813
+ getNamedNode(nodeId: any): Node_2 | undefined;
814
+ getSubObjects(node: any, subArr: any): void;
815
+ getMeasureIds(): any[];
816
+ addMeasureIds(meshnodeIndices: any): void;
817
+ clearMeasureIds(): void;
818
+ refresh: boolean | undefined;
819
+ hasMeasureIds(arr: any): boolean;
820
+ removeMeasureIds(meshnodeIndices: any): void;
821
+ getMeshnodeFromNodeId(nodeId: any): Node_2 | Meshnode;
822
+ getMeshnode(offset: any): Meshnode;
823
+ getNode(offset: any): Node_2 | Meshnode;
824
+ numNodes(): number;
825
+ numMeshnodes(): number;
826
+ numMeshes(): number;
827
+ loadAllMeshGeometryToGPU(): {
828
+ isComplete: boolean;
829
+ };
830
+ loadAllPartitionProxies(): void;
831
+ prefetchPartitions(geometryFactory: any): {
832
+ isComplete: boolean;
833
+ };
834
+ currentIndex: number | undefined;
835
+ partitionProxies: PartitionProxy[] | undefined;
836
+ loadPartitionPromises: any[] | undefined;
837
+ getNodeById(id: any): Node_2;
838
+ hasNode(id: any): boolean;
839
+ globalOffset(): {
840
+ offsetX: number;
841
+ offsetY: number;
842
+ offsetZ: number;
843
+ };
844
+ root(): Node_2;
845
+ forEachMeshnode(callback: any): void;
846
+ forEachNode(callback: any): void;
847
+ getMeshVerticesAndFaces(meshRef: any, meshnodeOffset: any): MeshVerticesAndFaces;
848
+ findFirstObject(meshnodeIndex: any): Node_2;
849
+ captureModelStats(): void;
850
+ captureStandardModelStats(pwfModel: any): void;
851
+ capturePartitionedModelStats(pwfModel: any): void;
852
+ numFirstObjects(): number;
853
+ #private;
854
+ }
855
+
856
+ declare interface PWFMesh {
857
+ offset(): number;
858
+ color(): number;
859
+ vertices(): Float32Array;
860
+ faces(): Uint16Array;
861
+ opacity(): number;
862
+ drawType(): number;
863
+ }
864
+
865
+ declare interface PWFMeshnode {
866
+ index(): number;
867
+ offset(): number;
868
+ opaque(): number;
869
+ nodeType(): number;
870
+ nodeId(): number;
871
+ parentOffset(): number;
872
+ numChildren(): number;
873
+ childRefs(): Uint32Array;
874
+ bbox(): Float32Array;
875
+ box3(): THREE.Box3;
876
+ matrix(): Float32Array;
877
+ group(): number;
878
+ }
879
+
880
+ declare class PWFModelParser {
881
+ private nodeAB;
882
+ private nodeBufferReader;
883
+ private meshnodeAB;
884
+ private meshnodeBufferReader;
885
+ private meshAB;
886
+ private meshBufferReader?;
887
+ constructor(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer);
888
+ getGlobalOffset(): {
889
+ offsetX: number;
890
+ offsetY: number;
891
+ offsetZ: number;
892
+ };
893
+ getMeshnodeOffPointer(): number;
894
+ parseNodes(): {
895
+ nodes: PWFNode[];
896
+ isComplete: boolean;
897
+ };
898
+ parseMeshnodes(): {
899
+ meshnodes: PWFMeshnode[];
900
+ isComplete: boolean;
901
+ };
902
+ getNumMeshnodes(): number;
903
+ getNumMeshes(): number;
904
+ parseMeshes(): PWFMesh[];
905
+ }
906
+
907
+ declare interface PWFNode {
908
+ offset(): number;
909
+ nodeId(): number;
910
+ parentOffset(): number;
911
+ numChildren(): number;
912
+ group(): number;
913
+ childOffs(): number;
914
+ childrenOffsets(): Uint32Array;
915
+ nodeType(): number;
916
+ opaque(): number;
917
+ toString(): string;
918
+ }
919
+
920
+ declare interface PWFPartition {
921
+ partitionId(): number;
922
+ meshData(): MeshData[];
923
+ }
924
+
925
+ declare interface PWFPartitionProxy {
926
+ partitionId(): number;
927
+ partitionUrl(): string;
928
+ meshnodeOffsets(): Uint32Array;
929
+ }
930
+
285
931
  export declare type PwfV1Bundle = {
286
932
  nodeUrl: GeometryFile['url'];
287
933
  meshnodeUrl: GeometryFile['url'];
@@ -302,6 +948,18 @@ export declare const RENDER_MODE: {
302
948
 
303
949
  export declare type RenderMode = (typeof RENDER_MODE)[keyof typeof RENDER_MODE];
304
950
 
951
+ export declare type Resource = FileExtractionModePwfV1OverrideResource | FileExtractionModePwfV2OverrideResource | FileExtractionModeResource | ModelRevisionModePwfV1Resource | ModelRevisionModePwfV2Resource;
952
+
953
+ export declare type ResourceDiscriminator = {
954
+ fileExtractionId: number;
955
+ } | {
956
+ modelRevisionId: number;
957
+ };
958
+
959
+ export declare type ResourceOptions = CommonOptions & {
960
+ resources: Resource[];
961
+ };
962
+
305
963
  export declare type RGB = `rgb(${number}, ${number}, ${number})`;
306
964
 
307
965
  export declare type RGBA = `rgba(${number}, ${number}, ${number}, ${number})`;
@@ -318,6 +976,51 @@ export declare type SectionDataAutodeskFormat = {
318
976
 
319
977
  export declare type SectionDataProcoreFormat = ProcoreFormatClipPlane[];
320
978
 
979
+ declare class StreamedGeometryFactory extends GeometryFactory {
980
+ createMeshGeometry(vertexArray: Float32Array, indexArray: Uint16Array, color: number, opacity: number, drawType: number): StreamedMeshGeometry;
981
+ createMeshGeometryPrefetching(vertexArray: Float32Array, indexArray: Uint16Array, color: number, opacity: number, drawType: number): StreamedMeshGeometry;
982
+ createCylinderGeometry(vertexArray: Float32Array, indexArray: Uint16Array, color: number, opacity: number, drawType: number): StreamedMeshGeometry;
983
+ protected newVertexBufferStream(size: number): WebGLBuffer;
984
+ protected newIndexBufferStream(size: number): WebGLBuffer;
985
+ }
986
+
987
+ declare class StreamedMeshGeometry extends MeshGeometry {
988
+ color: number;
989
+ opacity: number;
990
+ drawType: number;
991
+ numFaces: number;
992
+ vertexArrayObject: WebGLVertexArrayObject | null;
993
+ verticesLength: number;
994
+ verticesGLBuffer: WebGLBuffer | null;
995
+ facesLength: number;
996
+ facesGLBuffer: WebGLBuffer | null;
997
+ lastFrameId: number;
998
+ constructor(color: number, opacity: number, drawType: number, vertexArrayObject: WebGLVertexArrayObject | null, numVertices: number, verticesBuffer: WebGLBuffer | null, numFaces: number, facesBuffer: WebGLBuffer | null, facesBytesLength: number, index: number);
999
+ }
1000
+
1001
+ declare class StreamedMeshnode extends Meshnode {
1002
+ private _partitionProxy?;
1003
+ private _meshGeometries;
1004
+ setPartitionProxy(partitionProxy: PartitionProxy): void;
1005
+ partitionProxy(): PartitionProxy;
1006
+ meshGeometries(): MeshGeometry[];
1007
+ setMeshGeometry(meshIndex: number, meshGeometry: StreamedMeshGeometry): void;
1008
+ getMeshGeometry(meshIndex: number): StreamedMeshGeometry | undefined;
1009
+ asObject(): MeshnodeObject;
1010
+ private getMeshVerticesAndFaces;
1011
+ }
1012
+
1013
+ declare class StreamedMeshnodeServices extends MeshnodeServices {
1014
+ protected createMeshnode(pwfMeshnode: PWFMeshnode): Meshnode;
1015
+ }
1016
+
1017
+ declare class StreamedMeshServices extends MeshServices {
1018
+ constructor(pwf: PWF);
1019
+ getMeshVerticesAndFaces(meshOffset: number, _meshnodeOffset: number): MeshVerticesAndFaces;
1020
+ loadPartitionContainingMeshnode(streamedMeshnode: StreamedMeshnode): Promise<void>;
1021
+ getMeshGeometryForOffsets(meshOffset: number, meshnodeOffset: number): StreamedMeshGeometry | undefined;
1022
+ }
1023
+
321
1024
  export declare class TestRoutineRecorder {
322
1025
  camera: Camera;
323
1026
  points: Point[];
@@ -369,6 +1072,22 @@ export declare const TOOL_BAR_TOOLS: {
369
1072
 
370
1073
  export declare type ToolBarTools = (typeof TOOL_BAR_TOOLS)[keyof typeof TOOL_BAR_TOOLS];
371
1074
 
1075
+ declare namespace V1 {
1076
+ export {
1077
+ MeshnodeServices_2 as MeshnodeServices,
1078
+ MeshServices_2 as MeshServices,
1079
+ NodeServices_2 as NodeServices
1080
+ }
1081
+ }
1082
+
1083
+ declare namespace V2 {
1084
+ export {
1085
+ MeshnodeServices_3 as MeshnodeServices,
1086
+ MeshServices_3 as MeshServices,
1087
+ NodeServices_3 as NodeServices
1088
+ }
1089
+ }
1090
+
372
1091
  export declare type Vector2 = {
373
1092
  x: number;
374
1093
  y: number;
@@ -398,6 +1117,20 @@ export declare type Visibility = {
398
1117
  };
399
1118
  };
400
1119
 
1120
+ declare class WASMTree {
1121
+ static maxChunkSize: number;
1122
+ meshnodes: any[];
1123
+ currentIndex: number;
1124
+ cullTree(cameraPosition: any, projectviewMatrix: any, detailsParam: any): {
1125
+ opaques: any[];
1126
+ transparents: any[];
1127
+ };
1128
+ maxChunkSize: number;
1129
+ buildTree(meshnodes: any): {
1130
+ isComplete: boolean;
1131
+ };
1132
+ }
1133
+
401
1134
  export declare type WebFormatExtractionItem = {
402
1135
  item_type: 'WebFormat';
403
1136
  artifact: {
@@ -611,14 +1344,24 @@ export declare class Webviewer {
611
1344
  selectAllObjects: (objectTreeName?: string) => Promise<boolean>;
612
1345
  getSelectedObjects: () => Promise<number[]>;
613
1346
  setMeasurement: (enable: boolean) => void;
614
- setObjectColor: (palettes: any) => void;
615
- clearObjectColor: (objectIds: number[]) => Promise<void> | void;
616
- clearAllObjectColor: () => Promise<void> | void;
1347
+ setObjectColor: (palettes: PaletteParams[], options?: {
1348
+ resource?: ResourceDiscriminator;
1349
+ }) => void;
1350
+ clearObjectColor: (objectIds: number[], options?: {
1351
+ resource?: ResourceDiscriminator;
1352
+ }) => Promise<void> | void;
1353
+ clearAllObjectColor: (options?: {
1354
+ resource?: ResourceDiscriminator;
1355
+ }) => Promise<void> | void;
617
1356
  filterObjectTree: (objectIds: number[]) => Promise<void>;
618
1357
  clearObjectTreeFilter: () => Promise<void>;
619
- getViewpoint: () => Promise<Viewpoint>;
1358
+ getViewpoint: (options?: {
1359
+ defaultVisibilityAlwaysTrue?: boolean;
1360
+ }) => Promise<Viewpoint>;
620
1361
  setViewpoint: (viewpoint: Viewpoint) => Promise<void>;
621
- getVisibility: () => Promise<Visibility>;
1362
+ getVisibility: (options?: {
1363
+ defaultVisibilityAlwaysTrue?: boolean;
1364
+ }) => Promise<Visibility>;
622
1365
  setVisibility: (visibility: Visibility) => Promise<void>;
623
1366
  };
624
1367
  api: {