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