@cognite/reveal 4.2.2 → 4.3.0

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

@@ -17,7 +17,7 @@ export declare class CogniteCadModel implements CdfModelNodeCollectionDataProvid
     /**
      * Returns the unit the coordinates for the model is stored. Returns an empty string
      * if no unit has been stored.
-     * Note that coordinates in Reveal always are converted to meters using {@link modelUnitToMetersFactor}.
+     * Note that coordinates in Reveal always are converted to meters using {@link CogniteCadModel.modelUnitToMetersFactor}.
      */
     get modelUnit(): WellKnownUnit | '';
     /**
@@ -51,7 +51,7 @@ export declare class CogniteCadModel implements CdfModelNodeCollectionDataProvid
     private readonly _styledNodeCollections;
     /**
      * Sets the default appearance for nodes that are not styled using
-     * {@link assignStyledNodeCollection}. Updating the default style can be an
+     * {@link CogniteCadModel.assignStyledNodeCollection}. Updating the default style can be an
      * expensive operation, so use with care.
      *
      * @param appearance  Default node appearance.
@@ -59,7 +59,7 @@ export declare class CogniteCadModel implements CdfModelNodeCollectionDataProvid
     setDefaultNodeAppearance(appearance: NodeAppearance): void;
     /**
      * Gets the default appearance for nodes that are not styled using
-     * {@link assignStyledNodeCollection}.
+     * {@link CogniteCadModel.assignStyledNodeCollection}.
      */
     getDefaultNodeAppearance(): NodeAppearance;
     /**
@@ -100,7 +100,7 @@ export declare class CogniteCadModel implements CdfModelNodeCollectionDataProvid
     /**
      * Removes styling for previously added styled collection, resetting the style to the default (or
      * the style imposed by other styled collections).
-     * @param nodeCollection   Node collection previously added using {@link assignStyledNodeCollection}.
+     * @param nodeCollection   Node collection previously added using {@link CogniteCadModel.assignStyledNodeCollection}.
      * @throws Error if node collection isn't assigned to the model.
      */
     unassignStyledNodeCollection(nodeCollection: NodeCollection): void;
@@ -207,7 +207,7 @@ export declare class CogniteCadModel implements CdfModelNodeCollectionDataProvid
     /**
      * Gets transformation from CDF space to ThreeJS space,
      * which includes any additional "default" transformations assigned to this model.
-     * Does not include any custom transformations set by {@link CognitePointcloudmodel.setModelTransformation}
+     * Does not include any custom transformations set by {@link CogniteCadModel.setModelTransformation}
      * @param out Preallocated `THREE.Matrix4` (optional)
      */
     getCdfToDefaultModelTransformation(out?: THREE.Matrix4): THREE.Matrix4;
@@ -305,7 +305,7 @@ export declare class CogniteCadModel implements CdfModelNodeCollectionDataProvid
     /**
      * Maps a single node ID to tree index. This is useful when you e.g. have a
      * node ID from an asset mapping and want to highlight the given asset using
-     * {@link mapNodeIdsToTreeIndices} is recommended for better performance when
+     * {@link CogniteCadModel.mapNodeIdsToTreeIndices} is recommended for better performance when
      * mapping multiple IDs.
      *
      * @param nodeId A Node ID to map to a tree index.
@@ -326,7 +326,7 @@ export declare class CogniteCadModel implements CdfModelNodeCollectionDataProvid
     mapTreeIndicesToNodeIds(treeIndices: number[]): Promise<CogniteInternalId[]>;
     /**
      * Maps a single tree index to node ID for use with the API. If you have multiple
-     * tree indices to map, {@link mapNodeIdsToTreeIndices} is recommended for better
+     * tree indices to map, {@link CogniteCadModel.mapNodeIdsToTreeIndices} is recommended for better
      * performance.
      * @param treeIndex A tree index to map to a Node ID.
      * @returns TreeIndex of the provided node.

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

@@ -15,7 +15,7 @@ export interface CadModelMetadata {
      */
     readonly format: File3dFormat;
     /**
-     * Revision of the {@link format} (e.g. 8 for "legacy models" or
+     * Revision of the {@link CadModelMetadata.format} (e.g. 8 for "legacy models" or
      * 9 for GLTF).
      */
     readonly formatVersion: number;

package/dist/packages/cad-styling/src/NodeAppearance.d.ts

@@ -29,12 +29,12 @@ export type NodeAppearance = {
     /**
      * When set to true, the node is rendered in front
      * of all other nodes even if it's occluded.
-     * Note that this take precedence over {@link renderGhosted}.
+     * Note that this take precedence over {@link NodeAppearance.renderGhosted}.
      */
     readonly renderInFront?: boolean;
     /**
      * When set to true, the node is rendered ghosted, i.e.
-     * transparent with a fixed color. This has no effect if {@link renderInFront}
+     * transparent with a fixed color. This has no effect if {@link NodeAppearance.renderInFront}
      * is `true`.
      */
     readonly renderGhosted?: boolean;

package/dist/packages/cad-styling/src/PopulateIndexSetFromPagedResponseHelper.d.ts

@@ -24,7 +24,8 @@ export declare class PopulateIndexSetFromPagedResponseHelper<T> {
     /**
      * Loops through all the pages of the provided response and populated the IndexSet provided.
      * @param request
-     * @returns True if the operation was completed, false if it was interrupted using {@link interrupt}.
+     * @returns True if the operation was completed, false if it was interrupted using
+     * {@link PopulateIndexSetFromPagedResponseHelper.interrupt}.
      */
     pageResults(request: Promise<ListResponse<T[]>>): Promise<boolean>;
 }

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

@@ -6,13 +6,13 @@ import { CameraState, CameraChangeDelegate, CameraStopDelegate, CameraManagerEve
 /**
  * Interface for manager responsible for all manipulations to the camera,
  * including animations and modification of state. Implementations are responsible for
- * providing a `THREE.PerspectiveCamera` instance to {@link Cognite3DViewer}. Implementations
+ * providing a `THREE.PerspectiveCamera` instance to the viewer. Implementations
  * must trigger the `cameraChange`-event when camera is changed.
  * The default implementation is {@link DefaultCameraManager}.
  */
 export interface CameraManager {
     /**
-     * Returns the camera used for rendering in {@link Cognite3DViewer}.
+     * Returns the camera used for rendering the viewer.
      * Note that the camera will not be modified directly by Reveal.
      * Implementations must trigger the `cameraChange`-event whenever the
      * camera changes.
@@ -44,7 +44,7 @@ export interface CameraManager {
      * Set this manager as active and enable controls.
      *
      * Should update {@link CameraManager.enabled} to reflect the state of the manager.
-     * Note that this is called automatically when a new CameraManager is set on the {@link Cognite3DViewer}.
+     * Note that this is called automatically when a new CameraManager is set on the viewer.
      * @param cameraManager Previously used camera manager.
      */
     activate(cameraManager?: CameraManager): void;
@@ -52,7 +52,7 @@ export interface CameraManager {
      * Deactivate this manager and disable controls.
      *
      * Should update {@link CameraManager.enabled} to reflect the state of the manager.
-     * Note that this is called automatically when a new CameraManager is set on the {@link Cognite3DViewer}.
+     * Note that this is called automatically when a new CameraManager is set on the viewer.
      */
     deactivate(): void;
     /**

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

@@ -19,6 +19,13 @@ export declare class CameraManagerHelper {
      * @returns
      */
     static calculateNewTargetFromRotation(camera: THREE.PerspectiveCamera, rotation: THREE.Quaternion, currentTarget: THREE.Vector3): THREE.Vector3;
+    /**
+     * Calculates camera rotation from target
+     * @param camera Used Camera instance
+     * @param newTarget The target to compute rotation from
+     * @returns New camera rotationg
+     */
+    static calculateNewRotationFromTarget(camera: THREE.PerspectiveCamera, newTarget: THREE.Vector3): THREE.Quaternion;
     /**
      * Updates near and far plane of the camera based on the bounding box.
      * @param camera Used camera instance.

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

@@ -17,5 +17,5 @@ export { PointCloudStylableObjectProvider } from './src/PointCloudStylableObject
 export { StylableObject, SerializableStylableObject } from './src/pointcloud-stylable-object-providers/StylableObject';
 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, Image360Texture } from './src/types';
+export { Image360Provider, Image360DataProvider } from './src/Image360Provider';
+export { BinaryFileProvider, JsonFileProvider, File3dFormat, BlobOutputMetadata, Image360Descriptor, Image360FileProvider, Image360Face, Image360Texture, Image360FileDescriptor } from './src/types';

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

@@ -1,6 +1,8 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import { Image360DescriptorProvider, Image360FileProvider } from './types';
-export interface Image360Provider<T> extends Image360DescriptorProvider<T>, Image360FileProvider {
+import { Image360DescriptorProvider, Image360FileProvider, Image360AnnotationProvider, Image360AssetProvider } from './types';
+export interface Image360Provider<T> extends Image360DescriptorProvider<T>, Image360DataProvider {
+}
+export interface Image360DataProvider extends Image360FileProvider, Image360AnnotationProvider, Image360AssetProvider {
 }

package/dist/packages/data-providers/src/image-360-data-providers/Cdf360ImageEventProvider.d.ts

@@ -1,13 +1,15 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import { CogniteClient, Metadata } from '@cognite/sdk';
-import { Image360Descriptor, Image360Face, Image360FileDescriptor } from '../types';
+import { AnnotationModel, CogniteClient, IdEither, Metadata, CogniteInternalId } from '@cognite/sdk';
+import { Historical360ImageSet, Image360Face, Image360FileDescriptor } from '../types';
 import { Image360Provider } from '../Image360Provider';
 export declare class Cdf360ImageEventProvider implements Image360Provider<Metadata> {
     private readonly _client;
     constructor(client: CogniteClient);
-    get360ImageDescriptors(metadataFilter: Metadata, preMultipliedRotation: boolean): Promise<Image360Descriptor[]>;
+    get360ImageDescriptors(metadataFilter: Metadata, preMultipliedRotation: boolean): Promise<Historical360ImageSet[]>;
+    get360ImageAnnotations(descriptors: Image360FileDescriptor[]): Promise<AnnotationModel[]>;
+    getFilesByAssetRef(assetRef: IdEither): Promise<CogniteInternalId[]>;
     get360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
     getLowResolution360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
     private getFileIds;
@@ -15,12 +17,12 @@ export declare class Cdf360ImageEventProvider implements Image360Provider<Metada
     private mergeDescriptors;
     private listEvents;
     private listFiles;
-    private getNewestFileInfoSet;
+    private sortFileInfoSetByNewest;
     private getFileBuffers;
     getIconBuffers(fileIds: {
         id: number;
     }[], abortSignal?: AbortSignal): Promise<ArrayBuffer[]>;
     private getDownloadUrls;
     private parseEventMetadata;
-    get360ImageFaces(): Promise<void>;
+    get360ImageAssets(image360FileDescriptors: Image360FileDescriptor[]): Promise<IdEither[]>;
 }

package/dist/packages/data-providers/src/image-360-data-providers/Local360ImageProvider.d.ts

@@ -1,9 +1,13 @@
 import { Image360Provider } from '../Image360Provider';
-import { Image360Descriptor, Image360Face, Image360FileDescriptor } from '../types';
+import { Historical360ImageSet, Image360Face, Image360FileDescriptor } from '../types';
+import { AnnotationModel, CogniteInternalId, IdEither } from '@cognite/sdk/dist/src';
 export declare class Local360ImageProvider implements Image360Provider<unknown> {
     private readonly _modelUrl;
     constructor(modelUrl: string);
-    get360ImageDescriptors(): Promise<Image360Descriptor[]>;
+    get360ImageDescriptors(): Promise<Historical360ImageSet[]>;
+    get360ImageAnnotations(_descriptors: Image360FileDescriptor[]): Promise<AnnotationModel[]>;
     get360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
     getLowResolution360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
+    getFilesByAssetRef(_assetId: IdEither): Promise<CogniteInternalId[]>;
+    get360ImageAssets(_image360FileDescriptors: Image360FileDescriptor[]): Promise<IdEither[]>;
 }

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

@@ -1,6 +1,7 @@
 /*!
  * Copyright 2021 Cognite AS
  */
+import { AnnotationModel, CogniteInternalId, IdEither } from '@cognite/sdk';
 import * as THREE from 'three';
 export interface JsonFileProvider {
     getJsonFile(baseUrl: string, fileName: string): Promise<any>;
@@ -8,21 +9,32 @@ export interface JsonFileProvider {
 export interface BinaryFileProvider {
     getBinaryFile(baseUrl: string, fileName: string, abortSignal?: AbortSignal): Promise<ArrayBuffer>;
 }
+export interface Image360AnnotationProvider {
+    get360ImageAnnotations(descriptors: Image360FileDescriptor[]): Promise<AnnotationModel[]>;
+    getFilesByAssetRef(assetId: IdEither): Promise<CogniteInternalId[]>;
+}
 export interface Image360DescriptorProvider<T> {
-    get360ImageDescriptors(metadataFilter: T, preMultipliedRotation: boolean): Promise<Image360Descriptor[]>;
+    get360ImageDescriptors(metadataFilter: T, preMultipliedRotation: boolean): Promise<Historical360ImageSet[]>;
 }
 export interface Image360FileProvider {
     get360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
     getLowResolution360ImageFiles(image360FaceDescriptors: Image360FileDescriptor[], abortSignal?: AbortSignal): Promise<Image360Face[]>;
 }
-export type Image360Descriptor = Image360EventDescriptor & {
+export interface Image360AssetProvider {
+    get360ImageAssets(image360FileDescriptors: Image360FileDescriptor[]): Promise<IdEither[]>;
+}
+export type Historical360ImageSet = Image360EventDescriptor & {
+    imageRevisions: Image360Descriptor[];
+};
+export type Image360Descriptor = {
+    timestamp?: number;
     faceDescriptors: Image360FileDescriptor[];
 };
 export type Image360EventDescriptor = {
     id: string;
-    label: string;
+    label: string | undefined;
     collectionId: string;
-    collectionLabel: string;
+    collectionLabel: string | undefined;
     transform: THREE.Matrix4;
 };
 export type Image360Face = {

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

@@ -3,10 +3,7 @@
  */
 import * as THREE from 'three';
 export interface IntersectInput {
-    normalizedCoords: {
-        x: number;
-        y: number;
-    };
+    normalizedCoords: THREE.Vector2;
     camera: THREE.PerspectiveCamera;
     clippingPlanes: THREE.Plane[];
     renderer: THREE.WebGLRenderer;

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

@@ -53,14 +53,14 @@ export declare class CognitePointCloudModel {
     setModelTransformation(transformationMatrix: THREE.Matrix4): void;
     /**
      * Gets transformation matrix that has previously been
-     * set with {@link CognitePointCloudmodel.setModelTransformation}.
+     * set with {@link CognitePointCloudModel.setModelTransformation}.
      * @param out Preallocated `THREE.Matrix4` (optional).
      */
     getModelTransformation(out?: THREE.Matrix4): THREE.Matrix4;
     /**
      * Gets transformation from CDF space to ThreeJS space,
      * which includes any additional "default" transformations assigned to this model.
-     * Does not include any custom transformations set by {@link CognitePointcloudmodel.setModelTransformation}
+     * Does not include any custom transformations set by {@link CognitePointCloudModel.setModelTransformation}
      * @param out Preallocated `THREE.Matrix4` (optional)
      */
     getCdfToDefaultModelTransformation(out?: THREE.Matrix4): THREE.Matrix4;

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

@@ -13,7 +13,7 @@ export type PointCloudIntersection = {
      */
     model: CognitePointCloudModel;
     /**
-     * Tree index of the intersected 3D node.
+     * Coordinate of the intersection.
      */
     point: THREE.Vector3;
     /**

package/dist/packages/pointclouds/src/potree-three-loader/loading/ClassificationInfo.d.ts

@@ -4,7 +4,7 @@
 export type PointClass = {
     name: string;
     code: number;
-    rgb?: string;
+    rgb?: `#${string}`;
 };
 export type ClassificationSet = {
     name: string;

package/dist/packages/rendering/src/pointcloud-rendering/PointCloudMaterial.d.ts

@@ -1,10 +1,8 @@
 /*!
  * Adapted from pnext/three-loader (https://github.com/pnext/three-loader)
  */
-import { Camera, RawShaderMaterial, Texture, WebGLRenderer } from 'three';
-import { PointColorType, PointShape, PointSizeType } from './enums';
-import { PointClassification, IUniform, OctreeMaterialParams } from './types';
-import { PointCloudObjectAppearanceTexture } from './PointCloudObjectAppearanceTexture';
+import { Texture } from 'three';
+import { IUniform } from './types';
 import { PointCloudObjectIdMaps } from './PointCloudObjectIdMaps';
 export interface IPointCloudMaterialParameters {
     size: number;
@@ -28,7 +26,6 @@ export interface IPointCloudMaterialUniforms {
     minSize: IUniform<number>;
     objectIdLUT: IUniform<Texture>;
     octreeSize: IUniform<number>;
-    opacity: IUniform<number>;
     pcIndex: IUniform<number>;
     screenHeight: IUniform<number>;
     screenWidth: IUniform<number>;
@@ -37,85 +34,3 @@ export interface IPointCloudMaterialUniforms {
     visibleNodes: IUniform<Texture>;
     vnStart: IUniform<number>;
 }
-export declare class PointCloudMaterial extends RawShaderMaterial {
-    private static readonly helperVec3;
-    /**
-     * Use the drawing buffer size instead of the dom client width and height when passing the screen height and screen width uniforms to the
-     * shader. This is useful if you have offscreen canvases (which in some browsers return 0 as client width and client height).
-     */
-    useDrawingBufferSize: boolean;
-    lights: boolean;
-    fog: boolean;
-    visibleNodesTexture: Texture | undefined;
-    visibleNodeTextureOffsets: Map<string, number>;
-    private readonly _gradient;
-    private gradientTexture;
-    private _objectAppearanceTexture;
-    private _classification;
-    private classificationTexture;
-    uniforms: IPointCloudMaterialUniforms & Record<string, IUniform<any>>;
-    fov: number;
-    heightMax: number;
-    heightMin: number;
-    intensityBrightness: number;
-    intensityContrast: number;
-    intensityGamma: number;
-    intensityRange: [number, number];
-    maxSize: number;
-    minSize: number;
-    octreeSize: number;
-    opacity: number;
-    screenHeight: number;
-    screenWidth: number;
-    size: number;
-    spacing: number;
-    weighted: boolean;
-    hqDepthPass: boolean;
-    pointColorType: PointColorType;
-    pointSizeType: PointSizeType;
-    useEDL: boolean;
-    shape: PointShape;
-    attributes: {
-        position: {
-            type: string;
-            value: never[];
-        };
-        color: {
-            type: string;
-            value: never[];
-        };
-        intensity: {
-            type: string;
-            value: never[];
-        };
-        classification: {
-            type: string;
-            value: never[];
-        };
-        objectId: {
-            type: string;
-            value: never[];
-        };
-        indices: {
-            type: string;
-            value: never[];
-        };
-    };
-    constructor(parameters?: Partial<IPointCloudMaterialParameters>);
-    dispose(): void;
-    clearVisibleNodeTextureOffsets(): void;
-    updateShaderSource(): void;
-    applyDefines(shaderSrc: string): string;
-    get objectAppearanceTexture(): PointCloudObjectAppearanceTexture;
-    set objectAppearanceTexture(texture: PointCloudObjectAppearanceTexture);
-    get classification(): PointClassification;
-    set classification(value: PointClassification);
-    private recomputeClassification;
-    get elevationRange(): [number, number];
-    set elevationRange(value: [number, number]);
-    getUniform<K extends keyof IPointCloudMaterialUniforms>(name: K): IPointCloudMaterialUniforms[K]['value'];
-    setUniform<K extends keyof IPointCloudMaterialUniforms>(name: K, value: IPointCloudMaterialUniforms[K]['value']): void;
-    onBeforeRender(renderer: WebGLRenderer): void;
-    updateMaterial(octreeParams: OctreeMaterialParams, visibilityTextureData: Uint8Array, camera: Camera): void;
-    private updateVisibilityTextureData;
-}

package/dist/packages/rendering/src/rendering/NodeAppearanceTextureBuilder.d.ts

@@ -20,8 +20,8 @@ export declare class NodeAppearanceTextureBuilder {
     getDefaultAppearance(): NodeAppearance;
     /**
      * Sets the default style and invalidates the builder. Note that this causes a full
-     * recomputation of values the next time {@link build} is called, so using this might be
-     * expensive.
+     * recomputation of values the next time {@link NodeAppearanceTextureBuilder.build} is called,
+     * so using this might be expensive.
      * @param appearance New style that is applied to all 'unstyled' elements.
      */
     setDefaultAppearance(appearance: NodeAppearance): void;

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

@@ -5,6 +5,7 @@ export { HtmlOverlayTool, HtmlOverlayOptions, HtmlOverlayToolOptions, HtmlOverla
 export { DebugCameraTool } from './src/DebugCameraTool';
 export { AxisViewTool } from './src/AxisView/AxisViewTool';
 export { AxisBoxConfig, AxisBoxCompassConfig, AxisBoxFaceConfig, Corner, AbsolutePosition, RelativePosition } from './src/AxisView/types';
+export { Overlay3DTool, Overlay3DToolParameters, OverlayEventHandler, OverlayToolEvent, OverlayCollectionOptions } from './src/Overlay3D/Overlay3DTool';
 export { TimelineTool } from './src/Timeline/TimelineTool';
 export { Keyframe } from './src/Timeline/Keyframe';
 export { TimelineDateUpdateDelegate } from './src/Timeline/types';

package/dist/packages/tools/src/HtmlOverlay/BucketGrid2D.d.ts

@@ -16,7 +16,7 @@ export declare class BucketGrid2D<T> {
     private readonly _bounds;
     private readonly _cells;
     /**
-     * Holds elements that has been removed from the collection using {@link removeOverlappingElements}.
+     * Holds elements that has been removed from the collection using {@link BucketGrid2D.removeOverlappingElements}.
      * This is used to avoid expensive re-allocations of cells when removing elements.
      */
     private readonly _removedElements;

package/dist/packages/tools/src/HtmlOverlay/HtmlOverlayTool.d.ts

@@ -38,7 +38,7 @@ export type HtmlOverlayToolClusteringOptions = {
     /**
      * Currently only 'overlapInScreenSpace' is supported. In this mode,
      * overlays are clustered together into a single element as defined by
-     * the {@link createClusterElementCallback} and hidden when they overlap
+     * the {@link HtmlOverlayToolClusteringOptions.createClusterElementCallback} and hidden when they overlap
      * in screen space. The composite element is placed at the midpoint of
      * all clustered elements.
      *

package/dist/packages/tools/src/Overlay3D/Overlay3DTool.d.ts

@@ -0,0 +1,134 @@
+/*!
+ * Copyright 2023 Cognite AS
+ */
+import { Cognite3DViewer } from '../../../api';
+import { DisposedDelegate } from '../../../utilities';
+import * as THREE from 'three';
+import { OverlayInfo, DefaultOverlay3DContentType, OverlayCollection, Overlay3D } from '../../../3d-overlays';
+import { Cognite3DViewerToolBase } from '../Cognite3DViewerToolBase';
+/**
+ * Events related to overlays
+ */
+export type OverlayToolEvent = 'hover' | 'click' | 'disposed';
+/**
+ * Type for handlers of overlay events
+ */
+export type OverlayEventHandler<ContentType> = (event: {
+    targetOverlay: Overlay3D<ContentType>;
+    htmlTextOverlay: HTMLElement;
+    mousePosition: {
+        offsetX: number;
+        offsetY: number;
+    };
+}) => void;
+/**
+ * Parameters for instantiating the Overlay3DTool
+ */
+export type Overlay3DToolParameters = {
+    /**
+     * Max point markers size in pixels. Different platforms has limitations for this value.
+     * On Android and MacOS in Chrome maximum is 64. Windows in Chrome and MacOS Safari desktops can support up to 500.
+     * Default is 64.
+     */
+    maxPointSize?: number;
+    /**
+     * Sets default overlay color for newly added labels.
+     */
+    defaultOverlayColor: THREE.Color;
+};
+/**
+ * Parameters for instantiating the OverlayCollection.
+ */
+export type OverlayCollectionOptions = {
+    /**
+     * Sets default overlay color for newly added overlays.
+     * Default is yellow.
+     * */
+    defaultOverlayColor?: THREE.Color;
+    /**
+     * Sets default texture for all overlays of this OverlayCollection.
+     * Must be a square texture, recommended size is at least `maxPointSize` for
+     * not pixelated overlays.
+     */
+    overlayTexture?: THREE.Texture;
+    /**
+     * Sets default mask for all overlays of this OverlayCollection,
+     * denoting where overlay color should be placed compared to texture color.
+     * Must be a square texture with the same size as `overlayTexture`.
+     * Texture should be monochrome. Internally, R channel is used for
+     * denoting pixels that should be colored by texture and not by overlay color.
+     */
+    overlayTextureMask?: THREE.Texture;
+};
+/**
+ * Tool for adding and interacting with 2D overlays positioned at points in
+ */
+export declare class Overlay3DTool<ContentType = DefaultOverlay3DContentType> extends Cognite3DViewerToolBase {
+    private readonly _viewer;
+    private readonly _textOverlay;
+    private readonly _defaultOverlayColor;
+    private readonly _defaultTextOverlayToCursorOffset;
+    private readonly _temporaryVec;
+    private readonly _raycaster;
+    private _overlayCollections;
+    private _isVisible;
+    private _textOverlayVisible;
+    private readonly _events;
+    constructor(viewer: Cognite3DViewer, toolParameters?: Overlay3DToolParameters);
+    /**
+     * Creates new OverlayCollection.
+     * @param overlays Array of overlays to add.
+     * @returns Overlay group containing it's id.
+     */
+    createOverlayCollection(overlays?: OverlayInfo<ContentType>[], options?: OverlayCollectionOptions): OverlayCollection<ContentType>;
+    /**
+     * Removes overlays that were added with addOverlays method.
+     * @param overlayCollection Id of the overlay group to remove.
+     */
+    removeOverlayCollection(overlayCollection: OverlayCollection<ContentType>): void;
+    /**
+     * Gets all added overlay collections.
+     */
+    getCollections(): OverlayCollection<ContentType>[];
+    /**
+     * Sets whether overlays are visible.
+     */
+    setVisible(visible: boolean): void;
+    /**
+     * Gets whether overlays are visible.
+     */
+    getVisible(): boolean;
+    /**
+     * Sets whether text overlay is visible.
+     * Default is false.
+     */
+    setTextOverlayVisible(visible: boolean): void;
+    /**
+     * Gets whether text overlay is visible.
+     */
+    getTextOverlayVisible(): boolean;
+    /**
+     * Removes all overlays.
+     */
+    clear(): void;
+    /**
+     * Subscribes to overlay events.
+     * @param event event to subscribe to.
+     * @param eventHandler
+     */
+    on(event: 'hover', eventHandler: OverlayEventHandler<ContentType>): void;
+    on(event: 'click', eventHandler: OverlayEventHandler<ContentType>): void;
+    on(event: 'disposed', eventHandler: DisposedDelegate): void;
+    off(event: 'hover', eventHandler: OverlayEventHandler<ContentType>): void;
+    off(event: 'click', eventHandler: OverlayEventHandler<ContentType>): void;
+    off(event: 'disposed', eventHandler: DisposedDelegate): void;
+    /**
+     * Dispose of resources used by this tool
+     */
+    dispose(): void;
+    private readonly onMouseMove;
+    private readonly onMouseClick;
+    private positionTextOverlay;
+    private intersectPointsMarkers;
+    private createTextOverlay;
+}

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

@@ -14,12 +14,12 @@ export { IndexSet } from './src/IndexSet';
 export { DynamicDefragmentedBuffer } from './src/datastructures/DynamicDefragmentedBuffer';
 export { AttributeDataAccessor } from './src/three/AttributeDataAccessor';
 export { AutoDisposeGroup } from './src/three/AutoDisposeGroup';
-export { BoundingBoxLOD } from './src/three/BoundingBoxLOD';
 export { toThreeBox3 } from './src/three/toThreeBox3';
 export { fromThreeVector3 } from './src/three/fromThreeVector3';
 export { unionBoxes } from './src/three/unionBoxes';
 export { determineCurrentDevice, DeviceDescriptor } from './src/device';
 export { createRenderTriangle } from './src/three/createFullScreenTriangleGeometry';
+export { VariableWidthLine } from './src/three/VariableWidthLine';
 export { fitCameraToBoundingBox } from './src/three/fitCameraToBoundingBox';
 export { isBox3OnPositiveSideOfPlane } from './src/three/isBox3OnPositiveSideOfPlane';
 export { visitBox3CornerPoints } from './src/three/visitBox3CornerPoints';

package/dist/packages/utilities/src/WebGLRendererStateHelper.d.ts

@@ -17,7 +17,7 @@ export declare class WebGLRendererStateHelper {
     constructor(renderer: THREE.WebGLRenderer);
     setScissor(x: number, y: number, width: number, height: number): void;
     setScissorTest(enabled: boolean): void;
-    setClearColor(color: THREE.Color | number | string, alpha?: number): void;
+    setClearColor(color: THREE.Color | number, alpha?: number): void;
     setWebGLState(state: WebGLState, resetState?: WebGLState): void;
     setSize(width: number, height: number): void;
     set localClippingEnabled(enabled: boolean);

package/dist/packages/utilities/src/constants.d.ts

@@ -5,8 +5,6 @@ import { Matrix4 } from 'three';
 export declare const cadFromCdfToThreeMatrix: Matrix4;
 /**
  * The transformation matrix from CDF coordinates to ThreeJS/Reveal.
- * Note that this is already applied to {@link CogniteCadModel} and {@link CognitePointCloudModel}
- * automatically, as it is factored into the matrix returned from e.g.
- * the {@link CogniteCadModel.getCdfToDefaultModelTransformation} method.
+ * Note that this is already applied to Reveal models.
  */
 export declare const CDF_TO_VIEWER_TRANSFORMATION: Matrix4;