@types/three 0.175.0 → 0.177.0

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

@@ -1,8 +1,10 @@
 import { SpotLight } from "../../lights/SpotLight.js";
 import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import AnalyticLightNode from "./AnalyticLightNode.js";
 
-export default class PointLightNode extends AnalyticLightNode<SpotLight> {
+declare class SpotLightNode extends AnalyticLightNode<SpotLight> {
     directionNode: Node;
 
     coneCosNode: Node;
@@ -11,5 +13,17 @@ export default class PointLightNode extends AnalyticLightNode<SpotLight> {
     cutoffDistanceNode: Node;
     decayExponentNode: Node;
 
+    colorNode: Node;
+
     constructor(light?: SpotLight | null);
+
+    getLightCoord(builder: NodeBuilder): ShaderNodeObject<Node>;
 }
+
+declare module "three" {
+    export interface SpotLight {
+        attenuationNode?: ((lightNode: SpotLightNode) => Node) | null | undefined;
+    }
+}
+
+export default SpotLightNode;

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

@@ -7,9 +7,7 @@ import StackNode from "../core/StackNode.js";
 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 +32,8 @@ export interface NodeElements {
 
     element: typeof element;
     convert: typeof convert;
+
+    append: typeof append;
 }
 
 export function addMethodChaining(name: string, nodeElement: unknown): void;
@@ -113,7 +113,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 +136,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"
@@ -246,43 +246,34 @@ interface Layout {
 
 interface ShaderNodeFn<Args extends readonly unknown[]> {
     (...args: Args): ShaderNodeObject<ShaderCallNodeInternal>;
+
     shaderNode: ShaderNodeObject<ShaderNodeInternal>;
+    id: number;
+
+    getNodeType: (builder: NodeBuilder) => string | null;
+    getCacheKey: (force?: boolean) => number;
+
     setLayout: (layout: Layout) => this;
-    once: () => this;
+
+    once: (namespace?: string | null) => this;
 }
 
-export function Fn(jsFunc: () => void): ShaderNodeFn<[]>;
+export function Fn(jsFunc: (builder: NodeBuilder) => void): ShaderNodeFn<[]>;
 export function Fn<T extends readonly unknown[]>(
-    jsFunc: (args: T) => void,
+    jsFunc: (args: T, builder: NodeBuilder) => void,
 ): ShaderNodeFn<ProxiedTuple<T>>;
 export function Fn<T extends { readonly [key: string]: unknown }>(
-    jsFunc: (args: T) => void,
+    jsFunc: (args: T, builder: NodeBuilder) => 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 +313,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,8 +31,9 @@ declare class ReflectorBaseNode extends Node {
     bounces: boolean;
 
     virtualCameras: WeakMap<Camera, Camera>;
-    renderTargets: WeakMap<Camera, RenderTarget>;
+    renderTargets: Map<Camera, RenderTarget>;
     forceUpdate: boolean;
+    hasOutput: boolean;
 
     constructor(textureNode: TextureNode, parameters?: ReflectorNodeParameters);
 

three/src/objects/Mesh.d.ts

@@ -76,6 +76,14 @@ export class Mesh<
      */
     morphTargetDictionary?: { [key: string]: number } | undefined;
 
+    /**
+     * The number of instances of this mesh.
+     * Can only be used with {@link WebGPURenderer}.
+     *
+     * @default 1
+     */
+    count: number;
+
     /**
      * Updates the morphTargets to have no influence on the object
      * @remarks Resets the {@link morphTargetInfluences} and {@link morphTargetDictionary} properties.

three/src/objects/Sprite.d.ts

@@ -62,4 +62,12 @@ export class Sprite<TEventMap extends Object3DEventMap = Object3DEventMap> exten
      * @defaultValue {@link THREE.Vector2 | `new Vector2(0.5, 0.5)`}.
      */
     center: Vector2;
+
+    /**
+     * The number of instances of this sprite.
+     * Can only be used with {@link WebGPURenderer}.
+     *
+     * @default 1
+     */
+    count: number;
 }

three/src/renderers/WebGLRenderer.d.ts

@@ -202,8 +202,6 @@ export class WebGLRenderer {
 
     shadowMap: WebGLShadowMap;
 
-    pixelRatio: number;
-
     capabilities: WebGLCapabilities;
     properties: WebGLProperties;
     renderLists: WebGLRenderLists;
@@ -408,6 +406,7 @@ export class WebGLRenderer {
         height: number,
         buffer: TypedArray,
         activeCubeFaceIndex?: number,
+        textureIndex?: number,
     ): void;
 
     readRenderTargetPixelsAsync(
@@ -418,6 +417,7 @@ export class WebGLRenderer {
         height: number,
         buffer: TypedArray,
         activeCubeFaceIndex?: number,
+        textureIndex?: number,
     ): Promise<TypedArray>;
 
     /**

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.
      *
@@ -322,6 +341,7 @@ declare class Renderer {
      * @return {RenderContext} The current render context.
      */
     _renderScene(scene: Scene, camera: Camera, useFrameBufferTarget?: boolean): RenderContext | undefined;
+    _setXRLayerSize(width: number, height: number): void;
     /**
      * The output pass performs tone mapping and color space conversion.
      *
@@ -657,6 +677,10 @@ declare class Renderer {
      * @return {?RenderTarget} The current output render target. Returns `null` if no output target is set.
      */
     getOutputRenderTarget(): RenderTarget<Texture> | null;
+    /**
+     * Resets the renderer to the initial state before WebXR started.
+     */
+    _resetXRState(): void;
     /**
      * Callback for {@link Renderer#setRenderObjectFunction}.
      *

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

@@ -1,6 +1,7 @@
 import { ArrayCamera } from "../../cameras/ArrayCamera.js";
 import { PerspectiveCamera } from "../../cameras/PerspectiveCamera.js";
 import { EventDispatcher } from "../../core/EventDispatcher.js";
+import { RenderTarget } from "../../core/RenderTarget.js";
 import { CylinderGeometry } from "../../geometries/CylinderGeometry.js";
 import { PlaneGeometry } from "../../geometries/PlaneGeometry.js";
 import { Material } from "../../materials/Material.js";
@@ -11,6 +12,7 @@ import { Vector3 } from "../../math/Vector3.js";
 import { Mesh } from "../../objects/Mesh.js";
 import { WebXRController } from "../webxr/WebXRController.js";
 import { AnimationContext } from "./Animation.js";
+import QuadMesh from "./QuadMesh.js";
 import Renderer from "./Renderer.js";
 import { XRRenderTarget } from "./XRRenderTarget.js";
 export interface XRManagerEventMap {
@@ -77,6 +79,12 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
     _xrRenderTarget: XRRenderTarget | null;
     _layers: XRLayerObject[];
     _supportsLayers: boolean;
+    _frameBufferTargets:
+        | WeakMap<XRRenderTarget, {
+            frameBufferTarget: RenderTarget | null;
+            quad: QuadMesh;
+        }>
+        | null;
     _createXRLayer: (layer: XRLayerObject) => XRLayer;
     _gl: WebGL2RenderingContext | null;
     _currentAnimationContext: AnimationContext | null;
@@ -98,12 +106,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 +213,27 @@ 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;
+    /**
+     * This method can be used in XR applications to create a quadratic layer that presents a separate
+     * rendered scene.
+     *
+     * @param {number} width - The width of the layer plane in world units.
+     * @param {number} height - The height of the layer plane in world units.
+     * @param {Vector3} translation - The position/translation of the layer plane in world units.
+     * @param {Quaternion} quaternion - The orientation of the layer plane expressed as a quaternion.
+     * @param {number} pixelwidth - The width of the layer's render target in pixels.
+     * @param {number} pixelheight - The height of the layer's render target in pixels.
+     * @param {Function} rendercall - A callback function that renders the layer. Similar to code in
+     * the default animation loop, this method can be used to update/transform 3D object in the layer's scene.
+     * @param {Object} [attributes={}] - Allows to configure the layer's render target.
+     * @return {Mesh} A mesh representing the quadratic XR layer. This mesh should be added to the XR scene.
+     */
     createQuadLayer(
         width: number,
         height: number,
@@ -212,6 +244,22 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
         rendercall: () => void,
         attributes?: LayerAttributes,
     ): Mesh<PlaneGeometry, MeshBasicMaterial, import("../../core/Object3D.js").Object3DEventMap>;
+    /**
+     * This method can be used in XR applications to create a cylindrical layer that presents a separate
+     * rendered scene.
+     *
+     * @param {number} radius - The radius of the cylinder in world units.
+     * @param {number} centralAngle - The central angle of the cylinder in radians.
+     * @param {number} aspectratio - The aspect ratio.
+     * @param {Vector3} translation - The position/translation of the layer plane in world units.
+     * @param {Quaternion} quaternion - The orientation of the layer plane expressed as a quaternion.
+     * @param {number} pixelwidth - The width of the layer's render target in pixels.
+     * @param {number} pixelheight - The height of the layer's render target in pixels.
+     * @param {Function} rendercall - A callback function that renders the layer. Similar to code in
+     * the default animation loop, this method can be used to update/transform 3D object in the layer's scene.
+     * @param {Object} [attributes={}] - Allows to configure the layer's render target.
+     * @return {Mesh} A mesh representing the cylindrical XR layer. This mesh should be added to the XR scene.
+     */
     createCylinderLayer(
         radius: number,
         centralAngle: number,
@@ -223,6 +271,12 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
         rendercall: () => void,
         attributes?: LayerAttributes,
     ): Mesh<CylinderGeometry, MeshBasicMaterial, import("../../core/Object3D.js").Object3DEventMap>;
+    /**
+     * Renders the XR layers that have been previously added to the scene.
+     *
+     * This method is usually called in your animation loop before rendering
+     * the actual scene via `renderer.render( scene, camera );`.
+     */
     renderLayers(): void;
     /**
      * Returns the current XR session.

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/renderers/webgpu/nodes/WGSLNodeBuilder.d.ts

@@ -48,6 +48,7 @@ export default class WGSLNodeBuilder extends NodeBuilder {
         texture: Texture,
         textureProperty: string,
         uvIndexSnippet: string,
+        depthSnippet: string | null,
         valueSnippet: string,
     ): string;
     isUnfilterable(texture: Texture): boolean;

three/src/renderers/webgpu/utils/WebGPUConstants.d.ts

@@ -225,7 +225,7 @@ export enum GPUBlendFactor {
     SrcAlpha = "src-alpha",
     OneMinusSrcAlpha = "one-minus-src-alpha",
     Dst = "dst",
-    OneMinusDstColor = "one-minus-dst",
+    OneMinusDst = "one-minus-dst",
     DstAlpha = "dst-alpha",
     OneMinusDstAlpha = "one-minus-dst-alpha",
     SrcAlphaSaturated = "src-alpha-saturated",

three/src/textures/DepthTexture.d.ts

@@ -28,6 +28,7 @@ export class DepthTexture extends Texture {
      * @param minFilter  See {@link Texture.minFilter | .minFilter}. Default {@link THREE.NearestFilter}
      * @param anisotropy See {@link Texture.anisotropy | .anisotropy}. Default {@link THREE.Texture.DEFAULT_ANISOTROPY}
      * @param format See {@link DepthTexture.format | .format}. Default {@link THREE.DepthFormat}
+     * @param {number} [depth=1] - The depth of the texture.
      */
     constructor(
         width: number,
@@ -40,6 +41,7 @@ export class DepthTexture extends Texture {
         minFilter?: MinificationTextureFilter,
         anisotropy?: number,
         format?: DepthTexturePixelFormat,
+        depth?: number,
     );
 
     /**
@@ -53,8 +55,8 @@ export class DepthTexture extends Texture {
      * Overridden with a record type holding width and height.
      * @override
      */
-    get image(): { width: number; height: number };
-    set image(value: { width: number; height: number });
+    get image(): { width: number; height: number; depth: number };
+    set image(value: { width: number; height: number; depth: number });
 
     /**
      * @override