@cognite/reveal 3.0.0-beta.1 → 3.0.2

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

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

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

@@ -0,0 +1,26 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { CognitePointCloudModel } from './CognitePointCloudModel';
+export declare type PointCloudIntersection = {
+    /**
+     * The intersection type.
+     */
+    type: 'pointcloud';
+    /**
+     * The model that was intersected.
+     */
+    model: CognitePointCloudModel;
+    /**
+     * Tree index of the intersected 3D node.
+     */
+    point: THREE.Vector3;
+    /**
+     * The index of the point that was intersected.
+     */
+    pointIndex: number;
+    /**
+     * Distance from the camera to the intersection.
+     */
+    distanceToCamera: number;
+};

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

@@ -2,12 +2,12 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { LoadingState } from '../../../../packages/cad-geometry-loaders';
+import { LoadingState } from '../../model-base';
 import { PointCloudFactory } from './PointCloudFactory';
 import { PointCloudNode } from './PointCloudNode';
 import { PointCloudMetadataRepository } from './PointCloudMetadataRepository';
 import { Observable } from 'rxjs';
-import { ModelIdentifier } from '../../../../packages/modeldata-api';
+import { ModelIdentifier } from '../../modeldata-api';
 export declare class PointCloudManager {
     private readonly _pointCloudMetadataRepository;
     private readonly _pointCloudFactory;

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

@@ -2,8 +2,8 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { CameraConfiguration } from '../../../../packages/utilities';
-import { File3dFormat } from '../../../../packages/modeldata-api';
+import { CameraConfiguration } from '../../utilities';
+import { File3dFormat } from '../../modeldata-api';
 export interface PointCloudMetadata {
     readonly format: File3dFormat;
     readonly formatVersion: number;

package/{core/src/datamodels/pointcloud → packages/pointclouds/src}/PointCloudMetadataRepository.d.ts

@@ -2,8 +2,8 @@
  * Copyright 2021 Cognite AS
  */
 import { PointCloudMetadata } from './PointCloudMetadata';
-import { MetadataRepository } from '../base';
-import { ModelDataProvider, ModelMetadataProvider, ModelIdentifier } from '../../../../packages/modeldata-api';
+import { MetadataRepository } from '../../model-base';
+import { ModelDataProvider, ModelMetadataProvider, ModelIdentifier } from '../../modeldata-api';
 export declare class PointCloudMetadataRepository implements MetadataRepository<Promise<PointCloudMetadata>> {
     private readonly _modelMetadataProvider;
     private readonly _modelDataProvider;

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

@@ -2,7 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { CameraConfiguration } from '../../../../packages/utilities';
+import { CameraConfiguration } from '../../utilities';
 import { PotreeGroupWrapper } from './PotreeGroupWrapper';
 import { PotreeNodeWrapper } from './PotreeNodeWrapper';
 import { PotreePointSizeType, PotreePointColorType, PotreePointShape, WellKnownAsprsPointClassCodes } from './types';

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

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { LoadingState } from '../../../../packages/cad-geometry-loaders';
+import { LoadingState } from '../../model-base';
 import { Observable } from 'rxjs';
 import * as THREE from 'three';
 import { PotreeNodeWrapper } from './PotreeNodeWrapper';

package/{core/src/datamodels/pointcloud → packages/pointclouds/src}/PotreeNodeWrapper.d.ts

@@ -1,7 +1,6 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import * as Potree from '@cognite/potree-core';
 import * as THREE from 'three';
 import { PotreePointSizeType, PotreePointColorType, PotreePointShape } from './types';
 export declare type PotreeClassification = {
@@ -16,10 +15,10 @@ export declare type PotreeClassification = {
  * Wrapper around `Potree.PointCloudOctree` with some convinence functions.
  */
 export declare class PotreeNodeWrapper {
-    readonly octtree: Potree.PointCloudOctreeNode;
+    readonly octtree: any;
     private _needsRedraw;
     get needsRedraw(): boolean;
-    constructor(octtree: Potree.PointCloudOctreeNode);
+    constructor(octtree: any);
     get pointSize(): number;
     set pointSize(size: number);
     get pointSizeType(): PotreePointSizeType;

package/{core/src/datamodels/pointcloud → packages/pointclouds/src}/createPointCloudManager.d.ts

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

package/{core/src/datamodels/pointcloud → packages/pointclouds/src}/picking.d.ts

@@ -2,7 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { IntersectInput } from '../base';
+import { IntersectInput } from '../../model-base';
 import { PointCloudNode } from './PointCloudNode';
 export interface IntersectPointCloudNodeResult {
     /**

package/packages/rendering/index.d.ts

@@ -4,14 +4,11 @@
 export { SectorQuads } from './src/rendering/types';
 export { CadMaterialManager } from './src/CadMaterialManager';
 export { createSimpleGeometryMesh } from './src/rendering/createSimpleGeometryMesh';
-export { NodeAppearanceTextureBuilder } from './src/rendering/NodeAppearanceTextureBuilder';
-export { NodeTransformTextureBuilder } from './src/transform/NodeTransformTextureBuilder';
 export { NodeTransformProvider } from './src/transform/NodeTransformProvider';
-export { CogniteColors, RevealColors } from './src/utilities/types';
 export { CadNode } from './src/sector/CadNode';
 export { RenderOptions, defaultRenderOptions, SsaoParameters, SsaoSampleQuality, AntiAliasingMode } from './src/rendering/types';
 export { EffectRenderManager } from './src/rendering/EffectRenderManager';
 export { RenderMode } from './src/rendering/RenderMode';
 export { coverageShaders } from './src/rendering/shaders';
-export { Materials, createMaterials } from './src/rendering/materials';
+export { Materials } from './src/rendering/materials';
 export { createPrimitives } from './src/rendering/primitives';

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

@@ -17,18 +17,20 @@ export declare class CadMaterialManager {
     on(event: 'materialsChanged', listener: () => void): void;
     off(event: 'materialsChanged', listener: () => void): void;
     addModelMaterials(modelIdentifier: string, maxTreeIndex: number): void;
+    removeModelMaterials(modelIdentifier: string): void;
     getModelMaterials(modelIdentifier: string): Materials;
     getModelNodeAppearanceProvider(modelIdentifier: string): NodeAppearanceProvider;
     getModelNodeTransformProvider(modelIdentifier: string): NodeTransformProvider;
     getModelDefaultNodeAppearance(modelIdentifier: string): NodeAppearance;
     setModelClippingPlanes(modelIdentifier: string, clippingPlanes: THREE.Plane[]): void;
-    private updateClippingPlanesForModel;
     setModelDefaultNodeAppearance(modelIdentifier: string, defaultAppearance: NodeAppearance): void;
     getModelBackTreeIndices(modelIdentifier: string): IndexSet;
     getModelInFrontTreeIndices(modelIdentifier: string): IndexSet;
     getModelGhostedTreeIndices(modelIdentifier: string): IndexSet;
     setRenderMode(mode: RenderMode): void;
     getRenderMode(): RenderMode;
+    dispose(): void;
+    private updateClippingPlanesForModel;
     private updateMaterials;
     private updateTransforms;
     private getModelMaterialsWrapper;

package/packages/rendering/src/GeometryBatchingManager.d.ts

@@ -11,6 +11,7 @@ export declare class GeometryBatchingManager {
     private readonly _sectorMap;
     private static readonly TypedArrayViews;
     constructor(group: THREE.Group, materials: Materials);
+    dispose(): void;
     batchGeometries(geometryBatchingQueue: ParsedGeometry[], sectorId: number): void;
     removeSectorBatches(sectorId: number): void;
     private processGeometries;

package/packages/rendering/src/rendering/materials.d.ts

@@ -4,20 +4,20 @@
 import * as THREE from 'three';
 import { RenderMode } from './RenderMode';
 export interface Materials {
-    box: THREE.ShaderMaterial;
-    circle: THREE.ShaderMaterial;
-    generalRing: THREE.ShaderMaterial;
-    nut: THREE.ShaderMaterial;
-    quad: THREE.ShaderMaterial;
-    cone: THREE.ShaderMaterial;
-    eccentricCone: THREE.ShaderMaterial;
-    sphericalSegment: THREE.ShaderMaterial;
-    torusSegment: THREE.ShaderMaterial;
-    generalCylinder: THREE.ShaderMaterial;
-    trapezium: THREE.ShaderMaterial;
-    ellipsoidSegment: THREE.ShaderMaterial;
-    instancedMesh: THREE.ShaderMaterial;
-    triangleMesh: THREE.ShaderMaterial;
-    simple: THREE.ShaderMaterial;
+    box: THREE.RawShaderMaterial;
+    circle: THREE.RawShaderMaterial;
+    generalRing: THREE.RawShaderMaterial;
+    nut: THREE.RawShaderMaterial;
+    quad: THREE.RawShaderMaterial;
+    cone: THREE.RawShaderMaterial;
+    eccentricCone: THREE.RawShaderMaterial;
+    sphericalSegment: THREE.RawShaderMaterial;
+    torusSegment: THREE.RawShaderMaterial;
+    generalCylinder: THREE.RawShaderMaterial;
+    trapezium: THREE.RawShaderMaterial;
+    ellipsoidSegment: THREE.RawShaderMaterial;
+    instancedMesh: THREE.RawShaderMaterial;
+    triangleMesh: THREE.RawShaderMaterial;
+    simple: THREE.RawShaderMaterial;
 }
 export declare function createMaterials(renderMode: RenderMode, clippingPlanes: THREE.Plane[], overrideColorPerTreeIndex: THREE.DataTexture, transformOverrideIndexTexture: THREE.DataTexture, transformOverrideLookupTexture: THREE.DataTexture): Materials;

package/packages/rendering/src/sector/CadNode.d.ts

@@ -15,13 +15,13 @@ export declare type ParseCallbackDelegate = (parsed: {
     data: SectorGeometry | SectorQuads;
 }) => void;
 export declare class CadNode extends THREE.Object3D {
-    private readonly _rootSector;
     private readonly _cadModelMetadata;
     private readonly _materialManager;
-    private readonly _sectorScene;
     private readonly _instancedMeshManager;
     private readonly _sectorRepository;
-    private readonly _geometryBatchingManager;
+    private _rootSector;
+    private _sectorScene;
+    private _geometryBatchingManager;
     constructor(model: CadModelMetadata, materialManager: CadMaterialManager, sectorRepository: SectorRepository);
     get nodeTransformProvider(): NodeTransformProvider;
     get nodeAppearanceProvider(): NodeAppearanceProvider;
@@ -53,5 +53,5 @@ export declare class CadNode extends THREE.Object3D {
     batchGeometry(geometryBatchingQueue: ParsedGeometry[], sectorId: number): void;
     removeBatchedSectorGeometries(sectorId: number): void;
     setCacheSize(sectorCount: number): void;
-    clearCache(): void;
+    dispose(): void;
 }

package/packages/utilities/index.d.ts

@@ -6,6 +6,7 @@ export { transformCameraConfiguration } from './src/transformCameraConfiguration
 export { RandomColors } from './src/RandomColors';
 export { CameraConfiguration } from './src/CameraConfiguration';
 export { EventTrigger, clickOrTouchEventOffset, InputHandler, disposeOfAllEventListeners } from './src/events';
+export { DisposedDelegate, SceneRenderedDelegate, PointerEventDelegate } from './src/events/types';
 export { assertNever } from './src/assertNever';
 export { NumericRange } from './src/NumericRange';
 export { determinePowerOfTwoDimensions } from './src/determinePowerOfTwoDimensions';
@@ -28,3 +29,5 @@ export { disposeAttributeArrayOnUpload } from './src/disposeAttributeArrayOnUplo
 export { revealEnv } from './src/revealEnv';
 export { incrementOrInsertIndex, decrementOrDeleteIndex } from './src/counterMap';
 export { calculateVolumeOfMesh } from './src/calculateVolumeOfMesh';
+export { worldToNormalizedViewportCoordinates, worldToViewportCoordinates } from './src/worldToViewport';
+export { DeferredPromise } from './src/DeferredPromise';

package/packages/utilities/src/events/InputHandler.d.ts

@@ -1,8 +1,5 @@
 import { EventTrigger } from './EventTrigger';
-declare type PointerEventDelegate = (event: {
-    offsetX: number;
-    offsetY: number;
-}) => void;
+import { PointerEventDelegate } from './types';
 export declare type EventCollection = {
     [eventName: string]: EventTrigger<(...args: any[]) => void>;
 };
@@ -31,4 +28,3 @@ export declare class InputHandler {
  * Method for deleting all external events that are associated with current instance of a class.
  */
 export declare function disposeOfAllEventListeners(eventList: EventCollection): void;
-export {};

package/packages/utilities/src/events/index.d.ts

@@ -4,3 +4,4 @@
 export { clickOrTouchEventOffset } from './clickOrTouchEventOffset';
 export { EventTrigger } from './EventTrigger';
 export { InputHandler, disposeOfAllEventListeners } from './InputHandler';
+export * from './types';

package/packages/utilities/src/events/types.d.ts

@@ -0,0 +1,27 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+/**
+ * Delegate for pointer events.
+ * @module @cognite/reveal
+ */
+export declare type PointerEventDelegate = (event: {
+    offsetX: number;
+    offsetY: number;
+    button?: number;
+}) => void;
+/**
+ * Delegate for disposal events.
+ * @module @cognite/reveal
+ */
+export declare type DisposedDelegate = () => void;
+/**
+ * Delegate for rendering events.
+ * @module @cognite/reveal
+ */
+export declare type SceneRenderedDelegate = (event: {
+    frameNumber: number;
+    renderTime: number;
+    renderer: THREE.WebGLRenderer;
+    camera: THREE.PerspectiveCamera;
+}) => void;