@cognite/reveal 4.33.0 → 4.34.1

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

@@ -1,23 +1,20 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import * as THREE from 'three';
-import type { Materials } from './rendering/materials';
+import { Plane, RawShaderMaterial, Texture } from 'three';
+import { Materials } from './rendering/materials';
 import { RenderMode } from './rendering/RenderMode';
-import type { NodeAppearance } from '../../cad-styling';
-import { NodeAppearanceProvider, NodeAppearanceTextureBuilder, NodeTransformProvider, NodeTransformTextureBuilder } from '../../cad-styling';
-import type { IndexSet } from '../../utilities';
+import { NodeAppearance, ClippingPlanesProvider, NodeAppearanceProvider, NodeAppearanceTextureBuilder, NodeTransformProvider, NodeTransformTextureBuilder } from '../../cad-styling';
+import { IndexSet } from '../../utilities';
 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,13 +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[];
-    setModelClippingPlanes(modelIdentifier: symbol, clippingPlanes: THREE.Plane[]): void;
+    getModelClippingPlanes(modelIdentifier: symbol): Plane[];
     setModelDefaultNodeAppearance(modelIdentifier: symbol, defaultAppearance: NodeAppearance): void;
     getModelBackTreeIndices(modelIdentifier: symbol): IndexSet;
     getModelInFrontTreeIndices(modelIdentifier: symbol): IndexSet;

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

@@ -1,10 +1,7 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import type { PointCloudObjectIdMaps } from './pointcloud-rendering/PointCloudObjectIdMaps';
+import { PointCloudObjectIdMaps } from './pointcloud-rendering/PointCloudObjectIdMaps';
 import { PointCloudMaterial } from './pointcloud-rendering';
-import type { PointCloudMaterialParameters } from './render-passes/types';
-import type { Plane } from 'three';
+import { PointCloudMaterialParameters } from './render-passes/types';
+import { Plane } from 'three';
 export declare class PointCloudMaterialManager {
     private readonly _modelsMaterialsMap;
     addModelMaterial(modelIdentifier: symbol, objectIdMaps: PointCloudObjectIdMaps): void;

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

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

@@ -1,8 +1,5 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import type { WebGLRenderer } from 'three';
-import type { RenderPass } from './RenderPass';
+import { WebGLRenderer } from 'three';
+import { RenderPass } from './RenderPass';
 /**
  * Defines a provider that provides a set of renderpasses
  * in the form of a generator.

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

@@ -1,8 +1,5 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import type { WebGLRenderer, PerspectiveCamera } from 'three';
-import type { CameraManager } from '../../camera-manager';
+import { WebGLRenderer, PerspectiveCamera } from 'three';
+import { CameraManager } from '../../camera-manager';
 export type ResizeHandlerOptions = {
     renderResolutionThreshold?: number;
 };

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

@@ -1,12 +1,9 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import type * as THREE from 'three';
-import type { RenderPipelineExecutor } from '../RenderPipelineExecutor';
-import type { RenderPipelineProvider } from '../RenderPipelineProvider';
+import { PerspectiveCamera, WebGLRenderer } 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.PerspectiveCamera): void;
+    constructor(renderer: WebGLRenderer);
+    render(renderPipeline: RenderPipelineProvider, camera: PerspectiveCamera): void;
     dispose(): void;
 }

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

@@ -0,0 +1,14 @@
+import { Camera, WebGLRenderer } from 'three';
+import { RenderPipelineExecutor } from '../RenderPipelineExecutor';
+import { RenderPipelineProvider } from '../RenderPipelineProvider';
+export declare class StepPipelineExecutor implements RenderPipelineExecutor {
+    private readonly _renderer;
+    private _numSteps;
+    private readonly _gpuTimer;
+    set numberOfSteps(steps: number);
+    get timings(): number[];
+    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

@@ -1,12 +1,8 @@
-/*!
- * Adapted from pnext/three-loader (https://github.com/pnext/three-loader)
- */
-import type { Camera, DataTexture, WebGLRenderer } from 'three';
-import { RawShaderMaterial, Texture } from 'three';
+import { Camera, DataTexture, WebGLRenderer, RawShaderMaterial, Texture } from 'three';
 import { PointColorType, PointShape, PointSizeType } from './enums';
-import type { PointClassification, IUniform, OctreeMaterialParams } from './types';
+import { PointClassification, IUniform, OctreeMaterialParams } from './types';
 import { PointCloudObjectAppearanceTexture } from './PointCloudObjectAppearanceTexture';
-import type { PointCloudObjectIdMaps } from './PointCloudObjectIdMaps';
+import { PointCloudObjectIdMaps } from './PointCloudObjectIdMaps';
 export interface IPointCloudMaterialParameters {
     size: number;
     minSize: number;
@@ -77,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 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import * as THREE from 'three';
-import type { PointCloudAnnotationVolumeCollection, CompletePointCloudAppearance, StyledPointCloudVolumeCollection } from '../../../pointcloud-styling';
-import type { PointCloudObjectIdMaps } from './PointCloudObjectIdMaps';
-import type { DataSourceType } from '../../../data-providers';
+import { DataTexture } from 'three';
+import { CompletePointCloudAppearance, StyledPointCloudVolumeCollection } from '../../../pointcloud-styling';
+import { PointCloudObjectIdMaps } from './PointCloudObjectIdMaps';
+import { DataSourceType } from '../../../data-providers';
 export declare class PointCloudObjectAppearanceTexture {
     private readonly _objectStyleTexture;
     private _needsReconstruction;
@@ -21,9 +18,9 @@ export declare class PointCloudObjectAppearanceTexture {
     private resetTexture;
     onBeforeRender(): void;
     assignStyledObjectSet(styledCollection: StyledPointCloudVolumeCollection<DataSourceType>): void;
-    removeStyledObjectSet(collection: PointCloudAnnotationVolumeCollection): void;
+    removeStyledObjectSet(collection: StyledPointCloudVolumeCollection<DataSourceType>['volumeCollection']): void;
     removeAllStyledObjectSets(): void;
     set defaultAppearance(appearance: CompletePointCloudAppearance);
     get defaultAppearance(): CompletePointCloudAppearance;
-    get objectStyleTexture(): THREE.DataTexture;
+    get objectStyleTexture(): DataTexture;
 }

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

@@ -1,7 +1,4 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import type { DMInstanceKey, DMInstanceRef } from '../../../utilities';
+import { DMInstanceKey, DMInstanceRef } from '../../../utilities';
 export type PointCloudObjectIdMaps = {
     annotationToObjectIds: Map<number | DMInstanceKey, number>;
     objectToAnnotationIds: Map<number, number | DMInstanceRef>;

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

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

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

@@ -1,6 +1,3 @@
-/*!
- * Adapted from pnext/three-loader (https://github.com/pnext/three-loader)
- */
 import { Color } from 'three';
 export declare const DEFAULT_MAX_POINT_SIZE = 10;
 export declare const DEFAULT_MIN_NODE_PIXEL_SIZE = 50;

package/dist/packages/rendering/src/pointcloud-rendering/gradients/SpectralGradient.d.ts

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

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

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

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

@@ -1,8 +1,4 @@
-/*!
- * Adapted from pnext/three-loader (https://github.com/pnext/three-loader)
- */
-import type { Color, IUniform as IThreeUniform, Vector4 } from 'three';
-import { type Box3, type Vector3 } from 'three';
+import { Color, IUniform as IThreeUniform, Vector4, Box3, Vector3 } from 'three';
 export type IGradient = [number, Color][];
 export interface PointClassification {
     [value: string]: Vector4;

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

@@ -1,16 +1,13 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import type * as THREE from 'three';
-import type { CadMaterialManager } from '../CadMaterialManager';
+import { Camera, Object3D, WebGLRenderer } from 'three';
+import { CadMaterialManager } from '../CadMaterialManager';
 import { RenderMode } from '../rendering/RenderMode';
-import type { RenderPass } from '../RenderPass';
+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;
+    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 type * as THREE from 'three';
-import type { RenderPass } from '../RenderPass';
-import type { PointCloudPassParameters } from './types';
-import type { PointCloudMaterialManager } from '../PointCloudMaterialManager';
+import { Camera, Object3D, WebGLRenderer } 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;
+    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 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import type * as THREE from 'three';
-import type { PostProcessingObjectsVisibilityParameters } from './types';
-import type { RenderPass } from '../RenderPass';
-import type { PostProcessingPipelineOptions } from '../render-pipeline-providers/types';
+import { Camera, Scene, WebGLRenderer } 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.
@@ -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 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import * as THREE from 'three';
-import type { SsaoParameters } from '../rendering/types';
-import type { RenderPass } from '../RenderPass';
+import { Camera, Texture, WebGLRenderer } 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 | 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,14 +1,11 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import type { PointShape } from '../pointcloud-rendering';
-import * as THREE from 'three';
-import type { EdlOptions } from '../rendering/types';
+import { PointShape } from '../pointcloud-rendering';
+import { Blending, BlendingDstFactor, BlendingSrcFactor, DepthTexture, IUniform, Texture } from 'three';
+import { EdlOptions } from '../rendering/types';
 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,
@@ -16,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;
@@ -51,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 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import * as THREE from 'three';
-import type { CadMaterialManager } from '../CadMaterialManager';
-import type { RenderPass } from '../RenderPass';
-import type { RenderPipelineProvider } from '../RenderPipelineProvider';
-import type { RenderMode } from '../rendering/RenderMode';
-import type { SceneHandler } from '../../../utilities';
-import type { SettableRenderTarget } from '../rendering/SettableRenderTarget';
+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';
 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,13 +1,10 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import type { SceneHandler } from '../../../utilities';
-import * as THREE from 'three';
-import type { CadMaterialManager } from '../CadMaterialManager';
-import type { RenderOptions } from '../rendering/types';
-import type { RenderPass } from '../RenderPass';
-import type { RenderPipelineProvider } from '../RenderPipelineProvider';
-import type { CadGeometryRenderTargets } from './types';
+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';
 export declare class CadGeometryRenderPipelineProvider implements RenderPipelineProvider {
     private readonly _cadGeometryRenderTargets;
     private readonly _cadGeometryRenderPasses;
@@ -16,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,14 +1,11 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import * as THREE from 'three';
-import type { CadMaterialManager } from '../CadMaterialManager';
-import type { RenderPass } from '../RenderPass';
-import type { RenderPipelineProvider } from '../RenderPipelineProvider';
-import type { RenderOptions } from '../rendering/types';
-import type { SceneHandler } from '../../../utilities';
-import type { PointCloudMaterialManager } from '../PointCloudMaterialManager';
-import type { SettableRenderTarget } from '../rendering/SettableRenderTarget';
+import { WebGLRenderTarget, WebGLRenderer } from 'three';
+import { CadMaterialManager } from '../CadMaterialManager';
+import { RenderPass } from '../RenderPass';
+import { RenderPipelineProvider } from '../RenderPipelineProvider';
+import { RenderOptions } from '../rendering/types';
+import { SceneHandler } from '../../../utilities';
+import { PointCloudMaterialManager } from '../PointCloudMaterialManager';
+import { SettableRenderTarget } from '../rendering/SettableRenderTarget';
 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 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import * as THREE from 'three';
-import type { RenderPass } from '../RenderPass';
-import type { RenderPipelineProvider } from '../RenderPipelineProvider';
-import type { SceneHandler } from '../../../utilities';
-import type { PointCloudRenderTargets } from './types';
-import type { PointCloudParameters } from '../rendering/types';
-import type { PointCloudMaterialManager } from '../PointCloudMaterialManager';
+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';
 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/pointCloudParameterUtils.d.ts

@@ -1,5 +1,2 @@
-/*!
- * Copyright 2022 Cognite AS
- */
-import type { EdlOptions } from '../rendering/types';
+import { EdlOptions } from '../rendering/types';
 export declare function shouldApplyEdl(edlOptions: EdlOptions): boolean;