@procore/bim-webviewer-sdk 15.2.0 → 15.3.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 +19 -4
- package/dist/Procore.Bim.Webviewer.d.ts +749 -6
- package/dist/Procore.Bim.Webviewer.js +1 -1
- package/dist/types/src/Webviewer.d.ts +21 -5
- package/dist/types/src/api/analytic_events/analyticKeys.d.ts +2 -0
- package/dist/types/src/api/analytic_events/payloadFactories.d.ts +1 -0
- package/dist/types/src/components/ViewpointManager/ViewpointManager.d.ts +6 -2
- package/dist/types/src/controllers/RenderController.d.ts +4 -4
- package/dist/types/src/controllers/RenderControllerProxy.d.ts +99 -98
- package/dist/types/src/controllers/RenderControllerWorker.d.ts +94 -94
- package/dist/types/src/procoregl/HiddenNodeServices/HiddenNodeServices.d.ts +3 -1
- package/dist/types/src/sdk.d.ts +4 -1
- package/dist/types/src/types/Palette.d.ts +1 -1
- package/dist/types/src/types/WebviewerOptions.d.ts +28 -1
- package/dist/types/src/utils/ApiMetaData/ApiMetaData.d.ts +18 -12
- package/dist/types/src/utils/ApiMetaData/__tests__/mocks.d.ts +25 -1
- package/dist/types/src/utils/Error/CustomError.d.ts +3 -0
- package/dist/types/src/utils/Error/ErrorLogger.d.ts +12 -0
- package/dist/types/src/utils/Error/ExternalError.d.ts +5 -0
- package/dist/types/src/utils/Error/__tests__/CustomError.test.d.ts +1 -0
- package/dist/types/src/utils/Error/__tests__/ErrorLogger.test.d.ts +1 -0
- package/dist/types/src/utils/Error/__tests__/ExternalError.test.d.ts +1 -0
- package/dist/types/src/utils/Error/index.d.ts +3 -0
- package/dist/types/src/utils/Logger/BugsnagLogger.d.ts +8 -0
- package/dist/types/src/utils/Logger/Logger.d.ts +3 -0
- package/dist/types/src/utils/Logger/__tests__/BugsnagLogger.test.d.ts +1 -0
- package/dist/types/src/utils/Logger/index.d.ts +2 -0
- package/package.json +1 -1
|
@@ -1,3 +1,6 @@
|
|
|
1
|
+
import { Matrix4 } from 'three/src/math/Matrix4';
|
|
2
|
+
import { Vector3 as Vector3_2 } from 'three/src/math/Vector3';
|
|
3
|
+
|
|
1
4
|
export declare const ACTION: {
|
|
2
5
|
readonly NONE: -1;
|
|
3
6
|
readonly PAN: 1;
|
|
@@ -76,6 +79,18 @@ export declare type BoundingBox = {
|
|
|
76
79
|
min: Vector3;
|
|
77
80
|
};
|
|
78
81
|
|
|
82
|
+
declare class BVHTree {
|
|
83
|
+
static maxChunkSize: number;
|
|
84
|
+
constructor(pwf: any);
|
|
85
|
+
pwf: any;
|
|
86
|
+
meshnodes: any;
|
|
87
|
+
currentIndex: number;
|
|
88
|
+
buildTree(): {
|
|
89
|
+
isComplete: boolean;
|
|
90
|
+
};
|
|
91
|
+
rollupBBox(meshnode: any): void;
|
|
92
|
+
}
|
|
93
|
+
|
|
79
94
|
declare const Cache_2: {
|
|
80
95
|
removeModel: (options: any) => Promise<boolean>;
|
|
81
96
|
hasModel: (geometryBundle: GeometryBundle) => Promise<boolean>;
|
|
@@ -84,6 +99,11 @@ export { Cache_2 as Cache }
|
|
|
84
99
|
|
|
85
100
|
declare type Camera = any;
|
|
86
101
|
|
|
102
|
+
declare type Color = {
|
|
103
|
+
color: string;
|
|
104
|
+
opacity: number;
|
|
105
|
+
};
|
|
106
|
+
|
|
87
107
|
export declare type CommonOptions = {
|
|
88
108
|
/**
|
|
89
109
|
* Always required
|
|
@@ -131,6 +151,18 @@ export declare type CommonOptions = {
|
|
|
131
151
|
|
|
132
152
|
export declare type CssColor = RGB | RGBA | HEX | string;
|
|
133
153
|
|
|
154
|
+
export declare namespace ErrorLogger {
|
|
155
|
+
let logger: Logger;
|
|
156
|
+
const init: (params: {
|
|
157
|
+
bugsnagConfig: {
|
|
158
|
+
apiKey: string;
|
|
159
|
+
releaseStage?: string;
|
|
160
|
+
};
|
|
161
|
+
}) => void;
|
|
162
|
+
const logError: <T extends Error>(error: T) => void;
|
|
163
|
+
const dispose: () => void;
|
|
164
|
+
}
|
|
165
|
+
|
|
134
166
|
export declare type FeatureFlags = Partial<{
|
|
135
167
|
enableObjectTreeSearch: boolean;
|
|
136
168
|
}>;
|
|
@@ -151,10 +183,22 @@ export declare type FileExtractionModePwfV1OverrideOptions = CommonOptions & Pwf
|
|
|
151
183
|
fileExtractionId: FileExtraction['id'];
|
|
152
184
|
};
|
|
153
185
|
|
|
186
|
+
export declare type FileExtractionModePwfV1OverrideResource = PwfV1Bundle & {
|
|
187
|
+
fileExtractionId: FileExtraction['id'];
|
|
188
|
+
};
|
|
189
|
+
|
|
154
190
|
export declare type FileExtractionModePwfV2OverrideOptions = CommonOptions & PwfV2Bundle & {
|
|
155
191
|
fileExtractionId: FileExtraction['id'];
|
|
156
192
|
};
|
|
157
193
|
|
|
194
|
+
export declare type FileExtractionModePwfV2OverrideResource = PwfV2Bundle & {
|
|
195
|
+
fileExtractionId: FileExtraction['id'];
|
|
196
|
+
};
|
|
197
|
+
|
|
198
|
+
export declare type FileExtractionModeResource = {
|
|
199
|
+
fileExtractionId: FileExtraction['id'];
|
|
200
|
+
};
|
|
201
|
+
|
|
158
202
|
export declare type FileVersion = {
|
|
159
203
|
id: number;
|
|
160
204
|
file_id: number;
|
|
@@ -180,18 +224,258 @@ export declare type GeometryBundle = {
|
|
|
180
224
|
manifestUrl?: GeometryFile['url'];
|
|
181
225
|
};
|
|
182
226
|
|
|
227
|
+
declare class GeometryFactory {
|
|
228
|
+
private static maxArraySize;
|
|
229
|
+
private vbuffers;
|
|
230
|
+
private fbuffers;
|
|
231
|
+
private curVertexPos;
|
|
232
|
+
private curIndexPos;
|
|
233
|
+
private cylinderVBuffer;
|
|
234
|
+
private cylinderFBuffer;
|
|
235
|
+
protected gl: WebGL2RenderingContext;
|
|
236
|
+
constructor(gl: WebGL2RenderingContext);
|
|
237
|
+
createDataBuffer(vertexArray: Float32Array, indexArray: Uint16Array): GPUMeshData;
|
|
238
|
+
createCylinderBuffer(vertexArray: Float32Array, indexArray: Uint16Array): GPUMeshData;
|
|
239
|
+
protected newVertexBuffer(_size?: number): void;
|
|
240
|
+
protected newIndexBuffer(_size?: number): void;
|
|
241
|
+
createCylinderGeometry(_vertices: Float32Array, _faces: Uint16Array, _color: number, _opacity: number, _drawType: number): StreamedMeshGeometry;
|
|
242
|
+
createMeshGeometry(_vertices: Float32Array, _faces: Uint16Array, _color: number, _opacity: number, _drawType: number): StreamedMeshGeometry;
|
|
243
|
+
}
|
|
244
|
+
|
|
183
245
|
export declare type GeometryFile = {
|
|
184
246
|
url: string;
|
|
185
247
|
};
|
|
186
248
|
|
|
249
|
+
declare type GPUMeshData = {
|
|
250
|
+
index: number;
|
|
251
|
+
f_byte_size: number;
|
|
252
|
+
vertexArrayObject: WebGLVertexArrayObject | null;
|
|
253
|
+
};
|
|
254
|
+
|
|
187
255
|
export declare type HEX = `#${string}`;
|
|
188
256
|
|
|
257
|
+
declare class KDTree {
|
|
258
|
+
private MAX_CHILDREN_PER_NODE;
|
|
259
|
+
private root;
|
|
260
|
+
private tmpFrustum;
|
|
261
|
+
private queue;
|
|
262
|
+
private result;
|
|
263
|
+
constructor();
|
|
264
|
+
cullTree(cameraPosition: Vector3_2, frustumMatrix: Matrix4, detailsParam: number): {
|
|
265
|
+
opaques: Meshnode[];
|
|
266
|
+
transparents: Meshnode[];
|
|
267
|
+
};
|
|
268
|
+
buildTree(meshnodes: Meshnode[]): {
|
|
269
|
+
isComplete: boolean;
|
|
270
|
+
};
|
|
271
|
+
collectMeshnodes(cameraPosition: Vector3_2, detailsFactor: number): {
|
|
272
|
+
opaques: Meshnode[];
|
|
273
|
+
transparents: Meshnode[];
|
|
274
|
+
};
|
|
275
|
+
}
|
|
276
|
+
|
|
277
|
+
declare interface Logger {
|
|
278
|
+
logError(error: any): void;
|
|
279
|
+
}
|
|
280
|
+
|
|
281
|
+
declare type Manifest = {
|
|
282
|
+
version: string;
|
|
283
|
+
globalAABB: BoundingBox;
|
|
284
|
+
reducedGlobalAABB: BoundingBox;
|
|
285
|
+
meshnodeOffset: number;
|
|
286
|
+
numMeshnodes: number;
|
|
287
|
+
numMeshes: number;
|
|
288
|
+
numNodes: number;
|
|
289
|
+
globalOffset: Vector3;
|
|
290
|
+
};
|
|
291
|
+
|
|
292
|
+
declare type Mesh = {
|
|
293
|
+
[key: string]: any;
|
|
294
|
+
};
|
|
295
|
+
|
|
296
|
+
declare class Mesh_2 {
|
|
297
|
+
private pwfMesh;
|
|
298
|
+
constructor(pwfMesh: PWFMesh);
|
|
299
|
+
offset(): number;
|
|
300
|
+
color(): number;
|
|
301
|
+
opacity(): number;
|
|
302
|
+
drawType(): number;
|
|
303
|
+
numVertices(): number;
|
|
304
|
+
lenVertices(): number;
|
|
305
|
+
numFaces(): number;
|
|
306
|
+
lenFaces(): number;
|
|
307
|
+
vertices(): Float32Array;
|
|
308
|
+
faces(): Uint16Array;
|
|
309
|
+
asObject(): Record<string, unknown>;
|
|
310
|
+
}
|
|
311
|
+
|
|
312
|
+
declare class MeshData {
|
|
313
|
+
private _meshIndex;
|
|
314
|
+
private compressedMeshData;
|
|
315
|
+
private uncompressedMeshData?;
|
|
316
|
+
private meshGeometry?;
|
|
317
|
+
constructor(meshIndex: number, compressedMeshData: ArrayBuffer);
|
|
318
|
+
meshIndex(): number;
|
|
319
|
+
color(): number;
|
|
320
|
+
opacity(): number;
|
|
321
|
+
drawType(): number;
|
|
322
|
+
vertices(): Float32Array;
|
|
323
|
+
faces(): Uint16Array;
|
|
324
|
+
uploadToGPU(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
|
|
325
|
+
uploadToGPUPreFetching(geometryFactory: StreamedGeometryFactory): StreamedMeshGeometry;
|
|
326
|
+
getUncompressedMeshData(): ArrayBuffer;
|
|
327
|
+
}
|
|
328
|
+
|
|
329
|
+
declare class MeshGeometry {
|
|
330
|
+
index: number;
|
|
331
|
+
indexLength: number;
|
|
332
|
+
vertexArrayObject: WebGLVertexArrayObject | null;
|
|
333
|
+
color: number;
|
|
334
|
+
opacity: number;
|
|
335
|
+
drawType: number;
|
|
336
|
+
lastFrameId: number;
|
|
337
|
+
numFaces: number;
|
|
338
|
+
constructor(meshData: GPUMeshData, color: number, opacity: number, drawType: number);
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
declare class Meshnode {
|
|
342
|
+
protected pwfMeshnode: PWFMeshnode;
|
|
343
|
+
private hiddenValue;
|
|
344
|
+
private box3Value?;
|
|
345
|
+
private centerValue?;
|
|
346
|
+
private meshDataValue?;
|
|
347
|
+
private meshGeometriesValue?;
|
|
348
|
+
protected pwf: PWF;
|
|
349
|
+
selected: boolean;
|
|
350
|
+
private _parent?;
|
|
351
|
+
constructor(pwfMeshnode: PWFMeshnode, pwf: PWF);
|
|
352
|
+
offset(): number;
|
|
353
|
+
parentOffset(): number;
|
|
354
|
+
parent(): Node_2;
|
|
355
|
+
children(): never[];
|
|
356
|
+
nodeId(): number;
|
|
357
|
+
bbox(): Float32Array;
|
|
358
|
+
box3(): NonNullable<Meshnode['box3Value']>;
|
|
359
|
+
center(): THREE.Vector3;
|
|
360
|
+
matrix(): Float32Array;
|
|
361
|
+
group(): number;
|
|
362
|
+
opaque(): number;
|
|
363
|
+
numChild(): number;
|
|
364
|
+
childRefs(): Uint32Array;
|
|
365
|
+
isNode(): boolean;
|
|
366
|
+
isMeshnode(): this is Meshnode;
|
|
367
|
+
index(): number;
|
|
368
|
+
meshGeometries(): MeshGeometry[];
|
|
369
|
+
protected geometries(): MeshGeometry[];
|
|
370
|
+
private meshData;
|
|
371
|
+
isRoot(): boolean;
|
|
372
|
+
hidden(): Meshnode['hiddenValue'];
|
|
373
|
+
setHidden(hidden: boolean): void;
|
|
374
|
+
setParent(node: Node_2): void;
|
|
375
|
+
asObject(): MeshnodeObject;
|
|
376
|
+
}
|
|
377
|
+
|
|
378
|
+
declare type MeshnodeObject = {
|
|
379
|
+
bbox: Float32Array;
|
|
380
|
+
matrix: Float32Array;
|
|
381
|
+
numChild: number;
|
|
382
|
+
childRefs: Uint32Array;
|
|
383
|
+
meshData: Mesh[];
|
|
384
|
+
nodeId: number;
|
|
385
|
+
meshnodeIndex: number;
|
|
386
|
+
hidden: boolean;
|
|
387
|
+
type: string;
|
|
388
|
+
selected: boolean;
|
|
389
|
+
};
|
|
390
|
+
|
|
391
|
+
declare class MeshnodeServices {
|
|
392
|
+
private meshnodeCount;
|
|
393
|
+
private meshnodes;
|
|
394
|
+
protected pwf: PWF;
|
|
395
|
+
protected cachedMeshnodes: Map<number, Meshnode>;
|
|
396
|
+
constructor(pwfMeshnodes: PWFMeshnode[], pwf: PWF);
|
|
397
|
+
getMeshnodeFromIndex(index: number): Meshnode;
|
|
398
|
+
getMeshnode(offset: number): Meshnode;
|
|
399
|
+
numMeshnodes(): number;
|
|
400
|
+
allMeshnodes(): NonNullable<MeshnodeServices['meshnodes']>;
|
|
401
|
+
protected createMeshnode(pwfMeshnode: PWFMeshnode): Meshnode;
|
|
402
|
+
}
|
|
403
|
+
|
|
404
|
+
declare class MeshnodeServices_2 extends MeshnodeServices {
|
|
405
|
+
}
|
|
406
|
+
|
|
407
|
+
declare class MeshnodeServices_3 extends MeshnodeServices_2 {
|
|
408
|
+
protected manifest: Manifest;
|
|
409
|
+
constructor(_buffer: ArrayBuffer, pwf: PWF, manifest: Manifest);
|
|
410
|
+
numMeshnodes(): number;
|
|
411
|
+
globalOffset(): {
|
|
412
|
+
offsetX: number;
|
|
413
|
+
offsetY: number;
|
|
414
|
+
offsetZ: number;
|
|
415
|
+
};
|
|
416
|
+
}
|
|
417
|
+
|
|
418
|
+
declare class MeshServices {
|
|
419
|
+
protected pwf: PWF;
|
|
420
|
+
protected geometryFactory?: GeometryFactory;
|
|
421
|
+
private meshGeometryMap;
|
|
422
|
+
private pwfMeshes;
|
|
423
|
+
private pwfMeshOffsetMap;
|
|
424
|
+
private meshCount;
|
|
425
|
+
private currentIndex;
|
|
426
|
+
static maxChunkSize: number;
|
|
427
|
+
constructor(pwfMeshes: PWFMesh[], pwf: PWF);
|
|
428
|
+
setGeometryFactory(geometryFactory: GeometryFactory): void;
|
|
429
|
+
getMeshGeometryForOffsets(meshOffset: number, _meshnodeOffset: number | undefined): MeshGeometry | undefined;
|
|
430
|
+
meshFromOffset(offset: number): Mesh_2;
|
|
431
|
+
numMeshes(): number;
|
|
432
|
+
meshes(): PWFMesh[];
|
|
433
|
+
loadAllMeshGeometryToGPU(): {
|
|
434
|
+
isComplete: boolean;
|
|
435
|
+
};
|
|
436
|
+
private loadToGPU;
|
|
437
|
+
getMeshVerticesAndFaces(meshOffset: number, _meshnodeOffset: number): MeshVerticesAndFaces;
|
|
438
|
+
private loadMeshGeometryToGPU;
|
|
439
|
+
}
|
|
440
|
+
|
|
441
|
+
declare class MeshServices_2 extends MeshServices {
|
|
442
|
+
}
|
|
443
|
+
|
|
444
|
+
declare class MeshServices_3 extends MeshServices_2 {
|
|
445
|
+
protected manifest: Manifest;
|
|
446
|
+
constructor(_buffer: ArrayBuffer, pwf: PWF, manifest: Manifest);
|
|
447
|
+
}
|
|
448
|
+
|
|
449
|
+
declare type MeshVerticesAndFaces = {
|
|
450
|
+
meshOffset: number;
|
|
451
|
+
vertices: number[];
|
|
452
|
+
faces: number[];
|
|
453
|
+
};
|
|
454
|
+
|
|
189
455
|
declare type MetricId = string;
|
|
190
456
|
|
|
191
457
|
export declare type Model = {
|
|
192
458
|
id: number;
|
|
193
459
|
};
|
|
194
460
|
|
|
461
|
+
declare type ModelInitializationPayload = {
|
|
462
|
+
success: boolean;
|
|
463
|
+
start_timestamp: number;
|
|
464
|
+
end_timestamp: number;
|
|
465
|
+
total_time: number;
|
|
466
|
+
model_type: ModelType;
|
|
467
|
+
node_size?: number;
|
|
468
|
+
meshnode_size?: number;
|
|
469
|
+
num_nodes?: number;
|
|
470
|
+
num_meshnodes?: number;
|
|
471
|
+
mesh_size?: number;
|
|
472
|
+
num_meshes?: number;
|
|
473
|
+
partition_proxy_size?: number;
|
|
474
|
+
web_viewer_version: string;
|
|
475
|
+
step_failed?: string;
|
|
476
|
+
error_description?: string;
|
|
477
|
+
};
|
|
478
|
+
|
|
195
479
|
export declare type ModelRevision = {
|
|
196
480
|
id: number;
|
|
197
481
|
revision: number;
|
|
@@ -203,15 +487,27 @@ export declare type ModelRevisionModePwfV1Options = CommonOptions & PwfV1Bundle
|
|
|
203
487
|
modelRevisionId: ModelRevision['id'];
|
|
204
488
|
};
|
|
205
489
|
|
|
490
|
+
export declare type ModelRevisionModePwfV1Resource = PwfV1Bundle & {
|
|
491
|
+
modelId: Model['id'];
|
|
492
|
+
modelRevisionId: ModelRevision['id'];
|
|
493
|
+
};
|
|
494
|
+
|
|
206
495
|
export declare type ModelRevisionModePwfV2Options = CommonOptions & PwfV2Bundle & {
|
|
207
496
|
modelId: Model['id'];
|
|
208
497
|
modelRevisionId: ModelRevision['id'];
|
|
209
498
|
};
|
|
210
499
|
|
|
500
|
+
export declare type ModelRevisionModePwfV2Resource = PwfV2Bundle & {
|
|
501
|
+
modelId: Model['id'];
|
|
502
|
+
modelRevisionId: ModelRevision['id'];
|
|
503
|
+
};
|
|
504
|
+
|
|
211
505
|
export declare type ModelRevisionViewpoint = Viewpoint & {
|
|
212
506
|
primary: boolean;
|
|
213
507
|
};
|
|
214
508
|
|
|
509
|
+
declare type ModelType = 'standard' | 'partitioned' | undefined;
|
|
510
|
+
|
|
215
511
|
export declare const NAV_MODE: {
|
|
216
512
|
readonly DEFAULT: 0;
|
|
217
513
|
readonly FLY: 1;
|
|
@@ -224,17 +520,171 @@ export declare const NAV_MODE: {
|
|
|
224
520
|
|
|
225
521
|
export declare type NavigationMode = (typeof NAV_MODE)[keyof typeof NAV_MODE];
|
|
226
522
|
|
|
523
|
+
declare class Node_2 {
|
|
524
|
+
private pwfNode;
|
|
525
|
+
private pwf;
|
|
526
|
+
private box3Value;
|
|
527
|
+
isFirstObjectValue: boolean;
|
|
528
|
+
private _parent?;
|
|
529
|
+
constructor(pwfNode: PWFNode, pwf: PWF);
|
|
530
|
+
box3(): Node_2['box3Value'];
|
|
531
|
+
unionBBox(bbox: THREE.Box3): void;
|
|
532
|
+
isRoot(): boolean;
|
|
533
|
+
offset(): number;
|
|
534
|
+
nodeId(): number;
|
|
535
|
+
parentOff(): number;
|
|
536
|
+
setParent(node: Node_2): void;
|
|
537
|
+
parent(): Node_2 | undefined;
|
|
538
|
+
numChild(): number;
|
|
539
|
+
hasChildren(): boolean;
|
|
540
|
+
group(): number;
|
|
541
|
+
isSelectable(): boolean;
|
|
542
|
+
nodeType(): number;
|
|
543
|
+
childOffsets(): Uint32Array;
|
|
544
|
+
children(): (Node_2 | Meshnode)[];
|
|
545
|
+
isNode(): this is Node_2;
|
|
546
|
+
isMeshnode(): boolean;
|
|
547
|
+
isFirstObject(): boolean;
|
|
548
|
+
hasMeshnodeChildren(): boolean;
|
|
549
|
+
numMeshnodeChildren(): number;
|
|
550
|
+
asObject(): NodeAsObject;
|
|
551
|
+
}
|
|
552
|
+
|
|
553
|
+
declare type NodeAsObject = {
|
|
554
|
+
offset: number;
|
|
555
|
+
nodeId: number;
|
|
556
|
+
parentOff: number;
|
|
557
|
+
childOffsets: Uint32Array;
|
|
558
|
+
numChild: number;
|
|
559
|
+
nodeType: number;
|
|
560
|
+
hasChildren: boolean;
|
|
561
|
+
hasMeshnodeChildren: boolean;
|
|
562
|
+
bbox: NodeBoundingBox;
|
|
563
|
+
type: string;
|
|
564
|
+
parentId: number | undefined;
|
|
565
|
+
children: number[];
|
|
566
|
+
};
|
|
567
|
+
|
|
227
568
|
export declare type NodeBoundingBox = {
|
|
228
569
|
min: number[];
|
|
229
570
|
max: number[];
|
|
230
571
|
};
|
|
231
572
|
|
|
573
|
+
declare type NodeId = ReturnType<Node_2['nodeId']>;
|
|
574
|
+
|
|
575
|
+
declare class NodeServices {
|
|
576
|
+
private nodes;
|
|
577
|
+
private nodeIdToOffsetMap;
|
|
578
|
+
private pwf;
|
|
579
|
+
protected meshnodeOffPointerValue: number;
|
|
580
|
+
private stack;
|
|
581
|
+
private queue;
|
|
582
|
+
static maxChunkSize: number;
|
|
583
|
+
private _numFirstObjects;
|
|
584
|
+
nodesOffset: number;
|
|
585
|
+
private _pwfRootNode;
|
|
586
|
+
private _numNodes;
|
|
587
|
+
private _pwfNodeOffsetMap;
|
|
588
|
+
private _rootNode?;
|
|
589
|
+
constructor(pwfNodes: PWFNode[], meshnodeOffPointer: number, pwf: PWF);
|
|
590
|
+
nodeFromOffset(offset: number): Node_2;
|
|
591
|
+
buildNodes(): {
|
|
592
|
+
nodes: NodeServices['nodes'];
|
|
593
|
+
isComplete: boolean;
|
|
594
|
+
};
|
|
595
|
+
root(): Node_2;
|
|
596
|
+
getNode(offset: number): Node_2 | Meshnode;
|
|
597
|
+
getNodeById(id: number): Node_2;
|
|
598
|
+
hasNode(id: number): boolean;
|
|
599
|
+
breadthFirstTraversal(callback: (n: Node_2 | Meshnode) => void): {
|
|
600
|
+
isComplete: boolean;
|
|
601
|
+
};
|
|
602
|
+
private buildNodesRecursively;
|
|
603
|
+
private buildChildren;
|
|
604
|
+
meshnodeOffPointer(): NonNullable<NodeServices['meshnodeOffPointerValue']>;
|
|
605
|
+
findFirstObject(meshnode: Meshnode): Node_2;
|
|
606
|
+
numNodes(): number;
|
|
607
|
+
allNodes(): Node_2[];
|
|
608
|
+
numFirstObjects(): number;
|
|
609
|
+
}
|
|
610
|
+
|
|
611
|
+
declare class NodeServices_2 extends NodeServices {
|
|
612
|
+
}
|
|
613
|
+
|
|
614
|
+
declare class NodeServices_3 extends NodeServices_2 {
|
|
615
|
+
protected manifest: Manifest;
|
|
616
|
+
constructor(_buffer: ArrayBuffer, pwf: PWF, manifest: Manifest);
|
|
617
|
+
meshnodeOffPointer(): NonNullable<NodeServices_3['meshnodeOffPointerValue']>;
|
|
618
|
+
}
|
|
619
|
+
|
|
232
620
|
export declare type ObjectFilter = {
|
|
233
621
|
filterField: FilterField;
|
|
234
622
|
filterValue: string;
|
|
235
623
|
};
|
|
236
624
|
|
|
237
|
-
export declare type Options = FileExtractionModePwfV2OverrideOptions | FileExtractionModePwfV1OverrideOptions | FileExtractionModeOptions | ModelRevisionModePwfV2Options | ModelRevisionModePwfV1Options;
|
|
625
|
+
export declare type Options = FileExtractionModePwfV2OverrideOptions | FileExtractionModePwfV1OverrideOptions | FileExtractionModeOptions | ModelRevisionModePwfV2Options | ModelRevisionModePwfV1Options | ResourceOptions;
|
|
626
|
+
|
|
627
|
+
declare type Palette = {
|
|
628
|
+
default?: Color;
|
|
629
|
+
xray?: Color;
|
|
630
|
+
selected?: Color;
|
|
631
|
+
};
|
|
632
|
+
|
|
633
|
+
export declare type PaletteParams = {
|
|
634
|
+
palette: Palette;
|
|
635
|
+
objectIds: NodeId[];
|
|
636
|
+
};
|
|
637
|
+
|
|
638
|
+
declare class Partition {
|
|
639
|
+
private pwfPartition;
|
|
640
|
+
constructor(pwfPartition: PWFPartition);
|
|
641
|
+
partitionId(): number;
|
|
642
|
+
meshData(): MeshData[];
|
|
643
|
+
}
|
|
644
|
+
|
|
645
|
+
declare class PartitionProxy {
|
|
646
|
+
static projectId: number;
|
|
647
|
+
static baseUrl: string;
|
|
648
|
+
private pwfPartitionProxy;
|
|
649
|
+
static numberOfPartitions: number;
|
|
650
|
+
static numberOfPartitionsLoaded: number;
|
|
651
|
+
static currentNumberOfDownloading: number;
|
|
652
|
+
static prefetchingPartitions: boolean;
|
|
653
|
+
loadedToGPU: boolean;
|
|
654
|
+
isLoading: boolean;
|
|
655
|
+
private _meshnodes;
|
|
656
|
+
private static partitionsLoaded;
|
|
657
|
+
static initCompletePayload: ModelInitializationPayload;
|
|
658
|
+
static renderReadyParams: {
|
|
659
|
+
offsetWidth: number;
|
|
660
|
+
offsetHeight: number;
|
|
661
|
+
offsetTop: number;
|
|
662
|
+
offsetLeft: number;
|
|
663
|
+
};
|
|
664
|
+
private _byteLength?;
|
|
665
|
+
private _compressedByteLength?;
|
|
666
|
+
static Stats: {
|
|
667
|
+
PartitionsLoaded: number;
|
|
668
|
+
MeshesLoaded: number;
|
|
669
|
+
VerticesLoaded: number;
|
|
670
|
+
FacesLoaded: number;
|
|
671
|
+
};
|
|
672
|
+
constructor(pwfPartitionProxy: PWFPartitionProxy);
|
|
673
|
+
partitionId(): number;
|
|
674
|
+
partitionUrl(): string;
|
|
675
|
+
meshnodeOffsets(): Uint32Array;
|
|
676
|
+
meshnodes(): StreamedMeshnode[];
|
|
677
|
+
setMeshnodes(meshnodes: StreamedMeshnode[]): void;
|
|
678
|
+
loadPartitionData(callbackFn: (partition: Partition) => void): Promise<void>;
|
|
679
|
+
loadPartition(factory: StreamedGeometryFactory): Promise<void>;
|
|
680
|
+
size(): {
|
|
681
|
+
compressed: number;
|
|
682
|
+
size: number;
|
|
683
|
+
};
|
|
684
|
+
static processPartitionProxiesAB(partitionProxiesAB: Uint8Array, callback: (partitionProxy: PartitionProxy) => void): void;
|
|
685
|
+
static getPartitionProxies(partitionProxiesAB: ArrayBuffer): PWFPartitionProxy[];
|
|
686
|
+
getContentOfPartitionUrl(): string;
|
|
687
|
+
}
|
|
238
688
|
|
|
239
689
|
declare type Point = {
|
|
240
690
|
position: {
|
|
@@ -282,6 +732,202 @@ export declare type PublicNode = {
|
|
|
282
732
|
children: number[];
|
|
283
733
|
};
|
|
284
734
|
|
|
735
|
+
declare class PWF {
|
|
736
|
+
static timeSince(time: any): string;
|
|
737
|
+
static isPartitionProxiesAB(meshAB: any): boolean;
|
|
738
|
+
constructor(params: any);
|
|
739
|
+
meshnodeOffPointerValue: number;
|
|
740
|
+
globalOffsetValue: {
|
|
741
|
+
offsetX: number;
|
|
742
|
+
offsetY: number;
|
|
743
|
+
offsetZ: number;
|
|
744
|
+
};
|
|
745
|
+
sceneGraphName: any;
|
|
746
|
+
isLogging: any;
|
|
747
|
+
locale: any;
|
|
748
|
+
downloadMetaData: any;
|
|
749
|
+
streaming: boolean;
|
|
750
|
+
nodeServices: NodeServices | null;
|
|
751
|
+
meshnodeServices: StreamedMeshnodeServices | MeshnodeServices | null;
|
|
752
|
+
meshServices: StreamedMeshServices | MeshServices | null;
|
|
753
|
+
sceneGraph: WASMTree | KDTree | null;
|
|
754
|
+
bvhTree: BVHTree | null;
|
|
755
|
+
measureSet: any[];
|
|
756
|
+
_gl: any;
|
|
757
|
+
manifest: any;
|
|
758
|
+
_numMeshnodes: number;
|
|
759
|
+
loadPWFVersion(version: any): void;
|
|
760
|
+
version: typeof V1 | typeof V2 | undefined;
|
|
761
|
+
setArrayBuffers(nodeAB: any, meshnodeAB: any, meshAB: any): void;
|
|
762
|
+
setStandardModelBuffers(nodeAB: any, meshnodeAB: any, meshAB: any): void;
|
|
763
|
+
nodeAB: any;
|
|
764
|
+
meshnodeAB: any;
|
|
765
|
+
meshAB: any;
|
|
766
|
+
detailsParams: {
|
|
767
|
+
[key: string]: any;
|
|
768
|
+
} | undefined;
|
|
769
|
+
setPartitionedModelBuffers(nodeAB: any, meshnodeAB: any, partitionProxiesAB: any): void;
|
|
770
|
+
partitionProxiesAB: ArrayBuffer | undefined;
|
|
771
|
+
computeDetailsValues(): number[];
|
|
772
|
+
getNumPartitions(): number;
|
|
773
|
+
initPwfParser(): void;
|
|
774
|
+
pwfModelParser: PWFModelParser | undefined;
|
|
775
|
+
_numMeshes: number | undefined;
|
|
776
|
+
pwfModel: {
|
|
777
|
+
nodes: never[];
|
|
778
|
+
meshnodes: never[];
|
|
779
|
+
meshes: never[];
|
|
780
|
+
} | undefined;
|
|
781
|
+
parsePwfNodes(): {
|
|
782
|
+
isComplete: boolean;
|
|
783
|
+
};
|
|
784
|
+
parsePwfMeshnodes(): {
|
|
785
|
+
isComplete: boolean;
|
|
786
|
+
};
|
|
787
|
+
parsePwfMeshes(): void;
|
|
788
|
+
initMeshServices(): void;
|
|
789
|
+
initNodeServices(): void;
|
|
790
|
+
initMeshnodeServices(): void;
|
|
791
|
+
initNodeTree(): {
|
|
792
|
+
nodes: {
|
|
793
|
+
[key: string]: Node_2 | Meshnode;
|
|
794
|
+
};
|
|
795
|
+
isComplete: boolean;
|
|
796
|
+
};
|
|
797
|
+
initNodeTreeBoundingBoxes(): {
|
|
798
|
+
isComplete: boolean;
|
|
799
|
+
};
|
|
800
|
+
meshnodes: null;
|
|
801
|
+
initSceneGraph(sceneGraphName: any): {
|
|
802
|
+
isComplete: boolean;
|
|
803
|
+
};
|
|
804
|
+
sceneGraphFactory(impl: any): WASMTree | KDTree;
|
|
805
|
+
allMeshnodes(): Meshnode[];
|
|
806
|
+
rebuildSceneGraph(lessRelevantMeshnodes: any): void;
|
|
807
|
+
getNodeServices(): NodeServices | null;
|
|
808
|
+
getSceneGraph(): WASMTree | KDTree | null;
|
|
809
|
+
getMeshnodeFromIndex(index: any): Meshnode;
|
|
810
|
+
getParentNodeIds(nodeId: any): any[];
|
|
811
|
+
getSubtreeNodeIds(nodeId: any): any[];
|
|
812
|
+
getSubtreeMeshnodeIndex(nodeId: any): any[];
|
|
813
|
+
getNamedNode(nodeId: any): Node_2 | undefined;
|
|
814
|
+
getSubObjects(node: any, subArr: any): void;
|
|
815
|
+
getMeasureIds(): any[];
|
|
816
|
+
addMeasureIds(meshnodeIndices: any): void;
|
|
817
|
+
clearMeasureIds(): void;
|
|
818
|
+
refresh: boolean | undefined;
|
|
819
|
+
hasMeasureIds(arr: any): boolean;
|
|
820
|
+
removeMeasureIds(meshnodeIndices: any): void;
|
|
821
|
+
getMeshnodeFromNodeId(nodeId: any): Node_2 | Meshnode;
|
|
822
|
+
getMeshnode(offset: any): Meshnode;
|
|
823
|
+
getNode(offset: any): Node_2 | Meshnode;
|
|
824
|
+
numNodes(): number;
|
|
825
|
+
numMeshnodes(): number;
|
|
826
|
+
numMeshes(): number;
|
|
827
|
+
loadAllMeshGeometryToGPU(): {
|
|
828
|
+
isComplete: boolean;
|
|
829
|
+
};
|
|
830
|
+
loadAllPartitionProxies(): void;
|
|
831
|
+
prefetchPartitions(geometryFactory: any): {
|
|
832
|
+
isComplete: boolean;
|
|
833
|
+
};
|
|
834
|
+
currentIndex: number | undefined;
|
|
835
|
+
partitionProxies: PartitionProxy[] | undefined;
|
|
836
|
+
loadPartitionPromises: any[] | undefined;
|
|
837
|
+
getNodeById(id: any): Node_2;
|
|
838
|
+
hasNode(id: any): boolean;
|
|
839
|
+
globalOffset(): {
|
|
840
|
+
offsetX: number;
|
|
841
|
+
offsetY: number;
|
|
842
|
+
offsetZ: number;
|
|
843
|
+
};
|
|
844
|
+
root(): Node_2;
|
|
845
|
+
forEachMeshnode(callback: any): void;
|
|
846
|
+
forEachNode(callback: any): void;
|
|
847
|
+
getMeshVerticesAndFaces(meshRef: any, meshnodeOffset: any): MeshVerticesAndFaces;
|
|
848
|
+
findFirstObject(meshnodeIndex: any): Node_2;
|
|
849
|
+
captureModelStats(): void;
|
|
850
|
+
captureStandardModelStats(pwfModel: any): void;
|
|
851
|
+
capturePartitionedModelStats(pwfModel: any): void;
|
|
852
|
+
numFirstObjects(): number;
|
|
853
|
+
#private;
|
|
854
|
+
}
|
|
855
|
+
|
|
856
|
+
declare interface PWFMesh {
|
|
857
|
+
offset(): number;
|
|
858
|
+
color(): number;
|
|
859
|
+
vertices(): Float32Array;
|
|
860
|
+
faces(): Uint16Array;
|
|
861
|
+
opacity(): number;
|
|
862
|
+
drawType(): number;
|
|
863
|
+
}
|
|
864
|
+
|
|
865
|
+
declare interface PWFMeshnode {
|
|
866
|
+
index(): number;
|
|
867
|
+
offset(): number;
|
|
868
|
+
opaque(): number;
|
|
869
|
+
nodeType(): number;
|
|
870
|
+
nodeId(): number;
|
|
871
|
+
parentOffset(): number;
|
|
872
|
+
numChildren(): number;
|
|
873
|
+
childRefs(): Uint32Array;
|
|
874
|
+
bbox(): Float32Array;
|
|
875
|
+
box3(): THREE.Box3;
|
|
876
|
+
matrix(): Float32Array;
|
|
877
|
+
group(): number;
|
|
878
|
+
}
|
|
879
|
+
|
|
880
|
+
declare class PWFModelParser {
|
|
881
|
+
private nodeAB;
|
|
882
|
+
private nodeBufferReader;
|
|
883
|
+
private meshnodeAB;
|
|
884
|
+
private meshnodeBufferReader;
|
|
885
|
+
private meshAB;
|
|
886
|
+
private meshBufferReader?;
|
|
887
|
+
constructor(nodeAB: ArrayBuffer, meshnodeAB: ArrayBuffer, meshAB: ArrayBuffer);
|
|
888
|
+
getGlobalOffset(): {
|
|
889
|
+
offsetX: number;
|
|
890
|
+
offsetY: number;
|
|
891
|
+
offsetZ: number;
|
|
892
|
+
};
|
|
893
|
+
getMeshnodeOffPointer(): number;
|
|
894
|
+
parseNodes(): {
|
|
895
|
+
nodes: PWFNode[];
|
|
896
|
+
isComplete: boolean;
|
|
897
|
+
};
|
|
898
|
+
parseMeshnodes(): {
|
|
899
|
+
meshnodes: PWFMeshnode[];
|
|
900
|
+
isComplete: boolean;
|
|
901
|
+
};
|
|
902
|
+
getNumMeshnodes(): number;
|
|
903
|
+
getNumMeshes(): number;
|
|
904
|
+
parseMeshes(): PWFMesh[];
|
|
905
|
+
}
|
|
906
|
+
|
|
907
|
+
declare interface PWFNode {
|
|
908
|
+
offset(): number;
|
|
909
|
+
nodeId(): number;
|
|
910
|
+
parentOffset(): number;
|
|
911
|
+
numChildren(): number;
|
|
912
|
+
group(): number;
|
|
913
|
+
childOffs(): number;
|
|
914
|
+
childrenOffsets(): Uint32Array;
|
|
915
|
+
nodeType(): number;
|
|
916
|
+
opaque(): number;
|
|
917
|
+
toString(): string;
|
|
918
|
+
}
|
|
919
|
+
|
|
920
|
+
declare interface PWFPartition {
|
|
921
|
+
partitionId(): number;
|
|
922
|
+
meshData(): MeshData[];
|
|
923
|
+
}
|
|
924
|
+
|
|
925
|
+
declare interface PWFPartitionProxy {
|
|
926
|
+
partitionId(): number;
|
|
927
|
+
partitionUrl(): string;
|
|
928
|
+
meshnodeOffsets(): Uint32Array;
|
|
929
|
+
}
|
|
930
|
+
|
|
285
931
|
export declare type PwfV1Bundle = {
|
|
286
932
|
nodeUrl: GeometryFile['url'];
|
|
287
933
|
meshnodeUrl: GeometryFile['url'];
|
|
@@ -302,6 +948,18 @@ export declare const RENDER_MODE: {
|
|
|
302
948
|
|
|
303
949
|
export declare type RenderMode = (typeof RENDER_MODE)[keyof typeof RENDER_MODE];
|
|
304
950
|
|
|
951
|
+
export declare type Resource = FileExtractionModePwfV1OverrideResource | FileExtractionModePwfV2OverrideResource | FileExtractionModeResource | ModelRevisionModePwfV1Resource | ModelRevisionModePwfV2Resource;
|
|
952
|
+
|
|
953
|
+
export declare type ResourceDiscriminator = {
|
|
954
|
+
fileExtractionId: number;
|
|
955
|
+
} | {
|
|
956
|
+
modelRevisionId: number;
|
|
957
|
+
};
|
|
958
|
+
|
|
959
|
+
export declare type ResourceOptions = CommonOptions & {
|
|
960
|
+
resources: Resource[];
|
|
961
|
+
};
|
|
962
|
+
|
|
305
963
|
export declare type RGB = `rgb(${number}, ${number}, ${number})`;
|
|
306
964
|
|
|
307
965
|
export declare type RGBA = `rgba(${number}, ${number}, ${number}, ${number})`;
|
|
@@ -318,6 +976,51 @@ export declare type SectionDataAutodeskFormat = {
|
|
|
318
976
|
|
|
319
977
|
export declare type SectionDataProcoreFormat = ProcoreFormatClipPlane[];
|
|
320
978
|
|
|
979
|
+
declare class StreamedGeometryFactory extends GeometryFactory {
|
|
980
|
+
createMeshGeometry(vertexArray: Float32Array, indexArray: Uint16Array, color: number, opacity: number, drawType: number): StreamedMeshGeometry;
|
|
981
|
+
createMeshGeometryPrefetching(vertexArray: Float32Array, indexArray: Uint16Array, color: number, opacity: number, drawType: number): StreamedMeshGeometry;
|
|
982
|
+
createCylinderGeometry(vertexArray: Float32Array, indexArray: Uint16Array, color: number, opacity: number, drawType: number): StreamedMeshGeometry;
|
|
983
|
+
protected newVertexBufferStream(size: number): WebGLBuffer;
|
|
984
|
+
protected newIndexBufferStream(size: number): WebGLBuffer;
|
|
985
|
+
}
|
|
986
|
+
|
|
987
|
+
declare class StreamedMeshGeometry extends MeshGeometry {
|
|
988
|
+
color: number;
|
|
989
|
+
opacity: number;
|
|
990
|
+
drawType: number;
|
|
991
|
+
numFaces: number;
|
|
992
|
+
vertexArrayObject: WebGLVertexArrayObject | null;
|
|
993
|
+
verticesLength: number;
|
|
994
|
+
verticesGLBuffer: WebGLBuffer | null;
|
|
995
|
+
facesLength: number;
|
|
996
|
+
facesGLBuffer: WebGLBuffer | null;
|
|
997
|
+
lastFrameId: number;
|
|
998
|
+
constructor(color: number, opacity: number, drawType: number, vertexArrayObject: WebGLVertexArrayObject | null, numVertices: number, verticesBuffer: WebGLBuffer | null, numFaces: number, facesBuffer: WebGLBuffer | null, facesBytesLength: number, index: number);
|
|
999
|
+
}
|
|
1000
|
+
|
|
1001
|
+
declare class StreamedMeshnode extends Meshnode {
|
|
1002
|
+
private _partitionProxy?;
|
|
1003
|
+
private _meshGeometries;
|
|
1004
|
+
setPartitionProxy(partitionProxy: PartitionProxy): void;
|
|
1005
|
+
partitionProxy(): PartitionProxy;
|
|
1006
|
+
meshGeometries(): MeshGeometry[];
|
|
1007
|
+
setMeshGeometry(meshIndex: number, meshGeometry: StreamedMeshGeometry): void;
|
|
1008
|
+
getMeshGeometry(meshIndex: number): StreamedMeshGeometry | undefined;
|
|
1009
|
+
asObject(): MeshnodeObject;
|
|
1010
|
+
private getMeshVerticesAndFaces;
|
|
1011
|
+
}
|
|
1012
|
+
|
|
1013
|
+
declare class StreamedMeshnodeServices extends MeshnodeServices {
|
|
1014
|
+
protected createMeshnode(pwfMeshnode: PWFMeshnode): Meshnode;
|
|
1015
|
+
}
|
|
1016
|
+
|
|
1017
|
+
declare class StreamedMeshServices extends MeshServices {
|
|
1018
|
+
constructor(pwf: PWF);
|
|
1019
|
+
getMeshVerticesAndFaces(meshOffset: number, _meshnodeOffset: number): MeshVerticesAndFaces;
|
|
1020
|
+
loadPartitionContainingMeshnode(streamedMeshnode: StreamedMeshnode): Promise<void>;
|
|
1021
|
+
getMeshGeometryForOffsets(meshOffset: number, meshnodeOffset: number): StreamedMeshGeometry | undefined;
|
|
1022
|
+
}
|
|
1023
|
+
|
|
321
1024
|
export declare class TestRoutineRecorder {
|
|
322
1025
|
camera: Camera;
|
|
323
1026
|
points: Point[];
|
|
@@ -369,6 +1072,22 @@ export declare const TOOL_BAR_TOOLS: {
|
|
|
369
1072
|
|
|
370
1073
|
export declare type ToolBarTools = (typeof TOOL_BAR_TOOLS)[keyof typeof TOOL_BAR_TOOLS];
|
|
371
1074
|
|
|
1075
|
+
declare namespace V1 {
|
|
1076
|
+
export {
|
|
1077
|
+
MeshnodeServices_2 as MeshnodeServices,
|
|
1078
|
+
MeshServices_2 as MeshServices,
|
|
1079
|
+
NodeServices_2 as NodeServices
|
|
1080
|
+
}
|
|
1081
|
+
}
|
|
1082
|
+
|
|
1083
|
+
declare namespace V2 {
|
|
1084
|
+
export {
|
|
1085
|
+
MeshnodeServices_3 as MeshnodeServices,
|
|
1086
|
+
MeshServices_3 as MeshServices,
|
|
1087
|
+
NodeServices_3 as NodeServices
|
|
1088
|
+
}
|
|
1089
|
+
}
|
|
1090
|
+
|
|
372
1091
|
export declare type Vector2 = {
|
|
373
1092
|
x: number;
|
|
374
1093
|
y: number;
|
|
@@ -398,6 +1117,20 @@ export declare type Visibility = {
|
|
|
398
1117
|
};
|
|
399
1118
|
};
|
|
400
1119
|
|
|
1120
|
+
declare class WASMTree {
|
|
1121
|
+
static maxChunkSize: number;
|
|
1122
|
+
meshnodes: any[];
|
|
1123
|
+
currentIndex: number;
|
|
1124
|
+
cullTree(cameraPosition: any, projectviewMatrix: any, detailsParam: any): {
|
|
1125
|
+
opaques: any[];
|
|
1126
|
+
transparents: any[];
|
|
1127
|
+
};
|
|
1128
|
+
maxChunkSize: number;
|
|
1129
|
+
buildTree(meshnodes: any): {
|
|
1130
|
+
isComplete: boolean;
|
|
1131
|
+
};
|
|
1132
|
+
}
|
|
1133
|
+
|
|
401
1134
|
export declare type WebFormatExtractionItem = {
|
|
402
1135
|
item_type: 'WebFormat';
|
|
403
1136
|
artifact: {
|
|
@@ -611,14 +1344,24 @@ export declare class Webviewer {
|
|
|
611
1344
|
selectAllObjects: (objectTreeName?: string) => Promise<boolean>;
|
|
612
1345
|
getSelectedObjects: () => Promise<number[]>;
|
|
613
1346
|
setMeasurement: (enable: boolean) => void;
|
|
614
|
-
setObjectColor: (palettes:
|
|
615
|
-
|
|
616
|
-
|
|
1347
|
+
setObjectColor: (palettes: PaletteParams[], options?: {
|
|
1348
|
+
resource?: ResourceDiscriminator;
|
|
1349
|
+
}) => void;
|
|
1350
|
+
clearObjectColor: (objectIds: number[], options?: {
|
|
1351
|
+
resource?: ResourceDiscriminator;
|
|
1352
|
+
}) => Promise<void> | void;
|
|
1353
|
+
clearAllObjectColor: (options?: {
|
|
1354
|
+
resource?: ResourceDiscriminator;
|
|
1355
|
+
}) => Promise<void> | void;
|
|
617
1356
|
filterObjectTree: (objectIds: number[]) => Promise<void>;
|
|
618
1357
|
clearObjectTreeFilter: () => Promise<void>;
|
|
619
|
-
getViewpoint: (
|
|
1358
|
+
getViewpoint: (options?: {
|
|
1359
|
+
defaultVisibilityAlwaysTrue?: boolean;
|
|
1360
|
+
}) => Promise<Viewpoint>;
|
|
620
1361
|
setViewpoint: (viewpoint: Viewpoint) => Promise<void>;
|
|
621
|
-
getVisibility: (
|
|
1362
|
+
getVisibility: (options?: {
|
|
1363
|
+
defaultVisibilityAlwaysTrue?: boolean;
|
|
1364
|
+
}) => Promise<Visibility>;
|
|
622
1365
|
setVisibility: (visibility: Visibility) => Promise<void>;
|
|
623
1366
|
};
|
|
624
1367
|
api: {
|