@procore/bim-webviewer-sdk 17.0.0-4d-scheduling-hackathon.1 → 17.0.0-pins-hackathon.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 (26) hide show
  1. package/dist/Procore.Bim.Webviewer.d.ts +2182 -137
  2. package/dist/Procore.Bim.Webviewer.js +1 -1
  3. package/dist/types/src/Webviewer.d.ts +4 -7
  4. package/dist/types/src/api/coordination_issues.d.ts +1 -0
  5. package/dist/types/src/components/DropdownComponent/MenuOptions/MenuOption.d.ts +2 -2
  6. package/dist/types/src/components/DropdownComponent/MenuOptions/MenuOptionSelect.d.ts +8 -0
  7. package/dist/types/src/components/DropdownComponent/MenuOptions/MenuTitle.d.ts +9 -0
  8. package/dist/types/src/components/DropdownComponent/PinsToolDropdown/PinsToolDropdown.d.ts +31 -0
  9. package/dist/types/src/components/Markup/SvgRenderer.d.ts +13 -0
  10. package/dist/types/src/components/RootComponent.d.ts +5 -2
  11. package/dist/types/src/components/Tool.d.ts +1 -0
  12. package/dist/types/src/components/ToolBarComponent/ToolBarComponent.d.ts +7 -2
  13. package/dist/types/src/components/ToolBarTools.d.ts +1 -0
  14. package/dist/types/src/components/WindowPinsCreationComponent.d.ts +13 -0
  15. package/dist/types/src/controllers/ApiController/ApiController.d.ts +1 -0
  16. package/dist/types/src/controllers/PubSubController.d.ts +4 -0
  17. package/dist/types/src/controllers/RenderController.d.ts +0 -2
  18. package/dist/types/src/controllers/RenderControllerProxy.d.ts +0 -2
  19. package/dist/types/src/controllers/RenderControllerWorker.d.ts +0 -2
  20. package/dist/types/src/picking/PickingController.d.ts +0 -7
  21. package/dist/types/src/pins/PinsManager.d.ts +45 -0
  22. package/dist/types/src/procoregl/PartitionsRenderer.d.ts +0 -2
  23. package/dist/types/src/procoregl/PartitionsRendererImpl.d.ts +0 -2
  24. package/dist/types/src/procoregl/ViewerRenderer.d.ts +0 -2
  25. package/dist/types/src/types/Palette.d.ts +1 -1
  26. package/package.json +2 -2
@@ -1,3 +1,25 @@
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
+
1
23
  export declare const ACTION: {
2
24
  readonly NONE: -1;
3
25
  readonly PAN: 1;
@@ -10,6 +32,47 @@ export declare const ACTION: {
10
32
 
11
33
  export declare type Action = (typeof ACTION)[keyof typeof ACTION];
12
34
 
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 AnchoredCustomSvg = CustomSvg & Anchorable;
50
+
51
+ declare type AnchoredLine = Omit<Line, 'start' | 'end'> & AnchorableLine;
52
+
53
+ declare type AnchoredRadiusEllipse = Omit<RadiusEllipse, 'center'> & Anchorable;
54
+
55
+ declare type AnchoredRect = Omit<Rect, 'x' | 'y'> & Anchorable;
56
+
57
+ declare type AnchoredSvgData = {
58
+ ellipses?: (AnchoredBoxEllipse | AnchoredRadiusEllipse)[];
59
+ lines?: AnchoredLine[];
60
+ arrows?: AnchoredArrow[];
61
+ texts?: AnchoredText[];
62
+ rects?: AnchoredRect[];
63
+ custom?: AnchoredCustomSvg[];
64
+ };
65
+
66
+ declare type AnchoredText = Omit<Text_2, 'origin'> & Anchorable;
67
+
68
+ declare type Arrow = {
69
+ start: Vector2;
70
+ end: Vector2;
71
+ stroke: CssColor;
72
+ strokeWidth: number;
73
+ zIndex?: number;
74
+ };
75
+
13
76
  export declare type Attachment = {
14
77
  id: number;
15
78
  content_type: string;
@@ -80,6 +143,15 @@ export declare type BoundingBox = {
80
143
  min: Vector3;
81
144
  };
82
145
 
146
+ declare type BoxEllipse = {
147
+ min: Vector2;
148
+ max: Vector2;
149
+ stroke: CssColor;
150
+ fill?: CssColor;
151
+ strokeWidth: number;
152
+ zIndex?: number;
153
+ };
154
+
83
155
  declare class BVHTree {
84
156
  static maxChunkSize: number;
85
157
  constructor(pwf: any);
@@ -105,6 +177,33 @@ declare type Color = {
105
177
  opacity: number;
106
178
  };
107
179
 
180
+ declare class ColorServices {
181
+ private _palettes;
182
+ private meshnodeToPalette;
183
+ private models;
184
+ private resourceIdToVirtualMeshnodeIndexes;
185
+ constructor(params: {
186
+ models: Models;
187
+ });
188
+ setNodeColor(params: {
189
+ colorPalettes: SetNodeColorParams[];
190
+ resourceId: number;
191
+ }): void;
192
+ setMeshnodeColor(params: {
193
+ palette: Palette;
194
+ virtualMeshnodeIndex: number;
195
+ resourceId: number;
196
+ }): void;
197
+ clearNodeColor(params: {
198
+ nodeIds: number[];
199
+ resourceId: number;
200
+ }): void;
201
+ clearAllNodeColor(resourceId: number): void;
202
+ getPaletteByVirtualMeshnodeIndex(virtualMeshnodeIdx: number): Palette | undefined;
203
+ get palettes(): Palette[];
204
+ private addPalette;
205
+ }
206
+
108
207
  export declare type CommonOptions = {
109
208
  /**
110
209
  * Always required
@@ -150,8 +249,31 @@ export declare type CommonOptions = {
150
249
  bimFileId?: number;
151
250
  };
152
251
 
252
+ declare type Configuration = {
253
+ dropdown?: boolean;
254
+ selectCIs?: boolean;
255
+ selectObservations?: boolean;
256
+ selectRFIs?: boolean;
257
+ selectScheduledItems?: boolean;
258
+ hideCIs?: boolean;
259
+ hideObservations?: boolean;
260
+ hideRFIs?: boolean;
261
+ hideScheduledItems?: boolean;
262
+ };
263
+
153
264
  export declare type CssColor = RGB | RGBA | HEX | string;
154
265
 
266
+ declare type CssFont = string;
267
+
268
+ declare type CustomSvg = {
269
+ svgStr: string;
270
+ x: number;
271
+ y: number;
272
+ width: number;
273
+ height: number;
274
+ zIndex?: number;
275
+ };
276
+
155
277
  export declare const DISPLAY_UNIT: {
156
278
  readonly Meters: "m";
157
279
  readonly Millimeters: "mm";
@@ -278,6 +400,99 @@ declare type GPUMeshData = {
278
400
 
279
401
  export declare type HEX = `#${string}`;
280
402
 
403
+ declare class HiddenNodeServices {
404
+ private hiddenObjectCountByResourceId;
405
+ private hiddenMeshnodeIndicesByResourceId;
406
+ private hiddenNodesIdsByResourceId;
407
+ private models;
408
+ private objectTrees;
409
+ constructor(params: {
410
+ models: Models;
411
+ objectTrees: Map<number, ObjectTree>;
412
+ });
413
+ getCount: (resourceId: number) => number;
414
+ getHiddenMeshnodeIndices: (resourceId: number) => Set<number>;
415
+ getHiddenNodeIds: (resourceId: number) => Set<number>;
416
+ setMeshnodeHidden: (virtualMeshnodeIndex: number, hidden: boolean) => void;
417
+ setNodeHidden: (objectTreeNode: InternalNode, hidden: boolean, resourceId: number) => void;
418
+ setMeshnodeHiddenFromSet: (virtualMeshnodeIndexes: Set<number>, hidden: boolean) => void;
419
+ setNodeHiddenFromSet: (nodeIds: Set<number>, hidden: boolean, resourceId: number) => void;
420
+ clear: (resourceId: number) => void;
421
+ hideAll(resourceId: number): void;
422
+ hasMeshnodeIndices: (indexes: Array<number>, resourceId: number) => boolean;
423
+ private nodeNeedsUpdating;
424
+ getVisibility: (resourceId: number, options?: {
425
+ defaultVisibilityAlwaysTrue?: boolean;
426
+ }) => Visibility;
427
+ setVisibility: (visibility: Visibility, resourceId: number) => void;
428
+ private updateNodeAndChildren;
429
+ private updateNodeAndParentsDF;
430
+ private setNodeHiddenIfChildrenHidden;
431
+ private updateNodesAndParentsByIdBF;
432
+ updateHiddenAncestry: (nodeId: number, hidden: boolean, resourceId: number) => void;
433
+ }
434
+
435
+ declare class Hotkeys implements KeyboardControl {
436
+ private renderControllerProxy;
437
+ private navigationManager;
438
+ private _enabled;
439
+ constructor(params: {
440
+ renderControllerProxy: RenderControllerProxy;
441
+ navigationManager: NavigationManager;
442
+ });
443
+ get enabled(): boolean;
444
+ set enabled(value: boolean);
445
+ onKeyDown: (event: KeyboardEvent) => void;
446
+ onKeyUp: () => void;
447
+ private publishSelectedToolEvent;
448
+ dispose(): void;
449
+ }
450
+
451
+ declare type InternalNode = {
452
+ id: number;
453
+ parentId: number | undefined;
454
+ children: number[];
455
+ meshnodes: number[];
456
+ isFirstObject: boolean;
457
+ };
458
+
459
+ declare class KDTree {
460
+ private MAX_CHILDREN_PER_NODE;
461
+ private readonly root;
462
+ private frustum;
463
+ private queue;
464
+ private readonly result;
465
+ meshnodes: Meshnode[];
466
+ constructor();
467
+ cullTree(cameraPosition: Vector3_3, frustumMatrix: Matrix4, detailsParam: number): {
468
+ opaques: Set<Meshnode>;
469
+ transparents: Set<Meshnode>;
470
+ };
471
+ buildTree(meshnodes: Meshnode[]): {
472
+ isComplete: boolean;
473
+ };
474
+ collectMeshnodes(cameraPosition: Vector3_3, detailsFactor: number): {
475
+ opaques: Set<Meshnode>;
476
+ transparents: Set<Meshnode>;
477
+ };
478
+ }
479
+
480
+ declare type KeyboardControl = {
481
+ onKeyDown: (event: KeyboardEvent) => void;
482
+ onKeyUp: (event: KeyboardEvent) => void;
483
+ dispose: () => void;
484
+ };
485
+
486
+ declare type Line = {
487
+ start: Vector2;
488
+ end: Vector2;
489
+ stroke: CssColor;
490
+ strokeWidth: number;
491
+ strokeDasharray?: string;
492
+ opacity?: number;
493
+ zIndex?: number;
494
+ };
495
+
281
496
  declare interface Logger {
282
497
  logError(error: any): void;
283
498
  }
@@ -296,7 +511,9 @@ declare class LRUCache<K, V> {
296
511
  getKeys(): K[];
297
512
  }
298
513
 
299
- declare type Manifest = {
514
+ declare type Manifest = Manifest_2;
515
+
516
+ declare type Manifest_2 = {
300
517
  version: PWFVersion;
301
518
  globalAABB: BoundingBox;
302
519
  reducedGlobalAABB: BoundingBox;
@@ -331,7 +548,7 @@ declare class Mesh {
331
548
  lenFaces(): number;
332
549
  vertices(): Float32Array;
333
550
  faces(): Uint16Array;
334
- asObject(): MeshObject_2;
551
+ asObject(): MeshObject;
335
552
  }
336
553
 
337
554
  declare class Mesh_2 {
@@ -347,7 +564,7 @@ declare class Mesh_2 {
347
564
  lenFaces(): number;
348
565
  vertices(): Float32Array;
349
566
  faces(): Uint16Array;
350
- asObject(): MeshObject;
567
+ asObject(): MeshObject_2;
351
568
  }
352
569
 
353
570
  declare class MeshData {
@@ -364,6 +581,7 @@ declare class MeshData {
364
581
  faces(): Uint16Array;
365
582
  uploadToGPU(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
366
583
  uploadToGPUPreFetching(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
584
+ getCompressedMeshData(): ArrayBuffer;
367
585
  getUncompressedMeshData(): ArrayBuffer;
368
586
  }
369
587
 
@@ -381,7 +599,6 @@ declare class MeshData_2 {
381
599
  faces(): Uint16Array;
382
600
  uploadToGPU(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
383
601
  uploadToGPUPreFetching(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
384
- getCompressedMeshData(): ArrayBuffer;
385
602
  getUncompressedMeshData(): ArrayBuffer;
386
603
  }
387
604
 
@@ -414,7 +631,7 @@ declare class Meshnode_2 {
414
631
  constructor(pwfMeshnode: PWFMeshnode, pwf: PWFV1);
415
632
  offset(): number;
416
633
  parentOffset(): number;
417
- parent(): Node_3;
634
+ parent(): Node_2;
418
635
  children(): never[];
419
636
  nodeId(): number;
420
637
  bbox(): Float32Array;
@@ -436,7 +653,7 @@ declare class Meshnode_2 {
436
653
  isRoot(): boolean;
437
654
  hidden(): Meshnode_2['hiddenValue'];
438
655
  setHidden(hidden: boolean): void;
439
- setParent(node: Node_3): void;
656
+ setParent(node: Node_2): void;
440
657
  asObject(): MeshnodeObject;
441
658
  }
442
659
 
@@ -454,7 +671,7 @@ declare class Meshnode_3 {
454
671
  constructor(pwfMeshnode: PWFMeshnode_2, pwf: PWFV2);
455
672
  offset(): number;
456
673
  parentOffset(): number;
457
- parent(): Node_4;
674
+ parent(): Node_3;
458
675
  children(): never[];
459
676
  nodeId(): number;
460
677
  bbox(): Float32Array;
@@ -476,7 +693,7 @@ declare class Meshnode_3 {
476
693
  isRoot(): boolean;
477
694
  hidden(): Meshnode_3['hiddenValue'];
478
695
  setHidden(hidden: boolean): void;
479
- setParent(node: Node_4): void;
696
+ setParent(node: Node_3): void;
480
697
  asObject(): MeshnodeObject_2;
481
698
  }
482
699
 
@@ -509,27 +726,27 @@ declare type MeshnodeObject_3 = MeshnodeObject | MeshnodeObject_2;
509
726
  declare class MeshnodeServices {
510
727
  private meshnodeCount;
511
728
  private meshnodes;
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;
729
+ protected pwf: PWFV1;
730
+ protected cachedMeshnodes: Map<number, Meshnode_2>;
731
+ constructor(pwfMeshnodes: PWFMeshnode[], pwf: PWFV1);
732
+ getMeshnodeFromIndex(index: number): Meshnode_2;
733
+ getMeshnode(offset: number): Meshnode_2;
517
734
  numMeshnodes(): number;
518
735
  allMeshnodes(): NonNullable<MeshnodeServices['meshnodes']>;
519
- protected createMeshnode(pwfMeshnode: PWFMeshnode_2): Meshnode_3;
736
+ protected createMeshnode(pwfMeshnode: PWFMeshnode): Meshnode_2;
520
737
  }
521
738
 
522
739
  declare class MeshnodeServices_2 {
523
740
  private meshnodeCount;
524
741
  private meshnodes;
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;
742
+ protected pwf: PWFV2;
743
+ protected cachedMeshnodes: Map<number, Meshnode_3>;
744
+ constructor(pwfMeshnodes: PWFMeshnode_2[], pwf: PWFV2);
745
+ getMeshnodeFromIndex(index: number): Meshnode_3;
746
+ getMeshnode(offset: number): Meshnode_3;
530
747
  numMeshnodes(): number;
531
748
  allMeshnodes(): NonNullable<MeshnodeServices_2['meshnodes']>;
532
- protected createMeshnode(pwfMeshnode: PWFMeshnode): Meshnode_2;
749
+ protected createMeshnode(pwfMeshnode: PWFMeshnode_2): Meshnode_3;
533
750
  }
534
751
 
535
752
  declare type MeshObject = {
@@ -553,14 +770,14 @@ declare type MeshObject_2 = {
553
770
  declare type MeshObject_3 = MeshObject | MeshObject_2;
554
771
 
555
772
  declare class MeshServices {
556
- protected pwf: PWFV2;
773
+ protected pwf: PWFV1;
557
774
  protected geometryFactory?: GeometryFactory;
558
775
  private meshGeometryMap;
559
776
  private readonly pwfMeshes;
560
777
  private pwfMeshOffsetMap;
561
778
  private readonly meshCount;
562
779
  private currentIndex;
563
- constructor(pwfMeshes: PWFMesh[], pwf: PWFV2);
780
+ constructor(pwfMeshes: PWFMesh[], pwf: PWFV1);
564
781
  setGeometryFactory(geometryFactory: GeometryFactory): void;
565
782
  getMeshGeometryForOffsets(meshOffset: number, _meshnodeOffset: number | undefined): MeshGeometry | undefined;
566
783
  meshFromOffset(offset: number): Mesh;
@@ -570,20 +787,20 @@ declare class MeshServices {
570
787
  isComplete: boolean;
571
788
  };
572
789
  private loadToGPU;
573
- getMeshObject(meshOffset: number): MeshObject_2;
790
+ getMeshObject(meshOffset: number): MeshObject;
574
791
  private loadMeshGeometryToGPU;
575
792
  dispose(): void;
576
793
  }
577
794
 
578
795
  declare class MeshServices_2 {
579
- protected pwf: PWFV1;
796
+ protected pwf: PWFV2;
580
797
  protected geometryFactory?: GeometryFactory;
581
798
  private meshGeometryMap;
582
799
  private readonly pwfMeshes;
583
800
  private pwfMeshOffsetMap;
584
801
  private readonly meshCount;
585
802
  private currentIndex;
586
- constructor(pwfMeshes: PWFMesh_2[], pwf: PWFV1);
803
+ constructor(pwfMeshes: PWFMesh_2[], pwf: PWFV2);
587
804
  setGeometryFactory(geometryFactory: GeometryFactory): void;
588
805
  getMeshGeometryForOffsets(meshOffset: number, _meshnodeOffset: number | undefined): MeshGeometry | undefined;
589
806
  meshFromOffset(offset: number): Mesh_2;
@@ -593,7 +810,7 @@ declare class MeshServices_2 {
593
810
  isComplete: boolean;
594
811
  };
595
812
  private loadToGPU;
596
- getMeshObject(meshOffset: number): MeshObject;
813
+ getMeshObject(meshOffset: number): MeshObject_2;
597
814
  private loadMeshGeometryToGPU;
598
815
  dispose(): void;
599
816
  }
@@ -614,6 +831,32 @@ declare type ModelAnalyticsData = {
614
831
  partition_proxy_size?: number;
615
832
  };
616
833
 
834
+ declare type ModelDescriptor = {
835
+ resource: ResourceDiscriminator;
836
+ meshAB: ArrayBuffer;
837
+ meshnodeAB: ArrayBuffer;
838
+ nodeAB: ArrayBuffer;
839
+ manifest?: Manifest;
840
+ };
841
+
842
+ declare type ModelInitializationPayload = {
843
+ success: boolean;
844
+ start_timestamp: number;
845
+ end_timestamp: number;
846
+ total_time: number;
847
+ model_type: ModelType;
848
+ node_size?: number;
849
+ meshnode_size?: number;
850
+ num_nodes?: number;
851
+ num_meshnodes?: number;
852
+ mesh_size?: number;
853
+ num_meshes?: number;
854
+ partition_proxy_size?: number;
855
+ web_viewer_version: string;
856
+ step_failed?: string;
857
+ error_description?: string;
858
+ };
859
+
617
860
  export declare type ModelRevision = {
618
861
  id: number;
619
862
  revision: number;
@@ -644,6 +887,91 @@ export declare type ModelRevisionViewpoint = Viewpoint & {
644
887
  primary: boolean;
645
888
  };
646
889
 
890
+ declare class Models {
891
+ private resourceIds;
892
+ private pwfs;
893
+ private currentParsingPwfIndex;
894
+ private streaming;
895
+ private prefetchingPartitions;
896
+ private geometryFactory?;
897
+ private objectTrees;
898
+ private readonly selectionOption;
899
+ private partitionProxiesLoaded;
900
+ private readonly sceneGraph;
901
+ private tempVirtualizedMeshnodes;
902
+ private detailsParams?;
903
+ private readonly isLogging;
904
+ constructor(params: {
905
+ sceneGraphName: SceneGraphName;
906
+ isLogging: boolean;
907
+ locale: string;
908
+ downloadMetaData: DownloadMetaData;
909
+ modelDescriptors: ModelDescriptor[];
910
+ selectionOption: SelectMethod;
911
+ prefetchingPartitions?: boolean;
912
+ featureFlags: ValidatedFeatureFlags;
913
+ });
914
+ private sceneGraphFactory;
915
+ getResourceId: (resource: ResourceDiscriminator) => number;
916
+ getAllResourceIds(): number[];
917
+ getPwf(resourceId: number): PWFProxy;
918
+ getObjectTrees(resourceId: number): Map<string, ObjectTree>;
919
+ getSceneGraph(): KDTree | WASMTree;
920
+ parsePwfNodes(): BootstrapperResult;
921
+ parsePwfMeshnodes(): BootstrapperResult;
922
+ parsePwfMeshes(): void;
923
+ initMeshServices(): BootstrapperResult;
924
+ initNodeServices(): void;
925
+ initMeshnodeServices(): void;
926
+ initNodeTree(): BootstrapperResult;
927
+ initNodeTreeBoundingBoxes(): BootstrapperResult;
928
+ initSceneGraph(): BootstrapperResult;
929
+ captureModelStats(): {
930
+ detailsInMotion: number;
931
+ detailsAtRest: number;
932
+ };
933
+ getResourceFromVirtualMeshnodeIndex(virtualMeshnodeIndex: number): number;
934
+ getMeshnodeFromVirtualIndex(virtualMeshnodeIndex: number): {
935
+ meshnode: Meshnode;
936
+ resourceId: number;
937
+ };
938
+ getMeshnodeFromVirtualIndexAndResourceId(virtualMeshnodeIndex: number, resourceId: number): Meshnode;
939
+ getMeshnodeVirtualIndexFromMeshnodeIndex(params: {
940
+ resourceId: number;
941
+ meshnodeIndex: number;
942
+ }): number;
943
+ getMeshObject(params: {
944
+ resourceId: number;
945
+ meshRef: number;
946
+ }): MeshObject;
947
+ globalOffset(resourceId: number): Vector3;
948
+ initGeometryFactory(params: {
949
+ viewerRenderer: ViewerRenderer;
950
+ }): void;
951
+ private instantiateGeometryFactory;
952
+ initTreeServices(): BootstrapperResult;
953
+ initPartitionedGeometry(): BootstrapperResult;
954
+ loadAllMeshGeometryToGPU(): BootstrapperResult;
955
+ private forEachResourceInterruptible;
956
+ getVirtualMeshnodeIndexesByNodeId(params: {
957
+ nodeId: number;
958
+ resourceId: number;
959
+ }): number[];
960
+ findFirstObjectNodeId(params: {
961
+ virtualMeshnodeIndex: number;
962
+ resourceId: number;
963
+ }): number;
964
+ }
965
+
966
+ declare type ModelType = 'standard' | 'partitioned' | undefined;
967
+
968
+ declare type MouseControl = {
969
+ onMouseDown: (event: MouseEvent) => void;
970
+ onMouseUp: (event: MouseEvent) => void;
971
+ onMouseMove: (event: MouseEvent) => void;
972
+ dispose: () => void;
973
+ };
974
+
647
975
  export declare const NAV_MODE: {
648
976
  readonly DEFAULT: 0;
649
977
  readonly FLY: 1;
@@ -654,76 +982,217 @@ export declare const NAV_MODE: {
654
982
  readonly SURVEY: 6;
655
983
  };
656
984
 
985
+ declare class NavigationManager {
986
+ private renderControllerProxy;
987
+ private canvas;
988
+ private isMoved;
989
+ private wheeling?;
990
+ private _selectedNavigationMode;
991
+ private _mouseControls;
992
+ private _wheelControls;
993
+ keyboardControls: KeyboardControl;
994
+ private static DEBUG;
995
+ private debugEl?;
996
+ private modifierKeys;
997
+ private lastMousemoveEvent?;
998
+ constructor(params: {
999
+ renderWrapperController: RenderControllerProxy;
1000
+ canvas: HTMLCanvasElement;
1001
+ });
1002
+ get mouseControls(): MouseControl;
1003
+ private set mouseControls(value);
1004
+ get wheelControls(): WheelControl;
1005
+ private set wheelControls(value);
1006
+ get selectedNavigationMode(): NavigationMode;
1007
+ private set selectedNavigationMode(value);
1008
+ private updateDebugEl;
1009
+ private setWheelControls;
1010
+ private setKeyboardControls;
1011
+ setNavigationMode(navigationMode: NavigationMode): void;
1012
+ dispose(): void;
1013
+ private setMouseControls;
1014
+ private updateModifierKeys;
1015
+ private onKeyDown;
1016
+ private onKeyUp;
1017
+ private onMouseDown;
1018
+ private onMouseUp;
1019
+ private onMouseMove;
1020
+ private onWheel;
1021
+ private wheelDetect;
1022
+ private onSelectTool;
1023
+ }
1024
+
657
1025
  export declare type NavigationMode = (typeof NAV_MODE)[keyof typeof NAV_MODE];
658
1026
 
659
- declare type Node_2 = Node_3 | Node_4;
1027
+ declare function NavigationModel(cam: any, rc: any, dom: any): void;
1028
+
1029
+ declare class NavigationModel {
1030
+ constructor(cam: any, rc: any, dom: any);
1031
+ cam: any;
1032
+ rc: any;
1033
+ dom: any;
1034
+ curKeysMultiple: any[];
1035
+ curAction: -1;
1036
+ EPS: number;
1037
+ quatWorldToModelSpace: Quaternion;
1038
+ quatModelToWorldSpace: Quaternion;
1039
+ lastZoomPos: Vector2_2;
1040
+ lastZoomModelPos: Vector3_2;
1041
+ zoomDir: Vector3_2;
1042
+ zoomDistanceInterval: number;
1043
+ zoomDistanceThrehold: number;
1044
+ panControl: Vector2_2;
1045
+ spherical: Spherical;
1046
+ sphericalDelta: Spherical;
1047
+ orbitPoint: any;
1048
+ cameraPoint: Vector3_2;
1049
+ panTarget: Vector3_2 | null;
1050
+ panOffset: Vector3_2;
1051
+ orbitInit: {
1052
+ orbitPoint: Vector3_2;
1053
+ initialCameraTheta: number;
1054
+ initialCameraCylindrical: Cylindrical;
1055
+ initialCameraDirectionCylindrical: Cylindrical;
1056
+ initialDirectionInOrbitPointSpace: Vector3_2;
1057
+ cameraThetaRange: number[];
1058
+ directionThetaRange: number[];
1059
+ } | null;
1060
+ qua: Quaternion;
1061
+ moveOffset: Vector3_2;
1062
+ lookDir: Vector3_2;
1063
+ lookDirOnMouseDown: Vector3_2;
1064
+ rotateWithKeys: boolean;
1065
+ lookQuaOnMouseDown: Quaternion;
1066
+ mouseRotateQua: Quaternion;
1067
+ isMoved: boolean;
1068
+ modelCenter: Vector3_2;
1069
+ gui: {
1070
+ navigation: {
1071
+ default: {
1072
+ keyboardMoveSpeed: number;
1073
+ keyboardRotateSpeed: number;
1074
+ };
1075
+ fly: {
1076
+ moveSpeed: number;
1077
+ rotateSpeed: number;
1078
+ strafeXSpeed: number;
1079
+ strafeYSpeed: number;
1080
+ };
1081
+ orbit: {
1082
+ rotateHorizontalSpeed: number;
1083
+ rotateVerticalSpeed: number;
1084
+ };
1085
+ };
1086
+ };
1087
+ deltaTime: number;
1088
+ flyEvent: any;
1089
+ strafeEvent: any;
1090
+ handleZoom(event: any, zoomSpeed: any): void;
1091
+ moveForward(fwdDistance: any, speed: any): any;
1092
+ moveBackward(fwdDistance: any, speed: any): number;
1093
+ setZoomValue(zoomValue: any, dir1: any): void;
1094
+ panLeft(distance: any, objectMatrix: any): void;
1095
+ panUp(distance: any, objectMatrix: any): void;
1096
+ handlePan(event: any): void;
1097
+ moveRight(dir: any): void;
1098
+ moveLeft(dir: any): void;
1099
+ moveDown(): void;
1100
+ moveUp(): void;
1101
+ handleMouseDown(): void;
1102
+ handleMouseUpDown(event: any): void;
1103
+ CalculateAngle(vec1: any, vec2: any, speed: any): any;
1104
+ handleStrafe(panDistance: any, speedX: any, speedY: any, clientWidth: any, clientHeight: any): void;
1105
+ handleRotate(angle: any): void;
1106
+ handleLookAround(angle: any): void;
1107
+ handleFly(walkDistance: any, flyRotateSpeed: any, flyMoveSpeed: any, clientWidth: any, clientHeight: any): void;
1108
+ rotateOrbitLeft(angle: any): void;
1109
+ rotateOrbitUp(angle: any): void;
1110
+ handleOrbitRotate(event: any): void;
1111
+ GetRotateOffset(offset: any, position: any, target: any, quat: any, quatInverse: any): void;
1112
+ handleKeyPress(code: any): void;
1113
+ moveXYForward(): void;
1114
+ moveXYBackward(): void;
1115
+ pitchUp(): void;
1116
+ pitchDown(): void;
1117
+ yawLeft(): void;
1118
+ yawRight(): void;
1119
+ handleMeasurementZoom(event: any, orbitPoint: any, zoomSpeed: any): void;
1120
+ updateWithState(state: any, event: any): void;
1121
+ update(deltaTime: any): void;
1122
+ clearOrbit(): void;
1123
+ clearMove(): void;
1124
+ clearPan(): void;
1125
+ SetDirection(dir: any): void;
1126
+ }
660
1127
 
661
- declare class Node_3 {
1128
+ declare class Node_2 {
662
1129
  private pwfNode;
663
1130
  private pwf;
664
1131
  private readonly box3Value;
665
1132
  isFirstObjectValue: boolean;
666
1133
  private _parent?;
667
1134
  constructor(pwfNode: PWFNode, pwf: PWFV1);
668
- box3(): Node_3['box3Value'];
1135
+ box3(): Node_2['box3Value'];
669
1136
  unionBBox(bbox: THREE.Box3): void;
670
1137
  isRoot(): boolean;
671
1138
  offset(): number;
672
1139
  nodeId(): number;
673
1140
  parentOff(): number;
674
- setParent(node: Node_3): void;
675
- parent(): Node_3 | undefined;
1141
+ setParent(node: Node_2): void;
1142
+ parent(): Node_2 | undefined;
676
1143
  numChild(): number;
677
1144
  hasChildren(): boolean;
678
1145
  group(): number;
679
1146
  isSelectable(): boolean;
680
1147
  nodeType(): number;
681
1148
  childOffsets(): Uint32Array;
682
- children(): (Node_3 | Meshnode_2)[];
683
- isNode(): this is Node_3;
1149
+ children(): (Node_2 | Meshnode_2)[];
1150
+ isNode(): this is Node_2;
684
1151
  isMeshnode(): boolean;
685
1152
  isFirstObject(): boolean;
686
1153
  hasMeshnodeChildren(): boolean;
687
1154
  numMeshnodeChildren(): number;
688
- asObject(): NodeObject_2;
1155
+ asObject(): NodeObject;
689
1156
  }
690
1157
 
691
- declare class Node_4 {
1158
+ declare class Node_3 {
692
1159
  private pwfNode;
693
1160
  private pwf;
694
1161
  private readonly box3Value;
695
1162
  isFirstObjectValue: boolean;
696
1163
  private _parent?;
697
1164
  constructor(pwfNode: PWFNode_2, pwf: PWFV2);
698
- box3(): Node_4['box3Value'];
1165
+ box3(): Node_3['box3Value'];
699
1166
  unionBBox(bbox: THREE.Box3): void;
700
1167
  isRoot(): boolean;
701
1168
  offset(): number;
702
1169
  nodeId(): number;
703
1170
  parentOff(): number;
704
- setParent(node: Node_4): void;
705
- parent(): Node_4 | undefined;
1171
+ setParent(node: Node_3): void;
1172
+ parent(): Node_3 | undefined;
706
1173
  numChild(): number;
707
1174
  hasChildren(): boolean;
708
1175
  group(): number;
709
1176
  isSelectable(): boolean;
710
1177
  nodeType(): number;
711
1178
  childOffsets(): Uint32Array;
712
- children(): (Node_4 | Meshnode_3)[];
713
- isNode(): this is Node_4;
1179
+ children(): (Node_3 | Meshnode_3)[];
1180
+ isNode(): this is Node_3;
714
1181
  isMeshnode(): boolean;
715
1182
  isFirstObject(): boolean;
716
1183
  hasMeshnodeChildren(): boolean;
717
1184
  numMeshnodeChildren(): number;
718
- asObject(): NodeObject;
1185
+ asObject(): NodeObject_2;
719
1186
  }
720
1187
 
1188
+ declare type Node_4 = Node_2 | Node_3;
1189
+
721
1190
  export declare type NodeBoundingBox = {
722
1191
  min: number[];
723
1192
  max: number[];
724
1193
  };
725
1194
 
726
- declare type NodeId = ReturnType<Node_2['nodeId']>;
1195
+ declare type NodeId = ReturnType<Node_4['nodeId']>;
727
1196
 
728
1197
  declare type NodeObject = {
729
1198
  offset: number;
@@ -766,25 +1235,24 @@ declare class NodeServices {
766
1235
  private _numNodes;
767
1236
  private _pwfNodeOffsetMap;
768
1237
  private _rootNode?;
769
- constructor(pwfNodes: PWFNode_2[], meshnodeOffPointer: number, pwf: PWFV2);
770
- nodeFromOffset(offset: number): Node_4;
1238
+ constructor(pwfNodes: PWFNode[], meshnodeOffPointer: number, pwf: PWFV1);
1239
+ nodeFromOffset(offset: number): Node_2;
771
1240
  buildNodes(): {
772
- nodes: NodeServices['nodes'];
773
1241
  isComplete: boolean;
774
1242
  };
775
- root(): Node_4;
776
- getNode(offset: number): Node_4 | Meshnode_3;
777
- getNodeById(id: number): Node_4;
1243
+ root(): Node_2;
1244
+ getNode(offset: number): Node_2 | Meshnode_2;
1245
+ getNodeById(id: number): Node_2;
778
1246
  hasNode(id: number): boolean;
779
- breadthFirstTraversal(callback: (n: Node_4 | Meshnode_3) => void): {
1247
+ breadthFirstTraversal(callback: (n: Node_2 | Meshnode_2) => void): {
780
1248
  isComplete: boolean;
781
1249
  };
782
1250
  private buildNodesRecursively;
783
1251
  private buildChildren;
784
1252
  meshnodeOffPointer(): NonNullable<NodeServices['meshnodeOffPointerValue']>;
785
- findFirstObject(meshnode: Meshnode_3): Node_4;
1253
+ findFirstObject(meshnode: Meshnode_2): Node_2;
786
1254
  numNodes(): number;
787
- allNodes(): Node_4[];
1255
+ allNodes(): Node_2[];
788
1256
  numFirstObjects(): number;
789
1257
  }
790
1258
 
@@ -801,22 +1269,23 @@ declare class NodeServices_2 {
801
1269
  private _numNodes;
802
1270
  private _pwfNodeOffsetMap;
803
1271
  private _rootNode?;
804
- constructor(pwfNodes: PWFNode[], meshnodeOffPointer: number, pwf: PWFV1);
1272
+ constructor(pwfNodes: PWFNode_2[], meshnodeOffPointer: number, pwf: PWFV2);
805
1273
  nodeFromOffset(offset: number): Node_3;
806
1274
  buildNodes(): {
1275
+ nodes: NodeServices_2['nodes'];
807
1276
  isComplete: boolean;
808
1277
  };
809
1278
  root(): Node_3;
810
- getNode(offset: number): Node_3 | Meshnode_2;
1279
+ getNode(offset: number): Node_3 | Meshnode_3;
811
1280
  getNodeById(id: number): Node_3;
812
1281
  hasNode(id: number): boolean;
813
- breadthFirstTraversal(callback: (n: Node_3 | Meshnode_2) => void): {
1282
+ breadthFirstTraversal(callback: (n: Node_3 | Meshnode_3) => void): {
814
1283
  isComplete: boolean;
815
1284
  };
816
1285
  private buildNodesRecursively;
817
1286
  private buildChildren;
818
1287
  meshnodeOffPointer(): NonNullable<NodeServices_2['meshnodeOffPointerValue']>;
819
- findFirstObject(meshnode: Meshnode_2): Node_3;
1288
+ findFirstObject(meshnode: Meshnode_3): Node_3;
820
1289
  numNodes(): number;
821
1290
  allNodes(): Node_3[];
822
1291
  numFirstObjects(): number;
@@ -827,10 +1296,51 @@ export declare type ObjectFilter = {
827
1296
  filterValue: string;
828
1297
  };
829
1298
 
1299
+ declare class ObjectTree {
1300
+ pwf: PWF;
1301
+ resourceId: number;
1302
+ _selectedNodeServices: SelectedNodeServices | null;
1303
+ _hiddenNodeServices: HiddenNodeServices | null;
1304
+ nodeIds: Set<number>;
1305
+ constructor(params: {
1306
+ pwf: PWF;
1307
+ resourceId: number;
1308
+ });
1309
+ set hiddenNodeServices(hiddenNodeServices: HiddenNodeServices);
1310
+ get hiddenNodeServices(): HiddenNodeServices;
1311
+ set selectedNodeServices(selectedNodeServices: SelectedNodeServices);
1312
+ get selectedNodeServices(): SelectedNodeServices;
1313
+ add: (nodeId: number) => boolean;
1314
+ has: (nodeId: number) => boolean;
1315
+ getParentInternalNode: (internalNode: InternalNode) => InternalNode | undefined;
1316
+ getInternalObjectTreeNode(nodeId: number): InternalNode | undefined;
1317
+ getObjectTreeNode(nodeId: number): PublicNode | undefined;
1318
+ buildFromPWF: () => {
1319
+ isComplete: boolean;
1320
+ };
1321
+ buildFromNodeIds: (nodeIds: number[]) => {
1322
+ nodeIds: number[];
1323
+ ancestors: number[];
1324
+ children: number[];
1325
+ };
1326
+ synchronizeSelected: (source: ObjectTree) => void;
1327
+ private synchronizeSelectedNodeIds;
1328
+ private getSelectedStack;
1329
+ private evaluateSelectedState;
1330
+ synchronizeHidden: (source: ObjectTree) => void;
1331
+ private synchronizeHiddenNodes;
1332
+ }
1333
+
830
1334
  export declare type Options = FileExtractionModePwfV2OverrideOptions | FileExtractionModePwfV1OverrideOptions | FileExtractionModeOptions | ModelRevisionModePwfV2Options | ModelRevisionModePwfV1Options | ResourceOptions;
831
1335
 
1336
+ declare type OrientedBox = {
1337
+ min: Vector3;
1338
+ max: Vector3;
1339
+ rotation?: Vector3 | null;
1340
+ };
1341
+
832
1342
  declare type Palette = {
833
- shaded?: Color;
1343
+ default?: Color;
834
1344
  xray?: Color;
835
1345
  selected?: Color;
836
1346
  };
@@ -856,6 +1366,7 @@ declare class Partition_2 {
856
1366
 
857
1367
  declare class PartitionProxy {
858
1368
  private pwfPartitionProxy;
1369
+ private meshServices;
859
1370
  static numberOfPartitions: number;
860
1371
  static numberOfPartitionsLoaded: number;
861
1372
  static currentNumberOfDownloading: number;
@@ -866,7 +1377,10 @@ declare class PartitionProxy {
866
1377
  private _byteLength?;
867
1378
  private _compressedByteLength?;
868
1379
  private stats;
869
- constructor(pwfPartitionProxy: PWFPartitionProxy);
1380
+ constructor(params: {
1381
+ pwfPartitionProxy: PWFPartitionProxy;
1382
+ meshServices: StreamedMeshServices;
1383
+ });
870
1384
  meshCount(): number;
871
1385
  incrementMeshCount(numMeshes: number): void;
872
1386
  vertexCount(): number;
@@ -884,14 +1398,13 @@ declare class PartitionProxy {
884
1398
  compressed: number;
885
1399
  size: number;
886
1400
  };
887
- static processPartitionProxiesAB(partitionProxiesAB: ArrayBuffer, callback: (partitionProxy: PartitionProxy) => void): void;
1401
+ static processPartitionProxiesAB(partitionProxiesAB: ArrayBuffer, meshServices: StreamedMeshServices, callback: (partitionProxy: PartitionProxy) => void): void;
888
1402
  static getPartitionProxies(partitionProxiesAB: ArrayBuffer): PWFPartitionProxy[];
889
1403
  getContentOfPartitionUrl(): string;
890
1404
  }
891
1405
 
892
1406
  declare class PartitionProxy_2 {
893
1407
  private pwfPartitionProxy;
894
- private meshServices;
895
1408
  static numberOfPartitions: number;
896
1409
  static numberOfPartitionsLoaded: number;
897
1410
  static currentNumberOfDownloading: number;
@@ -902,10 +1415,7 @@ declare class PartitionProxy_2 {
902
1415
  private _byteLength?;
903
1416
  private _compressedByteLength?;
904
1417
  private stats;
905
- constructor(params: {
906
- pwfPartitionProxy: PWFPartitionProxy_2;
907
- meshServices: StreamedMeshServices_2;
908
- });
1418
+ constructor(pwfPartitionProxy: PWFPartitionProxy_2);
909
1419
  meshCount(): number;
910
1420
  incrementMeshCount(numMeshes: number): void;
911
1421
  vertexCount(): number;
@@ -923,11 +1433,154 @@ declare class PartitionProxy_2 {
923
1433
  compressed: number;
924
1434
  size: number;
925
1435
  };
926
- static processPartitionProxiesAB(partitionProxiesAB: ArrayBuffer, meshServices: StreamedMeshServices_2, callback: (partitionProxy: PartitionProxy_2) => void): void;
1436
+ static processPartitionProxiesAB(partitionProxiesAB: ArrayBuffer, callback: (partitionProxy: PartitionProxy_2) => void): void;
927
1437
  static getPartitionProxies(partitionProxiesAB: ArrayBuffer): PWFPartitionProxy_2[];
928
1438
  getContentOfPartitionUrl(): string;
929
1439
  }
930
1440
 
1441
+ /**
1442
+ * Modified version based on Three WebGlRenderer
1443
+ */
1444
+ declare function PartitionsRenderer(parameters: any): void;
1445
+
1446
+ declare class PartitionsRenderer {
1447
+ /**
1448
+ * Modified version based on Three WebGlRenderer
1449
+ */
1450
+ constructor(parameters: any);
1451
+ domElement: any;
1452
+ context: any;
1453
+ textures: any;
1454
+ debug: {
1455
+ /**
1456
+ * Enables error checking and reporting when shader programs are being compiled
1457
+ * @type {boolean}
1458
+ */
1459
+ checkShaderErrors: boolean;
1460
+ };
1461
+ autoClear: boolean;
1462
+ autoClearColor: boolean;
1463
+ autoClearDepth: boolean;
1464
+ autoClearStencil: boolean;
1465
+ sortObjects: boolean;
1466
+ clippingPlanes: any[];
1467
+ localClippingEnabled: boolean;
1468
+ gammaFactor: number;
1469
+ gammaInput: boolean;
1470
+ gammaOutput: boolean;
1471
+ physicallyCorrectLights: boolean;
1472
+ toneMapping: ToneMapping;
1473
+ toneMappingExposure: number;
1474
+ toneMappingWhitePoint: number;
1475
+ commonRenderingParams: {
1476
+ xRayMode: {
1477
+ opacity: number;
1478
+ colorMode: string;
1479
+ color: string;
1480
+ };
1481
+ preferences: {
1482
+ overrideBackgroundColor: boolean;
1483
+ backgroundColor: string;
1484
+ };
1485
+ };
1486
+ refresh: boolean;
1487
+ renderingParameters: {
1488
+ renderingInMotion: {
1489
+ renderCullTreeOpaque: boolean;
1490
+ renderCullTreeTransparent: boolean;
1491
+ };
1492
+ };
1493
+ renderingAtRest: boolean;
1494
+ initialize: (measureSet: any, models: any, colorServices: any) => void;
1495
+ render: (scene: any, camera: any) => void;
1496
+ cleanBuffer: () => void;
1497
+ setRenderMode: (renderMode: any) => void;
1498
+ getRenderMode: () => "shaded";
1499
+ getRenderingStage: () => "renderIdle";
1500
+ renderSection: (scene: any, camera: any) => void;
1501
+ enableBackFaceFillColor: (enable: any) => void;
1502
+ loadMeshShader: () => void;
1503
+ setDetailsParams: (detailsParams: any) => void;
1504
+ setGeometryFactory: (geometryFactory: any) => void;
1505
+ renderMeshnode: (meshnode: any, scene: any, camera: any, renderStage: any) => void;
1506
+ renderMesh: (scene: any, camera: any, meshGeometry: any, nodedata: any, renderStage: any, isPicked: any, overrideMaterial: any) => void;
1507
+ vr: WebXRManager | WebVRManager | null;
1508
+ shadowMap: WebGLShadowMap;
1509
+ renderBufferImmediate: (object: any, program: any) => void;
1510
+ clear: (color: any, depth: any, stencil: any) => void;
1511
+ clearColor: () => void;
1512
+ clearDepth: () => void;
1513
+ dispose: () => void;
1514
+ getRenderTarget: () => any;
1515
+ getContext: () => any;
1516
+ getContextAttributes: () => any;
1517
+ getClearAlpha: () => any;
1518
+ getClearColor: () => any;
1519
+ getPixelRatio: () => number;
1520
+ getSize: () => {
1521
+ width: any;
1522
+ height: any;
1523
+ };
1524
+ setSize: (width: any, height: any, updateStyle: any) => void;
1525
+ setViewport: (x: any, y: any, width: any, height: any) => void;
1526
+ setScissorTest: (boolean: any) => void;
1527
+ setClearColor: (args: any) => void;
1528
+ setClearAlpha: (args: any) => void;
1529
+ setAnimationLoop: (callback: any) => void;
1530
+ setRenderTarget: (renderTarget: any) => void;
1531
+ readRenderTargetPixels: (renderTarget: any, x: any, y: any, width: any, height: any, buffer: any) => void;
1532
+ allocTextureUnit: () => number;
1533
+ renderBufferDirect: (camera: any, fog: any, geometry: any, material: any, object: any, group: any) => void;
1534
+ }
1535
+
1536
+ declare class PickingController {
1537
+ private renderer;
1538
+ private pickingTexture;
1539
+ private models;
1540
+ private camera;
1541
+ private sectionController;
1542
+ constructor(params: {
1543
+ renderer: ViewerRenderer;
1544
+ pickingTexture: THREE.WebGLRenderTarget;
1545
+ models: Models;
1546
+ camera: THREE.PerspectiveCamera;
1547
+ sectionController: SectionController;
1548
+ });
1549
+ getRayIntersectPoint(params: {
1550
+ event: MouseEvent;
1551
+ returnOnEdgeHitFailure: 'null' | 'bboxCenter';
1552
+ }): {
1553
+ intersection: Vector3 | null;
1554
+ meshnodeIndex: number;
1555
+ faceNormal: Vector3 | null;
1556
+ };
1557
+ mouseToThreeRay(event: MouseEvent): THREE.Raycaster;
1558
+ extractId(event: MouseEvent): number;
1559
+ private rayTestMesh;
1560
+ }
1561
+
1562
+ declare class PinsManager {
1563
+ private pins;
1564
+ private svgRenderer;
1565
+ private pinsEnabled;
1566
+ private configuration;
1567
+ private windowPinsCreationComponent;
1568
+ private renderControllerProxy;
1569
+ constructor(svgRenderer: SvgRenderer, renderControllerProxy: RenderControllerProxy, windowPinsCreationComponent: WindowPinsCreationComponent);
1570
+ static readonly DEFAULT_CONFIG: Readonly<Required<Configuration>>;
1571
+ init(): Promise<void>;
1572
+ private onIntersectPointClick;
1573
+ isEnabled(): boolean;
1574
+ draw(): void;
1575
+ clear(): void;
1576
+ toggle(params: {
1577
+ enable: boolean;
1578
+ }): void;
1579
+ getConfiguration(): Configuration;
1580
+ configurePinsSelection(config?: Configuration): void;
1581
+ configurePinsDisplay(config?: Configuration): void;
1582
+ }
1583
+
931
1584
  declare type Point = {
932
1585
  position: {
933
1586
  x: number;
@@ -941,12 +1594,57 @@ declare type Point = {
941
1594
  };
942
1595
  };
943
1596
 
1597
+ declare class PointToPointController {
1598
+ private readonly pickingController;
1599
+ private readonly models;
1600
+ private readonly camera;
1601
+ private currentHoverMeshnodeIndex;
1602
+ private readonly meshTopologyCache;
1603
+ private _enabled;
1604
+ private readonly globalOffset;
1605
+ private prevLastWorldIntersectionSnapResult;
1606
+ private lastWorldIntersectionSnapResult;
1607
+ private readonly debugGui;
1608
+ private readonly viewerRenderer;
1609
+ private renderController;
1610
+ constructor(params: {
1611
+ pickingController: PickingController;
1612
+ renderController: RenderController;
1613
+ models: Models;
1614
+ camera: THREE.PerspectiveCamera;
1615
+ globalOffset: THREE.Vector3;
1616
+ viewerRenderer: ViewerRenderer;
1617
+ });
1618
+ get enabled(): boolean;
1619
+ set enabled(value: boolean);
1620
+ handleMouseClick(): void;
1621
+ handleMouseMove(event: MouseEvent): void;
1622
+ handleWheel(event: WheelEvent): Promise<void>;
1623
+ private computeIntersectionSnapResult;
1624
+ private getWorldIntersectionSnapResult;
1625
+ private publishIntersectionSnapResult;
1626
+ private getMeshTopology;
1627
+ private meshnodeTooComplex;
1628
+ private determineHoverState;
1629
+ }
1630
+
944
1631
  export declare type ProcoreFormatClipPlane = {
945
1632
  unit?: string;
946
1633
  direction: Vector3;
947
1634
  location: Vector3;
948
1635
  };
949
1636
 
1637
+ declare type ProcoreRender = any;
1638
+
1639
+ declare class ProcoreRenderPass extends Pass {
1640
+ scene: THREE.Scene;
1641
+ camera: THREE.Camera;
1642
+ clearDepth: boolean;
1643
+ refresh: boolean;
1644
+ constructor(scene: THREE.Scene, camera: THREE.Camera);
1645
+ render(renderer: THREE.WebGLRenderer | ProcoreRender, _writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget): void;
1646
+ }
1647
+
950
1648
  export declare type Project = {
951
1649
  id: number;
952
1650
  };
@@ -978,6 +1676,123 @@ export declare type PublicNode = {
978
1676
  children: number[];
979
1677
  };
980
1678
 
1679
+ declare function PubSubController(): void;
1680
+
1681
+ declare class PubSubController {
1682
+ subscribe: (evt: any, cb: any) => void;
1683
+ unsubscribe: (evt: any, cb: any) => void;
1684
+ publish: (evt: any, value: any) => void;
1685
+ clear: () => void;
1686
+ }
1687
+
1688
+ declare namespace PubSubController {
1689
+ let EVENTS: Readonly<{
1690
+ animate: "animate";
1691
+ appResize: "appResize";
1692
+ appStart: "appStart";
1693
+ bcfCameraSet: "bcfCameraSet";
1694
+ browserSettingsReady: "browserSettingsReady";
1695
+ cameraUpdated: "cameraUpdated";
1696
+ canvasReady: "canvasReady";
1697
+ coachmarkHyperlinkClicked: "coachmarkHyperlinkClicked";
1698
+ contextMenu: "contextMenu";
1699
+ curKeysUpdated: "curKeysUpdated";
1700
+ databaseOpened: "databaseOpened";
1701
+ doubleClick: "doubleClick";
1702
+ downloadComplete: "downloadComplete";
1703
+ downloadError: "downloadError";
1704
+ downloadStart: "downloadStart";
1705
+ drawingMiniClick: "drawingMiniClick";
1706
+ drawingNavigated: "drawingNavigated";
1707
+ fieldOfViewChanged: "fieldOfViewChanged";
1708
+ fileTooBigError: "fileTooBigError";
1709
+ floorPlan: "floorPlan";
1710
+ getBimFileViewFolders: "getBimFileViewFolders";
1711
+ getBimModelRevisionViewpoints: "getBimModelRevisionViewpoints";
1712
+ getBimObjectsFor: "getBimObjectsFor";
1713
+ getBimPropertiesFor: "getBimPropertiesFor";
1714
+ globalBoundingBoxInitialized: "globalBoundingBoxInitialized";
1715
+ graphicContextLost: "graphicContextLost";
1716
+ hideSimilarCompleted: "hideSimilarCompleted";
1717
+ hideUpdated: "hideUpdated";
1718
+ homeViewpointActivated: "homeViewpointActivated";
1719
+ initializationComplete: "initializationComplete";
1720
+ initializationFailed: "initializationFailed";
1721
+ initializationProgress: "initializationProgress";
1722
+ initializationStart: "initializationStart";
1723
+ intersectPointClick: "intersectPointClick";
1724
+ isolateCompleted: "isolateCompleted";
1725
+ launchedAnimationLoop: "launchedAnimationLoop";
1726
+ mainThreadDebugGuiAdd: "mainThreadDebugGuiAdd";
1727
+ mainThreadDebugGuiDestroy: "mainThreadDebugGuiDestroy";
1728
+ markupDismissed: "markupDismissed";
1729
+ markupDisplayed: "markupDisplayed";
1730
+ measured: "measured";
1731
+ measurementObjectEnter: "measurementObjectEnter";
1732
+ measurementObjectLeave: "measurementObjectLeave";
1733
+ measurementObjectMove: "measurementObjectMove";
1734
+ measurementObjectClick: "measurementObjectClick";
1735
+ messages: "messages";
1736
+ modelTreeParentInteracted: "modelTreeParentInteracted";
1737
+ modelTypeDetermined: "modelTypeDetermined";
1738
+ mouseMove: "mouseMove";
1739
+ navigationChanged: "navigationChanged";
1740
+ navigationMouseDown: "navigationMouseDown";
1741
+ navigationMouseUp: "navigationMouseUp";
1742
+ navigationUpdated: "navigationUpdated";
1743
+ objectDeselect: "objectDeselect";
1744
+ objectDoubleClick: "objectDoubleClick";
1745
+ objectHide: "objectHide";
1746
+ objectMeasure: "objectMeasure";
1747
+ objectRightClick: "objectRightClick";
1748
+ objectSelect: "objectSelect";
1749
+ objectSelectFromModelTree: "objectSelectFromModelTree";
1750
+ objectSingleClick: "objectSingleClick";
1751
+ objectTreeUpdated: "objectTreeUpdated";
1752
+ objectUnhide: "objectUnhide";
1753
+ optionsChanged: "optionsChanged";
1754
+ allPartitionsDownloadComplete: "allPartitionsDownloadComplete";
1755
+ pinsToggled: "pinsToggled";
1756
+ pinsDisplayToggled: "pinsDisplayToggled";
1757
+ pinsDisplayConfigured: "pinsDisplayConfigured";
1758
+ pinsSelectionConfigured: "pinsSelectionConfigured";
1759
+ projectSettingsLoaded: "projectSettingsLoaded";
1760
+ projectSettingsUpdated: "projectSettingsUpdated";
1761
+ propertiesReady: "propertiesReady";
1762
+ propertyServiceCheck: "propertyServiceCheck";
1763
+ redo: "redo";
1764
+ renderModeChanged: "renderModeChanged";
1765
+ refreshScene: "refreshScene";
1766
+ renderReady: "renderReady";
1767
+ rightClick: "rightClick";
1768
+ savedViewpointClicked: "savedViewpointClicked";
1769
+ sectionBoxDisplayConfigured: "sectionBoxDisplayConfigured";
1770
+ sectionBoxDisplayHoverUpdated: "sectionBoxDisplayHoverUpdated";
1771
+ sectionBoxDisplayResized: "sectionBoxDisplayResized";
1772
+ sectionBoxDisplayToggled: "sectionBoxDisplayToggled";
1773
+ measurementToggled: "measurementToggled";
1774
+ sectionBoxRemoved: "sectionBoxRemoved";
1775
+ sectionBoxSet: "sectionBoxSet";
1776
+ sectionPlaneAdded: "sectionPlaneAdded";
1777
+ sectionPlaneRemoved: "sectionPlaneRemoved";
1778
+ sectionsCleared: "sectionsCleared";
1779
+ selectSimilarCompleted: "selectSimilarCompleted";
1780
+ selectSimilarStarted: "selectSimilarStarted";
1781
+ selectTool: "selectTool";
1782
+ selectedUpdated: "selectedUpdated";
1783
+ singleClick: "singleClick";
1784
+ undo: "undo";
1785
+ updatePivot: "updatePivot";
1786
+ windowClose: "windowClose";
1787
+ wheel: "wheel";
1788
+ windowComponentChanged: "windowComponentChanged";
1789
+ windowComponentShouldClose: "windowComponentShouldClose";
1790
+ windowComponentShouldOpen: "windowComponentShouldOpen";
1791
+ windowComponentTouched: "windowComponentTouched";
1792
+ windowOpen: "windowOpen";
1793
+ }>;
1794
+ }
1795
+
981
1796
  declare interface PWF {
982
1797
  setStandardModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer): void;
983
1798
  setPartitionedModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, partitionAB: ArrayBuffer): void;
@@ -991,12 +1806,12 @@ declare interface PWF {
991
1806
  initNodeTree(): BootstrapperResult;
992
1807
  initNodeTreeBoundingBoxes(): void;
993
1808
  allMeshnodes(): Meshnode[];
994
- breadthFirstTraversalNodes(callback: (n: Node_2 | Meshnode) => void): BootstrapperResult;
1809
+ breadthFirstTraversalNodes(callback: (n: Node_4 | Meshnode) => void): BootstrapperResult;
995
1810
  getMeshnodeFromIndex(meshnodeIndex: number): Meshnode;
996
1811
  getParentNodeIds(nodeId: number): number[];
997
1812
  getSubtreeNodeIds(nodeId: number): number[];
998
1813
  getVirtualMeshnodeIndexesByNodeId(nodeId: number): number[];
999
- getNamedNode(nodeId: number): Node_2;
1814
+ getNamedNode(nodeId: number): Node_4;
1000
1815
  globalOffset(): Vector3;
1001
1816
  getPwfPartitionContentUrls(): string[];
1002
1817
  numNodes(): number;
@@ -1005,15 +1820,15 @@ declare interface PWF {
1005
1820
  prefetchPartitions(geometryFactory: StreamedGeometryFactory): BootstrapperResult;
1006
1821
  setGeometryFactory(geometryFactory: GeometryFactory): void;
1007
1822
  numFirstObjects(): number;
1008
- getNodeById(id: number): Node_2;
1823
+ getNodeById(id: number): Node_4;
1009
1824
  getMeshnodeFromNodeId(nodeId: number): Meshnode;
1010
1825
  getMeshnode(offset: number): Meshnode;
1011
- getNode(offset: number): Node_2 | Meshnode;
1826
+ getNode(offset: number): Node_4 | Meshnode;
1012
1827
  getMeshObject(meshRef: number): MeshObject_3;
1013
- findFirstObject(meshnodeIndex: number): Node_2;
1014
- root(): Node_2;
1828
+ findFirstObject(meshnodeIndex: number): Node_4;
1829
+ root(): Node_4;
1015
1830
  forEachMeshnode(callback: (meshnode: Meshnode) => void): void;
1016
- forEachNode(callback: (node: Node_2) => void): void;
1831
+ forEachNode(callback: (node: Node_4) => void): void;
1017
1832
  hasNode(id: number): boolean;
1018
1833
  loadAllMeshGeometryToGPU(): BootstrapperResult;
1019
1834
  loadAllPartitionProxies(): void;
@@ -1025,6 +1840,18 @@ declare interface PWF {
1025
1840
  dispose(): void;
1026
1841
  }
1027
1842
 
1843
+ declare type PWF_2 = PWFV1 | PWFV2;
1844
+
1845
+ declare class PWFCache {
1846
+ private readonly httpClient;
1847
+ private abortController;
1848
+ private abortSignal;
1849
+ constructor();
1850
+ fetchData(url: string, dataType?: 'arrayBuffer' | 'json'): Promise<ArrayBuffer>;
1851
+ fetchArrayBuffers(urls: string[]): Promise<ArrayBuffer[]>;
1852
+ dispose(): void;
1853
+ }
1854
+
1028
1855
  declare interface PWFMesh {
1029
1856
  offset(): number;
1030
1857
  color(): number;
@@ -1080,15 +1907,20 @@ declare class PWFModelParser {
1080
1907
  private meshnodeBufferReader;
1081
1908
  private meshAB;
1082
1909
  private meshBufferReader?;
1083
- constructor(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer, manifest: Manifest);
1910
+ constructor(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer);
1911
+ getGlobalOffset(): Vector3;
1912
+ getMeshnodeOffPointer(): number;
1084
1913
  parseNodes(): {
1085
- nodes: PWFNode_2[];
1914
+ nodes: PWFNode[];
1086
1915
  isComplete: boolean;
1087
1916
  };
1088
1917
  parseMeshnodes(): {
1089
- meshnodes: PWFMeshnode_2[];
1918
+ meshnodes: PWFMeshnode[];
1090
1919
  isComplete: boolean;
1091
1920
  };
1921
+ getNumMeshnodes(): number;
1922
+ getNumMeshes(): number;
1923
+ getNumNodes(): number;
1092
1924
  parseMeshes(): PWFMesh[];
1093
1925
  }
1094
1926
 
@@ -1099,20 +1931,15 @@ declare class PWFModelParser_2 {
1099
1931
  private meshnodeBufferReader;
1100
1932
  private meshAB;
1101
1933
  private meshBufferReader?;
1102
- constructor(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer);
1103
- getGlobalOffset(): Vector3;
1104
- getMeshnodeOffPointer(): number;
1934
+ constructor(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer, manifest: Manifest_2);
1105
1935
  parseNodes(): {
1106
- nodes: PWFNode[];
1936
+ nodes: PWFNode_2[];
1107
1937
  isComplete: boolean;
1108
1938
  };
1109
1939
  parseMeshnodes(): {
1110
- meshnodes: PWFMeshnode[];
1940
+ meshnodes: PWFMeshnode_2[];
1111
1941
  isComplete: boolean;
1112
1942
  };
1113
- getNumMeshnodes(): number;
1114
- getNumMeshes(): number;
1115
- getNumNodes(): number;
1116
1943
  parseMeshes(): PWFMesh_2[];
1117
1944
  }
1118
1945
 
@@ -1164,7 +1991,62 @@ declare interface PWFPartitionProxy_2 {
1164
1991
  meshnodeOffsets(): Uint32Array;
1165
1992
  }
1166
1993
 
1167
- declare class PWFV1 implements PWF {
1994
+ declare class PWFProxy implements PWF {
1995
+ pwf: PWF_2;
1996
+ constructor(params: {
1997
+ manifest: Manifest | undefined;
1998
+ downloadMetaData: DownloadMetaData;
1999
+ resourceId: number;
2000
+ featureFlags: ValidatedFeatureFlags;
2001
+ });
2002
+ setStandardModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer): void;
2003
+ setPartitionedModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, partitionAB: ArrayBuffer): void;
2004
+ getPwfPartitionContentUrls(): string[];
2005
+ initPwfParser(): void;
2006
+ parsePwfNodes(): BootstrapperResult;
2007
+ parsePwfMeshnodes(): BootstrapperResult;
2008
+ parsePwfMeshes(): void;
2009
+ initMeshServices(): BootstrapperResult;
2010
+ initNodeServices(): void;
2011
+ initMeshnodeServices(): void;
2012
+ initNodeTree(): BootstrapperResult;
2013
+ initNodeTreeBoundingBoxes(): BootstrapperResult;
2014
+ allMeshnodes(): Meshnode[];
2015
+ getMeshnodeFromIndex(index: number): Meshnode;
2016
+ getParentNodeIds(nodeId: number): number[];
2017
+ getNodeById(id: number): Node_4;
2018
+ hasNode(id: number): boolean;
2019
+ getSubtreeNodeIds(nodeId: number): number[];
2020
+ getVirtualMeshnodeIndexesByNodeId(nodeId: number): number[];
2021
+ getMeshnodeFromNodeId(nodeId: number): Meshnode;
2022
+ getMeshnode(offset: number): Meshnode;
2023
+ getNode(offset: number): Node_4 | Meshnode;
2024
+ numNodes(): number;
2025
+ numMeshnodes(): number;
2026
+ numMeshes(): number;
2027
+ loadAllMeshGeometryToGPU(): BootstrapperResult;
2028
+ loadAllPartitionProxies(): void;
2029
+ prefetchPartitions(geometryFactory: StreamedGeometryFactory): BootstrapperResult;
2030
+ setGeometryFactory(geometryFactory: GeometryFactory): void;
2031
+ globalOffset(): Vector3;
2032
+ root(): Node_4;
2033
+ forEachNode(callback: (node: Node_4) => void): void;
2034
+ forEachMeshnode(callback: (meshnode: Meshnode) => void): void;
2035
+ getMeshObject(meshRef: number): MeshObject_3;
2036
+ findFirstObject(meshnodeIndex: number): Node_4;
2037
+ numFirstObjects(): number;
2038
+ breadthFirstTraversalNodes(callback: (n: Node_4 | Meshnode) => void): BootstrapperResult;
2039
+ getNamedNode(nodeId: number): Node_4;
2040
+ getMeshDataForPartitionedModel(meshnodeIndex: number): Promise<MeshnodeObject_3>;
2041
+ captureModelStats(): number;
2042
+ getModelAnalyticsData(): ModelAnalyticsData;
2043
+ get virtualMeshnodeIndexOffset(): number;
2044
+ set virtualMeshnodeIndexOffset(offset: number);
2045
+ isPartitionedModel(): boolean;
2046
+ dispose(): void;
2047
+ }
2048
+
2049
+ declare class PWFV1 implements PWF {
1168
2050
  private readonly downloadMetaData;
1169
2051
  resourceId: number;
1170
2052
  streaming: boolean;
@@ -1172,7 +2054,7 @@ declare class PWFV1 implements PWF {
1172
2054
  meshnodeAB?: ArrayBuffer;
1173
2055
  meshAB?: ArrayBuffer;
1174
2056
  partitionProxiesAB?: ArrayBuffer;
1175
- pwfModelParser?: PWFModelParser_2;
2057
+ pwfModelParser?: PWFModelParser;
1176
2058
  private _numMeshnodes;
1177
2059
  private _numMeshes;
1178
2060
  private _numNodes;
@@ -1180,18 +2062,18 @@ declare class PWFV1 implements PWF {
1180
2062
  pwfModel: {
1181
2063
  nodes: PWFNode[];
1182
2064
  meshnodes: PWFMeshnode[];
1183
- meshes: PWFMesh_2[];
2065
+ meshes: PWFMesh[];
1184
2066
  };
1185
- meshServices?: MeshServices_2 | StreamedMeshServices_2;
1186
- nodeServices?: NodeServices_2;
1187
- meshnodeServices?: MeshnodeServices_2 | StreamedMeshnodeServices_2;
2067
+ meshServices?: MeshServices | StreamedMeshServices;
2068
+ nodeServices?: NodeServices;
2069
+ meshnodeServices?: MeshnodeServices | StreamedMeshnodeServices;
1188
2070
  bvhTree?: BVHTree;
1189
2071
  _virtualMeshnodeIndexOffset: number;
1190
2072
  private readonly featureFlags;
1191
2073
  loadPartitionPromises: Promise<void>[];
1192
2074
  currentIndex: number;
1193
- partitionProxies: PartitionProxy_2[];
1194
- partitionsCache: LRUCache<string, Partition_2>;
2075
+ partitionProxies: PartitionProxy[];
2076
+ partitionsCache: LRUCache<string, Partition>;
1195
2077
  private meshServicesOPFSInitialized;
1196
2078
  constructor(params: {
1197
2079
  downloadMetaData: DownloadMetaData;
@@ -1213,7 +2095,7 @@ declare class PWFV1 implements PWF {
1213
2095
  allMeshnodes(): Meshnode_2[];
1214
2096
  getMeshnodeFromIndex(index: number): Meshnode_2;
1215
2097
  getParentNodeIds(nodeId: number): number[];
1216
- getNodeById(id: number): Node_3;
2098
+ getNodeById(id: number): Node_2;
1217
2099
  hasNode(id: number): boolean;
1218
2100
  private crawlAndCollectParentNodeIds;
1219
2101
  getSubtreeNodeIds(nodeId: number): number[];
@@ -1222,7 +2104,7 @@ declare class PWFV1 implements PWF {
1222
2104
  private getSubTreeVirtualMeshnodeIndexes;
1223
2105
  getMeshnodeFromNodeId(nodeId: number): Meshnode_2;
1224
2106
  getMeshnode(offset: number): Meshnode_2;
1225
- getNode(offset: number): Node_3 | Meshnode_2;
2107
+ getNode(offset: number): Node_2 | Meshnode_2;
1226
2108
  numNodes(): number;
1227
2109
  numMeshnodes(): number;
1228
2110
  numMeshes(): number;
@@ -1231,14 +2113,14 @@ declare class PWFV1 implements PWF {
1231
2113
  prefetchPartitions(geometryFactory: StreamedGeometryFactory): BootstrapperResult;
1232
2114
  setGeometryFactory(geometryFactory: GeometryFactory): void;
1233
2115
  globalOffset(): Vector3;
1234
- root(): Node_3;
2116
+ root(): Node_2;
1235
2117
  forEachMeshnode(callback: (meshnode: Meshnode_2) => void): void;
1236
- forEachNode(callback: (node: Node_3) => void): void;
2118
+ forEachNode(callback: (node: Node_2) => void): void;
1237
2119
  getMeshObject(meshRef: number): MeshObject;
1238
- findFirstObject(meshnodeIndex: number): Node_3;
2120
+ findFirstObject(meshnodeIndex: number): Node_2;
1239
2121
  numFirstObjects(): number;
1240
- breadthFirstTraversalNodes(callback: (n: Node_3 | Meshnode_2) => void): BootstrapperResult;
1241
- getNamedNode(nodeId: number): Node_3;
2122
+ breadthFirstTraversalNodes(callback: (n: Node_2 | Meshnode_2) => void): BootstrapperResult;
2123
+ getNamedNode(nodeId: number): Node_2;
1242
2124
  getMeshDataForPartitionedModel(meshnodeIndex: number): Promise<MeshnodeObject>;
1243
2125
  captureModelStats(): number;
1244
2126
  private captureStandardModelStats;
@@ -1263,7 +2145,7 @@ declare class PWFV2 implements PWF {
1263
2145
  meshnodeAB?: ArrayBuffer;
1264
2146
  meshAB?: ArrayBuffer;
1265
2147
  partitionProxiesAB?: ArrayBuffer;
1266
- pwfModelParser?: PWFModelParser;
2148
+ pwfModelParser?: PWFModelParser_2;
1267
2149
  private _numMeshnodes;
1268
2150
  private _numMeshes;
1269
2151
  private _numNodes;
@@ -1271,23 +2153,23 @@ declare class PWFV2 implements PWF {
1271
2153
  pwfModel: {
1272
2154
  nodes: PWFNode_2[];
1273
2155
  meshnodes: PWFMeshnode_2[];
1274
- meshes: PWFMesh[];
2156
+ meshes: PWFMesh_2[];
1275
2157
  };
1276
- meshServices?: MeshServices | StreamedMeshServices;
1277
- nodeServices?: NodeServices;
1278
- meshnodeServices?: MeshnodeServices | StreamedMeshnodeServices;
1279
- manifest?: Manifest;
2158
+ meshServices?: MeshServices_2 | StreamedMeshServices_2;
2159
+ nodeServices?: NodeServices_2;
2160
+ meshnodeServices?: MeshnodeServices_2 | StreamedMeshnodeServices_2;
2161
+ manifest?: Manifest_2;
1280
2162
  meshnodeOffPointer: number;
1281
2163
  bvhTree?: BVHTree;
1282
2164
  _virtualMeshnodeIndexOffset: number;
1283
2165
  loadPartitionPromises: Promise<void>[];
1284
2166
  currentIndex: number;
1285
- partitionProxies: PartitionProxy[];
1286
- partitionsCache: LRUCache<string, Partition>;
2167
+ partitionProxies: PartitionProxy_2[];
2168
+ partitionsCache: LRUCache<string, Partition_2>;
1287
2169
  constructor(params: {
1288
2170
  downloadMetaData: DownloadMetaData;
1289
2171
  resourceId: number;
1290
- manifest: Manifest;
2172
+ manifest: Manifest_2;
1291
2173
  });
1292
2174
  setStandardModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer): void;
1293
2175
  setPartitionedModelBuffers(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, partitionProxiesAB: ArrayBuffer): void;
@@ -1304,7 +2186,7 @@ declare class PWFV2 implements PWF {
1304
2186
  allMeshnodes(): Meshnode_3[];
1305
2187
  getMeshnodeFromIndex(index: number): Meshnode_3;
1306
2188
  getParentNodeIds(nodeId: number): number[];
1307
- getNodeById(id: number): Node_4;
2189
+ getNodeById(id: number): Node_3;
1308
2190
  hasNode(id: number): boolean;
1309
2191
  private crawlAndCollectParentNodeIds;
1310
2192
  getSubtreeNodeIds(nodeId: number): number[];
@@ -1313,7 +2195,7 @@ declare class PWFV2 implements PWF {
1313
2195
  private getSubTreeVirtualMeshnodeIndexes;
1314
2196
  getMeshnodeFromNodeId(nodeId: number): Meshnode_3;
1315
2197
  getMeshnode(offset: number): Meshnode_3;
1316
- getNode(offset: number): Node_4 | Meshnode_3;
2198
+ getNode(offset: number): Node_3 | Meshnode_3;
1317
2199
  numNodes(): number;
1318
2200
  numMeshnodes(): number;
1319
2201
  numMeshes(): number;
@@ -1322,14 +2204,14 @@ declare class PWFV2 implements PWF {
1322
2204
  prefetchPartitions(geometryFactory: StreamedGeometryFactory): BootstrapperResult;
1323
2205
  setGeometryFactory(geometryFactory: GeometryFactory): void;
1324
2206
  globalOffset(): Vector3;
1325
- root(): Node_4;
2207
+ root(): Node_3;
1326
2208
  forEachMeshnode(callback: (meshnode: Meshnode_3) => void): void;
1327
- forEachNode(callback: (node: Node_4) => void): void;
2209
+ forEachNode(callback: (node: Node_3) => void): void;
1328
2210
  getMeshObject(meshRef: number): MeshObject_2;
1329
- findFirstObject(meshnodeIndex: number): Node_4;
2211
+ findFirstObject(meshnodeIndex: number): Node_3;
1330
2212
  numFirstObjects(): number;
1331
- breadthFirstTraversalNodes(callback: (n: Node_4 | Meshnode_3) => void): BootstrapperResult;
1332
- getNamedNode(nodeId: number): Node_4;
2213
+ breadthFirstTraversalNodes(callback: (n: Node_3 | Meshnode_3) => void): BootstrapperResult;
2214
+ getNamedNode(nodeId: number): Node_3;
1333
2215
  getMeshDataForPartitionedModel(meshnodeIndex: number): Promise<MeshnodeObject_2>;
1334
2216
  captureModelStats(): number;
1335
2217
  private captureStandardModelStats;
@@ -1349,15 +2231,885 @@ export declare type PwfV2Bundle = {
1349
2231
 
1350
2232
  declare type PWFVersion = `${number}.${number}`;
1351
2233
 
2234
+ declare type RadiusEllipse = {
2235
+ center: Vector2;
2236
+ radius: Vector2;
2237
+ stroke: CssColor;
2238
+ fill?: CssColor;
2239
+ strokeWidth: number;
2240
+ zIndex?: number;
2241
+ };
2242
+
2243
+ declare type Rect = {
2244
+ width: number;
2245
+ height: number;
2246
+ x: number;
2247
+ y: number;
2248
+ radius?: Vector2;
2249
+ fill?: CssColor;
2250
+ stroke?: CssColor;
2251
+ strokeWidth?: number;
2252
+ zIndex?: number;
2253
+ };
2254
+
1352
2255
  export declare const RENDER_MODE: {
1353
2256
  readonly SHADED: "shaded";
1354
2257
  readonly XRAY: "xray";
1355
2258
  };
1356
2259
 
2260
+ declare function RenderController(params: any): void;
2261
+
2262
+ declare class RenderController {
2263
+ constructor(params: any);
2264
+ params: any;
2265
+ logInitializationTimes: any;
2266
+ cameras: {
2267
+ default: PerspectiveCamera;
2268
+ global: PerspectiveCamera;
2269
+ old: {
2270
+ position: Vector3_2;
2271
+ rotation: Vector3_2;
2272
+ };
2273
+ };
2274
+ scenes: {
2275
+ default: Scene;
2276
+ };
2277
+ controls: any;
2278
+ frameId: number | null;
2279
+ measureEnabled: boolean;
2280
+ canvasSelectionEnabled: boolean;
2281
+ globalOffset: Vector3 | null;
2282
+ clock: Clock;
2283
+ delta: number;
2284
+ webengine: InitOutput | null;
2285
+ webenginePromise: Promise<InitOutput>;
2286
+ enableWebWorker: any;
2287
+ prefetchingPartitions: boolean;
2288
+ projectId: any;
2289
+ baseUrl: any;
2290
+ meshnodeABCached: boolean;
2291
+ nodeABCached: boolean;
2292
+ meshABCached: boolean;
2293
+ trackingController: StatusTrackingController;
2294
+ zoomExtentsParams: {
2295
+ zoomExtents: {
2296
+ zenith: number;
2297
+ azimuth: number;
2298
+ distanceFromCenterFactor: number;
2299
+ };
2300
+ };
2301
+ zoomToGlobalParams: {
2302
+ spaceJunkEliminationThreshold: number;
2303
+ };
2304
+ initCanvas(): void;
2305
+ streaming: boolean | undefined;
2306
+ viewerRenderer: ViewerRenderer | undefined;
2307
+ textures: {
2308
+ picking: WebGLRenderTarget;
2309
+ } | undefined;
2310
+ section: SectionController | undefined;
2311
+ composer: EffectComposer | undefined;
2312
+ procoreRenderPass: ProcoreRenderPass | undefined;
2313
+ sectionRenderPass: SectionRenderPass | undefined;
2314
+ pickingController: PickingController | undefined;
2315
+ initWasm(): Promise<void>;
2316
+ parsePwfNodes(): BootstrapperResult;
2317
+ parsePwfMeshnodes(): BootstrapperResult;
2318
+ parsePwfMeshes(): void;
2319
+ initMeshServices(): BootstrapperResult;
2320
+ initNodeServices(): void;
2321
+ initMeshnodeServices(): void;
2322
+ initNodeTree(): BootstrapperResult;
2323
+ initNodeTreeBoundingBoxes(): BootstrapperResult;
2324
+ initSceneGraph(): BootstrapperResult;
2325
+ initGlobalOffset(): void;
2326
+ pointToPointController: PointToPointController | undefined;
2327
+ initGeometryFactory(): void;
2328
+ initTreeServices(): BootstrapperResult;
2329
+ initViewerRenderer(): void;
2330
+ initGeometry(): BootstrapperResult;
2331
+ initGlobalBoundingBox(): void;
2332
+ initNavigationModel(): void;
2333
+ navigationModel: NavigationModel | undefined;
2334
+ initLightingAndShader(): void;
2335
+ light: {
2336
+ default: DirectionalLight;
2337
+ ambient: AmbientLight;
2338
+ } | null | undefined;
2339
+ getInitEventPayload(params: any): ModelInitializationPayload;
2340
+ launchAnimationLoop(): void;
2341
+ waitTillRenderStage(params: any): Promise<any>;
2342
+ captureModelStats(): void;
2343
+ init(modelDescriptors: any, downloadMetaData: any): Promise<void>;
2344
+ meshnodeAB: any;
2345
+ nodeAB: any;
2346
+ meshAB: any;
2347
+ manifest: any;
2348
+ sceneGraphName: any;
2349
+ downloadMetaData: any;
2350
+ modelDescriptors: any;
2351
+ locale: any;
2352
+ models: Models | undefined;
2353
+ firstModelResourceId: number | undefined;
2354
+ pwf: PWFProxy | undefined;
2355
+ shortestDistanceController: ShortestDistanceController | undefined;
2356
+ colorServices: ColorServices | undefined;
2357
+ onUpdateWithState(data: any): void;
2358
+ close(): boolean;
2359
+ renderer: any;
2360
+ animate(): void;
2361
+ getCameraDirection(): {
2362
+ x: number;
2363
+ y: number;
2364
+ z: number;
2365
+ };
2366
+ getPosition(params?: {
2367
+ applyOffset: boolean;
2368
+ }): {
2369
+ x: number;
2370
+ y: number;
2371
+ z: number;
2372
+ };
2373
+ setMeshnodeColor(params: any): void;
2374
+ setNodeColor(palettes: any, options: any): void;
2375
+ clearNodeColor(nodeIds: any, options: any): void;
2376
+ clearAllNodeColor(options: any): void;
2377
+ setLookAt(params: any): {
2378
+ direction: {
2379
+ x: number;
2380
+ y: number;
2381
+ z: number;
2382
+ };
2383
+ position: {
2384
+ x: number;
2385
+ y: number;
2386
+ z: number;
2387
+ };
2388
+ };
2389
+ getLookAt(params?: {}): {
2390
+ x: number;
2391
+ y: number;
2392
+ z: number;
2393
+ };
2394
+ getBenchmarkPoint(): {
2395
+ position: {
2396
+ x: number;
2397
+ y: number;
2398
+ z: number;
2399
+ };
2400
+ lookAt: {
2401
+ x: number;
2402
+ y: number;
2403
+ z: number;
2404
+ };
2405
+ };
2406
+ setBenchmarkPoint(params: any): void;
2407
+ setPosition(params: any): {
2408
+ direction: {
2409
+ x: number;
2410
+ y: number;
2411
+ z: number;
2412
+ };
2413
+ position: {
2414
+ x: number;
2415
+ y: number;
2416
+ z: number;
2417
+ };
2418
+ };
2419
+ getModelItemBoundary(id: any): Box3;
2420
+ getGlobalOffset(): Vector3 | null;
2421
+ getMeshnodeFromNodeId(nodeId: any): Meshnode | null;
2422
+ getMeshnodeFromIndex(id: any): Meshnode | null;
2423
+ getMeasureObjectMeshes(): MeshnodeObject_3[];
2424
+ getCamera(): PerspectiveCamera;
2425
+ getRenderer(): ViewerRenderer | undefined;
2426
+ resizeScene(params: any): void;
2427
+ getContextMenuData(evt: any): {
2428
+ intersection: Vector3 | null;
2429
+ meshnodeIndex: number;
2430
+ faceNormal: Vector3 | null;
2431
+ } | {
2432
+ meshnodeIndex: number;
2433
+ };
2434
+ onContextMenu(evt: any): void;
2435
+ isSectionBlockingClick(): boolean;
2436
+ getIntersectionAndMeshnodeIndex(evt: any): {
2437
+ intersection: Vector3 | null;
2438
+ meshnodeIndex: number;
2439
+ faceNormal: Vector3 | null;
2440
+ };
2441
+ isMeshnodeSelected(virtualMeshnodeIndex: any): boolean;
2442
+ clickedOnSelectedObject(virtualMeshnodeIndex: any, rightClick: any): void;
2443
+ clickedOnUnselectedObject(virtualMeshnodeIndex: any, rightClick: any): void;
2444
+ handleObjectSelection(meshnodeIndex: any, rightClick: any): void;
2445
+ handleEmptySpaceClick(): void;
2446
+ onSingleClick(evt: any, rightClick?: boolean): void;
2447
+ onMouseMove(evt: any): void;
2448
+ onWheel(evt: any): void;
2449
+ setCanvasSelectionEnabled(enabled: any): void;
2450
+ getSelectedSubtree(meshnodeIndex: any): {
2451
+ objectId: number;
2452
+ selectionContainerId: number | undefined;
2453
+ ancestry: {
2454
+ children: (PublicNode | undefined)[];
2455
+ id?: number | undefined;
2456
+ bbox?: NodeBoundingBox | undefined;
2457
+ nodeType?: number | undefined;
2458
+ hidden?: boolean | undefined;
2459
+ selected?: boolean | undefined;
2460
+ partiallySelected?: boolean | undefined;
2461
+ parentId?: number;
2462
+ }[];
2463
+ };
2464
+ onDoubleClick(evt: any): void;
2465
+ onRightClick(evt: any): void;
2466
+ hideSelected(params?: {}): void;
2467
+ unhideNodeFromNodeIds(params: any): boolean;
2468
+ hideNodesFromNodeIds(params?: {}): boolean;
2469
+ getHiddenNodeIds(params?: {}): number[];
2470
+ getHiddenMeshnodeIndices(params?: {}): number[];
2471
+ getHiddenGeoIdsSet(params?: {}): Set<number>;
2472
+ addHiddenMeshnodeIndices(arr: any, resourceId?: any): void;
2473
+ setVisibility(params: any): void;
2474
+ getVisibility(params: any): Visibility;
2475
+ getZoomInterSectPoint(evt: any): {
2476
+ x: number;
2477
+ y: number;
2478
+ z: number;
2479
+ };
2480
+ ToScreenPosition(params: any): Vector3 | Vector3[];
2481
+ ConvertScreenPosition(vector: any): {
2482
+ x: any;
2483
+ y: any;
2484
+ z: any;
2485
+ };
2486
+ ModelToMapSpace(params: any): {
2487
+ x?: undefined;
2488
+ y?: undefined;
2489
+ dir_x?: undefined;
2490
+ dir_y?: undefined;
2491
+ } | {
2492
+ x: number;
2493
+ y: number;
2494
+ dir_x: number;
2495
+ dir_y: number;
2496
+ };
2497
+ MapToModelSpace(params: any): {
2498
+ x?: undefined;
2499
+ y?: undefined;
2500
+ dir_x?: undefined;
2501
+ dir_y?: undefined;
2502
+ } | {
2503
+ x: number;
2504
+ y: number;
2505
+ dir_x: number;
2506
+ dir_y: number;
2507
+ };
2508
+ setBcfCamera(params: any): false | {
2509
+ perspective_camera: {
2510
+ camera_view_point: {
2511
+ x: number;
2512
+ y: number;
2513
+ z: number;
2514
+ };
2515
+ camera_direction: {
2516
+ x: number;
2517
+ y: number;
2518
+ z: number;
2519
+ };
2520
+ camera_up_vector: {
2521
+ x: number;
2522
+ y: number;
2523
+ z: number;
2524
+ };
2525
+ field_of_view: number;
2526
+ target_distance: number;
2527
+ unit: string;
2528
+ };
2529
+ };
2530
+ setCameraRotation(params: any): void;
2531
+ sanitizeFieldOfView(fov: any): any;
2532
+ getBcfCamera(params?: {
2533
+ applyOffset: boolean;
2534
+ }): {
2535
+ perspective_camera: {
2536
+ camera_view_point: {
2537
+ x: number;
2538
+ y: number;
2539
+ z: number;
2540
+ };
2541
+ camera_direction: {
2542
+ x: number;
2543
+ y: number;
2544
+ z: number;
2545
+ };
2546
+ camera_up_vector: {
2547
+ x: number;
2548
+ y: number;
2549
+ z: number;
2550
+ };
2551
+ field_of_view: number;
2552
+ target_distance: number;
2553
+ unit: string;
2554
+ };
2555
+ };
2556
+ refreshScene(): void;
2557
+ setHiddenSet(params: any): void;
2558
+ refreshLighting(): void;
2559
+ setSectionBox(params: any): void;
2560
+ setSectionsData(params: any): boolean;
2561
+ removeSectionBox(): void;
2562
+ addSectionPlane(params: any): void;
2563
+ removeSectionPlane(uuid: any): void;
2564
+ getSections(format: any): SectionDataProcoreFormat | SectionDataAutodeskFormat | null;
2565
+ clearSection(): void;
2566
+ setOptions(options: any): void;
2567
+ findFirstObject(params: any): PublicNode | undefined;
2568
+ getNamedNode(nodeId: any, options?: {}): PublicNode | undefined;
2569
+ setEulerAngles(params: any): void;
2570
+ statusChange(type: any): void;
2571
+ onUndo(): void;
2572
+ onRedo(): void;
2573
+ getOrbitTranslate(event: any): {
2574
+ translate: Vector3 | Vector3[];
2575
+ orbitPoint: Vector3;
2576
+ };
2577
+ setMeasureEnabled(enabled: any): void;
2578
+ getMeasureEnabled(): boolean;
2579
+ getMeasureIds(): number[];
2580
+ removeMeasureIds(measureIds: any): void;
2581
+ clearMeasureIds(): void;
2582
+ hasHiddenMeshnodeIndices(ids: any, options?: {}): boolean;
2583
+ clearHidden(options?: {}): boolean;
2584
+ getSelectedMeshnodeIndices(options?: {}): number[];
2585
+ addSelectedMeshnodeIndices(ids: any, options?: {}): boolean;
2586
+ clearAndSelectNode(nodeId: any, options?: {}): void;
2587
+ clearAndSelectNodes(params: any): void;
2588
+ getNode(params: any): PublicNode | undefined;
2589
+ getNodes(params: any): any;
2590
+ getRootNode(params?: {}): PublicNode | undefined;
2591
+ setNodesSelected(params: any): boolean;
2592
+ hasSelectedMeshnodeIndices(ids: any, options?: {}): boolean;
2593
+ clearSelected(params?: {}): boolean;
2594
+ getFieldOfView(): number;
2595
+ setFieldOfView(deg: any): void;
2596
+ setPose(params: any): void;
2597
+ zoomToGlobal(): void;
2598
+ zoomToBoundingBox(bbox: any): void;
2599
+ getBoundingBoxByMeshnodeIndices(params: any): any;
2600
+ zoomToSelection(options?: {}): void;
2601
+ isolateSelection(options?: {}): void;
2602
+ isolateSelectionInSectionBox(options?: {}): void;
2603
+ zoomToNodes(nodeIds: any): void;
2604
+ getNumNodesSelected(params?: {}): {
2605
+ count: number;
2606
+ };
2607
+ getNumNodesHidden(options?: {}): {
2608
+ count: number;
2609
+ };
2610
+ setRenderMode(renderMode: any, origin: any): void;
2611
+ getRenderMode(): string;
2612
+ getSelectedNodeIds(params?: {}): number[];
2613
+ toggleSectionBoxDisplay(enable: any): void;
2614
+ togglePointToPoint(enabled: any): void;
2615
+ getSectionBoxDisplayBbox(): BoundingBox;
2616
+ getSectionsAsBox(): OrientedBox | null;
2617
+ zoomToSectionBox(): void;
2618
+ resetSectionBox(): void;
2619
+ setSectionBoxHidden(hide: any): void;
2620
+ updateSectionHover(event: any): void;
2621
+ clearSectionHover(): void;
2622
+ isSectionBoxHovered(): boolean;
2623
+ resizeSectionBox(xyDelta: any): void;
2624
+ onSectionMouseDown(): void;
2625
+ hideUpdated(): void;
2626
+ constructObjectTreeFromNodeIds(nodeIds: any, options?: {}): {
2627
+ nodeIds: number[];
2628
+ ancestors: number[];
2629
+ children: number[];
2630
+ };
2631
+ clearFilteredObjectTree(params?: {}): void;
2632
+ getObjectTree(resourceId?: any, objectTreeName?: string): ObjectTree | undefined;
2633
+ syncObjectTreesWithHidden(params: any): void;
2634
+ syncObjectTreesWithSelected({ resourceId, sourceObjectTreeName, destinationObjectTreeName, }: {
2635
+ resourceId: any;
2636
+ sourceObjectTreeName: any;
2637
+ destinationObjectTreeName: any;
2638
+ }): void;
2639
+ validateObjectTree(resourceId: any, objectTreeName: any): boolean;
2640
+ isPartitionedModel(): boolean;
2641
+ setPwfFileCacheState(states: any): void;
2642
+ getPwfFileCacheState(): {
2643
+ meshnodeABCached: boolean;
2644
+ nodeABCached: boolean;
2645
+ meshABCached: boolean;
2646
+ };
2647
+ getPwfPartitionContentUrls(params?: {}): string[];
2648
+ getNumMeshes(params?: {}): number;
2649
+ getNumMeshnodes(params?: {}): number;
2650
+ getNumNodes(params?: {}): number;
2651
+ getMeasureObjectMeshesPartition(): Promise<MeshnodeObject_3[]>;
2652
+ }
2653
+
2654
+ declare namespace RenderController {
2655
+ namespace NullSelectedSubtree {
2656
+ let objectId: number;
2657
+ let selectionContainerId: number;
2658
+ let ancestry: never[];
2659
+ }
2660
+ function createCameras(options: any): {
2661
+ default: PerspectiveCamera;
2662
+ global: PerspectiveCamera;
2663
+ old: {
2664
+ position: Vector3_2;
2665
+ rotation: Vector3_2;
2666
+ };
2667
+ };
2668
+ function createScenes(options: any, cameras: any): {
2669
+ default: Scene;
2670
+ };
2671
+ function createLighting(cameras: any, scenes: any): {
2672
+ default: DirectionalLight;
2673
+ ambient: AmbientLight;
2674
+ };
2675
+ function createTextures(renderer: any): {
2676
+ picking: WebGLRenderTarget;
2677
+ };
2678
+ function sanitizeOptions(options: any): any;
2679
+ }
2680
+
2681
+ declare function RenderControllerProxy(options: any): void;
2682
+
2683
+ declare class RenderControllerProxy {
2684
+ constructor(options: any);
2685
+ cache: Promise<Cache>;
2686
+ pubsub: PubSubController;
2687
+ options: any;
2688
+ worker: any;
2689
+ enableWebWorker: any;
2690
+ navigationManager: NavigationManager;
2691
+ hotkeys: Hotkeys;
2692
+ renderController: RenderController | RenderControllerWorker | null;
2693
+ pwfCache: PWFCache | null;
2694
+ renderControllerParams: {
2695
+ canvas: HTMLElement | null;
2696
+ debug: any;
2697
+ sceneGraph: any;
2698
+ selection: any;
2699
+ min_boundary: any;
2700
+ max_boundary: any;
2701
+ rotation: any;
2702
+ offsetWidth: any;
2703
+ offsetHeight: any;
2704
+ offsetTop: any;
2705
+ offsetLeft: any;
2706
+ multiselect: any;
2707
+ locale: any;
2708
+ enableWebWorker: any;
2709
+ logInitializationTimes: any;
2710
+ projectId: any;
2711
+ baseUrl: any;
2712
+ featureFlags: any;
2713
+ nodeUrl: any;
2714
+ meshnodeUrl: any;
2715
+ meshUrl: any;
2716
+ manifestUrl: any;
2717
+ fileExtractionId: any;
2718
+ modelId: any;
2719
+ modelRevisionId: any;
2720
+ resources: any;
2721
+ companyId: any;
2722
+ accessToken: any;
2723
+ };
2724
+ processPWFArrayBuffers: (modelDescriptors: any) => void;
2725
+ messageToEvent: {
2726
+ 'Error: Download exception.': "downloadError";
2727
+ 'Error: File size exception.': "fileTooBigError";
2728
+ };
2729
+ handleDownloadError: (message: any) => void;
2730
+ downloadMetaData: {
2731
+ timeToDownload: number;
2732
+ modelCached: boolean;
2733
+ };
2734
+ navmode: any;
2735
+ globalOffset: any;
2736
+ createRenderController(): void;
2737
+ onUpdateWithState(data: any): void | Promise<any> | undefined;
2738
+ close(): void;
2739
+ cameras: any;
2740
+ setNavigationMode(...params: any[]): void;
2741
+ waitTillRenderStage(...params: any[]): Promise<any>;
2742
+ getCameraDirection(...params: any[]): Promise<any> | {
2743
+ x: number;
2744
+ y: number;
2745
+ z: number;
2746
+ };
2747
+ getPosition(...params: any[]): Promise<any> | {
2748
+ x: number;
2749
+ y: number;
2750
+ z: number;
2751
+ };
2752
+ getLookAt(...params: any[]): Promise<any> | {
2753
+ x: number;
2754
+ y: number;
2755
+ z: number;
2756
+ };
2757
+ getBenchmarkPoint(...params: any[]): Promise<any> | {
2758
+ position: {
2759
+ x: number;
2760
+ y: number;
2761
+ z: number;
2762
+ };
2763
+ lookAt: {
2764
+ x: number;
2765
+ y: number;
2766
+ z: number;
2767
+ };
2768
+ };
2769
+ setBenchmarkPoint(...params: any[]): void | Promise<any>;
2770
+ setNodeColor(...params: any[]): void;
2771
+ clearNodeColor(...params: any[]): void;
2772
+ clearAllNodeColor(...params: any[]): void;
2773
+ setMeshnodeColor(...params: any[]): void;
2774
+ setLookAt(...params: any[]): Promise<any> | {
2775
+ direction: {
2776
+ x: number;
2777
+ y: number;
2778
+ z: number;
2779
+ };
2780
+ position: {
2781
+ x: number;
2782
+ y: number;
2783
+ z: number;
2784
+ };
2785
+ };
2786
+ setPosition(...params: any[]): Promise<any> | {
2787
+ direction: {
2788
+ x: number;
2789
+ y: number;
2790
+ z: number;
2791
+ };
2792
+ position: {
2793
+ x: number;
2794
+ y: number;
2795
+ z: number;
2796
+ };
2797
+ };
2798
+ setCameraRotation(...params: any[]): void | Promise<any>;
2799
+ getGlobalOffset(...params: any[]): Promise<any> | Vector3 | null;
2800
+ getMeshnodeFromNodeId(...params: any[]): Promise<any> | Meshnode | null;
2801
+ unhideNodeFromNodeIds(...params: any[]): boolean | Promise<any>;
2802
+ hideNodesFromNodeIds(...params: any[]): boolean | Promise<any>;
2803
+ onResize(...params: any[]): void;
2804
+ getMeshnodeFromIndex(...params: any[]): Promise<any> | Meshnode | null;
2805
+ getMeasureObjectMeshes(...params: any[]): Promise<any> | MeshnodeObject_3[];
2806
+ onContextMenu(...params: any[]): void | Promise<any>;
2807
+ getContextMenuData(...params: any[]): Promise<any> | {
2808
+ meshnodeIndex: number;
2809
+ };
2810
+ onSingleClick(...params: any[]): void | Promise<any>;
2811
+ onMouseMove(...params: any[]): void | Promise<any>;
2812
+ onWheel(...params: any[]): void | Promise<any>;
2813
+ resizeScene(...params: any[]): void;
2814
+ onDoubleClick(...params: any[]): void | Promise<any>;
2815
+ onRightClick(...params: any[]): void | Promise<any>;
2816
+ getNumNodesHidden(...params: any[]): Promise<any> | {
2817
+ count: number;
2818
+ };
2819
+ hideSelected(...params: any[]): void;
2820
+ hideNodeOffset(...params: any[]): any;
2821
+ getHiddenNodeIds(...params: any[]): Promise<any> | number[];
2822
+ getHiddenMeshnodeIndices(...params: any[]): Promise<any> | number[];
2823
+ getHiddenGeoIdsSet(...params: any[]): Promise<any> | Set<number>;
2824
+ addHiddenMeshnodeIndices(...params: any[]): void | Promise<any>;
2825
+ removeHiddenGeoIds(...params: any[]): any;
2826
+ setVisibility(...params: any[]): void | Promise<any>;
2827
+ getVisibility(...params: any[]): Promise<any> | Visibility;
2828
+ getOrbitTranslate(...params: any[]): Promise<any> | {
2829
+ translate: Vector3 | Vector3[];
2830
+ orbitPoint: Vector3;
2831
+ };
2832
+ ToScreenPosition(...params: any[]): Promise<any> | Vector3 | Vector3[];
2833
+ ModelToMapSpace(...params: any[]): Promise<any> | {
2834
+ x?: undefined;
2835
+ y?: undefined;
2836
+ dir_x?: undefined;
2837
+ dir_y?: undefined;
2838
+ } | {
2839
+ x: number;
2840
+ y: number;
2841
+ dir_x: number;
2842
+ dir_y: number;
2843
+ };
2844
+ MapToModelSpace(...params: any[]): Promise<any> | {
2845
+ x?: undefined;
2846
+ y?: undefined;
2847
+ dir_x?: undefined;
2848
+ dir_y?: undefined;
2849
+ } | {
2850
+ x: number;
2851
+ y: number;
2852
+ dir_x: number;
2853
+ dir_y: number;
2854
+ };
2855
+ setBcfCamera(...params: any[]): false | Promise<any> | {
2856
+ perspective_camera: {
2857
+ camera_view_point: {
2858
+ x: number;
2859
+ y: number;
2860
+ z: number;
2861
+ };
2862
+ camera_direction: {
2863
+ x: number;
2864
+ y: number;
2865
+ z: number;
2866
+ };
2867
+ camera_up_vector: {
2868
+ x: number;
2869
+ y: number;
2870
+ z: number;
2871
+ };
2872
+ field_of_view: number;
2873
+ target_distance: number;
2874
+ unit: string;
2875
+ };
2876
+ };
2877
+ getBcfCamera(...params: any[]): Promise<any> | {
2878
+ perspective_camera: {
2879
+ camera_view_point: {
2880
+ x: number;
2881
+ y: number;
2882
+ z: number;
2883
+ };
2884
+ camera_direction: {
2885
+ x: number;
2886
+ y: number;
2887
+ z: number;
2888
+ };
2889
+ camera_up_vector: {
2890
+ x: number;
2891
+ y: number;
2892
+ z: number;
2893
+ };
2894
+ field_of_view: number;
2895
+ target_distance: number;
2896
+ unit: string;
2897
+ };
2898
+ };
2899
+ refreshScene(...params: any[]): void;
2900
+ refreshLighting(...params: any[]): void;
2901
+ setSectionBox(...params: any[]): void | Promise<any>;
2902
+ setSectionsData(...params: any[]): boolean | Promise<any>;
2903
+ removeSectionBox(...params: any[]): void;
2904
+ addSectionPlane(...params: any[]): void;
2905
+ removeSectionPlane(...params: any[]): void;
2906
+ getSections(...params: any[]): Promise<any> | SectionDataProcoreFormat | SectionDataAutodeskFormat | null;
2907
+ clearSection(...params: any[]): void | Promise<any>;
2908
+ setOptions(options: any): void;
2909
+ setCanvasSelectionEnabled(...params: any[]): void;
2910
+ findFirstObject(...params: any[]): Promise<any> | PublicNode | undefined;
2911
+ getNamedNode(...params: any[]): Promise<any> | PublicNode | undefined;
2912
+ setEulerAngles(...params: any[]): void | Promise<any>;
2913
+ setMeasureEnabled(...params: any[]): void | Promise<any>;
2914
+ statusChange(...params: any[]): void | Promise<any>;
2915
+ onUndo(...params: any[]): void | Promise<any>;
2916
+ getMeasureEnabled(...params: any[]): boolean | Promise<any>;
2917
+ getMeasureIds(...params: any[]): Promise<any> | number[];
2918
+ removeMeasureIds(...params: any[]): void | Promise<any>;
2919
+ onRedo(...params: any[]): void | Promise<any>;
2920
+ clearMeasureIds(...params: any[]): void | Promise<any>;
2921
+ clearHidden(...params: any[]): boolean | Promise<any>;
2922
+ hasHiddenMeshnodeIndices(...params: any[]): boolean | Promise<any>;
2923
+ addSelectedMeshnodeIndices(...params: any[]): boolean | Promise<any>;
2924
+ clearAndSelectNode(...params: any[]): void | Promise<any>;
2925
+ clearAndSelectNodes(...params: any[]): void | Promise<any>;
2926
+ getNode(...params: any[]): Promise<any> | PublicNode | undefined;
2927
+ getNodes(...params: any[]): any;
2928
+ setNodesSelected(...params: any[]): boolean | Promise<any>;
2929
+ getRootNode(...params: any[]): Promise<any> | PublicNode | undefined;
2930
+ getSelectedMeshnodeIndices(...params: any[]): Promise<any> | number[];
2931
+ hasSelectedMeshnodeIndices(...params: any[]): boolean | Promise<any>;
2932
+ clearSelected(...params: any[]): boolean | Promise<any>;
2933
+ getFieldOfView(...params: any[]): number | Promise<any>;
2934
+ setFieldOfView(...params: any[]): void | Promise<any>;
2935
+ zoomToBoundingBox(...params: any[]): void | Promise<any>;
2936
+ setPose(...params: any[]): void | Promise<any>;
2937
+ zoomToGlobal(...params: any[]): void | Promise<any>;
2938
+ zoomToSelection(...params: any[]): void | Promise<any>;
2939
+ isolateSelectionInSectionBox(...params: any[]): void | Promise<any>;
2940
+ isolateSelection(...params: any[]): void | Promise<any>;
2941
+ zoomToNodes(...params: any[]): void | Promise<any>;
2942
+ getNumNodesSelected(...params: any[]): Promise<any> | {
2943
+ count: number;
2944
+ };
2945
+ setRenderMode(...params: any[]): void;
2946
+ getRenderMode(...params: any[]): string | Promise<any>;
2947
+ getSelectedNodeIds(...params: any[]): Promise<any> | number[];
2948
+ toggleSectionBoxDisplay(...params: any[]): void | Promise<any>;
2949
+ togglePointToPoint(...params: any[]): void | Promise<any>;
2950
+ zoomToSectionBox(...params: any[]): void | Promise<any>;
2951
+ setSectionBoxHidden(...params: any[]): void | Promise<any>;
2952
+ resetSectionBox(...params: any[]): void | Promise<any>;
2953
+ constructObjectTreeFromNodeIds(...params: any[]): Promise<any> | {
2954
+ nodeIds: number[];
2955
+ ancestors: number[];
2956
+ children: number[];
2957
+ };
2958
+ clearFilteredObjectTree(...params: any[]): void | Promise<any>;
2959
+ getSectionBoxDisplayBbox(...params: any[]): Promise<any> | BoundingBox;
2960
+ getSectionsAsBox(...params: any[]): Promise<any> | OrientedBox | null;
2961
+ setHotkeysEnabled(enabled: any): void;
2962
+ isPartitionedModel(...params: any[]): boolean | Promise<any>;
2963
+ getMeasureObjectMeshesPartition(...params: any[]): Promise<any>;
2964
+ }
2965
+
2966
+ declare namespace RenderControllerProxy {
2967
+ namespace NAVIGATION_MODE {
2968
+ let NONE: number;
2969
+ let GENERAL: number;
2970
+ let WALK: number;
2971
+ let ORBIT: number;
2972
+ let MEASURE: number;
2973
+ }
2974
+ }
2975
+
2976
+ declare function RenderControllerWorker(params: any): void;
2977
+
2978
+ declare class RenderControllerWorker {
2979
+ constructor(params: any);
2980
+ pubsub: PubSubController;
2981
+ params: any;
2982
+ resolves: {};
2983
+ rejects: {};
2984
+ worker: any;
2985
+ globalPromiseId: number;
2986
+ init(modelDescriptors: any, downloadMetaData: any): void;
2987
+ postSimpleMessage(fn: any, args: any): Promise<any>;
2988
+ postMessage(payload: any): Promise<any>;
2989
+ onUpdateWithState(data: any): Promise<any>;
2990
+ close(...params: any[]): void;
2991
+ waitTillRenderStage(...params: any[]): Promise<any>;
2992
+ getCameraDirection(...params: any[]): Promise<any>;
2993
+ getPosition(...params: any[]): Promise<any>;
2994
+ setNodeColor(...params: any[]): Promise<any>;
2995
+ clearNodeColor(...params: any[]): Promise<any>;
2996
+ clearAllNodeColor(...params: any[]): Promise<any>;
2997
+ setMeshnodeColor(...params: any[]): Promise<any>;
2998
+ setLookAt(...params: any[]): Promise<any>;
2999
+ getLookAt(...params: any[]): Promise<any>;
3000
+ getBenchmarkPoint(...params: any[]): Promise<any>;
3001
+ setBenchmarkPoint(...params: any[]): Promise<any>;
3002
+ setPosition(...params: any[]): Promise<any>;
3003
+ setCameraRotation(...params: any[]): Promise<any>;
3004
+ getGlobalOffset(...params: any[]): Promise<any>;
3005
+ getMeshnodeFromNodeId(...params: any[]): Promise<any>;
3006
+ onResize(...params: any[]): Promise<any>;
3007
+ getMeshnodeFromIndex(...params: any[]): Promise<any>;
3008
+ getMeasureObjectMeshes(...params: any[]): Promise<any>;
3009
+ extractEventVars(evt: any): {
3010
+ pageX: any;
3011
+ pageY: any;
3012
+ offsetX: any;
3013
+ offsetY: any;
3014
+ };
3015
+ onContextMenu(evt: any): Promise<any>;
3016
+ getContextMenuData(evt: any): Promise<any>;
3017
+ onSingleClick(evt: any): Promise<any>;
3018
+ onMouseMove(evt: any): Promise<any>;
3019
+ onWheel(evt: any): Promise<any>;
3020
+ resizeScene(...params: any[]): Promise<any>;
3021
+ onDoubleClick(evt: any): Promise<any>;
3022
+ onRightClick(evt: any): Promise<any>;
3023
+ getNumNodesHidden(...params: any[]): Promise<any>;
3024
+ hideSelected(...params: any[]): Promise<any>;
3025
+ hideNodeOffset(...params: any[]): Promise<any>;
3026
+ getHiddenNodeIds(...params: any[]): Promise<any>;
3027
+ getHiddenMeshnodeIndices(...params: any[]): Promise<any>;
3028
+ getHiddenGeoIdsSet(...params: any[]): Promise<any>;
3029
+ addHiddenMeshnodeIndices(...params: any[]): Promise<any>;
3030
+ removeHiddenGeoIds(...params: any[]): Promise<any>;
3031
+ setVisibility(...params: any[]): Promise<any>;
3032
+ getVisibility(...params: any[]): Promise<any>;
3033
+ getOrbitTranslate(evt: any): Promise<any>;
3034
+ ToScreenPosition(...params: any[]): Promise<any>;
3035
+ ModelToMapSpace(...params: any[]): Promise<any>;
3036
+ MapToModelSpace(...params: any[]): Promise<any>;
3037
+ setBcfCamera(...params: any[]): Promise<any>;
3038
+ getBcfCamera(...params: any[]): Promise<any>;
3039
+ refreshScene(...params: any[]): Promise<any>;
3040
+ refreshLighting(...params: any[]): Promise<any>;
3041
+ setSectionBox(...params: any[]): Promise<any>;
3042
+ setSectionsData(...params: any[]): Promise<any>;
3043
+ removeSectionBox(...params: any[]): Promise<any>;
3044
+ addSectionPlane(...params: any[]): Promise<any>;
3045
+ removeSectionPlane(...params: any[]): Promise<any>;
3046
+ getSections(...params: any[]): Promise<any>;
3047
+ clearSection(...params: any[]): Promise<any>;
3048
+ setOptions(...params: any[]): Promise<any>;
3049
+ setCanvasSelectionEnabled(...params: any[]): Promise<any>;
3050
+ findFirstObject(...params: any[]): Promise<any>;
3051
+ getNamedNode(...params: any[]): Promise<any>;
3052
+ setEulerAngles(...params: any[]): Promise<any>;
3053
+ setMeasureEnabled(...params: any[]): Promise<any>;
3054
+ statusChange(...params: any[]): Promise<any>;
3055
+ onUndo(...params: any[]): Promise<any>;
3056
+ getMeasureEnabled(...params: any[]): Promise<any>;
3057
+ getMeasureIds(...params: any[]): Promise<any>;
3058
+ removeMeasureIds(...params: any[]): Promise<any>;
3059
+ onRedo(...params: any[]): Promise<any>;
3060
+ clearMeasureIds(...params: any[]): Promise<any>;
3061
+ clearHidden(...params: any[]): Promise<any>;
3062
+ hasHiddenMeshnodeIndices(...params: any[]): Promise<any>;
3063
+ addSelectedMeshnodeIndices(...params: any[]): Promise<any>;
3064
+ clearAndSelectNode(...params: any[]): Promise<any>;
3065
+ clearAndSelectNodes(...params: any[]): Promise<any>;
3066
+ getNode(...params: any[]): Promise<any>;
3067
+ getNodes(...params: any[]): Promise<any>;
3068
+ getRootNode(...params: any[]): Promise<any>;
3069
+ setNodesSelected(...params: any[]): Promise<any>;
3070
+ getSelectedMeshnodeIndices(...params: any[]): Promise<any>;
3071
+ hasSelectedMeshnodeIndices(...params: any[]): Promise<any>;
3072
+ clearSelected(...params: any[]): Promise<any>;
3073
+ getFieldOfView(...params: any[]): Promise<any>;
3074
+ setFieldOfView(...params: any[]): Promise<any>;
3075
+ zoomToBoundingBox(...params: any[]): Promise<any>;
3076
+ setPose(...params: any[]): Promise<any>;
3077
+ zoomToGlobal(...params: any[]): Promise<any>;
3078
+ zoomToSelection(...params: any[]): Promise<any>;
3079
+ isolateSelectionInSectionBox(...params: any[]): Promise<any>;
3080
+ isolateSelection(...params: any[]): Promise<any>;
3081
+ zoomToNodes(...params: any[]): Promise<any>;
3082
+ unhideNodeFromNodeIds(...params: any[]): Promise<any>;
3083
+ hideNodesFromNodeIds(...params: any[]): Promise<any>;
3084
+ getNumNodesSelected(...params: any[]): Promise<any>;
3085
+ setRenderMode(...params: any[]): Promise<any>;
3086
+ getRenderMode(...params: any[]): Promise<any>;
3087
+ getSelectedNodeIds(...params: any[]): Promise<any>;
3088
+ toggleSectionBoxDisplay(...params: any[]): Promise<any>;
3089
+ togglePointToPoint(...params: any[]): Promise<any>;
3090
+ zoomToSectionBox(...params: any[]): Promise<any>;
3091
+ setSectionBoxHidden(...params: any[]): Promise<any>;
3092
+ resetSectionBox(...params: any[]): Promise<any>;
3093
+ constructObjectTreeFromNodeIds(...params: any[]): Promise<any>;
3094
+ clearFilteredObjectTree(...params: any[]): Promise<any>;
3095
+ getSectionBoxDisplayBbox(...params: any[]): Promise<any>;
3096
+ getSectionsAsBox(...params: any[]): Promise<any>;
3097
+ setPwfFileCacheState(...params: any[]): Promise<any>;
3098
+ partitionUrlsFromMeshnodeIndices(...params: any[]): Promise<any>;
3099
+ isPartitionedModel(...params: any[]): Promise<any>;
3100
+ getMeasureObjectMeshesPartition(...params: any[]): Promise<any>;
3101
+ }
3102
+
1357
3103
  export declare type RenderMode = (typeof RENDER_MODE)[keyof typeof RENDER_MODE];
1358
3104
 
1359
3105
  export declare type Resource = FileExtractionModePwfV1OverrideResource | FileExtractionModePwfV2OverrideResource | FileExtractionModeResource | ModelRevisionModePwfV1Resource | ModelRevisionModePwfV2Resource;
1360
3106
 
3107
+ declare type ResourceDiscriminator = {
3108
+ fileExtractionId: number;
3109
+ } | {
3110
+ modelRevisionId: number;
3111
+ };
3112
+
1361
3113
  export declare type ResourceOptions = CommonOptions & {
1362
3114
  resources: Resource[];
1363
3115
  };
@@ -1366,6 +3118,74 @@ export declare type RGB = `rgb(${number}, ${number}, ${number})`;
1366
3118
 
1367
3119
  export declare type RGBA = `rgba(${number}, ${number}, ${number}, ${number})`;
1368
3120
 
3121
+ declare type SceneGraphName = 'kdtree' | 'wasmtree';
3122
+
3123
+ declare class SectionController {
3124
+ static readonly TYPE: {
3125
+ NULL: number;
3126
+ BOX: number;
3127
+ PLANE: number;
3128
+ };
3129
+ private renderer;
3130
+ private sectionDisplay;
3131
+ private sectionDisplayEnabled;
3132
+ private defaultSection;
3133
+ private currentSectionType;
3134
+ private _globalOffset?;
3135
+ private box;
3136
+ constructor(params: {
3137
+ renderer: PartitionsRenderer;
3138
+ });
3139
+ /**
3140
+ * Existing SectionController Methods
3141
+ */
3142
+ get globalOffset(): THREE.Vector3;
3143
+ set globalOffset(offset: THREE.Vector3);
3144
+ setDefaultSection(min: THREE.Vector3, max: THREE.Vector3, rotation: THREE.Vector3): void;
3145
+ addSectionPlane(distance: number, normal: Vector3): void;
3146
+ removeSectionPlane(uuid: string): void;
3147
+ private getSectionsAsBcf;
3148
+ private getSectionsAsAutodesk;
3149
+ getSections(format: 'bcf' | 'autodesk'): SectionDataProcoreFormat | SectionDataAutodeskFormat | null;
3150
+ getSectionsAsBox(): OrientedBox | null;
3151
+ setSectionBox(min: Vector3, max: Vector3, rotation: Vector3 | null, applyOffset?: boolean): void;
3152
+ removeSectionBox(): void;
3153
+ clearSection(): void;
3154
+ private setSectionsAutodeskFormat;
3155
+ private setSectionsProcoreFormat;
3156
+ setSectionData(sectionData: SectionData, unit?: string): void;
3157
+ /**
3158
+ * SectionBoxDisplay Passthrough Methods
3159
+ */
3160
+ getSectionBoxDisplayBbox(): BoundingBox;
3161
+ clearSectionHover(): void;
3162
+ setSectionBoxHidden(hide: boolean): void;
3163
+ getSectionBoxHidden(): boolean;
3164
+ isSectionBoxHovered(): boolean;
3165
+ onMouseDown(): void;
3166
+ isSectionDisplayEnabled(): boolean;
3167
+ updateSectionDisplay(scene: THREE.Scene, camera: THREE.Camera): void;
3168
+ checkInsideSection(position: Vector3): boolean;
3169
+ resetSectionBox(): void;
3170
+ toggleSectionBoxDisplay(params: {
3171
+ enable: boolean;
3172
+ scene: THREE.Scene;
3173
+ }): void;
3174
+ setSectionBoxDisplay(bbox: BoundingBox): void;
3175
+ updateSectionHover(params: {
3176
+ camera: THREE.Camera;
3177
+ raycaster: THREE.Raycaster;
3178
+ }): boolean;
3179
+ insideSectionBox(position: THREE.Vector3): boolean;
3180
+ resizeSectionBox(params: {
3181
+ xyDelta: Vector2;
3182
+ cameraPosition: THREE.Vector3;
3183
+ cameraDirection: THREE.Vector3;
3184
+ }): void;
3185
+ }
3186
+
3187
+ declare type SectionData = SectionDataAutodeskFormat | SectionDataProcoreFormat;
3188
+
1369
3189
  export declare type SectionDataAutodeskFormat = {
1370
3190
  Type: 'ClipPlaneSet';
1371
3191
  Version: 1;
@@ -1378,6 +3198,107 @@ export declare type SectionDataAutodeskFormat = {
1378
3198
 
1379
3199
  export declare type SectionDataProcoreFormat = ProcoreFormatClipPlane[];
1380
3200
 
3201
+ declare class SectionRenderPass extends Pass {
3202
+ scene: THREE.Scene;
3203
+ camera: THREE.Camera;
3204
+ clearDepth: boolean;
3205
+ refresh: boolean;
3206
+ private sectionController;
3207
+ constructor(scene: THREE.Scene, camera: THREE.Camera, sectionController: SectionController);
3208
+ render(renderer: THREE.WebGLRenderer | any, _writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget): void;
3209
+ }
3210
+
3211
+ declare class SelectedNodeServices {
3212
+ private _selectionOption;
3213
+ private selectedVirtualMeshnodeIndicesByResourceId;
3214
+ private selectedFirstObjectCountByResourceId;
3215
+ private selectedNodeIdsByResourceId;
3216
+ private partiallySelectedNodeIdsByResourceId;
3217
+ private models;
3218
+ private objectTrees;
3219
+ static SelectMethod: {
3220
+ readonly Geometry: "Geometry";
3221
+ readonly FirstObject: "FirstObject";
3222
+ };
3223
+ constructor(params: {
3224
+ models: Models;
3225
+ objectTrees: Map<number, ObjectTree>;
3226
+ });
3227
+ get selectionOption(): SelectMethod;
3228
+ set selectionOption(method: SelectMethod);
3229
+ getSelectedVirtualMeshnodesSet(resourceId: number): Set<number>;
3230
+ addSelectedMeshnodeIndices(virtualMeshnodeIndices: number[], resourceId: number): void;
3231
+ private selectFirstObject;
3232
+ private selectGeometry;
3233
+ clear(resourceId: number): void;
3234
+ selectAll(resourceId: number): void;
3235
+ private nodeNeedsUpdating;
3236
+ updateSelectedAncestry(resourceId: number, nodeId: number, isSelected: boolean): void;
3237
+ private removeChildNodesFromPartiallySelected;
3238
+ private recursivelyUpdateParentNodes;
3239
+ setMeshnodeSelectedByVirtualIndex(virtualMeshnodeIndex: number, select: boolean): void;
3240
+ setMeshnodeSelected(meshnode: Meshnode, select: boolean, resourceId: number): void;
3241
+ setNodeSelected(internalNode: InternalNode, select: boolean, resourceId: number): void;
3242
+ private updateNodeAndChildren;
3243
+ getSelectedNodeIds(resourceId: number): Set<number>;
3244
+ getPartiallySelectedNodeIds(resourceId: number): Set<number>;
3245
+ getSelectedObjectCount(method: SelectMethod, resourceId: number): number;
3246
+ hasSelectedMeshnodeIndices(arr: number[], resourceId: number): boolean;
3247
+ removeSelectedMeshnodeIndices(virtualMeshnodeIndices: number[], resourceId: number): void;
3248
+ private unSelectGeometry;
3249
+ private unSelectFirstObject;
3250
+ }
3251
+
3252
+ declare type SelectMethod = keyof typeof SelectedNodeServices.SelectMethod;
3253
+
3254
+ declare type SetNodeColorParams = {
3255
+ palette: Palette;
3256
+ nodeIds: number[];
3257
+ };
3258
+
3259
+ declare class ShortestDistanceController {
3260
+ private measureSet;
3261
+ private models;
3262
+ constructor(params: {
3263
+ models: Models;
3264
+ });
3265
+ getMeasureIds(): number[];
3266
+ addMeasureIds(virtualMeshnodeIndices: number[]): void;
3267
+ clearMeasureIds(): void;
3268
+ hasMeasureIds(arr: number[]): boolean;
3269
+ removeMeasureIds(virtualMeshnodeIndices: number[]): void;
3270
+ handleMeasurementClick(virtualMeshnodeIndex: number): void;
3271
+ getMeasureObjectMeshes(): MeshnodeObject_3[];
3272
+ getMeasureObjectMeshesPartition(): Promise<MeshnodeObject_3[]>;
3273
+ }
3274
+
3275
+ declare function StatusTrackingController(camera: any, renderController: any): void;
3276
+
3277
+ declare class StatusTrackingController {
3278
+ constructor(camera: any, renderController: any);
3279
+ camera: any;
3280
+ renderController: any;
3281
+ cameraUndo: {
3282
+ pos: any;
3283
+ qua: any;
3284
+ }[];
3285
+ cameraRedo: any[];
3286
+ sectionUndo: any[];
3287
+ sectionRedo: any[];
3288
+ hiddenUndo: {
3289
+ hideNode: Set<any>;
3290
+ hideGeo: Set<any>;
3291
+ }[];
3292
+ hiddenRedo: any[];
3293
+ statesUndo: any[];
3294
+ statesRedo: any[];
3295
+ onStatusChange(types: any): void;
3296
+ onUndo(): void;
3297
+ onRedo(): void;
3298
+ setCamera(camera: any): void;
3299
+ setHideObject(hideObject: any): void;
3300
+ }
3301
+
1381
3302
  declare class StreamedGeometryFactory extends GeometryFactory {
1382
3303
  createMeshGeometry(vertexArray: Float32Array, indexArray: Uint16Array, color: number, opacity: number, drawType: number): StreamedMeshGeometry;
1383
3304
  createMeshGeometryPrefetching(vertexArray: Float32Array, indexArray: Uint16Array, color: number, opacity: number, drawType: number): StreamedMeshGeometry;
@@ -1398,7 +3319,7 @@ declare class StreamedMeshGeometry extends MeshGeometry {
1398
3319
  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);
1399
3320
  }
1400
3321
 
1401
- declare class StreamedMeshnode extends Meshnode_3 {
3322
+ declare class StreamedMeshnode extends Meshnode_2 {
1402
3323
  private _partitionProxy?;
1403
3324
  private _meshGeometries;
1404
3325
  setPartitionProxy(partitionProxy: PartitionProxy): void;
@@ -1406,11 +3327,11 @@ declare class StreamedMeshnode extends Meshnode_3 {
1406
3327
  meshGeometries(): MeshGeometry[];
1407
3328
  setMeshGeometry(meshIndex: number, meshGeometry: StreamedMeshGeometry): void;
1408
3329
  getMeshGeometry(meshIndex: number): StreamedMeshGeometry | undefined;
1409
- asObject(): MeshnodeObject_2;
3330
+ asObject(): MeshnodeObject;
1410
3331
  private getMeshObject;
1411
3332
  }
1412
3333
 
1413
- declare class StreamedMeshnode_2 extends Meshnode_2 {
3334
+ declare class StreamedMeshnode_2 extends Meshnode_3 {
1414
3335
  private _partitionProxy?;
1415
3336
  private _meshGeometries;
1416
3337
  setPartitionProxy(partitionProxy: PartitionProxy_2): void;
@@ -1418,27 +3339,19 @@ declare class StreamedMeshnode_2 extends Meshnode_2 {
1418
3339
  meshGeometries(): MeshGeometry[];
1419
3340
  setMeshGeometry(meshIndex: number, meshGeometry: StreamedMeshGeometry): void;
1420
3341
  getMeshGeometry(meshIndex: number): StreamedMeshGeometry | undefined;
1421
- asObject(): MeshnodeObject;
3342
+ asObject(): MeshnodeObject_2;
1422
3343
  private getMeshObject;
1423
3344
  }
1424
3345
 
1425
3346
  declare class StreamedMeshnodeServices extends MeshnodeServices {
1426
- protected createMeshnode(pwfMeshnode: PWFMeshnode_2): Meshnode_3;
3347
+ protected createMeshnode(pwfMeshnode: PWFMeshnode): Meshnode_2;
1427
3348
  }
1428
3349
 
1429
3350
  declare class StreamedMeshnodeServices_2 extends MeshnodeServices_2 {
1430
- protected createMeshnode(pwfMeshnode: PWFMeshnode): Meshnode_2;
3351
+ protected createMeshnode(pwfMeshnode: PWFMeshnode_2): Meshnode_3;
1431
3352
  }
1432
3353
 
1433
3354
  declare class StreamedMeshServices extends MeshServices {
1434
- constructor(pwf: PWFV2);
1435
- getMeshObject(meshOffset: number): MeshObject_2;
1436
- loadPartitionContainingMeshnode(streamedMeshnode: StreamedMeshnode): Promise<void>;
1437
- getMeshGeometryForOffsets(meshOffset: number, meshnodeOffset: number): StreamedMeshGeometry | undefined;
1438
- dispose(): void;
1439
- }
1440
-
1441
- declare class StreamedMeshServices_2 extends MeshServices_2 {
1442
3355
  private readonly featureFlags;
1443
3356
  private meshIndexToOPFSRecord;
1444
3357
  private opfsFile?;
@@ -1449,15 +3362,69 @@ declare class StreamedMeshServices_2 extends MeshServices_2 {
1449
3362
  });
1450
3363
  initOPFS(): Promise<void>;
1451
3364
  closeOPFS(): Promise<void>;
1452
- writeMeshDataToOPFS(meshData: MeshData_2): Promise<void>;
3365
+ writeMeshDataToOPFS(meshData: MeshData): Promise<void>;
1453
3366
  getMeshObject(meshIndex: number): MeshObject;
1454
- loadPartitionContainingMeshnode(streamedMeshnode: StreamedMeshnode_2): Promise<void>;
3367
+ loadPartitionContainingMeshnode(streamedMeshnode: StreamedMeshnode): Promise<void>;
1455
3368
  getMeshGeometryForOffsets(meshOffset: number, meshnodeOffset: number): StreamedMeshGeometry | undefined;
1456
- meshFromOffset(meshIndex: number): Mesh_2;
3369
+ meshFromOffset(meshIndex: number): Mesh;
1457
3370
  private getCompressedMeshDataFromOPFS;
1458
3371
  dispose(): void;
1459
3372
  }
1460
3373
 
3374
+ declare class StreamedMeshServices_2 extends MeshServices_2 {
3375
+ constructor(pwf: PWFV2);
3376
+ getMeshObject(meshOffset: number): MeshObject_2;
3377
+ loadPartitionContainingMeshnode(streamedMeshnode: StreamedMeshnode_2): Promise<void>;
3378
+ getMeshGeometryForOffsets(meshOffset: number, meshnodeOffset: number): StreamedMeshGeometry | undefined;
3379
+ dispose(): void;
3380
+ }
3381
+
3382
+ declare type SvgData = {
3383
+ ellipses?: (BoxEllipse | RadiusEllipse)[];
3384
+ lines?: Line[];
3385
+ arrows?: Arrow[];
3386
+ texts?: Text_2[];
3387
+ rects?: Rect[];
3388
+ custom?: CustomSvg[];
3389
+ };
3390
+
3391
+ declare class SvgRenderer {
3392
+ private svgEl;
3393
+ private dom;
3394
+ private arrowId;
3395
+ private camera;
3396
+ private anchoredSvgData;
3397
+ private _renderControllerProxy;
3398
+ private _globalOffset;
3399
+ constructor();
3400
+ private static createSvgEl;
3401
+ private calculateScaleFactor;
3402
+ private onRenderReady;
3403
+ private onResize;
3404
+ private set globalOffset(value);
3405
+ private get globalOffset();
3406
+ set renderControllerProxy(renderControllerProxy: RenderControllerProxy);
3407
+ get renderControllerProxy(): RenderControllerProxy;
3408
+ private hasAnchoredElements;
3409
+ private onCameraUpdated;
3410
+ private computeFromAnchored;
3411
+ private saveAnchoredSvgData;
3412
+ private collateByZIndex;
3413
+ draw(svgData: SvgData): void;
3414
+ drawAnchored(anchoredSvgData: AnchoredSvgData): Promise<void>;
3415
+ drawEllipse(ellipse: BoxEllipse | RadiusEllipse): void;
3416
+ drawLine(line: Line): void;
3417
+ drawArrow(arrow: Arrow): void;
3418
+ drawText(text: Text_2): void;
3419
+ drawRect(rect: Rect): void;
3420
+ drawCustomSvg(customSvg: AnchoredCustomSvg): void;
3421
+ private clipLine;
3422
+ private _clear;
3423
+ clear(): void;
3424
+ hasContent(): boolean;
3425
+ dispose(): void;
3426
+ }
3427
+
1461
3428
  export declare class TestRoutineRecorder {
1462
3429
  camera: Camera;
1463
3430
  points: Point[];
@@ -1469,6 +3436,14 @@ export declare class TestRoutineRecorder {
1469
3436
  print(): void;
1470
3437
  }
1471
3438
 
3439
+ declare type Text_2 = {
3440
+ origin: Vector2;
3441
+ text: string;
3442
+ font?: CssFont;
3443
+ fill: CssColor;
3444
+ zIndex?: number;
3445
+ };
3446
+
1472
3447
  export declare const TOOL: {
1473
3448
  readonly ALL: 0;
1474
3449
  readonly BOTTOMTOOL: 1;
@@ -1486,6 +3461,7 @@ export declare const TOOL: {
1486
3461
  readonly LOADING: 13;
1487
3462
  readonly XRAY_MODE: 14;
1488
3463
  readonly SECTION_BOX: 15;
3464
+ readonly PINS: 16;
1489
3465
  };
1490
3466
 
1491
3467
  export declare type Tool = (typeof TOOL)[keyof typeof TOOL];
@@ -1505,6 +3481,7 @@ export declare const TOOL_BAR_TOOLS: {
1505
3481
  readonly CONTEXT_MENU: 11;
1506
3482
  readonly XRAY_MODE: 12;
1507
3483
  readonly SECTION_BOX: 13;
3484
+ readonly PINS: 14;
1508
3485
  };
1509
3486
 
1510
3487
  export declare type ToolBarTools = (typeof TOOL_BAR_TOOLS)[keyof typeof TOOL_BAR_TOOLS];
@@ -1565,6 +3542,44 @@ export declare type Vector3 = {
1565
3542
 
1566
3543
  export declare const version: string;
1567
3544
 
3545
+ declare interface ViewerRenderer {
3546
+ initialize(measureSet: number[], models: Models, colorService: ColorServices): void;
3547
+ autoClear: boolean;
3548
+ domElement: HTMLCanvasElement;
3549
+ clippingPlanes: any[];
3550
+ refresh: boolean;
3551
+ context: WebGLRenderingContext;
3552
+ getSize(): {
3553
+ width: number;
3554
+ height: number;
3555
+ };
3556
+ getPixelRatio(): number;
3557
+ getContext(): WebGLRenderingContext;
3558
+ getRenderTarget(): THREE.WebGLRenderTarget;
3559
+ setRenderTarget(renderTarget: THREE.WebGLRenderTarget): void;
3560
+ clear(): void;
3561
+ setSize(width: number, height: number): void;
3562
+ render(scene: THREE.Scene, camera: THREE.Camera): void;
3563
+ cleanBuffer(): void;
3564
+ textures: {
3565
+ picking: THREE.WebGLRenderTarget;
3566
+ };
3567
+ readRenderTargetPixels(renderTarget: THREE.WebGLRenderTarget, x: number, y: number, width: number, height: number, buffer: Uint8Array): void;
3568
+ setRenderMode(mode: RenderMode): void;
3569
+ getRenderMode(): string;
3570
+ setDetailsParams(detailsParam: {
3571
+ detailsInMotion: number;
3572
+ detailsAtRest: number;
3573
+ }): void;
3574
+ getRenderingStage(): string;
3575
+ dispose(): void;
3576
+ enableBackFaceFillColor(state: boolean): void;
3577
+ loadMeshShader(): void;
3578
+ renderSection(scene: THREE.Scene, camera: THREE.Camera): void;
3579
+ getWebGLRenderer(): THREE.WebGLRenderer;
3580
+ setGeometryFactory(geometryFactory: GeometryFactory): void;
3581
+ }
3582
+
1568
3583
  export declare type Viewpoint = {
1569
3584
  camera_data: string;
1570
3585
  sections_data: string;
@@ -1581,6 +3596,20 @@ export declare type Visibility = {
1581
3596
  };
1582
3597
  };
1583
3598
 
3599
+ declare class WASMTree {
3600
+ static maxChunkSize: number;
3601
+ meshnodes: any[];
3602
+ currentIndex: number;
3603
+ cullTree(cameraPosition: any, projectViewMatrix: any, detailsFactor: any): {
3604
+ opaques: Set<any>;
3605
+ transparents: Set<any>;
3606
+ };
3607
+ maxChunkSize: number;
3608
+ buildTree(meshnodes: any): {
3609
+ isComplete: boolean;
3610
+ };
3611
+ }
3612
+
1584
3613
  export declare type WebFormatExtractionItem = {
1585
3614
  item_type: 'WebFormat';
1586
3615
  artifact: {
@@ -1595,6 +3624,7 @@ export declare type WebFormatExtractionItem = {
1595
3624
 
1596
3625
  export declare class Webviewer {
1597
3626
  options: Options;
3627
+ pinsManager: PinsManager;
1598
3628
  private readonly measurementRenderer;
1599
3629
  private readonly measurementManager;
1600
3630
  static readonly tools: {
@@ -1614,6 +3644,7 @@ export declare class Webviewer {
1614
3644
  readonly LOADING: 13;
1615
3645
  readonly XRAY_MODE: 14;
1616
3646
  readonly SECTION_BOX: 15;
3647
+ readonly PINS: 16;
1617
3648
  };
1618
3649
  static readonly toolbar_enum: {
1619
3650
  readonly NONE: 0;
@@ -1630,6 +3661,7 @@ export declare class Webviewer {
1630
3661
  readonly CONTEXT_MENU: 11;
1631
3662
  readonly XRAY_MODE: 12;
1632
3663
  readonly SECTION_BOX: 13;
3664
+ readonly PINS: 14;
1633
3665
  };
1634
3666
  static readonly action: {
1635
3667
  readonly NONE: -1;
@@ -1803,13 +3835,6 @@ export declare class Webviewer {
1803
3835
  clearAllObjectColor: (options?: {
1804
3836
  resourceId?: number;
1805
3837
  }) => Promise<void> | void;
1806
- setPickable: (objectIds: number[], options?: {
1807
- pickable?: boolean;
1808
- resourceId?: number;
1809
- }) => Promise<void>;
1810
- clearPickable: (options?: {
1811
- resourceId?: number;
1812
- }) => Promise<void>;
1813
3838
  filterObjectTree: (objectIds: number[]) => Promise<void>;
1814
3839
  clearObjectTreeFilter: () => Promise<void>;
1815
3840
  getViewpoint: (options?: {
@@ -1865,4 +3890,24 @@ export declare class Webviewer {
1865
3890
  terminate: () => void;
1866
3891
  }
1867
3892
 
3893
+ declare type WheelControl = {
3894
+ onWheel: (event: WheelEvent) => void;
3895
+ dispose: () => void;
3896
+ };
3897
+
3898
+ declare function WindowPinsCreationComponent(options: any, domController: any): void;
3899
+
3900
+ declare class WindowPinsCreationComponent {
3901
+ constructor(options: any, domController: any);
3902
+ domController: any;
3903
+ submitButton: HTMLButtonElement | null;
3904
+ cancelButton: HTMLButtonElement | null;
3905
+ imageElement: HTMLImageElement | null;
3906
+ toolId: 16;
3907
+ createFooterHtml(): void;
3908
+ createHtml(): void;
3909
+ dispose(): void;
3910
+ show(): Promise<any>;
3911
+ }
3912
+
1868
3913
  export { }