@types/three 0.183.1 → 0.184.0

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

@@ -0,0 +1,63 @@
+import { EventDispatcher } from "../../core/EventDispatcher.js";
+
+export interface ReadbackBufferEventMap {
+    release: {};
+    dispose: {};
+}
+
+/**
+ * A readback buffer is used to transfer data from the GPU to the CPU.
+ * It is primarily used to read back compute shader results.
+ *
+ * @augments EventDispatcher
+ */
+declare class ReadbackBuffer<TEventMap extends ReadbackBufferEventMap = ReadbackBufferEventMap>
+    extends EventDispatcher<TEventMap>
+{
+    /**
+     * Constructs a new readback buffer.
+     *
+     * @param {number} maxByteLength - The maximum size of the buffer to be read back.
+     */
+    constructor(maxByteLength: number);
+    /**
+     * Name used for debugging purposes.
+     *
+     * @type {string}
+     */
+    name: string;
+    /**
+     * The mapped, read back array buffer.
+     *
+     * @type {ArrayBuffer|null}
+     */
+    buffer: ArrayBuffer | null;
+    /**
+     * The maximum size of the buffer to be read back.
+     *
+     * @type {number}
+     */
+    maxByteLength: number;
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isReadbackBuffer: boolean;
+    /**
+     * Releases the mapped buffer data so the GPU buffer can be
+     * used by the GPU again.
+     *
+     * Note: Any `ArrayBuffer` data associated with this readback buffer
+     * are removed and no longer accessible after calling this method.
+     */
+    release(): void;
+    /**
+     * Frees internal resources.
+     */
+    dispose(): void;
+}
+
+export default ReadbackBuffer;

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

@@ -1,5 +1,6 @@
 import { Camera } from "../../cameras/Camera.js";
 import BundleGroup from "./BundleGroup.js";
+import RenderContext from "./RenderContext.js";
 
 /**
  * This module is used to represent render bundles inside the renderer
@@ -13,10 +14,12 @@ declare class RenderBundle {
      *
      * @param {BundleGroup} bundleGroup - The bundle group.
      * @param {Camera} camera - The camera the bundle group is rendered with.
+     * @param {RenderContext} renderContext - The render context the bundle is rendered with.
      */
-    constructor(bundleGroup: BundleGroup, camera: Camera);
+    constructor(bundleGroup: BundleGroup, camera: Camera, renderContext: RenderContext);
     bundleGroup: BundleGroup;
     camera: Camera;
+    renderContext: RenderContext;
 }
 
 export default RenderBundle;

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

@@ -2,6 +2,7 @@ import { Camera } from "../../cameras/Camera.js";
 import BundleGroup from "./BundleGroup.js";
 import ChainMap from "./ChainMap.js";
 import RenderBundle from "./RenderBundle.js";
+import RenderContext from "./RenderContext.js";
 
 /**
  * This renderer module manages render bundles.
@@ -20,9 +21,10 @@ declare class RenderBundles {
      *
      * @param {BundleGroup} bundleGroup - The bundle group.
      * @param {Camera} camera - The camera the bundle group is rendered with.
+     * @param {RenderContext} renderContext - The render context the bundle is rendered with.
      * @return {RenderBundle} The render bundle.
      */
-    get(bundleGroup: BundleGroup, camera: Camera): RenderBundle;
+    get(bundleGroup: BundleGroup, camera: Camera, renderContext: RenderContext): RenderBundle;
     /**
      * Frees all internal resources.
      */

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

@@ -39,7 +39,7 @@ declare class RenderObject {
     /**
      * Constructs a new render object.
      *
-     * @param {Nodes} nodes - Renderer component for managing nodes related logic.
+     * @param {NodeManager} nodes - Renderer component for managing nodes related logic.
      * @param {Geometries} geometries - Renderer component for managing geometries.
      * @param {Renderer} renderer - The renderer.
      * @param {Object3D} object - The 3D object.
@@ -66,7 +66,7 @@ declare class RenderObject {
     /**
      * Renderer component for managing nodes related logic.
      *
-     * @type {Nodes}
+     * @type {NodeManager}
      * @private
      */
     private _nodes;

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

@@ -24,7 +24,7 @@ declare class RenderObjects {
      * Constructs a new render object management component.
      *
      * @param {Renderer} renderer - The renderer.
-     * @param {Nodes} nodes - Renderer component for managing nodes related logic.
+     * @param {NodeManager} nodes - Renderer component for managing nodes related logic.
      * @param {Geometries} geometries - Renderer component for managing geometries.
      * @param {Pipelines} pipelines - Renderer component for managing pipelines.
      * @param {Bindings} bindings - Renderer component for managing bindings.
@@ -47,7 +47,7 @@ declare class RenderObjects {
     /**
      * Renderer component for managing nodes related logic.
      *
-     * @type {Nodes}
+     * @type {NodeManager}
      */
     nodes: NodeManager;
     /**
@@ -120,7 +120,7 @@ declare class RenderObjects {
     /**
      * Factory method for creating render objects with the given list of parameters.
      *
-     * @param {Nodes} nodes - Renderer component for managing nodes related logic.
+     * @param {NodeManager} nodes - Renderer component for managing nodes related logic.
      * @param {Geometries} geometries - Renderer component for managing geometries.
      * @param {Renderer} renderer - The renderer.
      * @param {Object3D} object - The 3D object.

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

@@ -27,8 +27,8 @@ import Info from "./Info.js";
 import InspectorBase from "./InspectorBase.js";
 import Lighting from "./Lighting.js";
 import NodeLibrary from "./nodes/NodeLibrary.js";
+import ReadbackBuffer from "./ReadbackBuffer.js";
 import { RenderItem } from "./RenderList.js";
-import StorageBufferAttribute from "./StorageBufferAttribute.js";
 import XRManager from "./XRManager.js";
 
 interface DeviceLostInfo {
@@ -359,13 +359,14 @@ declare class Renderer {
      */
     private _background;
     /**
+     * Cache for the fullscreen quad.
      * This fullscreen quad is used for internal render passes
      * like the tone mapping and color space output pass.
      *
      * @private
-     * @type {QuadMesh}
+     * @type {Map<Texture,QuadMesh>}
      */
-    private _quad;
+    private _quadCache;
     /**
      * A reference to the current render context.
      *
@@ -391,13 +392,12 @@ declare class Renderer {
      */
     private _transparentSort;
     /**
-     * The framebuffer target.
+     * Cache of framebuffer targets per canvas target.
      *
      * @private
-     * @type {?RenderTarget}
-     * @default null
+     * @type {Map<CanvasTarget, RenderTarget>}
      */
-    private _frameBufferTarget;
+    private _frameBufferTargets;
     /**
      * The clear color value.
      *
@@ -865,10 +865,24 @@ declare class Renderer {
      * from the GPU to the CPU in context of compute shaders.
      *
      * @async
-     * @param {StorageBufferAttribute} attribute - The storage buffer attribute.
-     * @return {Promise<ArrayBuffer>} A promise that resolves with the buffer data when the data are ready.
-     */
-    getArrayBufferAsync(attribute: BufferAttribute): Promise<ArrayBuffer>;
+     * @param {BufferAttribute} attribute - The storage buffer attribute to read frm.
+     * @param {ReadbackBuffer|ArrayBuffer} target - The storage buffer attribute.
+     * @param {number} offset - The storage buffer attribute.
+     * @param {number} count - The offset from which to start reading the
+     * @return {Promise<ArrayBuffer|ReadbackBuffer>} A promise that resolves with the buffer data when the data are ready.
+     */
+    getArrayBufferAsync(
+        attribute: BufferAttribute,
+        target?: null,
+        offset?: number,
+        count?: number,
+    ): Promise<ArrayBuffer>;
+    getArrayBufferAsync<TTarget extends ReadbackBuffer | ArrayBuffer>(
+        attribute: BufferAttribute,
+        target: TTarget,
+        offset?: number,
+        count?: number,
+    ): Promise<TTarget>;
     /**
      * Returns the rendering context.
      *
@@ -984,7 +998,7 @@ declare class Renderer {
      * Defines the viewport.
      *
      * @param {number} x - The horizontal coordinate for the upper left corner of the viewport origin in logical pixel unit.
-     * @param {number} y - The vertical coordinate for the upper left corner of the viewport origin  in logical pixel unit.
+     * @param {number} y - The vertical coordinate for the upper left corner of the viewport origin in logical pixel unit.
      * @param {number} width - The width of the viewport in logical pixel unit.
      * @param {number} height - The height of the viewport in logical pixel unit.
      * @param {number} minDepth - The minimum depth value of the viewport. WebGPU only.
@@ -1171,9 +1185,9 @@ declare class Renderer {
     /**
      * Sets the output render target for the renderer.
      *
-     * @param {Object} renderTarget - The render target to set as the output target.
+     * @param {?RenderTarget} renderTarget - The render target to set as the output target.
      */
-    setOutputRenderTarget(renderTarget: RenderTarget): void;
+    setOutputRenderTarget(renderTarget: RenderTarget | null): void;
     /**
      * Returns the current output target.
      *
@@ -1461,8 +1475,7 @@ declare class Renderer {
         passId?: string | null,
     ): void;
     /**
-     * Checks if the given compatibility is supported by the selected backend. If the
-     * renderer has not been initialized, this method always returns `false`.
+     * Checks if the given compatibility is supported by the selected backend.
      *
      * @param {string} name - The compatibility's name.
      * @return {boolean} Whether the compatibility is supported or not.

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

@@ -33,7 +33,7 @@ export interface LayerAttributes {
  *
  * @augments EventDispatcher
  */
-declare class XRManager extends EventDispatcher<XRManagerEventMap> {
+declare class XRManager<TEventMap extends XRManagerEventMap = XRManagerEventMap> extends EventDispatcher<TEventMap> {
     /**
      * Constructs a new XR manager.
      *
@@ -162,12 +162,6 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
      * @readonly
      */
     private readonly _supportsGlBinding;
-    _frameBufferTargets:
-        | WeakMap<XRRenderTarget, {
-            frameBufferTarget: RenderTarget | null;
-            quad: QuadMesh;
-        }>
-        | null;
     /**
      * Helper function to create native WebXR Layer.
      *

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

@@ -74,6 +74,20 @@ declare class NodeManager extends DataMap {
      * @type {ChainMap}
      */
     groupsData: ChainMap;
+    /**
+     * Queue for pending async builds to limit concurrent compilation.
+     *
+     * @private
+     * @type {Array<Function>}
+     */
+    private _buildQueue;
+    /**
+     * Whether an async build is currently in progress.
+     *
+     * @private
+     * @type {boolean}
+     */
+    private _buildInProgress;
     /**
      * A cache for managing node objects of
      * scene properties like fog or environments.
@@ -97,13 +111,47 @@ declare class NodeManager extends DataMap {
      * @return {number} The cache key.
      */
     getForRenderCacheKey(renderObject: RenderObject): number;
+    /**
+     * Creates a node builder configured for the given render object and material.
+     *
+     * @private
+     * @param {RenderObject} renderObject - The render object.
+     * @param {Material} material - The material to use.
+     * @return {NodeBuilder} The configured node builder.
+     */
+    private _createNodeBuilder;
     /**
      * Returns a node builder state for the given render object.
      *
      * @param {RenderObject} renderObject - The render object.
-     * @return {NodeBuilderState} The node builder state.
+     * @param {boolean} [useAsync=false] - Whether to use async build with yielding.
+     * @return {NodeBuilderState|Promise<NodeBuilderState>} The node builder state (or Promise if async).
      */
-    getForRender(renderObject: RenderObject): NodeBuilderState;
+    getForRender(renderObject: RenderObject, useAsync?: boolean): NodeBuilderState | Promise<NodeBuilderState>;
+    /**
+     * Async version of getForRender() that yields to main thread during build.
+     * Use this in compileAsync() to prevent blocking the main thread.
+     *
+     * @param {RenderObject} renderObject - The render object.
+     * @return {Promise<NodeBuilderState>} A promise that resolves to the node builder state.
+     */
+    getForRenderAsync(renderObject: RenderObject): Promise<NodeBuilderState>;
+    /**
+     * Returns nodeBuilderState if ready, null if pending async build.
+     * Queues async build on first call for cache miss.
+     * Use this in render() path to enable non-blocking compilation.
+     *
+     * @param {RenderObject} renderObject - The render object.
+     * @return {?NodeBuilderState} The node builder state, or null if still building.
+     */
+    getForRenderDeferred(renderObject: RenderObject): NodeBuilderState | null;
+    /**
+     * Processes the build queue one item at a time.
+     * This ensures builds don't all run simultaneously and freeze the main thread.
+     *
+     * @private
+     */
+    private _processBuildQueue;
     /**
      * Deletes the given object from the internal data map
      *
@@ -213,14 +261,6 @@ declare class NodeManager extends DataMap {
      * @return {string} The output cache key.
      */
     getOutputCacheKey(): string;
-    /**
-     * Checks if the output configuration (tone mapping and color space) for
-     * the given target has changed.
-     *
-     * @param {Texture} outputTarget - The output target.
-     * @return {boolean} Whether the output configuration has changed or not.
-     */
-    hasOutputChange(outputTarget: Texture): boolean;
     /**
      * Returns a node that represents the output configuration (tone mapping and
      * color space) for the current target.
@@ -252,7 +292,7 @@ declare class NodeManager extends DataMap {
     updateForCompute(computeNode: ComputeNode): void;
     /**
      * Triggers the call of `update()` methods
-     * for all nodes of the given compute node.
+     * for all nodes of the given render object.
      *
      * @param {RenderObject} renderObject - The render object.
      */

three/src/renderers/shaders/ShaderChunk.d.ts

@@ -55,6 +55,7 @@ export const ShaderChunk: {
     lights_fragment_begin: string;
     lights_fragment_maps: string;
     lights_fragment_end: string;
+    lightprobes_pars_fragment: string;
     logdepthbuf_fragment: string;
     logdepthbuf_pars_fragment: string;
     logdepthbuf_pars_vertex: string;

three/src/renderers/shaders/UniformsLib.d.ts

@@ -1,6 +1,7 @@
 import { Color } from "../../math/Color.js";
 import { Matrix3 } from "../../math/Matrix3.js";
 import { Vector2 } from "../../math/Vector2.js";
+import { Vector3 } from "../../math/Vector3.js";
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
 export interface IUniform<TValue = any> {
@@ -24,7 +25,6 @@ export const UniformsLib: {
     envmap: {
         envMap: IUniform<unknown>;
         envMapRotation: IUniform<Matrix3>;
-        flipEnvMap: IUniform<number>;
         reflectivity: IUniform<number>;
         ior: IUniform<number>;
         refractRatio: IUniform<number>;
@@ -162,6 +162,10 @@ export const UniformsLib: {
         };
         ltc_1: IUniform<unknown>;
         ltc_2: IUniform<unknown>;
+        probesSH: IUniform<unknown>;
+        probesMin: IUniform<Vector3>;
+        probesMax: IUniform<Vector3>;
+        probesResolution: IUniform<Vector3>;
     };
     points: {
         diffuse: IUniform<Color>;

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

@@ -12,10 +12,4 @@ export class WebGLBufferRenderer {
     render: (start: any, count: number) => void;
     renderInstances: (start: any, count: number, primcount: number) => void;
     renderMultiDraw: (starts: Int32Array, counts: Int32Array, drawCount: number) => void;
-    renderMultiDrawInstances: (
-        starts: Int32Array,
-        counts: Int32Array,
-        drawCount: number,
-        primcount: Int32Array,
-    ) => void;
 }

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

@@ -10,10 +10,4 @@ export class WebGLIndexedBufferRenderer {
     render: (start: number, count: number) => void;
     renderInstances: (start: number, count: number, primcount: number) => void;
     renderMultiDraw: (starts: Int32Array, counts: Int32Array, drawCount: number) => void;
-    renderMultiDrawInstances: (
-        starts: Int32Array,
-        counts: Int32Array,
-        drawCount: number,
-        primcount: Int32Array,
-    ) => void;
 }

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

@@ -53,6 +53,7 @@ export interface WebGLProgramParameters {
 
     normalMapObjectSpace: boolean;
     normalMapTangentSpace: boolean;
+    packedNormalMap: boolean;
 
     metalnessMap: boolean;
     roughnessMap: boolean;
@@ -130,6 +131,7 @@ export interface WebGLProgramParameters {
     //
 
     vertexTangents: boolean;
+    vertexNormals: boolean;
     vertexColors: boolean;
     vertexAlphas: boolean;
     vertexUv1s: boolean;
@@ -170,6 +172,8 @@ export interface WebGLProgramParameters {
 
     numLightProbes: number;
 
+    numLightProbeGrids: number;
+
     numClippingPlanes: number;
     numClipIntersection: number;
 
@@ -223,6 +227,7 @@ export class WebGLPrograms {
         shadows: Light[],
         scene: Scene,
         object: Object3D,
+        lightProbeGrids: unknown[],
     ): WebGLProgramParameters;
 
     getProgramCacheKey(parameters: WebGLProgramParameters): string;

three/src/renderers/webgl-fallback/WebGLBackend.d.ts

@@ -6,6 +6,8 @@ export interface WebGLBackendParameters extends BackendParameters {
 }
 
 export default class WebGLBackend extends Backend {
+    readonly isWebGLBackend: boolean;
+
     constructor(parameters?: BackendParameters);
 
     get coordinateSystem(): CoordinateSystem;

three/src/renderers/webgl-fallback/nodes/GLSLNodeBuilder.d.ts

@@ -0,0 +1,19 @@
+import { Object3D } from "../../../core/Object3D.js";
+import { NodeShaderStage } from "../../../nodes/core/constants.js";
+import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
+import Renderer from "../../common/Renderer.js";
+
+declare class GLSLNodeBuilder extends NodeBuilder {
+    constructor(object: Object3D, renderer: Renderer);
+
+    getUniforms(shaderStage: NodeShaderStage): string;
+    getAttributes(shaderStage: NodeShaderStage): string;
+    getVaryings(shaderStage: NodeShaderStage): string;
+    getInstanceIndex(): string;
+    getDrawIndex(): string | null;
+    getFrontFacing(): string;
+    getFragCoord(): string;
+    buildCode(): void;
+}
+
+export default GLSLNodeBuilder;

three/src/renderers/webgl-fallback/utils/WebGLCapabilities.d.ts

@@ -0,0 +1,51 @@
+import WebGLBackend from "../WebGLBackend.js";
+
+/**
+ * A WebGL 2 backend utility module for managing the device's capabilities.
+ *
+ * @private
+ */
+declare class WebGLCapabilities {
+    /**
+     * Constructs a new utility object.
+     *
+     * @param {WebGLBackend} backend - The WebGL 2 backend.
+     */
+    constructor(backend: WebGLBackend);
+    /**
+     * A reference to the WebGL 2 backend.
+     *
+     * @type {WebGLBackend}
+     */
+    backend: WebGLBackend;
+    /**
+     * This value holds the cached max anisotropy value.
+     *
+     * @type {?number}
+     * @default null
+     */
+    maxAnisotropy: number | null;
+    /**
+     * This value holds the cached max uniform block size value.
+     *
+     * @type {?number}
+     * @default null
+     */
+    maxUniformBlockSize: number | null;
+    /**
+     * Returns the maximum anisotropy texture filtering value. This value
+     * depends on the device and is reported by the `EXT_texture_filter_anisotropic`
+     * WebGL extension.
+     *
+     * @return {number} The maximum anisotropy texture filtering value.
+     */
+    getMaxAnisotropy(): number;
+    /**
+     * Returns the maximum number of bytes available for uniform buffers.
+     *
+     * @return {number} The maximum number of bytes available for uniform buffers.
+     */
+    getUniformBufferLimit(): number;
+}
+
+export default WebGLCapabilities;

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

@@ -1,14 +1,19 @@
-/// <reference types="@webgpu/types" />
-
 import { CoordinateSystem, HalfFloatType, UnsignedByteType } from "../../constants.js";
 import Backend, { BackendParameters } from "../common/Backend.js";
 
+interface GPUDevice {}
+
+interface GPUCanvasContext {}
+
 export interface WebGPUBackendParameters extends BackendParameters {
     alpha?: boolean | undefined;
-    requiredLimits?: Record<string, GPUSize64> | undefined;
+    requiredLimits?: Record<string, number> | undefined;
     trackTimestamp?: boolean | undefined;
     device?: GPUDevice | undefined;
-    powerPreference?: GPUPowerPreference | undefined;
+    powerPreference?:
+        | "low-power"
+        | "high-performance"
+        | undefined;
     context?: GPUCanvasContext | undefined;
     outputType?: typeof UnsignedByteType | typeof HalfFloatType | undefined;
 }

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

@@ -93,6 +93,8 @@ export enum GPUTextureFormat {
     RG8Snorm = "rg8snorm",
     RG8Uint = "rg8uint",
     RG8Sint = "rg8sint",
+    R16Unorm = "r16unorm",
+    R16Snorm = "r16snorm",
 
     // 32-bit formats
 
@@ -109,6 +111,8 @@ export enum GPUTextureFormat {
     RGBA8Sint = "rgba8sint",
     BGRA8Unorm = "bgra8unorm",
     BGRA8UnormSRGB = "bgra8unorm-srgb",
+    RG16Unorm = "rg16unorm",
+    RG16Snorm = "rg16snorm",
     // Packed 32-bit formats
     RGB9E5UFloat = "rgb9e5ufloat",
     RGB10A2Unorm = "rgb10a2unorm",
@@ -122,6 +126,8 @@ export enum GPUTextureFormat {
     RGBA16Uint = "rgba16uint",
     RGBA16Sint = "rgba16sint",
     RGBA16Float = "rgba16float",
+    RGBA16Unorm = "rgba16unorm",
+    RGBA16Snorm = "rgba16snorm",
 
     // 128-bit formats
 

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

@@ -43,7 +43,11 @@ export class XRTargetRaySpace extends Group<WebXRSpaceEventMap> {
     readonly angularVelocity: Vector3;
 }
 
-export class XRGripSpace extends Group<WebXRSpaceEventMap> {
+export interface WebXRGripSpaceEventMap extends WebXRSpaceEventMap {
+    gripUpdated: { data: XRInputSource; target: WebXRController }; // This Event break the THREE.EventDispatcher contract, replacing the target to the wrong instance.
+}
+
+export class XRGripSpace extends Group<WebXRGripSpaceEventMap> {
     hasLinearVelocity: boolean;
     readonly linearVelocity: Vector3;
     hasAngularVelocity: boolean;

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

@@ -21,7 +21,9 @@ export interface WebXRManagerEventMap {
     planesdetected: { data: XRPlaneSet };
 }
 
-export class WebXRManager extends EventDispatcher<WebXRManagerEventMap> {
+export class WebXRManager<TEventMap extends WebXRManagerEventMap = WebXRManagerEventMap>
+    extends EventDispatcher<TEventMap>
+{
     /**
      * @default true
      */

three/src/scenes/Scene.d.ts

@@ -1,4 +1,4 @@
-import { JSONMeta, Object3D, Object3DJSON, Object3DJSONObject } from "../core/Object3D.js";
+import { JSONMeta, Object3D, Object3DEventMap, Object3DJSON, Object3DJSONObject } from "../core/Object3D.js";
 import { Material } from "../materials/Material.js";
 import { Color } from "../math/Color.js";
 import { Euler, EulerTuple } from "../math/Euler.js";
@@ -25,7 +25,7 @@ export interface SceneJSON extends Object3DJSON {
  * Scenes allow you to set up what is to be rendered and where by three.js.
  * This is where you place 3D objects like meshes, lines or lights.
  */
-export class Scene extends Object3D {
+export class Scene<TEventMap extends Object3DEventMap = Object3DEventMap> extends Object3D<TEventMap> {
     /**
      * This flag can be used for type testing.
      *

three/src/textures/ExternalTexture.d.ts

@@ -1,7 +1,8 @@
-/// <reference types="@webgpu/types" />
-
 import { Texture } from "./Texture.js";
 
+interface GPUTexture {
+}
+
 declare class ExternalTexture extends Texture<null> {
     sourceTexture: WebGLTexture | GPUTexture | null;