@types/three 0.167.2 → 0.169.0

three/src/core/EventDispatcher.d.ts

@@ -53,7 +53,6 @@ export class EventDispatcher<TEventMap extends {} = {}> {
         type: T,
         listener: EventListener<TEventMap[T], T, this>,
     ): void;
-    addEventListener<T extends string>(type: T, listener: EventListener<{}, T, this>): void;
 
     /**
      * Checks if listener is added to an event type.
@@ -64,7 +63,6 @@ export class EventDispatcher<TEventMap extends {} = {}> {
         type: T,
         listener: EventListener<TEventMap[T], T, this>,
     ): boolean;
-    hasEventListener<T extends string>(type: T, listener: EventListener<{}, T, this>): boolean;
 
     /**
      * Removes a listener from an event type.
@@ -75,7 +73,6 @@ export class EventDispatcher<TEventMap extends {} = {}> {
         type: T,
         listener: EventListener<TEventMap[T], T, this>,
     ): void;
-    removeEventListener<T extends string>(type: T, listener: EventListener<{}, T, this>): void;
 
     /**
      * Fire an event type.

three/src/core/InterleavedBuffer.d.ts

@@ -42,18 +42,6 @@ export class InterleavedBuffer {
      */
     usage: Usage;
 
-    /**
-     * Object containing offset and count.
-     * @defaultValue `{ offset: number = 0; count: number = -1 }`
-     * @deprecated Will be removed in r169. Use "addUpdateRange()" instead.
-     */
-    updateRange: {
-        /** @defaultValue `0` */
-        offset: number;
-        /** @defaultValue `-1` */
-        count: number;
-    };
-
     /**
      * This can be used to only update some components of stored data. Use the {@link .addUpdateRange} function to add
      * ranges to this array.

three/src/core/Object3D.d.ts

@@ -127,7 +127,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
      * Sub-classes will update this value.
      * @defaultValue `Object3D`
      */
-    readonly type: string | "Object3D";
+    readonly type: string;
 
     /**
      * Object's parent in the {@link https://en.wikipedia.org/wiki/Scene_graph | scene graph}.
@@ -299,6 +299,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     onBeforeShadow(
         renderer: WebGLRenderer,
         scene: Scene,
+        camera: Camera,
         shadowCamera: Camera,
         geometry: BufferGeometry,
         depthMaterial: Material,
@@ -317,6 +318,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     onAfterShadow(
         renderer: WebGLRenderer,
         scene: Scene,
+        camera: Camera,
         shadowCamera: Camera,
         geometry: BufferGeometry,
         depthMaterial: Material,

three/src/core/Raycaster.d.ts

@@ -24,7 +24,8 @@ export interface Intersection<TIntersected extends Object3D = Object3D> {
     /** Intersected face */
     face?: Face | null | undefined;
     /** Index of the intersected face */
-    faceIndex?: number | undefined;
+    faceIndex?: number | null | undefined;
+    barycoord?: Vector3 | null;
     /** The intersected object */
     object: TIntersected;
     uv?: Vector2 | undefined;

three/src/extras/Controls.d.ts

@@ -0,0 +1,54 @@
+import { EventDispatcher } from "../core/EventDispatcher.js";
+import { Object3D } from "../core/Object3D.js";
+
+/**
+ * Abstract base class for controls.
+ */
+declare abstract class Controls<TEventMap extends {}> extends EventDispatcher<TEventMap> {
+    /**
+     * The 3D object that is managed by the controls.
+     */
+    object: Object3D;
+
+    /**
+     * The HTML element used for event listeners. If not provided via the constructor, {@link .connect} must be called
+     * after `domElement` has been set.
+     */
+    domElement: HTMLElement | null;
+
+    /**
+     * When set to `false`, the controls will not respond to user input. Default is `true`.
+     */
+    enabled: boolean;
+
+    /**
+     * Creates a new instance of {@link Controls}.
+     * @param object The object the controls should manage (usually the camera).
+     * @param domElement The HTML element used for event listeners. (optional)
+     */
+    constructor(object: Object3D, domElement?: HTMLElement | null);
+
+    /**
+     * Connects the controls to the DOM. This method has so called "side effects" since it adds the module's event
+     * listeners to the DOM.
+     */
+    connect(): void;
+
+    /**
+     * Disconnects the controls from the DOM.
+     */
+    disconnect(): void;
+
+    /**
+     * Call this method if you no longer want use to the controls. It frees all internal resources and removes all event
+     * listeners.
+     */
+    dispose(): void;
+
+    /**
+     * Controls should implement this method if they have to update their internal state per simulation step.
+     */
+    update(delta: number): void;
+}
+
+export { Controls };

three/src/loaders/MaterialLoader.d.ts

@@ -15,5 +15,7 @@ export class MaterialLoader extends Loader<Material> {
 
     setTextures(textures: { [key: string]: Texture }): this;
 
+    createMaterialFromType(type: string): Material;
+
     static createMaterialFromType(type: string): Material;
 }

three/src/{nodes/loaders → loaders/nodes}/NodeLoader.d.ts

@@ -1,16 +1,21 @@
-import { Loader } from "../../loaders/Loader.js";
-import { LoadingManager } from "../../loaders/LoadingManager.js";
+import { Node } from "../../nodes/Nodes.js";
 import { Texture } from "../../textures/Texture.js";
-import { Node } from "../Nodes.js";
+import { Loader } from "../Loader.js";
+import { LoadingManager } from "../LoadingManager.js";
 
 export interface NodeLoaderResult {
     [hash: string]: Node;
 }
 
 export default class NodeLoader extends Loader<NodeLoaderResult> {
+    textures: { [key: string]: Texture };
+    nodes: { [type: string]: Node };
+
     constructor(manager?: LoadingManager);
 
     parseNodes(json: unknown): NodeLoaderResult;
     parse(json: unknown): Node;
     setTextures(textures: { [key: string]: Texture }): this;
+    setNodes(value: { [type: string]: Node }): this;
+    createNodeFromType(type: string): Node;
 }

three/src/loaders/nodes/NodeMaterialLoader.d.ts

@@ -0,0 +1,11 @@
+import NodeMaterial from "../../materials/nodes/NodeMaterial.js";
+import { MaterialLoader } from "../MaterialLoader.js";
+import { NodeLoaderResult } from "./NodeLoader.js";
+
+export default class NodeMaterialLoader extends MaterialLoader {
+    nodes: NodeLoaderResult;
+    nodeMaterials: { [type: string]: NodeMaterial };
+
+    setNodes(value: NodeLoaderResult): this;
+    setNodeMaterials(value: { [type: string]: NodeMaterial }): this;
+}

three/src/loaders/nodes/NodeObjectLoader.d.ts

@@ -0,0 +1,22 @@
+import { Material } from "../../materials/Material.js";
+import NodeMaterial from "../../materials/nodes/NodeMaterial.js";
+import { Node } from "../../nodes/Nodes.js";
+import { Texture } from "../../textures/Texture.js";
+import { LoadingManager } from "../LoadingManager.js";
+import { ObjectLoader } from "../ObjectLoader.js";
+import { NodeLoaderResult } from "./NodeLoader.js";
+
+export default class NodeObjectLoader extends ObjectLoader {
+    nodes: { [type: string]: Node };
+    nodeMaterials: { [type: string]: NodeMaterial };
+
+    constructor(manager?: LoadingManager);
+
+    setNodes(value: { [type: string]: Node }): this;
+
+    setNodeMaterials(value: { [type: string]: NodeMaterial }): this;
+
+    parseNodes(json: unknown, textures: { [key: string]: Texture }): NodeLoaderResult;
+
+    parseMaterials(json: unknown, textures: { [key: string]: Texture }): { [key: string]: Material };
+}

three/src/materials/Material.d.ts

@@ -556,10 +556,26 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      */
     set alphaTest(value: number);
 
+    /**
+     * An optional callback that is executed immediately before the material is used to render a 3D object.
+     * Unlike properties, the callback is not supported by {@link .clone()}, {@link .copy()} and {@link .toJSON()}.
+     * This callback is only supported in `WebGLRenderer` (not `WebGPURenderer`).
+     */
+    onBeforeRender(
+        renderer: WebGLRenderer,
+        scene: Scene,
+        camera: Camera,
+        geometry: BufferGeometry,
+        object: Object3D,
+        group: Group,
+    ): void;
+
     /**
      * An optional callback that is executed immediately before the shader program is compiled.
-     * This function is called with the associated WebGL program parameters and renderer.
+     * This function is called with the shader source code as a parameter.
      * Useful for the modification of built-in materials.
+     * Unlike properties, the callback is not supported by {@link .clone()}, {@link .copy()} and {@link .toJSON()}.
+     * This callback is only supported in `WebGLRenderer` (not `WebGPURenderer`).
      * @param parameters WebGL program parameters
      * @param renderer WebGLRenderer context that is initializing the material
      */
@@ -612,16 +628,4 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      * @deprecated onBuild() has been removed.
      */
     onBuild(object: Object3D, parameters: WebGLProgramParametersWithUniforms, renderer: WebGLRenderer): void;
-
-    /**
-     * @deprecated onBeforeRender() has been removed.
-     */
-    onBeforeRender(
-        renderer: WebGLRenderer,
-        scene: Scene,
-        camera: Camera,
-        geometry: BufferGeometry,
-        object: Object3D,
-        group: Group,
-    ): void;
 }

three/src/materials/nodes/InstancedPointsNodeMaterial.d.ts

@@ -0,0 +1,33 @@
+import { Color } from "../../math/Color.js";
+import Node from "../../nodes/core/Node.js";
+import { Texture } from "../../textures/Texture.js";
+import { PointsMaterialParameters } from "../PointsMaterial.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface InstancedPointsNodeMaterialParameters extends NodeMaterialParameters, PointsMaterialParameters {
+    useAlphaToCoverage?: boolean | undefined;
+    useColor?: boolean | undefined;
+    pointWidth?: number | undefined;
+    pointColorNode?: Node | null | undefined;
+    pointWidthNode?: Node | null | undefined;
+}
+
+declare class InstancedPointsNodeMaterial extends NodeMaterial {
+    useAlphaToCoverage: boolean;
+    useColor: boolean | undefined;
+    pointWidth: number;
+    pointColorNode: Node | null;
+    pointWidthNode: Node | null;
+
+    // Properties from LineDashedMaterial
+    readonly isPointsMaterial: true;
+    color: Color;
+    map: Texture | null;
+    alphaMap: Texture | null;
+    size: number;
+    sizeAttenuation: boolean;
+
+    constructor(params?: InstancedPointsNodeMaterialParameters);
+}
+
+export default InstancedPointsNodeMaterial;

three/src/{nodes/materials → materials/nodes}/Line2NodeMaterial.d.ts

@@ -1,7 +1,7 @@
-import { LineDashedMaterialParameters } from "../../materials/LineDashedMaterial.js";
 import { Color } from "../../math/Color.js";
+import Node from "../../nodes/core/Node.js";
 import { Texture } from "../../textures/Texture.js";
-import Node from "../core/Node.js";
+import { LineDashedMaterialParameters } from "../LineDashedMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface Line2NodeMaterialParameters extends NodeMaterialParameters, LineDashedMaterialParameters {

three/src/{nodes/materials → materials/nodes}/LineBasicNodeMaterial.d.ts

@@ -1,6 +1,6 @@
-import { LineBasicMaterialParameters } from "../../materials/LineBasicMaterial.js";
 import { Color } from "../../math/Color.js";
 import { Texture } from "../../textures/Texture.js";
+import { LineBasicMaterialParameters } from "../LineBasicMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface LineBasicNodeMaterialParameters extends NodeMaterialParameters, LineBasicMaterialParameters {

three/src/materials/nodes/LineDashedNodeMaterial.d.ts

@@ -0,0 +1,29 @@
+import Node from "../../nodes/core/Node.js";
+import { LineDashedMaterialParameters } from "../LineDashedMaterial.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface LineDashedNodeMaterialParameters extends NodeMaterialParameters, LineDashedMaterialParameters {
+    offsetNode?: Node | null | undefined;
+    dashScaleNode?: Node | null | undefined;
+    dashSizeNode?: Node | null | undefined;
+    gapSizeNode?: Node | null | undefined;
+}
+
+declare class LineDashedNodeMaterial extends NodeMaterial {
+    readonly isLineDashedNodeMaterial: true;
+
+    offsetNode: Node | null;
+    dashScaleNode: Node | null;
+    dashSizeNode: Node | null;
+    gapSizeNode: Node | null;
+
+    // Properties from LineDashedMaterial
+    readonly isLineDashedMaterial: true;
+    scale: number;
+    dashSize: number;
+    gapSize: number;
+
+    constructor(parameters?: LineDashedMaterialParameters);
+}
+
+export default LineDashedNodeMaterial;

three/src/{nodes/materials → materials/nodes}/MeshBasicNodeMaterial.d.ts

@@ -1,8 +1,8 @@
 import { Combine } from "../../constants.js";
-import { MeshBasicMaterialParameters } from "../../materials/MeshBasicMaterial.js";
 import { Color } from "../../math/Color.js";
 import { Euler } from "../../math/Euler.js";
 import { Texture } from "../../textures/Texture.js";
+import { MeshBasicMaterialParameters } from "../MeshBasicMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshBasicMaterialParameters {

three/src/materials/nodes/MeshLambertNodeMaterial.d.ts

@@ -0,0 +1,49 @@
+import { Combine, NormalMapTypes } from "../../constants.js";
+import { Color } from "../../math/Color.js";
+import { Euler } from "../../math/Euler.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Texture } from "../../textures/Texture.js";
+import { MeshLambertMaterialParameters } from "../MeshLambertMaterial.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshLambertNodeMaterialParameters extends NodeMaterialParameters, MeshLambertMaterialParameters {}
+
+declare class MeshLambertNodeMaterial extends NodeMaterial {
+    readonly isMeshLambertNodeMaterial: true;
+
+    // Properties from MeshLambertMaterial
+    readonly isMeshLambertMaterial: true;
+    color: Color;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    emissive: Color;
+    emissiveIntensity: number;
+    emissiveMap: Texture | null;
+    flatShading: boolean;
+    map: Texture | null;
+    lightMap: Texture | null;
+    lightMapIntensity: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    aoMap: Texture | null;
+    aoMapIntensity: number;
+    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;
+
+    constructor(parameters?: MeshLambertNodeMaterialParameters);
+}
+
+export default MeshLambertNodeMaterial;

three/src/{nodes/materials → materials/nodes}/MeshMatcapNodeMaterial.d.ts

@@ -1,8 +1,8 @@
 import { NormalMapTypes } from "../../constants.js";
-import { MeshMatcapMaterialParameters } from "../../materials/MeshMatcapMaterial.js";
 import { Color } from "../../math/Color.js";
 import { Vector2 } from "../../math/Vector2.js";
 import { Texture } from "../../textures/Texture.js";
+import { MeshMatcapMaterialParameters } from "../MeshMatcapMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshMatcapNodeMaterialParameters extends NodeMaterialParameters, MeshMatcapMaterialParameters {
@@ -28,5 +28,5 @@ export default class MeshMatcapNodeMaterial extends NodeMaterial {
     flatShading: boolean;
     fog: boolean;
 
-    constructor(paramters: MeshMatcapNodeMaterialParameters);
+    constructor(parameters?: MeshMatcapNodeMaterialParameters);
 }

three/src/{nodes/materials → materials/nodes}/MeshNormalNodeMaterial.d.ts

@@ -1,7 +1,7 @@
 import { NormalMapTypes } from "../../constants.js";
-import { MeshNormalMaterialParameters } from "../../materials/MeshNormalMaterial.js";
 import { Vector2 } from "../../math/Vector2.js";
 import { Texture } from "../../textures/Texture.js";
+import { MeshNormalMaterialParameters } from "../MeshNormalMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshNormalMaterialParameters {

three/src/{nodes/materials → materials/nodes}/MeshPhongNodeMaterial.d.ts

@@ -1,10 +1,10 @@
 import { Combine, NormalMapTypes } from "../../constants.js";
-import { MeshPhongMaterialParameters } from "../../materials/MeshPhongMaterial.js";
 import { Color } from "../../math/Color.js";
 import { Euler } from "../../math/Euler.js";
 import { Vector2 } from "../../math/Vector2.js";
+import Node from "../../nodes/core/Node.js";
 import { Texture } from "../../textures/Texture.js";
-import Node from "../core/Node.js";
+import { MeshPhongMaterialParameters } from "../MeshPhongMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshPhongNodeMaterialParameters extends NodeMaterialParameters, MeshPhongMaterialParameters {

three/src/{nodes/materials → materials/nodes}/MeshPhysicalNodeMaterial.d.ts

@@ -1,8 +1,9 @@
-import { MeshPhysicalMaterialParameters } from "../../materials/MeshPhysicalMaterial.js";
 import { Color } from "../../math/Color.js";
 import { Vector2 } from "../../math/Vector2.js";
+import Node from "../../nodes/core/Node.js";
+import { ShaderNodeObject } from "../../nodes/tsl/TSLCore.js";
 import { Texture } from "../../textures/Texture.js";
-import Node from "../core/Node.js";
+import { MeshPhysicalMaterialParameters } from "../MeshPhysicalMaterial.js";
 import MeshStandardNodeMaterial, { MeshStandardNodeMaterialParameters } from "./MeshStandardNodeMaterial.js";
 
 export interface MeshPhysicalNodeMaterialParameters
@@ -87,4 +88,6 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     get useAnisotropy(): boolean;
     get useTransmission(): boolean;
     get useDispersion(): boolean;
+
+    setupClearcoatNormal(): ShaderNodeObject<Node>;
 }

three/src/{nodes/materials → materials/nodes}/MeshSSSNodeMaterial.d.ts

@@ -1,5 +1,5 @@
-import ConstNode from "../core/ConstNode.js";
-import Node from "../core/Node.js";
+import ConstNode from "../../nodes/core/ConstNode.js";
+import Node from "../../nodes/core/Node.js";
 import MeshPhysicalNodeMaterial, { MeshPhysicalNodeMaterialParameters } from "./MeshPhysicalNodeMaterial.js";
 
 export default class MeshSSSNodeMaterial extends MeshPhysicalNodeMaterial {

three/src/{nodes/materials → materials/nodes}/MeshStandardNodeMaterial.d.ts

@@ -1,10 +1,10 @@
 import { NormalMapTypes } from "../../constants.js";
-import { MeshStandardMaterialParameters } from "../../materials/MeshStandardMaterial.js";
 import { Color } from "../../math/Color.js";
 import { Euler } from "../../math/Euler.js";
 import { Vector2 } from "../../math/Vector2.js";
+import Node from "../../nodes/core/Node.js";
 import { Texture } from "../../textures/Texture.js";
-import Node from "../core/Node.js";
+import { MeshStandardMaterialParameters } from "../MeshStandardMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshStandardNodeMaterialParameters extends NodeMaterialParameters, MeshStandardMaterialParameters {
@@ -52,5 +52,5 @@ export default class MeshStandardNodeMaterial extends NodeMaterial {
     flatShading: boolean;
     fog: boolean;
 
-    constructor(paramters?: MeshStandardNodeMaterialParameters);
+    constructor(parameters?: MeshStandardNodeMaterialParameters);
 }

three/src/{nodes/materials → materials/nodes}/MeshToonNodeMaterial.d.ts

@@ -1,8 +1,8 @@
 import { NormalMapTypes } from "../../constants.js";
-import { MeshToonMaterialParameters } from "../../materials/MeshToonMaterial.js";
 import { Color } from "../../math/Color.js";
 import { Vector2 } from "../../math/Vector2.js";
 import { Texture } from "../../textures/Texture.js";
+import { MeshToonMaterialParameters } from "../MeshToonMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshToonNodeMaterialParameters extends NodeMaterialParameters, MeshToonMaterialParameters {
@@ -38,5 +38,5 @@ export default class MeshToonNodeMaterial extends NodeMaterial {
     wireframeLinejoin: string;
     fog: boolean;
 
-    constructor(paramters: MeshToonNodeMaterialParameters);
+    constructor(parameters?: MeshToonNodeMaterialParameters);
 }

three/src/materials/nodes/NodeMaterial.d.ts

@@ -0,0 +1,89 @@
+import ClippingNode from "../../nodes/accessors/ClippingNode.js";
+import LightingModel from "../../nodes/core/LightingModel.js";
+import MRTNode from "../../nodes/core/MRTNode.js";
+import Node from "../../nodes/core/Node.js";
+import NodeBuilder from "../../nodes/core/NodeBuilder.js";
+import LightsNode from "../../nodes/lighting/LightsNode.js";
+import { ShaderNodeObject } from "../../nodes/tsl/TSLCore.js";
+import { Material, MaterialParameters } from "../Material.js";
+
+export interface NodeMaterialParameters extends MaterialParameters {
+    normals?: boolean | undefined;
+
+    colorSpaced?: boolean | undefined;
+
+    lightsNode?: LightsNode | null | undefined;
+    envNode?: Node | null | undefined;
+    aoNode?: 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?: Node | null | undefined;
+
+    depthNode?: Node | null | undefined;
+    shadowNode?: Node | null | undefined;
+
+    outputNode?: Node | null | undefined;
+
+    fragmentNode?: Node | null | undefined;
+    vertexNode?: Node | null | undefined;
+}
+
+declare class NodeMaterial extends Material {
+    static get type(): string;
+
+    readonly isNodeMaterial: true;
+
+    fog: boolean;
+    lights: boolean;
+
+    lightsNode: LightsNode | null;
+    envNode: Node | null;
+    aoNode: Node | null;
+
+    colorNode: Node | null;
+    normalNode: Node | null;
+    opacityNode: Node | null;
+    backdropNode: Node | null;
+    backdropAlphaNode: Node | null;
+    alphaTestNode: Node | null;
+
+    positionNode: Node | null;
+
+    depthNode: Node | null;
+    shadowNode: Node | null;
+    shadowPositionNode: Node | null;
+
+    outputNode: Node | null;
+    mrtNode: MRTNode | null;
+
+    fragmentNode: Node | null;
+    vertexNode: Node | null;
+
+    constructor();
+
+    build(builder: NodeBuilder): void;
+    setup(builder: NodeBuilder): void;
+    setupClipping(builder: NodeBuilder): ClippingNode | null;
+    setupDepth(builder: NodeBuilder): void;
+    setupPosition(builder: NodeBuilder): Node;
+    setupDiffuseColor(builder: NodeBuilder): void;
+    setupVariants(builder: NodeBuilder): void;
+    setupNormal(builder: NodeBuilder): ShaderNodeObject<Node>;
+    setupEnvironment(builder: NodeBuilder): Node | null;
+    setupLightMap(builder: NodeBuilder): Node | null;
+    setupLights(builder: NodeBuilder): LightsNode;
+    setupOutgoingLight(): Node;
+    setupLightingModel(builder: NodeBuilder): LightingModel;
+    setupLighting(builder: NodeBuilder): Node;
+    setupOutput(builder: NodeBuilder, outputNode: Node): Node;
+
+    setDefaultValues(material: Material): void;
+}
+
+export default NodeMaterial;

three/src/{nodes/materials/Materials.d.ts → materials/nodes/NodeMaterials.d.ts}

@@ -1,14 +1,17 @@
+export { default as InstancedPointsNodeMaterial } from "./InstancedPointsNodeMaterial.js";
 export { default as Line2NodeMaterial } from "./Line2NodeMaterial.js";
 export { default as LineBasicNodeMaterial } from "./LineBasicNodeMaterial.js";
+export { default as LineDashedNodeMaterial } from "./LineDashedNodeMaterial.js";
 export { default as MeshBasicNodeMaterial } from "./MeshBasicNodeMaterial.js";
+export { default as MeshLambertNodeMaterial } from "./MeshLambertNodeMaterial.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 MeshSSSNodeMaterial } from "./MeshSSSNodeMaterial.js";
 export { default as MeshStandardNodeMaterial } from "./MeshStandardNodeMaterial.js";
 export { default as MeshToonNodeMaterial } from "./MeshToonNodeMaterial.js";
-export { addNodeMaterial, createNodeMaterialFromType, default as NodeMaterial } from "./NodeMaterial.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";

three/src/{nodes/materials → materials/nodes}/PointsNodeMaterial.d.ts

@@ -1,6 +1,6 @@
-import { PointsMaterialParameters } from "../../materials/PointsMaterial.js";
 import { Color } from "../../math/Color.js";
 import { Texture } from "../../textures/Texture.js";
+import { PointsMaterialParameters } from "../PointsMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface PointsNodeMaterialParameters extends NodeMaterialParameters, PointsMaterialParameters {
@@ -16,7 +16,6 @@ export default class PointsNodeMaterial extends NodeMaterial {
     alphaMap: Texture | null;
     size: number;
     sizeAttenuation: boolean;
-    fog: boolean;
 
     constructor(parameters?: PointsNodeMaterialParameters);
 }

three/src/{nodes/materials → materials/nodes}/ShadowNodeMaterial.d.ts

@@ -1,5 +1,5 @@
-import { ShadowMaterialParameters } from "../../materials/ShadowMaterial.js";
 import { Color } from "../../math/Color.js";
+import { ShadowMaterialParameters } from "../ShadowMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface ShadowNodeMaterialParameters extends NodeMaterialParameters, ShadowMaterialParameters {

three/src/{nodes/materials → materials/nodes}/SpriteNodeMaterial.d.ts

@@ -1,7 +1,7 @@
-import { SpriteMaterialParameters } from "../../materials/SpriteMaterial.js";
 import { Color } from "../../math/Color.js";
+import Node from "../../nodes/core/Node.js";
 import { Texture } from "../../textures/Texture.js";
-import Node from "../core/Node.js";
+import { SpriteMaterialParameters } from "../SpriteMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface SpriteNodeMaterialParameters extends NodeMaterialParameters, SpriteMaterialParameters {