@types/three 0.161.2 → 0.163.0

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

@@ -1,14 +1,6 @@
-import { Object3D } from "../../../../src/Three.js";
+import { Object3D } from "three";
 import Node from "../core/Node.js";
-
-export type Object3DNodeScope =
-    | typeof Object3DNode.VIEW_MATRIX
-    | typeof Object3DNode.NORMAL_MATRIX
-    | typeof Object3DNode.WORLD_MATRIX
-    | typeof Object3DNode.POSITION
-    | typeof Object3DNode.SCALE
-    | typeof Object3DNode.VIEW_POSITION
-    | typeof Object3DNode.DIRECTION;
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class Object3DNode extends Node {
     scope: string;
@@ -24,3 +16,11 @@ export default class Object3DNode extends Node {
     static VIEW_POSITION: "viewPosition";
     static DIRECTION: "direction";
 }
+
+export const objectDirection: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectViewMatrix: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectNormalMatrix: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectWorldMatrix: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectPosition: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectScale: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;
+export const objectViewPosition: (object3d: Object3D) => ShaderNodeObject<Object3DNode>;

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

@@ -1,16 +1,28 @@
 import { NodeTypeOption } from "../core/constants.js";
 import Node from "../core/Node.js";
-import { NodeOrType, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeOrType, NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class ReferenceNode<T> extends Node {
-    object: T;
     property: string;
-    uniformType: string;
+
+    uniformType: NodeTypeOption;
+
+    object: T;
+    count: number | null;
+
+    properties: string[];
+    reference: T | null;
     node: Node | null;
 
-    constructor(property: string, uniformType: NodeTypeOption, object?: T | null);
+    constructor(property: string, uniformType: NodeTypeOption, object?: T | null, count?: number | null);
 
     setNodeType(uniformType: NodeTypeOption): void;
 }
 
 export const reference: <T>(name: string, nodeOrType: NodeOrType, object: T) => ShaderNodeObject<ReferenceNode<T>>;
+export const referenceBuffer: <T>(
+    name: string,
+    nodeOrType: NodeOrType,
+    count: NodeRepresentation,
+    object: T,
+) => ShaderNodeObject<ReferenceNode<T>>;

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

@@ -0,0 +1,16 @@
+import Renderer from "../../renderers/common/Renderer.js";
+import { NodeTypeOption } from "../core/constants.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import ReferenceNode from "./ReferenceNode.js";
+
+export default class RendererReferenceNode extends ReferenceNode<Renderer> {
+    renderer: Renderer | null;
+
+    constructor(property: string, inputType: NodeTypeOption, renderer?: Renderer | null);
+}
+
+export const rendererReference: (
+    name: string,
+    type: NodeTypeOption,
+    renderer?: Renderer | null,
+) => ShaderNodeObject<RendererReferenceNode>;

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

@@ -1,8 +1,11 @@
-import { SkinnedMesh } from "../../../../src/Three.js";
+import { SkinnedMesh } from "three";
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class SkinningNode extends Node {
+    skinnedMesh: SkinnedMesh;
+    useReference: boolean;
+
     skinIndexNode: Node;
     skinWeightNode: Node;
 
@@ -10,7 +13,8 @@ export default class SkinningNode extends Node {
     bindMatrixInverseNode: Node;
     boneMatricesNode: Node;
 
-    constructor(skinnedMesh: SkinnedMesh);
+    constructor(skinnedMesh: SkinnedMesh, useReference?: boolean);
 }
 
-export function skinning(skinnedMesh: SkinnedMesh): ShaderNodeObject<SkinningNode>;
+export const skinning: (skinnedMesh: SkinnedMesh) => ShaderNodeObject<SkinningNode>;
+export const skinningReference: (skinnedMesh: SkinnedMesh) => ShaderNodeObject<SkinningNode>;

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

@@ -1,9 +1,17 @@
 import { NodeTypeOption } from "../core/constants.js";
-import { NodeOrType, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeOrType, NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import StorageArrayElementNode from "../utils/StoargeArrayElementNode.js";
 import BufferNode from "./BufferNode.js";
 
 export default class StorageBufferNode extends BufferNode {
+    readonly isStorageBufferNode: true;
+    bufferObject: boolean;
+
     constructor(value: ArrayLike<number>, bufferType: NodeTypeOption, bufferCount?: number);
+
+    element(indexNode: NodeRepresentation): ShaderNodeObject<StorageArrayElementNode>;
+
+    setBufferObject(value: boolean): this;
 }
 
 export const storage: (
@@ -11,3 +19,8 @@ export const storage: (
     nodeOrType: NodeOrType,
     count: number,
 ) => ShaderNodeObject<StorageBufferNode>;
+export const storageObject: (
+    value: ArrayLike<number>,
+    nodeOrType: NodeOrType,
+    count: number,
+) => ShaderNodeObject<StorageBufferNode>;

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

@@ -1,13 +1,20 @@
-import { Texture } from "../../../../src/Three.js";
+import { Texture } from "three";
 import Node from "../core/Node.js";
 import UniformNode from "../core/UniformNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class TextureNode extends UniformNode<Texture> {
-    isTextureNode: true;
+    readonly isTextureNode: true;
 
     uvNode: ShaderNodeObject<Node> | null;
     levelNode: ShaderNodeObject<Node> | null;
+    compareNode: Node | null;
+    depthNode: Node | null;
+
+    sampler: boolean;
+    updateMatrix: boolean;
+
+    referenceNode: Node | null;
 
     constructor(value: Texture, uvNode?: ShaderNodeObject<Node>, levelNode?: ShaderNodeObject<Node> | null);
 

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

@@ -3,8 +3,6 @@ import NodeBuilder from "./NodeBuilder.js";
 import NodeFrame from "./NodeFrame.js";
 
 export default abstract class Node {
-    readonly isNode: true;
-
     nodeType: NodeTypeOption | null;
 
     updateType: NodeUpdateType;
@@ -12,17 +10,23 @@ export default abstract class Node {
 
     uuid: string;
 
+    version: number;
+
+    readonly isNode: true;
+
     readonly id: number;
 
     constructor(nodeType?: NodeTypeOption | null);
 
+    set needsUpdate(value: boolean);
+
     get type(): number;
 
     isGlobal(builder: NodeBuilder): boolean;
 
     getChildren(): Node[];
 
-    getCacheKey(): string;
+    getCacheKey(force?: boolean): string;
 
     getHash(builder: NodeBuilder): string;
 
@@ -36,6 +40,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 {
@@ -7,7 +7,7 @@ export interface NodeChild {
     childNode: Node;
 }
 
-export function getCacheKey(object: Node): string;
+export function getCacheKey(object: Node, force?: boolean): string;
 export function getNodeChildren(object: Node): Generator<NodeChild, void>;
 export function getValueType(value: unknown): string | null;
 export function getValueFromType(

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";
@@ -25,6 +25,8 @@ export default class PassNode extends TempNode {
 
     getTextureDepthNode(): ShaderNodeObject<PassTextureNode>;
 
+    getViewZNode(): ShaderNodeObject<Node>;
+
     getDepthNode(): ShaderNodeObject<Node>;
 
     setSize(width: number, height: number): void;

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

@@ -1,4 +1,5 @@
-import { ToneMapping } from "../../../../src/Three.js";
+import { ToneMapping } from "three";
+import RendererReferenceNode from "../accessors/RendererReferenceNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
@@ -19,3 +20,14 @@ export const toneMapping: (
     exposure: NodeRepresentation,
     color?: NodeRepresentation,
 ) => ShaderNodeObject<ToneMappingNode>;
+export const toneMappingExposure: ShaderNodeObject<RendererReferenceNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        toneMapping: (
+            color: NodeRepresentation,
+            mapping?: NodeRepresentation,
+            exposure?: NodeRepresentation,
+        ) => ShaderNodeObject<ToneMappingNode>;
+    }
+}

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/fog/FogNode.d.ts

@@ -1,16 +1,21 @@
 import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class FogNode extends Node {
     isFogNode: true;
-    colorNode: Node;
-    factorNode: Node;
+    colorNode: Node | null;
+    factorNode: Node | null;
 
-    constructor(colorNode: Node, factorNode: Node);
-    mixAssign(outputNode: Node): Node;
+    constructor(colorNode: Node | null, factorNode: Node | null);
+
+    getViewZNode(builder: NodeBuilder): Node;
 }
 
-export const fog: (colorNode: NodeRepresentation, factorNode: NodeRepresentation) => ShaderNodeObject<FogNode>;
+export const fog: (
+    colorNode: NodeRepresentation | null,
+    factorNode: NodeRepresentation | null,
+) => ShaderNodeObject<FogNode>;
 
 declare module "../shadernode/ShaderNode.js" {
     interface NodeElements {

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

@@ -1,16 +1,20 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import FogNode from "./FogNode.js";
 
 export default class FogRangeNode extends FogNode {
     isFogRangeNode: true;
-    nearNode: Node;
-    farNode: Node;
+    nearNode: Node | null;
+    farNode: Node | null;
 
-    constructor(colorNode: Node, nearNode: Node, farNode: Node);
+    constructor(colorNode: Node | null, nearNode: Node | null, farNode: Node | null);
 }
 
-export const rangeFog: (colorNode: Node, nearNode: Node, farNode: Node) => ShaderNodeObject<FogRangeNode>;
+export const rangeFog: (
+    colorNode: NodeRepresentation | null,
+    nearNode: NodeRepresentation | null,
+    farNode: NodeRepresentation | null,
+) => ShaderNodeObject<FogRangeNode>;
 
 declare module "../shadernode/ShaderNode.js" {
     interface NodeElements {

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

@@ -1,5 +1,6 @@
 export { default as LineBasicNodeMaterial } from "./LineBasicNodeMaterial.js";
 export { default as MeshBasicNodeMaterial } from "./MeshBasicNodeMaterial.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";

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

@@ -0,0 +1,23 @@
+import { MeshNormalMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshNormalMaterialParameters {
+}
+
+export default class MeshNormalNodeMaterial extends NodeMaterial {
+    readonly isMeshNormalNodeMaterial: true;
+
+    // Properties from MeshNormalMaterial
+    readonly isMeshNormalMaterial: true;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    flatShading: boolean;
+
+    constructor(parameters?: MeshBasicNodeMaterialParameters);
+}