@types/three 0.165.0 → 0.167.0

three/src/nodes/display/TransitionNode.d.ts

@@ -0,0 +1,41 @@
+import TextureNode from "../accessors/TextureNode.js";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import UniformNode from "../core/UniformNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+declare class TransitionNode extends TempNode {
+    textureNodeA: TextureNode;
+    textureNodeB: TextureNode;
+    mixTextureNode: TextureNode;
+
+    mixRatioNode: Node;
+    thresholdNode: Node;
+    useTextureNode: Node;
+
+    constructor(
+        textureNodeA: TextureNode,
+        textureNodeB: TextureNode,
+        mixTextureNode: TextureNode,
+        mixRatioNode: Node,
+        thresholdNode: Node,
+        useTextureNode: Node,
+    );
+}
+
+export const transition: (
+    node: NodeRepresentation,
+    nodeB: NodeRepresentation,
+    mixTexture: NodeRepresentation,
+    mixRatio: UniformNode<number>,
+    threshold: UniformNode<number>,
+    useTexture: UniformNode<number>,
+) => ShaderNodeObject<TransitionNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        transition: typeof transition;
+    }
+}
+
+export default TransitionNode;

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

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

three/src/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 → src}/nodes/functions/BSDF/V_GGX_SmithCorrelated_Anisotropic.d.ts

@@ -1,5 +1,5 @@
 import Node from "../../core/Node.js";
-import MathNode from "../../math/MathNode";
+import MathNode from "../../math/MathNode.js";
 import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
 declare const V_GGX_SmithCorrelated: (inputs: {

three/src/nodes/functions/BasicLightingModel.d.ts

@@ -0,0 +1,7 @@
+import LightingModel from "../core/LightingModel.js";
+
+declare class BasicLightingModel extends LightingModel {
+    constructor();
+}
+
+export default BasicLightingModel;

three/src/nodes/functions/PhongLightingModel.d.ts

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

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

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

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

@@ -1,4 +1,4 @@
-import { Light } from "three";
+import { Light } from "../../lights/Light.js";
 import LightingNode from "./LightingNode.js";
 
 export default class AnalyticLightNode<T extends Light> extends LightingNode {

three/src/nodes/lighting/BasicEnvironmentNode.d.ts

@@ -0,0 +1,10 @@
+import Node from "../core/Node.js";
+import LightingNode from "./LightingNode.js";
+
+declare class BasicEnvironmentNode extends LightingNode {
+    envNode: Node | null;
+
+    constructor(envNode?: Node | null);
+}
+
+export default BasicEnvironmentNode;

three/src/nodes/lighting/BasicLightMapNode.d.ts

@@ -0,0 +1,8 @@
+import Node from "../core/Node.js";
+import LightingNode from "./LightingNode.js";
+
+declare class BasicLightMapNode extends LightingNode {
+    constructor(lightMapNode?: Node | null);
+}
+
+export default BasicLightMapNode;

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

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

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

@@ -1,5 +1,7 @@
 import Node from "../core/Node.js";
 
 export default abstract class LightingNode extends Node {
+    readonly isLightingNode: true;
+
     constructor();
 }

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

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

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

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

three/src/nodes/lighting/RectAreaLightNode.d.ts

@@ -0,0 +1,21 @@
+import { RectAreaLight } from "../../lights/RectAreaLight.js";
+import { DataTexture } from "../../textures/DataTexture.js";
+import Node from "../core/Node.js";
+import AnalyticLightNode from "./AnalyticLightNode.js";
+
+export interface RectAreaLightTexturesLib {
+    LTC_HALF_1: DataTexture;
+    LTC_HALF_2: DataTexture;
+
+    LTC_FLOAT_1: DataTexture;
+    LTC_FLOAT_2: DataTexture;
+}
+
+export default class RectAreaLightNode extends AnalyticLightNode<RectAreaLight> {
+    halfHeight: Node;
+    halfWidth: Node;
+
+    constructor(light?: RectAreaLight | null);
+
+    static setLTC(ltc: RectAreaLightTexturesLib): void;
+}

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

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

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

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

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

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

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

@@ -1,4 +1,6 @@
-import { Material, ObjectLoader, Texture } from "three";
+import { ObjectLoader } from "../../loaders/ObjectLoader.js";
+import { Material } from "../../materials/Material.js";
+import { Texture } from "../../textures/Texture.js";
 import { NodeLoaderResult } from "./NodeLoader.js";
 
 export default class NodeObjectLoader extends ObjectLoader {

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

@@ -0,0 +1,53 @@
+import { LineDashedMaterialParameters } from "../../materials/LineDashedMaterial.js";
+import { Color } from "../../math/Color.js";
+import { Texture } from "../../textures/Texture.js";
+import Node from "../core/Node.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface Line2NodeMaterialParameters extends NodeMaterialParameters, LineDashedMaterialParameters {
+    dashed?: boolean | undefined;
+}
+
+export default class Line2NodeMaterial extends NodeMaterial {
+    lights: boolean;
+
+    // Properties from LineDashedMaterial
+    readonly isLineDashedMaterial: true;
+    scale: number;
+    dashSize: number;
+    gapSize: number;
+
+    // Properties from LineBasicMaterial
+    readonly isLineBasicMaterial: true;
+    color: Color;
+    fog: boolean;
+    linewidth: number;
+    linecap: string;
+    linejoin: string;
+    map: Texture | null;
+
+    useAlphaToCoverage: boolean;
+    useColor: boolean;
+    useDash: boolean;
+    useWorldUnits: boolean;
+
+    dashOffset: number;
+    lineWidth: number;
+
+    lineColorNode: Node | null;
+
+    offsetNode: Node | null;
+    dashScaleNode: Node | null;
+    dashSizeNode: Node | null;
+    gapSizeNode: Node | null;
+
+    constructor(parameters?: Line2NodeMaterialParameters);
+
+    setupShaders(): void;
+
+    get worldUnits(): boolean;
+    set worldUnits(value: boolean);
+
+    get dashed(): boolean;
+    set dashed(value: boolean);
+}

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

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

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

@@ -1,3 +1,4 @@
+export { default as Line2NodeMaterial } from "./Line2NodeMaterial.js";
 export { default as LineBasicNodeMaterial } from "./LineBasicNodeMaterial.js";
 export { default as MeshBasicNodeMaterial } from "./MeshBasicNodeMaterial.js";
 export { default as MeshMatcapNodeMaterial } from "./MeshMatcapNodeMaterial.js";
@@ -7,7 +8,7 @@ export { default as MeshPhysicalNodeMaterial } from "./MeshPhysicalNodeMaterial.
 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 { addNodeMaterial, createNodeMaterialFromType, 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/{examples/jsm → src}/nodes/materials/MeshBasicNodeMaterial.d.ts

@@ -1,4 +1,8 @@
-import { Color, Combine, Euler, MeshBasicMaterialParameters, Texture } from "three";
+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 NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshBasicMaterialParameters {

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

@@ -1,4 +1,8 @@
-import { Color, MeshMatcapMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
+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 NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshMatcapNodeMaterialParameters extends NodeMaterialParameters, MeshMatcapMaterialParameters {

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

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

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

@@ -1,6 +1,10 @@
-import { Color, Combine, Euler, MeshPhongMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
+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 { Texture } from "../../textures/Texture.js";
 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 +13,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;

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

@@ -1,7 +1,8 @@
-import { Color, MeshPhysicalMaterialParameters, Texture, Vector2 } from "three";
-
+import { MeshPhysicalMaterialParameters } from "../../materials/MeshPhysicalMaterial.js";
+import { Color } from "../../math/Color.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Texture } from "../../textures/Texture.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import MeshStandardNodeMaterial, { MeshStandardNodeMaterialParameters } from "./MeshStandardNodeMaterial.js";
 
 export interface MeshPhysicalNodeMaterialParameters
@@ -12,29 +13,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;
-    dispersionNode: 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;

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

@@ -0,0 +1,16 @@
+import ConstNode from "../core/ConstNode.js";
+import Node from "../core/Node.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>;
+
+    constructor(parameters?: MeshPhysicalNodeMaterialParameters);
+
+    get useSSS(): boolean;
+}

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

@@ -1,6 +1,10 @@
-import { Color, Euler, MeshStandardMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
+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 { Texture } from "../../textures/Texture.js";
 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 +13,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;

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

@@ -1,4 +1,8 @@
-import { Color, MeshToonMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
+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 NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshToonNodeMaterialParameters extends NodeMaterialParameters, MeshToonMaterialParameters {

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

@@ -1,24 +1,21 @@
-import {
-    LineBasicMaterial,
-    Material,
-    MaterialParameters,
-    MeshBasicMaterial,
-    MeshMatcapMaterial,
-    MeshNormalMaterial,
-    MeshPhongMaterial,
-    MeshPhysicalMaterial,
-    MeshStandardMaterial,
-    MeshToonMaterial,
-    PointsMaterial,
-    ShadowMaterial,
-    SpriteMaterial,
-} from "three";
+import { LineBasicMaterial } from "../../materials/LineBasicMaterial.js";
+import { Material, MaterialParameters } from "../../materials/Material.js";
+import { MeshBasicMaterial } from "../../materials/MeshBasicMaterial.js";
+import { MeshMatcapMaterial } from "../../materials/MeshMatcapMaterial.js";
+import { MeshNormalMaterial } from "../../materials/MeshNormalMaterial.js";
+import { MeshPhongMaterial } from "../../materials/MeshPhongMaterial.js";
+import { MeshPhysicalMaterial } from "../../materials/MeshPhysicalMaterial.js";
+import { MeshStandardMaterial } from "../../materials/MeshStandardMaterial.js";
+import { MeshToonMaterial } from "../../materials/MeshToonMaterial.js";
+import { PointsMaterial } from "../../materials/PointsMaterial.js";
+import { ShadowMaterial } from "../../materials/ShadowMaterial.js";
+import { SpriteMaterial } from "../../materials/SpriteMaterial.js";
 import ClippingNode from "../accessors/ClippingNode.js";
 import LightingModel from "../core/LightingModel.js";
+import MRTNode from "../core/MRTNode.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";
@@ -36,67 +33,72 @@ export interface NodeMaterialParameters extends MaterialParameters {
 
     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 Material {
     readonly isNodeMaterial: true;
 
+    fog: boolean;
+    lights: boolean;
     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;
+    mrtNode: MRTNode | 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;
     setupVariants(builder: NodeBuilder): void;
     setupNormal(builder: NodeBuilder): void;
-    getEnvNode(builder: NodeBuilder): Node | null;
+    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;
@@ -117,3 +119,6 @@ export default class NodeMaterial extends Material {
     static fromMaterial(material: NodeMaterial): NodeMaterial;
     static fromMaterial(material: Material): NodeMaterial;
 }
+
+export function addNodeMaterial(type: string, nodeMaterial: typeof NodeMaterial): void;
+export function createNodeMaterialFromType(type: string): NodeMaterial;