@types/three 0.175.0 → 0.177.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: Mon, 02 Jun 2025 15:36:26 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/Addons.d.ts

@@ -28,7 +28,6 @@ export * from "./effects/AnaglyphEffect.js";
 export * from "./effects/AsciiEffect.js";
 export * from "./effects/OutlineEffect.js";
 export * from "./effects/ParallaxBarrierEffect.js";
-export * from "./effects/PeppersGhostEffect.js";
 export * from "./effects/StereoEffect.js";
 
 export * from "./environments/DebugEnvironment.js";

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

@@ -19,11 +19,16 @@ export class LDrawLoader extends Loader<Group> {
     ): this;
 
     preloadMaterials(url: string): Promise<void>;
-    setFileMap(fileMap: Record<string, string>): void;
-    setMaterials(materials: Material[]): void;
 
     parse(text: string, path: string, onLoad: (data: Group) => void, onError?: (error: unknown) => void): void;
 
-    addMaterial(material: Material): void;
+    setMaterials(materials: Material[]): this;
+    clearMaterials(): this;
+    addMaterials(materials: Material[]): this;
+    addDefaultMaterials(): this;
+
+    setFileMap(fileMap: Record<string, string>): this;
+
+    addMaterial(material: Material): this;
     getMaterial(colourCode: string): Material | null;
 }

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

@@ -10,6 +10,9 @@ export class Octree {
     triangles: Triangle[];
     layers: Layers;
 
+    trianglesPerLeaf: number;
+    maxLevel: number;
+
     constructor(box?: Box3 | null);
 
     addTriangle(triangle: Triangle): this;

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

@@ -1,14 +1,17 @@
-import { IUniform, ShaderMaterial, WebGLRenderTarget } from "three";
+import { IUniform, ShaderMaterial } from "three";
 
-import { FullScreenQuad, Pass } from "./Pass.js";
+import { Pass } from "./Pass.js";
 
-export class AfterimagePass extends Pass {
-    constructor(damp?: number);
-    shader: object;
+declare class AfterimagePass extends Pass {
     uniforms: Record<string, IUniform>;
-    textureComp: WebGLRenderTarget;
-    textureOld: WebGLRenderTarget;
-    shaderMaterial: ShaderMaterial;
-    compFsQuad: FullScreenQuad;
-    copyFsQuad: FullScreenQuad;
+
+    compFsMaterial: ShaderMaterial;
+    copyFsMaterial: ShaderMaterial;
+
+    constructor(damp?: number);
+
+    get damp(): number;
+    set damp(value: number);
 }
+
+export { AfterimagePass };

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

@@ -0,0 +1,7 @@
+import { ShaderPass } from "./ShaderPass.js";
+
+declare class FXAAPass extends ShaderPass {
+    constructor();
+}
+
+export { FXAAPass };

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

@@ -1,8 +1,14 @@
 import { NodeRepresentation, ShaderNodeObject } from "three/tsl";
 import { Node } from "three/webgpu";
 
+interface HashBlurOptions {
+    repeats?: NodeRepresentation | undefined;
+    mask?: NodeRepresentation | null | undefined;
+    premultipliedAlpha?: boolean | undefined;
+}
+
 export const hashBlur: (
     textureNode: NodeRepresentation,
     bluramount?: NodeRepresentation,
-    repeats?: NodeRepresentation,
+    options?: HashBlurOptions,
 ) => ShaderNodeObject<Node>;

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.177.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": "b00477afa796eb933a6474b328923a76b02409bbc6391520fd096f0ace56fb28",
+    "typeScriptVersion": "5.1"
 }

three/src/Three.Core.d.ts

@@ -39,7 +39,6 @@ export * from "./core/Object3D.js";
 export * from "./core/Raycaster.js";
 export * from "./core/RenderTarget.js";
 export * from "./core/RenderTarget3D.js";
-export * from "./core/RenderTargetArray.js";
 export * from "./core/Uniform.js";
 export * from "./core/UniformsGroup.js";
 export * from "./extras/Controls.js";
@@ -103,6 +102,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";

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;
@@ -319,6 +327,7 @@ export const mx_transform_uv: typeof TSL.mx_transform_uv;
 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 namespace: typeof TSL.namespace;
 export const negate: typeof TSL.negate;
 export const neutralToneMapping: typeof TSL.neutralToneMapping;
 export const nodeArray: typeof TSL.nodeArray;
@@ -377,6 +386,7 @@ export const pow: typeof TSL.pow;
 export const pow2: typeof TSL.pow2;
 export const pow3: typeof TSL.pow3;
 export const pow4: typeof TSL.pow4;
+export const premult: typeof TSL.premult;
 export const property: typeof TSL.property;
 export const radians: typeof TSL.radians;
 export const rand: typeof TSL.rand;
@@ -469,13 +479,10 @@ export const textureLoad: typeof TSL.textureLoad;
 export const textureSize: typeof TSL.textureSize;
 export const textureStore: typeof TSL.textureStore;
 export const thickness: typeof TSL.thickness;
-export const threshold: typeof TSL.threshold;
 export const time: typeof TSL.time;
 export const timerDelta: typeof TSL.timerDelta;
 export const timerGlobal: typeof TSL.timerGlobal;
 export const timerLocal: typeof TSL.timerLocal;
-export const toOutputColorSpace: typeof TSL.toOutputColorSpace;
-export const toWorkingColorSpace: typeof TSL.toWorkingColorSpace;
 export const toneMapping: typeof TSL.toneMapping;
 export const toneMappingExposure: typeof TSL.toneMappingExposure;
 export const toonOutlinePass: typeof TSL.toonOutlinePass;
@@ -492,8 +499,6 @@ export const transformedTangentView: typeof TSL.transformedTangentView;
 export const transformedTangentWorld: typeof TSL.transformedTangentWorld;
 export const transmission: typeof TSL.transmission;
 export const transpose: typeof TSL.transpose;
-export const tri: typeof TSL.tri;
-export const tri3: typeof TSL.tri3;
 export const triNoise3D: typeof TSL.triNoise3D;
 export const triplanarTexture: typeof TSL.triplanarTexture;
 export const triplanarTextures: typeof TSL.triplanarTextures;
@@ -501,9 +506,12 @@ export const trunc: typeof TSL.trunc;
 export const tslFn: typeof TSL.tslFn;
 export const uint: typeof TSL.uint;
 export const uniform: typeof TSL.uniform;
+export const uniformCubeTexture: typeof TSL.uniformCubeTexture;
 export const uniformArray: typeof TSL.uniformArray;
 export const uniformGroup: typeof TSL.uniformGroup;
+export const uniformTexture: typeof TSL.uniformTexture;
 export const uniforms: typeof TSL.uniforms;
+export const unpremult: typeof TSL.unpremult;
 export const userData: typeof TSL.userData;
 export const uv: typeof TSL.uv;
 export const uvec2: typeof TSL.uvec2;

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

@@ -11,6 +11,7 @@ export { default as WebGPURenderer } from "./renderers/webgpu/WebGPURenderer.Nod
 import * as RendererUtils from "./renderers/common/RendererUtils.js";
 export { RendererUtils };
 export { default as IESSpotLight } from "./lights/webgpu/IESSpotLight.js";
+export { default as ProjectorLight } from "./lights/webgpu/ProjectorLight.js";
 export { default as NodeLoader } from "./loaders/nodes/NodeLoader.js";
 export { default as NodeMaterialLoader } from "./loaders/nodes/NodeMaterialLoader.js";
 export { default as NodeObjectLoader } from "./loaders/nodes/NodeObjectLoader.js";

three/src/Three.WebGPU.d.ts

@@ -11,6 +11,7 @@ export { default as WebGPURenderer } from "./renderers/webgpu/WebGPURenderer.js"
 import * as RendererUtils from "./renderers/common/RendererUtils.js";
 export { RendererUtils };
 export { default as IESSpotLight } from "./lights/webgpu/IESSpotLight.js";
+export { default as ProjectorLight } from "./lights/webgpu/ProjectorLight.js";
 export { default as NodeLoader } from "./loaders/nodes/NodeLoader.js";
 export { default as NodeMaterialLoader } from "./loaders/nodes/NodeMaterialLoader.js";
 export { default as NodeObjectLoader } from "./loaders/nodes/NodeObjectLoader.js";

three/src/animation/tracks/NumberKeyframeTrack.d.ts

@@ -13,5 +13,5 @@ export class NumberKeyframeTrack extends KeyframeTrack {
      * @param {Array<number>} values - A list of keyframe values.
      * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
      */
-    constructor(name: string, times: Array<number>, values: Array<number>, interpolation?: InterpolationModes);
+    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<number>, interpolation?: InterpolationModes);
 }

three/src/animation/tracks/QuaternionKeyframeTrack.d.ts

@@ -13,5 +13,5 @@ export class QuaternionKeyframeTrack extends KeyframeTrack {
      * @param {Array<number>} values - A list of keyframe values.
      * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
      */
-    constructor(name: string, times: Array<number>, values: Array<number>, interpolation?: InterpolationModes);
+    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<number>, interpolation?: InterpolationModes);
 }

three/src/animation/tracks/StringKeyframeTrack.d.ts

@@ -14,5 +14,5 @@ export class StringKeyframeTrack extends KeyframeTrack {
      * @param {Array<number>} times - A list of keyframe times.
      * @param {Array<number>} values - A list of keyframe values.
      */
-    constructor(name: string, times: Array<number>, values: Array<number>);
+    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<number>);
 }

three/src/animation/tracks/VectorKeyframeTrack.d.ts

@@ -13,5 +13,5 @@ export class VectorKeyframeTrack extends KeyframeTrack {
      * @param {Array<number>} values - A list of keyframe values.
      * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
      */
-    constructor(name: string, times: Array<number>, values: Array<number>, interpolation?: InterpolationModes);
+    constructor(name: string, times: ArrayLike<number>, values: ArrayLike<number>, interpolation?: InterpolationModes);
 }

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

@@ -172,7 +172,11 @@ export class BufferGeometry<
      * You will have to call {@link dispose | .dispose}(), and create a new instance of {@link THREE.BufferGeometry | BufferGeometry}.
      * @defaultValue `{}`
      */
-    morphAttributes: Record<"position" | "normal" | "color", Array<BufferAttribute | InterleavedBufferAttribute>>;
+    morphAttributes: {
+        position?: Array<BufferAttribute | InterleavedBufferAttribute> | undefined;
+        normal?: Array<BufferAttribute | InterleavedBufferAttribute> | undefined;
+        color?: Array<BufferAttribute | InterleavedBufferAttribute> | undefined;
+    };
 
     /**
      * Used to control the morph target behavior; when set to true, the morph target data is treated as relative offsets, rather than as absolute positions/normals.

three/src/core/RenderTarget.d.ts

@@ -1,26 +1,9 @@
-import {
-    MagnificationTextureFilter,
-    MinificationTextureFilter,
-    PixelFormatGPU,
-    TextureDataType,
-    Wrapping,
-} from "../constants.js";
 import { Vector4 } from "../math/Vector4.js";
 import { DepthTexture } from "../textures/DepthTexture.js";
-import { Texture } from "../textures/Texture.js";
+import { Texture, TextureParameters } from "../textures/Texture.js";
 import { EventDispatcher } from "./EventDispatcher.js";
 
-export interface RenderTargetOptions {
-    wrapS?: Wrapping | undefined;
-    wrapT?: Wrapping | undefined;
-    magFilter?: MagnificationTextureFilter | undefined;
-    minFilter?: MinificationTextureFilter | undefined;
-    generateMipmaps?: boolean | undefined; // true
-    format?: number | undefined; // RGBAFormat
-    type?: TextureDataType | undefined; // UnsignedByteType
-    anisotropy?: number | undefined; // 1
-    colorSpace?: string | undefined;
-    internalFormat?: PixelFormatGPU | null | undefined; // null
+export interface RenderTargetOptions extends TextureParameters {
     depthBuffer?: boolean | undefined; // true
     stencilBuffer?: boolean | undefined; // false
     resolveDepthBuffer?: boolean | undefined; // true
@@ -32,6 +15,8 @@ export interface RenderTargetOptions {
      */
     samples?: number | undefined;
     count?: number | undefined;
+    depth?: number | undefined;
+    multiview?: boolean | undefined;
 }
 
 export class RenderTarget<TTexture extends Texture | Texture[] = Texture> extends EventDispatcher<{ dispose: {} }> {
@@ -78,6 +63,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/extras/DataUtils.d.ts

@@ -14,9 +14,9 @@ declare function toHalfFloat(val: number): number;
  */
 declare function fromHalfFloat(val: number): number;
 
-declare const DataUtils: {
-    toHalfFloat: typeof toHalfFloat;
-    fromHalfFloat: typeof fromHalfFloat;
-};
+declare class DataUtils {
+    static toHalfFloat(val: number): number;
+    static fromHalfFloat(val: number): number;
+}
 
 export { DataUtils, fromHalfFloat, toHalfFloat };

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,9 +45,10 @@ export class CapsuleGeometry extends BufferGeometry {
      */
     readonly parameters: {
         readonly radius: number;
-        readonly length: number;
+        readonly height: number;
         readonly capSegments: number;
         readonly radialSegments: number;
+        readonly heightSegments: number;
     };
 
     /** @internal */

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

@@ -69,4 +69,6 @@ export class SpotLightShadow extends LightShadow<PerspectiveCamera> {
      * @defaultValue `1`
      */
     focus: number;
+
+    aspect: number;
 }

three/src/lights/webgpu/ProjectorLight.d.ts

@@ -0,0 +1,17 @@
+import { ColorRepresentation } from "../../math/Color.js";
+import { SpotLight } from "../SpotLight.js";
+
+declare class ProjectorLight extends SpotLight {
+    aspect: number | null;
+
+    constructor(
+        color?: ColorRepresentation,
+        intensity?: number,
+        distance?: number,
+        angle?: number,
+        penumbra?: number,
+        decay?: number,
+    );
+}
+
+export default ProjectorLight;