@types/three 0.158.3 → 0.160.0

three/src/objects/BatchedMesh.d.ts

@@ -0,0 +1,169 @@
+import { Mesh } from './Mesh.js';
+import { BufferGeometry } from '../core/BufferGeometry.js';
+import { Material } from '../materials/Material.js';
+import { Box3 } from '../math/Box3.js';
+import { Sphere } from '../math/Sphere.js';
+import { Matrix4 } from '../math/Matrix4.js';
+import { Camera } from '../cameras/Camera.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
+ * 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.
+ *
+ * @example
+ * const box = new THREE.BoxGeometry( 1, 1, 1 );
+ * const sphere = new THREE.BoxGeometry( 1, 1, 1 );
+ * 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 );
+ *
+ * // position the geometries
+ * batchedMesh.setMatrixAt( boxId, boxMatrix );
+ * batchedMesh.setMatrixAt( sphereId, sphereMatrix );
+ *
+ * scene.add( batchedMesh );
+ *
+ * @also Example: {@link https://threejs.org/examples/#webgl_mesh_batch WebGL / mesh / batch}
+ */
+declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
+    /**
+     * This bounding box encloses all instances of the {@link BatchedMesh}. Can be calculated with
+     * {@link .computeBoundingBox()}.
+     * @default null
+     */
+    boundingBox: Box3 | null;
+
+    /**
+     * This bounding sphere encloses all instances of the {@link BatchedMesh}. Can be calculated with
+     * {@link .computeBoundingSphere()}.
+     * @default null
+     */
+    boundingSphere: Sphere | null;
+
+    customSort: ((this: this, list: Array<{ start: number; count: number; z: number }>, camera: Camera) => void) | null;
+
+    /**
+     * If true then the individual objects within the {@link BatchedMesh} are frustum culled.
+     * @default true
+     */
+    perObjectFrustumCulled: boolean;
+
+    /**
+     * If true then the individual objects within the {@link BatchedMesh} are sorted to improve overdraw-related
+     * artifacts. If the material is marked as "transparent" objects are rendered back to front and if not then they are
+     * rendered front to back.
+     * @default true
+     */
+    sortObjects: boolean;
+
+    /**
+     * The maximum number of individual geometries that can be stored in the {@link BatchedMesh}. Read only.
+     */
+    get maxGeometryCount(): number;
+
+    /**
+     * Read-only flag to check if a given object is of type {@link BatchedMesh}.
+     */
+    isBatchedMesh: true;
+
+    /**
+     *
+     * @param maxGeometryCount 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}.
+     */
+    constructor(maxGeometryCount: number, maxVertexCount: number, maxIndexCount?: number, material?: Material);
+
+    /**
+     * Computes the bounding box, updating {@link .boundingBox} attribute.
+     * Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+     */
+    computeBoundingBox(): void;
+
+    /**
+     * Computes the bounding sphere, updating {@link .boundingSphere} attribute.
+     * Bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+     */
+    computeBoundingSphere(): void;
+
+    /**
+     * Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer
+     * used in your app.
+     */
+    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.
+     */
+    setCustomSort(
+        func: ((this: this, list: Array<{ start: number; count: number; z: number }>, camera: Camera) => void) | null,
+    ): this;
+
+    /**
+     * 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.
+     */
+    getMatrixAt(index: number, matrix: 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].
+     */
+    getVisibleAt(index: 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].
+     * @param matrix A 4x4 matrix representing the local transformation of a single instance.
+     */
+    setMatrixAt(index: 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].
+     * @param visible A boolean value indicating the visibility state.
+     */
+    setVisibleAt(index: number, visible: boolean): this;
+
+    /**
+     * Adds the given geometry to the {@link BatchedMesh} and returns the associated index referring to it.
+     * @param geometry The geometry to add into the {@link BatchedMesh}.
+     * @param reservedVertexRange Optional parameter specifying the amount of vertex buffer space to reserve for the
+     * added geometry. This is necessary if it is planned to set a new geometry at this index at a later time that is
+     * larger than the original geometry. Defaults to the length of the given geometry vertex buffer.
+     * @param reservedIndexRange Optional parameter specifying the amount of index buffer space to reserve for the added
+     * geometry. This is necessary if it is planned to set a new geometry at this index at a later time that is larger
+     * than the original geometry. Defaults to the length of the given geometry index buffer.
+     */
+    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;
+
+    /**
+     * Marks the geometry at the given index as deleted and to not be rendered anymore.
+     */
+    deleteGeometry(index: number): this;
+
+    getBoundingBoxAt(index: number, target: Box3): Box3;
+    getBoundingSphereAt(index: number, target: Sphere): Sphere;
+}
+
+export { BatchedMesh };

three/src/objects/Bone.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from './../core/Object3D.js';
+import { Object3D } from '../core/Object3D.js';
 
 /**
  * A {@link Bone} which is part of a {@link THREE.Skeleton | Skeleton}

three/src/objects/LOD.d.ts

@@ -1,7 +1,5 @@
-import { Object3D } from './../core/Object3D.js';
-import { Raycaster } from './../core/Raycaster.js';
-import { Camera } from './../cameras/Camera.js';
-import { Intersection } from '../core/Raycaster.js';
+import { Object3D } from '../core/Object3D.js';
+import { Camera } from '../cameras/Camera.js';
 
 /**
  * Every level is associated with an object, and rendering can be switched between them at the distances specified

three/src/objects/Line.d.ts

@@ -1,8 +1,6 @@
-import { Material } from './../materials/Material.js';
-import { Raycaster } from './../core/Raycaster.js';
-import { Object3D } from './../core/Object3D.js';
+import { Material } from '../materials/Material.js';
+import { Object3D } from '../core/Object3D.js';
 import { BufferGeometry } from '../core/BufferGeometry.js';
-import { Intersection } from '../core/Raycaster.js';
 
 /**
  * A continuous line.

three/src/objects/LineLoop.d.ts

@@ -1,5 +1,5 @@
 import { Line } from './Line.js';
-import { Material } from './../materials/Material.js';
+import { Material } from '../materials/Material.js';
 import { BufferGeometry } from '../core/BufferGeometry.js';
 
 /**

three/src/objects/LineSegments.d.ts

@@ -1,4 +1,4 @@
-import { Material } from './../materials/Material.js';
+import { Material } from '../materials/Material.js';
 import { Line } from './Line.js';
 import { BufferGeometry } from '../core/BufferGeometry.js';
 

three/src/objects/Skeleton.d.ts

@@ -1,6 +1,6 @@
 import { Bone } from './Bone.js';
-import { Matrix4 } from './../math/Matrix4.js';
-import { DataTexture } from './../textures/DataTexture.js';
+import { Matrix4 } from '../math/Matrix4.js';
+import { DataTexture } from '../textures/DataTexture.js';
 
 /**
  * Use an array of {@link Bone | bones} to create a {@link Skeleton} that can be used by a {@link THREE.SkinnedMesh | SkinnedMesh}.
@@ -61,12 +61,6 @@ export class Skeleton {
      */
     boneTexture: null | DataTexture;
 
-    /**
-     * The size of the {@link boneTexture | .boneTexture}.
-     * @remarks Expects a `Integer`
-     */
-    boneTextureSize: number;
-
     frame: number;
 
     init(): void;

three/src/objects/SkinnedMesh.d.ts

@@ -11,8 +11,7 @@ import { BindMode } from '../constants.js';
 /**
  * A mesh that has a {@link THREE.Skeleton | Skeleton} with {@link Bone | bones} that can then be used to animate the vertices of the geometry.
  * @remarks
- * {@link SkinnedMesh} can only be used with WebGL 2 or
- * With WebGL 1 `OES_texture_float` and vertex textures support is required.
+ * {@link SkinnedMesh} can only be used with WebGL 2.
  * @example
  * ```typescript
  * const geometry = new THREE.CylinderGeometry(5, 5, 5, 5, 15, 5, 30);

three/src/renderers/WebGL3DRenderTarget.d.ts

@@ -1,5 +1,5 @@
 import { Data3DTexture } from '../textures/Data3DTexture.js';
-import { WebGLRenderTarget } from './WebGLRenderTarget.js';
+import { WebGLRenderTarget, WebGLRenderTargetOptions } from './WebGLRenderTarget.js';
 
 /**
  * Represents a three-dimensional render target.
@@ -8,11 +8,13 @@ export class WebGL3DRenderTarget extends WebGLRenderTarget {
     /**
      * Creates a new WebGL3DRenderTarget.
      *
-     * @param width the width of the render target, in pixels.
-     * @param height the height of the render target, in pixels.
-     * @param depth the depth of the render target.
+     * @param width the width of the render target, in pixels. Default is `1`.
+     * @param height the height of the render target, in pixels. Default is `1`.
+     * @param depth the depth of the render target. Default is `1`.
+     * @param options optional object that holds texture parameters for an auto-generated target texture and
+     * depthBuffer/stencilBuffer booleans. See {@link WebGLRenderTarget} for details.
      */
-    constructor(width?: number, height?: number, depth?: number);
+    constructor(width?: number, height?: number, depth?: number, options?: WebGLRenderTargetOptions);
 
     /**
      * The depth of the render target.

three/src/renderers/WebGLArrayRenderTarget.d.ts

@@ -1,5 +1,5 @@
 import { DataArrayTexture } from '../textures/DataArrayTexture.js';
-import { WebGLRenderTarget } from './WebGLRenderTarget.js';
+import { WebGLRenderTarget, WebGLRenderTargetOptions } from './WebGLRenderTarget.js';
 
 /**
  * This type of render target represents an array of textures.
@@ -8,11 +8,13 @@ export class WebGLArrayRenderTarget extends WebGLRenderTarget {
     /**
      * Creates a new WebGLArrayRenderTarget.
      *
-     * @param width the width of the render target, in pixels.
-     * @param height the height of the render target, in pixels.
-     * @param depth the depth/layer count of the render target.
+     * @param width the width of the render target, in pixels. Default is `1`.
+     * @param height the height of the render target, in pixels. Default is `1`.
+     * @param depth the depth/layer count of the render target. Default is `1`.
+     * @param options optional object that holds texture parameters for an auto-generated target texture and
+     * depthBuffer/stencilBuffer booleans. See {@link WebGLRenderTarget} for details.
      */
-    constructor(width?: number, height?: number, depth?: number);
+    constructor(width?: number, height?: number, depth?: number, options?: WebGLRenderTargetOptions);
 
     /**
      * The depth of the render target.

three/src/renderers/WebGLCubeRenderTarget.d.ts

@@ -1,7 +1,7 @@
 import { WebGLRenderTargetOptions, WebGLRenderTarget } from './WebGLRenderTarget.js';
 import { WebGLRenderer } from './WebGLRenderer.js';
-import { Texture } from './../textures/Texture.js';
-import { CubeTexture } from './../textures/CubeTexture.js';
+import { Texture } from '../textures/Texture.js';
+import { CubeTexture } from '../textures/CubeTexture.js';
 
 export class WebGLCubeRenderTarget extends WebGLRenderTarget {
     constructor(size?: number, options?: WebGLRenderTargetOptions);

three/src/renderers/WebGLRenderTarget.d.ts

@@ -5,7 +5,7 @@ import { RenderTarget, RenderTargetOptions } from '../core/RenderTarget.js';
 export interface WebGLRenderTargetOptions extends RenderTargetOptions {}
 
 export class WebGLRenderTarget<TTexture extends Texture | Texture[] = Texture> extends RenderTarget<TTexture> {
-    constructor(width?: number, height?: number, options?: RenderTargetOptions);
+    constructor(width?: number, height?: number, options?: WebGLRenderTargetOptions);
 
     readonly isWebGLRenderTarget: true;
 }

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

@@ -8,6 +8,7 @@ export const ShaderChunk: {
     alphatest_pars_fragment: string;
     aomap_fragment: string;
     aomap_pars_fragment: string;
+    batching_pars_vertex: string;
     begin_vertex: string;
     beginnormal_vertex: string;
     bsdfs: string;

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

@@ -1,27 +1,27 @@
 import { IUniform } from './UniformsLib.js';
 
-export interface Shader {
+export interface ShaderLibShader {
     uniforms: { [uniform: string]: IUniform };
     vertexShader: string;
     fragmentShader: string;
 }
 
 export let ShaderLib: {
-    [name: string]: Shader;
-    basic: Shader;
-    lambert: Shader;
-    phong: Shader;
-    standard: Shader;
-    matcap: Shader;
-    points: Shader;
-    dashed: Shader;
-    depth: Shader;
-    normal: Shader;
-    sprite: Shader;
-    background: Shader;
-    cube: Shader;
-    equirect: Shader;
-    distanceRGBA: Shader;
-    shadow: Shader;
-    physical: Shader;
+    [name: string]: ShaderLibShader;
+    basic: ShaderLibShader;
+    lambert: ShaderLibShader;
+    phong: ShaderLibShader;
+    standard: ShaderLibShader;
+    matcap: ShaderLibShader;
+    points: ShaderLibShader;
+    dashed: ShaderLibShader;
+    depth: ShaderLibShader;
+    normal: ShaderLibShader;
+    sprite: ShaderLibShader;
+    background: ShaderLibShader;
+    cube: ShaderLibShader;
+    equirect: ShaderLibShader;
+    distanceRGBA: ShaderLibShader;
+    shadow: ShaderLibShader;
+    physical: ShaderLibShader;
 };

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

@@ -1,7 +1,8 @@
 import { UniformsGroup } from '../../core/UniformsGroup.js';
+import { IUniform } from './UniformsLib.js';
 
-export function cloneUniforms(uniforms_src: any): any;
-export function mergeUniforms(uniforms: any): any;
+export function cloneUniforms<T extends { [uniform: string]: IUniform }>(uniformsSrc: T): T;
+export function mergeUniforms(uniforms: Array<{ [uniform: string]: IUniform }>): { [uniform: string]: IUniform };
 
 export function cloneUniformsGroups(src: UniformsGroup[]): UniformsGroup[];
 

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

@@ -12,6 +12,7 @@ export class WebGLAttributes {
               type: number;
               bytesPerElement: number;
               version: number;
+              size: number;
           }
         | undefined;
 

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

@@ -2,10 +2,10 @@ import { WebGLExtensions } from './WebGLExtensions.js';
 import { WebGLAttributes } from './WebGLAttributes.js';
 import { WebGLProgram } from './WebGLProgram.js';
 import { WebGLCapabilities } from './WebGLCapabilities.js';
-import { Object3D } from './../../core/Object3D.js';
-import { BufferGeometry } from './../../core/BufferGeometry.js';
-import { BufferAttribute } from './../../core/BufferAttribute.js';
-import { Material } from './../../materials/Material.js';
+import { Object3D } from '../../core/Object3D.js';
+import { BufferGeometry } from '../../core/BufferGeometry.js';
+import { BufferAttribute } from '../../core/BufferAttribute.js';
+import { Material } from '../../materials/Material.js';
 
 export class WebGLBindingStates {
     constructor(

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

@@ -11,7 +11,8 @@ export class WebGLBufferRenderer {
         capabilities: WebGLCapabilities,
     );
 
-    setMode(value: any): void;
-    render(start: any, count: number): void;
-    renderInstances(start: any, count: number, primcount: number): void;
+    setMode: (value: any) => void;
+    render: (start: any, count: number) => void;
+    renderInstances: (start: any, count: number, primcount: number) => void;
+    renderMultiDraw: (starts: Int32Array, counts: Int32Array, drawCount: number) => void;
 }

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

@@ -1,5 +1,5 @@
-import { Camera } from './../../cameras/Camera.js';
-import { Material } from './../../materials/Material.js';
+import { Camera } from '../../cameras/Camera.js';
+import { Material } from '../../materials/Material.js';
 import { Plane } from '../../math/Plane.js';
 import { WebGLProperties } from './WebGLProperties.js';
 

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

@@ -1,8 +1,9 @@
 export class WebGLIndexedBufferRenderer {
     constructor(gl: WebGLRenderingContext, extensions: any, info: any, capabilities: any);
 
-    setMode(value: any): void;
-    setIndex(index: any): void;
-    render(start: any, count: number): void;
-    renderInstances(start: any, count: number, primcount: number): void;
+    setMode: (value: any) => void;
+    setIndex: (index: any) => void;
+    render: (start: any, count: number) => void;
+    renderInstances: (start: any, count: number, primcount: number) => void;
+    renderMultiDraw: (starts: Int32Array, counts: Int32Array, drawCount: number) => void;
 }

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

@@ -1,47 +1,49 @@
 import { WebGLExtensions } from './WebGLExtensions.js';
 import { WebGLCapabilities } from './WebGLCapabilities.js';
 
-export class WebGLLights {
-    constructor(extensions: WebGLExtensions, capabilities: WebGLCapabilities);
+export interface WebGLLightsState {
+    version: number;
+
+    hash: {
+        directionalLength: number;
+        pointLength: number;
+        spotLength: number;
+        rectAreaLength: number;
+        hemiLength: number;
+
+        numDirectionalShadows: number;
+        numPointShadows: number;
+        numSpotShadows: number;
+        numSpotMaps: number;
 
-    state: {
-        version: number;
-
-        hash: {
-            directionalLength: number;
-            pointLength: number;
-            spotLength: number;
-            rectAreaLength: number;
-            hemiLength: number;
-
-            numDirectionalShadows: number;
-            numPointShadows: number;
-            numSpotShadows: number;
-            numSpotMaps: number;
-
-            numLightProbes: number;
-        };
-
-        ambient: number[];
-        probe: any[];
-        directional: any[];
-        directionalShadow: any[];
-        directionalShadowMap: any[];
-        directionalShadowMatrix: any[];
-        spot: any[];
-        spotShadow: any[];
-        spotShadowMap: any[];
-        spotShadowMatrix: any[];
-        rectArea: any[];
-        point: any[];
-        pointShadow: any[];
-        pointShadowMap: any[];
-        pointShadowMatrix: any[];
-        hemi: any[];
-        numSpotLightShadowsWithMaps: number;
         numLightProbes: number;
     };
 
+    ambient: number[];
+    probe: any[];
+    directional: any[];
+    directionalShadow: any[];
+    directionalShadowMap: any[];
+    directionalShadowMatrix: any[];
+    spot: any[];
+    spotShadow: any[];
+    spotShadowMap: any[];
+    spotShadowMatrix: any[];
+    rectArea: any[];
+    point: any[];
+    pointShadow: any[];
+    pointShadowMap: any[];
+    pointShadowMatrix: any[];
+    hemi: any[];
+    numSpotLightShadowsWithMaps: number;
+    numLightProbes: number;
+}
+
+export class WebGLLights {
+    constructor(extensions: WebGLExtensions, capabilities: WebGLCapabilities);
+
+    state: WebGLLightsState;
+
     get(light: any): any;
     setup(lights: any): void;
     setupView(lights: any, camera: any): void;