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