@procore/bim-webviewer-sdk 16.6.0-rc.9 → 17.0.0-rc.0

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