@types/three 0.176.0 → 0.178.0

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

@@ -0,0 +1,20 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const triplanarTextures: (
+    textureXNode: Node,
+    textureYNode?: Node | null,
+    textureZNode?: Node | null,
+    scaleNode?: Node,
+    positionNode?: Node,
+    normalNode?: Node,
+) => ShaderNodeObject<Node>;
+
+export const triplanarTexture: (
+    textureXNode: Node,
+    textureYNode?: Node | null,
+    textureZNode?: Node | null,
+    scaleNode?: Node,
+    positionNode?: Node,
+    normalNode?: Node,
+) => ShaderNodeObject<Node>;

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

@@ -1,14 +1,15 @@
+import Node from "../core/Node.js";
 import OperatorNode from "../math/OperatorNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export const rotateUV: (
-    uv: NodeRepresentation,
-    rotation: NodeRepresentation,
-    center?: NodeRepresentation,
+    uv: Node,
+    rotation: Node,
+    center?: Node,
 ) => ShaderNodeObject<OperatorNode>;
 
 export const spherizeUV: (
-    uv: NodeRepresentation,
-    strength: NodeRepresentation,
-    center?: NodeRepresentation,
+    uv: Node,
+    strength: Node | number,
+    center?: Node,
 ) => ShaderNodeObject<OperatorNode>;

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

@@ -1,4 +1,4 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const viewportSafeUV: (uv?: NodeRepresentation | null) => ShaderNodeObject<Node>;
+export const viewportSafeUV: (uv?: Node | null) => ShaderNodeObject<Node>;

three/src/objects/LOD.d.ts

@@ -87,7 +87,7 @@ export class LOD<TEventMap extends Object3DEventMap = Object3DEventMap> extends
      * Otherwise `false`.
      * @param distance Distance of the level to delete.
      */
-    removeLabel(distance: number): boolean;
+    removeLevel(distance: number): boolean;
 
     /**
      * Get the currently active {@link LOD} level

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>;
 
     /**
@@ -463,7 +463,7 @@ export class WebGLRenderer {
      * position. The `depthTexture` and `texture` property of 3D render targets are supported as well.
      *
      * When using render target textures as `srcTexture` and `dstTexture`, you must make sure both render targets are
-     * intitialized e.g. via {@link .initRenderTarget}().
+     * initialized e.g. via {@link .initRenderTarget}().
      *
      * @param srcTexture Specifies the source texture.
      * @param dstTexture Specifies the destination texture.

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

@@ -13,12 +13,12 @@ declare module "../../core/Object3D.js" {
 }
 
 export interface BackendParameters {
-    canvas?: HTMLCanvasElement | undefined;
+    canvas?: HTMLCanvasElement | OffscreenCanvas | undefined;
 }
 
 export default abstract class Backend {
     renderer: Renderer | null;
-    domElement: HTMLCanvasElement | null;
+    domElement: HTMLCanvasElement | OffscreenCanvas | null;
 
     constructor(parameters?: BackendParameters);
 
@@ -26,5 +26,5 @@ export default abstract class Backend {
 
     abstract get coordinateSystem(): CoordinateSystem;
 
-    getDomElement(): HTMLCanvasElement;
+    getDomElement(): HTMLCanvasElement | OffscreenCanvas;
 }

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

@@ -53,7 +53,14 @@ declare class RenderObject {
         count: number;
     } | null;
     attributes: Array<BufferAttribute | InterleavedBufferAttribute> | null;
+    attributesId: {
+        [attributeName: string]: number;
+    } | null;
     pipeline: RenderPipeline | null;
+    group: {
+        start: number;
+        count: number;
+    } | null;
     vertexBuffers: Array<BufferAttribute | InterleavedBuffer> | null;
     drawParams: {
         vertexCount: number;
@@ -64,14 +71,15 @@ declare class RenderObject {
     bundle: BundleGroup | null;
     clippingContext: ClippingContext | null;
     clippingContextCacheKey: string;
-    initialNodesCacheKey: string;
-    initialCacheKey: string;
+    initialNodesCacheKey: number;
+    initialCacheKey: number;
     _nodeBuilderState: NodeBuilderState | null;
     _bindings: BindGroup[] | null;
     _monitor: NodeMaterialObserver | null;
     onDispose: (() => void) | null;
     readonly isRenderObject: true;
     onMaterialDispose: () => void;
+    onGeometryDispose: () => void;
     /**
      * Constructs a new render object.
      *

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

@@ -239,7 +239,7 @@ declare class Renderer {
      * @param {?Scene} targetScene - If the first argument is a 3D object, this parameter must represent the scene the 3D object is going to be added.
      * @return {Promise<Array|undefined>} A Promise that resolves when the compile has been finished.
      */
-    compileAsync(scene: Object3D, camera: Camera, targetScene?: Object3D | null): Promise<void>;
+    compileAsync(scene: Object3D, camera: Camera, targetScene?: Scene | null): Promise<void>;
     /**
      * Renders the scene in an async fashion.
      *
@@ -248,7 +248,7 @@ declare class Renderer {
      * @param {Camera} camera - The camera.
      * @return {Promise} A Promise that resolves when the render has been finished.
      */
-    renderAsync(scene: Scene, camera: Camera): Promise<void>;
+    renderAsync(scene: Object3D, camera: Camera): Promise<void>;
     /**
      * Can be used to synchronize CPU operations with GPU tasks. So when this method is called,
      * the CPU waits for the GPU to complete its operation (e.g. a compute task).
@@ -321,7 +321,7 @@ declare class Renderer {
      * @return {?Promise} A Promise that resolve when the scene has been rendered.
      * Only returned when the renderer has not been initialized.
      */
-    render(scene: Scene, camera: Camera): Promise<void> | undefined;
+    render(scene: Object3D, camera: Camera): Promise<void> | undefined;
     /**
      * Returns an internal render target which is used when computing the output tone mapping
      * and color space conversion. Unlike in `WebGLRenderer`, this is done in a separate render
@@ -340,7 +340,8 @@ declare class Renderer {
      * @param {boolean} [useFrameBufferTarget=true] - Whether to use a framebuffer target or not.
      * @return {RenderContext} The current render context.
      */
-    _renderScene(scene: Scene, camera: Camera, useFrameBufferTarget?: boolean): RenderContext | undefined;
+    _renderScene(scene: Object3D, camera: Camera, useFrameBufferTarget?: boolean): RenderContext | undefined;
+    _setXRLayerSize(width: number, height: number): void;
     /**
      * The output pass performs tone mapping and color space conversion.
      *
@@ -676,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}.
      *
@@ -978,6 +983,6 @@ declare class Renderer {
      * @param {Scene} targetScene - If the first argument is a 3D object, this parameter must represent the scene the 3D object is going to be added.
      * @return {function(Object3D, Camera, ?Scene): Promise|undefined} A Promise that resolves when the compile has been finished.
      */
-    get compile(): (scene: Object3D, camera: Camera, targetScene?: Object3D | null) => Promise<void>;
+    get compile(): (scene: Object3D, camera: Camera, targetScene?: Scene | null) => Promise<void>;
 }
 export default Renderer;

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

@@ -0,0 +1,40 @@
+import { Wrapping } from "../../constants.js";
+import { Texture } from "../../textures/Texture.js";
+
+/**
+ * This special type of texture is intended for compute shaders.
+ * It can be used to compute the data of a texture with a compute shader.
+ *
+ * Note: This type of texture can only be used with `WebGPURenderer`
+ * and a WebGPU backend.
+ */
+declare class Storage3DTexture extends Texture {
+    /**
+     * This defines how the texture is wrapped in the depth direction and corresponds to
+     * *W* in UVW mapping.
+     */
+    wrapR: Wrapping;
+
+    /**
+     * This flag can be used for type testing.
+     *
+     * @default true
+     */
+    readonly isStorageTexture: true;
+
+    /**
+     * Indicates whether this texture is a 3D texture.
+     */
+    is3DTexture: boolean;
+
+    /**
+     * Constructs a new storage texture.
+     *
+     * @param {number} [width=1] - The storage texture's width.
+     * @param {number} [height=1] - The storage texture's height.
+     * @param {number} [depth=1] - The storage texture's depth.
+     */
+    constructor(width?: number, height?: number, depth?: number);
+}
+
+export default Storage3DTexture;

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

@@ -0,0 +1,29 @@
+import { Wrapping } from "../../constants.js";
+import { Texture } from "../../textures/Texture.js";
+
+/**
+ * This special type of texture is intended for compute shaders.
+ * It can be used to compute the data of a texture with a compute shader.
+ *
+ * Note: This type of texture can only be used with `WebGPURenderer`
+ * and a WebGPU backend.
+ */
+declare class Storage3DTexture extends Texture {
+    /**
+     * This flag can be used for type testing.
+     *
+     * @default true
+     */
+    readonly isStorageTexture: true;
+
+    /**
+     * Constructs a new storage texture.
+     *
+     * @param {number} [width=1] - The storage texture's width.
+     * @param {number} [height=1] - The storage texture's height.
+     * @param {number} [depth=1] - The storage texture's depth.
+     */
+    constructor(width?: number, height?: number, depth?: number);
+}
+
+export default Storage3DTexture;

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

@@ -6,7 +6,7 @@ import Backend from "./Backend.js";
 import DataMap from "./DataMap.js";
 import Info from "./Info.js";
 import Renderer from "./Renderer.js";
-type SizeVector3Unitialized = Vector3 & {
+type SizeVector3Uninitialized = Vector3 & {
     width?: number;
     height?: number;
     depth?: number;
@@ -99,7 +99,7 @@ declare class Textures extends DataMap<{
      * @param {Vector3} target - The target vector.
      * @return {Vector3} The target vector.
      */
-    getSize(texture: Texture, target?: SizeVector3Unitialized): SizeVector3;
+    getSize(texture: Texture, target?: SizeVector3Uninitialized): SizeVector3;
     /**
      * Computes the number of mipmap levels for the given texture.
      *

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;
@@ -211,6 +219,21 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
      * @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,
@@ -221,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,
@@ -232,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/common/XRRenderTarget.d.ts

@@ -8,8 +8,9 @@ import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
  */
 declare class XRRenderTarget extends RenderTarget {
     readonly isXRRenderTarget: true;
-    hasExternalTextures: boolean;
-    autoAllocateDepthBuffer: boolean;
+    _hasExternalTextures: boolean;
+    _autoAllocateDepthBuffer: boolean;
+    _isOpaqueFramebuffer: boolean;
     /**
      * Constructs a new XR render target.
      *

three/src/renderers/common/nodes/NodeLibrary.d.ts

@@ -4,7 +4,7 @@ import { Material } from "../../../materials/Material.js";
 import NodeMaterial from "../../../materials/nodes/NodeMaterial.js";
 import Node from "../../../nodes/core/Node.js";
 import AnalyticLightNode from "../../../nodes/lighting/AnalyticLightNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../../../nodes/tsl/TSLCore.js";
+import { ShaderNodeObject } from "../../../nodes/tsl/TSLCore.js";
 /**
  * The purpose of a node library is to assign node implementations
  * to existing library features. In `WebGPURenderer` lights, materials
@@ -22,10 +22,7 @@ declare class NodeLibrary {
     materialNodes: Map<string, {
         new(): NodeMaterial;
     }>;
-    toneMappingNodes: Map<
-        ToneMapping,
-        (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>
-    >;
+    toneMappingNodes: Map<ToneMapping, (color: Node, exposure: Node) => ShaderNodeObject<Node>>;
     /**
      * Constructs a new node library.
      */
@@ -48,7 +45,7 @@ declare class NodeLibrary {
      * @param {number} toneMapping - The tone mapping.
      */
     addToneMapping(
-        toneMappingNode: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>,
+        toneMappingNode: (color: Node, exposure: Node) => ShaderNodeObject<Node>,
         toneMapping: ToneMapping,
     ): void;
     /**
@@ -57,9 +54,7 @@ declare class NodeLibrary {
      * @param {number} toneMapping - The tone mapping.
      * @return {?Function} The tone mapping node function. Returns `null` if no node function is found.
      */
-    getToneMappingFunction(
-        toneMapping: ToneMapping,
-    ): ((color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>) | null;
+    getToneMappingFunction(toneMapping: ToneMapping): ((color: Node, exposure: Node) => ShaderNodeObject<Node>) | null;
     /**
      * Returns a node material class definition for a material type.
      *

three/src/renderers/common/nodes/NodeSampledTexture.d.ts

@@ -23,7 +23,7 @@ declare class NodeSampledCubeTexture extends NodeSampledTexture {
 }
 
 declare class NodeSampledTexture3D extends NodeSampledTexture {
-    readonly isSampledTexture3D = true;
+    readonly isSampledTexture3D: true;
 }
 
 export { NodeSampledCubeTexture, NodeSampledTexture, NodeSampledTexture3D };

three/src/renderers/common/nodes/Nodes.d.ts

@@ -106,7 +106,7 @@ declare class Nodes extends DataMap<{
      * @param {RenderObject} renderObject - The render object.
      * @return {number} The cache key.
      */
-    getForRenderCacheKey(renderObject: RenderObject): string;
+    getForRenderCacheKey(renderObject: RenderObject): number;
     /**
      * Returns a node builder state for the given render object.
      *

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

@@ -1,4 +1,5 @@
 import Renderer, { RendererParameters } from "../common/Renderer.js";
+import StandardNodeLibrary from "./nodes/StandardNodeLibrary.js";
 import { WebGPUBackendParameters } from "./WebGPUBackend.js";
 
 export interface WebGPURendererParameters extends RendererParameters, WebGPUBackendParameters {
@@ -6,6 +7,8 @@ export interface WebGPURendererParameters extends RendererParameters, WebGPUBack
 }
 
 declare class WebGPURenderer extends Renderer {
+    library: StandardNodeLibrary;
+
     readonly isWebGPURenderer: true;
 
     constructor(parameters?: WebGPURendererParameters);

three/src/renderers/webgpu/nodes/StandardNodeLibrary.d.ts

@@ -1,3 +1,16 @@
+import { LineBasicNodeMaterialNodeProperties } from "../../../materials/nodes/LineBasicNodeMaterial.js";
+import { LineDashedNodeMaterialNodeProperties } from "../../../materials/nodes/LineDashedNodeMaterial.js";
+import { MeshBasicNodeMaterialNodeProperties } from "../../../materials/nodes/MeshBasicNodeMaterial.js";
+import { MeshLambertNodeMaterialNodeProperties } from "../../../materials/nodes/MeshLambertNodeMaterial.js";
+import { MeshMatcapNodeMaterialNodeProperties } from "../../../materials/nodes/MeshMatcapNodeMaterial.js";
+import { MeshNormalNodeMaterialNodeProperties } from "../../../materials/nodes/MeshNormalNodeMaterial.js";
+import { MeshPhongNodeMaterialNodeProperties } from "../../../materials/nodes/MeshPhongNodeMaterial.js";
+import { MeshPhysicalNodeMaterialNodeProperties } from "../../../materials/nodes/MeshPhysicalNodeMaterial.js";
+import { MeshStandardNodeMaterialNodeProperties } from "../../../materials/nodes/MeshStandardNodeMaterial.js";
+import { MeshToonNodeMaterialNodeProperties } from "../../../materials/nodes/MeshToonNodeMaterial.js";
+import { PointsNodeMaterialNodeProperties } from "../../../materials/nodes/PointsNodeMaterial.js";
+import { ShadowNodeMaterialNodeProperties } from "../../../materials/nodes/ShadowNodeMaterial.js";
+import { SpriteNodeMaterialNodeProperties } from "../../../materials/nodes/SpriteNodeMaterial.js";
 import NodeLibrary from "../../common/nodes/NodeLibrary.js";
 /**
  * This version of a node library represents the standard version
@@ -13,4 +26,56 @@ declare class StandardNodeLibrary extends NodeLibrary {
      */
     constructor();
 }
+declare module "../../../materials/MeshPhongMaterial.js" {
+    interface MeshPhongMaterialProperties extends MeshPhongNodeMaterialNodeProperties {
+    }
+}
+declare module "../../../materials/MeshStandardMaterial.js" {
+    interface MeshStandardMaterialProperties extends MeshStandardNodeMaterialNodeProperties {
+    }
+}
+declare module "../../../materials/MeshPhysicalMaterial.js" {
+    interface MeshPhysicalMaterialProperties extends MeshPhysicalNodeMaterialNodeProperties {
+    }
+}
+declare module "../../../materials/MeshToonMaterial.js" {
+    interface MeshToonMaterialProperties extends MeshToonNodeMaterialNodeProperties {
+    }
+}
+declare module "../../../materials/MeshBasicMaterial.js" {
+    interface MeshBasicMaterialProperties extends MeshBasicNodeMaterialNodeProperties {
+    }
+}
+declare module "../../../materials/MeshLambertMaterial.js" {
+    interface MeshLambertMaterialProperties extends MeshLambertNodeMaterialNodeProperties {
+    }
+}
+declare module "../../../materials/MeshNormalMaterial.js" {
+    interface MeshNormalMaterialProperties extends MeshNormalNodeMaterialNodeProperties {
+    }
+}
+declare module "../../../materials/MeshMatcapMaterial.js" {
+    interface MeshMatcapMaterialProperties extends MeshMatcapNodeMaterialNodeProperties {
+    }
+}
+declare module "../../../materials/LineBasicMaterial.js" {
+    interface LineBasicMaterialProperties extends LineBasicNodeMaterialNodeProperties {
+    }
+}
+declare module "../../../materials/LineDashedMaterial.js" {
+    interface LineDashedMaterialProperties extends LineDashedNodeMaterialNodeProperties {
+    }
+}
+declare module "../../../materials/PointsMaterial.js" {
+    interface PointsMaterialProperties extends PointsNodeMaterialNodeProperties {
+    }
+}
+declare module "../../../materials/SpriteMaterial.js" {
+    interface SpriteMaterialProperties extends SpriteNodeMaterialNodeProperties {
+    }
+}
+declare module "../../../materials/ShadowMaterial.js" {
+    interface ShadowMaterialProperties extends ShadowNodeMaterialNodeProperties {
+    }
+}
 export default StandardNodeLibrary;

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",
@@ -314,15 +314,24 @@ export enum GPUInputStepMode {
 }
 
 export enum GPUFeatureName {
+    CoreFeaturesAndLimits = "core-features-and-limits",
     DepthClipControl = "depth-clip-control",
     Depth32FloatStencil8 = "depth32float-stencil8",
     TextureCompressionBC = "texture-compression-bc",
+    TextureCompressionBCSliced3D = "texture-compression-bc-sliced-3d",
     TextureCompressionETC2 = "texture-compression-etc2",
     TextureCompressionASTC = "texture-compression-astc",
+    TextureCompressionASTCSliced3D = "texture-compression-astc-sliced-3d",
     TimestampQuery = "timestamp-query",
     IndirectFirstInstance = "indirect-first-instance",
     ShaderF16 = "shader-f16",
     RG11B10UFloat = "rg11b10ufloat-renderable",
     BGRA8UNormStorage = "bgra8unorm-storage",
     Float32Filterable = "float32-filterable",
+    Float32Blendable = "float32-blendable",
+    ClipDistances = "clip-distances",
+    DualSourceBlending = "dual-source-blending",
+    Subgroups = "subgroups",
+    TextureFormatsTier1 = "texture-formats-tier1",
+    TextureFormatsTier2 = "texture-formats-tier2",
 }

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