@cognite/reveal 3.0.2 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cognite/reveal",
-	"version": "3.0.2",
+	"version": "3.1.0",
 	"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": {
@@ -19,12 +19,11 @@
 	"main": "index.js",
 	"types": "index.d.ts",
 	"dependencies": {
-		"@cognite/potree-core": "1.5.2",
 		"@cognite/reveal-parser-worker": "1.3.0",
 		"@tweenjs/tween.js": "18.6.4",
 		"@types/draco3dgltf": "1.4.0",
-		"@types/geojson": "^7946.0.8",
-		"@types/three": "0.139.0",
+		"@types/geojson": "7946.0.8",
+		"@types/three": "0.140.0",
 		"assert": "2.0.0",
 		"comlink": "4.3.1",
 		"geo-three": "0.0.17",
@@ -33,9 +32,10 @@
 		"lodash": "4.17.21",
 		"loglevel": "1.8.0",
 		"mixpanel-browser": "2.45.0",
+		"proj4": "^2.8.0",
 		"rxjs": "7.5.5",
 		"skmeans": "0.11.3",
-		"three": "0.139.2"
+		"three": "0.140.2"
 	},
 	"peerDependencies": {
 		"@cognite/sdk": "^5.0.0 || ^6.0.0 || ^7.0.0",

package/packages/cad-geometry-loaders/index.d.ts

@@ -5,3 +5,6 @@ export { CadModelBudget, defaultDesktopCadModelBudget } from './src/CadModelBudg
 export { CadModelUpdateHandler } from './src/CadModelUpdateHandler';
 export { SectorCuller } from './src/sector/culling/SectorCuller';
 export { createV8SectorCuller } from './src/sector/culling/createV8SectorCuller';
+export { CadManager } from './src/CadManager';
+export { createCadManager } from './src/createCadManager';
+export { InternalRevealCadOptions } from './src/InternalRevealCadOptions';

package/packages/{cad-model → cad-geometry-loaders}/src/CadManager.d.ts

@@ -3,14 +3,12 @@
  */
 import * as THREE from 'three';
 import { Observable } from 'rxjs';
-import { CadModelFactory } from './CadModelFactory';
-import { CadModelSectorLoadStatistics } from './CadModelSectorLoadStatistics';
-import { GeometryFilter } from './GeometryFilter';
 import { CadModelMetadata } from '../../cad-parsers';
 import { CadModelUpdateHandler, CadModelBudget } from '../../cad-geometry-loaders';
 import { LoadingState } from '../../model-base';
-import { CadNode, CadMaterialManager, RenderMode } from '../../rendering';
+import { CadMaterialManager, RenderMode } from '../../rendering';
 import { ModelIdentifier } from '../../modeldata-api';
+import { CadModelFactory, CadModelSectorLoadStatistics, CadNode, GeometryFilter } from '../../cad-model';
 export declare class CadManager {
     private readonly _materialManager;
     private readonly _cadModelFactory;

package/packages/cad-geometry-loaders/src/CadModelUpdateHandler.d.ts

@@ -3,13 +3,13 @@
  */
 import * as THREE from 'three';
 import { ConsumedSector } from '../../cad-parsers';
-import { CadNode } from '../../rendering';
 import { Observable } from 'rxjs';
 import { SectorCuller } from './sector/culling/SectorCuller';
 import { CadLoadingHints } from './CadLoadingHints';
 import { LoadingState } from '../../model-base';
 import { CadModelBudget } from './CadModelBudget';
 import { SectorLoadingSpent } from './sector/culling/types';
+import { CadNode } from '../../cad-model';
 export declare class CadModelUpdateHandler {
     private readonly _sectorCuller;
     private readonly _modelStateHandler;

package/packages/{cad-model → cad-geometry-loaders}/src/createCadManager.d.ts

@@ -3,8 +3,8 @@
  */
 import { CadManager } from './CadManager';
 import { InternalRevealCadOptions } from './InternalRevealCadOptions';
-import { CadMaterialManager, EffectRenderManager } from '../../rendering';
+import { CadMaterialManager, CadGeometryRenderModePipelineProvider } from '../../rendering';
 import { ModelDataProvider, ModelMetadataProvider } from '../../modeldata-api';
-export declare function createCadManager(modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider, renderer: THREE.WebGLRenderer, materialManager: CadMaterialManager, renderManager: EffectRenderManager, cadOptions: InternalRevealCadOptions & {
+export declare function createCadManager(modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider, renderer: THREE.WebGLRenderer, materialManager: CadMaterialManager, depthOnlyRenderPipeline: CadGeometryRenderModePipelineProvider, cadOptions: InternalRevealCadOptions & {
     continuousModelStreaming?: boolean;
 }): CadManager;

package/packages/cad-geometry-loaders/src/sector/culling/OrderSectorsByVisibilityCoverage.d.ts

@@ -3,7 +3,7 @@
  */
 import * as THREE from 'three';
 import { CadModelMetadata, WantedSector } from '../../../../cad-parsers';
-import { EffectRenderManager } from '../../../../rendering';
+import { CadGeometryRenderModePipelineProvider } from '../../../../rendering';
 /**
  * Options for OrderSectorsByVisibleCoverage.
  */
@@ -13,9 +13,9 @@ export interface OrderSectorsByVisibleCoverageOptions {
      */
     renderer: THREE.WebGLRenderer;
     /**
-     * EffectRenderManager used to initialize the RenderAlreadyLoadedGeometryProvider
+     * GeometryDepthRenderPipeline used to initialize the RenderAlreadyLoadedGeometryProvider
      */
-    renderManager: EffectRenderManager;
+    depthOnlyRenderPipeline: CadGeometryRenderModePipelineProvider;
 }
 export declare type PrioritizedSectorIdentifier = {
     /**

package/packages/cad-geometry-loaders/src/sector/culling/RenderAlreadyLoadedGeometryProvider.d.ts

@@ -1,9 +1,11 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { EffectRenderManager } from '../../../../rendering';
+import * as THREE from 'three';
+import { CadGeometryRenderModePipelineProvider } from '../../../../rendering';
 export declare class RenderAlreadyLoadedGeometryProvider {
-    private readonly _renderManager;
-    constructor(renderManager: EffectRenderManager);
+    private readonly _depthOnlyRenderPipeline;
+    private readonly _basicPipelineExecutor;
+    constructor(renderer: THREE.WebGLRenderer, depthOnlyRenderPipeline: CadGeometryRenderModePipelineProvider);
     renderOccludingGeometry(target: THREE.WebGLRenderTarget | null, camera: THREE.PerspectiveCamera): void;
 }

package/packages/cad-geometry-loaders/src/sector/culling/createV8SectorCuller.d.ts

@@ -2,6 +2,6 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { EffectRenderManager } from '../../../../rendering';
+import { CadGeometryRenderModePipelineProvider } from '../../../../rendering';
 import { SectorCuller } from './SectorCuller';
-export declare function createV8SectorCuller(renderer: THREE.WebGLRenderer, renderManager: EffectRenderManager): SectorCuller;
+export declare function createV8SectorCuller(renderer: THREE.WebGLRenderer, depthOnlyRenderPipeline: CadGeometryRenderModePipelineProvider): SectorCuller;

package/packages/cad-geometry-loaders/src/sector/culling/types.d.ts

@@ -6,7 +6,7 @@ import { PrioritizedArea } from '../../../../cad-styling';
 import { CadModelMetadata, LevelOfDetail, WantedSector } from '../../../../cad-parsers';
 import { CadLoadingHints } from '../../CadLoadingHints';
 import { CadModelBudget } from '../../CadModelBudget';
-import { CadNode } from '../../../../rendering';
+import { CadNode } from '../../../../cad-model';
 export interface DetermineSectorsInput {
     camera: THREE.PerspectiveCamera;
     clippingPlanes: THREE.Plane[];

package/packages/cad-model/index.d.ts

@@ -1,12 +1,9 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-export { CadManager } from './src/CadManager';
-export { GeometryFilter } from './src/GeometryFilter';
-export { CadModelSectorLoadStatistics } from './src/CadModelSectorLoadStatistics';
-export { intersectCadNodes } from './src/picking';
-export { createCadManager } from './src/createCadManager';
-export { BoundingBoxClipper } from './src/BoundingBoxClipper';
-export { InternalRevealCadOptions } from './src/InternalRevealCadOptions';
-export { Cognite3DModel } from './src/Cognite3DModel';
-export { WellKnownUnit } from './src/WellKnownUnit';
+export { BoundingBoxClipper } from './src/utilities/BoundingBoxClipper';
+export { Cognite3DModel } from './src/wrappers/Cognite3DModel';
+export { PickingHandler } from './src/picking/PickingHandler';
+export { CadNode } from './src/wrappers/CadNode';
+export { CadModelFactory } from './src/CadModelFactory';
+export { WellKnownUnit, GeometryFilter, CadModelSectorLoadStatistics } from './src/types';

package/packages/cad-model/src/CadModelFactory.d.ts

@@ -1,7 +1,8 @@
-import { GeometryFilter } from './GeometryFilter';
-import { CadMaterialManager, CadNode } from '../../rendering';
+import { GeometryFilter } from './types';
+import { CadMaterialManager } from '../../rendering';
 import { CadModelMetadata } from '../../cad-parsers';
 import { ModelDataProvider, ModelMetadataProvider, ModelIdentifier } from '../../modeldata-api';
+import { CadNode } from './wrappers/CadNode';
 export declare class CadModelFactory {
     private readonly _materialManager;
     private readonly _modelDataProvider;

package/packages/{rendering/src → cad-model/src/batching}/GeometryBatchingManager.d.ts

@@ -2,8 +2,8 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { ParsedGeometry } from '../../sector-parser';
-import { Materials } from './rendering/materials';
+import { ParsedGeometry } from '../../../sector-parser';
+import { Materials } from '../../../rendering';
 export declare class GeometryBatchingManager {
     private readonly _batchedGeometriesGroup;
     private readonly _materials;

package/packages/{rendering/src → cad-model/src/batching}/InstancedMeshManager.d.ts

@@ -2,8 +2,8 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { InstancedMeshFile } from '../../cad-parsers';
-import { CadMaterialManager } from './CadMaterialManager';
+import { InstancedMeshFile } from '../../../cad-parsers';
+import { CadMaterialManager } from '../../../rendering';
 export declare class InstancedMeshManager {
     private readonly _instancedGeometryMap;
     private readonly _instancedAttributeMap;

package/packages/cad-model/src/picking/PickingHandler.d.ts

@@ -0,0 +1,35 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import * as THREE from 'three';
+import { IntersectInput } from '../../../model-base';
+import { CadMaterialManager } from '../../../rendering';
+import { SceneHandler } from '../../../utilities';
+import { CadNode } from '../wrappers/CadNode';
+declare type IntersectCadNodesResult = {
+    distance: number;
+    point: THREE.Vector3;
+    treeIndex: number;
+    cadNode: CadNode;
+    object: THREE.Object3D;
+};
+export declare class PickingHandler {
+    private readonly _clearColor;
+    private readonly _clearAlpha;
+    private readonly _pickPixelColorStorage;
+    private readonly _rgbaVector;
+    private readonly _unpackFactors;
+    private readonly _pipelineExecutor;
+    private readonly _depthRenderPipeline;
+    private readonly _treeIndexRenderPipeline;
+    constructor(renderer: THREE.WebGLRenderer, materialManager: CadMaterialManager, sceneHandler: SceneHandler);
+    intersectCadNodes(cadNodes: CadNode[], input: IntersectInput): IntersectCadNodesResult[];
+    intersectCadNode(cadNode: CadNode, input: IntersectInput): IntersectCadNodesResult | undefined;
+    private pickTreeIndex;
+    private perspectiveDepthToViewZ;
+    private pickDepth;
+    private getPosition;
+    private pickPixel;
+    private unpackRGBAToDepth;
+}
+export {};

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

@@ -0,0 +1,59 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+/**
+ * Units supported by {@link Cognite3DModel}.
+ */
+export declare type WellKnownUnit = 'Meters' | 'Centimeters' | 'Millimeters' | 'Micrometers' | 'Kilometers' | 'Feet' | 'Inches' | 'Yards' | 'Miles' | 'Mils' | 'Microinches';
+export declare 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 isBoundingBoxInModelCoordinates}.
+     */
+    boundingBox?: THREE.Box3;
+    /**
+     * When set, the geometry filter {@link 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 declare type CadModelSectorLoadStatistics = {
+    /**
+     * Estimated number of bytes to download sectors.
+     */
+    readonly downloadSize: number;
+    /**
+     * Estimated number of draw calls required to draw sectors.
+     */
+    readonly drawCalls: number;
+    /**
+     * Total number of sectors to load.
+     */
+    readonly loadedSectorCount: number;
+    /**
+     * Number of 'simple' sectors to load.
+     */
+    readonly simpleSectorCount: number;
+    /**
+     * Number of 'detailed' sectors to load.
+     */
+    readonly detailedSectorCount: number;
+    /**
+     * How many sectors that was "forced prioritized", e.g.
+     * because they are near the camera.
+     */
+    readonly forcedDetailedSectorCount: number;
+    /**
+     * The total number of sectors in models we are loading.
+     */
+    readonly totalSectorCount: number;
+    /**
+     * How much of the prioritized nodes that are loaded (between 0 and 1).
+     */
+    readonly accumulatedPriority: number;
+};

package/packages/{rendering/src/sector → cad-model/src/wrappers}/CadNode.d.ts

@@ -2,14 +2,11 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { CadMaterialManager } from '../CadMaterialManager';
-import { SectorQuads } from '../rendering/types';
-import { NodeTransformProvider } from '../transform/NodeTransformProvider';
-import { RenderMode } from '../rendering/RenderMode';
 import { NodeAppearanceProvider, NodeAppearance, PrioritizedArea } from '../../../cad-styling';
 import { SectorScene, CadModelMetadata, SectorGeometry, InstancedMeshFile, RootSectorNode, WantedSector, ConsumedSector } from '../../../cad-parsers';
 import { SectorRepository } from '../../../sector-loader';
 import { ParsedGeometry } from '../../../sector-parser';
+import { CadMaterialManager, NodeTransformProvider, RenderMode, SectorQuads } from '../../../rendering';
 export declare type ParseCallbackDelegate = (parsed: {
     lod: string;
     data: SectorGeometry | SectorQuads;
@@ -21,7 +18,7 @@ export declare class CadNode extends THREE.Object3D {
     private readonly _sectorRepository;
     private _rootSector;
     private _sectorScene;
-    private _geometryBatchingManager;
+    private _geometryBatchingManager?;
     constructor(model: CadModelMetadata, materialManager: CadMaterialManager, sectorRepository: SectorRepository);
     get nodeTransformProvider(): NodeTransformProvider;
     get nodeAppearanceProvider(): NodeAppearanceProvider;

package/packages/cad-model/src/{Cognite3DModel.d.ts → wrappers/Cognite3DModel.d.ts}

@@ -3,10 +3,10 @@
  */
 import * as THREE from 'three';
 import { CogniteInternalId } from '@cognite/sdk';
-import { WellKnownUnit } from './WellKnownUnit';
-import { SupportedModelTypes, CogniteModelBase } from '../../model-base';
-import { NumericRange, CameraConfiguration } from '../../utilities';
-import { NodeAppearance, NodeCollection, CdfModelNodeCollectionDataProvider } from '../../cad-styling';
+import { SupportedModelTypes, CogniteModelBase } from '../../../model-base';
+import { NumericRange, CameraConfiguration } from '../../../utilities';
+import { NodeAppearance, NodeCollection, CdfModelNodeCollectionDataProvider } from '../../../cad-styling';
+import { WellKnownUnit } from '../types';
 /**
  * Represents a single 3D CAD model loaded from CDF.
  * @noInheritDoc

package/packages/cad-parsers/src/cad/primitiveGeometries.d.ts

@@ -3,11 +3,11 @@
  */
 import * as THREE from 'three';
 export declare const boxGeometry: {
-    index: THREE.BufferAttribute;
+    index: THREE.BufferAttribute | null;
     position: THREE.BufferAttribute | THREE.InterleavedBufferAttribute;
 }, boxGeometryBoundingBox: THREE.Box3;
 export declare const quadGeometry: {
-    index: THREE.BufferAttribute;
+    index: THREE.BufferAttribute | null;
     position: THREE.BufferAttribute | THREE.InterleavedBufferAttribute;
     normal: THREE.BufferAttribute | THREE.InterleavedBufferAttribute;
 }, quadGeometryBoundingBox: THREE.Box3;
@@ -24,7 +24,7 @@ export declare const torusLodGeometries: {
     position: THREE.Float32BufferAttribute;
 }[];
 export declare const nutGeometry: {
-    index: THREE.BufferAttribute;
+    index: THREE.BufferAttribute | null;
     position: THREE.BufferAttribute | THREE.InterleavedBufferAttribute;
     normal: THREE.BufferAttribute | THREE.InterleavedBufferAttribute;
 }, nutGeometryBoundingBox: THREE.Box3;

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

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

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

@@ -62,7 +62,7 @@ export declare class ComboControls extends EventDispatcher {
     private _targetFPSOverActualFPS;
     private _isFocused;
     constructor(camera: PerspectiveCamera | OrthographicCamera, domElement: HTMLElement);
-    update: (deltaTime: number) => boolean;
+    update: (deltaTime: number, forceUpdate?: boolean) => boolean;
     getState: () => {
         target: Vector3;
         position: Vector3;

package/packages/modeldata-api/index.d.ts

@@ -9,4 +9,4 @@ export { LocalModelIdentifier } from './src/LocalModelIdentifier';
 export { LocalModelMetadataProvider } from './src/LocalModelMetadataProvider';
 export { ModelIdentifier } from './src/ModelIdentifier';
 export { ModelMetadataProvider } from './src/ModelMetadataProvider';
-export { BinaryFileProvider, File3dFormat, HttpHeadersProvider, ModelDataProvider, BlobOutputMetadata } from './src/types';
+export { BinaryFileProvider, File3dFormat, ModelDataProvider, BlobOutputMetadata } from './src/types';

package/packages/modeldata-api/src/CdfModelDataProvider.d.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { CogniteClient, HttpHeaders } from '@cognite/sdk';
+import { CogniteClient } from '@cognite/sdk';
 import { ModelDataProvider } from './types';
 /**
  * Provides 3D V2 specific extensions for the standard CogniteClient used by Reveal.
@@ -10,7 +10,6 @@ export declare class CdfModelDataProvider implements ModelDataProvider {
     private readonly client;
     private authenticationPromise;
     constructor(client: CogniteClient);
-    get headers(): HttpHeaders;
     getBinaryFile(baseUrl: string, fileName: string): Promise<ArrayBuffer>;
     getJsonFile(baseUrl: string, fileName: string): Promise<any>;
     private fetchWithRetry;

package/packages/modeldata-api/src/LocalModelDataProvider.d.ts

@@ -1,10 +1,8 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { HttpHeaders } from '@cognite/sdk-core';
 import { ModelDataProvider } from './types';
 export declare class LocalModelDataProvider implements ModelDataProvider {
-    get headers(): HttpHeaders;
     getBinaryFile(baseUrl: string, fileName: string): Promise<ArrayBuffer>;
     getJsonFile(baseUrl: string, fileName: string): Promise<any>;
 }

package/packages/modeldata-api/src/LocalModelMetadataProvider.d.ts

@@ -4,10 +4,10 @@
 import * as THREE from 'three';
 import { ModelIdentifier } from './ModelIdentifier';
 import { ModelMetadataProvider } from './ModelMetadataProvider';
-import { BlobOutputMetadata } from './types';
+import { BlobOutputMetadata, File3dFormat } from './types';
 export declare class LocalModelMetadataProvider implements ModelMetadataProvider {
     getModelUri(modelIdentifier: ModelIdentifier): Promise<string>;
-    getModelMatrix(modelIdentifier: ModelIdentifier): Promise<THREE.Matrix4>;
+    getModelMatrix(modelIdentifier: ModelIdentifier, format: File3dFormat): Promise<THREE.Matrix4>;
     getModelCamera(modelIdentifier: ModelIdentifier): Promise<{
         position: THREE.Vector3;
         target: THREE.Vector3;

package/packages/modeldata-api/src/types.d.ts

@@ -1,7 +1,6 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { HttpHeaders } from '@cognite/sdk-core';
 export interface JsonFileProvider {
     getJsonFile(baseUrl: string, fileName: string): Promise<any>;
 }
@@ -11,7 +10,7 @@ export interface BinaryFileProvider {
 /**
  * Provides data for 3D models.
  */
-export interface ModelDataProvider extends HttpHeadersProvider, JsonFileProvider, BinaryFileProvider {
+export interface ModelDataProvider extends JsonFileProvider, BinaryFileProvider {
     /**
      * Download and parse a JSON file and return the resulting struct.
      * @param baseUrl     Base URL of the model.
@@ -25,9 +24,6 @@ export interface ModelDataProvider extends HttpHeadersProvider, JsonFileProvider
      */
     getBinaryFile(baseUrl: string, fileName: string): Promise<ArrayBuffer>;
 }
-export interface HttpHeadersProvider {
-    readonly headers: HttpHeaders;
-}
 export declare enum File3dFormat {
     EptPointCloud = "ept-pointcloud",
     /**

package/packages/pointclouds/index.d.ts

@@ -2,10 +2,14 @@
  * Copyright 2022 Cognite AS
  */
 export { intersectPointClouds } from './src/picking';
-export { PotreePointShape, PotreePointColorType, PotreePointSizeType, WellKnownAsprsPointClassCodes } from './src/types';
+export { WellKnownAsprsPointClassCodes } from './src/types';
+export { PotreePointShape, PotreePointColorType, PotreePointSizeType } from './src/potree-three-loader';
 export { PointCloudNode } from './src/PointCloudNode';
 export { PointCloudManager } from './src/PointCloudManager';
 export { createPointCloudManager } from './src/createPointCloudManager';
 export { PointCloudBudget } from './src/PointCloudBudget';
 export { PointCloudIntersection } from './src/PointCloudIntersection';
 export { CognitePointCloudModel } from './src/CognitePointCloudModel';
+export { PotreeNodeWrapper } from './src/PotreeNodeWrapper';
+export { PotreeGroupWrapper } from './src/PotreeGroupWrapper';
+export { Potree, PointCloudOctree } from './src/PotreePnextLoader';

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

@@ -3,7 +3,8 @@
  */
 import * as THREE from 'three';
 import { CameraConfiguration } from '../../utilities';
-import { PotreePointColorType, PotreePointShape, WellKnownAsprsPointClassCodes } from './types';
+import { WellKnownAsprsPointClassCodes } from './types';
+import { PotreePointColorType, PotreePointShape, PotreePointSizeType } from './potree-three-loader';
 import { SupportedModelTypes, CogniteModelBase } from '../../model-base';
 /**
  * Represents a point clouds model loaded from CDF.
@@ -106,6 +107,16 @@ export declare class CognitePointCloudModel extends THREE.Object3D implements Co
      * @default `1`
      */
     set pointSize(size: number);
+    /**
+     * Get the point size type.
+     */
+    get pointSizeType(): PotreePointSizeType;
+    /**
+     * Set the point size type for the point cloud.
+     * The point size type can be either Fixed or Adaptive.
+     * @default `PotreePointSizeType.Adaptive`
+     */
+    set pointSizeType(type: PotreePointSizeType);
     /**
      * Sets the point shape of each rendered point in the point cloud.
      * @default `PotreePointShape.Circle`

package/packages/pointclouds/src/PointCloudFactory.d.ts

@@ -1,9 +1,13 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
 import { PotreeNodeWrapper } from './PotreeNodeWrapper';
 import { PointCloudMetadata } from './PointCloudMetadata';
-import { HttpHeadersProvider } from '../../modeldata-api';
+import { ModelDataProvider } from '../../modeldata-api';
+import { Potree } from './potree-three-loader';
 export declare class PointCloudFactory {
-    private readonly _httpHeadersProvider;
-    constructor(httpHeadersProvider: HttpHeadersProvider);
-    createModel(modelMetadata: PointCloudMetadata): PotreeNodeWrapper;
-    private initializePointCloudXhrRequestHeaders;
+    private readonly _potreeInstance;
+    constructor(modelLoader: ModelDataProvider);
+    get potreeInstance(): Potree;
+    createModel(modelMetadata: PointCloudMetadata): Promise<PotreeNodeWrapper>;
 }

package/packages/pointclouds/src/PointCloudManager.d.ts

@@ -6,21 +6,32 @@ import { LoadingState } from '../../model-base';
 import { PointCloudFactory } from './PointCloudFactory';
 import { PointCloudNode } from './PointCloudNode';
 import { PointCloudMetadataRepository } from './PointCloudMetadataRepository';
+import { PotreeGroupWrapper } from './PotreeGroupWrapper';
+import { PointCloudOctree } from './potree-three-loader';
 import { Observable } from 'rxjs';
 import { ModelIdentifier } from '../../modeldata-api';
 export declare class PointCloudManager {
     private readonly _pointCloudMetadataRepository;
     private readonly _pointCloudFactory;
     private readonly _pointCloudGroupWrapper;
-    constructor(metadataRepository: PointCloudMetadataRepository, modelFactory: PointCloudFactory);
+    private readonly _cameraSubject;
+    private readonly _modelSubject;
+    private readonly _budgetSubject;
+    private readonly _renderer;
+    private _clippingPlanes;
+    constructor(metadataRepository: PointCloudMetadataRepository, modelFactory: PointCloudFactory, scene: THREE.Scene, renderer: THREE.WebGLRenderer);
+    get pointCloudGroupWrapper(): PotreeGroupWrapper;
     requestRedraw(): void;
     resetRedraw(): void;
     get pointBudget(): number;
     set pointBudget(points: number);
     get needsRedraw(): boolean;
     set clippingPlanes(planes: THREE.Plane[]);
+    setClippingPlanesForPointCloud(octree: PointCloudOctree): void;
     getLoadingStateObserver(): Observable<LoadingState>;
-    updateCamera(_camera: THREE.PerspectiveCamera): void;
+    updatePointClouds(camera: THREE.PerspectiveCamera): void;
+    updateCamera(camera: THREE.PerspectiveCamera): void;
     addModel(modelIdentifier: ModelIdentifier): Promise<PointCloudNode>;
     removeModel(node: PointCloudNode): void;
+    private loadedModelsObservable;
 }

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

@@ -5,7 +5,8 @@ import * as THREE from 'three';
 import { CameraConfiguration } from '../../utilities';
 import { PotreeGroupWrapper } from './PotreeGroupWrapper';
 import { PotreeNodeWrapper } from './PotreeNodeWrapper';
-import { PotreePointSizeType, PotreePointColorType, PotreePointShape, WellKnownAsprsPointClassCodes } from './types';
+import { WellKnownAsprsPointClassCodes } from './types';
+import { PickPoint, PotreePointColorType, PotreePointShape, PotreePointSizeType } from './potree-three-loader';
 export declare class PointCloudNode extends THREE.Group {
     private readonly _potreeGroup;
     private readonly _potreeNode;
@@ -20,14 +21,20 @@ export declare class PointCloudNode extends THREE.Group {
     get pointSize(): number;
     set pointSize(size: number);
     get pointSizeType(): PotreePointSizeType;
-    set pointSizeType(value: PotreePointSizeType);
-    get pointBudget(): number;
-    set pointBudget(count: number);
+    set pointSizeType(pointSizeType: PotreePointSizeType);
     get visiblePointCount(): number;
     get pointColorType(): PotreePointColorType;
     set pointColorType(type: PotreePointColorType);
     get pointShape(): PotreePointShape;
     set pointShape(value: PotreePointShape);
+    /**
+     * GPU-based picking allowing to get point data based on ray directing from the camera.
+     * @param renderer Renderer object used for Reveal rendereing.
+     * @param camera Camera object used for Reveal rendering.
+     * @param ray Ray representing the direction for picking.
+     * @returns Picked point data.
+     */
+    pick(renderer: THREE.WebGLRenderer, camera: THREE.Camera, ray: THREE.Ray): PickPoint | null;
     /**
      * Sets a visible filter on points of a given class.
      * @param pointClass ASPRS classification class code. Either one of the well known