@types/three 0.172.0 → 0.173.0

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

@@ -1,5 +1,5 @@
 import { Camera } from "../../cameras/Camera.js";
-import { ShadowMapType, ToneMapping } from "../../constants.js";
+import { ShadowMapType, TextureDataType, TimestampQuery, ToneMapping } from "../../constants.js";
 import { BufferAttribute } from "../../core/BufferAttribute.js";
 import { BufferGeometry, GeometryGroup } from "../../core/BufferGeometry.js";
 import { Object3D } from "../../core/Object3D.js";
@@ -38,6 +38,7 @@ import RenderList, { Bundle, RenderItem } from "./RenderList.js";
 import RenderLists from "./RenderLists.js";
 import RenderObjects from "./RenderObjects.js";
 import Textures from "./Textures.js";
+import XRManager from "./XRManager.js";
 interface Rectangle {
     x: number;
     y: number;
@@ -58,6 +59,7 @@ export interface RendererParameters {
     antialias?: boolean | undefined;
     samples?: number | undefined;
     getFallback?: ((error: unknown) => Backend) | null | undefined;
+    colorBufferType?: TextureDataType | undefined;
 }
 /**
  * Base class for renderers.
@@ -122,6 +124,8 @@ declare class Renderer {
             material: Material,
             group: GeometryGroup,
             lightsNode: LightsNode,
+            clippingContext: ClippingContext | null,
+            passId: string | null,
         ) => void)
         | null;
     _currentRenderObjectFunction:
@@ -133,6 +137,8 @@ declare class Renderer {
             material: Material,
             group: GeometryGroup,
             lightsNode: LightsNode,
+            clippingContext: ClippingContext | null,
+            passId: string | null,
         ) => void)
         | null;
     _currentRenderBundle: RenderBundle | null;
@@ -143,10 +149,12 @@ declare class Renderer {
         camera: Camera,
         lightsNode: LightsNode,
         group: GeometryGroup,
+        clippingContext: ClippingContext | null,
         passId?: string,
     ) => void;
     _isDeviceLost: boolean;
     onDeviceLost: (info: DeviceLostInfo) => void;
+    _colorBufferType: TextureDataType;
     _initialized: boolean;
     _initPromise: Promise<void> | null;
     _compilationPromises: Promise<void>[] | null;
@@ -156,9 +164,7 @@ declare class Renderer {
         enabled: boolean;
         type: ShadowMapType | null;
     };
-    xr: {
-        enabled: boolean;
-    };
+    xr: XRManager;
     debug: {
         checkShaderErrors: boolean;
         onShaderError:
@@ -188,6 +194,8 @@ declare class Renderer {
      * @param {Number} [parameters.samples=0] - When `antialias` is `true`, `4` samples are used by default. This parameter can set to any other integer value than 0
      * to overwrite the default.
      * @param {Function?} [parameters.getFallback=null] - This callback function can be used to provide a fallback backend, if the primary backend can't be targeted.
+     * @param {Number} [parameters.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.
      */
     constructor(backend: Backend, parameters?: RendererParameters);
     /**
@@ -219,7 +227,7 @@ declare class Renderer {
      * @param {Object3D} scene - The scene or 3D object to precompile.
      * @param {Camera} camera - The camera that is used to render the scene.
      * @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} A Promise that resolves when the compile has been finished.
+     * @return {Promise<Array>} A Promise that resolves when the compile has been finished.
      */
     compileAsync(scene: Object3D, camera: Camera, targetScene?: Object3D | null): Promise<void>;
     /**
@@ -252,6 +260,12 @@ declare class Renderer {
      * @return {MRTNode} The MRT configuration.
      */
     getMRT(): MRTNode | null;
+    /**
+     * Returns the color buffer type.
+     *
+     * @return {Number} The color buffer type.
+     */
+    getColorBufferType(): TextureDataType;
     /**
      * Default implementation of the device lost callback.
      *
@@ -325,7 +339,7 @@ declare class Renderer {
      *
      * @async
      * @param {Function} callback - The application's animation loop.
-     * @return {Promise} A Promise that resolves when the set has been exeucted.
+     * @return {Promise} A Promise that resolves when the set has been executed.
      */
     setAnimationLoop(callback: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null): Promise<void>;
     /**
@@ -662,6 +676,8 @@ declare class Renderer {
             material: Material,
             group: GeometryGroup,
             lightsNode: LightsNode,
+            clippingContext: ClippingContext | null,
+            passId: string | null,
         ) => void)
         | null;
     /**
@@ -677,7 +693,7 @@ declare class Renderer {
      *
      * @async
      * @param {Node|Array<Node>} computeNodes - The compute node(s).
-     * @return {Promise?} A Promise that resolve when the compute has finished.
+     * @return {Promise} A Promise that resolve when the compute has finished.
      */
     computeAsync(computeNodes: ComputeNode | ComputeNode[]): Promise<void>;
     /**
@@ -688,6 +704,7 @@ declare class Renderer {
      * @return {Promise<Boolean>} A Promise that resolves with a bool that indicates whether the feature is supported or not.
      */
     hasFeatureAsync(name: string): Promise<void>;
+    resolveTimestampsAsync(type?: TimestampQuery): Promise<number | undefined>;
     /**
      * Checks if the given feature is supported by the selected backend. If the
      * renderer has not been initialized, this method always returns `false`.
@@ -860,7 +877,7 @@ declare class Renderer {
      * @param {Scene} scene - The scene the 3D object belongs to.
      * @param {Camera} camera - The camera the object should be rendered with.
      * @param {LightsNode} lightsNode - The current lights node.
-     * @param {Object?} group - Only relevant for objects using multiple materials. This represents a group entry from the respective `BufferGeometry`.
+     * @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.
      */
@@ -884,7 +901,7 @@ declare class Renderer {
      * @param {Scene} scene - The scene the 3D object belongs to.
      * @param {Camera} camera - The camera the object should be rendered with.
      * @param {LightsNode} lightsNode - The current lights node.
-     * @param {Object?} group - Only relevant for objects using multiple materials. This represents a group entry from the respective `BufferGeometry`.
+     * @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.
      */

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

@@ -0,0 +1,31 @@
+import RenderContext from "./RenderContext.js";
+declare abstract class TimestampQueryPool {
+    trackTimestamp: boolean;
+    maxQueries: number;
+    currentQueryIndex: number;
+    queryOffsets: Map<number, number>;
+    isDisposed: boolean;
+    lastValue: number;
+    pendingResolve: boolean;
+    constructor(maxQueries?: number);
+    /**
+     * Allocate queries for a specific renderContext.
+     *
+     * @abstract
+     */
+    abstract allocateQueriesForContext(renderContext: RenderContext): number | null;
+    /**
+     * Resolve all timestamps and return data (or process them).
+     *
+     * @abstract
+     * @returns {Promise<Number>|Number} The resolved timestamp value.
+     */
+    abstract resolveQueriesAsync(): Promise<number>;
+    /**
+     * Dispose of the query pool.
+     *
+     * @abstract
+     */
+    abstract dispose(): void;
+}
+export default TimestampQueryPool;

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

@@ -1,4 +1,5 @@
 import { Color } from "../../math/Color.js";
+import { Matrix2 } from "../../math/Matrix2.js";
 import { Matrix3 } from "../../math/Matrix3.js";
 import { Matrix4 } from "../../math/Matrix4.js";
 import { Vector2 } from "../../math/Vector2.js";
@@ -116,6 +117,22 @@ declare class ColorUniform extends Uniform<Color> {
      */
     constructor(name: string, value?: Color);
 }
+/**
+ * Represents a Matrix2 uniform.
+ *
+ * @private
+ * @augments Uniform
+ */
+declare class Matrix2Uniform extends Uniform<Matrix2> {
+    readonly isMatrix2Uniform: true;
+    /**
+     * Constructs a new Number uniform.
+     *
+     * @param {String} name - The uniform's name.
+     * @param {Matrix2} value - The uniform's value.
+     */
+    constructor(name: string, value?: Matrix2);
+}
 /**
  * Represents a Matrix3 uniform.
  *
@@ -148,4 +165,13 @@ declare class Matrix4Uniform extends Uniform<Matrix4> {
      */
     constructor(name: string, value?: Matrix4);
 }
-export { ColorUniform, Matrix3Uniform, Matrix4Uniform, NumberUniform, Vector2Uniform, Vector3Uniform, Vector4Uniform };
+export {
+    ColorUniform,
+    Matrix2Uniform,
+    Matrix3Uniform,
+    Matrix4Uniform,
+    NumberUniform,
+    Vector2Uniform,
+    Vector3Uniform,
+    Vector4Uniform,
+};

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

@@ -0,0 +1,196 @@
+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 { Vector2 } from "../../math/Vector2.js";
+import { WebXRController } from "../webxr/WebXRController.js";
+import { AnimationContext } from "./Animation.js";
+import Renderer from "./Renderer.js";
+import { XRRenderTarget } from "./XRRenderTarget.js";
+export interface XRManagerEventMap {
+    sessionstart: {};
+    sessionend: {};
+    planesdetected: {
+        data: XRFrame;
+    };
+}
+/**
+ * The XR manager is built on top of the WebXR Device API to
+ * manage XR sessions with `WebGPURenderer`.
+ *
+ * XR is currently only supported with a WebGL 2 backend.
+ *
+ * @augments EventDispatcher
+ */
+declare class XRManager extends EventDispatcher<XRManagerEventMap> {
+    enabled: boolean;
+    isPresenting: boolean;
+    cameraAutoUpdate: boolean;
+    _renderer: Renderer;
+    _cameraL: PerspectiveCamera;
+    _cameraR: PerspectiveCamera;
+    _cameras: PerspectiveCamera[];
+    _cameraXR: ArrayCamera;
+    _currentDepthNear: number | null;
+    _currentDepthFar: number | null;
+    _controllers: WebXRController[];
+    _controllerInputSources: (XRInputSource | null)[];
+    _currentRenderTarget: RenderTarget | null;
+    _xrRenderTarget: XRRenderTarget | null;
+    _currentAnimationContext: AnimationContext | null;
+    _currentAnimationLoop: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null;
+    _currentPixelRatio: number | null;
+    _currentSize: Vector2;
+    _onSessionEvent: (event: XRInputSourceEvent) => void;
+    _onSessionEnd: () => void;
+    _onInputSourcesChange: (event: XRInputSourcesChangeEvent) => void;
+    _onAnimationFrame: (time: DOMHighResTimeStamp, frame?: XRFrame) => void;
+    _referenceSpace: XRReferenceSpace | null;
+    _referenceSpaceType: XRReferenceSpaceType;
+    _customReferenceSpace: XRReferenceSpace | null;
+    _framebufferScaleFactor: number;
+    _foveation: number;
+    _session: XRSession | null;
+    _glBaseLayer: XRWebGLLayer | null;
+    _glBinding: XRWebGLBinding | null;
+    _glProjLayer: XRProjectionLayer | null;
+    _xrFrame: XRFrame | null;
+    _useLayers: boolean;
+    /**
+     * Constructs a new XR manager.
+     *
+     * @param {Renderer} renderer - The renderer.
+     */
+    constructor(renderer: Renderer);
+    /**
+     * Returns an instance of `THREE.Group` that represents the transformation
+     * of a XR controller in target ray space. The requested controller is defined
+     * by the given index.
+     *
+     * @param {Number} index - The index of the XR controller.
+     * @return {Group} A group that represents the controller's transformation.
+     */
+    getController(index: number): import("../webxr/WebXRController.js").XRTargetRaySpace;
+    /**
+     * Returns an instance of `THREE.Group` that represents the transformation
+     * of a XR controller in grip space. The requested controller is defined
+     * by the given index.
+     *
+     * @param {Number} index - The index of the XR controller.
+     * @return {Group} A group that represents the controller's transformation.
+     */
+    getControllerGrip(index: number): import("../webxr/WebXRController.js").XRGripSpace;
+    /**
+     * Returns an instance of `THREE.Group` that represents the transformation
+     * of a XR controller in hand space. The requested controller is defined
+     * by the given index.
+     *
+     * @param {Number} index - The index of the XR controller.
+     * @return {Group} A group that represents the controller's transformation.
+     */
+    getHand(index: number): import("../webxr/WebXRController.js").XRHandSpace;
+    /**
+     * Returns the foveation value.
+     *
+     * @return {Number|undefined} The foveation value. Returns `undefined` if no base or projection layer is defined.
+     */
+    getFoveation(): number | undefined;
+    /**
+     * Sets the foveation value.
+     *
+     * @param {Number} foveation - A number in the range `[0,1]` where `0` means no foveation (full resolution)
+     * and `1` means maximum foveation (the edges render at lower resolution).
+     */
+    setFoveation(foveation: number): void;
+    /**
+     * Returns the framebuffer scale factor.
+     *
+     * @return {Number} The framebuffer scale factor.
+     */
+    getFramebufferScaleFactor(): number;
+    /**
+     * Sets the framebuffer scale factor.
+     *
+     * This method can not be used during a XR session.
+     *
+     * @param {Number} factor - The framebuffer scale factor.
+     */
+    setFramebufferScaleFactor(factor: number): void;
+    /**
+     * Returns the reference space type.
+     *
+     * @return {String} The reference space type.
+     */
+    getReferenceSpaceType(): XRReferenceSpaceType;
+    /**
+     * Sets the reference space type.
+     *
+     * This method can not be used during a XR session.
+     *
+     * @param {String} type - The reference space type.
+     */
+    setReferenceSpaceType(type: XRReferenceSpaceType): void;
+    /**
+     * Returns the XR reference space.
+     *
+     * @return {XRReferenceSpace} The XR reference space.
+     */
+    getReferenceSpace(): XRReferenceSpace | null;
+    /**
+     * Sets a custom XR reference space.
+     *
+     * @param {XRReferenceSpace} space - The XR reference space.
+     */
+    setReferenceSpace(space: XRReferenceSpace): void;
+    /**
+     * Returns the XR camera.
+     *
+     * @return {ArrayCamera} The XR camera.
+     */
+    getCamera(): ArrayCamera;
+    /**
+     * Returns the environment blend mode from the current XR session.
+     *
+     * @return {('opaque'|'additive'|'alpha-blend')?} The environment blend mode. Returns `null` when used outside of a XR session.
+     */
+    getEnvironmentBlendMode(): XREnvironmentBlendMode | undefined;
+    /**
+     * Returns the current XR frame.
+     *
+     * @return {XRFrame?} The XR frame. Returns `null` when used outside a XR session.
+     */
+    getFrame(): XRFrame | null;
+    /**
+     * Returns the current XR session.
+     *
+     * @return {XRSession?} The XR session. Returns `null` when used outside a XR session.
+     */
+    getSession(): XRSession | null;
+    /**
+     * After a XR session has been requested usually with one of the `*Button` modules, it
+     * is injected into the renderer with this method. This method triggers the start of
+     * the actual XR rendering.
+     *
+     * @async
+     * @param {XRSession} session - The XR session to set.
+     * @return {Promise} A Promise that resolves when the session has been set.
+     */
+    setSession(session: XRSession): Promise<void>;
+    /**
+     * This method is called by the renderer per frame and updates the XR camera
+     * and it sub cameras based on the given camera. The given camera is the "user"
+     * camera created on application level and used for non-XR rendering.
+     *
+     * @param {PerspectiveCamera} camera - The camera.
+     */
+    updateCamera(camera: PerspectiveCamera): void;
+    /**
+     * Returns a WebXR controller for the given controller index.
+     *
+     * @private
+     * @param {Number} index - The controller index.
+     * @return {WebXRController} The XR controller.
+     */
+    _getController(index: number): WebXRController;
+}
+export default XRManager;

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

@@ -0,0 +1,23 @@
+import { RenderTarget } from "../../core/RenderTarget.js";
+/**
+ * A special type of render target that is used when rendering
+ * with the WebXR Device API.
+ *
+ * @private
+ * @augments RenderTarget
+ */
+declare class XRRenderTarget extends RenderTarget {
+    readonly isXRRenderTarget: true;
+    hasExternalTextures: boolean;
+    autoAllocateDepthBuffer: boolean;
+    /**
+     * Constructs a new XR render target.
+     *
+     * @param {Number} [width=1] - The width of the render target.
+     * @param {Number} [height=1] - The height of the render target.
+     * @param {Object} [options={}] - The configuration options.
+     */
+    constructor(width?: number, height?: number, options?: {});
+    copy(source: XRRenderTarget): this;
+}
+export { XRRenderTarget };

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

@@ -21,7 +21,7 @@ declare class NodeBuilderState {
     updateNodes: Node[];
     updateBeforeNodes: Node[];
     updateAfterNodes: Node[];
-    monitor: NodeMaterialObserver;
+    observer: NodeMaterialObserver;
     usedTimes: number;
     /**
      * Constructs a new node builder state.
@@ -34,7 +34,7 @@ declare class NodeBuilderState {
      * @param {Array<Node>} updateNodes - An array of nodes that implement their `update()` method.
      * @param {Array<Node>} updateBeforeNodes - An array of nodes that implement their `updateBefore()` method.
      * @param {Array<Node>} updateAfterNodes - An array of nodes that implement their `updateAfter()` method.
-     * @param {NodeMaterialObserver} monitor - A node material observer.
+     * @param {NodeMaterialObserver} observer - A node material observer.
      * @param {Array<Object>} transforms - An array with transform attribute objects. Only relevant when using compute shaders with WebGL 2.
      */
     constructor(
@@ -46,7 +46,7 @@ declare class NodeBuilderState {
         updateNodes: Node[],
         updateBeforeNodes: Node[],
         updateAfterNodes: Node[],
-        monitor: NodeMaterialObserver,
+        observer: NodeMaterialObserver,
         transforms?: never[],
     );
     /**

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

@@ -63,7 +63,7 @@ declare class NodeLibrary {
     /**
      * Returns a node material class definition for a material type.
      *
-     * @param {Sring} materialType - The material type.
+     * @param {String} materialType - The material type.
      * @return {NodeMaterial.constructor?} The node material class definition. Returns `null` if no node material is found.
      */
     getMaterialNodeClass(materialType: string): (new() => NodeMaterial) | null;
@@ -71,7 +71,7 @@ declare class NodeLibrary {
      * Adds a node material class definition for a given material type.
      *
      * @param {NodeMaterial.constructor} materialNodeClass - The node material class definition.
-     * @param {Sring} materialClassType - The material type.
+     * @param {String} materialClassType - The material type.
      */
     addMaterial(materialNodeClass: {
         new(): NodeMaterial;
@@ -98,7 +98,7 @@ 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 {String} type - The object type.
+     * @param {Number|String} type - The object type.
      * @param {Map} library - The type library.
      */
     addType<TNodeClass, TType>(nodeClass: TNodeClass, type: TType, library: Map<TType, TNodeClass>): void;

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

@@ -1,4 +1,5 @@
 import { Color } from "../../../math/Color.js";
+import { Matrix2 } from "../../../math/Matrix2.js";
 import { Matrix3 } from "../../../math/Matrix3.js";
 import { Matrix4 } from "../../../math/Matrix4.js";
 import { Vector2 } from "../../../math/Vector2.js";
@@ -7,6 +8,7 @@ import { Vector4 } from "../../../math/Vector4.js";
 import NodeUniform from "../../../nodes/core/NodeUniform.js";
 import {
     ColorUniform,
+    Matrix2Uniform,
     Matrix3Uniform,
     Matrix4Uniform,
     NumberUniform,
@@ -154,6 +156,34 @@ declare class ColorNodeUniform extends ColorUniform {
      */
     getType(): string | null;
 }
+/**
+ * A special form of Matrix2 uniform binding type.
+ * It's value is managed by a node object.
+ *
+ * @private
+ * @augments Matrix2Uniform
+ */
+declare class Matrix2NodeUniform extends Matrix2Uniform {
+    nodeUniform: NodeUniform<Matrix2>;
+    /**
+     * Constructs a new node-based Matrix2 uniform.
+     *
+     * @param {NodeUniform} nodeUniform - The node uniform.
+     */
+    constructor(nodeUniform: NodeUniform<Matrix2>);
+    /**
+     * Overwritten to return the value of the node uniform.
+     *
+     * @return {Matrix2} The value.
+     */
+    getValue(): Matrix2;
+    /**
+     * Returns the node uniform data type.
+     *
+     * @return {String} The data type.
+     */
+    getType(): string | null;
+}
 /**
  * A special form of Matrix3 uniform binding type.
  * It's value is managed by a node object.
@@ -212,6 +242,7 @@ declare class Matrix4NodeUniform extends Matrix4Uniform {
 }
 export {
     ColorNodeUniform,
+    Matrix2NodeUniform,
     Matrix3NodeUniform,
     Matrix4NodeUniform,
     NumberNodeUniform,

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

@@ -39,6 +39,10 @@ interface SceneData {
     environment?: Texture | undefined;
     environmentNode?: ShaderNodeObject<Node> | undefined;
 }
+interface CacheKeyData {
+    callId: number;
+    cacheKey: number;
+}
 declare module "../../../scenes/Scene.js" {
     interface Scene {
         environmentNode?: ShaderNodeObject<Node> | null | undefined;
@@ -81,10 +85,7 @@ declare class Nodes extends DataMap<{
     backend: Backend;
     nodeFrame: NodeFrame;
     nodeBuilderCache: Map<string, NodeBuilderState>;
-    callHashCache: ChainMap<readonly [Scene, LightsNode], {
-        callId: number;
-        cacheKey: string;
-    }>;
+    callHashCache: ChainMap<readonly [Scene, LightsNode], CacheKeyData>;
     groupsData: ChainMap<readonly [UniformGroupNode, NodeUniformsGroup], {
         version?: number;
     }>;
@@ -121,7 +122,7 @@ declare class Nodes extends DataMap<{
      */
     delete(
         object: NodeUniformsGroup | RenderObject | ComputeNode | Scene,
-    ): SceneData | RenderObjectData | NodeUniformsGroupData | ComputeNodeData;
+    ): RenderObjectData | NodeUniformsGroupData | ComputeNodeData | SceneData;
     /**
      * Returns a node builder state for the given compute node.
      *
@@ -170,7 +171,7 @@ declare class Nodes extends DataMap<{
      * @param {LightsNode} lightsNode - The lights node.
      * @return {Number} The cache key.
      */
-    getCacheKey(scene: Scene, lightsNode: LightsNode): string;
+    getCacheKey(scene: Scene, lightsNode: LightsNode): number;
     /**
      * A boolean that indicates whether tone mapping should be enabled
      * or not.
@@ -281,7 +282,7 @@ declare class Nodes extends DataMap<{
      */
     needsRefresh(renderObject: RenderObject): boolean;
     /**
-     * Frees the intenral resources.
+     * Frees the internal resources.
      */
     dispose(): void;
 }

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

@@ -1,6 +1,6 @@
 /// <reference types="@webgpu/types" />
 
-import { CoordinateSystem } from "../../constants.js";
+import { CoordinateSystem, HalfFloatType, UnsignedByteType } from "../../constants.js";
 import Backend, { BackendParameters } from "../common/Backend.js";
 
 export interface WebGPUBackendParameters extends BackendParameters {
@@ -10,6 +10,7 @@ export interface WebGPUBackendParameters extends BackendParameters {
     device?: GPUDevice | undefined;
     powerPreference?: GPUPowerPreference | undefined;
     context?: GPUCanvasContext | undefined;
+    outputType?: typeof UnsignedByteType | typeof HalfFloatType | undefined;
 }
 
 export default class WebGPUBackend extends Backend {

three/src/textures/Texture.d.ts

@@ -455,11 +455,8 @@ export class Texture extends EventDispatcher<{ dispose: {} }> {
     updateMatrix(): void;
 
     /**
-     * Make copy of the texture
-     * @remarks Note this is not a **"deep copy"**, the image is shared
-     * @remarks
-     * Besides, cloning a texture does not automatically mark it for a texture upload
-     * You have to set {@link needsUpdate | .needsUpdate} to `true` as soon as it's image property (the data source) is fully loaded or ready.
+     * Make copy of the texture. Note this is not a "deep copy", the image is shared. Cloning the texture automatically
+     * marks it for texture upload.
      */
     clone(): this;
 

three/src/textures/VideoFrameTexture.d.ts

@@ -0,0 +1,27 @@
+import {
+    MagnificationTextureFilter,
+    Mapping,
+    MinificationTextureFilter,
+    PixelFormat,
+    TextureDataType,
+    Wrapping,
+} from "../constants.js";
+import { VideoTexture } from "./VideoTexture.js";
+
+declare class VideoFrameTexture extends VideoTexture {
+    constructor(
+        mapping?: Mapping,
+        wrapS?: Wrapping,
+        wrapT?: Wrapping,
+        magFilter?: MagnificationTextureFilter,
+        minFilter?: MinificationTextureFilter,
+        format?: PixelFormat,
+        type?: TextureDataType,
+        anisotropy?: number,
+    );
+
+    // FIXME Replace with VideoFrame when we no longer need to support TypeScript 5.0
+    setFrame(frane: unknown): void;
+}
+
+export { VideoFrameTexture };

three/examples/jsm/geometries/InstancedPointsGeometry.d.ts

@@ -1,13 +0,0 @@
-import { InstancedBufferGeometry } from "three";
-
-declare class InstancedPointsGeometry extends InstancedBufferGeometry {
-    readonly isInstancedPointsGeometry: true;
-
-    constructor();
-
-    setPositions(array: Float32Array | ArrayLike<number>): this;
-
-    setColors(array: Float32Array | ArrayLike<number>): this;
-}
-
-export default InstancedPointsGeometry;