@types/three 0.165.0 → 0.166.0

three/src/objects/BatchedMesh.d.ts

@@ -9,26 +9,36 @@ 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 );
  *
@@ -68,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.
@@ -102,54 +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 index The index of a geometry. Values have to be in the range [0, count].
-     * @param color This color object will be set to 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(index: number, color: Color): void;
+    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 color to the defined geometry.
-     * @param index The index of a geometry. Values have to be in the range [0, count].
-     * @param color The color of a single geometry.
+     * 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(index: number, color: Color): void;
+    setColorAt(instanceId: number, color: Color): void;
 
     /**
-     * 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 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.
@@ -164,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.
+     * 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.
      */
-    setGeometryAt(index: number, geometry: BufferGeometry): number;
+    addInstance(geometryId: number): 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].
+     * 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.
      */
-    getInstanceCountAt(index: number): number | null;
-
-    /**
-     * 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.
-     */
-    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/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/webxr/WebXRDepthSensing.d.ts

@@ -24,4 +24,6 @@ export class WebXRDepthSensing {
     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
@@ -37,8 +37,8 @@ export class CompressedArrayTexture extends CompressedTexture {
 
     /**
      * 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
@@ -46,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,

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

three/src/textures/Texture.d.ts

@@ -13,6 +13,8 @@ import {
 import { EventDispatcher } from "../core/EventDispatcher.js";
 import { Matrix3 } from "../math/Matrix3.js";
 import { Vector2 } from "../math/Vector2.js";
+import { CompressedTextureMipmap } from "./CompressedTexture.js";
+import { CubeTexture } from "./CubeTexture.js";
 import { Source } from "./Source.js";
 
 /** Shim for OffscreenCanvas. */
@@ -127,7 +129,7 @@ export class Texture extends EventDispatcher<{ dispose: {} }> {
      * Array of user-specified mipmaps
      * @defaultValue `[]`
      */
-    mipmaps: any[]; // ImageData[] for 2D textures and CubeTexture[] for cube textures;
+    mipmaps: CompressedTextureMipmap[] | CubeTexture[] | HTMLCanvasElement[] | undefined;
 
     /**
      * How the image is applied to the object.

three/examples/jsm/renderers/webgl/nodes/SlotNode.d.ts

@@ -1,17 +0,0 @@
-import Node from "../../../nodes/core/Node.js";
-
-export interface SlotNodeParameters<TNode extends Node = Node> {
-    node?: TNode;
-    nodeType?: string;
-    source?: string | null;
-    target?: string | null;
-}
-
-export default class SlotNode<TNode extends Node = Node> extends Node {
-    inclusionType: "replace";
-    node: TNode | null;
-    source: null;
-    target: null;
-
-    constructor(params: SlotNodeParameters<TNode>);
-}

three/examples/jsm/renderers/webgl/nodes/WebGLNodeBuilder.d.ts

@@ -1,37 +0,0 @@
-import { Object3D, Renderer } from "three";
-import { NodeShaderStage } from "../../../nodes/core/constants.js";
-import Node from "../../../nodes/core/Node.js";
-import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
-import SlotNode from "./SlotNode.js";
-
-export class WebGLNodeBuilder extends NodeBuilder {
-    constructor(
-        object: Object3D,
-        renderer: Renderer,
-        shader: { uniforms: any; vertexShader: any; fragmentShader: any },
-    );
-
-    addSlot(shaderStage: NodeShaderStage, slotNode: SlotNode): Node;
-
-    getUniforms(shaderStage: string): string;
-
-    getAttributes(shaderStage: string): string;
-
-    getVarys(shaderStage: string): string;
-
-    addCode(shaderStage: string, source: string, code: string, scope?: this): string;
-    addCodeAfterInclude(shaderStage: string, snippet: string, code: string): string;
-
-    replaceCode(shaderStage: string, source: string, target: string, scope?: this): void;
-    parseInclude(shaderStage: string, ...includes: string[]): void;
-
-    getInstanceIndex(): string;
-    getFrontFacing(): string;
-    getFragCoord(): "gl_FragCoord";
-    isFlipY(): true;
-
-    buildCode(): void;
-    build(): this;
-
-    getSlot(shaderStage: string, name: string): Node;
-}

three/examples/jsm/renderers/webgl/nodes/WebGLNodes.d.ts

@@ -1,3 +0,0 @@
-import NodeFrame from "../../../nodes/core/NodeFrame.js";
-
-export const nodeFrame: NodeFrame;