@cognite/reveal 4.0.0 → 4.1.0-dev.20230127

package/dist/packages/cad-parsers/src/utilities/SectorScene.d.ts

@@ -19,5 +19,16 @@ export declare class SectorSceneImpl implements SectorScene {
     getSectorsIntersectingBox(b: THREE.Box3): SectorMetadata[];
     getBoundsOfMostGeometry(): THREE.Box3;
     getSectorsIntersectingFrustum(projectionMatrix: THREE.Matrix4, inverseCameraModelMatrix: THREE.Matrix4): SectorMetadata[];
+    /**
+     * Recursive intersection detection.
+     */
+    private detectIntersectingBounds;
+    /**
+     * Use kmeans to group inputBounds into clusters.
+     *
+     * @param inBounds The bounds to be grouped into clusters.
+     * @returns Both the list of cluster bounds and the cluster with the highest node count
+     */
+    private generateClusters;
     private computeBoundsOfMostGeometry;
 }

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

@@ -76,7 +76,7 @@ export declare class ComboControls extends EventDispatcher {
     private readonly _scrollTarget;
     private readonly _targetEnd;
     private readonly _spherical;
-    private _sphericalEnd;
+    private readonly _sphericalEnd;
     private readonly _deltaTarget;
     private readonly _rawCameraRotation;
     private readonly _keyboard;

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

@@ -9,10 +9,12 @@ export declare class StationaryCameraManager implements CameraManager {
     private readonly _cameraChangedListeners;
     private readonly _domElement;
     private _defaultFOV;
+    private readonly _minFOV;
     private readonly _stopEventTrigger;
     private _isDragging;
     constructor(domElement: HTMLElement, camera: THREE.PerspectiveCamera);
     getCamera(): THREE.PerspectiveCamera;
+    get defaultFOV(): number;
     setCameraState(state: CameraState): void;
     getCameraState(): Required<CameraState>;
     activate(cameraManager: CameraManager): void;
@@ -21,10 +23,13 @@ export declare class StationaryCameraManager implements CameraManager {
     off(eventType: CameraManagerEventType, callback: CameraChangeDelegate): void;
     fitCameraToBoundingBox(boundingBox: THREE.Box3, _?: number, radiusFactor?: number): void;
     moveTo(targetPosition: THREE.Vector3, duration?: number): Promise<void>;
+    setFOV(fov: number): void;
     update(_: number, boundingBox: THREE.Box3): void;
     dispose(): void;
     private readonly enableDragging;
     private readonly disableDragging;
     private readonly rotateCamera;
     private readonly zoomCamera;
+    private getCursorRay;
+    private getTarget;
 }

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

@@ -80,4 +80,4 @@ export declare const CAMERA_MANAGER_EVENT_TYPE_LIST: readonly ["cameraChange", "
 /**
  * Union type of the supported camera manager event types
  */
-export type CameraManagerEventType = typeof CAMERA_MANAGER_EVENT_TYPE_LIST[number];
+export type CameraManagerEventType = (typeof CAMERA_MANAGER_EVENT_TYPE_LIST)[number];

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

@@ -17,6 +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 { cadFromCdfToThreeMatrix } from './src/utilities/applyDefaultModelTransformation';
 export { Image360Provider } from './src/Image360Provider';
 export { BinaryFileProvider, JsonFileProvider, File3dFormat, BlobOutputMetadata, Image360Descriptor, Image360FileProvider, Image360Face } from './src/types';

package/dist/packages/data-providers/src/pointcloud-stylable-object-providers/DummyPointCloudStylableObjectProvider.d.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import { ModelIdentifier } from '../../../data-providers';
+import { ModelIdentifier } from '../ModelIdentifier';
 import { PointCloudStylableObjectProvider } from '../PointCloudStylableObjectProvider';
 import { PointCloudObject } from './types';
 export declare class DummyPointCloudStylableObjectProvider implements PointCloudStylableObjectProvider {

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

@@ -4,14 +4,34 @@
 import { StylableObject } from './StylableObject';
 import { IShape } from '../../../utilities';
 import { Box3 } from 'three';
+import { AnnotationsAssetRef } from '@cognite/sdk';
 export type CdfPointCloudObjectAnnotation = {
     annotationId: number;
-    assetId?: number;
+    asset?: AnnotationsAssetRef;
     region: IShape[];
 };
+/**
+ * @public
+ * Metadata for a single point cloud object
+ */
 export type PointCloudObjectMetadata = {
+    /**
+     * The CDF Annotation ID associated with the point cloud object.
+     */
     annotationId: number;
+    /**
+     * The CDF Asset ID associated with the point cloud object, if any.
+     *
+     * @deprecated Use {@link PointCloudObjectMetadata.assetRef} instead.
+     */
     assetId?: number;
+    /**
+     * Asset identifiers for asset associated with this point cloud object, if any.
+     */
+    assetRef?: AnnotationsAssetRef;
+    /**
+     * The bounding box of this annotation
+     */
     boundingBox: Box3;
 };
 export type PointCloudObject = PointCloudObjectMetadata & {

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

@@ -3,5 +3,4 @@
  */
 import * as THREE from 'three';
 import { File3dFormat } from '../types';
-export declare const cadFromCdfToThreeMatrix: THREE.Matrix4;
 export declare function applyDefaultModelTransformation(matrix: THREE.Matrix4, format: File3dFormat | string): void;

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

@@ -1,5 +1,6 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import log from './src/Log';
-export default log;
+import defaultLog from './src/Log';
+declare const Log: defaultLog.RootLogger;
+export { Log };

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

@@ -64,6 +64,18 @@ export declare class CognitePointCloudModel {
      * @param out Preallocated `THREE.Matrix4` (optional)
      */
     getCdfToDefaultModelTransformation(out?: THREE.Matrix4): THREE.Matrix4;
+    /**
+     * Map point from CDF to model space, taking the model's custom transformation into account
+     * @param point Point to compute transformation from
+     * @param out Optional pre-allocated point
+     */
+    mapPointFromCdfToModelCoordinates(point: THREE.Vector3, out?: THREE.Vector3): THREE.Vector3;
+    /**
+     * Map bounding box from CDF to model space, taking the model's custom transformation into account
+     * @param box Box to compute transformation from
+     * @param out Optional pre-allocated box
+     */
+    mapBoxFromCdfToModelCoordinates(box: THREE.Box3, out?: THREE.Box3): THREE.Box3;
     /**
      * Sets a visible filter on points of a given class.
      * @param pointClass ASPRS classification class code. Either one of the well known
@@ -143,6 +155,11 @@ export declare class CognitePointCloudModel {
      * @see {@link PointShape}.
      */
     set pointShape(shape: PointShape);
+    /**
+     * Sets the clipping planes for this model. They will be combined with the
+     * global clipping planes.
+     */
+    setModelClippingPlanes(clippingPlanes: THREE.Plane[]): void;
     /**
      * Gets default point appearance
      */

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

@@ -1,6 +1,7 @@
 /*!
  * Copyright 2022 Cognite AS
  */
+import { AnnotationsAssetRef } from '@cognite/sdk';
 import { CognitePointCloudModel } from './CognitePointCloudModel';
 export type PointCloudIntersection = {
     /**
@@ -27,4 +28,8 @@ export type PointCloudIntersection = {
      * Annotation Id of the intersected object within a pointcloud. (0 if not applicable)
      */
     annotationId: number;
+    /**
+     * Reference to the asset associated to the intersected point cloud object, if any.
+     */
+    assetRef?: AnnotationsAssetRef;
 };

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

@@ -11,7 +11,7 @@ import { Matrix4, Group } from 'three';
 export declare class PointCloudNode extends Group {
     private readonly _cameraConfiguration?;
     private readonly _octree;
-    private readonly _annotations;
+    private readonly _objectIdToAnnotationsMap;
     private readonly _classificationHandler;
     private _needsRedraw;
     private static readonly pickingWindowSize;
@@ -78,9 +78,12 @@ export declare class PointCloudNode extends Group {
     getModelTransformation(out?: Matrix4): THREE.Matrix4;
     getCdfToDefaultModelTransformation(out?: Matrix4): Matrix4;
     get stylableObjectAnnotationMetadata(): Iterable<PointCloudObjectMetadata>;
-    get stylableObjects(): PointCloudObject[];
+    getStylableObjectMetadata(objectId: number): PointCloudObjectMetadata | undefined;
+    get stylableObjectCount(): number;
     get defaultAppearance(): CompletePointCloudAppearance;
     set defaultAppearance(appearance: CompletePointCloudAppearance);
+    set clippingPlanes(clippingPlanes: THREE.Plane[]);
     assignStyledPointCloudObjectCollection(styledCollection: StyledPointCloudObjectCollection): void;
     removeAllStyledPointCloudObjects(): void;
+    dispose(): void;
 }

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

@@ -4,6 +4,7 @@
 import * as THREE from 'three';
 import { IntersectInput } from '../../model-base';
 import { PointCloudNode } from './PointCloudNode';
+import { AnnotationsAssetRef } from '@cognite/sdk';
 export interface IntersectPointCloudNodeResult {
     /**
      * Distance from camera to intersected point.
@@ -29,6 +30,10 @@ export interface IntersectPointCloudNodeResult {
      * annotationId of the clicked object within a pointcloud.
      */
     annotationId: number;
+    /**
+     * asset reference of the clicked object in the pointcloud, if any.
+     */
+    assetRef?: AnnotationsAssetRef;
 }
 export declare class PointCloudPickingHandler {
     private readonly _normalized;

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

@@ -18,11 +18,13 @@ export declare class Potree implements IPotree {
     private readonly _modelDataProvider;
     private readonly _materialManager;
     private readonly _throttledUpdateFunc;
+    private _shouldLoad;
     maxNumNodesLoading: number;
     lru: LRU;
     constructor(modelDataProvider: ModelDataProvider, pointCloudMaterialManager: PointCloudMaterialManager);
     loadPointCloud(baseUrl: string, fileName: string, pointCloudObjects: PointCloudObject[], modelIdentifier: symbol): Promise<PointCloudOctree>;
     updatePointClouds(pointClouds: PointCloudOctree[], camera: Camera, renderer: WebGLRenderer): void;
+    set shouldLoad(value: boolean);
     private innerUpdatePointClouds;
     get pointBudget(): number;
     set pointBudget(value: number);

package/dist/packages/pointclouds/src/potree-three-loader/geometry/PointCloudEptGeometry.d.ts

@@ -16,7 +16,6 @@ export declare class PointCloudEptGeometry implements IPointCloudTreeGeometry {
     private readonly _spacing;
     private readonly _schema;
     private _root;
-    private readonly _projection;
     get loader(): EptBinaryLoader;
     get root(): PointCloudEptGeometryNode | undefined;
     set root(r: PointCloudEptGeometryNode | undefined);

package/dist/packages/pointclouds/src/potree-three-loader/tree/PointCloudOctree.d.ts

@@ -1,4 +1,4 @@
-import { Box3, Camera, Object3D, Ray, Sphere, WebGLRenderer } from 'three';
+import { Box3, Camera, Object3D, Plane, Ray, Sphere, WebGLRenderer } from 'three';
 import { IPointCloudTreeGeometry } from '../geometry/IPointCloudTreeGeometry';
 import { IPointCloudTreeGeometryNode } from '../geometry/IPointCloudTreeGeometryNode';
 import { PickParams } from './PointCloudOctreePicker';
@@ -29,14 +29,24 @@ export declare class PointCloudOctree extends PointCloudTree {
     showBoundingBox: boolean;
     private readonly visibleBounds;
     private picker;
+    private _globalClippingPlanes;
+    private _localClippingPlanes;
     constructor(potree: IPotree, pcoGeometry: IPointCloudTreeGeometry, material: PointCloudMaterial);
     private updateMaterial;
+    setGlobalClippingPlane(planes: Plane[]): void;
+    setModelClippingPlane(planes: Plane[]): void;
+    updateClippingPlanes(): void;
     dispose(): void;
     get pointSizeType(): PointSizeType;
     set pointSizeType(value: PointSizeType);
     toTreeNode(geometryNode: IPointCloudTreeGeometryNode, parent?: IPointCloudTreeNode | null): IPointCloudTreeNode;
     updateVisibleBounds(): void;
     updateBoundingBoxes(): void;
+    updateMatricesForDescendants(): void;
+    /**
+     * Override updateMatrixWorld to not update children recursively. Child transformations
+     * are defined in relation to the base octree, and are instead updated using updateMatricesfordescendants()
+     */
     updateMatrixWorld(force: boolean): void;
     hideDescendants(object: Object3D): void;
     moveToOrigin(): void;

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

@@ -11,7 +11,8 @@ export * from './src/pointcloud-rendering/types';
 export * from './src/pointcloud-rendering/PointCloudObjectIdMaps';
 export { DEFAULT_CLASSIFICATION } from './src/pointcloud-rendering/classification';
 export { RenderMode } from './src/rendering/RenderMode';
-export { RenderLayer } from './src/utilities/renderUtilities';
+export { RenderLayer, setModelRenderLayers } from './src/utilities/renderUtilities';
+export { StyledTreeIndexSets } from './src/utilities/types';
 export { coverageShaders } from './src/rendering/shaders';
 export { Materials } from './src/rendering/materials';
 export { PointCloudMaterial, OctreeMaterialParams } from './src/pointcloud-rendering';
@@ -20,3 +21,5 @@ export { CadGeometryRenderModePipelineProvider } from './src/render-pipeline-pro
 export { BasicPipelineExecutor } from './src/pipeline-executors/BasicPipelineExecutor';
 export { RenderPipelineExecutor } from './src/RenderPipelineExecutor';
 export { RenderPipelineProvider } from './src/RenderPipelineProvider';
+export { ResizeHandler } from './src/ResizeHandler';
+export { SettableRenderTarget } from './src/rendering/SettableRenderTarget';

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

@@ -22,6 +22,7 @@ export declare class CadMaterialManager {
     getModelNodeAppearanceProvider(modelIdentifier: string): NodeAppearanceProvider;
     getModelNodeTransformProvider(modelIdentifier: string): NodeTransformProvider;
     getModelDefaultNodeAppearance(modelIdentifier: string): NodeAppearance;
+    getModelClippingPlanes(modelIdentifier: string): THREE.Plane[];
     setModelClippingPlanes(modelIdentifier: string, clippingPlanes: THREE.Plane[]): void;
     setModelDefaultNodeAppearance(modelIdentifier: string, defaultAppearance: NodeAppearance): void;
     getModelBackTreeIndices(modelIdentifier: string): IndexSet;

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

@@ -6,13 +6,10 @@ import { PointCloudMaterial } from './pointcloud-rendering';
 import { PointCloudMaterialParameters } from './render-passes/types';
 export declare class PointCloudMaterialManager {
     private readonly _modelsMaterialsMap;
-    private _clippingPlanes;
     addModelMaterial(modelIdentifier: symbol, objectIdMaps: PointCloudObjectIdMaps): void;
     removeModelMaterial(modelIdentifier: symbol): void;
     getModelMaterial(modelIdentifier: symbol): PointCloudMaterial;
-    get clippingPlanes(): THREE.Plane[];
-    set clippingPlanes(clippingPlanes: THREE.Plane[]);
-    setClippingPlanesForPointCloud(modelIdentifier: symbol): void;
+    initializeClippingPlanesForPointCloud(modelIdentifier: symbol): void;
     setModelsMaterialParameters(materialParameters: PointCloudMaterialParameters | undefined): void;
     setMaterialParameters(material: PointCloudMaterial, parameters: PointCloudMaterialParameters): void;
     dispose(): void;

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

@@ -0,0 +1,29 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { WebGLRenderer, PerspectiveCamera } from 'three';
+import { CameraManager } from '../../camera-manager';
+export type ResizeHandlerOptions = {
+    renderResolutionThreshold?: number;
+};
+export declare class ResizeHandler {
+    private readonly _defaultResolutionThreshold;
+    private readonly _renderer;
+    private readonly _cameraManager;
+    private _stoppedCameraResolutionThreshold;
+    private _currentResolutionThreshold;
+    private _movingResolutionFactor;
+    private readonly _onCameraChangeCallback;
+    private readonly _onCameraStopCallback;
+    private readonly _resizeObserver;
+    private _shouldResize;
+    constructor(renderer: WebGLRenderer, cameraManager: CameraManager, resizeOptions?: ResizeHandlerOptions);
+    get needsRedraw(): boolean;
+    resetRedraw(): void;
+    setResolutionThreshold(threshold: number): void;
+    setMovingCameraResolutionFactor(factor: number): void;
+    handleResize(camera: PerspectiveCamera): void;
+    private setupResizeListener;
+    private resize;
+    dispose(): void;
+}

package/dist/packages/rendering/src/pipeline-executors/BasicPipelineExecutor.d.ts

@@ -4,19 +4,9 @@
 import * as THREE from 'three';
 import { RenderPipelineExecutor } from '../RenderPipelineExecutor';
 import { RenderPipelineProvider } from '../RenderPipelineProvider';
-export type BasicPipelineExecutorOptions = {
-    autoResizeRenderer: boolean;
-    resolutionThreshold?: number;
-};
 export declare class BasicPipelineExecutor implements RenderPipelineExecutor {
-    private readonly _defaultResolutionThreshold;
     private readonly _renderer;
-    private readonly _resolutionThreshold;
-    private readonly _resizeObserver;
-    private _shouldResize;
-    constructor(renderer: THREE.WebGLRenderer, options?: BasicPipelineExecutorOptions);
+    constructor(renderer: THREE.WebGLRenderer);
     render(renderPipeline: RenderPipelineProvider, camera: THREE.PerspectiveCamera): void;
-    private setupResizeListener;
-    private resize;
     dispose(): void;
 }

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

@@ -5,7 +5,7 @@ import { Camera, RawShaderMaterial, Texture, WebGLRenderer } from 'three';
 import { PointColorType, PointShape, PointSizeType } from './enums';
 import { PointClassification, IUniform, OctreeMaterialParams } from './types';
 import { PointCloudObjectAppearanceTexture } from './PointCloudObjectAppearanceTexture';
-import { PointCloudObjectIdMaps } from '../../../rendering';
+import { PointCloudObjectIdMaps } from './PointCloudObjectIdMaps';
 export interface IPointCloudMaterialParameters {
     size: number;
     minSize: number;
@@ -39,7 +39,6 @@ export interface IPointCloudMaterialUniforms {
 }
 export declare class PointCloudMaterial extends RawShaderMaterial {
     private static readonly helperVec3;
-    private static readonly helperVec2;
     /**
      * 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).
@@ -51,7 +50,7 @@ export declare class PointCloudMaterial extends RawShaderMaterial {
     visibleNodeTextureOffsets: Map<string, number>;
     private readonly _gradient;
     private gradientTexture;
-    private readonly _objectAppearanceTexture;
+    private _objectAppearanceTexture;
     private _classification;
     private classificationTexture;
     uniforms: IPointCloudMaterialUniforms & Record<string, IUniform<any>>;
@@ -108,6 +107,7 @@ export declare class PointCloudMaterial extends RawShaderMaterial {
     updateShaderSource(): void;
     applyDefines(shaderSrc: string): string;
     get objectAppearanceTexture(): PointCloudObjectAppearanceTexture;
+    set objectAppearanceTexture(texture: PointCloudObjectAppearanceTexture);
     get classification(): PointClassification;
     set classification(value: PointClassification);
     private recomputeClassification;
@@ -115,7 +115,7 @@ export declare class PointCloudMaterial extends RawShaderMaterial {
     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(): void;
-    updateMaterial(octreeParams: OctreeMaterialParams, visibilityTextureData: Uint8Array, camera: Camera, renderer: WebGLRenderer): void;
+    onBeforeRender(renderer: WebGLRenderer): void;
+    updateMaterial(octreeParams: OctreeMaterialParams, visibilityTextureData: Uint8Array, camera: Camera): void;
     private updateVisibilityTextureData;
 }

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

@@ -5,17 +5,15 @@ import * as THREE from 'three';
 import { StyledPointCloudObjectCollection, PointCloudObjectCollection, CompletePointCloudAppearance } from '../../../pointcloud-styling';
 import { PointCloudObjectIdMaps } from './PointCloudObjectIdMaps';
 export declare class PointCloudObjectAppearanceTexture {
-    private _objectStyleTexture;
+    private readonly _objectStyleTexture;
     private _needsReconstruction;
     private readonly _styledObjectSets;
     private _defaultAppearance;
     private readonly _width;
     private readonly _height;
     private _annotationIdsToObjectId;
-    private _objectIdsToAnnotationId;
     constructor(width: number, height: number);
     setObjectsMaps(objectsMaps: PointCloudObjectIdMaps): void;
-    convertObjectIdToAnnotationId(objectId: number): number;
     private appearanceToRgba;
     private setObjectStyle;
     private setObjectCollectionStyle;

package/dist/packages/rendering/src/render-pipeline-providers/CadGeometryRenderModePipelineProvider.d.ts

@@ -7,9 +7,8 @@ import { RenderPass } from '../RenderPass';
 import { RenderPipelineProvider } from '../RenderPipelineProvider';
 import { RenderMode } from '../rendering/RenderMode';
 import { SceneHandler } from '../../../utilities';
-export declare class CadGeometryRenderModePipelineProvider implements RenderPipelineProvider {
-    private readonly _materialManager;
-    private readonly _cadModels;
+import { SettableRenderTarget } from '../rendering/SettableRenderTarget';
+export declare class CadGeometryRenderModePipelineProvider implements RenderPipelineProvider, SettableRenderTarget {
     private readonly _renderTargetData;
     private readonly _geometryPass;
     private _outputRenderTarget;

package/dist/packages/rendering/src/render-pipeline-providers/DefaultRenderPipelineProvider.d.ts

@@ -8,14 +8,15 @@ import { RenderPipelineProvider } from '../RenderPipelineProvider';
 import { RenderOptions } from '../rendering/types';
 import { SceneHandler } from '../../../utilities';
 import { PointCloudMaterialManager } from '../PointCloudMaterialManager';
-export declare class DefaultRenderPipelineProvider implements RenderPipelineProvider {
+import { SettableRenderTarget } from '../rendering/SettableRenderTarget';
+export declare class DefaultRenderPipelineProvider implements RenderPipelineProvider, SettableRenderTarget {
     private readonly _viewerScene;
     private readonly _renderTargetData;
     private readonly _cadModels;
     private readonly _pointCloudModels;
     private readonly _customObjects;
-    private readonly _autoResizeOutputTarget;
-    private readonly _outputRenderTarget;
+    private _autoResizeOutputTarget;
+    private _outputRenderTarget;
     private readonly _cadGeometryRenderPipeline;
     private readonly _pointCloudRenderPipeline;
     private readonly _postProcessingPass;
@@ -29,6 +30,7 @@ export declare class DefaultRenderPipelineProvider implements RenderPipelineProv
         target: THREE.WebGLRenderTarget;
         autoSize?: boolean;
     });
+    setOutputRenderTarget(target: THREE.WebGLRenderTarget | null, autoSizeRenderTarget?: boolean): void;
     pipeline(renderer: THREE.WebGLRenderer): Generator<RenderPass>;
     dispose(): void;
     private pipelineSetup;

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

@@ -0,0 +1,9 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+/**
+ * Interface for allowing render targets in renderPipelines to be changed dynamicaly in RevealManager.
+ */
+export interface SettableRenderTarget {
+    setOutputRenderTarget(target: THREE.WebGLRenderTarget | null, autoSizeRenderTarget?: boolean): void;
+}

package/dist/packages/rendering/src/utilities/renderUtilities.d.ts

@@ -4,6 +4,7 @@
 import * as THREE from 'three';
 import { WebGLRendererStateHelper } from '../../../utilities';
 import { CadMaterialManager } from '../CadMaterialManager';
+import { StyledTreeIndexSets } from './types';
 import { BlitOptions, DepthBlendBlitOptions, PointCloudPassParameters, PointCloudPostProcessingOptions } from '../render-passes/types';
 export declare const unitOrthographicCamera: THREE.OrthographicCamera;
 export declare function createFullScreenTriangleMesh(shaderMaterial: THREE.RawShaderMaterial): THREE.Mesh;
@@ -18,14 +19,11 @@ export declare enum RenderLayer {
     PointCloud = 8,
     Default = 0
 }
-export declare function setupCadModelsGeometryLayers(materialManager: CadMaterialManager, cadModels?: {
-    cadNode: THREE.Object3D;
-    modelIdentifier: string;
-}[]): void;
 export declare function getLayerMask(renderLayer: number): number;
 export declare function hasStyledNodes(modelIdentifiers: string[], materialManager: CadMaterialManager): {
     back: boolean;
     inFront: boolean;
     ghost: boolean;
 };
+export declare function setModelRenderLayers(rootNode: THREE.Object3D, stylingSets: StyledTreeIndexSets): void;
 export declare function setRendererParameters(rendererHelper: WebGLRendererStateHelper, parameters: PointCloudPassParameters): void;

package/dist/packages/rendering/src/utilities/types.d.ts

@@ -1,6 +1,7 @@
 /*!
  * Copyright 2021 Cognite AS
  */
+import { IndexSet } from '../../../utilities';
 import * as THREE from 'three';
 /**
  * Colors from the Cognite theme.
@@ -24,3 +25,9 @@ export declare class RevealColors {
     static readonly Red: THREE.Color;
     static readonly Green: THREE.Color;
 }
+export type StyledTreeIndexSets = {
+    back: IndexSet;
+    ghost: IndexSet;
+    inFront: IndexSet;
+    visible: IndexSet;
+};

package/dist/packages/tools/src/Measurement/MeasurementLine.d.ts

@@ -7,7 +7,8 @@ export declare class MeasurementLine {
     private readonly _meshes;
     private readonly _fixedWidthLineMaterial;
     private readonly _adaptiveWidthLineMaterial;
-    private readonly _position;
+    private readonly _startPos;
+    private readonly _endpoint;
     constructor(lineWidth: number, lineColor: THREE.Color, startPoint: THREE.Vector3);
     dispose(): void;
     get meshes(): THREE.Group;
@@ -38,7 +39,6 @@ export declare class MeasurementLine {
     updateLineColor(color: THREE.Color): void;
     /**
      * Generate line geometry and create the mesh.
-     * @param point Point from where the line will be generated.
      */
     private startLine;
 }

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

@@ -34,6 +34,7 @@ export { calculateVolumeOfMesh } from './src/calculateVolumeOfMesh';
 export { worldToNormalizedViewportCoordinates, worldToViewportCoordinates, pixelToNormalizedDeviceCoordinates } from './src/worldToViewport';
 export { DeferredPromise } from './src/DeferredPromise';
 export { SceneHandler } from './src/SceneHandler';
+export { CDF_TO_VIEWER_TRANSFORMATION } from './src/constants';
 export * from './src/workers/workerize-transferable';
 export * from './src/shapes';
 export * from './src/linalg';

package/dist/packages/{api/src/public → utilities/src}/constants.d.ts

@@ -2,6 +2,7 @@
  * Copyright 2022 Cognite AS
  */
 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}