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