@types/three 0.165.0 → 0.167.0

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

@@ -8,13 +8,14 @@ export { bypass, default as BypassNode } from "./core/BypassNode.js";
 export { cache, default as CacheNode } from "./core/CacheNode.js";
 export { default as ConstNode } from "./core/ConstNode.js";
 export { context, default as ContextNode, label } from "./core/ContextNode.js";
-export { default as IndexNode, IndexNodeScope, instanceIndex, vertexIndex } from "./core/IndexNode.js";
+export { default as IndexNode, drawIndex, IndexNodeScope, instanceIndex, vertexIndex } from "./core/IndexNode.js";
 export {
     default as LightingModel,
     LightingModelDirectInput,
     LightingModelIndirectInput,
     LightingModelReflectedLight,
 } from "./core/LightingModel.js";
+export { default as MRTNode, mrt } from "./core/MRTNode.js";
 export { default as Node } from "./core/Node.js";
 export { default as NodeAttribute } from "./core/NodeAttribute.js";
 export { default as NodeBuilder } from "./core/NodeBuilder.js";
@@ -37,6 +38,7 @@ export {
     dashSize,
     default as PropertyNode,
     diffuseColor,
+    emissive,
     gapSize,
     iridescence,
     iridescenceIOR,
@@ -54,6 +56,13 @@ export {
 } from "./core/PropertyNode.js";
 export { default as StackNode } from "./core/StackNode.js";
 export { default as TempNode } from "./core/TempNode.js";
+export {
+    default as UniformGroupNode,
+    frameGroup,
+    objectGroup,
+    renderGroup,
+    uniformGroup,
+} from "./core/UniformGroupNode.js";
 export { default as UniformNode, uniform } from "./core/UniformNode.js";
 export { default as VarNode, temp } from "./core/VarNode.js";
 export { default as VaryingNode, varying } from "./core/VaryingNode.js";
@@ -115,6 +124,7 @@ export {
     pow3,
     pow4,
     radians,
+    rand,
     reciprocal,
     reflect,
     refract,
@@ -127,6 +137,7 @@ export {
     step,
     tan,
     transformDirection,
+    transpose,
     trunc,
 } from "./math/MathNode.js";
 
@@ -164,16 +175,18 @@ 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";
 export { default as MaxMipLevelNode, maxMipLevel } from "./utils/MaxMipLevelNode.js";
 export { default as OscNode, OscNodeMethod, oscSawtooth, oscSine, oscSquare, oscTriangle } from "./utils/OscNode.js";
+export { colorToDirection, default as PackingNode, directionToColor } from "./utils/PackingNode.js";
 export { default as ReflectorNode, reflector, ReflectorNodeParameters } from "./utils/ReflectorNode.js";
 export { default as RemapNode, remap, remapClamp } from "./utils/RemapNode.js";
 export { default as RotateNode, rotate } from "./utils/RotateNode.js";
 export { default as RotateUVNode, rotateUV } from "./utils/RotateUVNode.js";
+export { default as RTTNode, rtt, RTTNodeOptions } from "./utils/RTTNode.js";
 export { default as SplitNode } from "./utils/SplitNode.js";
 export { default as SpriteSheetUVNode, spritesheetUV } from "./utils/SpriteSheetUVNode.js";
 export { default as StorageArrayElementNode } from "./utils/SpriteSheetUVNode.js";
@@ -207,6 +220,7 @@ export {
     materialAlphaTest,
     materialAnisotropy,
     materialAnisotropyVector,
+    materialAOMap,
     materialClearcoat,
     materialClearcoatNormal,
     materialClearcoatRoughness,
@@ -216,6 +230,7 @@ export {
     materialIridescence,
     materialIridescenceIOR,
     materialIridescenceThickness,
+    materialLightMap,
     materialLineDashOffset,
     materialLineDashSize,
     materialLineGapSize,
@@ -264,8 +279,9 @@ export * from "./accessors/PositionNode.js";
 export { default as ReferenceNode, reference, referenceBuffer } from "./accessors/ReferenceNode.js";
 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 SkinningNode, skinning, skinningReference } 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";
@@ -279,11 +295,11 @@ export { default as VertexColorNode, vertexColor } from "./accessors/VertexColor
 export { afterImage, default as AfterImageNode } from "./display/AfterImageNode.js";
 export { anamorphic, default as AnamorphicNode } from "./display/AnamorphicNode.js";
 export { BlendMode, burn, default as BlendModeNode, dodge, overlay, screen } from "./display/BlendModeNode.js";
+export { bloom, default as BloomNode } from "./display/BloomNode.js";
 export {
     ColorAdjustmentMethod,
     default as ColorAdjustmentNode,
     hue,
-    lumaCoeffs,
     luminance,
     saturation,
     threshold,
@@ -297,19 +313,31 @@ export {
     linearTosRGB,
     sRGBToLinear,
 } from "./display/ColorSpaceNode.js";
+export { default as DenoiseNode, denoise } from "./display/DenoiseNode.js";
+export { default as DepthOfFieldNode, dof } from "./display/DepthOfFieldNode.js";
+export { default as DotScreenNode, dotScreen } from "./display/DotScreenNode.js";
+export { default as FilmNode, film } from "./display/FilmNode.js";
 export { default as FrontFacingNode, faceDirection, frontFacing } from "./display/FrontFacingNode.js";
+export { default as FXAANode, fxaa } from "./display/FXAANode.js";
 export { default as GaussianBlurNode, gaussianBlur } from "./display/GaussianBlurNode.js";
+export { ao, default as GTAONode } from "./display/GTAONode.js";
+export { default as Lut3DNode, lut3D } from "./display/Lut3DNode.js";
 export { default as NormalMapNode, normalMap } from "./display/NormalMapNode.js";
+export { default as PixelationPassNode, pixelationPass } from "./display/PixelationPassNode.js";
 export { default as PosterizeNode, posterize } from "./display/PosterizeNode.js";
+export { default as RenderOutputNode, renderOutput } from "./display/RenderOutputNode.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 TransitionNode, transition } from "./display/TransitionNode.js";
 export {
     default as ViewportDepthNode,
     depth,
-    depthPixel,
-    depthTexture,
+    linearDepth,
     orthographicDepthToViewZ,
     perspectiveDepthToViewZ,
     ViewportDepthNodeScope,
+    viewportLinearDepth,
     viewZToOrthographicDepth,
     viewZToPerspectiveDepth,
 } from "./display/ViewportDepthNode.js";
@@ -326,7 +354,7 @@ export {
 export { default as ViewportSharedTextureNode, viewportSharedTexture } from "./display/ViewportSharedTextureNode.js";
 export { default as ViewportTextureNode, viewportMipTexture, viewportTexture } from "./display/ViewportTextureNode.js";
 
-export { default as PassNode, depthPass, pass, PassNodeScope, texturePass } from "./display/PassNode.js";
+export { default as PassNode, depthPass, pass, PassNodeScope, passTexture } from "./display/PassNode.js";
 
 // code
 export { code, CodeNodeInclude, default as CodeNode, glsl, js, wgsl } from "./code/CodeNode.js";
@@ -348,6 +376,7 @@ export { compute, default as ComputeNode } from "./gpgpu/ComputeNode.js";
 // lighting
 export { default as AnalyticLightNode } from "./lighting/AnalyticLightNode.js";
 export { default as AONode } from "./lighting/AONode.js";
+export { default as BasicEnvironmentNode } from "./lighting/BasicEnvironmentNode.js";
 export { default as EnvironmentNode } from "./lighting/EnvironmentNode.js";
 export { default as HemisphereLightNode } from "./lighting/HemisphereLightNode.js";
 export { default as IrradianceNode } from "./lighting/IrradianceNode.js";
@@ -355,6 +384,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, RectAreaLightTexturesLib } from "./lighting/RectAreaLightNode.js";
 export { default as SpotLightNode } from "./lighting/SpotLightNode.js";
 
 // pmrem

three/{examples/jsm → src}/nodes/accessors/BatchNode.d.ts

@@ -1,4 +1,4 @@
-import { BatchedMesh } from "three";
+import { BatchedMesh } from "../../objects/BatchedMesh.js";
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 

three/{examples/jsm → src}/nodes/accessors/BufferAttributeNode.d.ts

@@ -1,4 +1,7 @@
-import { BufferAttribute, InterleavedBuffer, InterleavedBufferAttribute, TypedArray, Usage } from "three";
+import { Usage } from "../../constants.js";
+import { BufferAttribute, TypedArray } from "../../core/BufferAttribute.js";
+import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
+import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
 import InputNode from "../core/InputNode.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 declare class BufferAttributeNode extends InputNode<TypedArray | InterleavedBuffer | BufferAttribute> {
@@ -15,6 +18,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 → src}/nodes/accessors/CameraNode.d.ts

@@ -1,4 +1,6 @@
-import { Matrix3, Matrix4, Vector3 } from "three";
+import { Matrix3 } from "../../math/Matrix3.js";
+import { Matrix4 } from "../../math/Matrix4.js";
+import { Vector3 } from "../../math/Vector3.js";
 import UniformNode from "../core/UniformNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 

three/{examples/jsm → src}/nodes/accessors/CubeTextureNode.d.ts

@@ -1,22 +1,30 @@
-import { CubeTexture } from "three";
+import { CubeTexture } from "../../textures/CubeTexture.js";
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import TextureNode from "./TextureNode.js";
 
-export default class CubeTextureNode extends TextureNode {
+declare class CubeTextureNode extends TextureNode {
     isCubeTextureNode: boolean;
     uvNode: ShaderNodeObject<Node> | null;
     levelNode: ShaderNodeObject<Node> | null;
 
-    constructor(value: CubeTexture, uvNode?: ShaderNodeObject<Node> | null, levelNode?: ShaderNodeObject<Node> | null);
+    constructor(
+        value: CubeTexture,
+        uvNode?: ShaderNodeObject<Node> | null,
+        levelNode?: ShaderNodeObject<Node> | null,
+        biasNode?: ShaderNodeObject<Node> | null,
+    );
 
     getDefaultUV(): Node;
 }
 
+export default CubeTextureNode;
+
 export const cubeTexture: (
     value: CubeTexture,
     uvNode?: NodeRepresentation,
     levelNode?: NodeRepresentation,
+    biasNode?: NodeRepresentation,
 ) => ShaderNodeObject<CubeTextureNode>;
 
 declare module "../shadernode/ShaderNode.js" {

three/{examples/jsm → src}/nodes/accessors/InstanceNode.d.ts

@@ -1,4 +1,4 @@
-import { InstancedMesh } from "three";
+import { InstancedMesh } from "../../objects/InstancedMesh.js";
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 

three/{examples/jsm → src}/nodes/accessors/MaterialNode.d.ts

@@ -1,4 +1,4 @@
-import { Vector2 } from "three";
+import { Vector2 } from "../../math/Vector2.js";
 import Node from "../core/Node.js";
 import UniformNode from "../core/UniformNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
@@ -38,7 +38,10 @@ export type MaterialNodeScope =
     | typeof MaterialNode.LINE_WIDTH
     | typeof MaterialNode.LINE_DASH_OFFSET
     | typeof MaterialNode.POINT_WIDTH
-    | typeof MaterialNode.DISPERSION;
+    | typeof MaterialNode.DISPERSION
+    | typeof MaterialNode.LIGHT_MAP
+    | typeof MaterialNode.AO_MAP
+    | typeof MaterialNode.REFRACTION_RATIO;
 
 export default class MaterialNode extends Node {
     static ALPHA_TEST: "alphaTest";
@@ -76,6 +79,9 @@ export default class MaterialNode extends Node {
     static LINE_DASH_OFFSET: "dashOffset";
     static POINT_WIDTH: "pointWidth";
     static DISPERSION: "dispersion";
+    static LIGHT_MAP: "light";
+    static AO_MAP: "ao";
+    static REFRACTION_RATIO: "refractionRatio";
 
     scope: MaterialNodeScope;
     constructor(scope?: MaterialNodeScope);
@@ -118,4 +124,7 @@ export const materialLineWidth: ShaderNodeObject<MaterialNode>;
 export const materialLineDashOffset: ShaderNodeObject<MaterialNode>;
 export const materialPointWidth: ShaderNodeObject<MaterialNode>;
 export const materialDispersion: ShaderNodeObject<MaterialNode>;
+export const materialLightMap: ShaderNodeObject<MaterialNode>;
+export const materialAOMap: ShaderNodeObject<MaterialNode>;
+export const materialRefractionRatio: ShaderNodeObject<MaterialNode>;
 export const materialAnisotropyVector: ShaderNodeObject<UniformNode<Vector2>>;

three/{examples/jsm → src}/nodes/accessors/MaterialReferenceNode.d.ts

@@ -1,4 +1,4 @@
-import { Material } from "three";
+import { Material } from "../../materials/Material.js";
 import { NodeOrType, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import ReferenceNode from "./ReferenceNode.js";
 

three/{examples/jsm → src}/nodes/accessors/ModelNode.d.ts

@@ -1,4 +1,4 @@
-import { Matrix4 } from "three/src/Three.js";
+import { Matrix4 } from "../../math/Matrix4.js";
 import { UniformNode } from "../Nodes.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import Object3DNode from "./Object3DNode.js";

three/{examples/jsm → src}/nodes/accessors/NormalNode.d.ts

@@ -1,12 +1,12 @@
 import AttributeNode from "../core/AttributeNode.js";
 import PropertyNode from "../core/PropertyNode.js";
 import VarNode from "../core/VarNode.js";
-import MathNode from "../math/MathNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export const normalGeometry: ShaderNodeObject<AttributeNode>;
 export const normalLocal: ShaderNodeObject<VarNode>;
-export const normalView: ShaderNodeObject<MathNode>;
-export const normalWorld: ShaderNodeObject<MathNode>;
+export const normalView: ShaderNodeObject<VarNode>;
+export const normalWorld: ShaderNodeObject<VarNode>;
 export const transformedNormalView: ShaderNodeObject<PropertyNode>;
+export const transformedNormalWorld: ShaderNodeObject<VarNode>;
 export const transformedClearcoatNormalView: ShaderNodeObject<PropertyNode>;

three/{examples/jsm → src}/nodes/accessors/Object3DNode.d.ts

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

three/{examples/jsm → src}/nodes/accessors/ReflectVectorNode.d.ts

@@ -3,4 +3,7 @@ import VarNode from "../core/VarNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export const reflectView: ShaderNodeObject<Node>;
+export const refractView: ShaderNodeObject<Node>;
+
 export const reflectVector: ShaderNodeObject<VarNode>;
+export const refractVector: ShaderNodeObject<VarNode>;

three/{examples/jsm → src}/nodes/accessors/SkinningNode.d.ts

@@ -1,4 +1,4 @@
-import { SkinnedMesh } from "three";
+import { SkinnedMesh } from "../../objects/SkinnedMesh.js";
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 

three/{examples/jsm → src}/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/src/nodes/accessors/StorageTextureNode.d.ts

@@ -0,0 +1,40 @@
+import { GPUStorageTextureAccess } from "../../renderers/webgpu/utils/WebGPUConstants.js";
+import { Texture } from "../../textures/Texture.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 → src}/nodes/accessors/Texture3DNode.d.ts

@@ -1,4 +1,5 @@
-import { CubeTexture, Texture } from "three";
+import { CubeTexture } from "../../textures/CubeTexture.js";
+import { Texture } from "../../textures/Texture.js";
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import TextureNode from "./TextureNode.js";
@@ -10,7 +11,7 @@ export default class Texture3DNode extends TextureNode {
 }
 
 export const texture3D: (
-    value: CubeTexture,
+    value: Texture,
     uvNode?: NodeRepresentation,
     levelNode?: NodeRepresentation,
 ) => ShaderNodeObject<Texture3DNode>;

three/{examples/jsm → src}/nodes/accessors/TextureNode.d.ts

@@ -1,4 +1,4 @@
-import { Texture } from "three";
+import { Texture } from "../../textures/Texture.js";
 import Node from "../core/Node.js";
 import UniformNode from "../core/UniformNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
@@ -8,6 +8,7 @@ export default class TextureNode extends UniformNode<Texture> {
 
     uvNode: ShaderNodeObject<Node> | null;
     levelNode: ShaderNodeObject<Node> | null;
+    biasNode: ShaderNodeObject<Node> | null;
     compareNode: Node | null;
     depthNode: Node | null;
     gradNode: Node | null;
@@ -17,7 +18,12 @@ export default class TextureNode extends UniformNode<Texture> {
 
     referenceNode: Node | null;
 
-    constructor(value: Texture, uvNode?: ShaderNodeObject<Node> | null, levelNode?: ShaderNodeObject<Node> | null);
+    constructor(
+        value: Texture,
+        uvNode?: ShaderNodeObject<Node> | null,
+        levelNode?: ShaderNodeObject<Node> | null,
+        biasNode?: ShaderNodeObject<Node> | null,
+    );
 
     getDefaultUV(): Node;
 
@@ -30,6 +36,7 @@ export const texture: (
     value: Texture,
     uvNode?: NodeRepresentation,
     levelNode?: NodeRepresentation,
+    biasNode?: NodeRepresentation,
 ) => ShaderNodeObject<TextureNode>;
 export const sampler: (aTexture: Texture | TextureNode) => ShaderNodeObject<Node>;
 

three/{examples/jsm → src}/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 → src}/nodes/core/IndexNode.d.ts

@@ -1,7 +1,7 @@
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import Node from "./Node.js";
 
-export type IndexNodeScope = typeof IndexNode.VERTEX | typeof IndexNode.INSTANCE;
+export type IndexNodeScope = typeof IndexNode.VERTEX | typeof IndexNode.INSTANCE | typeof IndexNode.DRAW;
 
 export default class IndexNode extends Node {
     scope: IndexNodeScope;
@@ -12,7 +12,9 @@ export default class IndexNode extends Node {
 
     static VERTEX: "vertex";
     static INSTANCE: "instance";
+    static DRAW: "draw";
 }
 
 export const vertexIndex: ShaderNodeObject<IndexNode>;
 export const instanceIndex: ShaderNodeObject<IndexNode>;
+export const drawIndex: ShaderNodeObject<IndexNode>;

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

@@ -13,7 +13,16 @@ export interface LightingModelDirectInput {
     lightDirection: Node;
     lightColor: Node;
     reflectedLight: LightingModelReflectedLight;
-    shadowMask: Node;
+}
+
+export interface LightingModelDirectRectAreaInput {
+    lightColor: Node;
+    lightPosition: Node;
+    halfWidth: Node;
+    halfHeight: Node;
+    reflectedLight: LightingModelReflectedLight;
+    ltc_1: Node;
+    ltc_2: Node;
 }
 
 export interface LightingModelIndirectInput {
@@ -31,7 +40,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;
-    indirectDiffuse(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
-    indirectSpecular(input: LightingModelIndirectInput, stack: StackNode, builder: NodeBuilder): void;
+    directRectArea(input: LightingModelDirectRectAreaInput, 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;
@@ -69,6 +63,7 @@ declare class Node extends EventDispatcher<{
     nodeType: string | null;
     updateType: NodeUpdateType;
     updateBeforeType: NodeUpdateType;
+    updateAfterType: NodeUpdateType;
     uuid: string;
     version: number;
     _cacheKey: string | null;
@@ -95,15 +90,16 @@ 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;
     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;
     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 → src}/nodes/core/NodeBuilder.d.ts

@@ -1,4 +1,8 @@
-import { BufferGeometry, Material, Object3D, Renderer } 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";
@@ -58,6 +62,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,10 +70,15 @@ 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;
 
+    abstract getDrawIndex(): string | null;
+
     abstract getFrontFacing(): string;
 
     abstract getFragCoord(): string;
@@ -83,7 +93,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 +127,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;