@cognite/reveal 3.0.2 → 3.2.0

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

@@ -0,0 +1,6 @@
+import { Object3D } from 'three';
+import { IPointCloudTreeNodeBase } from './IPointCloudTreeNodeBase';
+export declare class PointCloudTree extends Object3D {
+    root: IPointCloudTreeNodeBase | undefined;
+    initialized(): boolean;
+}

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

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

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

@@ -0,0 +1,18 @@
+import { IPointCloudTreeNodeBase } from '../tree/IPointCloudTreeNodeBase';
+export interface IVisibilityUpdateResult {
+    visibleNodes: IPointCloudTreeNodeBase[];
+    numVisiblePoints: number;
+    /**
+     * True when a node has been loaded but was not added to the scene yet.
+     * Make sure to call updatePointClouds() again on the next frame.
+     */
+    exceededMaxLoadsToGPU: boolean;
+    /**
+     * True when at least one node in view has failed to load.
+     */
+    nodeLoadFailed: boolean;
+    /**
+     * Promises for loading nodes, will reject when loading fails.
+     */
+    nodeLoadPromises: Promise<void>[];
+}

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

@@ -0,0 +1,6 @@
+import { IPointCloudTreeNodeBase } from '../tree/IPointCloudTreeNodeBase';
+import { IPointCloudTreeGeometryNode } from '../geometry/IPointCloudTreeGeometryNode';
+import { IPointCloudTreeNode } from '../tree/IPointCloudTreeNode';
+export declare function isGeometryNode(node?: any): node is IPointCloudTreeGeometryNode;
+export declare function isTreeNode(node?: IPointCloudTreeNodeBase): node is IPointCloudTreeNode;
+export declare function isOptionalTreeNode(node?: IPointCloudTreeNodeBase): node is IPointCloudTreeNode | undefined;

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

@@ -0,0 +1,14 @@
+import { Vector3 } from 'three';
+import { PointCloudOctree } from '../tree/PointCloudOctree';
+export interface PickPoint {
+    pointIndex: number;
+    object: THREE.Object3D;
+    position: Vector3;
+    normal?: Vector3;
+    pointCloud?: PointCloudOctree;
+    [property: string]: any;
+}
+export interface PointCloudHit {
+    pIndex: number;
+    pcIndex: number;
+}

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

@@ -0,0 +1,11 @@
+export declare class BinaryHeap<T> {
+    _content: T[];
+    _scoreFunction: (element: T) => number;
+    constructor(scoreFunction: (element: T) => number);
+    push(element: T): void;
+    pop(): T | undefined;
+    remove(node: T): void;
+    size(): number;
+    bubbleUp(n: number): void;
+    sinkDown(n: number): void;
+}

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

@@ -0,0 +1,31 @@
+export declare class AutoTerminatingWorker {
+    private readonly wrappedWorker;
+    private readonly maxIdle;
+    private timeoutId;
+    private terminated;
+    constructor(wrappedWorker: Worker, maxIdle: number);
+    get worker(): Worker;
+    get isTerminated(): boolean;
+    markIdle(): void;
+    markInUse(): void;
+}
+export declare class WorkerPool<T extends Worker> {
+    maxWorkers: number;
+    private readonly workerType;
+    /**
+     * The maximum amount of idle time that can elapse before a worker from this pool is automatically terminated
+     */
+    private static readonly POOL_MAX_IDLE;
+    private readonly pool;
+    private poolSize;
+    constructor(maxWorkers: number, workerType: new () => T);
+    /**
+     * Returns a worker promise which is resolved when one is available.
+     */
+    getWorker(): Promise<AutoTerminatingWorker>;
+    /**
+     * Releases a Worker back into the pool
+     * @param worker
+     */
+    releaseWorker(worker: AutoTerminatingWorker): void;
+}

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

@@ -0,0 +1,8 @@
+export declare class AsyncBlockingQueue<T> {
+    private readonly promises;
+    private readonly resolvers;
+    constructor();
+    enqueue(t: T): void;
+    dequeue(): Promise<T>;
+    private add;
+}

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

@@ -0,0 +1,6 @@
+import { Box3, Matrix4 } from 'three';
+/**
+ * adapted from mhluska at https://github.com/mrdoob/three.js/issues/1561
+ */
+export declare function computeTransformedBoundingBox(box: Box3, transform: Matrix4): Box3;
+export declare function createChildAABB(aabb: Box3, index: number): Box3;

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

@@ -0,0 +1,13 @@
+import { Box3, Color, LineSegments } from 'three';
+/**
+ *
+ * code adapted from three.js BoxHelper.js
+ * https://github.com/mrdoob/three.js/blob/dev/src/helpers/BoxHelper.js
+ *
+ * @author mrdoob / http://mrdoob.com/
+ * @author Mugen87 / http://github.com/Mugen87
+ * @author mschuetz / http://potree.org
+ */
+export declare class Box3Helper extends LineSegments {
+    constructor(box: Box3, color?: Color);
+}

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

@@ -0,0 +1,32 @@
+import { IPointCloudTreeNodeBase } from '../tree/IPointCloudTreeNodeBase';
+export declare type Node = IPointCloudTreeNodeBase;
+export declare class LRUItem {
+    node: Node;
+    next: LRUItem | null;
+    previous: LRUItem | null;
+    constructor(node: Node);
+}
+/**
+ * A doubly-linked-list of the least recently used elements.
+ */
+export declare class LRU {
+    pointBudget: number;
+    first: LRUItem | null;
+    last: LRUItem | null;
+    numPoints: number;
+    private readonly items;
+    constructor(pointBudget?: number);
+    get size(): number;
+    has(node: Node): boolean;
+    /**
+     * Makes the specified the most recently used item. if the list does not contain node, it will
+     * be added.
+     */
+    touch(node: Node): void;
+    private addNew;
+    private touchExisting;
+    remove(node: Node): void;
+    getLRUItem(): Node | undefined;
+    freeMemory(): void;
+    disposeSubtree(node: Node): void;
+}

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

@@ -0,0 +1 @@
+export declare function clamp(value: number, min: number, max: number): number;

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

@@ -0,0 +1,8 @@
+import { IPointCloudTreeNodeBase } from '../tree/IPointCloudTreeNodeBase';
+export declare function getIndexFromName(name: string): number;
+/**
+ * When passed to `[].sort`, sorts the array by level and index: r, r0, r3, r4, r01, r07, r30, ...
+ */
+export declare function byLevelAndIndex(a: IPointCloudTreeNodeBase, b: IPointCloudTreeNodeBase): number;
+export declare function handleFailedRequest(response: Response): Response;
+export declare function handleEmptyBuffer(buffer: ArrayBuffer): ArrayBuffer;

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

@@ -0,0 +1,9 @@
+export declare class Version {
+    version: string;
+    versionMajor: number;
+    versionMinor: number;
+    constructor(version: string);
+    newerThan(version: string): boolean;
+    equalOrHigher(version: string): boolean;
+    upTo(version: string): boolean;
+}

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

@@ -0,0 +1,18 @@
+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;

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

@@ -1,114 +1,84 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-export declare enum PotreePointShape {
-    Circle,
-    Square
-}
-export declare enum PotreePointColorType {
-    /** Describes the observed real-world color of a point. */
-    Rgb,
-    /** Shows the distance from current camera with color gradient */
-    Depth,
-    /** Height, or elevation, mapped to a color with a gradient. */
-    Height,
-    /** Specifies the order in which points were captured from a single beam. */
-    PointIndex,
-    /**
-     * Calculated during rendering.
-     * It is equal to the level of the most detailed visible node in a region
-     */
-    LevelOfDetail,
-    /**
-     * Indicates whether a point is part of some class of objects.
-     * Classes are mapped to colors.
-     */
-    Classification,
-    /** Indicates the strength of the backscattered signal in a laser scan. */
-    Intensity
-}
-export declare enum PotreePointSizeType {
-    Adaptive,
-    Fixed
-}
-/**
- * ASPRS well known point class types.
- * @see {@link http://www.asprs.org/wp-content/uploads/2019/03/LAS_1_4_r14.pdf} (page 30)
- */
-export declare enum WellKnownAsprsPointClassCodes {
-    /**
-     * Special value for all other classes. Some point in Potree might be in this class
-     *
-     */
-    Default = -1,
-    /**
-     * Created, never classified.
-     */
-    Created = 0,
-    Unclassified = 1,
-    Ground = 2,
-    LowVegetation = 3,
-    MedVegetation = 4,
-    HighVegetation = 5,
-    Building = 6,
-    /**
-     * Low point, typically "low noise".
-     */
-    LowPoint = 7,
-    /**
-     * In previous revisions of LAS this was High point ("high noise"), in more recent
-     * revisions this value is reserved.
-     */
-    ReservedOrHighPoint = 8,
-    Water = 9,
-    Rail = 10,
-    RoadSurface = 11,
-    /**
-     * In previous revisions of LAS this was "Bridge deck", but in more recent
-     * revisions this value is reserved.
-     */
-    ReservedOrBridgeDeck = 12,
-    /**
-     * Wire guard shield.
-     */
-    WireGuard = 13,
-    /**
-     * Wire conductor (phase).
-     */
-    WireConductor = 14,
-    TransmissionTower = 15,
-    /**
-     * Wire-structure connector (e.g. insulator).
-     */
-    WireStructureConnector = 16,
-    /**
-     * Note that {@link WellKnownAsprsPointClassCodes.ReservedOrBridgeDeck} has been used
-     * historically.
-     */
-    BridgeDeck = 17,
-    /**
-     * High point, or "high noise".
-     * Note that {@link WellKnownAsprsPointClassCodes.ReservedOrHighPoint} has been used
-     * historically.
-     */
-    HighNoise = 18,
-    /**
-     * E.g. conveyors, mining equipment, traffic lights.
-     */
-    OverheadStructure = 19,
-    /**
-     * E.g. breakline proximity.
-     */
-    IgnoredGround = 20,
-    Snow = 21,
-    /**
-     * Features excluded due to changes over time between data sources – e.g., water
-     * levels, landslides, permafrost
-     */
-    TemporalExclusion = 22,
-    /**
-     * First user definable class identifier (64).
-     * Values up to and including 63 are reserved
-     */
-    UserDefinableOffset = 64
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * ASPRS well known point class types.
+ * @see {@link http://www.asprs.org/wp-content/uploads/2019/03/LAS_1_4_r14.pdf} (page 30)
+ */
+export declare enum WellKnownAsprsPointClassCodes {
+    /**
+     * Special value for all other classes. Some point in Potree might be in this class
+     *
+     */
+    Default = -1,
+    /**
+     * Created, never classified.
+     */
+    Created = 0,
+    Unclassified = 1,
+    Ground = 2,
+    LowVegetation = 3,
+    MedVegetation = 4,
+    HighVegetation = 5,
+    Building = 6,
+    /**
+     * Low point, typically "low noise".
+     */
+    LowPoint = 7,
+    /**
+     * In previous revisions of LAS this was High point ("high noise"), in more recent
+     * revisions this value is reserved.
+     */
+    ReservedOrHighPoint = 8,
+    Water = 9,
+    Rail = 10,
+    RoadSurface = 11,
+    /**
+     * In previous revisions of LAS this was "Bridge deck", but in more recent
+     * revisions this value is reserved.
+     */
+    ReservedOrBridgeDeck = 12,
+    /**
+     * Wire guard shield.
+     */
+    WireGuard = 13,
+    /**
+     * Wire conductor (phase).
+     */
+    WireConductor = 14,
+    TransmissionTower = 15,
+    /**
+     * Wire-structure connector (e.g. insulator).
+     */
+    WireStructureConnector = 16,
+    /**
+     * Note that {@link WellKnownAsprsPointClassCodes.ReservedOrBridgeDeck} has been used
+     * historically.
+     */
+    BridgeDeck = 17,
+    /**
+     * High point, or "high noise".
+     * Note that {@link WellKnownAsprsPointClassCodes.ReservedOrHighPoint} has been used
+     * historically.
+     */
+    HighNoise = 18,
+    /**
+     * E.g. conveyors, mining equipment, traffic lights.
+     */
+    OverheadStructure = 19,
+    /**
+     * E.g. breakline proximity.
+     */
+    IgnoredGround = 20,
+    Snow = 21,
+    /**
+     * Features excluded due to changes over time between data sources – e.g., water
+     * levels, landslides, permafrost
+     */
+    TemporalExclusion = 22,
+    /**
+     * First user definable class identifier (64).
+     * Values up to and including 63 are reserved
+     */
+    UserDefinableOffset = 64
+}

package/packages/rendering/index.d.ts

@@ -1,14 +1,18 @@
-/**
- * Copyright 2021 Cognite AS
- */
-export { SectorQuads } from './src/rendering/types';
-export { CadMaterialManager } from './src/CadMaterialManager';
-export { createSimpleGeometryMesh } from './src/rendering/createSimpleGeometryMesh';
-export { NodeTransformProvider } from './src/transform/NodeTransformProvider';
-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 } from './src/rendering/materials';
-export { createPrimitives } from './src/rendering/primitives';
+/**
+ * Copyright 2021 Cognite AS
+ */
+export { SectorQuads } from './src/rendering/types';
+export { CadMaterialManager } from './src/CadMaterialManager';
+export { createSimpleGeometryMesh } from './src/rendering/createSimpleGeometryMesh';
+export { NodeTransformProvider } from './src/transform/NodeTransformProvider';
+export { RenderOptions, defaultRenderOptions, SsaoParameters, SsaoSampleQuality, AntiAliasingMode } from './src/rendering/types';
+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 { DefaultRenderPipelineProvider } from './src/render-pipeline-providers/DefaultRenderPipelineProvider';
+export { CadGeometryRenderModePipelineProvider } from './src/render-pipeline-providers/CadGeometryRenderModePipelineProvider';
+export { BasicPipelineExecutor } from './src/pipeline-executors/BasicPipelineExecutor';
+export { RenderPipelineExecutor } from './src/RenderPipelineExecutor';
+export { RenderPipelineProvider } from './src/RenderPipelineProvider';

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

@@ -1,39 +1,39 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import { NodeTransformProvider } from './transform/NodeTransformProvider';
-import { Materials } from './rendering/materials';
-import { RenderMode } from './rendering/RenderMode';
-import { NodeAppearance, NodeAppearanceProvider } from '../../cad-styling';
-import { IndexSet } from '../../utilities';
-export declare class CadMaterialManager {
-    private readonly _events;
-    get clippingPlanes(): THREE.Plane[];
-    set clippingPlanes(clippingPlanes: THREE.Plane[]);
-    private _renderMode;
-    private readonly materialsMap;
-    private _clippingPlanes;
-    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;
-    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;
-    private applyToAllMaterials;
-    private triggerMaterialsChanged;
-}
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { NodeTransformProvider } from './transform/NodeTransformProvider';
+import { Materials } from './rendering/materials';
+import { RenderMode } from './rendering/RenderMode';
+import { NodeAppearance, NodeAppearanceProvider } from '../../cad-styling';
+import { IndexSet } from '../../utilities';
+export declare class CadMaterialManager {
+    private readonly _events;
+    get clippingPlanes(): THREE.Plane[];
+    set clippingPlanes(clippingPlanes: THREE.Plane[]);
+    private _renderMode;
+    private readonly materialsMap;
+    private _clippingPlanes;
+    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;
+    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;
+    private applyToAllMaterials;
+    private triggerMaterialsChanged;
+}

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

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import * as THREE from 'three';
+/**
+ * The RenderPass interface describes some render pass
+ * that executes some job either for visual presentation or
+ * gpu compute task.
+ *
+ * Usually multiple RenderPass' will be combined and managed by
+ * some RenderPipelineProvider that defines the rendering job.
+ */
+export interface RenderPass {
+    render(renderer: THREE.WebGLRenderer, camera: THREE.Camera): void;
+}

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

@@ -0,0 +1,13 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import * as THREE from 'three';
+import { RenderPipelineProvider } from './RenderPipelineProvider';
+/**
+ * The job of the implementor of this interface is to exectute some subset of
+ * a given pipeline from a RenderPipelineProvider.
+ */
+export interface RenderPipelineExecutor {
+    render(renderPipeline: RenderPipelineProvider, camera: THREE.Camera): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,15 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { RenderPass } from './RenderPass';
+/**
+ * Defines a provider that provides a set of renderpasses
+ * in the form of a generator.
+ * Note that though a render pipeline may be terminated early
+ * skipping any passes may yield undefined behaviour for following
+ * render passes given some dependency.
+ */
+export interface RenderPipelineProvider {
+    pipeline(renderer: THREE.WebGLRenderer): Generator<RenderPass>;
+    dispose(): void;
+}

package/packages/rendering/src/pipeline-executors/BasicPipelineExecutor.d.ts

@@ -0,0 +1,22 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import * as THREE from 'three';
+import { RenderPipelineExecutor } from '../RenderPipelineExecutor';
+import { RenderPipelineProvider } from '../RenderPipelineProvider';
+export declare type BasicPipelineExecutorOptions = {
+    autoResizeRenderer: boolean;
+    resolutionThreshold?: number;
+};
+export declare class BasicPipelineExecutor implements RenderPipelineExecutor {
+    private readonly _defaultResolutionThreshold;
+    private readonly _renderer;
+    private readonly _resolutionThreshold;
+    private readonly _resizeObserver;
+    private _shouldResize;
+    constructor(renderer: THREE.WebGLRenderer, options?: BasicPipelineExecutorOptions);
+    render(renderPipeline: RenderPipelineProvider, camera: THREE.PerspectiveCamera): void;
+    private setupResizeListener;
+    private resize;
+    dispose(): void;
+}

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

@@ -0,0 +1,16 @@
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import * as THREE from 'three';
+import { CadMaterialManager } from '../CadMaterialManager';
+import { RenderMode } from '../rendering/RenderMode';
+import { RenderPass } from '../RenderPass';
+export declare class GeometryPass implements RenderPass {
+    private readonly _geometryScene;
+    private readonly _materialManager;
+    private readonly _renderMode;
+    private readonly _overrideRenderLayer;
+    private readonly _renderLayer;
+    constructor(scene: THREE.Object3D, materialManager: CadMaterialManager, renderMode?: RenderMode, overrideLayerMask?: number);
+    render(renderer: THREE.WebGLRenderer, camera: THREE.Camera): void;
+}

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

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