@types/three 0.184.1 → 0.185.0

three/examples/jsm/tsl/display/TemporalReprojectNode.d.ts

@@ -0,0 +1,64 @@
+import { Camera, Node, TempNode, Texture, TextureNode, UniformNode } from "three/webgpu";
+
+export type TemporalReprojectMode = "diffuse" | "specular";
+
+export interface TemporalReprojectNodeOptions {
+    mode?: TemporalReprojectMode | undefined;
+    hitPointReprojection?: boolean | undefined;
+    accumulate?: boolean | undefined;
+}
+
+declare class TemporalReprojectNode extends TempNode<"vec4"> {
+    readonly isTemporalReprojectNode: boolean;
+
+    beautyNode: Node<"vec4">;
+    depthNode: TextureNode;
+    normalNode: TextureNode;
+    velocityNode: TextureNode;
+    camera: Camera;
+
+    mode: TemporalReprojectMode;
+
+    /**
+     * When `true`, resolve output is copied into the internal history buffer each frame.
+     * When `false`, history is supplied externally via {@link TemporalReprojectNode#setHistoryTexture}.
+     *
+     * @type {boolean}
+     */
+    accumulate: boolean;
+
+    maxVelocityLength: number;
+
+    maxFrames: UniformNode<"float", number>;
+    hitPointReprojection: UniformNode<"bool", boolean>;
+    clampIntensity: UniformNode<"float", number>;
+    flickerSuppression: UniformNode<"float", number>;
+
+    constructor(
+        beautyNode: Node<"vec4">,
+        depthNode: TextureNode,
+        normalNode: TextureNode,
+        velocityNode: TextureNode,
+        camera: Camera,
+        options?: TemporalReprojectNodeOptions,
+    );
+
+    /**
+     * Supplies an external history source (e.g. a {@link RecurrentDenoiseNode} or its
+     * texture). Only used when {@link TemporalReprojectNode#accumulate} is `false`.
+     *
+     * @param {?(Object|Texture)} source
+     */
+    setHistoryTexture(source: Texture | { getRenderTarget(): { texture: Texture } }): void;
+}
+
+export default TemporalReprojectNode;
+
+export const temporalReproject: (
+    beautyNode: Node<"vec4">,
+    depthNode: TextureNode,
+    normalNode: TextureNode,
+    velocityNode: TextureNode,
+    camera: Camera,
+    options?: TemporalReprojectNodeOptions,
+) => TemporalReprojectNode;

three/examples/jsm/tsl/lighting/ClusteredLightsNode.d.ts

@@ -0,0 +1,54 @@
+import { Light, LightsNode, Node } from "three/webgpu";
+
+/**
+ * A custom version of `LightsNode` implementing Forward+ clustered shading:
+ * the view frustum is subdivided into a 3D grid of clusters (X × Y screen tiles
+ * times an exponentially-spaced set of Z depth slices), and each cluster holds
+ * only the point lights whose spheres intersect it. At shading time each fragment
+ * looks up its cluster and loops over just that cluster's lights. Unlike 2D tiled
+ * lighting, clustered shading culls lights that share screen pixels but lie at
+ * different depths — suitable for 3D scenes with real depth complexity.
+ *
+ * @augments LightsNode
+ */
+declare class ClusteredLightsNode extends LightsNode {
+    materialLights: Light[];
+    clusteredLights: Light[];
+    maxLights: number;
+    tileSize: number;
+    zSlices: number;
+    maxLightsPerCluster: number;
+
+    /**
+     * Constructs a new clustered lights node.
+     *
+     * @param {number} [maxLights=1024] - Maximum number of point lights.
+     * @param {number} [tileSize=32] - Screen tile size in pixels (cluster XY size).
+     * @param {number} [zSlices=24] - Number of exponential depth slices.
+     * @param {number} [maxLightsPerCluster=64] - Per-cluster light-list capacity.
+     */
+    constructor(maxLights?: number, tileSize?: number, zSlices?: number, maxLightsPerCluster?: number);
+
+    getClusterLightCount(zSliceNode: Node<"int">): Node<"int">;
+
+    setSize(width: number, height: number): this;
+}
+
+/**
+ * TSL function that creates a clustered lights node.
+ *
+ * @function
+ * @param {number} [maxLights=1024] - Maximum number of point lights.
+ * @param {number} [tileSize=32] - Screen tile size in pixels.
+ * @param {number} [zSlices=24] - Depth slice count.
+ * @param {number} [maxLightsPerCluster=64] - Per-cluster light-list capacity.
+ * @return {ClusteredLightsNode} The clustered lights node.
+ */
+export const clusteredLights: (
+    maxLights?: number,
+    tileSize?: number,
+    zSlices?: number,
+    maxLightsPerCluster?: number,
+) => ClusteredLightsNode;
+
+export default ClusteredLightsNode;

three/examples/jsm/tsl/math/curlNoise.d.ts

@@ -0,0 +1,38 @@
+import { Node, Vector3, Vector4 } from "three/webgpu";
+
+/**
+ * Permutation polynomial for noise generation.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec4>} x - Input vector.
+ * @return {Node<vec4>} Permuted vector.
+ */
+export const permute: (x: Node<"vec4"> | Vector4) => Node<"vec4">;
+/**
+ * 3D Simplex noise implementation in TSL.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} v - Input coordinate vector.
+ * @return {Node<float>} Simplex noise value.
+ */
+export const snoise: (v: Node<"vec3"> | Vector3) => Node<"float">;
+/**
+ * 3D Simplex noise vector. Returns a vec3 containing three independent noise samples.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} x - Input coordinate vector.
+ * @return {Node<vec3>} Vector of three noise values.
+ */
+export const snoiseVec3: (x: Node<"vec3"> | Vector3) => Node<"vec3">;
+/**
+ * 3D Curl noise in TSL. Generates a divergence-free vector field from simplex noise.
+ *
+ * @tsl
+ * @function
+ * @param {Node<vec3>} p - Input coordinate vector.
+ * @return {Node<vec3>} Curl noise vector.
+ */
+export const curlNoise: (p: Node<"vec3"> | Vector3) => Node<"vec3">;

three/examples/jsm/tsl/utils/GroundedSkybox.d.ts

@@ -0,0 +1,17 @@
+import { Node } from "three/webgpu";
+
+/**
+ * @module GroundedSkybox
+ * @three_import import { getGroundProjectedNormal } from 'three/addons/tsl/utils/GroundedSkybox.js';
+ */
+/**
+ * Projects the world position onto a sphere whose bottom is clipped by a ground disk,
+ * then returns a vector usable for sampling an environment cube map.
+ *
+ * @tsl
+ * @function
+ * @param {Node<float>} radiusNode - The radius of the projection sphere. Must be large enough to ensure the scene's camera stays inside.
+ * @param {Node<float>} heightNode - The height is how far the camera that took the photo was above the ground. A larger value will magnify the downward part of the image.
+ * @return {Node<vec3>} A direction vector for sampling the environment cube map.
+ */
+export const getGroundProjectedNormal: (radiusNode: Node<"float">, heightNode: Node<"float">) => Node<"vec3">;

three/examples/jsm/tsl/utils/RNoise.d.ts

@@ -0,0 +1,12 @@
+import { UniformNode, Vector2 } from "three/webgpu";
+
+/**
+ * Returns a TSL function that samples texture-free analytic R² noise.
+ * Index 0 uses continuous screen pixels; other indices tile-shift with an R²
+ * sequence into a 64×64 period. Values are four independent R² dimensions
+ * hashed from the sample coordinates.
+ *
+ * @param {UniformNode<Vector2>} resolution
+ * @param {number} [seed=0] - Added to the coordinate hash so each pass gets an independent R² phase.
+ */
+export function bindAnalyticNoise(resolution: UniformNode<"vec2", Vector2>, seed?: number): () => void;

three/examples/jsm/tsl/utils/SpecularHelpers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Specular / microfacet BRDF helpers: VNDF sampling, GTR distribution, Smith geometry,
+ * Fresnel, reflection importance sampling, parallax-corrected ray-length terms, and
+ * equirectangular environment sampling / MIS helpers.
+ * Pure TSL functions of their inputs (no scene/camera state).
+ */
+/**
+ * Sentinel ray length the SSR pass writes for environment misses (no screen-space hit), set far above
+ * any real hit distance so a single magnitude test separates misses from hits and survives `.max( 0 )`.
+ *
+ * @type {number}
+ */
+export const ENV_RAY_LENGTH: number;
+/**
+ * Classification threshold for {@link ENV_RAY_LENGTH}: above this is an env miss, below a real hit.
+ * An order of magnitude under the sentinel, robust to fp16 storage and bilinear blending at borders.
+ *
+ * @type {number}
+ */
+export const ENV_RAY_LENGTH_THRESHOLD: number;

three/examples/jsm/webxr/WebGLXRFallback.d.ts

@@ -0,0 +1,14 @@
+import { WebGPURenderer } from "three/webgpu";
+
+/**
+ * Sets up a construction-time WebGL fallback for WebGPU XR examples.
+ *
+ * @param {WebGPURenderer} renderer - The initial renderer.
+ * @param {Function} createFallbackRenderer - A function that returns a new renderer with a WebGL backend.
+ * @param {Function} onFallback - A function that installs the new renderer in the app.
+ */
+export function setupWebGLXRFallback(
+    renderer: WebGPURenderer,
+    createFallbackRenderer: (renderer: WebGPURenderer) => WebGPURenderer,
+    onFallback?: (fallbackRenderer: WebGPURenderer, renderer: WebGPURenderer) => Promise<void> | void,
+): void;

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.184.1",
+    "version": "0.185.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -48,6 +48,6 @@
         "meshoptimizer": "~1.1.1"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "67363064a17642624b2c45fc4f61890fb71a24dafc84869a7c0661c82d47d208",
-    "typeScriptVersion": "5.3"
+    "typesPublisherContentHash": "8fbe871a42225be87979eaf8580d12b6ea8cddd22eb100a6639a79de0771d026",
+    "typeScriptVersion": "5.6"
 }

three/src/Three.TSL.d.ts

@@ -47,6 +47,7 @@ export const addNodeElement: typeof TSL.addNodeElement;
 export const agxToneMapping: typeof TSL.agxToneMapping;
 export const all: typeof TSL.all;
 export const alphaT: typeof TSL.alphaT;
+export const ambientOcclusion: typeof TSL.ambientOcclusion;
 export const and: typeof TSL.and;
 export const anisotropy: typeof TSL.anisotropy;
 export const anisotropyB: typeof TSL.anisotropyB;
@@ -54,7 +55,6 @@ export const anisotropyT: typeof TSL.anisotropyT;
 export const any: typeof TSL.any;
 export const append: typeof TSL.append;
 export const array: typeof TSL.array;
-export const arrayBuffer: typeof TSL.arrayBuffer;
 export const asin: typeof TSL.asin;
 export const asinh: typeof TSL.asinh;
 export const assign: typeof TSL.assign;
@@ -177,6 +177,7 @@ export const dynamicBufferAttribute: typeof TSL.dynamicBufferAttribute;
 export const element: typeof TSL.element;
 export const emissive: typeof TSL.emissive;
 export const equal: typeof TSL.equal;
+export const equirectDirection: typeof TSL.equirectDirection;
 export const equirectUV: typeof TSL.equirectUV;
 export const exp: typeof TSL.exp;
 export const exp2: typeof TSL.exp2;
@@ -320,7 +321,6 @@ export const min: typeof TSL.min;
 export const mix: typeof TSL.mix;
 export const mixElement: typeof TSL.mixElement;
 export const mod: typeof TSL.mod;
-export const modInt: typeof TSL.modInt;
 export const modelDirection: typeof TSL.modelDirection;
 export const modelNormalMatrix: typeof TSL.modelNormalMatrix;
 export const modelPosition: typeof TSL.modelPosition;
@@ -378,6 +378,7 @@ export const mx_worley_noise_float: typeof TSL.mx_worley_noise_float;
 export const mx_worley_noise_vec2: typeof TSL.mx_worley_noise_vec2;
 export const mx_worley_noise_vec3: typeof TSL.mx_worley_noise_vec3;
 export const negate: typeof TSL.negate;
+export const negateOnBackSide: typeof TSL.negateOnBackSide;
 export const neutralToneMapping: typeof TSL.neutralToneMapping;
 export const nodeArray: typeof TSL.nodeArray;
 export const nodeImmutable: typeof TSL.nodeImmutable;
@@ -419,9 +420,12 @@ export const oscTriangle: typeof TSL.oscTriangle;
 export const output: typeof TSL.output;
 export const outputStruct: typeof TSL.outputStruct;
 export const overloadingFn: typeof TSL.overloadingFn;
+export const overrideNode: typeof TSL.overrideNode;
+export const overrideNodes: typeof TSL.overrideNodes;
 export const packHalf2x16: typeof TSL.packHalf2x16;
 export const packSnorm2x16: typeof TSL.packSnorm2x16;
 export const packUnorm2x16: typeof TSL.packUnorm2x16;
+export const packNormalToRGB: typeof TSL.packNormalToRGB;
 export const parabola: typeof TSL.parabola;
 export const parallaxDirection: typeof TSL.parallaxDirection;
 export const parallaxUV: typeof TSL.parallaxUV;
@@ -518,7 +522,7 @@ export const stepElement: typeof TSL.stepElement;
 export const storage: typeof TSL.storage;
 export const storageBarrier: typeof TSL.storageBarrier;
 export const storageTexture: typeof TSL.storageTexture;
-export const string: typeof TSL.string;
+export const storageTexture3D: typeof TSL.storageTexture3D;
 export const struct: typeof TSL.struct;
 export const sub: typeof TSL.sub;
 export const subgroupAdd: typeof TSL.subgroupAdd;
@@ -568,6 +572,8 @@ export const toneMappingExposure: typeof TSL.toneMappingExposure;
 export const toonOutlinePass: typeof TSL.toonOutlinePass;
 export const transformDirection: typeof TSL.transformDirection;
 export const transformNormal: typeof TSL.transformNormal;
+export const transformNormalByInverseViewMatrix: typeof TSL.transformNormalByInverseViewMatrix;
+export const transformNormalByViewMatrix: typeof TSL.transformNormalByViewMatrix;
 export const transformNormalToView: typeof TSL.transformNormalToView;
 export const transformedClearcoatNormalView: typeof TSL.transformedClearcoatNormalView;
 export const transformedNormalView: typeof TSL.transformedNormalView;
@@ -589,6 +595,7 @@ export const uniformTexture: typeof TSL.uniformTexture;
 export const unpackHalf2x16: typeof TSL.unpackHalf2x16;
 export const unpackSnorm2x16: typeof TSL.unpackSnorm2x16;
 export const unpackUnorm2x16: typeof TSL.unpackUnorm2x16;
+export const unpackRGBToNormal: typeof TSL.unpackRGBToNormal;
 export const unpremultiplyAlpha: typeof TSL.unpremultiplyAlpha;
 export const userData: typeof TSL.userData;
 export const uv: typeof TSL.uv;

three/src/Three.WebGPU.Nodes.d.ts

@@ -8,11 +8,11 @@ export { default as Lighting } from "./renderers/common/Lighting.js";
 export { default as PostProcessing } from "./renderers/common/PostProcessing.js";
 export { default as QuadMesh } from "./renderers/common/QuadMesh.js";
 export { default as ReadbackBuffer } from "./renderers/common/ReadbackBuffer.js";
-export type { default as Renderer } from "./renderers/common/Renderer.js";
+export type { default as Renderer, RendererParameters } from "./renderers/common/Renderer.js";
 export { default as RenderPipeline } from "./renderers/common/RenderPipeline.js";
 export { default as WebGLBackend } from "./renderers/webgl-fallback/WebGLBackend.js";
 export { default as WebGPUBackend } from "./renderers/webgpu/WebGPUBackend.js";
-export { default as WebGPURenderer } from "./renderers/webgpu/WebGPURenderer.Nodes.js";
+export { default as WebGPURenderer, WebGPURendererParameters } from "./renderers/webgpu/WebGPURenderer.Nodes.js";
 import * as RendererUtils from "./renderers/common/RendererUtils.js";
 export { RendererUtils };
 export { default as IESSpotLight } from "./lights/webgpu/IESSpotLight.js";

three/src/Three.WebGPU.d.ts

@@ -1,19 +1,19 @@
 export * from "./Three.Core.js";
 
 export * from "./materials/nodes/NodeMaterials.js";
-export type { default as Backend } from "./renderers/common/Backend.js";
+export { default as Backend } from "./renderers/common/Backend.js";
 export { default as BundleGroup } from "./renderers/common/BundleGroup.js";
 export { default as PMREMGenerator } from "./renderers/common/extras/PMREMGenerator.js";
 export { default as Lighting } from "./renderers/common/Lighting.js";
 export { default as PostProcessing } from "./renderers/common/PostProcessing.js";
 export { default as QuadMesh } from "./renderers/common/QuadMesh.js";
 export { default as ReadbackBuffer } from "./renderers/common/ReadbackBuffer.js";
-export type { default as Renderer } from "./renderers/common/Renderer.js";
+export { default as Renderer, RendererParameters } from "./renderers/common/Renderer.js";
 export { default as RenderPipeline } from "./renderers/common/RenderPipeline.js";
 export { default as WebGLCapabilities } from "./renderers/webgl-fallback/utils/WebGLCapabilities.js";
 export { default as WebGLBackend } from "./renderers/webgl-fallback/WebGLBackend.js";
 export { default as WebGPUBackend } from "./renderers/webgpu/WebGPUBackend.js";
-export { default as WebGPURenderer } from "./renderers/webgpu/WebGPURenderer.js";
+export { default as WebGPURenderer, WebGPURendererParameters } from "./renderers/webgpu/WebGPURenderer.js";
 import * as RendererUtils from "./renderers/common/RendererUtils.js";
 export { RendererUtils };
 export { default as IESSpotLight } from "./lights/webgpu/IESSpotLight.js";
@@ -35,5 +35,7 @@ export { default as StorageInstancedBufferAttribute } from "./renderers/common/S
 export { default as StorageTexture } from "./renderers/common/StorageTexture.js";
 export { default as GLSLNodeBuilder } from "./renderers/webgl-fallback/nodes/GLSLNodeBuilder.js";
 export { default as BasicNodeLibrary } from "./renderers/webgpu/nodes/BasicNodeLibrary.js";
+export { default as StandardNodeLibrary } from "./renderers/webgpu/nodes/StandardNodeLibrary.js";
+export { default as WGSLNodeBuilder } from "./renderers/webgpu/nodes/WGSLNodeBuilder.js";
 import * as TSL from "./nodes/TSL.js";
 export { TSL };

three/src/animation/AnimationClip.d.ts

@@ -86,16 +86,6 @@ export class AnimationClip {
         fps: number,
         noLoop: boolean,
     ): Array<AnimationClip>;
-    /**
-     * Parses the `animation.hierarchy` format and returns a new animation clip.
-     *
-     * @static
-     * @deprecated since r175.
-     * @param {Object} animation - A serialized animation clip as JSON.
-     * @param {Array<Bone>} bones - An array of bones.
-     * @return {?AnimationClip} The new animation clip.
-     */
-    static parseAnimation(animation: AnimationClipJSON, bones: Array<Bone>): AnimationClip | null;
     /**
      * Constructs a new animation clip.
      *

three/src/cameras/Camera.d.ts

@@ -37,6 +37,6 @@ export class Camera extends Object3D {
      * @default false
      */
     get reversedDepth(): boolean;
-    copy(source: Camera, recursive?: boolean): this;
     clone(): this;
+    copy(source: Camera, recursive?: boolean): this;
 }

three/src/core/InterleavedBuffer.d.ts

@@ -104,7 +104,7 @@ export class InterleavedBuffer {
      * @param offset index of the {@link BufferAttribute.array | array} at which to start copying. Expects a `Integer`. Default `0`.
      * @throws `RangeError` When {@link offset} is negative or is too large.
      */
-    set(value: ArrayLike<number>, offset: number): this;
+    set(value: ArrayLike<number>, offset?: number): this;
 
     /**
      * Set {@link BufferAttribute.usage | usage}

three/src/core/Object3D.d.ts

@@ -669,11 +669,15 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     updateMatrixWorld(force?: boolean): void;
 
     /**
-     * Updates the global transform of the object.
-     * @param updateParents Recursively updates global transform of ancestors.
-     * @param updateChildren Recursively updates global transform of descendants.
+     * An alternative version of {@link Object3D#updateMatrixWorld} with more control over the
+     * update of ancestor and descendant nodes.
+     *
+     * @param {boolean} [updateParents=false] Whether ancestor nodes should be updated or not.
+     * @param {boolean} [updateChildren=false] Whether descendant nodes should be updated or not.
+     * @param {boolean} [force=false] - When set to `true`, a recomputation of world matrices is forced even
+     * when {@link Object3D#matrixWorldNeedsUpdate} is `false`.
      */
-    updateWorldMatrix(updateParents: boolean, updateChildren: boolean): void;
+    updateWorldMatrix(updateParents: boolean, updateChildren: boolean, force?: boolean): void;
 
     /**
      * Convert the object to three.js {@link https://github.com/mrdoob/three.js/wiki/JSON-Object-Scene-format-4 | JSON Object/Scene format}.

three/src/core/RenderTarget.d.ts

@@ -17,6 +17,7 @@ export interface RenderTargetOptions extends TextureParameters {
     count?: number | undefined;
     depth?: number | undefined;
     multiview?: boolean | undefined;
+    useArrayDepthTexture?: boolean | undefined;
 }
 
 export interface RenderTargetEventMap {
@@ -77,6 +78,16 @@ export class RenderTarget<
      */
     multiview: boolean;
 
+    /**
+     * Whether to create the depth texture as an array texture for per-layer depth testing.
+     * This is separate from multiview so layered render targets can use array depth without
+     * the multiview extension.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    useArrayDepthTexture: boolean;
+
     constructor(width?: number, height?: number, options?: RenderTargetOptions);
 
     get texture(): TTexture;

three/src/core/Timer.d.ts

@@ -63,7 +63,7 @@ declare class Timer {
     /**
      * Can be used to free all internal resources. Usually called when the timer instance isn't required anymore.
      */
-    dispose(): this;
+    dispose(): void;
 
     /**
      * Updates the internal state of the timer. This method should be called once per simulation step and before you

three/src/core/UniformsGroup.d.ts

@@ -31,7 +31,7 @@ export class UniformsGroup<TEventMap extends UniformsGroupEventMap = UniformsGro
 
     setUsage(value: Usage): this;
 
-    dispose(): this;
+    dispose(): void;
 
     copy(source: UniformsGroup): this;
 

three/src/extras/Controls.d.ts

@@ -6,13 +6,14 @@ export interface ControlsEventMap {}
 /**
  * Abstract base class for controls.
  */
-declare abstract class Controls<TEventMap extends ControlsEventMap = ControlsEventMap>
-    extends EventDispatcher<TEventMap>
-{
+declare abstract class Controls<
+    TEventMap extends ControlsEventMap = ControlsEventMap,
+    TObject extends Object3D = Object3D,
+> extends EventDispatcher<TEventMap> {
     /**
      * The 3D object that is managed by the controls.
      */
-    object: Object3D;
+    object: TObject;
 
     /**
      * The HTML element used for event listeners. If not provided via the constructor, {@link .connect} must be called
@@ -30,7 +31,7 @@ declare abstract class Controls<TEventMap extends ControlsEventMap = ControlsEve
      * @param object The object the controls should manage (usually the camera).
      * @param domElement The HTML element used for event listeners. (optional)
      */
-    constructor(object: Object3D, domElement?: HTMLElement | SVGElement | null);
+    constructor(object: TObject, domElement?: HTMLElement | SVGElement | null);
 
     /**
      * Connects the controls to the DOM. This method has so called "side effects" since it adds the module's event