@cognite/reveal 3.0.2 → 3.1.0

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

@@ -5,6 +5,7 @@ import { LoadingState } from '../../model-base';
 import { Observable } from 'rxjs';
 import * as THREE from 'three';
 import { PotreeNodeWrapper } from './PotreeNodeWrapper';
+import { Potree, PointCloudOctree } from './potree-three-loader';
 /**
  * Wrapper around Potree.Group with type information and
  * basic functionality.
@@ -14,20 +15,26 @@ export declare class PotreeGroupWrapper extends THREE.Object3D {
     private _lastDrawPointBuffersHash;
     private readonly _forceLoadingSubject;
     private readonly _loadingObservable;
+    private readonly _pointClouds;
     get needsRedraw(): boolean;
     private readonly nodes;
     private readonly potreeGroup;
+    private readonly _potreeInstance;
     private numNodesLoadingAfterLastRedraw;
     private numChildrenAfterLastRedraw;
     /**
+     * @param potreeInstance Main instance of the Potree library in this Reveal instance
      * @param pollLoadingStatusInterval Controls how often the wrapper checks for loading status. Used for testing.
      */
-    constructor(pollLoadingStatusInterval?: number);
+    constructor(potreeInstance: Potree, pollLoadingStatusInterval?: number);
     get pointBudget(): number;
     set pointBudget(points: number);
+    get pointClouds(): PointCloudOctree[];
+    get potreeInstance(): Potree;
     getLoadingStateObserver(): Observable<LoadingState>;
     addPointCloud(node: PotreeNodeWrapper): void;
     removePointCloud(node: PotreeNodeWrapper): void;
+    traversePointClouds(callback: (pointCloud: PointCloudOctree) => void): void;
     requestRedraw(): void;
     resetRedraw(): void;
     private createLoadingStateObservable;

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

@@ -2,7 +2,6 @@
  * Copyright 2021 Cognite AS
  */
 import * as THREE from 'three';
-import { PotreePointSizeType, PotreePointColorType, PotreePointShape } from './types';
 export declare type PotreeClassification = {
     [pointClass: number]: {
         x: number;
@@ -11,20 +10,19 @@ export declare type PotreeClassification = {
         w: number;
     };
 };
+import { PointCloudOctree, PotreePointColorType, PotreePointShape, PickPoint } from './potree-three-loader';
+import { WellKnownAsprsPointClassCodes } from './types';
 /**
- * Wrapper around `Potree.PointCloudOctree` with some convinence functions.
+ * Wrapper around `Potree.PointCloudOctree` with some convenience functions.
  */
 export declare class PotreeNodeWrapper {
-    readonly octtree: any;
+    readonly octree: PointCloudOctree;
     private _needsRedraw;
+    private readonly _classification;
     get needsRedraw(): boolean;
-    constructor(octtree: any);
+    constructor(octree: PointCloudOctree);
     get pointSize(): number;
     set pointSize(size: number);
-    get pointSizeType(): PotreePointSizeType;
-    set pointSizeType(type: PotreePointSizeType);
-    get pointBudget(): number;
-    set pointBudget(count: number);
     get visiblePointCount(): number;
     get boundingBox(): THREE.Box3;
     get pointColorType(): PotreePointColorType;
@@ -32,6 +30,7 @@ export declare class PotreeNodeWrapper {
     get pointShape(): PotreePointShape;
     set pointShape(shape: PotreePointShape);
     get classification(): PotreeClassification;
-    recomputeClassification(): void;
+    pick(renderer: THREE.WebGLRenderer, camera: THREE.Camera, ray: THREE.Ray): PickPoint | null;
+    setClassificationAndRecompute(pointClass: number | WellKnownAsprsPointClassCodes, visible: boolean): void;
     resetRedraw(): void;
 }

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

@@ -0,0 +1,4 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+export { Potree, PointCloudOctree, PotreePointSizeType } from './potree-three-loader';

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

@@ -0,0 +1,5 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { WellKnownAsprsPointClassCodes } from './types';
+export declare function createPointClassKey(pointClass: number | WellKnownAsprsPointClassCodes): number;

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

@@ -2,5 +2,6 @@
  * Copyright 2021 Cognite AS
  */
 import { PointCloudManager } from './PointCloudManager';
+import * as THREE from 'three';
 import { ModelDataProvider, ModelMetadataProvider } from '../../modeldata-api';
-export declare function createPointCloudManager(modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider): PointCloudManager;
+export declare function createPointCloudManager(modelMetadataProvider: ModelMetadataProvider, modelDataProvider: ModelDataProvider, scene: THREE.Scene, renderer: THREE.WebGLRenderer): PointCloudManager;

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

@@ -0,0 +1,46 @@
+import { Camera, Ray, WebGLRenderer } from 'three';
+import { PointCloudOctree } from './tree/PointCloudOctree';
+import { PickParams } from './tree/PointCloudOctreePicker';
+import { PickPoint } from './types/types';
+import { IPotree } from './types/IPotree';
+import { IVisibilityUpdateResult } from './types/IVisibilityUpdateResult';
+import { IPointCloudTreeNodeBase } from './tree/IPointCloudTreeNodeBase';
+import { LRU } from './utils/lru';
+import { ModelDataProvider } from '../../../modeldata-api';
+export declare class QueueItem {
+    pointCloudIndex: number;
+    weight: number;
+    node: IPointCloudTreeNodeBase;
+    parent?: IPointCloudTreeNodeBase | undefined;
+    constructor(pointCloudIndex: number, weight: number, node: IPointCloudTreeNodeBase, parent?: IPointCloudTreeNodeBase | undefined);
+}
+export declare class Potree implements IPotree {
+    private static picker;
+    private _pointBudget;
+    private readonly _rendererSize;
+    private readonly _modelDataProvider;
+    maxNumNodesLoading: number;
+    features: {
+        SHADER_INTERPOLATION: boolean;
+        SHADER_SPLATS: boolean;
+        SHADER_EDL: boolean;
+        precision: string;
+    };
+    lru: LRU;
+    constructor(modelDataProvider: ModelDataProvider);
+    loadPointCloud(baseUrl: string, fileName: string, _xhrRequest?: (input: RequestInfo, init?: RequestInit) => Promise<Response>): Promise<PointCloudOctree>;
+    updatePointClouds(pointClouds: PointCloudOctree[], camera: Camera, renderer: WebGLRenderer): IVisibilityUpdateResult;
+    static pick(pointClouds: PointCloudOctree[], renderer: WebGLRenderer, camera: Camera, ray: Ray, params?: Partial<PickParams>): PickPoint | null;
+    get pointBudget(): number;
+    set pointBudget(value: number);
+    static set maxLoaderWorkers(value: number);
+    static get maxLoaderWorkers(): number;
+    private updateVisibilityForNode;
+    private createVisibilityUpdateResult;
+    private updateVisibility;
+    private updateTreeNodeVisibility;
+    private updateChildVisibility;
+    private updateBoundingBoxVisibility;
+    private shouldClip;
+    private readonly updateVisibilityStructures;
+}

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

@@ -0,0 +1,10 @@
+import { IPointCloudTreeNodeBase } from '../tree/IPointCloudTreeNodeBase';
+import * as THREE from 'three';
+export interface IPointCloudTreeGeometry {
+    root: IPointCloudTreeNodeBase | undefined;
+    boundingBox: THREE.Box3;
+    tightBoundingBox: THREE.Box3;
+    offset: THREE.Vector3;
+    spacing: number;
+    dispose(): void;
+}

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

@@ -0,0 +1,11 @@
+import { IPointCloudTreeNodeBase } from '../tree/IPointCloudTreeNodeBase';
+import * as THREE from 'three';
+export interface IPointCloudTreeGeometryNode extends IPointCloudTreeNodeBase {
+    geometry: THREE.BufferGeometry | undefined;
+    failed: boolean;
+    load: () => Promise<void>;
+    baseUrl: () => string;
+    fileName: () => string;
+    oneTimeDisposeHandlers: (() => void)[];
+    doneLoading: (bufferGeometry: THREE.BufferGeometry, _tightBoundingBox: THREE.Box3, np: number, _mean: THREE.Vector3) => void;
+}

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

@@ -0,0 +1,50 @@
+import * as THREE from 'three';
+import { ILoader } from '../loading/ILoader';
+import { PointCloudEptGeometryNode } from './PointCloudEptGeometryNode';
+import { IPointCloudTreeGeometry } from './IPointCloudTreeGeometry';
+import { ModelDataProvider } from '../../../../modeldata-api';
+declare type SchemaEntry = {
+    name: string;
+    scale: number;
+    offset: number;
+};
+export declare class PointCloudEptGeometry implements IPointCloudTreeGeometry {
+    private readonly _eptScale;
+    private readonly _eptOffset;
+    private readonly _url;
+    private readonly _boundingBox;
+    private readonly _tightBoundingBox;
+    private readonly _offset;
+    private readonly _span;
+    private readonly _spacing;
+    private readonly _loader;
+    private readonly _schema;
+    private _root;
+    private readonly _projection;
+    get root(): PointCloudEptGeometryNode | undefined;
+    set root(r: PointCloudEptGeometryNode | undefined);
+    get boundingBox(): THREE.Box3;
+    get tightBoundingBox(): THREE.Box3;
+    get offset(): THREE.Vector3;
+    get spacing(): number;
+    get url(): string;
+    get schema(): SchemaEntry[];
+    get eptScale(): THREE.Vector3;
+    get eptOffset(): THREE.Vector3;
+    get loader(): ILoader;
+    constructor(url: string, info: any, dataLoader: ModelDataProvider);
+    dispose(): void;
+}
+export declare class EptKey {
+    readonly ept: PointCloudEptGeometry;
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly b: THREE.Box3;
+    readonly d: number;
+    constructor(ept: PointCloudEptGeometry, b: THREE.Box3, d: number, x?: number, y?: number, z?: number);
+    name(): string;
+    step(a: number, b: number, c: number): EptKey;
+    children(): string[];
+}
+export {};

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

@@ -0,0 +1,63 @@
+import { IPointCloudTreeGeometryNode } from './IPointCloudTreeGeometryNode';
+import { IPointCloudTreeNodeBase } from '../tree/IPointCloudTreeNodeBase';
+import * as THREE from 'three';
+import { PointCloudEptGeometry, EptKey } from './PointCloudEptGeometry';
+import { ModelDataProvider } from '../../../../modeldata-api';
+export declare class PointCloudEptGeometryNode implements IPointCloudTreeGeometryNode {
+    private readonly _id;
+    private readonly _ept;
+    private readonly _key;
+    private readonly _dataLoader;
+    private readonly _boundingBox;
+    private readonly _boundingSphere;
+    private readonly _spacing;
+    private _level;
+    private _numPoints;
+    private readonly _name;
+    private readonly _index;
+    private readonly _children;
+    private _loading;
+    private _loaded;
+    private _parent;
+    private _isLeafNode;
+    private _geometry;
+    private _oneTimeDisposeHandlers;
+    static IDCount: number;
+    get id(): number;
+    get name(): string;
+    get level(): number;
+    get spacing(): number;
+    get boundingBox(): THREE.Box3;
+    get boundingSphere(): THREE.Sphere;
+    get loaded(): boolean;
+    get key(): EptKey;
+    get failed(): boolean;
+    get numPoints(): number;
+    get children(): IPointCloudTreeNodeBase[];
+    get oneTimeDisposeHandlers(): (() => void)[];
+    get isLeafNode(): boolean;
+    get geometry(): THREE.BufferGeometry | undefined;
+    get ept(): PointCloudEptGeometry;
+    get index(): number;
+    set parent(_p: PointCloudEptGeometryNode | undefined);
+    get parent(): PointCloudEptGeometryNode | undefined;
+    constructor(ept: PointCloudEptGeometry, modelDataProvider: ModelDataProvider, b?: THREE.Box3, d?: number, x?: number, y?: number, z?: number);
+    get isGeometryNode(): boolean;
+    getLevel(): number;
+    get isTreeNode(): boolean;
+    isLoaded(): boolean;
+    getBoundingSphere(): THREE.Sphere;
+    getBoundingBox(): THREE.Box3;
+    baseUrl(): string;
+    getNumPoints(): number;
+    fileName(): string;
+    getChildren(): IPointCloudTreeGeometryNode[];
+    traverse(callback: (node: IPointCloudTreeNodeBase) => void, includeSelf?: boolean): void;
+    addChild(child: PointCloudEptGeometryNode): void;
+    load(): Promise<void>;
+    loadPoints(): Promise<void>;
+    loadHierarchy(): Promise<void>;
+    doneLoading(bufferGeometry: THREE.BufferGeometry, _tightBoundingBox: THREE.Box3, np: number, _mean: THREE.Vector3): void;
+    toPotreeName(d: number, x: number, y: number, z: number): string;
+    dispose(): void;
+}

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

@@ -0,0 +1,7 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import * as THREE from 'three';
+export declare function toVector3(v: number[], offset?: number): THREE.Vector3;
+export declare function toBox3(b: number[]): THREE.Box3;
+export declare function sphereFrom(b: THREE.Box3): THREE.Sphere;

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

@@ -0,0 +1,10 @@
+export * from './rendering';
+export * from './tree/PointAttributes';
+export * from './tree/PointCloudOctreeNode';
+export * from './tree/PointCloudOctreePicker';
+export * from './tree/PointCloudOctree';
+export * from './tree/PointCloudTree';
+export * from './Potree';
+export * from './types/types';
+export * from './version';
+export { globalNumNodesLoading as numPointCloudNodesLoading } from './loading/globalLoadingCounter';

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

@@ -0,0 +1,12 @@
+import { WorkerPool } from '../utils/WorkerPool';
+import { ILoader } from './ILoader';
+import { ModelDataProvider } from '../../../../modeldata-api';
+import { PointCloudEptGeometryNode } from '../geometry/PointCloudEptGeometryNode';
+export declare class EptBinaryLoader implements ILoader {
+    private readonly _dataLoader;
+    static readonly WORKER_POOL: WorkerPool<Worker>;
+    extension(): string;
+    constructor(dataLoader: ModelDataProvider);
+    load(node: PointCloudEptGeometryNode): Promise<void>;
+    parse(node: PointCloudEptGeometryNode, buffer: ArrayBuffer): Promise<void>;
+}

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

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

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

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

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

@@ -0,0 +1,5 @@
+declare let globalNumNodesLoading: number;
+declare const globalMaxNumNodesLoading: number;
+export { globalNumNodesLoading, globalMaxNumNodesLoading };
+export declare function incrementGlobalNumNodesLoading(): void;
+export declare function decrementGlobalNumNodesLoading(): void;

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

@@ -0,0 +1,203 @@
+import { BufferGeometry, Camera, Color, Material, RawShaderMaterial, Scene, Texture, Vector3, Vector4, WebGLRenderer } from 'three';
+import { PointCloudOctree } from '../tree/PointCloudOctree';
+import { IPointCloudTreeNodeBase } from '../tree/IPointCloudTreeNodeBase';
+import { IPointCloudTreeNode } from '../tree/IPointCloudTreeNode';
+import { ClipMode, IClipBox } from './clipping';
+import { PointCloudMixingMode, PotreePointColorType, PointOpacityType, PotreePointShape, PotreePointSizeType, TreeType } from './enums';
+import { IClassification, IUniform } from './types';
+export interface IPointCloudMaterialParameters {
+    size: number;
+    minSize: number;
+    maxSize: number;
+    treeType: TreeType;
+}
+export interface IPointCloudMaterialUniforms {
+    bbSize: IUniform<[number, number, number]>;
+    blendDepthSupplement: IUniform<number>;
+    blendHardness: IUniform<number>;
+    classificationLUT: IUniform<Texture>;
+    clipBoxCount: IUniform<number>;
+    clipBoxes: IUniform<Float32Array>;
+    depthMap: IUniform<Texture | null>;
+    diffuse: IUniform<[number, number, number]>;
+    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>;
+    octreeSize: IUniform<number>;
+    opacity: IUniform<number>;
+    pcIndex: IUniform<number>;
+    rgbBrightness: IUniform<number>;
+    rgbContrast: IUniform<number>;
+    rgbGamma: IUniform<number>;
+    screenHeight: IUniform<number>;
+    screenWidth: IUniform<number>;
+    size: IUniform<number>;
+    spacing: IUniform<number>;
+    toModel: IUniform<number[]>;
+    transition: IUniform<number>;
+    uColor: IUniform<Color>;
+    visibleNodes: IUniform<Texture>;
+    vnStart: IUniform<number>;
+    wClassification: IUniform<number>;
+    wElevation: IUniform<number>;
+    wIntensity: IUniform<number>;
+    wReturnNumber: IUniform<number>;
+    wRGB: IUniform<number>;
+    wSourceID: IUniform<number>;
+    opacityAttenuation: IUniform<number>;
+    filterByNormalThreshold: IUniform<number>;
+    highlightedPointCoordinate: IUniform<Vector3>;
+    highlightedPointColor: IUniform<Vector4>;
+    enablePointHighlighting: IUniform<boolean>;
+    highlightedPointScale: IUniform<number>;
+    normalFilteringMode: IUniform<number>;
+    backgroundMap: IUniform<Texture | null>;
+    pointCloudID: IUniform<number>;
+    pointCloudMixAngle: IUniform<number>;
+    stripeDistanceX: IUniform<number>;
+    stripeDistanceY: IUniform<number>;
+    stripeDivisorX: IUniform<number>;
+    stripeDivisorY: IUniform<number>;
+    pointCloudMixingMode: 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;
+    numClipBoxes: number;
+    clipBoxes: IClipBox[];
+    visibleNodesTexture: Texture | undefined;
+    private readonly visibleNodeTextureOffsets;
+    private readonly _gradient;
+    private gradientTexture;
+    private _classification;
+    private classificationTexture;
+    uniforms: IPointCloudMaterialUniforms & Record<string, IUniform<any>>;
+    bbSize: [number, number, number];
+    depthMap: Texture | undefined;
+    fov: number;
+    heightMax: number;
+    heightMin: number;
+    intensityBrightness: number;
+    intensityContrast: number;
+    intensityGamma: number;
+    intensityRange: [number, number];
+    maxSize: number;
+    minSize: number;
+    octreeSize: number;
+    opacity: number;
+    rgbBrightness: number;
+    rgbContrast: number;
+    rgbGamma: number;
+    screenHeight: number;
+    screenWidth: number;
+    size: number;
+    spacing: number;
+    transition: number;
+    color: Color;
+    weightClassification: number;
+    weightElevation: number;
+    weightIntensity: number;
+    weightReturnNumber: number;
+    weightRGB: number;
+    weightSourceID: number;
+    opacityAttenuation: number;
+    filterByNormalThreshold: number;
+    highlightedPointCoordinate: Vector3;
+    highlightedPointColor: Vector4;
+    enablePointHighlighting: boolean;
+    highlightedPointScale: number;
+    normalFilteringMode: number;
+    backgroundMap: Texture | undefined;
+    pointCloudID: number;
+    pointCloudMixingMode: number;
+    stripeDistanceX: number;
+    stripeDistanceY: number;
+    stripeDivisorX: number;
+    stripeDivisorY: number;
+    pointCloudMixAngle: number;
+    useClipBox: boolean;
+    weighted: boolean;
+    pointColorType: PotreePointColorType;
+    pointSizeType: PotreePointSizeType;
+    clipMode: ClipMode;
+    useEDL: boolean;
+    shape: PotreePointShape;
+    treeType: TreeType;
+    pointOpacityType: PointOpacityType;
+    useFilterByNormal: boolean;
+    useTextureBlending: boolean;
+    usePointCloudMixing: boolean;
+    highlightPoint: boolean;
+    attributes: {
+        position: {
+            type: string;
+            value: never[];
+        };
+        color: {
+            type: string;
+            value: never[];
+        };
+        normal: {
+            type: string;
+            value: never[];
+        };
+        intensity: {
+            type: string;
+            value: never[];
+        };
+        classification: {
+            type: string;
+            value: never[];
+        };
+        returnNumber: {
+            type: string;
+            value: never[];
+        };
+        numberOfReturns: {
+            type: string;
+            value: never[];
+        };
+        pointSourceID: {
+            type: string;
+            value: never[];
+        };
+        indices: {
+            type: string;
+            value: never[];
+        };
+    };
+    constructor(parameters?: Partial<IPointCloudMaterialParameters>);
+    dispose(): void;
+    clearVisibleNodeTextureOffsets(): void;
+    updateShaderSource(): void;
+    applyDefines(shaderSrc: string): string;
+    setPointCloudMixingMode(mode: PointCloudMixingMode): void;
+    getPointCloudMixingMode(): PointCloudMixingMode;
+    setClipBoxes(clipBoxes: IClipBox[]): void;
+    get classification(): IClassification;
+    set classification(value: IClassification);
+    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;
+    updateMaterial(octree: PointCloudOctree, visibleNodes: IPointCloudTreeNodeBase[], camera: Camera, renderer: WebGLRenderer): void;
+    private updateVisibilityTextureData;
+    static makeOnBeforeRender(octree: PointCloudOctree, node: IPointCloudTreeNode, pcIndex?: number): (renderer: WebGLRenderer, scene: Scene, camera: Camera, bufferGeometry: BufferGeometry, material: Material) => void;
+}

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

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

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

@@ -0,0 +1,12 @@
+import { Box3, Matrix4, Vector3 } from 'three';
+export declare enum ClipMode {
+    DISABLED = 0,
+    CLIP_OUTSIDE = 1,
+    HIGHLIGHT_INSIDE = 2
+}
+export interface IClipBox {
+    box: Box3;
+    inverse: Matrix4;
+    matrix: Matrix4;
+    position: Vector3;
+}

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

@@ -0,0 +1,14 @@
+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;
+export declare const DEFAULT_MAX_POINT_SIZE = 50;
+export declare const DEFAULT_MIN_NODE_PIXEL_SIZE = 50;
+export declare const DEFAULT_MIN_POINT_SIZE = 2;
+export declare const DEFAULT_PICK_WINDOW_SIZE = 15;
+export declare const DEFAULT_POINT_BUDGET = 1000000;
+export declare const MAX_LOADS_TO_GPU = 2;
+export declare const MAX_NUM_NODES_LOADING = 4;
+export declare const PERSPECTIVE_CAMERA = "PerspectiveCamera";
+export declare const COLOR_BLACK: Color;
+export declare const DEFAULT_HIGHLIGHT_COLOR: Vector4;

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

@@ -0,0 +1,46 @@
+export declare enum PotreePointSizeType {
+    Fixed = 0,
+    Attenuated = 1,
+    Adaptive = 2
+}
+export declare enum PotreePointShape {
+    Square = 0,
+    Circle = 1,
+    Paraboloid = 2
+}
+export declare enum TreeType {
+    Octree = 0,
+    KdTree = 1
+}
+export declare enum PointOpacityType {
+    Fixed = 0,
+    Attenuated = 1
+}
+export declare enum PotreePointColorType {
+    Rgb = 0,
+    Color = 1,
+    Depth = 2,
+    Height = 3,
+    Elevation = 3,
+    Intensity = 4,
+    IntensityGradient = 5,
+    Lod = 6,
+    LevelOfDetail = 6,
+    PointIndex = 7,
+    Classification = 8,
+    ReturnNumber = 9,
+    Source = 10,
+    Normal = 11,
+    Phong = 12,
+    RgbHeight = 13,
+    Composite = 50
+}
+export declare enum NormalFilteringMode {
+    ABSOLUTE_NORMAL_FILTERING_MODE = 1,
+    LESS_EQUAL_NORMAL_FILTERING_MODE = 2,
+    GREATER_NORMAL_FILTERING_MODE = 3
+}
+export declare enum PointCloudMixingMode {
+    CHECKBOARD = 1,
+    STRIPES = 2
+}

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

@@ -0,0 +1,6 @@
+export declare const FEATURES: {
+    SHADER_INTERPOLATION: boolean;
+    SHADER_SPLATS: boolean;
+    SHADER_EDL: boolean;
+    precision: string;
+};

package/packages/pointclouds/src/potree-three-loader/rendering/gradients/SpectralGradient.d.ts

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

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

@@ -0,0 +1,5 @@
+export * from './clipping';
+export * from './enums';
+export * from './PointCloudMaterial';
+export * from './texture-generation';
+export * from './types';

package/packages/pointclouds/src/potree-three-loader/rendering/texture-generation.d.ts

@@ -0,0 +1,5 @@
+import { Color, Texture } from 'three';
+import { IClassification, IGradient } from './types';
+export declare function generateDataTexture(width: number, height: number, color: Color): Texture;
+export declare function generateGradientTexture(gradient: IGradient): Texture;
+export declare function generateClassificationTexture(classification: IClassification): Texture;

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

@@ -0,0 +1,10 @@
+import { Color, IUniform as IThreeUniform, Vector4 } from 'three';
+export declare type IGradient = [number, Color][];
+export interface IClassification {
+    [value: string]: Vector4;
+    DEFAULT: Vector4;
+}
+export interface IUniform<T> extends IThreeUniform {
+    type: string;
+    value: T;
+}