@types/three 0.164.1 → 0.166.0

three/src/objects/BatchedMesh.d.ts

@@ -2,32 +2,43 @@ import { Camera } from "../cameras/Camera.js";
 import { BufferGeometry } from "../core/BufferGeometry.js";
 import { Material } from "../materials/Material.js";
 import { Box3 } from "../math/Box3.js";
+import { Color } from "../math/Color.js";
 import { Matrix4 } from "../math/Matrix4.js";
 import { Sphere } from "../math/Sphere.js";
 import { Mesh } from "./Mesh.js";
 
 /**
  * A special version of {@link Mesh} with multi draw batch rendering support. Use {@link BatchedMesh} if you have to
- * render a large number of objects with the same material but with different world transformations and geometry. The
- * usage of {@link BatchedMesh} will help you to reduce the number of draw calls and thus improve the overall rendering
+ * render a large number of objects with the same material but with different world transformations. The  usage of
+ * {@link BatchedMesh} will help you to reduce the number of draw calls and thus improve the overall rendering
  * performance in your application.
  *
  * If the {@link https://developer.mozilla.org/en-US/docs/Web/API/WEBGL_multi_draw WEBGL_multi_draw extension} is not
- * supported then a less performant callback is used.
+ * supported then a less performant fallback is used.
  *
  * @example
  * const box = new THREE.BoxGeometry( 1, 1, 1 );
- * const sphere = new THREE.BoxGeometry( 1, 1, 1 );
+ * const sphere = new THREE.SphereGeometry( 1, 12, 12 );
  * const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
  *
  * // initialize and add geometries into the batched mesh
  * const batchedMesh = new BatchedMesh( 10, 5000, 10000, material );
- * const boxId = batchedMesh.addGeometry( box );
- * const sphereId = batchedMesh.addGeometry( sphere );
+ * const boxGeometryId = batchedMesh.addGeometry( box );
+ * const sphereGeometryId = batchedMesh.addGeometry( sphere );
+ *
+ * // create instances of those geometries
+ * const boxInstancedId1 = batchedMesh.addInstance( boxGeometryId );
+ * const boxInstancedId2 = batchedMesh.addInstance( boxGeometryId );
+ *
+ * const sphereInstancedId1 = batchedMesh.addInstance( sphereGeometryId );
+ * const sphereInstancedId2 = batchedMesh.addInstance( sphereGeometryId );
  *
  * // position the geometries
- * batchedMesh.setMatrixAt( boxId, boxMatrix );
- * batchedMesh.setMatrixAt( sphereId, sphereMatrix );
+ * batchedMesh.setMatrixAt( boxInstancedId1, boxMatrix1 );
+ * batchedMesh.setMatrixAt( boxInstancedId2, boxMatrix2 );
+ *
+ * batchedMesh.setMatrixAt( sphereInstancedId1, sphereMatrix1 );
+ * batchedMesh.setMatrixAt( sphereInstancedId2, sphereMatrix2 );
  *
  * scene.add( batchedMesh );
  *
@@ -67,20 +78,20 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
     /**
      * The maximum number of individual geometries that can be stored in the {@link BatchedMesh}. Read only.
      */
-    get maxGeometryCount(): number;
+    get maxInstanceCount(): number;
 
     /**
      * Read-only flag to check if a given object is of type {@link BatchedMesh}.
      */
-    isBatchedMesh: true;
+    readonly isBatchedMesh: true;
 
     /**
-     * @param maxGeometryCount the max number of individual geometries planned to be added.
+     * @param maxInstanceCount the max number of individual geometries planned to be added.
      * @param maxVertexCount the max number of vertices to be used by all geometries.
      * @param maxIndexCount the max number of indices to be used by all geometries.
-     * @param material an instance of [page:Material]. Default is a new {@link MeshBasicMaterial}.
+     * @param material an instance of {@link Material}. Default is a new {@link MeshBasicMaterial}.
      */
-    constructor(maxGeometryCount: number, maxVertexCount: number, maxIndexCount?: number, material?: Material);
+    constructor(maxInstanceCount: number, maxVertexCount: number, maxIndexCount?: number, material?: Material);
 
     /**
      * Computes the bounding box, updating {@link .boundingBox} attribute.
@@ -101,40 +112,55 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
     dispose(): this;
 
     /**
-     * Takes a sort a function that is run before render. The function takes a list of items to sort and a camera. The
-     * objects in the list include a "z" field to perform a depth-ordered sort with.
+     * Takes a sort a function that is run before render. The function takes a list of instances to sort and a camera.
+     * The objects in the list include a "z" field to perform a depth-ordered sort with.
      */
     setCustomSort(
-        func: ((this: this, list: Array<{ start: number; count: number; z: number }>, camera: Camera) => void) | null,
+        sortFunction:
+            | ((this: this, list: Array<{ start: number; count: number; z: number }>, camera: Camera) => void)
+            | null,
     ): this;
 
+    /**
+     * Get the color of the defined geometry.
+     * @param instanceId The id of an instance to get the color of.
+     * @param target The target object to copy the color in to.
+     */
+    getColorAt(instanceId: number, target: Color): void;
+
     /**
      * Get the local transformation matrix of the defined instance.
-     * @param index The index of an instance. Values have to be in the range [0, count].
-     * @param matrix This 4x4 matrix will be set to the local transformation matrix of the defined instance.
+     * @param instanceId The id of an instance to get the matrix of.
+     * @param target This 4x4 matrix will be set to the local transformation matrix of the defined instance.
      */
-    getMatrixAt(index: number, matrix: Matrix4): Matrix4;
+    getMatrixAt(instanceId: number, target: Matrix4): Matrix4;
 
     /**
      * Get whether the given instance is marked as "visible" or not.
-     * @param index The index of an instance. Values have to be in the range [0, count].
+     * @param instanceId The id of an instance to get the visibility state of.
      */
-    getVisibleAt(index: number): boolean;
+    getVisibleAt(instanceId: number): boolean;
 
     /**
-     * Sets the given local transformation matrix to the defined instance. Make sure you set {@link .instanceMatrix}
-     * {@link BufferAttribute.needsUpdate} to true after updating all the matrices.
-     * @param index The index of an instance. Values have to be in the range [0, count].
+     * Sets the given color to the defined geometry instance.
+     * @param instanceId The id of the instance to set the color of.
+     * @param color The color to set the instance to.
+     */
+    setColorAt(instanceId: number, color: Color): void;
+
+    /**
+     * Sets the given local transformation matrix to the defined instance.
+     * @param instanceId The id of an instance to set the matrix of.
      * @param matrix A 4x4 matrix representing the local transformation of a single instance.
      */
-    setMatrixAt(index: number, matrix: Matrix4): this;
+    setMatrixAt(instanceId: number, matrix: Matrix4): this;
 
     /**
-     * Sets the visibility of the object at the given index.
-     * @param index The index of an instance. Values have to be in the range [0, count].
+     * Sets the visibility of the instance at the given index.
+     * @param instanceId The id of the instance to set the visibility of.
      * @param visible A boolean value indicating the visibility state.
      */
-    setVisibleAt(index: number, visible: boolean): this;
+    setVisibleAt(instanceId: number, visible: boolean): this;
 
     /**
      * Adds the given geometry to the {@link BatchedMesh} and returns the associated index referring to it.
@@ -149,30 +175,23 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
     addGeometry(geometry: BufferGeometry, reservedVertexRange?: number, reservedIndexRange?: number): number;
 
     /**
-     * Replaces the geometry at `index` with the provided geometry. Throws an error if there is not enough space
-     * reserved for geometry at the index.
-     * @param index Which geometry index to replace with this geometry.
-     * @param geometry The geometry to substitute at the given geometry index.
-     */
-    setGeometryAt(index: number, geometry: BufferGeometry): number;
-
-    /**
-     * Gets the instance count of the geometry at `index`. Returns `null` if instance counts are not configured.
-     * @param index The index of an instance. Values have to be in the range [0, count].
+     * Adds a new instance to the {@link BatchedMesh} using the geometry of the given geometryId and returns a new id
+     * referring to the new instance to be used by other functions.
+     * @param geometryId The id of a previously added geometry via "addGeometry" to add into the {@link BatchedMesh} to
+     * render.
      */
-    getInstanceCountAt(index: number): number | null;
+    addInstance(geometryId: number): number;
 
     /**
-     * Sets an instance count of the geometry at `index`.
-     * @param index Which geometry index to configure an instance count for.
-     * @param instanceCount The number of instances to render of the given geometry index.
+     * Replaces the geometry at `geometryId` with the provided geometry. Throws an error if there is not enough space
+     * reserved for geometry. Calling this will change all instances that are rendering that geometry.
+     * @param geometryId Which geometry id to replace with this geometry.
+     * @param geometry The geometry to substitute at the given geometry id.
      */
-    setInstanceCountAt(index: number, instanceCount: number): number;
-
-    deleteGeometry(index: number): this;
+    setGeometryAt(geometryId: number, geometry: BufferGeometry): number;
 
-    getBoundingBoxAt(index: number, target: Box3): Box3 | null;
-    getBoundingSphereAt(index: number, target: Sphere): Sphere | null;
+    getBoundingBoxAt(geometryId: number, target: Box3): Box3 | null;
+    getBoundingSphereAt(geometryId: number, target: Sphere): Sphere | null;
 }
 
 export { BatchedMesh };

three/src/objects/InstancedMesh.d.ts

@@ -16,7 +16,7 @@ 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 but with different world transformations
+ * 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}
@@ -33,8 +33,8 @@ export class InstancedMesh<
 > extends Mesh<TGeometry, TMaterial, TEventMap> {
     /**
      * Create a new instance of {@link InstancedMesh}
-     * @param geometry An instance of {@link THREE.BufferGeometry | BufferGeometry}.
-     * @param material A single or an array of {@link THREE.Material | Material}. Default {@link THREE.MeshBasicMaterial | `new THREE.MeshBasicMaterial()`}.
+     * @param geometry An instance of {@link BufferGeometry}.
+     * @param material A single or an array of {@link Material}. Default is a new {@link MeshBasicMaterial}.
      * @param count The **maximum** number of instances of this Mesh. Expects a `Integer`
      */
     constructor(geometry: TGeometry | undefined, material: TMaterial | undefined, count: number);

three/src/renderers/WebGLRenderer.d.ts

@@ -1,8 +1,10 @@
 import { Camera } from "../cameras/Camera.js";
 import { ColorSpace, CullFace, ShadowMapType, ToneMapping, WebGLCoordinateSystem } from "../constants.js";
+import { TypedArray } from "../core/BufferAttribute.js";
 import { BufferGeometry } from "../core/BufferGeometry.js";
 import { Object3D } from "../core/Object3D.js";
 import { Material } from "../materials/Material.js";
+import { Box2 } from "../math/Box2.js";
 import { Box3 } from "../math/Box3.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
 import { Plane } from "../math/Plane.js";
@@ -125,7 +127,7 @@ export interface WebGLDebug {
  */
 export class WebGLRenderer implements Renderer {
     /**
-     * parameters is an optional object with properties defining the renderer's behaviour.
+     * parameters is an optional object with properties defining the renderer's behavior.
      * The constructor also accepts no parameters at all.
      * In all cases, it will assume sane defaults when parameters are missing.
      */
@@ -196,13 +198,6 @@ export class WebGLRenderer implements Renderer {
 
     get coordinateSystem(): typeof WebGLCoordinateSystem;
 
-    /**
-     * @deprecated Migrate your lighting according to the following guide:
-     * https://discourse.threejs.org/t/updates-to-lighting-in-three-js-r155/53733.
-     * @default true
-     */
-    useLegacyLights: boolean;
-
     /**
      * @default THREE.NoToneMapping
      */
@@ -421,46 +416,73 @@ export class WebGLRenderer implements Renderer {
         y: number,
         width: number,
         height: number,
-        buffer: any,
+        buffer: TypedArray,
         activeCubeFaceIndex?: number,
     ): void;
 
+    readRenderTargetPixelsAsync(
+        renderTarget: WebGLRenderTarget | WebGLRenderTarget<Texture[]>,
+        x: number,
+        y: number,
+        width: number,
+        height: number,
+        buffer: TypedArray,
+        activeCubeFaceIndex?: number,
+    ): Promise<TypedArray>;
+
     /**
      * Copies a region of the currently bound framebuffer into the selected mipmap level of the selected texture.
      * This region is defined by the size of the destination texture's mip level, offset by the input position.
      *
-     * @param position Specifies the pixel offset from which to copy out of the framebuffer.
      * @param texture Specifies the destination texture.
+     * @param position Specifies the pixel offset from which to copy out of the framebuffer.
      * @param level Specifies the destination mipmap level of the texture.
      */
-    copyFramebufferToTexture(position: Vector2, texture: Texture, level?: number): void;
+    copyFramebufferToTexture(texture: Texture, position?: Vector2 | null, level?: number): void;
 
     /**
-     * Copies srcTexture to the specified level of dstTexture, offset by the input position.
+     * Copies the pixels of a texture in the bounds `srcRegion` in the destination texture starting from the given
+     * position.
      *
-     * @param position Specifies the pixel offset into the dstTexture where the copy will occur.
      * @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.
      */
-    copyTextureToTexture(position: Vector2, srcTexture: Texture, dstTexture: Texture, level?: number): void;
+    copyTextureToTexture(
+        srcTexture: Texture,
+        dstTexture: Texture,
+        srcRegion?: Box2 | null,
+        dstPosition?: Vector2 | null,
+        level?: number,
+    ): void;
 
     /**
-     * Copies the pixels of a texture in the bounds sourceBox in the desination texture starting from the given position.
-     * @param sourceBox Specifies the bounds
-     * @param position Specifies the pixel offset into the dstTexture where the copy will occur.
+     * Copies the pixels of a texture in the bounds `srcRegion` in the destination texture starting from the given
+     * position.
+     *
      * @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(
-        sourceBox: Box3,
-        position: Vector3,
         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.
+     * @param target
+     */
+    initRenderTarget(target: WebGLRenderTarget): void;
+
     /**
      * Initializes the given texture. Can be used to preload a texture rather than waiting until first render (which can cause noticeable lags due to decode and GPU upload overhead).
      *

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

@@ -89,6 +89,7 @@ export const UniformsLib: {
         directionalLightShadows: {
             value: unknown[];
             properties: {
+                shadowIntensity: number;
                 shadowBias: {};
                 shadowNormalBias: {};
                 shadowRadius: {};
@@ -112,6 +113,7 @@ export const UniformsLib: {
         spotLightShadows: {
             value: unknown[];
             properties: {
+                shadowIntensity: number;
                 shadowBias: {};
                 shadowNormalBias: {};
                 shadowRadius: {};
@@ -133,6 +135,7 @@ export const UniformsLib: {
         pointLightShadows: {
             value: unknown[];
             properties: {
+                shadowIntensity: number;
                 shadowBias: {};
                 shadowNormalBias: {};
                 shadowRadius: {};

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

@@ -39,6 +39,7 @@ export interface WebGLProgramParameters {
     precision: "lowp" | "mediump" | "highp";
 
     batching: boolean;
+    batchingColor: boolean;
     instancing: boolean;
     instancingColor: boolean;
     instancingMorph: boolean;
@@ -186,7 +187,6 @@ export interface WebGLProgramParameters {
     shadowMapType: ShadowMapType;
 
     toneMapping: ToneMapping;
-    useLegacyLights: boolean;
 
     decodeVideoTexture: boolean;
 

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

@@ -21,7 +21,9 @@ export class WebXRDepthSensing {
 
     init(renderer: WebGLRenderer, depthData: XRWebGLDepthInformation, renderState: XRRenderState): void;
 
-    render(renderer: WebGLRenderer, cameraXR: WebXRArrayCamera): void;
+    getMesh(cameraXR: WebXRArrayCamera): Mesh | null;
 
     reset(): void;
+
+    getDepthTexture(): Texture | null;
 }

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

@@ -6,6 +6,8 @@ import { ArrayCamera } from "../../cameras/ArrayCamera.js";
 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 { WebGLRenderer } from "../WebGLRenderer.js";
 import { XRGripSpace, XRHandSpace, XRTargetRaySpace } from "./WebXRController.js";
 
@@ -22,7 +24,10 @@ export interface WebXRManagerEventMap {
 }
 
 export class WebXRManager extends EventDispatcher<WebXRManagerEventMap> {
-    constructor(renderer: WebGLRenderer, gl: WebGLRenderingContext);
+    /**
+     * @default true
+     */
+    cameraAutoUpdate: boolean;
 
     /**
      * @default false
@@ -34,44 +39,49 @@ export class WebXRManager extends EventDispatcher<WebXRManagerEventMap> {
      */
     isPresenting: boolean;
 
-    /**
-     * @default true
-     */
-    cameraAutoUpdate: boolean;
+    constructor(renderer: WebGLRenderer, gl: WebGLRenderingContext);
+
+    getController: (index: number) => XRTargetRaySpace;
+
+    getControllerGrip: (index: number) => XRGripSpace;
+
+    getHand: (index: number) => XRHandSpace;
+
+    setFramebufferScaleFactor: (value: number) => void;
 
-    getController(index: number): XRTargetRaySpace;
+    setReferenceSpaceType: (value: XRReferenceSpaceType) => void;
 
-    getControllerGrip(index: number): XRGripSpace;
+    getReferenceSpace: () => XRReferenceSpace | null;
 
-    getHand(index: number): XRHandSpace;
+    setReferenceSpace: (value: XRReferenceSpace) => void;
 
-    setFramebufferScaleFactor(value: number): void;
+    getBaseLayer: () => XRWebGLLayer | XRProjectionLayer;
 
-    setReferenceSpaceType(value: XRReferenceSpaceType): void;
+    getBinding: () => XRWebGLBinding;
 
-    getReferenceSpace(): XRReferenceSpace | null;
+    getFrame: () => XRFrame;
 
-    setReferenceSpace(value: XRReferenceSpace): void;
+    getSession: () => XRSession | null;
 
-    getBaseLayer(): XRWebGLLayer | XRProjectionLayer;
+    setSession: (value: XRSession | null) => Promise<void>;
 
-    getBinding(): XRWebGLBinding;
+    getEnvironmentBlendMode: () => XREnvironmentBlendMode | undefined;
 
-    getFrame(): XRFrame;
+    getDepthTexture: () => Texture | null;
 
-    getSession(): XRSession | null;
+    updateCamera: (camera: PerspectiveCamera) => void;
 
-    setSession(value: XRSession | null): Promise<void>;
+    getCamera: () => WebXRArrayCamera;
 
-    getCamera(): WebXRArrayCamera;
+    getFoveation: () => number | undefined;
 
-    updateCamera(camera: PerspectiveCamera): void;
+    setFoveation: (value: number) => void;
 
-    setAnimationLoop(callback: XRFrameRequestCallback | null): void;
+    hasDepthSensing: () => boolean;
 
-    getFoveation(): number | undefined;
+    getDepthSensingMesh: () => Mesh | null;
 
-    setFoveation(value: number): void;
+    setAnimationLoop: (callback: XRFrameRequestCallback | null) => void;
 
-    dispose(): void;
+    dispose: () => void;
 }

three/src/textures/CompressedArrayTexture.d.ts

@@ -1,5 +1,5 @@
 import { CompressedPixelFormat, TextureDataType, Wrapping } from "../constants.js";
-import { CompressedTexture } from "./CompressedTexture.js";
+import { CompressedTexture, CompressedTextureMipmap } from "./CompressedTexture.js";
 
 /**
  * Creates an texture 2D array based on data in compressed form, for example from a
@@ -9,10 +9,36 @@ import { CompressedTexture } from "./CompressedTexture.js";
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/textures/CompressedArrayTexture.js | Source}
  */
 export class CompressedArrayTexture extends CompressedTexture {
+    /**
+     * Read-only flag to check if a given object is of type {@link CompressedArrayTexture}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isCompressedArrayTexture: true;
+
+    /**
+     * Overridden with a object containing width and height.
+     * @override
+     */
+    get image(): { width: number; height: number; depth: number };
+    set image(value: { width: number; height: number; depth: number });
+
+    /**
+     * This defines how the texture is wrapped in the depth direction.
+     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
+     * @defaultValue {@link THREE.ClampToEdgeWrapping}
+     */
+    wrapR: Wrapping;
+
+    /**
+     * A set of all layers which need to be updated in the texture. See {@link CompressedArrayTexture.addLayerUpdate}.
+     */
+    layerUpdates: Set<number>;
+
     /**
      * Create a new instance of {@link CompressedArrayTexture}
-     * @param mipmaps The mipmaps array should contain objects with data, width and height.
-     * The mipmaps should be of the correct {@link format} and {@link type}. See {@link THREE.mipmaps}.
+     * @param mipmaps The mipmaps array should contain objects with data, width and height. The mipmaps should be of the
+     * correct format and type.
      * @param width The width of the biggest mipmap.
      * @param height The height of the biggest mipmap.
      * @param depth The number of layers of the 2D array texture
@@ -20,7 +46,7 @@ export class CompressedArrayTexture extends CompressedTexture {
      * @param type See {@link Texture.type | .type}. Default {@link THREE.UnsignedByteType}
      */
     constructor(
-        mipmaps: ImageData[],
+        mipmaps: CompressedTextureMipmap[],
         width: number,
         height: number,
         depth: number,
@@ -29,23 +55,14 @@ export class CompressedArrayTexture extends CompressedTexture {
     );
 
     /**
-     * Read-only flag to check if a given object is of type {@link CompressedArrayTexture}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
+     * Describes that a specific layer of the texture needs to be updated. Normally when {@link Texture.needsUpdate} is
+     * set to true, the entire compressed texture array is sent to the GPU. Marking specific layers will only transmit
+     * subsets of all mipmaps associated with a specific depth in the array which is often much more performant.
      */
-    readonly isCompressedArrayTexture: true;
+    addLayerUpdate(layerIndex: number): void;
 
     /**
-     * Overridden with a object containing width and height.
-     * @override
+     * Resets the layer updates registry. See {@link CompressedArrayTexture.addLayerUpdate}.
      */
-    get image(): { width: number; height: number; depth: number };
-    set image(value: { width: number; height: number; depth: number });
-
-    /**
-     * This defines how the texture is wrapped in the depth direction.
-     * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
-     * @defaultValue {@link THREE.ClampToEdgeWrapping}
-     */
-    wrapR: Wrapping;
+    clearLayoutUpdates(): void;
 }

three/src/textures/CompressedTexture.d.ts

@@ -7,8 +7,15 @@ import {
     TextureDataType,
     Wrapping,
 } from "../constants.js";
+import { TypedArray } from "../core/BufferAttribute.js";
 import { Texture } from "./Texture.js";
 
+export interface CompressedTextureMipmap {
+    data: TypedArray;
+    width: number;
+    height: number;
+}
+
 /**
  * Creates a texture based on data in compressed form, for example from a {@link https://en.wikipedia.org/wiki/DirectDraw_Surface | DDS} file.
  * @remarks For use with the {@link THREE.CompressedTextureLoader | CompressedTextureLoader}.
@@ -18,8 +25,8 @@ import { Texture } from "./Texture.js";
 export class CompressedTexture extends Texture {
     /**
      * This creates a new {@link THREE.CompressedTexture | CompressedTexture} object.
-     * @param mipmaps The mipmaps array should contain objects with data, width and height.
-     * The mipmaps should be of the correct {@link format} and {@link type}. See {@link THREE.mipmaps}.
+     * @param mipmaps The mipmaps array should contain objects with data, width and height. The mipmaps should be of the
+     * correct format and type.
      * @param width The width of the biggest mipmap.
      * @param height The height of the biggest mipmap.
      * @param format The format used in the mipmaps. See {@link THREE.CompressedPixelFormat}.
@@ -33,10 +40,10 @@ export class CompressedTexture extends Texture {
      * @param colorSpace See {@link Texture.colorSpace .colorSpace}. Default {@link NoColorSpace}
      */
     constructor(
-        mipmaps: ImageData[],
-        width: number,
-        height: number,
-        format: CompressedPixelFormat,
+        mipmaps?: CompressedTextureMipmap[],
+        width?: number,
+        height?: number,
+        format?: CompressedPixelFormat,
         type?: TextureDataType,
         mapping?: Mapping,
         wrapS?: Wrapping,
@@ -62,9 +69,10 @@ export class CompressedTexture extends Texture {
     set image(value: { width: number; height: number });
 
     /**
-     *  The mipmaps array should contain objects with data, width and height. The mipmaps should be of the correct {@link format} and {@link type}.
+     *  The mipmaps array should contain objects with data, width and height. The mipmaps should be of the correct
+     *  format and type.
      */
-    mipmaps: ImageData[];
+    mipmaps: CompressedTextureMipmap[] | undefined;
 
     /**
      * @override