@types/three 0.162.0 → 0.164.0

three/src/core/RenderTarget.d.ts

@@ -16,15 +16,17 @@ export interface RenderTargetOptions {
     wrapT?: Wrapping | undefined;
     magFilter?: MagnificationTextureFilter | undefined;
     minFilter?: MinificationTextureFilter | undefined;
-    generateMipmaps?: boolean | undefined; // true;
-    format?: number | undefined; // RGBAFormat;
-    type?: TextureDataType | undefined; // UnsignedByteType;
-    anisotropy?: number | undefined; // 1;
+    generateMipmaps?: boolean | undefined; // true
+    format?: number | undefined; // RGBAFormat
+    type?: TextureDataType | undefined; // UnsignedByteType
+    anisotropy?: number | undefined; // 1
     colorSpace?: ColorSpace | undefined;
-    internalFormat?: PixelFormatGPU | null | undefined;
-    depthBuffer?: boolean | undefined; // true;
-    stencilBuffer?: boolean | undefined; // false;
-    depthTexture?: DepthTexture | undefined;
+    internalFormat?: PixelFormatGPU | null | undefined; // null
+    depthBuffer?: boolean | undefined; // true
+    stencilBuffer?: boolean | undefined; // false
+    resolveDepthBuffer?: boolean | undefined; // true
+    resolveStencilBuffer?: boolean | undefined; // true
+    depthTexture?: DepthTexture | null | undefined; // null
     /**
      * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.
      * @default 0
@@ -54,14 +56,27 @@ export class RenderTarget<TTexture extends Texture | Texture[] = Texture> extend
     depthBuffer: boolean;
 
     /**
-     * @default true
+     * @default false
      */
     stencilBuffer: boolean;
 
+    /**
+     * Defines whether the depth buffer should be resolved when rendering into a multisampled render target.
+     * @default true
+     */
+    resolveDepthBuffer: boolean;
+
+    /**
+     * Defines whether the stencil buffer should be resolved when rendering into a multisampled render target.
+     * This property has no effect when {@link .resolveDepthBuffer} is set to `false`.
+     * @default true
+     */
+    resolveStencilBuffer: boolean;
+
     /**
      * @default null
      */
-    depthTexture: DepthTexture;
+    depthTexture: DepthTexture | null;
 
     /**
      * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.

three/src/materials/Material.d.ts

@@ -1,3 +1,4 @@
+import { Camera } from "../cameras/Camera.js";
 import {
     Blending,
     BlendingDstFactor,
@@ -9,11 +10,15 @@ import {
     StencilFunc,
     StencilOp,
 } from "../constants.js";
+import { BufferGeometry } from "../core/BufferGeometry.js";
 import { EventDispatcher } from "../core/EventDispatcher.js";
+import { Object3D } from "../core/Object3D.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
 import { Plane } from "../math/Plane.js";
+import { Group } from "../objects/Group.js";
 import { WebGLProgramParametersWithUniforms } from "../renderers/webgl/WebGLPrograms.js";
 import { WebGLRenderer } from "../renderers/WebGLRenderer.js";
+import { Scene } from "../scenes/Scene.js";
 
 export interface MaterialParameters {
     alphaHash?: boolean | undefined;
@@ -84,12 +89,6 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      */
     alphaHash: boolean;
 
-    /**
-     * Sets the alpha value to be used when running an alpha test. Default is 0.
-     * @default 0
-     */
-    alphaTest: number;
-
     /**
      * Enables alpha to coverage. Can only be used with MSAA-enabled rendering contexts (meaning when the renderer was
      * created with *antialias* parameter set to `true`). Enabling this will smooth aliasing on clip plane edges and
@@ -271,13 +270,6 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      */
     name: string;
 
-    /**
-     * Specifies that the material needs to be updated, WebGL wise. Set it to true if you made changes that need to be reflected in WebGL.
-     * This property is automatically set to true when instancing a new material.
-     * @default false
-     */
-    needsUpdate: boolean;
-
     /**
      * Opacity. Default is 1.
      * @default 1
@@ -342,7 +334,8 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
 
     /**
      * Defines whether this material is tone mapped according to the renderer's
-     * {@link WebGLRenderer.toneMapping toneMapping} setting. It is ignored when rendering to a render target.
+     * {@link WebGLRenderer.toneMapping toneMapping} setting. It is ignored when rendering to a render target or using
+     * post processing.
      * @default true
      */
     toneMapped: boolean;
@@ -390,20 +383,27 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
     version: number;
 
     /**
-     * Return a new material with the same parameters as this material.
+     * Gets the alpha value to be used when running an alpha test. Default is 0.
+     * @default 0
      */
-    clone(): this;
+    get alphaTest(): number;
 
     /**
-     * Copy the parameters from the passed material into this material.
-     * @param material
+     * Sets the alpha value to be used when running an alpha test. Default is 0.
+     * @default 0
      */
-    copy(material: Material): this;
+    set alphaTest(value: number);
 
-    /**
-     * This disposes the material. Textures of a material don't get disposed. These needs to be disposed by {@link Texture}.
-     */
-    dispose(): void;
+    onBuild(object: Object3D, parameters: WebGLProgramParametersWithUniforms, renderer: WebGLRenderer): void;
+
+    onBeforeRender(
+        renderer: WebGLRenderer,
+        scene: Scene,
+        camera: Camera,
+        geometry: BufferGeometry,
+        object: Object3D,
+        group: Group,
+    ): void;
 
     /**
      * An optional callback that is executed immediately before the shader program is compiled.
@@ -430,4 +430,27 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      * @param meta Object containing metadata such as textures or images for the material.
      */
     toJSON(meta?: any): any;
+
+    /**
+     * Return a new material with the same parameters as this material.
+     */
+    clone(): this;
+
+    /**
+     * Copy the parameters from the passed material into this material.
+     * @param material
+     */
+    copy(material: Material): this;
+
+    /**
+     * This disposes the material. Textures of a material don't get disposed. These needs to be disposed by {@link Texture}.
+     */
+    dispose(): void;
+
+    /**
+     * Specifies that the material needs to be updated, WebGL wise. Set it to true if you made changes that need to be reflected in WebGL.
+     * This property is automatically set to true when instancing a new material.
+     * @default false
+     */
+    set needsUpdate(value: boolean);
 }

three/src/materials/MeshPhysicalMaterial.d.ts

@@ -4,45 +4,47 @@ import { Texture } from "../textures/Texture.js";
 import { MeshStandardMaterial, MeshStandardMaterialParameters } from "./MeshStandardMaterial.js";
 
 export interface MeshPhysicalMaterialParameters extends MeshStandardMaterialParameters {
-    clearcoat?: number | undefined;
+    anisotropyRotation?: number | undefined;
+    anisotropyMap?: Texture | null | undefined;
+
     clearcoatMap?: Texture | null | undefined;
     clearcoatRoughness?: number | undefined;
     clearcoatRoughnessMap?: Texture | null | undefined;
     clearcoatNormalScale?: Vector2 | undefined;
     clearcoatNormalMap?: Texture | null | undefined;
 
-    reflectivity?: number | undefined;
     ior?: number | undefined;
 
-    sheen?: number | undefined;
+    reflectivity?: number | undefined;
+
+    iridescenceMap?: Texture | null | undefined;
+    iridescenceIOR?: number | undefined;
+    iridescenceThicknessRange?: [number, number] | undefined;
+    iridescenceThicknessMap?: Texture | null | undefined;
+
     sheenColor?: ColorRepresentation | undefined;
     sheenColorMap?: Texture | null | undefined;
     sheenRoughness?: number | undefined;
     sheenRoughnessMap?: Texture | null | undefined;
 
-    transmission?: number | undefined;
     transmissionMap?: Texture | null | undefined;
 
     thickness?: number | undefined;
     thicknessMap?: Texture | null | undefined;
-
     attenuationDistance?: number | undefined;
     attenuationColor?: ColorRepresentation | undefined;
 
     specularIntensity?: number | undefined;
-    specularColor?: ColorRepresentation | undefined;
     specularIntensityMap?: Texture | null | undefined;
+    specularColor?: ColorRepresentation | undefined;
     specularColorMap?: Texture | null | undefined;
 
-    iridescenceMap?: Texture | null | undefined;
-    iridescenceIOR?: number | undefined;
-    iridescence?: number | undefined;
-    iridescenceThicknessRange?: [number, number] | undefined;
-    iridescenceThicknessMap?: Texture | null | undefined;
-
     anisotropy?: number | undefined;
-    anisotropyRotation?: number | undefined;
-    anisotropyMap?: Texture | null | undefined;
+    clearcoat?: number | undefined;
+    iridescence?: number | undefined;
+    dispersion?: number | undefined;
+    sheen?: number | undefined;
+    transmission?: number | undefined;
 }
 
 export class MeshPhysicalMaterial extends MeshStandardMaterial {
@@ -55,20 +57,25 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
      */
     readonly isMeshPhysicalMaterial: true;
 
+    /**
+     * @default { 'STANDARD': '', 'PHYSICAL': '' }
+     */
+    defines: { [key: string]: any };
+
     /**
      * @default 'MeshPhysicalMaterial'
      */
     type: string;
 
     /**
-     * @default { 'STANDARD': '', 'PHYSICAL': '' }
+     * @default 0
      */
-    defines: { [key: string]: any };
+    anisotropyRotation?: number;
 
     /**
-     * @default 0
+     * @default null
      */
-    clearcoat: number;
+    anisotropyMap?: Texture | null;
 
     /**
      * @default null
@@ -95,20 +102,36 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
      */
     clearcoatNormalMap: Texture | null;
 
+    /**
+     * @default 1.5
+     */
+    ior: number;
+
     /**
      * @default 0.5
      */
-    reflectivity: number;
+    get reflectivity(): number;
+    set reflectivity(reflectivity: number);
 
     /**
-     * @default 1.5
+     * @default null
      */
-    ior: number;
+    iridescenceMap: Texture | null;
 
     /**
-     * @default 0.0
+     * @default 1.3
+     */
+    iridescenceIOR: number;
+
+    /**
+     * @default [100, 400]
+     */
+    iridescenceThicknessRange: [number, number];
+
+    /**
+     * @default null
      */
-    sheen: number;
+    iridescenceThicknessMap: Texture | null;
 
     /**
      * @default Color( 0x000000 )
@@ -130,11 +153,6 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
      */
     sheenRoughnessMap: Texture | null;
 
-    /**
-     * @default 0
-     */
-    transmission: number;
-
     /**
      * @default null
      */
@@ -165,58 +183,54 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
      */
     specularIntensity: number;
 
-    /**
-     * @default Color(1, 1, 1)
-     */
-    specularColor: Color;
-
     /**
      * @default null
      */
     specularIntensityMap: Texture | null;
 
     /**
-     * @default null
+     * @default Color(1, 1, 1)
      */
-    specularColorMap: Texture | null;
+    specularColor: Color;
 
     /**
      * @default null
      */
-    iridescenceMap: Texture | null;
-
-    /**
-     * @default 1.3
-     */
-    iridescenceIOR: number;
+    specularColorMap: Texture | null;
 
     /**
      * @default 0
      */
-    iridescence: number;
+    get anisotropy(): number;
+    set anisotropy(value: number);
 
     /**
-     * @default [100, 400]
+     * @default 0
      */
-    iridescenceThicknessRange: [number, number];
+    get clearcoat(): number;
+    set clearcoat(value: number);
 
     /**
-     * @default null
+     * @default 0
      */
-    iridescenceThicknessMap: Texture | null;
+    get iridescence(): number;
+    set iridescence(value: number);
 
     /**
      * @default 0
      */
-    anisotropy?: number;
+    get dispersion(): number;
+    set dispersion(value: number);
 
     /**
-     * @default 0
+     * @default 0.0
      */
-    anisotropyRotation?: number;
+    get sheen(): number;
+    set sheen(value: number);
 
     /**
-     * @default null
+     * @default 0
      */
-    anisotropyMap?: Texture | null;
+    get transmission(): number;
+    set transmission(value: number);
 }

three/src/materials/ShaderMaterial.d.ts

@@ -16,10 +16,8 @@ export interface ShaderMaterialParameters extends MaterialParameters {
     fog?: boolean | undefined;
     extensions?:
         | {
-            derivatives?: boolean | undefined;
-            fragDepth?: boolean | undefined;
-            drawBuffers?: boolean | undefined;
-            shaderTextureLOD?: boolean | undefined;
+            clipCullDistance?: boolean | undefined;
+            multiDraw?: boolean | undefined;
         }
         | undefined;
     glslVersion?: GLSLVersion | undefined;
@@ -86,26 +84,13 @@ export class ShaderMaterial extends Material {
      */
     clipping: boolean;
 
-    /**
-     * @deprecated Use {@link ShaderMaterial#extensions.derivatives extensions.derivatives} instead.
-     */
-    derivatives: any;
-
     /**
      * @default {
-     *   derivatives: false,
-     *   fragDepth: false,
-     *   drawBuffers: false,
-     *   shaderTextureLOD: false,
      *   clipCullDistance: false,
      *   multiDraw: false
      * }
      */
     extensions: {
-        derivatives: boolean;
-        fragDepth: boolean;
-        drawBuffers: boolean;
-        shaderTextureLOD: boolean;
         clipCullDistance: boolean;
         multiDraw: boolean;
     };

three/src/objects/BatchedMesh.d.ts

@@ -157,8 +157,18 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
     setGeometryAt(index: number, geometry: BufferGeometry): number;
 
     /**
-     * Marks the geometry at the given index as deleted and to not be rendered anymore.
+     * 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].
      */
+    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;
 
     getBoundingBoxAt(index: number, target: Box3): Box3 | null;

three/src/objects/InstancedMesh.d.ts

@@ -162,5 +162,5 @@ export class InstancedMesh<
      * @remarks
      * Call this method whenever this instance is no longer used in your app.
      */
-    dispose(): void;
+    dispose(): this;
 }

three/src/objects/SkinnedMesh.d.ts

@@ -11,8 +11,6 @@ import { Skeleton } from "./Skeleton.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.
  * @example
  * ```typescript
  * const geometry = new THREE.CylinderGeometry(5, 5, 5, 5, 15, 5, 30);

three/src/renderers/WebGLRenderer.d.ts

@@ -65,7 +65,7 @@ export interface WebGLRendererParameters {
     antialias?: boolean | undefined;
 
     /**
-     * default is true.
+     * default is false.
      */
     stencil?: boolean | undefined;
 
@@ -177,7 +177,7 @@ export class WebGLRenderer implements Renderer {
     /**
      * @default []
      */
-    clippingPlanes: readonly Plane[];
+    clippingPlanes: Plane[];
 
     /**
      * @default false

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

@@ -42,7 +42,6 @@ export const ShaderChunk: {
     fog_fragment: string;
     fog_pars_fragment: string;
     gradientmap_pars_fragment: string;
-    lightmap_fragment: string;
     lightmap_pars_fragment: string;
     lights_lambert_fragment: string;
     lights_lambert_pars_fragment: string;

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

@@ -1,10 +1,9 @@
 import { BufferAttribute } from "../../core/BufferAttribute.js";
 import { GLBufferAttribute } from "../../core/GLBufferAttribute.js";
 import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
 
 export class WebGLAttributes {
-    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, capabilities: WebGLCapabilities);
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
 
     get(attribute: BufferAttribute | InterleavedBufferAttribute | GLBufferAttribute):
         | {

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

@@ -3,17 +3,10 @@ import { BufferGeometry } from "../../core/BufferGeometry.js";
 import { Object3D } from "../../core/Object3D.js";
 import { Material } from "../../materials/Material.js";
 import { WebGLAttributes } from "./WebGLAttributes.js";
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
-import { WebGLExtensions } from "./WebGLExtensions.js";
 import { WebGLProgram } from "./WebGLProgram.js";
 
 export class WebGLBindingStates {
-    constructor(
-        gl: WebGLRenderingContext,
-        extensions: WebGLExtensions,
-        attributes: WebGLAttributes,
-        capabilities: WebGLCapabilities,
-    );
+    constructor(gl: WebGLRenderingContext, attributes: WebGLAttributes);
 
     setup(
         object: Object3D,

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

@@ -1,5 +1,3 @@
-// Renderers / WebGL /////////////////////////////////////////////////////////////////////
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
 import { WebGLExtensions } from "./WebGLExtensions.js";
 import { WebGLInfo } from "./WebGLInfo.js";
 
@@ -8,11 +6,16 @@ export class WebGLBufferRenderer {
         gl: WebGLRenderingContext,
         extensions: WebGLExtensions,
         info: WebGLInfo,
-        capabilities: WebGLCapabilities,
     );
 
     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;
+    renderMultiDrawInstances: (
+        starts: Int32Array,
+        counts: Int32Array,
+        drawCount: number,
+        primcount: Int32Array,
+    ) => void;
 }

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

@@ -1,3 +1,5 @@
+import { PixelFormat, TextureDataType } from "../../constants.js";
+
 export interface WebGLCapabilitiesParameters {
     precision?: string | undefined;
     logarithmicDepthBuffer?: boolean | undefined;
@@ -7,22 +9,27 @@ export class WebGLCapabilities {
     constructor(gl: WebGLRenderingContext, extensions: any, parameters: WebGLCapabilitiesParameters);
 
     readonly isWebGL2: boolean;
-    readonly drawBuffers: boolean;
+
+    getMaxAnisotropy: () => number;
+    getMaxPrecision: (precision: string) => string;
+
+    textureFormatReadable: (textureFormat: PixelFormat) => boolean;
+    textureTypeReadable: (textureType: TextureDataType) => boolean;
+
     precision: string;
     logarithmicDepthBuffer: boolean;
+
     maxTextures: number;
     maxVertexTextures: number;
     maxTextureSize: number;
     maxCubemapSize: number;
+
     maxAttributes: number;
     maxVertexUniforms: number;
     maxVaryings: number;
     maxFragmentUniforms: number;
+
     vertexTextures: boolean;
-    floatFragmentTextures: boolean;
-    floatVertexTextures: boolean;
-    maxSamples: number;
 
-    getMaxAnisotropy(): number;
-    getMaxPrecision(precision: string): string;
+    maxSamples: number;
 }

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

@@ -1,9 +1,7 @@
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
-
 export class WebGLExtensions {
     constructor(gl: WebGLRenderingContext);
 
     has(name: string): boolean;
-    init(capabilities: WebGLCapabilities): void;
+    init(): void;
     get(name: string): any;
 }

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

@@ -1,9 +1,15 @@
 export class WebGLIndexedBufferRenderer {
-    constructor(gl: WebGLRenderingContext, extensions: any, info: any, capabilities: any);
+    constructor(gl: WebGLRenderingContext, extensions: any, info: any);
 
     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;
+    renderMultiDrawInstances: (
+        starts: Int32Array,
+        counts: Int32Array,
+        drawCount: number,
+        primcount: Int32Array,
+    ) => void;
 }

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

@@ -1,4 +1,3 @@
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
 import { WebGLExtensions } from "./WebGLExtensions.js";
 
 export interface WebGLLightsState {
@@ -40,7 +39,7 @@ export interface WebGLLightsState {
 }
 
 export class WebGLLights {
-    constructor(extensions: WebGLExtensions, capabilities: WebGLCapabilities);
+    constructor(extensions: WebGLExtensions);
 
     state: WebGLLightsState;