@types/three 0.169.0 → 0.171.0

three/src/renderers/common/RenderObject.d.ts

@@ -44,8 +44,8 @@ export default class RenderObject {
         firstInstance: number;
     } | null;
     bundle: BundleGroup | null;
-    clippingContext: ClippingContext;
-    clippingContextVersion: number;
+    clippingContext: ClippingContext | null;
+    clippingContextCacheKey: string;
     initialNodesCacheKey: string;
     initialCacheKey: string;
     _nodeBuilderState: NodeBuilderState | null;
@@ -64,21 +64,25 @@ export default class RenderObject {
         camera: Camera,
         lightsNode: LightsNode,
         renderContext: RenderContext,
+        clippingContext: ClippingContext | null,
     );
     updateClipping(parent: ClippingContext): void;
     get clippingNeedsUpdate(): boolean;
+    get hardwareClippingPlanes(): number;
     getNodeBuilderState(): NodeBuilderState;
     getMonitor(): NodeMaterialObserver;
     getBindings(): BindGroup[];
     getIndex(): BufferAttribute | null;
+    getIndirect(): import("./IndirectStorageBufferAttribute.js").default | null;
     getChainArray(): readonly [
         Object3D<import("../../core/Object3D.js").Object3DEventMap>,
         Material,
         RenderContext,
         LightsNode,
     ];
-    getAttributes(): (InterleavedBufferAttribute | BufferAttribute)[];
-    getVertexBuffers(): (InterleavedBuffer | BufferAttribute)[] | null;
+    setGeometry(geometry: BufferGeometry): void;
+    getAttributes(): (BufferAttribute | InterleavedBufferAttribute)[];
+    getVertexBuffers(): (BufferAttribute | InterleavedBuffer)[] | null;
     getDrawParameters(): {
         vertexCount: number;
         firstVertex: number;
@@ -87,6 +91,7 @@ export default class RenderObject {
     } | null;
     getGeometryCacheKey(): string;
     getMaterialCacheKey(): number;
+    get needsGeometryUpdate(): boolean;
     get needsUpdate(): boolean;
     getDynamicCacheKey(): string;
     getCacheKey(): string;

three/src/renderers/common/RenderObjects.d.ts

@@ -5,6 +5,7 @@ import LightsNode from "../../nodes/lighting/LightsNode.js";
 import { Scene } from "../../scenes/Scene.js";
 import Bindings from "./Bindings.js";
 import ChainMap from "./ChainMap.js";
+import ClippingContext from "./ClippingContext.js";
 import Geometries from "./Geometries.js";
 import Info from "./Info.js";
 import Nodes from "./nodes/Nodes.js";
@@ -37,6 +38,7 @@ declare class RenderObjects {
         camera: Camera,
         lightsNode: LightsNode,
         renderContext: RenderContext,
+        clippingContext: ClippingContext | null,
         passId?: string | undefined,
     ): RenderObject;
     getChainMap(
@@ -56,6 +58,7 @@ declare class RenderObjects {
         camera: Camera,
         lightsNode: LightsNode,
         renderContext: RenderContext,
+        clippingContext: ClippingContext | null,
         passId: string | undefined,
     ): RenderObject;
 }

three/src/renderers/common/Renderer.d.ts

@@ -1,5 +1,5 @@
 import { Camera } from "../../cameras/Camera.js";
-import { ColorSpace, ShadowMapType, ToneMapping } from "../../constants.js";
+import { ShadowMapType, ToneMapping } from "../../constants.js";
 import { BufferAttribute } from "../../core/BufferAttribute.js";
 import { BufferGeometry, GeometryGroup } from "../../core/BufferGeometry.js";
 import { Object3D } from "../../core/Object3D.js";
@@ -21,9 +21,11 @@ import Attributes from "./Attributes.js";
 import Backend from "./Backend.js";
 import Background from "./Background.js";
 import Bindings from "./Bindings.js";
+import ClippingContext from "./ClippingContext.js";
 import Color4 from "./Color4.js";
 import Geometries from "./Geometries.js";
 import Info from "./Info.js";
+import Lighting from "./Lighting.js";
 import NodeLibrary from "./nodes/NodeLibrary.js";
 import Nodes from "./nodes/Nodes.js";
 import Pipelines from "./Pipelines.js";
@@ -42,9 +44,17 @@ interface Rectangle {
     z: number;
     w: number;
 }
+interface DeviceLostInfo {
+    api: "WebGL" | "WebGPU";
+    message: string;
+    reason: string | null;
+    originalEvent: unknown;
+}
 export interface RendererParameters {
     logarithmicDepthBuffer?: boolean | undefined;
     alpha?: boolean | undefined;
+    depth?: boolean | undefined;
+    stencil?: boolean | undefined;
     antialias?: boolean | undefined;
     samples?: number | undefined;
     getFallback?: ((error: unknown) => Backend) | null | undefined;
@@ -60,7 +70,7 @@ declare class Renderer {
     autoClearStencil: boolean;
     alpha: boolean;
     logarithmicDepthBuffer: boolean;
-    outputColorSpace: ColorSpace;
+    outputColorSpace: string;
     toneMapping: ToneMapping;
     toneMappingExposure: number;
     sortObjects: boolean;
@@ -68,9 +78,8 @@ declare class Renderer {
     stencil: boolean;
     clippingPlanes: readonly Plane[];
     info: Info;
-    nodes: {
-        library: NodeLibrary;
-    };
+    library: NodeLibrary;
+    lighting: Lighting;
     _getFallback: ((error: unknown) => Backend) | null;
     _pixelRatio: number;
     _width: number;
@@ -134,6 +143,8 @@ declare class Renderer {
         group: GeometryGroup,
         passId?: string,
     ) => void;
+    _isDeviceLost: boolean;
+    onDeviceLost: (info: DeviceLostInfo) => void;
     _initialized: boolean;
     _initPromise: Promise<void> | null;
     _compilationPromises: Promise<void>[] | null;
@@ -167,12 +178,14 @@ declare class Renderer {
     get coordinateSystem(): import("../../constants.js").CoordinateSystem;
     compileAsync(scene: Object3D, camera: Camera, targetScene?: Object3D | null): Promise<void>;
     renderAsync(scene: Scene, camera: Camera): Promise<void>;
+    waitForGPU(): Promise<void>;
     setMRT(mrt: MRTNode | null): this;
     getMRT(): MRTNode | null;
+    _onDeviceLost(info: DeviceLostInfo): void;
     _renderBundle(bundle: Bundle, sceneRef: Scene, lightsNode: LightsNode): void;
     render(scene: Scene, camera: Camera): Promise<void> | undefined;
     _getFrameBufferTarget(): RenderTarget<Texture> | null;
-    _renderScene(scene: Scene, camera: Camera, useFrameBufferTarget?: boolean): RenderContext;
+    _renderScene(scene: Scene, camera: Camera, useFrameBufferTarget?: boolean): RenderContext | undefined;
     getMaxAnisotropy(): number;
     getActiveCubeFace(): number;
     getActiveMipmapLevel(): number;
@@ -213,7 +226,7 @@ declare class Renderer {
     clearDepthAsync(): Promise<void>;
     clearStencilAsync(): Promise<void>;
     get currentToneMapping(): ToneMapping;
-    get currentColorSpace(): ColorSpace;
+    get currentColorSpace(): string;
     dispose(): void;
     setRenderTarget(renderTarget: RenderTarget | null, activeCubeFace?: number, activeMipmapLevel?: number): void;
     getRenderTarget(): RenderTarget<Texture> | null;
@@ -241,9 +254,13 @@ declare class Renderer {
             lightsNode: LightsNode,
         ) => void)
         | null;
+    compute(computeNodes: ComputeNode | ComputeNode[]): Promise<void> | undefined;
     computeAsync(computeNodes: ComputeNode | ComputeNode[]): Promise<void>;
     hasFeatureAsync(name: string): Promise<void>;
     hasFeature(name: string): false | void;
+    hasInitialized(): boolean;
+    initTextureAsync(texture: Texture): Promise<void>;
+    initTexture(texture: Texture): false | undefined;
     copyFramebufferToTexture(framebufferTexture: FramebufferTexture, rectangle?: Rectangle | null): void;
     copyTextureToTexture(
         srcTexture: Texture,
@@ -261,9 +278,28 @@ declare class Renderer {
         index?: number,
         faceIndex?: number,
     ): Promise<import("../../core/BufferAttribute.js").TypedArray>;
-    _projectObject(object: Object3D, camera: Camera, groupOrder: number, renderList: RenderList): void;
+    _projectObject(
+        object: Object3D,
+        camera: Camera,
+        groupOrder: number,
+        renderList: RenderList,
+        clippingContext: ClippingContext | null,
+    ): void;
     _renderBundles(bundles: Bundle[], sceneRef: Scene, lightsNode: LightsNode): void;
-    _renderObjects(renderList: RenderItem[], camera: Camera, scene: Scene, lightsNode: LightsNode): void;
+    _renderTransparents(
+        renderList: RenderItem[],
+        doublePassList: RenderItem[],
+        camera: Camera,
+        scene: Scene,
+        lightsNode: LightsNode,
+    ): void;
+    _renderObjects(
+        renderList: RenderItem[],
+        camera: Camera,
+        scene: Scene,
+        lightsNode: LightsNode,
+        passId?: string | null,
+    ): void;
     renderObject(
         object: Object3D,
         scene: Scene,
@@ -272,6 +308,8 @@ declare class Renderer {
         material: Material,
         group: GeometryGroup,
         lightsNode: LightsNode,
+        clippingContext?: ClippingContext | null,
+        passId?: string | null,
     ): void;
     _renderObjectDirect(
         object: Object3D,
@@ -280,6 +318,7 @@ declare class Renderer {
         camera: Camera,
         lightsNode: LightsNode,
         group: GeometryGroup,
+        clippingContext: ClippingContext | null,
         passId?: string,
     ): void;
     _createObjectPipeline(
@@ -288,9 +327,9 @@ declare class Renderer {
         scene: Scene,
         camera: Camera,
         lightsNode: LightsNode,
+        clippingContext: ClippingContext | null,
         passId?: string,
     ): void;
-    get compute(): (computeNodes: ComputeNode | ComputeNode[]) => Promise<void>;
     get compile(): (scene: Object3D, camera: Camera, targetScene?: Object3D | null) => Promise<void>;
 }
 export default Renderer;

three/src/renderers/common/UniformsGroup.d.ts

@@ -28,5 +28,6 @@ declare class UniformsGroup extends UniformBuffer {
     updateColor(uniform: ColorNodeUniform): boolean;
     updateMatrix3(uniform: Matrix3NodeUniform): boolean;
     updateMatrix4(uniform: Matrix4NodeUniform): boolean;
+    _getBufferForType(type: string | null): Int32Array | Uint32Array | Float32Array;
 }
 export default UniformsGroup;

three/src/renderers/common/extras/PMREMGenerator.d.ts

@@ -2,8 +2,26 @@ import { RenderTarget } from "../../../core/RenderTarget.js";
 import { Scene } from "../../../scenes/Scene.js";
 import Renderer from "../Renderer.js";
 
-export default class PMREMGenerator {
+declare class PMREMGenerator {
     constructor(renderer: Renderer);
 
-    fromScene(scene: Scene, sigma?: number, near?: number, far?: number): RenderTarget;
+    fromScene(
+        scene: Scene,
+        sigma?: number,
+        near?: number,
+        far?: number,
+        renderTarget?: RenderTarget | null,
+    ): RenderTarget;
+
+    fromSceneAsync(
+        scene: Scene,
+        sigma?: number,
+        near?: number,
+        far?: number,
+        renderTarget?: RenderTarget | null,
+    ): Promise<RenderTarget>;
+
+    dispose(): void;
 }
+
+export default PMREMGenerator;

three/src/renderers/common/nodes/NodeLibrary.d.ts

@@ -3,7 +3,6 @@ import { Light } from "../../../lights/Light.js";
 import { Material } from "../../../materials/Material.js";
 import NodeMaterial from "../../../materials/nodes/NodeMaterial.js";
 import Node from "../../../nodes/core/Node.js";
-import { ColorSpaceMethod } from "../../../nodes/display/ColorSpaceNode.js";
 import AnalyticLightNode from "../../../nodes/lighting/AnalyticLightNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../../../nodes/tsl/TSLCore.js";
 declare class NodeLibrary {
@@ -19,14 +18,8 @@ declare class NodeLibrary {
         ToneMapping,
         (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>
     >;
-    colorSpaceNodes: Map<ColorSpaceMethod, (color: NodeRepresentation) => ShaderNodeObject<Node>>;
     constructor();
-    fromMaterial(material: Material): Material | null;
-    addColorSpace(
-        colorSpaceNode: (color: NodeRepresentation) => ShaderNodeObject<Node>,
-        colorSpace: ColorSpaceMethod,
-    ): void;
-    getColorSpaceFunction(colorSpace: ColorSpaceMethod): ((color: NodeRepresentation) => ShaderNodeObject<Node>) | null;
+    fromMaterial(material: Material): Material | NodeMaterial | null;
     addToneMapping(
         toneMappingNode: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>,
         toneMapping: ToneMapping,
@@ -37,9 +30,7 @@ declare class NodeLibrary {
     getMaterialNodeClass(materialType: string): (new() => NodeMaterial) | null;
     addMaterial(materialNodeClass: {
         new(): NodeMaterial;
-    }, materialClass: {
-        new(): Material;
-    }): void;
+    }, materialClassType: string): void;
     getLightNodeClass(light: Light): (new(light: Light) => AnalyticLightNode<Light>) | null;
     addLight<TLight extends Light>(lightNodeClass: {
         new(light: TLight): AnalyticLightNode<TLight>;

three/src/renderers/common/nodes/NodeUniform.d.ts

@@ -18,36 +18,43 @@ declare class NumberNodeUniform extends NumberUniform {
     nodeUniform: NodeUniform<number>;
     constructor(nodeUniform: NodeUniform<number>);
     getValue(): number;
+    getType(): string | null;
 }
 declare class Vector2NodeUniform extends Vector2Uniform {
     nodeUniform: NodeUniform<Vector2>;
     constructor(nodeUniform: NodeUniform<Vector2>);
     getValue(): Vector2;
+    getType(): string | null;
 }
 declare class Vector3NodeUniform extends Vector3Uniform {
     nodeUniform: NodeUniform<Vector3>;
     constructor(nodeUniform: NodeUniform<Vector3>);
     getValue(): Vector3;
+    getType(): string | null;
 }
 declare class Vector4NodeUniform extends Vector4Uniform {
     nodeUniform: NodeUniform<Vector4>;
     constructor(nodeUniform: NodeUniform<Vector4>);
     getValue(): Vector4;
+    getType(): string | null;
 }
 declare class ColorNodeUniform extends ColorUniform {
     nodeUniform: NodeUniform<Color>;
     constructor(nodeUniform: NodeUniform<Color>);
     getValue(): Color;
+    getType(): string | null;
 }
 declare class Matrix3NodeUniform extends Matrix3Uniform {
     nodeUniform: NodeUniform<Matrix3>;
     constructor(nodeUniform: NodeUniform<Matrix3>);
     getValue(): Matrix3;
+    getType(): string | null;
 }
 declare class Matrix4NodeUniform extends Matrix4Uniform {
     nodeUniform: NodeUniform<Matrix4>;
     constructor(nodeUniform: NodeUniform<Matrix4>);
     getValue(): Matrix4;
+    getType(): string | null;
 }
 export {
     ColorNodeUniform,

three/src/renderers/webgl/WebGLPrograms.d.ts

@@ -1,12 +1,4 @@
-import {
-    ColorSpace,
-    Combine,
-    DepthPackingStrategies,
-    GLSLVersion,
-    Mapping,
-    ShadowMapType,
-    ToneMapping,
-} from "../../constants.js";
+import { Combine, DepthPackingStrategies, GLSLVersion, Mapping, ShadowMapType, ToneMapping } from "../../constants.js";
 import { Object3D } from "../../core/Object3D.js";
 import { Light } from "../../lights/Light.js";
 import { Material } from "../../materials/Material.js";
@@ -45,7 +37,7 @@ export interface WebGLProgramParameters {
     instancingMorph: boolean;
 
     supportsVertexTextures: boolean;
-    outputColorSpace: ColorSpace;
+    outputColorSpace: string;
     alphaToCoverage: boolean;
 
     map: boolean;
@@ -190,6 +182,7 @@ export interface WebGLProgramParameters {
     toneMapping: ToneMapping;
 
     decodeVideoTexture: boolean;
+    decodeVideoTextureEmissive: boolean;
 
     premultipliedAlpha: boolean;
 

three/src/renderers/webgl/WebGLState.d.ts

@@ -9,19 +9,20 @@ import {
 import { Material } from "../../materials/Material.js";
 import { Vector4 } from "../../math/Vector4.js";
 import { WebGLRenderTarget } from "../WebGLRenderTarget.js";
+import { WebGLExtensions } from "./WebGLExtensions.js";
 
-export class WebGLColorBuffer {
-    constructor();
-
+declare class ColorBuffer {
     setMask(colorMask: boolean): void;
     setLocked(lock: boolean): void;
     setClear(r: number, g: number, b: number, a: number, premultipliedAlpha: boolean): void;
     reset(): void;
 }
 
-export class WebGLDepthBuffer {
+declare class DepthBuffer {
     constructor();
 
+    setReversed(value: boolean): void;
+    getReversed(): boolean;
     setTest(depthTest: boolean): void;
     setMask(depthMask: boolean): void;
     setFunc(depthFunc: DepthModes): void;
@@ -30,7 +31,7 @@ export class WebGLDepthBuffer {
     reset(): void;
 }
 
-export class WebGLStencilBuffer {
+declare class StencilBuffer {
     constructor();
 
     setTest(stencilTest: boolean): void;
@@ -42,13 +43,13 @@ export class WebGLStencilBuffer {
     reset(): void;
 }
 
-export class WebGLState {
-    constructor(gl: WebGLRenderingContext);
+declare class WebGLState {
+    constructor(gl: WebGLRenderingContext, extensions: WebGLExtensions);
 
     buffers: {
-        color: WebGLColorBuffer;
-        depth: WebGLDepthBuffer;
-        stencil: WebGLStencilBuffer;
+        color: ColorBuffer;
+        depth: DepthBuffer;
+        stencil: StencilBuffer;
     };
 
     enable(id: number): void;
@@ -66,7 +67,7 @@ export class WebGLState {
         blendDstAlpha?: BlendingDstFactor,
         premultiplyAlpha?: boolean,
     ): void;
-    setMaterial(material: Material, frontFaceCW: boolean): void;
+    setMaterial(material: Material, frontFaceCW: boolean, hardwareClippingPlanes: number): void;
     setFlipSided(flipSided: boolean): void;
     setCullFace(cullFace: CullFace): void;
     setLineWidth(width: number): void;
@@ -114,3 +115,5 @@ export class WebGLState {
     viewport(viewport: Vector4): void;
     reset(): void;
 }
+
+export { WebGLState };

three/src/renderers/webgl/WebGLUtils.d.ts

@@ -1,4 +1,4 @@
-import { ColorSpace, CompressedPixelFormat, PixelFormat, TextureDataType } from "../../constants.js";
+import { CompressedPixelFormat, PixelFormat, TextureDataType } from "../../constants.js";
 import { WebGLExtensions } from "./WebGLExtensions.js";
 
 export class WebGLUtils {
@@ -7,5 +7,5 @@ export class WebGLUtils {
         extensions: WebGLExtensions,
     );
 
-    convert(p: PixelFormat | CompressedPixelFormat | TextureDataType, colorSpace?: ColorSpace): number | null;
+    convert(p: PixelFormat | CompressedPixelFormat | TextureDataType, colorSpace?: string): number | null;
 }

three/src/textures/CompressedTexture.d.ts

@@ -1,5 +1,4 @@
 import {
-    ColorSpace,
     CompressedPixelFormat,
     MagnificationTextureFilter,
     Mapping,
@@ -51,7 +50,7 @@ export class CompressedTexture extends Texture {
         magFilter?: MagnificationTextureFilter,
         minFilter?: MinificationTextureFilter,
         anisotropy?: number,
-        colorSpace?: ColorSpace,
+        colorSpace?: string,
     );
 
     /**

three/src/textures/CubeTexture.d.ts

@@ -1,5 +1,4 @@
 import {
-    ColorSpace,
     CubeTextureMapping,
     MagnificationTextureFilter,
     MinificationTextureFilter,
@@ -52,7 +51,7 @@ export class CubeTexture extends Texture {
         format?: PixelFormat,
         type?: TextureDataType,
         anisotropy?: number,
-        colorSpace?: ColorSpace,
+        colorSpace?: string,
     );
 
     /**

three/src/textures/Data3DTexture.d.ts

@@ -1,6 +1,6 @@
 import { MagnificationTextureFilter, MinificationTextureFilter, Wrapping } from "../constants.js";
+import { TextureImageData } from "./DataTexture.js";
 import { Texture } from "./Texture.js";
-import { Texture3DImageData } from "./types.js";
 
 /**
  * Creates a three-dimensional texture from raw data, with parameters to divide it into width, height, and depth
@@ -93,4 +93,6 @@ export class Data3DTexture extends Texture {
     unpackAlignment: number;
 }
 
-export {};
+export interface Texture3DImageData extends TextureImageData {
+    depth: number;
+}

three/src/textures/DataArrayTexture.d.ts

@@ -1,6 +1,6 @@
 import { MagnificationTextureFilter, MinificationTextureFilter } from "../constants.js";
+import { Texture3DImageData } from "./Data3DTexture.js";
 import { Texture } from "./Texture.js";
-import { Texture3DImageData } from "./types.js";
 
 /**
  * Creates an array of textures directly from raw data, width and height and depth

three/src/textures/DataTexture.d.ts

@@ -1,5 +1,4 @@
 import {
-    ColorSpace,
     MagnificationTextureFilter,
     Mapping,
     MinificationTextureFilter,
@@ -8,7 +7,6 @@ import {
     Wrapping,
 } from "../constants.js";
 import { Texture } from "./Texture.js";
-import { TextureImageData } from "./types.js";
 
 /**
  * Creates a texture directly from raw data, width and height.
@@ -64,7 +62,7 @@ export class DataTexture extends Texture {
         magFilter?: MagnificationTextureFilter,
         minFilter?: MinificationTextureFilter,
         anisotropy?: number,
-        colorSpace?: ColorSpace,
+        colorSpace?: string,
     );
 
     /**
@@ -111,3 +109,9 @@ export class DataTexture extends Texture {
      */
     unpackAlignment: number;
 }
+
+export interface TextureImageData {
+    data: Uint8Array | Uint8ClampedArray;
+    height: number;
+    width: number;
+}

three/src/textures/Texture.d.ts

@@ -1,7 +1,6 @@
 import {
     AnyMapping,
     AnyPixelFormat,
-    ColorSpace,
     MagnificationTextureFilter,
     Mapping,
     MinificationTextureFilter,
@@ -38,7 +37,7 @@ export interface TextureJSON {
     format: AnyPixelFormat;
     internalFormat: PixelFormatGPU | null;
     type: TextureDataType;
-    colorSpace: ColorSpace;
+    colorSpace: string;
 
     minFilter: MinificationTextureFilter;
     magFilter: MagnificationTextureFilter;
@@ -99,7 +98,7 @@ export class Texture extends EventDispatcher<{ dispose: {} }> {
         format?: PixelFormat,
         type?: TextureDataType,
         anisotropy?: number,
-        colorSpace?: ColorSpace,
+        colorSpace?: string,
     );
 
     /**
@@ -369,7 +368,7 @@ export class Texture extends EventDispatcher<{ dispose: {} }> {
      * @see {@link THREE.TextureDataType}
      * @defaultValue {@link THREE.NoColorSpace}
      */
-    colorSpace: ColorSpace;
+    colorSpace: string;
 
     /**
      * Indicates whether a texture belongs to a render target or not

three/examples/jsm/cameras/CinematicCamera.d.ts

@@ -1,34 +0,0 @@
-import { OrthographicCamera, PerspectiveCamera, Scene, ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from "three";
-
-import { BokehShaderUniforms } from "../shaders/BokehShader2.js";
-
-export class CinematicCamera extends PerspectiveCamera {
-    constructor(fov: number, aspect: number, near: number, far: number);
-
-    postprocessing: {
-        enabled: boolean;
-        scene: Scene;
-        camera: OrthographicCamera;
-        rtTextureDepth: WebGLRenderTarget;
-        rtTextureColor: WebGLRenderTarget;
-        bokeh_uniforms: BokehShaderUniforms;
-    };
-    shaderSettings: {
-        rings: number;
-        samples: number;
-    };
-    materialDepth: ShaderMaterial;
-    coc: number;
-    aperture: number;
-    fNumber: number;
-    hyperFocal: number;
-    filmGauge: number;
-
-    linearize(depth: number): number;
-    smoothstep(near: number, far: number, depth: number): number;
-    saturate(x: number): number;
-    focusAt(focusDistance: number): void;
-    initPostProcessing(): void;
-    renderCinematic(scene: Scene, renderer: WebGLRenderer): void;
-    setLens(focalLength: number, frameHeight?: number, fNumber?: number, coc?: number): void;
-}

three/src/nodes/display/BleachBypass.d.ts

@@ -1,4 +0,0 @@
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
-
-export const bleach: (color: NodeRepresentation, opacity?: number) => ShaderNodeObject<Node>;

three/src/nodes/display/BlendMode.d.ts

@@ -1,10 +0,0 @@
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
-
-export const burn: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
-
-export const dodge: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
-
-export const screen: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
-
-export const overlay: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;

three/src/nodes/display/Sepia.d.ts

@@ -1,4 +0,0 @@
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
-
-export const sepia: (color: NodeRepresentation) => ShaderNodeObject<Node>;

three/src/nodes/lighting/LightNode.d.ts

@@ -1,18 +0,0 @@
-import { Light } from "../../lights/Light.js";
-import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
-
-export type LightNodeScope = typeof LightNode.TARGET_DIRECTION;
-
-declare class LightNode extends Node {
-    scope: LightNodeScope;
-    light: Light;
-
-    constructor(scope?: LightNodeScope, light?: Light | null);
-
-    static TARGET_DIRECTION: "targetDirection";
-}
-
-export default LightNode;
-
-export const lightTargetDirection: (light?: Light | null) => ShaderNodeObject<LightNode>;