@types/three 0.179.0 → 0.180.0

three/src/nodes/display/ScreenNode.d.ts

@@ -5,7 +5,8 @@ export type ScreenNodeScope =
     | typeof ScreenNode.COORDINATE
     | typeof ScreenNode.VIEWPORT
     | typeof ScreenNode.SIZE
-    | typeof ScreenNode.UV;
+    | typeof ScreenNode.UV
+    | typeof ScreenNode.DPR;
 
 declare class ScreenNode extends Node {
     scope: ScreenNodeScope;
@@ -18,12 +19,14 @@ declare class ScreenNode extends Node {
     static VIEWPORT: "viewport";
     static SIZE: "size";
     static UV: "uv";
+    static DPR: "dpr";
 }
 
 export default ScreenNode;
 
 // Screen
 
+export const screenDPR: ShaderNodeObject<ScreenNode>;
 export const screenUV: ShaderNodeObject<ScreenNode>;
 export const screenSize: ShaderNodeObject<ScreenNode>;
 export const screenCoordinate: ShaderNodeObject<ScreenNode>;

three/src/nodes/display/ToneMappingNode.d.ts

@@ -16,7 +16,7 @@ export default ToneMappingNode;
 
 export const toneMapping: (
     mapping: ToneMapping,
-    exposure: Node,
+    exposure: Node | number,
     color?: Node,
 ) => ShaderNodeObject<ToneMappingNode>;
 export const toneMappingExposure: ShaderNodeObject<RendererReferenceNode>;
@@ -26,7 +26,7 @@ declare module "../tsl/TSLCore.js" {
         toneMapping: (
             color: Node,
             mapping?: ToneMapping,
-            exposure?: Node,
+            exposure?: Node | number,
         ) => ShaderNodeObject<ToneMappingNode>;
     }
 }

three/src/nodes/display/ViewportDepthTextureNode.d.ts

@@ -1,9 +1,12 @@
+import { DepthTexture } from "../../textures/DepthTexture.js";
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ViewportTextureNode from "./ViewportTextureNode.js";
 
 declare class ViewportDepthTextureNode extends ViewportTextureNode {
     constructor(uvNode?: Node, levelNode?: Node | null);
+
+    getTextureForReference(): DepthTexture;
 }
 
 export default ViewportDepthTextureNode;

three/src/nodes/display/ViewportSharedTextureNode.d.ts

@@ -1,9 +1,12 @@
+import { FramebufferTexture } from "../../textures/FramebufferTexture.js";
 import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ViewportTextureNode from "./ViewportTextureNode.js";
 
 declare class ViewportSharedTextureNode extends ViewportTextureNode {
     constructor(uvNode?: Node, levelNode?: Node | null);
+
+    getTextureForReference(): FramebufferTexture;
 }
 
 export default ViewportSharedTextureNode;

three/src/nodes/display/ViewportTextureNode.d.ts

@@ -1,4 +1,6 @@
+import { RenderTarget } from "../../core/RenderTarget.js";
 import { FramebufferTexture } from "../../textures/FramebufferTexture.js";
+import { Texture } from "../../textures/Texture.js";
 import TextureNode from "../accessors/TextureNode.js";
 import { NodeUpdateType } from "../core/constants.js";
 import Node from "../core/Node.js";
@@ -12,6 +14,8 @@ declare class ViewportTextureNode extends TextureNode {
     updateBeforeType: NodeUpdateType;
 
     constructor(uvNode?: Node, levelNode?: Node | null, framebufferTexture?: FramebufferTexture | null);
+
+    getTextureForReference(reference?: RenderTarget | null): Texture;
 }
 
 export default ViewportTextureNode;

three/src/nodes/gpgpu/SubgroupFunctionNode.d.ts

@@ -0,0 +1,100 @@
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export type SubgroupFunctionNodeMethod0 = typeof SubgroupFunctionNode.SUBGROUP_ELECT;
+
+export type SubgroupFunctionNodeMethod1 =
+    | typeof SubgroupFunctionNode.SUBGROUP_BALLOT
+    | typeof SubgroupFunctionNode.SUBGROUP_ADD
+    | typeof SubgroupFunctionNode.SUBGROUP_INCLUSIVE_ADD
+    | typeof SubgroupFunctionNode.SUBGROUP_EXCLUSIVE_AND
+    | typeof SubgroupFunctionNode.SUBGROUP_MUL
+    | typeof SubgroupFunctionNode.SUBGROUP_INCLUSIVE_MUL
+    | typeof SubgroupFunctionNode.SUBGROUP_EXCLUSIVE_MUL
+    | typeof SubgroupFunctionNode.SUBGROUP_AND
+    | typeof SubgroupFunctionNode.SUBGROUP_OR
+    | typeof SubgroupFunctionNode.SUBGROUP_XOR
+    | typeof SubgroupFunctionNode.SUBGROUP_MIN
+    | typeof SubgroupFunctionNode.SUBGROUP_MAX
+    | typeof SubgroupFunctionNode.SUBGROUP_ALL
+    | typeof SubgroupFunctionNode.SUBGROUP_ANY
+    | typeof SubgroupFunctionNode.SUBGROUP_BROADCAST_FIRST
+    | typeof SubgroupFunctionNode.QUAD_SWAP_X
+    | typeof SubgroupFunctionNode.QUAD_SWAP_Y
+    | typeof SubgroupFunctionNode.QUAD_SWAP_DIAGONAL;
+
+export type SubgroupFunctionNodeMethod2 =
+    | typeof SubgroupFunctionNode.SUBGROUP_BROADCAST
+    | typeof SubgroupFunctionNode.SUBGROUP_SHUFFLE
+    | typeof SubgroupFunctionNode.SUBGROUP_SHUFFLE_XOR
+    | typeof SubgroupFunctionNode.SUBGROUP_SHUFFLE_UP
+    | typeof SubgroupFunctionNode.SUBGROUP_SHUFFLE_DOWN
+    | typeof SubgroupFunctionNode.QUAD_BROADCAST;
+
+declare class SubgroupFunctionNode extends TempNode {
+    constructor(method: SubgroupFunctionNodeMethod0);
+    constructor(method: SubgroupFunctionNodeMethod1, aNode: Node);
+    constructor(method: SubgroupFunctionNodeMethod2, aNode: Node, bNode: Node);
+
+    // 0 inputs
+    static SUBGROUP_ELECT: "subgroupElect";
+
+    // 1 input
+    static SUBGROUP_BALLOT: "subgroupBallot";
+    static SUBGROUP_ADD: "subgroupAdd";
+    static SUBGROUP_INCLUSIVE_ADD: "subgroupInclusiveAdd";
+    static SUBGROUP_EXCLUSIVE_AND: "subgroupExclusiveAdd";
+    static SUBGROUP_MUL: "subgroupMul";
+    static SUBGROUP_INCLUSIVE_MUL: "subgroupInclusiveMul";
+    static SUBGROUP_EXCLUSIVE_MUL: "subgroupExclusiveMul";
+    static SUBGROUP_AND: "subgroupAnd";
+    static SUBGROUP_OR: "subgroupOr";
+    static SUBGROUP_XOR: "subgroupXor";
+    static SUBGROUP_MIN: "subgroupMin";
+    static SUBGROUP_MAX: "subgroupMax";
+    static SUBGROUP_ALL: "subgroupAll";
+    static SUBGROUP_ANY: "subgroupAny";
+    static SUBGROUP_BROADCAST_FIRST: "subgroupBroadcastFirst";
+    static QUAD_SWAP_X: "quadSwapX";
+    static QUAD_SWAP_Y: "quadSwapY";
+    static QUAD_SWAP_DIAGONAL: "quadSwapDiagonal";
+
+    // 2 inputs
+    static SUBGROUP_BROADCAST: "subgroupBroadcast";
+    static SUBGROUP_SHUFFLE: "subgroupShuffle";
+    static SUBGROUP_SHUFFLE_XOR: "subgroupShuffleXor";
+    static SUBGROUP_SHUFFLE_UP: "subgroupShuffleUp";
+    static SUBGROUP_SHUFFLE_DOWN: "subgroupShuffleDown";
+    static QUAD_BROADCAST: "quadBroadcast";
+}
+
+export default SubgroupFunctionNode;
+
+export const subgroupElect: () => ShaderNodeObject<Node>;
+
+export const subgroupBallot: (pred: Node) => ShaderNodeObject<Node>;
+export const subgroupAdd: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupInclusiveAdd: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupExclusiveAdd: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupMul: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupInclusiveMul: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupExclusiveMul: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupAnd: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupOr: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupXor: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupMin: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupMax: (e: Node) => ShaderNodeObject<Node>;
+export const subgroupAll: () => ShaderNodeObject<Node>;
+export const subgroupAny: () => ShaderNodeObject<Node>;
+export const subgroupBroadcastFirst: (e: Node, id: Node) => ShaderNodeObject<Node>;
+export const quadSwapX: (e: Node) => ShaderNodeObject<Node>;
+export const quadSwapY: (e: Node) => ShaderNodeObject<Node>;
+export const quadSwapDiagonal: (e: Node) => ShaderNodeObject<Node>;
+
+export const subgroupBroadcast: (e: Node, id: Node) => ShaderNodeObject<Node>;
+export const subgroupShuffle: (v: Node, id: Node) => ShaderNodeObject<Node>;
+export const subgroupShuffleXor: (v: Node, mask: Node) => ShaderNodeObject<Node>;
+export const subgroupShuffleUp: (v: Node, delta: Node) => ShaderNodeObject<Node>;
+export const subgroupShuffleDown: (v: Node, delta: Node) => ShaderNodeObject<Node>;
+export const quadBroadcast: (e: Node) => ShaderNodeObject<Node>;

three/src/nodes/math/BitcastNode.d.ts

@@ -0,0 +1,25 @@
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+declare class BitcastNode extends TempNode {
+    valueNode: Node;
+    conversionType: string;
+    inputType: string | null;
+
+    readonly isBitcastNode: true;
+
+    constructor(valueNode: Node, conversionType: string, inputType: string | null);
+}
+
+export default BitcastNode;
+
+export const bitcast: (x: Node | number, y: string) => ShaderNodeObject<BitcastNode>;
+
+export const floatBitsToInt: (value: Node) => ShaderNodeObject<BitcastNode>;
+
+export const floatBitsToUint: (value: Node) => ShaderNodeObject<BitcastNode>;
+
+export const intBitsToFloat: (value: Node) => ShaderNodeObject<BitcastNode>;
+
+export const uintBitsToFloat: (value: Node) => ShaderNodeObject<BitcastNode>;

three/src/nodes/math/MathNode.d.ts

@@ -34,7 +34,6 @@ export type MathNodeMethod1 =
     | typeof MathNode.RECIPROCAL
     | typeof MathNode.TRUNC
     | typeof MathNode.FWIDTH
-    | typeof MathNode.BITCAST
     | typeof MathNode.TRANSPOSE
     | typeof MathNode.DETERMINANT
     | typeof MathNode.INVERSE;
@@ -95,7 +94,6 @@ export default class MathNode extends TempNode {
     static RECIPROCAL: "reciprocal";
     static TRUNC: "trunc";
     static FWIDTH: "fwidth";
-    static BITCAST: "bitcast";
     static TRANSPOSE: "transpose";
     static DETERMINANT: "determinant";
     static INVERSE: "inverse";
@@ -184,7 +182,6 @@ export const inverse: (x: Node) => ShaderNodeObject<MathNode>;
 
 type Binary = (a: MathNodeParameter, b: MathNodeParameter) => ShaderNodeObject<MathNode>;
 
-export const bitcast: Binary;
 export const min: (
     x: MathNodeParameter,
     y: MathNodeParameter,

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

@@ -742,7 +742,7 @@ 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.
+     * @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(
@@ -754,7 +754,7 @@ declare class Renderer {
      *
      * @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.
+     * @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(
@@ -806,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;
     /**

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,6 +78,7 @@ declare class XRManager extends EventDispatcher<XRManagerEventMap> {
     _controllerInputSources: (XRInputSource | null)[];
     _xrRenderTarget: XRRenderTarget | null;
     _layers: XRLayerObject[];
+    _sessionUsesLayers: boolean;
     _supportsLayers: boolean;
     _supportsGlBinding: boolean;
     _frameBufferTargets:
@@ -208,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/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/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

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

three/examples/jsm/loaders/RGBMLoader.d.ts

@@ -1,37 +0,0 @@
-import { CubeTexture, DataTextureLoader, LoadingManager, PixelFormat, TextureDataType } from "three";
-
-export interface RGBM {
-    width: number;
-    height: number;
-    data: Uint16Array | Float32Array;
-    header: string;
-    format: PixelFormat;
-    type: TextureDataType;
-    flipY: boolean;
-}
-
-export class RGBMLoader extends DataTextureLoader {
-    type: TextureDataType;
-
-    maxRange: number;
-
-    constructor(manager?: LoadingManager);
-
-    loadCubemap(
-        urls: string[],
-        onLoad?: (texture: CubeTexture) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): CubeTexture;
-
-    loadCubemapAsync(
-        urls: string[],
-        onProgress?: (event: ProgressEvent) => void,
-    ): Promise<CubeTexture>;
-
-    parse(buffer: ArrayBuffer): RGBM;
-
-    setDataType(dataType: TextureDataType): this;
-
-    setMaxRange(value: number): this;
-}