@types/three 0.152.0 → 0.153.0

three/src/core/BufferAttribute.d.ts

@@ -1,4 +1,4 @@
-import { Usage } from '../constants';
+import { Usage, AttributeGPUType } from '../constants';
 import { Matrix3 } from './../math/Matrix3';
 import { Matrix4 } from './../math/Matrix4';
 
@@ -66,6 +66,14 @@ export class BufferAttribute {
      */
     usage: Usage;
 
+    /**
+     * Configures the bound GPU type for use in shaders. Either {@link FloatType} or {@link IntType}, default is {@link FloatType}.
+     *
+     * Note: this only has an effect for integer arrays and is not configurable for float arrays. For lower precision
+     * float types, see https://threejs.org/docs/#api/en/core/bufferAttributeTypes/BufferAttributeTypes.
+     */
+    gpuType: AttributeGPUType;
+
     /**
      * This can be used to only update some components of stored vectors (for example, just the component related to color).
      * @defaultValue `{ offset: number = 0; count: number = -1 }`
@@ -161,7 +169,7 @@ export class BufferAttribute {
 
     /**
      * Copy the array given here (which can be a normal array or `TypedArray`) into {@link BufferAttribute.array | array}.
-     * @See {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set | TypedArray.set} for notes on requirements if copying a `TypedArray`.
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/set | TypedArray.set} for notes on requirements if copying a `TypedArray`.
      */
     copyArray(array: ArrayLike<number>): this;
 

three/src/helpers/GridHelper.d.ts

@@ -1,5 +1,7 @@
 import { ColorRepresentation } from '../math/Color';
 import { LineSegments } from './../objects/LineSegments';
+import { BufferGeometry } from '../core/BufferGeometry';
+import { LineBasicMaterial } from '../materials/LineBasicMaterial';
 
 /**
  * The {@link GridHelper} is an object to define grids
@@ -16,7 +18,7 @@ import { LineSegments } from './../objects/LineSegments';
  * @see {@link https://threejs.org/docs/index.html#api/en/helpers/GridHelper | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/helpers/GridHelper.js | Source}
  */
-export class GridHelper extends LineSegments {
+export class GridHelper extends LineSegments<BufferGeometry, LineBasicMaterial> {
     /**
      * Creates a new {@link GridHelper} of size 'size' and divided into 'divisions' segments per side
      * @remarks

three/src/lights/DirectionalLight.d.ts

@@ -65,7 +65,7 @@ export class DirectionalLight extends Light<DirectionalLightShadow> {
      * This is set equal to {@link THREE.Object3D.DEFAULT_UP}, so that the light shines from the top down.
      * @defaultValue {@link Object3D.DEFAULT_UP} _(0, 1, 0)_
      */
-    override position: Vector3;
+    override readonly position: Vector3;
 
     /**
      * A {@link THREE.DirectionalLightShadow | DirectionalLightShadow} used to calculate shadows for this light.

three/src/lights/Light.d.ts

@@ -38,7 +38,7 @@ export abstract class Light<TShadowSupport extends LightShadow | undefined = Lig
 
     /**
      * The light's intensity, or strength.
-     * In {@link THREE.WebGLRenderer.physicallyCorrectLights | physically correct} mode, the units of intensity depend on the type of light.
+     * When {@link THREE.WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled, the units of intensity depend on the type of light.
      * @remarks Expects a `Float`
      * @defaultValue `1`
      */

three/src/lights/PointLight.d.ts

@@ -37,7 +37,7 @@ export class PointLight extends Light<PointLightShadow> {
     /**
      * The light's intensity.
      *
-     * When **{@link WebGLRenderer.physicallyCorrectLights | physically correct} mode** — intensity is the luminous intensity of the light measured in candela (cd).
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — intensity is the luminous intensity of the light measured in candela (cd).
      * @remarks Changing the intensity will also change the light's power.
      * @remarks Expects a `Float`
      * @defaultValue `1`
@@ -48,7 +48,7 @@ export class PointLight extends Light<PointLightShadow> {
      * When **Default mode** — When distance is zero, light does not attenuate. When distance is non-zero,
      * light will attenuate linearly from maximum intensity at the light's position down to zero at this distance from the light.
      *
-     * When **{@link WebGLRenderer.physicallyCorrectLights | Physically correct} rendering mode** — When distance is zero,
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — When distance is zero,
      * light will attenuate according to inverse-square law to infinite distance.
      * When distance is non-zero, light will attenuate according to inverse-square law until near the distance cutoff,
      * where it will then attenuate quickly and smoothly to 0. Inherently, cutoffs are not physically correct.
@@ -68,7 +68,7 @@ export class PointLight extends Light<PointLightShadow> {
 
     /**
      * The amount the light dims along the distance of the light.
-     * In **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** — the default value **should not** be changed.
+     * In context of physically-correct rendering the default value should not be changed.
      * @remarks Expects a `Float`
      * @defaultValue `2`
      */
@@ -87,7 +87,7 @@ export class PointLight extends Light<PointLightShadow> {
 
     /**
      * The light's power.
-     * When **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** — power is the luminous power of the light measured in lumens (lm).
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — power is the luminous power of the light measured in lumens (lm).
      * @remarks Changing the power will also change the light's intensity.
      * @remarks Expects a `Float`
      */

three/src/lights/RectAreaLight.d.ts

@@ -66,7 +66,7 @@ export class RectAreaLight extends Light<undefined> {
     /**
      * The light's intensity.
      * @remarks Changing the intensity will also change the light's power.
-     * In **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** — intensity is the luminance (brightness) of the light measured in nits (cd/m^2).
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — intensity is the luminance (brightness) of the light measured in nits (cd/m^2).
      * @remarks Expects a `Float`
      * @defaultValue `1`
      */
@@ -75,7 +75,7 @@ export class RectAreaLight extends Light<undefined> {
     /**
      * The light's power.
      * @remarks Changing the power will also change the light's intensity.
-     * In **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** — power is the luminous power of the light measured in lumens (lm).
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — power is the luminous power of the light measured in lumens (lm).
      * @remarks Expects a `Float`
      */
     power: number;

three/src/lights/SpotLight.d.ts

@@ -63,7 +63,7 @@ export class SpotLight extends Light<SpotLightShadow> {
      * This is set equal to {@link THREE.Object3D.DEFAULT_UP | Object3D.DEFAULT_UP} (0, 1, 0), so that the light shines from the top down.
      * @defaultValue `{@link Object3D.DEFAULT_UP}`
      */
-    position: Vector3;
+    readonly position: Vector3;
 
     /**
      * The {@link SpotLight} points from its {@link SpotLight.position | position} to target.position.
@@ -97,7 +97,7 @@ export class SpotLight extends Light<SpotLightShadow> {
     /**
      * The light's intensity.
      * @remarks Changing the intensity will also change the light's power.
-     * When **{@link WebGLRenderer.physicallyCorrectLights | Physically correct} rendering mode** — intensity is the luminous intensity of the light measured in candela (cd).
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — intensity is the luminous intensity of the light measured in candela (cd).
      * @remarks Expects a `Float`
      * @defaultValue `1`
      */
@@ -107,7 +107,7 @@ export class SpotLight extends Light<SpotLightShadow> {
      * When **Default mode** — When distance is zero, light does not attenuate. When distance is non-zero,
      * light will attenuate linearly from maximum intensity at the light's position down to zero at this distance from the light.
      *
-     * When **{@link WebGLRenderer.physicallyCorrectLights | Physically correct} rendering mode** — When distance is zero,
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** — When distance is zero,
      * light will attenuate according to inverse-square law to infinite distance.
      * When distance is non-zero, light will attenuate according to inverse-square law until near the distance cutoff,
      * where it will then attenuate quickly and smoothly to `0`. Inherently, cutoffs are not physically correct.
@@ -126,7 +126,7 @@ export class SpotLight extends Light<SpotLightShadow> {
 
     /**
      * The amount the light dims along the distance of the light.
-     * In **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** — the default value should not be changed.
+     * In context of physically-correct rendering the default value should not be changed.
      * @remarks Expects a `Float`
      * @defaultValue `2`
      */
@@ -141,7 +141,7 @@ export class SpotLight extends Light<SpotLightShadow> {
     /**
      * The light's power.
      * @remarks Changing the power will also change the light's intensity.
-     * In **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** —  power is the luminous power of the light measured in lumens (lm).
+     * When **{@link WebGLRenderer.useLegacyLights | legacy lighting mode} is disabled** —  power is the luminous power of the light measured in lumens (lm).
      * @remarks Expects a `Float`
      */
     power: number;

three/src/loaders/Loader.d.ts

@@ -12,7 +12,7 @@ export class Loader {
     crossOrigin: string;
 
     /**
-     * @default: false
+     * @default false
      */
     withCredentials: boolean;
 

three/src/materials/MeshPhysicalMaterial.d.ts

@@ -39,6 +39,10 @@ export interface MeshPhysicalMaterialParameters extends MeshStandardMaterialPara
     iridescence?: number | undefined;
     iridescenceThicknessRange?: [number, number] | undefined;
     iridescenceThicknessMap?: Texture | null | undefined;
+
+    anisotropy?: number | undefined;
+    anisotropyRotation?: number | undefined;
+    anisotropyMap?: Texture | null | undefined;
 }
 
 export class MeshPhysicalMaterial extends MeshStandardMaterial {
@@ -193,4 +197,19 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
      * @default null
      */
     iridescenceThicknessMap: Texture | null;
+
+    /**
+     * @default 0
+     */
+    anisotropy?: number;
+
+    /**
+     * @default 0
+     */
+    anisotropyRotation?: number;
+
+    /**
+     * @default null
+     */
+    anisotropyMap?: Texture | null;
 }

three/src/math/Color.d.ts

@@ -204,7 +204,8 @@ export class Color {
      */
     b: number;
 
-    set(color: ColorRepresentation): Color;
+    set(color: ColorRepresentation): this;
+    set(r: number, g: number, b: number): this;
 
     /**
      * Sets this color's {@link r}, {@link g} and {@link b} components from the x, y, and z components of the specified

three/src/math/Frustum.d.ts

@@ -5,6 +5,7 @@ import { Sprite } from './../objects/Sprite';
 import { Sphere } from './Sphere';
 import { Box3 } from './Box3';
 import { Vector3 } from './Vector3';
+import { CoordinateSystem } from '../constants';
 
 /**
  * Frustums are used to determine what is inside the camera's field of view. They help speed up the rendering process.
@@ -20,7 +21,7 @@ export class Frustum {
     set(p0: Plane, p1: Plane, p2: Plane, p3: Plane, p4: Plane, p5: Plane): Frustum;
     clone(): this;
     copy(frustum: Frustum): this;
-    setFromProjectionMatrix(m: Matrix4): this;
+    setFromProjectionMatrix(m: Matrix4, coordinateSystem?: CoordinateSystem): this;
     intersectsObject(object: Object3D): boolean;
     intersectsSprite(sprite: Sprite): boolean;
     intersectsSphere(sphere: Sphere): boolean;

three/src/math/MathUtils.d.ts

@@ -5,6 +5,7 @@ import { Quaternion } from './Quaternion';
  */
 
 export const DEG2RAD: number;
+
 export const RAD2DEG: number;
 
 export function generateUUID(): string;
@@ -13,10 +14,11 @@ export function generateUUID(): string;
  * Clamps the x to be between a and b.
  *
  * @param value Value to be clamped.
- * @param min Minimum value
+ * @param min Minimum value.
  * @param max Maximum value.
  */
 export function clamp(value: number, min: number, max: number): number;
+
 export function euclideanModulo(n: number, m: number): number;
 
 /**
@@ -30,44 +32,6 @@ export function euclideanModulo(n: number, m: number): number;
  */
 export function mapLinear(x: number, a1: number, a2: number, b1: number, b2: number): number;
 
-export function smoothstep(x: number, min: number, max: number): number;
-
-export function smootherstep(x: number, min: number, max: number): number;
-
-/**
- * Random float from 0 to 1 with 16 bits of randomness.
- * Standard Math.random() creates repetitive patterns when applied over larger space.
- *
- * @deprecated Use {@link Math#random Math.random()}
- */
-export function random16(): number;
-
-/**
- * Random integer from low to high interval.
- */
-export function randInt(low: number, high: number): number;
-
-/**
- * Random float from low to high interval.
- */
-export function randFloat(low: number, high: number): number;
-
-/**
- * Random float from - range / 2 to range / 2 interval.
- */
-export function randFloatSpread(range: number): number;
-
-/**
- * Deterministic pseudo-random float in the interval [ 0, 1 ].
- */
-export function seededRandom(seed?: number): number;
-
-export function degToRad(degrees: number): number;
-
-export function radToDeg(radians: number): number;
-
-export function isPowerOfTwo(value: number): boolean;
-
 export function inverseLerp(x: number, y: number, t: number): number;
 
 /**
@@ -99,18 +63,75 @@ export function damp(x: number, y: number, lambda: number, dt: number): number;
  */
 export function pingpong(x: number, length?: number): number;
 
+export function smoothstep(x: number, min: number, max: number): number;
+
+export function smootherstep(x: number, min: number, max: number): number;
+
 /**
- * @deprecated Use {@link Math#floorPowerOfTwo .floorPowerOfTwo()}
+ * Random integer from low to high interval.
  */
-export function nearestPowerOfTwo(value: number): number;
+export function randInt(low: number, high: number): number;
 
 /**
- * @deprecated Use {@link Math#ceilPowerOfTwo .ceilPowerOfTwo()}
+ * Random float from low to high interval.
  */
-export function nextPowerOfTwo(value: number): number;
+export function randFloat(low: number, high: number): number;
 
-export function floorPowerOfTwo(value: number): number;
+/**
+ * Random float from - range / 2 to range / 2 interval.
+ */
+export function randFloatSpread(range: number): number;
+
+/**
+ * Deterministic pseudo-random float in the interval [ 0, 1 ].
+ */
+export function seededRandom(seed?: number): number;
+
+export function degToRad(degrees: number): number;
+
+export function radToDeg(radians: number): number;
+
+export function isPowerOfTwo(value: number): boolean;
 
 export function ceilPowerOfTwo(value: number): number;
 
+export function floorPowerOfTwo(value: number): number;
+
 export function setQuaternionFromProperEuler(q: Quaternion, a: number, b: number, c: number, order: string): void;
+
+export function denormalize(
+    value: number,
+    array: Float32Array | Uint32Array | Uint16Array | Uint8Array | Int32Array | Int16Array | Int8Array,
+): number;
+
+export function normalize(
+    value: number,
+    array: Float32Array | Uint32Array | Uint16Array | Uint8Array | Int32Array | Int16Array | Int8Array,
+): number;
+
+export const MathUtils: {
+    DEG2RAD: typeof DEG2RAD;
+    RAD2DEG: typeof RAD2DEG;
+    generateUUID: typeof generateUUID;
+    clamp: typeof clamp;
+    euclideanModulo: typeof euclideanModulo;
+    mapLinear: typeof mapLinear;
+    inverseLerp: typeof inverseLerp;
+    lerp: typeof lerp;
+    damp: typeof damp;
+    pingpong: typeof pingpong;
+    smoothstep: typeof smoothstep;
+    smootherstep: typeof smootherstep;
+    randInt: typeof randInt;
+    randFloat: typeof randFloat;
+    randFloatSpread: typeof randFloatSpread;
+    seededRandom: typeof seededRandom;
+    degToRad: typeof degToRad;
+    radToDeg: typeof radToDeg;
+    isPowerOfTwo: typeof isPowerOfTwo;
+    ceilPowerOfTwo: typeof ceilPowerOfTwo;
+    floorPowerOfTwo: typeof floorPowerOfTwo;
+    setQuaternionFromProperEuler: typeof setQuaternionFromProperEuler;
+    normalize: typeof normalize;
+    denormalize: typeof denormalize;
+};

three/src/math/Matrix3.d.ts

@@ -1,6 +1,7 @@
 // https://threejs.org/docs/#api/en/math/Matrix3
 
 import { Matrix4 } from './Matrix4';
+import { Vector2 } from './Vector2';
 import { Vector3 } from './Vector3';
 
 export type Matrix3Tuple = [number, number, number, number, number, number, number, number, number];
@@ -55,6 +56,20 @@ export class Matrix3 implements Matrix {
      * Creates an identity matrix.
      */
     constructor();
+    /**
+     * Creates a 3x3 matrix with the given arguments in row-major order.
+     */
+    constructor(
+        n11: number,
+        n12: number,
+        n13: number,
+        n21: number,
+        n22: number,
+        n23: number,
+        n31: number,
+        n32: number,
+        n33: number,
+    );
 
     /**
      * Array with matrix values.
@@ -113,8 +128,8 @@ export class Matrix3 implements Matrix {
      * @param x the amount to translate in the X axis.
      * @param y the amount to translate in the Y axis.
      */
+    makeTranslation(v: Vector2): this;
     makeTranslation(x: number, y: number): this;
-    makeTranslation(x: number, y: number): Matrix3;
 
     /**
      * Sets this matrix as a 2D rotational transformation by theta radians. The resulting matrix will be:

three/src/math/Matrix4.d.ts

@@ -2,6 +2,7 @@ import { Vector3 } from './Vector3';
 import { Euler } from './Euler';
 import { Quaternion } from './Quaternion';
 import { Matrix, Matrix3 } from './Matrix3';
+import { CoordinateSystem } from '../constants';
 
 export type Matrix4Tuple = [
     number,
@@ -41,7 +42,31 @@ export type Matrix4Tuple = [
  * m.multiply( m3 );
  */
 export class Matrix4 implements Matrix {
+    /**
+     * Creates an identity matrix.
+     */
     constructor();
+    /**
+     * Creates a 4x4 matrix with the given arguments in row-major order.
+     */
+    constructor(
+        n11: number,
+        n12: number,
+        n13: number,
+        n14: number,
+        n21: number,
+        n22: number,
+        n23: number,
+        n24: number,
+        n31: number,
+        n32: number,
+        n33: number,
+        n34: number,
+        n41: number,
+        n42: number,
+        n43: number,
+        n44: number,
+    );
 
     /**
      * Array with matrix values.
@@ -147,7 +172,8 @@ export class Matrix4 implements Matrix {
     /**
      * Sets this matrix as translation transform.
      */
-    makeTranslation(x: number, y: number, z: number): Matrix4;
+    makeTranslation(v: Vector3): this;
+    makeTranslation(x: number, y: number, z: number): this;
 
     /**
      * Sets this matrix as rotation transform around x axis by theta radians.
@@ -199,20 +225,31 @@ export class Matrix4 implements Matrix {
      */
     decompose(translation: Vector3, rotation: Quaternion, scale: Vector3): Matrix4;
 
-    /**
-     * Creates a frustum matrix.
-     */
-    makePerspective(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4;
-
     /**
      * Creates a perspective projection matrix.
      */
-    makePerspective(fov: number, aspect: number, near: number, far: number): Matrix4;
+    makePerspective(
+        left: number,
+        right: number,
+        top: number,
+        bottom: number,
+        near: number,
+        far: number,
+        coordinateSystem?: CoordinateSystem,
+    ): Matrix4;
 
     /**
      * Creates an orthographic projection matrix.
      */
-    makeOrthographic(left: number, right: number, top: number, bottom: number, near: number, far: number): Matrix4;
+    makeOrthographic(
+        left: number,
+        right: number,
+        top: number,
+        bottom: number,
+        near: number,
+        far: number,
+        coordinateSystem?: CoordinateSystem,
+    ): Matrix4;
     equals(matrix: Matrix4): boolean;
 
     /**

three/src/math/Vector2.d.ts

@@ -448,4 +448,9 @@ export class Vector2 implements Vector {
      * Sets this vector's x and y from Math.random
      */
     random(): this;
+
+    /**
+     * Iterating through a Vector2 instance will yield its components (x, y) in the corresponding order.
+     */
+    [Symbol.iterator](): Iterator<number>;
 }

three/src/math/Vector3.d.ts

@@ -301,4 +301,9 @@ export class Vector3 implements Vector {
     random(): this;
 
     randomDirection(): this;
+
+    /**
+     * Iterating through a Vector3 instance will yield its components (x, y, z) in the corresponding order.
+     */
+    [Symbol.iterator](): Iterator<number>;
 }

three/src/math/Vector4.d.ts

@@ -220,4 +220,9 @@ export class Vector4 implements Vector {
      * Sets this vector's x, y, z and w from Math.random
      */
     random(): this;
+
+    /**
+     * Iterating through a Vector4 instance will yield its components (x, y, z, w) in the corresponding order.
+     */
+    [Symbol.iterator](): Iterator<number>;
 }

three/src/renderers/WebGLRenderer.d.ts

@@ -14,7 +14,7 @@ import { WebGLRenderTarget } from './WebGLRenderTarget';
 import { WebGLMultipleRenderTargets } from './WebGLMultipleRenderTargets';
 import { Object3D } from './../core/Object3D';
 import { Material } from './../materials/Material';
-import { ToneMapping, ShadowMapType, CullFace, TextureEncoding, ColorSpace } from '../constants';
+import { ToneMapping, ShadowMapType, CullFace, TextureEncoding, ColorSpace, WebGLCoordinateSystem } from '../constants';
 import { WebXRManager } from '../renderers/webxr/WebXRManager';
 import { BufferGeometry } from './../core/BufferGeometry';
 import { OffscreenCanvas, Texture } from '../textures/Texture';
@@ -200,6 +200,8 @@ export class WebGLRenderer implements Renderer {
      */
     outputColorSpace: ColorSpace;
 
+    get coordinateSystem(): typeof WebGLCoordinateSystem;
+
     /**
      * @default true
      */

three/src/renderers/webxr/WebXRManager.d.ts

@@ -26,31 +26,48 @@ export class WebXRManager extends EventDispatcher {
 
     /**
      * @default true
+     * @deprecated
      */
     cameraAutoUpdate: boolean;
 
     getController(index: number): XRTargetRaySpace;
+
     getControllerGrip(index: number): XRGripSpace;
+
     getHand(index: number): XRHandSpace;
+
     setFramebufferScaleFactor(value: number): void;
+
     setReferenceSpaceType(value: XRReferenceSpaceType): void;
+
     getReferenceSpace(): XRReferenceSpace | null;
+
     setReferenceSpace(value: XRReferenceSpace): void;
+
     getBaseLayer(): XRWebGLLayer | XRProjectionLayer;
+
     getBinding(): XRWebGLBinding;
+
     getFrame(): XRFrame;
+
     getSession(): XRSession | null;
+
     setSession(value: XRSession | null): Promise<void>;
+
+    /**
+     * @deprecated
+     */
     getCamera(): WebXRArrayCamera;
-    updateCamera(camera: PerspectiveCamera): void;
+
+    setUserCamera(camera: PerspectiveCamera): void;
+
+    updateCameraXR(camera: PerspectiveCamera): void;
+
     setAnimationLoop(callback: XRFrameRequestCallback | null): void;
+
     getFoveation(): number | undefined;
-    setFoveation(value: number): void;
 
-    /**
-     * Returns the set of planes detected by WebXR's plane detection API.
-     */
-    getPlanes(): Set<XRPlane>;
+    setFoveation(value: number): void;
 
     dispose(): void;
 }

three/src/textures/DepthTexture.d.ts

@@ -6,6 +6,7 @@ import {
     DeepTexturePixelFormat,
     MagnificationTextureFilter,
     MinificationTextureFilter,
+    TextureComparisonFunction,
 } from '../constants';
 
 /**
@@ -95,4 +96,12 @@ export class DepthTexture extends Texture {
      * @defaultValue {@link THREE.UnsignedInt248Type} when {@link format | .format} === {@link THREE.DepthStencilFormat}
      */
     type: TextureDataType;
+
+    /**
+     * This is used to define the comparison function used when comparing texels in the depth texture to the value in
+     * the depth buffer. Default is `null` which means comparison is disabled.
+     *
+     * See {@link THREE.TextureComparisonFunction} for functions.
+     */
+    compareFunction: TextureComparisonFunction | null;
 }

three/src/textures/FramebufferTexture.d.ts

@@ -1,5 +1,5 @@
 import { Texture } from './Texture';
-import { MagnificationTextureFilter, MinificationTextureFilter, PixelFormat } from '../constants';
+import { MagnificationTextureFilter, MinificationTextureFilter } from '../constants';
 
 /**
  * This class can only be used in combination with {@link THREE.WebGLRenderer.copyFramebufferToTexture | WebGLRenderer.copyFramebufferToTexture()}.
@@ -32,9 +32,8 @@ export class FramebufferTexture extends Texture {
      * Create a new instance of {@link FramebufferTexture}
      * @param width The width of the texture.
      * @param height The height of the texture.
-     * @param format See {@link Texture.format | .format}. Default {@link THREE.RGBAFormat}.
      */
-    constructor(width: number, height: number, format: PixelFormat);
+    constructor(width: number, height: number);
 
     /**
      * Read-only flag to check if a given object is of type {@link FramebufferTexture}.

three/src/textures/Source.d.ts

@@ -17,6 +17,8 @@ export class Source {
      */
     readonly isSource: true;
 
+    readonly id: number;
+
     /**
      * The actual data of a texture.
      * @remarks The type of this property depends on the texture that uses this instance.