@cognite/reveal 2.1.2 → 3.0.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cognite/reveal",
-	"version": "2.1.2",
+	"version": "3.0.0-alpha.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,14 +19,12 @@
 	"main": "index.js",
 	"types": "index.d.ts",
 	"dependencies": {
-		"@cognite/potree-core": "1.5.0",
-		"@cognite/reveal-parser-worker": "1.2.0",
-		"@gltf-transform/core": "^0.12.11",
-		"@gltf-transform/extensions": "^0.12.11",
+		"@cognite/potree-core": "^1.5.1",
+		"@cognite/reveal-parser-worker": "1.3.0",
 		"@tweenjs/tween.js": "^18.6.4",
-		"@types/three": "0.133.0",
+		"@types/three": "0.135.0",
 		"assert": "^2.0.0",
-		"comlink": "4.3.1",
+		"comlink": "^4.3.1",
 		"geo-three": "^0.0.15",
 		"glslify": "^7.1.1",
 		"glslify-import": "^3.1.0",
@@ -35,7 +33,7 @@
 		"mixpanel-browser": "^2.39.0",
 		"rxjs": "^7.1.0",
 		"skmeans": "^0.11.3",
-		"three": "0.133.0"
+		"three": "0.135.0"
 	},
 	"peerDependencies": {
 		"@cognite/sdk": "^5.0.0",

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

@@ -1,20 +1,13 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-export { CadNode, SuggestedCameraConfig } from './src/CadNode';
-export { SimpleAndDetailedToSector3D } from './src/sector/SimpleAndDetailedToSector3D';
-export { NodeTransformProvider } from './src/material-manager/styling/NodeTransformProvider';
-export { CadModelSectorBudget } from './src/CadModelSectorBudget';
-export { SectorNode } from './src/sector/SectorNode';
-export { CachedRepository } from './src/sector/CachedRepository';
-export { defaultRenderOptions, SsaoParameters, SsaoSampleQuality, AntiAliasingMode, SectorQuads, RenderOptions } from './src/material-manager/rendering/types';
+export { CadModelBudget } from './src/CadModelBudget';
 export { CadLoadingHints } from './src/CadLoadingHints';
-export { EffectRenderManager } from './src/material-manager/rendering/EffectRenderManager';
-export { CadMaterialManager } from './src/material-manager/CadMaterialManager';
 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 { 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/{CadModelSectorBudget.d.ts → CadModelBudget.d.ts}

@@ -4,23 +4,16 @@
 /**
  * Represents a measurement of how much geometry can be loaded.
  */
-export declare type CadModelSectorBudget = {
+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;
-    /**
-     * 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;
+export declare const defaultCadModelBudget: CadModelBudget;

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

@@ -3,16 +3,14 @@
  */
 import * as THREE from 'three';
 import { ConsumedSector } from '../../cad-parsers';
+import { CadNode } from '../../rendering';
 import { Observable } from 'rxjs';
-import { CadNode } from './CadNode';
 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 { CadModelBudget } from './CadModelBudget';
 import { SectorLoadingSpent } from './sector/culling/types';
 export declare class CadModelUpdateHandler {
-    private readonly _sectorRepository;
     private readonly _sectorCuller;
     private readonly _modelStateHandler;
     private _budget;
@@ -24,12 +22,12 @@ export declare class CadModelUpdateHandler {
     private readonly _budgetSubject;
     private readonly _progressSubject;
     private readonly _updateObservable;
-    constructor(sectorRepository: Repository, sectorCuller: SectorCuller);
+    constructor(sectorCuller: SectorCuller, continuousModelStreaming?: boolean);
     dispose(): void;
     updateCamera(camera: THREE.PerspectiveCamera): void;
     set clippingPlanes(value: THREE.Plane[]);
-    get budget(): CadModelSectorBudget;
-    set budget(b: CadModelSectorBudget);
+    get budget(): CadModelBudget;
+    set budget(b: CadModelBudget);
     get lastBudgetSpendage(): SectorLoadingSpent;
     addModel(model: CadNode): void;
     removeModel(model: CadNode): void;

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

@@ -2,10 +2,9 @@
  * Copyright 2021 Cognite AS
  */
 import { ConsumedSector } from '../../../cad-parsers';
-import { DetermineSectorsInput, SectorLoadingSpent } from './culling/types';
+import { DetermineSectorsPayload, 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
@@ -17,12 +16,14 @@ import { Repository } from './Repository';
  */
 export declare class SectorLoader {
     private readonly _modelStateHandler;
-    private readonly _sectorCuller;
-    private readonly _sectorRepository;
+    private readonly _v8SectorCuller;
     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 readonly _gltfSectorCuller;
+    private readonly _continuousModelStreaming;
+    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

@@ -2,13 +2,12 @@
  * 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';
+import { WantedSector, V8SectorMetadata } from '../../../../cad-parsers';
 /**
- * Options for creating GpuBasedSectorCuller.
+ * Options for creating {@link ByVisibilityGpuSectorCuller}.
  */
 export declare type ByVisibilityGpuSectorCullerOptions = {
     /**
@@ -19,7 +18,7 @@ export declare type ByVisibilityGpuSectorCullerOptions = {
      * Optional callback for determining the cost of a sector. The default unit of the cost
      * function is bytes downloaded.
      */
-    determineSectorCost?: DetermineSectorCostDelegate;
+    determineSectorCost?: DetermineSectorCostDelegate<V8SectorMetadata>;
     /**
      * Use a custom coverage utility to determine how "visible" each sector is.
      */
@@ -50,4 +49,3 @@ export declare class ByVisibilityGpuSectorCuller implements SectorCuller {
     private markSectorsAsDetailed;
     private log;
 }
-export declare function createDefaultSectorCuller(renderer: THREE.WebGLRenderer, occludingGeometryProvider: OccludingGeometryProvider): SectorCuller;

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

@@ -0,0 +1,50 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { SectorMetadata, V9SectorMetadata } from '../../../../cad-parsers';
+import { PrioritizedArea } from '../../../../cad-styling';
+export declare class WeightFunctionsHelper {
+    private readonly _camera;
+    private _minSectorDistance;
+    private _maxSectorDistance;
+    private readonly _modifiedFrustums;
+    constructor(camera: THREE.PerspectiveCamera);
+    addCandidateSectors(sectors: SectorMetadata[], modelMatrix: THREE.Matrix4): void;
+    computeTransformedSectorBounds(sectorBounds: THREE.Box3, modelMatrix: THREE.Matrix4, out: THREE.Box3): void;
+    /**
+     * Computes a weight in range [0-1], where 1 means close to camera and 0 means far away.
+     */
+    computeDistanceToCameraWeight(transformedSectorBounds: THREE.Box3): number;
+    /**
+     * Compute a weight in range [0-1] where 1 means the sector covers the entire screen
+     * and 0 means no coverage.
+     * @param transformedSectorBounds
+     * @returns
+     */
+    computeScreenAreaWeight(transformedSectorBounds: THREE.Box3): number;
+    /**
+     * Compute a weight in range [0-1] based on at what "depths"
+     * in the frustum the sector is placed.
+     * @param transformedSectorBounds
+     */
+    computeFrustumDepthWeight(transformedSectorBounds: THREE.Box3): number;
+    /**
+     * Computes a weight based on placement in sector tree (i.e. prioritize)
+     * sectors right below root sector.
+     * @param sector
+     */
+    computeSectorTreePlacementWeight(sector: V9SectorMetadata): number;
+    /**
+     * Computes a weight based on how large the biggest node within the sector
+     * will be on screen (a number in range [0-1]).
+     */
+    computeMaximumNodeScreenSizeWeight(transformedSectorBounds: THREE.Box3, maxNodeDiagonalLength: number): number;
+    /**
+     * Returns a weight that is the maximum of the extra priority in intersecting prioritized areas.
+     * @param transformedSectorBounds   Bounds of sectors in "Reveal coordinates".
+     * @param prioritizedAreas          Zero or more areas with associated priorities.
+     */
+    computePrioritizedAreaWeight(transformedSectorBounds: THREE.Box3, prioritizedAreas: PrioritizedArea[]): number;
+    private distanceToCamera;
+}

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

@@ -0,0 +1,12 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+/**
+ * Computes area of the box after converting it to NDC space. The returned value will be a number
+ * in range [0, 1].
+ * @param camera
+ * @param box
+ * @returns
+ */
+export declare function computeNdcAreaOfBox(camera: THREE.Camera, box: THREE.Box3): number;

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

@@ -0,0 +1,7 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { SectorCost } from './types';
+import { LevelOfDetail, SectorMetadata } from '../../../../cad-parsers';
+export declare function computeV9SectorCost(sectorMetadata: SectorMetadata, lod: LevelOfDetail): SectorCost;
+export declare function computeV8SectorCost(sectorMetadata: SectorMetadata, lod: LevelOfDetail): SectorCost;

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

@@ -0,0 +1,7 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { SectorCuller } from './SectorCuller';
+import { OccludingGeometryProvider } from './OccludingGeometryProvider';
+export declare function createV8SectorCuller(renderer: THREE.WebGLRenderer, occludingGeometryProvider: OccludingGeometryProvider): SectorCuller;

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

@@ -0,0 +1,11 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { PrioritizedWantedSector, SectorCost, SectorLoadingSpent } from '../types';
+import { CadModelMetadata } from '../../../../../cad-parsers';
+export declare abstract class TakenSectorMapBase {
+    protected abstract get modelsMetadata(): CadModelMetadata[];
+    abstract get totalCost(): SectorCost;
+    abstract collectWantedSectors(): PrioritizedWantedSector[];
+    computeSpentBudget(): SectorLoadingSpent;
+}

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

@@ -0,0 +1,17 @@
+import { PrioritizedWantedSector, DetermineSectorCostDelegate, SectorCost } from '../types';
+import { CadModelBudget } from '../../../CadModelBudget';
+import { TakenSectorMapBase } from './TakenSectorMapBase';
+import { CadModelMetadata, V8SectorMetadata } from '../../../../../cad-parsers';
+export declare class TakenV8SectorMap extends TakenSectorMapBase {
+    private readonly _takenSectorTrees;
+    private readonly determineSectorCost;
+    get totalCost(): SectorCost;
+    get modelsMetadata(): CadModelMetadata[];
+    constructor(determineSectorCost: DetermineSectorCostDelegate<V8SectorMetadata>);
+    initializeScene(modelMetadata: CadModelMetadata): void;
+    getWantedSectorCount(): number;
+    markSectorDetailed(model: CadModelMetadata, sectorId: number, priority: number): void;
+    isWithinBudget(budget: CadModelBudget): boolean;
+    collectWantedSectors(): PrioritizedWantedSector[];
+    clear(): void;
+}

package/packages/cad-geometry-loaders/src/sector/culling/{TakenSectorTree.d.ts → takensectors/TakenV8SectorTree.d.ts}

@@ -1,15 +1,15 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { SectorMetadata } from '../../../../cad-parsers';
-import { PrioritizedWantedSector, DetermineSectorCostDelegate, SectorCost } from './types';
-export declare class TakenSectorTree {
+import { V8SectorMetadata } from '../../../../../cad-parsers';
+import { PrioritizedWantedSector, DetermineSectorCostDelegate, SectorCost } from '../types';
+export declare class TakenV8SectorTree {
     get totalCost(): SectorCost;
     private readonly sectors;
     private readonly determineSectorCost;
-    private _totalCost;
-    constructor(sectorRoot: SectorMetadata, determineSectorCost: DetermineSectorCostDelegate);
-    determineWantedSectorCount(): number;
+    private readonly _totalCost;
+    constructor(sectorRoot: V8SectorMetadata, determineSectorCost: DetermineSectorCostDelegate<V8SectorMetadata>);
+    getWantedSectorCount(): number;
     toWantedSectors(modelIdentifier: string, modelBaseUrl: string, geometryClipBox: THREE.Box3 | null): PrioritizedWantedSector[];
     markSectorDetailed(sectorId: number, priority: number): void;
     /**

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

@@ -0,0 +1,20 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { DetermineSectorCostDelegate, PrioritizedWantedSector, SectorCost } from '../types';
+import { CadModelBudget } from '../../../CadModelBudget';
+import { TakenSectorMapBase } from './TakenSectorMapBase';
+import { CadModelMetadata, V9SectorMetadata } from '../../../../../cad-parsers';
+export declare class TakenV9SectorMap extends TakenSectorMapBase {
+    private readonly determineSectorCost;
+    private readonly _totalCost;
+    private readonly _models;
+    get totalCost(): SectorCost;
+    get modelsMetadata(): CadModelMetadata[];
+    constructor(determineSectorCost: DetermineSectorCostDelegate<V9SectorMetadata>);
+    initializeScene(modelMetadata: CadModelMetadata): void;
+    markSectorDetailed(model: CadModelMetadata, sectorId: number, priority: number): void;
+    isWithinBudget(budget: CadModelBudget): boolean;
+    collectWantedSectors(): PrioritizedWantedSector[];
+    clear(): void;
+}

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

@@ -0,0 +1,5 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export { TakenV9SectorMap } from './TakenV9SectorMap';
+export { TakenV8SectorMap } from './TakenV8SectorMap';

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

@@ -0,0 +1,5 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+export declare function transformBoxToNDC(box: THREE.Box3, camera: THREE.Camera, out?: THREE.Box3): THREE.Box3;

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

@@ -2,17 +2,29 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { SectorMetadata, CadModelMetadata, LevelOfDetail, WantedSector } from '../../../../cad-parsers';
+import { PrioritizedArea } from '../../../../cad-styling';
+import { CadModelMetadata, LevelOfDetail, WantedSector } from '../../../../cad-parsers';
 import { CadLoadingHints } from '../../CadLoadingHints';
-import { CadModelSectorBudget } from '../../CadModelSectorBudget';
+import { CadModelBudget } from '../../CadModelBudget';
+import { CadNode } from '../../../../rendering';
 export interface DetermineSectorsInput {
     camera: THREE.PerspectiveCamera;
     clippingPlanes: THREE.Plane[];
     cadModelsMetadata: CadModelMetadata[];
     loadingHints: CadLoadingHints;
     cameraInMotion: boolean;
-    budget: CadModelSectorBudget;
+    budget: CadModelBudget;
+    prioritizedAreas: PrioritizedArea[];
 }
+export declare type DetermineSectorsPayload = {
+    camera: THREE.PerspectiveCamera;
+    clippingPlanes: THREE.Plane[];
+    models: CadNode[];
+    loadingHints: CadLoadingHints;
+    cameraInMotion: boolean;
+    budget: CadModelBudget;
+    prioritizedAreas: PrioritizedArea[];
+};
 /**
  * Statistics for how much data is required to load set of sectors.
  */
@@ -68,4 +80,4 @@ export declare type PrioritizedWantedSector = WantedSector & {
 /**
  * Delegates that computes 'cost' of loading/visualizing a given sector.
  */
-export declare type DetermineSectorCostDelegate = (sector: SectorMetadata, levelOfDetail: LevelOfDetail) => SectorCost;
+export declare type DetermineSectorCostDelegate<TSectorMetadata> = (sector: TSectorMetadata, levelOfDetail: LevelOfDetail) => SectorCost;

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

@@ -2,8 +2,8 @@
  * Copyright 2021 Cognite AS
  */
 import { LevelOfDetail } from '../../../cad-parsers';
-import { DetermineSectorsInput } from './culling/types';
-export declare function loadingEnabled({ cadModelsMetadata, loadingHints }: DetermineSectorsInput): boolean;
+import { DetermineSectorsPayload } from './culling/types';
+export declare function loadingEnabled({ models, loadingHints }: DetermineSectorsPayload): boolean;
 export interface ModelState {
     [id: number]: LevelOfDetail;
 }

package/packages/cad-geometry-loaders/src/utilities/rxOperations.d.ts

@@ -1,5 +1,6 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-export declare const emissionLastMillis: (millis: number) => import("rxjs").UnaryFunction<import("rxjs").Observable<unknown>, import("rxjs").Observable<boolean>>;
-export declare const delayedSwitch: (millis: number) => import("rxjs").Observable<boolean>;
+import { Observable, OperatorFunction } from 'rxjs';
+export declare function emissionLastMillis(millis: number): OperatorFunction<unknown, boolean>;
+export declare function delayedSwitch(millis: number): Observable<boolean>;

package/packages/cad-geometry-loaders/src/utilities/types.d.ts

@@ -1,29 +1,6 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import * as THREE from 'three';
-/**
- * Colors from the Cognite theme.
- */
-export declare class CogniteColors {
-    static readonly Black: THREE.Color;
-    static readonly White: THREE.Color;
-    static readonly Cyan: THREE.Color;
-    static readonly Blue: THREE.Color;
-    static readonly Purple: THREE.Color;
-    static readonly Pink: THREE.Color;
-    static readonly Orange: THREE.Color;
-    static readonly Yellow: THREE.Color;
-    static readonly VeryLightGray: THREE.Color;
-    static readonly LightGray: THREE.Color;
-}
-/**
- * Some additional colors to supplement {@link CogniteColors}.
- */
-export declare class RevealColors {
-    static readonly Red: THREE.Color;
-    static readonly Green: THREE.Color;
-}
 /**
  * State holding information about data being loaded.
  */

package/packages/cad-parsers/index.d.ts

@@ -8,13 +8,14 @@ export { CadModelMetadata } from './src/metadata/CadModelMetadata';
 export { SectorSceneImpl } from './src/utilities/SectorScene';
 export { SectorSceneFactory } from './src/utilities/SectorSceneFactory';
 export { SectorScene } from './src/utilities/types';
-export { SectorMetadataIndexFileSection, SectorMetadataFacesFileSection, SectorMetadata } from './src/metadata/types';
+export { SectorMetadata, V8SectorMetadata, V9SectorMetadata } from './src/metadata/types';
+export { SectorNode } from './src/sector/SectorNode';
+export { RootSectorNode } from './src/sector/RootSectorNode';
 export { CadSectorParser } from './src/cad/CadSectorParser';
-export { RenderMode } from './src/cad/RenderMode';
 export { LevelOfDetail } from './src/cad/LevelOfDetail';
+export { filterPrimitivesOutsideClipBoxByBaseBoundsAndInstanceMatrix, filterPrimitivesOutsideClipBoxByCenterAndRadius, filterPrimitivesOutsideClipBoxByEllipse, filterPrimitivesOutsideClipBoxByVertices } from './src/cad/filterPrimitivesV8';
+export { filterInstanceMesh } from './src/cad/filterInstanceMesh';
+export { boxGeometry, quadGeometry, coneGeometry, trapeziumGeometry, nutGeometry, torusLodGeometries, boxGeometryBoundingBox, quadGeometryBoundingBox, nutGeometryBoundingBox } from './src/cad/primitiveGeometries';
 export { SectorGeometry, InstancedMeshFile, InstancedMesh, TriangleMesh, WantedSector, ConsumedSector } from './src/cad/types';
-export { createMaterials, Materials } from './src/cad/materials';
-export { createPrimitives } from './src/cad/primitives';
-export { filterPrimitivesOutsideClipBoxByBaseBoundsAndInstanceMatrix } from './src/cad/filterPrimitives';
 export { WellKnownDistanceToMeterConversionFactors } from './src/utilities/types';
-export { outlineDetectionShaders, fxaaShaders, ssaoShaders, ssaoBlurCombineShaders, coverageShaders } from './src/cad/shaders';
+export { createTriangleMeshes } from './src/cad/triangleMeshes';

package/packages/{cad-geometry-loaders/src/material-manager/rendering → cad-parsers/src/cad}/filterInstanceMesh.d.ts

@@ -2,5 +2,5 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { InstancedMesh } from '../../../../cad-parsers';
+import { InstancedMesh } from './types';
 export declare function filterInstanceMesh(vertices: Float32Array, indices: Uint32Array, instanceMesh: InstancedMesh, geometryClipBox: THREE.Box3 | null): InstancedMesh;

package/packages/cad-parsers/src/cad/filterPrimitivesCommon.d.ts

@@ -0,0 +1,5 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+export declare function filterPrimitivesOutsideClipBox(attributesByteValues: Uint8Array, elementSize: number, clipBox: THREE.Box3, getBoundsOfElementsCallback: (index: number, elementSize: number, attributeFloatValues: Float32Array, outBox: THREE.Box3) => void): Uint8Array;

package/packages/cad-parsers/src/cad/filterPrimitivesV9.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { RevealGeometryCollectionType } from '../../../sector-parser';
+import * as THREE from 'three';
+export declare function filterGeometryOutsideClipBox(geometryBuffer: THREE.BufferGeometry, type: RevealGeometryCollectionType, clipBox?: THREE.Box3): THREE.BufferGeometry | undefined;

package/packages/cad-parsers/src/cad/primitiveGeometries.d.ts

@@ -23,7 +23,7 @@ export declare const coneGeometry: {
 export declare const torusLodGeometries: {
     index: THREE.Uint16BufferAttribute;
     position: THREE.Float32BufferAttribute;
-}[], torusGeometryBoundingBox: THREE.Box3;
+}[];
 export declare const nutGeometry: {
     index: THREE.BufferAttribute | null;
     position: THREE.BufferAttribute | THREE.InterleavedBufferAttribute;

package/packages/{cad-geometry-loaders/src/material-manager/rendering → cad-parsers/src/cad}/triangleMeshes.d.ts

@@ -2,5 +2,5 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { TriangleMesh } from '../../../../cad-parsers';
+import { TriangleMesh } from '../../../cad-parsers';
 export declare function createTriangleMeshes(triangleMeshes: TriangleMesh[], bounds: THREE.Box3, material: THREE.ShaderMaterial, geometryClipBox: THREE.Box3 | null): THREE.Mesh[];

package/packages/cad-parsers/src/cad/types.d.ts

@@ -6,6 +6,7 @@ import { AutoDisposeGroup } from '../../../utilities';
 import { ParsedPrimitives, ParseSectorResult, ParseCtmResult, SectorQuads } from '@cognite/reveal-parser-worker';
 import { SectorMetadata } from '../metadata/types';
 import { LevelOfDetail } from './LevelOfDetail';
+import { ParsedGeometry } from '../../../sector-parser';
 export declare type TriangleMesh = {
     readonly fileId: number;
     readonly indices: Uint32Array;
@@ -28,8 +29,6 @@ export declare type InstancedMesh = {
     readonly treeIndices: Float32Array;
 };
 export interface SectorGeometry {
-    readonly nodeIdToTreeIndexMap: Map<number, number>;
-    readonly treeIndexToNodeIdMap: Map<number, number>;
     readonly primitives: ParsedPrimitives;
     readonly instanceMeshes: InstancedMeshFile[];
     readonly triangleMeshes: TriangleMesh[];
@@ -40,6 +39,7 @@ export interface ConsumedSector {
     levelOfDetail: LevelOfDetail;
     group: AutoDisposeGroup | undefined;
     instancedMeshes: InstancedMeshFile[] | undefined;
+    geometryBatchingQueue?: ParsedGeometry[];
 }
 export interface ParsedSector {
     modelIdentifier: string;

package/packages/cad-parsers/src/metadata/CadModelMetadata.d.ts

@@ -4,11 +4,21 @@
 import * as THREE from 'three';
 import { SectorScene } from '../utilities/types';
 import { CameraConfiguration } from '../../../utilities';
+import { File3dFormat } from '../../../modeldata-api';
 export interface CadModelMetadata {
     /**
      * A unique identifier of the model.
      */
     readonly modelIdentifier: string;
+    /**
+     * File format of the 3D model (i3d/f3d, gltf, etc.)
+     */
+    readonly format: File3dFormat;
+    /**
+     * Revision of the {@link format} (e.g. 8 for "legacy models" or
+     * 9 for GLTF).
+     */
+    readonly formatVersion: number;
     /**
      * Base URL of the model.
      */

package/packages/cad-parsers/src/metadata/CadModelMetadataRepository.d.ts

@@ -1,16 +1,16 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { CadMetadataParser } from './CadMetadataParser';
 import { CadModelMetadata } from './CadModelMetadata';
 import { MetadataRepository } from './MetadataRepository';
-import { ModelDataClient, ModelMetadataProvider } from '../../../modeldata-api';
-export declare class CadModelMetadataRepository<TModelIdentifier> implements MetadataRepository<TModelIdentifier, Promise<CadModelMetadata>> {
+import { ModelDataProvider, ModelMetadataProvider, ModelIdentifier } from '../../../modeldata-api';
+export declare class CadModelMetadataRepository implements MetadataRepository<Promise<CadModelMetadata>> {
     private readonly _modelMetadataProvider;
-    private readonly _modelDataClient;
+    private readonly _modelDataProvider;
     private readonly _cadSceneParser;
     private readonly _blobFileName;
     private _currentModelIdentifier;
-    constructor(modelMetadataProvider: ModelMetadataProvider<TModelIdentifier>, modelDataClient: ModelDataClient, cadMetadataParser: CadMetadataParser, blobFileName?: string);
-    loadData(model: TModelIdentifier): Promise<CadModelMetadata>;
+    constructor(modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider, blobFileName?: string);
+    loadData(modelIdentifier: ModelIdentifier): Promise<CadModelMetadata>;
+    private getSupportedOutput;
 }

package/packages/cad-parsers/src/metadata/MetadataRepository.d.ts

@@ -1,6 +1,7 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-export interface MetadataRepository<Input, Output> {
-    loadData(input: Input): Output;
+import { ModelIdentifier } from '../../../modeldata-api';
+export interface MetadataRepository<Output> {
+    loadData(modelIdentifier: ModelIdentifier): Output;
 }

package/packages/cad-parsers/src/metadata/parsers/CadMetadataParserGltf.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { SectorScene } from '../../utilities/types';
+import { CadSceneRootMetadata } from './types';
+export declare function parseCadMetadataGltf(metadata: CadSceneRootMetadata): SectorScene;