@cognite/reveal 4.1.2 → 4.2.0-dev.20230329

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

@@ -1,11 +1,11 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-export { Image360 } from './src/Image360';
-export { Image360Collection } from './src/Image360Collection';
+export { Image360 } from './src/entity/Image360';
+export { Image360Collection } from './src/collection/Image360Collection';
 export { Image360Facade } from './src/Image360Facade';
-export { Image360EntityFactory } from './src/Image360EntityFactory';
-export { Image360Entity } from './src/Image360Entity';
-export { Image360Visualization } from './src/Image360Visualization';
+export { Image360CollectionFactory } from './src/collection/Image360CollectionFactory';
+export { Image360Entity } from './src/entity/Image360Entity';
+export { Image360Visualization } from './src/entity/Image360Visualization';
 export { Image360EnteredDelegate, Image360ExitedDelegate } from './src/types';
-export { DefaultImage360Collection } from './src/DefaultImage360Collection';
+export { DefaultImage360Collection } from './src/collection/DefaultImage360Collection';

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

@@ -2,21 +2,24 @@
  * Copyright 2022 Cognite AS
  */
 import * as THREE from 'three';
-import { Image360Entity } from './Image360Entity';
-import { Image360EntityFactory } from './Image360EntityFactory';
+import { Image360Entity } from './entity/Image360Entity';
+import { Image360CollectionFactory } from './collection/Image360CollectionFactory';
+import { DefaultImage360Collection } from './collection/DefaultImage360Collection';
+import { IconCullingScheme } from './icons/IconCollection';
 export declare class Image360Facade<T> {
     private readonly _entityFactory;
-    private readonly _image360Entities;
+    private readonly _image360Collections;
     private readonly _rayCaster;
     private readonly _image360Cache;
+    get collections(): DefaultImage360Collection[];
     set allIconsVisibility(visible: boolean);
     set allHoverIconsVisibility(visible: boolean);
-    constructor(_entityFactory: Image360EntityFactory<T>);
-    create(dataProviderFilter: T, postTransform?: THREE.Matrix4, preComputedRotation?: boolean): Promise<Image360Entity[]>;
+    set allIconCullingScheme(scheme: IconCullingScheme);
+    constructor(_entityFactory: Image360CollectionFactory<T>);
+    create(dataProviderFilter: T, postTransform?: THREE.Matrix4, preComputedRotation?: boolean): Promise<DefaultImage360Collection>;
     delete(entity: Image360Entity): Promise<void>;
-    preload(entity: Image360Entity): Promise<void>;
-    intersect(coords: {
-        x: number;
-        y: number;
-    }, camera: THREE.Camera): Image360Entity | undefined;
+    preload(entity: Image360Entity, lockDownload?: boolean): Promise<void>;
+    getCollectionContainingEntity(entity: Image360Entity): DefaultImage360Collection;
+    intersect(coords: THREE.Vector2, camera: THREE.Camera): Image360Entity | undefined;
+    dispose(): void;
 }

package/dist/packages/360-images/src/cache/Image360LoadingCache.d.ts

@@ -0,0 +1,30 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { Image360Entity } from '../entity/Image360Entity';
+export type DownloadRequest = {
+    entity: Image360Entity;
+    firstCompleted: Promise<void>;
+    fullResolutionCompleted: Promise<void>;
+    abort: () => void;
+};
+export type Loaded360Image = {
+    entity: Image360Entity;
+    isFullResolution: boolean;
+};
+export declare class Image360LoadingCache {
+    private readonly _imageCacheSize;
+    private readonly _downloadCacheSize;
+    private readonly _loaded360Images;
+    private readonly _inProgressDownloads;
+    private _lockedDownload;
+    get cachedEntities(): Image360Entity[];
+    get currentlyLoadingEntities(): DownloadRequest[];
+    getDownloadInProgress(entity: Image360Entity): DownloadRequest | undefined;
+    constructor(_imageCacheSize?: number, _downloadCacheSize?: number);
+    cachedPreload(entity: Image360Entity, lockDownload?: boolean): Promise<void>;
+    purge(entity: Image360Entity): Promise<void>;
+    private addEntityToCache;
+    private abortLastRecentlyReqestedEntity;
+    private createAbortSignal;
+}

package/dist/packages/360-images/src/{DefaultImage360Collection.d.ts → collection/DefaultImage360Collection.d.ts}

@@ -1,11 +1,11 @@
 /*!
  * Copyright 2023 Cognite AS
  */
-import { EventTrigger } from '../../utilities';
-import { Image360 } from './Image360';
+import { EventTrigger } from '../../../utilities';
 import { Image360Collection } from './Image360Collection';
-import { Image360Entity } from './Image360Entity';
-import { Image360EnteredDelegate, Image360ExitedDelegate } from './types';
+import { Image360Entity } from '../entity/Image360Entity';
+import { Image360EnteredDelegate, Image360ExitedDelegate } from '../types';
+import { IconCollection, IconCullingScheme } from '../icons/IconCollection';
 /**
  * Default implementation of {@link Image360Collection}. Used for events when entering
  * and exiting 360 image mode
@@ -16,6 +16,8 @@ export declare class DefaultImage360Collection implements Image360Collection {
      */
     readonly image360Entities: Image360Entity[];
     private readonly _events;
+    private readonly _icons;
+    private _isCollectionVisible;
     /**
      * The events from the image collection.
      */
@@ -23,7 +25,8 @@ export declare class DefaultImage360Collection implements Image360Collection {
         image360Entered: EventTrigger<Image360EnteredDelegate>;
         image360Exited: EventTrigger<Image360ExitedDelegate>;
     };
-    constructor(entities: Image360[]);
+    get isCollectionVisible(): boolean;
+    constructor(entities: Image360Entity[], icons: IconCollection);
     /**
      * Subscribes to events on 360 Image datasets. There are several event types:
      * 'image360Entered' - Subscribes to a event for entering 360 image mode.
@@ -33,6 +36,17 @@ export declare class DefaultImage360Collection implements Image360Collection {
      */
     on(event: 'image360Entered', callback: Image360EnteredDelegate): void;
     on(event: 'image360Exited', callback: Image360ExitedDelegate): void;
+    /**
+     * Specify parameters used to determine the number of icons that are visible when entering 360 Images.
+     * @param radius Only icons within the given radius will be made visible.
+     * @param pointLimit Limit the number of points within the given radius. Points closer to the camera will be prioritized.
+     */
+    set360IconCullingRestrictions(radius: number, pointLimit: number): void;
+    /**
+     * Set visibility of all 360 image icons.
+     * @param visible If true all icons are made visible according to the active culling scheme. If false all icons are hidden.
+     */
+    setIconsVisibility(visible: boolean): void;
     /**
      * Unsubscribes from 360 image dataset event.
      * @param event The event type.
@@ -40,5 +54,8 @@ export declare class DefaultImage360Collection implements Image360Collection {
      */
     off(event: 'image360Entered', callback: Image360EnteredDelegate): void;
     off(event: 'image360Exited', callback: Image360ExitedDelegate): void;
+    setSelectedVisibility(visible: boolean): void;
+    setCullingScheme(scheme: IconCullingScheme): void;
+    remove(entity: Image360Entity): void;
     dispose(): void;
 }

package/dist/packages/360-images/src/{Image360Collection.d.ts → collection/Image360Collection.d.ts}

@@ -1,8 +1,8 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import { Image360 } from './Image360';
-import { Image360EnteredDelegate, Image360ExitedDelegate } from './types';
+import { Image360 } from './../entity/Image360';
+import { Image360EnteredDelegate, Image360ExitedDelegate } from '../types';
 /**
  * A wrapper that represents a set of 360 images.
  */
@@ -11,6 +11,17 @@ export interface Image360Collection {
      * A list containing all the 360 images in this set.
      */
     readonly image360Entities: Image360[];
+    /**
+     * Specify parameters used to determine the number of icons that are visible when entering 360 Images.
+     * @param radius Only icons within the given radius will be made visible.
+     * @param pointLimit Limit the number of points within the given radius. Points closer to the camera will be prioritized.
+     */
+    set360IconCullingRestrictions(radius: number, pointLimit: number): void;
+    /**
+     * Set visibility of all 360 image icons.
+     * @param visible If true all icons are made visible according to the active culling scheme. If false all icons are hidden.
+     */
+    setIconsVisibility(visible: boolean): void;
     /**
      * Subscribes to events on 360 Image datasets. There are several event types:
      * 'image360Entered' - Subscribes to a event for entering 360 image mode.

package/dist/packages/360-images/src/collection/Image360CollectionFactory.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Image360Provider } from '../../../data-providers';
+import { BeforeSceneRenderedDelegate, EventTrigger, SceneHandler } from '../../../utilities';
+import { DefaultImage360Collection } from './DefaultImage360Collection';
+export declare class Image360CollectionFactory<T> {
+    private readonly _image360DataProvider;
+    private readonly _sceneHandler;
+    private readonly _onBeforeSceneRendered;
+    constructor(image360DataProvider: Image360Provider<T>, sceneHandler: SceneHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>);
+    create(dataProviderFilter: T, postTransform: THREE.Matrix4, preMultipliedRotation: boolean): Promise<DefaultImage360Collection>;
+}

package/dist/packages/360-images/src/{Image360Entity.d.ts → entity/Image360Entity.d.ts}

@@ -2,9 +2,9 @@
  * Copyright 2022 Cognite AS
  */
 import * as THREE from 'three';
-import { SceneHandler } from '../../utilities';
-import { Image360Descriptor, Image360FileProvider } from '../../data-providers';
-import { Image360Icon } from './Image360Icon';
+import { SceneHandler } from '../../../utilities';
+import { Image360Descriptor, Image360FileProvider } from '../../../data-providers';
+import { Image360Icon } from '../icons/Image360Icon';
 import { Image360VisualizationBox } from './Image360VisualizationBox';
 import { Image360 } from './Image360';
 export declare class Image360Entity implements Image360 {
@@ -13,6 +13,7 @@ export declare class Image360Entity implements Image360 {
     private readonly _transform;
     private readonly _image360Icon;
     private readonly _image360VisualzationBox;
+    private _getFullResolutionTextures;
     /**
      * Get a copy of the model-to-world transformation matrix
      * of the given 360 image.
@@ -30,11 +31,26 @@ export declare class Image360Entity implements Image360 {
      * @returns Image360Visualization
      */
     get image360Visualization(): Image360VisualizationBox;
-    constructor(image360Metadata: Image360Descriptor, sceneHandler: SceneHandler, imageProvider: Image360FileProvider, postTransform: THREE.Matrix4, preComputedRotation: boolean);
+    constructor(image360Metadata: Image360Descriptor, sceneHandler: SceneHandler, imageProvider: Image360FileProvider, transform: THREE.Matrix4, icon: Image360Icon);
     /**
      * Loads the 360 image (6 faces) into the visualization object.
+     *
+     * This will start the download of both low and full resolution images and return one promise for when the first image set is ready
+     * and one promise for when both downloads are completed. If the low resolution images are completed first the full resolution
+     * download and texture loading will continue in the background, and applyFullResolution can be used to apply full resolution textures
+     * to the image360VisualzationBox at a desired time.
+     *
+     * @returns firstCompleted A promise for when the first set om images has been loaded and applied to the image360VisualzationBox.
+     * @returns fullResolutionCompleted A promise for when full resolution images are done loading.
      */
-    load360Image(): Promise<void>;
+    load360Image(abortSignal?: AbortSignal): {
+        firstCompleted: Promise<void>;
+        fullResolutionCompleted: Promise<void>;
+    };
+    /**
+     * Apply full resolution textures to the image360VisualzationBox. This has no effect if full resolution has already been applied.
+     */
+    applyFullResolution(): Promise<void>;
     /**
      * Drops the GPU resources for the 360 image
      * the icon will be preserved.
@@ -44,5 +60,4 @@ export declare class Image360Entity implements Image360 {
      * @obvious
      */
     dispose(): void;
-    private computeTransform;
 }

package/dist/packages/360-images/src/{Image360VisualizationBox.d.ts → entity/Image360VisualizationBox.d.ts}

@@ -2,8 +2,8 @@
  * Copyright 2022 Cognite AS
  */
 import * as THREE from 'three';
-import { SceneHandler } from '../../utilities';
-import { Image360Face } from '../../data-providers';
+import { SceneHandler } from '../../../utilities';
+import { Image360Face, Image360Texture } from '../../../data-providers';
 import { Image360Visualization } from './Image360Visualization';
 export declare class Image360VisualizationBox implements Image360Visualization {
     private readonly _worldTransform;
@@ -11,6 +11,8 @@ export declare class Image360VisualizationBox implements Image360Visualization {
     private _faceMaterials;
     private readonly _sceneHandler;
     private readonly _visualizationState;
+    private readonly _textureLoader;
+    private readonly _faceMaterialOrder;
     get opacity(): number;
     set opacity(alpha: number);
     get visible(): boolean;
@@ -18,6 +20,7 @@ export declare class Image360VisualizationBox implements Image360Visualization {
     set scale(newScale: THREE.Vector3);
     set renderOrder(newRenderOrder: number);
     constructor(worldTransform: THREE.Matrix4, sceneHandler: SceneHandler);
-    loadImages(faces: Image360Face[]): Promise<void>;
+    loadImages(textures: Image360Texture[]): Promise<void>;
+    loadFaceTextures(faces: Image360Face[]): Promise<Image360Texture[]>;
     unloadImages(): void;
 }

package/dist/packages/360-images/src/icons/IconCollection.d.ts

@@ -0,0 +1,34 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Vector3 } from 'three';
+import { BeforeSceneRenderedDelegate, EventTrigger, SceneHandler } from '../../../utilities';
+import { Image360Icon } from './Image360Icon';
+export type IconCullingScheme = 'clustered' | 'proximity';
+export declare class IconCollection {
+    private readonly MIN_PIXEL_SIZE;
+    private readonly MAX_PIXEL_SIZE;
+    private readonly _sceneHandler;
+    private readonly _hoverIconTexture;
+    private readonly _sharedTexture;
+    private readonly _icons;
+    private readonly _iconsSprite;
+    private readonly _computeClustersEventHandler;
+    private readonly _computeProximityPointsEventHandler;
+    private readonly _onBeforeSceneRenderedEvent;
+    private readonly _iconRadius;
+    private _activeCullingSchemeEventHandeler;
+    private _iconCullingScheme;
+    private _proximityRadius;
+    private _proximityPointLimit;
+    get icons(): Image360Icon[];
+    setCullingScheme(scheme: IconCullingScheme): void;
+    set360IconCullingRestrictions(radius: number, pointLimit: number): void;
+    constructor(points: Vector3[], sceneHandler: SceneHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>);
+    private setIconClustersByLOD;
+    private computeProximityPoints;
+    private initializeImage360Icons;
+    dispose(): void;
+    private createOuterRingsTexture;
+    private createHoverIconTexture;
+}

package/dist/packages/360-images/src/icons/IconOctree.d.ts

@@ -0,0 +1,21 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Node, PointOctant, PointOctree } from 'sparse-octree';
+import { Box3, Matrix4 } from 'three';
+import { Image360Icon } from '../icons/Image360Icon';
+export declare class IconOctree extends PointOctree<Image360Icon> {
+    private readonly _nodeCenters;
+    static getMinimalOctreeBoundsFromIcons(icons: Image360Icon[]): Box3;
+    constructor(icons: Image360Icon[], bounds: Box3, maxLeafSize: number);
+    getNodeIcon(node: Node): Image360Icon | undefined;
+    getLODByScreenArea(areaThreshold: number, projection: Matrix4, minimumLevel?: number): Set<PointOctant<Image360Icon>>;
+    private populateNodeCenters;
+    private filterEmptyLeaves;
+    private hasChildren;
+    private isEmptyLeaf;
+    private hasData;
+    private isPointOctant;
+    private getClosestToAverageIcon;
+    traverseLevelsBottomUp(func: (nodes: Node[]) => void): void;
+}

package/dist/packages/360-images/src/icons/Image360Icon.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { BeforeSceneRenderedDelegate, EventTrigger, SceneHandler } from '../../../utilities';
+import * as THREE from 'three';
+import { Ray, Vector3 } from 'three';
+export declare class Image360Icon {
+    private readonly _hoverSprite;
+    private readonly _position;
+    private readonly _sceneHandler;
+    private readonly _minPixelSize;
+    private readonly _maxPixelSize;
+    private readonly _iconRadius;
+    private readonly _setAdaptiveScale;
+    private readonly _onRenderTrigger;
+    private _adaptiveScale;
+    private _visible;
+    private _culled;
+    constructor(position: THREE.Vector3, hoverIconTexture: THREE.CanvasTexture, sceneHandler: SceneHandler, minPixelSize: number, maxPixelSize: number, iconRadius: number, onRenderTrigger: EventTrigger<BeforeSceneRenderedDelegate>);
+    setVisibility(visible: boolean): void;
+    setCulled(culled: boolean): void;
+    isVisible(): boolean;
+    get position(): Vector3;
+    set hoverSpriteVisible(visible: boolean);
+    intersect(ray: Ray): Vector3 | null;
+    dispose(): void;
+    private setupAdaptiveScaling;
+    private createHoverSprite;
+}

package/dist/packages/360-images/src/icons/InstancedIconSprite.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Color, Group, Texture, Vector3 } from 'three';
+export declare class InstancedIconSprite extends Group {
+    private readonly _geometry;
+    private readonly _frontMaterial;
+    private readonly _backMaterial;
+    private readonly _positionBuffer;
+    private readonly _positionAttribute;
+    constructor(maxNumberOfPoints: number, spriteTexture: Texture, minPixelSize: number, maxPixelSize: number, radius: number, colorTint?: Color);
+    setPoints(points: Vector3[]): void;
+    dispose(): void;
+    private initializePoints;
+    private createIconsMaterial;
+}

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

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2023 Cognite AS
  */
-import { Image360 } from './Image360';
+import { Image360 } from './entity/Image360';
 /**
  * Delegate for 360 image mode entered events.
  */

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

@@ -3,22 +3,22 @@
  */
 import * as THREE from 'three';
 import { CogniteClient } from '@cognite/sdk';
-import { Image360Collection, Image360Entity } from '../../../360-images';
-import { InputHandler, SceneHandler } from '../../../utilities';
+import { Image360Collection, Image360Entity, Image360 } from '../../../360-images';
+import { BeforeSceneRenderedDelegate, EventTrigger, InputHandler, SceneHandler } from '../../../utilities';
 import { ProxyCameraManager } from '../../../camera-manager';
-import { Image360 } from '../../../360-images/src/Image360';
 export declare class Image360ApiHelper {
     private readonly _image360Facade;
     private readonly _domElement;
     private _transitionInProgress;
     private readonly _interactionState;
-    private readonly _domEventHandlers;
+    private readonly _eventHandlers;
+    private readonly _debouncePreLoad;
     private readonly _requestRedraw;
     private readonly _activeCameraManager;
     private readonly _image360Navigation;
+    private readonly _onBeforeSceneRenderedEvent;
     private _cachedCameraManager;
-    private readonly _imageCollection;
-    constructor(cogniteClient: CogniteClient, sceneHandler: SceneHandler, domElement: HTMLElement, activeCameraManager: ProxyCameraManager, inputHandler: InputHandler, requestRedraw: () => void);
+    constructor(cogniteClient: CogniteClient, sceneHandler: SceneHandler, domElement: HTMLElement, activeCameraManager: ProxyCameraManager, inputHandler: InputHandler, requestRedraw: () => void, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>);
     add360ImageSet(eventFilter: {
         [key: string]: string;
     }, collectionTransform: THREE.Matrix4, preMultipliedRotation: boolean): Promise<Image360Collection>;

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

@@ -8,10 +8,9 @@ import { PointCloudBudget, CognitePointCloudModel } from '../../../../pointcloud
 import { AddImage360Options, AddModelOptions, Cognite3DViewerOptions, Intersection, CadModelBudget, ResolutionOptions } from './types';
 import { CogniteModel } from '../types';
 import { ViewerState } from '../../utilities/ViewStateHelper';
-import { CameraManager, CameraChangeDelegate } from '../../../../camera-manager';
+import { CameraManager, CameraChangeDelegate, CameraStopDelegate } from '../../../../camera-manager';
 import { SupportedModelTypes } from '../../../../model-base';
-import { Image360Collection } from '../../../../360-images';
-import { Image360 } from '../../../../360-images/src/Image360';
+import { Image360Collection, Image360 } from '../../../../360-images';
 /**
  * @example
  * ```js
@@ -57,8 +56,10 @@ export declare class Cognite3DViewer {
     private readonly _models;
     private isDisposed;
     private latestRequestId;
-    private readonly clock;
+    private readonly sessionLogger;
+    private readonly cameraManagerClock;
     private _clippingNeedsUpdate;
+    private _forceStopRendering;
     private readonly spinner;
     private get revealManager();
     /**
@@ -137,6 +138,15 @@ export declare class Cognite3DViewer {
      * ```
      */
     on(event: 'cameraChange', callback: CameraChangeDelegate): void;
+    /**
+     * @example
+     * ```js
+     * viewer.on('cameraStop', () => {
+     *   console.log('Camera stopped');
+     * });
+     * ```
+     */
+    on(event: 'cameraStop', callback: CameraStopDelegate): void;
     /**
      * Event that is triggered immediately before the scene is rendered.
      * @param event Metadata about the rendering frame.
@@ -163,6 +173,13 @@ export declare class Cognite3DViewer {
      * ```
      */
     off(event: 'cameraChange', callback: CameraChangeDelegate): void;
+    /**
+     * @example
+     * ```js
+     * viewer.off('cameraStop', onCameraStop);
+     * ```
+     */
+    off(event: 'cameraStop', callback: CameraStopDelegate): void;
     /**
      * Unsubscribe the 'beforeSceneRendered'-event previously subscribed with {@link on}.
      */
@@ -451,7 +468,7 @@ export declare class Cognite3DViewer {
     requestRedraw(): void;
     /**
      * Convert a point in world space to its coordinates in the canvas. This can be used to place HTML objects near 3D objects on top of the 3D viewer.
-     * @see {@link https://www.w3schools.com/graphics/canvas_coordinates.asp https://www.w3schools.com/graphics/canvas_coordinates.asp}.
+     * @see {@link https://www.w3schools.com/graphics/canvas_coordinates.asp} For details on HTML Canvas Coordinates.
      * @param point World space coordinate.
      * @param normalize Optional. If true, coordinates are normalized into [0,1]. If false, the values are in the range [0, <canvas_size>).
      * @returns Returns 2D coordinates if the point is visible on screen, or `null` if object is outside screen.
@@ -491,7 +508,7 @@ export declare class Cognite3DViewer {
      * `html2canvas` is used to draw UI and this has some limitations on what CSS properties it is able to render. See {@link https://html2canvas.hertzen.com/documentation the html2canvas documentation} for details.
      * @param width Width of the final image. Default is current canvas size.
      * @param height Height of the final image. Default is current canvas size.
-     * @param includeUI If false the screenshot will include only the rendered 3D.
+     * @param includeUI If false the screenshot will include only the rendered 3D. Default is true.
      * @returns A {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs Data URL} of the image ('image/png').
      * @example
      * ```js
@@ -513,8 +530,7 @@ export declare class Cognite3DViewer {
      * @param offsetY Y coordinate in pixels (relative to the domElement).
      * @returns A promise that if there was an intersection then return the intersection object - otherwise it
      * returns `null` if there were no intersections.
-     * @see {@link https://en.wikipedia.org/wiki/Ray_casting}.
-     *
+     * @see {@link https://en.wikipedia.org/wiki/Ray_casting} For more details on Ray casting.
      * @example For CAD model
      * ```js
      * const offsetX = 50 // pixels from the left

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

@@ -4,7 +4,7 @@
 import { ConsumedSector, WantedSector } from '../../../cad-parsers';
 export type SectorDownloadData = {
     sector: WantedSector;
-    downloadSector: (sector: WantedSector) => Promise<ConsumedSector>;
+    downloadSector: (sector: WantedSector, abortSignal: AbortSignal) => Promise<ConsumedSector>;
 };
 export declare class SectorDownloadScheduler {
     private readonly _maxConcurrentSectorDownloads;
@@ -15,8 +15,12 @@ export declare class SectorDownloadScheduler {
     get numberOfQueuedDownloads(): number;
     constructor(maxConcurrentSectorDownloads?: number);
     queueSectorBatchForDownload(downloadData: SectorDownloadData[]): Promise<ConsumedSector>[];
+    private createDiscardedConsumedSector;
+    private abortPendingDownload;
+    private removeDownloadFromQueue;
     private getOrAddToQueuedDownloads;
     private addSectorToPendingDownloads;
     private processNextQueuedSectorDownload;
     private getSectorIdentifier;
+    private createAbortSignal;
 }

package/dist/packages/cad-model/src/picking/PickingHandler.d.ts

@@ -16,6 +16,7 @@ type IntersectCadNodesResult = {
 export declare class PickingHandler {
     private readonly _clearColor;
     private readonly _clearAlpha;
+    private readonly _raycaster;
     private readonly _pickPixelColorStorage;
     private readonly _rgbaVector;
     private readonly _unpackFactors;
@@ -25,7 +26,9 @@ export declare class PickingHandler {
     private readonly _mutex;
     constructor(renderer: THREE.WebGLRenderer, materialManager: CadMaterialManager, sceneHandler: SceneHandler);
     intersectCadNodes(cadNodes: CadNode[], input: IntersectInput, async?: boolean): Promise<IntersectCadNodesResult[]>;
-    intersectCadNode(cadNode: CadNode, input: IntersectInput, async: boolean): Promise<IntersectCadNodesResult | undefined>;
+    private filterOutOfBoundCadNodes;
+    private intersectCadNodeDepth;
+    private intersectCadNodeTreeIndex;
     private pickTreeIndex;
     private perspectiveDepthToViewZ;
     private pickDepth;

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

@@ -35,7 +35,7 @@ export declare class CadNode extends Object3D {
     get materialManager(): CadMaterialManager;
     set renderMode(mode: RenderMode);
     get renderMode(): RenderMode;
-    loadSector(sector: WantedSector): Promise<ConsumedSector>;
+    loadSector(sector: WantedSector, abortSignal?: AbortSignal): Promise<ConsumedSector>;
     /**
      * Sets transformation matrix of the model. This overrides the current transformation.
      * @param matrix Transformation matrix.

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

@@ -200,6 +200,10 @@ export declare class CogniteCadModel implements CdfModelNodeCollectionDataProvid
      * global clipping planes.
      */
     setModelClippingPlanes(clippingPlanes: THREE.Plane[]): void;
+    /**
+     * Get the clipping planes for this model.
+     */
+    getModelClippingPlanes(): THREE.Plane[];
     /**
      * Gets transformation from CDF space to ThreeJS space,
      * which includes any additional "default" transformations assigned to this model.

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

@@ -29,6 +29,7 @@ export type SceneSectorMetadata = {
     readonly boundingBox: BoundingBox;
     readonly geometryBoundingBox?: BoundingBox;
     readonly sectorFileName: string | null;
+    readonly texturedFileName: string | null;
     readonly maxDiagonalLength: number;
     readonly minDiagonalLength: number;
     readonly downloadSize: number;

package/dist/packages/camera-manager/src/ComboControls.d.ts

@@ -85,6 +85,7 @@ export declare class ComboControls extends EventDispatcher {
     private readonly _raycaster;
     private readonly _targetFPS;
     private _targetFPSOverActualFPS;
+    private readonly _pointEventCache;
     private _enabled;
     private _options;
     private static readonly DefaultControlsOptions;
@@ -128,6 +129,7 @@ export declare class ComboControls extends EventDispatcher {
     private readonly convertPixelCoordinatesToNormalized;
     private readonly onPointerDown;
     private readonly onMouseDown;
+    private readonly onPointerUp;
     private readonly onMouseUp;
     private readonly onMouseWheel;
     private readonly onTouchStart;

package/dist/packages/camera-manager/src/DefaultCameraManager.d.ts

@@ -114,7 +114,7 @@ export declare class DefaultCameraManager implements CameraManager {
     private calculateNewTargetWithoutModel;
     /**
      * Calculates new camera target based on cursor position.
-     * @param event MouseEvent that contains pointer location data.
+     * @param event PointerEvent that contains pointer location data.
      */
     private calculateNewTarget;
     /**

package/dist/packages/camera-manager/src/StationaryCameraManager.d.ts

@@ -12,7 +12,7 @@ export declare class StationaryCameraManager implements CameraManager {
     private readonly _minFOV;
     private readonly _stopEventTrigger;
     private _isDragging;
-    private _downEventCache;
+    private _pointerEventCache;
     constructor(domElement: HTMLElement, camera: THREE.PerspectiveCamera);
     getCamera(): THREE.PerspectiveCamera;
     get defaultFOV(): number;
@@ -33,9 +33,9 @@ export declare class StationaryCameraManager implements CameraManager {
     private readonly onPointerDown;
     private readonly onPointerMove;
     private rotateCamera;
-    private pinchCamera;
+    private pinchZoomAndRotate;
     private readonly zoomCamera;
     private getCursorRay;
     private getTarget;
-    private calculateDownEventDistance;
+    private calculatePinchZoomDistanceDelta;
 }

package/dist/packages/data-providers/index.d.ts

@@ -18,4 +18,4 @@ export { StylableObject, SerializableStylableObject } from './src/pointcloud-sty
 export { CdfPointCloudStylableObjectProvider } from './src/pointcloud-stylable-object-providers/CdfPointCloudStylableObjectProvider';
 export { DummyPointCloudStylableObjectProvider } from './src/pointcloud-stylable-object-providers/DummyPointCloudStylableObjectProvider';
 export { Image360Provider } from './src/Image360Provider';
-export { BinaryFileProvider, JsonFileProvider, File3dFormat, BlobOutputMetadata, Image360Descriptor, Image360FileProvider, Image360Face } from './src/types';
+export { BinaryFileProvider, JsonFileProvider, File3dFormat, BlobOutputMetadata, Image360Descriptor, Image360FileProvider, Image360Face, Image360Texture } from './src/types';

package/dist/packages/data-providers/src/ModelDataProvider.d.ts

@@ -16,6 +16,7 @@ export interface ModelDataProvider extends JsonFileProvider, BinaryFileProvider
      * Downloads a binary blob.
      * @param baseUrl     Base URL of the model.
      * @param fileName    Filename of binary file.
+     * @param abortSignal Optional abort signal that can be used to cancel an in progress fetch.
      */
-    getBinaryFile(baseUrl: string, fileName: string): Promise<ArrayBuffer>;
+    getBinaryFile(baseUrl: string, fileName: string, abortSignal?: AbortSignal): Promise<ArrayBuffer>;
 }