@cognite/reveal 4.34.0 → 4.34.1

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

@@ -1,8 +1,8 @@
 import { IPointCloudTreeGeometryNode } from './IPointCloudTreeGeometryNode';
 import { IPointCloudTreeNodeBase } from '../tree/IPointCloudTreeNodeBase';
+import { Box3, BufferGeometry, Sphere, Vector3 } from 'three';
 import { PointCloudEptGeometry, EptKey } from './PointCloudEptGeometry';
 import { ModelDataProvider } from '../../../../data-providers';
-import type * as THREE from 'three';
 export declare class PointCloudEptGeometryNode implements IPointCloudTreeGeometryNode {
     private readonly _id;
     private readonly _ept;
@@ -27,8 +27,8 @@ export declare class PointCloudEptGeometryNode implements IPointCloudTreeGeometr
     get name(): string;
     get level(): number;
     get spacing(): number;
-    get boundingBox(): THREE.Box3;
-    get boundingSphere(): THREE.Sphere;
+    get boundingBox(): Box3;
+    get boundingSphere(): Sphere;
     get loaded(): boolean;
     get key(): EptKey;
     get failed(): boolean;
@@ -36,18 +36,18 @@ export declare class PointCloudEptGeometryNode implements IPointCloudTreeGeometr
     get children(): IPointCloudTreeNodeBase[];
     get oneTimeDisposeHandlers(): (() => void)[];
     get isLeafNode(): boolean;
-    get geometry(): THREE.BufferGeometry | undefined;
+    get geometry(): 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);
+    constructor(ept: PointCloudEptGeometry, modelDataProvider: ModelDataProvider, b?: 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;
+    getBoundingSphere(): Sphere;
+    getBoundingBox(): Box3;
     baseUrl(): string;
     getNumPoints(): number;
     fileName(): string;
@@ -57,7 +57,7 @@ export declare class PointCloudEptGeometryNode implements IPointCloudTreeGeometr
     load(): Promise<void>;
     loadPoints(): Promise<void>;
     loadHierarchy(): Promise<void>;
-    doneLoading(bufferGeometry: THREE.BufferGeometry, _tightBoundingBox: THREE.Box3, np: number, _mean: THREE.Vector3): void;
+    doneLoading(bufferGeometry: BufferGeometry, _tightBoundingBox: Box3, np: number, _mean: Vector3): void;
     markAsNotLoading(): void;
     toPotreeName(d: number, x: number, y: number, z: number): string;
     dispose(): void;

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

@@ -1,7 +1,4 @@
-/*!
- * 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;
+import { Box3, Sphere, Vector3 } from 'three';
+export declare function toVector3(v: number[], offset?: number): Vector3;
+export declare function toBox3(b: number[]): Box3;
+export declare function sphereFrom(b: Box3): Sphere;

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

@@ -1,7 +1,7 @@
 import { IPointCloudTreeNodeBase } from './IPointCloudTreeNodeBase';
 import { IPointCloudTreeGeometryNode } from '../geometry/IPointCloudTreeGeometryNode';
-import type * as THREE from 'three';
+import { Points } from 'three';
 export interface IPointCloudTreeNode extends IPointCloudTreeNodeBase {
-    sceneNode: THREE.Points;
+    sceneNode: Points;
     geometryNode: IPointCloudTreeGeometryNode;
 }

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

@@ -1,12 +1,12 @@
-import type * as THREE from 'three';
+import { Box3, Sphere } from 'three';
 export interface IPointCloudTreeNodeBase {
     id: number;
     name: string;
     level: number;
     index: number;
     spacing: number;
-    boundingBox: THREE.Box3;
-    boundingSphere: THREE.Sphere;
+    boundingBox: Box3;
+    boundingSphere: Sphere;
     loaded: boolean;
     numPoints: number;
     isTreeNode: boolean;

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

@@ -27,7 +27,7 @@ export interface IPointAttributes {
     byteSize: number;
     size: number;
 }
-export declare const POINT_ATTRIBUTES: {
+type PointShaderAttributes = {
     POSITION_CARTESIAN: IPointAttribute;
     RGBA_PACKED: IPointAttribute;
     COLOR_PACKED: IPointAttribute;
@@ -40,7 +40,8 @@ export declare const POINT_ATTRIBUTES: {
     NORMAL_OCT16: IPointAttribute;
     NORMAL: IPointAttribute;
 };
-export type PointAttributeStringName = keyof typeof POINT_ATTRIBUTES;
+export declare const POINT_ATTRIBUTES: PointShaderAttributes;
+export type PointAttributeStringName = keyof PointShaderAttributes;
 export declare class PointAttributes implements IPointAttributes {
     attributes: IPointAttribute[];
     byteSize: number;
@@ -50,3 +51,4 @@ export declare class PointAttributes implements IPointAttributes {
     hasColors(): boolean;
     hasNormals(): boolean;
 }
+export {};

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

@@ -1,10 +1,13 @@
+import * as Comlink from 'comlink';
 export declare class AutoTerminatingWorker {
     private readonly maxIdle;
     private timeoutId;
     private terminated;
     private _wrappedWorker;
+    private _comlinkProxy;
     constructor(wrappedWorker: Worker, maxIdle: number);
     get worker(): Worker;
+    getComlinkProxy<T>(): Comlink.Remote<T>;
     get isTerminated(): boolean;
     markIdle(): void;
     markInUse(): void;

package/dist/packages/pointclouds/visual-tests/EdlPointCloud.VisualTest.d.ts

@@ -1,10 +1,10 @@
 import { CadMaterialManager, PointCloudMaterialManager, DefaultRenderPipelineProvider } from '../../rendering';
 import { StreamingTestFixtureComponents, StreamingVisualTestFixture } from '../../../visual-tests/test-fixtures/StreamingVisualTestFixture';
 import { SceneHandler } from '../../utilities';
-import * as THREE from 'three';
+import { PerspectiveCamera } from 'three';
 export default class EdlPointCloudVisualTest extends StreamingVisualTestFixture {
     constructor();
-    createCamera(): THREE.PerspectiveCamera;
+    createCamera(): PerspectiveCamera;
     createDefaultRenderPipelineProvider(materialManager: CadMaterialManager, pointCloudMaterialManager: PointCloudMaterialManager, sceneHandler: SceneHandler): DefaultRenderPipelineProvider;
     setup(testFixtureComponents: StreamingTestFixtureComponents): Promise<void>;
 }

package/dist/packages/pointclouds/visual-tests/PointCloudColorStyling.VisualTest.d.ts

@@ -1,9 +1,9 @@
 import { StreamingTestFixtureComponents, StreamingVisualTestFixture } from '../../../visual-tests/test-fixtures/StreamingVisualTestFixture';
 import { PointCloudFactory } from '../src/PointCloudFactory';
-import * as THREE from 'three';
+import { PerspectiveCamera } from 'three';
 export default class PointCloudColorStylingVisualTest extends StreamingVisualTestFixture {
     constructor();
     createPointCloudFactory(): PointCloudFactory;
-    createCamera(): THREE.PerspectiveCamera;
+    createCamera(): PerspectiveCamera;
     setup(testFixtureComponents: StreamingTestFixtureComponents): Promise<void>;
 }

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

@@ -1,23 +1,20 @@
+import { Plane, RawShaderMaterial, Texture } from 'three';
 import { Materials } from './rendering/materials';
 import { RenderMode } from './rendering/RenderMode';
 import { NodeAppearance, ClippingPlanesProvider, NodeAppearanceProvider, NodeAppearanceTextureBuilder, NodeTransformProvider, NodeTransformTextureBuilder } from '../../cad-styling';
 import { IndexSet } from '../../utilities';
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
 export type CadMaterial = {
     materials: Materials;
     nodeAppearanceProvider: NodeAppearanceProvider;
     nodeTransformProvider: NodeTransformProvider;
     nodeAppearanceTextureBuilder: NodeAppearanceTextureBuilder;
     nodeTransformTextureBuilder: NodeTransformTextureBuilder;
-    matCapTexture: THREE.Texture;
+    matCapTexture: Texture;
     clippingPlanesProvider: ClippingPlanesProvider;
 };
 export declare class CadMaterialManager {
-    get clippingPlanes(): THREE.Plane[];
-    set clippingPlanes(clippingPlanes: THREE.Plane[]);
+    get clippingPlanes(): Plane[];
+    set clippingPlanes(clippingPlanes: Plane[]);
     get needsRedraw(): boolean;
     private _renderMode;
     private readonly materialsMap;
@@ -25,12 +22,12 @@ export declare class CadMaterialManager {
     private _needsRedraw;
     addModelMaterials(modelIdentifier: symbol, cadMaterial: CadMaterial): void;
     removeModelMaterials(modelIdentifier: symbol): void;
-    addTexturedMeshMaterial(modelIdentifier: symbol, sectorId: number, texture: THREE.Texture): THREE.RawShaderMaterial;
+    addTexturedMeshMaterial(modelIdentifier: symbol, sectorId: number, texture: Texture): RawShaderMaterial;
     getModelMaterials(modelIdentifier: symbol): Materials;
     getModelNodeAppearanceProvider(modelIdentifier: symbol): NodeAppearanceProvider;
     getModelNodeTransformProvider(modelIdentifier: symbol): NodeTransformProvider;
     getModelDefaultNodeAppearance(modelIdentifier: symbol): NodeAppearance;
-    getModelClippingPlanes(modelIdentifier: symbol): THREE.Plane[];
+    getModelClippingPlanes(modelIdentifier: symbol): Plane[];
     setModelDefaultNodeAppearance(modelIdentifier: symbol, defaultAppearance: NodeAppearance): void;
     getModelBackTreeIndices(modelIdentifier: symbol): IndexSet;
     getModelInFrontTreeIndices(modelIdentifier: symbol): IndexSet;

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

@@ -1,7 +1,4 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import type * as THREE from 'three';
+import { Camera, WebGLRenderer } from 'three';
 /**
  * The RenderPass interface describes some render pass
  * that executes some job either for visual presentation or
@@ -11,5 +8,5 @@ import type * as THREE from 'three';
  * some RenderPipelineProvider that defines the rendering job.
  */
 export interface RenderPass {
-    render(renderer: THREE.WebGLRenderer, camera: THREE.Camera): void;
+    render(renderer: WebGLRenderer, camera: Camera): void;
 }

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

@@ -1,13 +1,10 @@
+import { Camera } from 'three';
 import { RenderPipelineProvider } from './RenderPipelineProvider';
-/*!
- * Copyright 2022 Cognite AS
- */
-import type * as THREE from 'three';
 /**
  * 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;
+    render(renderPipeline: RenderPipelineProvider, camera: Camera): void;
     dispose(): void;
 }

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

@@ -1,12 +1,9 @@
+import { PerspectiveCamera, WebGLRenderer } from 'three';
 import { RenderPipelineExecutor } from '../RenderPipelineExecutor';
 import { RenderPipelineProvider } from '../RenderPipelineProvider';
-/*!
- * Copyright 2022 Cognite AS
- */
-import type * as THREE from 'three';
 export declare class BasicPipelineExecutor implements RenderPipelineExecutor {
     private readonly _renderer;
-    constructor(renderer: THREE.WebGLRenderer);
-    render(renderPipeline: RenderPipelineProvider, camera: THREE.PerspectiveCamera): void;
+    constructor(renderer: WebGLRenderer);
+    render(renderPipeline: RenderPipelineProvider, camera: PerspectiveCamera): void;
     dispose(): void;
 }

package/dist/packages/rendering/src/pipeline-executors/StepPipelineExecutor.d.ts

@@ -1,17 +1,14 @@
+import { Camera, WebGLRenderer } from 'three';
 import { RenderPipelineExecutor } from '../RenderPipelineExecutor';
 import { RenderPipelineProvider } from '../RenderPipelineProvider';
-/*!
- * Copyright 2022 Cognite AS
- */
-import type * as THREE from 'three';
 export declare class StepPipelineExecutor implements RenderPipelineExecutor {
     private readonly _renderer;
     private _numSteps;
     private readonly _gpuTimer;
     set numberOfSteps(steps: number);
     get timings(): number[];
-    constructor(renderer: THREE.WebGLRenderer);
-    render(renderPipeline: RenderPipelineProvider, camera: THREE.Camera): void;
+    constructor(renderer: WebGLRenderer);
+    render(renderPipeline: RenderPipelineProvider, camera: Camera): void;
     calcNumSteps(renderPipeline: RenderPipelineProvider): number;
     dispose(): void;
 }

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

@@ -73,27 +73,27 @@ export declare class PointCloudMaterial extends RawShaderMaterial {
     attributes: {
         position: {
             type: string;
-            value: never[];
+            value: readonly [];
         };
         color: {
             type: string;
-            value: never[];
+            value: readonly [];
         };
         intensity: {
             type: string;
-            value: never[];
+            value: readonly [];
         };
         classification: {
             type: string;
-            value: never[];
+            value: readonly [];
         };
         objectId: {
             type: string;
-            value: never[];
+            value: readonly [];
         };
         indices: {
             type: string;
-            value: never[];
+            value: readonly [];
         };
     };
     constructor(parameters?: Partial<IPointCloudMaterialParameters>);

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

@@ -1,10 +1,7 @@
+import { DataTexture } from 'three';
 import { CompletePointCloudAppearance, StyledPointCloudVolumeCollection } from '../../../pointcloud-styling';
 import { PointCloudObjectIdMaps } from './PointCloudObjectIdMaps';
 import { DataSourceType } from '../../../data-providers';
-/*!
- * Copyright 2022 Cognite AS
- */
-import * as THREE from 'three';
 export declare class PointCloudObjectAppearanceTexture {
     private readonly _objectStyleTexture;
     private _needsReconstruction;
@@ -25,5 +22,5 @@ export declare class PointCloudObjectAppearanceTexture {
     removeAllStyledObjectSets(): void;
     set defaultAppearance(appearance: CompletePointCloudAppearance);
     get defaultAppearance(): CompletePointCloudAppearance;
-    get objectStyleTexture(): THREE.DataTexture;
+    get objectStyleTexture(): DataTexture;
 }

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

@@ -1,16 +1,13 @@
+import { Camera, Object3D, WebGLRenderer } from 'three';
 import { CadMaterialManager } from '../CadMaterialManager';
 import { RenderMode } from '../rendering/RenderMode';
 import { RenderPass } from '../RenderPass';
-/*!
- * Copyright 2022 Cognite AS
- */
-import type * as THREE from 'three';
 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;
+    constructor(scene: Object3D, materialManager: CadMaterialManager, renderMode?: RenderMode, overrideLayerMask?: number);
+    render(renderer: WebGLRenderer, camera: Camera): void;
 }

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

@@ -1,11 +1,11 @@
+import { Camera, Object3D, WebGLRenderer } from 'three';
 import { RenderPass } from '../RenderPass';
 import { PointCloudPassParameters } from './types';
 import { PointCloudMaterialManager } from '../PointCloudMaterialManager';
-import type * as THREE from 'three';
 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;
+    constructor(scene: Object3D, pointCloudMaterialManager: PointCloudMaterialManager, materialParameters?: PointCloudPassParameters);
+    render(renderer: WebGLRenderer, camera: Camera): void;
 }

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

@@ -1,10 +1,7 @@
+import { Camera, Scene, WebGLRenderer } from 'three';
 import { PostProcessingObjectsVisibilityParameters } from './types';
 import { RenderPass } from '../RenderPass';
 import { PostProcessingPipelineOptions } from '../render-pipeline-providers/types';
-/*!
- * Copyright 2022 Cognite AS
- */
-import type * as THREE from 'three';
 /**
  * Single pass that applies post processing effects and
  * combines results from geometry passes.
@@ -18,7 +15,7 @@ export declare class PostProcessingPass implements RenderPass {
     private readonly _postProcessingOptions;
     private readonly setBlendFactorByBackVisibility;
     updateRenderObjectsVisibility(visibilityParameters: PostProcessingObjectsVisibilityParameters): void;
-    constructor(scene: THREE.Scene, postProcessingPipelineOptions: PostProcessingPipelineOptions);
-    render(renderer: THREE.WebGLRenderer, camera: THREE.Camera): void;
+    constructor(scene: Scene, postProcessingPipelineOptions: PostProcessingPipelineOptions);
+    render(renderer: WebGLRenderer, camera: Camera): void;
     dispose(): void;
 }

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

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

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

@@ -1,11 +1,11 @@
 import { PointShape } from '../pointcloud-rendering';
+import { Blending, BlendingDstFactor, BlendingSrcFactor, DepthTexture, IUniform, Texture } from 'three';
 import { EdlOptions } from '../rendering/types';
-import * as THREE from 'three';
 export type BlendOptions = {
-    blendDestination: THREE.BlendingDstFactor;
-    blendSource: THREE.BlendingDstFactor | THREE.BlendingSrcFactor;
-    blendDestinationAlpha?: THREE.BlendingDstFactor;
-    blendSourceAlpha?: THREE.BlendingDstFactor | THREE.BlendingSrcFactor;
+    blendDestination: BlendingDstFactor;
+    blendSource: BlendingDstFactor | BlendingSrcFactor;
+    blendDestinationAlpha?: BlendingDstFactor;
+    blendSourceAlpha?: BlendingDstFactor | BlendingSrcFactor;
 };
 export declare enum BlitEffect {
     None = 0,
@@ -13,34 +13,34 @@ export declare enum BlitEffect {
     Fxaa = 2
 }
 export type BlitOptions = {
-    texture: THREE.Texture;
+    texture: Texture;
     effect?: BlitEffect;
-    depthTexture: THREE.DepthTexture | null;
-    ssaoTexture?: THREE.Texture;
+    depthTexture: DepthTexture | null;
+    ssaoTexture?: Texture;
     blendOptions?: BlendOptions;
     overrideAlpha?: number;
     edges?: boolean;
     outline?: boolean;
 };
 export type DepthBlendBlitOptions = {
-    texture: THREE.Texture;
-    depthTexture: THREE.DepthTexture | null;
-    blendTexture: THREE.Texture;
-    blendDepthTexture: THREE.Texture | null;
+    texture: Texture;
+    depthTexture: DepthTexture | null;
+    blendTexture: Texture;
+    blendDepthTexture: Texture | null;
     blendFactor: number;
     overrideAlpha?: number;
     outline?: boolean;
 };
 export type PointCloudPostProcessingOptions = {
-    logDepthTexture: THREE.Texture;
-    texture: THREE.Texture;
-    depthTexture: THREE.DepthTexture | null;
+    logDepthTexture: Texture;
+    texture: Texture;
+    depthTexture: DepthTexture | null;
     pointBlending: boolean;
     edlOptions: EdlOptions;
 };
 export declare const transparentBlendOptions: BlendOptions;
 export type ThreeUniforms = {
-    [uniform: string]: THREE.IUniform<any>;
+    [uniform: string]: IUniform<any>;
 };
 export type PointCloudMaterialParameters = {
     weighted?: boolean;
@@ -48,9 +48,9 @@ export type PointCloudMaterialParameters = {
     useEDL?: boolean;
     hqDepthPass?: boolean;
     depthWrite?: boolean;
-    blending?: THREE.Blending;
-    blendSrc?: THREE.BlendingDstFactor | THREE.BlendingSrcFactor;
-    blendDst?: THREE.BlendingDstFactor;
+    blending?: Blending;
+    blendSrc?: BlendingDstFactor | BlendingSrcFactor;
+    blendDst?: BlendingDstFactor;
     colorWrite?: boolean;
 };
 export type PointCloudPassParameters = {

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

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

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

@@ -1,10 +1,10 @@
 import { SceneHandler } from '../../../utilities';
+import { WebGLRenderer } from 'three';
 import { CadMaterialManager } from '../CadMaterialManager';
 import { RenderOptions } from '../rendering/types';
 import { RenderPass } from '../RenderPass';
 import { RenderPipelineProvider } from '../RenderPipelineProvider';
 import { CadGeometryRenderTargets } from './types';
-import * as THREE from 'three';
 export declare class CadGeometryRenderPipelineProvider implements RenderPipelineProvider {
     private readonly _cadGeometryRenderTargets;
     private readonly _cadGeometryRenderPasses;
@@ -13,7 +13,7 @@ export declare class CadGeometryRenderPipelineProvider implements RenderPipeline
     private _rendererStateHelper;
     get cadGeometryRenderTargets(): CadGeometryRenderTargets;
     constructor(sceneHandler: SceneHandler, materialManager: CadMaterialManager, renderOptions: RenderOptions);
-    pipeline(renderer: THREE.WebGLRenderer): Generator<RenderPass>;
+    pipeline(renderer: WebGLRenderer): Generator<RenderPass>;
     dispose(): void;
     private pipelineSetup;
     private initializeRenderTargets;

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

@@ -1,3 +1,4 @@
+import { WebGLRenderTarget, WebGLRenderer } from 'three';
 import { CadMaterialManager } from '../CadMaterialManager';
 import { RenderPass } from '../RenderPass';
 import { RenderPipelineProvider } from '../RenderPipelineProvider';
@@ -5,10 +6,6 @@ import { RenderOptions } from '../rendering/types';
 import { SceneHandler } from '../../../utilities';
 import { PointCloudMaterialManager } from '../PointCloudMaterialManager';
 import { SettableRenderTarget } from '../rendering/SettableRenderTarget';
-/*!
- * Copyright 2022 Cognite AS
- */
-import * as THREE from 'three';
 export declare class DefaultRenderPipelineProvider implements RenderPipelineProvider, SettableRenderTarget {
     private readonly _viewerScene;
     private readonly _renderTargetData;
@@ -27,11 +24,11 @@ export declare class DefaultRenderPipelineProvider implements RenderPipelineProv
     private _rendererStateHelper;
     set renderOptions(renderOptions: RenderOptions);
     constructor(materialManager: CadMaterialManager, pointCloudMaterialManager: PointCloudMaterialManager, sceneHandler: SceneHandler, renderOptions: RenderOptions, outputRenderTarget?: {
-        target: THREE.WebGLRenderTarget;
+        target: WebGLRenderTarget;
         autoSize?: boolean;
     });
-    setOutputRenderTarget(target: THREE.WebGLRenderTarget | null, autoSizeRenderTarget?: boolean): void;
-    pipeline(renderer: THREE.WebGLRenderer): Generator<RenderPass>;
+    setOutputRenderTarget(target: WebGLRenderTarget | null, autoSizeRenderTarget?: boolean): void;
+    pipeline(renderer: WebGLRenderer): Generator<RenderPass>;
     dispose(): void;
     private pipelineSetup;
     private updateRenderTargetSizes;

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

@@ -1,13 +1,10 @@
+import { WebGLRenderer } from 'three';
 import { RenderPass } from '../RenderPass';
 import { RenderPipelineProvider } from '../RenderPipelineProvider';
 import { SceneHandler } from '../../../utilities';
 import { PointCloudRenderTargets } from './types';
 import { PointCloudParameters } from '../rendering/types';
 import { PointCloudMaterialManager } from '../PointCloudMaterialManager';
-/*!
- * Copyright 2022 Cognite AS
- */
-import * as THREE from 'three';
 export declare class PointCloudRenderPipelineProvider implements RenderPipelineProvider {
     private readonly _renderTargetData;
     private readonly _renderParameters;
@@ -19,7 +16,7 @@ export declare class PointCloudRenderPipelineProvider implements RenderPipelineP
     private static readonly AttributePassParameters;
     constructor(sceneHandler: SceneHandler, pointCloudMaterialManager: PointCloudMaterialManager, renderParameters: PointCloudParameters);
     get pointCloudRenderTargets(): PointCloudRenderTargets;
-    pipeline(renderer: THREE.WebGLRenderer): Generator<RenderPass>;
+    pipeline(renderer: WebGLRenderer): Generator<RenderPass>;
     dispose(): void;
     private updateRenderTargetSizes;
 }

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

@@ -1,25 +1,22 @@
+import { Texture, Vector2, WebGLRenderTarget } from 'three';
 import { EdlOptions } from '../rendering/types';
-/*!
- * Copyright 2022 Cognite AS
- */
-import type * as THREE from 'three';
 export type RenderTargetData = {
-    currentRenderSize: THREE.Vector2;
-    ssaoRenderTarget: THREE.WebGLRenderTarget;
-    postProcessingRenderTarget: THREE.WebGLRenderTarget;
+    currentRenderSize: Vector2;
+    ssaoRenderTarget: WebGLRenderTarget;
+    postProcessingRenderTarget: WebGLRenderTarget;
 };
 export type CadGeometryRenderTargets = {
-    currentRenderSize: THREE.Vector2;
-    back: THREE.WebGLRenderTarget;
-    ghost: THREE.WebGLRenderTarget;
-    inFront: THREE.WebGLRenderTarget;
+    currentRenderSize: Vector2;
+    back: WebGLRenderTarget;
+    ghost: WebGLRenderTarget;
+    inFront: WebGLRenderTarget;
 };
 export type PointCloudRenderTargets = {
-    pointCloudLogDepth: THREE.WebGLRenderTarget;
-    pointCloud: THREE.WebGLRenderTarget;
+    pointCloudLogDepth: WebGLRenderTarget;
+    pointCloud: WebGLRenderTarget;
 };
 export type PostProcessingPipelineOptions = CadGeometryRenderTargets & PointCloudRenderTargets & {
-    ssaoTexture: THREE.Texture;
+    ssaoTexture: Texture;
     edges: boolean;
     pointBlending?: boolean;
     edlOptions: EdlOptions;