@cognite/reveal 2.2.2 → 3.0.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cognite/reveal",
-	"version": "2.2.2",
+	"version": "3.0.0-beta.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": {
@@ -19,23 +19,22 @@
 	"main": "index.js",
 	"types": "index.d.ts",
 	"dependencies": {
-		"@cognite/potree-core": "^1.5.1",
-		"@cognite/reveal-parser-worker": "1.2.0",
-		"@gltf-transform/core": "^0.12.11",
-		"@gltf-transform/extensions": "^0.12.11",
-		"@tweenjs/tween.js": "^18.6.4",
-		"@types/three": "0.133.0",
-		"assert": "^2.0.0",
-		"comlink": "^4.3.1",
-		"geo-three": "^0.0.15",
-		"glslify": "^7.1.1",
-		"glslify-import": "^3.1.0",
-		"lodash": "^4.17.20",
-		"loglevel": "^1.7.1",
-		"mixpanel-browser": "^2.39.0",
-		"rxjs": "^7.1.0",
-		"skmeans": "^0.11.3",
-		"three": "0.133.0"
+		"@cognite/potree-core": "1.5.1",
+		"@cognite/reveal-parser-worker": "1.3.0",
+		"@tweenjs/tween.js": "18.6.4",
+		"@types/draco3dgltf": "1.4.0",
+		"@types/three": "0.137.0",
+		"assert": "2.0.0",
+		"comlink": "4.3.1",
+		"geo-three": "0.0.15",
+		"glslify": "7.1.1",
+		"glslify-import": "3.1.0",
+		"lodash": "4.17.21",
+		"loglevel": "1.7.1",
+		"mixpanel-browser": "2.41.0",
+		"rxjs": "7.3.0",
+		"skmeans": "0.11.3",
+		"three": "0.137.0"
 	},
 	"peerDependencies": {
 		"@cognite/sdk": "^5.0.0",

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

@@ -1,14 +1,13 @@
-/*!
- * 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 { CadModelBudget, defaultCadModelBudget } from './src/CadModelBudget';
+export { CadLoadingHints } from './src/CadLoadingHints';
+export { CadModelUpdateHandler } from './src/CadModelUpdateHandler';
+export { LoadingState } from './src/utilities/types';
+export { SectorCuller } from './src/sector/culling/SectorCuller';
+export { ByVisibilityGpuSectorCuller } from './src/sector/culling/ByVisibilityGpuSectorCuller';
+export { ByScreenSizeSectorCuller } from './src/sector/culling/ByScreenSizeSectorCuller';
+export { createV8SectorCuller } from './src/sector/culling/createV8SectorCuller';
+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 → CadModelBudget.d.ts}

@@ -1,26 +1,21 @@
-/*!
- * 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 CadModelBudget = {
+    /**
+     * Sectors within this distance from the camera will always be loaded in high details.
+     * @deprecated This is only used for 3D models processed prior to the Reveal 3.0 release (Q1 2022).
+     */
+    readonly highDetailProximityThreshold: 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 defaultDesktopCadModelBudget: CadModelBudget;
+export declare const defaultMobileCadModelBudget: CadModelBudget;
+export declare const defaultCadModelBudget: CadModelBudget;

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 { LoadingState } from './utilities/types';
+import { CadModelBudget } from './CadModelBudget';
+import { SectorLoadingSpent } from './sector/culling/types';
+export declare class CadModelUpdateHandler {
+    private readonly _sectorCuller;
+    private readonly _modelStateHandler;
+    private _budget;
+    private _lastSpent;
+    private readonly _cameraSubject;
+    private readonly _clippingPlaneSubject;
+    private readonly _loadingHintsSubject;
+    private readonly _prioritizedLoadingHintsSubject;
+    private readonly _modelSubject;
+    private readonly _budgetSubject;
+    private readonly _progressSubject;
+    private readonly _updateObservable;
+    constructor(sectorCuller: SectorCuller, continuousModelStreaming?: boolean);
+    dispose(): void;
+    updateCamera(camera: THREE.PerspectiveCamera): void;
+    set clippingPlanes(value: THREE.Plane[]);
+    get budget(): CadModelBudget;
+    set budget(b: CadModelBudget);
+    get lastBudgetSpendage(): SectorLoadingSpent;
+    addModel(model: CadNode): void;
+    removeModel(model: CadNode): void;
+    updateLoadingHints(cadLoadingHints: CadLoadingHints): void;
+    private updatePrioritizedAreas;
+    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/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 { LevelOfDetail } from '../../../cad-parsers';
+export declare class ModelStateHandler {
+    private readonly _sceneModelState;
+    constructor();
+    hasStateChanged(modelIdentifier: string, sectorId: number, levelOfDetail: LevelOfDetail): boolean;
+    addModel(modelIdentifier: string): void;
+    removeModel(modelIdentifier: string): void;
+    updateState(modelIdentifier: string, sectorId: number, levelOfDetail: LevelOfDetail): void;
+}

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

@@ -0,0 +1,22 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { ConsumedSector, WantedSector } from '../../../cad-parsers';
+export declare type SectorDownloadData = {
+    sector: WantedSector;
+    downloadSector: (sector: WantedSector) => Promise<ConsumedSector>;
+};
+export declare class SectorDownloadScheduler {
+    private readonly _maxConcurrentSectorDownloads;
+    private readonly _pendingSectorDownloads;
+    private readonly _queuedSectorDownloads;
+    private readonly _sectorDownloadQueue;
+    get numberOfPendingDownloads(): number;
+    get numberOfQueuedDownloads(): number;
+    constructor(maxConcurrentSectorDownloads?: number);
+    queueSectorBatchForDownload(downloadData: SectorDownloadData[]): Promise<ConsumedSector>[];
+    private getOrAddToQueuedDownloads;
+    private addSectorToPendingDownloads;
+    private processNextQueuedSectorDownload;
+    private getSectorIdentifier;
+}

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

@@ -1,28 +1,31 @@
-/*!
- * 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 { DetermineSectorsPayload, SectorLoadingSpent } from './culling/types';
+import { SectorCuller } from './culling/SectorCuller';
+import { ModelStateHandler } from './ModelStateHandler';
+/**
+ * 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 _v8SectorCuller;
+    private readonly _progressCallback;
+    private readonly _collectStatisticsCallback;
+    private readonly _gltfSectorCuller;
+    private readonly _continuousModelStreaming;
+    private readonly _sectorDownloadScheduler;
+    private _batchId;
+    constructor(sectorCuller: SectorCuller, modelStateHandler: ModelStateHandler, collectStatisticsCallback: (spent: SectorLoadingSpent) => void, progressCallback: (sectorsLoaded: number, sectorsScheduled: number, sectorsCulled: number) => void, continuousModelStreaming: boolean);
+    loadSectors(input: DetermineSectorsPayload): AsyncIterable<ConsumedSector>;
+    private getSectorCuller;
+    private filterSectors;
+    private startLoadingBatch;
+}

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

@@ -0,0 +1,23 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { DetermineSectorCostDelegate, DetermineSectorsInput, SectorLoadingSpent } from './types';
+import { SectorCuller } from './SectorCuller';
+import { V9SectorMetadata, WantedSector } from '../../../../cad-parsers';
+export declare type ByScreenSizeSectorCullerOptions = {
+    /**
+     * Optional callback for determining the cost of a sector. The default unit of the cost
+     * function is bytes downloaded.
+     */
+    determineSectorCost?: DetermineSectorCostDelegate<V9SectorMetadata>;
+};
+export declare class ByScreenSizeSectorCuller implements SectorCuller {
+    private readonly _determineSectorCost;
+    constructor(options?: ByScreenSizeSectorCullerOptions);
+    determineSectors(input: DetermineSectorsInput): {
+        wantedSectors: WantedSector[];
+        spentBudget: SectorLoadingSpent;
+    };
+    filterSectorsToLoad(_input: DetermineSectorsInput, wantedSectorsBatch: WantedSector[]): Promise<WantedSector[]>;
+    dispose(): void;
+}

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

@@ -1,53 +1,51 @@
-/*!
- * 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 { OrderSectorsByVisibilityCoverage } from './OrderSectorsByVisibilityCoverage';
+import { SectorCuller } from './SectorCuller';
+import { DetermineSectorCostDelegate, DetermineSectorsInput, SectorLoadingSpent } from './types';
+import { WantedSector, V8SectorMetadata } from '../../../../cad-parsers';
+/**
+ * Options for creating {@link ByVisibilityGpuSectorCuller}.
+ */
+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<V8SectorMetadata>;
+    /**
+     * 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;
+}

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;
+}