@cognite/reveal 4.0.0 → 4.1.0-dev.20230126

package/dist/packages/360-images/index.d.ts

@@ -7,3 +7,5 @@ export { Image360Facade } from './src/Image360Facade';
 export { Image360EntityFactory } from './src/Image360EntityFactory';
 export { Image360Entity } from './src/Image360Entity';
 export { Image360Visualization } from './src/Image360Visualization';
+export { Image360EnteredDelegate, Image360ExitedDelegate } from './src/types';
+export { DefaultImage360Collection } from './src/DefaultImage360Collection';

package/dist/packages/360-images/src/DefaultImage360Collection.d.ts

@@ -0,0 +1,44 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { EventTrigger } from '../../utilities';
+import { Image360 } from './Image360';
+import { Image360Collection } from './Image360Collection';
+import { Image360Entity } from './Image360Entity';
+import { Image360EnteredDelegate, Image360ExitedDelegate } from './types';
+/**
+ * Default implementation of {@link Image360Collection}. Used for events when entering
+ * and exiting 360 image mode
+ */
+export declare class DefaultImage360Collection implements Image360Collection {
+    /**
+     * A list containing all the 360 images in this set.
+     */
+    readonly image360Entities: Image360Entity[];
+    private readonly _events;
+    /**
+     * The events from the image collection.
+     */
+    get events(): {
+        image360Entered: EventTrigger<Image360EnteredDelegate>;
+        image360Exited: EventTrigger<Image360ExitedDelegate>;
+    };
+    constructor(entities: Image360[]);
+    /**
+     * Subscribes to events on 360 Image datasets. There are several event types:
+     * 'image360Entered' - Subscribes to a event for entering 360 image mode.
+     * 'image360Exited' - Subscribes to events indicating 360 image mode has exited.
+     * @param event The event type.
+     * @param callback Callback to be called when the event is fired.
+     */
+    on(event: 'image360Entered', callback: Image360EnteredDelegate): void;
+    on(event: 'image360Exited', callback: Image360ExitedDelegate): void;
+    /**
+     * Unsubscribes from 360 image dataset event.
+     * @param event The event type.
+     * @param callback Callback function to be unsubscribed.
+     */
+    off(event: 'image360Entered', callback: Image360EnteredDelegate): void;
+    off(event: 'image360Exited', callback: Image360ExitedDelegate): void;
+    dispose(): void;
+}

package/dist/packages/360-images/src/Image360Collection.d.ts

@@ -2,6 +2,7 @@
  * Copyright 2022 Cognite AS
  */
 import { Image360 } from './Image360';
+import { Image360EnteredDelegate, Image360ExitedDelegate } from './types';
 /**
  * A wrapper that represents a set of 360 images.
  */
@@ -10,4 +11,20 @@ export interface Image360Collection {
      * A list containing all the 360 images in this set.
      */
     readonly image360Entities: Image360[];
+    /**
+     * Subscribes to events on 360 Image datasets. There are several event types:
+     * 'image360Entered' - Subscribes to a event for entering 360 image mode.
+     * 'image360Exited' - Subscribes to events indicating 360 image mode has exited.
+     * @param event The event type.
+     * @param callback Callback to be called when the event is fired.
+     */
+    on(event: 'image360Entered', callback: Image360EnteredDelegate): void;
+    on(event: 'image360Exited', callback: Image360ExitedDelegate): void;
+    /**
+     * Unsubscribes from 360 image dataset event.
+     * @param event The event type.
+     * @param callback Callback function to be unsubscribed.
+     */
+    off(event: 'image360Entered', callback: Image360EnteredDelegate): void;
+    off(event: 'image360Exited', callback: Image360ExitedDelegate): void;
 }

package/dist/packages/360-images/src/types.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Image360 } from './Image360';
+/**
+ * Delegate for 360 image mode entered events.
+ */
+export type Image360EnteredDelegate = (image360: Image360) => void;
+/**
+ * Delegate for 360 image mode exited events.
+ */
+export type Image360ExitedDelegate = () => void;

package/dist/packages/api/index.d.ts

@@ -5,6 +5,5 @@ export { Cognite3DViewer } from './src/public/migration/Cognite3DViewer';
 export { CogniteCadModel } from '../cad-model';
 export { ViewerState, ModelState, ClippingPlanesState } from './src/utilities/ViewStateHelper';
 export * from './src/public/types';
-export { CDF_TO_VIEWER_TRANSFORMATION } from './src/public/constants';
 declare const REVEAL_VERSION: string;
 export { REVEAL_VERSION };

package/dist/packages/api/src/api-helpers/Image360ApiHelper.d.ts

@@ -3,7 +3,7 @@
  */
 import * as THREE from 'three';
 import { CogniteClient } from '@cognite/sdk';
-import { Image360Entity } from '../../../360-images';
+import { Image360Collection, Image360Entity } from '../../../360-images';
 import { InputHandler, SceneHandler } from '../../../utilities';
 import { ProxyCameraManager } from '../../../camera-manager';
 import { Image360 } from '../../../360-images/src/Image360';
@@ -17,14 +17,16 @@ export declare class Image360ApiHelper {
     private readonly _activeCameraManager;
     private readonly _image360Navigation;
     private _cachedCameraManager;
+    private readonly _imageCollection;
     constructor(cogniteClient: CogniteClient, sceneHandler: SceneHandler, domElement: HTMLElement, activeCameraManager: ProxyCameraManager, inputHandler: InputHandler, requestRedraw: () => void);
     add360ImageSet(eventFilter: {
         [key: string]: string;
-    }, collectionTransform: THREE.Matrix4, preMultipliedRotation: boolean): Promise<Image360Entity[]>;
+    }, collectionTransform: THREE.Matrix4, preMultipliedRotation: boolean): Promise<Image360Collection>;
     remove360Images(entities: Image360[]): Promise<void>;
     enter360Image(image360Entity: Image360Entity): Promise<void>;
     private transition;
     private tweenVisualizationAlpha;
+    private tweenVisualizationZoom;
     private set360CameraManager;
     exit360Image(): void;
     dispose(): void;

package/dist/packages/api/src/public/RevealManager.d.ts

@@ -8,7 +8,7 @@ import { PointCloudManager, PointCloudNode } from '../../../pointclouds';
 import { LoadingState } from '../../../model-base';
 import { CadManager, CadModelBudget } from '../../../cad-geometry-loaders';
 import { NodeAppearanceProvider } from '../../../cad-styling';
-import { RenderMode, RenderPipelineExecutor, CadMaterialManager, RenderPipelineProvider } from '../../../rendering';
+import { RenderMode, RenderPipelineExecutor, CadMaterialManager, RenderPipelineProvider, ResizeHandler, SettableRenderTarget } from '../../../rendering';
 import { CameraManager } from '../../../camera-manager';
 import { ModelIdentifier } from '../../../data-providers';
 export type AddCadModelOptions = {
@@ -24,6 +24,7 @@ export declare class RevealManager {
     private readonly _pointCloudManager;
     private readonly _pipelineExecutor;
     private readonly _renderPipeline;
+    private readonly _resizeHandler;
     private _cameraInMotion;
     private _isDisposed;
     private readonly _subscriptions;
@@ -32,10 +33,11 @@ export declare class RevealManager {
     private readonly _cameraManager;
     private readonly _onCameraChange;
     private readonly _onCameraStop;
-    constructor(cadManager: CadManager, pointCloudManager: PointCloudManager, pipelineExecutor: RenderPipelineExecutor, renderPipeline: RenderPipelineProvider, cameraManager: CameraManager);
+    constructor(cadManager: CadManager, pointCloudManager: PointCloudManager, pipelineExecutor: RenderPipelineExecutor, renderPipeline: RenderPipelineProvider & SettableRenderTarget, resizeHandler: ResizeHandler, cameraManager: CameraManager);
     dispose(): void;
     requestRedraw(): void;
     resetRedraw(): void;
+    setOutputRenderTarget(target: THREE.WebGLRenderTarget | null, autoSizeRenderTarget?: boolean): void;
     get materialManager(): CadMaterialManager;
     get needsRedraw(): boolean;
     update(camera: THREE.PerspectiveCamera): void;
@@ -50,6 +52,8 @@ export declare class RevealManager {
     get clippingPlanes(): THREE.Plane[];
     on(event: 'loadingStateChanged', listener: LoadingStateChangeListener): void;
     off(event: 'loadingStateChanged', listener: LoadingStateChangeListener): void;
+    setResolutionThreshold(threshold: number): void;
+    setMovingCameraResolutionFactor(factor: number): void;
     render(camera: THREE.PerspectiveCamera): void;
     addModel(type: 'cad', modelIdentifier: ModelIdentifier, options?: AddCadModelOptions): Promise<CadNode>;
     addModel(type: 'pointcloud', modelIdentifier: ModelIdentifier): Promise<PointCloudNode>;

package/dist/packages/api/src/public/RevealOptions.d.ts

@@ -6,7 +6,8 @@ import { RenderOptions } from '../../../rendering';
 import { InternalRevealCadOptions } from '../../../cad-geometry-loaders';
 /**
  * @property logMetrics Might be used to disable usage statistics.
- * @property nodeAppearanceProvider Style node by tree-index.
+ * @property movingCameraResolutionFactor Factor with which the resolution (number of screen pixels) is scaled
+ * when camera is moving.
  * @property internal Internals are for internal usage only (like unit-testing).
  */
 export type RevealOptions = {

package/dist/packages/api/src/public/migration/Cognite3DViewer.d.ts

@@ -5,7 +5,7 @@ import * as THREE from 'three';
 import { PointerEventDelegate, SceneRenderedDelegate, DisposedDelegate, BeforeSceneRenderedDelegate } from '../../../../utilities';
 import { CogniteCadModel } from '../../../../cad-model';
 import { PointCloudBudget, CognitePointCloudModel } from '../../../../pointclouds';
-import { AddImage360Options, AddModelOptions, Cognite3DViewerOptions, Intersection, CadModelBudget } from './types';
+import { AddImage360Options, AddModelOptions, Cognite3DViewerOptions, Intersection, CadModelBudget, ResolutionOptions } from './types';
 import { CogniteModel } from '../types';
 import { ViewerState } from '../../utilities/ViewStateHelper';
 import { CameraManager, CameraChangeDelegate } from '../../../../camera-manager';
@@ -48,13 +48,13 @@ export declare class Cognite3DViewer {
     private readonly _revealManagerHelper;
     private readonly _domElement;
     private readonly _renderer;
+    private readonly _ownsRenderer;
     private readonly _pickingHandler;
     private readonly _pointCloudPickingHandler;
     private readonly _boundAnimate;
     private readonly _events;
     private readonly _mouseHandler;
     private readonly _models;
-    private readonly _extraObjects;
     private isDisposed;
     private latestRequestId;
     private readonly clock;
@@ -90,6 +90,12 @@ export declare class Cognite3DViewer {
      */
     get models(): CogniteModel[];
     constructor(options: Cognite3DViewerOptions);
+    /**
+     * Set options to control resolution of the viewer. This includes
+     * settings for max resolution and limiting resolution when moving the camera.
+     * @param options Options to apply.
+     */
+    setResolutionOptions(options: ResolutionOptions): void;
     /**
      * Returns reveal version installed.
      */
@@ -342,34 +348,45 @@ export declare class Cognite3DViewer {
      * ```js
      * // Hide pixels with values less than 0 in the x direction
      * const plane = new THREE.Plane(new THREE.Vector3(1, 0, 0), 0);
-     * viewer.setClippingPlanes([plane]);
+     * viewer.setGlobalClippingPlanes([plane]);
      * ```
      * ```js
      * // Hide pixels with values greater than 20 in the x direction
      *  const plane = new THREE.Plane(new THREE.Vector3(-1, 0, 0), 20);
-     * viewer.setClippingPlanes([plane]);
+     * viewer.setGlobalClippingPlanes([plane]);
      * ```
      * ```js
      * // Hide pixels with values less than 0 in the x direction or greater than 0 in the y direction
      * const xPlane = new THREE.Plane(new THREE.Vector3(1, 0, 0), 0);
      * const yPlane = new THREE.Plane(new THREE.Vector3(0, -1, 0), 0);
-     * viewer.setClippingPlanes([xPlane, yPlane]);
+     * viewer.setGlobalClippingPlanes([xPlane, yPlane]);
      * ```
      * ```js
      * // Hide pixels behind an arbitrary, non axis-aligned plane
      *  const plane = new THREE.Plane(new THREE.Vector3(1.5, 20, -19), 20);
-     * viewer.setClippingPlanes([plane]);
+     * viewer.setGlobalClippingPlanes([plane]);
      * ```
      * ```js
      * // Disable clipping planes
-     *  viewer.setClippingPlanes([]);
+     *  viewer.setGlobalClippingPlanes([]);
      * ```
      */
+    setGlobalClippingPlanes(clippingPlanes: THREE.Plane[]): void;
+    /**
+     * Sets per-pixel clipping planes. Pixels behind any of the planes will be sliced away.
+     * @param clippingPlanes
+     * @deprecated Use {@link Cognite3DViewer.setGlobalClippingPlanes} instead.
+     */
     setClippingPlanes(clippingPlanes: THREE.Plane[]): void;
     /**
-     * Returns the current active clipping planes.
+     * Returns the current active global clipping planes.
+     * @deprecated Use {@link Cognite3DViewer.getGlobalClippingPlanes} instead.
      */
     getClippingPlanes(): THREE.Plane[];
+    /**
+     * Returns the current active global clipping planes.
+     */
+    getGlobalClippingPlanes(): THREE.Plane[];
     /**
      * Attempts to load the camera settings from the settings stored for the
      * provided model. See {@link https://docs.cognite.com/api/v1/#operation/get3DRevision}

package/dist/packages/api/src/public/migration/types.d.ts

@@ -69,6 +69,8 @@ export interface Cognite3DViewerOptions {
      * To ensure managable performance, Reveal will by default set an upper threshold to limit
      * the resolution. Setting the {@link Cognite3DViewerOptions.rendererResolutionThreshold} will
      * set this upper limit of what resolution Reveal will allow.
+     *
+     * @deprecated Use {@link Cognite3DViewer.setResolutionOptions} instead.
      */
     rendererResolutionThreshold?: number;
     /**
@@ -175,6 +177,30 @@ export type CadIntersection = {
      */
     distanceToCamera: number;
 };
+/**
+ * Options to control resolution of the viewer. This includes
+ * settings for max resolution and limiting resolution when moving the camera.
+ *
+ * @module @cognite/reveal
+ */
+export type ResolutionOptions = {
+    /**
+     * Generally Reveal will follow the resolution given by the size
+     * of the encapsulating DOM element of the Canvas {@link Cognite3DViewerOptions.domElement}.
+     * To ensure managable performance, Reveal will by default set an upper threshold to limit
+     * the resolution. The `maxRenderResolution` option will
+     * directly control this upper limit. It corresponds to the number of pixels in the render target.
+     */
+    maxRenderResolution?: number;
+    /**
+     * A factor that will scale down the resolution when moving the camera. This can
+     * be used to achieve a better user experience on devices with limited hardware.
+     * Values must be greater than 0 and at most 1.
+     * This factor is applied to the number of physical pixels of the canvas.
+     * A value of e.g. 0.25 will approximately divide the number of pixels rendered on the screen by four.
+     */
+    movingCameraResolutionFactor?: number;
+};
 /**
  * Represents the result from {@link Cognite3DViewer.getIntersectionFromPixel}.
  * @module @cognite/reveal

package/dist/packages/cad-geometry-loaders/src/CadManager.d.ts

@@ -4,10 +4,11 @@
 import * as THREE from 'three';
 import { Observable } from 'rxjs';
 import { CadModelMetadata } from '../../cad-parsers';
-import { CadModelUpdateHandler, CadModelBudget } from '../../cad-geometry-loaders';
+import { CadModelUpdateHandler } from './CadModelUpdateHandler';
 import { LoadingState } from '../../model-base';
 import { CadMaterialManager, RenderMode } from '../../rendering';
 import { ModelIdentifier } from '../../data-providers';
+import { CadModelBudget } from './CadModelBudget';
 import { CadModelFactory, CadModelSectorLoadStatistics, CadNode, GeometryFilter } from '../../cad-model';
 export declare class CadManager {
     private readonly _materialManager;

package/dist/packages/cad-geometry-loaders/src/InternalRevealCadOptions.d.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import { SectorCuller } from '../../cad-geometry-loaders';
+import { SectorCuller } from './sector/culling/SectorCuller';
 export type InternalRevealCadOptions = {
     sectorCuller?: SectorCuller;
 };

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

@@ -3,13 +3,13 @@
  */
 import { DetermineSectorCostDelegate, DetermineSectorsInput, SectorLoadingSpent } from './types';
 import { SectorCuller } from './SectorCuller';
-import { V9SectorMetadata, WantedSector } from '../../../../cad-parsers';
+import { SectorMetadata, WantedSector } from '../../../../cad-parsers';
 export type ByScreenSizeSectorCullerOptions = {
     /**
      * Optional callback for determining the cost of a sector. The default unit of the cost
      * function is bytes downloaded.
      */
-    determineSectorCost?: DetermineSectorCostDelegate<V9SectorMetadata>;
+    determineSectorCost?: DetermineSectorCostDelegate<SectorMetadata>;
 };
 export declare class ByScreenSizeSectorCuller implements SectorCuller {
     private readonly _determineSectorCost;

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

@@ -2,7 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { SectorMetadata, V9SectorMetadata } from '../../../../cad-parsers';
+import { SectorMetadata } from '../../../../cad-parsers';
 import { PrioritizedArea } from '../../../../cad-styling';
 export declare class WeightFunctionsHelper {
     private readonly _camera;
@@ -35,7 +35,7 @@ export declare class WeightFunctionsHelper {
      * sectors right below root sector.
      * @param sector
      */
-    computeSectorTreePlacementWeight(sector: V9SectorMetadata): number;
+    computeSectorTreePlacementWeight(sector: SectorMetadata): number;
     /**
      * Computes a weight based on how large the biggest node within the sector
      * will be on screen (a number in range [0-1]).

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

@@ -4,14 +4,14 @@
 import { DetermineSectorCostDelegate, PrioritizedWantedSector, SectorCost } from '../types';
 import { CadModelBudget } from '../../../CadModelBudget';
 import { TakenSectorMapBase } from './TakenSectorMapBase';
-import { CadModelMetadata, V9SectorMetadata } from '../../../../../cad-parsers';
+import { CadModelMetadata, SectorMetadata } 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>);
+    constructor(determineSectorCost: DetermineSectorCostDelegate<SectorMetadata>);
     initializeScene(modelMetadata: CadModelMetadata): void;
     markSectorDetailed(model: CadModelMetadata, sectorId: number, priority: number): void;
     isWithinBudget(budget: CadModelBudget): boolean;

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

@@ -9,7 +9,7 @@ import { CadModelBudget } from '../../CadModelBudget';
 import { CadNode } from '../../../../cad-model';
 export interface DetermineSectorsInput {
     camera: THREE.PerspectiveCamera;
-    clippingPlanes: THREE.Plane[];
+    modelClippingPlanes: THREE.Plane[][];
     cadModelsMetadata: CadModelMetadata[];
     loadingHints: CadLoadingHints;
     cameraInMotion: boolean;

package/dist/packages/cad-model/src/batching/DrawCallBatchingManager.d.ts

@@ -0,0 +1,9 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { ParsedGeometry } from '../../../sector-parser';
+export interface DrawCallBatchingManager {
+    batchGeometries(geometryBatchingQueue: ParsedGeometry[], sectorId: number): void;
+    removeSectorBatches(sectorId: number): void;
+    dispose(): void;
+}

package/dist/packages/cad-model/src/batching/MultiBufferBatchingManager.d.ts

@@ -0,0 +1,38 @@
+import { Group } from 'three';
+import { Materials, StyledTreeIndexSets } from '../../../rendering';
+import { ParsedGeometry } from '../../../sector-parser';
+import { DrawCallBatchingManager } from './DrawCallBatchingManager';
+/**
+ * The objective of this class is to batch together instances
+ * of the same type from different sectors.
+ * This is done to reduce the number of draw calls that have to be issued during rendering.
+ * Essentially this works by allocating n (numberOfInstanceBatches) buffers for each unique instanced type
+ * and continually filling / ejecting data from those buffers when new sectors are added / removed.
+ */
+export declare class MultiBufferBatchingManager implements DrawCallBatchingManager {
+    private readonly initialBufferSize;
+    private readonly numberOfInstanceBatches;
+    private readonly _sectorBatches;
+    private readonly _instanceBatches;
+    private readonly _materials;
+    private readonly _batchGroup;
+    private readonly _styledTreeIndexSets;
+    constructor(batchGroup: Group, materials: Materials, styleTreeIndexSets: StyledTreeIndexSets, initialBufferSize?: number, numberOfInstanceBatches?: number);
+    batchGeometries(geometryBatchingQueue: ParsedGeometry[], sectorId: number): void;
+    removeSectorBatches(sectorId: number): void;
+    dispose(): void;
+    private removeTreeIndicesFromMeshUserData;
+    private processGeometries;
+    private batchInstanceAttributes;
+    private addTreeIndicesToMeshUserData;
+    private reallocateBufferGeometry;
+    private updateInstanceAttributes;
+    private extendUpdateRange;
+    private getBatchBufferToFill;
+    private getOrCreateInstanceBatch;
+    private createBatchBuffer;
+    private createInstanceMesh;
+    private createDefragmentedBufferGeometry;
+    private getTreeIndexAttribute;
+    private createSectorBatch;
+}

package/dist/packages/cad-model/src/utilities/GeometryBufferUtils.d.ts

@@ -0,0 +1,18 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { TypedArray } from '../../../utilities';
+import { BufferAttribute, InterleavedBufferAttribute, BufferGeometry } from 'three';
+export declare class GeometryBufferUtils {
+    private static readonly TypedArrayViews;
+    static getAttributes<T extends BufferAttribute | InterleavedBufferAttribute>(geometry: BufferGeometry, filterType: new (...args: any[]) => T): {
+        name: string;
+        attribute: T;
+    }[];
+    static copyGeometryWithBufferAttributes(geometry: BufferGeometry): THREE.BufferGeometry;
+    static setInstanceAttributeDescriptors(instanceAttributes: {
+        name: string;
+        attribute: InterleavedBufferAttribute;
+    }[], bufferGeometry: BufferGeometry, backingBuffer: ArrayBufferLike): void;
+    static getInstanceAttributesSharedView(geometry: BufferGeometry): TypedArray;
+}

package/dist/packages/cad-model/src/utilities/getShaderMaterial.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Materials } from '../../../rendering';
+import { RevealGeometryCollectionType } from '../../../sector-parser';
+import { RawShaderMaterial } from 'three';
+export declare function getShaderMaterial(type: RevealGeometryCollectionType, materials: Materials): RawShaderMaterial;

package/dist/packages/cad-model/src/wrappers/CadNode.d.ts

@@ -16,7 +16,12 @@ export declare class CadNode extends Object3D {
     private _geometryBatchingManager?;
     private readonly _sourceTransform;
     private readonly _customTransform;
+    private readonly _setModelRenderLayers;
+    private readonly _batchedGeometryMeshGroup;
+    private readonly _styledTreeIndexSets;
+    private _needsRedraw;
     constructor(model: CadModelMetadata, materialManager: CadMaterialManager, sectorRepository: SectorRepository);
+    get needsRedraw(): boolean;
     get nodeTransformProvider(): NodeTransformProvider;
     get nodeAppearanceProvider(): NodeAppearanceProvider;
     get defaultNodeAppearance(): NodeAppearance;
@@ -42,6 +47,7 @@ export declare class CadNode extends Object3D {
      */
     getModelTransformation(out?: Matrix4): Matrix4;
     getCdfToDefaultModelTransformation(out?: Matrix4): Matrix4;
+    setModelRenderLayers(root?: Object3D): void;
     get prioritizedAreas(): PrioritizedArea[];
     batchGeometry(geometryBatchingQueue: ParsedGeometry[], sectorId: number): void;
     removeBatchedSectorGeometries(sectorId: number): void;

package/dist/packages/cad-model/src/wrappers/CogniteCadModel.d.ts

@@ -195,6 +195,11 @@ export declare class CogniteCadModel implements CdfModelNodeCollectionDataProvid
      * @param out Preallocated `THREE.Matrix4` (optional).
      */
     getModelTransformation(out?: THREE.Matrix4): THREE.Matrix4;
+    /**
+     * Sets the clipping planes for this model. They will be combined with the
+     * global clipping planes.
+     */
+    setModelClippingPlanes(clippingPlanes: THREE.Plane[]): void;
     /**
      * Gets transformation from CDF space to ThreeJS space,
      * which includes any additional "default" transformations assigned to this model.
@@ -202,6 +207,18 @@ export declare class CogniteCadModel implements CdfModelNodeCollectionDataProvid
      * @param out Preallocated `THREE.Matrix4` (optional)
      */
     getCdfToDefaultModelTransformation(out?: THREE.Matrix4): THREE.Matrix4;
+    /**
+     * Map point from CDF to model space, taking the model's custom transformation into account
+     * @param point Point to compute transformation from
+     * @param out Optional pre-allocated point
+     */
+    mapPointFromCdfToModelCoordinates(point: THREE.Vector3, out?: THREE.Vector3): THREE.Vector3;
+    /**
+     * Map bounding box from CDF to model space, taking the model's custom transformation into account
+     * @param box Box to compute transformation from
+     * @param out Optional pre-allocated box
+     */
+    mapBoxFromCdfToModelCoordinates(box: THREE.Box3, out?: THREE.Box3): THREE.Box3;
     /**
      * Fetches a bounding box from the CDF by the nodeId.
      * @param nodeId

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

@@ -6,7 +6,7 @@ export { CadModelMetadata } from './src/metadata/CadModelMetadata';
 export { SectorSceneFactory } from './src/utilities/SectorSceneFactory';
 export { CadModelClipper } from './src/metadata/CadModelClipper';
 export { SectorScene } from './src/utilities/types';
-export { SectorMetadata, V9SectorMetadata } from './src/metadata/types';
+export { SectorMetadata } from './src/metadata/types';
 export { SectorNode } from './src/sector/SectorNode';
 export { RootSectorNode } from './src/sector/RootSectorNode';
 export { LevelOfDetail } from './src/cad/LevelOfDetail';

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

@@ -7,9 +7,6 @@ export type CadSceneRootMetadata = {
     readonly sectors: SceneSectorMetadata[];
     readonly unit: string | null;
 };
-export type SceneSectorMetadata = BaseSceneSectorMetadata & (GltfSceneSectorMetadata | I3dF3dSceneSectorMetadata);
-export type V8SceneSectorMetadata = BaseSceneSectorMetadata & I3dF3dSceneSectorMetadata;
-export type V9SceneSectorMetadata = BaseSceneSectorMetadata & GltfSceneSectorMetadata;
 export type BoundingBox = {
     readonly min: {
         x: number;
@@ -22,7 +19,7 @@ export type BoundingBox = {
         z: number;
     };
 };
-export type BaseSceneSectorMetadata = {
+export type SceneSectorMetadata = {
     readonly id: number;
     readonly parentId: number | null;
     readonly path: string;
@@ -31,32 +28,8 @@ export type BaseSceneSectorMetadata = {
     readonly estimatedTriangleCount: number;
     readonly boundingBox: BoundingBox;
     readonly geometryBoundingBox?: BoundingBox;
-};
-export type GltfSceneSectorMetadata = {
     readonly sectorFileName: string | null;
     readonly maxDiagonalLength: number;
     readonly minDiagonalLength: number;
     readonly downloadSize: number;
 };
-export type I3dF3dSceneSectorMetadata = {
-    readonly indexFile: {
-        readonly fileName: string;
-        readonly peripheralFiles: string[];
-        readonly downloadSize: number;
-    };
-    readonly facesFile: {
-        readonly quadSize: number;
-        readonly coverageFactors: {
-            xy: number;
-            yz: number;
-            xz: number;
-        };
-        readonly recursiveCoverageFactors: {
-            xy: number;
-            yz: number;
-            xz: number;
-        } | undefined;
-        readonly fileName: string | null;
-        readonly downloadSize: number;
-    } | null;
-};

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

@@ -2,33 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-export interface SectorMetadataIndexFileSection {
-    readonly fileName: string;
-    readonly peripheralFiles: string[];
-    readonly downloadSize: number;
-}
-export interface SectorMetadataFacesFileSection {
-    readonly quadSize: number;
-    /**
-     * Coverage factors for the sector without children.
-     */
-    readonly coverageFactors: {
-        xy: number;
-        yz: number;
-        xz: number;
-    };
-    /**
-     * Coverage factor for the sectors including children.
-     */
-    readonly recursiveCoverageFactors: {
-        xy: number;
-        yz: number;
-        xz: number;
-    };
-    readonly fileName: string | null;
-    readonly downloadSize: number;
-}
-export type BaseSectorMetadata = {
+export type SectorMetadata = {
     readonly id: number;
     readonly path: string;
     readonly depth: number;
@@ -36,14 +10,6 @@ export type BaseSectorMetadata = {
     readonly children: SectorMetadata[];
     readonly estimatedDrawCallCount: number;
     readonly estimatedRenderCost: number;
-};
-export type SectorMetadata = BaseSectorMetadata & (I3dF3dSectorMetadata | GltfSectorMetadata);
-export type V9SectorMetadata = BaseSectorMetadata & GltfSectorMetadata;
-export type I3dF3dSectorMetadata = {
-    readonly indexFile: SectorMetadataIndexFileSection;
-    readonly facesFile: SectorMetadataFacesFileSection;
-};
-export type GltfSectorMetadata = {
     readonly sectorFileName: string | null;
     readonly maxDiagonalLength: number;
     readonly minDiagonalLength: number;