@types/three 0.161.1 → 0.162.0

three/examples/jsm/nodes/accessors/UniformsNode.d.ts

@@ -0,0 +1,25 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import ArrayElementNode from "../utils/ArrayElementNode.js";
+import BufferNode from "./BufferNode.js";
+
+declare class UniformsElementNode extends ArrayElementNode {
+    constructor(arrayBuffer: Node, indexNode: Node);
+}
+
+export default class UniformsNode extends BufferNode {
+    array: unknown[];
+    elementType: string | null;
+
+    readonly isArrayBufferNode: true;
+
+    constructor(value: unknown[], elementType?: string | null);
+
+    getElementType(): string | null;
+
+    getElementLength(): number;
+
+    element(indexNode: number): ShaderNodeObject<UniformsElementNode>;
+}
+
+export const uniforms: (values: unknown[], nodeType?: string | null) => ShaderNodeObject<UniformsNode>;

three/examples/jsm/nodes/core/AssignNode.d.ts

@@ -1,11 +1,12 @@
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import Node from "./Node.js";
+import NodeBuilder from "./NodeBuilder.js";
 import TempNode from "./TempNode.js";
 
 export default class AssignNode extends TempNode {
     constructor(targetNode: Node, sourceNode: Node);
 
-    hasDependencies(): false;
+    needsSplitAssign(builder: NodeBuilder): boolean;
 }
 
 export const assign: (targetNode: NodeRepresentation, sourceNode: NodeRepresentation) => ShaderNodeObject<AssignNode>;

three/examples/jsm/nodes/core/Node.d.ts

@@ -36,6 +36,8 @@ export default abstract class Node {
 
     setup(builder: NodeBuilder): Node | null;
 
+    increaseUsage(builder: NodeBuilder): number;
+
     analyze(builder: NodeBuilder): void;
 
     generate(builder: NodeBuilder, output?: string | null): string;

three/examples/jsm/nodes/core/NodeBuilder.d.ts

@@ -1,12 +1,4 @@
-import {
-    BufferGeometry,
-    Material,
-    Object3D,
-    Renderer,
-    Texture,
-    TextureEncoding,
-    WebGLRenderTarget,
-} from "../../../../src/Three.js";
+import { BufferGeometry, Material, Object3D, Renderer } from "three";
 import FogNode from "../fog/FogNode.js";
 import LightsNode from "../lighting/LightsNode.js";
 import { AnyObject, NodeShaderStage, NodeTypeOption } from "./constants.js";
@@ -97,7 +89,6 @@ export default abstract class NodeBuilder {
     isMatrix(type: NodeTypeOption): boolean;
     isReference(type: NodeTypeOption): boolean;
     isShaderStage(shaderStage: NodeShaderStage): boolean;
-    getTextureEncodingFromMap(map: Texture | WebGLRenderTarget | unknown): TextureEncoding;
     getComponentType(type: NodeTypeOption): NodeTypeOption;
     getVectorType(type: NodeTypeOption): NodeTypeOption;
     getTypeFromLength(length: number): NodeTypeOption;

three/examples/jsm/nodes/core/NodeFrame.d.ts

@@ -1,4 +1,4 @@
-import { Camera, Material, Object3D, Renderer, Scene } from "../../../../src/Three.js";
+import { Camera, Material, Object3D, Renderer, Scene } from "three";
 
 import Node from "./Node.js";
 

three/examples/jsm/nodes/core/NodeUtils.d.ts

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

three/examples/jsm/nodes/core/TempNode.d.ts

@@ -7,5 +7,5 @@ export default class TempNode extends Node {
 
     constructor(type: NodeTypeOption | null);
 
-    hasDependencies(builder: NodeBuilder): void;
+    hasDependencies(builder: NodeBuilder): boolean;
 }

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

@@ -1,25 +1,24 @@
-import { Vector2 } from "../../../../src/Three.js";
-import TextureNode from "../accessors/TextureNode.js";
+import { Vector2 } from "three";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class AnamorphicNode extends TempNode {
-    textureNode: TextureNode;
+    textureNode: Node;
     thresholdNode: Node;
     scaleNode: Node;
     samples: number;
     resolution: Vector2;
 
-    constructor(textureNode: TextureNode, thresholdNode: Node, scaleNode: Node, samples: number);
+    constructor(textureNode: Node, thresholdNode: Node, scaleNode: Node, samples: number);
 
-    getTextureNode(): TextureNode;
+    getTextureNode(): Node;
 
     setSize(width: number, height: number): void;
 }
 
 export const anamorphic: (
-    node: TextureNode,
+    node: Node,
     threshold?: NodeRepresentation,
     scale?: NodeRepresentation,
     samples?: NodeRepresentation,

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

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

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

@@ -1,4 +1,4 @@
-import { Vector2 } from "../../../../src/Three.js";
+import { Vector2 } from "three";
 import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";

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

@@ -1,4 +1,4 @@
-import { NormalMapTypes } from "../../../../src/Three.js";
+import { NormalMapTypes } from "three";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import MathNode from "../math/MathNode.js";
@@ -15,8 +15,6 @@ export default class NormalMapNode extends TempNode {
 
 export const normalMap: (node: Node, scaleNode?: Node) => ShaderNodeObject<NormalMapNode>;
 
-export const TBNViewMatrix: ShaderNodeObject<MathNode>;
-
 declare module "../shadernode/ShaderNode.js" {
     interface NodeElements {
         normalMap: typeof normalMap;

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

@@ -1,4 +1,4 @@
-import { Camera, RenderTarget, Scene, Texture } from "../../../../src/Three.js";
+import { Camera, RenderTarget, Scene, Texture } from "three";
 import TextureNode from "../accessors/TextureNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";

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

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

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

@@ -0,0 +1,12 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import ViewportTextureNode from "./ViewportTextureNode.js";
+
+export default class ViewportDepthTextureNode extends ViewportTextureNode {
+    constructor(uvNode?: Node, levelNode?: Node | null);
+}
+
+export const viewportDepthTexture: (
+    uvNode?: NodeRepresentation,
+    levelNode?: NodeRepresentation,
+) => ShaderNodeObject<ViewportDepthTextureNode>;

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

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

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

@@ -1,4 +1,4 @@
-import { Color, Vector2, Vector3, Vector4 } from "../../../../src/Three.js";
+import { Color, Vector2, Vector3, Vector4 } from "three";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";

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

@@ -1,4 +1,4 @@
-import { Light } from "../../../../src/Three.js";
+import { Light } from "three";
 import Node from "../core/Node.js";
 import LightingNode from "./LightingNode.js";
 

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

@@ -1,4 +1,4 @@
-import { HemisphereLight } from "../../../../src/Three.js";
+import { HemisphereLight } from "three";
 import Object3DNode from "../accessors/Object3DNode.js";
 import Node from "../core/Node.js";
 import AnalyticLightNode from "./AnalyticLightNode.js";

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

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

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

@@ -1,4 +1,4 @@
-import { PointLight } from "../../../../src/Three.js";
+import { PointLight } from "three";
 import Node from "../core/Node.js";
 import AnalyticLightNode from "./AnalyticLightNode.js";
 

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

@@ -1,4 +1,4 @@
-import { SpotLight } from "../../../../src/Three.js";
+import { SpotLight } from "three";
 import Node from "../core/Node.js";
 import AnalyticLightNode from "./AnalyticLightNode.js";
 

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

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager, Texture } from "../../../../src/Three.js";
+import { Loader, LoadingManager, Texture } from "three";
 import { AnyJson, Node } from "../Nodes.js";
 
 export interface NodeLoaderResult {

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

@@ -1,4 +1,4 @@
-import { MaterialLoader } from "../../../../src/Three.js";
+import { MaterialLoader } from "three";
 import { NodeLoaderResult } from "./NodeLoader.js";
 
 export default class NodeMaterialLoader extends MaterialLoader {

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

@@ -1,4 +1,4 @@
-import { Material, ObjectLoader, Texture } from "../../../../src/Three.js";
+import { Material, ObjectLoader, Texture } from "three";
 import { AnyJson } from "../core/constants.js";
 import { NodeLoaderResult } from "./NodeLoader.js";
 

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

@@ -1,8 +1,18 @@
-import { ShaderMaterialParameters } from "../../../../src/Three.js";
-import NodeMaterial from "./NodeMaterial.js";
+import { Color, LineBasicMaterialParameters, Texture } from "three";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface LineBasicNodeMaterialParameters extends NodeMaterialParameters, LineBasicMaterialParameters {
+}
 
 export default class LineBasicNodeMaterial extends NodeMaterial {
     readonly isLineBasicNodeMaterial: true;
 
-    constructor(parameters?: ShaderMaterialParameters);
+    // Properties from LineBasicMaterial
+    readonly isLineBasicMaterial: true;
+    color: Color;
+    linecap: string;
+    linejoin: string;
+    map: Texture | null;
+
+    constructor(parameters?: LineBasicNodeMaterialParameters);
 }

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

@@ -1,8 +1,28 @@
-import { ShaderMaterialParameters } from "../../../../src/Three.js";
-import NodeMaterial from "./NodeMaterial.js";
+import { Color, Combine, MeshBasicMaterialParameters, Texture } from "three";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshBasicMaterialParameters {
+}
 
 export default class MeshBasicNodeMaterial extends NodeMaterial {
     readonly isMeshBasicNodeMaterial: true;
 
-    constructor(parameters?: ShaderMaterialParameters);
+    // Properties from MeshBasicMaterial
+    readonly isMeshBasicMaterial: true;
+    color: Color;
+    map: Texture | null;
+    lightMap: Texture | null;
+    lightMapIntensity: number;
+    aoMap: Texture | null;
+    aoMapIntensity: number;
+    specularMap: Texture | null;
+    alphaMap: Texture | null;
+    envMap: Texture | null;
+    combine: Combine;
+    reflectivity: number;
+    refractionRatio: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+
+    constructor(parameters?: MeshBasicNodeMaterialParameters);
 }

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

@@ -1,12 +1,48 @@
-import { ShaderMaterialParameters } from "../../../../src/Three.js";
+import { Color, Combine, MeshPhongMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
 import Node from "../core/Node.js";
-import NodeMaterial from "./NodeMaterial.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshPhongNodeMaterialParameters extends NodeMaterialParameters, MeshPhongMaterialParameters {
+}
 
 export default class MeshPhongNodeMaterial extends NodeMaterial {
     readonly isMeshPhongNodeMaterial: true;
 
-    shininessNode: Node | null;
-    specularNode: Node | null;
+    shininessNode: ShaderNodeObject<Node> | null;
+    specularNode: ShaderNodeObject<Node> | null;
+
+    // Properties from MeshPhongMaterial
+    readonly isMeshPhongMaterial: true;
+    color: Color;
+    specular: Color;
+    shininess: number;
+    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;
+    specularMap: Texture | null;
+    alphaMap: Texture | null;
+    envMap: Texture | null;
+    combine: Combine;
+    reflectivity: number;
+    refractionRatio: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+    flatShading: boolean;
+    metal: boolean;
 
-    constructor(parameters?: ShaderMaterialParameters);
+    constructor(parameters?: MeshPhongNodeMaterialParameters);
 }

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

@@ -1,31 +1,71 @@
-import { ShaderMaterialParameters } from "../../../../src/Three.js";
+import { Color, MeshPhysicalMaterialParameters, Texture, Vector2 } from "three";
 
 import Node from "../core/Node.js";
-import MeshStandardNodeMaterial from "./MeshStandardNodeMaterial.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import MeshStandardNodeMaterial, { MeshStandardNodeMaterialParameters } from "./MeshStandardNodeMaterial.js";
+
+export interface MeshPhysicalNodeMaterialParameters
+    extends MeshStandardNodeMaterialParameters, MeshPhysicalMaterialParameters
+{
+}
 
 export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     readonly isMeshPhysicalNodeMaterial: true;
 
-    clearcoatNode: Node | null;
-    clearcoatRoughnessNode: Node | null;
-    clearcoatNormalNode: Node | null;
+    clearcoatNode: ShaderNodeObject<Node> | null;
+    clearcoatRoughnessNode: ShaderNodeObject<Node> | null;
+    clearcoatNormalNode: ShaderNodeObject<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;
+    // Properties from MeshPhysicalMaterial
+    readonly isMeshPhysicalMaterial: true;
+    clearcoat: number;
+    clearcoatMap: Texture | null;
+    clearcoatRoughness: number;
+    clearcoatRoughnessMap: Texture | null;
+    clearcoatNormalScale: Vector2;
+    clearcoatNormalMap: Texture | null;
+    reflectivity: number;
+    ior: number;
+    sheen: number;
+    sheenColor: Color;
+    sheenColorMap: Texture | null;
+    sheenRoughness: number;
+    sheenRoughnessMap: Texture | null;
+    transmission: number;
+    transmissionMap: Texture | null;
+    thickness: number;
+    thicknessMap: Texture | null;
+    attenuationDistance: number;
+    attenuationColor: Color;
+    specularIntensity: number;
+    specularColor: Color;
+    specularIntensityMap: Texture | null;
+    specularColorMap: Texture | null;
+    iridescenceMap: Texture | null;
+    iridescenceIOR: number;
+    iridescence: number;
+    iridescenceThicknessRange: [number, number];
+    iridescenceThicknessMap: Texture | null;
+    anisotropy?: number;
+    anisotropyRotation?: number;
+    anisotropyMap?: Texture | null;
 
-    constructor(parameters?: ShaderMaterialParameters);
+    constructor(parameters?: MeshPhysicalNodeMaterialParameters);
 }

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

@@ -1,17 +1,17 @@
-import { ShaderMaterialParameters } from "../../../../src/Three.js";
 import ConstNode from "../core/ConstNode.js";
 import Node from "../core/Node.js";
-import MeshPhysicalNodeMaterial from "./MeshPhysicalNodeMaterial.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import MeshPhysicalNodeMaterial, { MeshPhysicalNodeMaterialParameters } 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>;
+    thicknessColorNode: ShaderNodeObject<Node> | null;
+    thicknessDistortionNode: ShaderNodeObject<ConstNode<number>>;
+    thicknessAmbientNode: ShaderNodeObject<ConstNode<number>>;
+    thicknessAttenuationNode: ShaderNodeObject<ConstNode<number>>;
+    thicknessPowerNode: ShaderNodeObject<ConstNode<number>>;
+    thicknessScaleNode: ShaderNodeObject<ConstNode<number>>;
 
-    constructor(parameters?: ShaderMaterialParameters);
+    constructor(parameters?: MeshPhysicalNodeMaterialParameters);
 
     get useSSS(): boolean;
 }

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

@@ -1,14 +1,48 @@
-import { ShaderMaterialParameters } from "../../../../src/Three.js";
+import { Color, MeshStandardMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
 import Node from "../core/Node.js";
-import NodeMaterial from "./NodeMaterial.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshStandardNodeMaterialParameters extends NodeMaterialParameters, MeshStandardMaterialParameters {
+}
 
 export default class MeshStandardNodeMaterial extends NodeMaterial {
     readonly isMeshStandardNodeMaterial: true;
 
-    emissiveNode: Node | null;
+    emissiveNode: ShaderNodeObject<Node> | null;
+
+    metalnessNode: ShaderNodeObject<Node> | null;
+    roughnessNode: ShaderNodeObject<Node> | null;
 
-    metalnessNode: Node | null;
-    roughnessNode: Node | null;
+    // Properties from MeshStandardMaterial
+    readonly isMeshStandardMaterial: true;
+    color: Color;
+    roughness: number;
+    metalness: number;
+    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;
+    roughnessMap: Texture | null;
+    metalnessMap: Texture | null;
+    alphaMap: Texture | null;
+    envMap: Texture | null;
+    envMapIntensity: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+    flatShading: boolean;
 
-    constructor(paramters?: ShaderMaterialParameters);
+    constructor(paramters?: MeshStandardNodeMaterialParameters);
 }

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

@@ -7,12 +7,15 @@ import {
     MeshStandardMaterial,
     PointsMaterial,
     ShaderMaterial,
+    ShaderMaterialParameters,
     SpriteMaterial,
-} from "../../../../src/Three.js";
+} from "three";
+import ClippingNode from "../accessors/ClippingNode.js";
 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 MeshPhongNodeMaterial from "./MeshPhongNodeMaterial.js";
@@ -21,6 +24,32 @@ import MeshStandardNodeMaterial from "./MeshStandardNodeMaterial.js";
 import PointsNodeMaterial from "./PointsNodeMaterial.js";
 import SpriteNodeMaterial from "./SpriteNodeMaterial.js";
 
+export interface NodeMaterialParameters extends ShaderMaterialParameters {
+    normals?: boolean | undefined;
+
+    colorSpaced?: boolean | undefined;
+
+    lightsNode?: ShaderNodeObject<LightsNode> | null | undefined;
+    envNode?: ShaderNodeObject<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;
+
+    positionNode?: ShaderNodeObject<Node> | null | undefined;
+
+    depthNode?: ShaderNodeObject<Node> | null | undefined;
+    shadowNode?: ShaderNodeObject<Node> | null | undefined;
+
+    outputNode?: ShaderNodeObject<Node> | null | undefined;
+
+    fragmentNode?: ShaderNodeObject<Node> | null | undefined;
+    vertexNode?: ShaderNodeObject<Node> | null | undefined;
+}
+
 export default class NodeMaterial extends ShaderMaterial {
     readonly isNodeMaterial: true;
 
@@ -28,30 +57,31 @@ export default class NodeMaterial extends ShaderMaterial {
 
     colorSpaced: boolean;
 
-    lightsNode: LightsNode | null;
-    envNode: Node | null;
+    lightsNode: ShaderNodeObject<LightsNode> | null;
+    envNode: ShaderNodeObject<Node> | null;
 
-    colorNode: Node | null;
-    normalNode: Node | null;
-    opacityNode: Node | null;
-    backdropNode: Node | null;
-    backdropAlphaNode: Node | null;
-    alphaTestNode: 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;
 
-    positionNode: Node | null;
+    positionNode: ShaderNodeObject<Node> | null;
 
-    depthNode: Node | null;
-    shadowNode: Node | null;
+    depthNode: ShaderNodeObject<Node> | null;
+    shadowNode: ShaderNodeObject<Node> | null;
 
-    outputNode: Node | null;
+    outputNode: ShaderNodeObject<Node> | null;
 
-    fragmentNode: Node | null;
-    vertexNode: Node | null;
+    fragmentNode: ShaderNodeObject<Node> | null;
+    vertexNode: ShaderNodeObject<Node> | null;
 
     constructor();
 
     build(builder: NodeBuilder): void;
     setup(builder: NodeBuilder): void;
+    setupClipping(builder: NodeBuilder): ShaderNodeObject<ClippingNode> | null;
     setupDepth(builder: NodeBuilder): void;
     setupPosition(builder: NodeBuilder): Node;
     setupDiffuseColor(builder: NodeBuilder): void;