@cognite/reveal 3.1.0 → 4.0.0-dev.20221025

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

@@ -1,11 +1,22 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import * as THREE from 'three';
-import { RenderPipelineExecutor } from '../RenderPipelineExecutor';
-import { RenderPipelineProvider } from '../RenderPipelineProvider';
-export declare class BasicPipelineExecutor implements RenderPipelineExecutor {
-    private readonly _renderer;
-    constructor(renderer: THREE.WebGLRenderer);
-    render(renderPipeline: RenderPipelineProvider, camera: THREE.Camera): void;
-}
+/*!
+ * 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/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/rendering/src/pointcloud-rendering/constants.d.ts

@@ -0,0 +1,17 @@
+/*!
+ * 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;
+export declare const DEFAULT_PICK_WINDOW_SIZE = 15;
+export declare const DEFAULT_POINT_BUDGET = 3000000;
+export declare const MAX_LOADS_TO_GPU = 2;
+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 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/{pointclouds/src/potree-three-loader/rendering → rendering/src/pointcloud-rendering}/gradients/SpectralGradient.d.ts

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

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,10 +1,18 @@
-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;
-}
+/*!
+ * 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 PointClassification {
+    [value: string]: Vector4;
+    DEFAULT: Vector4;
+}
+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/GeometryPass.d.ts

@@ -1,16 +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;
-}
+/*!
+ * 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,11 @@
+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 _pointCloudMaterialManager;
+    private readonly _passMaterialParameters;
+    constructor(scene: THREE.Object3D, pointCloudMaterialManager: PointCloudMaterialManager, materialParameters?: PointCloudPassParameters);
+    render(renderer: THREE.WebGLRenderer, camera: THREE.Camera): void;
+}

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

@@ -1,24 +1,22 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import * as THREE from 'three';
-import { RenderPass } from '../RenderPass';
-import { PostProcessingPipelineOptions } from '../render-pipeline-providers/types';
-/**
- * Single pass that applies post processing effects and
- * combines results from geometry passes.
- * This is done by intentionally layering full screen-space
- * triangles in a specific render order.
- */
-export declare class PostProcessingPass implements RenderPass {
-    private readonly _scene;
-    private readonly _postProcessingObjects;
-    updateRenderObjectsVisability(hasStyling: {
-        back: boolean;
-        inFront: boolean;
-        ghost: boolean;
-    }): void;
-    constructor(scene: THREE.Scene, postProcessingPipelineOptions: PostProcessingPipelineOptions);
-    render(renderer: THREE.WebGLRenderer, camera: THREE.Camera): void;
-    dispose(): void;
-}
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import * as THREE from 'three';
+import { PostProcessingObjectsVisibilityParameters } from './types';
+import { RenderPass } from '../RenderPass';
+import { PostProcessingPipelineOptions } from '../render-pipeline-providers/types';
+/**
+ * Single pass that applies post processing effects and
+ * combines results from geometry passes.
+ * This is done by intentionally layering full screen-space
+ * triangles in a specific render order.
+ */
+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;
+    dispose(): void;
+}

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

@@ -1,14 +1,14 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import * as THREE from 'three';
-import { SsaoParameters } from '../rendering/types';
-import { RenderPass } from '../RenderPass';
-export declare class SSAOPass implements RenderPass {
-    private readonly _fullScreenTriangle;
-    private readonly _ssaoShaderMaterial;
-    set ssaoParameters(ssaoParameters: SsaoParameters);
-    constructor(depthTexture: THREE.Texture, ssaoParameters: SsaoParameters);
-    render(renderer: THREE.WebGLRenderer, camera: THREE.Camera): void;
-    private createKernel;
-}
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import * as THREE from 'three';
+import { SsaoParameters } from '../rendering/types';
+import { RenderPass } from '../RenderPass';
+export declare class SSAOPass implements RenderPass {
+    private readonly _fullScreenTriangle;
+    private readonly _ssaoShaderMaterial;
+    set ssaoParameters(ssaoParameters: SsaoParameters);
+    constructor(depthTexture: THREE.Texture, ssaoParameters: SsaoParameters);
+    render(renderer: THREE.WebGLRenderer, camera: THREE.Camera): void;
+    private createKernel;
+}

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

@@ -1,31 +1,68 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import * as THREE from 'three';
-export declare type BlendOptions = {
-    blendDestination: THREE.BlendingDstFactor;
-    blendSource: THREE.BlendingDstFactor | THREE.BlendingSrcFactor;
-    blendDestinationAlpha?: THREE.BlendingDstFactor;
-    blendSourceAlpha?: THREE.BlendingDstFactor | THREE.BlendingSrcFactor;
-};
-export declare enum BlitEffect {
-    None = 0,
-    GaussianBlur = 1,
-    Fxaa = 2
-}
-export declare type BlitOptions = {
-    texture: THREE.Texture;
-    effect?: BlitEffect;
-    depthTexture?: THREE.DepthTexture;
-    ssaoTexture?: THREE.Texture;
-    blendOptions?: BlendOptions;
-    overrideAlpha?: number;
-    writeColor?: boolean;
-    edges?: boolean;
-    outline?: boolean;
-};
-export declare const transparentBlendOptions: BlendOptions;
-export declare const alphaMaskBlendOptions: BlendOptions;
-export declare type ThreeUniforms = {
-    [uniform: string]: THREE.IUniform<any>;
-};
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { PointShape } from '../pointcloud-rendering';
+import * as THREE from 'three';
+export declare type BlendOptions = {
+    blendDestination: THREE.BlendingDstFactor;
+    blendSource: THREE.BlendingDstFactor | THREE.BlendingSrcFactor;
+    blendDestinationAlpha?: THREE.BlendingDstFactor;
+    blendSourceAlpha?: THREE.BlendingDstFactor | THREE.BlendingSrcFactor;
+};
+export declare enum BlitEffect {
+    None = 0,
+    GaussianBlur = 1,
+    Fxaa = 2
+}
+export declare type BlitOptions = {
+    texture: THREE.Texture;
+    effect?: BlitEffect;
+    depthTexture?: THREE.DepthTexture;
+    ssaoTexture?: THREE.Texture;
+    blendOptions?: BlendOptions;
+    overrideAlpha?: number;
+    edges?: boolean;
+    outline?: boolean;
+};
+export declare type DepthBlendBlitOptions = {
+    texture: THREE.Texture;
+    depthTexture: THREE.DepthTexture;
+    blendTexture: THREE.Texture;
+    blendDepthTexture: THREE.Texture;
+    blendFactor: number;
+    overrideAlpha?: number;
+    outline?: boolean;
+};
+export declare type PointCloudPostProcessingOptions = {
+    texture: THREE.Texture;
+    depthTexture: THREE.DepthTexture;
+    pointBlending: boolean;
+};
+export declare const transparentBlendOptions: BlendOptions;
+export declare type ThreeUniforms = {
+    [uniform: string]: THREE.IUniform<any>;
+};
+export declare type PointCloudMaterialParameters = {
+    weighted?: boolean;
+    shape?: PointShape;
+    hqDepthPass?: boolean;
+    depthWrite?: boolean;
+    blending?: THREE.Blending;
+    blendSrc?: THREE.BlendingDstFactor | THREE.BlendingSrcFactor;
+    blendDst?: THREE.BlendingDstFactor;
+    colorWrite?: boolean;
+};
+export declare type PointCloudPassParameters = {
+    material?: PointCloudMaterialParameters;
+    renderer?: {
+        autoClearDepth?: boolean;
+    };
+};
+export declare type PostProcessingObjectsVisibilityParameters = {
+    cad: {
+        back: boolean;
+        ghost: boolean;
+        inFront: boolean;
+    };
+    pointCloud: boolean;
+};

package/packages/rendering/src/render-pipeline-providers/CadGeometryRenderModePipelineProvider.d.ts

@@ -1,23 +1,23 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import * as THREE from 'three';
-import { CadMaterialManager } from '../CadMaterialManager';
-import { RenderPass } from '../RenderPass';
-import { RenderPipelineProvider } from '../RenderPipelineProvider';
-import { RenderMode } from '../rendering/RenderMode';
-import { SceneHandler } from '../../../utilities';
-export declare class CadGeometryRenderModePipelineProvider implements RenderPipelineProvider {
-    private readonly _materialManager;
-    private readonly _cadModels;
-    private readonly _renderTargetData;
-    private readonly _geometryPass;
-    private _outputRenderTarget;
-    private _autoSizeRenderTarget;
-    readonly scene: THREE.Scene;
-    constructor(renderMode: RenderMode, materialManager: CadMaterialManager, sceneHandler: SceneHandler);
-    setOutputRenderTarget(target: THREE.WebGLRenderTarget | null, autoSizeRenderTarget?: boolean): void;
-    pipeline(renderer: THREE.WebGLRenderer): Generator<RenderPass>;
-    dispose(): void;
-    private updateRenderTargetSizes;
-}
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import * as THREE from 'three';
+import { CadMaterialManager } from '../CadMaterialManager';
+import { RenderPass } from '../RenderPass';
+import { RenderPipelineProvider } from '../RenderPipelineProvider';
+import { RenderMode } from '../rendering/RenderMode';
+import { SceneHandler } from '../../../utilities';
+export declare class CadGeometryRenderModePipelineProvider implements RenderPipelineProvider {
+    private readonly _materialManager;
+    private readonly _cadModels;
+    private readonly _renderTargetData;
+    private readonly _geometryPass;
+    private _outputRenderTarget;
+    private _autoSizeRenderTarget;
+    readonly scene: THREE.Scene;
+    constructor(renderMode: RenderMode, materialManager: CadMaterialManager, sceneHandler: SceneHandler);
+    setOutputRenderTarget(target: THREE.WebGLRenderTarget | null, autoSizeRenderTarget?: boolean): void;
+    pipeline(renderer: THREE.WebGLRenderer): Generator<RenderPass>;
+    dispose(): void;
+    private updateRenderTargetSizes;
+}

package/packages/rendering/src/render-pipeline-providers/CadGeometryRenderPipelineProvider.d.ts

@@ -1,25 +1,25 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import { SceneHandler } from '../../../utilities';
-import * as THREE from 'three';
-import { CadMaterialManager } from '../CadMaterialManager';
-import { RenderOptions } from '../rendering/types';
-import { RenderPass } from '../RenderPass';
-import { RenderPipelineProvider } from '../RenderPipelineProvider';
-import { CadGeometryRenderTargets } from './types';
-export declare class CadGeometryRenderPipelineProvider implements RenderPipelineProvider {
-    private readonly _cadGeometryRenderTargets;
-    private readonly _cadGeometryRenderPasses;
-    private readonly _cadModels;
-    private readonly _materialManager;
-    private _rendererStateHelper;
-    get cadGeometryRenderTargets(): CadGeometryRenderTargets;
-    constructor(sceneHandler: SceneHandler, materialManager: CadMaterialManager, renderOptions: RenderOptions);
-    pipeline(renderer: THREE.WebGLRenderer): Generator<RenderPass>;
-    dispose(): void;
-    private pipelineSetup;
-    private initializeRenderTargets;
-    private initializeRenderPasses;
-    private updateRenderTargetSizes;
-}
+/*!
+ * Copyright 2022 Cognite AS
+ */
+import { SceneHandler } from '../../../utilities';
+import * as THREE from 'three';
+import { CadMaterialManager } from '../CadMaterialManager';
+import { RenderOptions } from '../rendering/types';
+import { RenderPass } from '../RenderPass';
+import { RenderPipelineProvider } from '../RenderPipelineProvider';
+import { CadGeometryRenderTargets } from './types';
+export declare class CadGeometryRenderPipelineProvider implements RenderPipelineProvider {
+    private readonly _cadGeometryRenderTargets;
+    private readonly _cadGeometryRenderPasses;
+    private readonly _cadModels;
+    private readonly _materialManager;
+    private _rendererStateHelper;
+    get cadGeometryRenderTargets(): CadGeometryRenderTargets;
+    constructor(sceneHandler: SceneHandler, materialManager: CadMaterialManager, renderOptions: RenderOptions);
+    pipeline(renderer: THREE.WebGLRenderer): Generator<RenderPass>;
+    dispose(): void;
+    private pipelineSetup;
+    private initializeRenderTargets;
+    private initializeRenderPasses;
+    private updateRenderTargetSizes;
+}