@types/three 0.175.0 → 0.176.0

three/README.md

@@ -8,8 +8,8 @@ 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, 28 Mar 2025 18:39:32 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), [@webgpu/types](https://npmjs.com/package/@webgpu/types), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
+ * Last updated: Thu, 24 Apr 2025 08:02:30 GMT
+ * Dependencies: [@dimforge/rapier3d-compat](https://npmjs.com/package/@dimforge/rapier3d-compat), [@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), [@webgpu/types](https://npmjs.com/package/@webgpu/types), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits
 These definitions were written by [Josh Ellis](https://github.com/joshuaellis), and [Nathan Bierema](https://github.com/Methuselah96).

three/examples/jsm/helpers/RapierHelper.d.ts

@@ -0,0 +1,13 @@
+import * as RAPIER from "@dimforge/rapier3d-compat";
+import { LineSegments } from "three";
+
+declare class RapierHelper extends LineSegments {
+    world: RAPIER.World;
+
+    constructor(world: RAPIER.World);
+
+    update(): void;
+    dispose(): void;
+}
+
+export { RapierHelper };

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

@@ -1,6 +1,10 @@
 import { CanvasTexture, Loader, LoadingManager } from "three";
 
 export class LottieLoader extends Loader<CanvasTexture> {
+    /**
+     * @deprecated The loader has been deprecated and will be removed with r186. Use lottie-web instead and create your
+     * animated texture manually.
+     */
     constructor(manager?: LoadingManager);
 
     load(

three/examples/jsm/misc/MD2CharacterComplex.d.ts

@@ -9,7 +9,7 @@ export class MD2CharacterComplex {
     maxReverseSpeed: number;
     frontAcceleration: number;
     backAcceleration: number;
-    frontDecceleration: number;
+    frontDeceleration: number;
     angularSpeed: number;
     root: Object3D;
     meshBody: Mesh | null;

three/examples/jsm/physics/RapierPhysics.d.ts

@@ -1,12 +1,24 @@
+import * as RAPIER from "@dimforge/rapier3d-compat";
 import { Mesh, Object3D } from "three";
 
 type Vector = { x: number; y: number; z: number };
 
 export interface RapierPhysicsObject {
+    RAPIER: typeof RAPIER;
+    world: RAPIER.World;
     addScene: (scene: Object3D) => void;
     addMesh: (mesh: Mesh, mass?: number, restitution?: number) => void;
     setMeshPosition: (mesh: Mesh, position: Vector, index?: number) => void;
     setMeshVelocity: (mesh: Mesh, velocity: Vector, index?: number) => void;
+    addHeightfield: (
+        mesh: Mesh,
+        width: number,
+        depth: number,
+        heights: Float32Array,
+        scale: Vector,
+    ) => RAPIER.RigidBody;
 }
 
 export function RapierPhysics(): Promise<RapierPhysicsObject>;
+
+export type RAPIER = typeof RAPIER;

three/examples/jsm/postprocessing/BokehPass.d.ts

@@ -2,7 +2,7 @@ import { Camera, Color, MeshDepthMaterial, Scene, ShaderMaterial, WebGLRenderTar
 
 import { FullScreenQuad, Pass } from "./Pass.js";
 
-export interface BokehPassParamters {
+export interface BokehPassParameters {
     focus?: number;
     aspect?: number;
     aperture?: number;
@@ -10,7 +10,7 @@ export interface BokehPassParamters {
 }
 
 export class BokehPass extends Pass {
-    constructor(scene: Scene, camera: Camera, params: BokehPassParamters);
+    constructor(scene: Scene, camera: Camera, params: BokehPassParameters);
     scene: Scene;
     camera: Camera;
     renderTargetColor: WebGLRenderTarget;

three/examples/jsm/tsl/shadows/TileShadowNode.d.ts

@@ -0,0 +1,14 @@
+import { Light, ShadowBaseNode } from "three/webgpu";
+
+export interface TileShadeNodeConfig {
+    tilesX?: number | undefined;
+    tilesY?: number | undefined;
+    resolution?: { width: number; height: number };
+    debug?: boolean | undefined;
+}
+
+declare class TileShadowNode extends ShadowBaseNode {
+    constructor(light: Light, options?: TileShadeNodeConfig);
+}
+
+export { TileShadowNode };

three/examples/jsm/tsl/shadows/TileShadowNodeHelper.d.ts

@@ -0,0 +1,14 @@
+import { Group } from "three/webgpu";
+import { TileShadowNode } from "./TileShadowNode.js";
+
+declare class TileShadowNodeHelper extends Group {
+    constructor(tileShadowNode: TileShadowNode);
+
+    init(): void;
+
+    update(): void;
+
+    dispose(): void;
+}
+
+export { TileShadowNodeHelper };

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.175.0",
+    "version": "0.176.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -40,6 +40,7 @@
     },
     "scripts": {},
     "dependencies": {
+        "@dimforge/rapier3d-compat": "^0.12.0",
         "@tweenjs/tween.js": "~23.1.3",
         "@types/stats.js": "*",
         "@types/webxr": "*",
@@ -48,6 +49,6 @@
         "meshoptimizer": "~0.18.1"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "4f8410c1c95a3d20772bbb010426c784f9e9d9f20a8e4ab737d05ff2918553d6",
-    "typeScriptVersion": "5.0"
+    "typesPublisherContentHash": "2633ecc9f78b2c3a7ff53ae098668242bacbcea8b1a3e8ca27d1bf0a943233a6",
+    "typeScriptVersion": "5.1"
 }

three/src/Three.Core.d.ts

@@ -103,6 +103,7 @@ export { ColorManagement, ColorSpaceDefinition } from "./math/ColorManagement.js
 export * from "./math/Cylindrical.js";
 export * from "./math/Euler.js";
 export * from "./math/Frustum.js";
+export * from "./math/FrustumArray.js";
 export * from "./math/Interpolant.js";
 export * from "./math/interpolants/CubicInterpolant.js";
 export * from "./math/interpolants/DiscreteInterpolant.js";
@@ -152,6 +153,7 @@ export * from "./textures/CubeTexture.js";
 export * from "./textures/Data3DTexture.js";
 export * from "./textures/DataArrayTexture.js";
 export * from "./textures/DataTexture.js";
+export * from "./textures/DepthArrayTexture.js";
 export * from "./textures/DepthTexture.js";
 export * from "./textures/FramebufferTexture.js";
 export * from "./textures/Source.js";

three/src/Three.TSL.d.ts

@@ -13,6 +13,7 @@ export const F_Schlick: typeof TSL.F_Schlick;
 export const Fn: typeof TSL.Fn;
 export const INFINITY: typeof TSL.INFINITY;
 export const If: typeof TSL.If;
+export const Switch: typeof TSL.Switch;
 export const Loop: typeof TSL.Loop;
 export const NodeShaderStage: typeof TSL.NodeShaderStage;
 export const NodeType: typeof TSL.NodeType;
@@ -130,6 +131,8 @@ export const dFdx: typeof TSL.dFdx;
 export const dFdy: typeof TSL.dFdy;
 export const dashSize: typeof TSL.dashSize;
 export const debug: typeof TSL.debug;
+export const decrement: typeof TSL.decrement;
+export const decrementBefore: typeof TSL.decrementBefore;
 export const defaultBuildStages: typeof TSL.defaultBuildStages;
 export const defaultShaderStages: typeof TSL.defaultShaderStages;
 export const defined: typeof TSL.defined;
@@ -183,6 +186,8 @@ export const getScreenPosition: typeof TSL.getScreenPosition;
 export const getShIrradianceAt: typeof TSL.getShIrradianceAt;
 export const getTextureIndex: typeof TSL.getTextureIndex;
 export const getViewPosition: typeof TSL.getViewPosition;
+export const getShadowMaterial: typeof TSL.getShadowMaterial;
+export const getShadowRenderObjectFunction: typeof TSL.getShadowRenderObjectFunction;
 export const glsl: typeof TSL.glsl;
 export const glslFn: typeof TSL.glslFn;
 export const grayscale: typeof TSL.grayscale;
@@ -192,6 +197,8 @@ export const hash: typeof TSL.hash;
 export const highpModelNormalViewMatrix: typeof TSL.highpModelNormalViewMatrix;
 export const highPrecisionModelViewMatrix: typeof TSL.highpModelViewMatrix;
 export const hue: typeof TSL.hue;
+export const increment: typeof TSL.increment;
+export const incrementBefore: typeof TSL.incrementBefore;
 export const instance: typeof TSL.instance;
 export const instanceIndex: typeof TSL.instanceIndex;
 export const instancedArray: typeof TSL.instancedArray;
@@ -217,6 +224,7 @@ export const lengthSq: typeof TSL.lengthSq;
 export const lessThan: typeof TSL.lessThan;
 export const lessThanEqual: typeof TSL.lessThanEqual;
 export const lightPosition: typeof TSL.lightPosition;
+export const lightShadowMatrix: typeof TSL.lightShadowMatrix;
 export const lightTargetDirection: typeof TSL.lightTargetDirection;
 export const lightTargetPosition: typeof TSL.lightTargetPosition;
 export const lightViewPosition: typeof TSL.lightViewPosition;

three/src/audio/AudioListener.d.ts

@@ -4,7 +4,7 @@ import { AudioContext } from "./AudioContext.js";
 /**
  * The {@link AudioListener} represents a virtual {@link https://developer.mozilla.org/en-US/docs/Web/API/AudioListener | listener} of the all positional and non-positional audio effects in the scene.
  * A three.js application usually creates a single instance of {@link AudioListener}  * @remarks
- * It is a mandatory construtor parameter for audios entities like {@link Audio | Audio} and {@link PositionalAudio | PositionalAudio}.
+ * It is a mandatory constructor parameter for audios entities like {@link Audio | Audio} and {@link PositionalAudio | PositionalAudio}.
  * In most cases, the listener object is a child of the camera
  * So the 3D transformation of the camera represents the 3D transformation of the listener.
  * @example

three/src/cameras/ArrayCamera.d.ts

@@ -18,6 +18,11 @@ export class ArrayCamera extends PerspectiveCamera {
      */
     readonly isArrayCamera: true;
 
+    /**
+     * Whether this camera is used with multiview rendering or not.
+     */
+    isMultiViewCamera: boolean;
+
     /**
      * An array of cameras.
      * @defaultValue `[]`

three/src/constants.d.ts

@@ -371,19 +371,6 @@ export const RGBFormat: 1022;
 /** {@link RGBAFormat} is the default and reads the red, green, blue and alpha components. */
 export const RGBAFormat: 1023;
 
-/**
- * {@link LuminanceFormat} reads each element as a single luminance component.
- * This is then converted to a floating point, clamped to the range `[0,1]`, and then assembled into an RGBA element by
- * placing the luminance value in the red, green and blue channels, and attaching `1.0` to the alpha channel.
- */
-export const LuminanceFormat: 1024;
-
-/**
- * {@link LuminanceAlphaFormat} reads each element as a luminance/alpha double.
- * The same process occurs as for the {@link LuminanceFormat}, except that the alpha channel may have values other than `1.0`.
- */
-export const LuminanceAlphaFormat: 1025;
-
 /**
  * {@link DepthFormat} reads each element as a single depth value, converts it to floating point, and clamps to the range `[0,1]`.
  * @remarks This is the default for {@link THREE.DepthTexture}.
@@ -440,8 +427,6 @@ export type PixelFormat =
     | typeof AlphaFormat
     | typeof RGBFormat
     | typeof RGBAFormat
-    | typeof LuminanceFormat
-    | typeof LuminanceAlphaFormat
     | typeof DepthFormat
     | typeof DepthStencilFormat
     | typeof RedFormat
@@ -797,6 +782,22 @@ export const TimestampQuery: {
 };
 export type TimestampQuery = "compute" | "render";
 
+export const InterpolationSamplingType: {
+    PERSPECTIVE: "perspective";
+    LINEAR: "linear";
+    FLAT: "flat";
+};
+export type InterpolationSamplingType = "perspective" | "linear" | "flat";
+
+export const InterpolationSamplingMode: {
+    NORMAL: "normal";
+    CENTROID: "centroid";
+    SAMPLE: "sample";
+    FLAT_FIRST: "flat first";
+    FLAT_EITHER: "flat either";
+};
+export type InterpolationSamplingMode = "normal" | "centroid" | "sample" | "flat first" | "flat either";
+
 ///////////////////////////////////////////////////////////////////////////////
 // Texture - Internal Pixel Formats
 

three/src/core/RenderTarget.d.ts

@@ -11,6 +11,7 @@ import { Texture } from "../textures/Texture.js";
 import { EventDispatcher } from "./EventDispatcher.js";
 
 export interface RenderTargetOptions {
+    depth?: number | undefined;
     wrapS?: Wrapping | undefined;
     wrapT?: Wrapping | undefined;
     magFilter?: MagnificationTextureFilter | undefined;
@@ -32,6 +33,7 @@ export interface RenderTargetOptions {
      */
     samples?: number | undefined;
     count?: number | undefined;
+    multiview?: boolean | undefined;
 }
 
 export class RenderTarget<TTexture extends Texture | Texture[] = Texture> extends EventDispatcher<{ dispose: {} }> {
@@ -78,6 +80,13 @@ export class RenderTarget<TTexture extends Texture | Texture[] = Texture> extend
      */
     samples: number;
 
+    /**
+     * Whether to this target is used in multiview rendering.
+     *
+     * @default false
+     */
+    multiview: boolean;
+
     constructor(width?: number, height?: number, options?: RenderTargetOptions);
 
     get texture(): TTexture;

three/src/geometries/CapsuleGeometry.d.ts

@@ -19,11 +19,18 @@ export class CapsuleGeometry extends BufferGeometry {
     /**
      * Create a new instance of {@link CapsuleGeometry}
      * @param radius Radius of the capsule. Expects a `Float`. Default `1`
-     * @param length Length of the middle section. Expects a `Float`. Default `1`
+     * @param height Height of the middle section. Expects a `Float`. Default `1`
      * @param capSegments Number of curve segments used to build the caps. Expects a `Integer`. Default `4`
      * @param radialSegments Number of segmented faces around the circumference of the capsule. Expects a `Integer`. Default `8`
+     * @param heightSegments Number of rows of faces along the height of the capsule. Optional; defaults to `1`.
      */
-    constructor(radius?: number, length?: number, capSegments?: number, radialSegments?: number);
+    constructor(
+        radius?: number,
+        height?: number,
+        capSegments?: number,
+        radialSegments?: number,
+        heightSegments?: number,
+    );
 
     /**
      * A Read-only _string_ to check if `this` object type.
@@ -38,7 +45,7 @@ export class CapsuleGeometry extends BufferGeometry {
      */
     readonly parameters: {
         readonly radius: number;
-        readonly length: number;
+        readonly height: number;
         readonly capSegments: number;
         readonly radialSegments: number;
     };

three/src/lights/LightShadow.d.ts

@@ -1,4 +1,5 @@
 import { Camera } from "../cameras/Camera.js";
+import { TextureDataType } from "../constants.js";
 import { Object3DJSONObject } from "../core/Object3D.js";
 import { Frustum } from "../math/Frustum.js";
 import { Matrix4 } from "../math/Matrix4.js";
@@ -86,6 +87,13 @@ export class LightShadow<TCamera extends Camera = Camera> {
      */
     mapSize: Vector2;
 
+    /**
+     * The type of shadow texture. The default is `UnsignedByteType`.
+     *
+     * @default UnsignedByteType
+     */
+    mapType: TextureDataType;
+
     /**
      * The depth map generated using the internal camera; a location beyond a pixel's depth is in shadow. Computed internally during rendering.
      * @defaultValue null

three/src/materials/Material.d.ts

@@ -287,7 +287,7 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
     blendDst: BlendingDstFactor;
 
     /**
-     * The tranparency of the .blendDst. Default is null.
+     * The transparency of the .blendDst. Default is null.
      * @default null
      */
     blendDstAlpha: number | null;
@@ -299,7 +299,7 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
     blendEquation: BlendingEquation;
 
     /**
-     * The tranparency of the .blendEquation. Default is null.
+     * The transparency of the .blendEquation. Default is null.
      * @default null
      */
     blendEquationAlpha: number | null;
@@ -317,7 +317,7 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
     blendSrc: BlendingSrcFactor | BlendingDstFactor;
 
     /**
-     * The tranparency of the .blendSrc. Default is null.
+     * The transparency of the .blendSrc. Default is null.
      * @default null
      */
     blendSrcAlpha: number | null;
@@ -628,9 +628,4 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      * @default false
      */
     set needsUpdate(value: boolean);
-
-    /**
-     * @deprecated onBuild() has been removed.
-     */
-    onBuild(object: Object3D, parameters: WebGLProgramParametersWithUniforms, renderer: WebGLRenderer): void;
 }

three/src/materials/ShaderMaterial.d.ts

@@ -61,7 +61,7 @@ export interface ShaderMaterialJSON extends MaterialJSON {
     defines?: Record<string, unknown>;
 
     vertexShader: string;
-    ragmentShader: string;
+    fragmentShader: string;
 
     lights: boolean;
     clipping: boolean;

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

@@ -27,7 +27,8 @@ export interface NodeMaterialParameters extends MaterialParameters {
     geometryNode?: Node | null | undefined;
 
     depthNode?: Node | null | undefined;
-    shadowNode?: Node | null | undefined;
+    receivedShadowPositionNode?: Node | null | undefined;
+    castShadowPositionNode?: Node | null | undefined;
 
     outputNode?: Node | null | undefined;
 
@@ -59,7 +60,8 @@ declare class NodeMaterial extends Material {
     geometryNode: Node | null;
 
     depthNode: Node | null;
-    shadowPositionNode: Node | null;
+    receivedShadowPositionNode: Node | null;
+    castShadowPositionNode: Node | null;
     receivedShadowNode: (() => Node) | null;
     castShadowNode: Node | null;
 
@@ -69,6 +71,12 @@ declare class NodeMaterial extends Material {
     fragmentNode: Node | null;
     vertexNode: Node | null;
 
+    /**
+     * @deprecated ".shadowPositionNode" was renamed to ".receivedShadowPositionNode".'
+     */
+    get shadowPositionNode(): Node | null;
+    set shadowPositionNode(value: Node | null);
+
     constructor();
 
     build(builder: NodeBuilder): void;

three/src/materials/nodes/manager/NodeMaterialObserver.d.ts

@@ -2,6 +2,7 @@ import { BufferAttribute } from "../../../core/BufferAttribute.js";
 import { Matrix4 } from "../../../math/Matrix4.js";
 import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
 import NodeFrame from "../../../nodes/core/NodeFrame.js";
+import Renderer from "../../../renderers/common/Renderer.js";
 import RenderObject from "../../../renderers/common/RenderObject.js";
 import { Material } from "../../Material.js";
 declare const refreshUniforms: readonly [
@@ -103,6 +104,13 @@ declare class NodeMaterialObserver {
      * @return {boolean} Whether the given render object is verified for the first time of this observer.
      */
     firstInitialization(renderObject: RenderObject): boolean;
+    /**
+     * Returns `true` if the current rendering produces motion vectors.
+     *
+     * @param {Renderer} renderer - The renderer.
+     * @return {boolean} Whether the current rendering produces motion vectors or not.
+     */
+    needsVelocity(renderer: Renderer): boolean;
     /**
      * Returns monitoring data for the given render object.
      *

three/src/math/FrustumArray.d.ts

@@ -0,0 +1,27 @@
+import { ArrayCamera } from "../cameras/ArrayCamera.js";
+import { CoordinateSystem } from "../constants.js";
+import { Object3D } from "../core/Object3D.js";
+import { Sprite } from "../objects/Sprite.js";
+import { Box3 } from "./Box3.js";
+import { Sphere } from "./Sphere.js";
+import { Vector3 } from "./Vector3.js";
+
+declare class FrustumArray {
+    coordinateSystem: CoordinateSystem;
+
+    constructor();
+
+    intersectsObject(object: Object3D, cameraArray: ArrayCamera): boolean;
+
+    intersectsSprite(sprite: Sprite, cameraArray: ArrayCamera): boolean;
+
+    intersectsSprite(sphere: Sphere, cameraArray: ArrayCamera): boolean;
+
+    intersectsBox(box: Box3, cameraArray: ArrayCamera): boolean;
+
+    containsPoint(point: Vector3, cameraArray: ArrayCamera): boolean;
+
+    clone(): FrustumArray;
+}
+
+export { FrustumArray };

three/src/nodes/TSL.d.ts

@@ -135,6 +135,7 @@ export * from "./lighting/LightsNode.js";
 export * from "./lighting/PointLightNode.js";
 export * from "./lighting/PointShadowNode.js";
 export * from "./lighting/ShadowBaseNode.js";
+export * from "./lighting/ShadowFilterNode.js";
 export * from "./lighting/ShadowNode.js";
 
 // pmrem

three/src/nodes/accessors/InstanceNode.d.ts

@@ -1,5 +1,4 @@
 import { InstancedBufferAttribute } from "../../core/InstancedBufferAttribute.js";
-import { InstancedMesh } from "../../objects/InstancedMesh.js";
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
@@ -14,12 +13,12 @@ export default class InstanceNode extends Node {
     constructor(
         count: number,
         instanceMatrix: InstancedBufferAttribute,
-        instanceColor: InstancedBufferAttribute | null,
+        instanceColor?: InstancedBufferAttribute | null,
     );
 }
 
 export const instance: (
     count: number,
     instanceMatrix: InstancedBufferAttribute,
-    instanceColor: InstancedBufferAttribute | null,
+    instanceColor?: InstancedBufferAttribute | null,
 ) => ShaderNodeObject<InstanceNode>;

three/src/nodes/accessors/VertexColorNode.d.ts

@@ -6,7 +6,7 @@ export default class VertexColorNode extends AttributeNode {
 
     index: number;
 
-    constructor(index?: number);
+    constructor(index: number);
 }
 
 export const vertexColor: (index?: number) => ShaderNodeObject<VertexColorNode>;

three/src/nodes/core/Node.d.ts

@@ -75,6 +75,7 @@ declare class Node extends EventDispatcher<{
     _cacheKey: number | null;
     _cacheKeyVersion: number;
     global: boolean;
+    parents: boolean;
     readonly isNode: true;
     readonly id: number;
     self?: this;
@@ -319,14 +320,16 @@ declare class Node extends EventDispatcher<{
      */
     update(frame: NodeFrame): void;
     /**
-     * This method performs the build of a node. The behavior of this method as well as its return value depend
-     * on the current build stage (setup, analyze or generate).
+     * This method performs the build of a node. The behavior and return value depend on the current build stage:
+     * - **setup**: Prepares the node and its children for the build process. This process can also create new nodes. Returns the node itself or a variant.
+     * - **analyze**: Analyzes the node hierarchy for optimizations in the code generation stage. Returns `null`.
+     * - **generate**: Generates the shader code for the node. Returns the generated shader string.
      *
      * @param {NodeBuilder} builder - The current node builder.
-     * @param {?string} output - Can be used to define the output type.
-     * @return {?string} When this method is executed in the setup or analyze stage, `null` is returned. In the generate stage, the generated shader string.
+     * @param {?string} [output=null] - Can be used to define the output type.
+     * @return {Node|string|null} The result of the build process, depending on the build stage.
      */
-    build(builder: NodeBuilder, output?: string | null): string | null;
+    build(builder: NodeBuilder, output?: string | null): Node | string | null;
     /**
      * Returns the child nodes as a JSON object.
      *

three/src/nodes/core/NodeVarying.d.ts

@@ -1,3 +1,4 @@
+import { InterpolationSamplingMode, InterpolationSamplingType } from "../../constants.js";
 import NodeVar from "./NodeVar.js";
 /**
  * {@link NodeBuilder} is going to create instances of this class during the build process
@@ -10,12 +11,21 @@ import NodeVar from "./NodeVar.js";
 declare class NodeVarying extends NodeVar {
     needsInterpolation: boolean;
     readonly isNodeVarying: true;
+    interpolationType: InterpolationSamplingType | null;
+    interpolationSampling: InterpolationSamplingMode | null;
     /**
      * Constructs a new node varying.
      *
      * @param {string} name - The name of the varying.
      * @param {string} type - The type of the varying.
+     * @param {?string} interpolationType - The interpolation type of the varying.
+     * @param {?string} interpolationSampling - The interpolation sampling type of the varying.
      */
-    constructor(name: string, type: string | null);
+    constructor(
+        name: string,
+        type: string,
+        interpolationType?: InterpolationSamplingType | null,
+        interpolationSampling?: InterpolationSamplingMode | null,
+    );
 }
 export default NodeVarying;

three/src/nodes/core/StackNode.d.ts

@@ -1,4 +1,4 @@
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 
 declare class StackNode extends Node {
@@ -16,6 +16,12 @@ declare class StackNode extends Node {
 
     Else(method: () => void): this;
 
+    Switch(expression: NodeRepresentation): this;
+
+    Case(...params: NodeRepresentation[]): this;
+
+    Default(method: () => void): this;
+
     /**
      * @deprecated Use {@link StackNode#ElseIf Else()} instead.
      */

three/src/nodes/core/VaryingNode.d.ts

@@ -1,3 +1,4 @@
+import { InterpolationSamplingMode, InterpolationSamplingType } from "../../constants.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 import Node from "./Node.js";
 import NodeBuilder from "./NodeBuilder.js";
@@ -6,9 +7,14 @@ import NodeVarying from "./NodeVarying.js";
 export default class VaryingNode extends Node {
     node: Node;
     name: string | null;
+    readonly isVaryingNode: true;
+    interpolationType: InterpolationSamplingType | null;
+    interpolationSampling: InterpolationSamplingMode | null;
 
     constructor(node: Node, name?: string | null);
 
+    setInterpolation(type: InterpolationSamplingType | null, sampling?: InterpolationSamplingMode | null): this;
+
     setupVarying(builder: NodeBuilder): NodeVarying;
 }
 

three/src/nodes/gpgpu/AtomicFunctionNode.d.ts

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import TempNode from "../core/TempNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type AtomicMethod =
@@ -13,10 +12,11 @@ export type AtomicMethod =
     | typeof AtomicFunctionNode.ATOMIC_OR
     | typeof AtomicFunctionNode.ATOMIC_XOR;
 
-declare class AtomicFunctionNode extends TempNode {
+declare class AtomicFunctionNode extends Node {
     method: AtomicMethod;
     pointerNode: Node;
     valueNode: Node;
+    parents: boolean;
 
     constructor(method: AtomicMethod, pointerNode: Node, valueNode: Node);
 

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

@@ -0,0 +1,28 @@
+import { Light } from "../../lights/Light.js";
+import NodeMaterial from "../../materials/nodes/NodeMaterial.js";
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const BasicShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const PCFShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+    shadow: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const PCFSoftShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+    shadow: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const VSMShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const getShadowMaterial: (light: Light) => NodeMaterial;

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

@@ -1,30 +1,33 @@
+import { Camera } from "../../cameras/Camera.js";
+import { BufferGeometry } from "../../core/BufferGeometry.js";
+import { Object3D } from "../../core/Object3D.js";
 import { Light } from "../../lights/Light.js";
 import { LightShadow } from "../../lights/LightShadow.js";
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { Material } from "../../materials/Material.js";
+import { Group } from "../../objects/Group.js";
+import ClippingContext from "../../renderers/common/ClippingContext.js";
+import Renderer from "../../renderers/common/Renderer.js";
+import { Scene } from "../../scenes/Scene.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import LightsNode from "./LightsNode.js";
 import ShadowBaseNode from "./ShadowBaseNode.js";
 
-export const BasicShadowFilter: (
-    depthTexture: NodeRepresentation,
-    shadowCoord: NodeRepresentation,
-) => ShaderNodeObject<Node>;
-
-export const PCFShadowFilter: (
-    depthTexture: NodeRepresentation,
-    shadowCoord: NodeRepresentation,
-    shadow: NodeRepresentation,
-) => ShaderNodeObject<Node>;
-
-export const PCFSoftShadowFilter: (
-    depthTexture: NodeRepresentation,
-    shadowCoord: NodeRepresentation,
-    shadow: NodeRepresentation,
-) => ShaderNodeObject<Node>;
-
-export const VSMShadowFilter: (
-    depthTexture: NodeRepresentation,
-    shadowCoord: NodeRepresentation,
-) => ShaderNodeObject<Node>;
+export const getShadowRenderObjectFunction: (
+    renderer: Renderer,
+    shadow: LightShadow,
+    shadowType: number,
+    useVelocity: boolean,
+) => (
+    object: Object3D,
+    scene: Scene,
+    _camera: Camera,
+    geometry: BufferGeometry,
+    material: Material,
+    group: Group,
+    lightsNode: LightsNode,
+    clippingContext?: ClippingContext | null,
+    passId?: string | null,
+) => void;
 
 declare class ShadowNode extends ShadowBaseNode {
     constructor(light: Light, shadow: LightShadow | null);
@@ -33,4 +36,3 @@ declare class ShadowNode extends ShadowBaseNode {
 export default ShadowNode;
 
 export const shadow: (light: Light, shadow?: LightShadow) => ShaderNodeObject<ShadowNode>;
-export const shadows: ShaderNodeObject<Node>;

three/src/nodes/math/OperatorNode.d.ts

@@ -79,6 +79,11 @@ export const bitXor: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNod
 export const shiftLeft: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
 export const shiftRight: (a: NodeRepresentation, b: NodeRepresentation) => ShaderNodeObject<OperatorNode>;
 
+export const incrementBefore: (a: NodeRepresentation) => ShaderNodeObject<Node>;
+export const decrementBefore: (a: NodeRepresentation) => ShaderNodeObject<Node>;
+export const increment: (a: NodeRepresentation) => ShaderNodeObject<Node>;
+export const decrement: (a: NodeRepresentation) => ShaderNodeObject<Node>;
+
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         add: typeof add;
@@ -102,6 +107,10 @@ declare module "../tsl/TSLCore.js" {
         bitXor: typeof bitXor;
         shiftLeft: typeof shiftLeft;
         shiftRight: typeof shiftRight;
+        incrementBefore: typeof incrementBefore;
+        decrementBefore: typeof decrement;
+        increment: typeof increment;
+        decrement: typeof decrement;
     }
 }
 

three/src/nodes/tsl/TSLCore.d.ts

@@ -9,7 +9,7 @@ import ConvertNode from "../utils/ConvertNode.js";
 export interface NodeElements {
     toGlobal: (node: Node) => Node;
 
-    append: typeof append;
+    toStack: typeof Stack;
 
     toColor: typeof color;
     toFloat: typeof float;
@@ -34,6 +34,8 @@ export interface NodeElements {
 
     element: typeof element;
     convert: typeof convert;
+
+    append: typeof append;
 }
 
 export function addMethodChaining(name: string, nodeElement: unknown): void;
@@ -113,7 +115,7 @@ type RemoveHeadAndTail<T extends readonly [...unknown[]]> = T extends [unknown,
  *
  * We use an object instead of tuple or union as it makes stuff easier, especially in Typescript 4.0.
  */
-interface Construtors<
+interface Constructors<
     A extends undefined | [...unknown[]],
     B extends undefined | [...unknown[]],
     C extends undefined | [...unknown[]],
@@ -136,20 +138,20 @@ type OverloadedConstructorsOf<T> = T extends {
     new(...args: infer A2): unknown;
     new(...args: infer A3): unknown;
     new(...args: infer A4): unknown;
-} ? Construtors<A1, A2, A3, A4>
+} ? Constructors<A1, A2, A3, A4>
     : T extends {
         new(...args: infer A1): unknown;
         new(...args: infer A2): unknown;
         new(...args: infer A3): unknown;
-    } ? Construtors<A1, A2, A3, undefined>
+    } ? Constructors<A1, A2, A3, undefined>
     : T extends {
         new(...args: infer A1): unknown;
         new(...args: infer A2): unknown;
-    } ? Construtors<A1, A2, undefined, undefined>
-    : T extends new(...args: infer A) => unknown ? Construtors<A, undefined, undefined, undefined>
-    : Construtors<undefined, undefined, undefined, undefined>;
+    } ? Constructors<A1, A2, undefined, undefined>
+    : T extends new(...args: infer A) => unknown ? Constructors<A, undefined, undefined, undefined>
+    : Constructors<undefined, undefined, undefined, undefined>;
 
-type AnyConstructors = Construtors<any, any, any, any>;
+type AnyConstructors = Constructors<any, any, any, any>;
 
 /**
  * Returns all constructors where the first paramter is assignable to given "scope"
@@ -259,30 +261,14 @@ export function Fn<T extends { readonly [key: string]: unknown }>(
     jsFunc: (args: T) => void,
 ): ShaderNodeFn<[ProxiedObject<T>]>;
 
-/**
- * @deprecated tslFn() has been renamed to Fn()
- */
-export function tslFn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R): () => R;
-/**
- * @deprecated tslFn() has been renamed to Fn()
- */
-export function tslFn<T extends any[], R extends Node = ShaderNodeObject<Node>>(
-    jsFunc: (args: T) => R,
-): (...args: ProxiedTuple<T>) => R;
-/**
- * @deprecated tslFn() has been renamed to Fn()
- */
-export function tslFn<T extends { [key: string]: unknown }, R extends Node = ShaderNodeObject<Node>>(
-    jsFunc: (args: T) => R,
-): (args: ProxiedObject<T>) => R;
-
 export const setCurrentStack: (stack: StackNode | null) => void;
 
 export const getCurrentStack: () => StackNode | null;
 
 export const If: (boolNode: Node, method: () => void) => StackNode;
+export const Switch: (expression: NodeRepresentation) => StackNode;
 
-export function append(node: Node): Node;
+export function Stack(node: Node): Node;
 
 interface ColorFunction {
     (color?: ColorRepresentation): ShaderNodeObject<ConstNode<Color>>;
@@ -322,3 +308,25 @@ export const arrayBuffer: (value: ArrayBuffer) => ShaderNodeObject<ConstNode<Arr
 export const element: (node: NodeRepresentation, indexNode: NodeRepresentation) => ShaderNodeObject<Node>;
 export const convert: (node: NodeRepresentation, types: string) => ShaderNodeObject<Node>;
 export const split: (node: NodeRepresentation, channels?: string) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated append() has been renamed to Stack().
+ */
+export const append: (node: Node) => Node;
+
+/**
+ * @deprecated tslFn() has been renamed to Fn()
+ */
+export function tslFn<R extends Node = ShaderNodeObject<Node>>(jsFunc: () => R): () => R;
+/**
+ * @deprecated tslFn() has been renamed to Fn()
+ */
+export function tslFn<T extends any[], R extends Node = ShaderNodeObject<Node>>(
+    jsFunc: (args: T) => R,
+): (...args: ProxiedTuple<T>) => R;
+/**
+ * @deprecated tslFn() has been renamed to Fn()
+ */
+export function tslFn<T extends { [key: string]: unknown }, R extends Node = ShaderNodeObject<Node>>(
+    jsFunc: (args: T) => R,
+): (args: ProxiedObject<T>) => R;

three/src/nodes/utils/DebugNode.d.ts

@@ -1,4 +1,5 @@
 import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
 import TempNode from "../core/TempNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
@@ -10,7 +11,7 @@ export default DebugNode;
 
 export const debug: (
     node: NodeRepresentation,
-    callback?: ((code: string) => void) | null,
+    callback?: ((node: NodeBuilder, code: string) => void) | null,
 ) => ShaderNodeObject<DebugNode>;
 
 declare module "../tsl/TSLCore.js" {

three/src/nodes/utils/ReflectorNode.d.ts

@@ -31,7 +31,7 @@ declare class ReflectorBaseNode extends Node {
     bounces: boolean;
 
     virtualCameras: WeakMap<Camera, Camera>;
-    renderTargets: WeakMap<Camera, RenderTarget>;
+    renderTargets: Map<Camera, RenderTarget>;
     forceUpdate: boolean;
 
     constructor(textureNode: TextureNode, parameters?: ReflectorNodeParameters);

three/src/renderers/common/Animation.d.ts

@@ -12,7 +12,7 @@ export interface AnimationContext {
 declare class Animation {
     nodes: Nodes;
     info: Info;
-    _context: AnimationContext;
+    _context: AnimationContext | null;
     _animationLoop: ((time: DOMHighResTimeStamp, xrFrame?: XRFrame) => void) | null;
     _requestId: number | null;
     /**
@@ -47,7 +47,7 @@ declare class Animation {
      *
      * @return {Window|XRSession} The animation context.
      */
-    getContext(): AnimationContext;
+    getContext(): AnimationContext | null;
     /**
      * Defines the context in which `requestAnimationFrame()` is executed.
      *

three/src/renderers/common/Renderer.d.ts

@@ -62,6 +62,7 @@ export interface RendererParameters {
     samples?: number | undefined;
     getFallback?: ((error: unknown) => Backend) | null | undefined;
     colorBufferType?: TextureDataType | undefined;
+    multiview?: boolean | undefined;
 }
 /**
  * Base class for renderers.
@@ -198,6 +199,7 @@ declare class Renderer {
      * @property {?Function} [getFallback=null] - This callback function can be used to provide a fallback backend, if the primary backend can't be targeted.
      * @property {number} [colorBufferType=HalfFloatType] - Defines the type of color buffers. The default `HalfFloatType` is recommend for best
      * quality. To save memory and bandwidth, `UnsignedByteType` might be used. This will reduce rendering quality though.
+     * @property {boolean} [multiview=false] - If set to `true`, the renderer will use multiview during WebXR rendering if supported.
      */
     /**
      * Constructs a new renderer.
@@ -255,6 +257,23 @@ declare class Renderer {
      * @return {Promise} A Promise that resolves when synchronization has been finished.
      */
     waitForGPU(): Promise<void>;
+    /**
+     * Enables or disables high precision for model-view and normal-view matrices.
+     * When enabled, will use CPU 64-bit precision for higher precision instead of GPU 32-bit for higher performance.
+     *
+     * NOTE: 64-bit precision is not compatible with `InstancedMesh` and `SkinnedMesh`.
+     *
+     * @param {boolean} value - Whether to enable or disable high precision.
+     * @type {boolean}
+     */
+    set highPrecision(value: boolean);
+    /**
+     * Returns whether high precision is enabled or not.
+     *
+     * @return {boolean} Whether high precision is enabled or not.
+     * @type {boolean}
+     */
+    get highPrecision(): boolean;
     /**
      * Sets the given MRT configuration.
      *

three/src/renderers/common/Textures.d.ts

@@ -116,13 +116,6 @@ declare class Textures extends DataMap<{
      * @return {boolean} Whether mipmaps are required or not.
      */
     needsMipmaps(texture: Texture): boolean;
-    /**
-     * Returns `true` if the given texture is an environment map.
-     *
-     * @param {Texture} texture - The texture.
-     * @return {boolean} Whether the given texture is an environment map or not.
-     */
-    isEnvironmentTexture(texture: Texture): boolean;
     /**
      * Frees internal resource when the given texture isn't
      * required anymore.

three/src/renderers/common/TimestampQueryPool.d.ts

@@ -23,6 +23,7 @@ declare abstract class TimestampQueryPool {
      *
      * @abstract
      * @param {Object} renderContext - The render context to allocate queries for.
+     * @returns {?number}
      */
     abstract allocateQueriesForContext(renderContext: RenderContext): number | null;
     /**

three/src/renderers/common/XRManager.d.ts

@@ -98,12 +98,15 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
     _glProjLayer: XRProjectionLayer | null;
     _xrFrame: XRFrame | null;
     _useLayers: boolean;
+    _useMultiviewIfPossible: boolean;
+    _useMultiview: boolean;
     /**
      * Constructs a new XR manager.
      *
      * @param {Renderer} renderer - The renderer.
+     * @param {boolean} [multiview=false] - Enables multiview if the device supports it.
      */
-    constructor(renderer: Renderer);
+    constructor(renderer: Renderer, multiview?: boolean);
     /**
      * Returns an instance of `THREE.Group` that represents the transformation
      * of a XR controller in target ray space. The requested controller is defined
@@ -202,6 +205,12 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
      * @return {?XRFrame} The XR frame. Returns `null` when used outside a XR session.
      */
     getFrame(): XRFrame | null;
+    /**
+     * Returns `true` if the engine renders to a multiview target.
+     *
+     * @return {boolean} Whether the engine renders to a multiview render target or not.
+     */
+    useMultiview(): boolean;
     createQuadLayer(
         width: number,
         height: number,

three/src/renderers/webgpu/WebGPUBackend.d.ts

@@ -5,6 +5,7 @@ import Backend, { BackendParameters } from "../common/Backend.js";
 
 export interface WebGPUBackendParameters extends BackendParameters {
     alpha?: boolean | undefined;
+    compatibilityMode?: boolean | undefined;
     requiredLimits?: Record<string, GPUSize64> | undefined;
     trackTimestamp?: boolean | undefined;
     device?: GPUDevice | undefined;

three/src/textures/DepthArrayTexture.d.ts

@@ -0,0 +1,14 @@
+import { DepthTexture } from "./DepthTexture.js";
+
+declare class DepthArrayTexture extends DepthTexture {
+    readonly isDepthArrayTexture: true;
+    layerUpdates: Set<number>;
+
+    constructor(width?: number, height?: number, depth?: number);
+
+    addLayerUpdate(layerIndex: number): void;
+
+    clearLayerUpdates(): void;
+}
+
+export { DepthArrayTexture };

three/src/textures/Texture.d.ts

@@ -377,6 +377,13 @@ export class Texture extends EventDispatcher<{ dispose: {} }> {
      */
     isRenderTargetTexture: boolean;
 
+    /**
+     * Indicates if a texture should be handled like a texture array.
+     *
+     * @default false
+     */
+    isTextureArray: boolean;
+
     /**
      * An object that can be used to store custom data about the texture.
      * @remarks It should not hold references to functions as these will not be cloned.
@@ -432,7 +439,7 @@ export class Texture extends EventDispatcher<{ dispose: {} }> {
     /**
      * A callback function, called when the texture is updated _(e.g., when needsUpdate has been set to true and then the texture is used)_.
      */
-    onUpdate: () => void;
+    onUpdate: ((texture: Texture) => void) | null;
 
     /**
      * Transform the **UV** based on the value of this texture's

three/src/textures/VideoFrameTexture.d.ts

@@ -21,7 +21,7 @@ declare class VideoFrameTexture extends VideoTexture {
     );
 
     // FIXME Replace with VideoFrame when we no longer need to support TypeScript 5.0
-    setFrame(frane: unknown): void;
+    setFrame(frame: unknown): void;
 }
 
 export { VideoFrameTexture };