@types/three 0.178.1 → 0.180.0

three/src/nodes/tsl/TSLCore.d.ts

@@ -210,6 +210,7 @@ export class ShaderNode<T = {}, R extends Node = Node> {
 }
 
 export function nodeObject<T extends NodeObjectOption>(obj: T): NodeObject<T>;
+export function nodeObjectIntent<T extends NodeObjectOption>(obj: T): NodeObject<T>;
 export function nodeObjects<T>(obj: T): NodeObjects<T>;
 
 export function nodeArray<T extends NodeObjectOption[]>(obj: readonly [...T]): NodeArray<T>;
@@ -234,6 +235,21 @@ export function nodeImmutable<T>(
     ...params: ProxiedTuple<GetConstructors<T>>
 ): ShaderNodeObject<ConstructedNode<T>>;
 
+export function nodeProxyIntent<T>(
+    nodeClass: T,
+): (...params: ProxiedTuple<GetConstructors<T>>) => ShaderNodeObject<ConstructedNode<T>>;
+
+export function nodeProxyIntent<T, S extends GetPossibleScopes<T>>(
+    nodeClass: T,
+    scope: S,
+): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
+
+export function nodeProxyIntent<T, S extends GetPossibleScopes<T>>(
+    nodeClass: T,
+    scope: S,
+    factor: NodeObjectOption,
+): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => ShaderNodeObject<ConstructedNode<T>>;
+
 interface Layout {
     name: string;
     type: string;

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

@@ -0,0 +1,21 @@
+import Node from "../core/Node.js";
+import NodeFrame from "../core/NodeFrame.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export type EventNodeType = typeof EventNode.OBJECT | typeof EventNode.MATERIAL;
+
+declare class EventNode extends Node {
+    eventType: EventNodeType;
+    callback: (frame: NodeFrame) => void;
+
+    constructor(eventType: EventNodeType, callback: (frame: NodeFrame) => void);
+
+    static OBJECT: "object";
+    static MATERIAL: "material";
+}
+
+export default EventNode;
+
+export const OnObjectUpdate: (callback: (frame: NodeFrame) => void) => ShaderNodeObject<Node>;
+
+export const OnMaterialUpdate: (callback: (frame: NodeFrame) => void) => ShaderNodeObject<Node>;

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

@@ -9,6 +9,8 @@ export interface RTTNodeOptions {
 }
 
 declare class RTTNode extends TextureNode {
+    readonly isRTTNode: true;
+
     node: Node;
     width: number | null;
     height: number | null;

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

@@ -7,9 +7,15 @@ import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export interface ReflectorNodeParameters {
     target?: Object3D | undefined;
+    /**
+     * @deprecated The "resolution" parameter has been renamed to "resolutionScale".
+     */
     resolution?: number | undefined;
+    resolutionScale?: number | undefined;
     generateMipmaps?: boolean | undefined;
     bounces?: boolean | undefined;
+    depth?: boolean | undefined;
+    samples?: number | undefined;
 }
 
 declare class ReflectorNode extends TextureNode {
@@ -26,7 +32,7 @@ declare class ReflectorBaseNode extends Node {
     textureNode: TextureNode;
 
     target: Object3D;
-    resolution: number;
+    resolutionScale: number;
     generateMipmaps: boolean;
     bounces: boolean;
 
@@ -40,6 +46,15 @@ declare class ReflectorBaseNode extends Node {
     getVirtualCamera(camera: Camera): Camera;
 
     getRenderTarget(camera: Camera): RenderTarget;
+
+    /**
+     * @deprecated The "resolution" property has been renamed to "resolutionScale" and is now of type `number`.
+     */
+    get resolution(): number;
+    /**
+     * @deprecated The "resolution" property has been renamed to "resolutionScale" and is now of type `number`.
+     */
+    set resolution(value: number);
 }
 
 export const reflector: (parameters?: ReflectorNodeParameters) => ShaderNodeObject<ReflectorNode>;

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

@@ -3,14 +3,15 @@ import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class SampleNode extends Node {
     callback: (uv: Node) => Node;
+    uvNode: Node | null;
 
     readonly isSampleNode: true;
 
-    constructor(callback: (uv: Node) => Node);
+    constructor(callback: (uv: Node) => Node, uvNode?: Node | null);
 
     sample(uv: Node): Node;
 }
 
 export default SampleNode;
 
-export const sample: (callback: (uv: Node) => Node) => ShaderNodeObject<SampleNode>;
+export const sample: (callback: (uv: Node) => Node, uv?: Node | null) => ShaderNodeObject<SampleNode>;

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

@@ -4,18 +4,3 @@ import { ShaderNodeObject } from "../tsl/TSLCore.js";
 export const time: ShaderNodeObject<Node>;
 export const deltaTime: ShaderNodeObject<Node>;
 export const frameId: ShaderNodeObject<Node>;
-
-/**
- * @deprecated Use "time" instead.
- */
-export const timerLocal: (timeScale?: number) => ShaderNodeObject<Node>;
-
-/**
- * @deprecated Use "time" instead.
- */
-export const timerGlobal: (timeScale?: number) => ShaderNodeObject<Node>;
-
-/**
- * @deprecated Use "deltaTime" instead.
- */
-export const timerDelta: (timeScale?: number) => ShaderNodeObject<Node>;

three/src/objects/InstancedMesh.d.ts

@@ -28,7 +28,6 @@ export interface InstancedMeshEventMap extends Object3DEventMap {
  * A special version of {@link THREE.Mesh | Mesh} with instanced rendering support
  * @remarks
  * Use {@link InstancedMesh} if you have to render a large number of objects with the same geometry and material(s) but with different world transformations
- * @remarks
  * The usage of {@link InstancedMesh} will help you to reduce the number of draw calls and thus improve the overall rendering performance in your application.
  * @see Example: {@link https://threejs.org/examples/#webgl_instancing_dynamic | WebGL / instancing / dynamic}
  * @see Example: {@link https://threejs.org/examples/#webgl_instancing_performance | WebGL / instancing / performance}
@@ -76,8 +75,8 @@ export class InstancedMesh<
      * @remarks
      * The `count` value passed into the {@link InstancedMesh | constructor} represents the **maximum** number of instances of this mesh.
      * You can change the number of instances at runtime to an integer value in the range `[0, count]`.
-     * @remarks If you need more instances than the original `count` value, you have to create a new InstancedMesh.
-     * @remarks Expects a `Integer`
+     * If you need more instances than the original `count` value, you have to create a new InstancedMesh.
+     * Expects a `Integer`
      */
     count: number;
 

three/src/renderers/WebGLRenderer.d.ts

@@ -12,8 +12,6 @@ import { Vector2 } from "../math/Vector2.js";
 import { Vector3 } from "../math/Vector3.js";
 import { Vector4 } from "../math/Vector4.js";
 import { Scene } from "../scenes/Scene.js";
-import { Data3DTexture } from "../textures/Data3DTexture.js";
-import { DataArrayTexture } from "../textures/DataArrayTexture.js";
 import { OffscreenCanvas, Texture } from "../textures/Texture.js";
 import { WebGLCapabilities, WebGLCapabilitiesParameters } from "./webgl/WebGLCapabilities.js";
 import { WebGLExtensions } from "./webgl/WebGLExtensions.js";
@@ -456,29 +454,6 @@ export class WebGLRenderer {
         dstLevel?: number,
     ): void;
 
-    /**
-     * @deprecated Use "copyTextureToTexture" instead.
-     *
-     * Copies the pixels of a texture in the bounds `srcRegion` in the destination texture starting from the given
-     * 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
-     * initialized e.g. via {@link .initRenderTarget}().
-     *
-     * @param srcTexture Specifies the source texture.
-     * @param dstTexture Specifies the destination texture.
-     * @param srcRegion Specifies the bounds
-     * @param dstPosition Specifies the pixel offset into the dstTexture where the copy will occur.
-     * @param level Specifies the destination mipmap level of the texture.
-     */
-    copyTextureToTexture3D(
-        srcTexture: Texture,
-        dstTexture: Data3DTexture | DataArrayTexture,
-        srcRegion?: Box3 | null,
-        dstPosition?: Vector3 | null,
-        level?: number,
-    ): void;
-
     /**
      * Initializes the given WebGLRenderTarget memory. Useful for initializing a render target so data can be copied
      * into it using {@link WebGLRenderer.copyTextureToTexture} before it has been rendered to.

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

@@ -30,7 +30,7 @@ declare class Attributes extends DataMap<{
      * Deletes the data for the given attribute.
      *
      * @param {BufferAttribute} attribute - The attribute.
-     * @return {Object|null} The deleted attribute data.
+     * @return {?Object} The deleted attribute data.
      */
     delete(attribute: BufferAttribute | InterleavedBufferAttribute): Data;
     /**

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

@@ -27,8 +27,8 @@ declare class Color4 extends Color {
      * string argument to this method.
      *
      * @param {number|string|Color} r - The red value.
-     * @param {number} g - The green value.
-     * @param {number} b - The blue value.
+     * @param {number} [g] - The green value.
+     * @param {number} [b] - The blue value.
      * @param {number} [a=1] - The alpha value.
      * @return {Color4} A reference to this object.
      */

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

@@ -625,15 +625,15 @@ declare class Renderer {
      */
     clearStencilAsync(): Promise<void>;
     /**
-     * The current output tone mapping of the renderer. When a render target is set,
-     * the output tone mapping is always `NoToneMapping`.
+     * The current tone mapping of the renderer. When not producing screen output,
+     * the tone mapping is always `NoToneMapping`.
      *
      * @type {number}
      */
     get currentToneMapping(): ToneMapping;
     /**
-     * The current output color space of the renderer. When a render target is set,
-     * the output color space is always `LinearSRGBColorSpace`.
+     * The current color space of the renderer. When not producing screen output,
+     * the color space is always the working color space.
      *
      * @type {string}
      */
@@ -742,17 +742,25 @@ declare class Renderer {
      * if the renderer has been initialized.
      *
      * @param {Node|Array<Node>} computeNodes - The compute node(s).
+     * @param {?(Array<number>|number)} [dispatchSizeOrCount=null] - Array with [ x, y, z ] values for dispatch or a single number for the count.
      * @return {Promise|undefined} A Promise that resolve when the compute has finished. Only returned when the renderer has not been initialized.
      */
-    compute(computeNodes: ComputeNode | ComputeNode[]): Promise<void> | undefined;
+    compute(
+        computeNodes: ComputeNode | ComputeNode[],
+        dispatchSizeOrCount?: number[] | number | null,
+    ): Promise<void> | undefined;
     /**
      * Execute a single or an array of compute nodes.
      *
      * @async
      * @param {Node|Array<Node>} computeNodes - The compute node(s).
+     * @param {?(Array<number>|number)} [dispatchSizeOrCount=null] - Array with [ x, y, z ] values for dispatch or a single number for the count.
      * @return {Promise} A Promise that resolve when the compute has finished.
      */
-    computeAsync(computeNodes: ComputeNode | ComputeNode[]): Promise<void>;
+    computeAsync(
+        computeNodes: ComputeNode | ComputeNode[],
+        dispatchSizeOrCount?: number[] | number | null,
+    ): Promise<void>;
     /**
      * Checks if the given feature is supported by the selected backend.
      *
@@ -798,7 +806,7 @@ declare class Renderer {
      * Copies the current bound framebuffer into the given texture.
      *
      * @param {FramebufferTexture} framebufferTexture - The texture.
-     * @param {?Vector2|Vector4} [rectangle=null] - A two or four dimensional vector that defines the rectangular portion of the framebuffer that should be copied.
+     * @param {?(Vector2|Vector4)} [rectangle=null] - A two or four dimensional vector that defines the rectangular portion of the framebuffer that should be copied.
      */
     copyFramebufferToTexture(framebufferTexture: FramebufferTexture, rectangle?: Rectangle | null): void;
     /**
@@ -938,7 +946,7 @@ declare class Renderer {
      * @param {LightsNode} lightsNode - The current lights node.
      * @param {?{start: number, count: number}} group - Only relevant for objects using multiple materials. This represents a group entry from the respective `BufferGeometry`.
      * @param {ClippingContext} clippingContext - The clipping context.
-     * @param {?string} [passId=null] - An optional ID for identifying the pass.
+     * @param {string} [passId] - An optional ID for identifying the pass.
      */
     _renderObjectDirect(
         object: Object3D,
@@ -962,7 +970,7 @@ declare class Renderer {
      * @param {LightsNode} lightsNode - The current lights node.
      * @param {?{start: number, count: number}} group - Only relevant for objects using multiple materials. This represents a group entry from the respective `BufferGeometry`.
      * @param {ClippingContext} clippingContext - The clipping context.
-     * @param {?string} [passId=null] - An optional ID for identifying the pass.
+     * @param {string} [passId] - An optional ID for identifying the pass.
      */
     _createObjectPipeline(
         object: Object3D,

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

@@ -1,21 +1,14 @@
 import { Texture } from "../../textures/Texture.js";
-import Binding from "./Binding.js";
+import Sampler from "./Sampler.js";
 
-declare class SampledTexture extends Binding {
+declare class SampledTexture extends Sampler {
     id: number;
 
-    texture: Texture | null;
-    version: number;
     store: boolean;
-    generation: number | null;
 
     readonly isSampledTexture: true;
 
     constructor(name: string, texture: Texture | null);
-
-    needsBindingsUpdate(generation: number): boolean;
-
-    update(): boolean;
 }
 
 declare class SampledArrayTexture extends SampledTexture {

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

@@ -1,11 +1,17 @@
-import TextureNode from "../../nodes/accessors/TextureNode.js";
+import { Texture } from "../../textures/Texture.js";
 import Binding from "./Binding.js";
 
 declare class Sampler extends Binding {
-    texture: TextureNode | null;
     version: number;
+
+    generation: number | null;
+
     readonly isSampler: true;
-    constructor(name: string, texture: TextureNode | null);
+
+    constructor(name: string, texture: Texture | null);
+
+    set texture(value: Texture | null);
+    get texture(): Texture | null;
 }
 
 export default Sampler;

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

@@ -35,6 +35,8 @@ declare class Storage3DTexture extends Texture {
      * @param {number} [depth=1] - The storage texture's depth.
      */
     constructor(width?: number, height?: number, depth?: number);
+
+    setSize(width: number, height: number, depth: number): void;
 }
 
 export default Storage3DTexture;

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

@@ -24,6 +24,8 @@ declare class Storage3DTexture extends Texture {
      * @param {number} [depth=1] - The storage texture's depth.
      */
     constructor(width?: number, height?: number, depth?: number);
+
+    setSize(width: number, height: number, depth: number): void;
 }
 
 export default Storage3DTexture;

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

@@ -2,4 +2,6 @@ import { Texture } from "../../textures/Texture.js";
 
 export default class StorageTexture extends Texture {
     constructor(width?: number, height?: number);
+
+    setSize(width: number, height: number, depth: number): void;
 }

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

@@ -110,7 +110,7 @@ declare class Textures extends DataMap<{
      */
     getMipLevels(texture: Texture, width: number, height: number): number;
     /**
-     * Returns `true` if the given texture requires mipmaps.
+     * Returns `true` if the given texture makes use of mipmapping.
      *
      * @param {Texture} texture - The texture.
      * @return {boolean} Whether mipmaps are required or not.

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

@@ -1,4 +1,3 @@
-import RenderContext from "./RenderContext.js";
 /**
  * Abstract base class of a timestamp query pool.
  *
@@ -19,13 +18,13 @@ declare abstract class TimestampQueryPool {
      */
     constructor(maxQueries?: number);
     /**
-     * Allocate queries for a specific renderContext.
+     * Allocate queries for a specific uid.
      *
      * @abstract
-     * @param {Object} renderContext - The render context to allocate queries for.
+     * @param {string} uid - A unique identifier for the render context.
      * @returns {?number}
      */
-    abstract allocateQueriesForContext(renderContext: RenderContext): number | null;
+    abstract allocateQueriesForContext(uid: string): number | null;
     /**
      * Resolve all timestamps and return data (or process them).
      *

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

@@ -78,7 +78,9 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
     _controllerInputSources: (XRInputSource | null)[];
     _xrRenderTarget: XRRenderTarget | null;
     _layers: XRLayerObject[];
+    _sessionUsesLayers: boolean;
     _supportsLayers: boolean;
+    _supportsGlBinding: boolean;
     _frameBufferTargets:
         | WeakMap<XRRenderTarget, {
             frameBufferTarget: RenderTarget | null;
@@ -207,6 +209,15 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
      * @return {'opaque'|'additive'|'alpha-blend'|undefined} The environment blend mode. Returns `undefined` when used outside of a XR session.
      */
     getEnvironmentBlendMode(): XREnvironmentBlendMode | undefined;
+    /**
+     * Returns the current XR binding.
+     *
+     * Creates a new binding if needed and the browser is
+     * capable of doing so.
+     *
+     * @return {?XRWebGLBinding} The XR binding. Returns `null` if one cannot be created.
+     */
+    getBinding(): XRWebGLBinding | null;
     /**
      * Returns the current XR frame.
      *

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

@@ -92,17 +92,17 @@ declare class NodeLibrary {
     /**
      * Adds a node class definition for the given type to the provided type library.
      *
-     * @param {any} nodeClass - The node class definition.
+     * @param {Node.constructor} nodeClass - The node class definition.
      * @param {number|string} type - The object type.
-     * @param {Map} library - The type library.
+     * @param {Map<number|string,Node.constructor>} library - The type library.
      */
     addType<TNodeClass, TType>(nodeClass: TNodeClass, type: TType, library: Map<TType, TNodeClass>): void;
     /**
      * Adds a node class definition for the given class definition to the provided type library.
      *
-     * @param {any} nodeClass - The node class definition.
-     * @param {any} baseClass - The class definition.
-     * @param {WeakMap} library - The type library.
+     * @param {Node.constructor} nodeClass - The node class definition.
+     * @param {Node.constructor} baseClass - The class definition.
+     * @param {WeakMap<Node.constructor, Node.constructor>} library - The type library.
      */
     addClass<TNodeClass, TBaseClass extends object>(
         nodeClass: TNodeClass,

three/src/renderers/webgl/WebGLCapabilities.d.ts

@@ -14,7 +14,7 @@ export interface WebGLCapabilitiesParameters {
     /**
      * default is false.
      */
-    reverseDepthBuffer?: boolean | undefined;
+    reversedDepthBuffer?: boolean | undefined;
 }
 
 export class WebGLCapabilities {
@@ -30,7 +30,7 @@ export class WebGLCapabilities {
 
     precision: string;
     logarithmicDepthBuffer: boolean;
-    reverseDepthBuffer: boolean;
+    reversedDepthBuffer: boolean;
 
     maxTextures: number;
     maxVertexTextures: number;

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

@@ -19,7 +19,6 @@ export default class WGSLNodeBuilder extends NodeBuilder {
     builtins: { [key in BuiltinStage]: Map<string, BuiltinType> };
     uniformGroups: { [key in NodeShaderStage]: NodeUniformsGroup };
 
-    needsToWorkingColorSpace(texture: Texture): boolean;
     _generateTextureSample(
         texture: Texture,
         textureProperty: string,

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

@@ -112,7 +112,7 @@ export enum GPUTextureFormat {
     // Packed 32-bit formats
     RGB9E5UFloat = "rgb9e5ufloat",
     RGB10A2Unorm = "rgb10a2unorm",
-    RG11B10UFloat = "rgb10a2unorm",
+    RG11B10UFloat = "rg11b10ufloat",
 
     // 64-bit formats
 

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

@@ -1,10 +1,9 @@
 import { Mesh } from "../../objects/Mesh.js";
-import { Texture } from "../../textures/Texture.js";
-import { WebGLRenderer } from "../WebGLRenderer.js";
+import { ExternalTexture } from "../../textures/ExternalTexture.js";
 import { WebXRArrayCamera } from "./WebXRManager.js";
 
 export class WebXRDepthSensing {
-    texture: Texture | null;
+    texture: ExternalTexture | null;
     mesh: Mesh | null;
 
     depthNear: number;
@@ -12,11 +11,11 @@ export class WebXRDepthSensing {
 
     constructor();
 
-    init(renderer: WebGLRenderer, depthData: XRWebGLDepthInformation, renderState: XRRenderState): void;
+    init(depthData: XRWebGLDepthInformation, renderState: XRRenderState): void;
 
     getMesh(cameraXR: WebXRArrayCamera): Mesh | null;
 
     reset(): void;
 
-    getDepthTexture(): Texture | null;
+    getDepthTexture(): ExternalTexture | null;
 }

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

@@ -5,7 +5,7 @@ import { PerspectiveCamera } from "../../cameras/PerspectiveCamera.js";
 import { EventDispatcher } from "../../core/EventDispatcher.js";
 import { Vector4 } from "../../math/Vector4.js";
 import { Mesh } from "../../objects/Mesh.js";
-import { Texture } from "../../textures/Texture.js";
+import { ExternalTexture } from "../../textures/ExternalTexture.js";
 import { WebGLRenderer } from "../WebGLRenderer.js";
 import { XRGripSpace, XRHandSpace, XRTargetRaySpace } from "./WebXRController.js";
 
@@ -65,7 +65,7 @@ export class WebXRManager extends EventDispatcher<WebXRManagerEventMap> {
 
     getEnvironmentBlendMode: () => XREnvironmentBlendMode | undefined;
 
-    getDepthTexture: () => Texture | null;
+    getDepthTexture: () => ExternalTexture | null;
 
     updateCamera: (camera: PerspectiveCamera) => void;
 
@@ -79,6 +79,8 @@ export class WebXRManager extends EventDispatcher<WebXRManagerEventMap> {
 
     getDepthSensingMesh: () => Mesh | null;
 
+    getCameraTexture: (xrCamera: WebXRCamera) => ExternalTexture | undefined;
+
     setAnimationLoop: (callback: XRFrameRequestCallback | null) => void;
 
     dispose: () => void;

three/src/textures/CompressedTexture.d.ts

@@ -39,9 +39,9 @@ export class CompressedTexture extends Texture {
      * @param colorSpace See {@link Texture.colorSpace .colorSpace}. Default {@link NoColorSpace}
      */
     constructor(
-        mipmaps?: CompressedTextureMipmap[],
-        width?: number,
-        height?: number,
+        mipmaps: CompressedTextureMipmap[],
+        width: number,
+        height: number,
         format?: CompressedPixelFormat,
         type?: TextureDataType,
         mapping?: Mapping,
@@ -71,7 +71,7 @@ export class CompressedTexture extends Texture {
      *  The mipmaps array should contain objects with data, width and height. The mipmaps should be of the correct
      *  format and type.
      */
-    mipmaps: CompressedTextureMipmap[] | undefined;
+    mipmaps: CompressedTextureMipmap[];
 
     /**
      * @override

three/src/textures/Data3DTexture.d.ts

@@ -1,4 +1,5 @@
 import { MagnificationTextureFilter, MinificationTextureFilter, Wrapping } from "../constants.js";
+import { TypedArray } from "../core/BufferAttribute.js";
 import { TextureImageData } from "./DataTexture.js";
 import { Texture } from "./Texture.js";
 
@@ -40,7 +41,7 @@ export class Data3DTexture extends Texture {
      * @param height Height of the texture. Default `1`.
      * @param depth Depth of the texture. Default `1`.
      */
-    constructor(data?: BufferSource | null, width?: number, height?: number, depth?: number);
+    constructor(data?: TypedArray | null, width?: number, height?: number, depth?: number);
 
     /**
      * Read-only flag to check if a given object is of type {@link Data3DTexture}.

three/src/textures/DataTexture.d.ts

@@ -6,6 +6,7 @@ import {
     TextureDataType,
     Wrapping,
 } from "../constants.js";
+import { TypedArray } from "../core/BufferAttribute.js";
 import { Texture } from "./Texture.js";
 
 /**
@@ -51,7 +52,7 @@ export class DataTexture extends Texture {
      * @param colorSpace See {@link Texture.colorSpace | .colorSpace}. Default {@link NoColorSpace}
      */
     constructor(
-        data?: ArrayBufferView | null,
+        data?: TypedArray | null,
         width?: number,
         height?: number,
         format?: PixelFormat,
@@ -111,7 +112,7 @@ export class DataTexture extends Texture {
 }
 
 export interface TextureImageData {
-    data: ArrayBufferView;
+    data: TypedArray;
     height: number;
     width: number;
 }

three/src/textures/ExternalTexture.d.ts

@@ -0,0 +1,11 @@
+import { Texture } from "./Texture.js";
+
+declare class ExternalTexture extends Texture {
+    sourceTexture: WebGLTexture | GPUTexture | null;
+
+    readonly isExternalTexture: true;
+
+    constructor(sourceTexture?: WebGLTexture | GPUTexture | null);
+}
+
+export { ExternalTexture };

three/src/textures/Texture.d.ts

@@ -207,7 +207,7 @@ export class Texture extends EventDispatcher<{ dispose: {} }> {
      * Array of user-specified mipmaps
      * @defaultValue `[]`
      */
-    mipmaps: CompressedTextureMipmap[] | CubeTexture[] | HTMLCanvasElement[] | undefined;
+    mipmaps: CompressedTextureMipmap[] | CubeTexture[] | HTMLCanvasElement[];
 
     /**
      * How the image is applied to the object.