@types/three 0.163.0 → 0.164.0

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Fri, 29 Mar 2024 19:35:33 GMT
+ * Last updated: Fri, 26 Apr 2024 16:08:00 GMT
  * Dependencies: [@tweenjs/tween.js](https://npmjs.com/package/@tweenjs/tween.js), [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits

three/examples/jsm/animation/CCDIKSolver.d.ts

@@ -1,7 +1,7 @@
-import { Object3D, SkinnedMesh, Vector3 } from "three";
+import { LineBasicMaterial, MeshBasicMaterial, Object3D, SkinnedMesh, SphereGeometry, Vector3 } from "three";
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-export interface IKS {
+export interface IK {
     effector: number;
     iteration?: number | undefined;
     links: Array<{
@@ -17,14 +17,27 @@ export interface IKS {
 }
 
 export class CCDIKSolver {
-    constructor(mesh: SkinnedMesh, iks: IKS[]);
+    mesh: SkinnedMesh;
+    iks: IK[];
+
+    constructor(mesh: SkinnedMesh, iks?: IK[]);
 
     update(): this;
-    updateOne(iks: IKS): this;
-    createHelper(): CCDIKHelper;
+    updateOne(ik: IK): this;
+    createHelper(sphereSize?: number): CCDIKHelper;
 }
 
 export class CCDIKHelper extends Object3D {
-    constructor(mesh: SkinnedMesh, iks?: IKS[], sphereSize?: number);
+    root: SkinnedMesh;
+    iks: IK[];
+
+    sphereGeometry: SphereGeometry;
+    targetSphereMaterial: MeshBasicMaterial;
+    effectorSphereMaterial: MeshBasicMaterial;
+    linkSphereMaterial: MeshBasicMaterial;
+    lineMaterial: LineBasicMaterial;
+
+    constructor(mesh: SkinnedMesh, iks?: IK[], sphereSize?: number);
+
     dispose(): void;
 }

three/examples/jsm/exporters/USDZExporter.d.ts

@@ -8,5 +8,12 @@ export interface USDZExporterOptions {
 export class USDZExporter {
     constructor();
 
-    parse(scene: Object3D, options?: USDZExporterOptions): Promise<Uint8Array>;
+    parse(
+        scene: Object3D,
+        onDone: (result: Uint8Array) => void,
+        onError: (error: unknown) => void,
+        options?: USDZExporterOptions,
+    ): void;
+
+    parseAsync(scene: Object3D, options?: USDZExporterOptions): Promise<Uint8Array>;
 }

three/examples/jsm/interactive/SelectionBox.d.ts

@@ -8,6 +8,7 @@ export class SelectionBox {
     endPoint: Vector3;
     scene: Scene;
     startPoint: Vector3;
+    instances: Record<string, number[]>;
 
     select(startPoint?: Vector3, endPoint?: Vector3): Mesh[];
     updateFrustum(startPoint: Vector3, endPoint: Vector3): void;

three/examples/jsm/math/Octree.d.ts

@@ -1,4 +1,4 @@
-import { Box3, Object3D, Ray, Sphere, Triangle } from "three";
+import { Box3, Layers, Object3D, Ray, Sphere, Triangle } from "three";
 
 import { Capsule } from "./Capsule.js";
 
@@ -8,6 +8,7 @@ export class Octree {
 
     subTrees: Octree[];
     triangles: Triangle[];
+    layers: Layers;
 
     constructor(box?: Box3 | null);
 

three/examples/jsm/nodes/Nodes.d.ts

@@ -26,7 +26,12 @@ export { default as NodeKeywords } from "./core/NodeKeywords.js";
 export { default as NodeUniform } from "./core/NodeUniform.js";
 export { default as NodeVar } from "./core/NodeVar.js";
 export { default as NodeVarying } from "./core/NodeVarying.js";
+export { default as OutputStructNode, outputStruct } from "./core/OutputStructNode.js";
 export {
+    alphaT,
+    anisotropy,
+    anisotropyB,
+    anisotropyT,
     clearcoat,
     clearcoatRoughness,
     dashSize,
@@ -190,7 +195,7 @@ export {
 export * from "./shadernode/ShaderNode.js";
 
 // accessors
-export { parallaxDirection, parallaxUV, TBNViewMatrix } from "./accessors/AccessorsUtils.js";
+export { parallaxDirection, parallaxUV, TBNViewMatrix, transformedBentNormalView } from "./accessors/AccessorsUtils.js";
 export { batch, default as BatchNode } from "./accessors/BatchNode.js";
 export {
     bitangentGeometry,
@@ -220,16 +225,34 @@ export { default as InstanceNode, instance } from "./accessors/InstanceNode.js";
 export {
     default as MaterialNode,
     materialAlphaTest,
+    materialAnisotropy,
+    materialAnisotropyVector,
+    materialClearcoat,
+    materialClearcoatNormal,
+    materialClearcoatRoughness,
     materialColor,
     materialEmissive,
+    materialIridescence,
+    materialIridescenceIOR,
+    materialIridescenceThickness,
+    materialLineDashOffset,
+    materialLineDashSize,
+    materialLineGapSize,
+    materialLineScale,
+    materialLineWidth,
     materialMetalness,
     MaterialNodeScope,
+    materialNormal,
     materialOpacity,
+    materialPointWidth,
     materialReflectivity,
     materialRotation,
     materialRoughness,
+    materialSheen,
+    materialSheenRoughness,
     materialShininess,
-    materialSpecularColor,
+    materialSpecular,
+    materialSpecularStrength,
 } from "./accessors/MaterialNode.js";
 export { default as MaterialReferenceNode, materialReference } from "./accessors/MaterialReferenceNode.js";
 export {
@@ -349,10 +372,10 @@ export { default as ViewportTextureNode, viewportMipTexture, viewportTexture } f
 export { default as PassNode, depthPass, pass, PassNodeScope } from "./display/PassNode.js";
 
 // code
-export { code, CodeNodeInclude, default as CodeNode } from "./code/CodeNode.js";
+export { code, CodeNodeInclude, default as CodeNode, glsl, js, wgsl } from "./code/CodeNode.js";
 export { default as ExpressionNode, expression } from "./code/ExpressionNode.js";
 export { call, default as FunctionCallNode } from "./code/FunctionCallNode.js";
-export { default as FunctionNode, Fn, fn, func, FunctionNodeArguments } from "./code/FunctionNode.js";
+export { default as FunctionNode, Fn, FunctionNodeArguments, glslFn, wgslFn } from "./code/FunctionNode.js";
 
 // fog
 export { default as FogExp2Node, densityFog } from "./fog/FogExp2Node.js";
@@ -370,6 +393,7 @@ export { default as AnalyticLightNode } from "./lighting/AnalyticLightNode.js";
 export { default as AONode } from "./lighting/AONode.js";
 export { default as EnvironmentNode } from "./lighting/EnvironmentNode.js";
 export { default as HemisphereLightNode } from "./lighting/HemisphereLightNode.js";
+export { default as IrradianceNode } from "./lighting/IrradianceNode.js";
 export { default as LightingContextNode, lightingContext } from "./lighting/LightingContextNode.js";
 export { default as LightingNode } from "./lighting/LightingNode.js";
 export { default as LightsNode, lights } from "./lighting/LightsNode.js";

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

@@ -5,3 +5,5 @@ export const TBNViewMatrix: ShaderNodeObject<Node>;
 
 export const parallaxDirection: ShaderNodeObject<Node>;
 export const parallaxUV: (uv: ShaderNodeObject<Node>, scale: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const transformedBentNormalView: ShaderNodeObject<Node>;

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

@@ -1,23 +1,79 @@
+import { Vector2 } from "three";
 import Node from "../core/Node.js";
+import UniformNode from "../core/UniformNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export type MaterialNodeScope =
     | typeof MaterialNode.ALPHA_TEST
     | typeof MaterialNode.COLOR
     | typeof MaterialNode.OPACITY
+    | typeof MaterialNode.SHININESS
+    | typeof MaterialNode.SPECULAR
+    | typeof MaterialNode.SPECULAR_STRENGTH
+    | typeof MaterialNode.SPECULAR_INTENSITY
+    | typeof MaterialNode.SPECULAR_COLOR
+    | typeof MaterialNode.REFLECTIVITY
     | typeof MaterialNode.ROUGHNESS
     | typeof MaterialNode.METALNESS
+    | typeof MaterialNode.NORMAL
+    | typeof MaterialNode.CLEARCOAT
+    | typeof MaterialNode.CLEARCOAT_ROUGHNESS
+    | typeof MaterialNode.CLEARCOAT_NORMAL
     | typeof MaterialNode.EMISSIVE
-    | typeof MaterialNode.ROTATION;
+    | typeof MaterialNode.ROTATION
+    | typeof MaterialNode.SHEEN
+    | typeof MaterialNode.SHEEN_ROUGHNESS
+    | typeof MaterialNode.ANISOTROPY
+    | typeof MaterialNode.IRIDESCENCE
+    | typeof MaterialNode.IRIDESCENCE_IOR
+    | typeof MaterialNode.IRIDESCENCE_THICKNESS
+    | typeof MaterialNode.IOR
+    | typeof MaterialNode.TRANSMISSION
+    | typeof MaterialNode.THICKNESS
+    | typeof MaterialNode.ATTENUATION_DISTANCE
+    | typeof MaterialNode.ATTENUATION_COLOR
+    | typeof MaterialNode.LINE_SCALE
+    | typeof MaterialNode.LINE_DASH_SIZE
+    | typeof MaterialNode.LINE_GAP_SIZE
+    | typeof MaterialNode.LINE_WIDTH
+    | typeof MaterialNode.LINE_DASH_OFFSET
+    | typeof MaterialNode.POINT_WIDTH;
 
 export default class MaterialNode extends Node {
     static ALPHA_TEST: "alphaTest";
     static COLOR: "color";
     static OPACITY: "opacity";
+    static SHININESS: "shininess";
+    static SPECULAR: "specular";
+    static SPECULAR_STRENGTH: "specularStrength";
+    static SPECULAR_INTENSITY: "specularIntensity";
+    static SPECULAR_COLOR: "specularColor";
+    static REFLECTIVITY: "reflectivity";
     static ROUGHNESS: "roughness";
     static METALNESS: "metalness";
+    static NORMAL: "normal";
+    static CLEARCOAT: "clearcoat";
+    static CLEARCOAT_ROUGHNESS: "clearcoatRoughness";
+    static CLEARCOAT_NORMAL: "clearcoatNormal";
     static EMISSIVE: "emissive";
     static ROTATION: "rotation";
+    static SHEEN: "sheen";
+    static SHEEN_ROUGHNESS: "sheenRoughness";
+    static ANISOTROPY: "anisotropy";
+    static IRIDESCENCE: "iridescence";
+    static IRIDESCENCE_IOR: "iridescenceIOR";
+    static IRIDESCENCE_THICKNESS: "iridescenceThickness";
+    static IOR: "ior";
+    static TRANSMISSION: "transmission";
+    static THICKNESS: "thickness";
+    static ATTENUATION_DISTANCE: "attenuationDistance";
+    static ATTENUATION_COLOR: "attenuationColor";
+    static LINE_SCALE: "scale";
+    static LINE_DASH_SIZE: "dashSize";
+    static LINE_GAP_SIZE: "gapSize";
+    static LINE_WIDTH: "linewidth";
+    static LINE_DASH_OFFSET: "dashOffset";
+    static POINT_WIDTH: "pointWidth";
 
     scope: MaterialNodeScope;
     constructor(scope?: MaterialNodeScope);
@@ -28,8 +84,35 @@ export const materialColor: ShaderNodeObject<MaterialNode>;
 export const materialShininess: ShaderNodeObject<MaterialNode>;
 export const materialEmissive: ShaderNodeObject<MaterialNode>;
 export const materialOpacity: ShaderNodeObject<MaterialNode>;
+export const materialSpecular: ShaderNodeObject<MaterialNode>;
+
+export const materialSpecularIntensity: ShaderNodeObject<MaterialNode>;
 export const materialSpecularColor: ShaderNodeObject<MaterialNode>;
+
+export const materialSpecularStrength: ShaderNodeObject<MaterialNode>;
 export const materialReflectivity: ShaderNodeObject<MaterialNode>;
 export const materialRoughness: ShaderNodeObject<MaterialNode>;
 export const materialMetalness: ShaderNodeObject<MaterialNode>;
+export const materialNormal: ShaderNodeObject<MaterialNode>;
+export const materialClearcoat: ShaderNodeObject<MaterialNode>;
+export const materialClearcoatRoughness: ShaderNodeObject<MaterialNode>;
+export const materialClearcoatNormal: ShaderNodeObject<MaterialNode>;
 export const materialRotation: ShaderNodeObject<MaterialNode>;
+export const materialSheen: ShaderNodeObject<MaterialNode>;
+export const materialSheenRoughness: ShaderNodeObject<MaterialNode>;
+export const materialAnisotropy: ShaderNodeObject<MaterialNode>;
+export const materialIridescence: ShaderNodeObject<MaterialNode>;
+export const materialIridescenceIOR: ShaderNodeObject<MaterialNode>;
+export const materialIridescenceThickness: ShaderNodeObject<MaterialNode>;
+export const materialTransmission: ShaderNodeObject<MaterialNode>;
+export const materialThickness: ShaderNodeObject<MaterialNode>;
+export const materialIOR: ShaderNodeObject<MaterialNode>;
+export const materialAttenuationDistance: ShaderNodeObject<MaterialNode>;
+export const materialAttenuationColor: ShaderNodeObject<MaterialNode>;
+export const materialLineScale: ShaderNodeObject<MaterialNode>;
+export const materialLineDashSize: ShaderNodeObject<MaterialNode>;
+export const materialLineGapSize: ShaderNodeObject<MaterialNode>;
+export const materialLineWidth: ShaderNodeObject<MaterialNode>;
+export const materialLineDashOffset: ShaderNodeObject<MaterialNode>;
+export const materialPointWidth: ShaderNodeObject<MaterialNode>;
+export const materialAnisotropyVector: ShaderNodeObject<UniformNode<Vector2>>;

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

@@ -10,6 +10,7 @@ export default class TextureNode extends UniformNode<Texture> {
     levelNode: ShaderNodeObject<Node> | null;
     compareNode: Node | null;
     depthNode: Node | null;
+    gradNode: Node | null;
 
     sampler: boolean;
     updateMatrix: boolean;
@@ -20,6 +21,8 @@ export default class TextureNode extends UniformNode<Texture> {
 
     getDefaultUV(): Node;
 
+    grad(gradeNodeX: NodeRepresentation, gradeNodeY: NodeRepresentation): ShaderNodeObject<Node>;
+
     clone(): this;
 }
 

three/examples/jsm/nodes/code/CodeNode.d.ts

@@ -10,10 +10,15 @@ export interface CodeNodeInclude {
 export default class CodeNode extends Node {
     isCodeNode: true;
     code: string;
-    constructor(code?: string, includes?: CodeNodeInclude[]);
+    language: string;
+
+    constructor(code?: string, includes?: CodeNodeInclude[], language?: string);
 
     setIncludes(includes: CodeNodeInclude[]): this;
     getIncludes(builder: NodeBuilder): CodeNodeInclude[];
 }
 
-export const code: (code: string, nodeType?: NodeTypeOption) => ShaderNodeObject<CodeNode>;
+export const code: (code: string, includes?: CodeNodeInclude[], language?: string) => ShaderNodeObject<CodeNode>;
+export const js: (src: string, includes?: CodeNodeInclude[]) => ShaderNodeObject<CodeNode>;
+export const wgsl: (src: string, includes?: CodeNodeInclude[]) => ShaderNodeObject<CodeNode>;
+export const glsl: (src: string, includes?: CodeNodeInclude[]) => ShaderNodeObject<CodeNode>;

three/examples/jsm/nodes/code/FunctionNode.d.ts

@@ -10,7 +10,7 @@ export type FunctionNodeArguments = Node[] | { [name: string]: Node };
 
 export default class FunctionNode<P extends Node[] | { [name: string]: Node }> extends CodeNode {
     keywords: { [key: string]: Node };
-    constructor(code?: string, includes?: CodeNodeInclude[]);
+    constructor(code?: string, includes?: CodeNodeInclude[], language?: string);
 
     getInputs(builder: NodeBuilder): NodeFunctionInput[];
     getNodeFunction(builder: NodeBuilder): NodeFunction;
@@ -20,13 +20,19 @@ export default class FunctionNode<P extends Node[] | { [name: string]: Node }> e
 export type Fn<P extends FunctionNodeArguments> = P extends readonly [...unknown[]] ? ProxiedTuple<P>
     : readonly [ProxiedObject<P>];
 
-export const func: <P extends FunctionNodeArguments>(
+export const nativeFn: <P extends FunctionNodeArguments>(
     code: string,
     includes?: CodeNodeInclude[],
+    language?: string,
     // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-) => { call: (...params: Fn<P>) => ShaderNodeObject<Node> };
+) => (...params: Fn<P>) => ShaderNodeObject<Node>;
 
-export const fn: <P extends FunctionNodeArguments>(
+export const glslFn: <P extends FunctionNodeArguments>(
+    code: string,
+    includes?: CodeNodeInclude[],
+    // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
+) => (...params: Fn<P>) => ShaderNodeObject<Node>;
+export const wgslFn: <P extends FunctionNodeArguments>(
     code: string,
     includes?: CodeNodeInclude[],
     // eslint-disable-next-line @definitelytyped/no-unnecessary-generics

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

@@ -13,6 +13,7 @@ export interface LightingModelDirectInput {
     lightDirection: Node;
     lightColor: Node;
     reflectedLight: LightingModelReflectedLight;
+    shadowMask: Node;
 }
 
 export interface LightingModelIndirectInput {

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

@@ -127,7 +127,7 @@ export default abstract class NodeBuilder {
     setBuildStage(buildStage: BuildStageOption): void;
     getBuildStage(): BuildStageOption;
     abstract buildCode(): void;
-    build(createMaterial?: boolean): this;
+    build(): this;
     format(snippet: string, fromType: NodeTypeOption, toType: NodeTypeOption): string;
     getSignature(): string;
 }

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

@@ -0,0 +1,12 @@
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import Node from "./Node.js";
+
+export default class OutputStructNode extends Node {
+    members: Node[];
+
+    readonly isOutputStructNode: true;
+
+    constructor(...members: Node[]);
+}
+
+export const outputStruct: (...members: Node[]) => ShaderNodeObject<OutputStructNode>;

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

@@ -24,9 +24,19 @@ export const sheenRoughness: ShaderNodeObject<PropertyNode>;
 export const iridescence: ShaderNodeObject<PropertyNode>;
 export const iridescenceIOR: ShaderNodeObject<PropertyNode>;
 export const iridescenceThickness: ShaderNodeObject<PropertyNode>;
+export const alphaT: ShaderNodeObject<PropertyNode>;
+export const anisotropy: ShaderNodeObject<PropertyNode>;
+export const anisotropyT: ShaderNodeObject<PropertyNode>;
+export const anisotropyB: ShaderNodeObject<PropertyNode>;
 export const specularColor: ShaderNodeObject<PropertyNode>;
+export const specularF90: ShaderNodeObject<PropertyNode>;
 export const shininess: ShaderNodeObject<PropertyNode>;
 export const output: ShaderNodeObject<PropertyNode>;
 export const dashSize: ShaderNodeObject<PropertyNode>;
 export const gapSize: ShaderNodeObject<PropertyNode>;
 export const pointWidth: ShaderNodeObject<PropertyNode>;
+export const ior: ShaderNodeObject<PropertyNode>;
+export const transmission: ShaderNodeObject<PropertyNode>;
+export const thickness: ShaderNodeObject<PropertyNode>;
+export const attenuationDistance: ShaderNodeObject<PropertyNode>;
+export const attenuationColor: ShaderNodeObject<PropertyNode>;

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

@@ -7,7 +7,9 @@ declare const BRDF_GGX: (args: {
     f0: Node;
     f90: Node;
     roughness: Node;
-    iridescenceFresnel?: Node;
+    f?: Node;
+    USE_IRIDESCENCE?: Node;
+    USE_ANISOTROPY?: Node;
 }) => ShaderNodeObject<OperatorNode>;
 
 export default BRDF_GGX;

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

@@ -0,0 +1,10 @@
+import Node from "../../core/Node.js";
+import OperatorNode from "../../math/OperatorNode.js";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
+
+// https://google.github.io/filament/Filament.md.html#materialsystem/anisotropicmodel/anisotropicspecularbrdf
+declare const D_GGX_Anisotropic: (
+    args: { alphaT: Node; alphaB: Node; dotNH: Node; dotTH: Node; dotBH: Node },
+) => ShaderNodeObject<OperatorNode>;
+
+export default D_GGX_Anisotropic;

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

@@ -1,6 +1,11 @@
 import Node from "../../core/Node.js";
-import { ShaderNode } from "../../shadernode/ShaderNode.js";
+import OperatorNode from "../../math/OperatorNode.js";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
-declare const V_GGX_SmithCorrelated: ShaderNode<{ alpha: Node; dotNL: Node; dotNV: Node }>;
+declare const V_GGX_SmithCorrelated: (inputs: {
+    alpha: Node;
+    dotNL: Node;
+    dotNV: Node;
+}) => ShaderNodeObject<OperatorNode>;
 
 export default V_GGX_SmithCorrelated;

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

@@ -0,0 +1,16 @@
+import Node from "../../core/Node.js";
+import MathNode from "../../math/MathNode";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
+
+declare const V_GGX_SmithCorrelated: (inputs: {
+    alphaT: Node;
+    alphaB: Node;
+    dotTV: Node;
+    dotBV: Node;
+    dotTL: Node;
+    dotBL: Node;
+    dotNV: Node;
+    dotNL: Node;
+}) => ShaderNodeObject<MathNode>;
+
+export default V_GGX_SmithCorrelated;

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

@@ -5,6 +5,8 @@ export default class PhysicalLightingModel extends LightingModel {
     clearcoat: boolean;
     sheen: boolean;
     iridescence: boolean;
+    anisotropy: boolean;
+    transmission: boolean;
 
     clearcoatRadiance: Node | null;
     clearcoatSpecularDirect: Node | null;
@@ -14,7 +16,13 @@ export default class PhysicalLightingModel extends LightingModel {
     iridescenceFresnel: Node | null;
     iridescenceF0: Node | null;
 
-    constructor(clearcoat?: boolean, sheen?: boolean, iridescence?: boolean);
+    constructor(
+        clearcoat?: boolean,
+        sheen?: boolean,
+        iridescence?: boolean,
+        anisotropy?: boolean,
+        transmission?: boolean,
+    );
 
-    computeMultiscattering(singleScatter: Node, multiScatter: Node, specularF90?: Node): void;
+    computeMultiscattering(singleScatter: Node, multiScatter: Node, specularF90: Node): void;
 }

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

@@ -0,0 +1,9 @@
+import LightingModel from "../core/LightingModel.js";
+import VarNode from "../core/VarNode.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class ShadowMaskModel extends LightingModel {
+    shadowNode: ShaderNodeObject<VarNode>;
+
+    constructor();
+}

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

@@ -1,5 +1,6 @@
-import { ShaderNode } from "../../shadernode/ShaderNode.js";
+import MathNode from "../../math/MathNode.js";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
-declare const getGeometryRoughness: ShaderNode;
+declare const getGeometryRoughness: () => ShaderNodeObject<MathNode>;
 
 export default getGeometryRoughness;

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

@@ -1,6 +1,7 @@
 import Node from "../../core/Node.js";
-import { ShaderNode } from "../../shadernode/ShaderNode.js";
+import MathNode from "../../math/MathNode.js";
+import { ShaderNodeObject } from "../../shadernode/ShaderNode.js";
 
-declare const getRoughness: ShaderNode<{ roughness: Node }>;
+declare const getRoughness: (args: { roughness: Node }) => ShaderNodeObject<MathNode>;
 
 export default getRoughness;

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

@@ -1,10 +1,8 @@
 import { Light } from "three";
-import Node from "../core/Node.js";
 import LightingNode from "./LightingNode.js";
 
 export default class AnalyticLightNode<T extends Light> extends LightingNode {
     light: T | null;
-    colorNode: Node;
 
     constructor(light?: T | null);
 }

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

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

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

@@ -1,4 +1,9 @@
 import Node from "../core/Node.js";
-import { ShaderNode } from "../shadernode/ShaderNode.js";
+import CondNode from "../math/CondNode.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
-export const getDistanceAttenuation: ShaderNode<{ lightDistance: Node; cutoffDistance: Node; decayExponent: Node }>;
+export const getDistanceAttenuation: (args: {
+    lightDistance: Node;
+    cutoffDistance: Node;
+    decayExponent: Node;
+}) => ShaderNodeObject<CondNode>;

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

@@ -7,4 +7,5 @@ export { default as MeshSSSPhysicalNodeMaterial } from "./MeshSSSNodeMaterial.js
 export { default as MeshStandardNodeMaterial } from "./MeshStandardNodeMaterial.js";
 export { 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/nodes/materials/MeshPhysicalNodeMaterial.d.ts

@@ -23,7 +23,7 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     iridescenceIORNode: ShaderNodeObject<Node> | null;
     iridescenceThicknessNode: ShaderNodeObject<Node> | null;
 
-    iorNode?: ShaderNodeObject<Node> | null;
+    iorNode: ShaderNodeObject<Node> | null;
 
     specularIntensityNode: ShaderNodeObject<Node> | null;
     specularColorNode: ShaderNodeObject<Node> | null;
@@ -33,39 +33,49 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     attenuationDistanceNode: ShaderNodeObject<Node> | null;
     attenuationColorNode: ShaderNodeObject<Node> | null;
 
+    anisotropyNode: ShaderNodeObject<Node> | null;
+
     // Properties from MeshPhysicalMaterial
     readonly isMeshPhysicalMaterial: true;
-    clearcoat: number;
+    anisotropyRotation: number;
+    anisotropyMap: Texture | null;
     clearcoatMap: Texture | null;
     clearcoatRoughness: number;
     clearcoatRoughnessMap: Texture | null;
     clearcoatNormalScale: Vector2;
     clearcoatNormalMap: Texture | null;
-    reflectivity: number;
     ior: number;
-    sheen: number;
+    get reflectivity(): number;
+    set reflectivity(reflectivity: number);
+    iridescenceMap: Texture | null;
+    iridescenceIOR: number;
+    iridescenceThicknessRange: [number, number];
+    iridescenceThicknessMap: Texture | null;
     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;
+    specularColor: Color;
     specularColorMap: Texture | null;
-    iridescenceMap: Texture | null;
-    iridescenceIOR: number;
-    iridescence: number;
-    iridescenceThicknessRange: [number, number];
-    iridescenceThicknessMap: Texture | null;
-    anisotropy?: number;
-    anisotropyRotation?: number;
-    anisotropyMap?: Texture | null;
+    get anisotropy(): number;
+    set anisotropy(value: number);
+    get clearcoat(): number;
+    set clearcoat(value: number);
+    get iridescence(): number;
+    set iridescence(value: number);
+    get dispersion(): number;
+    set dispersion(value: number);
+    get sheen(): number;
+    set sheen(value: number);
+    get transmission(): number;
+    set transmission(value: number);
 
     constructor(parameters?: MeshPhysicalNodeMaterialParameters);
 }