@types/three 0.165.0 → 0.166.0

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Fri, 31 May 2024 15:07:05 GMT
+ * Last updated: Fri, 28 Jun 2024 21:35:38 GMT
  * Dependencies: [@tweenjs/tween.js](https://npmjs.com/package/@tweenjs/tween.js), [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits

three/examples/jsm/exporters/GLTFExporter.d.ts

@@ -82,6 +82,12 @@ export class GLTFExporter {
         options?: GLTFExporterOptions,
     ): void;
 
+    /**
+     * Generates a .gltf (JSON) or .glb (binary) output from the input (Scenes or Objects).
+     *
+     * This is just like the {@link parse}() method, but instead of accepting callbacks it returns a promise that
+     * resolves with the result, and otherwise accepts the same options.
+     */
     parseAsync(
         input: Object3D | Object3D[],
         options?: GLTFExporterOptions,

three/examples/jsm/geometries/TeapotGeometry.d.ts

@@ -1,6 +1,30 @@
 import { BufferGeometry } from "three";
 
+/**
+ * {@link TeapotGeometry} tesselates the famous Utah teapot database by Martin Newell.
+ *
+ * {@link TeapotGeometry} is an add-on, and must be imported explicitly. See
+ * [Installation / Addons]{@link https://threejs.org/docs/#manual/en/introduction/Installation}.
+ *
+ * @example
+ * import { TeapotGeometry } from 'three/addons/geometries/TeapotGeometry.js';
+ *
+ * const geometry = new TeapotGeometry( 50, 18 );
+ * const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
+ * const teapot = new THREE.Mesh( geometry, material );
+ * scene.add( teapot );
+ */
 export class TeapotGeometry extends BufferGeometry {
+    /**
+     * @param size Relative scale of the teapot. Optional; Defaults to `50`.
+     * @param segments Number of line segments to subdivide each patch edge. Optional; Defaults to `10`.
+     * @param bottom Whether the bottom of the teapot is generated or not. Optional; Defaults to `true`.
+     * @param lid Whether the lid is generated or not. Optional; Defaults to `true`.
+     * @param body Whether the body is generated or not. Optional; Defaults to `true`.
+     * @param fitLid Whether the lid is slightly stretched to prevent gaps between the body and lid or not. Optional;
+     * Defaults to `true`.
+     * @param blinn Whether the teapot is scaled vertically for better aesthetics or not. Optional; Defaults to `true`.
+     */
     constructor(
         size?: number,
         segments?: number,

three/examples/jsm/helpers/ViewHelper.d.ts

@@ -1,15 +1,17 @@
 import { Camera, Object3D, Vector3, WebGLRenderer } from "three";
 
 export class ViewHelper extends Object3D {
+    readonly isViewHelper: true;
+
     animating: boolean;
     center: Vector3;
 
-    readonly isViewHelper: true;
+    render: (renderer: WebGLRenderer) => void;
+    handleClick: (event: MouseEvent) => boolean;
+    setLabels: (labelX?: string, labelY?: string, labelZ?: string) => void;
+    setLabelStyle: (font?: string, color?: string, radius?: number) => void;
+    update: (delta: number) => void;
+    dispose: () => void;
 
     constructor(camera: Camera, domElement: HTMLElement);
-
-    render(renderer: WebGLRenderer): void;
-    handleClick(event: MouseEvent): boolean;
-    update(delta: number): void;
-    dispose(): void;
 }

three/examples/jsm/lines/LineMaterial.d.ts

@@ -1,6 +1,6 @@
-import { Color, ColorRepresentation, MaterialParameters, ShaderMaterial, Vector2 } from "three";
+import { Color, ColorRepresentation, ShaderMaterial, ShaderMaterialParameters, Vector2 } from "three";
 
-export interface LineMaterialParameters extends MaterialParameters {
+export interface LineMaterialParameters extends ShaderMaterialParameters {
     alphaToCoverage?: boolean | undefined;
     color?: ColorRepresentation | undefined;
     dashed?: boolean | undefined;
@@ -8,9 +8,7 @@ export interface LineMaterialParameters extends MaterialParameters {
     dashSize?: number | undefined;
     dashOffset?: number | undefined;
     gapSize?: number | undefined;
-    linewidth?: number | undefined;
     resolution?: Vector2 | undefined;
-    wireframe?: boolean | undefined;
     worldUnits?: boolean | undefined;
 }
 

three/examples/jsm/loaders/DDSLoader.d.ts

@@ -1,7 +1,13 @@
-import { CompressedPixelFormat, CompressedTextureLoader, LoadingManager, PixelFormat } from "three";
+import {
+    CompressedPixelFormat,
+    CompressedTextureLoader,
+    CompressedTextureMipmap,
+    LoadingManager,
+    PixelFormat,
+} from "three";
 
 export interface DDS {
-    mipmaps: object[];
+    mipmaps: CompressedTextureMipmap[];
     width: number;
     height: number;
     format: PixelFormat | CompressedPixelFormat;

three/examples/jsm/loaders/GLTFLoader.d.ts

@@ -3,6 +3,7 @@ import {
     BufferAttribute,
     BufferGeometry,
     Camera,
+    ColorSpace,
     FileLoader,
     Group,
     ImageBitmapLoader,
@@ -112,7 +113,8 @@ export class GLTFParser {
             texCoord?: number | undefined;
             extensions?: any;
         },
-    ) => Promise<void>;
+        colorSpace?: ColorSpace | undefined,
+    ) => Promise<Texture | null>;
     assignFinalMaterial: (object: Mesh) => void;
     getMaterialType: () => typeof MeshStandardMaterial;
     loadMaterial: (materialIndex: number) => Promise<Material>;

three/examples/jsm/loaders/KTXLoader.d.ts

@@ -1,7 +1,13 @@
-import { CompressedPixelFormat, CompressedTextureLoader, LoadingManager, PixelFormat } from "three";
+import {
+    CompressedPixelFormat,
+    CompressedTextureLoader,
+    CompressedTextureMipmap,
+    LoadingManager,
+    PixelFormat,
+} from "three";
 
 export interface KTX {
-    mipmaps: object[];
+    mipmaps: CompressedTextureMipmap[];
     width: number;
     height: number;
     format: PixelFormat | CompressedPixelFormat;

three/examples/jsm/loaders/PVRLoader.d.ts

@@ -1,7 +1,7 @@
-import { CompressedPixelFormat, CompressedTextureLoader, LoadingManager } from "three";
+import { CompressedPixelFormat, CompressedTextureLoader, CompressedTextureMipmap, LoadingManager } from "three";
 
 export interface PVR {
-    mipmaps: object[];
+    mipmaps: CompressedTextureMipmap[];
     width: number;
     height: number;
     format: CompressedPixelFormat;

three/examples/jsm/nodes/Nodes.d.ts

@@ -127,6 +127,7 @@ export {
     step,
     tan,
     transformDirection,
+    transpose,
     trunc,
 } from "./math/MathNode.js";
 
@@ -164,7 +165,7 @@ export { triNoise3D } from "./math/TriNoise3D.js";
 // utils
 export { default as ArrayElementNode } from "./utils/ArrayElementNode.js";
 export { default as ConvertNode } from "./utils/ConvertNode.js";
-export { default as DiscardNode, discard } from "./utils/DiscardNode.js";
+export { default as DiscardNode, discard, Return } from "./utils/DiscardNode.js";
 export { default as EquirectUVNode, equirectUV } from "./utils/EquirectUVNode.js";
 export { default as JoinNode } from "./utils/JoinNode.js";
 export { default as MatcapUVNode, matcapUV } from "./utils/MatcapUVNode.js";
@@ -266,6 +267,7 @@ export * from "./accessors/ReflectVectorNode.js";
 export { default as RendererReferenceNode, rendererReference } from "./accessors/RendererReferenceNode.js";
 export { default as SkinningNode, skinning } from "./accessors/SkinningNode.js";
 export { default as StorageBufferNode, storage, storageObject } from "./accessors/StorageBufferNode.js";
+export { default as StorageTextureNode, storageTexture, textureStore } from "./accessors/StorageTextureNode.js";
 export * from "./accessors/TangentNode.js";
 export { default as Texture3DNode, texture3D } from "./accessors/Texture3DNode.js";
 export { default as TextureBicubicNode, textureBicubic } from "./accessors/TextureBicubicNode.js";
@@ -297,19 +299,23 @@ export {
     linearTosRGB,
     sRGBToLinear,
 } from "./display/ColorSpaceNode.js";
+export { default as DepthOfFieldNode, dof } from "./display/DepthOfFieldNode.js";
+export { default as DotScreenNode, dotScreen } from "./display/DotScreenNode.js";
 export { default as FrontFacingNode, faceDirection, frontFacing } from "./display/FrontFacingNode.js";
 export { default as GaussianBlurNode, gaussianBlur } from "./display/GaussianBlurNode.js";
 export { default as NormalMapNode, normalMap } from "./display/NormalMapNode.js";
 export { default as PosterizeNode, posterize } from "./display/PosterizeNode.js";
+export { default as RGBShiftNode, rgbShift } from "./display/RGBShiftNode.js";
+export { default as SobelOperatorNode, sobel } from "./display/SobelOperatorNode.js";
 export { default as ToneMappingNode, toneMapping } from "./display/ToneMappingNode.js";
 export {
     default as ViewportDepthNode,
     depth,
-    depthPixel,
-    depthTexture,
+    linearDepth,
     orthographicDepthToViewZ,
     perspectiveDepthToViewZ,
     ViewportDepthNodeScope,
+    viewportLinearDepth,
     viewZToOrthographicDepth,
     viewZToPerspectiveDepth,
 } from "./display/ViewportDepthNode.js";
@@ -355,6 +361,7 @@ export { default as LightingContextNode, lightingContext } from "./lighting/Ligh
 export { default as LightingNode } from "./lighting/LightingNode.js";
 export { default as LightsNode, lights } from "./lighting/LightsNode.js";
 export { default as PointLightNode } from "./lighting/PointLightNode.js";
+export { default as RectAreaLightNode } from "./lighting/RectAreaLightNode.js";
 export { default as SpotLightNode } from "./lighting/SpotLightNode.js";
 
 // pmrem

three/examples/jsm/nodes/accessors/BufferAttributeNode.d.ts

@@ -15,6 +15,7 @@ declare class BufferAttributeNode extends InputNode<TypedArray | InterleavedBuff
         bufferStride?: number,
         bufferOffset?: number,
     );
+    getHash(builder: NodeBuilder): string;
     getNodeType(builder: NodeBuilder): string | null;
     setup(builder: NodeBuilder): void;
     generate(builder: NodeBuilder): string | null | undefined;

three/examples/jsm/nodes/accessors/StorageBufferNode.d.ts

@@ -1,5 +1,6 @@
 import StorageBufferAttribute from "../../renderers/common/StorageBufferAttribute.js";
 import StorageInstancedBufferAttribute from "../../renderers/common/StorageInstancedBufferAttribute.js";
+import { GPUBufferBindingType } from "../../renderers/webgpu/utils/WebGPUConstants.js";
 import { NodeOrType, NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import StorageArrayElementNode from "../utils/StoargeArrayElementNode.js";
 import BufferNode from "./BufferNode.js";
@@ -8,6 +9,8 @@ export default class StorageBufferNode extends BufferNode {
     readonly isStorageBufferNode: true;
     bufferObject: boolean;
 
+    access: GPUBufferBindingType;
+
     constructor(
         value: StorageBufferAttribute | StorageInstancedBufferAttribute,
         bufferType: string,
@@ -17,6 +20,10 @@ export default class StorageBufferNode extends BufferNode {
     element(indexNode: NodeRepresentation): ShaderNodeObject<StorageArrayElementNode>;
 
     setBufferObject(value: boolean): this;
+
+    setAccess(value: GPUBufferBindingType): this;
+
+    toReadOnly(): this;
 }
 
 export const storage: (

three/examples/jsm/nodes/accessors/StorageTextureNode.d.ts

@@ -0,0 +1,40 @@
+import { Texture } from "three";
+import { GPUStorageTextureAccess } from "../../renderers/webgpu/utils/WebGPUConstants.js";
+import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import TextureNode from "./TextureNode.js";
+
+export default class StorageTextureNode extends TextureNode {
+    storeNode: Node | null;
+
+    readonly isStorageTextureNode: true;
+
+    access: GPUStorageTextureAccess;
+
+    constructor(
+        value: Texture,
+        uvNode?: ShaderNodeObject<Node> | null,
+        storeNode?: Node | null,
+    );
+
+    setAccess(value: GPUStorageTextureAccess): this;
+
+    toReadOnly(): this;
+
+    toWriteOnly(): this;
+
+    generateStore(builder: NodeBuilder): void;
+}
+
+export const storageTexture: (
+    value: Texture,
+    uvNode?: NodeRepresentation,
+    storeNode?: NodeRepresentation,
+) => ShaderNodeObject<StorageTextureNode>;
+
+export const textureStore: (
+    value: Texture,
+    uvNode?: NodeRepresentation,
+    storeNode?: NodeRepresentation,
+) => ShaderNodeObject<StorageTextureNode>;

three/examples/jsm/nodes/core/CacheNode.d.ts

@@ -3,19 +3,18 @@ import Node from "./Node.js";
 import NodeCache from "./NodeCache.js";
 
 export default class CacheNode extends Node {
-    isCacheNode: true;
     node: Node;
-    cache: NodeCache;
+    parent: boolean;
 
-    constructor(node: Node, cache?: NodeCache);
+    readonly isCacheNode: true;
+
+    constructor(node: Node, parent?: boolean);
 }
 
 export const cache: (node: Node, cache?: NodeCache) => ShaderNodeObject<CacheNode>;
-export const globalCache: (node: Node) => ShaderNodeObject<CacheNode>;
 
 declare module "../shadernode/ShaderNode.js" {
     interface NodeElements {
         cache: typeof cache;
-        globalCache: typeof globalCache;
     }
 }

three/examples/jsm/nodes/core/LightingModel.d.ts

@@ -16,6 +16,16 @@ export interface LightingModelDirectInput {
     shadowMask: Node;
 }
 
+export interface LightingModelDirectRectAreaInput {
+    lightColor: Node;
+    lightPosition: Node;
+    halfWidth: Node;
+    halfHeight: Node;
+    reflectedLight: LightingModelReflectedLight;
+    ltc_1: Node;
+    ltc_2: Node;
+}
+
 export interface LightingModelIndirectInput {
     radiance: Node;
     irradiance: Node;
@@ -31,6 +41,7 @@ export default class LightingModel {
     start(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
     finish(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
     direct(input: LightingModelDirectInput, stack: StackNode, builder: NodeBuilder): void;
+    directRectArea(input: LightingModelDirectRectAreaInput, stack: StackNode, builder: NodeBuilder): void;
     indirectDiffuse(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
     indirectSpecular(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
     ambientOcclusion(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;

three/examples/jsm/nodes/core/Node.d.ts

@@ -69,6 +69,7 @@ declare class Node extends EventDispatcher<{
     nodeType: string | null;
     updateType: NodeUpdateType;
     updateBeforeType: NodeUpdateType;
+    updateAfterType: NodeUpdateType;
     uuid: string;
     version: number;
     _cacheKey: string | null;
@@ -95,6 +96,7 @@ declare class Node extends EventDispatcher<{
     getHash(builder: NodeBuilder): string;
     getUpdateType(): NodeUpdateType;
     getUpdateBeforeType(): NodeUpdateType;
+    getUpdateAfterType(): NodeUpdateType;
     getElementType(builder: NodeBuilder): "bool" | "int" | "float" | "vec2" | "vec3" | "vec4" | "uint" | null;
     getNodeType(builder: NodeBuilder): string | null;
     getShared(builder: NodeBuilder): Node;
@@ -104,6 +106,7 @@ declare class Node extends EventDispatcher<{
     analyze(builder: NodeBuilder): void;
     generate(builder: NodeBuilder, output?: string | null): string | null | undefined;
     updateBefore(frame: NodeFrame): void;
+    updateAfter(frame: NodeFrame): void;
     update(frame: NodeFrame): void;
     build(builder: NodeBuilder, output?: string | null): string | null;
     getSerializeChildren(): Generator<import("./NodeUtils.js").NodeChild, void, unknown>;

three/examples/jsm/nodes/core/NodeBuilder.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry, Material, Object3D, Renderer } from "three";
+import { BufferGeometry, Material, Object3D, Renderer, Texture } from "three";
 import FogNode from "../fog/FogNode.js";
 import LightsNode from "../lighting/LightsNode.js";
 import { NodeShaderStage } from "./constants.js";
@@ -58,6 +58,7 @@ export default abstract class NodeBuilder {
     setHashNode(node: Node, hash: string): void;
     addNode(node: Node): void;
     get currentNode(): Node;
+    isFilteredTexture(texture: Texture): boolean;
     getMethod(method: string): string;
     getNodeFromHash(hash: string): Node;
 
@@ -65,6 +66,9 @@ export default abstract class NodeBuilder {
 
     setContext(context: NodeBuilderContext): void;
     getContext(): NodeBuilderContext;
+    setCache(cache: NodeCache): void;
+    getCache(): NodeCache;
+    getCacheFromNode(node: Node, parent?: boolean): NodeCache;
     isAvailable(name: string): boolean;
 
     abstract getInstanceIndex(): string;
@@ -83,7 +87,7 @@ export default abstract class NodeBuilder {
 
     getAttribute(name: string, type: string): NodeAttribute;
 
-    getPropertyName(node: Node, shaderStage: NodeShaderStage): string;
+    getPropertyName<TValue>(node: NodeVar | NodeUniform<TValue>, shaderStage: NodeShaderStage): string;
     isVector(type: string): boolean;
 
     isMatrix(type: string): boolean;
@@ -117,7 +121,7 @@ export default abstract class NodeBuilder {
     ): FlowData;
     hasGeometryAttribute(name: string): boolean;
     abstract getAttributes(shaderStage: NodeShaderStage): string;
-    abstract getVarys(shaderStage: NodeShaderStage): string;
+    abstract getVaryings(shaderStage: NodeShaderStage): string;
     getVars(shaderStage: NodeShaderStage): string;
     abstract getUniforms(stage: NodeShaderStage): string;
     getCodes(shaderStage: NodeShaderStage): string;

three/examples/jsm/nodes/core/NodeCache.d.ts

@@ -1,3 +1,5 @@
+import { BufferAttribute, InterleavedBuffer, TypedArray } from "three";
+import BufferAttributeNode from "../accessors/BufferAttributeNode.js";
 import Node from "./Node.js";
 import NodeAttribute from "./NodeAttribute.js";
 import NodeCode from "./NodeCode.js";
@@ -33,11 +35,17 @@ interface NodeData {
     compute?: ShaderStageNodeData | undefined;
     any?: ShaderStageNodeData | undefined;
 }
+interface BufferAttributeData {
+    node: BufferAttributeNode;
+}
 declare class NodeCache {
     id: number;
-    nodesData: WeakMap<Node, NodeData>;
-    constructor();
-    getNodeData(node: Node): NodeData | undefined;
-    setNodeData(node: Node, data: NodeData): void;
+    nodesData: WeakMap<Node | TypedArray | InterleavedBuffer | BufferAttribute, NodeData | BufferAttributeData>;
+    parent: NodeCache | null;
+    constructor(parent?: NodeCache | null);
+    getData(node: Node): NodeData | undefined;
+    getData(node: TypedArray | InterleavedBuffer | BufferAttribute): BufferAttributeData | undefined;
+    setData(node: Node, data: NodeData): void;
+    setData(node: TypedArray | InterleavedBuffer | BufferAttribute, data: BufferAttributeData): void;
 }
 export default NodeCache;

three/examples/jsm/nodes/core/NodeFunction.d.ts

@@ -5,9 +5,9 @@ export default abstract class NodeFunction {
     type: string;
     inputs: NodeFunctionInput[];
     name: string;
-    presicion: string;
+    precision: string;
 
-    constructor(type: string, inputs: NodeFunctionInput[], name?: string, presicion?: string);
+    constructor(type: string, inputs: NodeFunctionInput[], name?: string, precision?: string);
 
     abstract getCode(name?: string): string;
 }

three/examples/jsm/nodes/core/NodeUniform.d.ts

@@ -5,7 +5,7 @@ declare class NodeUniform<TValue> {
     type: string | null;
     node: UniformNode<TValue>;
     needsUpdate: boolean | undefined;
-    constructor(name: string, type: string | null, node: UniformNode<TValue>, needsUpdate?: undefined);
+    constructor(name: string, type: string | null, node: UniformNode<TValue>);
     get value(): TValue;
     set value(val: TValue);
     get id(): number;

three/examples/jsm/nodes/core/UniformNode.d.ts

@@ -6,8 +6,10 @@ import NodeFrame from "./NodeFrame.js";
 import UniformGroupNode from "./UniformGroupNode.js";
 declare class UniformNode<TValue> extends InputNode<TValue> {
     readonly isUniformNode: true;
+    name: string;
     groupNode: UniformGroupNode;
     constructor(value: TValue, nodeType?: string | null);
+    label(name: string): this;
     setGroup(group: UniformGroupNode): this;
     getGroup(): UniformGroupNode;
     getUniformHash(builder: NodeBuilder): string;

three/examples/jsm/nodes/core/VarNode.d.ts

@@ -6,6 +6,8 @@ export default class VarNode extends Node {
     node: Node;
     name: string | null;
 
+    readonly isVarNode: true;
+
     constructor(node: Node, name?: string | null);
 
     op(op: OperatorNodeOp, ...params: Node[]): this;

three/examples/jsm/nodes/display/DepthOfFieldNode.d.ts

@@ -0,0 +1,30 @@
+import TextureNode from "../accessors/TextureNode.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import UniformNode from "../core/UniformNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class DepthOfFieldNode extends TempNode {
+    textureNode: TextureNode;
+    viewZNode: Node;
+
+    focus: UniformNode<number>;
+    aperture: UniformNode<number>;
+    maxblur: UniformNode<number>;
+
+    constructor(textureNode: TextureNode, viewZNode: Node, focus?: number, aperture?: number, maxblur?: number);
+}
+
+export const dof: (
+    node: NodeRepresentation,
+    viewZNode: NodeRepresentation,
+    focus?: number,
+    aperture?: number,
+    maxblur?: number,
+) => ShaderNodeObject<DepthOfFieldNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        dof: typeof dof;
+    }
+}

three/examples/jsm/nodes/display/DotScreenNode.d.ts

@@ -0,0 +1,32 @@
+import { Vector2 } from "three";
+import TextureNode from "../accessors/TextureNode.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import UniformNode from "../core/UniformNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class DotScreenNode extends TempNode {
+    colorNode: Node;
+    center: UniformNode<Vector2>;
+    angle: UniformNode<number>;
+    scale: UniformNode<number>;
+
+    constructor(colorNode: Node, center?: Vector2, angle?: number, scale?: number);
+
+    getTextureNode(): ShaderNodeObject<TextureNode>;
+
+    setSize(width: number, height: number): void;
+}
+
+export const dotScreen: (
+    node: NodeRepresentation,
+    center?: Vector2,
+    angle?: number,
+    scale?: number,
+) => ShaderNodeObject<DotScreenNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        dotScreen: typeof dotScreen;
+    }
+}

three/examples/jsm/nodes/display/PassNode.d.ts

@@ -27,7 +27,7 @@ export default class PassNode extends TempNode {
 
     getViewZNode(): ShaderNodeObject<Node>;
 
-    getDepthNode(): ShaderNodeObject<Node>;
+    getLinearDepthNode(): ShaderNodeObject<Node>;
 
     setSize(width: number, height: number): void;
 

three/examples/jsm/nodes/display/RGBShiftNode.d.ts

@@ -0,0 +1,24 @@
+import TextureNode from "../accessors/TextureNode.js";
+import TempNode from "../core/TempNode.js";
+import UniformNode from "../core/UniformNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class RGBShiftNode extends TempNode {
+    textureNode: TextureNode;
+    amount: UniformNode<number>;
+    angle: UniformNode<number>;
+
+    constructor(textureNode: TextureNode, amount?: number, angle?: number);
+
+    getTextureNode(): TextureNode;
+
+    setSize(width: number, height: number): void;
+}
+
+export const rgbShift: (node: NodeRepresentation, amount?: number, angle?: number) => ShaderNodeObject<RGBShiftNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        rgbShift: typeof rgbShift;
+    }
+}

three/examples/jsm/nodes/display/SobelOperatorNode.d.ts

@@ -0,0 +1,17 @@
+import TextureNode from "../accessors/TextureNode.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class SobelOperatorNode extends TempNode {
+    textureNode: TextureNode;
+
+    constructor(textureNode: TextureNode);
+}
+
+export const sobel: (node: NodeRepresentation) => ShaderNodeObject<SobelOperatorNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        sobel: typeof sobel;
+    }
+}

three/examples/jsm/nodes/display/ViewportDepthNode.d.ts

@@ -10,14 +10,12 @@ export default class ViewportDepthNode extends Node {
     constructor(scope: ViewportDepthNodeScope, valueNode?: Node | null);
 
     static DEPTH: "depth";
-    static DEPTH_TEXTURE: "depthTexture";
-    static DEPTH_PIXEL: "depthPixel";
+    static LINEAR_DEPTH: "linearDepth";
 }
 
 export type ViewportDepthNodeScope =
     | typeof ViewportDepthNode.DEPTH
-    | typeof ViewportDepthNode.DEPTH_TEXTURE
-    | typeof ViewportDepthNode.DEPTH_PIXEL;
+    | typeof ViewportDepthNode.LINEAR_DEPTH;
 
 export const viewZToOrthographicDepth: (viewZ: Node, near: Node, far: Node) => Node;
 
@@ -28,5 +26,5 @@ export const viewZToPerspectiveDepth: (viewZ: Node, near: Node, far: Node) => No
 export const perspectiveDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
 
 export const depth: ShaderNodeObject<ViewportDepthNode>;
-export const depthTexture: (valueNode?: Node | null) => ShaderNodeObject<ViewportDepthNode>;
-export const depthPixel: ShaderNodeObject<ViewportDepthNode>;
+export const linearDepth: (valueNode?: Node | null) => ShaderNodeObject<ViewportDepthNode>;
+export const viewportLinearDepth: ShaderNodeObject<ViewportDepthNode>;

three/examples/jsm/nodes/functions/BSDF/LTC.d.ts

@@ -0,0 +1,9 @@
+import Node from "../../core/Node.js";
+
+declare const LTC_Uv: (args: { N: Node; V: Node; roughness: Node }) => Node;
+
+declare const LTC_Evaluate: (
+    args: { N: Node; V: Node; P: Node; mInv: Node; p0: Node; p1: Node; p2: Node; p3: Node },
+) => Node;
+
+export { LTC_Evaluate, LTC_Uv };

three/examples/jsm/nodes/lighting/RectAreaLightNode.d.ts

@@ -0,0 +1,10 @@
+import { RectAreaLight } from "three";
+import Node from "../core/Node.js";
+import AnalyticLightNode from "./AnalyticLightNode.js";
+
+export default class RectAreaLightNode extends AnalyticLightNode<RectAreaLight> {
+    halfHeight: Node;
+    halfWidth: Node;
+
+    constructor(light?: RectAreaLight | null);
+}