@cognite/reveal 4.36.0 → 4.38.0

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

@@ -25,3 +25,10 @@ export { DEFAULT_IMAGE_360_OPACITY } from './src/entity/Image360VisualizationBox
 export { Image360Action } from './src/Image360Action';
 export { Image360History } from './src/Image360History';
 export { createCollectionIdString } from './src/collection/createCollectionIdString';
+export type { Image360Provider, Image360ProviderMap } from './src/providers/Image360Provider';
+export { getImage360ProviderFromMap } from './src/providers/Image360Provider';
+export { Image360ProviderCombiner } from './src/providers/Image360ProviderCombiner';
+export { Cdf360ImageAnnotationProvider } from './src/providers/Cdf360ImageAnnotationProvider';
+export { CoreDm360ImageAnnotationProvider } from './src/providers/CoreDm360ImageAnnotationProvider';
+export { Local360ImageProvider } from './src/providers/Local360ImageProvider';
+export { getAnnotationIdKey } from './src/providers/annotations';

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

@@ -7,10 +7,10 @@ import { Overlay3DIcon } from '../../../3d-overlays';
 import { Image360AnnotationAppearance } from '../annotation/types';
 import { ClusterScreenInfo } from '../icons/clustering';
 import { HtmlClusterCollection } from '../icons/clustering/HtmlClusterCoordinator';
-import { ClassicDataSourceType, DataSourceType, DMDataSourceType, Image360FileDescriptor, Image360Provider } from '../../../data-providers';
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType, Image360FileDescriptor, InstanceReference } from '../../../data-providers';
+import { Image360Provider } from '../providers/Image360Provider';
 import { Image360AnnotationFilter } from '../annotation/Image360AnnotationFilter';
 import { Matrix4, Ray } from 'three';
-import { InstanceReference } from '../../../data-providers/src/types';
 /**
  * Default implementation of {@link Image360Collection}. Used for events when entering
  * and exiting 360 image mode

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

@@ -4,7 +4,7 @@ import { DefaultImage360Collection } from './DefaultImage360Collection';
 import { IconsOptions } from '../icons/IconCollection';
 import { Matrix4 } from 'three';
 import { Image360AnnotationFilterOptions } from '../annotation/types';
-import { Image360ProviderMap } from '../../../data-providers/src/Image360Provider';
+import { Image360ProviderMap } from '../providers/Image360Provider';
 export declare class Image360CollectionFactory {
     private readonly _image360ProviderMap;
     private readonly _sceneHandler;

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

@@ -1,5 +1,6 @@
 import { DeviceDescriptor, SceneHandler } from '../../../utilities';
-import { DataSourceType, Image360Provider } from '../../../data-providers';
+import { DataSourceType } from '../../../data-providers';
+import { Image360Provider } from '../providers/Image360Provider';
 import { Image360 } from './Image360';
 import { Historical360ImageSet, Image360RevisionId } from '../../../data-providers/src/types';
 import { Image360RevisionEntity } from './Image360RevisionEntity';

package/dist/packages/360-images/src/entity/Image360RevisionEntity.d.ts

@@ -1,4 +1,5 @@
-import { Image360Descriptor, Image360RevisionId, DataSourceType, Image360Provider } from '../../../data-providers';
+import { Image360Descriptor, Image360RevisionId, DataSourceType } from '../../../data-providers';
+import { Image360Provider } from '../providers/Image360Provider';
 import { Image360Revision } from './Image360Revision';
 import { Image360VisualizationBox } from './Image360VisualizationBox';
 import { JpegType } from '../utils/JpegDataStreamParser';

package/dist/packages/{data-providers/src/image-360-data-providers → 360-images/src/providers}/Cdf360ImageAnnotationProvider.d.ts

@@ -1,8 +1,10 @@
 import { AnnotationModel } from '@cognite/sdk';
-import { FaceName, Image360AnnotationFilterDelegate, Image360AnnotationProvider, Image360AnnotationSpecifier, Image360FileDescriptor, InstanceReference } from '../types';
-import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from '../DataSourceType';
-import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, DefaultImage360Collection, Image360AnnotationAssetQueryResult, Image360Entity, Image360RevisionEntity } from '../../../360-images';
-import { Cdf360ImageAnnotationCache } from './Cdf360ImageAnnotationCache';
+import { FaceName, Image360FileDescriptor, InstanceReference, ClassicDataSourceType, DataSourceType, DMDataSourceType, Cdf360ImageAnnotationCache } from '../../../data-providers';
+import { Image360AnnotationFilterDelegate, Image360AnnotationProvider, Image360AnnotationSpecifier } from './Image360AnnotationProvider';
+import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, Image360AnnotationAssetQueryResult } from '../collection/Image360Collection';
+import { DefaultImage360Collection } from '../collection/DefaultImage360Collection';
+import { Image360Entity } from '../entity/Image360Entity';
+import { Image360RevisionEntity } from '../entity/Image360RevisionEntity';
 export type RevisionFaceRelation = {
     entity: Image360Entity<ClassicDataSourceType>;
     revision: Image360RevisionEntity<ClassicDataSourceType>;

package/dist/packages/{data-providers/src/image-360-data-providers → 360-images/src/providers}/CoreDm360ImageAnnotationProvider.d.ts

@@ -1,6 +1,7 @@
-import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from '../DataSourceType';
-import { Image360AnnotationFilterDelegate, Image360AnnotationProvider, Image360AnnotationSpecifier, InstanceReference } from '../types';
-import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, DefaultImage360Collection, Image360AnnotationAssetQueryResult } from '../../../360-images';
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType, InstanceReference } from '../../../data-providers';
+import { Image360AnnotationFilterDelegate, Image360AnnotationProvider, Image360AnnotationSpecifier } from './Image360AnnotationProvider';
+import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, Image360AnnotationAssetQueryResult } from '../collection/Image360Collection';
+import { DefaultImage360Collection } from '../collection/DefaultImage360Collection';
 import { CogniteClient } from '@cognite/sdk';
 export declare class CoreDm360ImageAnnotationProvider implements Image360AnnotationProvider<DMDataSourceType> {
     private readonly _client;

package/dist/packages/360-images/src/providers/Image360AnnotationProvider.d.ts

@@ -0,0 +1,24 @@
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType, Image360RevisionId, Image360FileDescriptor } from '../../../data-providers';
+import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, Image360AnnotationAssetQueryResult } from '../collection/Image360Collection';
+import { DefaultImage360Collection } from '../collection/DefaultImage360Collection';
+import { Image360AnnotationInstanceReference } from '../annotation/types';
+export type Image360AnnotationFilterDelegate<T extends DataSourceType> = (annotation: T['image360AnnotationType']) => boolean;
+export type Image360AnnotationSpecifier<T extends DataSourceType> = {
+    revisionId: Image360RevisionId<T>;
+    fileDescriptors: Image360FileDescriptor[];
+};
+export interface Image360AnnotationProvider<T extends DataSourceType> {
+    getRelevant360ImageAnnotations(annotationSpecifier: Image360AnnotationSpecifier<T>): Promise<T['image360AnnotationType'][]>;
+    /**
+     * Resolves the mapping from internal file IDs (annotatedResourceId) to external IDs.
+     * This is needed to match annotations to face descriptors when descriptors use externalId.
+     * Optional - if not implemented, the caller should build mapping from descriptors only.
+     */
+    resolveFileIdToExternalIdMapping?(annotations: T['image360AnnotationType'][], descriptors: Image360FileDescriptor[]): Promise<Map<number, string>>;
+    findImageAnnotationsForInstance(instanceFilter: Image360AnnotationInstanceReference<T>, collection: DefaultImage360Collection<T>): Promise<Image360AnnotationAssetQueryResult<T>[]>;
+    getAllImage360AnnotationInfos(source: 'assets', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<ClassicDataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'hybrid', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetHybridAnnotationImage360Info[]>;
+    getAllImage360AnnotationInfos(source: 'cdm', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<DMDataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'all', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<DataSourceType>[]>;
+    getAllImage360AnnotationInfos(source: 'assets' | 'hybrid' | 'cdm' | 'all', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<ClassicDataSourceType>[] | AssetAnnotationImage360Info<DMDataSourceType>[] | AssetAnnotationImage360Info<DataSourceType>[] | AssetHybridAnnotationImage360Info[]>;
+}

package/dist/packages/{data-providers/src → 360-images/src/providers}/Image360Provider.d.ts

@@ -1,6 +1,6 @@
-import { Image360CollectionSourceType } from '../../360-images';
-import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from './DataSourceType';
-import { Image360DescriptorProvider, Image360FileProvider, Image360AnnotationProvider } from './types';
+import { Image360CollectionSourceType } from '../types';
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType, Image360DescriptorProvider, Image360FileProvider } from '../../../data-providers';
+import { Image360AnnotationProvider } from './Image360AnnotationProvider';
 export type Image360ProviderMap = Map<Image360CollectionSourceType, Image360Provider<DMDataSourceType> | Image360Provider<ClassicDataSourceType>>;
 export declare function getImage360ProviderFromMap<T extends DataSourceType>(identifier: T['image360Identifier'], providerMap: Image360ProviderMap): Image360Provider<T>;
 export interface Image360Provider<T extends DataSourceType> extends Image360DescriptorProvider<T>, Image360FileProvider, Image360AnnotationProvider<T> {

package/dist/packages/{data-providers/src → 360-images/src/providers}/Image360ProviderCombiner.d.ts

@@ -1,8 +1,9 @@
 import { Image360Provider } from './Image360Provider';
-import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from './DataSourceType';
-import { Historical360ImageSet, Image360AnnotationFilterDelegate, Image360AnnotationProvider, Image360AnnotationSpecifier, Image360DescriptorProvider, Image360Face, Image360FileDescriptor, Image360FileProvider } from './types';
-import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, DefaultImage360Collection, Image360AnnotationAssetQueryResult } from '../../360-images';
-import { Image360AnnotationInstanceReference } from '../../360-images/src/annotation/types';
+import { ClassicDataSourceType, DataSourceType, DMDataSourceType, Historical360ImageSet, Image360DescriptorProvider, Image360Face, Image360FileDescriptor, Image360FileProvider } from '../../../data-providers';
+import { Image360AnnotationFilterDelegate, Image360AnnotationProvider, Image360AnnotationSpecifier } from './Image360AnnotationProvider';
+import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, Image360AnnotationAssetQueryResult } from '../collection/Image360Collection';
+import { DefaultImage360Collection } from '../collection/DefaultImage360Collection';
+import { Image360AnnotationInstanceReference } from '../annotation/types';
 export declare class Image360ProviderCombiner<T extends DataSourceType> implements Image360Provider<T> {
     private readonly _descriptorProvider;
     private readonly _fileProvider;

package/dist/packages/{data-providers/src/image-360-data-providers → 360-images/src/providers}/Local360ImageProvider.d.ts

@@ -1,8 +1,9 @@
-import { Image360Provider } from '../Image360Provider';
-import { Historical360ImageSet, Image360AnnotationFilterDelegate, Image360AnnotationSpecifier, Image360Face, Image360FileDescriptor, InstanceReference } from '../types';
+import { Image360Provider } from './Image360Provider';
+import { Historical360ImageSet, Image360Face, Image360FileDescriptor, InstanceReference, ClassicDataSourceType, DataSourceType, DMDataSourceType } from '../../../data-providers';
+import { Image360AnnotationFilterDelegate, Image360AnnotationSpecifier } from './Image360AnnotationProvider';
 import { CogniteInternalId, IdEither } from '@cognite/sdk';
-import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from '../DataSourceType';
-import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, DefaultImage360Collection, Image360AnnotationAssetQueryResult } from '../../../360-images';
+import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, Image360AnnotationAssetQueryResult } from '../collection/Image360Collection';
+import { DefaultImage360Collection } from '../collection/DefaultImage360Collection';
 export declare class Local360ImageProvider implements Image360Provider<ClassicDataSourceType> {
     private readonly _modelUrl;
     constructor(modelUrl: string);

package/dist/packages/{data-providers/src/image-360-data-providers → 360-images/src/providers}/annotations.d.ts

@@ -1,2 +1,2 @@
-import { DataSourceType } from '../DataSourceType';
+import { DataSourceType } from '../../../data-providers';
 export declare function getAnnotationIdKey(annotation: DataSourceType['image360AnnotationType']): string;

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

@@ -26,6 +26,7 @@ export declare class Image360ApiHelper<DataSourceT extends DataSourceType> {
     private readonly onBeforeRender;
     private readonly onKeyPressed;
     readonly onHover: (event: PointerEvent) => void;
+    readonly onPointerLeave: () => void;
     readonly onClick: (event: PointerEventData) => Promise<boolean>;
     private readonly updateHoverStateOnRenderHandler;
     constructor(cogniteClient: CogniteClient, sceneHandler: SceneHandler, domElement: HTMLElement, activeCameraManager: ProxyCameraManager, inputHandler: InputHandler, onBeforeSceneRendered: EventTrigger<BeforeSceneRenderedDelegate>, hasEventListeners?: boolean, iconsOptions?: IconsOptions);
@@ -77,6 +78,7 @@ export declare class Image360ApiHelper<DataSourceT extends DataSourceType> {
      */
     findBestNext360ImageEntity(clickedWorldPosition: Vector3): Image360WithCollection<DataSourceT> | undefined;
     private setHoverIconOnIntersect;
+    clearHoverIntersection(): void;
     private exit360ImageByTween;
     private getImageOpacity;
 }

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

@@ -38,12 +38,15 @@ export declare class RevealManager {
     setOutputRenderTarget(target: WebGLRenderTarget | null, autoSizeRenderTarget?: boolean): void;
     get materialManager(): CadMaterialManager;
     get needsRedraw(): boolean;
+    get cameraInMotion(): boolean;
     update(camera: PerspectiveCamera): void;
     get cadBudget(): CadModelBudget;
     set cadBudget(budget: CadModelBudget);
     get cadLoadedStatistics(): CadModelSectorLoadStatistics;
     get cadRenderMode(): RenderMode;
     set cadRenderMode(renderMode: RenderMode);
+    get shadowsEnabled(): boolean;
+    set shadowsEnabled(enabled: boolean);
     get pointCloudBudget(): PointCloudBudget;
     set pointCloudBudget(budget: PointCloudBudget);
     set clippingPlanes(clippingPlanes: Plane[]);

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

@@ -11,6 +11,7 @@ export type RevealOptions = {
     logMetrics?: boolean;
     renderOptions?: RenderOptions;
     continuousModelStreaming?: boolean;
+    enableShadows?: boolean;
     outputRenderTarget?: {
         target: WebGLRenderTarget;
         autoSize?: boolean;

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

@@ -24,6 +24,8 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
     private readonly _domElementResizeObserver;
     private readonly _image360ApiHelper;
     private readonly _unsubsribeOnLoading;
+    private _onContextLost;
+    private _onContextRestored;
     /**
      * Returns the rendering canvas, the DOM element where the renderer draws its output.
      */
@@ -83,6 +85,19 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      * budget is shared between all added CAD models and not a per-model budget.
      */
     set cadBudget(budget: CadModelBudget);
+    /**
+     * Gets whether CAD shadows are currently enabled.
+     * @beta
+     */
+    get shadowsEnabled(): boolean;
+    /**
+     * Enables or disables CAD shadows at runtime, along with the world-space sun shading
+     * that matches them. Turning shadows on changes the CAD look even where no shadow is
+     * cast, including ghosted nodes. The GPU resources are allocated the first time shadows
+     * are enabled.
+     * @beta
+     */
+    set shadowsEnabled(enabled: boolean);
     /**
      * Returns the point cloud budget. The budget is shared between all loaded
      * point cloud models.
@@ -98,6 +113,12 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      */
     get models(): CogniteModel<DataSourceT>[];
     constructor(options: Cognite3DViewerOptions);
+    /**
+     * Listens for render context loss/restore. On loss, prevents the default (so the
+     * browser attempts recovery) and sets `isRenderContextLost()`; on restore, clears
+     * the flag and requests a redraw.
+     */
+    private registerContextLossHandlers;
     /**
      * Get resolution options that are set on the viewer. This includes
      * settings for max resolution and limiting resolution when moving the camera.
@@ -677,6 +698,7 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
      * @param options
      * @param options.stopOnHitting360Icon
      * @param options.predicate Check whether a CustomObject should be intersected.
+     * @param options.forceWindowedPick Skip point-cloud full-frame pick caching for this call.
      * @returns A promise that if there was an intersection then return the intersection object - otherwise it
      * returns `null` if there were no intersections.
      * @beta
@@ -684,6 +706,7 @@ export declare class Cognite3DViewer<DataSourceT extends DataSourceType = Classi
     getAnyIntersectionFromPixel(pixelCoords: Vector2, options?: {
         stopOnHitting360Icon?: boolean;
         predicate?: (customObject: ICustomObject) => boolean;
+        forceWindowedPick?: boolean;
     }): Promise<AnyIntersection<DataSourceT> | undefined>;
     /**
      * Event function to click on 360 images.

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

@@ -1,4 +1,4 @@
-import { SsaoParameters, AntiAliasingMode } from '../../../../rendering';
+import { EdlOptions, SsaoParameters, AntiAliasingMode } from '../../../../rendering';
 import { DeviceDescriptor } from '../../../../utilities';
 import { PropType } from '../../utilities/reflection';
 import { Cognite3DViewerOptions } from './types';
@@ -30,4 +30,9 @@ export declare function determineSsaoRenderParameters(qualityHint: SsaoQualityHi
  * @param devicePixelRatio Device pixel ratio set on the renderer.
  */
 export declare function determineResolutionCap(rendererResolutionThreshold: number | undefined, device: DeviceDescriptor, devicePixelRatio: number): number;
+/**
+ * Create EDL options from input options. The radius is clamped to the maximum supported radius.
+ * @param inputOptions
+ */
+export declare function createCompleteEdlOptions(inputOptions?: Partial<EdlOptions> | 'disabled'): EdlOptions;
 export {};

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

@@ -147,6 +147,15 @@ export interface Cognite3DViewerOptions {
      * Enables / disables visualizing the edges of geometry. Defaults to true.
      */
     enableEdges?: boolean;
+    /**
+     * Enables shadows cast by CAD geometry, and the world-space sun shading that goes with
+     * them. Turning shadows on changes the CAD look even where no shadow is cast, including
+     * ghosted nodes. Defaults to false. Can also be toggled at runtime through
+     * {@link Cognite3DViewer.shadowsEnabled}.
+     * GPU resources for shadows are only allocated the first time they are enabled.
+     * @beta
+     */
+    enableShadows?: boolean;
     /** Callback to download stream progress. */
     onLoading?: OnLoadingCallback;
     /**

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

@@ -7,7 +7,7 @@ import { CognitePointCloudModel } from '../../../pointclouds';
  */
 export type CogniteModel<T extends DataSourceType = ClassicDataSourceType> = CogniteCadModel | CognitePointCloudModel<T>;
 export { WellKnownAsprsPointClassCodes } from '../../../pointclouds';
-export { PointShape, PointColorType, PointSizeType } from '../../../rendering';
+export { PointShape, PointColorType, PointSizeType, CadShadowReceiverForCustomObjectMaterial } from '../../../rendering';
 /**
  * A tuple of a 360 image and its collection.
  */

package/dist/packages/cad-model/src/types.d.ts

@@ -1,25 +1,11 @@
-import { Box3 } from 'three';
+/*!
+ * Copyright 2022 Cognite AS
+ */
+export type { GeometryFilter } from '../../data-providers';
 /**
  * Units supported by {@link CogniteCadModel}.
  */
 export type WellKnownUnit = 'Meters' | 'Centimeters' | 'Millimeters' | 'Micrometers' | 'Kilometers' | 'Feet' | 'Inches' | 'Yards' | 'Miles' | 'Mils' | 'Microinches';
-export type GeometryFilter = {
-    /**
-     * The bounds to load geometry within. By default this box is in CDF coordinate space which
-     * will be transformed into coordinates relative to the model using the the model transformation
-     * which can be specified using {@link https://docs.cognite.com/api/v1/#operation/update3DRevisions |the CDF API},
-     * or set in {@link https://fusion.cognite.com/ |Cognite Fusion}.
-     * @see {@link GeometryFilter.isBoundingBoxInModelCoordinates}.
-     */
-    boundingBox?: Box3;
-    /**
-     * When set, the geometry filter `boundingBox` will be considered to be in "Reveal/ThreeJS space".
-     * Rather than CDF space which is the default. When using Reveal space, the model transformation
-     * which can be specified using {@link https://docs.cognite.com/api/v1/#operation/update3DRevisions |the CDF API},
-     * or set in {@link https://fusion.cognite.com/ |Cognite Fusion}.
-     */
-    isBoundingBoxInModelCoordinates?: boolean;
-};
 export type CadModelSectorLoadStatistics = {
     /**
      * Estimated number of bytes to download sectors.

package/dist/packages/camera-manager/src/Flexible/FlexibleCameraManager.d.ts

@@ -2,12 +2,11 @@ import { PerspectiveCamera, Scene, Box3, Vector3 } from 'three';
 import { FlexibleControls } from './FlexibleControls';
 import { FlexibleControlsOptions } from './FlexibleControlsOptions';
 import { PointerEvents } from '../../../utilities';
-import { CameraEventDelegate, CameraManagerCallbackData, CameraManagerEventType, CameraState } from './../types';
+import { CameraEventDelegate, CameraManagerEventType, CameraState, RaycastCallback } from './../types';
 import { CameraManager } from './../CameraManager';
 import { FlexibleControlsType } from './FlexibleControlsType';
 import { FlexibleControlsTypeChangeDelegate, IFlexibleCameraManager } from './IFlexibleCameraManager';
 import { FlexibleCameraEventTarget } from './FlexibleCameraEventTarget';
-type RaycastCallback = (x: number, y: number, pickBoundingBox: boolean) => Promise<CameraManagerCallbackData>;
 /**
  * Flexible implementation of {@link CameraManager}. The user can switch between Orbit, FirstPersion or OrbitInCenter
  * Supports automatic update of camera near and far planes and animated change of camera position and target.
@@ -79,4 +78,3 @@ export declare class FlexibleCameraManager extends PointerEvents implements IFle
     private updateControlsSensitivity;
     static as(manager: CameraManager): FlexibleCameraManager | undefined;
 }
-export {};

package/dist/packages/camera-manager/src/Flexible/GetPickedPointByPixelCoordinates.d.ts

@@ -1,2 +1,2 @@
 import { Vector2, Vector3 } from 'three';
-export type GetPickedPointByPixelCoordinates = (position: Vector2) => Promise<Vector3>;
+export type GetPickedPointByPixelCoordinates = (position: Vector2, forceWindowedPick?: boolean) => Promise<Vector3>;

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

@@ -54,6 +54,11 @@ export type CameraManagerCallbackData = {
      */
     pickedBoundingBox: Box3 | undefined;
 };
+/**
+ * Callback used by camera managers to request a raycast/pick against the scene.
+ * @beta
+ */
+export type RaycastCallback = (x: number, y: number, pickBoundingBox: boolean, forceWindowedPick?: boolean) => Promise<CameraManagerCallbackData>;
 /**
  * List of supported event types (adapted from https://stackoverflow.com/questions/44480644/string-union-to-string-array)
  */

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

@@ -5,26 +5,26 @@ export { CdfModelDataProvider } from './src/model-data-providers/CdfModelDataPro
 export { CachedModelDataProvider } from './src/model-data-providers/CachedModelDataProvider';
 export { CdfModelIdentifier } from './src/model-identifiers/CdfModelIdentifier';
 export { CdfModelMetadataProvider } from './src/metadata-providers/CdfModelMetadataProvider';
-export { getAnnotationIdKey } from './src/image-360-data-providers/annotations';
-export { Cdf360ImageAnnotationProvider } from './src/image-360-data-providers/Cdf360ImageAnnotationProvider';
 export { type Cdf360ImageAnnotationCache, createCdf360ImageAnnotationCache } from './src/image-360-data-providers/Cdf360ImageAnnotationCache';
 export { Cdf360EventDescriptorProvider } from './src/image-360-data-providers/descriptor-providers/events/Cdf360EventDescriptorProvider';
-export { CoreDm360ImageAnnotationProvider } from './src/image-360-data-providers/CoreDm360ImageAnnotationProvider';
 export { Cdf360CdmDescriptorProvider } from './src/image-360-data-providers/descriptor-providers/datamodels/cdm/Cdf360CdmDescriptorProvider';
 export { Cdf360ImageFileProvider } from './src/image-360-data-providers/Cdf360ImageFileProvider';
 export type { Image360DataModelIdentifier, Image360CoreDataModelIdentifier, Image360LegacyDataModelIdentifier, Image360BaseIdentifier } from './src/image-360-data-providers/descriptor-providers/datamodels/system-space/Cdf360DataModelsDescriptorProvider';
 export { Cdf360DataModelsDescriptorProvider } from './src/image-360-data-providers/descriptor-providers/datamodels/system-space/Cdf360DataModelsDescriptorProvider';
-export { isClassic360Identifier, isCoreDmImage360Identifier, isLegacyDM360Identifier, isFdm360ImageCollectionIdentifier, isClassicMetadata360Identifier } from './src/image-360-data-providers/shared';
+export { isClassic360Identifier, isCoreDmImage360Identifier, isLegacyDM360Identifier, isFdm360ImageCollectionIdentifier, isClassicMetadata360Identifier, isSameImage360RevisionId } from './src/image-360-data-providers/shared';
+export { fetchCoreDm360AnnotationsForRevision } from './src/image-360-data-providers/cdm/fetchCoreDm360AnnotationsForRevision';
+export { fetchAnnotationsForInstance, type Image360AnnotationsForInstanceResult } from './src/image-360-data-providers/cdm/fetchAnnotationsForInstance';
+export { fetchCoreDm360AnnotationsForCollection } from './src/image-360-data-providers/cdm/fetchCoreDm360AnnotationsForCollection';
 export type { CoreDmImage360Annotation } from './src/image-360-data-providers/cdm/types';
 export { LocalModelDataProvider } from './src/model-data-providers/LocalModelDataProvider';
 export { LocalModelIdentifier } from './src/model-identifiers/LocalModelIdentifier';
 export { DMModelIdentifier } from './src/model-identifiers/DMModelIdentifier';
 export { LocalModelMetadataProvider } from './src/metadata-providers/LocalModelMetadataProvider';
-export { Local360ImageProvider } from './src/image-360-data-providers/Local360ImageProvider';
 export type { ModelIdentifier } from './src/ModelIdentifier';
 export { createModelIdentifier } from './src/ModelIdentifier';
 export type { ModelMetadataProvider } from './src/ModelMetadataProvider';
 export type { ModelDataProvider } from './src/ModelDataProvider';
+export type { GeometryFilter } from './src/GeometryFilter';
 export type { PointCloudObjectMetadata, PointCloudObject } from './src/pointcloud-stylable-object-providers/types';
 export type { PointCloudStylableObjectProvider } from './src/PointCloudStylableObjectProvider';
 export type { StylableObject, SerializableStylableObject } from './src/pointcloud-stylable-object-providers/StylableObject';
@@ -32,16 +32,16 @@ export { CdfPointCloudStylableObjectProvider } from './src/pointcloud-stylable-o
 export { DummyPointCloudStylableObjectProvider } from './src/pointcloud-stylable-object-providers/DummyPointCloudStylableObjectProvider';
 export { CdfPointCloudDMStylableObjectProvider } from './src/pointcloud-stylable-object-providers/pointcloud-volume-data-providers/CdfPointCloudDMStylableObjectProvider';
 export { DummyPointCloudDMStylableObjectProvider } from './src/pointcloud-stylable-object-providers/pointcloud-volume-data-providers/DummyPointCloudDMStylableObjectProvider';
-export type { Image360Provider, Image360ProviderMap } from './src/Image360Provider';
-export { getImage360ProviderFromMap } from './src/Image360Provider';
-export { Image360ProviderCombiner } from './src/Image360ProviderCombiner';
-export type { BinaryFileProvider, JsonFileProvider, SignedFileProvider, BlobOutputMetadata, Image360Descriptor, Image360FileProvider, Image360Face, Image360Texture, Image360FileDescriptor, ImageAssetLinkAnnotationInfo, ImageInstanceLinkAnnotationInfo, InstanceReference, Image360Id, Image360RevisionId, SignedFileItem } from './src/types';
+export type { BinaryFileProvider, JsonFileProvider, SignedFileProvider, BlobOutputMetadata, Image360Descriptor, Image360DescriptorProvider, Image360FileProvider, Image360Face, Image360Texture, Image360FileDescriptor, ImageAssetLinkAnnotationInfo, ImageInstanceLinkAnnotationInfo, InstanceReference, Image360Id, Image360RevisionId, Historical360ImageSet, FaceName, SignedFileItem } from './src/types';
 export { File3dFormat } from './src/types';
 export { fetchDMModelIdFromRevisionId } from './src/requests/fetchDMModelIdFromRevisionId';
 export { isDMPointCloudVolumeObject, isClassicPointCloudVolumeObject, isDMPointCloudVolume, isClassicPointCloudVolume } from './src/utilities/utils';
 export { getExternalIdFromDescriptor } from './src/utilities/getExternalIdFromDescriptor';
+export { getInstanceKey } from './src/utilities/instanceIds';
 export type { DataSourceType, ClassicDataSourceType, DMDataSourceType, ClassicModelIdentifierType, DMModelIdentifierType, InternalDataSourceType, LocalDataSourceType, LocalModelIdentifierType, GenericDataSourceType } from './src/DataSourceType';
-export { isClassicIdentifier, isDMIdentifier, isLocalIdentifier } from './src/DataSourceType';
+export { isClassicIdentifier, isDMIdentifier, isLocalIdentifier, isSameDMIdentifier } from './src/DataSourceType';
 export type { LocalAddModelOptions, CommonModelOptions, InternalAddModelOptions, AddModelOptionsWithModelRevisionId } from './src/utilities/internalAddModelOptions';
 export type { MetadataWithSignedFiles } from './src/metadata-providers/types';
 export { SignedUrlRefresher, type FetchWithRefreshOptions } from './src/utilities/SignedUrlRefresh';
+export { PointCloudObjectCollection, PointCloudAnnotationVolumeCollection } from './src/point-cloud-collections/PointCloudObjectCollection';
+export { PointCloudDMVolumeCollection } from './src/point-cloud-collections/PointCloudDMVolumeCollection';

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

@@ -1,6 +1,7 @@
 import { AnnotationModel, AnnotationsAssetRef } from '@cognite/sdk';
 import { Image360DataModelIdentifier } from './image-360-data-providers/descriptor-providers/datamodels/system-space/Cdf360DataModelsDescriptorProvider';
-import { PointCloudAnnotationVolumeCollection, PointCloudDMVolumeCollection } from '../../pointcloud-styling';
+import { PointCloudAnnotationVolumeCollection } from './point-cloud-collections/PointCloudObjectCollection';
+import { PointCloudDMVolumeCollection } from './point-cloud-collections/PointCloudDMVolumeCollection';
 import { CoreDmImage360Annotation } from './image-360-data-providers/cdm/types';
 import { DMInstanceRef } from '../../utilities';
 /**

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

@@ -0,0 +1,18 @@
+import { Box3 } from 'three';
+export type GeometryFilter = {
+    /**
+     * The bounds to load geometry within. By default this box is in CDF coordinate space which
+     * will be transformed into coordinates relative to the model using the the model transformation
+     * which can be specified using {@link https://docs.cognite.com/api/v1/#operation/update3DRevisions |the CDF API},
+     * or set in {@link https://fusion.cognite.com/ |Cognite Fusion}.
+     * @see {@link GeometryFilter.isBoundingBoxInModelCoordinates}.
+     */
+    boundingBox?: Box3;
+    /**
+     * When set, the geometry filter `boundingBox` will be considered to be in "Reveal/ThreeJS space".
+     * Rather than CDF space which is the default. When using Reveal space, the model transformation
+     * which can be specified using {@link https://docs.cognite.com/api/v1/#operation/update3DRevisions |the CDF API},
+     * or set in {@link https://fusion.cognite.com/ |Cognite Fusion}.
+     */
+    isBoundingBoxInModelCoordinates?: boolean;
+};

package/dist/packages/{pointcloud-styling/src → data-providers/src/point-cloud-collections}/PointCloudDMVolumeCollection.d.ts

@@ -1,4 +1,4 @@
-import { DMInstanceRef } from '../../utilities';
+import { DMInstanceRef } from '../../../utilities';
 /**
  * A simple PointCloudDMVolumeCollection that consists of an explicitly provided list of data model instance.
  */

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

@@ -1,10 +1,8 @@
 import { AnnotationModel, AnnotationsTypesImagesAssetLink, AnnotationsTypesImagesInstanceLink, IdEither } from '@cognite/sdk';
 import { Matrix4, Texture } from 'three';
 import { ClassicDataSourceType, DataSourceType, DMDataSourceType } from './DataSourceType';
-import { AssetAnnotationImage360Info, AssetHybridAnnotationImage360Info, DefaultImage360Collection, Image360AnnotationAssetQueryResult, Image360AnnotationInstanceReference } from '../../360-images';
 import { DMInstanceRef } from '../../utilities';
 import { ModelIdentifier } from './ModelIdentifier';
-export type Image360AnnotationFilterDelegate<T extends DataSourceType> = (annotation: T['image360AnnotationType']) => boolean;
 export interface JsonFileProvider {
     /**
      * Download and parse a JSON file and return the resulting struct.
@@ -48,29 +46,10 @@ export type Image360Id<T extends DataSourceType> = Image360RevisionId<T>;
  * An ID identifiying a single Image360 revision within a collection
  */
 export type Image360RevisionId<T extends DataSourceType> = T extends DMDataSourceType ? DMInstanceRef : string;
-export type Image360AnnotationSpecifier<T extends DataSourceType> = {
-    revisionId: Image360RevisionId<T>;
-    fileDescriptors: Image360FileDescriptor[];
-};
 /**
  * Filter for finding linked annotations in either a classic 360 collection or a new one
  */
 export type InstanceReference<T extends DataSourceType> = T extends ClassicDataSourceType ? IdEither : DMInstanceRef;
-export interface Image360AnnotationProvider<T extends DataSourceType> {
-    getRelevant360ImageAnnotations(annotationSpecifier: Image360AnnotationSpecifier<T>): Promise<T['image360AnnotationType'][]>;
-    /**
-     * Resolves the mapping from internal file IDs (annotatedResourceId) to external IDs.
-     * This is needed to match annotations to face descriptors when descriptors use externalId.
-     * Optional - if not implemented, the caller should build mapping from descriptors only.
-     */
-    resolveFileIdToExternalIdMapping?(annotations: T['image360AnnotationType'][], descriptors: Image360FileDescriptor[]): Promise<Map<number, string>>;
-    findImageAnnotationsForInstance(instanceFilter: Image360AnnotationInstanceReference<T>, collection: DefaultImage360Collection<T>): Promise<Image360AnnotationAssetQueryResult<T>[]>;
-    getAllImage360AnnotationInfos(source: 'assets', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<ClassicDataSourceType>[]>;
-    getAllImage360AnnotationInfos(source: 'hybrid', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetHybridAnnotationImage360Info[]>;
-    getAllImage360AnnotationInfos(source: 'cdm', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<DMDataSourceType>[]>;
-    getAllImage360AnnotationInfos(source: 'all', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<DataSourceType>[]>;
-    getAllImage360AnnotationInfos(source: 'assets' | 'hybrid' | 'cdm' | 'all', collection: DefaultImage360Collection<T>, annotationFilter: Image360AnnotationFilterDelegate<T>): Promise<AssetAnnotationImage360Info<ClassicDataSourceType>[] | AssetAnnotationImage360Info<DMDataSourceType>[] | AssetAnnotationImage360Info<DataSourceType>[] | AssetHybridAnnotationImage360Info[]>;
-}
 export interface Image360DescriptorProvider<T extends DataSourceType> {
     get360ImageDescriptors(metadataFilter: T['image360Identifier'], preMultipliedRotation: boolean): Promise<Historical360ImageSet<T>[]>;
 }

package/dist/packages/data-providers/src/utilities/internalAddModelOptions.d.ts

@@ -1,4 +1,4 @@
-import { GeometryFilter } from '../../../cad-model';
+import { GeometryFilter } from '../GeometryFilter';
 import { ClassicModelIdentifierType, InternalDataSourceType, LocalModelIdentifierType } from '../DataSourceType';
 import { File3dFormat } from '../types';
 /**

package/dist/packages/model-base/src/types.d.ts

@@ -5,6 +5,8 @@ export interface IntersectInput {
     clippingPlanes: Plane[];
     renderer: WebGLRenderer;
     domElement: HTMLElement;
+    cameraInMotion?: boolean;
+    forceWindowedPick?: boolean;
 }
 /**
  * State holding information about data being loaded.

package/dist/packages/pointcloud-styling/index.d.ts

@@ -4,7 +4,6 @@
 export type { CompletePointCloudAppearance, PointCloudAppearance } from './src/PointCloudAppearance';
 export { DefaultPointCloudAppearance, applyDefaultsToPointCloudAppearance } from './src/PointCloudAppearance';
 export { StyledPointCloudObjectCollection, StyledPointCloudVolumeCollection } from './src/StyledPointCloudVolumeCollection';
-export { PointCloudObjectCollection, PointCloudAnnotationVolumeCollection } from './src/PointCloudObjectCollection';
+export { PointCloudObjectCollection, PointCloudAnnotationVolumeCollection, PointCloudDMVolumeCollection } from '../data-providers';
 export { AnnotationIdPointCloudObjectCollection } from './src/AnnotationIdPointCloudObjectCollection';
-export { PointCloudDMVolumeCollection } from './src/PointCloudDMVolumeCollection';
 export { isPointCloudObjectCollection, isDMInstanceRefPointCloudObjectCollection } from './src/utils';

package/dist/packages/pointcloud-styling/src/AnnotationIdPointCloudObjectCollection.d.ts

@@ -1,4 +1,4 @@
-import { PointCloudAnnotationVolumeCollection } from './PointCloudObjectCollection';
+import { PointCloudAnnotationVolumeCollection } from '../../data-providers';
 /**
  * A simple PointCloudAnnotationVolumeCollection that consists of an explicitly provided list of annotation IDs
  */

package/dist/packages/pointcloud-styling/src/utils.d.ts

@@ -1,4 +1,3 @@
-import { PointCloudDMVolumeCollection } from './PointCloudDMVolumeCollection';
-import { PointCloudAnnotationVolumeCollection } from './PointCloudObjectCollection';
+import { PointCloudDMVolumeCollection, PointCloudAnnotationVolumeCollection } from '../../data-providers';
 export declare function isPointCloudObjectCollection(collection: PointCloudAnnotationVolumeCollection | PointCloudDMVolumeCollection): collection is PointCloudAnnotationVolumeCollection;
 export declare function isDMInstanceRefPointCloudObjectCollection(collection: PointCloudAnnotationVolumeCollection | PointCloudDMVolumeCollection): collection is PointCloudDMVolumeCollection;

package/dist/packages/pointclouds/src/PointCloudPickingHandler.d.ts

@@ -3,13 +3,33 @@ import { IntersectInput } from '../../model-base';
 import { PointCloudNode } from './PointCloudNode';
 import { DataSourceType } from '../../data-providers';
 import { IntersectPointCloudNodeResult } from './types';
+import { EdlOptions } from '../../rendering';
 export declare class PointCloudPickingHandler {
     private readonly _normalized;
+    private readonly _drawingBufferSize;
     private readonly _raycaster;
+    private readonly _renderer;
     private readonly _picker;
+    private readonly _edlOptions;
     private readonly _mutex;
-    private static readonly PickingWindowSize;
-    constructor(renderer: WebGLRenderer);
+    /**
+     * @param renderer Renderer used for the pick render.
+     * @param edlOptions EDL options the point clouds are rendered with, if any. EDL shades empty pixels
+     * within its radius of a point, closing small gaps on screen that the pick render (which has no EDL)
+     * still sees as empty, so the pick window is widened to cover that radius.
+     */
+    constructor(renderer: WebGLRenderer, edlOptions?: EdlOptions);
     dispose(): void;
+    /**
+     * Invalidates the picker's cached full-frame pick buffer. Must be called whenever a new
+     * frame of the scene is rendered.
+     */
+    invalidatePickCache(): void;
     intersectPointClouds(nodes: PointCloudNode<DataSourceType>[], input: IntersectInput): Promise<IntersectPointCloudNodeResult<DataSourceType>[]>;
+    private getPickWindowSize;
 }
+/**
+ * Pick window size in drawing buffer pixels. Odd, so the window is centered on the pick position.
+ * Wide enough to cover the EDL outline, which is drawn around points on screen but not in the pick render.
+ */
+export declare function computePickWindowSize(edlOptions: EdlOptions | undefined, drawingBufferHeight: number): number;