@types/three 0.160.0 → 0.161.0

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

@@ -0,0 +1,32 @@
+import { Vector2 } from '../../../../src/Three.js';
+import Node from '../core/Node.js';
+import TempNode from '../core/TempNode.js';
+import TextureNode from '../accessors/TextureNode.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class AnamorphicNode extends TempNode {
+    textureNode: TextureNode;
+    thresholdNode: Node;
+    scaleNode: Node;
+    samples: number;
+    resolution: Vector2;
+
+    constructor(textureNode: TextureNode, thresholdNode: Node, scaleNode: Node, samples: number);
+
+    getTextureNode(): TextureNode;
+
+    setSize(width: number, height: number): void;
+}
+
+export const anamorphic: (
+    node: TextureNode,
+    threshold?: NodeRepresentation,
+    scale?: NodeRepresentation,
+    samples?: NodeRepresentation,
+) => ShaderNodeObject<AnamorphicNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        anamorphic: typeof anamorphic;
+    }
+}

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

@@ -1,14 +1,15 @@
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
 import { NodeRepresentation, ShaderNode, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import { JoinNode } from '../Nodes.js';
 
-export const BurnNode: ShaderNode<{ base: Node; blendNode: Node }>;
+export const BurnNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
 
-export const DodgeNode: ShaderNode<{ base: Node; blendNode: Node }>;
+export const DodgeNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
 
-export const ScreenNode: ShaderNode<{ base: Node; blendNode: Node }>;
+export const ScreenNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
 
-export const OverlayNode: ShaderNode<{ base: Node; blendNode: Node }>;
+export const OverlayNode: (args: { base: Node; blend: Node }) => ShaderNodeObject<JoinNode>;
 
 export type BlendMode =
     | typeof BlendModeNode.BURN
@@ -35,3 +36,12 @@ export const burn: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation
 export const dodge: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
 export const overlay: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
 export const screen: (baseNode: NodeRepresentation, blendNode?: NodeRepresentation) => ShaderNodeObject<BlendModeNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        burn: typeof burn;
+        dodge: typeof dodge;
+        overlay: typeof overlay;
+        screen: typeof screen;
+    }
+}

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

@@ -35,3 +35,14 @@ export const hue: (
 
 export const lumaCoeffs: ShaderNodeObject<MathNode>;
 export const luminance: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+export const threshold: (color: NodeRepresentation, thershold: NodeRepresentation) => ShaderNodeObject<MathNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        saturation: typeof saturation;
+        vibrance: typeof vibrance;
+        hue: typeof hue;
+        threshold: typeof threshold;
+    }
+}

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

@@ -1,4 +1,4 @@
-import { TextureEncoding } from '../../../../src/Three.js';
+import { ColorSpace } from '../../../../src/Three.js';
 import TempNode from '../core/TempNode.js';
 import Node from '../core/Node.js';
 import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
@@ -19,4 +19,17 @@ export default class ColorSpaceNode extends TempNode {
     constructor(method: ColorSpaceNodeMethod | null, node: Node);
 }
 
-export const colorSpace: (node: NodeRepresentation, encoding: TextureEncoding) => ShaderNodeObject<ColorSpaceNode>;
+export const linearToColorSpace: (node: NodeRepresentation, colorSpace: ColorSpace) => ShaderNodeObject<ColorSpaceNode>;
+export const colorSpaceToLinear: (node: NodeRepresentation, colorSpace: ColorSpace) => ShaderNodeObject<ColorSpaceNode>;
+
+export const linearTosRGB: (node: NodeRepresentation) => ShaderNodeObject<ColorSpaceNode>;
+export const sRGBToLinear: (node: NodeRepresentation) => ShaderNodeObject<ColorSpaceNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        linearTosRGB: typeof linearTosRGB;
+        sRGBToLinear: typeof sRGBToLinear;
+        linearToColorSpace: typeof linearToColorSpace;
+        colorSpaceToLinear: typeof colorSpaceToLinear;
+    }
+}

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

@@ -0,0 +1,28 @@
+import { Vector2 } from '../../../../src/Three.js';
+import TempNode from '../core/TempNode.js';
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+import { NodeRepresentation, ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class GaussianBlurNode extends TempNode {
+    textureNode: TextureNode;
+    sigma: number;
+
+    directionNode: Node;
+
+    resolution: Vector2;
+
+    constructor(textureNode: TextureNode, sigma?: number);
+
+    setSize(width: number, height: number): void;
+
+    getTextureNode(): TextureNode;
+}
+
+export const gaussianBlur: (node: NodeRepresentation, sigma?: number) => ShaderNodeObject<GaussianBlurNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        gaussianBlur: typeof gaussianBlur;
+    }
+}

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

@@ -16,3 +16,9 @@ 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

@@ -0,0 +1,44 @@
+import { Camera, RenderTarget, Scene, Texture } from '../../../../src/Three.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import TempNode from '../core/TempNode.js';
+import TextureNode from '../accessors/TextureNode.js';
+import Node from '../core/Node.js';
+
+declare class PassTextureNode extends TextureNode {
+    passNode: PassNode;
+
+    constructor(passNode: PassNode, texture: Texture);
+}
+
+export default class PassNode extends TempNode {
+    scope: PassNodeScope;
+    scene: Scene;
+    camera: Camera;
+
+    renderTarget: RenderTarget;
+
+    readonly isPassNode: true;
+
+    constructor(scope: PassNodeScope, scene: Scene, camera: Camera);
+
+    getTextureNode(): ShaderNodeObject<PassTextureNode>;
+
+    getTextureDepthNode(): ShaderNodeObject<PassTextureNode>;
+
+    getDepthNode(): ShaderNodeObject<Node>;
+
+    setSize(width: number, height: number): void;
+
+    setPixelRatio(pixelRatio: number): void;
+
+    dispose(): void;
+
+    static COLOR: 'color';
+    static DEPTH: 'depth';
+}
+
+export type PassNodeScope = typeof PassNode.COLOR | typeof PassNode.DEPTH;
+
+export const pass: (scene: Scene, camera: Camera) => ShaderNodeObject<PassNode>;
+export const texturePass: (pass: PassNode, texture: Texture) => ShaderNodeObject<PassTextureNode>;
+export const depthPass: (scene: Scene, camera: Camera) => ShaderNodeObject<PassNode>;

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

@@ -12,3 +12,9 @@ export const posterize: (
     sourceNode: NodeRepresentation,
     stepsNode: NodeRepresentation,
 ) => ShaderNodeObject<PosterizeNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        posterize: typeof posterize;
+    }
+}

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

@@ -0,0 +1,32 @@
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+
+export default class ViewportDepthNode extends Node {
+    scope: ViewportDepthNodeScope;
+    valueNode: Node;
+
+    readonly isViewportDepthNode: true;
+
+    constructor(scope: ViewportDepthNodeScope, valueNode?: Node | null);
+
+    static DEPTH: 'depth';
+    static DEPTH_TEXTURE: 'depthTexture';
+    static DEPTH_PIXEL: 'depthPixel';
+}
+
+export type ViewportDepthNodeScope =
+    | typeof ViewportDepthNode.DEPTH
+    | typeof ViewportDepthNode.DEPTH_TEXTURE
+    | typeof ViewportDepthNode.DEPTH_PIXEL;
+
+export const viewZToOrthographicDepth: (viewZ: Node, near: Node, far: Node) => Node;
+
+export const orthographicDepthToViewZ: (depth: Node, near: Node, far: Node) => Node;
+
+export const viewZToPerspectiveDepth: (viewZ: Node, near: Node, far: Node) => Node;
+
+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>;

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

@@ -0,0 +1,18 @@
+import Node from '../core/Node.js';
+import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
+import ViewportTextureNode from './ViewportTextureNode.js';
+
+export default class ViewportSharedTextureNode extends ViewportTextureNode {
+    constructor(uvNode?: Node, levelNode?: Node | null);
+}
+
+export const viewportSharedTexture: (
+    uvNode?: Node,
+    levelNode?: Node | null,
+) => ShaderNodeObject<ViewportSharedTextureNode>;
+
+declare module '../shadernode/ShaderNode.js' {
+    interface NodeElements {
+        viewportSharedTexture: typeof viewportSharedTexture;
+    }
+}

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

@@ -10,3 +10,9 @@ export default class FogExp2Node extends FogNode {
 }
 
 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

@@ -11,3 +11,9 @@ export default class FogNode extends 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

@@ -11,3 +11,9 @@ export default class FogRangeNode extends FogNode {
 }
 
 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/ShaderNode.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/ShaderNode.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/ShaderNode.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/ShaderNode.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/ShaderNode.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/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/ShaderNode.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/gpgpu/ComputeNode.d.ts

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

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

@@ -2,8 +2,6 @@ import { ShaderMaterialParameters } from '../../../../src/Three.js';
 
 import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
 import Node from '../core/Node.js';
-import CheckerNode from '../procedural/CheckerNode.js';
-import { ShaderNodeObject } from '../shadernode/ShaderNode.js';
 
 export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     readonly isMeshPhysicalNodeMaterial: true;
@@ -15,9 +13,9 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     sheenNode: Node | null;
     sheenRoughnessNode: Node | null;
 
-    iridescenceNode: null | ShaderNodeObject<CheckerNode>;
-    iridescenceIORNode: null | ShaderNodeObject<Node>;
-    iridescenceThicknessNode: null | ShaderNodeObject<Node>;
+    iridescenceNode: Node | null;
+    iridescenceIORNode: Node | null;
+    iridescenceThicknessNode: Node | null;
 
     iorNode?: Node | null;
 
@@ -30,6 +28,4 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     attenuationColorNode: Node | null;
 
     constructor(parameters?: ShaderMaterialParameters);
-
-    copy(source: MeshPhysicalNodeMaterial): this;
 }

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,7 +3,7 @@ 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;
 
@@ -11,5 +11,4 @@ export default class MeshStandardNodeMaterial extends NodeMaterial {
     roughnessNode: Node | null;
 
     constructor(paramters?: ShaderMaterialParameters);
-    copy(source: MeshStandardNodeMaterial): this;
 }