@procore/bim-webviewer-sdk 16.0.0 → 16.1.0-BIM-4505.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 (50) hide show
  1. package/CHANGELOG.md +22 -0
  2. package/dist/Procore.Bim.Webviewer.d.ts +1998 -13
  3. package/dist/Procore.Bim.Webviewer.js +1 -1
  4. package/dist/types/src/Webviewer.d.ts +10 -0
  5. package/dist/types/src/components/CoachmarkManagerComponent/CoachmarkComponent.d.ts +2 -0
  6. package/dist/types/src/components/CoachmarkManagerComponent/CoachmarkManagerComponent.d.ts +9 -0
  7. package/dist/types/src/components/CoachmarkManagerComponent/Coachmarks.d.ts +2 -0
  8. package/dist/types/src/components/Markup/SvgRenderer.d.ts +5 -2
  9. package/dist/types/src/components/Markup/__tests__/fixtures.d.ts +1 -1
  10. package/dist/types/src/components/ShortestDistanceComponent.d.ts +2 -1
  11. package/dist/types/src/components/Tooltip/Tooltip.d.ts +22 -0
  12. package/dist/types/src/components/Tooltip/__tests__/Tooltip.test.d.ts +1 -0
  13. package/dist/types/src/components/Tooltip/index.d.ts +1 -0
  14. package/dist/types/src/controllers/PubSubController.d.ts +5 -0
  15. package/dist/types/src/controllers/RenderController.d.ts +12 -23
  16. package/dist/types/src/controllers/RenderControllerProxy.d.ts +4 -18
  17. package/dist/types/src/controllers/RenderControllerWorker.d.ts +2 -0
  18. package/dist/types/src/measuring/MeasureToolUtils.d.ts +45 -0
  19. package/dist/types/src/measuring/PointToPointController.d.ts +50 -0
  20. package/dist/types/src/measuring/PointToPointManager.d.ts +42 -0
  21. package/dist/types/src/measuring/__tests__/MeasureToolUtils.test.d.ts +1 -0
  22. package/dist/types/src/measuring/__tests__/PointToPointController.test.d.ts +1 -0
  23. package/dist/types/src/measuring/__tests__/PointToPointFixtures.d.ts +184 -0
  24. package/dist/types/src/measuring/__tests__/PointToPointManager.test.d.ts +1 -0
  25. package/dist/types/src/measuring/createPointToPointControllerDebugGui.d.ts +2 -0
  26. package/dist/types/src/measuring/createPointToPointManagerDebugGui.d.ts +7 -0
  27. package/dist/types/src/measuring/index.d.ts +2 -0
  28. package/dist/types/src/navigation/DefaultControl.d.ts +11 -0
  29. package/dist/types/src/picking/PickingController.d.ts +1 -0
  30. package/dist/types/src/procoregl/GeometryFactory.d.ts +1 -0
  31. package/dist/types/src/procoregl/MeshGeometry.d.ts +6 -2
  32. package/dist/types/src/procoregl/MeshTopology/MeshTopology.d.ts +1 -2
  33. package/dist/types/src/procoregl/MeshTopology/__tests__/TopologyFixtures.d.ts +9 -7
  34. package/dist/types/src/procoregl/Models/Models.d.ts +7 -5
  35. package/dist/types/src/procoregl/PartitionsRenderer.d.ts +1 -0
  36. package/dist/types/src/procoregl/PartitionsRendererImpl.d.ts +2 -0
  37. package/dist/types/src/procoregl/SelectedNodeServices/SelectedNodeServices.d.ts +23 -22
  38. package/dist/types/src/procoregl/StreamedMeshGeometry.d.ts +1 -2
  39. package/dist/types/src/procoregl/ViewerRenderer.d.ts +2 -0
  40. package/dist/types/src/pwfreader/PWF.d.ts +1 -1
  41. package/dist/types/src/pwfreader/pwf/impl/pwfNoCache/PWFMeshNoCache.d.ts +1 -0
  42. package/dist/types/src/pwfreader/pwf/impl/recordReader/PWFMeshDataReader.d.ts +1 -0
  43. package/dist/types/src/pwfreader/pwf/impl/recordReader/PWFMeshReader.d.ts +1 -0
  44. package/dist/types/src/pwfreader/shared/Meshnode.d.ts +4 -6
  45. package/dist/types/src/utils/LRUCache.d.ts +5 -5
  46. package/dist/types/src/utils/MathHelper/MathHelper.d.ts +17 -0
  47. package/dist/types/src/utils/MathHelper/__tests__/MathHelper.test.d.ts +1 -0
  48. package/dist/types/src/utils/MathHelper/index.d.ts +1 -0
  49. package/package.json +1 -1
  50. package/dist/types/src/procoregl/__tests__/MockMeshnode.d.ts +0 -13
@@ -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,44 @@ 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 AnchoredLine = Omit<Line, 'start' | 'end'> & AnchorableLine;
50
+
51
+ declare type AnchoredRadiusEllipse = Omit<RadiusEllipse, 'center'> & Anchorable;
52
+
53
+ declare type AnchoredRect = Omit<Rect, 'x' | 'y'> & Anchorable;
54
+
55
+ declare type AnchoredSvgData = {
56
+ ellipses?: (AnchoredBoxEllipse | AnchoredRadiusEllipse)[];
57
+ lines?: AnchoredLine[];
58
+ arrows?: AnchoredArrow[];
59
+ texts?: AnchoredText[];
60
+ rects?: AnchoredRect[];
61
+ };
62
+
63
+ declare type AnchoredText = Omit<Text_2, 'origin'> & Anchorable;
64
+
65
+ declare type Arrow = {
66
+ start: Vector2;
67
+ end: Vector2;
68
+ stroke: CssColor;
69
+ strokeWidth: number;
70
+ zIndex?: number;
71
+ };
72
+
13
73
  export declare type Attachment = {
14
74
  id: number;
15
75
  content_type: string;
@@ -71,11 +131,24 @@ export declare type BimFileUpload = {
71
131
  attachment: Attachment;
72
132
  };
73
133
 
134
+ declare type BootstrapperResult = {
135
+ isComplete: boolean;
136
+ };
137
+
74
138
  export declare type BoundingBox = {
75
139
  max: Vector3;
76
140
  min: Vector3;
77
141
  };
78
142
 
143
+ declare type BoxEllipse = {
144
+ min: Vector2;
145
+ max: Vector2;
146
+ stroke: CssColor;
147
+ fill?: CssColor;
148
+ strokeWidth: number;
149
+ zIndex?: number;
150
+ };
151
+
79
152
  declare class BVHTree {
80
153
  static maxChunkSize: number;
81
154
  constructor(pwf: any);
@@ -101,6 +174,33 @@ declare type Color = {
101
174
  opacity: number;
102
175
  };
103
176
 
177
+ declare class ColorServices {
178
+ private _palettes;
179
+ private meshnodeToPalette;
180
+ private models;
181
+ private resourceIdToVirtualMeshnodeIndexes;
182
+ constructor(params: {
183
+ models: Models;
184
+ });
185
+ setNodeColor(params: {
186
+ colorPalettes: SetNodeColorParams[];
187
+ resourceId: number;
188
+ }): void;
189
+ setMeshnodeColor(params: {
190
+ palette: Palette;
191
+ virtualMeshnodeIndex: number;
192
+ resourceId: number;
193
+ }): void;
194
+ clearNodeColor(params: {
195
+ nodeIds: number[];
196
+ resourceId: number;
197
+ }): void;
198
+ clearAllNodeColor(resourceId: number): void;
199
+ getPaletteByVirtualMeshnodeIndex(virtualMeshnodeIdx: number): Palette | undefined;
200
+ get palettes(): Palette[];
201
+ private addPalette;
202
+ }
203
+
104
204
  export declare type CommonOptions = {
105
205
  /**
106
206
  * Always required
@@ -148,6 +248,13 @@ export declare type CommonOptions = {
148
248
 
149
249
  export declare type CssColor = RGB | RGBA | HEX | string;
150
250
 
251
+ declare type CssFont = string;
252
+
253
+ declare type DownloadMetaData = {
254
+ modelCached: boolean;
255
+ timeToDownload: number;
256
+ };
257
+
151
258
  export declare namespace ErrorLogger {
152
259
  let logger: Logger;
153
260
  const init: (params: {
@@ -235,6 +342,7 @@ declare class GeometryFactory {
235
342
  protected gl: WebGL2RenderingContext;
236
343
  constructor(gl: WebGL2RenderingContext);
237
344
  createDataBuffer(vertexArray: Float32Array, indexArray: Uint16Array): GPUMeshData;
345
+ bindBuffer(meshData: GPUMeshData): void;
238
346
  createCylinderBuffer(vertexArray: Float32Array, indexArray: Uint16Array): GPUMeshData;
239
347
  protected newVertexBuffer(_size?: number): void;
240
348
  protected newIndexBuffer(_size?: number): void;
@@ -249,11 +357,106 @@ export declare type GeometryFile = {
249
357
  declare type GPUMeshData = {
250
358
  index: number;
251
359
  f_byte_size: number;
252
- vertexArrayObject: WebGLVertexArrayObject | null;
360
+ vertexBufferIndex: number;
361
+ indexBufferIndex: number;
362
+ vertexPosition: number;
253
363
  };
254
364
 
255
365
  export declare type HEX = `#${string}`;
256
366
 
367
+ declare class HiddenNodeServices {
368
+ private hiddenObjectCountByResourceId;
369
+ private hiddenMeshnodeIndicesByResourceId;
370
+ private hiddenNodesIdsByResourceId;
371
+ private models;
372
+ private objectTrees;
373
+ constructor(params: {
374
+ models: Models;
375
+ objectTrees: Map<number, ObjectTree>;
376
+ });
377
+ getCount: (resourceId: number) => number;
378
+ getHiddenMeshnodeIndices: (resourceId: number) => Set<number>;
379
+ getHiddenNodeIds: (resourceId: number) => Set<number>;
380
+ setMeshnodeHidden: (virtualMeshnodeIndex: number, hidden: boolean) => void;
381
+ setNodeHidden: (objectTreeNode: InternalNode, hidden: boolean, resourceId: number) => void;
382
+ setMeshnodeHiddenFromSet: (virtualMeshnodeIndexes: Set<number>, hidden: boolean) => void;
383
+ setNodeHiddenFromSet: (nodeIds: Set<number>, hidden: boolean, resourceId: number) => void;
384
+ clear: (resourceId: number) => void;
385
+ hideAll(resourceId: number): void;
386
+ hasMeshnodeIndices: (indexes: Array<number>, resourceId: number) => boolean;
387
+ private nodeNeedsUpdating;
388
+ getVisibility: (resourceId: number, options?: {
389
+ defaultVisibilityAlwaysTrue?: boolean | undefined;
390
+ }) => Visibility;
391
+ setVisibility: (visibility: Visibility, resourceId: number) => void;
392
+ private updateNodeAndChildren;
393
+ private updateNodeAndParentsDF;
394
+ private setNodeHiddenIfChildrenHidden;
395
+ private updateNodesAndParentsByIdBF;
396
+ updateHiddenAncestry: (nodeId: number, hidden: boolean, resourceId: number) => void;
397
+ }
398
+
399
+ declare class Hotkeys implements KeyboardControl {
400
+ private renderControllerProxy;
401
+ private navigationManager;
402
+ private _enabled;
403
+ constructor(params: {
404
+ renderControllerProxy: RenderControllerProxy;
405
+ navigationManager: NavigationManager;
406
+ });
407
+ get enabled(): boolean;
408
+ set enabled(value: boolean);
409
+ onKeyDown: (event: KeyboardEvent) => void;
410
+ onKeyUp: () => void;
411
+ private publishSelectedToolEvent;
412
+ dispose(): void;
413
+ }
414
+
415
+ declare type InternalNode = {
416
+ id: number;
417
+ parentId: number | undefined;
418
+ children: number[];
419
+ meshnodes: number[];
420
+ isFirstObject: boolean;
421
+ };
422
+
423
+ declare class KDTree {
424
+ private MAX_CHILDREN_PER_NODE;
425
+ private readonly root;
426
+ private frustum;
427
+ private queue;
428
+ private readonly result;
429
+ meshnodes: Meshnode[];
430
+ constructor();
431
+ cullTree(cameraPosition: Vector3_3, frustumMatrix: Matrix4, detailsParam: number): {
432
+ opaques: Set<Meshnode>;
433
+ transparents: Set<Meshnode>;
434
+ };
435
+ buildTree(meshnodes: Meshnode[]): {
436
+ isComplete: boolean;
437
+ };
438
+ collectMeshnodes(cameraPosition: Vector3_3, detailsFactor: number): {
439
+ opaques: Set<Meshnode>;
440
+ transparents: Set<Meshnode>;
441
+ };
442
+ }
443
+
444
+ declare type KeyboardControl = {
445
+ onKeyDown: (event: KeyboardEvent) => void;
446
+ onKeyUp: (event: KeyboardEvent) => void;
447
+ dispose: () => void;
448
+ };
449
+
450
+ declare type Line = {
451
+ start: Vector2;
452
+ end: Vector2;
453
+ stroke: CssColor;
454
+ strokeWidth: number;
455
+ strokeDasharray?: string;
456
+ opacity?: number;
457
+ zIndex?: number;
458
+ };
459
+
257
460
  declare interface Logger {
258
461
  logError(error: any): void;
259
462
  }
@@ -269,11 +472,7 @@ declare type Manifest = {
269
472
  globalOffset: Vector3;
270
473
  };
271
474
 
272
- declare type Mesh = {
273
- [key: string]: any;
274
- };
275
-
276
- declare class Mesh_2 {
475
+ declare class Mesh {
277
476
  private pwfMesh;
278
477
  constructor(pwfMesh: PWFMesh);
279
478
  offset(): number;
@@ -309,11 +508,13 @@ declare class MeshData {
309
508
  declare class MeshGeometry {
310
509
  index: number;
311
510
  indexLength: number;
312
- vertexArrayObject: WebGLVertexArrayObject | null;
313
511
  color: number;
314
512
  opacity: number;
315
513
  drawType: number;
316
514
  numFaces: number;
515
+ vertexBufferIndex: number;
516
+ indexBufferIndex: number;
517
+ vertexPosition: number;
317
518
  constructor(meshData: GPUMeshData, color: number, opacity: number, drawType: number);
318
519
  }
319
520
 
@@ -324,6 +525,7 @@ declare class Meshnode {
324
525
  private centerValue?;
325
526
  private meshDataValue?;
326
527
  private meshGeometriesValue?;
528
+ private matrixWorldValue?;
327
529
  protected pwf: PWF;
328
530
  selected: boolean;
329
531
  private _parent?;
@@ -337,6 +539,7 @@ declare class Meshnode {
337
539
  box3(): NonNullable<Meshnode['box3Value']>;
338
540
  center(): THREE.Vector3;
339
541
  matrix(): Float32Array;
542
+ matrixWorld(): THREE.Matrix4;
340
543
  group(): number;
341
544
  opaque(): number;
342
545
  numChild(): number;
@@ -347,7 +550,7 @@ declare class Meshnode {
347
550
  virtualIndex(): number;
348
551
  meshGeometries(): MeshGeometry[];
349
552
  protected geometries(): MeshGeometry[];
350
- private meshData;
553
+ meshData(): NonNullable<Meshnode['meshDataValue']>;
351
554
  isRoot(): boolean;
352
555
  hidden(): Meshnode['hiddenValue'];
353
556
  setHidden(hidden: boolean): void;
@@ -360,7 +563,7 @@ declare type MeshnodeObject = {
360
563
  matrix: Float32Array;
361
564
  numChild: number;
362
565
  childRefs: Uint32Array;
363
- meshData: Mesh[];
566
+ meshData: Record<string, unknown>[];
364
567
  nodeId: number;
365
568
  meshnodeIndex: number;
366
569
  hidden: boolean;
@@ -407,7 +610,7 @@ declare class MeshServices {
407
610
  constructor(pwfMeshes: PWFMesh[], pwf: PWF);
408
611
  setGeometryFactory(geometryFactory: GeometryFactory): void;
409
612
  getMeshGeometryForOffsets(meshOffset: number, _meshnodeOffset: number | undefined): MeshGeometry | undefined;
410
- meshFromOffset(offset: number): Mesh_2;
613
+ meshFromOffset(offset: number): Mesh;
411
614
  numMeshes(): number;
412
615
  meshes(): PWFMesh[];
413
616
  loadAllMeshGeometryToGPU(): {
@@ -438,6 +641,14 @@ export declare type Model = {
438
641
  id: number;
439
642
  };
440
643
 
644
+ declare type ModelDescriptor = {
645
+ resource: ResourceDiscriminator;
646
+ meshAB: ArrayBuffer;
647
+ meshnodeAB: ArrayBuffer;
648
+ nodeAB: ArrayBuffer;
649
+ manifest?: Record<string, unknown>;
650
+ };
651
+
441
652
  declare type ModelInitializationPayload = {
442
653
  success: boolean;
443
654
  start_timestamp: number;
@@ -486,8 +697,102 @@ export declare type ModelRevisionViewpoint = Viewpoint & {
486
697
  primary: boolean;
487
698
  };
488
699
 
700
+ declare class Models {
701
+ private resourceIds;
702
+ private pwfs;
703
+ private currentParsingPwfIndex;
704
+ private streaming;
705
+ private static PREFETCHING_PARTITIONS;
706
+ private geometryFactory?;
707
+ private objectTrees;
708
+ private selectionOption;
709
+ private startTimestamp;
710
+ private startTime;
711
+ private partitionProxiesLoaded;
712
+ private sceneGraph;
713
+ private tempVirtualizedMeshnodes;
714
+ private detailsParams?;
715
+ private isLogging;
716
+ constructor(params: {
717
+ sceneGraphName: SceneGraphName;
718
+ isLogging: boolean;
719
+ locale: string;
720
+ downloadMetaData: DownloadMetaData;
721
+ modelDescriptors: ModelDescriptor[];
722
+ selectionOption: SelectMethod;
723
+ startTimestamp: number;
724
+ startTime: number;
725
+ });
726
+ private sceneGraphFactory;
727
+ getResourceId: (resource: ResourceDiscriminator) => number;
728
+ getAllResourceIds(): number[];
729
+ getPwf(resourceId: number): PWF;
730
+ getObjectTrees(resourceId: number): Map<string, ObjectTree>;
731
+ getSceneGraph(): KDTree | WASMTree;
732
+ initPwfParser(): void;
733
+ parsePwfNodes(): BootstrapperResult;
734
+ parsePwfMeshnodes(): BootstrapperResult;
735
+ parsePwfMeshes(): void;
736
+ initMeshServices(): void;
737
+ initNodeServices(): void;
738
+ initMeshnodeServices(): void;
739
+ initNodeTree(): BootstrapperResult;
740
+ initNodeTreeBoundingBoxes(): BootstrapperResult;
741
+ initSceneGraph(): BootstrapperResult;
742
+ captureModelStats(): {
743
+ detailsInMotion: number;
744
+ detailsAtRest: number;
745
+ };
746
+ getResourceFromVirtualMeshnodeIndex(virtualMeshnodeIndex: number): number;
747
+ getMeshnodeFromVirtualIndex(virtualMeshnodeIndex: number): {
748
+ meshnode: Meshnode;
749
+ resourceId: number;
750
+ };
751
+ getMeshnodeFromVirtualIndexAndResourceId(virtualMeshnodeIndex: number, resourceId: number): Meshnode;
752
+ getMeshnodeVirtualIndexFromMeshnodeIndex(params: {
753
+ resourceId: number;
754
+ meshnodeIndex: number;
755
+ }): number;
756
+ getMeshVerticesAndFaces(params: {
757
+ resourceId: number;
758
+ meshRef: number;
759
+ }): MeshVerticesAndFaces;
760
+ globalOffset(resourceId: number): {
761
+ offsetX: number;
762
+ offsetY: number;
763
+ offsetZ: number;
764
+ };
765
+ initGeometryFactory(params: {
766
+ viewerRenderer: ViewerRenderer;
767
+ }): void;
768
+ private instantiateGeometryFactory;
769
+ initTreeServices(): BootstrapperResult;
770
+ getInitEventPayload(params: {
771
+ pwf: PWF;
772
+ success: boolean;
773
+ }): ModelInitializationPayload;
774
+ initPartitionedGeometry(): BootstrapperResult;
775
+ loadAllMeshGeometryToGPU(): BootstrapperResult;
776
+ private forEachResourceInterruptible;
777
+ getVirtualMeshnodeIndexesByNodeId(params: {
778
+ nodeId: number;
779
+ resourceId: number;
780
+ }): number[];
781
+ findFirstObjectNodeId(params: {
782
+ virtualMeshnodeIndex: number;
783
+ resourceId: number;
784
+ }): number;
785
+ }
786
+
489
787
  declare type ModelType = 'standard' | 'partitioned' | undefined;
490
788
 
789
+ declare type MouseControl = {
790
+ onMouseDown: (event: MouseEvent) => void;
791
+ onMouseUp: (event: MouseEvent) => void;
792
+ onMouseMove: (event: MouseEvent) => void;
793
+ dispose: () => void;
794
+ };
795
+
491
796
  export declare const NAV_MODE: {
492
797
  readonly DEFAULT: 0;
493
798
  readonly FLY: 1;
@@ -498,8 +803,149 @@ export declare const NAV_MODE: {
498
803
  readonly SURVEY: 6;
499
804
  };
500
805
 
806
+ declare class NavigationManager {
807
+ private renderControllerProxy;
808
+ private canvas;
809
+ private isMoved;
810
+ private wheeling?;
811
+ private _selectedNavigationMode;
812
+ private _mouseControls;
813
+ private _wheelControls;
814
+ keyboardControls: KeyboardControl;
815
+ private static DEBUG;
816
+ private debugEl?;
817
+ private modifierKeys;
818
+ private lastMousemoveEvent?;
819
+ constructor(params: {
820
+ renderWrapperController: RenderControllerProxy;
821
+ canvas: HTMLCanvasElement;
822
+ });
823
+ get mouseControls(): MouseControl;
824
+ private set mouseControls(value);
825
+ get wheelControls(): WheelControl;
826
+ private set wheelControls(value);
827
+ get selectedNavigationMode(): NavigationMode;
828
+ private set selectedNavigationMode(value);
829
+ private updateDebugEl;
830
+ private setWheelControls;
831
+ private setKeyboardControls;
832
+ setNavigationMode(navigationMode: NavigationMode): void;
833
+ dispose(): void;
834
+ private setMouseControls;
835
+ private updateModifierKeys;
836
+ private onKeyDown;
837
+ private onKeyUp;
838
+ private onMouseDown;
839
+ private onMouseUp;
840
+ private onMouseMove;
841
+ private onWheel;
842
+ private wheelDetect;
843
+ private onSelectTool;
844
+ }
845
+
501
846
  export declare type NavigationMode = (typeof NAV_MODE)[keyof typeof NAV_MODE];
502
847
 
848
+ declare function NavigationModel(cam: any, rc: any, dom: any): void;
849
+
850
+ declare class NavigationModel {
851
+ constructor(cam: any, rc: any, dom: any);
852
+ cam: any;
853
+ rc: any;
854
+ dom: any;
855
+ curKeysMultiple: any[];
856
+ curAction: -1;
857
+ EPS: number;
858
+ quatWorldToModelSpace: Quaternion;
859
+ quatModelToWorldSpace: Quaternion;
860
+ lastZoomPos: Vector2_2;
861
+ lastZoomModelPos: Vector3_2;
862
+ zoomDir: Vector3_2;
863
+ zoomDistanceInterval: number;
864
+ zoomDistanceThrehold: number;
865
+ panControl: Vector2_2;
866
+ spherical: Spherical;
867
+ sphericalDelta: Spherical;
868
+ orbitPoint: any;
869
+ cameraPoint: Vector3_2;
870
+ panTarget: Vector3_2 | null;
871
+ panOffset: Vector3_2;
872
+ orbitInit: {
873
+ orbitPoint: Vector3_2;
874
+ initialCameraTheta: number;
875
+ initialCameraCylindrical: Cylindrical;
876
+ initialCameraDirectionCylindrical: Cylindrical;
877
+ initialDirectionInOrbitPointSpace: Vector3_2;
878
+ cameraThetaRange: number[];
879
+ directionThetaRange: number[];
880
+ } | null;
881
+ qua: Quaternion;
882
+ moveOffset: Vector3_2;
883
+ lookDir: Vector3_2;
884
+ lookDirOnMouseDown: Vector3_2;
885
+ rotateWithKeys: boolean;
886
+ lookQuaOnMouseDown: Quaternion;
887
+ mouseRotateQua: Quaternion;
888
+ isMoved: boolean;
889
+ modelCenter: Vector3_2;
890
+ gui: {
891
+ navigation: {
892
+ default: {
893
+ keyboardMoveSpeed: number;
894
+ keyboardRotateSpeed: number;
895
+ };
896
+ fly: {
897
+ moveSpeed: number;
898
+ rotateSpeed: number;
899
+ strafeXSpeed: number;
900
+ strafeYSpeed: number;
901
+ };
902
+ orbit: {
903
+ rotateHorizontalSpeed: number;
904
+ rotateVerticalSpeed: number;
905
+ };
906
+ };
907
+ };
908
+ deltaTime: number;
909
+ flyEvent: any;
910
+ strafeEvent: any;
911
+ handleZoom(event: any, zoomSpeed: any): void;
912
+ moveForward(fwdDistance: any, speed: any): any;
913
+ moveBackward(fwdDistance: any, speed: any): number;
914
+ setZoomValue(zoomValue: any, dir1: any): void;
915
+ panLeft(distance: any, objectMatrix: any): void;
916
+ panUp(distance: any, objectMatrix: any): void;
917
+ handlePan(event: any): void;
918
+ moveRight(dir: any): void;
919
+ moveLeft(dir: any): void;
920
+ moveDown(): void;
921
+ moveUp(): void;
922
+ handleMouseDown(): void;
923
+ handleMouseUpDown(event: any): void;
924
+ CalculateAngle(vec1: any, vec2: any, speed: any): any;
925
+ handleStrafe(panDistance: any, speedX: any, speedY: any, clientWidth: any, clientHeight: any): void;
926
+ handleRotate(angle: any): void;
927
+ handleLookAround(angle: any): void;
928
+ handleFly(walkDistance: any, flyRotateSpeed: any, flyMoveSpeed: any, clientWidth: any, clientHeight: any): void;
929
+ rotateOrbitLeft(angle: any): void;
930
+ rotateOrbitUp(angle: any): void;
931
+ handleOrbitRotate(event: any): void;
932
+ GetRotateOffset(offset: any, position: any, target: any, quat: any, quatInverse: any): void;
933
+ handleKeyPress(code: any): void;
934
+ moveXYForward(): void;
935
+ moveXYBackward(): void;
936
+ pitchUp(): void;
937
+ pitchDown(): void;
938
+ yawLeft(): void;
939
+ yawRight(): void;
940
+ handleMeasurementZoom(event: any, orbitPoint: any, zoomSpeed: any): void;
941
+ updateWithState(state: any, event: any): void;
942
+ update(deltaTime: any): void;
943
+ clearOrbit(): void;
944
+ clearMove(): void;
945
+ clearPan(): void;
946
+ SetDirection(dir: any): void;
947
+ }
948
+
503
949
  declare class Node_2 {
504
950
  private pwfNode;
505
951
  private pwf;
@@ -602,8 +1048,49 @@ export declare type ObjectFilter = {
602
1048
  filterValue: string;
603
1049
  };
604
1050
 
1051
+ declare class ObjectTree {
1052
+ pwf: PWF;
1053
+ resourceId: number;
1054
+ _selectedNodeServices: SelectedNodeServices | null;
1055
+ _hiddenNodeServices: HiddenNodeServices | null;
1056
+ nodeIds: Set<number>;
1057
+ constructor(params: {
1058
+ pwf: PWF;
1059
+ resourceId: number;
1060
+ });
1061
+ set hiddenNodeServices(hiddenNodeServices: HiddenNodeServices);
1062
+ get hiddenNodeServices(): HiddenNodeServices;
1063
+ set selectedNodeServices(selectedNodeServices: SelectedNodeServices);
1064
+ get selectedNodeServices(): SelectedNodeServices;
1065
+ add: (nodeId: number) => boolean;
1066
+ has: (nodeId: number) => boolean;
1067
+ getParentInternalNode: (internalNode: InternalNode) => InternalNode | undefined;
1068
+ getInternalObjectTreeNode(nodeId: number): InternalNode | undefined;
1069
+ getObjectTreeNode(nodeId: number): PublicNode | undefined;
1070
+ buildFromPWF: () => {
1071
+ isComplete: boolean;
1072
+ };
1073
+ buildFromNodeIds: (nodeIds: number[]) => {
1074
+ nodeIds: number[];
1075
+ ancestors: number[];
1076
+ children: number[];
1077
+ };
1078
+ synchronizeSelected: (source: ObjectTree) => void;
1079
+ private synchronizeSelectedNodeIds;
1080
+ private getSelectedStack;
1081
+ private evaluateSelectedState;
1082
+ synchronizeHidden: (source: ObjectTree) => void;
1083
+ private synchronizeHiddenNodes;
1084
+ }
1085
+
605
1086
  export declare type Options = FileExtractionModePwfV2OverrideOptions | FileExtractionModePwfV1OverrideOptions | FileExtractionModeOptions | ModelRevisionModePwfV2Options | ModelRevisionModePwfV1Options | ResourceOptions;
606
1087
 
1088
+ declare type OrientedBox = {
1089
+ min: Vector3;
1090
+ max: Vector3;
1091
+ rotation?: Vector3 | null;
1092
+ };
1093
+
607
1094
  declare type Palette = {
608
1095
  default?: Color;
609
1096
  xray?: Color;
@@ -667,6 +1154,127 @@ declare class PartitionProxy {
667
1154
  getContentOfPartitionUrl(): string;
668
1155
  }
669
1156
 
1157
+ /**
1158
+ * Modified version based on Three WebGlRenderer
1159
+ */
1160
+ declare function PartitionsRenderer(parameters: any): void;
1161
+
1162
+ declare class PartitionsRenderer {
1163
+ /**
1164
+ * Modified version based on Three WebGlRenderer
1165
+ */
1166
+ constructor(parameters: any);
1167
+ domElement: any;
1168
+ context: any;
1169
+ textures: any;
1170
+ debug: {
1171
+ /**
1172
+ * Enables error checking and reporting when shader programs are being compiled
1173
+ * @type {boolean}
1174
+ */
1175
+ checkShaderErrors: boolean;
1176
+ };
1177
+ autoClear: boolean;
1178
+ autoClearColor: boolean;
1179
+ autoClearDepth: boolean;
1180
+ autoClearStencil: boolean;
1181
+ sortObjects: boolean;
1182
+ clippingPlanes: any[];
1183
+ localClippingEnabled: boolean;
1184
+ gammaFactor: number;
1185
+ gammaInput: boolean;
1186
+ gammaOutput: boolean;
1187
+ physicallyCorrectLights: boolean;
1188
+ toneMapping: ToneMapping;
1189
+ toneMappingExposure: number;
1190
+ toneMappingWhitePoint: number;
1191
+ commonRenderingParams: {
1192
+ xRayMode: {
1193
+ opacity: number;
1194
+ colorMode: string;
1195
+ color: string;
1196
+ };
1197
+ preferences: {
1198
+ overrideBackgroundColor: boolean;
1199
+ backgroundColor: string;
1200
+ };
1201
+ };
1202
+ refresh: boolean;
1203
+ renderingParameters: {
1204
+ renderingInMotion: {
1205
+ renderCullTreeOpaque: boolean;
1206
+ renderCullTreeTransparent: boolean;
1207
+ };
1208
+ };
1209
+ renderingAtRest: boolean;
1210
+ initialize: (measureSet: any, models: any, colorServices: any) => void;
1211
+ render: (scene: any, camera: any) => void;
1212
+ cleanBuffer: () => void;
1213
+ setRenderMode: (renderMode: any) => void;
1214
+ getRenderMode: () => "shaded";
1215
+ getRenderingStage: () => "renderIdle";
1216
+ renderSection: (scene: any, camera: any) => void;
1217
+ enableBackFaceFillColor: (enable: any) => void;
1218
+ loadMeshShader: () => void;
1219
+ setDetailsParams: (detailsParams: any) => void;
1220
+ setGeometryFactory: (geometryFactory: any) => void;
1221
+ renderMeshnode: (meshnode: any, scene: any, camera: any, renderStage: any) => void;
1222
+ renderMesh: (scene: any, camera: any, meshGeometry: any, nodedata: any, renderStage: any, isPicked: any, overrideMaterial: any) => void;
1223
+ vr: WebXRManager | WebVRManager | null;
1224
+ shadowMap: WebGLShadowMap;
1225
+ renderBufferImmediate: (object: any, program: any) => void;
1226
+ clear: (color: any, depth: any, stencil: any) => void;
1227
+ clearColor: () => void;
1228
+ clearDepth: () => void;
1229
+ dispose: () => void;
1230
+ getRenderTarget: () => any;
1231
+ getContext: () => any;
1232
+ getContextAttributes: () => any;
1233
+ getClearAlpha: () => any;
1234
+ getClearColor: () => any;
1235
+ getPixelRatio: () => number;
1236
+ getSize: () => {
1237
+ width: any;
1238
+ height: any;
1239
+ };
1240
+ setSize: (width: any, height: any, updateStyle: any) => void;
1241
+ setViewport: (x: any, y: any, width: any, height: any) => void;
1242
+ setScissorTest: (boolean: any) => void;
1243
+ setClearColor: (args: any) => void;
1244
+ setClearAlpha: (args: any) => void;
1245
+ setAnimationLoop: (callback: any) => void;
1246
+ setRenderTarget: (renderTarget: any) => void;
1247
+ readRenderTargetPixels: (renderTarget: any, x: any, y: any, width: any, height: any, buffer: any) => void;
1248
+ allocTextureUnit: () => number;
1249
+ renderBufferDirect: (camera: any, fog: any, geometry: any, material: any, object: any, group: any) => void;
1250
+ }
1251
+
1252
+ declare class PickingController {
1253
+ private renderer;
1254
+ private pickingTexture;
1255
+ private models;
1256
+ private camera;
1257
+ private sectionController;
1258
+ constructor(params: {
1259
+ renderer: ViewerRenderer;
1260
+ pickingTexture: THREE.WebGLRenderTarget;
1261
+ models: Models;
1262
+ camera: THREE.PerspectiveCamera;
1263
+ sectionController: SectionController;
1264
+ });
1265
+ getRayIntersectPoint(params: {
1266
+ event: MouseEvent;
1267
+ returnOnEdgeHitFailure: 'null' | 'bboxCenter';
1268
+ }): {
1269
+ intersection: Vector3 | null;
1270
+ meshnodeIndex: number;
1271
+ faceNormal: Vector3 | null;
1272
+ };
1273
+ mouseToThreeRay(event: MouseEvent): THREE.Raycaster;
1274
+ extractId(event: MouseEvent): number;
1275
+ private rayTestMesh;
1276
+ }
1277
+
670
1278
  declare type Point = {
671
1279
  position: {
672
1280
  x: number;
@@ -680,12 +1288,94 @@ declare type Point = {
680
1288
  };
681
1289
  };
682
1290
 
1291
+ declare class PointToPointController {
1292
+ private pickingController;
1293
+ private models;
1294
+ private camera;
1295
+ private currentHoverMeshnodeIndex;
1296
+ private meshTopologyCache;
1297
+ private _enabled;
1298
+ private globalOffset;
1299
+ private prevLastWorldIntersectionSnapResult;
1300
+ private lastWorldIntersectionSnapResult;
1301
+ private debugGui;
1302
+ private viewerRenderer;
1303
+ constructor(params: {
1304
+ pickingController: PickingController;
1305
+ models: Models;
1306
+ camera: THREE.PerspectiveCamera;
1307
+ globalOffset: THREE.Vector3;
1308
+ viewerRenderer: ViewerRenderer;
1309
+ });
1310
+ get enabled(): boolean;
1311
+ set enabled(value: boolean);
1312
+ handleMouseClick(): void;
1313
+ handleMouseMove(event: MouseEvent): void;
1314
+ private getWorldIntersectionSnapResult;
1315
+ private publishIntersectionSnapResult;
1316
+ private getMeshTopology;
1317
+ private meshnodeTooComplex;
1318
+ private determineHoverState;
1319
+ }
1320
+
1321
+ declare class PointToPointManager {
1322
+ private svgRenderer;
1323
+ private renderControllerProxy;
1324
+ private static pointToPointEnabled;
1325
+ private firstMeasurePoint;
1326
+ private secondMeasurePoint;
1327
+ private outlines;
1328
+ private intersection;
1329
+ private pivot;
1330
+ private dist;
1331
+ private xDist;
1332
+ private yDist;
1333
+ private zDist;
1334
+ private gui;
1335
+ private globalOffset;
1336
+ constructor(params: {
1337
+ renderControllerProxy: RenderControllerProxy;
1338
+ svgRenderer: SvgRenderer;
1339
+ globalOffset: {
1340
+ offsetX: number;
1341
+ offsetY: number;
1342
+ offsetZ: number;
1343
+ };
1344
+ });
1345
+ private onSelectTool;
1346
+ private onNavigationChanged;
1347
+ private onMeasurementObjectMove;
1348
+ private onMeasurementObjectLeave;
1349
+ private onMeasurementObjectClick;
1350
+ private resetMeasurement;
1351
+ private calculateDistances;
1352
+ static isEnabled(): boolean;
1353
+ togglePointToPoint(params: {
1354
+ enable: boolean;
1355
+ }): void;
1356
+ private setCameraAndNavigationControls;
1357
+ private updateSvg;
1358
+ private createLine;
1359
+ private createEllipse;
1360
+ }
1361
+
683
1362
  export declare type ProcoreFormatClipPlane = {
684
1363
  unit?: string;
685
1364
  direction: Vector3;
686
1365
  location: Vector3;
687
1366
  };
688
1367
 
1368
+ declare type ProcoreRender = any;
1369
+
1370
+ declare class ProcoreRenderPass extends Pass {
1371
+ scene: THREE.Scene;
1372
+ camera: THREE.Camera;
1373
+ clearDepth: boolean;
1374
+ refresh: boolean;
1375
+ constructor(scene: THREE.Scene, camera: THREE.Camera);
1376
+ render(renderer: THREE.WebGLRenderer | ProcoreRender, _writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget): void;
1377
+ }
1378
+
689
1379
  export declare type Project = {
690
1380
  id: number;
691
1381
  };
@@ -713,6 +1403,116 @@ export declare type PublicNode = {
713
1403
  children: number[];
714
1404
  };
715
1405
 
1406
+ declare function PubSubController(): void;
1407
+
1408
+ declare class PubSubController {
1409
+ subscribe: (evt: any, cb: any) => void;
1410
+ unsubscribe: (evt: any, cb: any) => void;
1411
+ publish: (evt: any, value: any) => void;
1412
+ clear: () => void;
1413
+ }
1414
+
1415
+ declare namespace PubSubController {
1416
+ const EVENTS: Readonly<{
1417
+ animate: "animate";
1418
+ appResize: "appResize";
1419
+ appStart: "appStart";
1420
+ bcfCameraSet: "bcfCameraSet";
1421
+ browserSettingsReady: "browserSettingsReady";
1422
+ cameraUpdated: "cameraUpdated";
1423
+ canvasReady: "canvasReady";
1424
+ coachmarkHyperlinkClicked: "coachmarkHyperlinkClicked";
1425
+ contextMenu: "contextMenu";
1426
+ curKeysUpdated: "curKeysUpdated";
1427
+ databaseOpened: "databaseOpened";
1428
+ doubleClick: "doubleClick";
1429
+ downloadComplete: "downloadComplete";
1430
+ downloadError: "downloadError";
1431
+ downloadStart: "downloadStart";
1432
+ drawingMiniClick: "drawingMiniClick";
1433
+ drawingNavigated: "drawingNavigated";
1434
+ fieldOfViewChanged: "fieldOfViewChanged";
1435
+ fileTooBigError: "fileTooBigError";
1436
+ floorPlan: "floorPlan";
1437
+ getBimFileViewFolders: "getBimFileViewFolders";
1438
+ getBimModelRevisionViewpoints: "getBimModelRevisionViewpoints";
1439
+ getBimObjectsFor: "getBimObjectsFor";
1440
+ getBimPropertiesFor: "getBimPropertiesFor";
1441
+ globalBoundingBoxInitialized: "globalBoundingBoxInitialized";
1442
+ graphicContextLost: "graphicContextLost";
1443
+ hideSimilarCompleted: "hideSimilarCompleted";
1444
+ hideUpdated: "hideUpdated";
1445
+ homeViewpointActivated: "homeViewpointActivated";
1446
+ initializationComplete: "initializationComplete";
1447
+ initializationFailed: "initializationFailed";
1448
+ initializationProgress: "initializationProgress";
1449
+ initializationStart: "initializationStart";
1450
+ intersectPointClick: "intersectPointClick";
1451
+ isolateCompleted: "isolateCompleted";
1452
+ launchedAnimationLoop: "launchedAnimationLoop";
1453
+ mainThreadDebugGuiAdd: "mainThreadDebugGuiAdd";
1454
+ mainThreadDebugGuiDestroy: "mainThreadDebugGuiDestroy";
1455
+ markupDismissed: "markupDismissed";
1456
+ markupDisplayed: "markupDisplayed";
1457
+ measured: "measured";
1458
+ measurementObjectEnter: "measurementObjectEnter";
1459
+ measurementObjectLeave: "measurementObjectLeave";
1460
+ measurementObjectMove: "measurementObjectMove";
1461
+ measurementObjectClick: "measurementObjectClick";
1462
+ messages: "messages";
1463
+ modelTreeParentInteracted: "modelTreeParentInteracted";
1464
+ modelTypeDetermined: "modelTypeDetermined";
1465
+ mouseMove: "mouseMove";
1466
+ navigationChanged: "navigationChanged";
1467
+ navigationMouseDown: "navigationMouseDown";
1468
+ navigationMouseUp: "navigationMouseUp";
1469
+ navigationUpdated: "navigationUpdated";
1470
+ objectDeselect: "objectDeselect";
1471
+ objectDoubleClick: "objectDoubleClick";
1472
+ objectHide: "objectHide";
1473
+ objectMeasure: "objectMeasure";
1474
+ objectRightClick: "objectRightClick";
1475
+ objectSelect: "objectSelect";
1476
+ objectSelectFromModelTree: "objectSelectFromModelTree";
1477
+ objectSingleClick: "objectSingleClick";
1478
+ objectTreeUpdated: "objectTreeUpdated";
1479
+ objectUnhide: "objectUnhide";
1480
+ optionsChanged: "optionsChanged";
1481
+ projectSettingsLoaded: "projectSettingsLoaded";
1482
+ projectSettingsUpdated: "projectSettingsUpdated";
1483
+ propertiesReady: "propertiesReady";
1484
+ propertyServiceCheck: "propertyServiceCheck";
1485
+ redo: "redo";
1486
+ renderModeChanged: "renderModeChanged";
1487
+ refreshScene: "refreshScene";
1488
+ renderReady: "renderReady";
1489
+ rightClick: "rightClick";
1490
+ savedViewpointClicked: "savedViewpointClicked";
1491
+ sectionBoxDisplayConfigured: "sectionBoxDisplayConfigured";
1492
+ sectionBoxDisplayHoverUpdated: "sectionBoxDisplayHoverUpdated";
1493
+ sectionBoxDisplayResized: "sectionBoxDisplayResized";
1494
+ sectionBoxDisplayToggled: "sectionBoxDisplayToggled";
1495
+ sectionBoxRemoved: "sectionBoxRemoved";
1496
+ sectionBoxSet: "sectionBoxSet";
1497
+ sectionPlaneAdded: "sectionPlaneAdded";
1498
+ sectionPlaneRemoved: "sectionPlaneRemoved";
1499
+ sectionsCleared: "sectionsCleared";
1500
+ selectSimilarCompleted: "selectSimilarCompleted";
1501
+ selectSimilarStarted: "selectSimilarStarted";
1502
+ selectTool: "selectTool";
1503
+ selectedUpdated: "selectedUpdated";
1504
+ singleClick: "singleClick";
1505
+ undo: "undo";
1506
+ updatePivot: "updatePivot";
1507
+ windowClose: "windowClose";
1508
+ windowComponentChanged: "windowComponentChanged";
1509
+ windowComponentShouldClose: "windowComponentShouldClose";
1510
+ windowComponentShouldOpen: "windowComponentShouldOpen";
1511
+ windowComponentTouched: "windowComponentTouched";
1512
+ windowOpen: "windowOpen";
1513
+ }>;
1514
+ }
1515
+
716
1516
  declare class PWF {
717
1517
  static timeSince(time: any): string;
718
1518
  static isPartitionProxiesAB(meshAB: any): boolean;
@@ -813,7 +1613,7 @@ declare class PWF {
813
1613
  forEachMeshnode(callback: any): void;
814
1614
  forEachNode(callback: any): void;
815
1615
  getMeshVerticesAndFaces(meshRef: any): MeshVerticesAndFaces;
816
- findFirstObject(virtualMeshnodeIndex: any): Node_2;
1616
+ findFirstObject(meshnodeIndex: any): Node_2;
817
1617
  captureModelStats(): number;
818
1618
  captureStandardModelStats(pwfModel: any): number;
819
1619
  capturePartitionedModelStats(pwfModel: any): number | undefined;
@@ -821,6 +1621,16 @@ declare class PWF {
821
1621
  #private;
822
1622
  }
823
1623
 
1624
+ declare class PWFCache {
1625
+ private readonly httpClient;
1626
+ private abortController;
1627
+ private abortSignal;
1628
+ constructor();
1629
+ fetchArrayBuffer(url: string): Promise<ArrayBuffer>;
1630
+ fetchArrayBuffers(urls: string[]): Promise<ArrayBuffer[]>;
1631
+ dispose(): void;
1632
+ }
1633
+
824
1634
  declare interface PWFMesh {
825
1635
  offset(): number;
826
1636
  color(): number;
@@ -909,15 +1719,906 @@ export declare type PwfV2Bundle = {
909
1719
  manifestUrl: GeometryFile['url'];
910
1720
  };
911
1721
 
1722
+ declare type RadiusEllipse = {
1723
+ center: Vector2;
1724
+ radius: Vector2;
1725
+ stroke: CssColor;
1726
+ fill?: CssColor;
1727
+ strokeWidth: number;
1728
+ zIndex?: number;
1729
+ };
1730
+
1731
+ declare type Rect = {
1732
+ width: number;
1733
+ height: number;
1734
+ x: number;
1735
+ y: number;
1736
+ radius?: Vector2;
1737
+ fill?: CssColor;
1738
+ stroke?: CssColor;
1739
+ strokeWidth?: number;
1740
+ zIndex?: number;
1741
+ };
1742
+
912
1743
  export declare const RENDER_MODE: {
913
1744
  readonly SHADED: "shaded";
914
1745
  readonly XRAY: "xray";
915
1746
  };
916
1747
 
1748
+ declare function RenderController(params: any): void;
1749
+
1750
+ declare class RenderController {
1751
+ constructor(params: any);
1752
+ params: any;
1753
+ logInitializationTimes: any;
1754
+ cameras: {
1755
+ default: PerspectiveCamera;
1756
+ global: PerspectiveCamera;
1757
+ old: {
1758
+ position: Vector3_2;
1759
+ rotation: Vector3_2;
1760
+ };
1761
+ };
1762
+ scenes: {
1763
+ default: Scene;
1764
+ };
1765
+ controls: any;
1766
+ frameId: number | null;
1767
+ measureEnabled: boolean;
1768
+ canvasSelectionEnabled: boolean;
1769
+ globalOffset: {
1770
+ offsetX: number;
1771
+ offsetY: number;
1772
+ offsetZ: number;
1773
+ } | null;
1774
+ clock: Clock;
1775
+ delta: number;
1776
+ webengine: InitOutput | null;
1777
+ webenginePromise: Promise<InitOutput>;
1778
+ enableWebWorker: any;
1779
+ prefetchingPartitions: boolean;
1780
+ projectId: any;
1781
+ baseUrl: any;
1782
+ meshnodeABCached: boolean;
1783
+ nodeABCached: boolean;
1784
+ meshABCached: boolean;
1785
+ trackingController: StatusTrackingController;
1786
+ zoomExtentsParams: {
1787
+ zoomExtents: {
1788
+ zenith: number;
1789
+ azimuth: number;
1790
+ distanceFromCenterFactor: number;
1791
+ };
1792
+ };
1793
+ zoomToGlobalParams: {
1794
+ spaceJunkEliminationThreshold: number;
1795
+ };
1796
+ initCanvas(): void;
1797
+ streaming: boolean | undefined;
1798
+ viewerRenderer: ViewerRenderer | undefined;
1799
+ textures: {
1800
+ picking: WebGLRenderTarget;
1801
+ } | undefined;
1802
+ section: SectionController | undefined;
1803
+ composer: EffectComposer | undefined;
1804
+ procoreRenderPass: ProcoreRenderPass | undefined;
1805
+ sectionRenderPass: SectionRenderPass | undefined;
1806
+ initWasm(): Promise<void>;
1807
+ initPwf(): void;
1808
+ pwf: PWF | undefined;
1809
+ pickingController: PickingController | undefined;
1810
+ initPwfParser(): void;
1811
+ parsePwfNodes(): {
1812
+ isComplete: boolean;
1813
+ };
1814
+ parsePwfMeshnodes(): {
1815
+ isComplete: boolean;
1816
+ };
1817
+ parsePwfMeshes(): void;
1818
+ initMeshServices(): void;
1819
+ initNodeServices(): void;
1820
+ initMeshnodeServices(): void;
1821
+ initNodeTree(): {
1822
+ isComplete: boolean;
1823
+ };
1824
+ initNodeTreeBoundingBoxes(): {
1825
+ isComplete: boolean;
1826
+ };
1827
+ initSceneGraph(): {
1828
+ isComplete: boolean;
1829
+ };
1830
+ initGlobalOffset(): void;
1831
+ pointToPointController: PointToPointController | undefined;
1832
+ initGeometryFactory(): void;
1833
+ initTreeServices(): {
1834
+ isComplete: boolean;
1835
+ };
1836
+ initViewerRenderer(): void;
1837
+ initGeometry(): {
1838
+ isComplete: boolean;
1839
+ };
1840
+ initGlobalBoundingBox(): void;
1841
+ initNavigationModel(): void;
1842
+ navigationModel: NavigationModel | undefined;
1843
+ initLightingAndShader(): void;
1844
+ light: {
1845
+ default: DirectionalLight;
1846
+ ambient: AmbientLight;
1847
+ } | null | undefined;
1848
+ getInitEventPayload(params: any): ModelInitializationPayload;
1849
+ launchAnimationLoop(): void;
1850
+ waitTillRenderStage(params: any): Promise<any>;
1851
+ captureModelStats(): void;
1852
+ init(modelDescriptors: any, downloadMetaData: any): Promise<void>;
1853
+ meshnodeAB: any;
1854
+ nodeAB: any;
1855
+ meshAB: any;
1856
+ manifest: any;
1857
+ startTimestamp: number | undefined;
1858
+ startTime: number | undefined;
1859
+ sceneGraphName: any;
1860
+ downloadMetaData: any;
1861
+ modelDescriptors: any;
1862
+ locale: any;
1863
+ models: Models | undefined;
1864
+ firstModelResourceId: number | undefined;
1865
+ shortestDistanceController: ShortestDistanceController | undefined;
1866
+ colorServices: ColorServices | undefined;
1867
+ onUpdateWithState(data: any): void;
1868
+ close(): boolean;
1869
+ renderer: any;
1870
+ animate(): void;
1871
+ getCameraDirection(): {
1872
+ x: number;
1873
+ y: number;
1874
+ z: number;
1875
+ };
1876
+ getPosition(params?: {
1877
+ applyOffset: boolean;
1878
+ }): {
1879
+ x: number;
1880
+ y: number;
1881
+ z: number;
1882
+ };
1883
+ setMeshnodeColor(params: any): void;
1884
+ setNodeColor(palettes: any, options: any): void;
1885
+ clearNodeColor(nodeIds: any, options: any): void;
1886
+ clearAllNodeColor(options: any): void;
1887
+ setLookAt(params: any): {
1888
+ direction: {
1889
+ x: number;
1890
+ y: number;
1891
+ z: number;
1892
+ };
1893
+ position: {
1894
+ x: number;
1895
+ y: number;
1896
+ z: number;
1897
+ };
1898
+ };
1899
+ getLookAt(params?: {}): {
1900
+ x: number;
1901
+ y: number;
1902
+ z: number;
1903
+ };
1904
+ getBenchmarkPoint(): {
1905
+ position: {
1906
+ x: number;
1907
+ y: number;
1908
+ z: number;
1909
+ };
1910
+ lookAt: {
1911
+ x: number;
1912
+ y: number;
1913
+ z: number;
1914
+ };
1915
+ };
1916
+ setBenchmarkPoint(params: any): void;
1917
+ setPosition(params: any): {
1918
+ direction: {
1919
+ x: number;
1920
+ y: number;
1921
+ z: number;
1922
+ };
1923
+ position: {
1924
+ x: number;
1925
+ y: number;
1926
+ z: number;
1927
+ };
1928
+ };
1929
+ getModelItemBoundary(id: any): Box3;
1930
+ getGlobalOffset(): {
1931
+ offsetX: number;
1932
+ offsetY: number;
1933
+ offsetZ: number;
1934
+ } | null;
1935
+ getMeshnodeFromNodeId(nodeId: any): Meshnode | Node_2 | null;
1936
+ getMeshnodeFromIndex(id: any): Meshnode | null;
1937
+ getMeasureObjectMeshes(): MeshnodeObject[];
1938
+ getCamera(): PerspectiveCamera;
1939
+ getRenderer(): ViewerRenderer | undefined;
1940
+ resizeScene(params: any): void;
1941
+ getContextMenuData(evt: any): {
1942
+ intersection: Vector3 | null;
1943
+ meshnodeIndex: number;
1944
+ faceNormal: Vector3 | null;
1945
+ } | {
1946
+ meshnodeIndex: number;
1947
+ };
1948
+ onContextMenu(evt: any): void;
1949
+ isSectionBlockingClick(): boolean;
1950
+ getIntersectionAndMeshnodeIndex(evt: any): {
1951
+ intersection: Vector3 | null;
1952
+ meshnodeIndex: number;
1953
+ faceNormal: Vector3 | null;
1954
+ };
1955
+ isMeshnodeSelected(virtualMeshnodeIndex: any): boolean;
1956
+ clickedOnSelectedObject(virtualMeshnodeIndex: any, rightClick: any): void;
1957
+ clickedOnUnselectedObject(virtualMeshnodeIndex: any, rightClick: any): void;
1958
+ handleObjectSelection(meshnodeIndex: any, rightClick: any): void;
1959
+ handleEmptySpaceClick(): void;
1960
+ onSingleClick(evt: any, rightClick?: boolean): void;
1961
+ onMouseMove(evt: any): void;
1962
+ setCanvasSelectionEnabled(enabled: any): void;
1963
+ getSelectedSubtree(meshnodeIndex: any): {
1964
+ objectId: number;
1965
+ selectionContainerId: number | undefined;
1966
+ ancestry: {
1967
+ children: (PublicNode | undefined)[];
1968
+ id?: number | undefined;
1969
+ bbox?: NodeBoundingBox | undefined;
1970
+ nodeType?: number | undefined;
1971
+ hidden?: boolean | undefined;
1972
+ selected?: boolean | undefined;
1973
+ partiallySelected?: boolean | undefined;
1974
+ parentId?: number | undefined;
1975
+ }[];
1976
+ };
1977
+ onDoubleClick(evt: any): void;
1978
+ onRightClick(evt: any): void;
1979
+ hideSelected(params?: {}): void;
1980
+ unhideNodeFromNodeIds(params: any): boolean;
1981
+ hideNodesFromNodeIds(params?: {}): boolean;
1982
+ getHiddenNodeIds(params?: {}): number[];
1983
+ getHiddenMeshnodeIndices(params?: {}): number[];
1984
+ getHiddenGeoIdsSet(params?: {}): Set<number>;
1985
+ addHiddenMeshnodeIndices(arr: any, resourceId?: any): void;
1986
+ setVisibility(params: any): void;
1987
+ getVisibility(params: any): Visibility;
1988
+ getZoomInterSectPoint(evt: any): {
1989
+ x: number;
1990
+ y: number;
1991
+ z: number;
1992
+ };
1993
+ ToScreenPosition(params: any): Vector3 | Vector3[];
1994
+ ConvertScreenPosition(vector: any): {
1995
+ x: any;
1996
+ y: any;
1997
+ z: any;
1998
+ };
1999
+ ModelToMapSpace(params: any): {
2000
+ x?: undefined;
2001
+ y?: undefined;
2002
+ dir_x?: undefined;
2003
+ dir_y?: undefined;
2004
+ } | {
2005
+ x: number;
2006
+ y: number;
2007
+ dir_x: number;
2008
+ dir_y: number;
2009
+ };
2010
+ MapToModelSpace(params: any): {
2011
+ x?: undefined;
2012
+ y?: undefined;
2013
+ dir_x?: undefined;
2014
+ dir_y?: undefined;
2015
+ } | {
2016
+ x: number;
2017
+ y: number;
2018
+ dir_x: number;
2019
+ dir_y: number;
2020
+ };
2021
+ setBcfCamera(params: any): false | {
2022
+ perspective_camera: {
2023
+ camera_view_point: {
2024
+ x: number;
2025
+ y: number;
2026
+ z: number;
2027
+ };
2028
+ camera_direction: {
2029
+ x: number;
2030
+ y: number;
2031
+ z: number;
2032
+ };
2033
+ camera_up_vector: {
2034
+ x: number;
2035
+ y: number;
2036
+ z: number;
2037
+ };
2038
+ field_of_view: number;
2039
+ target_distance: number;
2040
+ unit: string;
2041
+ };
2042
+ };
2043
+ setCameraRotation(params: any): void;
2044
+ sanitizeFieldOfView(fov: any): any;
2045
+ getBcfCamera(params?: {
2046
+ applyOffset: boolean;
2047
+ }): {
2048
+ perspective_camera: {
2049
+ camera_view_point: {
2050
+ x: number;
2051
+ y: number;
2052
+ z: number;
2053
+ };
2054
+ camera_direction: {
2055
+ x: number;
2056
+ y: number;
2057
+ z: number;
2058
+ };
2059
+ camera_up_vector: {
2060
+ x: number;
2061
+ y: number;
2062
+ z: number;
2063
+ };
2064
+ field_of_view: number;
2065
+ target_distance: number;
2066
+ unit: string;
2067
+ };
2068
+ };
2069
+ refreshScene(): void;
2070
+ setHiddenSet(params: any): void;
2071
+ refreshLighting(): void;
2072
+ setSectionBox(params: any): void;
2073
+ setSectionsData(params: any): boolean;
2074
+ removeSectionBox(): void;
2075
+ addSectionPlane(params: any): void;
2076
+ removeSectionPlane(uuid: any): void;
2077
+ getSections(format: any): SectionDataProcoreFormat | SectionDataAutodeskFormat | null;
2078
+ clearSection(): void;
2079
+ setOptions(options: any): void;
2080
+ findFirstObject(params: any): PublicNode | undefined;
2081
+ getNamedNode(nodeId: any, options?: {}): PublicNode | undefined;
2082
+ setEulerAngles(params: any): void;
2083
+ statusChange(type: any): void;
2084
+ onUndo(): void;
2085
+ onRedo(): void;
2086
+ getOrbitTranslate(event: any): {
2087
+ translate: Vector3 | Vector3[];
2088
+ orbitPoint: Vector3;
2089
+ };
2090
+ setMeasureEnabled(enabled: any): void;
2091
+ getMeasureEnabled(): boolean;
2092
+ getMeasureIds(): number[];
2093
+ removeMeasureIds(measureIds: any): void;
2094
+ clearMeasureIds(): void;
2095
+ hasHiddenMeshnodeIndices(ids: any, options?: {}): boolean;
2096
+ clearHidden(options?: {}): boolean;
2097
+ getSelectedMeshnodeIndices(options?: {}): number[];
2098
+ addSelectedMeshnodeIndices(ids: any, options?: {}): boolean;
2099
+ clearAndSelectNode(nodeId: any, options?: {}): void;
2100
+ clearAndSelectNodes(params: any): void;
2101
+ getNode(params: any): PublicNode | undefined;
2102
+ getNodes(params: any): any;
2103
+ getRootNode(params?: {}): PublicNode | undefined;
2104
+ setNodesSelected(params: any): boolean;
2105
+ hasSelectedMeshnodeIndices(ids: any, options?: {}): boolean;
2106
+ clearSelected(params?: {}): boolean;
2107
+ getFieldOfView(): number;
2108
+ setFieldOfView(deg: any): void;
2109
+ setPose(params: any): void;
2110
+ zoomToGlobal(): void;
2111
+ zoomToBoundingBox(bbox: any): void;
2112
+ getBoundingBoxByMeshnodeIndices(params: any): any;
2113
+ zoomToSelection(options?: {}): void;
2114
+ isolateSelection(options?: {}): void;
2115
+ isolateSelectionInSectionBox(options?: {}): void;
2116
+ zoomToNodes(nodeIds: any): void;
2117
+ getNumNodesSelected(params?: {}): {
2118
+ count: number;
2119
+ };
2120
+ getNumNodesHidden(options?: {}): {
2121
+ count: number;
2122
+ };
2123
+ setRenderMode(renderMode: any, origin: any): void;
2124
+ getRenderMode(): string;
2125
+ getSelectedNodeIds(params?: {}): number[];
2126
+ toggleSectionBoxDisplay(enable: any): void;
2127
+ togglePointToPoint(enabled: any): void;
2128
+ getSectionBoxDisplayBbox(): BoundingBox;
2129
+ getSectionsAsBox(): OrientedBox | null;
2130
+ zoomToSectionBox(): void;
2131
+ resetSectionBox(): void;
2132
+ setSectionBoxHidden(hide: any): void;
2133
+ updateSectionHover(event: any): void;
2134
+ clearSectionHover(): void;
2135
+ isSectionBoxHovered(): boolean;
2136
+ resizeSectionBox(xyDelta: any): void;
2137
+ onSectionMouseDown(): void;
2138
+ hideUpdated(): void;
2139
+ constructObjectTreeFromNodeIds(nodeIds: any, options?: {}): {
2140
+ nodeIds: number[];
2141
+ ancestors: number[];
2142
+ children: number[];
2143
+ };
2144
+ clearFilteredObjectTree(params?: {}): void;
2145
+ getObjectTree(resourceId?: any, objectTreeName?: string): ObjectTree | undefined;
2146
+ syncObjectTreesWithHidden(params: any): void;
2147
+ syncObjectTreesWithSelected({ resourceId, sourceObjectTreeName, destinationObjectTreeName, }: {
2148
+ resourceId: any;
2149
+ sourceObjectTreeName: any;
2150
+ destinationObjectTreeName: any;
2151
+ }): void;
2152
+ validateObjectTree(resourceId: any, objectTreeName: any): boolean;
2153
+ isPartitionedModel(): boolean;
2154
+ setPwfFileCacheState(states: any): void;
2155
+ getPwfFileCacheState(): {
2156
+ meshnodeABCached: boolean;
2157
+ nodeABCached: boolean;
2158
+ meshABCached: boolean;
2159
+ };
2160
+ partitionUrlsFromMeshnodeIndices(meshnodeIndices: any): any;
2161
+ }
2162
+
2163
+ declare namespace RenderController {
2164
+ namespace NullSelectedSubtree {
2165
+ const objectId: number;
2166
+ const selectionContainerId: number;
2167
+ const ancestry: never[];
2168
+ }
2169
+ function createCameras(options: any): {
2170
+ default: PerspectiveCamera;
2171
+ global: PerspectiveCamera;
2172
+ old: {
2173
+ position: Vector3_2;
2174
+ rotation: Vector3_2;
2175
+ };
2176
+ };
2177
+ function createScenes(options: any, cameras: any): {
2178
+ default: Scene;
2179
+ };
2180
+ function createLighting(cameras: any, scenes: any): {
2181
+ default: DirectionalLight;
2182
+ ambient: AmbientLight;
2183
+ };
2184
+ function createTextures(renderer: any): {
2185
+ picking: WebGLRenderTarget;
2186
+ };
2187
+ function sanitizeOptions(options: any): any;
2188
+ }
2189
+
2190
+ declare function RenderControllerProxy(options: any): void;
2191
+
2192
+ declare class RenderControllerProxy {
2193
+ constructor(options: any);
2194
+ cache: Promise<Cache>;
2195
+ pubsub: PubSubController;
2196
+ options: any;
2197
+ worker: any;
2198
+ enableWebWorker: any;
2199
+ navigationManager: NavigationManager;
2200
+ hotkeys: Hotkeys;
2201
+ renderController: RenderController | RenderControllerWorker | null;
2202
+ pwfCache: PWFCache | null;
2203
+ renderControllerParams: {
2204
+ canvas: HTMLElement | null;
2205
+ debug: any;
2206
+ sceneGraph: any;
2207
+ selection: any;
2208
+ min_boundary: any;
2209
+ max_boundary: any;
2210
+ rotation: any;
2211
+ offsetWidth: any;
2212
+ offsetHeight: any;
2213
+ offsetTop: any;
2214
+ offsetLeft: any;
2215
+ multiselect: any;
2216
+ locale: any;
2217
+ enableWebWorker: any;
2218
+ logInitializationTimes: any;
2219
+ projectId: any;
2220
+ baseUrl: any;
2221
+ nodeUrl: any;
2222
+ meshnodeUrl: any;
2223
+ meshUrl: any;
2224
+ manifestUrl: any;
2225
+ fileExtractionId: any;
2226
+ modelId: any;
2227
+ modelRevisionId: any;
2228
+ resources: any;
2229
+ companyId: any;
2230
+ accessToken: any;
2231
+ };
2232
+ processPWFArrayBuffers: (modelDescriptors: any) => void;
2233
+ messageToEvent: {
2234
+ 'Error: Download exception.': "downloadError";
2235
+ 'Error: File size exception.': "fileTooBigError";
2236
+ };
2237
+ handleDownloadError: (message: any) => void;
2238
+ downloadMetaData: {
2239
+ timeToDownload: number;
2240
+ modelCached: boolean;
2241
+ };
2242
+ navmode: any;
2243
+ globalOffset: any;
2244
+ createRenderController(): void;
2245
+ onUpdateWithState(data: any): void | Promise<any> | undefined;
2246
+ close(): void;
2247
+ cameras: any;
2248
+ setNavigationMode(...params: any[]): void;
2249
+ waitTillRenderStage(...params: any[]): Promise<any>;
2250
+ getCameraDirection(...params: any[]): Promise<any> | {
2251
+ x: number;
2252
+ y: number;
2253
+ z: number;
2254
+ };
2255
+ getPosition(...params: any[]): Promise<any> | {
2256
+ x: number;
2257
+ y: number;
2258
+ z: number;
2259
+ };
2260
+ getLookAt(...params: any[]): Promise<any> | {
2261
+ x: number;
2262
+ y: number;
2263
+ z: number;
2264
+ };
2265
+ getBenchmarkPoint(...params: any[]): Promise<any> | {
2266
+ position: {
2267
+ x: number;
2268
+ y: number;
2269
+ z: number;
2270
+ };
2271
+ lookAt: {
2272
+ x: number;
2273
+ y: number;
2274
+ z: number;
2275
+ };
2276
+ };
2277
+ setBenchmarkPoint(...params: any[]): void | Promise<any>;
2278
+ setNodeColor(...params: any[]): void;
2279
+ clearNodeColor(...params: any[]): void;
2280
+ clearAllNodeColor(...params: any[]): void;
2281
+ setMeshnodeColor(...params: any[]): void;
2282
+ setLookAt(...params: any[]): Promise<any> | {
2283
+ direction: {
2284
+ x: number;
2285
+ y: number;
2286
+ z: number;
2287
+ };
2288
+ position: {
2289
+ x: number;
2290
+ y: number;
2291
+ z: number;
2292
+ };
2293
+ };
2294
+ setPosition(...params: any[]): Promise<any> | {
2295
+ direction: {
2296
+ x: number;
2297
+ y: number;
2298
+ z: number;
2299
+ };
2300
+ position: {
2301
+ x: number;
2302
+ y: number;
2303
+ z: number;
2304
+ };
2305
+ };
2306
+ setCameraRotation(...params: any[]): void | Promise<any>;
2307
+ getGlobalOffset(...params: any[]): Promise<any> | {
2308
+ offsetX: number;
2309
+ offsetY: number;
2310
+ offsetZ: number;
2311
+ } | null;
2312
+ getMeshnodeFromNodeId(...params: any[]): Promise<any> | Meshnode | Node_2 | null;
2313
+ unhideNodeFromNodeIds(...params: any[]): boolean | Promise<any>;
2314
+ hideNodesFromNodeIds(...params: any[]): boolean | Promise<any>;
2315
+ onResize(...params: any[]): void;
2316
+ getMeshnodeFromIndex(...params: any[]): Promise<any> | Meshnode | null;
2317
+ getMeasureObjectMeshes(...params: any[]): Promise<any> | MeshnodeObject[];
2318
+ onContextMenu(...params: any[]): void | Promise<any>;
2319
+ getContextMenuData(...params: any[]): Promise<any> | {
2320
+ meshnodeIndex: number;
2321
+ };
2322
+ onSingleClick(...params: any[]): void | Promise<any>;
2323
+ onMouseMove(...params: any[]): void | Promise<any>;
2324
+ resizeScene(...params: any[]): void;
2325
+ onDoubleClick(...params: any[]): void | Promise<any>;
2326
+ onRightClick(...params: any[]): void | Promise<any>;
2327
+ getNumNodesHidden(...params: any[]): Promise<any> | {
2328
+ count: number;
2329
+ };
2330
+ hideSelected(...params: any[]): void;
2331
+ hideNodeOffset(...params: any[]): any;
2332
+ getHiddenNodeIds(...params: any[]): Promise<any> | number[];
2333
+ getHiddenMeshnodeIndices(...params: any[]): Promise<any> | number[];
2334
+ getHiddenGeoIdsSet(...params: any[]): Promise<any> | Set<number>;
2335
+ addHiddenMeshnodeIndices(...params: any[]): void | Promise<any>;
2336
+ removeHiddenGeoIds(...params: any[]): any;
2337
+ setVisibility(...params: any[]): void | Promise<any>;
2338
+ getVisibility(...params: any[]): Promise<any> | Visibility;
2339
+ getOrbitTranslate(...params: any[]): Promise<any> | {
2340
+ translate: Vector3 | Vector3[];
2341
+ orbitPoint: Vector3;
2342
+ };
2343
+ ToScreenPosition(...params: any[]): Promise<any> | Vector3 | Vector3[];
2344
+ ModelToMapSpace(...params: any[]): Promise<any> | {
2345
+ x?: undefined;
2346
+ y?: undefined;
2347
+ dir_x?: undefined;
2348
+ dir_y?: undefined;
2349
+ } | {
2350
+ x: number;
2351
+ y: number;
2352
+ dir_x: number;
2353
+ dir_y: number;
2354
+ };
2355
+ MapToModelSpace(...params: any[]): Promise<any> | {
2356
+ x?: undefined;
2357
+ y?: undefined;
2358
+ dir_x?: undefined;
2359
+ dir_y?: undefined;
2360
+ } | {
2361
+ x: number;
2362
+ y: number;
2363
+ dir_x: number;
2364
+ dir_y: number;
2365
+ };
2366
+ setBcfCamera(...params: any[]): false | Promise<any> | {
2367
+ perspective_camera: {
2368
+ camera_view_point: {
2369
+ x: number;
2370
+ y: number;
2371
+ z: number;
2372
+ };
2373
+ camera_direction: {
2374
+ x: number;
2375
+ y: number;
2376
+ z: number;
2377
+ };
2378
+ camera_up_vector: {
2379
+ x: number;
2380
+ y: number;
2381
+ z: number;
2382
+ };
2383
+ field_of_view: number;
2384
+ target_distance: number;
2385
+ unit: string;
2386
+ };
2387
+ };
2388
+ getBcfCamera(...params: any[]): Promise<any> | {
2389
+ perspective_camera: {
2390
+ camera_view_point: {
2391
+ x: number;
2392
+ y: number;
2393
+ z: number;
2394
+ };
2395
+ camera_direction: {
2396
+ x: number;
2397
+ y: number;
2398
+ z: number;
2399
+ };
2400
+ camera_up_vector: {
2401
+ x: number;
2402
+ y: number;
2403
+ z: number;
2404
+ };
2405
+ field_of_view: number;
2406
+ target_distance: number;
2407
+ unit: string;
2408
+ };
2409
+ };
2410
+ refreshScene(...params: any[]): void;
2411
+ refreshLighting(...params: any[]): void;
2412
+ setSectionBox(...params: any[]): void | Promise<any>;
2413
+ setSectionsData(...params: any[]): boolean | Promise<any>;
2414
+ removeSectionBox(...params: any[]): void;
2415
+ addSectionPlane(...params: any[]): void;
2416
+ removeSectionPlane(...params: any[]): void;
2417
+ getSections(...params: any[]): Promise<any> | SectionDataProcoreFormat | SectionDataAutodeskFormat | null;
2418
+ clearSection(...params: any[]): void | Promise<any>;
2419
+ setOptions(options: any): void;
2420
+ setCanvasSelectionEnabled(...params: any[]): void;
2421
+ findFirstObject(...params: any[]): Promise<any> | PublicNode | undefined;
2422
+ getNamedNode(...params: any[]): Promise<any> | PublicNode | undefined;
2423
+ setEulerAngles(...params: any[]): void | Promise<any>;
2424
+ setMeasureEnabled(...params: any[]): void | Promise<any>;
2425
+ statusChange(...params: any[]): void | Promise<any>;
2426
+ onUndo(...params: any[]): void | Promise<any>;
2427
+ getMeasureEnabled(...params: any[]): boolean | Promise<any>;
2428
+ getMeasureIds(...params: any[]): Promise<any> | number[];
2429
+ removeMeasureIds(...params: any[]): void | Promise<any>;
2430
+ onRedo(...params: any[]): void | Promise<any>;
2431
+ clearMeasureIds(...params: any[]): void | Promise<any>;
2432
+ clearHidden(...params: any[]): boolean | Promise<any>;
2433
+ hasHiddenMeshnodeIndices(...params: any[]): boolean | Promise<any>;
2434
+ addSelectedMeshnodeIndices(...params: any[]): boolean | Promise<any>;
2435
+ clearAndSelectNode(...params: any[]): void | Promise<any>;
2436
+ clearAndSelectNodes(...params: any[]): void | Promise<any>;
2437
+ getNode(...params: any[]): Promise<any> | PublicNode | undefined;
2438
+ getNodes(...params: any[]): any;
2439
+ setNodesSelected(...params: any[]): boolean | Promise<any>;
2440
+ getRootNode(...params: any[]): Promise<any> | PublicNode | undefined;
2441
+ getSelectedMeshnodeIndices(...params: any[]): Promise<any> | number[];
2442
+ hasSelectedMeshnodeIndices(...params: any[]): boolean | Promise<any>;
2443
+ clearSelected(...params: any[]): boolean | Promise<any>;
2444
+ getFieldOfView(...params: any[]): number | Promise<any>;
2445
+ setFieldOfView(...params: any[]): void | Promise<any>;
2446
+ zoomToBoundingBox(...params: any[]): void | Promise<any>;
2447
+ setPose(...params: any[]): void | Promise<any>;
2448
+ zoomToGlobal(...params: any[]): void | Promise<any>;
2449
+ zoomToSelection(...params: any[]): void | Promise<any>;
2450
+ isolateSelectionInSectionBox(...params: any[]): void | Promise<any>;
2451
+ isolateSelection(...params: any[]): void | Promise<any>;
2452
+ zoomToNodes(...params: any[]): void | Promise<any>;
2453
+ getNumNodesSelected(...params: any[]): Promise<any> | {
2454
+ count: number;
2455
+ };
2456
+ setRenderMode(...params: any[]): void;
2457
+ getRenderMode(...params: any[]): string | Promise<any>;
2458
+ getSelectedNodeIds(...params: any[]): Promise<any> | number[];
2459
+ toggleSectionBoxDisplay(...params: any[]): void | Promise<any>;
2460
+ togglePointToPoint(...params: any[]): void | Promise<any>;
2461
+ zoomToSectionBox(...params: any[]): void | Promise<any>;
2462
+ setSectionBoxHidden(...params: any[]): void | Promise<any>;
2463
+ resetSectionBox(...params: any[]): void | Promise<any>;
2464
+ constructObjectTreeFromNodeIds(...params: any[]): Promise<any> | {
2465
+ nodeIds: number[];
2466
+ ancestors: number[];
2467
+ children: number[];
2468
+ };
2469
+ clearFilteredObjectTree(...params: any[]): void | Promise<any>;
2470
+ getSectionBoxDisplayBbox(...params: any[]): Promise<any> | BoundingBox;
2471
+ getSectionsAsBox(...params: any[]): Promise<any> | OrientedBox | null;
2472
+ setHotkeysEnabled(enabled: any): void;
2473
+ partitionUrlsFromMeshnodeIndices(...params: any[]): any;
2474
+ isPartitionedModel(...params: any[]): boolean | Promise<any>;
2475
+ }
2476
+
2477
+ declare namespace RenderControllerProxy {
2478
+ namespace NAVIGATION_MODE {
2479
+ const NONE: number;
2480
+ const GENERAL: number;
2481
+ const WALK: number;
2482
+ const ORBIT: number;
2483
+ const MEASURE: number;
2484
+ }
2485
+ }
2486
+
2487
+ declare function RenderControllerWorker(params: any): void;
2488
+
2489
+ declare class RenderControllerWorker {
2490
+ constructor(params: any);
2491
+ pubsub: PubSubController;
2492
+ params: any;
2493
+ resolves: {};
2494
+ rejects: {};
2495
+ worker: any;
2496
+ globalPromiseId: number;
2497
+ init(modelDescriptors: any, downloadMetaData: any): void;
2498
+ postSimpleMessage(fn: any, args: any): Promise<any>;
2499
+ postMessage(payload: any): Promise<any>;
2500
+ onUpdateWithState(data: any): Promise<any>;
2501
+ close(...params: any[]): void;
2502
+ waitTillRenderStage(...params: any[]): Promise<any>;
2503
+ getCameraDirection(...params: any[]): Promise<any>;
2504
+ getPosition(...params: any[]): Promise<any>;
2505
+ setNodeColor(...params: any[]): Promise<any>;
2506
+ clearNodeColor(...params: any[]): Promise<any>;
2507
+ clearAllNodeColor(...params: any[]): Promise<any>;
2508
+ setMeshnodeColor(...params: any[]): Promise<any>;
2509
+ setLookAt(...params: any[]): Promise<any>;
2510
+ getLookAt(...params: any[]): Promise<any>;
2511
+ getBenchmarkPoint(...params: any[]): Promise<any>;
2512
+ setBenchmarkPoint(...params: any[]): Promise<any>;
2513
+ setPosition(...params: any[]): Promise<any>;
2514
+ setCameraRotation(...params: any[]): Promise<any>;
2515
+ getGlobalOffset(...params: any[]): Promise<any>;
2516
+ getMeshnodeFromNodeId(...params: any[]): Promise<any>;
2517
+ onResize(...params: any[]): Promise<any>;
2518
+ getMeshnodeFromIndex(...params: any[]): Promise<any>;
2519
+ getMeasureObjectMeshes(...params: any[]): Promise<any>;
2520
+ extractEventVars(evt: any): {
2521
+ pageX: any;
2522
+ pageY: any;
2523
+ offsetX: any;
2524
+ offsetY: any;
2525
+ };
2526
+ onContextMenu(evt: any): Promise<any>;
2527
+ getContextMenuData(evt: any): Promise<any>;
2528
+ onSingleClick(evt: any): Promise<any>;
2529
+ onMouseMove(evt: any): Promise<any>;
2530
+ resizeScene(...params: any[]): Promise<any>;
2531
+ onDoubleClick(evt: any): Promise<any>;
2532
+ onRightClick(evt: any): Promise<any>;
2533
+ getNumNodesHidden(...params: any[]): Promise<any>;
2534
+ hideSelected(...params: any[]): Promise<any>;
2535
+ hideNodeOffset(...params: any[]): Promise<any>;
2536
+ getHiddenNodeIds(...params: any[]): Promise<any>;
2537
+ getHiddenMeshnodeIndices(...params: any[]): Promise<any>;
2538
+ getHiddenGeoIdsSet(...params: any[]): Promise<any>;
2539
+ addHiddenMeshnodeIndices(...params: any[]): Promise<any>;
2540
+ removeHiddenGeoIds(...params: any[]): Promise<any>;
2541
+ setVisibility(...params: any[]): Promise<any>;
2542
+ getVisibility(...params: any[]): Promise<any>;
2543
+ getOrbitTranslate(evt: any): Promise<any>;
2544
+ ToScreenPosition(...params: any[]): Promise<any>;
2545
+ ModelToMapSpace(...params: any[]): Promise<any>;
2546
+ MapToModelSpace(...params: any[]): Promise<any>;
2547
+ setBcfCamera(...params: any[]): Promise<any>;
2548
+ getBcfCamera(...params: any[]): Promise<any>;
2549
+ refreshScene(...params: any[]): Promise<any>;
2550
+ refreshLighting(...params: any[]): Promise<any>;
2551
+ setSectionBox(...params: any[]): Promise<any>;
2552
+ setSectionsData(...params: any[]): Promise<any>;
2553
+ removeSectionBox(...params: any[]): Promise<any>;
2554
+ addSectionPlane(...params: any[]): Promise<any>;
2555
+ removeSectionPlane(...params: any[]): Promise<any>;
2556
+ getSections(...params: any[]): Promise<any>;
2557
+ clearSection(...params: any[]): Promise<any>;
2558
+ setOptions(...params: any[]): Promise<any>;
2559
+ setCanvasSelectionEnabled(...params: any[]): Promise<any>;
2560
+ findFirstObject(...params: any[]): Promise<any>;
2561
+ getNamedNode(...params: any[]): Promise<any>;
2562
+ setEulerAngles(...params: any[]): Promise<any>;
2563
+ setMeasureEnabled(...params: any[]): Promise<any>;
2564
+ statusChange(...params: any[]): Promise<any>;
2565
+ onUndo(...params: any[]): Promise<any>;
2566
+ getMeasureEnabled(...params: any[]): Promise<any>;
2567
+ getMeasureIds(...params: any[]): Promise<any>;
2568
+ removeMeasureIds(...params: any[]): Promise<any>;
2569
+ onRedo(...params: any[]): Promise<any>;
2570
+ clearMeasureIds(...params: any[]): Promise<any>;
2571
+ clearHidden(...params: any[]): Promise<any>;
2572
+ hasHiddenMeshnodeIndices(...params: any[]): Promise<any>;
2573
+ addSelectedMeshnodeIndices(...params: any[]): Promise<any>;
2574
+ clearAndSelectNode(...params: any[]): Promise<any>;
2575
+ clearAndSelectNodes(...params: any[]): Promise<any>;
2576
+ getNode(...params: any[]): Promise<any>;
2577
+ getNodes(...params: any[]): Promise<any>;
2578
+ getRootNode(...params: any[]): Promise<any>;
2579
+ setNodesSelected(...params: any[]): Promise<any>;
2580
+ getSelectedMeshnodeIndices(...params: any[]): Promise<any>;
2581
+ hasSelectedMeshnodeIndices(...params: any[]): Promise<any>;
2582
+ clearSelected(...params: any[]): Promise<any>;
2583
+ getFieldOfView(...params: any[]): Promise<any>;
2584
+ setFieldOfView(...params: any[]): Promise<any>;
2585
+ zoomToBoundingBox(...params: any[]): Promise<any>;
2586
+ setPose(...params: any[]): Promise<any>;
2587
+ zoomToGlobal(...params: any[]): Promise<any>;
2588
+ zoomToSelection(...params: any[]): Promise<any>;
2589
+ isolateSelectionInSectionBox(...params: any[]): Promise<any>;
2590
+ isolateSelection(...params: any[]): Promise<any>;
2591
+ zoomToNodes(...params: any[]): Promise<any>;
2592
+ unhideNodeFromNodeIds(...params: any[]): Promise<any>;
2593
+ hideNodesFromNodeIds(...params: any[]): Promise<any>;
2594
+ getNumNodesSelected(...params: any[]): Promise<any>;
2595
+ setRenderMode(...params: any[]): Promise<any>;
2596
+ getRenderMode(...params: any[]): Promise<any>;
2597
+ getSelectedNodeIds(...params: any[]): Promise<any>;
2598
+ toggleSectionBoxDisplay(...params: any[]): Promise<any>;
2599
+ togglePointToPoint(...params: any[]): Promise<any>;
2600
+ zoomToSectionBox(...params: any[]): Promise<any>;
2601
+ setSectionBoxHidden(...params: any[]): Promise<any>;
2602
+ resetSectionBox(...params: any[]): Promise<any>;
2603
+ constructObjectTreeFromNodeIds(...params: any[]): Promise<any>;
2604
+ clearFilteredObjectTree(...params: any[]): Promise<any>;
2605
+ getSectionBoxDisplayBbox(...params: any[]): Promise<any>;
2606
+ getSectionsAsBox(...params: any[]): Promise<any>;
2607
+ setPwfFileCacheState(...params: any[]): Promise<any>;
2608
+ partitionUrlsFromMeshnodeIndices(...params: any[]): Promise<any>;
2609
+ isPartitionedModel(...params: any[]): Promise<any>;
2610
+ }
2611
+
917
2612
  export declare type RenderMode = (typeof RENDER_MODE)[keyof typeof RENDER_MODE];
918
2613
 
919
2614
  export declare type Resource = FileExtractionModePwfV1OverrideResource | FileExtractionModePwfV2OverrideResource | FileExtractionModeResource | ModelRevisionModePwfV1Resource | ModelRevisionModePwfV2Resource;
920
2615
 
2616
+ declare type ResourceDiscriminator = {
2617
+ fileExtractionId: number;
2618
+ } | {
2619
+ modelRevisionId: number;
2620
+ };
2621
+
921
2622
  export declare type ResourceOptions = CommonOptions & {
922
2623
  resources: Resource[];
923
2624
  };
@@ -926,6 +2627,74 @@ export declare type RGB = `rgb(${number}, ${number}, ${number})`;
926
2627
 
927
2628
  export declare type RGBA = `rgba(${number}, ${number}, ${number}, ${number})`;
928
2629
 
2630
+ declare type SceneGraphName = 'kdtree' | 'wasmtree';
2631
+
2632
+ declare class SectionController {
2633
+ static readonly TYPE: {
2634
+ NULL: number;
2635
+ BOX: number;
2636
+ PLANE: number;
2637
+ };
2638
+ private renderer;
2639
+ private sectionDisplay;
2640
+ private sectionDisplayEnabled;
2641
+ private defaultSection;
2642
+ private currentSectionType;
2643
+ private _globalOffset?;
2644
+ private box;
2645
+ constructor(params: {
2646
+ renderer: PartitionsRenderer;
2647
+ });
2648
+ /**
2649
+ * Existing SectionController Methods
2650
+ */
2651
+ get globalOffset(): THREE.Vector3;
2652
+ set globalOffset(offset: THREE.Vector3);
2653
+ setDefaultSection(min: THREE.Vector3, max: THREE.Vector3, rotation: THREE.Vector3): void;
2654
+ addSectionPlane(distance: number, normal: Vector3): void;
2655
+ removeSectionPlane(uuid: string): void;
2656
+ private getSectionsAsBcf;
2657
+ private getSectionsAsAutodesk;
2658
+ getSections(format: 'bcf' | 'autodesk'): SectionDataProcoreFormat | SectionDataAutodeskFormat | null;
2659
+ getSectionsAsBox(): OrientedBox | null;
2660
+ setSectionBox(min: Vector3, max: Vector3, rotation: Vector3 | null, applyOffset?: boolean): void;
2661
+ removeSectionBox(): void;
2662
+ clearSection(): void;
2663
+ private setSectionsAutodeskFormat;
2664
+ private setSectionsProcoreFormat;
2665
+ setSectionData(sectionData: SectionData, unit?: string): void;
2666
+ /**
2667
+ * SectionBoxDisplay Passthrough Methods
2668
+ */
2669
+ getSectionBoxDisplayBbox(): BoundingBox;
2670
+ clearSectionHover(): void;
2671
+ setSectionBoxHidden(hide: boolean): void;
2672
+ getSectionBoxHidden(): boolean;
2673
+ isSectionBoxHovered(): boolean;
2674
+ onMouseDown(): void;
2675
+ isSectionDisplayEnabled(): boolean;
2676
+ updateSectionDisplay(scene: THREE.Scene, camera: THREE.Camera): void;
2677
+ checkInsideSection(position: Vector3): boolean;
2678
+ resetSectionBox(): void;
2679
+ toggleSectionBoxDisplay(params: {
2680
+ enable: boolean;
2681
+ scene: THREE.Scene;
2682
+ }): void;
2683
+ setSectionBoxDisplay(bbox: BoundingBox): void;
2684
+ updateSectionHover(params: {
2685
+ camera: THREE.Camera;
2686
+ raycaster: THREE.Raycaster;
2687
+ }): boolean;
2688
+ insideSectionBox(position: THREE.Vector3): boolean;
2689
+ resizeSectionBox(params: {
2690
+ xyDelta: Vector2;
2691
+ cameraPosition: THREE.Vector3;
2692
+ cameraDirection: THREE.Vector3;
2693
+ }): void;
2694
+ }
2695
+
2696
+ declare type SectionData = SectionDataAutodeskFormat | SectionDataProcoreFormat;
2697
+
929
2698
  export declare type SectionDataAutodeskFormat = {
930
2699
  Type: 'ClipPlaneSet';
931
2700
  Version: 1;
@@ -938,6 +2707,106 @@ export declare type SectionDataAutodeskFormat = {
938
2707
 
939
2708
  export declare type SectionDataProcoreFormat = ProcoreFormatClipPlane[];
940
2709
 
2710
+ declare class SectionRenderPass extends Pass {
2711
+ scene: THREE.Scene;
2712
+ camera: THREE.Camera;
2713
+ clearDepth: boolean;
2714
+ refresh: boolean;
2715
+ private sectionController;
2716
+ constructor(scene: THREE.Scene, camera: THREE.Camera, sectionController: SectionController);
2717
+ render(renderer: THREE.WebGLRenderer | any, _writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget): void;
2718
+ }
2719
+
2720
+ declare class SelectedNodeServices {
2721
+ private _selectionOption;
2722
+ private selectedVirtualMeshnodeIndicesByResourceId;
2723
+ private selectedFirstObjectCountByResourceId;
2724
+ private selectedNodeIdsByResourceId;
2725
+ private partiallySelectedNodeIdsByResourceId;
2726
+ private models;
2727
+ private objectTrees;
2728
+ static SelectMethod: {
2729
+ readonly Geometry: "Geometry";
2730
+ readonly FirstObject: "FirstObject";
2731
+ };
2732
+ constructor(params: {
2733
+ models: Models;
2734
+ objectTrees: Map<number, ObjectTree>;
2735
+ });
2736
+ get selectionOption(): SelectMethod;
2737
+ set selectionOption(method: SelectMethod);
2738
+ getSelectedVirtualMeshnodesSet(resourceId: number): Set<number>;
2739
+ addSelectedMeshnodeIndices(virtualMeshnodeIndices: number[], resourceId: number): void;
2740
+ private selectFirstObject;
2741
+ private selectGeometry;
2742
+ clear(resourceId: number): void;
2743
+ selectAll(resourceId: number): void;
2744
+ private nodeNeedsUpdating;
2745
+ updateSelectedAncestry(resourceId: number, nodeId: number, isSelected: boolean): void;
2746
+ private removeChildNodesFromPartiallySelected;
2747
+ private recursivelyUpdateParentNodes;
2748
+ setMeshnodeSelectedByVirtualIndex(virtualMeshnodeIndex: number, select: boolean): void;
2749
+ setMeshnodeSelected(meshnode: Meshnode, select: boolean, resourceId: number): void;
2750
+ setNodeSelected(internalNode: InternalNode, select: boolean, resourceId: number): void;
2751
+ private updateNodeAndChildren;
2752
+ getSelectedNodeIds(resourceId: number): Set<number>;
2753
+ getPartiallySelectedNodeIds(resourceId: number): Set<number>;
2754
+ getSelectedObjectCount(method: SelectMethod, resourceId: number): number;
2755
+ hasSelectedMeshnodeIndices(arr: number[], resourceId: number): boolean;
2756
+ removeSelectedMeshnodeIndices(virtualMeshnodeIndices: number[], resourceId: number): void;
2757
+ private unSelectGeometry;
2758
+ private unSelectFirstObject;
2759
+ }
2760
+
2761
+ declare type SelectMethod = keyof typeof SelectedNodeServices.SelectMethod;
2762
+
2763
+ declare type SetNodeColorParams = {
2764
+ palette: Palette;
2765
+ nodeIds: number[];
2766
+ };
2767
+
2768
+ declare class ShortestDistanceController {
2769
+ private measureSet;
2770
+ private models;
2771
+ constructor(params: {
2772
+ models: Models;
2773
+ });
2774
+ getMeasureIds(): number[];
2775
+ addMeasureIds(virtualMeshnodeIndices: number[]): void;
2776
+ clearMeasureIds(): void;
2777
+ hasMeasureIds(arr: number[]): boolean;
2778
+ removeMeasureIds(virtualMeshnodeIndices: number[]): void;
2779
+ handleMeasurementClick(virtualMeshnodeIndex: number): void;
2780
+ getMeasureObjectMeshes(): MeshnodeObject[];
2781
+ }
2782
+
2783
+ declare function StatusTrackingController(camera: any, renderController: any): void;
2784
+
2785
+ declare class StatusTrackingController {
2786
+ constructor(camera: any, renderController: any);
2787
+ camera: any;
2788
+ renderController: any;
2789
+ cameraUndo: {
2790
+ pos: any;
2791
+ qua: any;
2792
+ }[];
2793
+ cameraRedo: any[];
2794
+ sectionUndo: any[];
2795
+ sectionRedo: any[];
2796
+ hiddenUndo: {
2797
+ hideNode: Set<any>;
2798
+ hideGeo: Set<any>;
2799
+ }[];
2800
+ hiddenRedo: any[];
2801
+ statesUndo: any[];
2802
+ statesRedo: any[];
2803
+ onStatusChange(types: any): void;
2804
+ onUndo(): void;
2805
+ onRedo(): void;
2806
+ setCamera(camera: any): void;
2807
+ setHideObject(hideObject: any): void;
2808
+ }
2809
+
941
2810
  declare class StreamedGeometryFactory extends GeometryFactory {
942
2811
  createMeshGeometry(vertexArray: Float32Array, indexArray: Uint16Array, color: number, opacity: number, drawType: number): StreamedMeshGeometry;
943
2812
  createMeshGeometryPrefetching(vertexArray: Float32Array, indexArray: Uint16Array, color: number, opacity: number, drawType: number): StreamedMeshGeometry;
@@ -951,12 +2820,11 @@ declare class StreamedMeshGeometry extends MeshGeometry {
951
2820
  opacity: number;
952
2821
  drawType: number;
953
2822
  numFaces: number;
954
- vertexArrayObject: WebGLVertexArrayObject | null;
955
2823
  verticesLength: number;
956
2824
  verticesGLBuffer: WebGLBuffer | null;
957
2825
  facesLength: number;
958
2826
  facesGLBuffer: WebGLBuffer | null;
959
- constructor(color: number, opacity: number, drawType: number, vertexArrayObject: WebGLVertexArrayObject | null, numVertices: number, verticesBuffer: WebGLBuffer | null, numFaces: number, facesBuffer: WebGLBuffer | null, facesBytesLength: number, index: number);
2827
+ 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);
960
2828
  }
961
2829
 
962
2830
  declare class StreamedMeshnode extends Meshnode {
@@ -982,6 +2850,49 @@ declare class StreamedMeshServices extends MeshServices {
982
2850
  getMeshGeometryForOffsets(meshOffset: number, meshnodeOffset: number): StreamedMeshGeometry | undefined;
983
2851
  }
984
2852
 
2853
+ declare type SvgData = {
2854
+ ellipses?: (BoxEllipse | RadiusEllipse)[];
2855
+ lines?: Line[];
2856
+ arrows?: Arrow[];
2857
+ texts?: Text_2[];
2858
+ rects?: Rect[];
2859
+ };
2860
+
2861
+ declare class SvgRenderer {
2862
+ private svgEl;
2863
+ private dom;
2864
+ private arrowId;
2865
+ private camera;
2866
+ private anchoredSvgData;
2867
+ private _renderControllerProxy;
2868
+ private _globalOffset;
2869
+ constructor();
2870
+ private static createSvgEl;
2871
+ private onRenderReady;
2872
+ private onResize;
2873
+ private set globalOffset(value);
2874
+ private get globalOffset();
2875
+ set renderControllerProxy(renderControllerProxy: RenderControllerProxy);
2876
+ get renderControllerProxy(): RenderControllerProxy;
2877
+ private hasAnchoredElements;
2878
+ private onCameraUpdated;
2879
+ private computeFromAnchored;
2880
+ private saveAnchoredSvgData;
2881
+ private collateByZIndex;
2882
+ draw(svgData: SvgData): void;
2883
+ drawAnchored(anchoredSvgData: AnchoredSvgData): Promise<void>;
2884
+ drawEllipse(ellipse: BoxEllipse | RadiusEllipse): void;
2885
+ drawLine(line: Line): void;
2886
+ drawArrow(arrow: Arrow): void;
2887
+ drawText(text: Text_2): void;
2888
+ drawRect(rect: Rect): void;
2889
+ private clipLine;
2890
+ private _clear;
2891
+ clear(): void;
2892
+ hasContent(): boolean;
2893
+ dispose(): void;
2894
+ }
2895
+
985
2896
  export declare class TestRoutineRecorder {
986
2897
  camera: Camera;
987
2898
  points: Point[];
@@ -993,6 +2904,14 @@ export declare class TestRoutineRecorder {
993
2904
  print(): void;
994
2905
  }
995
2906
 
2907
+ declare type Text_2 = {
2908
+ origin: Vector2;
2909
+ text: string;
2910
+ font?: CssFont;
2911
+ fill: CssColor;
2912
+ zIndex?: number;
2913
+ };
2914
+
996
2915
  export declare const TOOL: {
997
2916
  readonly ALL: 0;
998
2917
  readonly BOTTOMTOOL: 1;
@@ -1062,6 +2981,44 @@ export declare type Vector3 = {
1062
2981
 
1063
2982
  export declare const version: string;
1064
2983
 
2984
+ declare interface ViewerRenderer {
2985
+ initialize(measureSet: number[], models: Models, colorService: ColorServices): void;
2986
+ autoClear: boolean;
2987
+ domElement: HTMLCanvasElement;
2988
+ clippingPlanes: any[];
2989
+ refresh: boolean;
2990
+ context: WebGLRenderingContext;
2991
+ getSize(): {
2992
+ width: number;
2993
+ height: number;
2994
+ };
2995
+ getPixelRatio(): number;
2996
+ getContext(): WebGLRenderingContext;
2997
+ getRenderTarget(): THREE.WebGLRenderTarget;
2998
+ setRenderTarget(renderTarget: THREE.WebGLRenderTarget): void;
2999
+ clear(): void;
3000
+ setSize(width: number, height: number): void;
3001
+ render(scene: THREE.Scene, camera: THREE.Camera): void;
3002
+ cleanBuffer(): void;
3003
+ textures: {
3004
+ picking: THREE.WebGLRenderTarget;
3005
+ };
3006
+ readRenderTargetPixels(renderTarget: THREE.WebGLRenderTarget, x: number, y: number, width: number, height: number, buffer: Uint8Array): void;
3007
+ setRenderMode(mode: RenderMode): void;
3008
+ getRenderMode(): string;
3009
+ setDetailsParams(detailsParam: {
3010
+ detailsInMotion: number;
3011
+ detailsAtRest: number;
3012
+ }): void;
3013
+ getRenderingStage(): string;
3014
+ dispose(): void;
3015
+ enableBackFaceFillColor(state: boolean): void;
3016
+ loadMeshShader(): void;
3017
+ renderSection(scene: THREE.Scene, camera: THREE.Camera): void;
3018
+ getWebGLRenderer(): THREE.WebGLRenderer;
3019
+ setGeometryFactory(geometryFactory: GeometryFactory): void;
3020
+ }
3021
+
1065
3022
  export declare type Viewpoint = {
1066
3023
  camera_data: string;
1067
3024
  sections_data: string;
@@ -1078,6 +3035,20 @@ export declare type Visibility = {
1078
3035
  };
1079
3036
  };
1080
3037
 
3038
+ declare class WASMTree {
3039
+ static maxChunkSize: number;
3040
+ meshnodes: any[];
3041
+ currentIndex: number;
3042
+ cullTree(cameraPosition: any, projectViewMatrix: any, detailsFactor: any): {
3043
+ opaques: Set<any>;
3044
+ transparents: Set<any>;
3045
+ };
3046
+ maxChunkSize: number;
3047
+ buildTree(meshnodes: any): {
3048
+ isComplete: boolean;
3049
+ };
3050
+ }
3051
+
1081
3052
  export declare type WebFormatExtractionItem = {
1082
3053
  item_type: 'WebFormat';
1083
3054
  artifact: {
@@ -1092,6 +3063,7 @@ export declare type WebFormatExtractionItem = {
1092
3063
 
1093
3064
  export declare class Webviewer {
1094
3065
  options: Options;
3066
+ pointToPointManager: PointToPointManager;
1095
3067
  static readonly tools: {
1096
3068
  readonly ALL: 0;
1097
3069
  readonly BOTTOMTOOL: 1;
@@ -1326,6 +3298,14 @@ export declare class Webviewer {
1326
3298
  removeContextMenuItems: ({ contextMenuItemIds, }: {
1327
3299
  contextMenuItemIds: string[];
1328
3300
  }) => void;
3301
+ showCoachmark: (params: {
3302
+ id: string;
3303
+ label: string;
3304
+ buttonLabel: string;
3305
+ buttonOnClick: () => void;
3306
+ tooltipMessage?: string;
3307
+ }) => void;
3308
+ hideCoachmark: (coachmarkId: string) => void;
1329
3309
  getSettings: () => {
1330
3310
  displayUnits: string;
1331
3311
  };
@@ -1346,4 +3326,9 @@ export declare class Webviewer {
1346
3326
  terminate: () => void;
1347
3327
  }
1348
3328
 
3329
+ declare type WheelControl = {
3330
+ onWheel: (event: WheelEvent) => void;
3331
+ dispose: () => void;
3332
+ };
3333
+
1349
3334
  export { }