@types/three 0.159.0 → 0.161.0

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

@@ -0,0 +1,33 @@
+import { FramebufferTexture } from '../../../../src/Three.js';
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { NodeUpdateType } from '../core/constants.js';
+
+export default class ViewportTextureNode extends TextureNode {
+    generateMipmaps: boolean;
+
+    readonly isOutputTextureNode: true;
+
+    updateBeforeType: NodeUpdateType;
+
+    constructor(uvNode?: Node, levelNode?: Node | null, framebufferTexture?: FramebufferTexture | null);
+}
+
+export const viewportTexture: (
+    uvNode?: Node,
+    levelNode?: Node | null,
+    framebufferTexture?: FramebufferTexture | null,
+) => ShaderNodeObject<ViewportTextureNode>;
+export const viewportMipTexture: (
+    uvNode?: Node,
+    levelNode?: Node | null,
+    framebufferTexture?: FramebufferTexture | null,
+) => ShaderNodeObject<Node>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        viewportTexture: typeof viewportTexture;
+        viewportMipTexture: typeof viewportMipTexture;
+    }
+}

three/examples/jsm/nodes/fog/FogExp2Node.d.ts

@@ -1,5 +1,6 @@
 import Node from '../core/Node.js';
 import FogNode from './FogNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FogExp2Node extends FogNode {
     isFogExp2Node: true;
@@ -7,3 +8,11 @@ export default class FogExp2Node extends FogNode {
 
     constructor(colorNode: Node, densityNode: Node);
 }
+
+export const densityFog: (colorNode: Node, densityNode: Node) => ShaderNodeObject<FogExp2Node>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        densityFog: typeof densityFog;
+    }
+}

three/examples/jsm/nodes/fog/FogNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FogNode extends Node {
     isFogNode: true;
@@ -8,3 +9,11 @@ export default class FogNode extends Node {
     constructor(colorNode: Node, factorNode: Node);
     mixAssign(outputNode: Node): Node;
 }
+
+export const fog: (colorNode: NodeRepresentation, factorNode: NodeRepresentation) => ShaderNodeObject<FogNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        fog: typeof fog;
+    }
+}

three/examples/jsm/nodes/fog/FogRangeNode.d.ts

@@ -1,5 +1,6 @@
 import FogNode from './FogNode.js';
 import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class FogRangeNode extends FogNode {
     isFogRangeNode: true;
@@ -8,3 +9,11 @@ export default class FogRangeNode extends FogNode {
 
     constructor(colorNode: Node, nearNode: Node, farNode: Node);
 }
+
+export const rangeFog: (colorNode: Node, nearNode: Node, farNode: Node) => ShaderNodeObject<FogRangeNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        rangeFog: typeof rangeFog;
+    }
+}

three/examples/jsm/nodes/functions/BSDF/BRDF_GGX.d.ts

@@ -1,6 +1,13 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
 
-declare const BRDF_GGX: ShaderNode<{ lightDirection: Node; f0: Node; f90: Node; roughness: Node }>;
+declare const BRDF_GGX: (args: {
+    lightDirection: Node;
+    f0: Node;
+    f90: Node;
+    roughness: Node;
+    iridescenceFresnel?: Node;
+}) => ShaderNodeObject<OperatorNode>;
 
 export default BRDF_GGX;

three/examples/jsm/nodes/functions/BSDF/BRDF_Lambert.d.ts

@@ -1,6 +1,7 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
 
-declare const BRDF_Lambert: ShaderNode<{ diffuseColor: Node }>;
+declare const BRDF_Lambert: (args: { diffuseColor: Node }) => ShaderNodeObject<OperatorNode>;
 
 export default BRDF_Lambert;

three/examples/jsm/nodes/functions/BSDF/BRDF_Sheen.d.ts

@@ -0,0 +1,7 @@
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
+import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
+
+declare const BRDF_Sheen: (args: { lightDirection: Node }) => ShaderNodeObject<OperatorNode>;
+
+export default BRDF_Sheen;

three/examples/jsm/nodes/functions/BSDF/DFGApprox.d.ts

@@ -1,10 +1,11 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeElements.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
 
 // Analytical approximation of the DFG LUT, one half of the
 // split-sum approximation used in indirect specular lighting.
 // via 'environmentBRDF' from "Physically Based Shading on Mobile"
 // https://www.unrealengine.com/blog/physically-based-shading-on-mobile
-declare const DFGApprox: ShaderNode<{ roughness: Node }>;
+declare const DFGApprox: (args: { roughness: Node; dotNV: Node }) => ShaderNodeObject<OperatorNode>;
 
 export default DFGApprox;

three/examples/jsm/nodes/functions/BSDF/D_GGX.d.ts

@@ -1,9 +1,10 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
 
 // Microfacet Models for Refraction through Rough Surfaces - equation (33)
 // http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
 // alpha is "roughness squared" in Disney’s reparameterization
-declare const D_GGX: ShaderNode<{ alpha: Node; dotNH: Node }>;
+declare const D_GGX: (args: { alpha: Node; dotNH: Node }) => ShaderNodeObject<OperatorNode>;
 
 export default D_GGX;

three/examples/jsm/nodes/functions/BSDF/F_Schlick.d.ts

@@ -1,6 +1,7 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNodeObject } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
+import OperatorNode from '../../math/OperatorNode.js';
 
-declare const F_Schlick: ShaderNode<{ f0: Node; f90: Node; dotVH: Node }>;
+declare const F_Schlick: (args: { f0: Node; f90: Node; dotVH: Node }) => ShaderNodeObject<OperatorNode>;
 
 export default F_Schlick;

three/examples/jsm/nodes/functions/BSDF/V_GGX_SmithCorrelated.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 declare const V_GGX_SmithCorrelated: ShaderNode<{ alpha: Node; dotNL: Node; dotNV: Node }>;

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

@@ -0,0 +1,7 @@
+import LightingModel from '../core/LightingModel.js';
+
+export default class PhongLightingModel extends LightingModel {
+    specular: boolean;
+
+    constructor(specular?: boolean);
+}

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

@@ -1,11 +1,20 @@
-import { ShaderNode } from '../shadernode/ShaderNodeElements.js';
+import LightingModel from '../core/LightingModel.js';
 import Node from '../core/Node.js';
 
-declare const PhysicalLightingModel: {
-    direct: ShaderNode<{ lightDirection: Node; lightColor: Node; reflectedLight: Node }>;
-    indirectDiffuse: ShaderNode<{ irradiance: Node; reflectedLight: Node }>;
-    indirectSpecular: ShaderNode<{ radiance: Node; iblIrradiance: Node; reflectedLight: Node }>;
-    ambientOcclusion: ShaderNode<{ ambientOcclusion: Node; reflectedLight: Node }>;
-};
+export default class PhysicalLightingModel extends LightingModel {
+    clearcoat: boolean;
+    sheen: boolean;
+    iridescence: boolean;
 
-export default PhysicalLightingModel;
+    clearcoatRadiance: Node | null;
+    clearcoatSpecularDirect: Node | null;
+    clearcoatSpecularIndirect: Node | null;
+    sheenSpecularDirect: Node | null;
+    sheenSpecularIndirect: Node | null;
+    iridescenceFresnel: Node | null;
+    iridescenceF0: Node | null;
+
+    constructor(clearcoat?: boolean, sheen?: boolean, iridescence?: boolean);
+
+    computeMultiscattering(singleScatter: Node, multiScatter: Node, specularF90?: Node): void;
+}

three/examples/jsm/nodes/functions/material/getGeometryRoughness.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeBaseElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 
 declare const getGeometryRoughness: ShaderNode;
 

three/examples/jsm/nodes/functions/material/getRoughness.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNode } from '../../shadernode/ShaderNodeElements.js';
+import { ShaderNode } from '../../shadernode/ShaderNode.js';
 import Node from '../../core/Node.js';
 
 declare const getRoughness: ShaderNode<{ roughness: Node }>;

three/examples/jsm/nodes/geometry/RangeNode.d.ts

@@ -1,6 +1,7 @@
 import { Color, Vector2, Vector3, Vector4 } from '../../../../src/Three.js';
 import Node from '../core/Node.js';
 import NodeBuilder from '../core/NodeBuilder.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export type RangeModeBound = number | Color | Vector2 | Vector3 | Vector4;
 
@@ -11,3 +12,5 @@ export default class RangeNode extends Node {
     constructor(min: RangeModeBound, max: RangeModeBound);
     getVectorLength(builder: NodeBuilder): number;
 }
+
+export const range: (min: RangeModeBound, max: RangeModeBound) => ShaderNodeObject<RangeNode>;

three/examples/jsm/nodes/gpgpu/ComputeNode.d.ts

@@ -1,4 +1,5 @@
 import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class ComputeNode extends Node {
     isComputeNode: true;
@@ -9,3 +10,15 @@ export default class ComputeNode extends Node {
 
     constructor(computeNode: Node, count: number, workgroupSize?: number[]);
 }
+
+export const compute: (
+    node: NodeRepresentation,
+    count: number,
+    workgroupSize: number[],
+) => ShaderNodeObject<ComputeNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        compute: typeof compute;
+    }
+}

three/examples/jsm/nodes/lighting/LightingContextNode.d.ts

@@ -1,15 +1,27 @@
 import ContextNode from '../core/ContextNode.js';
 import Node from '../core/Node.js';
-import { ShaderNode } from '../Nodes.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import LightingModel, { LightingModelIndirectInput } from '../core/LightingModel.js';
 
-export interface LightingModelNode {
-    indirectDiffuse?: ShaderNode;
-    indirectSpecular?: ShaderNode;
-    ambientOcclusion?: ShaderNode;
+export default class LightingContextNode extends ContextNode {
+    lightingModelNode: LightingModel | null;
+    backdropNode: Node | null;
+    backdropAlphaNode: Node | null;
+
+    constructor(
+        node: Node,
+        lightingModel?: LightingModel | null,
+        backdropNode?: Node | null,
+        backdropAlphaNode?: Node | null,
+    );
+
+    getContext(): LightingModelIndirectInput;
 }
 
-export default class LightingContextNode extends ContextNode {
-    lightingModelNode: LightingModelNode | null;
+export const lightingContext: (node: Node, lightingModelNode?: LightingModel) => ShaderNodeObject<LightingContextNode>;
 
-    constructor(node: Node, lightingModelNode?: LightingModelNode | null);
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        lightingContext: typeof lightingContext;
+    }
 }

three/examples/jsm/nodes/lighting/LightsNode.d.ts

@@ -1,6 +1,7 @@
 import { Light } from '../../../../src/Three.js';
 import Node from '../core/Node.js';
 import LightingNode from './LightingNode.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class LightsNode extends Node {
     lightNodes: LightingNode[];
@@ -17,3 +18,5 @@ export default class LightsNode extends Node {
         lightNodeClass: { new (light: T): LightingNode },
     ): void;
 }
+
+export const lights: (lights: Light[]) => ShaderNodeObject<LightsNode>;

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

@@ -2,8 +2,7 @@ import NodeMaterial from './NodeMaterial.js';
 import { ShaderMaterialParameters } from '../../../../src/Three.js';
 
 export default class LineBasicNodeMaterial extends NodeMaterial {
-    isLineBasicNodeMaterial: true;
+    readonly isLineBasicNodeMaterial: true;
 
     constructor(parameters?: ShaderMaterialParameters);
-    copy(source: LineBasicNodeMaterial): this;
 }

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

@@ -1,17 +1,9 @@
-import NodeMaterial from './NodeMaterial.js';
-import LineBasicNodeMaterial from './LineBasicNodeMaterial.js';
-import MeshBasicNodeMaterial from './MeshBasicNodeMaterial.js';
-import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
-import PointsNodeMaterial from './PointsNodeMaterial.js';
-import SpriteNodeMaterial from './SpriteNodeMaterial.js';
-import MeshPhysicalNodeMaterial from './MeshPhysicalNodeMaterial.js';
-
-export {
-    NodeMaterial,
-    LineBasicNodeMaterial,
-    MeshBasicNodeMaterial,
-    MeshPhysicalNodeMaterial,
-    MeshStandardNodeMaterial,
-    PointsNodeMaterial,
-    SpriteNodeMaterial,
-};
+export { default as NodeMaterial } from './NodeMaterial.js';
+export { default as LineBasicNodeMaterial } from './LineBasicNodeMaterial.js';
+export { default as MeshBasicNodeMaterial } from './MeshBasicNodeMaterial.js';
+export { default as MeshPhongNodeMaterial } from './MeshPhongNodeMaterial.js';
+export { default as MeshStandardNodeMaterial } from './MeshStandardNodeMaterial.js';
+export { default as MeshPhysicalNodeMaterial } from './MeshPhysicalNodeMaterial.js';
+export { default as MeshSSSPhysicalNodeMaterial } from './MeshSSSNodeMaterial.js';
+export { default as PointsNodeMaterial } from './PointsNodeMaterial.js';
+export { default as SpriteNodeMaterial } from './SpriteNodeMaterial.js';

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

@@ -2,9 +2,7 @@ import NodeMaterial from './NodeMaterial.js';
 import { ShaderMaterialParameters } from '../../../../src/Three.js';
 
 export default class MeshBasicNodeMaterial extends NodeMaterial {
-    isMeshBasicNodeMaterial: true;
-    lights: true;
+    readonly isMeshBasicNodeMaterial: true;
 
-    constructor(paramters?: ShaderMaterialParameters);
-    copy(source: MeshBasicNodeMaterial): this;
+    constructor(parameters?: ShaderMaterialParameters);
 }

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

@@ -0,0 +1,12 @@
+import { ShaderMaterialParameters } from '../../../../src/Three.js';
+import NodeMaterial from './NodeMaterial.js';
+import Node from '../core/Node.js';
+
+export default class MeshPhongNodeMaterial extends NodeMaterial {
+    readonly isMeshPhongNodeMaterial: true;
+
+    shininessNode: Node | null;
+    specularNode: Node | null;
+
+    constructor(parameters?: ShaderMaterialParameters);
+}

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

@@ -1,12 +1,23 @@
 import { ShaderMaterialParameters } from '../../../../src/Three.js';
-import { Swizzable, CheckerNode, Node } from '../Nodes.js';
 
 import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
+import Node from '../core/Node.js';
 
 export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
-    iridescenceNode: null | Swizzable<CheckerNode>;
-    iridescenceIORNode: null | Swizzable;
-    iridescenceThicknessNode: null | Swizzable;
+    readonly isMeshPhysicalNodeMaterial: true;
+
+    clearcoatNode: Node | null;
+    clearcoatRoughnessNode: Node | null;
+    clearcoatNormalNode: Node | null;
+
+    sheenNode: Node | null;
+    sheenRoughnessNode: Node | null;
+
+    iridescenceNode: Node | null;
+    iridescenceIORNode: Node | null;
+    iridescenceThicknessNode: Node | null;
+
+    iorNode?: Node | null;
 
     specularIntensityNode: Node | null;
     specularColorNode: Node | null;
@@ -16,7 +27,5 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     attenuationDistanceNode: Node | null;
     attenuationColorNode: Node | null;
 
-    constructor(parameters: ShaderMaterialParameters);
-
-    copy(source: MeshPhysicalNodeMaterial): this;
+    constructor(parameters?: ShaderMaterialParameters);
 }

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

@@ -0,0 +1,17 @@
+import { ShaderMaterialParameters } from '../../../../src/Three.js';
+import Node from '../core/Node.js';
+import ConstNode from '../core/ConstNode.js';
+import MeshPhysicalNodeMaterial from './MeshPhysicalNodeMaterial.js';
+
+export default class MeshSSSNodeMaterial extends MeshPhysicalNodeMaterial {
+    thicknessColorNode: Node | null;
+    thicknessDistortionNode: ConstNode<number>;
+    thicknessAmbientNode: ConstNode<number>;
+    thicknessAttenuationNode: ConstNode<number>;
+    thicknessPowerNode: ConstNode<number>;
+    thicknessScaleNode: ConstNode<number>;
+
+    constructor(parameters?: ShaderMaterialParameters);
+
+    get useSSS(): boolean;
+}

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

@@ -3,16 +3,12 @@ import Node from '../core/Node.js';
 import NodeMaterial from './NodeMaterial.js';
 
 export default class MeshStandardNodeMaterial extends NodeMaterial {
-    isMeshStandardNodeMaterial: true;
+    readonly isMeshStandardNodeMaterial: true;
 
     emissiveNode: Node | null;
 
     metalnessNode: Node | null;
     roughnessNode: Node | null;
 
-    clearcoatNode: Node | null;
-    clearcoatRoughnessNode: Node | null;
-
     constructor(paramters?: ShaderMaterialParameters);
-    copy(source: MeshStandardNodeMaterial): this;
 }

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

@@ -1,17 +1,34 @@
-import { Material, ShaderMaterial } from '../../../../src/Three.js';
+import {
+    LineBasicMaterial,
+    Material,
+    MeshBasicMaterial,
+    MeshPhongMaterial,
+    MeshPhysicalMaterial,
+    MeshStandardMaterial,
+    PointsMaterial,
+    ShaderMaterial,
+    SpriteMaterial,
+} from '../../../../src/Three.js';
 import NodeBuilder from '../core/NodeBuilder.js';
 import Node from '../core/Node.js';
-import { LightingModelNode } from '../lighting/LightingContextNode.js';
+import LineBasicNodeMaterial from './LineBasicNodeMaterial.js';
+import MeshBasicNodeMaterial from './MeshBasicNodeMaterial.js';
+import MeshPhysicalNodeMaterial from './MeshPhysicalNodeMaterial.js';
+import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
+import PointsNodeMaterial from './PointsNodeMaterial.js';
+import SpriteNodeMaterial from './SpriteNodeMaterial.js';
+import LightsNode from '../lighting/LightsNode.js';
+import LightingModel from '../core/LightingModel.js';
+import MeshPhongNodeMaterial from './MeshPhongNodeMaterial.js';
 
 export default class NodeMaterial extends ShaderMaterial {
-    isNodeMaterial: true;
+    readonly isNodeMaterial: true;
 
-    type: string;
+    normals: boolean;
 
-    lights: true;
-    normals: true;
+    colorSpaced: boolean;
 
-    lightsNode: Node | null;
+    lightsNode: LightsNode | null;
     envNode: Node | null;
 
     colorNode: Node | null;
@@ -23,16 +40,38 @@ export default class NodeMaterial extends ShaderMaterial {
 
     positionNode: Node | null;
 
+    depthNode: Node | null;
+    shadowNode: Node | null;
+
+    outputNode: Node | null;
+
+    fragmentNode: Node | null;
+    vertexNode: Node | null;
+
     constructor();
 
     build(builder: NodeBuilder): void;
-    customProgramCacheKey(): string;
-    generatePosition(builder: NodeBuilder): void;
-    generateDiffuseColor(builder: NodeBuilder): void;
-    generateLight(
-        builder: NodeBuilder,
-        lights: { diffuseColorNode: Node; lightingModelNode: LightingModelNode; lightsNode?: Node },
-    ): void;
-    generateOutput(builder: NodeBuilder, lights: { diffuseColorNode: Node; outgoingLightNode: Node }): void;
-    static fromMaterial(m: Material): NodeMaterial;
+    setup(builder: NodeBuilder): void;
+    setupDepth(builder: NodeBuilder): void;
+    setupPosition(builder: NodeBuilder): Node;
+    setupDiffuseColor(builder: NodeBuilder): void;
+    setupVariants(builder: NodeBuilder): void;
+    setupNormal(builder: NodeBuilder): void;
+    getEnvNode(builder: NodeBuilder): Node | null;
+    setupLights(builder: NodeBuilder): LightsNode;
+    setupLightingModel(builder: NodeBuilder): LightingModel;
+    setupLighting(builder: NodeBuilder): Node;
+    setupOutput(builder: NodeBuilder, outputNode: Node): Node;
+
+    setDefaultValues(material: Material): void;
+
+    static fromMaterial(material: LineBasicMaterial): LineBasicNodeMaterial;
+    static fromMaterial(material: MeshBasicMaterial): MeshBasicNodeMaterial;
+    static fromMaterial(material: MeshPhongMaterial): MeshPhongNodeMaterial;
+    static fromMaterial(material: MeshPhysicalMaterial): MeshPhysicalNodeMaterial;
+    static fromMaterial(material: MeshStandardMaterial): MeshStandardNodeMaterial;
+    static fromMaterial(material: PointsMaterial): PointsNodeMaterial;
+    static fromMaterial(material: SpriteMaterial): SpriteNodeMaterial;
+    static fromMaterial(material: NodeMaterial): NodeMaterial;
+    static fromMaterial(material: Material): NodeMaterial;
 }

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

@@ -3,13 +3,7 @@ import { ShaderMaterialParameters } from '../../../../src/Three.js';
 import { Node } from '../Nodes.js';
 
 export default class PointsNodeMaterial extends NodeMaterial {
-    isPointsNodeMateria: true;
-    colorNode: Node | null;
-    opacityNode: Node | null;
-    alphaTestNode: Node | null;
-    lightNode: Node | null;
-    sizeNode: Node | null;
-    positionNode: Node | null;
+    readonly isPointsNodeMaterial: true;
+
     constructor(parameters?: ShaderMaterialParameters);
-    copy(source: PointsNodeMaterial): this;
 }

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

@@ -6,18 +6,8 @@ import Node from '../core/Node.js';
 export default class SpriteNodeMaterial extends NodeMaterial {
     isSpriteNodeMaterial: true;
 
-    colorNode: Node | null;
-    opacityNode: Node | null;
-
-    alphaTestNode: Node | null;
-
-    lightNode: Node | null;
-
-    positionNode: Node | null;
     rotationNode: Node | null;
     scaleNode: Node | null;
 
     constructor(parameters?: ShaderMaterialParameters);
-    generatePosition(builder: NodeBuilder): void;
-    copy(source: SpriteNodeMaterial): this;
 }