@procore/bim-webviewer-sdk 16.6.0-rc.14 → 16.6.0-rc.16

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.
@@ -1,25 +1,3 @@
1
- import { AmbientLight } from 'three';
2
- import { Box3 } from 'three';
3
- import { Clock } from 'three';
4
- import { Cylindrical } from 'three';
5
- import { DirectionalLight } from 'three';
6
- import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer';
7
- import { InitOutput } from '../../webassembly/webengine/dist/webengine';
8
- import { Matrix4 } from 'three/src/math/Matrix4';
9
- import { Pass } from 'three/examples/jsm/postprocessing/Pass';
10
- import { PerspectiveCamera } from 'three';
11
- import { Quaternion } from 'three';
12
- import { Scene } from 'three';
13
- import { Spherical } from 'three';
14
- import { ToneMapping } from 'three/src/constants';
15
- import { Vector2 as Vector2_2 } from 'three';
16
- import { Vector3 as Vector3_2 } from 'three';
17
- import { Vector3 as Vector3_3 } from 'three/src/math/Vector3';
18
- import { WebGLRenderTarget } from 'three';
19
- import { WebGLShadowMap } from 'three/src/renderers/webgl/WebGLShadowMap';
20
- import { WebVRManager } from 'three/src/renderers/webvr/WebVRManager';
21
- import { WebXRManager } from 'three/src/renderers/webvr/WebXRManager';
22
-
23
1
  export declare const ACTION: {
24
2
  readonly NONE: -1;
25
3
  readonly PAN: 1;
@@ -32,69 +10,6 @@ export declare const ACTION: {
32
10
 
33
11
  export declare type Action = (typeof ACTION)[keyof typeof ACTION];
34
12
 
35
- declare type Anchorable = {
36
- anchor: Vector3;
37
- anchorOffset?: Vector2;
38
- };
39
-
40
- declare type AnchorableLine = {
41
- anchorStart: Vector3;
42
- anchorEnd: Vector3;
43
- };
44
-
45
- declare type AnchoredArrow = Omit<Arrow, 'start' | 'end'> & AnchorableLine;
46
-
47
- declare type AnchoredBoxEllipse = BoxEllipse & Anchorable;
48
-
49
- declare type AnchoredLine = Omit<Line, 'start' | 'end'> & AnchorableLine;
50
-
51
- declare type AnchoredRadiusEllipse = Omit<RadiusEllipse, 'center'> & Anchorable;
52
-
53
- declare type AnchoredRect = Omit<Rect, 'x' | 'y'> & Anchorable;
54
-
55
- declare type AnchoredSvgData = {
56
- ellipses?: (AnchoredBoxEllipse | AnchoredRadiusEllipse)[];
57
- lines?: AnchoredLine[];
58
- arrows?: AnchoredArrow[];
59
- texts?: AnchoredText[];
60
- rects?: AnchoredRect[];
61
- };
62
-
63
- declare type AnchoredText = Omit<Text_2, 'origin'> & Anchorable;
64
-
65
- declare function ApiController(apiMethod?: {
66
- ModelRevisions: typeof ModelRevisions;
67
- FileExtractions: typeof FileExtractions;
68
- }): void;
69
-
70
- declare class ApiController {
71
- constructor(apiMethod?: {
72
- ModelRevisions: typeof ModelRevisions;
73
- FileExtractions: typeof FileExtractions;
74
- });
75
- modelRevisions: typeof ModelRevisions;
76
- fileExtractions: typeof FileExtractions;
77
- CheckBimPropertyService(): void;
78
- GetBimObjectsFor(ids: any): Promise<any>;
79
- GetBimModelRevisionViewpoints(): void;
80
- GetBimFileViewFolders(bimfileId: any): void;
81
- GetBimProperties({ firstObjectId, objectIds, curatedList, }: {
82
- firstObjectId: any;
83
- objectIds: any;
84
- curatedList?: boolean | undefined;
85
- }): void;
86
- GetSimilarObjects(query: any): Promise<Response>;
87
- trackEvent(key: any, properties?: {}): Promise<void>;
88
- }
89
-
90
- declare type Arrow = {
91
- start: Vector2;
92
- end: Vector2;
93
- stroke: CssColor;
94
- strokeWidth: number;
95
- zIndex?: number;
96
- };
97
-
98
13
  export declare type Attachment = {
99
14
  id: number;
100
15
  content_type: string;
@@ -156,19 +71,6 @@ export declare type BimFileUpload = {
156
71
  attachment: Attachment;
157
72
  };
158
73
 
159
- declare function BimPropertyServiceCheck({ projectId, modelRevisionId }: {
160
- projectId: any;
161
- modelRevisionId: any;
162
- }): Promise<Response>;
163
-
164
- declare const BimPropertyServiceCheck_2: ({ projectId, propertyFileId, holderType, }: BimPropertyServiceCheckParams) => Promise<Response>;
165
-
166
- declare type BimPropertyServiceCheckParams = {
167
- projectId: Project['id'];
168
- propertyFileId: PropertiesFile['id'];
169
- holderType: HolderType;
170
- };
171
-
172
74
  declare type BootstrapperResult = {
173
75
  isComplete: boolean;
174
76
  };
@@ -178,15 +80,6 @@ export declare type BoundingBox = {
178
80
  min: Vector3;
179
81
  };
180
82
 
181
- declare type BoxEllipse = {
182
- min: Vector2;
183
- max: Vector2;
184
- stroke: CssColor;
185
- fill?: CssColor;
186
- strokeWidth: number;
187
- zIndex?: number;
188
- };
189
-
190
83
  declare class BVHTree {
191
84
  static maxChunkSize: number;
192
85
  constructor(pwf: any);
@@ -212,33 +105,6 @@ declare type Color = {
212
105
  opacity: number;
213
106
  };
214
107
 
215
- declare class ColorServices {
216
- private _palettes;
217
- private meshnodeToPalette;
218
- private models;
219
- private resourceIdToVirtualMeshnodeIndexes;
220
- constructor(params: {
221
- models: Models;
222
- });
223
- setNodeColor(params: {
224
- colorPalettes: SetNodeColorParams[];
225
- resourceId: number;
226
- }): void;
227
- setMeshnodeColor(params: {
228
- palette: Palette;
229
- virtualMeshnodeIndex: number;
230
- resourceId: number;
231
- }): void;
232
- clearNodeColor(params: {
233
- nodeIds: number[];
234
- resourceId: number;
235
- }): void;
236
- clearAllNodeColor(resourceId: number): void;
237
- getPaletteByVirtualMeshnodeIndex(virtualMeshnodeIdx: number): Palette | undefined;
238
- get palettes(): Palette[];
239
- private addPalette;
240
- }
241
-
242
108
  export declare type CommonOptions = {
243
109
  /**
244
110
  * Always required
@@ -286,8 +152,6 @@ export declare type CommonOptions = {
286
152
 
287
153
  export declare type CssColor = RGB | RGBA | HEX | string;
288
154
 
289
- declare type CssFont = string;
290
-
291
155
  export declare const DISPLAY_UNIT: {
292
156
  readonly Meters: "m";
293
157
  readonly Millimeters: "mm";
@@ -356,16 +220,6 @@ export declare type FileExtractionModeResource = {
356
220
  fileExtractionId: FileExtraction['id'];
357
221
  };
358
222
 
359
- declare namespace FileExtractions {
360
- export {
361
- GetBimFileExtraction,
362
- GetBimObjectsFor_2 as GetBimObjectsFor,
363
- GetSimilarBimObjects_2 as GetSimilarBimObjects,
364
- BimPropertyServiceCheck_2 as BimPropertyServiceCheck,
365
- GetBimProperties_2 as GetBimProperties
366
- }
367
- }
368
-
369
223
  export declare type FileVersion = {
370
224
  id: number;
371
225
  file_id: number;
@@ -414,65 +268,6 @@ export declare type GeometryFile = {
414
268
  url: string;
415
269
  };
416
270
 
417
- declare const GetBimFileExtraction: ({ projectId, fileExtractionId, }: GetBimFileExtractionParams) => Promise<Response>;
418
-
419
- declare type GetBimFileExtractionParams = {
420
- projectId: Project['id'];
421
- fileExtractionId: FileExtraction['id'];
422
- };
423
-
424
- declare function GetBimModelRevision({ projectId, modelRevisionId }: {
425
- projectId: any;
426
- modelRevisionId: any;
427
- }): Promise<Response>;
428
-
429
- declare function GetBimObjectsFor({ ids, projectId, modelRevisionId }: {
430
- ids: any;
431
- projectId: any;
432
- modelRevisionId: any;
433
- }, method?: string): Promise<Response>;
434
-
435
- declare const GetBimObjectsFor_2: ({ projectId, propertyFileId, ids, holderType, }: GetBimObjectsForParams) => Promise<Response>;
436
-
437
- declare type GetBimObjectsForParams = {
438
- projectId: Project['id'];
439
- propertyFileId: PropertiesFile['id'];
440
- holderType: HolderType;
441
- ids: number[];
442
- };
443
-
444
- declare function GetBimProperties({ objectIds, projectId, modelRevisionId, curatedList, }: {
445
- objectIds: any;
446
- projectId: any;
447
- modelRevisionId: any;
448
- curatedList?: boolean | undefined;
449
- }): Promise<Response>;
450
-
451
- declare const GetBimProperties_2: (params: GetBimPropertiesParams) => Promise<Response>;
452
-
453
- declare type GetBimPropertiesParams = {
454
- projectId: Project['id'];
455
- propertyFileId: PropertiesFile['id'];
456
- holderType: HolderType;
457
- objectIds: Array<number>;
458
- curatedList?: boolean;
459
- };
460
-
461
- declare function GetSimilarBimObjects({ name, projectId, modelRevisionId }: {
462
- name: any;
463
- projectId: any;
464
- modelRevisionId: any;
465
- }): Promise<Response>;
466
-
467
- declare const GetSimilarBimObjects_2: ({ name, projectId, propertyFileId, holderType, }: GetSimilarBimObjectsParams) => Promise<Response>;
468
-
469
- declare type GetSimilarBimObjectsParams = {
470
- name: string;
471
- projectId: Project['id'];
472
- propertyFileId: PropertiesFile['id'];
473
- holderType: HolderType;
474
- };
475
-
476
271
  declare type GPUMeshData = {
477
272
  index: number;
478
273
  f_byte_size: number;
@@ -483,101 +278,6 @@ declare type GPUMeshData = {
483
278
 
484
279
  export declare type HEX = `#${string}`;
485
280
 
486
- declare class HiddenNodeServices {
487
- private hiddenObjectCountByResourceId;
488
- private hiddenMeshnodeIndicesByResourceId;
489
- private hiddenNodesIdsByResourceId;
490
- private models;
491
- private objectTrees;
492
- constructor(params: {
493
- models: Models;
494
- objectTrees: Map<number, ObjectTree>;
495
- });
496
- getCount: (resourceId: number) => number;
497
- getHiddenMeshnodeIndices: (resourceId: number) => Set<number>;
498
- getHiddenNodeIds: (resourceId: number) => Set<number>;
499
- setMeshnodeHidden: (virtualMeshnodeIndex: number, hidden: boolean) => void;
500
- setNodeHidden: (objectTreeNode: InternalNode, hidden: boolean, resourceId: number) => void;
501
- setMeshnodeHiddenFromSet: (virtualMeshnodeIndexes: Set<number>, hidden: boolean) => void;
502
- setNodeHiddenFromSet: (nodeIds: Set<number>, hidden: boolean, resourceId: number) => void;
503
- clear: (resourceId: number) => void;
504
- hideAll(resourceId: number): void;
505
- hasMeshnodeIndices: (indexes: Array<number>, resourceId: number) => boolean;
506
- private nodeNeedsUpdating;
507
- getVisibility: (resourceId: number, options?: {
508
- defaultVisibilityAlwaysTrue?: boolean;
509
- }) => Visibility;
510
- setVisibility: (visibility: Visibility, resourceId: number) => void;
511
- private updateNodeAndChildren;
512
- private updateNodeAndParentsDF;
513
- private setNodeHiddenIfChildrenHidden;
514
- private updateNodesAndParentsByIdBF;
515
- updateHiddenAncestry: (nodeId: number, hidden: boolean, resourceId: number) => void;
516
- }
517
-
518
- declare type HolderType = 'FileVersion' | 'BimModelRevision';
519
-
520
- declare class Hotkeys implements KeyboardControl {
521
- private renderControllerProxy;
522
- private navigationManager;
523
- private _enabled;
524
- constructor(params: {
525
- renderControllerProxy: RenderControllerProxy;
526
- navigationManager: NavigationManager;
527
- });
528
- get enabled(): boolean;
529
- set enabled(value: boolean);
530
- onKeyDown: (event: KeyboardEvent) => void;
531
- onKeyUp: () => void;
532
- private publishSelectedToolEvent;
533
- dispose(): void;
534
- }
535
-
536
- declare type InternalNode = {
537
- id: number;
538
- parentId: number | undefined;
539
- children: number[];
540
- meshnodes: number[];
541
- isFirstObject: boolean;
542
- };
543
-
544
- declare class KDTree {
545
- private MAX_CHILDREN_PER_NODE;
546
- private readonly root;
547
- private frustum;
548
- private queue;
549
- private readonly result;
550
- meshnodes: Meshnode[];
551
- constructor();
552
- cullTree(cameraPosition: Vector3_3, frustumMatrix: Matrix4, detailsParam: number): {
553
- opaques: Set<Meshnode>;
554
- transparents: Set<Meshnode>;
555
- };
556
- buildTree(meshnodes: Meshnode[]): {
557
- isComplete: boolean;
558
- };
559
- collectMeshnodes(cameraPosition: Vector3_3, detailsFactor: number): {
560
- opaques: Set<Meshnode>;
561
- transparents: Set<Meshnode>;
562
- };
563
- }
564
-
565
- declare type KeyboardControl = {
566
- onKeyDown: (event: KeyboardEvent) => void;
567
- onKeyUp: (event: KeyboardEvent) => void;
568
- dispose: () => void;
569
- };
570
-
571
- declare type Line = {
572
- start: Vector2;
573
- end: Vector2;
574
- stroke: CssColor;
575
- strokeWidth: number;
576
- strokeDasharray?: string;
577
- opacity?: number;
578
- zIndex?: number;
579
- };
580
-
581
281
  declare interface Logger {
582
282
  logError(error: any): void;
583
283
  }
@@ -596,9 +296,7 @@ declare class LRUCache<K, V> {
596
296
  getKeys(): K[];
597
297
  }
598
298
 
599
- declare type Manifest = Manifest_2;
600
-
601
- declare type Manifest_2 = {
299
+ declare type Manifest = {
602
300
  version: PWFVersion;
603
301
  globalAABB: BoundingBox;
604
302
  reducedGlobalAABB: BoundingBox;
@@ -613,58 +311,12 @@ declare type Manifest_2 = {
613
311
  numPartitions: number;
614
312
  };
615
313
 
616
- declare const MEASUREMENT_STATE: {
617
- readonly initial: "initial";
618
- readonly inProgress: "inProgress";
619
- readonly completed: "completed";
314
+ export declare const MEASURE_MODES: {
315
+ POINT_TO_POINT: string;
316
+ SHORTEST_DISTANCE: string;
620
317
  };
621
318
 
622
- declare interface MeasurementInterface {
623
- setGlobalOffset(params: Vector3): void;
624
- toggle(params: {
625
- enable: boolean;
626
- }): void;
627
- getMeasurementProgress(): MeasurementState;
628
- resetMeasurement(): void;
629
- }
630
-
631
- declare class MeasurementRenderer {
632
- element: HTMLElement;
633
- private measurements;
634
- private globalOffset;
635
- private readonly gui;
636
- private camera;
637
- private readonly settingsController;
638
- private readonly svgRenderer;
639
- constructor(params: {
640
- settingsController: SettingsController;
641
- svgRenderer: SvgRenderer;
642
- });
643
- setGlobalOffset(params: Vector3): void;
644
- getGlobalOffset(): THREE.Vector3;
645
- addMeasurement(params: {
646
- measurePoint1: Vector3;
647
- measurePoint2: Vector3;
648
- config?: {
649
- type: 'colorAxis' | 'greyTriangle';
650
- };
651
- }): Promise<void>;
652
- clearMeasurements(): void;
653
- private onProjectSettingsUpdated;
654
- private onRenderReady;
655
- private onResize;
656
- private onCameraUpdated;
657
- private updateDistanceLabelPosition;
658
- private isDistanceLabelHidden;
659
- private areRectsOverlapping;
660
- private isOverlapping;
661
- private stackElementsVerticallyToFirst;
662
- private createColorAxis;
663
- private createGreyTriangle;
664
- private updateSvgData;
665
- }
666
-
667
- declare type MeasurementState = (typeof MEASUREMENT_STATE)[keyof typeof MEASUREMENT_STATE];
319
+ export declare type MeasureMode = (typeof MEASURE_MODES)[keyof typeof MEASURE_MODES];
668
320
 
669
321
  declare class Mesh {
670
322
  private pwfMesh;
@@ -679,7 +331,7 @@ declare class Mesh {
679
331
  lenFaces(): number;
680
332
  vertices(): Float32Array;
681
333
  faces(): Uint16Array;
682
- asObject(): MeshObject;
334
+ asObject(): MeshObject_2;
683
335
  }
684
336
 
685
337
  declare class Mesh_2 {
@@ -695,7 +347,7 @@ declare class Mesh_2 {
695
347
  lenFaces(): number;
696
348
  vertices(): Float32Array;
697
349
  faces(): Uint16Array;
698
- asObject(): MeshObject_2;
350
+ asObject(): MeshObject;
699
351
  }
700
352
 
701
353
  declare class MeshData {
@@ -712,7 +364,6 @@ declare class MeshData {
712
364
  faces(): Uint16Array;
713
365
  uploadToGPU(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
714
366
  uploadToGPUPreFetching(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
715
- getCompressedMeshData(): ArrayBuffer;
716
367
  getUncompressedMeshData(): ArrayBuffer;
717
368
  }
718
369
 
@@ -730,6 +381,7 @@ declare class MeshData_2 {
730
381
  faces(): Uint16Array;
731
382
  uploadToGPU(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
732
383
  uploadToGPUPreFetching(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
384
+ getCompressedMeshData(): ArrayBuffer;
733
385
  getUncompressedMeshData(): ArrayBuffer;
734
386
  }
735
387
 
@@ -762,7 +414,7 @@ declare class Meshnode_2 {
762
414
  constructor(pwfMeshnode: PWFMeshnode, pwf: PWFV1);
763
415
  offset(): number;
764
416
  parentOffset(): number;
765
- parent(): Node_2;
417
+ parent(): Node_3;
766
418
  children(): never[];
767
419
  nodeId(): number;
768
420
  bbox(): Float32Array;
@@ -784,7 +436,7 @@ declare class Meshnode_2 {
784
436
  isRoot(): boolean;
785
437
  hidden(): Meshnode_2['hiddenValue'];
786
438
  setHidden(hidden: boolean): void;
787
- setParent(node: Node_2): void;
439
+ setParent(node: Node_3): void;
788
440
  asObject(): MeshnodeObject;
789
441
  }
790
442
 
@@ -802,7 +454,7 @@ declare class Meshnode_3 {
802
454
  constructor(pwfMeshnode: PWFMeshnode_2, pwf: PWFV2);
803
455
  offset(): number;
804
456
  parentOffset(): number;
805
- parent(): Node_3;
457
+ parent(): Node_4;
806
458
  children(): never[];
807
459
  nodeId(): number;
808
460
  bbox(): Float32Array;
@@ -824,7 +476,7 @@ declare class Meshnode_3 {
824
476
  isRoot(): boolean;
825
477
  hidden(): Meshnode_3['hiddenValue'];
826
478
  setHidden(hidden: boolean): void;
827
- setParent(node: Node_3): void;
479
+ setParent(node: Node_4): void;
828
480
  asObject(): MeshnodeObject_2;
829
481
  }
830
482
 
@@ -857,27 +509,27 @@ declare type MeshnodeObject_3 = MeshnodeObject | MeshnodeObject_2;
857
509
  declare class MeshnodeServices {
858
510
  private meshnodeCount;
859
511
  private meshnodes;
860
- protected pwf: PWFV1;
861
- protected cachedMeshnodes: Map<number, Meshnode_2>;
862
- constructor(pwfMeshnodes: PWFMeshnode[], pwf: PWFV1);
863
- getMeshnodeFromIndex(index: number): Meshnode_2;
864
- getMeshnode(offset: number): Meshnode_2;
512
+ protected pwf: PWFV2;
513
+ protected cachedMeshnodes: Map<number, Meshnode_3>;
514
+ constructor(pwfMeshnodes: PWFMeshnode_2[], pwf: PWFV2);
515
+ getMeshnodeFromIndex(index: number): Meshnode_3;
516
+ getMeshnode(offset: number): Meshnode_3;
865
517
  numMeshnodes(): number;
866
518
  allMeshnodes(): NonNullable<MeshnodeServices['meshnodes']>;
867
- protected createMeshnode(pwfMeshnode: PWFMeshnode): Meshnode_2;
519
+ protected createMeshnode(pwfMeshnode: PWFMeshnode_2): Meshnode_3;
868
520
  }
869
521
 
870
522
  declare class MeshnodeServices_2 {
871
523
  private meshnodeCount;
872
524
  private meshnodes;
873
- protected pwf: PWFV2;
874
- protected cachedMeshnodes: Map<number, Meshnode_3>;
875
- constructor(pwfMeshnodes: PWFMeshnode_2[], pwf: PWFV2);
876
- getMeshnodeFromIndex(index: number): Meshnode_3;
877
- getMeshnode(offset: number): Meshnode_3;
525
+ protected pwf: PWFV1;
526
+ protected cachedMeshnodes: Map<number, Meshnode_2>;
527
+ constructor(pwfMeshnodes: PWFMeshnode[], pwf: PWFV1);
528
+ getMeshnodeFromIndex(index: number): Meshnode_2;
529
+ getMeshnode(offset: number): Meshnode_2;
878
530
  numMeshnodes(): number;
879
531
  allMeshnodes(): NonNullable<MeshnodeServices_2['meshnodes']>;
880
- protected createMeshnode(pwfMeshnode: PWFMeshnode_2): Meshnode_3;
532
+ protected createMeshnode(pwfMeshnode: PWFMeshnode): Meshnode_2;
881
533
  }
882
534
 
883
535
  declare type MeshObject = {
@@ -901,14 +553,14 @@ declare type MeshObject_2 = {
901
553
  declare type MeshObject_3 = MeshObject | MeshObject_2;
902
554
 
903
555
  declare class MeshServices {
904
- protected pwf: PWFV1;
556
+ protected pwf: PWFV2;
905
557
  protected geometryFactory?: GeometryFactory;
906
558
  private meshGeometryMap;
907
559
  private readonly pwfMeshes;
908
560
  private pwfMeshOffsetMap;
909
561
  private readonly meshCount;
910
562
  private currentIndex;
911
- constructor(pwfMeshes: PWFMesh[], pwf: PWFV1);
563
+ constructor(pwfMeshes: PWFMesh[], pwf: PWFV2);
912
564
  setGeometryFactory(geometryFactory: GeometryFactory): void;
913
565
  getMeshGeometryForOffsets(meshOffset: number, _meshnodeOffset: number | undefined): MeshGeometry | undefined;
914
566
  meshFromOffset(offset: number): Mesh;
@@ -918,20 +570,20 @@ declare class MeshServices {
918
570
  isComplete: boolean;
919
571
  };
920
572
  private loadToGPU;
921
- getMeshObject(meshOffset: number): MeshObject;
573
+ getMeshObject(meshOffset: number): MeshObject_2;
922
574
  private loadMeshGeometryToGPU;
923
575
  dispose(): void;
924
576
  }
925
577
 
926
578
  declare class MeshServices_2 {
927
- protected pwf: PWFV2;
579
+ protected pwf: PWFV1;
928
580
  protected geometryFactory?: GeometryFactory;
929
581
  private meshGeometryMap;
930
582
  private readonly pwfMeshes;
931
583
  private pwfMeshOffsetMap;
932
584
  private readonly meshCount;
933
585
  private currentIndex;
934
- constructor(pwfMeshes: PWFMesh_2[], pwf: PWFV2);
586
+ constructor(pwfMeshes: PWFMesh_2[], pwf: PWFV1);
935
587
  setGeometryFactory(geometryFactory: GeometryFactory): void;
936
588
  getMeshGeometryForOffsets(meshOffset: number, _meshnodeOffset: number | undefined): MeshGeometry | undefined;
937
589
  meshFromOffset(offset: number): Mesh_2;
@@ -941,7 +593,7 @@ declare class MeshServices_2 {
941
593
  isComplete: boolean;
942
594
  };
943
595
  private loadToGPU;
944
- getMeshObject(meshOffset: number): MeshObject_2;
596
+ getMeshObject(meshOffset: number): MeshObject;
945
597
  private loadMeshGeometryToGPU;
946
598
  dispose(): void;
947
599
  }
@@ -962,32 +614,6 @@ declare type ModelAnalyticsData = {
962
614
  partition_proxy_size?: number;
963
615
  };
964
616
 
965
- declare type ModelDescriptor = {
966
- resource: ResourceDiscriminator;
967
- meshAB: ArrayBuffer;
968
- meshnodeAB: ArrayBuffer;
969
- nodeAB: ArrayBuffer;
970
- manifest?: Manifest;
971
- };
972
-
973
- declare type ModelInitializationPayload = {
974
- success: boolean;
975
- start_timestamp: number;
976
- end_timestamp: number;
977
- total_time: number;
978
- model_type: ModelType;
979
- node_size?: number;
980
- meshnode_size?: number;
981
- num_nodes?: number;
982
- num_meshnodes?: number;
983
- mesh_size?: number;
984
- num_meshes?: number;
985
- partition_proxy_size?: number;
986
- web_viewer_version: string;
987
- step_failed?: string;
988
- error_description?: string;
989
- };
990
-
991
617
  export declare type ModelRevision = {
992
618
  id: number;
993
619
  revision: number;
@@ -1014,105 +640,10 @@ export declare type ModelRevisionModePwfV2Resource = PwfV2Bundle & {
1014
640
  modelRevisionId: ModelRevision['id'];
1015
641
  };
1016
642
 
1017
- declare namespace ModelRevisions {
1018
- export {
1019
- GetBimObjectsFor,
1020
- GetSimilarBimObjects,
1021
- BimPropertyServiceCheck,
1022
- GetBimProperties,
1023
- GetBimModelRevision
1024
- }
1025
- }
1026
-
1027
643
  export declare type ModelRevisionViewpoint = Viewpoint & {
1028
644
  primary: boolean;
1029
645
  };
1030
646
 
1031
- declare class Models {
1032
- private resourceIds;
1033
- private pwfs;
1034
- private currentParsingPwfIndex;
1035
- private streaming;
1036
- private prefetchingPartitions;
1037
- private geometryFactory?;
1038
- private objectTrees;
1039
- private readonly selectionOption;
1040
- private partitionProxiesLoaded;
1041
- private readonly sceneGraph;
1042
- private tempVirtualizedMeshnodes;
1043
- private detailsParams?;
1044
- private readonly isLogging;
1045
- constructor(params: {
1046
- sceneGraphName: SceneGraphName;
1047
- isLogging: boolean;
1048
- locale: string;
1049
- downloadMetaData: DownloadMetaData;
1050
- modelDescriptors: ModelDescriptor[];
1051
- selectionOption: SelectMethod;
1052
- prefetchingPartitions?: boolean;
1053
- featureFlags: ValidatedFeatureFlags;
1054
- });
1055
- private sceneGraphFactory;
1056
- getResourceId: (resource: ResourceDiscriminator) => number;
1057
- getAllResourceIds(): number[];
1058
- getPwf(resourceId: number): PWFProxy;
1059
- getObjectTrees(resourceId: number): Map<string, ObjectTree>;
1060
- getSceneGraph(): KDTree | WASMTree;
1061
- parsePwfNodes(): BootstrapperResult;
1062
- parsePwfMeshnodes(): BootstrapperResult;
1063
- parsePwfMeshes(): void;
1064
- initMeshServices(): BootstrapperResult;
1065
- initNodeServices(): void;
1066
- initMeshnodeServices(): void;
1067
- initNodeTree(): BootstrapperResult;
1068
- initNodeTreeBoundingBoxes(): BootstrapperResult;
1069
- initSceneGraph(): BootstrapperResult;
1070
- captureModelStats(): {
1071
- detailsInMotion: number;
1072
- detailsAtRest: number;
1073
- };
1074
- getResourceFromVirtualMeshnodeIndex(virtualMeshnodeIndex: number): number;
1075
- getMeshnodeFromVirtualIndex(virtualMeshnodeIndex: number): {
1076
- meshnode: Meshnode;
1077
- resourceId: number;
1078
- };
1079
- getMeshnodeFromVirtualIndexAndResourceId(virtualMeshnodeIndex: number, resourceId: number): Meshnode;
1080
- getMeshnodeVirtualIndexFromMeshnodeIndex(params: {
1081
- resourceId: number;
1082
- meshnodeIndex: number;
1083
- }): number;
1084
- getMeshObject(params: {
1085
- resourceId: number;
1086
- meshRef: number;
1087
- }): MeshObject;
1088
- globalOffset(resourceId: number): Vector3;
1089
- initGeometryFactory(params: {
1090
- viewerRenderer: ViewerRenderer;
1091
- }): void;
1092
- private instantiateGeometryFactory;
1093
- initTreeServices(): BootstrapperResult;
1094
- initPartitionedGeometry(): BootstrapperResult;
1095
- loadAllMeshGeometryToGPU(): BootstrapperResult;
1096
- private forEachResourceInterruptible;
1097
- getVirtualMeshnodeIndexesByNodeId(params: {
1098
- nodeId: number;
1099
- resourceId: number;
1100
- }): number[];
1101
- findFirstObjectNodeId(params: {
1102
- virtualMeshnodeIndex: number;
1103
- resourceId: number;
1104
- }): number;
1105
- }
1106
-
1107
- declare type ModelType = 'standard' | 'partitioned' | undefined;
1108
-
1109
- declare type MouseControl = {
1110
- onMouseDown: (event: MouseEvent) => void;
1111
- onMouseUp: (event: MouseEvent) => void;
1112
- onMouseMove: (event: MouseEvent) => void;
1113
- dispose: () => void;
1114
- };
1115
-
1116
647
  export declare const NAV_MODE: {
1117
648
  readonly DEFAULT: 0;
1118
649
  readonly FLY: 1;
@@ -1123,217 +654,76 @@ export declare const NAV_MODE: {
1123
654
  readonly SURVEY: 6;
1124
655
  };
1125
656
 
1126
- declare class NavigationManager {
1127
- private renderControllerProxy;
1128
- private canvas;
1129
- private isMoved;
1130
- private wheeling?;
1131
- private _selectedNavigationMode;
1132
- private _mouseControls;
1133
- private _wheelControls;
1134
- keyboardControls: KeyboardControl;
1135
- private static DEBUG;
1136
- private debugEl?;
1137
- private modifierKeys;
1138
- private lastMousemoveEvent?;
1139
- constructor(params: {
1140
- renderWrapperController: RenderControllerProxy;
1141
- canvas: HTMLCanvasElement;
1142
- });
1143
- get mouseControls(): MouseControl;
1144
- private set mouseControls(value);
1145
- get wheelControls(): WheelControl;
1146
- private set wheelControls(value);
1147
- get selectedNavigationMode(): NavigationMode;
1148
- private set selectedNavigationMode(value);
1149
- private updateDebugEl;
1150
- private setWheelControls;
1151
- private setKeyboardControls;
1152
- setNavigationMode(navigationMode: NavigationMode): void;
1153
- dispose(): void;
1154
- private setMouseControls;
1155
- private updateModifierKeys;
1156
- private onKeyDown;
1157
- private onKeyUp;
1158
- private onMouseDown;
1159
- private onMouseUp;
1160
- private onMouseMove;
1161
- private onWheel;
1162
- private wheelDetect;
1163
- private onSelectTool;
1164
- }
1165
-
1166
657
  export declare type NavigationMode = (typeof NAV_MODE)[keyof typeof NAV_MODE];
1167
658
 
1168
- declare function NavigationModel(cam: any, rc: any, dom: any): void;
1169
-
1170
- declare class NavigationModel {
1171
- constructor(cam: any, rc: any, dom: any);
1172
- cam: any;
1173
- rc: any;
1174
- dom: any;
1175
- curKeysMultiple: any[];
1176
- curAction: -1;
1177
- EPS: number;
1178
- quatWorldToModelSpace: Quaternion;
1179
- quatModelToWorldSpace: Quaternion;
1180
- lastZoomPos: Vector2_2;
1181
- lastZoomModelPos: Vector3_2;
1182
- zoomDir: Vector3_2;
1183
- zoomDistanceInterval: number;
1184
- zoomDistanceThrehold: number;
1185
- panControl: Vector2_2;
1186
- spherical: Spherical;
1187
- sphericalDelta: Spherical;
1188
- orbitPoint: any;
1189
- cameraPoint: Vector3_2;
1190
- panTarget: Vector3_2 | null;
1191
- panOffset: Vector3_2;
1192
- orbitInit: {
1193
- orbitPoint: Vector3_2;
1194
- initialCameraTheta: number;
1195
- initialCameraCylindrical: Cylindrical;
1196
- initialCameraDirectionCylindrical: Cylindrical;
1197
- initialDirectionInOrbitPointSpace: Vector3_2;
1198
- cameraThetaRange: number[];
1199
- directionThetaRange: number[];
1200
- } | null;
1201
- qua: Quaternion;
1202
- moveOffset: Vector3_2;
1203
- lookDir: Vector3_2;
1204
- lookDirOnMouseDown: Vector3_2;
1205
- rotateWithKeys: boolean;
1206
- lookQuaOnMouseDown: Quaternion;
1207
- mouseRotateQua: Quaternion;
1208
- isMoved: boolean;
1209
- modelCenter: Vector3_2;
1210
- gui: {
1211
- navigation: {
1212
- default: {
1213
- keyboardMoveSpeed: number;
1214
- keyboardRotateSpeed: number;
1215
- };
1216
- fly: {
1217
- moveSpeed: number;
1218
- rotateSpeed: number;
1219
- strafeXSpeed: number;
1220
- strafeYSpeed: number;
1221
- };
1222
- orbit: {
1223
- rotateHorizontalSpeed: number;
1224
- rotateVerticalSpeed: number;
1225
- };
1226
- };
1227
- };
1228
- deltaTime: number;
1229
- flyEvent: any;
1230
- strafeEvent: any;
1231
- handleZoom(event: any, zoomSpeed: any): void;
1232
- moveForward(fwdDistance: any, speed: any): any;
1233
- moveBackward(fwdDistance: any, speed: any): number;
1234
- setZoomValue(zoomValue: any, dir1: any): void;
1235
- panLeft(distance: any, objectMatrix: any): void;
1236
- panUp(distance: any, objectMatrix: any): void;
1237
- handlePan(event: any): void;
1238
- moveRight(dir: any): void;
1239
- moveLeft(dir: any): void;
1240
- moveDown(): void;
1241
- moveUp(): void;
1242
- handleMouseDown(): void;
1243
- handleMouseUpDown(event: any): void;
1244
- CalculateAngle(vec1: any, vec2: any, speed: any): any;
1245
- handleStrafe(panDistance: any, speedX: any, speedY: any, clientWidth: any, clientHeight: any): void;
1246
- handleRotate(angle: any): void;
1247
- handleLookAround(angle: any): void;
1248
- handleFly(walkDistance: any, flyRotateSpeed: any, flyMoveSpeed: any, clientWidth: any, clientHeight: any): void;
1249
- rotateOrbitLeft(angle: any): void;
1250
- rotateOrbitUp(angle: any): void;
1251
- handleOrbitRotate(event: any): void;
1252
- GetRotateOffset(offset: any, position: any, target: any, quat: any, quatInverse: any): void;
1253
- handleKeyPress(code: any): void;
1254
- moveXYForward(): void;
1255
- moveXYBackward(): void;
1256
- pitchUp(): void;
1257
- pitchDown(): void;
1258
- yawLeft(): void;
1259
- yawRight(): void;
1260
- handleMeasurementZoom(event: any, orbitPoint: any, zoomSpeed: any): void;
1261
- updateWithState(state: any, event: any): void;
1262
- update(deltaTime: any): void;
1263
- clearOrbit(): void;
1264
- clearMove(): void;
1265
- clearPan(): void;
1266
- SetDirection(dir: any): void;
1267
- }
659
+ declare type Node_2 = Node_3 | Node_4;
1268
660
 
1269
- declare class Node_2 {
661
+ declare class Node_3 {
1270
662
  private pwfNode;
1271
663
  private pwf;
1272
664
  private readonly box3Value;
1273
665
  isFirstObjectValue: boolean;
1274
666
  private _parent?;
1275
667
  constructor(pwfNode: PWFNode, pwf: PWFV1);
1276
- box3(): Node_2['box3Value'];
668
+ box3(): Node_3['box3Value'];
1277
669
  unionBBox(bbox: THREE.Box3): void;
1278
670
  isRoot(): boolean;
1279
671
  offset(): number;
1280
672
  nodeId(): number;
1281
673
  parentOff(): number;
1282
- setParent(node: Node_2): void;
1283
- parent(): Node_2 | undefined;
674
+ setParent(node: Node_3): void;
675
+ parent(): Node_3 | undefined;
1284
676
  numChild(): number;
1285
677
  hasChildren(): boolean;
1286
678
  group(): number;
1287
679
  isSelectable(): boolean;
1288
680
  nodeType(): number;
1289
681
  childOffsets(): Uint32Array;
1290
- children(): (Node_2 | Meshnode_2)[];
1291
- isNode(): this is Node_2;
682
+ children(): (Node_3 | Meshnode_2)[];
683
+ isNode(): this is Node_3;
1292
684
  isMeshnode(): boolean;
1293
685
  isFirstObject(): boolean;
1294
686
  hasMeshnodeChildren(): boolean;
1295
687
  numMeshnodeChildren(): number;
1296
- asObject(): NodeObject;
688
+ asObject(): NodeObject_2;
1297
689
  }
1298
690
 
1299
- declare class Node_3 {
691
+ declare class Node_4 {
1300
692
  private pwfNode;
1301
693
  private pwf;
1302
694
  private readonly box3Value;
1303
695
  isFirstObjectValue: boolean;
1304
696
  private _parent?;
1305
697
  constructor(pwfNode: PWFNode_2, pwf: PWFV2);
1306
- box3(): Node_3['box3Value'];
698
+ box3(): Node_4['box3Value'];
1307
699
  unionBBox(bbox: THREE.Box3): void;
1308
700
  isRoot(): boolean;
1309
701
  offset(): number;
1310
702
  nodeId(): number;
1311
703
  parentOff(): number;
1312
- setParent(node: Node_3): void;
1313
- parent(): Node_3 | undefined;
704
+ setParent(node: Node_4): void;
705
+ parent(): Node_4 | undefined;
1314
706
  numChild(): number;
1315
707
  hasChildren(): boolean;
1316
708
  group(): number;
1317
709
  isSelectable(): boolean;
1318
710
  nodeType(): number;
1319
711
  childOffsets(): Uint32Array;
1320
- children(): (Node_3 | Meshnode_3)[];
1321
- isNode(): this is Node_3;
712
+ children(): (Node_4 | Meshnode_3)[];
713
+ isNode(): this is Node_4;
1322
714
  isMeshnode(): boolean;
1323
715
  isFirstObject(): boolean;
1324
716
  hasMeshnodeChildren(): boolean;
1325
717
  numMeshnodeChildren(): number;
1326
- asObject(): NodeObject_2;
718
+ asObject(): NodeObject;
1327
719
  }
1328
720
 
1329
- declare type Node_4 = Node_2 | Node_3;
1330
-
1331
721
  export declare type NodeBoundingBox = {
1332
722
  min: number[];
1333
723
  max: number[];
1334
724
  };
1335
725
 
1336
- declare type NodeId = ReturnType<Node_4['nodeId']>;
726
+ declare type NodeId = ReturnType<Node_2['nodeId']>;
1337
727
 
1338
728
  declare type NodeObject = {
1339
729
  offset: number;
@@ -1376,24 +766,25 @@ declare class NodeServices {
1376
766
  private _numNodes;
1377
767
  private _pwfNodeOffsetMap;
1378
768
  private _rootNode?;
1379
- constructor(pwfNodes: PWFNode[], meshnodeOffPointer: number, pwf: PWFV1);
1380
- nodeFromOffset(offset: number): Node_2;
769
+ constructor(pwfNodes: PWFNode_2[], meshnodeOffPointer: number, pwf: PWFV2);
770
+ nodeFromOffset(offset: number): Node_4;
1381
771
  buildNodes(): {
772
+ nodes: NodeServices['nodes'];
1382
773
  isComplete: boolean;
1383
774
  };
1384
- root(): Node_2;
1385
- getNode(offset: number): Node_2 | Meshnode_2;
1386
- getNodeById(id: number): Node_2;
775
+ root(): Node_4;
776
+ getNode(offset: number): Node_4 | Meshnode_3;
777
+ getNodeById(id: number): Node_4;
1387
778
  hasNode(id: number): boolean;
1388
- breadthFirstTraversal(callback: (n: Node_2 | Meshnode_2) => void): {
779
+ breadthFirstTraversal(callback: (n: Node_4 | Meshnode_3) => void): {
1389
780
  isComplete: boolean;
1390
781
  };
1391
782
  private buildNodesRecursively;
1392
783
  private buildChildren;
1393
784
  meshnodeOffPointer(): NonNullable<NodeServices['meshnodeOffPointerValue']>;
1394
- findFirstObject(meshnode: Meshnode_2): Node_2;
785
+ findFirstObject(meshnode: Meshnode_3): Node_4;
1395
786
  numNodes(): number;
1396
- allNodes(): Node_2[];
787
+ allNodes(): Node_4[];
1397
788
  numFirstObjects(): number;
1398
789
  }
1399
790
 
@@ -1410,23 +801,22 @@ declare class NodeServices_2 {
1410
801
  private _numNodes;
1411
802
  private _pwfNodeOffsetMap;
1412
803
  private _rootNode?;
1413
- constructor(pwfNodes: PWFNode_2[], meshnodeOffPointer: number, pwf: PWFV2);
804
+ constructor(pwfNodes: PWFNode[], meshnodeOffPointer: number, pwf: PWFV1);
1414
805
  nodeFromOffset(offset: number): Node_3;
1415
806
  buildNodes(): {
1416
- nodes: NodeServices_2['nodes'];
1417
807
  isComplete: boolean;
1418
808
  };
1419
809
  root(): Node_3;
1420
- getNode(offset: number): Node_3 | Meshnode_3;
810
+ getNode(offset: number): Node_3 | Meshnode_2;
1421
811
  getNodeById(id: number): Node_3;
1422
812
  hasNode(id: number): boolean;
1423
- breadthFirstTraversal(callback: (n: Node_3 | Meshnode_3) => void): {
813
+ breadthFirstTraversal(callback: (n: Node_3 | Meshnode_2) => void): {
1424
814
  isComplete: boolean;
1425
815
  };
1426
816
  private buildNodesRecursively;
1427
817
  private buildChildren;
1428
818
  meshnodeOffPointer(): NonNullable<NodeServices_2['meshnodeOffPointerValue']>;
1429
- findFirstObject(meshnode: Meshnode_3): Node_3;
819
+ findFirstObject(meshnode: Meshnode_2): Node_3;
1430
820
  numNodes(): number;
1431
821
  allNodes(): Node_3[];
1432
822
  numFirstObjects(): number;
@@ -1437,49 +827,8 @@ export declare type ObjectFilter = {
1437
827
  filterValue: string;
1438
828
  };
1439
829
 
1440
- declare class ObjectTree {
1441
- pwf: PWF;
1442
- resourceId: number;
1443
- _selectedNodeServices: SelectedNodeServices | null;
1444
- _hiddenNodeServices: HiddenNodeServices | null;
1445
- nodeIds: Set<number>;
1446
- constructor(params: {
1447
- pwf: PWF;
1448
- resourceId: number;
1449
- });
1450
- set hiddenNodeServices(hiddenNodeServices: HiddenNodeServices);
1451
- get hiddenNodeServices(): HiddenNodeServices;
1452
- set selectedNodeServices(selectedNodeServices: SelectedNodeServices);
1453
- get selectedNodeServices(): SelectedNodeServices;
1454
- add: (nodeId: number) => boolean;
1455
- has: (nodeId: number) => boolean;
1456
- getParentInternalNode: (internalNode: InternalNode) => InternalNode | undefined;
1457
- getInternalObjectTreeNode(nodeId: number): InternalNode | undefined;
1458
- getObjectTreeNode(nodeId: number): PublicNode | undefined;
1459
- buildFromPWF: () => {
1460
- isComplete: boolean;
1461
- };
1462
- buildFromNodeIds: (nodeIds: number[]) => {
1463
- nodeIds: number[];
1464
- ancestors: number[];
1465
- children: number[];
1466
- };
1467
- synchronizeSelected: (source: ObjectTree) => void;
1468
- private synchronizeSelectedNodeIds;
1469
- private getSelectedStack;
1470
- private evaluateSelectedState;
1471
- synchronizeHidden: (source: ObjectTree) => void;
1472
- private synchronizeHiddenNodes;
1473
- }
1474
-
1475
830
  export declare type Options = FileExtractionModePwfV2OverrideOptions | FileExtractionModePwfV1OverrideOptions | FileExtractionModeOptions | ModelRevisionModePwfV2Options | ModelRevisionModePwfV1Options | ResourceOptions;
1476
831
 
1477
- declare type OrientedBox = {
1478
- min: Vector3;
1479
- max: Vector3;
1480
- rotation?: Vector3 | null;
1481
- };
1482
-
1483
832
  declare type Palette = {
1484
833
  default?: Color;
1485
834
  xray?: Color;
@@ -1507,7 +856,6 @@ declare class Partition_2 {
1507
856
 
1508
857
  declare class PartitionProxy {
1509
858
  private pwfPartitionProxy;
1510
- private meshServices;
1511
859
  static numberOfPartitions: number;
1512
860
  static numberOfPartitionsLoaded: number;
1513
861
  static currentNumberOfDownloading: number;
@@ -1518,10 +866,7 @@ declare class PartitionProxy {
1518
866
  private _byteLength?;
1519
867
  private _compressedByteLength?;
1520
868
  private stats;
1521
- constructor(params: {
1522
- pwfPartitionProxy: PWFPartitionProxy;
1523
- meshServices: StreamedMeshServices;
1524
- });
869
+ constructor(pwfPartitionProxy: PWFPartitionProxy);
1525
870
  meshCount(): number;
1526
871
  incrementMeshCount(numMeshes: number): void;
1527
872
  vertexCount(): number;
@@ -1539,13 +884,14 @@ declare class PartitionProxy {
1539
884
  compressed: number;
1540
885
  size: number;
1541
886
  };
1542
- static processPartitionProxiesAB(partitionProxiesAB: ArrayBuffer, meshServices: StreamedMeshServices, callback: (partitionProxy: PartitionProxy) => void): void;
887
+ static processPartitionProxiesAB(partitionProxiesAB: ArrayBuffer, callback: (partitionProxy: PartitionProxy) => void): void;
1543
888
  static getPartitionProxies(partitionProxiesAB: ArrayBuffer): PWFPartitionProxy[];
1544
889
  getContentOfPartitionUrl(): string;
1545
890
  }
1546
891
 
1547
892
  declare class PartitionProxy_2 {
1548
893
  private pwfPartitionProxy;
894
+ private meshServices;
1549
895
  static numberOfPartitions: number;
1550
896
  static numberOfPartitionsLoaded: number;
1551
897
  static currentNumberOfDownloading: number;
@@ -1556,7 +902,10 @@ declare class PartitionProxy_2 {
1556
902
  private _byteLength?;
1557
903
  private _compressedByteLength?;
1558
904
  private stats;
1559
- constructor(pwfPartitionProxy: PWFPartitionProxy_2);
905
+ constructor(params: {
906
+ pwfPartitionProxy: PWFPartitionProxy_2;
907
+ meshServices: StreamedMeshServices_2;
908
+ });
1560
909
  meshCount(): number;
1561
910
  incrementMeshCount(numMeshes: number): void;
1562
911
  vertexCount(): number;
@@ -1574,132 +923,11 @@ declare class PartitionProxy_2 {
1574
923
  compressed: number;
1575
924
  size: number;
1576
925
  };
1577
- static processPartitionProxiesAB(partitionProxiesAB: ArrayBuffer, callback: (partitionProxy: PartitionProxy_2) => void): void;
926
+ static processPartitionProxiesAB(partitionProxiesAB: ArrayBuffer, meshServices: StreamedMeshServices_2, callback: (partitionProxy: PartitionProxy_2) => void): void;
1578
927
  static getPartitionProxies(partitionProxiesAB: ArrayBuffer): PWFPartitionProxy_2[];
1579
928
  getContentOfPartitionUrl(): string;
1580
929
  }
1581
930
 
1582
- /**
1583
- * Modified version based on Three WebGlRenderer
1584
- */
1585
- declare function PartitionsRenderer(parameters: any): void;
1586
-
1587
- declare class PartitionsRenderer {
1588
- /**
1589
- * Modified version based on Three WebGlRenderer
1590
- */
1591
- constructor(parameters: any);
1592
- domElement: any;
1593
- context: any;
1594
- textures: any;
1595
- debug: {
1596
- /**
1597
- * Enables error checking and reporting when shader programs are being compiled
1598
- * @type {boolean}
1599
- */
1600
- checkShaderErrors: boolean;
1601
- };
1602
- autoClear: boolean;
1603
- autoClearColor: boolean;
1604
- autoClearDepth: boolean;
1605
- autoClearStencil: boolean;
1606
- sortObjects: boolean;
1607
- clippingPlanes: any[];
1608
- localClippingEnabled: boolean;
1609
- gammaFactor: number;
1610
- gammaInput: boolean;
1611
- gammaOutput: boolean;
1612
- physicallyCorrectLights: boolean;
1613
- toneMapping: ToneMapping;
1614
- toneMappingExposure: number;
1615
- toneMappingWhitePoint: number;
1616
- commonRenderingParams: {
1617
- xRayMode: {
1618
- opacity: number;
1619
- colorMode: string;
1620
- color: string;
1621
- };
1622
- preferences: {
1623
- overrideBackgroundColor: boolean;
1624
- backgroundColor: string;
1625
- };
1626
- };
1627
- refresh: boolean;
1628
- renderingParameters: {
1629
- renderingInMotion: {
1630
- renderCullTreeOpaque: boolean;
1631
- renderCullTreeTransparent: boolean;
1632
- };
1633
- };
1634
- renderingAtRest: boolean;
1635
- initialize: (measureSet: any, models: any, colorServices: any) => void;
1636
- render: (scene: any, camera: any) => void;
1637
- cleanBuffer: () => void;
1638
- setRenderMode: (renderMode: any) => void;
1639
- getRenderMode: () => "shaded";
1640
- getRenderingStage: () => "renderIdle";
1641
- renderSection: (scene: any, camera: any) => void;
1642
- enableBackFaceFillColor: (enable: any) => void;
1643
- loadMeshShader: () => void;
1644
- setDetailsParams: (detailsParams: any) => void;
1645
- setGeometryFactory: (geometryFactory: any) => void;
1646
- renderMeshnode: (meshnode: any, scene: any, camera: any, renderStage: any) => void;
1647
- renderMesh: (scene: any, camera: any, meshGeometry: any, nodedata: any, renderStage: any, isPicked: any, overrideMaterial: any) => void;
1648
- vr: WebXRManager | WebVRManager | null;
1649
- shadowMap: WebGLShadowMap;
1650
- renderBufferImmediate: (object: any, program: any) => void;
1651
- clear: (color: any, depth: any, stencil: any) => void;
1652
- clearColor: () => void;
1653
- clearDepth: () => void;
1654
- dispose: () => void;
1655
- getRenderTarget: () => any;
1656
- getContext: () => any;
1657
- getContextAttributes: () => any;
1658
- getClearAlpha: () => any;
1659
- getClearColor: () => any;
1660
- getPixelRatio: () => number;
1661
- getSize: () => {
1662
- width: any;
1663
- height: any;
1664
- };
1665
- setSize: (width: any, height: any, updateStyle: any) => void;
1666
- setViewport: (x: any, y: any, width: any, height: any) => void;
1667
- setScissorTest: (boolean: any) => void;
1668
- setClearColor: (args: any) => void;
1669
- setClearAlpha: (args: any) => void;
1670
- setAnimationLoop: (callback: any) => void;
1671
- setRenderTarget: (renderTarget: any) => void;
1672
- readRenderTargetPixels: (renderTarget: any, x: any, y: any, width: any, height: any, buffer: any) => void;
1673
- allocTextureUnit: () => number;
1674
- renderBufferDirect: (camera: any, fog: any, geometry: any, material: any, object: any, group: any) => void;
1675
- }
1676
-
1677
- declare class PickingController {
1678
- private renderer;
1679
- private pickingTexture;
1680
- private models;
1681
- private camera;
1682
- private sectionController;
1683
- constructor(params: {
1684
- renderer: ViewerRenderer;
1685
- pickingTexture: THREE.WebGLRenderTarget;
1686
- models: Models;
1687
- camera: THREE.PerspectiveCamera;
1688
- sectionController: SectionController;
1689
- });
1690
- getRayIntersectPoint(params: {
1691
- event: MouseEvent;
1692
- returnOnEdgeHitFailure: 'null' | 'bboxCenter';
1693
- }): {
1694
- intersection: Vector3 | null;
1695
- meshnodeIndex: number;
1696
- faceNormal: Vector3 | null;
1697
- };
1698
- mouseToThreeRay(event: MouseEvent): THREE.Raycaster;
1699
- extractId(event: MouseEvent): number;
1700
- private rayTestMesh;
1701
- }
1702
-
1703
931
  declare type Point = {
1704
932
  position: {
1705
933
  x: number;
@@ -1713,100 +941,12 @@ declare type Point = {
1713
941
  };
1714
942
  };
1715
943
 
1716
- declare class PointToPointController {
1717
- private readonly pickingController;
1718
- private readonly models;
1719
- private readonly camera;
1720
- private currentHoverMeshnodeIndex;
1721
- private readonly meshTopologyCache;
1722
- private _enabled;
1723
- private readonly globalOffset;
1724
- private prevLastWorldIntersectionSnapResult;
1725
- private lastWorldIntersectionSnapResult;
1726
- private readonly debugGui;
1727
- private readonly viewerRenderer;
1728
- constructor(params: {
1729
- pickingController: PickingController;
1730
- models: Models;
1731
- camera: THREE.PerspectiveCamera;
1732
- globalOffset: THREE.Vector3;
1733
- viewerRenderer: ViewerRenderer;
1734
- });
1735
- get enabled(): boolean;
1736
- set enabled(value: boolean);
1737
- handleMouseClick(): void;
1738
- handleMouseMove(event: MouseEvent): void;
1739
- private getWorldIntersectionSnapResult;
1740
- private publishIntersectionSnapResult;
1741
- private getMeshTopology;
1742
- private meshnodeTooComplex;
1743
- private determineHoverState;
1744
- }
1745
-
1746
- declare class PointToPointManager implements MeasurementInterface {
1747
- private readonly svgRenderer;
1748
- private readonly renderControllerProxy;
1749
- private readonly settingsController;
1750
- private readonly measurementRenderer;
1751
- private readonly apiController;
1752
- private firstMeasurePoint;
1753
- private secondMeasurePoint;
1754
- private snapPosition;
1755
- private static pointToPointEnabled;
1756
- private outlines;
1757
- private pivot;
1758
- private readonly gui;
1759
- private globalOffset;
1760
- private temporaryDistanceLabel;
1761
- private camera;
1762
- private readonly locale;
1763
- private cursorTooltip;
1764
- private featureTooltip;
1765
- constructor(params: {
1766
- apiController: ApiController;
1767
- renderControllerProxy: RenderControllerProxy;
1768
- settingsController: SettingsController;
1769
- svgRenderer: SvgRenderer;
1770
- measurementRenderer: MeasurementRenderer;
1771
- locale: string;
1772
- });
1773
- setGlobalOffset(params: Vector3): void;
1774
- getGlobalOffset(): THREE.Vector3;
1775
- getMeasurementProgress(): MeasurementState;
1776
- private onCameraUpdated;
1777
- private onNavigationChanged;
1778
- private onMeasurementObjectMove;
1779
- private updateTemporaryDistanceLabel;
1780
- private onMeasurementObjectLeave;
1781
- private onMeasurementObjectClick;
1782
- resetMeasurement(): void;
1783
- static isEnabled(): boolean;
1784
- toggle(params: {
1785
- enable: boolean;
1786
- }): Promise<void>;
1787
- private clearDisplayElements;
1788
- private removeCursors;
1789
- private setCameraAndNavigationControls;
1790
- private updateSvg;
1791
- }
1792
-
1793
944
  export declare type ProcoreFormatClipPlane = {
1794
945
  unit?: string;
1795
946
  direction: Vector3;
1796
947
  location: Vector3;
1797
948
  };
1798
949
 
1799
- declare type ProcoreRender = any;
1800
-
1801
- declare class ProcoreRenderPass extends Pass {
1802
- scene: THREE.Scene;
1803
- camera: THREE.Camera;
1804
- clearDepth: boolean;
1805
- refresh: boolean;
1806
- constructor(scene: THREE.Scene, camera: THREE.Camera);
1807
- render(renderer: THREE.WebGLRenderer | ProcoreRender, _writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget): void;
1808
- }
1809
-
1810
950
  export declare type Project = {
1811
951
  id: number;
1812
952
  };
@@ -1838,118 +978,6 @@ export declare type PublicNode = {
1838
978
  children: number[];
1839
979
  };
1840
980
 
1841
- declare function PubSubController(): void;
1842
-
1843
- declare class PubSubController {
1844
- subscribe: (evt: any, cb: any) => void;
1845
- unsubscribe: (evt: any, cb: any) => void;
1846
- publish: (evt: any, value: any) => void;
1847
- clear: () => void;
1848
- }
1849
-
1850
- declare namespace PubSubController {
1851
- let EVENTS: Readonly<{
1852
- animate: "animate";
1853
- appResize: "appResize";
1854
- appStart: "appStart";
1855
- bcfCameraSet: "bcfCameraSet";
1856
- browserSettingsReady: "browserSettingsReady";
1857
- cameraUpdated: "cameraUpdated";
1858
- canvasReady: "canvasReady";
1859
- coachmarkHyperlinkClicked: "coachmarkHyperlinkClicked";
1860
- contextMenu: "contextMenu";
1861
- curKeysUpdated: "curKeysUpdated";
1862
- databaseOpened: "databaseOpened";
1863
- doubleClick: "doubleClick";
1864
- downloadComplete: "downloadComplete";
1865
- downloadError: "downloadError";
1866
- downloadStart: "downloadStart";
1867
- drawingMiniClick: "drawingMiniClick";
1868
- drawingNavigated: "drawingNavigated";
1869
- fieldOfViewChanged: "fieldOfViewChanged";
1870
- fileTooBigError: "fileTooBigError";
1871
- floorPlan: "floorPlan";
1872
- getBimFileViewFolders: "getBimFileViewFolders";
1873
- getBimModelRevisionViewpoints: "getBimModelRevisionViewpoints";
1874
- getBimObjectsFor: "getBimObjectsFor";
1875
- getBimPropertiesFor: "getBimPropertiesFor";
1876
- globalBoundingBoxInitialized: "globalBoundingBoxInitialized";
1877
- graphicContextLost: "graphicContextLost";
1878
- hideSimilarCompleted: "hideSimilarCompleted";
1879
- hideUpdated: "hideUpdated";
1880
- homeViewpointActivated: "homeViewpointActivated";
1881
- initializationComplete: "initializationComplete";
1882
- initializationFailed: "initializationFailed";
1883
- initializationProgress: "initializationProgress";
1884
- initializationStart: "initializationStart";
1885
- intersectPointClick: "intersectPointClick";
1886
- isolateCompleted: "isolateCompleted";
1887
- launchedAnimationLoop: "launchedAnimationLoop";
1888
- mainThreadDebugGuiAdd: "mainThreadDebugGuiAdd";
1889
- mainThreadDebugGuiDestroy: "mainThreadDebugGuiDestroy";
1890
- markupDismissed: "markupDismissed";
1891
- markupDisplayed: "markupDisplayed";
1892
- measured: "measured";
1893
- measurementObjectEnter: "measurementObjectEnter";
1894
- measurementObjectLeave: "measurementObjectLeave";
1895
- measurementObjectMove: "measurementObjectMove";
1896
- measurementObjectClick: "measurementObjectClick";
1897
- messages: "messages";
1898
- modelTreeParentInteracted: "modelTreeParentInteracted";
1899
- modelTypeDetermined: "modelTypeDetermined";
1900
- mouseMove: "mouseMove";
1901
- navigationChanged: "navigationChanged";
1902
- navigationMouseDown: "navigationMouseDown";
1903
- navigationMouseUp: "navigationMouseUp";
1904
- navigationUpdated: "navigationUpdated";
1905
- objectDeselect: "objectDeselect";
1906
- objectDoubleClick: "objectDoubleClick";
1907
- objectHide: "objectHide";
1908
- objectMeasure: "objectMeasure";
1909
- objectRightClick: "objectRightClick";
1910
- objectSelect: "objectSelect";
1911
- objectSelectFromModelTree: "objectSelectFromModelTree";
1912
- objectSingleClick: "objectSingleClick";
1913
- objectTreeUpdated: "objectTreeUpdated";
1914
- objectUnhide: "objectUnhide";
1915
- optionsChanged: "optionsChanged";
1916
- allPartitionsDownloadComplete: "allPartitionsDownloadComplete";
1917
- projectSettingsLoaded: "projectSettingsLoaded";
1918
- projectSettingsUpdated: "projectSettingsUpdated";
1919
- propertiesReady: "propertiesReady";
1920
- propertyServiceCheck: "propertyServiceCheck";
1921
- redo: "redo";
1922
- renderModeChanged: "renderModeChanged";
1923
- refreshScene: "refreshScene";
1924
- renderReady: "renderReady";
1925
- rightClick: "rightClick";
1926
- savedViewpointClicked: "savedViewpointClicked";
1927
- sectionBoxDisplayConfigured: "sectionBoxDisplayConfigured";
1928
- sectionBoxDisplayHoverUpdated: "sectionBoxDisplayHoverUpdated";
1929
- sectionBoxDisplayResized: "sectionBoxDisplayResized";
1930
- sectionBoxDisplayToggled: "sectionBoxDisplayToggled";
1931
- measurementToggled: "measurementToggled";
1932
- sectionBoxRemoved: "sectionBoxRemoved";
1933
- sectionBoxSet: "sectionBoxSet";
1934
- sectionPlaneAdded: "sectionPlaneAdded";
1935
- sectionPlaneRemoved: "sectionPlaneRemoved";
1936
- sectionsCleared: "sectionsCleared";
1937
- selectSimilarCompleted: "selectSimilarCompleted";
1938
- selectSimilarStarted: "selectSimilarStarted";
1939
- selectTool: "selectTool";
1940
- selectedUpdated: "selectedUpdated";
1941
- singleClick: "singleClick";
1942
- undo: "undo";
1943
- updatePivot: "updatePivot";
1944
- windowClose: "windowClose";
1945
- windowComponentChanged: "windowComponentChanged";
1946
- windowComponentShouldClose: "windowComponentShouldClose";
1947
- windowComponentShouldOpen: "windowComponentShouldOpen";
1948
- windowComponentTouched: "windowComponentTouched";
1949
- windowOpen: "windowOpen";
1950
- }>;
1951
- }
1952
-
1953
981
  declare interface PWF {
1954
982
  setStandardModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer): void;
1955
983
  setPartitionedModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, partitionAB: ArrayBuffer): void;
@@ -1963,12 +991,12 @@ declare interface PWF {
1963
991
  initNodeTree(): BootstrapperResult;
1964
992
  initNodeTreeBoundingBoxes(): void;
1965
993
  allMeshnodes(): Meshnode[];
1966
- breadthFirstTraversalNodes(callback: (n: Node_4 | Meshnode) => void): BootstrapperResult;
994
+ breadthFirstTraversalNodes(callback: (n: Node_2 | Meshnode) => void): BootstrapperResult;
1967
995
  getMeshnodeFromIndex(meshnodeIndex: number): Meshnode;
1968
996
  getParentNodeIds(nodeId: number): number[];
1969
997
  getSubtreeNodeIds(nodeId: number): number[];
1970
998
  getVirtualMeshnodeIndexesByNodeId(nodeId: number): number[];
1971
- getNamedNode(nodeId: number): Node_4;
999
+ getNamedNode(nodeId: number): Node_2;
1972
1000
  globalOffset(): Vector3;
1973
1001
  getPwfPartitionContentUrls(): string[];
1974
1002
  numNodes(): number;
@@ -1977,15 +1005,15 @@ declare interface PWF {
1977
1005
  prefetchPartitions(geometryFactory: StreamedGeometryFactory): BootstrapperResult;
1978
1006
  setGeometryFactory(geometryFactory: GeometryFactory): void;
1979
1007
  numFirstObjects(): number;
1980
- getNodeById(id: number): Node_4;
1008
+ getNodeById(id: number): Node_2;
1981
1009
  getMeshnodeFromNodeId(nodeId: number): Meshnode;
1982
1010
  getMeshnode(offset: number): Meshnode;
1983
- getNode(offset: number): Node_4 | Meshnode;
1011
+ getNode(offset: number): Node_2 | Meshnode;
1984
1012
  getMeshObject(meshRef: number): MeshObject_3;
1985
- findFirstObject(meshnodeIndex: number): Node_4;
1986
- root(): Node_4;
1013
+ findFirstObject(meshnodeIndex: number): Node_2;
1014
+ root(): Node_2;
1987
1015
  forEachMeshnode(callback: (meshnode: Meshnode) => void): void;
1988
- forEachNode(callback: (node: Node_4) => void): void;
1016
+ forEachNode(callback: (node: Node_2) => void): void;
1989
1017
  hasNode(id: number): boolean;
1990
1018
  loadAllMeshGeometryToGPU(): BootstrapperResult;
1991
1019
  loadAllPartitionProxies(): void;
@@ -1997,18 +1025,6 @@ declare interface PWF {
1997
1025
  dispose(): void;
1998
1026
  }
1999
1027
 
2000
- declare type PWF_2 = PWFV1 | PWFV2;
2001
-
2002
- declare class PWFCache {
2003
- private readonly httpClient;
2004
- private abortController;
2005
- private abortSignal;
2006
- constructor();
2007
- fetchData(url: string, dataType?: 'arrayBuffer' | 'json'): Promise<ArrayBuffer>;
2008
- fetchArrayBuffers(urls: string[]): Promise<ArrayBuffer[]>;
2009
- dispose(): void;
2010
- }
2011
-
2012
1028
  declare interface PWFMesh {
2013
1029
  offset(): number;
2014
1030
  color(): number;
@@ -2064,20 +1080,15 @@ declare class PWFModelParser {
2064
1080
  private meshnodeBufferReader;
2065
1081
  private meshAB;
2066
1082
  private meshBufferReader?;
2067
- constructor(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer);
2068
- getGlobalOffset(): Vector3;
2069
- getMeshnodeOffPointer(): number;
1083
+ constructor(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer, manifest: Manifest);
2070
1084
  parseNodes(): {
2071
- nodes: PWFNode[];
1085
+ nodes: PWFNode_2[];
2072
1086
  isComplete: boolean;
2073
1087
  };
2074
1088
  parseMeshnodes(): {
2075
- meshnodes: PWFMeshnode[];
1089
+ meshnodes: PWFMeshnode_2[];
2076
1090
  isComplete: boolean;
2077
1091
  };
2078
- getNumMeshnodes(): number;
2079
- getNumMeshes(): number;
2080
- getNumNodes(): number;
2081
1092
  parseMeshes(): PWFMesh[];
2082
1093
  }
2083
1094
 
@@ -2088,15 +1099,20 @@ declare class PWFModelParser_2 {
2088
1099
  private meshnodeBufferReader;
2089
1100
  private meshAB;
2090
1101
  private meshBufferReader?;
2091
- constructor(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer, manifest: Manifest_2);
1102
+ constructor(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer);
1103
+ getGlobalOffset(): Vector3;
1104
+ getMeshnodeOffPointer(): number;
2092
1105
  parseNodes(): {
2093
- nodes: PWFNode_2[];
1106
+ nodes: PWFNode[];
2094
1107
  isComplete: boolean;
2095
1108
  };
2096
1109
  parseMeshnodes(): {
2097
- meshnodes: PWFMeshnode_2[];
1110
+ meshnodes: PWFMeshnode[];
2098
1111
  isComplete: boolean;
2099
1112
  };
1113
+ getNumMeshnodes(): number;
1114
+ getNumMeshes(): number;
1115
+ getNumNodes(): number;
2100
1116
  parseMeshes(): PWFMesh_2[];
2101
1117
  }
2102
1118
 
@@ -2148,61 +1164,6 @@ declare interface PWFPartitionProxy_2 {
2148
1164
  meshnodeOffsets(): Uint32Array;
2149
1165
  }
2150
1166
 
2151
- declare class PWFProxy implements PWF {
2152
- pwf: PWF_2;
2153
- constructor(params: {
2154
- manifest: Manifest | undefined;
2155
- downloadMetaData: DownloadMetaData;
2156
- resourceId: number;
2157
- featureFlags: ValidatedFeatureFlags;
2158
- });
2159
- setStandardModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer): void;
2160
- setPartitionedModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, partitionAB: ArrayBuffer): void;
2161
- getPwfPartitionContentUrls(): string[];
2162
- initPwfParser(): void;
2163
- parsePwfNodes(): BootstrapperResult;
2164
- parsePwfMeshnodes(): BootstrapperResult;
2165
- parsePwfMeshes(): void;
2166
- initMeshServices(): BootstrapperResult;
2167
- initNodeServices(): void;
2168
- initMeshnodeServices(): void;
2169
- initNodeTree(): BootstrapperResult;
2170
- initNodeTreeBoundingBoxes(): BootstrapperResult;
2171
- allMeshnodes(): Meshnode[];
2172
- getMeshnodeFromIndex(index: number): Meshnode;
2173
- getParentNodeIds(nodeId: number): number[];
2174
- getNodeById(id: number): Node_4;
2175
- hasNode(id: number): boolean;
2176
- getSubtreeNodeIds(nodeId: number): number[];
2177
- getVirtualMeshnodeIndexesByNodeId(nodeId: number): number[];
2178
- getMeshnodeFromNodeId(nodeId: number): Meshnode;
2179
- getMeshnode(offset: number): Meshnode;
2180
- getNode(offset: number): Node_4 | Meshnode;
2181
- numNodes(): number;
2182
- numMeshnodes(): number;
2183
- numMeshes(): number;
2184
- loadAllMeshGeometryToGPU(): BootstrapperResult;
2185
- loadAllPartitionProxies(): void;
2186
- prefetchPartitions(geometryFactory: StreamedGeometryFactory): BootstrapperResult;
2187
- setGeometryFactory(geometryFactory: GeometryFactory): void;
2188
- globalOffset(): Vector3;
2189
- root(): Node_4;
2190
- forEachNode(callback: (node: Node_4) => void): void;
2191
- forEachMeshnode(callback: (meshnode: Meshnode) => void): void;
2192
- getMeshObject(meshRef: number): MeshObject_3;
2193
- findFirstObject(meshnodeIndex: number): Node_4;
2194
- numFirstObjects(): number;
2195
- breadthFirstTraversalNodes(callback: (n: Node_4 | Meshnode) => void): BootstrapperResult;
2196
- getNamedNode(nodeId: number): Node_4;
2197
- getMeshDataForPartitionedModel(meshnodeIndex: number): Promise<MeshnodeObject_3>;
2198
- captureModelStats(): number;
2199
- getModelAnalyticsData(): ModelAnalyticsData;
2200
- get virtualMeshnodeIndexOffset(): number;
2201
- set virtualMeshnodeIndexOffset(offset: number);
2202
- isPartitionedModel(): boolean;
2203
- dispose(): void;
2204
- }
2205
-
2206
1167
  declare class PWFV1 implements PWF {
2207
1168
  private readonly downloadMetaData;
2208
1169
  resourceId: number;
@@ -2211,7 +1172,7 @@ declare class PWFV1 implements PWF {
2211
1172
  meshnodeAB?: ArrayBuffer;
2212
1173
  meshAB?: ArrayBuffer;
2213
1174
  partitionProxiesAB?: ArrayBuffer;
2214
- pwfModelParser?: PWFModelParser;
1175
+ pwfModelParser?: PWFModelParser_2;
2215
1176
  private _numMeshnodes;
2216
1177
  private _numMeshes;
2217
1178
  private _numNodes;
@@ -2219,18 +1180,18 @@ declare class PWFV1 implements PWF {
2219
1180
  pwfModel: {
2220
1181
  nodes: PWFNode[];
2221
1182
  meshnodes: PWFMeshnode[];
2222
- meshes: PWFMesh[];
1183
+ meshes: PWFMesh_2[];
2223
1184
  };
2224
- meshServices?: MeshServices | StreamedMeshServices;
2225
- nodeServices?: NodeServices;
2226
- meshnodeServices?: MeshnodeServices | StreamedMeshnodeServices;
1185
+ meshServices?: MeshServices_2 | StreamedMeshServices_2;
1186
+ nodeServices?: NodeServices_2;
1187
+ meshnodeServices?: MeshnodeServices_2 | StreamedMeshnodeServices_2;
2227
1188
  bvhTree?: BVHTree;
2228
1189
  _virtualMeshnodeIndexOffset: number;
2229
1190
  private readonly featureFlags;
2230
1191
  loadPartitionPromises: Promise<void>[];
2231
1192
  currentIndex: number;
2232
- partitionProxies: PartitionProxy[];
2233
- partitionsCache: LRUCache<string, Partition>;
1193
+ partitionProxies: PartitionProxy_2[];
1194
+ partitionsCache: LRUCache<string, Partition_2>;
2234
1195
  private meshServicesOPFSInitialized;
2235
1196
  constructor(params: {
2236
1197
  downloadMetaData: DownloadMetaData;
@@ -2252,7 +1213,7 @@ declare class PWFV1 implements PWF {
2252
1213
  allMeshnodes(): Meshnode_2[];
2253
1214
  getMeshnodeFromIndex(index: number): Meshnode_2;
2254
1215
  getParentNodeIds(nodeId: number): number[];
2255
- getNodeById(id: number): Node_2;
1216
+ getNodeById(id: number): Node_3;
2256
1217
  hasNode(id: number): boolean;
2257
1218
  private crawlAndCollectParentNodeIds;
2258
1219
  getSubtreeNodeIds(nodeId: number): number[];
@@ -2261,7 +1222,7 @@ declare class PWFV1 implements PWF {
2261
1222
  private getSubTreeVirtualMeshnodeIndexes;
2262
1223
  getMeshnodeFromNodeId(nodeId: number): Meshnode_2;
2263
1224
  getMeshnode(offset: number): Meshnode_2;
2264
- getNode(offset: number): Node_2 | Meshnode_2;
1225
+ getNode(offset: number): Node_3 | Meshnode_2;
2265
1226
  numNodes(): number;
2266
1227
  numMeshnodes(): number;
2267
1228
  numMeshes(): number;
@@ -2270,14 +1231,14 @@ declare class PWFV1 implements PWF {
2270
1231
  prefetchPartitions(geometryFactory: StreamedGeometryFactory): BootstrapperResult;
2271
1232
  setGeometryFactory(geometryFactory: GeometryFactory): void;
2272
1233
  globalOffset(): Vector3;
2273
- root(): Node_2;
1234
+ root(): Node_3;
2274
1235
  forEachMeshnode(callback: (meshnode: Meshnode_2) => void): void;
2275
- forEachNode(callback: (node: Node_2) => void): void;
1236
+ forEachNode(callback: (node: Node_3) => void): void;
2276
1237
  getMeshObject(meshRef: number): MeshObject;
2277
- findFirstObject(meshnodeIndex: number): Node_2;
1238
+ findFirstObject(meshnodeIndex: number): Node_3;
2278
1239
  numFirstObjects(): number;
2279
- breadthFirstTraversalNodes(callback: (n: Node_2 | Meshnode_2) => void): BootstrapperResult;
2280
- getNamedNode(nodeId: number): Node_2;
1240
+ breadthFirstTraversalNodes(callback: (n: Node_3 | Meshnode_2) => void): BootstrapperResult;
1241
+ getNamedNode(nodeId: number): Node_3;
2281
1242
  getMeshDataForPartitionedModel(meshnodeIndex: number): Promise<MeshnodeObject>;
2282
1243
  captureModelStats(): number;
2283
1244
  private captureStandardModelStats;
@@ -2302,7 +1263,7 @@ declare class PWFV2 implements PWF {
2302
1263
  meshnodeAB?: ArrayBuffer;
2303
1264
  meshAB?: ArrayBuffer;
2304
1265
  partitionProxiesAB?: ArrayBuffer;
2305
- pwfModelParser?: PWFModelParser_2;
1266
+ pwfModelParser?: PWFModelParser;
2306
1267
  private _numMeshnodes;
2307
1268
  private _numMeshes;
2308
1269
  private _numNodes;
@@ -2310,23 +1271,23 @@ declare class PWFV2 implements PWF {
2310
1271
  pwfModel: {
2311
1272
  nodes: PWFNode_2[];
2312
1273
  meshnodes: PWFMeshnode_2[];
2313
- meshes: PWFMesh_2[];
1274
+ meshes: PWFMesh[];
2314
1275
  };
2315
- meshServices?: MeshServices_2 | StreamedMeshServices_2;
2316
- nodeServices?: NodeServices_2;
2317
- meshnodeServices?: MeshnodeServices_2 | StreamedMeshnodeServices_2;
2318
- manifest?: Manifest_2;
1276
+ meshServices?: MeshServices | StreamedMeshServices;
1277
+ nodeServices?: NodeServices;
1278
+ meshnodeServices?: MeshnodeServices | StreamedMeshnodeServices;
1279
+ manifest?: Manifest;
2319
1280
  meshnodeOffPointer: number;
2320
1281
  bvhTree?: BVHTree;
2321
1282
  _virtualMeshnodeIndexOffset: number;
2322
1283
  loadPartitionPromises: Promise<void>[];
2323
1284
  currentIndex: number;
2324
- partitionProxies: PartitionProxy_2[];
2325
- partitionsCache: LRUCache<string, Partition_2>;
1285
+ partitionProxies: PartitionProxy[];
1286
+ partitionsCache: LRUCache<string, Partition>;
2326
1287
  constructor(params: {
2327
1288
  downloadMetaData: DownloadMetaData;
2328
1289
  resourceId: number;
2329
- manifest: Manifest_2;
1290
+ manifest: Manifest;
2330
1291
  });
2331
1292
  setStandardModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer): void;
2332
1293
  setPartitionedModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, partitionProxiesAB: ArrayBuffer): void;
@@ -2343,7 +1304,7 @@ declare class PWFV2 implements PWF {
2343
1304
  allMeshnodes(): Meshnode_3[];
2344
1305
  getMeshnodeFromIndex(index: number): Meshnode_3;
2345
1306
  getParentNodeIds(nodeId: number): number[];
2346
- getNodeById(id: number): Node_3;
1307
+ getNodeById(id: number): Node_4;
2347
1308
  hasNode(id: number): boolean;
2348
1309
  private crawlAndCollectParentNodeIds;
2349
1310
  getSubtreeNodeIds(nodeId: number): number[];
@@ -2352,7 +1313,7 @@ declare class PWFV2 implements PWF {
2352
1313
  private getSubTreeVirtualMeshnodeIndexes;
2353
1314
  getMeshnodeFromNodeId(nodeId: number): Meshnode_3;
2354
1315
  getMeshnode(offset: number): Meshnode_3;
2355
- getNode(offset: number): Node_3 | Meshnode_3;
1316
+ getNode(offset: number): Node_4 | Meshnode_3;
2356
1317
  numNodes(): number;
2357
1318
  numMeshnodes(): number;
2358
1319
  numMeshes(): number;
@@ -2361,14 +1322,14 @@ declare class PWFV2 implements PWF {
2361
1322
  prefetchPartitions(geometryFactory: StreamedGeometryFactory): BootstrapperResult;
2362
1323
  setGeometryFactory(geometryFactory: GeometryFactory): void;
2363
1324
  globalOffset(): Vector3;
2364
- root(): Node_3;
1325
+ root(): Node_4;
2365
1326
  forEachMeshnode(callback: (meshnode: Meshnode_3) => void): void;
2366
- forEachNode(callback: (node: Node_3) => void): void;
1327
+ forEachNode(callback: (node: Node_4) => void): void;
2367
1328
  getMeshObject(meshRef: number): MeshObject_2;
2368
- findFirstObject(meshnodeIndex: number): Node_3;
1329
+ findFirstObject(meshnodeIndex: number): Node_4;
2369
1330
  numFirstObjects(): number;
2370
- breadthFirstTraversalNodes(callback: (n: Node_3 | Meshnode_3) => void): BootstrapperResult;
2371
- getNamedNode(nodeId: number): Node_3;
1331
+ breadthFirstTraversalNodes(callback: (n: Node_4 | Meshnode_3) => void): BootstrapperResult;
1332
+ getNamedNode(nodeId: number): Node_4;
2372
1333
  getMeshDataForPartitionedModel(meshnodeIndex: number): Promise<MeshnodeObject_2>;
2373
1334
  captureModelStats(): number;
2374
1335
  private captureStandardModelStats;
@@ -2388,882 +1349,15 @@ export declare type PwfV2Bundle = {
2388
1349
 
2389
1350
  declare type PWFVersion = `${number}.${number}`;
2390
1351
 
2391
- declare type RadiusEllipse = {
2392
- center: Vector2;
2393
- radius: Vector2;
2394
- stroke: CssColor;
2395
- fill?: CssColor;
2396
- strokeWidth: number;
2397
- zIndex?: number;
2398
- };
2399
-
2400
- declare type Rect = {
2401
- width: number;
2402
- height: number;
2403
- x: number;
2404
- y: number;
2405
- radius?: Vector2;
2406
- fill?: CssColor;
2407
- stroke?: CssColor;
2408
- strokeWidth?: number;
2409
- zIndex?: number;
2410
- };
2411
-
2412
1352
  export declare const RENDER_MODE: {
2413
1353
  readonly SHADED: "shaded";
2414
1354
  readonly XRAY: "xray";
2415
1355
  };
2416
1356
 
2417
- declare function RenderController(params: any): void;
2418
-
2419
- declare class RenderController {
2420
- constructor(params: any);
2421
- params: any;
2422
- logInitializationTimes: any;
2423
- cameras: {
2424
- default: PerspectiveCamera;
2425
- global: PerspectiveCamera;
2426
- old: {
2427
- position: Vector3_2;
2428
- rotation: Vector3_2;
2429
- };
2430
- };
2431
- scenes: {
2432
- default: Scene;
2433
- };
2434
- controls: any;
2435
- frameId: number | null;
2436
- measureEnabled: boolean;
2437
- canvasSelectionEnabled: boolean;
2438
- globalOffset: Vector3 | null;
2439
- clock: Clock;
2440
- delta: number;
2441
- webengine: InitOutput | null;
2442
- webenginePromise: Promise<InitOutput>;
2443
- enableWebWorker: any;
2444
- prefetchingPartitions: boolean;
2445
- projectId: any;
2446
- baseUrl: any;
2447
- meshnodeABCached: boolean;
2448
- nodeABCached: boolean;
2449
- meshABCached: boolean;
2450
- trackingController: StatusTrackingController;
2451
- zoomExtentsParams: {
2452
- zoomExtents: {
2453
- zenith: number;
2454
- azimuth: number;
2455
- distanceFromCenterFactor: number;
2456
- };
2457
- };
2458
- zoomToGlobalParams: {
2459
- spaceJunkEliminationThreshold: number;
2460
- };
2461
- initCanvas(): void;
2462
- streaming: boolean | undefined;
2463
- viewerRenderer: ViewerRenderer | undefined;
2464
- textures: {
2465
- picking: WebGLRenderTarget;
2466
- } | undefined;
2467
- section: SectionController | undefined;
2468
- composer: EffectComposer | undefined;
2469
- procoreRenderPass: ProcoreRenderPass | undefined;
2470
- sectionRenderPass: SectionRenderPass | undefined;
2471
- pickingController: PickingController | undefined;
2472
- initWasm(): Promise<void>;
2473
- parsePwfNodes(): BootstrapperResult;
2474
- parsePwfMeshnodes(): BootstrapperResult;
2475
- parsePwfMeshes(): void;
2476
- initMeshServices(): BootstrapperResult;
2477
- initNodeServices(): void;
2478
- initMeshnodeServices(): void;
2479
- initNodeTree(): BootstrapperResult;
2480
- initNodeTreeBoundingBoxes(): BootstrapperResult;
2481
- initSceneGraph(): BootstrapperResult;
2482
- initGlobalOffset(): void;
2483
- pointToPointController: PointToPointController | undefined;
2484
- initGeometryFactory(): void;
2485
- initTreeServices(): BootstrapperResult;
2486
- initViewerRenderer(): void;
2487
- initGeometry(): BootstrapperResult;
2488
- initGlobalBoundingBox(): void;
2489
- initNavigationModel(): void;
2490
- navigationModel: NavigationModel | undefined;
2491
- initLightingAndShader(): void;
2492
- light: {
2493
- default: DirectionalLight;
2494
- ambient: AmbientLight;
2495
- } | null | undefined;
2496
- getInitEventPayload(params: any): ModelInitializationPayload;
2497
- launchAnimationLoop(): void;
2498
- waitTillRenderStage(params: any): Promise<any>;
2499
- captureModelStats(): void;
2500
- init(modelDescriptors: any, downloadMetaData: any): Promise<void>;
2501
- meshnodeAB: any;
2502
- nodeAB: any;
2503
- meshAB: any;
2504
- manifest: any;
2505
- sceneGraphName: any;
2506
- downloadMetaData: any;
2507
- modelDescriptors: any;
2508
- locale: any;
2509
- models: Models | undefined;
2510
- firstModelResourceId: number | undefined;
2511
- pwf: PWFProxy | undefined;
2512
- shortestDistanceController: ShortestDistanceController | undefined;
2513
- colorServices: ColorServices | undefined;
2514
- onUpdateWithState(data: any): void;
2515
- close(): boolean;
2516
- renderer: any;
2517
- animate(): void;
2518
- getCameraDirection(): {
2519
- x: number;
2520
- y: number;
2521
- z: number;
2522
- };
2523
- getPosition(params?: {
2524
- applyOffset: boolean;
2525
- }): {
2526
- x: number;
2527
- y: number;
2528
- z: number;
2529
- };
2530
- setMeshnodeColor(params: any): void;
2531
- setNodeColor(palettes: any, options: any): void;
2532
- clearNodeColor(nodeIds: any, options: any): void;
2533
- clearAllNodeColor(options: any): void;
2534
- setLookAt(params: any): {
2535
- direction: {
2536
- x: number;
2537
- y: number;
2538
- z: number;
2539
- };
2540
- position: {
2541
- x: number;
2542
- y: number;
2543
- z: number;
2544
- };
2545
- };
2546
- getLookAt(params?: {}): {
2547
- x: number;
2548
- y: number;
2549
- z: number;
2550
- };
2551
- getBenchmarkPoint(): {
2552
- position: {
2553
- x: number;
2554
- y: number;
2555
- z: number;
2556
- };
2557
- lookAt: {
2558
- x: number;
2559
- y: number;
2560
- z: number;
2561
- };
2562
- };
2563
- setBenchmarkPoint(params: any): void;
2564
- setPosition(params: any): {
2565
- direction: {
2566
- x: number;
2567
- y: number;
2568
- z: number;
2569
- };
2570
- position: {
2571
- x: number;
2572
- y: number;
2573
- z: number;
2574
- };
2575
- };
2576
- getModelItemBoundary(id: any): Box3;
2577
- getGlobalOffset(): Vector3 | null;
2578
- getMeshnodeFromNodeId(nodeId: any): Meshnode | null;
2579
- getMeshnodeFromIndex(id: any): Meshnode | null;
2580
- getMeasureObjectMeshes(): MeshnodeObject_3[];
2581
- getCamera(): PerspectiveCamera;
2582
- getRenderer(): ViewerRenderer | undefined;
2583
- resizeScene(params: any): void;
2584
- getContextMenuData(evt: any): {
2585
- intersection: Vector3 | null;
2586
- meshnodeIndex: number;
2587
- faceNormal: Vector3 | null;
2588
- } | {
2589
- meshnodeIndex: number;
2590
- };
2591
- onContextMenu(evt: any): void;
2592
- isSectionBlockingClick(): boolean;
2593
- getIntersectionAndMeshnodeIndex(evt: any): {
2594
- intersection: Vector3 | null;
2595
- meshnodeIndex: number;
2596
- faceNormal: Vector3 | null;
2597
- };
2598
- isMeshnodeSelected(virtualMeshnodeIndex: any): boolean;
2599
- clickedOnSelectedObject(virtualMeshnodeIndex: any, rightClick: any): void;
2600
- clickedOnUnselectedObject(virtualMeshnodeIndex: any, rightClick: any): void;
2601
- handleObjectSelection(meshnodeIndex: any, rightClick: any): void;
2602
- handleEmptySpaceClick(): void;
2603
- onSingleClick(evt: any, rightClick?: boolean): void;
2604
- onMouseMove(evt: any): void;
2605
- setCanvasSelectionEnabled(enabled: any): void;
2606
- getSelectedSubtree(meshnodeIndex: any): {
2607
- objectId: number;
2608
- selectionContainerId: number | undefined;
2609
- ancestry: {
2610
- children: (PublicNode | undefined)[];
2611
- id?: number | undefined;
2612
- bbox?: NodeBoundingBox | undefined;
2613
- nodeType?: number | undefined;
2614
- hidden?: boolean | undefined;
2615
- selected?: boolean | undefined;
2616
- partiallySelected?: boolean | undefined;
2617
- parentId?: number;
2618
- }[];
2619
- };
2620
- onDoubleClick(evt: any): void;
2621
- onRightClick(evt: any): void;
2622
- hideSelected(params?: {}): void;
2623
- unhideNodeFromNodeIds(params: any): boolean;
2624
- hideNodesFromNodeIds(params?: {}): boolean;
2625
- getHiddenNodeIds(params?: {}): number[];
2626
- getHiddenMeshnodeIndices(params?: {}): number[];
2627
- getHiddenGeoIdsSet(params?: {}): Set<number>;
2628
- addHiddenMeshnodeIndices(arr: any, resourceId?: any): void;
2629
- setVisibility(params: any): void;
2630
- getVisibility(params: any): Visibility;
2631
- getZoomInterSectPoint(evt: any): {
2632
- x: number;
2633
- y: number;
2634
- z: number;
2635
- };
2636
- ToScreenPosition(params: any): Vector3 | Vector3[];
2637
- ConvertScreenPosition(vector: any): {
2638
- x: any;
2639
- y: any;
2640
- z: any;
2641
- };
2642
- ModelToMapSpace(params: any): {
2643
- x?: undefined;
2644
- y?: undefined;
2645
- dir_x?: undefined;
2646
- dir_y?: undefined;
2647
- } | {
2648
- x: number;
2649
- y: number;
2650
- dir_x: number;
2651
- dir_y: number;
2652
- };
2653
- MapToModelSpace(params: any): {
2654
- x?: undefined;
2655
- y?: undefined;
2656
- dir_x?: undefined;
2657
- dir_y?: undefined;
2658
- } | {
2659
- x: number;
2660
- y: number;
2661
- dir_x: number;
2662
- dir_y: number;
2663
- };
2664
- setBcfCamera(params: any): false | {
2665
- perspective_camera: {
2666
- camera_view_point: {
2667
- x: number;
2668
- y: number;
2669
- z: number;
2670
- };
2671
- camera_direction: {
2672
- x: number;
2673
- y: number;
2674
- z: number;
2675
- };
2676
- camera_up_vector: {
2677
- x: number;
2678
- y: number;
2679
- z: number;
2680
- };
2681
- field_of_view: number;
2682
- target_distance: number;
2683
- unit: string;
2684
- };
2685
- };
2686
- setCameraRotation(params: any): void;
2687
- sanitizeFieldOfView(fov: any): any;
2688
- getBcfCamera(params?: {
2689
- applyOffset: boolean;
2690
- }): {
2691
- perspective_camera: {
2692
- camera_view_point: {
2693
- x: number;
2694
- y: number;
2695
- z: number;
2696
- };
2697
- camera_direction: {
2698
- x: number;
2699
- y: number;
2700
- z: number;
2701
- };
2702
- camera_up_vector: {
2703
- x: number;
2704
- y: number;
2705
- z: number;
2706
- };
2707
- field_of_view: number;
2708
- target_distance: number;
2709
- unit: string;
2710
- };
2711
- };
2712
- refreshScene(): void;
2713
- setHiddenSet(params: any): void;
2714
- refreshLighting(): void;
2715
- setSectionBox(params: any): void;
2716
- setSectionsData(params: any): boolean;
2717
- removeSectionBox(): void;
2718
- addSectionPlane(params: any): void;
2719
- removeSectionPlane(uuid: any): void;
2720
- getSections(format: any): SectionDataProcoreFormat | SectionDataAutodeskFormat | null;
2721
- clearSection(): void;
2722
- setOptions(options: any): void;
2723
- findFirstObject(params: any): PublicNode | undefined;
2724
- getNamedNode(nodeId: any, options?: {}): PublicNode | undefined;
2725
- setEulerAngles(params: any): void;
2726
- statusChange(type: any): void;
2727
- onUndo(): void;
2728
- onRedo(): void;
2729
- getOrbitTranslate(event: any): {
2730
- translate: Vector3 | Vector3[];
2731
- orbitPoint: Vector3;
2732
- };
2733
- setMeasureEnabled(enabled: any): void;
2734
- getMeasureEnabled(): boolean;
2735
- getMeasureIds(): number[];
2736
- removeMeasureIds(measureIds: any): void;
2737
- clearMeasureIds(): void;
2738
- hasHiddenMeshnodeIndices(ids: any, options?: {}): boolean;
2739
- clearHidden(options?: {}): boolean;
2740
- getSelectedMeshnodeIndices(options?: {}): number[];
2741
- addSelectedMeshnodeIndices(ids: any, options?: {}): boolean;
2742
- clearAndSelectNode(nodeId: any, options?: {}): void;
2743
- clearAndSelectNodes(params: any): void;
2744
- getNode(params: any): PublicNode | undefined;
2745
- getNodes(params: any): any;
2746
- getRootNode(params?: {}): PublicNode | undefined;
2747
- setNodesSelected(params: any): boolean;
2748
- hasSelectedMeshnodeIndices(ids: any, options?: {}): boolean;
2749
- clearSelected(params?: {}): boolean;
2750
- getFieldOfView(): number;
2751
- setFieldOfView(deg: any): void;
2752
- setPose(params: any): void;
2753
- zoomToGlobal(): void;
2754
- zoomToBoundingBox(bbox: any): void;
2755
- getBoundingBoxByMeshnodeIndices(params: any): any;
2756
- zoomToSelection(options?: {}): void;
2757
- isolateSelection(options?: {}): void;
2758
- isolateSelectionInSectionBox(options?: {}): void;
2759
- zoomToNodes(nodeIds: any): void;
2760
- getNumNodesSelected(params?: {}): {
2761
- count: number;
2762
- };
2763
- getNumNodesHidden(options?: {}): {
2764
- count: number;
2765
- };
2766
- setRenderMode(renderMode: any, origin: any): void;
2767
- getRenderMode(): string;
2768
- getSelectedNodeIds(params?: {}): number[];
2769
- toggleSectionBoxDisplay(enable: any): void;
2770
- togglePointToPoint(enabled: any): void;
2771
- getSectionBoxDisplayBbox(): BoundingBox;
2772
- getSectionsAsBox(): OrientedBox | null;
2773
- zoomToSectionBox(): void;
2774
- resetSectionBox(): void;
2775
- setSectionBoxHidden(hide: any): void;
2776
- updateSectionHover(event: any): void;
2777
- clearSectionHover(): void;
2778
- isSectionBoxHovered(): boolean;
2779
- resizeSectionBox(xyDelta: any): void;
2780
- onSectionMouseDown(): void;
2781
- hideUpdated(): void;
2782
- constructObjectTreeFromNodeIds(nodeIds: any, options?: {}): {
2783
- nodeIds: number[];
2784
- ancestors: number[];
2785
- children: number[];
2786
- };
2787
- clearFilteredObjectTree(params?: {}): void;
2788
- getObjectTree(resourceId?: any, objectTreeName?: string): ObjectTree | undefined;
2789
- syncObjectTreesWithHidden(params: any): void;
2790
- syncObjectTreesWithSelected({ resourceId, sourceObjectTreeName, destinationObjectTreeName, }: {
2791
- resourceId: any;
2792
- sourceObjectTreeName: any;
2793
- destinationObjectTreeName: any;
2794
- }): void;
2795
- validateObjectTree(resourceId: any, objectTreeName: any): boolean;
2796
- isPartitionedModel(): boolean;
2797
- setPwfFileCacheState(states: any): void;
2798
- getPwfFileCacheState(): {
2799
- meshnodeABCached: boolean;
2800
- nodeABCached: boolean;
2801
- meshABCached: boolean;
2802
- };
2803
- getPwfPartitionContentUrls(params?: {}): string[];
2804
- getNumMeshes(params?: {}): number;
2805
- getNumMeshnodes(params?: {}): number;
2806
- getNumNodes(params?: {}): number;
2807
- getMeasureObjectMeshesPartition(): Promise<MeshnodeObject_3[]>;
2808
- }
2809
-
2810
- declare namespace RenderController {
2811
- namespace NullSelectedSubtree {
2812
- let objectId: number;
2813
- let selectionContainerId: number;
2814
- let ancestry: never[];
2815
- }
2816
- function createCameras(options: any): {
2817
- default: PerspectiveCamera;
2818
- global: PerspectiveCamera;
2819
- old: {
2820
- position: Vector3_2;
2821
- rotation: Vector3_2;
2822
- };
2823
- };
2824
- function createScenes(options: any, cameras: any): {
2825
- default: Scene;
2826
- };
2827
- function createLighting(cameras: any, scenes: any): {
2828
- default: DirectionalLight;
2829
- ambient: AmbientLight;
2830
- };
2831
- function createTextures(renderer: any): {
2832
- picking: WebGLRenderTarget;
2833
- };
2834
- function sanitizeOptions(options: any): any;
2835
- }
2836
-
2837
- declare function RenderControllerProxy(options: any): void;
2838
-
2839
- declare class RenderControllerProxy {
2840
- constructor(options: any);
2841
- cache: Promise<Cache>;
2842
- pubsub: PubSubController;
2843
- options: any;
2844
- worker: any;
2845
- enableWebWorker: any;
2846
- navigationManager: NavigationManager;
2847
- hotkeys: Hotkeys;
2848
- renderController: RenderController | RenderControllerWorker | null;
2849
- pwfCache: PWFCache | null;
2850
- renderControllerParams: {
2851
- canvas: HTMLElement | null;
2852
- debug: any;
2853
- sceneGraph: any;
2854
- selection: any;
2855
- min_boundary: any;
2856
- max_boundary: any;
2857
- rotation: any;
2858
- offsetWidth: any;
2859
- offsetHeight: any;
2860
- offsetTop: any;
2861
- offsetLeft: any;
2862
- multiselect: any;
2863
- locale: any;
2864
- enableWebWorker: any;
2865
- logInitializationTimes: any;
2866
- projectId: any;
2867
- baseUrl: any;
2868
- featureFlags: any;
2869
- nodeUrl: any;
2870
- meshnodeUrl: any;
2871
- meshUrl: any;
2872
- manifestUrl: any;
2873
- fileExtractionId: any;
2874
- modelId: any;
2875
- modelRevisionId: any;
2876
- resources: any;
2877
- companyId: any;
2878
- accessToken: any;
2879
- };
2880
- processPWFArrayBuffers: (modelDescriptors: any) => void;
2881
- messageToEvent: {
2882
- 'Error: Download exception.': "downloadError";
2883
- 'Error: File size exception.': "fileTooBigError";
2884
- };
2885
- handleDownloadError: (message: any) => void;
2886
- downloadMetaData: {
2887
- timeToDownload: number;
2888
- modelCached: boolean;
2889
- };
2890
- navmode: any;
2891
- globalOffset: any;
2892
- createRenderController(): void;
2893
- onUpdateWithState(data: any): void | Promise<any> | undefined;
2894
- close(): void;
2895
- cameras: any;
2896
- setNavigationMode(...params: any[]): void;
2897
- waitTillRenderStage(...params: any[]): Promise<any>;
2898
- getCameraDirection(...params: any[]): Promise<any> | {
2899
- x: number;
2900
- y: number;
2901
- z: number;
2902
- };
2903
- getPosition(...params: any[]): Promise<any> | {
2904
- x: number;
2905
- y: number;
2906
- z: number;
2907
- };
2908
- getLookAt(...params: any[]): Promise<any> | {
2909
- x: number;
2910
- y: number;
2911
- z: number;
2912
- };
2913
- getBenchmarkPoint(...params: any[]): Promise<any> | {
2914
- position: {
2915
- x: number;
2916
- y: number;
2917
- z: number;
2918
- };
2919
- lookAt: {
2920
- x: number;
2921
- y: number;
2922
- z: number;
2923
- };
2924
- };
2925
- setBenchmarkPoint(...params: any[]): void | Promise<any>;
2926
- setNodeColor(...params: any[]): void;
2927
- clearNodeColor(...params: any[]): void;
2928
- clearAllNodeColor(...params: any[]): void;
2929
- setMeshnodeColor(...params: any[]): void;
2930
- setLookAt(...params: any[]): Promise<any> | {
2931
- direction: {
2932
- x: number;
2933
- y: number;
2934
- z: number;
2935
- };
2936
- position: {
2937
- x: number;
2938
- y: number;
2939
- z: number;
2940
- };
2941
- };
2942
- setPosition(...params: any[]): Promise<any> | {
2943
- direction: {
2944
- x: number;
2945
- y: number;
2946
- z: number;
2947
- };
2948
- position: {
2949
- x: number;
2950
- y: number;
2951
- z: number;
2952
- };
2953
- };
2954
- setCameraRotation(...params: any[]): void | Promise<any>;
2955
- getGlobalOffset(...params: any[]): Promise<any> | Vector3 | null;
2956
- getMeshnodeFromNodeId(...params: any[]): Promise<any> | Meshnode | null;
2957
- unhideNodeFromNodeIds(...params: any[]): boolean | Promise<any>;
2958
- hideNodesFromNodeIds(...params: any[]): boolean | Promise<any>;
2959
- onResize(...params: any[]): void;
2960
- getMeshnodeFromIndex(...params: any[]): Promise<any> | Meshnode | null;
2961
- getMeasureObjectMeshes(...params: any[]): Promise<any> | MeshnodeObject_3[];
2962
- onContextMenu(...params: any[]): void | Promise<any>;
2963
- getContextMenuData(...params: any[]): Promise<any> | {
2964
- meshnodeIndex: number;
2965
- };
2966
- onSingleClick(...params: any[]): void | Promise<any>;
2967
- onMouseMove(...params: any[]): void | Promise<any>;
2968
- resizeScene(...params: any[]): void;
2969
- onDoubleClick(...params: any[]): void | Promise<any>;
2970
- onRightClick(...params: any[]): void | Promise<any>;
2971
- getNumNodesHidden(...params: any[]): Promise<any> | {
2972
- count: number;
2973
- };
2974
- hideSelected(...params: any[]): void;
2975
- hideNodeOffset(...params: any[]): any;
2976
- getHiddenNodeIds(...params: any[]): Promise<any> | number[];
2977
- getHiddenMeshnodeIndices(...params: any[]): Promise<any> | number[];
2978
- getHiddenGeoIdsSet(...params: any[]): Promise<any> | Set<number>;
2979
- addHiddenMeshnodeIndices(...params: any[]): void | Promise<any>;
2980
- removeHiddenGeoIds(...params: any[]): any;
2981
- setVisibility(...params: any[]): void | Promise<any>;
2982
- getVisibility(...params: any[]): Promise<any> | Visibility;
2983
- getOrbitTranslate(...params: any[]): Promise<any> | {
2984
- translate: Vector3 | Vector3[];
2985
- orbitPoint: Vector3;
2986
- };
2987
- ToScreenPosition(...params: any[]): Promise<any> | Vector3 | Vector3[];
2988
- ModelToMapSpace(...params: any[]): Promise<any> | {
2989
- x?: undefined;
2990
- y?: undefined;
2991
- dir_x?: undefined;
2992
- dir_y?: undefined;
2993
- } | {
2994
- x: number;
2995
- y: number;
2996
- dir_x: number;
2997
- dir_y: number;
2998
- };
2999
- MapToModelSpace(...params: any[]): Promise<any> | {
3000
- x?: undefined;
3001
- y?: undefined;
3002
- dir_x?: undefined;
3003
- dir_y?: undefined;
3004
- } | {
3005
- x: number;
3006
- y: number;
3007
- dir_x: number;
3008
- dir_y: number;
3009
- };
3010
- setBcfCamera(...params: any[]): false | Promise<any> | {
3011
- perspective_camera: {
3012
- camera_view_point: {
3013
- x: number;
3014
- y: number;
3015
- z: number;
3016
- };
3017
- camera_direction: {
3018
- x: number;
3019
- y: number;
3020
- z: number;
3021
- };
3022
- camera_up_vector: {
3023
- x: number;
3024
- y: number;
3025
- z: number;
3026
- };
3027
- field_of_view: number;
3028
- target_distance: number;
3029
- unit: string;
3030
- };
3031
- };
3032
- getBcfCamera(...params: any[]): Promise<any> | {
3033
- perspective_camera: {
3034
- camera_view_point: {
3035
- x: number;
3036
- y: number;
3037
- z: number;
3038
- };
3039
- camera_direction: {
3040
- x: number;
3041
- y: number;
3042
- z: number;
3043
- };
3044
- camera_up_vector: {
3045
- x: number;
3046
- y: number;
3047
- z: number;
3048
- };
3049
- field_of_view: number;
3050
- target_distance: number;
3051
- unit: string;
3052
- };
3053
- };
3054
- refreshScene(...params: any[]): void;
3055
- refreshLighting(...params: any[]): void;
3056
- setSectionBox(...params: any[]): void | Promise<any>;
3057
- setSectionsData(...params: any[]): boolean | Promise<any>;
3058
- removeSectionBox(...params: any[]): void;
3059
- addSectionPlane(...params: any[]): void;
3060
- removeSectionPlane(...params: any[]): void;
3061
- getSections(...params: any[]): Promise<any> | SectionDataProcoreFormat | SectionDataAutodeskFormat | null;
3062
- clearSection(...params: any[]): void | Promise<any>;
3063
- setOptions(options: any): void;
3064
- setCanvasSelectionEnabled(...params: any[]): void;
3065
- findFirstObject(...params: any[]): Promise<any> | PublicNode | undefined;
3066
- getNamedNode(...params: any[]): Promise<any> | PublicNode | undefined;
3067
- setEulerAngles(...params: any[]): void | Promise<any>;
3068
- setMeasureEnabled(...params: any[]): void | Promise<any>;
3069
- statusChange(...params: any[]): void | Promise<any>;
3070
- onUndo(...params: any[]): void | Promise<any>;
3071
- getMeasureEnabled(...params: any[]): boolean | Promise<any>;
3072
- getMeasureIds(...params: any[]): Promise<any> | number[];
3073
- removeMeasureIds(...params: any[]): void | Promise<any>;
3074
- onRedo(...params: any[]): void | Promise<any>;
3075
- clearMeasureIds(...params: any[]): void | Promise<any>;
3076
- clearHidden(...params: any[]): boolean | Promise<any>;
3077
- hasHiddenMeshnodeIndices(...params: any[]): boolean | Promise<any>;
3078
- addSelectedMeshnodeIndices(...params: any[]): boolean | Promise<any>;
3079
- clearAndSelectNode(...params: any[]): void | Promise<any>;
3080
- clearAndSelectNodes(...params: any[]): void | Promise<any>;
3081
- getNode(...params: any[]): Promise<any> | PublicNode | undefined;
3082
- getNodes(...params: any[]): any;
3083
- setNodesSelected(...params: any[]): boolean | Promise<any>;
3084
- getRootNode(...params: any[]): Promise<any> | PublicNode | undefined;
3085
- getSelectedMeshnodeIndices(...params: any[]): Promise<any> | number[];
3086
- hasSelectedMeshnodeIndices(...params: any[]): boolean | Promise<any>;
3087
- clearSelected(...params: any[]): boolean | Promise<any>;
3088
- getFieldOfView(...params: any[]): number | Promise<any>;
3089
- setFieldOfView(...params: any[]): void | Promise<any>;
3090
- zoomToBoundingBox(...params: any[]): void | Promise<any>;
3091
- setPose(...params: any[]): void | Promise<any>;
3092
- zoomToGlobal(...params: any[]): void | Promise<any>;
3093
- zoomToSelection(...params: any[]): void | Promise<any>;
3094
- isolateSelectionInSectionBox(...params: any[]): void | Promise<any>;
3095
- isolateSelection(...params: any[]): void | Promise<any>;
3096
- zoomToNodes(...params: any[]): void | Promise<any>;
3097
- getNumNodesSelected(...params: any[]): Promise<any> | {
3098
- count: number;
3099
- };
3100
- setRenderMode(...params: any[]): void;
3101
- getRenderMode(...params: any[]): string | Promise<any>;
3102
- getSelectedNodeIds(...params: any[]): Promise<any> | number[];
3103
- toggleSectionBoxDisplay(...params: any[]): void | Promise<any>;
3104
- togglePointToPoint(...params: any[]): void | Promise<any>;
3105
- zoomToSectionBox(...params: any[]): void | Promise<any>;
3106
- setSectionBoxHidden(...params: any[]): void | Promise<any>;
3107
- resetSectionBox(...params: any[]): void | Promise<any>;
3108
- constructObjectTreeFromNodeIds(...params: any[]): Promise<any> | {
3109
- nodeIds: number[];
3110
- ancestors: number[];
3111
- children: number[];
3112
- };
3113
- clearFilteredObjectTree(...params: any[]): void | Promise<any>;
3114
- getSectionBoxDisplayBbox(...params: any[]): Promise<any> | BoundingBox;
3115
- getSectionsAsBox(...params: any[]): Promise<any> | OrientedBox | null;
3116
- setHotkeysEnabled(enabled: any): void;
3117
- isPartitionedModel(...params: any[]): boolean | Promise<any>;
3118
- getMeasureObjectMeshesPartition(...params: any[]): Promise<any>;
3119
- }
3120
-
3121
- declare namespace RenderControllerProxy {
3122
- namespace NAVIGATION_MODE {
3123
- let NONE: number;
3124
- let GENERAL: number;
3125
- let WALK: number;
3126
- let ORBIT: number;
3127
- let MEASURE: number;
3128
- }
3129
- }
3130
-
3131
- declare function RenderControllerWorker(params: any): void;
3132
-
3133
- declare class RenderControllerWorker {
3134
- constructor(params: any);
3135
- pubsub: PubSubController;
3136
- params: any;
3137
- resolves: {};
3138
- rejects: {};
3139
- worker: any;
3140
- globalPromiseId: number;
3141
- init(modelDescriptors: any, downloadMetaData: any): void;
3142
- postSimpleMessage(fn: any, args: any): Promise<any>;
3143
- postMessage(payload: any): Promise<any>;
3144
- onUpdateWithState(data: any): Promise<any>;
3145
- close(...params: any[]): void;
3146
- waitTillRenderStage(...params: any[]): Promise<any>;
3147
- getCameraDirection(...params: any[]): Promise<any>;
3148
- getPosition(...params: any[]): Promise<any>;
3149
- setNodeColor(...params: any[]): Promise<any>;
3150
- clearNodeColor(...params: any[]): Promise<any>;
3151
- clearAllNodeColor(...params: any[]): Promise<any>;
3152
- setMeshnodeColor(...params: any[]): Promise<any>;
3153
- setLookAt(...params: any[]): Promise<any>;
3154
- getLookAt(...params: any[]): Promise<any>;
3155
- getBenchmarkPoint(...params: any[]): Promise<any>;
3156
- setBenchmarkPoint(...params: any[]): Promise<any>;
3157
- setPosition(...params: any[]): Promise<any>;
3158
- setCameraRotation(...params: any[]): Promise<any>;
3159
- getGlobalOffset(...params: any[]): Promise<any>;
3160
- getMeshnodeFromNodeId(...params: any[]): Promise<any>;
3161
- onResize(...params: any[]): Promise<any>;
3162
- getMeshnodeFromIndex(...params: any[]): Promise<any>;
3163
- getMeasureObjectMeshes(...params: any[]): Promise<any>;
3164
- extractEventVars(evt: any): {
3165
- pageX: any;
3166
- pageY: any;
3167
- offsetX: any;
3168
- offsetY: any;
3169
- };
3170
- onContextMenu(evt: any): Promise<any>;
3171
- getContextMenuData(evt: any): Promise<any>;
3172
- onSingleClick(evt: any): Promise<any>;
3173
- onMouseMove(evt: any): Promise<any>;
3174
- resizeScene(...params: any[]): Promise<any>;
3175
- onDoubleClick(evt: any): Promise<any>;
3176
- onRightClick(evt: any): Promise<any>;
3177
- getNumNodesHidden(...params: any[]): Promise<any>;
3178
- hideSelected(...params: any[]): Promise<any>;
3179
- hideNodeOffset(...params: any[]): Promise<any>;
3180
- getHiddenNodeIds(...params: any[]): Promise<any>;
3181
- getHiddenMeshnodeIndices(...params: any[]): Promise<any>;
3182
- getHiddenGeoIdsSet(...params: any[]): Promise<any>;
3183
- addHiddenMeshnodeIndices(...params: any[]): Promise<any>;
3184
- removeHiddenGeoIds(...params: any[]): Promise<any>;
3185
- setVisibility(...params: any[]): Promise<any>;
3186
- getVisibility(...params: any[]): Promise<any>;
3187
- getOrbitTranslate(evt: any): Promise<any>;
3188
- ToScreenPosition(...params: any[]): Promise<any>;
3189
- ModelToMapSpace(...params: any[]): Promise<any>;
3190
- MapToModelSpace(...params: any[]): Promise<any>;
3191
- setBcfCamera(...params: any[]): Promise<any>;
3192
- getBcfCamera(...params: any[]): Promise<any>;
3193
- refreshScene(...params: any[]): Promise<any>;
3194
- refreshLighting(...params: any[]): Promise<any>;
3195
- setSectionBox(...params: any[]): Promise<any>;
3196
- setSectionsData(...params: any[]): Promise<any>;
3197
- removeSectionBox(...params: any[]): Promise<any>;
3198
- addSectionPlane(...params: any[]): Promise<any>;
3199
- removeSectionPlane(...params: any[]): Promise<any>;
3200
- getSections(...params: any[]): Promise<any>;
3201
- clearSection(...params: any[]): Promise<any>;
3202
- setOptions(...params: any[]): Promise<any>;
3203
- setCanvasSelectionEnabled(...params: any[]): Promise<any>;
3204
- findFirstObject(...params: any[]): Promise<any>;
3205
- getNamedNode(...params: any[]): Promise<any>;
3206
- setEulerAngles(...params: any[]): Promise<any>;
3207
- setMeasureEnabled(...params: any[]): Promise<any>;
3208
- statusChange(...params: any[]): Promise<any>;
3209
- onUndo(...params: any[]): Promise<any>;
3210
- getMeasureEnabled(...params: any[]): Promise<any>;
3211
- getMeasureIds(...params: any[]): Promise<any>;
3212
- removeMeasureIds(...params: any[]): Promise<any>;
3213
- onRedo(...params: any[]): Promise<any>;
3214
- clearMeasureIds(...params: any[]): Promise<any>;
3215
- clearHidden(...params: any[]): Promise<any>;
3216
- hasHiddenMeshnodeIndices(...params: any[]): Promise<any>;
3217
- addSelectedMeshnodeIndices(...params: any[]): Promise<any>;
3218
- clearAndSelectNode(...params: any[]): Promise<any>;
3219
- clearAndSelectNodes(...params: any[]): Promise<any>;
3220
- getNode(...params: any[]): Promise<any>;
3221
- getNodes(...params: any[]): Promise<any>;
3222
- getRootNode(...params: any[]): Promise<any>;
3223
- setNodesSelected(...params: any[]): Promise<any>;
3224
- getSelectedMeshnodeIndices(...params: any[]): Promise<any>;
3225
- hasSelectedMeshnodeIndices(...params: any[]): Promise<any>;
3226
- clearSelected(...params: any[]): Promise<any>;
3227
- getFieldOfView(...params: any[]): Promise<any>;
3228
- setFieldOfView(...params: any[]): Promise<any>;
3229
- zoomToBoundingBox(...params: any[]): Promise<any>;
3230
- setPose(...params: any[]): Promise<any>;
3231
- zoomToGlobal(...params: any[]): Promise<any>;
3232
- zoomToSelection(...params: any[]): Promise<any>;
3233
- isolateSelectionInSectionBox(...params: any[]): Promise<any>;
3234
- isolateSelection(...params: any[]): Promise<any>;
3235
- zoomToNodes(...params: any[]): Promise<any>;
3236
- unhideNodeFromNodeIds(...params: any[]): Promise<any>;
3237
- hideNodesFromNodeIds(...params: any[]): Promise<any>;
3238
- getNumNodesSelected(...params: any[]): Promise<any>;
3239
- setRenderMode(...params: any[]): Promise<any>;
3240
- getRenderMode(...params: any[]): Promise<any>;
3241
- getSelectedNodeIds(...params: any[]): Promise<any>;
3242
- toggleSectionBoxDisplay(...params: any[]): Promise<any>;
3243
- togglePointToPoint(...params: any[]): Promise<any>;
3244
- zoomToSectionBox(...params: any[]): Promise<any>;
3245
- setSectionBoxHidden(...params: any[]): Promise<any>;
3246
- resetSectionBox(...params: any[]): Promise<any>;
3247
- constructObjectTreeFromNodeIds(...params: any[]): Promise<any>;
3248
- clearFilteredObjectTree(...params: any[]): Promise<any>;
3249
- getSectionBoxDisplayBbox(...params: any[]): Promise<any>;
3250
- getSectionsAsBox(...params: any[]): Promise<any>;
3251
- setPwfFileCacheState(...params: any[]): Promise<any>;
3252
- partitionUrlsFromMeshnodeIndices(...params: any[]): Promise<any>;
3253
- isPartitionedModel(...params: any[]): Promise<any>;
3254
- getMeasureObjectMeshesPartition(...params: any[]): Promise<any>;
3255
- }
3256
-
3257
1357
  export declare type RenderMode = (typeof RENDER_MODE)[keyof typeof RENDER_MODE];
3258
1358
 
3259
1359
  export declare type Resource = FileExtractionModePwfV1OverrideResource | FileExtractionModePwfV2OverrideResource | FileExtractionModeResource | ModelRevisionModePwfV1Resource | ModelRevisionModePwfV2Resource;
3260
1360
 
3261
- declare type ResourceDiscriminator = {
3262
- fileExtractionId: number;
3263
- } | {
3264
- modelRevisionId: number;
3265
- };
3266
-
3267
1361
  export declare type ResourceOptions = CommonOptions & {
3268
1362
  resources: Resource[];
3269
1363
  };
@@ -3272,74 +1366,6 @@ export declare type RGB = `rgb(${number}, ${number}, ${number})`;
3272
1366
 
3273
1367
  export declare type RGBA = `rgba(${number}, ${number}, ${number}, ${number})`;
3274
1368
 
3275
- declare type SceneGraphName = 'kdtree' | 'wasmtree';
3276
-
3277
- declare class SectionController {
3278
- static readonly TYPE: {
3279
- NULL: number;
3280
- BOX: number;
3281
- PLANE: number;
3282
- };
3283
- private renderer;
3284
- private sectionDisplay;
3285
- private sectionDisplayEnabled;
3286
- private defaultSection;
3287
- private currentSectionType;
3288
- private _globalOffset?;
3289
- private box;
3290
- constructor(params: {
3291
- renderer: PartitionsRenderer;
3292
- });
3293
- /**
3294
- * Existing SectionController Methods
3295
- */
3296
- get globalOffset(): THREE.Vector3;
3297
- set globalOffset(offset: THREE.Vector3);
3298
- setDefaultSection(min: THREE.Vector3, max: THREE.Vector3, rotation: THREE.Vector3): void;
3299
- addSectionPlane(distance: number, normal: Vector3): void;
3300
- removeSectionPlane(uuid: string): void;
3301
- private getSectionsAsBcf;
3302
- private getSectionsAsAutodesk;
3303
- getSections(format: 'bcf' | 'autodesk'): SectionDataProcoreFormat | SectionDataAutodeskFormat | null;
3304
- getSectionsAsBox(): OrientedBox | null;
3305
- setSectionBox(min: Vector3, max: Vector3, rotation: Vector3 | null, applyOffset?: boolean): void;
3306
- removeSectionBox(): void;
3307
- clearSection(): void;
3308
- private setSectionsAutodeskFormat;
3309
- private setSectionsProcoreFormat;
3310
- setSectionData(sectionData: SectionData, unit?: string): void;
3311
- /**
3312
- * SectionBoxDisplay Passthrough Methods
3313
- */
3314
- getSectionBoxDisplayBbox(): BoundingBox;
3315
- clearSectionHover(): void;
3316
- setSectionBoxHidden(hide: boolean): void;
3317
- getSectionBoxHidden(): boolean;
3318
- isSectionBoxHovered(): boolean;
3319
- onMouseDown(): void;
3320
- isSectionDisplayEnabled(): boolean;
3321
- updateSectionDisplay(scene: THREE.Scene, camera: THREE.Camera): void;
3322
- checkInsideSection(position: Vector3): boolean;
3323
- resetSectionBox(): void;
3324
- toggleSectionBoxDisplay(params: {
3325
- enable: boolean;
3326
- scene: THREE.Scene;
3327
- }): void;
3328
- setSectionBoxDisplay(bbox: BoundingBox): void;
3329
- updateSectionHover(params: {
3330
- camera: THREE.Camera;
3331
- raycaster: THREE.Raycaster;
3332
- }): boolean;
3333
- insideSectionBox(position: THREE.Vector3): boolean;
3334
- resizeSectionBox(params: {
3335
- xyDelta: Vector2;
3336
- cameraPosition: THREE.Vector3;
3337
- cameraDirection: THREE.Vector3;
3338
- }): void;
3339
- }
3340
-
3341
- declare type SectionData = SectionDataAutodeskFormat | SectionDataProcoreFormat;
3342
-
3343
1369
  export declare type SectionDataAutodeskFormat = {
3344
1370
  Type: 'ClipPlaneSet';
3345
1371
  Version: 1;
@@ -3352,124 +1378,6 @@ export declare type SectionDataAutodeskFormat = {
3352
1378
 
3353
1379
  export declare type SectionDataProcoreFormat = ProcoreFormatClipPlane[];
3354
1380
 
3355
- declare class SectionRenderPass extends Pass {
3356
- scene: THREE.Scene;
3357
- camera: THREE.Camera;
3358
- clearDepth: boolean;
3359
- refresh: boolean;
3360
- private sectionController;
3361
- constructor(scene: THREE.Scene, camera: THREE.Camera, sectionController: SectionController);
3362
- render(renderer: THREE.WebGLRenderer | any, _writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget): void;
3363
- }
3364
-
3365
- declare class SelectedNodeServices {
3366
- private _selectionOption;
3367
- private selectedVirtualMeshnodeIndicesByResourceId;
3368
- private selectedFirstObjectCountByResourceId;
3369
- private selectedNodeIdsByResourceId;
3370
- private partiallySelectedNodeIdsByResourceId;
3371
- private models;
3372
- private objectTrees;
3373
- static SelectMethod: {
3374
- readonly Geometry: "Geometry";
3375
- readonly FirstObject: "FirstObject";
3376
- };
3377
- constructor(params: {
3378
- models: Models;
3379
- objectTrees: Map<number, ObjectTree>;
3380
- });
3381
- get selectionOption(): SelectMethod;
3382
- set selectionOption(method: SelectMethod);
3383
- getSelectedVirtualMeshnodesSet(resourceId: number): Set<number>;
3384
- addSelectedMeshnodeIndices(virtualMeshnodeIndices: number[], resourceId: number): void;
3385
- private selectFirstObject;
3386
- private selectGeometry;
3387
- clear(resourceId: number): void;
3388
- selectAll(resourceId: number): void;
3389
- private nodeNeedsUpdating;
3390
- updateSelectedAncestry(resourceId: number, nodeId: number, isSelected: boolean): void;
3391
- private removeChildNodesFromPartiallySelected;
3392
- private recursivelyUpdateParentNodes;
3393
- setMeshnodeSelectedByVirtualIndex(virtualMeshnodeIndex: number, select: boolean): void;
3394
- setMeshnodeSelected(meshnode: Meshnode, select: boolean, resourceId: number): void;
3395
- setNodeSelected(internalNode: InternalNode, select: boolean, resourceId: number): void;
3396
- private updateNodeAndChildren;
3397
- getSelectedNodeIds(resourceId: number): Set<number>;
3398
- getPartiallySelectedNodeIds(resourceId: number): Set<number>;
3399
- getSelectedObjectCount(method: SelectMethod, resourceId: number): number;
3400
- hasSelectedMeshnodeIndices(arr: number[], resourceId: number): boolean;
3401
- removeSelectedMeshnodeIndices(virtualMeshnodeIndices: number[], resourceId: number): void;
3402
- private unSelectGeometry;
3403
- private unSelectFirstObject;
3404
- }
3405
-
3406
- declare type SelectMethod = keyof typeof SelectedNodeServices.SelectMethod;
3407
-
3408
- declare type SetNodeColorParams = {
3409
- palette: Palette;
3410
- nodeIds: number[];
3411
- };
3412
-
3413
- declare class SettingsController {
3414
- private projectId;
3415
- private projectSettings;
3416
- private db?;
3417
- private locale;
3418
- constructor(params: {
3419
- locale?: string;
3420
- projectId: number;
3421
- });
3422
- private onDatabaseOpened;
3423
- private loadSettings;
3424
- private updateProjectSettings;
3425
- private needsUpdating;
3426
- SetValue(key: string, value: number): void;
3427
- getSettings(): ProjectSettings;
3428
- }
3429
-
3430
- declare class ShortestDistanceController {
3431
- private measureSet;
3432
- private models;
3433
- constructor(params: {
3434
- models: Models;
3435
- });
3436
- getMeasureIds(): number[];
3437
- addMeasureIds(virtualMeshnodeIndices: number[]): void;
3438
- clearMeasureIds(): void;
3439
- hasMeasureIds(arr: number[]): boolean;
3440
- removeMeasureIds(virtualMeshnodeIndices: number[]): void;
3441
- handleMeasurementClick(virtualMeshnodeIndex: number): void;
3442
- getMeasureObjectMeshes(): MeshnodeObject_3[];
3443
- getMeasureObjectMeshesPartition(): Promise<MeshnodeObject_3[]>;
3444
- }
3445
-
3446
- declare function StatusTrackingController(camera: any, renderController: any): void;
3447
-
3448
- declare class StatusTrackingController {
3449
- constructor(camera: any, renderController: any);
3450
- camera: any;
3451
- renderController: any;
3452
- cameraUndo: {
3453
- pos: any;
3454
- qua: any;
3455
- }[];
3456
- cameraRedo: any[];
3457
- sectionUndo: any[];
3458
- sectionRedo: any[];
3459
- hiddenUndo: {
3460
- hideNode: Set<any>;
3461
- hideGeo: Set<any>;
3462
- }[];
3463
- hiddenRedo: any[];
3464
- statesUndo: any[];
3465
- statesRedo: any[];
3466
- onStatusChange(types: any): void;
3467
- onUndo(): void;
3468
- onRedo(): void;
3469
- setCamera(camera: any): void;
3470
- setHideObject(hideObject: any): void;
3471
- }
3472
-
3473
1381
  declare class StreamedGeometryFactory extends GeometryFactory {
3474
1382
  createMeshGeometry(vertexArray: Float32Array, indexArray: Uint16Array, color: number, opacity: number, drawType: number): StreamedMeshGeometry;
3475
1383
  createMeshGeometryPrefetching(vertexArray: Float32Array, indexArray: Uint16Array, color: number, opacity: number, drawType: number): StreamedMeshGeometry;
@@ -3490,7 +1398,7 @@ declare class StreamedMeshGeometry extends MeshGeometry {
3490
1398
  constructor(color: number, opacity: number, drawType: number, numVertices: number, verticesBuffer: WebGLBuffer | null, numFaces: number, facesBuffer: WebGLBuffer | null, facesBytesLength: number, index: number, vertexBufferIndex: number, indexBufferIndex: number, vertexPosition: number);
3491
1399
  }
3492
1400
 
3493
- declare class StreamedMeshnode extends Meshnode_2 {
1401
+ declare class StreamedMeshnode extends Meshnode_3 {
3494
1402
  private _partitionProxy?;
3495
1403
  private _meshGeometries;
3496
1404
  setPartitionProxy(partitionProxy: PartitionProxy): void;
@@ -3498,11 +1406,11 @@ declare class StreamedMeshnode extends Meshnode_2 {
3498
1406
  meshGeometries(): MeshGeometry[];
3499
1407
  setMeshGeometry(meshIndex: number, meshGeometry: StreamedMeshGeometry): void;
3500
1408
  getMeshGeometry(meshIndex: number): StreamedMeshGeometry | undefined;
3501
- asObject(): MeshnodeObject;
1409
+ asObject(): MeshnodeObject_2;
3502
1410
  private getMeshObject;
3503
1411
  }
3504
1412
 
3505
- declare class StreamedMeshnode_2 extends Meshnode_3 {
1413
+ declare class StreamedMeshnode_2 extends Meshnode_2 {
3506
1414
  private _partitionProxy?;
3507
1415
  private _meshGeometries;
3508
1416
  setPartitionProxy(partitionProxy: PartitionProxy_2): void;
@@ -3510,19 +1418,27 @@ declare class StreamedMeshnode_2 extends Meshnode_3 {
3510
1418
  meshGeometries(): MeshGeometry[];
3511
1419
  setMeshGeometry(meshIndex: number, meshGeometry: StreamedMeshGeometry): void;
3512
1420
  getMeshGeometry(meshIndex: number): StreamedMeshGeometry | undefined;
3513
- asObject(): MeshnodeObject_2;
1421
+ asObject(): MeshnodeObject;
3514
1422
  private getMeshObject;
3515
1423
  }
3516
1424
 
3517
1425
  declare class StreamedMeshnodeServices extends MeshnodeServices {
3518
- protected createMeshnode(pwfMeshnode: PWFMeshnode): Meshnode_2;
1426
+ protected createMeshnode(pwfMeshnode: PWFMeshnode_2): Meshnode_3;
3519
1427
  }
3520
1428
 
3521
1429
  declare class StreamedMeshnodeServices_2 extends MeshnodeServices_2 {
3522
- protected createMeshnode(pwfMeshnode: PWFMeshnode_2): Meshnode_3;
1430
+ protected createMeshnode(pwfMeshnode: PWFMeshnode): Meshnode_2;
3523
1431
  }
3524
1432
 
3525
1433
  declare class StreamedMeshServices extends MeshServices {
1434
+ constructor(pwf: PWFV2);
1435
+ getMeshObject(meshOffset: number): MeshObject_2;
1436
+ loadPartitionContainingMeshnode(streamedMeshnode: StreamedMeshnode): Promise<void>;
1437
+ getMeshGeometryForOffsets(meshOffset: number, meshnodeOffset: number): StreamedMeshGeometry | undefined;
1438
+ dispose(): void;
1439
+ }
1440
+
1441
+ declare class StreamedMeshServices_2 extends MeshServices_2 {
3526
1442
  private readonly featureFlags;
3527
1443
  private meshIndexToOPFSRecord;
3528
1444
  private opfsFile?;
@@ -3533,63 +1449,12 @@ declare class StreamedMeshServices extends MeshServices {
3533
1449
  });
3534
1450
  initOPFS(): Promise<void>;
3535
1451
  closeOPFS(): Promise<void>;
3536
- writeMeshDataToOPFS(meshData: MeshData): Promise<void>;
1452
+ writeMeshDataToOPFS(meshData: MeshData_2): Promise<void>;
3537
1453
  getMeshObject(meshIndex: number): MeshObject;
3538
- loadPartitionContainingMeshnode(streamedMeshnode: StreamedMeshnode): Promise<void>;
3539
- getMeshGeometryForOffsets(meshOffset: number, meshnodeOffset: number): StreamedMeshGeometry | undefined;
3540
- meshFromOffset(meshIndex: number): Mesh;
3541
- private getCompressedMeshDataFromOPFS;
3542
- dispose(): void;
3543
- }
3544
-
3545
- declare class StreamedMeshServices_2 extends MeshServices_2 {
3546
- constructor(pwf: PWFV2);
3547
- getMeshObject(meshOffset: number): MeshObject_2;
3548
1454
  loadPartitionContainingMeshnode(streamedMeshnode: StreamedMeshnode_2): Promise<void>;
3549
1455
  getMeshGeometryForOffsets(meshOffset: number, meshnodeOffset: number): StreamedMeshGeometry | undefined;
3550
- dispose(): void;
3551
- }
3552
-
3553
- declare type SvgData = {
3554
- ellipses?: (BoxEllipse | RadiusEllipse)[];
3555
- lines?: Line[];
3556
- arrows?: Arrow[];
3557
- texts?: Text_2[];
3558
- rects?: Rect[];
3559
- };
3560
-
3561
- declare class SvgRenderer {
3562
- private svgEl;
3563
- private dom;
3564
- private arrowId;
3565
- private camera;
3566
- private anchoredSvgData;
3567
- private _renderControllerProxy;
3568
- private _globalOffset;
3569
- constructor();
3570
- private static createSvgEl;
3571
- private onRenderReady;
3572
- private onResize;
3573
- private set globalOffset(value);
3574
- private get globalOffset();
3575
- set renderControllerProxy(renderControllerProxy: RenderControllerProxy);
3576
- get renderControllerProxy(): RenderControllerProxy;
3577
- private hasAnchoredElements;
3578
- private onCameraUpdated;
3579
- private computeFromAnchored;
3580
- private saveAnchoredSvgData;
3581
- private collateByZIndex;
3582
- draw(svgData: SvgData): void;
3583
- drawAnchored(anchoredSvgData: AnchoredSvgData): Promise<void>;
3584
- drawEllipse(ellipse: BoxEllipse | RadiusEllipse): void;
3585
- drawLine(line: Line): void;
3586
- drawArrow(arrow: Arrow): void;
3587
- drawText(text: Text_2): void;
3588
- drawRect(rect: Rect): void;
3589
- private clipLine;
3590
- private _clear;
3591
- clear(): void;
3592
- hasContent(): boolean;
1456
+ meshFromOffset(meshIndex: number): Mesh_2;
1457
+ private getCompressedMeshDataFromOPFS;
3593
1458
  dispose(): void;
3594
1459
  }
3595
1460
 
@@ -3604,14 +1469,6 @@ export declare class TestRoutineRecorder {
3604
1469
  print(): void;
3605
1470
  }
3606
1471
 
3607
- declare type Text_2 = {
3608
- origin: Vector2;
3609
- text: string;
3610
- font?: CssFont;
3611
- fill: CssColor;
3612
- zIndex?: number;
3613
- };
3614
-
3615
1472
  export declare const TOOL: {
3616
1473
  readonly ALL: 0;
3617
1474
  readonly BOTTOMTOOL: 1;
@@ -3708,44 +1565,6 @@ export declare type Vector3 = {
3708
1565
 
3709
1566
  export declare const version: string;
3710
1567
 
3711
- declare interface ViewerRenderer {
3712
- initialize(measureSet: number[], models: Models, colorService: ColorServices): void;
3713
- autoClear: boolean;
3714
- domElement: HTMLCanvasElement;
3715
- clippingPlanes: any[];
3716
- refresh: boolean;
3717
- context: WebGLRenderingContext;
3718
- getSize(): {
3719
- width: number;
3720
- height: number;
3721
- };
3722
- getPixelRatio(): number;
3723
- getContext(): WebGLRenderingContext;
3724
- getRenderTarget(): THREE.WebGLRenderTarget;
3725
- setRenderTarget(renderTarget: THREE.WebGLRenderTarget): void;
3726
- clear(): void;
3727
- setSize(width: number, height: number): void;
3728
- render(scene: THREE.Scene, camera: THREE.Camera): void;
3729
- cleanBuffer(): void;
3730
- textures: {
3731
- picking: THREE.WebGLRenderTarget;
3732
- };
3733
- readRenderTargetPixels(renderTarget: THREE.WebGLRenderTarget, x: number, y: number, width: number, height: number, buffer: Uint8Array): void;
3734
- setRenderMode(mode: RenderMode): void;
3735
- getRenderMode(): string;
3736
- setDetailsParams(detailsParam: {
3737
- detailsInMotion: number;
3738
- detailsAtRest: number;
3739
- }): void;
3740
- getRenderingStage(): string;
3741
- dispose(): void;
3742
- enableBackFaceFillColor(state: boolean): void;
3743
- loadMeshShader(): void;
3744
- renderSection(scene: THREE.Scene, camera: THREE.Camera): void;
3745
- getWebGLRenderer(): THREE.WebGLRenderer;
3746
- setGeometryFactory(geometryFactory: GeometryFactory): void;
3747
- }
3748
-
3749
1568
  export declare type Viewpoint = {
3750
1569
  camera_data: string;
3751
1570
  sections_data: string;
@@ -3762,20 +1581,6 @@ export declare type Visibility = {
3762
1581
  };
3763
1582
  };
3764
1583
 
3765
- declare class WASMTree {
3766
- static maxChunkSize: number;
3767
- meshnodes: any[];
3768
- currentIndex: number;
3769
- cullTree(cameraPosition: any, projectViewMatrix: any, detailsFactor: any): {
3770
- opaques: Set<any>;
3771
- transparents: Set<any>;
3772
- };
3773
- maxChunkSize: number;
3774
- buildTree(meshnodes: any): {
3775
- isComplete: boolean;
3776
- };
3777
- }
3778
-
3779
1584
  export declare type WebFormatExtractionItem = {
3780
1585
  item_type: 'WebFormat';
3781
1586
  artifact: {
@@ -3790,7 +1595,6 @@ export declare type WebFormatExtractionItem = {
3790
1595
 
3791
1596
  export declare class Webviewer {
3792
1597
  options: Options;
3793
- pointToPointManager: PointToPointManager;
3794
1598
  private readonly measurementRenderer;
3795
1599
  private readonly measurementManager;
3796
1600
  static readonly tools: {
@@ -3987,7 +1791,9 @@ export declare class Webviewer {
3987
1791
  deselectObjects: (objectIds: number[], objectTreeName?: string) => Promise<boolean>;
3988
1792
  selectAllObjects: (objectTreeName?: string) => Promise<boolean>;
3989
1793
  getSelectedObjects: () => Promise<number[]>;
3990
- setMeasurement: (enable: boolean) => void;
1794
+ setMeasurement: (enable: boolean, options?: {
1795
+ measurementMode?: MeasureMode;
1796
+ }) => void;
3991
1797
  setObjectColor: (palettes: PaletteParams[], options?: {
3992
1798
  resourceId?: number;
3993
1799
  }) => void;
@@ -4052,9 +1858,4 @@ export declare class Webviewer {
4052
1858
  terminate: () => void;
4053
1859
  }
4054
1860
 
4055
- declare type WheelControl = {
4056
- onWheel: (event: WheelEvent) => void;
4057
- dispose: () => void;
4058
- };
4059
-
4060
1861
  export { }