@types/three 0.150.2 → 0.152.0

three/src/math/Vector3.d.ts

@@ -2,12 +2,13 @@ import { Euler } from './Euler';
 import { Matrix3 } from './Matrix3';
 import { Matrix4 } from './Matrix4';
 import { Quaternion } from './Quaternion';
-import { Camera } from './../cameras/Camera';
+import { Camera } from '../cameras/Camera';
 import { Spherical } from './Spherical';
 import { Cylindrical } from './Cylindrical';
-import { BufferAttribute } from './../core/BufferAttribute';
-import { InterleavedBufferAttribute } from './../core/InterleavedBufferAttribute';
+import { BufferAttribute } from '../core/BufferAttribute';
+import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute';
 import { Vector } from './Vector2';
+import { Color } from './Color';
 
 export type Vector3Tuple = [number, number, number];
 
@@ -68,6 +69,12 @@ export class Vector3 implements Vector {
 
     setComponent(index: number, value: number): this;
 
+    /**
+     * Sets this vector's {@link x}, {@link y} and {@link z} components from the r, g, and b components of the specified
+     * {@link Color | color}.
+     */
+    setFromColor(color: Color): this;
+
     getComponent(index: number): number;
 
     /**

three/src/objects/InstancedMesh.d.ts

@@ -39,23 +39,19 @@ export class InstancedMesh<
      */
     readonly isInstancedMesh: true;
 
-    /////////////////////////////////////////////////
-    // FUTURE - r151
-    /////////////////////////////////////////////////
-    // /**
-    //  * This bounding box encloses all instances of the {@link InstancedMesh},, which can be calculated with {@link computeBoundingBox | .computeBoundingBox()}.
-    //  * @remarks Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
-    //  * @defaultValue `null`
-    //  */
-    // boundingBox: Box3 | null;
+    /**
+     * This bounding box encloses all instances of the {@link InstancedMesh},, which can be calculated with {@link computeBoundingBox | .computeBoundingBox()}.
+     * @remarks Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+     * @defaultValue `null`
+     */
+    boundingBox: Box3 | null;
 
-    // /**
-    //  * This bounding sphere encloses all instances of the {@link InstancedMesh}, which can be calculated with {@link computeBoundingSphere | .computeBoundingSphere()}.
-    //  * @remarks bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
-    //  * @defaultValue `null`
-    //  */
-    // boundingSphere: Sphere | null;
-    /////////////////////////////////////////////////
+    /**
+     * This bounding sphere encloses all instances of the {@link InstancedMesh}, which can be calculated with {@link computeBoundingSphere | .computeBoundingSphere()}.
+     * @remarks bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+     * @defaultValue `null`
+     */
+    boundingSphere: Sphere | null;
 
     /**
      * The number of instances.
@@ -80,21 +76,17 @@ export class InstancedMesh<
      */
     instanceMatrix: InstancedBufferAttribute;
 
-    /////////////////////////////////////////////////
-    // FUTURE - r151
-    /////////////////////////////////////////////////
-    // /**
-    //  * Computes bounding box of the all instances, updating {@link boundingBox | .boundingBox} attribute.
-    //  * @remarks Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
-    //  */
-    // computeBoundingBox(): void;
+    /**
+     * Computes bounding box of the all instances, updating {@link boundingBox | .boundingBox} attribute.
+     * @remarks Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+     */
+    computeBoundingBox(): void;
 
-    // /**
-    //  * Computes bounding sphere of the all instances, updating {@link boundingSphere | .boundingSphere} attribute.
-    //  * @remarks bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
-    //  */
-    // computeBoundingSphere(): void;
-    /////////////////////////////////////////////////
+    /**
+     * Computes bounding sphere of the all instances, updating {@link boundingSphere | .boundingSphere} attribute.
+     * @remarks bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`.
+     */
+    computeBoundingSphere(): void;
 
     /**
      * Get the color of the defined instance.

three/src/objects/LineSegments.d.ts

@@ -30,6 +30,8 @@ export class LineSegments<
     readonly isLineSegments: true;
 
     /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
      * @override
      * @defaultValue `LineSegments`
      */

three/src/objects/Points.d.ts

@@ -1,8 +1,9 @@
-import { Material } from './../materials/Material';
-import { Raycaster } from './../core/Raycaster';
-import { Object3D } from './../core/Object3D';
-import { BufferGeometry } from '../core/BufferGeometry';
-import { Intersection } from '../core/Raycaster';
+import { Material } from '../materials/Material';
+import { Object3D } from '../core/Object3D';
+import { BufferGeometry, NormalOrGLBufferAttributes } from '../core/BufferGeometry';
+import { BufferAttribute } from '../core/BufferAttribute';
+import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute';
+import { GLBufferAttribute } from '../core/GLBufferAttribute';
 
 /**
  * A class for displaying {@link Points}
@@ -12,7 +13,7 @@ import { Intersection } from '../core/Raycaster';
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/Points.js | Source}
  */
 export class Points<
-    TGeometry extends BufferGeometry = BufferGeometry,
+    TGeometry extends BufferGeometry<NormalOrGLBufferAttributes> = BufferGeometry,
     TMaterial extends Material | Material[] = Material | Material[],
 > extends Object3D {
     /**

three/src/objects/Skeleton.d.ts

@@ -32,7 +32,7 @@ export class Skeleton {
      * @param bones The array of {@link THREE.Bone | bones}. Default `[]`.
      * @param boneInverses An array of {@link THREE.Matrix4 | Matrix4s}. Default `[]`.
      */
-    constructor(bones: Bone[], boneInverses?: Matrix4[]);
+    constructor(bones?: Bone[], boneInverses?: Matrix4[]);
 
     /**
      * {@link http://en.wikipedia.org/wiki/Universally_unique_identifier | UUID} of this object instance.
@@ -112,4 +112,8 @@ export class Skeleton {
      * Call this method whenever this instance is no longer used in your app.
      */
     dispose(): void;
+
+    toJSON(): unknown;
+
+    fromJSON(json: unknown, bones: Record<string, Bone>): void;
 }

three/src/objects/SkinnedMesh.d.ts

@@ -1,9 +1,11 @@
 import { Material } from './../materials/Material';
+import { Box3 } from '../math/Box3';
 import { Matrix4 } from './../math/Matrix4';
 import { Vector3 } from './../math/Vector3';
 import { Skeleton } from './Skeleton';
 import { Mesh } from './Mesh';
 import { BufferGeometry } from '../core/BufferGeometry';
+import { Sphere } from '../math/Sphere';
 
 /**
  * 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.
@@ -86,6 +88,18 @@ export class SkinnedMesh<
      */
     bindMatrixInverse: Matrix4;
 
+    /**
+     * The bounding box of the SkinnedMesh. Can be calculated with {@link computeBoundingBox | .computeBoundingBox()}.
+     * @default `null`
+     */
+    boundingBox: Box3;
+
+    /**
+     * The bounding box of the SkinnedMesh. Can be calculated with {@link computeBoundingSphere | .computeBoundingSphere()}.
+     * @default `null`
+     */
+    boundingSphere: Sphere;
+
     /**
      * {@link THREE.Skeleton | Skeleton} representing the bone hierarchy of the skinned mesh.
      */
@@ -100,6 +114,23 @@ export class SkinnedMesh<
      */
     bind(skeleton: Skeleton, bindMatrix?: Matrix4): void;
 
+    /**
+     * Computes the bounding box, updating {@link boundingBox | .boundingBox} attribute.
+     * @remarks
+     * Bounding boxes aren't computed by default. They need to be explicitly computed, otherwise they are `null`. If an
+     * instance of SkinnedMesh is animated, this method should be called per frame to compute a correct bounding box.
+     */
+    computeBoundingBox(): void;
+
+    /**
+     * Computes the bounding sphere, updating {@link boundingSphere | .boundingSphere} attribute.
+     * @remarks
+     * Bounding spheres aren't computed by default. They need to be explicitly computed, otherwise they are `null`. If
+     * an instance of SkinnedMesh is animated, this method should be called per frame to compute a correct bounding
+     * sphere.
+     */
+    computeBoundingSphere(): void;
+
     /**
      * This method sets the skinned mesh in the rest pose (resets the pose).
      */
@@ -110,35 +141,16 @@ export class SkinnedMesh<
      */
     normalizeSkinWeights(): void;
 
-    /////////////////////////////////////////////////
-    // FUTURE - r151
-    /////////////////////////////////////////////////
-    // /**
-    //  * Applies the bone transform associated with the given index to the given position vector
-    //  * @remarks Returns the updated vector.
-    //  * @param index Expects a `Integer`
-    //  * @param vector
-    //  */
-    // applyBoneTransform(index: number, vector: Vector3): Vector3;
-
-    // /**
-    //  * @deprecated {@link THREE.SkinnedMesh}: {@link boneTransform | .boneTransform()} was renamed to {@link applyBoneTransform | .applyBoneTransform()} in **r151**.
-    //  */
-    // boneTransform(index: number, target: Vector3): Vector3;
-    /////////////////////////////////////////////////
-
     /**
-     * Applies the bone transform associated with the given index to the given position vector.
-     * Calculates the position of the vertex at the given index relative to the current bone transformations.
-     * Target vector must be initialized with the vertex coordinates prior to the transformation:
-     * ```typescript
-     * const target = new THREE.Vector3();
-     * target.fromBufferAttribute( mesh.geometry.attributes.position, index );
-     * mesh.boneTransform( index, target );
-     * ```
+     * Applies the bone transform associated with the given index to the given position vector
      * @remarks Returns the updated vector.
      * @param index Expects a `Integer`
      * @param vector
      */
+    applyBoneTransform(index: number, vector: Vector3): Vector3;
+
+    /**
+     * @deprecated {@link THREE.SkinnedMesh}: {@link boneTransform | .boneTransform()} was renamed to {@link applyBoneTransform | .applyBoneTransform()} in **r151**.
+     */
     boneTransform(index: number, target: Vector3): Vector3;
 }

three/src/renderers/WebGLRenderTarget.d.ts

@@ -8,6 +8,7 @@ import {
     TextureEncoding,
     MinificationTextureFilter,
     MagnificationTextureFilter,
+    ColorSpace,
 } from '../constants';
 
 export interface WebGLRenderTargetOptions {
@@ -22,7 +23,9 @@ export interface WebGLRenderTargetOptions {
     stencilBuffer?: boolean | undefined; // false;
     generateMipmaps?: boolean | undefined; // true;
     depthTexture?: DepthTexture | undefined;
+    /** @deprecated Use 'colorSpace' in three.js r152+. */
     encoding?: TextureEncoding | undefined;
+    colorSpace?: ColorSpace | undefined;
 
     /**
      * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.

three/src/renderers/WebGLRenderer.d.ts

@@ -14,7 +14,7 @@ import { WebGLRenderTarget } from './WebGLRenderTarget';
 import { WebGLMultipleRenderTargets } from './WebGLMultipleRenderTargets';
 import { Object3D } from './../core/Object3D';
 import { Material } from './../materials/Material';
-import { ToneMapping, ShadowMapType, CullFace, TextureEncoding } from '../constants';
+import { ToneMapping, ShadowMapType, CullFace, TextureEncoding, ColorSpace } from '../constants';
 import { WebXRManager } from '../renderers/webxr/WebXRManager';
 import { BufferGeometry } from './../core/BufferGeometry';
 import { OffscreenCanvas, Texture } from '../textures/Texture';
@@ -22,6 +22,7 @@ import { Data3DTexture } from '../textures/Data3DTexture';
 import { Vector3 } from '../math/Vector3';
 import { Box3 } from '../math/Box3';
 import { DataArrayTexture } from '../textures/DataArrayTexture';
+import { WebGLProgram } from './webgl/WebGLProgram';
 
 export interface Renderer {
     domElement: HTMLCanvasElement;
@@ -99,6 +100,21 @@ export interface WebGLDebug {
      * Enables error checking and reporting when shader programs are being compiled.
      */
     checkShaderErrors: boolean;
+
+    /**
+     * A callback function that can be used for custom error reporting. The callback receives the WebGL context, an
+     * instance of WebGLProgram as well two instances of WebGLShader representing the vertex and fragment shader.
+     * Assigning a custom function disables the default error reporting.
+     * @default `null`
+     */
+    onShaderError:
+        | ((
+              gl: WebGLRenderingContext,
+              program: WebGLProgram,
+              glVertexShader: WebGLShader,
+              glFragmentShader: WebGLShader,
+          ) => void)
+        | null;
 }
 
 /**
@@ -173,9 +189,17 @@ export class WebGLRenderer implements Renderer {
     /**
      * Default is LinearEncoding.
      * @default THREE.LinearEncoding
+     * @deprecated Use {@link WebGLRenderer.outputColorSpace .outputColorSpace} in three.js r152+.
      */
     outputEncoding: TextureEncoding;
 
+    /**
+     * Color space used for output to HTMLCanvasElement. Supported values are
+     * {@link SRGBColorSpace} and {@link LinearSRGBColorSpace}.
+     * @default THREE.SRGBColorSpace.
+     */
+    outputColorSpace: ColorSpace;
+
     /**
      * @default true
      */

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

@@ -1,15 +1,15 @@
 // Renderers / Shaders /////////////////////////////////////////////////////////////////////
-export let ShaderChunk: {
-    [name: string]: string;
-
+export const ShaderChunk: {
     alphamap_fragment: string;
     alphamap_pars_fragment: string;
     alphatest_fragment: string;
+    alphatest_pars_fragment: string;
     aomap_fragment: string;
     aomap_pars_fragment: string;
     begin_vertex: string;
     beginnormal_vertex: string;
     bsdfs: string;
+    iridescence_fragment: string;
     bumpmap_pars_fragment: string;
     clipping_planes_fragment: string;
     clipping_planes_pars_fragment: string;
@@ -20,37 +20,32 @@ export let ShaderChunk: {
     color_pars_vertex: string;
     color_vertex: string;
     common: string;
-    cube_frag: string;
-    cube_vert: string;
     cube_uv_reflection_fragment: string;
     defaultnormal_vertex: string;
-    depth_frag: string;
-    depth_vert: string;
-    distanceRGBA_frag: string;
-    distanceRGBA_vert: string;
-    displacementmap_vertex: string;
     displacementmap_pars_vertex: string;
+    displacementmap_vertex: string;
     emissivemap_fragment: string;
     emissivemap_pars_fragment: string;
-    encodings_pars_fragment: string;
     encodings_fragment: string;
+    encodings_pars_fragment: string;
     envmap_fragment: string;
     envmap_common_pars_fragment: string;
     envmap_pars_fragment: string;
     envmap_pars_vertex: string;
+    envmap_physical_pars_fragment: string;
     envmap_vertex: string;
-    equirect_frag: string;
-    equirect_vert: string;
+    fog_vertex: string;
+    fog_pars_vertex: string;
     fog_fragment: string;
     fog_pars_fragment: string;
-    linedashed_frag: string;
-    linedashed_vert: string;
+    gradientmap_pars_fragment: string;
     lightmap_fragment: string;
     lightmap_pars_fragment: string;
-    lights_lambert_vertex: string;
+    lights_lambert_fragment: string;
+    lights_lambert_pars_fragment: string;
     lights_pars_begin: string;
-    envmap_physical_pars_fragment: string;
-    lights_pars_map: string;
+    lights_toon_fragment: string;
+    lights_toon_pars_fragment: string;
     lights_phong_fragment: string;
     lights_phong_pars_fragment: string;
     lights_physical_fragment: string;
@@ -66,36 +61,28 @@ export let ShaderChunk: {
     map_pars_fragment: string;
     map_particle_fragment: string;
     map_particle_pars_fragment: string;
-    meshbasic_frag: string;
-    meshbasic_vert: string;
-    meshlambert_frag: string;
-    meshlambert_vert: string;
-    meshphong_frag: string;
-    meshphong_vert: string;
-    meshphysical_frag: string;
-    meshphysical_vert: string;
     metalnessmap_fragment: string;
     metalnessmap_pars_fragment: string;
+    morphcolor_vertex: string;
     morphnormal_vertex: string;
     morphtarget_pars_vertex: string;
     morphtarget_vertex: string;
-    normal_flip: string;
-    normal_frag: string;
     normal_fragment_begin: string;
     normal_fragment_maps: string;
-    normal_vert: string;
+    normal_pars_fragment: string;
+    normal_pars_vertex: string;
+    normal_vertex: string;
     normalmap_pars_fragment: string;
     clearcoat_normal_fragment_begin: string;
     clearcoat_normal_fragment_maps: string;
     clearcoat_pars_fragment: string;
+    iridescence_pars_fragment: string;
+    output_fragment: string;
     packing: string;
-    points_frag: string;
-    points_vert: string;
-    shadow_frag: string;
-    shadow_vert: string;
-
     premultiplied_alpha_fragment: string;
     project_vertex: string;
+    dithering_fragment: string;
+    dithering_pars_fragment: string;
     roughnessmap_fragment: string;
     roughnessmap_pars_fragment: string;
     shadowmap_pars_fragment: string;
@@ -110,11 +97,45 @@ export let ShaderChunk: {
     specularmap_pars_fragment: string;
     tonemapping_fragment: string;
     tonemapping_pars_fragment: string;
-    uv2_pars_fragment: string;
-    uv2_pars_vertex: string;
-    uv2_vertex: string;
+    transmission_fragment: string;
+    transmission_pars_fragment: string;
     uv_pars_fragment: string;
     uv_pars_vertex: string;
     uv_vertex: string;
     worldpos_vertex: string;
+
+    background_vert: string;
+    background_frag: string;
+    backgroundCube_vert: string;
+    backgroundCube_frag: string;
+    cube_vert: string;
+    cube_frag: string;
+    depth_vert: string;
+    depth_frag: string;
+    distanceRGBA_vert: string;
+    distanceRGBA_frag: string;
+    equirect_vert: string;
+    equirect_frag: string;
+    linedashed_vert: string;
+    linedashed_frag: string;
+    meshbasic_vert: string;
+    meshbasic_frag: string;
+    meshlambert_vert: string;
+    meshlambert_frag: string;
+    meshmatcap_vert: string;
+    meshmatcap_frag: string;
+    meshnormal_vert: string;
+    meshnormal_frag: string;
+    meshphong_vert: string;
+    meshphong_frag: string;
+    meshphysical_vert: string;
+    meshphysical_frag: string;
+    meshtoon_vert: string;
+    meshtoon_frag: string;
+    points_vert: string;
+    points_frag: string;
+    shadow_vert: string;
+    shadow_frag: string;
+    sprite_vert: string;
+    sprite_frag: string;
 };