@cognite/reveal 4.14.9 → 4.15.0-dev.20240625

package/dist/packages/3d-overlays/index.d.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2023 Cognite AS
  */
-export { Overlay3DCollection } from './src/Overlay3DCollection';
+export { Overlay3DCollection, Overlay3DCollectionOptions } from './src/Overlay3DCollection';
 export { OverlayPointsObject, OverlayPointsParameters } from './src/OverlayPointsObject';
 export { Overlay3DIcon } from './src/Overlay3DIcon';
 export { Overlay3D } from './src/Overlay3D';

package/dist/packages/3d-overlays/src/CameraChangeThrottler.d.ts

@@ -0,0 +1,8 @@
+import { Camera } from 'three';
+export type Callback = () => void;
+export declare class CameraChangeThrottler {
+    private readonly _prevCameraMatrix;
+    call: (camera: Camera, callback: Callback) => void;
+    constructor(wait?: number);
+    private _call;
+}

package/dist/packages/3d-overlays/src/IconOctree.d.ts

@@ -4,10 +4,11 @@
 import { Node, PointOctant, PointOctree } from 'sparse-octree';
 import { Box3, Matrix4 } from 'three';
 import { Overlay3DIcon } from './Overlay3DIcon';
-export declare class IconOctree extends PointOctree<Overlay3DIcon> {
+import { DefaultOverlay3DContentType } from './OverlayCollection';
+export declare class IconOctree<ContentType = DefaultOverlay3DContentType> extends PointOctree<Overlay3DIcon<ContentType>> {
     private readonly _nodeCenters;
-    static getMinimalOctreeBoundsFromIcons(icons: Overlay3DIcon[]): Box3;
-    constructor(icons: Overlay3DIcon[], bounds: Box3, maxLeafSize: number);
+    static getMinimalOctreeBoundsFromIcons<ContentType>(icons: Overlay3DIcon<ContentType>[]): Box3;
+    constructor(icons: Overlay3DIcon<ContentType>[], bounds: Box3, maxLeafSize: number);
     getNodeIcon(node: Node): Overlay3DIcon | undefined;
     getLODByScreenArea(areaThreshold: number, projection: Matrix4, minimumLevel?: number): Set<PointOctant<Overlay3DIcon>>;
     private populateNodeCenters;

package/dist/packages/3d-overlays/src/Overlay3DCollection.d.ts

@@ -1,15 +1,33 @@
 /*!
  * Copyright 2023 Cognite AS
  */
-import { Color, Texture, Object3D, type Camera } from 'three';
+import { Color, Texture, Object3D, Camera, Vector2 } from 'three';
 import { Overlay3D } from './Overlay3D';
 import { DefaultOverlay3DContentType, OverlayCollection, OverlayInfo } from './OverlayCollection';
+/**
+ * Constructor options for the Overlay3DCollection
+ */
 export type Overlay3DCollectionOptions = {
+    /**
+     * The texture to display as icons in this collection
+     */
     overlayTexture?: Texture;
+    /**
+     * A texture mask for marking what pixels are transparent in the supplied overlayTexture
+     */
     overlayTextureMask?: Texture;
+    /**
+     * The maximum display size of each icon in pixels
+     */
     maxPointSize?: number;
+    /**
+     * The default color to apply to overlay icons without a color on their own
+     */
     defaultOverlayColor?: Color;
 };
+/**
+ * A collection of overlay icons with associated data
+ */
 export declare class Overlay3DCollection<MetadataType = DefaultOverlay3DContentType> extends Object3D implements OverlayCollection<MetadataType> {
     private readonly MinPixelSize;
     private readonly MaxPixelSize;
@@ -20,16 +38,41 @@ export declare class Overlay3DCollection<MetadataType = DefaultOverlay3DContentT
     private readonly _iconRadius;
     private _overlays;
     private _octree;
-    constructor(overlayInfos?: OverlayInfo<MetadataType>[], options?: Overlay3DCollectionOptions);
+    private readonly _rayCaster;
+    private readonly _cameraChangeDebouncer;
+    constructor(overlayInfos: OverlayInfo<MetadataType>[], options?: Overlay3DCollectionOptions);
+    /**
+     * Set whether this collection is visible or not
+     */
     setVisibility(visibility: boolean): void;
+    /**
+     * Get the overlay icons contained in this collection
+     */
     getOverlays(): Overlay3D<MetadataType>[];
+    /**
+     * Add more overlays into this collection
+     */
     addOverlays(overlayInfos: OverlayInfo<MetadataType>[]): Overlay3D<MetadataType>[];
-    sortOverlaysRelativeToCamera(camera: Camera): void;
+    private readonly onBeforeRenderDelegate;
+    private sortOverlaysRelativeToCamera;
+    /**
+     * Remove the listed overlays from this collection
+     */
     removeOverlays(overlays: Overlay3D<MetadataType>[]): void;
+    /**
+     * Clean up all icons in this collection
+     */
     removeAllOverlays(): void;
+    /**
+     * Run intersection on icons in this collection. Returns the closest hit
+     */
+    intersectOverlays(normalizedCoordinates: Vector2, camera: Camera): Overlay3D<MetadataType> | undefined;
     private rebuildOctree;
     private updatePointsObject;
     private initializeOverlay3DIcons;
+    /**
+     * Dispose this collection and icons with all associated resources
+     */
     dispose(): void;
     private createCircleTextures;
 }

package/dist/packages/3d-overlays/src/OverlayPointsObject.d.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2023 Cognite AS
  */
-import { Color, DepthModes, Group, Matrix4, Texture, Vector3 } from 'three';
+import { Color, DepthModes, Group, Matrix4, Object3D, Texture, Vector3 } from 'three';
 export type OverlayPointsParameters = {
     spriteTexture: Texture;
     maskTexture?: Texture;
@@ -20,8 +20,9 @@ export declare class OverlayPointsObject extends Group {
     private readonly _colorBuffer;
     private readonly _colorAttribute;
     private readonly _points;
+    private readonly _onBeforeRender?;
     private _modelTransform;
-    constructor(maxNumberOfPoints: number, materialParameters: OverlayPointsParameters);
+    constructor(maxNumberOfPoints: number, materialParameters: OverlayPointsParameters, onBeforeRender?: Object3D['onBeforeRender']);
     setPoints(points: Vector3[], colors?: Color[]): void;
     setTransform(transform: Matrix4): void;
     getTransform(out?: Matrix4): Matrix4;

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

@@ -105,11 +105,11 @@ export declare const DefaultNodeAppearance: {
     InFront: NodeAppearance;
     Ghosted: NodeAppearance;
     Highlighted: {
-        color?: Color | undefined;
-        visible?: boolean | undefined;
-        renderInFront?: boolean | undefined;
-        renderGhosted?: boolean | undefined;
-        outlineColor?: NodeOutlineColor | undefined;
-        prioritizedForLoadingHint?: number | undefined;
+        color?: Color;
+        visible?: boolean;
+        renderInFront?: boolean;
+        renderGhosted?: boolean;
+        outlineColor?: NodeOutlineColor;
+        prioritizedForLoadingHint?: number;
     };
 };

package/dist/packages/metrics/src/MetricsLogger.d.ts

@@ -1,7 +1,6 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-/// <reference types="lodash" />
 import * as THREE from 'three';
 import { TrackedEvents, EventProps } from './types';
 export declare class MetricsLogger {

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

@@ -65,14 +65,10 @@ export type OverlayCollectionOptions = {
  */
 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 _textOverlay;
     private readonly _events;
     constructor(viewer: Cognite3DViewer, toolParameters?: Overlay3DToolParameters);
     /**
@@ -128,7 +124,5 @@ export declare class Overlay3DTool<ContentType = DefaultOverlay3DContentType> ex
     dispose(): void;
     private readonly onMouseMove;
     private readonly onMouseClick;
-    private positionTextOverlay;
     private intersectPointsMarkers;
-    private createTextOverlay;
 }

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

@@ -0,0 +1,26 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+export declare class TextOverlay {
+    private readonly _textOverlay;
+    private readonly _defaultTextOverlayToCursorOffset;
+    private _textOverlayVisible;
+    constructor(domElement: HTMLElement);
+    get textOverlay(): HTMLElement;
+    /**
+     * Sets whether text overlay is visible.
+     * Default is false.
+     */
+    setTextOverlayEnabled(visible: boolean): void;
+    /**
+     * Resets (i.e. hides) text overlay before recalculating position/visibility
+     */
+    reset(): void;
+    /**
+     * Gets whether text overlay is visible.
+     */
+    getTextOverlayEnabled(): boolean;
+    dispose(): void;
+    positionTextOverlay(event: MouseEvent): void;
+    private createTextOverlay;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/reveal",
-  "version": "4.14.9",
+  "version": "4.15.0-dev.20240625",
   "description": "WebGL based 3D viewer for CAD and point clouds processed in Cognite Data Fusion.",
   "homepage": "https://github.com/cognitedata/reveal/tree/master/viewer",
   "repository": {