@types/three 0.164.1 → 0.166.0

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

@@ -7,6 +7,7 @@ export default class PhysicalLightingModel extends LightingModel {
     iridescence: boolean;
     anisotropy: boolean;
     transmission: boolean;
+    dispersion: boolean;
 
     clearcoatRadiance: Node | null;
     clearcoatSpecularDirect: Node | null;
@@ -22,6 +23,7 @@ export default class PhysicalLightingModel extends LightingModel {
         iridescence?: boolean,
         anisotropy?: boolean,
         transmission?: boolean,
+        dispersion?: boolean,
     );
 
     computeMultiscattering(singleScatter: Node, multiScatter: Node, specularF90: Node): void;

three/examples/jsm/nodes/functions/ToonLightingModel.d.ts

@@ -0,0 +1,4 @@
+import LightingModel from "../core/LightingModel.js";
+
+export default class ToonLightingModel extends LightingModel {
+}

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);
+}

three/examples/jsm/nodes/loaders/NodeLoader.d.ts

@@ -1,5 +1,5 @@
 import { Loader, LoadingManager, Texture } from "three";
-import { AnyJson, Node } from "../Nodes.js";
+import { Node } from "../Nodes.js";
 
 export interface NodeLoaderResult {
     [hash: string]: Node;
@@ -8,7 +8,7 @@ export interface NodeLoaderResult {
 export default class NodeLoader extends Loader<NodeLoaderResult> {
     constructor(manager?: LoadingManager);
 
-    parseNodes(json: AnyJson): NodeLoaderResult;
-    parse(json: AnyJson): Node;
+    parseNodes(json: unknown): NodeLoaderResult;
+    parse(json: unknown): Node;
     setTextures(textures: { [key: string]: Texture }): this;
 }

three/examples/jsm/nodes/loaders/NodeObjectLoader.d.ts

@@ -1,9 +1,8 @@
 import { Material, ObjectLoader, Texture } from "three";
-import { AnyJson } from "../core/constants.js";
 import { NodeLoaderResult } from "./NodeLoader.js";
 
 export default class NodeObjectLoader extends ObjectLoader {
-    parseNodes(json: AnyJson, textures: { [key: string]: Texture }): NodeLoaderResult;
+    parseNodes(json: unknown, textures: { [key: string]: Texture }): NodeLoaderResult;
 
-    parseMaterials(json: AnyJson, textures: { [key: string]: Texture }): { [key: string]: Material };
+    parseMaterials(json: unknown, textures: { [key: string]: Texture }): { [key: string]: Material };
 }

three/examples/jsm/nodes/materials/LineBasicNodeMaterial.d.ts

@@ -10,6 +10,8 @@ export default class LineBasicNodeMaterial extends NodeMaterial {
     // Properties from LineBasicMaterial
     readonly isLineBasicMaterial: true;
     color: Color;
+    fog: boolean;
+    linewidth: number;
     linecap: string;
     linejoin: string;
     map: Texture | null;

three/examples/jsm/nodes/materials/Materials.d.ts

@@ -1,11 +1,14 @@
 export { default as LineBasicNodeMaterial } from "./LineBasicNodeMaterial.js";
 export { default as MeshBasicNodeMaterial } from "./MeshBasicNodeMaterial.js";
+export { default as MeshMatcapNodeMaterial } from "./MeshMatcapNodeMaterial.js";
 export { default as MeshNormalNodeMaterial } from "./MeshNormalNodeMaterial.js";
 export { default as MeshPhongNodeMaterial } from "./MeshPhongNodeMaterial.js";
 export { default as MeshPhysicalNodeMaterial } from "./MeshPhysicalNodeMaterial.js";
 export { default as MeshSSSPhysicalNodeMaterial } from "./MeshSSSNodeMaterial.js";
 export { default as MeshStandardNodeMaterial } from "./MeshStandardNodeMaterial.js";
+export { default as MeshToonNodeMaterial } from "./MeshToonNodeMaterial.js";
 export { default as NodeMaterial } from "./NodeMaterial.js";
 export { default as PointsNodeMaterial } from "./PointsNodeMaterial.js";
 export { default as ShadowNodeMaterial } from "./ShadowNodeMaterial.js";
 export { default as SpriteNodeMaterial } from "./SpriteNodeMaterial.js";
+export { default as VolumeNodeMaterial } from "./VolumeNodeMaterial.js";

three/examples/jsm/nodes/materials/MeshBasicNodeMaterial.d.ts

@@ -1,4 +1,4 @@
-import { Color, Combine, MeshBasicMaterialParameters, Texture } from "three";
+import { Color, Combine, Euler, MeshBasicMaterialParameters, Texture } from "three";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshBasicMaterialParameters {
@@ -18,11 +18,15 @@ export default class MeshBasicNodeMaterial extends NodeMaterial {
     specularMap: Texture | null;
     alphaMap: Texture | null;
     envMap: Texture | null;
+    envMapRotation: Euler;
     combine: Combine;
     reflectivity: number;
     refractionRatio: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
     wireframeLinecap: string;
     wireframeLinejoin: string;
+    fog: boolean;
 
     constructor(parameters?: MeshBasicNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/MeshMatcapNodeMaterial.d.ts

@@ -0,0 +1,28 @@
+import { Color, MeshMatcapMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshMatcapNodeMaterialParameters extends NodeMaterialParameters, MeshMatcapMaterialParameters {
+}
+
+export default class MeshMatcapNodeMaterial extends NodeMaterial {
+    readonly isMeshMatcapNodeMaterial: true;
+
+    // Properties from MeshMatcapMaterial
+    readonly isMeshMatcapMaterial: true;
+    color: Color;
+    matcap: Texture | null;
+    map: Texture | null;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    alphaMap: Texture | null;
+    flatShading: boolean;
+    fog: boolean;
+
+    constructor(paramters: MeshMatcapNodeMaterialParameters);
+}

three/examples/jsm/nodes/materials/MeshNormalNodeMaterial.d.ts

@@ -17,6 +17,8 @@ export default class MeshNormalNodeMaterial extends NodeMaterial {
     displacementMap: Texture | null;
     displacementScale: number;
     displacementBias: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
     flatShading: boolean;
 
     constructor(parameters?: MeshBasicNodeMaterialParameters);

three/examples/jsm/nodes/materials/MeshPhongNodeMaterial.d.ts

@@ -1,6 +1,5 @@
-import { Color, Combine, MeshPhongMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
+import { Color, Combine, Euler, MeshPhongMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshPhongNodeMaterialParameters extends NodeMaterialParameters, MeshPhongMaterialParameters {
@@ -9,8 +8,8 @@ export interface MeshPhongNodeMaterialParameters extends NodeMaterialParameters,
 export default class MeshPhongNodeMaterial extends NodeMaterial {
     readonly isMeshPhongNodeMaterial: true;
 
-    shininessNode: ShaderNodeObject<Node> | null;
-    specularNode: ShaderNodeObject<Node> | null;
+    shininessNode: Node | null;
+    specularNode: Node | null;
 
     // Properties from MeshPhongMaterial
     readonly isMeshPhongMaterial: true;
@@ -36,13 +35,17 @@ export default class MeshPhongNodeMaterial extends NodeMaterial {
     specularMap: Texture | null;
     alphaMap: Texture | null;
     envMap: Texture | null;
+    envMapRotation: Euler;
     combine: Combine;
     reflectivity: number;
     refractionRatio: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
     wireframeLinecap: string;
     wireframeLinejoin: string;
     flatShading: boolean;
     metal: boolean;
+    fog: boolean;
 
     constructor(parameters?: MeshPhongNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/MeshPhysicalNodeMaterial.d.ts

@@ -1,7 +1,6 @@
 import { Color, MeshPhysicalMaterialParameters, Texture, Vector2 } from "three";
 
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import MeshStandardNodeMaterial, { MeshStandardNodeMaterialParameters } from "./MeshStandardNodeMaterial.js";
 
 export interface MeshPhysicalNodeMaterialParameters
@@ -12,28 +11,29 @@ export interface MeshPhysicalNodeMaterialParameters
 export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     readonly isMeshPhysicalNodeMaterial: true;
 
-    clearcoatNode: ShaderNodeObject<Node> | null;
-    clearcoatRoughnessNode: ShaderNodeObject<Node> | null;
-    clearcoatNormalNode: ShaderNodeObject<Node> | null;
+    clearcoatNode: Node | null;
+    clearcoatRoughnessNode: Node | null;
+    clearcoatNormalNode: Node | null;
 
-    sheenNode: ShaderNodeObject<Node> | null;
-    sheenRoughnessNode: ShaderNodeObject<Node> | null;
+    sheenNode: Node | null;
+    sheenRoughnessNode: Node | null;
 
-    iridescenceNode: ShaderNodeObject<Node> | null;
-    iridescenceIORNode: ShaderNodeObject<Node> | null;
-    iridescenceThicknessNode: ShaderNodeObject<Node> | null;
+    iridescenceNode: Node | null;
+    iridescenceIORNode: Node | null;
+    iridescenceThicknessNode: Node | null;
 
-    iorNode: ShaderNodeObject<Node> | null;
+    iorNode: Node | null;
 
-    specularIntensityNode: ShaderNodeObject<Node> | null;
-    specularColorNode: ShaderNodeObject<Node> | null;
+    specularIntensityNode: Node | null;
+    specularColorNode: Node | null;
 
-    transmissionNode: ShaderNodeObject<Node> | null;
-    thicknessNode: ShaderNodeObject<Node> | null;
-    attenuationDistanceNode: ShaderNodeObject<Node> | null;
-    attenuationColorNode: ShaderNodeObject<Node> | null;
+    transmissionNode: Node | null;
+    thicknessNode: Node | null;
+    attenuationDistanceNode: Node | null;
+    attenuationColorNode: Node | null;
+    dispersionNode: Node | null;
 
-    anisotropyNode: ShaderNodeObject<Node> | null;
+    anisotropyNode: Node | null;
 
     // Properties from MeshPhysicalMaterial
     readonly isMeshPhysicalMaterial: true;
@@ -78,4 +78,11 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     set transmission(value: number);
 
     constructor(parameters?: MeshPhysicalNodeMaterialParameters);
+
+    get useClearcoat(): boolean;
+    get useIridescence(): boolean;
+    get useSheen(): boolean;
+    get useAnisotropy(): boolean;
+    get useTransmission(): boolean;
+    get useDispersion(): boolean;
 }

three/examples/jsm/nodes/materials/MeshSSSNodeMaterial.d.ts

@@ -1,15 +1,14 @@
 import ConstNode from "../core/ConstNode.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import MeshPhysicalNodeMaterial, { MeshPhysicalNodeMaterialParameters } from "./MeshPhysicalNodeMaterial.js";
 
 export default class MeshSSSNodeMaterial extends MeshPhysicalNodeMaterial {
-    thicknessColorNode: ShaderNodeObject<Node> | null;
-    thicknessDistortionNode: ShaderNodeObject<ConstNode<number>>;
-    thicknessAmbientNode: ShaderNodeObject<ConstNode<number>>;
-    thicknessAttenuationNode: ShaderNodeObject<ConstNode<number>>;
-    thicknessPowerNode: ShaderNodeObject<ConstNode<number>>;
-    thicknessScaleNode: ShaderNodeObject<ConstNode<number>>;
+    thicknessColorNode: Node | null;
+    thicknessDistortionNode: ConstNode<number>;
+    thicknessAmbientNode: ConstNode<number>;
+    thicknessAttenuationNode: ConstNode<number>;
+    thicknessPowerNode: ConstNode<number>;
+    thicknessScaleNode: ConstNode<number>;
 
     constructor(parameters?: MeshPhysicalNodeMaterialParameters);
 

three/examples/jsm/nodes/materials/MeshStandardNodeMaterial.d.ts

@@ -1,6 +1,5 @@
-import { Color, MeshStandardMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
+import { Color, Euler, MeshStandardMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshStandardNodeMaterialParameters extends NodeMaterialParameters, MeshStandardMaterialParameters {
@@ -9,10 +8,10 @@ export interface MeshStandardNodeMaterialParameters extends NodeMaterialParamete
 export default class MeshStandardNodeMaterial extends NodeMaterial {
     readonly isMeshStandardNodeMaterial: true;
 
-    emissiveNode: ShaderNodeObject<Node> | null;
+    emissiveNode: Node | null;
 
-    metalnessNode: ShaderNodeObject<Node> | null;
-    roughnessNode: ShaderNodeObject<Node> | null;
+    metalnessNode: Node | null;
+    roughnessNode: Node | null;
 
     // Properties from MeshStandardMaterial
     readonly isMeshStandardMaterial: true;
@@ -39,10 +38,14 @@ export default class MeshStandardNodeMaterial extends NodeMaterial {
     metalnessMap: Texture | null;
     alphaMap: Texture | null;
     envMap: Texture | null;
+    envMapRotation: Euler;
     envMapIntensity: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
     wireframeLinecap: string;
     wireframeLinejoin: string;
     flatShading: boolean;
+    fog: boolean;
 
     constructor(paramters?: MeshStandardNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/MeshToonNodeMaterial.d.ts

@@ -0,0 +1,38 @@
+import { Color, MeshToonMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshToonNodeMaterialParameters extends NodeMaterialParameters, MeshToonMaterialParameters {
+}
+
+export default class MeshToonNodeMaterial extends NodeMaterial {
+    readonly isMeshToonNodeMaterial: true;
+
+    // Properties from MeshToonMaterial
+    readonly isMeshToonMaterial: true;
+    color: Color;
+    gradientMap: Texture | null;
+    map: Texture | null;
+    lightMap: Texture | null;
+    lightMapIntensity: number;
+    aoMap: Texture | null;
+    aoMapIntensity: number;
+    emissive: Color;
+    emissiveIntensity: number;
+    emissiveMap: Texture | null;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    alphaMap: Texture | null;
+    wireframe: boolean;
+    wireframeLinewidth: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+    fog: boolean;
+
+    constructor(paramters: MeshToonNodeMaterialParameters);
+}

three/examples/jsm/nodes/materials/NodeMaterial.d.ts

@@ -1,14 +1,15 @@
 import {
     LineBasicMaterial,
     Material,
+    MaterialParameters,
     MeshBasicMaterial,
+    MeshMatcapMaterial,
     MeshNormalMaterial,
     MeshPhongMaterial,
     MeshPhysicalMaterial,
     MeshStandardMaterial,
+    MeshToonMaterial,
     PointsMaterial,
-    ShaderMaterial,
-    ShaderMaterialParameters,
     ShadowMaterial,
     SpriteMaterial,
 } from "three";
@@ -17,76 +18,77 @@ import LightingModel from "../core/LightingModel.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import LightsNode from "../lighting/LightsNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import LineBasicNodeMaterial from "./LineBasicNodeMaterial.js";
 import MeshBasicNodeMaterial from "./MeshBasicNodeMaterial.js";
+import MeshMatcapNodeMaterial from "./MeshMatcapNodeMaterial.js";
 import MeshNormalNodeMaterial from "./MeshNormalNodeMaterial.js";
 import MeshPhongNodeMaterial from "./MeshPhongNodeMaterial.js";
 import MeshPhysicalNodeMaterial from "./MeshPhysicalNodeMaterial.js";
 import MeshStandardNodeMaterial from "./MeshStandardNodeMaterial.js";
+import MeshToonNodeMaterial from "./MeshToonNodeMaterial.js";
 import PointsNodeMaterial from "./PointsNodeMaterial.js";
 import ShadowNodeMaterial from "./ShadowNodeMaterial.js";
 import SpriteNodeMaterial from "./SpriteNodeMaterial.js";
 
-export interface NodeMaterialParameters extends ShaderMaterialParameters {
+export interface NodeMaterialParameters extends MaterialParameters {
     normals?: boolean | undefined;
 
     colorSpaced?: boolean | undefined;
 
-    lightsNode?: ShaderNodeObject<LightsNode> | null | undefined;
-    envNode?: ShaderNodeObject<Node> | null | undefined;
-    aoNode?: ShaderNodeObject<Node> | null | undefined;
+    lightsNode?: LightsNode | null | undefined;
+    envNode?: Node | null | undefined;
+    aoNode?: Node | null | undefined;
 
-    colorNode?: ShaderNodeObject<Node> | null | undefined;
-    normalNode?: ShaderNodeObject<Node> | null | undefined;
-    opacityNode?: ShaderNodeObject<Node> | null | undefined;
-    backdropNode?: ShaderNodeObject<Node> | null | undefined;
-    backdropAlphaNode?: ShaderNodeObject<Node> | null | undefined;
-    alphaTestNode?: ShaderNodeObject<Node> | null | undefined;
+    colorNode?: Node | null | undefined;
+    normalNode?: Node | null | undefined;
+    opacityNode?: Node | null | undefined;
+    backdropNode?: Node | null | undefined;
+    backdropAlphaNode?: Node | null | undefined;
+    alphaTestNode?: Node | null | undefined;
 
-    positionNode?: ShaderNodeObject<Node> | null | undefined;
+    positionNode?: Node | null | undefined;
 
-    depthNode?: ShaderNodeObject<Node> | null | undefined;
-    shadowNode?: ShaderNodeObject<Node> | null | undefined;
+    depthNode?: Node | null | undefined;
+    shadowNode?: Node | null | undefined;
 
-    outputNode?: ShaderNodeObject<Node> | null | undefined;
+    outputNode?: Node | null | undefined;
 
-    fragmentNode?: ShaderNodeObject<Node> | null | undefined;
-    vertexNode?: ShaderNodeObject<Node> | null | undefined;
+    fragmentNode?: Node | null | undefined;
+    vertexNode?: Node | null | undefined;
 }
 
-export default class NodeMaterial extends ShaderMaterial {
+export default class NodeMaterial extends Material {
     readonly isNodeMaterial: true;
 
     normals: boolean;
 
-    lightsNode: ShaderNodeObject<LightsNode> | null;
-    envNode: ShaderNodeObject<Node> | null;
-    aoNode: ShaderNodeObject<Node> | null;
+    lightsNode: LightsNode | null;
+    envNode: Node | null;
+    aoNode: Node | null;
 
-    colorNode: ShaderNodeObject<Node> | null;
-    normalNode: ShaderNodeObject<Node> | null;
-    opacityNode: ShaderNodeObject<Node> | null;
-    backdropNode: ShaderNodeObject<Node> | null;
-    backdropAlphaNode: ShaderNodeObject<Node> | null;
-    alphaTestNode: ShaderNodeObject<Node> | null;
+    colorNode: Node | null;
+    normalNode: Node | null;
+    opacityNode: Node | null;
+    backdropNode: Node | null;
+    backdropAlphaNode: Node | null;
+    alphaTestNode: Node | null;
 
-    positionNode: ShaderNodeObject<Node> | null;
+    positionNode: Node | null;
 
-    depthNode: ShaderNodeObject<Node> | null;
-    shadowNode: ShaderNodeObject<Node> | null;
-    shadowPositionNode: ShaderNodeObject<Node> | null;
+    depthNode: Node | null;
+    shadowNode: Node | null;
+    shadowPositionNode: Node | null;
 
-    outputNode: ShaderNodeObject<Node> | null;
+    outputNode: Node | null;
 
-    fragmentNode: ShaderNodeObject<Node> | null;
-    vertexNode: ShaderNodeObject<Node> | null;
+    fragmentNode: Node | null;
+    vertexNode: Node | null;
 
     constructor();
 
     build(builder: NodeBuilder): void;
     setup(builder: NodeBuilder): void;
-    setupClipping(builder: NodeBuilder): ShaderNodeObject<ClippingNode> | null;
+    setupClipping(builder: NodeBuilder): ClippingNode | null;
     setupDepth(builder: NodeBuilder): void;
     setupPosition(builder: NodeBuilder): Node;
     setupDiffuseColor(builder: NodeBuilder): void;
@@ -102,10 +104,12 @@ export default class NodeMaterial extends ShaderMaterial {
 
     static fromMaterial(material: LineBasicMaterial): LineBasicNodeMaterial;
     static fromMaterial(material: MeshBasicMaterial): MeshBasicNodeMaterial;
+    static fromMaterial(material: MeshMatcapMaterial): MeshMatcapNodeMaterial;
     static fromMaterial(material: MeshNormalMaterial): MeshNormalNodeMaterial;
     static fromMaterial(material: MeshPhongMaterial): MeshPhongNodeMaterial;
     static fromMaterial(material: MeshPhysicalMaterial): MeshPhysicalNodeMaterial;
     static fromMaterial(material: MeshStandardMaterial): MeshStandardNodeMaterial;
+    static fromMaterial(material: MeshToonMaterial): MeshToonNodeMaterial;
     static fromMaterial(material: PointsMaterial): PointsNodeMaterial;
     static fromMaterial(material: ShadowMaterial): ShadowNodeMaterial;
     static fromMaterial(material: SpriteMaterial): SpriteNodeMaterial;

three/examples/jsm/nodes/materials/PointsNodeMaterial.d.ts

@@ -14,6 +14,7 @@ export default class PointsNodeMaterial extends NodeMaterial {
     alphaMap: Texture | null;
     size: number;
     sizeAttenuation: boolean;
+    fog: boolean;
 
     constructor(parameters?: PointsNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/ShadowNodeMaterial.d.ts

@@ -10,6 +10,7 @@ export default class ShadowNodeMaterial extends NodeMaterial {
     // Properties from ShadowMaterial
     readonly isShadowMaterial: true;
     color: Color;
+    fog: boolean;
 
     constructor(parameters?: ShadowNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/SpriteNodeMaterial.d.ts

@@ -1,6 +1,5 @@
 import { Color, SpriteMaterialParameters, Texture } from "three";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface SpriteNodeMaterialParameters extends NodeMaterialParameters, SpriteMaterialParameters {
@@ -9,8 +8,8 @@ export interface SpriteNodeMaterialParameters extends NodeMaterialParameters, Sp
 export default class SpriteNodeMaterial extends NodeMaterial {
     isSpriteNodeMaterial: true;
 
-    rotationNode: ShaderNodeObject<Node> | null;
-    scaleNode: ShaderNodeObject<Node> | null;
+    rotationNode: Node | null;
+    scaleNode: Node | null;
 
     // Properties from SpriteMaterial
     readonly isSpriteMaterial: true;
@@ -19,6 +18,7 @@ export default class SpriteNodeMaterial extends NodeMaterial {
     alphaMap: Texture | null;
     rotation: number;
     sizeAttenuation: boolean;
+    fog: boolean;
 
     constructor(parameters?: SpriteNodeMaterialParameters);
 }

three/examples/jsm/nodes/materials/VolumeNodeMaterial.d.ts

@@ -0,0 +1,10 @@
+import Node from "../core/Node.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export default class VolumeNodeMaterial extends NodeMaterial {
+    lights: boolean;
+    readonly isVolumeNodeMaterial: true;
+    testNode: Node | null;
+
+    constructor(parameters?: NodeMaterialParameters);
+}

three/examples/jsm/nodes/materialx/lib/mx_hsv.d.ts

@@ -2,4 +2,5 @@ import Node from "../../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
 export const mx_hsvtorgb: (hsv_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+
 export const mx_rgbtohsv: (c_immutable: NodeRepresentation) => ShaderNodeObject<Node>;