@types/three 0.166.0 → 0.167.0

three/{examples/jsm → src}/nodes/core/LightingModel.d.ts

@@ -13,7 +13,6 @@ export interface LightingModelDirectInput {
     lightDirection: Node;
     lightColor: Node;
     reflectedLight: LightingModelReflectedLight;
-    shadowMask: Node;
 }
 
 export interface LightingModelDirectRectAreaInput {
@@ -42,7 +41,6 @@ export default class LightingModel {
     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;
+    indirect(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
     ambientOcclusion(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
 }

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

@@ -0,0 +1,19 @@
+import { Node } from "../Nodes.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import OutputStructNode from "./OutputStructNode.js";
+
+declare class MRTNode extends OutputStructNode {
+    outputNodes: { [name: string]: Node };
+
+    readonly isMRTNode: true;
+
+    constructor(outputNodes: { [name: string]: Node });
+
+    getNode(name: string): Node;
+
+    merge(mrtNode: MRTNode): ShaderNodeObject<MRTNode>;
+}
+
+export default MRTNode;
+
+export const mrt: (outputNodes: { [name: string]: Node }) => ShaderNodeObject<MRTNode>;

three/{examples/jsm → src}/nodes/core/Node.d.ts

@@ -1,4 +1,4 @@
-import { EventDispatcher } from "three";
+import { EventDispatcher } from "../../core/EventDispatcher.js";
 import { NodeUpdateType } from "./constants.js";
 import NodeBuilder from "./NodeBuilder.js";
 import NodeFrame from "./NodeFrame.js";
@@ -27,7 +27,7 @@ interface NodeJSONInputNodes {
         | string
         | undefined;
 }
-interface NodeJSONInputData {
+export interface NodeJSONInputData {
     inputNodes?: NodeJSONInputNodes | undefined;
     meta: {
         textures: {
@@ -38,13 +38,7 @@ interface NodeJSONInputData {
         };
     };
 }
-interface NodeJSONInputData {
-    uuid: string;
-    type: string | undefined;
-    metadata?: NodeJSONMetadata;
-    inputNodes?: NodeJSONInputNodes | undefined;
-}
-interface NodeJSONIntermediateOutputData {
+export interface NodeJSONIntermediateOutputData {
     uuid: string;
     type: string | undefined;
     meta?: NodeJSONMeta | undefined;
@@ -101,7 +95,6 @@ declare class Node extends EventDispatcher<{
     getNodeType(builder: NodeBuilder): string | null;
     getShared(builder: NodeBuilder): Node;
     setup(builder: NodeBuilder): unknown;
-    construct(builder: NodeBuilder): unknown;
     increaseUsage(builder: NodeBuilder): number;
     analyze(builder: NodeBuilder): void;
     generate(builder: NodeBuilder, output?: string | null): string | null | undefined;

three/{examples/jsm → src}/nodes/core/NodeBuilder.d.ts

@@ -1,4 +1,8 @@
-import { BufferGeometry, Material, Object3D, Renderer, Texture } from "three";
+import { BufferGeometry } from "../../core/BufferGeometry.js";
+import { Object3D } from "../../core/Object3D.js";
+import { Material } from "../../materials/Material.js";
+import Renderer from "../../renderers/common/Renderer.js";
+import { Texture } from "../../textures/Texture.js";
 import FogNode from "../fog/FogNode.js";
 import LightsNode from "../lighting/LightsNode.js";
 import { NodeShaderStage } from "./constants.js";
@@ -73,6 +77,8 @@ export default abstract class NodeBuilder {
 
     abstract getInstanceIndex(): string;
 
+    abstract getDrawIndex(): string | null;
+
     abstract getFrontFacing(): string;
 
     abstract getFragCoord(): string;

three/{examples/jsm → src}/nodes/core/NodeCache.d.ts

@@ -1,4 +1,5 @@
-import { BufferAttribute, InterleavedBuffer, TypedArray } from "three";
+import { BufferAttribute, TypedArray } from "../../core/BufferAttribute.js";
+import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
 import BufferAttributeNode from "../accessors/BufferAttributeNode.js";
 import Node from "./Node.js";
 import NodeAttribute from "./NodeAttribute.js";

three/{examples/jsm → src}/nodes/core/NodeFrame.d.ts

@@ -1,5 +1,8 @@
-import { Camera, Material, Object3D, Renderer, Scene } from "three";
-
+import { Camera } from "../../cameras/Camera.js";
+import { Object3D } from "../../core/Object3D.js";
+import { Material } from "../../materials/Material.js";
+import Renderer from "../../renderers/common/Renderer.js";
+import { Scene } from "../../scenes/Scene.js";
 import Node from "./Node.js";
 
 export default class NodeFrame {

three/{examples/jsm → src}/nodes/core/NodeUtils.d.ts

@@ -1,4 +1,9 @@
-import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from "three";
+import { Color } from "../../math/Color.js";
+import { Matrix3 } from "../../math/Matrix3.js";
+import { Matrix4 } from "../../math/Matrix4.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Vector3 } from "../../math/Vector3.js";
+import { Vector4 } from "../../math/Vector4.js";
 import Node from "./Node.js";
 
 export interface NodeChild {

three/{examples/jsm → src}/nodes/core/PropertyNode.d.ts

@@ -14,6 +14,7 @@ export const property: (type?: string | null, name?: string | null) => ShaderNod
 export const varyingProperty: (type?: string | null, name?: string | null) => ShaderNodeObject<PropertyNode>;
 
 export const diffuseColor: ShaderNodeObject<PropertyNode>;
+export const emissive: ShaderNodeObject<PropertyNode>;
 export const roughness: ShaderNodeObject<PropertyNode>;
 export const metalness: ShaderNodeObject<PropertyNode>;
 export const clearcoat: ShaderNodeObject<PropertyNode>;

three/{examples/jsm → src}/nodes/display/AnamorphicNode.d.ts

@@ -1,4 +1,4 @@
-import { Vector2 } from "three";
+import { Vector2 } from "../../math/Vector2.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";

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

@@ -0,0 +1,35 @@
+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";
+
+declare class BloomNode extends TempNode {
+    inputNode: Node;
+    strength: UniformNode<number>;
+    radius: UniformNode<number>;
+    threshold: UniformNode<number>;
+
+    smoothWidth: UniformNode<number>;
+
+    constructor(inputNode: Node, strength?: number, radius?: number, threshold?: number);
+
+    getTexture(): ShaderNodeObject<TextureNode>;
+
+    setSize(width: number, height: number): void;
+}
+
+export const bloom: (
+    node: NodeRepresentation,
+    strength?: number,
+    radius?: number,
+    threshold?: number,
+) => ShaderNodeObject<BloomNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        bloom: typeof bloom;
+    }
+}
+
+export default BloomNode;

three/{examples/jsm → src}/nodes/display/ColorAdjustmentNode.d.ts

@@ -33,7 +33,6 @@ export const hue: (
     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>;

three/{examples/jsm → src}/nodes/display/ColorSpaceNode.d.ts

@@ -1,4 +1,4 @@
-import { ColorSpace } from "three";
+import { ColorSpace } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";

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

@@ -0,0 +1,38 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Matrix4 } from "../../math/Matrix4.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";
+
+declare class DenoiseNode extends TempNode {
+    textureNode: Node;
+    depthNode: Node;
+    normalNode: Node;
+    noiseNode: Node;
+
+    cameraProjectionMatrixInversion: UniformNode<Matrix4>;
+    lumaPhi: UniformNode<number>;
+    depthPhi: UniformNode<number>;
+    normalPhi: UniformNode<number>;
+    radius: UniformNode<number>;
+    index: UniformNode<number>;
+
+    constructor(textureNode: Node, depthNode: Node, normalNode: Node, noiseNode: Node, camera: Camera);
+}
+
+export const denoise: (
+    node: NodeRepresentation,
+    depthNode: NodeRepresentation,
+    normalNode: NodeRepresentation,
+    noiseNode: NodeRepresentation,
+    camera: Camera,
+) => ShaderNodeObject<DenoiseNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        denoise: typeof denoise;
+    }
+}
+
+export default DenoiseNode;

three/{examples/jsm → src}/nodes/display/DepthOfFieldNode.d.ts

@@ -12,15 +12,15 @@ export default class DepthOfFieldNode extends TempNode {
     aperture: UniformNode<number>;
     maxblur: UniformNode<number>;
 
-    constructor(textureNode: TextureNode, viewZNode: Node, focus?: number, aperture?: number, maxblur?: number);
+    constructor(textureNode: TextureNode, viewZNode: Node, focusNode: Node, apertureNode: Node, maxblurNode: Node);
 }
 
 export const dof: (
     node: NodeRepresentation,
     viewZNode: NodeRepresentation,
-    focus?: number,
-    aperture?: number,
-    maxblur?: number,
+    focus?: NodeRepresentation,
+    aperture?: NodeRepresentation,
+    maxblur?: NodeRepresentation,
 ) => ShaderNodeObject<DepthOfFieldNode>;
 
 declare module "../shadernode/ShaderNode.js" {

three/{examples/jsm → src}/nodes/display/DotScreenNode.d.ts

@@ -1,21 +1,16 @@
-import { Vector2 } from "three";
-import TextureNode from "../accessors/TextureNode.js";
+import { Vector2 } from "../../math/Vector2.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;
+    inputNode: 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;
+    constructor(inputNode: Node, center?: Vector2, angle?: number, scale?: number);
 }
 
 export const dotScreen: (

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

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

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

@@ -0,0 +1,25 @@
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+declare class FilmNode extends TempNode {
+    inputNode: Node;
+    intensityNode: Node | null;
+    uvNode: Node | null;
+
+    constructor(inputNode: Node, intensityNode?: Node | null, uvNode?: Node | null);
+}
+
+export const film: (
+    inputNode: NodeRepresentation,
+    intensityNode?: NodeRepresentation | null,
+    uvNode?: NodeRepresentation | null,
+) => ShaderNodeObject<FilmNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        film: typeof film;
+    }
+}
+
+export default FilmNode;

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

@@ -0,0 +1,46 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Matrix4 } from "../../math/Matrix4.js";
+import { Vector2 } from "../../math/Vector2.js";
+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";
+
+declare class GTAONode extends TempNode {
+    depthNode: Node;
+    normalNode: Node;
+
+    radius: ShaderNodeObject<UniformNode<number>>;
+    resolution: ShaderNodeObject<UniformNode<Vector2>>;
+    thickness: ShaderNodeObject<UniformNode<number>>;
+    distanceExponent: ShaderNodeObject<UniformNode<number>>;
+    distanceFallOff: ShaderNodeObject<UniformNode<number>>;
+    scale: ShaderNodeObject<UniformNode<number>>;
+    noiseNode: ShaderNodeObject<TextureNode>;
+
+    cameraProjectionMatrix: ShaderNodeObject<UniformNode<Matrix4>>;
+    cameraProjectionMatrixInverse: ShaderNodeObject<UniformNode<Matrix4>>;
+
+    SAMPLES: ShaderNodeObject<UniformNode<number>>;
+
+    constructor(depthNode: Node, normalNode: Node, camera: Camera);
+
+    getTextureNode(): ShaderNodeObject<TextureNode>;
+
+    setSize(width: number, height: number): void;
+}
+
+export const ao: (
+    depthNode: NodeRepresentation,
+    normalNode: NodeRepresentation,
+    camera: Camera,
+) => ShaderNodeObject<GTAONode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        ao: typeof ao;
+    }
+}
+
+export default GTAONode;

three/{examples/jsm → src}/nodes/display/GaussianBlurNode.d.ts

@@ -1,4 +1,4 @@
-import { Vector2 } from "three";
+import { Vector2 } from "../../math/Vector2.js";
 import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
@@ -6,20 +6,23 @@ import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.j
 
 export default class GaussianBlurNode extends TempNode {
     textureNode: TextureNode;
+    directionNode: Node | null;
     sigma: number;
 
-    directionNode: Node;
-
     resolution: Vector2;
 
-    constructor(textureNode: TextureNode, sigma?: number);
+    constructor(textureNode: TextureNode, directionNode?: Node | null, sigma?: number);
 
     setSize(width: number, height: number): void;
 
     getTextureNode(): TextureNode;
 }
 
-export const gaussianBlur: (node: NodeRepresentation, sigma?: number) => ShaderNodeObject<GaussianBlurNode>;
+export const gaussianBlur: (
+    node: NodeRepresentation,
+    directionNode?: NodeRepresentation | null,
+    sigma?: number,
+) => ShaderNodeObject<GaussianBlurNode>;
 
 declare module "../shadernode/ShaderNode.js" {
     interface NodeElements {

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

@@ -0,0 +1,30 @@
+import { Data3DTexture } from "../../textures/Data3DTexture.js";
+import Texture3DNode from "../accessors/Texture3DNode.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";
+
+declare class Lut3DNode extends TempNode {
+    inputNode: Node;
+    lutNode: Texture3DNode;
+    size: ShaderNodeObject<UniformNode<number>>;
+    intensityNode: UniformNode<number>;
+
+    constructor(inputNode: Node, lutNode: UniformNode<Data3DTexture>, size: number, intensityNode: UniformNode<number>);
+}
+
+export const lut3D: (
+    node: NodeRepresentation,
+    lut: NodeRepresentation,
+    size: number,
+    intensity: NodeRepresentation,
+) => ShaderNodeObject<Lut3DNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        lut3D: typeof lut3D;
+    }
+}
+
+export default Lut3DNode;

three/{examples/jsm → src}/nodes/display/NormalMapNode.d.ts

@@ -1,7 +1,6 @@
-import { NormalMapTypes } from "three";
+import { NormalMapTypes } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import MathNode from "../math/MathNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class NormalMapNode extends TempNode {

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

@@ -0,0 +1,62 @@
+import { Camera } from "../../cameras/Camera.js";
+import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
+import { Scene } from "../../scenes/Scene.js";
+import { Texture } from "../../textures/Texture.js";
+import TextureNode from "../accessors/TextureNode.js";
+import MRTNode from "../core/MRTNode.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+declare class PassTextureNode extends TextureNode {
+    passNode: PassNode;
+
+    constructor(passNode: PassNode, texture: Texture);
+}
+
+declare class PassMultipleTextureNode extends PassTextureNode {
+    textureName: string;
+
+    constructor(passNode: PassNode, textureName: string);
+}
+
+declare class PassNode extends TempNode {
+    scope: PassNodeScope;
+    scene: Scene;
+    camera: Camera;
+
+    renderTarget: RenderTarget;
+
+    readonly isPassNode: true;
+
+    constructor(scope: PassNodeScope, scene: Scene, camera: Camera, options?: RenderTargetOptions);
+
+    setMRT(mrt: MRTNode | null): this;
+
+    getMRT(): MRTNode | null;
+
+    getTexture(name: string): Texture;
+
+    getTextureNode(name?: string): ShaderNodeObject<Node>;
+
+    getViewZNode(name?: string): ShaderNodeObject<Node>;
+
+    getLinearDepthNode(name?: string): 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 default PassNode;
+
+export const pass: (scene: Scene, camera: Camera, options?: RenderTargetOptions) => ShaderNodeObject<PassNode>;
+export const passTexture: (pass: PassNode, texture: Texture) => ShaderNodeObject<PassTextureNode>;
+export const depthPass: (scene: Scene, camera: Camera) => ShaderNodeObject<PassNode>;

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

@@ -0,0 +1,67 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Scene } from "../../scenes/Scene.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";
+import PassNode from "./PassNode.js";
+
+declare class PixelationNode extends TempNode {
+    textureNode: Node;
+    depthNode: Node;
+    normalNode: Node;
+
+    pixelSize: Node;
+    normalEdgeStrength: Node;
+    depthEdgeStrength: Node;
+
+    constructor(
+        textureNode: Node,
+        depthNode: Node,
+        normalNode: Node,
+        pixelSize: Node,
+        normalEdgeStrength: Node,
+        depthEdgeStrength: Node,
+    );
+}
+
+declare const pixelation: (
+    node: NodeRepresentation,
+    depthNode: NodeRepresentation,
+    normalNode: NodeRepresentation,
+    pixelSize?: number,
+    normalEdgeStrength?: number,
+    depthEdgeStrength?: number,
+) => ShaderNodeObject<PixelationNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        pixelation: typeof pixelation;
+    }
+}
+
+declare class PixelationPassNode extends PassNode {
+    pixelSize: UniformNode<number>;
+    normalEdgeStrength: UniformNode<number>;
+    depthEdgeStrength: UniformNode<number>;
+
+    readonly isPixelationPassNode: true;
+
+    constructor(
+        scene: Scene,
+        camera: Camera,
+        pixelSize: number,
+        normalEdgeStrength: number,
+        depthEdgeStrength: number,
+    );
+}
+
+export const pixelationPass: (
+    scene: Scene,
+    camera: Camera,
+    pixelSize: UniformNode<number>,
+    normalEdgeStrength: UniformNode<number>,
+    depthEdgeStrength: UniformNode<number>,
+) => ShaderNodeObject<PixelationPassNode>;
+
+export default PixelationPassNode;

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

@@ -0,0 +1,28 @@
+import { ColorSpace, ToneMapping } from "../../constants.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+declare class RenderOutputNode extends TempNode {
+    colorNode: Node;
+    toneMapping: ToneMapping | null;
+    outputColorSpace: ColorSpace | null;
+
+    readonly isRenderOutput: true;
+
+    constructor(colorNode: Node, toneMapping?: ToneMapping | null, outputColorSpace?: ColorSpace | null);
+}
+
+export default RenderOutputNode;
+
+export const renderOutput: (
+    color: NodeRepresentation,
+    toneMapping?: ToneMapping | null,
+    outputColorSpace?: ColorSpace | null,
+) => ShaderNodeObject<RenderOutputNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        renderOutput: typeof renderOutput;
+    }
+}

three/{examples/jsm → src}/nodes/display/ToneMappingNode.d.ts

@@ -1,4 +1,4 @@
-import { ToneMapping } from "three";
+import { ToneMapping } from "../../constants.js";
 import RendererReferenceNode from "../accessors/RendererReferenceNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";

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

@@ -0,0 +1,41 @@
+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";
+
+declare class TransitionNode extends TempNode {
+    textureNodeA: TextureNode;
+    textureNodeB: TextureNode;
+    mixTextureNode: TextureNode;
+
+    mixRatioNode: Node;
+    thresholdNode: Node;
+    useTextureNode: Node;
+
+    constructor(
+        textureNodeA: TextureNode,
+        textureNodeB: TextureNode,
+        mixTextureNode: TextureNode,
+        mixRatioNode: Node,
+        thresholdNode: Node,
+        useTextureNode: Node,
+    );
+}
+
+export const transition: (
+    node: NodeRepresentation,
+    nodeB: NodeRepresentation,
+    mixTexture: NodeRepresentation,
+    mixRatio: UniformNode<number>,
+    threshold: UniformNode<number>,
+    useTexture: UniformNode<number>,
+) => ShaderNodeObject<TransitionNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        transition: typeof transition;
+    }
+}
+
+export default TransitionNode;

three/{examples/jsm → src}/nodes/display/ViewportTextureNode.d.ts

@@ -1,4 +1,4 @@
-import { FramebufferTexture } from "three";
+import { FramebufferTexture } from "../../textures/FramebufferTexture.js";
 import TextureNode from "../accessors/TextureNode.js";
 import { NodeUpdateType } from "../core/constants.js";
 import Node from "../core/Node.js";