@cognite/reveal 3.2.0 → 4.0.0-dev.20221025

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

@@ -1,13 +1,9 @@
 import * as THREE from 'three';
-import { ILoader } from '../loading/ILoader';
+import { EptBinaryLoader } from '../loading/EptBinaryLoader';
+import { EptJson, EptSchemaEntry } from '../loading/EptJson';
 import { PointCloudEptGeometryNode } from './PointCloudEptGeometryNode';
 import { IPointCloudTreeGeometry } from './IPointCloudTreeGeometry';
-import { ModelDataProvider } from '../../../../modeldata-api';
-declare type SchemaEntry = {
-    name: string;
-    scale: number;
-    offset: number;
-};
+import { ModelDataProvider, StylableObject } from '../../../../data-providers';
 export declare class PointCloudEptGeometry implements IPointCloudTreeGeometry {
     private readonly _eptScale;
     private readonly _eptOffset;
@@ -15,12 +11,13 @@ export declare class PointCloudEptGeometry implements IPointCloudTreeGeometry {
     private readonly _boundingBox;
     private readonly _tightBoundingBox;
     private readonly _offset;
+    private readonly _loader;
     private readonly _span;
     private readonly _spacing;
-    private readonly _loader;
     private readonly _schema;
     private _root;
     private readonly _projection;
+    get loader(): EptBinaryLoader;
     get root(): PointCloudEptGeometryNode | undefined;
     set root(r: PointCloudEptGeometryNode | undefined);
     get boundingBox(): THREE.Box3;
@@ -28,11 +25,10 @@ export declare class PointCloudEptGeometry implements IPointCloudTreeGeometry {
     get offset(): THREE.Vector3;
     get spacing(): number;
     get url(): string;
-    get schema(): SchemaEntry[];
+    get schema(): EptSchemaEntry[];
     get eptScale(): THREE.Vector3;
     get eptOffset(): THREE.Vector3;
-    get loader(): ILoader;
-    constructor(url: string, info: any, dataLoader: ModelDataProvider);
+    constructor(url: string, info: EptJson, dataLoader: ModelDataProvider, stylableObjects: StylableObject[]);
     dispose(): void;
 }
 export declare class EptKey {
@@ -47,4 +43,3 @@ export declare class EptKey {
     step(a: number, b: number, c: number): EptKey;
     children(): string[];
 }
-export {};

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

@@ -2,7 +2,7 @@ import { IPointCloudTreeGeometryNode } from './IPointCloudTreeGeometryNode';
 import { IPointCloudTreeNodeBase } from '../tree/IPointCloudTreeNodeBase';
 import * as THREE from 'three';
 import { PointCloudEptGeometry, EptKey } from './PointCloudEptGeometry';
-import { ModelDataProvider } from '../../../../modeldata-api';
+import { ModelDataProvider } from '../../../../data-providers';
 export declare class PointCloudEptGeometryNode implements IPointCloudTreeGeometryNode {
     private readonly _id;
     private readonly _ept;
@@ -58,6 +58,7 @@ export declare class PointCloudEptGeometryNode implements IPointCloudTreeGeometr
     loadPoints(): Promise<void>;
     loadHierarchy(): Promise<void>;
     doneLoading(bufferGeometry: THREE.BufferGeometry, _tightBoundingBox: THREE.Box3, np: number, _mean: THREE.Vector3): void;
+    markAsNotLoading(): void;
     toPotreeName(d: number, x: number, y: number, z: number): string;
     dispose(): void;
 }

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

@@ -1,4 +1,3 @@
-export * from './rendering';
 export * from './tree/PointAttributes';
 export * from './tree/PointCloudOctreeNode';
 export * from './tree/PointCloudOctreePicker';

package/packages/pointclouds/src/potree-three-loader/loading/ClassificationInfo.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+export declare type PointClass = {
+    name: string;
+    code: number;
+    rgb?: string;
+};
+export declare type ClassificationSet = {
+    name: string;
+    classificationSet: PointClass[];
+};
+export declare type ClassificationInfo = {
+    classificationSets: ClassificationSet[];
+};

package/packages/pointclouds/src/potree-three-loader/loading/EptBinaryLoader.d.ts

@@ -1,12 +1,15 @@
 import { WorkerPool } from '../utils/WorkerPool';
 import { ILoader } from './ILoader';
-import { ModelDataProvider } from '../../../../modeldata-api';
+import { ModelDataProvider, StylableObject } from '../../../../data-providers';
 import { PointCloudEptGeometryNode } from '../geometry/PointCloudEptGeometryNode';
+import { ParsedEptData } from '../workers/types';
 export declare class EptBinaryLoader implements ILoader {
     private readonly _dataLoader;
+    private readonly _stylableObjectsWithBox;
     static readonly WORKER_POOL: WorkerPool<Worker>;
     extension(): string;
-    constructor(dataLoader: ModelDataProvider);
+    constructor(dataLoader: ModelDataProvider, stylableObjects: StylableObject[]);
     load(node: PointCloudEptGeometryNode): Promise<void>;
-    parse(node: PointCloudEptGeometryNode, buffer: ArrayBuffer): Promise<void>;
+    private finalizeLoading;
+    parse(node: PointCloudEptGeometryNode, data: ArrayBuffer): Promise<ParsedEptData | Error>;
 }

package/packages/pointclouds/src/potree-three-loader/loading/EptJson.d.ts

@@ -0,0 +1,25 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+export declare type EptSchemaEntry = {
+    name: string;
+    type: 'signed' | 'unsigned' | 'float';
+    size: number;
+    scale: number;
+    offset: number;
+};
+export declare type SpatialReferenceSystem = {
+    authority: string;
+    horizontal: string;
+    vertical?: string;
+    wkt: string;
+};
+export declare type EptJson = {
+    schema: EptSchemaEntry[];
+    bounds: number[];
+    boundsConforming: number[];
+    ticks: number;
+    srs?: SpatialReferenceSystem;
+    span?: number;
+    dataType: 'binary' | 'laszip';
+};

package/packages/pointclouds/src/potree-three-loader/loading/EptLoader.d.ts

@@ -1,5 +1,5 @@
-import { ModelDataProvider } from '../../../../modeldata-api';
+import { ModelDataProvider, PointCloudObject } from '../../../../data-providers';
 import { PointCloudEptGeometry } from '../geometry/PointCloudEptGeometry';
 export declare class EptLoader {
-    static load(baseUrl: string, fileName: string, modelDataProvider: ModelDataProvider): Promise<PointCloudEptGeometry>;
+    static load(baseUrl: string, fileName: string, modelDataProvider: ModelDataProvider, objects: PointCloudObject[]): Promise<PointCloudEptGeometry>;
 }

package/packages/pointclouds/src/potree-three-loader/loading/ILoader.d.ts

@@ -1,4 +1,4 @@
 export interface ILoader {
     load(node: any): Promise<void>;
-    parse(node: any, buffer: ArrayBuffer): void;
+    parse(node: any, data: ArrayBuffer): void;
 }

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

@@ -1,5 +1,4 @@
 import { Box3, Camera, Object3D, Ray, Sphere, WebGLRenderer } from 'three';
-import { PointCloudMaterial, PotreePointSizeType } from '../rendering';
 import { IPointCloudTreeGeometry } from '../geometry/IPointCloudTreeGeometry';
 import { IPointCloudTreeGeometryNode } from '../geometry/IPointCloudTreeGeometryNode';
 import { PickParams } from './PointCloudOctreePicker';
@@ -8,6 +7,7 @@ import { PickPoint } from '../types/types';
 import { IPotree } from '../types/IPotree';
 import { IPointCloudTreeNodeBase } from './IPointCloudTreeNodeBase';
 import { IPointCloudTreeNode } from './IPointCloudTreeNode';
+import { PointCloudMaterial, PointSizeType } from '../../../../rendering';
 export declare class PointCloudOctree extends PointCloudTree {
     potree: IPotree;
     disposed: boolean;
@@ -29,11 +29,11 @@ export declare class PointCloudOctree extends PointCloudTree {
     showBoundingBox: boolean;
     private readonly visibleBounds;
     private picker;
-    constructor(potree: IPotree, pcoGeometry: IPointCloudTreeGeometry, material?: PointCloudMaterial);
+    constructor(potree: IPotree, pcoGeometry: IPointCloudTreeGeometry, material: PointCloudMaterial);
     private updateMaterial;
     dispose(): void;
-    get pointSizeType(): PotreePointSizeType;
-    set pointSizeType(value: PotreePointSizeType);
+    get pointSizeType(): PointSizeType;
+    set pointSizeType(value: PointSizeType);
     toTreeNode(geometryNode: IPointCloudTreeGeometryNode, parent?: IPointCloudTreeNode | null): IPointCloudTreeNode;
     updateVisibleBounds(): void;
     updateBoundingBoxes(): void;

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

@@ -1,5 +1,5 @@
 import { Camera, Ray, Scene, Vector3, WebGLRenderer, WebGLRenderTarget } from 'three';
-import { PointCloudMaterial } from '../rendering';
+import { PointCloudMaterial } from '../../../../rendering';
 import { PointCloudOctree } from './PointCloudOctree';
 import { IPointCloudTreeNode } from './IPointCloudTreeNode';
 import { PickPoint, PointCloudHit } from '../types/types';

package/packages/pointclouds/src/potree-three-loader/types/IPotree.d.ts

@@ -1,10 +1,11 @@
 import { Camera, WebGLRenderer } from 'three';
 import { LRU } from '../utils/lru';
 import { PointCloudOctree } from '../tree/PointCloudOctree';
+import { PointCloudObject } from '../../../../data-providers';
 export interface IPotree {
     pointBudget: number;
     maxNumNodesLoading: number;
     lru: LRU;
-    loadPointCloud(baseUrl: string, fileName: string): Promise<PointCloudOctree>;
+    loadPointCloud(baseUrl: string, fileName: string, objects: PointCloudObject[], modelIdentifier: symbol): Promise<PointCloudOctree>;
     updatePointClouds(pointClouds: PointCloudOctree[], camera: Camera, renderer: WebGLRenderer): void;
 }

package/packages/pointclouds/src/potree-three-loader/utils/createObjectIdMaps.d.ts

@@ -0,0 +1,6 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { PointCloudObject } from '../../../../data-providers';
+import { PointCloudObjectIdMaps } from '../../../../rendering';
+export declare function createObjectIdMaps(objects: PointCloudObject[]): PointCloudObjectIdMaps;

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

@@ -1,3 +1,5 @@
+import { BufferGeometry, Camera, Material, Scene, WebGLRenderer } from 'three';
+import { IPointCloudTreeNode } from '../tree/IPointCloudTreeNode';
 import { IPointCloudTreeNodeBase } from '../tree/IPointCloudTreeNodeBase';
 export declare function getIndexFromName(name: string): number;
 /**
@@ -6,3 +8,5 @@ export declare function getIndexFromName(name: string): number;
 export declare function byLevelAndIndex(a: IPointCloudTreeNodeBase, b: IPointCloudTreeNodeBase): number;
 export declare function handleFailedRequest(response: Response): Response;
 export declare function handleEmptyBuffer(buffer: ArrayBuffer): ArrayBuffer;
+export declare function createVisibilityTextureData(nodes: IPointCloudTreeNodeBase[], visibleNodeTextureOffsets: Map<string, number>): Uint8Array;
+export declare function makeOnBeforeRender(node: IPointCloudTreeNode, pcIndex: number): (renderer: WebGLRenderer, scene: Scene, camera: Camera, bufferGeometry: BufferGeometry, material: Material) => void;

package/packages/pointclouds/src/potree-three-loader/workers/assignPointsToObjectsWithWasm.d.ts

@@ -0,0 +1,5 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { SerializableStylableObject } from '../../../../data-providers';
+export declare function assignPointsToObjectsWithWasm(points: Float32Array, objects: SerializableStylableObject[], pointOffset: THREE.Vector3, sectorBoundingBox: THREE.Box3): Promise<Uint16Array>;

package/packages/pointclouds/src/potree-three-loader/workers/eptBinaryDecoder.worker.d.ts

@@ -1,18 +1,7 @@
-export declare type ParsedEptData = {
-    numPoints: number;
-    tightBoundingBox: {
-        min: number[];
-        max: number[];
-    };
-    mean: number[];
-    position: ArrayBuffer;
-    color: ArrayBuffer | undefined;
-    intensity: ArrayBuffer | undefined;
-    classification: ArrayBuffer | undefined;
-    returnNumber: ArrayBuffer | undefined;
-    numberOfReturns: ArrayBuffer | undefined;
-    pointSourceId: ArrayBuffer | undefined;
-    indices: ArrayBuffer;
-};
-declare const _default: any;
-export default _default;
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { EptInputData, ParsedEptData } from './types';
+import { SerializableStylableObject } from '../../../../data-providers';
+import { AABB, Vec3 } from '../../../../utilities';
+export declare function parse(data: EptInputData, objects: SerializableStylableObject[], pointOffset: Vec3, boundingBox: AABB): Promise<ParsedEptData | Error>;

package/packages/pointclouds/src/potree-three-loader/workers/parseEpt.d.ts

@@ -0,0 +1,4 @@
+import { AABB, Vec3 } from '../../../../utilities';
+import { SerializableStylableObject } from '../../../../data-providers';
+import { EptInputData, ParsedEptData } from './types';
+export declare function parseEpt(data: EptInputData, objects: SerializableStylableObject[], pointOffset: Vec3, sectorBoundingBox: AABB): Promise<ParsedEptData>;

package/packages/pointclouds/src/potree-three-loader/workers/types.d.ts

@@ -0,0 +1,33 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { Vec3 } from '../../../../utilities';
+export declare type ParsedEptData = {
+    numPoints: number;
+    tightBoundingBox: {
+        min: number[];
+        max: number[];
+    };
+    mean: number[];
+    position: ArrayBuffer;
+    color: ArrayBuffer | undefined;
+    intensity: ArrayBuffer | undefined;
+    classification: ArrayBuffer | undefined;
+    returnNumber: ArrayBuffer | undefined;
+    numberOfReturns: ArrayBuffer | undefined;
+    pointSourceId: ArrayBuffer | undefined;
+    indices: ArrayBuffer;
+    objectId: ArrayBuffer;
+};
+export declare type AttributeSchema = {
+    name: string;
+    size: number;
+    type: 'signed' | 'unsigned' | 'float';
+};
+export declare type EptInputData = {
+    buffer: ArrayBuffer;
+    schema: AttributeSchema[];
+    scale: Vec3;
+    offset: Vec3;
+    mins: [number, number, number];
+};

package/packages/pointclouds/wasm/index.d.ts

@@ -0,0 +1,18 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { AABB, Vec3 } from '../../utilities';
+export declare type WasmSerializedCylinder = {
+    center_a: Vec3;
+    center_b: Vec3;
+    radius: number;
+};
+export declare type WasmSerializedOrientedBox = {
+    inv_instance_matrix: number[];
+};
+export declare type WasmSerializedPointCloudObject = {
+    object_id: number;
+    cylinder?: WasmSerializedCylinder | undefined;
+    oriented_box?: WasmSerializedOrientedBox | undefined;
+};
+export declare function assignPoints(input_shapes: Array<WasmSerializedPointCloudObject>, input_points: Float32Array, input_bounding_box: AABB, input_point_offset: Vec3): Promise<Uint16Array>;

package/packages/rendering/index.d.ts

@@ -1,16 +1,20 @@
 /**
  * Copyright 2021 Cognite AS
  */
-export { SectorQuads } from './src/rendering/types';
 export { CadMaterialManager } from './src/CadMaterialManager';
-export { createSimpleGeometryMesh } from './src/rendering/createSimpleGeometryMesh';
+export { PointCloudMaterialManager } from './src/PointCloudMaterialManager';
 export { NodeTransformProvider } from './src/transform/NodeTransformProvider';
 export { RenderOptions, defaultRenderOptions, SsaoParameters, SsaoSampleQuality, AntiAliasingMode } from './src/rendering/types';
+export * from './src/pointcloud-rendering/constants';
+export * from './src/pointcloud-rendering/enums';
+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 { coverageShaders } from './src/rendering/shaders';
 export { Materials } from './src/rendering/materials';
-export { createPrimitives } from './src/rendering/primitives';
+export { PointCloudMaterial, OctreeMaterialParams } from './src/pointcloud-rendering';
 export { DefaultRenderPipelineProvider } from './src/render-pipeline-providers/DefaultRenderPipelineProvider';
 export { CadGeometryRenderModePipelineProvider } from './src/render-pipeline-providers/CadGeometryRenderModePipelineProvider';
 export { BasicPipelineExecutor } from './src/pipeline-executors/BasicPipelineExecutor';

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

@@ -0,0 +1,19 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { PointCloudObjectIdMaps } from './pointcloud-rendering/PointCloudObjectIdMaps';
+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;
+    setModelsMaterialParameters(materialParameters: PointCloudMaterialParameters | undefined): void;
+    setMaterialParameters(material: PointCloudMaterial, parameters: PointCloudMaterialParameters): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,121 @@
+/*!
+ * Adapted from pnext/three-loader (https://github.com/pnext/three-loader)
+ */
+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';
+export interface IPointCloudMaterialParameters {
+    size: number;
+    minSize: number;
+    maxSize: number;
+    objectsMaps: PointCloudObjectIdMaps;
+}
+export interface IPointCloudMaterialUniforms {
+    classificationLUT: IUniform<Texture>;
+    fov: IUniform<number>;
+    gradient: IUniform<Texture>;
+    heightMax: IUniform<number>;
+    heightMin: IUniform<number>;
+    intensityBrightness: IUniform<number>;
+    intensityContrast: IUniform<number>;
+    intensityGamma: IUniform<number>;
+    intensityRange: IUniform<[number, number]>;
+    isLeafNode: IUniform<boolean>;
+    level: IUniform<number>;
+    maxSize: IUniform<number>;
+    minSize: IUniform<number>;
+    objectIdLUT: IUniform<Texture>;
+    octreeSize: IUniform<number>;
+    opacity: IUniform<number>;
+    pcIndex: IUniform<number>;
+    screenHeight: IUniform<number>;
+    screenWidth: IUniform<number>;
+    size: IUniform<number>;
+    spacing: IUniform<number>;
+    visibleNodes: IUniform<Texture>;
+    vnStart: IUniform<number>;
+}
+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).
+     */
+    useDrawingBufferSize: boolean;
+    lights: boolean;
+    fog: boolean;
+    visibleNodesTexture: Texture | undefined;
+    visibleNodeTextureOffsets: Map<string, number>;
+    private readonly _gradient;
+    private gradientTexture;
+    private readonly _objectAppearanceTexture;
+    private _classification;
+    private classificationTexture;
+    uniforms: IPointCloudMaterialUniforms & Record<string, IUniform<any>>;
+    fov: number;
+    heightMax: number;
+    heightMin: number;
+    intensityBrightness: number;
+    intensityContrast: number;
+    intensityGamma: number;
+    intensityRange: [number, number];
+    maxSize: number;
+    minSize: number;
+    octreeSize: number;
+    opacity: number;
+    screenHeight: number;
+    screenWidth: number;
+    size: number;
+    spacing: number;
+    weighted: boolean;
+    hqDepthPass: boolean;
+    pointColorType: PointColorType;
+    pointSizeType: PointSizeType;
+    useEDL: boolean;
+    shape: PointShape;
+    attributes: {
+        position: {
+            type: string;
+            value: never[];
+        };
+        color: {
+            type: string;
+            value: never[];
+        };
+        intensity: {
+            type: string;
+            value: never[];
+        };
+        classification: {
+            type: string;
+            value: never[];
+        };
+        objectId: {
+            type: string;
+            value: never[];
+        };
+        indices: {
+            type: string;
+            value: never[];
+        };
+    };
+    constructor(parameters?: Partial<IPointCloudMaterialParameters>);
+    dispose(): void;
+    clearVisibleNodeTextureOffsets(): void;
+    updateShaderSource(): void;
+    applyDefines(shaderSrc: string): string;
+    get objectAppearanceTexture(): PointCloudObjectAppearanceTexture;
+    get classification(): PointClassification;
+    set classification(value: PointClassification);
+    private recomputeClassification;
+    get elevationRange(): [number, number];
+    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;
+    private updateVisibilityTextureData;
+}

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

@@ -0,0 +1,30 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import * as THREE from 'three';
+import { StyledPointCloudObjectCollection, PointCloudObjectCollection, CompletePointCloudAppearance } from '../../../pointcloud-styling';
+import { PointCloudObjectIdMaps } from './PointCloudObjectIdMaps';
+export declare class PointCloudObjectAppearanceTexture {
+    private _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;
+    private resetTexture;
+    onBeforeRender(): void;
+    assignStyledObjectSet(styledCollection: StyledPointCloudObjectCollection): void;
+    removeStyledObjectSet(collection: PointCloudObjectCollection): void;
+    removeAllStyledObjectSets(): void;
+    set defaultAppearance(appearance: CompletePointCloudAppearance);
+    get defaultAppearance(): CompletePointCloudAppearance;
+    get objectStyleTexture(): THREE.DataTexture;
+}

package/packages/rendering/src/pointcloud-rendering/PointCloudObjectIdMaps.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+export declare type PointCloudObjectIdMaps = {
+    annotationToObjectIds: Map<number, number>;
+    objectToAnnotationIds: Map<number, number>;
+};

package/packages/rendering/src/pointcloud-rendering/classification.d.ts

@@ -0,0 +1,2 @@
+import { PointClassification } from './types';
+export declare const DEFAULT_CLASSIFICATION: PointClassification;

package/packages/{pointclouds/src/potree-three-loader/rendering → rendering/src/pointcloud-rendering}/constants.d.ts

@@ -1,7 +1,7 @@
-import { Color, Vector4 } from 'three';
-export declare const DEFAULT_RGB_BRIGHTNESS = 0;
-export declare const DEFAULT_RGB_CONTRAST = 0;
-export declare const DEFAULT_RGB_GAMMA = 1;
+/*!
+ * Adapted from pnext/three-loader (https://github.com/pnext/three-loader)
+ */
+import { Color } from 'three';
 export declare const DEFAULT_MAX_POINT_SIZE = 50;
 export declare const DEFAULT_MIN_NODE_PIXEL_SIZE = 50;
 export declare const DEFAULT_MIN_POINT_SIZE = 1;
@@ -12,4 +12,6 @@ export declare const MAX_NUM_NODES_LOADING = 8;
 export declare const UPDATE_THROTTLE_TIME_MS = 100;
 export declare const PERSPECTIVE_CAMERA = "PerspectiveCamera";
 export declare const COLOR_BLACK: Color;
-export declare const DEFAULT_HIGHLIGHT_COLOR: Vector4;
+export declare const COLOR_WHITE: Color;
+export declare const OBJECT_STYLING_TEXTURE_WIDTH = 256;
+export declare const OBJECT_STYLING_TEXTURE_HEIGHT = 256;

package/packages/rendering/src/pointcloud-rendering/enums.d.ts

@@ -0,0 +1,24 @@
+/*!
+ * Adapted from pnext/three-loader (https://github.com/pnext/three-loader)
+ */
+export declare enum PointSizeType {
+    Fixed = 0,
+    Attenuated = 1,
+    Adaptive = 2
+}
+export declare enum PointShape {
+    Square = 0,
+    Circle = 1,
+    Paraboloid = 2
+}
+export declare enum PointColorType {
+    Rgb = 0,
+    Depth = 2,
+    Height = 3,
+    Elevation = 3,
+    Intensity = 4,
+    Lod = 6,
+    LevelOfDetail = 6,
+    PointIndex = 7,
+    Classification = 8
+}

package/packages/rendering/src/pointcloud-rendering/index.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Adapted from pnext/three-loader (https://github.com/pnext/three-loader)
+ */
+export * from './enums';
+export * from './PointCloudMaterial';
+export * from './texture-generation';
+export * from './types';
+export * from './PointCloudObjectAppearanceTexture';

package/packages/rendering/src/pointcloud-rendering/texture-generation.d.ts

@@ -0,0 +1,8 @@
+/*!
+ * Adapted from pnext/three-loader (https://github.com/pnext/three-loader)
+ */
+import { Color, DataTexture, Texture } from 'three';
+import { PointClassification, IGradient } from './types';
+export declare function generateDataTexture(width: number, height: number, color: Color): DataTexture;
+export declare function generateGradientTexture(gradient: IGradient): Texture;
+export declare function generateClassificationTexture(classification: PointClassification): Texture;

package/packages/{pointclouds/src/potree-three-loader/rendering → rendering/src/pointcloud-rendering}/types.d.ts

@@ -1,6 +1,9 @@
+/*!
+ * Adapted from pnext/three-loader (https://github.com/pnext/three-loader)
+ */
 import { Color, IUniform as IThreeUniform, Vector4 } from 'three';
 export declare type IGradient = [number, Color][];
-export interface IClassification {
+export interface PointClassification {
     [value: string]: Vector4;
     DEFAULT: Vector4;
 }
@@ -8,3 +11,8 @@ export interface IUniform<T> extends IThreeUniform {
     type: string;
     value: T;
 }
+export declare type OctreeMaterialParams = {
+    scale: THREE.Vector3;
+    spacing: number;
+    boundingBox: THREE.Box3;
+};

package/packages/rendering/src/render-passes/PointCloudEffectsPass.d.ts

@@ -1,16 +1,11 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import { SceneHandler } from '../../../utilities';
 import * as THREE from 'three';
 import { RenderPass } from '../RenderPass';
 import { PointCloudPassParameters } from './types';
+import { PointCloudMaterialManager } from '../PointCloudMaterialManager';
 export declare class PointCloudEffectsPass implements RenderPass {
     private readonly _viewerScene;
-    private readonly _sceneHandler;
+    private readonly _pointCloudMaterialManager;
     private readonly _passMaterialParameters;
-    constructor(sceneHandler: SceneHandler, materialParameters?: PointCloudPassParameters);
+    constructor(scene: THREE.Object3D, pointCloudMaterialManager: PointCloudMaterialManager, materialParameters?: PointCloudPassParameters);
     render(renderer: THREE.WebGLRenderer, camera: THREE.Camera): void;
-    private setMaterialParameters;
-    private setRendererParameters;
 }

package/packages/rendering/src/render-passes/PostProcessingPass.d.ts

@@ -14,6 +14,7 @@ import { PostProcessingPipelineOptions } from '../render-pipeline-providers/type
 export declare class PostProcessingPass implements RenderPass {
     private readonly _scene;
     private readonly _postProcessingObjects;
+    private readonly setBlendFactorByBackVisibility;
     updateRenderObjectsVisibility(visibilityParameters: PostProcessingObjectsVisibilityParameters): void;
     constructor(scene: THREE.Scene, postProcessingPipelineOptions: PostProcessingPipelineOptions);
     render(renderer: THREE.WebGLRenderer, camera: THREE.Camera): void;