@types/three 0.159.0 → 0.161.0

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

@@ -1,19 +1,31 @@
-import { Camera, Material, Object3D, Renderer } from '../../../../src/Three.js';
+import { Camera, Material, Object3D, Renderer, Scene } from '../../../../src/Three.js';
 
 import Node from './Node.js';
 
 export default class NodeFrame {
     time: number;
     deltaTime: number;
+
     frameId: number;
-    startTime: null | number;
-    renderer: null | Renderer;
-    material: null | Material;
-    camera: null | Camera;
-    object: null | Object3D;
+    renderId: number;
+
+    startTime: number | null;
+
+    frameMap: WeakMap<Node, number>;
+    frameBeforeMap: WeakMap<Node, number>;
+    renderMap: WeakMap<Node, number>;
+    renderBeforeMap: WeakMap<Node, number>;
+
+    renderer: Renderer | null;
+    material: Material | null;
+    camera: Camera | null;
+    object: Object3D | null;
+    scene: Scene | null;
 
     constructor();
 
+    updateBeforeNode(node: Node): void;
+
     updateNode(node: Node): void;
     update(): void;
 }

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

@@ -1,13 +1,17 @@
-import { NodeValueOption } from './constants.js';
-import InputNode from './InputNode.js';
+import UniformNode from './UniformNode.js';
+
+export default class NodeUniform<Value> {
+    readonly isNodeUniform: true;
 
-export default class NodeUniform {
-    isNodeUniform: true;
     name: string;
     type: string;
-    node: InputNode;
-    needsUpdate: boolean;
-    value: NodeValueOption;
+    node: UniformNode<Value>;
+    needsUpdate: boolean | undefined;
+
+    constructor(name: string, type: string, node: UniformNode<Value>, needsUpdate?: boolean);
+
+    get(): Value;
+    set value(val: Value);
 
-    constructor(name: string, type: string, node: InputNode, needsUpdate?: boolean);
+    get id(): number;
 }

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

@@ -1,4 +1,4 @@
-import { NodeValueOption } from './constants.js';
+import { Color, Vector2, Vector3, Vector4, Matrix3, Matrix4 } from '../../../../src/Three.js';
 import Node from './Node.js';
 
 export interface NodeChild {
@@ -9,5 +9,8 @@ export interface NodeChild {
 
 export function getCacheKey(object: Node): string;
 export function getNodeChildren(object: Node): Generator<NodeChild, void>;
-export function getValueType(value: NodeValueOption): string | null;
-export function getValueFromType(type: string, ...params: number[]): NodeValueOption | null;
+export function getValueType(value: unknown): string | null;
+export function getValueFromType(
+    type: string,
+    ...params: number[]
+): Color | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | boolean | number | string | ArrayBufferLike | null;

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

@@ -1,6 +1,32 @@
 import { NodeTypeOption } from './constants.js';
 import Node from './Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class PropertyNode extends Node {
-    constructor(name?: string, nodeType?: NodeTypeOption);
+    name: string | null;
+    varying: boolean;
+
+    readonly isPropertyNode: true;
+
+    constructor(nodeType?: NodeTypeOption | null, name?: string | null, varying?: boolean);
 }
+
+export const property: (type?: NodeTypeOption | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
+export const varyingProperty: (type?: NodeTypeOption | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
+
+export const diffuseColor: ShaderNodeObject<PropertyNode>;
+export const roughness: ShaderNodeObject<PropertyNode>;
+export const metalness: ShaderNodeObject<PropertyNode>;
+export const clearcoat: ShaderNodeObject<PropertyNode>;
+export const clearcoatRoughness: ShaderNodeObject<PropertyNode>;
+export const sheen: ShaderNodeObject<PropertyNode>;
+export const sheenRoughness: ShaderNodeObject<PropertyNode>;
+export const iridescence: ShaderNodeObject<PropertyNode>;
+export const iridescenceIOR: ShaderNodeObject<PropertyNode>;
+export const iridescenceThickness: ShaderNodeObject<PropertyNode>;
+export const specularColor: ShaderNodeObject<PropertyNode>;
+export const shininess: ShaderNodeObject<PropertyNode>;
+export const output: ShaderNodeObject<PropertyNode>;
+export const dashSize: ShaderNodeObject<PropertyNode>;
+export const gapSize: ShaderNodeObject<PropertyNode>;
+export const pointWidth: ShaderNodeObject<PropertyNode>;

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

@@ -1,10 +1,18 @@
-import { NodeTypeOption, NodeValueOption } from './constants.js';
+import { NodeTypeOption } from './constants.js';
 import InputNode from './InputNode.js';
 import NodeBuilder from './NodeBuilder.js';
+import Node from './Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
-export default class UniformNode extends InputNode {
-    isUniformNode: true;
+export default class UniformNode<Value> extends InputNode<Value> {
+    readonly isUniformNode: true;
+
+    constructor(value: Value, nodeType?: NodeTypeOption | null);
 
-    constructor(value: NodeValueOption, nodeType?: NodeTypeOption | null);
     getUniformHash(builder: NodeBuilder): string;
 }
+
+export const uniform: <Value>(
+    arg1: InputNode<Value> | Value,
+    arg2?: Node | string,
+) => ShaderNodeObject<UniformNode<Value>>;

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

@@ -1,5 +1,6 @@
 import { OperatorNodeOp } from '../math/OperatorNode.js';
 import Node from './Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class VarNode extends Node {
     node: Node;
@@ -14,3 +15,12 @@ export default class VarNode extends Node {
     mul(...params: Node[]): this;
     div(...params: Node[]): this;
 }
+
+export const temp: (node: NodeRepresentation, name?: string | null) => ShaderNodeObject<VarNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        temp: typeof temp;
+        toVar: typeof temp;
+    }
+}

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

@@ -1,4 +1,5 @@
 import Node from './Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class VaryingNode extends Node {
     node: Node;
@@ -6,3 +7,11 @@ export default class VaryingNode extends Node {
 
     constructor(node: Node, name?: string | null);
 }
+
+export const varying: (node: NodeRepresentation, name?: string) => ShaderNodeObject<VaryingNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        varying: typeof varying;
+    }
+}

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

@@ -1,21 +1,27 @@
-import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from '../../../../src/Three.js';
+export enum NodeShaderStage {
+    VERTEX = 'vertex',
+    FRAGMENT = 'fragment',
+}
 
-// disable automatic export, we have some private declarations
-export const NodeShaderStage: {
-    VERTEX: 'vertex';
-    FRAGMENT: 'fragment';
-};
+export enum NodeUpdateType {
+    NONE = 'none',
+    FRAME = 'frame',
+    RENDER = 'render',
+    OBJECT = 'object',
+}
 
-export const NodeUpdateType: {
-    NONE: 'none';
-    FRAME: 'frame';
-    RENDER: 'render';
-    OBJECT: 'object';
-};
+export enum NodeType {
+    BOOLEAN = 'bool',
+    INTEGER = 'int',
+    FLOAT = 'float',
+    VECTOR2 = 'vec2',
+    VECTOR3 = 'vec3',
+    VECTOR4 = 'vec4',
+    MATRIX2 = 'mat2',
+    MATRIX3 = 'mat3',
+    MATRIX4 = 'mat4',
+}
 
-export type NodeValueOption = Color | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | boolean | number;
-export type NodeUpdateTypeOption = 'none' | 'frame' | 'object';
-export type NodeShaderStageOption = 'vertex' | 'fragment' | 'compute';
 export type NodeTypeOption =
     | 'bool'
     | 'int'
@@ -23,6 +29,7 @@ export type NodeTypeOption =
     | 'vec2'
     | 'vec3'
     | 'vec4'
+    | 'mat2'
     | 'mat3'
     | 'mat4'
     | 'code' /* CodeNode */
@@ -50,8 +57,15 @@ export type NodeTypeOption =
     | 'umat4'
     | 'bmat4';
 
-// can be defined with string template type in Typescript 4.1
-export type SwizzleOption = string;
+export type SwizzleCharacter = 'x' | 'y' | 'z' | 'w' | 'r' | 'g' | 'b' | 'a' | 's' | 't' | 'p' | 'q';
+
+export type SwizzleOption = Exclude<
+    | `${SwizzleCharacter}`
+    | `${SwizzleCharacter}${SwizzleCharacter}`
+    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`
+    | `${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}${SwizzleCharacter}`,
+    'abs' | 'sqrt'
+>;
 
 /** Should be the same type as Object3D.userData */
 export type NodeUserData = Record<string, any>;
@@ -63,14 +77,3 @@ export interface AnyObject {
 
 /** a generic JSON type, used by nodes only */
 export type AnyJson = any;
-
-export const NodeType: {
-    BOOLEAN: 'bool';
-    INTEGER: 'int';
-    FLOAT: 'float';
-    VECTOR2: 'vec2';
-    VECTOR3: 'vec3';
-    VECTOR4: 'vec4';
-    MATRIX3: 'mat3';
-    MATRIX4: 'mat4';
-};

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

@@ -0,0 +1,25 @@
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import TextureNode from '../accessors/TextureNode.js';
+import UniformNode from '../core/UniformNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class AfterImageNode extends TempNode {
+    textureNode: TextureNode;
+    textureNodeOld: Node;
+    damp: UniformNode<number>;
+
+    constructor(textureNode: Node, damp?: number);
+
+    getTextureNode(): TextureNode;
+
+    setSize(width: number, height: number): void;
+}
+
+export const afterImage: (node: Node, damp?: number) => ShaderNodeObject<AfterImageNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        afterImage: typeof afterImage;
+    }
+}

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

@@ -0,0 +1,32 @@
+import { Vector2 } from '../../../../src/Three.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class AnamorphicNode extends TempNode {
+    textureNode: TextureNode;
+    thresholdNode: Node;
+    scaleNode: Node;
+    samples: number;
+    resolution: Vector2;
+
+    constructor(textureNode: TextureNode, thresholdNode: Node, scaleNode: Node, samples: number);
+
+    getTextureNode(): TextureNode;
+
+    setSize(width: number, height: number): void;
+}
+
+export const anamorphic: (
+    node: TextureNode,
+    threshold?: NodeRepresentation,
+    scale?: NodeRepresentation,
+    samples?: NodeRepresentation,
+) => ShaderNodeObject<AnamorphicNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        anamorphic: typeof anamorphic;
+    }
+}

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

@@ -1,14 +1,15 @@
 import TempNode from '../core/TempNode.js';
-import { ShaderNode } from '../shadernode/ShaderNodeBaseElements.js';
-import { Node } from '../Nodes.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNode, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { JoinNode } from '../Nodes.js';
 
-export const BurnNode: ShaderNode<{ base: Node; blendNode: Node }>;
+export const BurnNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
 
-export const DodgeNode: ShaderNode<{ base: Node; blendNode: Node }>;
+export const DodgeNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
 
-export const ScreenNode: ShaderNode<{ base: Node; blendNode: Node }>;
+export const ScreenNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
 
-export const OverlayNode: ShaderNode<{ base: Node; blendNode: Node }>;
+export const OverlayNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
 
 export type BlendMode =
     | typeof BlendModeNode.BURN
@@ -30,3 +31,17 @@ export default class BlendModeNode extends TempNode {
 
     setup(): Node;
 }
+
+export const burn: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
+export const dodge: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
+export const overlay: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
+export const screen: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        burn: typeof burn;
+        dodge: typeof dodge;
+        overlay: typeof overlay;
+        screen: typeof screen;
+    }
+}

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

@@ -1,5 +1,6 @@
 import TempNode from '../core/TempNode.js';
-import { Node } from '../Nodes.js';
+import MathNode from '../math/MathNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type ColorAdjustmentMethod =
     | typeof ColorAdjustmentNode.SATURATION
@@ -18,3 +19,30 @@ export default class ColorAdjustmentNode extends TempNode {
 
     constructor(method: ColorAdjustmentMethod, colorNode: Node, adjustmentNode?: Node);
 }
+
+export const saturation: (
+    colorNode: NodeRepresentation,
+    adjustmentNode?: NodeRepresentation,
+) => ShaderNodeObject<ColorAdjustmentNode>;
+export const vibrance: (
+    colorNode: NodeRepresentation,
+    adjustmentNode?: NodeRepresentation,
+) => ShaderNodeObject<ColorAdjustmentNode>;
+export const hue: (
+    colorNode: NodeRepresentation,
+    adjustmentNode?: NodeRepresentation,
+) => ShaderNodeObject<ColorAdjustmentNode>;
+
+export const lumaCoeffs: ShaderNodeObject<MathNode>;
+export const luminance: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+export const threshold: (color: NodeRepresentation, thershold: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        saturation: typeof saturation;
+        vibrance: typeof vibrance;
+        hue: typeof hue;
+        threshold: typeof threshold;
+    }
+}

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

@@ -1,5 +1,7 @@
+import { ColorSpace } from '../../../../src/Three.js';
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type ColorSpaceNodeMethod =
     | typeof ColorSpaceNode.LINEAR_TO_LINEAR
@@ -16,3 +18,18 @@ export default class ColorSpaceNode extends TempNode {
 
     constructor(method: ColorSpaceNodeMethod | null, node: Node);
 }
+
+export const linearToColorSpace: (node: NodeRepresentation, colorSpace: ColorSpace) => ShaderNodeObject<ColorSpaceNode>;
+export const colorSpaceToLinear: (node: NodeRepresentation, colorSpace: ColorSpace) => ShaderNodeObject<ColorSpaceNode>;
+
+export const linearTosRGB: (node: NodeRepresentation) => ShaderNodeObject<ColorSpaceNode>;
+export const sRGBToLinear: (node: NodeRepresentation) => ShaderNodeObject<ColorSpaceNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        linearTosRGB: typeof linearTosRGB;
+        sRGBToLinear: typeof sRGBToLinear;
+        linearToColorSpace: typeof linearToColorSpace;
+        colorSpaceToLinear: typeof colorSpaceToLinear;
+    }
+}

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

@@ -1,6 +1,10 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FrontFacingNode extends Node {
     isFrontFacingNode: true;
     constructor();
 }
+
+export const frontFacing: ShaderNodeObject<FrontFacingNode>;
+export const faceDirection: ShaderNodeObject<Node>;

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

@@ -0,0 +1,28 @@
+import { Vector2 } from '../../../../src/Three.js';
+import TempNode from '../core/TempNode.js';
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class GaussianBlurNode extends TempNode {
+    textureNode: TextureNode;
+    sigma: number;
+
+    directionNode: Node;
+
+    resolution: Vector2;
+
+    constructor(textureNode: TextureNode, sigma?: number);
+
+    setSize(width: number, height: number): void;
+
+    getTextureNode(): TextureNode;
+}
+
+export const gaussianBlur: (node: NodeRepresentation, sigma?: number) => ShaderNodeObject<GaussianBlurNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        gaussianBlur: typeof gaussianBlur;
+    }
+}

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

@@ -1,6 +1,8 @@
-import TempNode from '../core/TempNode.js';
 import { NormalMapTypes } from '../../../../src/Three.js';
+import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
+import MathNode from '../math/MathNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class NormalMapNode extends TempNode {
     node: Node;
@@ -10,3 +12,13 @@ export default class NormalMapNode extends TempNode {
 
     constructor(node: Node, scaleNode?: Node | null);
 }
+
+export const normalMap: (node: Node, scaleNode?: Node) => ShaderNodeObject<NormalMapNode>;
+
+export const TBNViewMatrix: ShaderNodeObject<MathNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        normalMap: typeof normalMap;
+    }
+}

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

@@ -0,0 +1,44 @@
+import { Camera, RenderTarget, Scene, Texture } from '../../../../src/Three.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import TempNode from '../core/TempNode.js';
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+
+declare class PassTextureNode extends TextureNode {
+    passNode: PassNode;
+
+    constructor(passNode: PassNode, texture: Texture);
+}
+
+export default class PassNode extends TempNode {
+    scope: PassNodeScope;
+    scene: Scene;
+    camera: Camera;
+
+    renderTarget: RenderTarget;
+
+    readonly isPassNode: true;
+
+    constructor(scope: PassNodeScope, scene: Scene, camera: Camera);
+
+    getTextureNode(): ShaderNodeObject<PassTextureNode>;
+
+    getTextureDepthNode(): ShaderNodeObject<PassTextureNode>;
+
+    getDepthNode(): ShaderNodeObject<Node>;
+
+    setSize(width: number, height: number): void;
+
+    setPixelRatio(pixelRatio: number): void;
+
+    dispose(): void;
+
+    static COLOR: 'color';
+    static DEPTH: 'depth';
+}
+
+export type PassNodeScope = typeof PassNode.COLOR | typeof PassNode.DEPTH;
+
+export const pass: (scene: Scene, camera: Camera) => ShaderNodeObject<PassNode>;
+export const texturePass: (pass: PassNode, texture: Texture) => ShaderNodeObject<PassTextureNode>;
+export const depthPass: (scene: Scene, camera: Camera) => ShaderNodeObject<PassNode>;

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

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class PosterizeNode extends Node {
     sourceNode: Node;
@@ -6,3 +7,14 @@ export default class PosterizeNode extends Node {
 
     constructor(sourceNode: Node, stepsNode: Node);
 }
+
+export const posterize: (
+    sourceNode: NodeRepresentation,
+    stepsNode: NodeRepresentation,
+) => ShaderNodeObject<PosterizeNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        posterize: typeof posterize;
+    }
+}

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

@@ -1,6 +1,7 @@
+import { ToneMapping } from '../../../../src/Three.js';
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
-import { ToneMapping } from '../../../../src/Three.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 // exposure only
 export const LinearToneMappingNode: Node;
@@ -12,3 +13,9 @@ export default class ToneMappingNode extends TempNode {
 
     constructor(toneMapping: ToneMapping, exposureNode?: Node, colorNode?: Node | null);
 }
+
+export const toneMapping: (
+    mapping: ToneMapping,
+    exposure: NodeRepresentation,
+    color?: NodeRepresentation,
+) => ShaderNodeObject<ToneMappingNode>;

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

@@ -0,0 +1,32 @@
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class ViewportDepthNode extends Node {
+    scope: ViewportDepthNodeScope;
+    valueNode: Node;
+
+    readonly isViewportDepthNode: true;
+
+    constructor(scope: ViewportDepthNodeScope, valueNode?: Node | null);
+
+    static DEPTH: 'depth';
+    static DEPTH_TEXTURE: 'depthTexture';
+    static DEPTH_PIXEL: 'depthPixel';
+}
+
+export type ViewportDepthNodeScope =
+    | typeof ViewportDepthNode.DEPTH
+    | typeof ViewportDepthNode.DEPTH_TEXTURE
+    | typeof ViewportDepthNode.DEPTH_PIXEL;
+
+export const viewZToOrthographicDepth: (viewZ: Node, near: Node, far: Node) => Node;
+
+export const orthographicDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
+
+export const viewZToPerspectiveDepth: (viewZ: Node, near: Node, far: Node) => Node;
+
+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>;

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

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type ViewportNodeScope =
     | typeof ViewportNode.COORDINATE
@@ -21,3 +22,10 @@ export default class ViewportNode extends Node {
 
     constructor(scope: ViewportNodeScope);
 }
+
+export const viewportCoordinate: ShaderNodeObject<ViewportNode>;
+export const viewportResolution: ShaderNodeObject<ViewportNode>;
+export const viewportTopLeft: ShaderNodeObject<ViewportNode>;
+export const viewportBottomLeft: ShaderNodeObject<ViewportNode>;
+export const viewportTopRight: ShaderNodeObject<ViewportNode>;
+export const viewportBottomRight: ShaderNodeObject<ViewportNode>;

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

@@ -0,0 +1,18 @@
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import ViewportTextureNode from './ViewportTextureNode.js';
+
+export default class ViewportSharedTextureNode extends ViewportTextureNode {
+    constructor(uvNode?: Node, levelNode?: Node | null);
+}
+
+export const viewportSharedTexture: (
+    uvNode?: Node,
+    levelNode?: Node | null,
+) => ShaderNodeObject<ViewportSharedTextureNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        viewportSharedTexture: typeof viewportSharedTexture;
+    }
+}