@types/three 0.181.0 → 0.183.0

three/src/nodes/core/constants.d.ts

@@ -4,10 +4,11 @@
  * @property {string} VERTEX The vertex shader stage.
  * @property {string} FRAGMENT The fragment shader stage.
  */
-export declare const NodeShaderStage: {
+export const NodeShaderStage: {
     readonly VERTEX: "vertex";
     readonly FRAGMENT: "fragment";
 };
+
 /**
  * Update types of a node.
  *
@@ -16,12 +17,13 @@ export declare const NodeShaderStage: {
  * @property {string} RENDER The update method is executed per render. A frame might be produced by multiple render calls so this value allows more detailed updates than FRAME.
  * @property {string} OBJECT The update method is executed per {@link Object3D} that uses the node for rendering.
  */
-export declare const NodeUpdateType: {
+export const NodeUpdateType: {
     readonly NONE: "none";
     readonly FRAME: "frame";
     readonly RENDER: "render";
     readonly OBJECT: "object";
 };
+
 /**
  * Data types of a node.
  *
@@ -35,7 +37,7 @@ export declare const NodeUpdateType: {
  * @property {string} MATRIX3 3x3 matrix type.
  * @property {string} MATRIX4 4x4 matrix type.
  */
-export declare const NodeType: {
+export const NodeType: {
     readonly BOOLEAN: "bool";
     readonly INTEGER: "int";
     readonly FLOAT: "float";
@@ -46,6 +48,7 @@ export declare const NodeType: {
     readonly MATRIX3: "mat3";
     readonly MATRIX4: "mat4";
 };
+
 /**
  * Access types of a node. These are relevant for compute and storage usage.
  *
@@ -53,14 +56,16 @@ export declare const NodeType: {
  * @property {string} WRITE_ONLY Write-only access.
  * @property {string} READ_WRITE Read and write access.
  */
-export declare const NodeAccess: {
+export const NodeAccess: {
     readonly READ_ONLY: "readOnly";
     readonly WRITE_ONLY: "writeOnly";
     readonly READ_WRITE: "readWrite";
 };
+
 export type NodeShaderStage = "vertex" | "fragment" | "compute";
 export type NodeUpdateType = "none" | "frame" | "render" | "object";
 export type NodeAccess = "readOnly" | "writeOnly" | "readWrite";
+
 export declare const defaultShaderStages: NodeShaderStage[];
 export declare const defaultBuildStages: string[];
 export declare const shaderStages: NodeShaderStage[];

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

@@ -1,35 +1,15 @@
 import Node from "../core/Node.js";
 
-export const blendBurn: (base: Node, blend: Node) => Node;
+export const blendBurn: (base: Node, blend: Node) => Node<"vec3">;
 
-export const blendDodge: (base: Node, blend: Node) => Node;
+export const blendDodge: (base: Node, blend: Node) => Node<"vec3">;
 
-export const blendScreen: (base: Node, blend: Node) => Node;
+export const blendScreen: (base: Node, blend: Node) => Node<"vec3">;
 
-export const blendOverlay: (base: Node, blend: Node) => Node;
+export const blendOverlay: (base: Node, blend: Node) => Node<"vec3">;
 
-export const blendColor: (base: Node, blend: Node) => Node;
+export const blendColor: (base: Node, blend: Node) => Node<"vec4">;
 
-export const premultiplyAlpha: (color: Node) => Node;
+export const premultiplyAlpha: (color: Node) => Node<"vec4">;
 
-export const unpremultiplyAlpha: (color: Node) => Node;
-
-/**
- * @deprecated
- */
-export const burn: (base: Node, blend: Node) => Node;
-
-/**
- * @deprecated
- */
-export const dodge: (base: Node, blend: Node) => Node;
-
-/**
- * @deprecated
- */
-export const screen: (base: Node, blend: Node) => Node;
-
-/**
- * @deprecated
- */
-export const overlay: (base: Node, blend: Node) => Node;
+export const unpremultiplyAlpha: (color: Node) => Node<"vec4">;

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

@@ -1,29 +1,26 @@
 import Node from "../core/Node.js";
-import MathNode from "../math/MathNode.js";
 
-export const grayscale: (color: Node) => Node;
+export const grayscale: (color: Node) => Node<"vec3">;
 
 export const saturation: (
     color: Node,
     adjustment?: Node | number,
-) => Node;
+) => Node<"vec3">;
 
 export const vibrance: (
     color: Node,
     adjustment?: Node | number,
-) => Node;
+) => Node<"vec3">;
 
 export const hue: (
     color: Node,
     adjustment?: Node | number,
-) => Node;
+) => Node<"vec3">;
 
 export const luminance: (
     color: Node,
     luminanceCoefficients?: Node,
-) => MathNode;
-
-export const threshold: (color: Node, thershold: Node) => MathNode;
+) => Node<"float">;
 
 /**
  * Color Decision List (CDL) v1.2
@@ -52,4 +49,6 @@ export const cdl: (
     power?: Node,
     saturation?: Node,
     luminanceCoefficients?: Node,
-) => Node;
+) => Node<"vec4">;
+
+export const posterize: <TNodeType>(sourceNode: Node<TNodeType>, stepsNode: Node | number) => Node<TNodeType>;

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

@@ -41,20 +41,14 @@ export const convertColorSpace: (
     targetColorSpace: string,
 ) => ColorSpaceNode;
 
-declare module "../Nodes.js" {
-    interface Node {
+declare module "../core/Node.js" {
+    interface NodeElements {
         workingToColorSpace: (
             targetColorSpace: string,
         ) => ColorSpaceNode;
-        workingToColorSpaceAssign: (
-            targetColorSpace: string,
-        ) => this;
 
         colorSpaceToWorking: (
             sourceColorSpace: string,
         ) => ColorSpaceNode;
-        colorSpaceToWorkingAssign: (
-            sourceColorSpace: string,
-        ) => this;
     }
 }

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

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 
-declare class FrontFacingNode extends Node {
+declare class FrontFacingNode extends Node<"bool"> {
     isFrontFacingNode: true;
     constructor();
 }

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

@@ -1,4 +1,4 @@
-import { NormalMapTypes } from "../../constants.js";
+import { NormalMapTypes, NormalPacking } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 
@@ -8,6 +8,8 @@ declare class NormalMapNode extends TempNode {
 
     normalMapType: NormalMapTypes;
 
+    unpackNormalMode: NormalPacking;
+
     constructor(node: Node, scaleNode?: Node | null);
 }
 

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

@@ -2,10 +2,12 @@ import { Camera } from "../../cameras/Camera.js";
 import { Layers } from "../../core/Layers.js";
 import { Object3D } from "../../core/Object3D.js";
 import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
+import { Material } from "../../materials/Material.js";
 import { Vector4 } from "../../math/Vector4.js";
 import Renderer from "../../renderers/common/Renderer.js";
 import { Texture } from "../../textures/Texture.js";
 import TextureNode from "../accessors/TextureNode.js";
+import ContextNode from "../core/ContextNode.js";
 import MRTNode from "../core/MRTNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
@@ -13,6 +15,8 @@ import TempNode from "../core/TempNode.js";
 declare class PassTextureNode extends TextureNode {
     passNode: PassNode;
 
+    readonly isPassTextureNode: boolean;
+
     constructor(passNode: PassNode, texture: Texture);
 }
 
@@ -20,18 +24,26 @@ declare class PassMultipleTextureNode extends PassTextureNode {
     textureName: string;
     previousTexture: boolean;
 
+    readonly isPassMultipleTextureNode: boolean;
+
     constructor(passNode: PassNode, textureName: string, previousTexture?: boolean);
 
     updateTexture(): void;
 }
 
-declare class PassNode extends TempNode {
+declare class PassNode extends TempNode<"vec4"> {
     scope: PassNodeScope;
     scene: Object3D;
     camera: Camera;
 
     renderTarget: RenderTarget;
 
+    overrideMaterial: Material | null;
+    transparent: boolean;
+    opaque: boolean;
+
+    contextNode: ContextNode<unknown> | null;
+
     readonly isPassNode: true;
 
     constructor(scope: PassNodeScope, scene: Object3D, camera: Camera, options?: RenderTargetOptions);
@@ -66,11 +78,11 @@ declare class PassNode extends TempNode {
 
     getTextureNode(name?: string): TextureNode;
 
-    getPreviousTextureNode(name?: string): Node;
+    getPreviousTextureNode(name?: string): TextureNode;
 
-    getViewZNode(name?: string): Node;
+    getViewZNode(name?: string): Node<"float">;
 
-    getLinearDepthNode(name?: string): Node;
+    getLinearDepthNode(name?: string): Node<"float">;
 
     compileAsync(renderer: Renderer): Promise<void>;
 

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

@@ -2,7 +2,7 @@ import { ToneMapping } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 
-declare class RenderOutputNode extends TempNode {
+declare class RenderOutputNode extends TempNode<"vec4"> {
     colorNode: Node;
     outputColorSpace: string | null;
 
@@ -19,15 +19,11 @@ export const renderOutput: (
     outputColorSpace?: string | null,
 ) => RenderOutputNode;
 
-declare module "../Nodes.js" {
-    interface Node {
+declare module "../core/Node.js" {
+    interface NodeElements {
         renderOutput: (
             toneMapping?: ToneMapping | null,
             outputColorSpace?: string | null,
         ) => RenderOutputNode;
-        renderOutputAssign: (
-            toneMapping?: ToneMapping | null,
-            outputColorSpace?: string | null,
-        ) => this;
     }
 }

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

@@ -7,39 +7,47 @@ export type ScreenNodeScope =
     | typeof ScreenNode.UV
     | typeof ScreenNode.DPR;
 
-declare class ScreenNode extends Node {
+interface ScreenNodeInterface {
     scope: ScreenNodeScope;
 
     readonly isViewportNode: true;
+}
 
-    constructor(scope: ScreenNodeScope);
+declare const ScreenNode: {
+    new(scope: typeof ScreenNode.COORDINATE): ScreenNode<"vec2">;
+    new(scope: typeof ScreenNode.VIEWPORT): ScreenNode<"vec4">;
+    new(scope: typeof ScreenNode.SIZE): ScreenNode<"vec2">;
+    new(scope: typeof ScreenNode.UV): ScreenNode<"vec2">;
+    new(scope: typeof ScreenNode.DPR): ScreenNode<"float">;
 
-    static COORDINATE: "coordinate";
-    static VIEWPORT: "viewport";
-    static SIZE: "size";
-    static UV: "uv";
-    static DPR: "dpr";
-}
+    COORDINATE: "coordinate";
+    VIEWPORT: "viewport";
+    SIZE: "size";
+    UV: "uv";
+    DPR: "dpr";
+};
+
+type ScreenNode<TValue> = Node<TValue> & ScreenNodeInterface;
 
 export default ScreenNode;
 
 // Screen
 
-export const screenDPR: ScreenNode;
-export const screenUV: ScreenNode;
-export const screenSize: ScreenNode;
-export const screenCoordinate: ScreenNode;
+export const screenDPR: ScreenNode<"float">;
+export const screenUV: ScreenNode<"vec2">;
+export const screenSize: ScreenNode<"vec2">;
+export const screenCoordinate: ScreenNode<"vec2">;
 
 // Viewport
 
-export const viewport: ScreenNode;
-export const viewportSize: Node;
-export const viewportCoordinate: Node;
-export const viewportUV: Node;
+export const viewport: ScreenNode<"vec4">;
+export const viewportSize: Node<"vec2">;
+export const viewportCoordinate: Node<"vec2">;
+export const viewportUV: Node<"vec2">;
 
 // Deprecated
 
 /**
  * @deprecated "viewportResolution" is deprecated. Use "screenSize" instead.
  */
-export const viewportResolution: ScreenNode;
+export const viewportResolution: Node<"vec2">;

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

@@ -3,7 +3,7 @@ import RendererReferenceNode from "../accessors/RendererReferenceNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 
-declare class ToneMappingNode extends TempNode {
+declare class ToneMappingNode extends TempNode<"vec3"> {
     exposureNode: Node;
     colorNode: Node | null;
 
@@ -19,15 +19,11 @@ export const toneMapping: (
 ) => ToneMappingNode;
 export const toneMappingExposure: RendererReferenceNode;
 
-declare module "../Nodes.js" {
-    interface Node {
+declare module "../core/Node.js" {
+    interface NodeElements {
         toneMapping: (
             mapping?: ToneMapping,
             exposure?: Node | number,
         ) => ToneMappingNode;
-        toneMappingAssign: (
-            mapping?: ToneMapping,
-            exposure?: Node | number,
-        ) => this;
     }
 }

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

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 
-declare class ViewportDepthNode extends Node {
+declare class ViewportDepthNode extends Node<"float"> {
     scope: ViewportDepthNodeScope;
     valueNode: Node;
 
@@ -20,17 +20,21 @@ export type ViewportDepthNodeScope =
 
 export default ViewportDepthNode;
 
-export const viewZToOrthographicDepth: (viewZ: Node, near: Node, far: Node) => Node;
+export const viewZToOrthographicDepth: (viewZ: Node, near: Node, far: Node) => Node<"float">;
 
-export const orthographicDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
+export const viewZToReversedOrthographicDepth: (viewZ: Node, near: Node, far: Node) => Node<"float">;
 
-export const viewZToPerspectiveDepth: (viewZ: Node, near: Node, far: Node) => Node;
+export const orthographicDepthToViewZ: (depth: Node, near: Node, far: Node) => Node<"float">;
 
-export const perspectiveDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
+export const viewZToPerspectiveDepth: (viewZ: Node, near: Node, far: Node) => Node<"float">;
 
-export const viewZToLogarithmicDepth: (viewZ: Node, near: Node, far: Node) => Node;
+export const viewZToReversedPerspectiveDepth: (viewZ: Node, near: Node, far: Node) => Node<"float">;
 
-export const logarithmicDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
+export const perspectiveDepthToViewZ: (depth: Node, near: Node, far: Node) => Node<"float">;
+
+export const viewZToLogarithmicDepth: (viewZ: Node, near: Node, far: Node) => Node<"float">;
+
+export const logarithmicDepthToViewZ: (depth: Node, near: Node, far: Node) => Node<"float">;
 
 export const depth: ViewportDepthNode;
 export const linearDepth: (valueNode?: Node | null) => ViewportDepthNode;

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

@@ -29,3 +29,5 @@ export const viewportMipTexture: (
     levelNode?: Node | null,
     framebufferTexture?: FramebufferTexture | null,
 ) => Node;
+
+export const viewportOpaqueMipTexture: (uv?: Node, level?: Node | null) => Node;

three/src/nodes/fog/Fog.d.ts

@@ -1,10 +1,12 @@
 import Node from "../core/Node.js";
 
-export const rangeFogFactor: (near: Node | number, far: Node | number) => Node;
+export const rangeFogFactor: (near: Node | number, far: Node | number) => Node<"float">;
 
-export const densityFogFactor: (density: Node) => Node;
+export const densityFogFactor: (density: Node) => Node<"float">;
 
-export const fog: (color: Node, factor: Node) => Node;
+export const exponentialHeightFogFactor: (density: Node, height: Node) => Node;
+
+export const fog: (color: Node, factor: Node) => Node<"vec4">;
 
 /**
  * @deprecated

three/src/nodes/functions/BSDF/DFGLUT.d.ts

@@ -0,0 +1,12 @@
+import Node from "../../core/Node.js";
+import OperatorNode from "../../math/OperatorNode.js";
+
+/**
+ * Precomputed DFG LUT for Image-Based Lighting
+ * Resolution: 16x16
+ * Samples: 4096 per texel
+ * Format: RG16F (2 half floats per texel: scale, bias)
+ */
+declare const DFGLUT: (args: { roughness: Node; dotNV: Node }) => OperatorNode;
+
+export default DFGLUT;

three/src/nodes/functions/PhysicalLightingModel.d.ts

@@ -16,6 +16,8 @@ export default class PhysicalLightingModel extends LightingModel {
     sheenSpecularIndirect: Node | null;
     iridescenceFresnel: Node | null;
     iridescenceF0: Node | null;
+    iridescenceF0Dielectric: Node | null;
+    iridescenceF0Metallic: Node | null;
 
     constructor(
         clearcoat?: boolean,
@@ -26,5 +28,10 @@ export default class PhysicalLightingModel extends LightingModel {
         dispersion?: boolean,
     );
 
-    computeMultiscattering(singleScatter: Node, multiScatter: Node, specularF90: Node): void;
+    computeMultiscattering(
+        singleScatter: Node,
+        multiScatter: Node,
+        specularF90: Node,
+        iridescenceF0?: Node | null,
+    ): void;
 }

three/src/nodes/geometry/RangeNode.d.ts

@@ -5,16 +5,58 @@ import { Vector4 } from "../../math/Vector4.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 
-export default class RangeNode extends Node {
-    minNode: Node;
-    maxNode: Node;
-
-    constructor(minNode: Node, maxNode: Node);
+interface RangeNodeInterface<TNodeType> {
+    minNode: Node<TNodeType>;
+    maxNode: Node<TNodeType>;
 
     getVectorLength(builder: NodeBuilder): number;
 }
 
-export const range: (
-    minNode: Node | number | Color | Vector2 | Vector3 | Vector4,
-    maxNode: Node | number | Color | Vector2 | Vector3 | Vector4,
-) => RangeNode;
+declare const RangeNode: {
+    new<TNodeType>(minNode: Node<TNodeType>, maxNode: Node<TNodeType>): RangeNode<TNodeType>;
+};
+
+type RangeNode<TNodeType> = RangeNodeInterface<TNodeType> & Node<TNodeType>;
+
+export default RangeNode;
+
+interface Range {
+    (
+        minNode: number,
+        maxNode: number,
+    ): RangeNode<"float">;
+    (
+        minNode: Vector2,
+        maxNode: Vector2,
+    ): RangeNode<"vec2">;
+    (
+        minNode: Vector3,
+        maxNode: Vector3,
+    ): RangeNode<"vec3">;
+    (
+        minNode: Vector4,
+        maxNode: Vector4,
+    ): RangeNode<"vec4">;
+    (
+        minNode: Color,
+        maxNode: Color,
+    ): RangeNode<"vec3">;
+    (
+        minNode: Node<"float">,
+        maxNode: Node<"float">,
+    ): RangeNode<"float">;
+    (
+        minNode: Node<"vec2">,
+        maxNode: Node<"vec2">,
+    ): RangeNode<"vec2">;
+    (
+        minNode: Node<"vec3">,
+        maxNode: Node<"vec3">,
+    ): RangeNode<"vec3">;
+    (
+        minNode: Node<"vec4">,
+        maxNode: Node<"vec4">,
+    ): RangeNode<"vec4">;
+}
+
+export const range: Range;

three/src/nodes/gpgpu/AtomicFunctionNode.d.ts

@@ -30,6 +30,8 @@ declare class AtomicFunctionNode extends Node {
     static ATOMIC_XOR: "atomicXor";
 }
 
+export default AtomicFunctionNode;
+
 export const atomicFunc: (
     method: AtomicMethod,
     pointerNode: Node,

three/src/nodes/gpgpu/BarrierNode.d.ts

@@ -6,6 +6,8 @@ declare class BarrierNode extends Node {
     constructor(scope: string);
 }
 
+export default BarrierNode;
+
 export const workgroupBarrier: () => Node;
 export const storageBarrier: () => Node;
 export const textureBarrier: () => Node;

three/src/nodes/gpgpu/ComputeNode.d.ts

@@ -34,18 +34,13 @@ export const compute: (
     workgroupSize?: number[],
 ) => ComputeNode;
 
-declare module "../Nodes.js" {
-    interface Node {
+declare module "../core/Node.js" {
+    interface NodeElements {
         compute: (
             count: number,
             workgroupSize?: number[],
         ) => ComputeNode;
-        computeAssign: (
-            count: number,
-            workgroupSize?: number[],
-        ) => this;
 
         computeKernel: (workgroupSize?: number[]) => ComputeNode;
-        computeKernelAssign: (workgroupSize?: number[]) => this;
     }
 }

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

@@ -6,7 +6,7 @@ import { DirectLightData, DirectRectAreaLightData } from "./LightsNode.js";
 import ShadowNode from "./ShadowNode.js";
 
 declare module "../../lights/LightShadow.js" {
-    export interface LightShadow {
+    interface LightShadow {
         shadowNode?: Node;
     }
 }
@@ -16,6 +16,8 @@ declare class AnalyticLightNode<T extends Light> extends LightingNode {
 
     constructor(light?: T | null);
 
+    disposeShadow(): void;
+
     getLightVector(builder: NodeBuilder): Node;
 
     setupDirect(builder: NodeBuilder): DirectLightData | undefined;

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

@@ -1,10 +1,11 @@
 import { HemisphereLight } from "../../lights/HemisphereLight.js";
-import Object3DNode from "../accessors/Object3DNode.js";
+import { Vector3 } from "../../math/Vector3.js";
 import Node from "../core/Node.js";
+import UniformNode from "../core/UniformNode.js";
 import AnalyticLightNode from "./AnalyticLightNode.js";
 
 export default class HemisphereLightNode extends AnalyticLightNode<HemisphereLight> {
-    lightPositionNode: Object3DNode;
+    lightPositionNode: UniformNode<"vec3", Vector3>;
     lightDirectionNode: Node;
 
     groundColorNode: Node;

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

@@ -3,7 +3,7 @@ import UniformArrayNode from "../accessors/UniformArrayNode.js";
 import AnalyticLightNode from "./AnalyticLightNode.js";
 
 declare class LightProbeNode extends AnalyticLightNode<LightProbe> {
-    lightProbe: UniformArrayNode;
+    lightProbe: UniformArrayNode<"vec3">;
 
     constructor(light?: LightProbe | null);
 }

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

@@ -5,4 +5,4 @@ export const getDistanceAttenuation: (args: {
     lightDistance: Node;
     cutoffDistance: Node;
     decayExponent: Node;
-}) => ConditionalNode;
+}) => Node<"float">;

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

@@ -13,7 +13,7 @@ export interface LightingContext {
     backdropAlpha: Node;
 }
 
-export default class LightingContextNode extends ContextNode {
+export default class LightingContextNode extends ContextNode<unknown> {
     lightingModelNode: LightingModel | null;
     backdropNode: Node | null;
     backdropAlphaNode: Node | null;