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