@cognite/reveal 2.2.2 → 3.0.0-beta.0

package/packages/cad-styling/src/IntersectionNodeCollection.d.ts

@@ -1,15 +1,20 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { NodeCollectionBase, SerializedNodeCollection } from './NodeCollectionBase';
-import { CombineNodeCollectionBase } from './CombineNodeCollectionBase';
-import { IndexSet } from '../../utilities';
-/**
- * Node collection that is the intersection between a set of underlying node collections.
- */
-export declare class IntersectionNodeCollection extends CombineNodeCollectionBase {
-    static readonly classToken = "IntersectionNodeCollection";
-    constructor(nodeCollections?: NodeCollectionBase[]);
-    serialize(): SerializedNodeCollection;
-    protected createCombinedIndexSet(): IndexSet;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { SerializedNodeCollection } from './SerializedNodeCollection';
+import { CombineNodeCollectionBase } from './CombineNodeCollectionBase';
+import { AreaCollection } from './prioritized/AreaCollection';
+import { IndexSet } from '../../utilities';
+import { NodeCollection } from './NodeCollection';
+/**
+ * Node collection that is the intersection between a set of underlying node collections.
+ */
+export declare class IntersectionNodeCollection extends CombineNodeCollectionBase {
+    private _cachedNodeAreas;
+    static readonly classToken = "IntersectionNodeCollection";
+    constructor(nodeCollections?: NodeCollection[]);
+    serialize(): SerializedNodeCollection;
+    protected createCombinedIndexSet(): IndexSet;
+    makeDirty(): void;
+    getAreas(): AreaCollection;
+}

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

@@ -1,62 +1,85 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export declare enum NodeOutlineColor {
-    NoOutline = 0,
-    White = 1,
-    Black = 2,
-    Cyan = 3,
-    Blue = 4,
-    Green = 5,
-    Red = 6,
-    Orange = 7
-}
-/**
- * Type for defining node appearance profiles to style a 3D CAD model.
- * @see {@link DefaultNodeAppearance}
- */
-export declare type NodeAppearance = {
-    /**
-     * Overrides the default color of the node in RGB. Each component
-     * is in range [0, 255]. `[0, 0, 0]` means no override.
-     */
-    readonly color?: [number, number, number];
-    /**
-     * Overrides the visibility of the node.
-     */
-    readonly visible?: boolean;
-    /**
-     * 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}.
-     */
-    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}
-     * is `true`.
-     */
-    readonly renderGhosted?: boolean;
-    /**
-     * When set, an outline is drawn around the
-     * node to make it stand out.
-     */
-    readonly outlineColor?: NodeOutlineColor;
-};
-/**
- * A set of default node appearances used in Reveal.
- */
-export declare const DefaultNodeAppearance: {
-    Default: NodeAppearance;
-    Outlined: NodeAppearance;
-    Hidden: NodeAppearance;
-    InFront: NodeAppearance;
-    Ghosted: NodeAppearance;
-    Highlighted: {
-        color?: [number, number, number] | undefined;
-        visible?: boolean | undefined;
-        renderInFront?: boolean | undefined;
-        renderGhosted?: boolean | undefined;
-        outlineColor?: NodeOutlineColor | undefined;
-    };
-};
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export declare enum NodeOutlineColor {
+    NoOutline = 0,
+    White = 1,
+    Black = 2,
+    Cyan = 3,
+    Blue = 4,
+    Green = 5,
+    Red = 6,
+    Orange = 7
+}
+/**
+ * Type for defining node appearance profiles to style a 3D CAD model.
+ * @see {@link DefaultNodeAppearance}
+ */
+export declare type NodeAppearance = {
+    /**
+     * Overrides the default color of the node in RGB. Each component
+     * is in range [0, 255]. `[0, 0, 0]` means no override.
+     */
+    readonly color?: [number, number, number];
+    /**
+     * Overrides the visibility of the node.
+     */
+    readonly visible?: boolean;
+    /**
+     * 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}.
+     */
+    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}
+     * is `true`.
+     */
+    readonly renderGhosted?: boolean;
+    /**
+     * When set, an outline is drawn around the
+     * node to make it stand out.
+     */
+    readonly outlineColor?: NodeOutlineColor;
+    /**
+     * When provided, this value can be used to prioritize certain areas of the
+     * 3D model to be loaded. This can be useful to prioritize key objects in the
+     * 3D model to always be loaded.
+     *
+     * When non-zero, sectors containing geometry in the vicinity of the prioritized
+     * sectors are given an *extra* priority. Recommended values are in range 1 (somewhat
+     * higher priority to be loaded) to 10 (very likely to be loaded). Usually values around 4-5
+     * is recommended.
+     *
+     * Prioritized nodes are loaded at the expense of non-prioritized areas. There are no
+     * guarantees that the nodes are actually loaded, and the more prioritized areas/nodes
+     * provided, the less likely it is that the hint is obeyed.
+     *
+     * Extra priority doesn't accumulate when sectors are prioritized because they intersect/contain
+     * several nodes.
+     *
+     * **This is an advanced feature and not recommended for most users**
+     *
+     * @version Only works with 3D models converted later than Q4 2021.
+     */
+    readonly prioritizedForLoadingHint?: number;
+};
+/**
+ * A set of default node appearances used in Reveal.
+ */
+export declare const DefaultNodeAppearance: {
+    Default: NodeAppearance;
+    Outlined: NodeAppearance;
+    Hidden: NodeAppearance;
+    InFront: NodeAppearance;
+    Ghosted: NodeAppearance;
+    Highlighted: {
+        color?: [number, number, number];
+        visible?: boolean;
+        renderInFront?: boolean;
+        renderGhosted?: boolean;
+        outlineColor?: NodeOutlineColor;
+        prioritizedForLoadingHint?: number;
+    };
+};

package/packages/cad-styling/src/NodeAppearanceProvider.d.ts

@@ -1,33 +1,38 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { NodeAppearance } from './NodeAppearance';
-import { NodeCollectionBase } from './NodeCollectionBase';
-import { IndexSet } from '../../utilities';
-/**
- * Delegate for applying styles in {@see NodeStyleProvider}.
- * @param treeIndices Set of tree indices that the style is applied to.
- * @param appearance  Style to be applied to the nodes.
- */
-export declare type ApplyStyleDelegate = (treeIndices: IndexSet, appearance: NodeAppearance) => void;
-export declare class NodeAppearanceProvider {
-    private readonly _styledCollections;
-    private _lastFiredLoadingState?;
-    private readonly _events;
-    on(event: 'changed', listener: () => void): void;
-    on(event: 'loadingStateChanged', listener: (isLoading: boolean) => void): void;
-    off(event: 'changed', listener: () => void): void;
-    off(event: 'loadingStateChanged', listener: (isLoading: boolean) => void): void;
-    assignStyledNodeCollection(nodeCollection: NodeCollectionBase, appearance: NodeAppearance): void;
-    unassignStyledNodeCollection(nodeCollection: NodeCollectionBase): void;
-    applyStyles(applyCb: ApplyStyleDelegate): void;
-    clear(): void;
-    get isLoading(): boolean;
-    private notifyChanged;
-    /**
-     * Schedules event 'changed' to trigger at the next tick.
-     */
-    private readonly scheduleNotifyChanged;
-    private notifyLoadingStateChanged;
-    private handleNodeCollectionChanged;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { NodeAppearance } from './NodeAppearance';
+import { NodeCollection } from './NodeCollection';
+import { PrioritizedArea } from './prioritized/types';
+import { IndexSet } from '../../utilities';
+/**
+ * Delegate for applying styles in {@see NodeStyleProvider}.
+ * @param treeIndices Set of tree indices that the style is applied to.
+ * @param appearance  Style to be applied to the nodes.
+ */
+export declare type ApplyStyleDelegate = (treeIndices: IndexSet, appearance: NodeAppearance) => void;
+export declare class NodeAppearanceProvider {
+    private readonly _styledCollections;
+    private _lastFiredLoadingState?;
+    private _cachedPrioritizedAreas?;
+    private readonly _events;
+    on(event: 'changed', listener: () => void): void;
+    on(event: 'loadingStateChanged', listener: (isLoading: boolean) => void): void;
+    on(event: 'prioritizedAreasChanged', listener: () => void): void;
+    off(event: 'changed', listener: () => void): void;
+    off(event: 'loadingStateChanged', listener: (isLoading: boolean) => void): void;
+    assignStyledNodeCollection(nodeCollection: NodeCollection, appearance: NodeAppearance): void;
+    unassignStyledNodeCollection(nodeCollection: NodeCollection): void;
+    applyStyles(applyCb: ApplyStyleDelegate): void;
+    getPrioritizedAreas(): PrioritizedArea[];
+    clear(): void;
+    get isLoading(): boolean;
+    private notifyChanged;
+    /**
+     * Schedules event 'changed' to trigger at the next tick.
+     */
+    private readonly scheduleNotifyChanged;
+    private notifyLoadingStateChanged;
+    private handleNodeCollectionChanged;
+    private notifyPrioritizedAreasChanged;
+}

package/packages/cad-styling/src/NodeCollection.d.ts

@@ -0,0 +1,26 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { AreaCollection } from './prioritized/AreaCollection';
+import { SerializedNodeCollection } from './SerializedNodeCollection';
+import { IndexSet } from '../../utilities';
+/**
+ * Abstract class for implementing a set of nodes to be styled.
+ */
+export declare abstract class NodeCollection {
+    private readonly _changedEvent;
+    private readonly _classToken;
+    protected constructor(classToken: string);
+    get classToken(): string;
+    on(event: 'changed', listener: () => void): void;
+    off(event: 'changed', listener: () => void): void;
+    abstract get isLoading(): boolean;
+    abstract getIndexSet(): IndexSet;
+    abstract getAreas(): AreaCollection;
+    abstract clear(): void;
+    abstract serialize(): SerializedNodeCollection;
+    /**
+     * Triggers the changed-event.
+     */
+    protected notifyChanged(): void;
+}

package/packages/cad-styling/src/SerializedNodeCollection.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+export declare type SerializedNodeCollection = {
+    token: string;
+    state: any;
+    options?: any;
+};

package/packages/cad-styling/src/TreeIndexNodeCollection.d.ts

@@ -1,23 +1,40 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { NumericRange, IndexSet } from '../../utilities';
-import { NodeCollectionBase, SerializedNodeCollection } from './NodeCollectionBase';
-/**
- * Node collection that holds a set of nodes defined by a set of tree indices.
- */
-export declare class TreeIndexNodeCollection extends NodeCollectionBase {
-    static readonly classToken = "TreeIndexNodeCollection";
-    private _treeIndices;
-    constructor(treeIndexSet?: IndexSet);
-    constructor(treeIndices?: Iterable<number>);
-    constructor(treeIndexRange?: NumericRange);
-    updateSet(treeIndices: IndexSet): void;
-    /**
-     * Sets this set to hold an empty set.
-     */
-    clear(): void;
-    getIndexSet(): IndexSet;
-    get isLoading(): boolean;
-    serialize(): SerializedNodeCollection;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { AreaCollection } from './prioritized/AreaCollection';
+import { NodeCollection } from './NodeCollection';
+import { SerializedNodeCollection } from './SerializedNodeCollection';
+import { NumericRange, IndexSet } from '../../utilities';
+/**
+ * Node collection that holds a set of nodes defined by a set of tree indices.
+ */
+export declare class TreeIndexNodeCollection extends NodeCollection {
+    static readonly classToken = "TreeIndexNodeCollection";
+    private _treeIndices;
+    private _areaCollection;
+    constructor(treeIndexSet?: IndexSet);
+    constructor(treeIndices?: Iterable<number>);
+    constructor(treeIndexRange?: NumericRange);
+    updateSet(treeIndices: IndexSet): void;
+    /**
+     * Sets this set to hold an empty set.
+     */
+    clear(): void;
+    getIndexSet(): IndexSet;
+    getAreas(): AreaCollection;
+    /**
+     * Add areas to this node collection's area set.
+     * Nearby areas may be clustered and merged together to keep
+     * the number of areas in the set small.
+     */
+    addAreas(areas: THREE.Box3[]): void;
+    /**
+     * Add points to this node collection's area set.
+     * This effectively adds boxes of size 1x1x1 meter with the points as their centers.
+     */
+    addAreaPoints(points: THREE.Vector3[]): void;
+    clearAreas(): void;
+    get isLoading(): boolean;
+    serialize(): SerializedNodeCollection;
+}

package/packages/cad-styling/src/UnionNodeCollection.d.ts

@@ -1,15 +1,19 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { NodeCollectionBase, SerializedNodeCollection } from './NodeCollectionBase';
-import { CombineNodeCollectionBase } from './CombineNodeCollectionBase';
-import { IndexSet } from '../../utilities';
-/**
- * Node collection that takes the set union of multiple node collections.
- */
-export declare class UnionNodeCollection extends CombineNodeCollectionBase {
-    static readonly classToken = "UnionNodeCollection";
-    constructor(nodeCollections?: NodeCollectionBase[]);
-    serialize(): SerializedNodeCollection;
-    protected createCombinedIndexSet(): IndexSet;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { SerializedNodeCollection } from './SerializedNodeCollection';
+import { NodeCollection } from './NodeCollection';
+import { CombineNodeCollectionBase } from './CombineNodeCollectionBase';
+import { AreaCollection } from './prioritized/AreaCollection';
+import { IndexSet } from '../../utilities';
+/**
+ * Node collection that takes the set union of multiple node collections.
+ */
+export declare class UnionNodeCollection extends CombineNodeCollectionBase {
+    private _cachedNodeAreas;
+    static readonly classToken = "UnionNodeCollection";
+    constructor(nodeCollections?: NodeCollection[]);
+    serialize(): SerializedNodeCollection;
+    protected createCombinedIndexSet(): IndexSet;
+    getAreas(): AreaCollection;
+}

package/packages/cad-styling/src/prioritized/AreaCollection.d.ts

@@ -0,0 +1,39 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * Represents a collection of areas/axis-aligned
+ * bounding boxes for use e.g. for load prioritization. Implementations
+ * are not expected to store all areas inserted with `addAreas`,
+ * but rather some "representative box set" covering the inserted areas.
+ * Performance will be better the fewer boxes the representative set contains,
+ * while the effectiveness of node prioritization will suffer if the
+ * representative set covers too much area that is not part
+ * of the inserted boxes
+ */
+export interface AreaCollection {
+    readonly isEmpty: boolean;
+    /**
+     * Return some set of boxes that cover the boxes inserted with `addAreas`.
+     * It is required that each inserted box is completely covered by some
+     * subset of boxes in the set returned from `areas`
+     */
+    areas(): Generator<THREE.Box3>;
+    /**
+     * Return whether the input box intersects the AreaCollection.
+     */
+    intersectsBox(box: THREE.Box3): boolean;
+    /**
+     * Add areas to be covered by the representative set of this
+     * AreaCollection.
+     */
+    addAreas(boxes: Iterable<THREE.Box3>): void;
+    /**
+     * Alter the representative set to cover only the intersection between the
+     * representative set of this AreaCollection and the incoming boxes.
+     * Note that the intersection of two representative sets A' and B' that
+     * represent the original box sets A and B will cover the intersection between
+     * A and B, and will thus be a valid representative set for the intersection of A and B.
+     */
+    intersectWith(boxes: Iterable<THREE.Box3>): void;
+}

package/packages/cad-styling/src/prioritized/BoxClusterer.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { Box3 } from 'three';
+/**
+ * SmartMergeBoxes - takes in batches of bounding boxes and
+ * clusters them together in larger bounding boxes. The union of the larger
+ * boxes contains all boxes that have been inserted
+ */
+export declare class BoxClusterer {
+    private readonly resultBoxes;
+    private addedSinceSquash;
+    constructor();
+    constructor(boxes: Box3[]);
+    private mergeBoxesAtIndices;
+    private readonly _surfaceAreaVars;
+    private surfaceArea;
+    private readonly _shouldMergeBoxesVars;
+    private shouldMergeBoxes;
+    private addBox;
+    get boxCount(): number;
+    addBoxes(boxes: Iterable<Box3>): void;
+    squashBoxes(): void;
+    getBoxes(): Generator<Box3>;
+    intersectsBox(box: Box3): boolean;
+    union(boxes: Iterable<Box3>): BoxClusterer;
+    private addIntersectionIfNonempty;
+    intersection(other: Iterable<THREE.Box3>): BoxClusterer;
+}

package/packages/cad-styling/src/prioritized/ClusteredAreaCollection.d.ts

@@ -0,0 +1,17 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { AreaCollection } from './AreaCollection';
+/**
+ * AreaCollection that stores a representative box set by merging
+ * inserted boxes that are overlapping or close to each other.
+ * It uses simple heuristics to determine which boxes are to be merged.
+ */
+export declare class ClusteredAreaCollection implements AreaCollection {
+    private readonly _clusterer;
+    get isEmpty(): boolean;
+    areas(): Generator<THREE.Box3>;
+    intersectsBox(box: THREE.Box3): boolean;
+    addAreas(boxes: Iterable<THREE.Box3>): void;
+    intersectWith(boxes: Iterable<THREE.Box3>): void;
+}

package/packages/cad-styling/src/prioritized/EmptyAreaCollection.d.ts

@@ -0,0 +1,18 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { AreaCollection } from './AreaCollection';
+/**
+ * Convenience implementation to represent an empty collection of areas.
+ * that can be shared among several instances.
+ */
+export declare class EmptyAreaCollection implements AreaCollection {
+    private static _instance;
+    static instance(): AreaCollection;
+    private constructor();
+    areas(): Generator<THREE.Box3>;
+    intersectsBox(_box: THREE.Box3): boolean;
+    addAreas(_: Iterable<THREE.Box3>): void;
+    intersectWith(_: Iterable<THREE.Box3>): void;
+    get isEmpty(): boolean;
+}

package/packages/cad-styling/src/prioritized/types.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export declare type PrioritizedArea = {
+    area: THREE.Box3;
+    extraPriority: number;
+};

package/packages/camera-manager/index.d.ts

@@ -1,4 +1,6 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export { default } from './src/ComboControls';
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export { DefaultCameraManager } from './src/DefaultCameraManager';
+export { CameraManager } from './src/CameraManager';
+export * from './src/types';

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

@@ -0,0 +1,72 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { CameraChangedEvent, CameraState } from './types';
+/**
+ * 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
+ * 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}.
+     * Note that the camera will not be modified directly by Reveal.
+     * Implementations must trigger the `cameraChange`-event whenever the
+     * camera changes.
+     */
+    getCamera(): THREE.PerspectiveCamera;
+    /**
+     * Set camera's state. Rotation and target can't be set at the same time. as they could conflict.
+     *
+     * @param state Camera state, all fields are optional.
+     * @param state.position Camera position in world space.
+     * @param state.target Camera target in world space.
+     * @param state.rotation Camera local rotation in quaternion form.
+     * @example
+     * ```js
+     * // store position, target
+     * const { position, target } = cameraManager.getCameraState();
+     * // restore position, target
+     * cameraManager.setCameraState({ position, target });
+     * ```
+     */
+    setCameraState(state: CameraState): void;
+    /**
+     * Get camera's state
+     * @returns Camera state: position, target and rotation.
+     */
+    getCameraState(): Required<CameraState>;
+    /**
+     * Subscribes to changes of the camera event. This is used by Reveal to react on changes of the camera.
+     * @param event Name of the event.
+     * @param callback Callback to be called when the event is fired.
+     */
+    on(event: 'cameraChange', callback: CameraChangedEvent): void;
+    /**
+     * Unsubscribes from changes of the camera event.
+     * @param event Name of the event.
+     * @param callback Callback function to be unsubscribed.
+     */
+    off(event: 'cameraChange', callback: CameraChangedEvent): void;
+    /**
+     * Moves camera to a place where the content of a bounding box is visible to the camera.
+     * @param box The bounding box in world space.
+     * @param duration The duration of the animation moving the camera.
+     * @param radiusFactor The ratio of the distance from camera to center of box and radius of the box.
+     */
+    fitCameraToBoundingBox(boundingBox: THREE.Box3, duration?: number, radiusFactor?: number): void;
+    /**
+     * Updates internal state of camera manager. Expected to update visual state of the camera
+     * as well as it's near and far planes if needed. Called in `requestAnimationFrame`-loop.
+     * Reveal performance affects frequency with which this method is called.
+     * @param deltaTime Delta time since last update in seconds.
+     * @param boundingBox Global bounding box of the model(s) and any custom objects added to the scene.
+     */
+    update(deltaTime: number, boundingBox: THREE.Box3): void;
+    /**
+     * @obvious
+     */
+    dispose(): void;
+}