@cognite/reveal 2.2.2 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cognite/reveal",
-	"version": "2.2.2",
+	"version": "2.3.0",
 	"description": "WebGL based 3D viewer for CAD and point clouds processed in Cognite Data Fusion.",
 	"homepage": "https://github.com/cognitedata/reveal/tree/master/viewer",
 	"repository": {
@@ -20,7 +20,7 @@
 	"types": "index.d.ts",
 	"dependencies": {
 		"@cognite/potree-core": "^1.5.1",
-		"@cognite/reveal-parser-worker": "1.2.0",
+		"@cognite/reveal-parser-worker": "1.3.0",
 		"@gltf-transform/core": "^0.12.11",
 		"@gltf-transform/extensions": "^0.12.11",
 		"@tweenjs/tween.js": "^18.6.4",

package/packages/cad-geometry-loaders/index.d.ts

@@ -1,14 +1,14 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export { SimpleAndDetailedToSector3D } from './src/sector/SimpleAndDetailedToSector3D';
-export { CadModelSectorBudget } from './src/CadModelSectorBudget';
-export { CachedRepository } from './src/sector/CachedRepository';
-export { CadLoadingHints } from './src/CadLoadingHints';
-export { CadModelUpdateHandler } from './src/CadModelUpdateHandler';
-export { LoadingState } from './src/utilities/types';
-export { SectorCuller } from './src/sector/culling/SectorCuller';
-export { createDefaultSectorCuller, ByVisibilityGpuSectorCuller } from './src/sector/culling/ByVisibilityGpuSectorCuller';
-export { GpuOrderSectorsByVisibilityCoverage } from './src/sector/culling/OrderSectorsByVisibilityCoverage';
-export { OccludingGeometryProvider } from './src/sector/culling/OccludingGeometryProvider';
-export { DetermineSectorsInput } from './src/sector/culling/types';
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export { SimpleAndDetailedToSector3D } from './src/sector/SimpleAndDetailedToSector3D';
+export { CadModelSectorBudget } from './src/CadModelSectorBudget';
+export { CachedRepository } from './src/sector/CachedRepository';
+export { CadLoadingHints } from './src/CadLoadingHints';
+export { CadModelUpdateHandler } from './src/CadModelUpdateHandler';
+export { LoadingState } from './src/utilities/types';
+export { SectorCuller } from './src/sector/culling/SectorCuller';
+export { createDefaultSectorCuller, ByVisibilityGpuSectorCuller } from './src/sector/culling/ByVisibilityGpuSectorCuller';
+export { GpuOrderSectorsByVisibilityCoverage } from './src/sector/culling/OrderSectorsByVisibilityCoverage';
+export { OccludingGeometryProvider } from './src/sector/culling/OccludingGeometryProvider';
+export { DetermineSectorsInput } from './src/sector/culling/types';

package/packages/cad-geometry-loaders/src/CadLoadingHints.d.ts

@@ -1,11 +1,11 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-/**
- * Hints that are used to modify how CAD sectors are loaded.
- * @property `suspendLoading` - disables loading of sectors.
- */
-export declare type CadLoadingHints = {
-    suspendLoading?: boolean;
-};
-export declare const defaultLoadingHints: Required<CadLoadingHints>;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * Hints that are used to modify how CAD sectors are loaded.
+ * @property `suspendLoading` - disables loading of sectors.
+ */
+export declare type CadLoadingHints = {
+    suspendLoading?: boolean;
+};
+export declare const defaultLoadingHints: Required<CadLoadingHints>;

package/packages/cad-geometry-loaders/src/CadModelSectorBudget.d.ts

@@ -1,26 +1,26 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-/**
- * Represents a measurement of how much geometry can be loaded.
- */
-export declare type CadModelSectorBudget = {
-    /**
-     * Sectors within this distance from the camera will always be loaded in high details.
-     */
-    readonly highDetailProximityThreshold: number;
-    /**
-     * Number of bytes of the geometry that must be downloaded.
-     */
-    readonly geometryDownloadSizeBytes: number;
-    /**
-     * Maximum number of estimated draw calls of geometry to load.
-     */
-    readonly maximumNumberOfDrawCalls: number;
-    /**
-     * Maximum render cost. This number can be thought of as triangle count, although the number
-     * doesn't match this directly.
-     */
-    readonly maximumRenderCost: number;
-};
-export declare const defaultCadModelSectorBudget: CadModelSectorBudget;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * Represents a measurement of how much geometry can be loaded.
+ */
+export declare type CadModelSectorBudget = {
+    /**
+     * Sectors within this distance from the camera will always be loaded in high details.
+     */
+    readonly highDetailProximityThreshold: number;
+    /**
+     * Number of bytes of the geometry that must be downloaded.
+     */
+    readonly geometryDownloadSizeBytes: number;
+    /**
+     * Maximum number of estimated draw calls of geometry to load.
+     */
+    readonly maximumNumberOfDrawCalls: number;
+    /**
+     * Maximum render cost. This number can be thought of as triangle count, although the number
+     * doesn't match this directly.
+     */
+    readonly maximumRenderCost: number;
+};
+export declare const defaultCadModelSectorBudget: CadModelSectorBudget;

package/packages/cad-geometry-loaders/src/CadModelUpdateHandler.d.ts

@@ -1,44 +1,44 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { ConsumedSector } from '../../cad-parsers';
-import { CadNode } from '../../rendering';
-import { Observable } from 'rxjs';
-import { SectorCuller } from './sector/culling/SectorCuller';
-import { CadLoadingHints } from './CadLoadingHints';
-import { Repository } from './sector/Repository';
-import { LoadingState } from './utilities/types';
-import { CadModelSectorBudget } from './CadModelSectorBudget';
-import { SectorLoadingSpent } from './sector/culling/types';
-export declare class CadModelUpdateHandler {
-    private readonly _sectorRepository;
-    private readonly _sectorCuller;
-    private readonly _modelStateHandler;
-    private _budget;
-    private _lastSpent;
-    private readonly _cameraSubject;
-    private readonly _clippingPlaneSubject;
-    private readonly _loadingHintsSubject;
-    private readonly _modelSubject;
-    private readonly _budgetSubject;
-    private readonly _progressSubject;
-    private readonly _updateObservable;
-    constructor(sectorRepository: Repository, sectorCuller: SectorCuller);
-    dispose(): void;
-    updateCamera(camera: THREE.PerspectiveCamera): void;
-    set clippingPlanes(value: THREE.Plane[]);
-    get budget(): CadModelSectorBudget;
-    set budget(b: CadModelSectorBudget);
-    get lastBudgetSpendage(): SectorLoadingSpent;
-    addModel(model: CadNode): void;
-    removeModel(model: CadNode): void;
-    updateLoadingHints(cadLoadingHints: CadLoadingHints): void;
-    consumedSectorObservable(): Observable<ConsumedSector>;
-    getLoadingStateObserver(): Observable<LoadingState>;
-    /**
-     * When loading hints of a CAD model changes, propagate the event down to the stream and either add or remove
-     * the {@link CadModelMetadata} from the array and push the new array down stream
-     */
-    private loadingModelObservable;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { ConsumedSector } from '../../cad-parsers';
+import { CadNode } from '../../rendering';
+import { Observable } from 'rxjs';
+import { SectorCuller } from './sector/culling/SectorCuller';
+import { CadLoadingHints } from './CadLoadingHints';
+import { Repository } from './sector/Repository';
+import { LoadingState } from './utilities/types';
+import { CadModelSectorBudget } from './CadModelSectorBudget';
+import { SectorLoadingSpent } from './sector/culling/types';
+export declare class CadModelUpdateHandler {
+    private readonly _sectorRepository;
+    private readonly _sectorCuller;
+    private readonly _modelStateHandler;
+    private _budget;
+    private _lastSpent;
+    private readonly _cameraSubject;
+    private readonly _clippingPlaneSubject;
+    private readonly _loadingHintsSubject;
+    private readonly _modelSubject;
+    private readonly _budgetSubject;
+    private readonly _progressSubject;
+    private readonly _updateObservable;
+    constructor(sectorRepository: Repository, sectorCuller: SectorCuller);
+    dispose(): void;
+    updateCamera(camera: THREE.PerspectiveCamera): void;
+    set clippingPlanes(value: THREE.Plane[]);
+    get budget(): CadModelSectorBudget;
+    set budget(b: CadModelSectorBudget);
+    get lastBudgetSpendage(): SectorLoadingSpent;
+    addModel(model: CadNode): void;
+    removeModel(model: CadNode): void;
+    updateLoadingHints(cadLoadingHints: CadLoadingHints): void;
+    consumedSectorObservable(): Observable<ConsumedSector>;
+    getLoadingStateObserver(): Observable<LoadingState>;
+    /**
+     * When loading hints of a CAD model changes, propagate the event down to the stream and either add or remove
+     * the {@link CadModelMetadata} from the array and push the new array down stream
+     */
+    private loadingModelObservable;
+}

package/packages/cad-geometry-loaders/src/sector/CachedRepository.d.ts

@@ -1,25 +1,25 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { SimpleAndDetailedToSector3D } from './SimpleAndDetailedToSector3D';
-import { Repository } from './Repository';
-import { CadSectorParser, WantedSector, ConsumedSector } from '../../../cad-parsers';
-import { BinaryFileProvider } from '../../../modeldata-api';
-export declare class CachedRepository implements Repository {
-    private readonly _consumedSectorCache;
-    private readonly _ctmFileCache;
-    private readonly _modelSectorProvider;
-    private readonly _modelDataParser;
-    private readonly _modelDataTransformer;
-    constructor(modelSectorProvider: BinaryFileProvider, modelDataParser: CadSectorParser, modelDataTransformer: SimpleAndDetailedToSector3D);
-    clear(): void;
-    loadSector(sector: WantedSector): Promise<ConsumedSector>;
-    private loadSimpleSectorFromNetwork;
-    private loadI3DFromNetwork;
-    private loadCtmsFromNetwork;
-    private loadDetailedSectorFromNetwork;
-    private loadCtmFileFromNetwork;
-    private finalizeDetailed;
-    private wantedSectorCacheKey;
-    private ctmFileCacheKey;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { SimpleAndDetailedToSector3D } from './SimpleAndDetailedToSector3D';
+import { Repository } from './Repository';
+import { CadSectorParser, WantedSector, ConsumedSector } from '../../../cad-parsers';
+import { BinaryFileProvider } from '../../../modeldata-api';
+export declare class CachedRepository implements Repository {
+    private readonly _consumedSectorCache;
+    private readonly _ctmFileCache;
+    private readonly _modelSectorProvider;
+    private readonly _modelDataParser;
+    private readonly _modelDataTransformer;
+    constructor(modelSectorProvider: BinaryFileProvider, modelDataParser: CadSectorParser, modelDataTransformer: SimpleAndDetailedToSector3D);
+    clear(): void;
+    loadSector(sector: WantedSector): Promise<ConsumedSector>;
+    private loadSimpleSectorFromNetwork;
+    private loadI3DFromNetwork;
+    private loadCtmsFromNetwork;
+    private loadDetailedSectorFromNetwork;
+    private loadCtmFileFromNetwork;
+    private finalizeDetailed;
+    private wantedSectorCacheKey;
+    private ctmFileCacheKey;
+}

package/packages/cad-geometry-loaders/src/sector/ModelStateHandler.d.ts

@@ -1,12 +1,12 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { WantedSector, ConsumedSector } from '../../../cad-parsers';
-export declare class ModelStateHandler {
-    private readonly _sceneModelState;
-    constructor();
-    hasStateChanged(wantedSector: WantedSector): boolean;
-    addModel(modelIdentifier: string): void;
-    removeModel(modelIdentifier: string): void;
-    updateState(consumedSector: ConsumedSector): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { WantedSector, ConsumedSector } from '../../../cad-parsers';
+export declare class ModelStateHandler {
+    private readonly _sceneModelState;
+    constructor();
+    hasStateChanged(wantedSector: WantedSector): boolean;
+    addModel(modelIdentifier: string): void;
+    removeModel(modelIdentifier: string): void;
+    updateState(consumedSector: ConsumedSector): void;
+}

package/packages/cad-geometry-loaders/src/sector/Repository.d.ts

@@ -1,9 +1,9 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { ConsumedSector, WantedSector } from '../../../cad-parsers';
-export declare type SectorId = number;
-export interface Repository {
-    loadSector(sector: WantedSector): Promise<ConsumedSector>;
-    clear(): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { ConsumedSector, WantedSector } from '../../../cad-parsers';
+export declare type SectorId = number;
+export interface Repository {
+    loadSector(sector: WantedSector): Promise<ConsumedSector>;
+    clear(): void;
+}

package/packages/cad-geometry-loaders/src/sector/SectorLoader.d.ts

@@ -1,28 +1,28 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { ConsumedSector } from '../../../cad-parsers';
-import { DetermineSectorsInput, SectorLoadingSpent } from './culling/types';
-import { SectorCuller } from './culling/SectorCuller';
-import { ModelStateHandler } from './ModelStateHandler';
-import { Repository } from './Repository';
-/**
- * Loads sector based on a given camera pose, a set of models and budget.
- * Uses {@link SectorCuller} to determine what to load, {@link Repository} to
- * load sectors and {@link ModelStateHandler} to keep track of what has been
- * loaded to avoid loading data that's already available.
- *
- * The caller is responsible for making the result from the load operation visible
- * on screen.
- */
-export declare class SectorLoader {
-    private readonly _modelStateHandler;
-    private readonly _sectorCuller;
-    private readonly _sectorRepository;
-    private readonly _progressCallback;
-    private readonly _collectStatisticsCallback;
-    constructor(sectorRepository: Repository, sectorCuller: SectorCuller, modelStateHandler: ModelStateHandler, collectStatisticsCallback: (spent: SectorLoadingSpent) => void, progressCallback: (sectorsLoaded: number, sectorsScheduled: number, sectorsCulled: number) => void);
-    loadSectors(input: DetermineSectorsInput): AsyncIterable<ConsumedSector>;
-    private filterSectors;
-    private startLoadingBatch;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { ConsumedSector } from '../../../cad-parsers';
+import { DetermineSectorsInput, SectorLoadingSpent } from './culling/types';
+import { SectorCuller } from './culling/SectorCuller';
+import { ModelStateHandler } from './ModelStateHandler';
+import { Repository } from './Repository';
+/**
+ * Loads sector based on a given camera pose, a set of models and budget.
+ * Uses {@link SectorCuller} to determine what to load, {@link Repository} to
+ * load sectors and {@link ModelStateHandler} to keep track of what has been
+ * loaded to avoid loading data that's already available.
+ *
+ * The caller is responsible for making the result from the load operation visible
+ * on screen.
+ */
+export declare class SectorLoader {
+    private readonly _modelStateHandler;
+    private readonly _sectorCuller;
+    private readonly _sectorRepository;
+    private readonly _progressCallback;
+    private readonly _collectStatisticsCallback;
+    constructor(sectorRepository: Repository, sectorCuller: SectorCuller, modelStateHandler: ModelStateHandler, collectStatisticsCallback: (spent: SectorLoadingSpent) => void, progressCallback: (sectorsLoaded: number, sectorsScheduled: number, sectorsCulled: number) => void);
+    loadSectors(input: DetermineSectorsInput): AsyncIterable<ConsumedSector>;
+    private filterSectors;
+    private startLoadingBatch;
+}

package/packages/cad-geometry-loaders/src/sector/SimpleAndDetailedToSector3D.d.ts

@@ -1,20 +1,20 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { SectorQuads } from '@cognite/reveal-parser-worker';
-import { SectorMetadata, InstancedMeshFile, SectorGeometry } from '../../../cad-parsers';
-import { AutoDisposeGroup } from '../../../utilities';
-import { CadMaterialManager } from '../../../rendering';
-export declare class SimpleAndDetailedToSector3D {
-    private readonly materialManager;
-    constructor(materialManager: CadMaterialManager);
-    transformSimpleSector(modelIdentifier: string, sector: SectorMetadata, geometry: SectorQuads, geometryClipBox: THREE.Box3 | null): Promise<{
-        sectorMeshes: AutoDisposeGroup;
-        instancedMeshes: InstancedMeshFile[];
-    }>;
-    transformDetailedSector(modelIdentifier: string, sector: SectorMetadata, geometry: SectorGeometry, geometryClipBox: THREE.Box3 | null): Promise<{
-        sectorMeshes: AutoDisposeGroup;
-        instancedMeshes: InstancedMeshFile[];
-    }>;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { SectorQuads } from '@cognite/reveal-parser-worker';
+import { SectorMetadata, InstancedMeshFile, SectorGeometry } from '../../../cad-parsers';
+import { AutoDisposeGroup } from '../../../utilities';
+import { CadMaterialManager } from '../../../rendering';
+export declare class SimpleAndDetailedToSector3D {
+    private readonly materialManager;
+    constructor(materialManager: CadMaterialManager);
+    transformSimpleSector(modelIdentifier: string, sector: SectorMetadata, geometry: SectorQuads, geometryClipBox: THREE.Box3 | null): Promise<{
+        sectorMeshes: AutoDisposeGroup;
+        instancedMeshes: InstancedMeshFile[];
+    }>;
+    transformDetailedSector(modelIdentifier: string, sector: SectorMetadata, geometry: SectorGeometry, geometryClipBox: THREE.Box3 | null): Promise<{
+        sectorMeshes: AutoDisposeGroup;
+        instancedMeshes: InstancedMeshFile[];
+    }>;
+}

package/packages/cad-geometry-loaders/src/sector/culling/ByVisibilityGpuSectorCuller.d.ts

@@ -1,53 +1,53 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { WantedSector } from '../../../../cad-parsers';
-import { OrderSectorsByVisibilityCoverage } from './OrderSectorsByVisibilityCoverage';
-import { SectorCuller } from './SectorCuller';
-import { DetermineSectorCostDelegate, DetermineSectorsInput, SectorLoadingSpent } from './types';
-import { OccludingGeometryProvider } from './OccludingGeometryProvider';
-/**
- * Options for creating GpuBasedSectorCuller.
- */
-export declare type ByVisibilityGpuSectorCullerOptions = {
-    /**
-     * Renderer used to determine what sector to load.
-     */
-    renderer: THREE.WebGLRenderer;
-    /**
-     * Optional callback for determining the cost of a sector. The default unit of the cost
-     * function is bytes downloaded.
-     */
-    determineSectorCost?: DetermineSectorCostDelegate;
-    /**
-     * Use a custom coverage utility to determine how "visible" each sector is.
-     */
-    coverageUtil: OrderSectorsByVisibilityCoverage;
-    /**
-     * Logging function for debugging.
-     */
-    logCallback?: (message?: any, ...optionalParameters: any[]) => void;
-};
-/**
- * SectorCuller that uses the GPU to determine an approximation
- * of how "visible" each sector is to get a priority for each sector
- * and loads sectors based on priority within a budget.
- */
-export declare class ByVisibilityGpuSectorCuller implements SectorCuller {
-    private readonly options;
-    private readonly takenSectors;
-    constructor(options: ByVisibilityGpuSectorCullerOptions);
-    dispose(): void;
-    determineSectors(input: DetermineSectorsInput): {
-        wantedSectors: WantedSector[];
-        spentBudget: SectorLoadingSpent;
-    };
-    filterSectorsToLoad(input: DetermineSectorsInput, wantedSectors: WantedSector[]): Promise<WantedSector[]>;
-    private update;
-    private addHighDetailsForNearSectors;
-    private testForClippingOcclusion;
-    private markSectorsAsDetailed;
-    private log;
-}
-export declare function createDefaultSectorCuller(renderer: THREE.WebGLRenderer, occludingGeometryProvider: OccludingGeometryProvider): SectorCuller;
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { WantedSector } from '../../../../cad-parsers';
+import { OrderSectorsByVisibilityCoverage } from './OrderSectorsByVisibilityCoverage';
+import { SectorCuller } from './SectorCuller';
+import { DetermineSectorCostDelegate, DetermineSectorsInput, SectorLoadingSpent } from './types';
+import { OccludingGeometryProvider } from './OccludingGeometryProvider';
+/**
+ * Options for creating GpuBasedSectorCuller.
+ */
+export declare type ByVisibilityGpuSectorCullerOptions = {
+    /**
+     * Renderer used to determine what sector to load.
+     */
+    renderer: THREE.WebGLRenderer;
+    /**
+     * Optional callback for determining the cost of a sector. The default unit of the cost
+     * function is bytes downloaded.
+     */
+    determineSectorCost?: DetermineSectorCostDelegate;
+    /**
+     * Use a custom coverage utility to determine how "visible" each sector is.
+     */
+    coverageUtil: OrderSectorsByVisibilityCoverage;
+    /**
+     * Logging function for debugging.
+     */
+    logCallback?: (message?: any, ...optionalParameters: any[]) => void;
+};
+/**
+ * SectorCuller that uses the GPU to determine an approximation
+ * of how "visible" each sector is to get a priority for each sector
+ * and loads sectors based on priority within a budget.
+ */
+export declare class ByVisibilityGpuSectorCuller implements SectorCuller {
+    private readonly options;
+    private readonly takenSectors;
+    constructor(options: ByVisibilityGpuSectorCullerOptions);
+    dispose(): void;
+    determineSectors(input: DetermineSectorsInput): {
+        wantedSectors: WantedSector[];
+        spentBudget: SectorLoadingSpent;
+    };
+    filterSectorsToLoad(input: DetermineSectorsInput, wantedSectors: WantedSector[]): Promise<WantedSector[]>;
+    private update;
+    private addHighDetailsForNearSectors;
+    private testForClippingOcclusion;
+    private markSectorsAsDetailed;
+    private log;
+}
+export declare function createDefaultSectorCuller(renderer: THREE.WebGLRenderer, occludingGeometryProvider: OccludingGeometryProvider): SectorCuller;

package/packages/cad-geometry-loaders/src/sector/culling/OccludingGeometryProvider.d.ts

@@ -1,6 +1,6 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export interface OccludingGeometryProvider {
-    renderOccludingGeometry(target: THREE.WebGLRenderTarget | null, camera: THREE.PerspectiveCamera): void;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export interface OccludingGeometryProvider {
+    renderOccludingGeometry(target: THREE.WebGLRenderTarget | null, camera: THREE.PerspectiveCamera): void;
+}