@types/three 0.162.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: Thu, 29 Feb 2024 18:08:09 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/controls/OrbitControls.d.ts

@@ -14,7 +14,7 @@ export interface OrbitControlsEventMap {
  * event listeners.
  */
 export class OrbitControls extends EventDispatcher<OrbitControlsEventMap> {
-    constructor(object: Camera, domElement?: HTMLElement);
+    constructor(object: Camera, domElement: HTMLElement);
 
     /**
      * The camera being controlled.

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

@@ -16,9 +16,17 @@ export interface TextGeometryParameters extends ExtrudeGeometryOptions {
      * Thickness to extrude text.
      * Expects a `Float`.
      * @defaultValue `50`
+     * @deprecated THREE.TextGeometry: .height is now depreciated. Please use .depth instead
      */
     height?: number | undefined;
 
+    /**
+     * Thickness to extrude text.
+     * Expects a `Float`.
+     * @defaultValue `50`
+     */
+    depth?: number | undefined;
+
     /**
      * @override
      * @defaultValue `12`

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

@@ -1,5 +1,17 @@
 import { Loader, LoadingManager, Shape } from "three";
 
+export interface FontData {
+    glyphs: Record<string, { ha: number; x_min: number; x_max: number; o: string }>;
+    familyName: string;
+    ascender: number;
+    descender: number;
+    underlinePosition: number;
+    underlineThickness: number;
+    boundingBox: { yMin: number; xMin: number; yMax: number; xMax: number };
+    resolution: number;
+    original_font_information: Record<string, string>;
+}
+
 export class FontLoader extends Loader<Font> {
     constructor(manager?: LoadingManager);
 
@@ -10,18 +22,20 @@ export class FontLoader extends Loader<Font> {
         onError?: (err: unknown) => void,
     ): void;
 
-    parse(json: any): Font;
+    parse(json: FontData): Font;
 }
 
 export class Font {
-    constructor(jsondata: any);
+    readonly isFont: true;
 
     /**
      * @default 'Font'
      */
     type: string;
 
-    data: string;
+    data: FontData;
+
+    constructor(data: FontData);
 
-    generateShapes(text: string, size: number): Shape[];
+    generateShapes(text: string, size?: number): Shape[];
 }

three/examples/jsm/loaders/LUT3dlLoader.d.ts

@@ -1,8 +1,7 @@
-import { Data3DTexture, DataTexture, FloatType, Loader, LoadingManager, UnsignedByteType } from "three";
+import { Data3DTexture, FloatType, Loader, LoadingManager, UnsignedByteType } from "three";
 
 export interface LUT3dlResult {
     size: number;
-    texture: DataTexture;
     texture3D: Data3DTexture;
 }
 

three/examples/jsm/loaders/LUTCubeLoader.d.ts

@@ -1,11 +1,10 @@
-import { Data3DTexture, DataTexture, FloatType, Loader, LoadingManager, UnsignedByteType, Vector3 } from "three";
+import { Data3DTexture, FloatType, Loader, LoadingManager, UnsignedByteType, Vector3 } from "three";
 
 export interface LUTCubeResult {
     title: string;
     size: number;
     domainMin: Vector3;
     domainMax: Vector3;
-    texture: DataTexture;
     texture3D: Data3DTexture;
 }
 

three/examples/jsm/loaders/RGBMLoader.d.ts

@@ -24,6 +24,11 @@ export class RGBMLoader extends DataTextureLoader {
         onError?: (event: ErrorEvent) => void,
     ): CubeTexture;
 
+    loadCubemapAsync(
+        urls: string[],
+        onProgress?: (event: ProgressEvent) => void,
+    ): Promise<CubeTexture>;
+
     parse(buffer: ArrayBuffer): RGBM;
 
     setDataType(dataType: TextureDataType): this;

three/examples/jsm/loaders/TTFLoader.d.ts

@@ -1,8 +1,10 @@
 import { Loader, LoadingManager } from "three";
+import { FontData } from "./FontLoader.js";
 
-export class TTFLoader extends Loader<object> {
-    constructor(manager?: LoadingManager);
+export class TTFLoader extends Loader<FontData> {
     reversed: boolean;
 
-    parse(arraybuffer: ArrayBuffer): object;
+    constructor(manager?: LoadingManager);
+
+    parse(arraybuffer: ArrayBuffer): FontData;
 }

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,
@@ -169,7 +174,6 @@ export { default as ReflectorNode, reflector, ReflectorNodeParameters } from "./
 export { default as RemapNode, remap, remapClamp } from "./utils/RemapNode.js";
 export { default as RotateNode, rotate } from "./utils/RotateNode.js";
 export { default as RotateUVNode, rotateUV } from "./utils/RotateUVNode.js";
-export { default as SpecularMIPLevelNode, specularMIPLevel } from "./utils/SpecularMIPLevelNode.js";
 export { default as SplitNode } from "./utils/SplitNode.js";
 export { default as SpriteSheetUVNode, spritesheetUV } from "./utils/SpriteSheetUVNode.js";
 export { default as StorageArrayElementNode } from "./utils/SpriteSheetUVNode.js";
@@ -191,7 +195,8 @@ 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,
     bitangentLocal,
@@ -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 {
@@ -275,6 +298,7 @@ export {
 } from "./accessors/PositionNode.js";
 export { default as ReferenceNode, reference, referenceBuffer } from "./accessors/ReferenceNode.js";
 export { default as ReflectVectorNode, reflectVector } from "./accessors/ReflectVectorNode.js";
+export { default as RendererReferenceNode, rendererReference } from "./accessors/RendererReferenceNode.js";
 export { default as SkinningNode, skinning } from "./accessors/SkinningNode.js";
 export { default as StorageBufferNode, storage, storageObject } from "./accessors/StorageBufferNode.js";
 export {
@@ -348,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";
@@ -369,12 +393,16 @@ 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";
 export { default as PointLightNode } from "./lighting/PointLightNode.js";
 export { default as SpotLightNode } from "./lighting/SpotLightNode.js";
 
+// pmrem
+export { default as PMREMNode, pmremTexture } from "./pmrem/PMREMNode.js";
+
 // procedural
 export { checker, default as CheckerNode } from "./procedural/CheckerNode.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/BatchNode.d.ts

@@ -0,0 +1,14 @@
+import { BatchedMesh } from "three";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class BatchNode extends Node {
+    batchMesh: BatchedMesh;
+
+    instanceColorNode: Node | null;
+    batchingIdNode: Node | null;
+
+    constructor(batchMesh: BatchedMesh);
+}
+
+export const batch: (batchMesh: BatchedMesh) => ShaderNodeObject<BatchNode>;

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

@@ -4,7 +4,8 @@ import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class InstanceNode extends Node {
     instanceMesh: InstancedMesh;
-    instanceMatrixNode: Node;
+    instanceMatrixNode: Node | null;
+    instanceColorNode: Node | null;
 
     constructor(instanceMesh: InstancedMesh);
 }

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

@@ -4,15 +4,25 @@ 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;
+    gradNode: Node | null;
+
+    sampler: boolean;
+    updateMatrix: boolean;
+
+    referenceNode: Node | null;
 
     constructor(value: Texture, uvNode?: ShaderNodeObject<Node>, levelNode?: ShaderNodeObject<Node> | null);
 
     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/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;
 

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

@@ -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/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>;