@types/three 0.182.0 → 0.183.0

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/PassNode.d.ts

@@ -15,6 +15,8 @@ import TempNode from "../core/TempNode.js";
 declare class PassTextureNode extends TextureNode {
     passNode: PassNode;
 
+    readonly isPassTextureNode: boolean;
+
     constructor(passNode: PassNode, texture: Texture);
 }
 
@@ -22,12 +24,14 @@ 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;
@@ -38,7 +42,7 @@ declare class PassNode extends TempNode {
     transparent: boolean;
     opaque: boolean;
 
-    contextNode: ContextNode | null;
+    contextNode: ContextNode<unknown> | null;
 
     readonly isPassNode: true;
 
@@ -74,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/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;
     }
 }

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;

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

@@ -19,10 +19,4 @@ declare class SpotLightNode extends AnalyticLightNode<SpotLight> {
     getLightCoord(builder: NodeBuilder): Node;
 }
 
-declare module "three" {
-    export interface SpotLight {
-        attenuationNode?: ((lightNode: SpotLightNode) => Node) | null | undefined;
-    }
-}
-
 export default SpotLightNode;

three/src/nodes/materialx/MaterialXNodes.d.ts

@@ -55,17 +55,17 @@ export const mx_noise_float: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-) => Node;
+) => Node<"float">;
 export const mx_noise_vec3: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-) => Node;
+) => Node<"vec3">;
 export const mx_noise_vec4: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-) => Node;
+) => Node<"vec4">;
 
 export const mx_unifiednoise2d: (
     noiseType: Node,
@@ -97,17 +97,17 @@ export const mx_unifiednoise3d: (
 export function mx_worley_noise_float(
     texcoord?: Node,
     jitter?: Node | number,
-): Node;
+): Node<"float">;
 export function mx_worley_noise_vec2(
     texcoord?: Node,
     jitter?: Node | number,
-): Node;
+): Node<"vec2">;
 export function mx_worley_noise_vec3(
     texcoord?: Node,
     jitter?: Node | number,
-): Node;
+): Node<"vec3">;
 
-export function mx_cell_noise_float(texcoord?: Node): Node;
+export function mx_cell_noise_float(texcoord?: Node): Node<"float">;
 
 export function mx_fractal_noise_float(
     position?: Node,
@@ -115,28 +115,28 @@ export function mx_fractal_noise_float(
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): Node;
+): Node<"float">;
 export function mx_fractal_noise_vec2(
     position?: Node,
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): Node;
+): Node<"vec2">;
 export function mx_fractal_noise_vec3(
     position?: Node,
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): Node;
+): Node<"vec3">;
 export function mx_fractal_noise_vec4(
     position?: Node,
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): Node;
+): Node<"vec4">;
 
 export { mx_hsvtorgb, mx_rgbtohsv, mx_srgb_texture_to_lin_rec709 };
 

three/src/nodes/math/BitcountNode.d.ts

@@ -16,6 +16,8 @@ declare class BitcountNode extends MathNode {
     static COUNT_ONE_BITS: "countOneBits";
 }
 
+export default BitcountNode;
+
 export const countTrailingZeros: (x: Node | number) => BitcountNode;
 export const countLeadingZeros: (x: Node | number) => BitcountNode;
 export const countOneBits: (x: Node | number) => BitcountNode;