@cognite/reveal 2.0.0-beta.4 → 2.2.0

package/README.md

@@ -14,13 +14,18 @@ import { CogniteClient } from "@cognite/sdk";
 const appId = "com.cognite.reveal.example";
 const client = new CogniteClient({ appId });
 
-client.loginWithOAuth({ project: "publicdata" });
+async function start() {
+  await client.loginWithOAuth({ type: "CDF_OAUTH", options: { project: "publicdata" }});
+  await client.authenticate();
 
-const viewer = new Cognite3DViewer({
-  sdk: client,
-  domElement: document.querySelector("#your-element-for-viewer")
-});
-viewer.addModel({ modelId: 4715379429968321, revisionId: 5688854005909501 });
+  const viewer = new Cognite3DViewer({
+    sdk: client,
+    domElement: document.querySelector("#your-element-for-viewer")
+  });
+  viewer.addModel({ modelId: 4715379429968321, revisionId: 5688854005909501 });
+}
+
+start();
 ```
 
 ## Installation
@@ -43,3 +48,73 @@ In case if you see an error like that:
 > Refused to load the script 'https://apps-cdn.cogniteapp.com/@cognite/reveal-parser-worker/1.1.0/reveal.parser.worker.js' because it violates the following Content Security Policy directive: "script-src 'self' https://localhost:* blob:"
 
 See the next steps in our [documentation](https://cognitedata.github.io/reveal-docs/docs/installation#installation-for-projects-with-content-security-policy).
+
+## Local Packages
+The Reveal viewer is structured using local packages.
+This allows you to test features in isolation and constrain the dependencies with logical barriers between features.
+Packages are located in the `/packages/` subfolder.
+There is no enforced structure of the packages and their layout and content will vary depending on what the package exposes to the rest of the system.
+Dependencies that are located in the `viewer/package.json` will be shared and are accessible by any package without having to explicitly declare a dependency in the respective package's `package.json`.
+Any external dependency (e.g. `lodash`, `threejs`, etc.) must be declared in the root `package.json` such that they will be properly installed by users that consume the `Reveal` NPM package. 
+
+### Creating a local package
+Create a new folder under the `/packages/` folder, e.g. `/packages/[MY-PACKAGE-NAME]` and include a package with the following structure:
+
+```json
+{
+  "name": "@reveal/[MY-PACKAGE-NAME]",
+  "private": true,
+  "main": "index.ts",
+}
+```
+
+Technically the `private: true` field can be omitted but it is highly recommended such that one does not accidentally publish the local package to NPM with the `npm publish` command.
+The `index.ts` should include any types, functions and/or classes you wish to expose to consumers of this package. You should also create a `README.md` file for your package that explains its intent and any information that is needed to use the package.
+
+If your package depends on another local package, it must be explicitly declared as a dependency:
+```json
+{
+  "name": "@reveal/[MY-PACKAGE-NAME]",
+  "private": true,
+  "main": "index.ts",
+  "dependencies": {
+    "@reveal/[SOME-LOCAL-PACKAGE]": "workspace:*"
+  }
+}
+```
+The `workspace` keyword declares that the dependency is a local package and should never be fetched from NPM.
+And the `':*'` syntax means that it should just grab any version available. See [this](https://yarnpkg.com/features/workspaces) for more documentation on yarn workspaces.
+
+It is also possible to run and test a local package in isolation from the rest of Reveal.
+Convenience functionality has been created to make this easy.
+Add the following script to your package's `package.json`:
+```json
+{
+  "scripts": {
+    "test": "yarn ws:test --config ./../../jest.config.js"
+  }
+}
+```
+Running `yarn run test` will run all tests in your package that resolves the `*.test.*` regex pattern.
+
+To run a test app that includes your package (and any dependencies), create a `/app/` subfolder in your package that includes an `index.ts` file.
+Add the following script to your package's `package.json`:
+```json
+{
+  "scripts": {
+    "start": "yarn ws:start"
+  }
+}
+```
+
+Running the command `yarn start` will host a localhost site with a template HTML that includes the `/app/index.ts` script that has been transpiled to javascript.
+To see an example of this check out the `packages/camera-manager` package.
+
+### Recommended package folder structure
+    ├── app                   # Runnable app
+      └──index.ts             # Entry point for runnable app
+    ├── src                   # Source code for package
+    ├── test                  # Automated tests
+    ├── package.json          # Package declaration
+    ├── index.ts              # Entry point for package
+    └── README.md             # Readme

package/core/cad.d.ts

@@ -0,0 +1,4 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export { LevelOfDetail, SectorNode } from '../packages/cad-parsers';

package/core/index.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export { Cognite3DViewer } from './src/public/migration/Cognite3DViewer';
+export { Cognite3DModel } from './src/public/migration/Cognite3DModel';
+export { CogniteModelBase } from './src/public/migration/CogniteModelBase';
+export * from './src/public/types';

package/{datamodels → core/src/datamodels}/base/index.d.ts

@@ -1,6 +1,6 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-export { MetadataRepository } from './MetadataRepository';
+export { MetadataRepository } from '../../../../packages/cad-parsers';
 export * from './SupportedModelTypes';
 export * from './types';

package/{datamodels → core/src/datamodels}/base/types.d.ts

@@ -8,6 +8,7 @@ export interface IntersectInput {
         y: number;
     };
     camera: THREE.PerspectiveCamera;
+    clippingPlanes: THREE.Plane[];
     renderer: THREE.WebGLRenderer;
     domElement: HTMLElement;
 }

package/{datamodels → core/src/datamodels}/cad/CadManager.d.ts

@@ -2,18 +2,15 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { CadNode } from './CadNode';
+import { Observable } from 'rxjs';
 import { CadModelFactory } from './CadModelFactory';
-import { CadModelMetadataRepository } from './CadModelMetadataRepository';
-import { CadModelUpdateHandler } from './CadModelUpdateHandler';
-import { CadMaterialManager } from './CadMaterialManager';
-import { RenderMode } from './rendering/RenderMode';
-import { LoadingState } from '../../utilities';
-import { CadModelSectorBudget } from './CadModelSectorBudget';
 import { CadModelSectorLoadStatistics } from './CadModelSectorLoadStatistics';
-import { Observable } from 'rxjs';
 import { GeometryFilter } from '../..';
-export declare class CadManager<TModelIdentifier> {
+import { CadModelMetadataRepository } from '../../../../packages/cad-parsers';
+import { CadModelUpdateHandler, CadModelSectorBudget, LoadingState } from '../../../../packages/cad-geometry-loaders';
+import { CadNode, CadMaterialManager, RenderMode } from '../../../../packages/rendering';
+import { ModelIdentifier } from '../../../../packages/modeldata-api';
+export declare class CadManager {
     private readonly _materialManager;
     private readonly _cadModelMetadataRepository;
     private readonly _cadModelFactory;
@@ -30,7 +27,7 @@ export declare class CadManager<TModelIdentifier> {
      * Returns statistics about how data loaded (or data about to be loaded).
      */
     get loadedStatistics(): CadModelSectorLoadStatistics;
-    constructor(materialManger: CadMaterialManager, cadModelMetadataRepository: CadModelMetadataRepository<TModelIdentifier>, cadModelFactory: CadModelFactory, cadModelUpdateHandler: CadModelUpdateHandler);
+    constructor(materialManger: CadMaterialManager, cadModelMetadataRepository: CadModelMetadataRepository, cadModelFactory: CadModelFactory, cadModelUpdateHandler: CadModelUpdateHandler);
     dispose(): void;
     requestRedraw(): void;
     resetRedraw(): void;
@@ -38,11 +35,9 @@ export declare class CadManager<TModelIdentifier> {
     updateCamera(camera: THREE.PerspectiveCamera): void;
     get clippingPlanes(): THREE.Plane[];
     set clippingPlanes(clippingPlanes: THREE.Plane[]);
-    get clipIntersection(): boolean;
-    set clipIntersection(clipIntersection: boolean);
     get renderMode(): RenderMode;
     set renderMode(renderMode: RenderMode);
-    addModel(modelIdentifier: TModelIdentifier, geometryFilter?: GeometryFilter): Promise<CadNode>;
+    addModel(modelIdentifier: ModelIdentifier, geometryFilter?: GeometryFilter): Promise<CadNode>;
     removeModel(model: CadNode): void;
     getLoadingStateObserver(): Observable<LoadingState>;
     private markNeedsRedraw;

package/{datamodels → core/src/datamodels}/cad/CadModelFactory.d.ts

@@ -1,9 +1,5 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { CadNode } from './CadNode';
-import { CadMaterialManager } from './CadMaterialManager';
-import { CadModelMetadata } from './CadModelMetadata';
+import { CadMaterialManager, CadNode } from '../../../../packages/rendering';
+import { CadModelMetadata } from '../../../../packages/cad-parsers';
 export declare class CadModelFactory {
     private readonly _materialManager;
     constructor(materialManager: CadMaterialManager);

package/core/src/datamodels/cad/createCadManager.d.ts

@@ -0,0 +1,9 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { CadManager } from './CadManager';
+import { OccludingGeometryProvider } from '../../../../packages/cad-geometry-loaders';
+import { CadMaterialManager } from '../../../../packages/rendering';
+import { RevealOptions } from '../../public/types';
+import { ModelDataProvider, ModelMetadataProvider } from '../../../../packages/modeldata-api';
+export declare function createCadManager(modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider, renderer: THREE.WebGLRenderer, materialManager: CadMaterialManager, occludingGeometryProvider: OccludingGeometryProvider, options: RevealOptions): CadManager;

package/{datamodels → core/src/datamodels}/cad/picking.d.ts

@@ -2,7 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { CadNode } from './CadNode';
+import { CadNode } from '../../../../packages/rendering';
 import { IntersectInput } from '../base/types';
 export interface PickingInput {
     normalizedCoords: {

package/{datamodels → core/src/datamodels}/cad/rendering/RenderAlreadyLoadedGeometryProvider.d.ts

@@ -1,8 +1,8 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { OccludingGeometryProvider } from '../sector/culling/OccludingGeometryProvider';
-import { EffectRenderManager } from './EffectRenderManager';
+import { OccludingGeometryProvider } from '../../../../../packages/cad-geometry-loaders';
+import { EffectRenderManager } from '../../../../../packages/rendering';
 export declare class RenderAlreadyLoadedGeometryProvider implements OccludingGeometryProvider {
     private readonly _renderManager;
     constructor(renderManager: EffectRenderManager);

package/{datamodels → core/src/datamodels}/cad/sector/CadModelClipper.d.ts

@@ -2,7 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { CadModelMetadata } from '..';
+import { CadModelMetadata } from '../../../../../packages/cad-parsers';
 export declare class CadModelClipper {
     private readonly _geometryClipBox;
     constructor(geometryClipBox: THREE.Box3);

package/{datamodels → core/src/datamodels}/cad/styling/AssetNodeCollection.d.ts

@@ -2,10 +2,10 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { CogniteClient } from '@cognite/sdk';
 import { Cognite3DModel } from '../../../public/migration/Cognite3DModel';
-import { IndexSet } from '../../../utilities/IndexSet';
-import { NodeCollectionBase, SerializedNodeCollection } from './NodeCollectionBase';
+import { IndexSet } from '../../../../../packages/utilities';
+import { NodeCollectionBase, SerializedNodeCollection } from '../../../../../packages/cad-styling';
+import { CogniteClient } from '@cognite/sdk';
 /**
  * Represents a set of nodes associated with an [asset in Cognite Fusion]{@link https://docs.cognite.com/api/v1/#tag/Assets}
  * linked to the 3D model using [asset mappings]{@link https://docs.cognite.com/api/v1/#tag/3D-Asset-Mapping}. A node

package/{datamodels → core/src/datamodels}/cad/styling/InvertedNodeCollection.d.ts

@@ -2,8 +2,8 @@
  * Copyright 2021 Cognite AS
  */
 import { Cognite3DModel } from '../../../public/migration/Cognite3DModel';
-import { IndexSet } from '../../../utilities/IndexSet';
-import { NodeCollectionBase, SerializedNodeCollection } from './NodeCollectionBase';
+import { IndexSet } from '../../../../../packages/utilities';
+import { NodeCollectionBase, SerializedNodeCollection } from '../../../../../packages/cad-styling';
 /**
  * Node collection that inverts the result from another node collection.
  */

package/{datamodels → core/src/datamodels}/cad/styling/NodeCollectionDeserializer.d.ts

@@ -3,7 +3,7 @@
  */
 import { CogniteClient } from '@cognite/sdk';
 import { Cognite3DModel } from '../../../migration';
-import { NodeCollectionBase } from './NodeCollectionBase';
+import { NodeCollectionBase } from '../../../../../packages/cad-styling';
 export declare type TypeName = string;
 export declare type NodeCollectionSerializationContext = {
     client: CogniteClient;

package/{datamodels → core/src/datamodels}/cad/styling/PopulateIndexSetFromPagedResponseHelper.d.ts

@@ -2,8 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 import { ListResponse } from '@cognite/sdk';
-import { IndexSet } from '../../../utilities/IndexSet';
-import { NumericRange } from '../../../utilities/NumericRange';
+import { IndexSet, NumericRange } from '../../../../../packages/utilities';
 /**
  * Helper class that populates an IndexSet based on a paged results from the Cognite SDK.
  */

package/{datamodels → core/src/datamodels}/cad/styling/PropertyFilterNodeCollection.d.ts

@@ -2,9 +2,9 @@
  * Copyright 2021 Cognite AS
  */
 import { CogniteClient } from '@cognite/sdk';
-import { IndexSet } from '../../../utilities/IndexSet';
 import { Cognite3DModel } from '../../../public/migration/Cognite3DModel';
-import { NodeCollectionBase } from './NodeCollectionBase';
+import { NodeCollectionBase } from '../../../../../packages/cad-styling';
+import { IndexSet } from '../../../../../packages/utilities';
 /**
  * Options for {@link PropertyFilterNodeCollection}.
  */

package/{datamodels → core/src/datamodels}/cad/styling/SinglePropertyFilterNodeCollection.d.ts

@@ -1,19 +1,16 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { CogniteClient } from '@cognite/sdk';
-import { IndexSet } from '../../../utilities/IndexSet';
 import { Cognite3DModel } from '../../../public/migration/Cognite3DModel';
 import { PropertyFilterNodeCollectionOptions } from './PropertyFilterNodeCollection';
-import { NodeCollectionBase } from './NodeCollectionBase';
+import { IndexSet } from '../../../../../packages/utilities';
+import { NodeCollectionBase } from '../../../../../packages/cad-styling';
+import { CogniteClient } from '@cognite/sdk';
 /**
  * Node collection that filters nodes based on a node property from a list of values, similarly to how
  * `SELECT ... IN (...)` works. This is useful when looking up nodes based on a list of identifiers,
  * nodes within a set of areas or systems. The node set is optimized for matching with properties with
  * a large number of values (i.e. thousands).
- *
- * @experimental This is an experimental feature that might be changed or removed, and changes
- * in minor releases might cause breaking changes.
  */
 export declare class SinglePropertyFilterNodeCollection extends NodeCollectionBase {
     static readonly classToken = "SinglePropertyNodeCollection";

package/{datamodels → core/src/datamodels}/cad/styling/index.d.ts

@@ -1,13 +1,8 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-export { AssetNodeCollection } from './AssetNodeCollection';
-export { PropertyFilterNodeCollection } from './PropertyFilterNodeCollection';
-export { TreeIndexNodeCollection } from './TreeIndexNodeCollection';
 export { InvertedNodeCollection } from './InvertedNodeCollection';
-export { UnionNodeCollection } from './UnionNodeCollection';
-export { IntersectionNodeCollection } from './IntersectionNodeCollection';
-export { NodeCollectionBase, SerializedNodeCollection } from './NodeCollectionBase';
-export { NodeAppearanceProvider } from './NodeAppearanceProvider';
 export { SinglePropertyFilterNodeCollection } from './SinglePropertyFilterNodeCollection';
+export { PropertyFilterNodeCollection } from './PropertyFilterNodeCollection';
+export { AssetNodeCollection } from './AssetNodeCollection';
 export { registerCustomNodeCollectionType, TypeName, NodeCollectionDescriptor, NodeCollectionSerializationContext } from './NodeCollectionDeserializer';

package/{datamodels → core/src/datamodels}/pointcloud/PointCloudFactory.d.ts

@@ -1,6 +1,6 @@
 import { PotreeNodeWrapper } from './PotreeNodeWrapper';
 import { PointCloudMetadata } from './PointCloudMetadata';
-import { HttpHeadersProvider } from '../../utilities/networking/HttpHeadersProvider';
+import { HttpHeadersProvider } from '../../../../packages/modeldata-api';
 export declare class PointCloudFactory {
     private readonly _httpHeadersProvider;
     constructor(httpHeadersProvider: HttpHeadersProvider);

package/{datamodels → core/src/datamodels}/pointcloud/PointCloudManager.d.ts

@@ -2,21 +2,25 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
+import { LoadingState } from '../../../../packages/cad-geometry-loaders';
 import { PointCloudFactory } from './PointCloudFactory';
+import { PointCloudNode } from './PointCloudNode';
 import { PointCloudMetadataRepository } from './PointCloudMetadataRepository';
 import { Observable } from 'rxjs';
-import { LoadingState } from '../../utilities';
-import { PointCloudNode } from './PointCloudNode';
-export declare class PointCloudManager<TModelIdentifier> {
+import { ModelIdentifier } from '../../../../packages/modeldata-api';
+export declare class PointCloudManager {
     private readonly _pointCloudMetadataRepository;
     private readonly _pointCloudFactory;
     private readonly _pointCloudGroupWrapper;
-    constructor(metadataRepository: PointCloudMetadataRepository<TModelIdentifier>, modelFactory: PointCloudFactory);
+    constructor(metadataRepository: PointCloudMetadataRepository, modelFactory: PointCloudFactory);
     requestRedraw(): void;
     resetRedraw(): void;
+    get pointBudget(): number;
+    set pointBudget(points: number);
     get needsRedraw(): boolean;
+    set clippingPlanes(planes: THREE.Plane[]);
     getLoadingStateObserver(): Observable<LoadingState>;
     updateCamera(_camera: THREE.PerspectiveCamera): void;
-    addModel(modelIdentifier: TModelIdentifier): Promise<PointCloudNode>;
+    addModel(modelIdentifier: ModelIdentifier): Promise<PointCloudNode>;
     removeModel(node: PointCloudNode): void;
 }

package/{datamodels → core/src/datamodels}/pointcloud/PointCloudMetadata.d.ts

@@ -2,7 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { CameraConfiguration } from '../../utilities';
+import { CameraConfiguration } from '../../../../packages/utilities';
 export interface PointCloudMetadata {
     modelBaseUrl: string;
     modelMatrix: THREE.Matrix4;

package/core/src/datamodels/pointcloud/PointCloudMetadataRepository.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { PointCloudMetadata } from './PointCloudMetadata';
+import { MetadataRepository } from '../base';
+import { ModelDataProvider, ModelMetadataProvider, ModelIdentifier } from '../../../../packages/modeldata-api';
+export declare class PointCloudMetadataRepository implements MetadataRepository<Promise<PointCloudMetadata>> {
+    private readonly _modelMetadataProvider;
+    private readonly _modelDataProvider;
+    private readonly _blobFileName;
+    constructor(modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider, blobFileName?: string);
+    loadData(modelIdentifier: ModelIdentifier): Promise<PointCloudMetadata>;
+}

package/{datamodels → core/src/datamodels}/pointcloud/PointCloudNode.d.ts

@@ -2,9 +2,9 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
+import { CameraConfiguration } from '../../../../packages/utilities';
 import { PotreeGroupWrapper } from './PotreeGroupWrapper';
 import { PotreeNodeWrapper } from './PotreeNodeWrapper';
-import { CameraConfiguration } from '../../utilities';
 import { PotreePointSizeType, PotreePointColorType, PotreePointShape, WellKnownAsprsPointClassCodes } from './types';
 export declare class PointCloudNode extends THREE.Group {
     private readonly _potreeGroup;
@@ -23,6 +23,7 @@ export declare class PointCloudNode extends THREE.Group {
     set pointSizeType(value: PotreePointSizeType);
     get pointBudget(): number;
     set pointBudget(count: number);
+    get visiblePointCount(): number;
     get pointColorType(): PotreePointColorType;
     set pointColorType(type: PotreePointColorType);
     get pointShape(): PotreePointShape;

package/{datamodels → core/src/datamodels}/pointcloud/PotreeGroupWrapper.d.ts

@@ -1,9 +1,9 @@
 /*!
  * Copyright 2021 Cognite AS
  */
+import { LoadingState } from '../../../../packages/cad-geometry-loaders';
 import { Observable } from 'rxjs';
 import * as THREE from 'three';
-import { LoadingState } from '../../utilities';
 import { PotreeNodeWrapper } from './PotreeNodeWrapper';
 /**
  * Wrapper around Potree.Group with type information and
@@ -23,11 +23,17 @@ export declare class PotreeGroupWrapper extends THREE.Object3D {
      * @param pollLoadingStatusInterval Controls how often the wrapper checks for loading status. Used for testing.
      */
     constructor(pollLoadingStatusInterval?: number);
+    get pointBudget(): number;
+    set pointBudget(points: number);
     getLoadingStateObserver(): Observable<LoadingState>;
     addPointCloud(node: PotreeNodeWrapper): void;
     removePointCloud(node: PotreeNodeWrapper): void;
     requestRedraw(): void;
     resetRedraw(): void;
     private createLoadingStateObservable;
+    /**
+     * Generates a hash for the current loaded points to allow determining if we have
+     * loaded data since last redraw.
+     */
     private get pointBuffersHash();
 }

package/core/src/datamodels/pointcloud/createPointCloudManager.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { PointCloudManager } from './PointCloudManager';
+import { ModelDataProvider, ModelMetadataProvider } from '../../../../packages/modeldata-api';
+export declare function createPointCloudManager(modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider): PointCloudManager;

package/core/src/index.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * @module @cognite/reveal
+ */
+export { NodeAppearanceProvider, NodeAppearance, NodeOutlineColor, DefaultNodeAppearance } from '../../packages/cad-styling';
+export { NodeCollectionBase, TreeIndexNodeCollection, IntersectionNodeCollection, UnionNodeCollection, SerializedNodeCollection } from '../../packages/cad-styling';
+export { revealEnv, IndexSet, NumericRange } from '../../packages/utilities';
+export * from './public/migration/Cognite3DViewer';
+export { BoundingBoxClipper } from './utilities';
+export { Cognite3DModel } from './public/migration/Cognite3DModel';
+export { Cognite3DViewer } from './public/migration/Cognite3DViewer';
+export { CognitePointCloudModel } from './public/migration/CognitePointCloudModel';
+export { ViewerState, ModelState } from './utilities/ViewStateHelper';
+export * from './public/types';
+export { PropertyFilterNodeCollection, SinglePropertyFilterNodeCollection, AssetNodeCollection, InvertedNodeCollection, registerCustomNodeCollectionType, TypeName, NodeCollectionDescriptor, NodeCollectionSerializationContext } from './datamodels/cad/styling';
+import * as THREE from 'three';
+export { THREE };

package/core/src/internals.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export { CdfModelIdentifier, LocalModelIdentifier, ModelIdentifier, File3dFormat } from '../../packages/modeldata-api';
+export { RevealManager } from './public/RevealManager';
+export { createLocalRevealManager, createCdfRevealManager } from './public/createRevealManager';
+export { intersectCadNodes } from './datamodels/cad/picking';
+export { CadModelSectorLoadStatistics } from './datamodels/cad/CadModelSectorLoadStatistics';
+export { PointCloudMetadata } from './datamodels/pointcloud';
+export * from './datamodels/pointcloud/types';
+export { PotreeNodeWrapper } from './datamodels/pointcloud/PotreeNodeWrapper';
+export { PotreeGroupWrapper } from './datamodels/pointcloud/PotreeGroupWrapper';
+export { PointCloudNode } from './datamodels/pointcloud/PointCloudNode';
+import * as utilities from './utilities';
+export { utilities };

package/{public → core/src/public}/RevealManager.d.ts

@@ -4,19 +4,19 @@
 import * as THREE from 'three';
 import { CadManager } from '../datamodels/cad/CadManager';
 import { PointCloudManager } from '../datamodels/pointcloud/PointCloudManager';
-import { LoadingStateChangeListener } from './types';
-import { CadNode } from '../datamodels/cad';
-import { RenderMode } from '../datamodels/cad/rendering/RenderMode';
-import { EffectRenderManager } from '../datamodels/cad/rendering/EffectRenderManager';
+import { LoadingStateChangeListener, PointCloudBudget } from './types';
 import { PointCloudNode } from '../datamodels/pointcloud/PointCloudNode';
-import { CadModelSectorBudget } from '../datamodels/cad/CadModelSectorBudget';
 import { CadModelSectorLoadStatistics } from '../datamodels/cad/CadModelSectorLoadStatistics';
-import { GeometryFilter, NodeAppearanceProvider, RenderOptions } from '..';
+import { GeometryFilter } from '..';
+import { CadModelSectorBudget } from '../../../packages/cad-geometry-loaders';
+import { NodeAppearanceProvider } from '../../../packages/cad-styling';
+import { RenderOptions, EffectRenderManager, CadNode, RenderMode } from '../../../packages/rendering';
+import { ModelIdentifier } from '../../../packages/modeldata-api';
 export declare type AddCadModelOptions = {
     nodeAppearanceProvider?: NodeAppearanceProvider;
     geometryFilter?: GeometryFilter;
 };
-export declare class RevealManager<TModelIdentifier> {
+export declare class RevealManager {
     private readonly _cadManager;
     private readonly _pointCloudManager;
     private readonly _effectRenderManager;
@@ -25,10 +25,12 @@ export declare class RevealManager<TModelIdentifier> {
     private readonly _subscriptions;
     private readonly _events;
     private readonly _updateSubject;
-    constructor(cadManager: CadManager<TModelIdentifier>, renderManager: EffectRenderManager, pointCloudManager: PointCloudManager<TModelIdentifier>);
+    constructor(cadManager: CadManager, renderManager: EffectRenderManager, pointCloudManager: PointCloudManager);
     dispose(): void;
     requestRedraw(): void;
     resetRedraw(): void;
+    get debugRenderTiming(): boolean;
+    set debugRenderTiming(enable: boolean);
     get renderOptions(): RenderOptions;
     set renderOptions(options: RenderOptions);
     get needsRedraw(): boolean;
@@ -36,12 +38,12 @@ export declare class RevealManager<TModelIdentifier> {
     get cadBudget(): CadModelSectorBudget;
     set cadBudget(budget: CadModelSectorBudget);
     get cadLoadedStatistics(): CadModelSectorLoadStatistics;
-    get renderMode(): RenderMode;
-    set renderMode(renderMode: RenderMode);
+    get cadRenderMode(): RenderMode;
+    set cadRenderMode(renderMode: RenderMode);
+    get pointCloudBudget(): PointCloudBudget;
+    set pointCloudBudget(budget: PointCloudBudget);
     set clippingPlanes(clippingPlanes: THREE.Plane[]);
     get clippingPlanes(): THREE.Plane[];
-    set clipIntersection(intersection: boolean);
-    get clipIntersection(): boolean;
     on(event: 'loadingStateChanged', listener: LoadingStateChangeListener): void;
     off(event: 'loadingStateChanged', listener: LoadingStateChangeListener): void;
     render(camera: THREE.PerspectiveCamera): void;
@@ -51,8 +53,8 @@ export declare class RevealManager<TModelIdentifier> {
      * @param autoSetTargetSize Auto size target to fit canvas.
      */
     setRenderTarget(target: THREE.WebGLRenderTarget | null, autoSetTargetSize?: boolean): void;
-    addModel(type: 'cad', modelIdentifier: TModelIdentifier, options?: AddCadModelOptions): Promise<CadNode>;
-    addModel(type: 'pointcloud', modelIdentifier: TModelIdentifier): Promise<PointCloudNode>;
+    addModel(type: 'cad', modelIdentifier: ModelIdentifier, options?: AddCadModelOptions): Promise<CadNode>;
+    addModel(type: 'pointcloud', modelIdentifier: ModelIdentifier): Promise<PointCloudNode>;
     removeModel(type: 'cad', model: CadNode): void;
     removeModel(type: 'pointcloud', model: PointCloudNode): void;
     addUiObject(object: THREE.Object3D, screenPos: THREE.Vector2, size: THREE.Vector2): void;

package/{public → core/src/public}/createRevealManager.d.ts

@@ -2,10 +2,9 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { LocalModelIdentifier, CdfModelIdentifier } from '../utilities/networking/types';
-import { CogniteClient } from '@cognite/sdk';
 import { RevealManager } from './RevealManager';
 import { RevealOptions } from './types';
+import { CogniteClient } from '@cognite/sdk';
 /**
  * Used to create an instance of reveal manager that works with localhost.
  * @param renderer
@@ -13,7 +12,7 @@ import { RevealOptions } from './types';
  * @param revealOptions
  * @returns RevealManager instance.
  */
-export declare function createLocalRevealManager(renderer: THREE.WebGLRenderer, scene: THREE.Scene, revealOptions?: RevealOptions): RevealManager<LocalModelIdentifier>;
+export declare function createLocalRevealManager(renderer: THREE.WebGLRenderer, scene: THREE.Scene, revealOptions?: RevealOptions): RevealManager;
 /**
  * Used to create an instance of reveal manager that works with the CDF.
  * @param client
@@ -21,4 +20,4 @@ export declare function createLocalRevealManager(renderer: THREE.WebGLRenderer,
  * @param scene
  * @param revealOptions
  */
-export declare function createCdfRevealManager(client: CogniteClient, renderer: THREE.WebGLRenderer, scene: THREE.Scene, revealOptions?: RevealOptions): RevealManager<CdfModelIdentifier>;
+export declare function createCdfRevealManager(client: CogniteClient, renderer: THREE.WebGLRenderer, scene: THREE.Scene, revealOptions?: RevealOptions): RevealManager;