@types/three 0.150.2 → 0.152.0

three/src/lights/PointLight.d.ts

@@ -3,12 +3,30 @@ import { Light } from './Light';
 import { PointLightShadow } from './PointLightShadow';
 
 /**
+ * A light that gets emitted from a single point in all directions
+ * @remarks
+ * A common use case for this is to replicate the light emitted from a bare lightbulb.
  * @example
- * const light = new THREE.PointLight( 0xff0000, 1, 100 );
- * light.position.set( 50, 50, 50 );
- * scene.add( light );
+ * ```typescript
+ * const light = new THREE.PointLight(0xff0000, 1, 100);
+ * light.position.set(50, 50, 50);
+ * scene.add(light);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_lights_pointlights | lights / pointlights }
+ * @see Example: {@link https://threejs.org/examples/#webgl_effects_anaglyph | effects / anaglyph }
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_text | geometry / text }
+ * @see Example: {@link https://threejs.org/examples/#webgl_lensflares | lensflares }
+ * @see {@link https://threejs.org/docs/index.html#api/en/lights/PointLight | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/PointLight.js | Source}
  */
-export class PointLight extends Light {
+export class PointLight extends Light<PointLightShadow> {
+    /**
+     * Creates a new PointLight.
+     * @param color Hexadecimal color of the light. Default is 0xffffff (white). Expects a `Integer`
+     * @param intensity Numeric value of the light's strength/intensity. Expects a `Float`. Default `1`
+     * @param distance Maximum range of the light. Default is 0 (no limit).
+     * @param decay The amount the light dims along the distance of the light. Expects a `Float`. Default `2`
+     */
     constructor(color?: ColorRepresentation, intensity?: number, distance?: number, decay?: number);
 
     /**
@@ -17,34 +35,61 @@ export class PointLight extends Light {
     type: string;
 
     /**
-     * Light's intensity.
-     * @default 2
+     * The light's intensity.
+     *
+     * When **{@link WebGLRenderer.physicallyCorrectLights | physically correct} mode** — intensity is the luminous intensity of the light measured in candela (cd).
+     * @remarks Changing the intensity will also change the light's power.
+     * @remarks Expects a `Float`
+     * @defaultValue `1`
      */
     intensity: number;
 
     /**
-     * If non-zero, light will attenuate linearly from maximum intensity at light position down to zero at distance.
-     * @default 0
+     * When **Default mode** — When distance is zero, light does not attenuate. When distance is non-zero,
+     * light will attenuate linearly from maximum intensity at the light's position down to zero at this distance from the light.
+     *
+     * When **{@link WebGLRenderer.physicallyCorrectLights | Physically correct} rendering mode** — When distance is zero,
+     * light will attenuate according to inverse-square law to infinite distance.
+     * When distance is non-zero, light will attenuate according to inverse-square law until near the distance cutoff,
+     * where it will then attenuate quickly and smoothly to 0. Inherently, cutoffs are not physically correct.
+     *
+     * @defaultValue `0.0`
+     * @remarks Expects a `Float`
      */
     distance: number;
 
     /**
      * If set to `true` light will cast dynamic shadows.
      * **Warning**: This is expensive and requires tweaking to get shadows looking right.
-     * See the {@link PointLightShadow} for details.
-     * The default is `false`.
+     * @see {@link THREE.PointLightShadow | PointLightShadow} for details.
+     * @defaultValue `false`
      */
     castShadow: boolean;
 
     /**
-     * @default 1
+     * The amount the light dims along the distance of the light.
+     * In **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** — the default value **should not** be changed.
+     * @remarks Expects a `Float`
+     * @defaultValue `2`
      */
     decay: number;
 
     /**
-     * @default new THREE.PointLightShadow()
+     * A {@link THREE.PointLightShadow | PointLightShadow} used to calculate shadows for this light.
+     * The lightShadow's {@link LightShadow.camera | camera} is set to
+     * a {@link THREE.PerspectiveCamera | PerspectiveCamera} with {@link PerspectiveCamera.fov | fov} of 90,
+     * {@link PerspectiveCamera.aspect | aspect} of 1,
+     * {@link PerspectiveCamera.near | near} clipping plane at 0.5
+     * and {@link PerspectiveCamera.far | far} clipping plane at 500.
+     * @defaultValue new THREE.PointLightShadow()
      */
     shadow: PointLightShadow;
 
+    /**
+     * The light's power.
+     * When **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** — power is the luminous power of the light measured in lumens (lm).
+     * @remarks Changing the power will also change the light's intensity.
+     * @remarks Expects a `Float`
+     */
     power: number;
 }

three/src/lights/PointLightShadow.d.ts

@@ -1,6 +1,22 @@
 import { PerspectiveCamera } from './../cameras/PerspectiveCamera';
+import { Light } from './Light';
 import { LightShadow } from './LightShadow';
 
-export class PointLightShadow extends LightShadow {
-    camera: PerspectiveCamera;
+/**
+ * Shadow for {@link THREE.PointLight | PointLight}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/PointLightShadow.js | Source}
+ */
+export class PointLightShadow extends LightShadow<PerspectiveCamera> {
+    /**
+     * Read-only flag to check if a given object is of type {@link PointLightShadow}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isPointLightShadow = true;
+
+    /**
+     * Update the matrices for the camera and shadow, used internally by the renderer.
+     * @param light The light for which the shadow is being rendered.
+     */
+    override updateMatrices(light: Light, viewportIndex?: number): void;
 }

three/src/lights/RectAreaLight.d.ts

@@ -1,30 +1,82 @@
 import { Light } from './Light';
 import { ColorRepresentation } from '../math/Color';
 
-export class RectAreaLight extends Light {
+/**
+ * {@link RectAreaLight} emits light uniformly across the face a rectangular plane
+ * @remarks
+ * This light type can be used to simulate light sources such as bright windows or strip lighting.
+ * Important Notes:
+ *  - There is no shadow support.
+ *  - Only {@link MeshStandardMaterial | MeshStandardMaterial} and {@link MeshPhysicalMaterial | MeshPhysicalMaterial} are supported.
+ *  - You have to include {@link https://threejs.org/examples/jsm/lights/RectAreaLightUniformsLib.js | RectAreaLightUniformsLib} into your scene and call `init()`.
+ * @example
+ * ```typescript
+ * const width = 10;
+ * const height = 10;
+ * const intensity = 1;
+ * const rectLight = new THREE.RectAreaLight(0xffffff, intensity, width, height);
+ * rectLight.position.set(5, 5, 0);
+ * rectLight.lookAt(0, 0, 0);
+ * scene.add(rectLight)
+ * const rectLightHelper = new RectAreaLightHelper(rectLight);
+ * rectLight.add(rectLightHelper);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_lights_rectarealight | WebGL / {@link RectAreaLight} }
+ * @see {@link https://threejs.org/docs/index.html#api/en/lights/RectAreaLight | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/RectAreaLight.js | Source}
+ */
+export class RectAreaLight extends Light<undefined> {
+    /**
+     * Creates a new {@link RectAreaLight}.
+     * @param color Hexadecimal color of the light. Default `0xffffff` _(white)_.
+     * @param intensity The light's intensity, or brightness. Expects a `Float`. Default `1`
+     * @param width Width of the light. Expects a `Float`. Default `10`
+     * @param height Height of the light. Expects a `Float`. Default `10`
+     */
     constructor(color?: ColorRepresentation, intensity?: number, width?: number, height?: number);
 
     /**
-     * @default 'RectAreaLight'
+     * Read-only flag to check if a given object is of type {@link RectAreaLight}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isRectAreaLight: true;
+
+    /**
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `RectAreaLight`
      */
-    type: string;
+    override readonly type: string | 'RectAreaLight';
 
     /**
-     * @default 10
+     * The width of the light.
+     * @remarks Expects a `Float`
+     * @defaultValue `10`
      */
     width: number;
 
     /**
-     * @default 10
+     * The height of the light.
+     * @remarks Expects a `Float`
+     * @defaultValue `10`
      */
     height: number;
 
     /**
-     * @default 1
+     * The light's intensity.
+     * @remarks Changing the intensity will also change the light's power.
+     * In **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** — intensity is the luminance (brightness) of the light measured in nits (cd/m^2).
+     * @remarks Expects a `Float`
+     * @defaultValue `1`
      */
     intensity: number;
 
+    /**
+     * The light's power.
+     * @remarks Changing the power will also change the light's intensity.
+     * In **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** — power is the luminous power of the light measured in lumens (lm).
+     * @remarks Expects a `Float`
+     */
     power: number;
-
-    readonly isRectAreaLight: true;
 }

three/src/lights/SpotLight.d.ts

@@ -6,9 +6,36 @@ import { ColorRepresentation } from '../math/Color';
 import { Texture } from '../textures/Texture';
 
 /**
- * A point light that can cast shadow in one direction.
+ * This light gets emitted from a single point in one direction, along a cone that increases in size the further from the light it gets.
+ * @example
+ * ```typescript
+ * // white {@link SpotLight} shining from the side, modulated by a texture, casting a shadow
+ * const {@link SpotLight} = new THREE.SpotLight(0xffffff);
+ * spotLight.position.set(100, 1000, 100);
+ * spotLight.map = new THREE.TextureLoader().load(url);
+ * spotLight.castShadow = true;
+ * spotLight.shadow.mapSize.width = 1024;
+ * spotLight.shadow.mapSize.height = 1024;
+ * spotLight.shadow.camera.near = 500;
+ * spotLight.shadow.camera.far = 4000;
+ * spotLight.shadow.camera.fov = 30;
+ * scene.add(spotLight);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_lights_spotlight | lights / {@link SpotLight} }
+ * @see Example: {@link https://threejs.org/examples/#webgl_lights_spotlights | lights / spotlights }
+ * @see {@link https://threejs.org/docs/index.html#api/en/lights/SpotLight | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/SpotLight.js | Source}
  */
-export class SpotLight extends Light {
+export class SpotLight extends Light<SpotLightShadow> {
+    /**
+     * Creates a new SpotLight.
+     * @param color Hexadecimal color of the light. Default `0xffffff` _(white)_.
+     * @param intensity Numeric value of the light's strength/intensity. Expects a `Float`. Default `1`.
+     * @param distance Maximum range of the light. Default is 0 (no limit). Expects a `Float`.
+     * @param angle Maximum angle of light dispersion from its direction whose upper bound is Math.PI/2.
+     * @param penumbra Percent of the {@link SpotLight} cone that is attenuated due to penumbra. Takes values between zero and 1. Expects a `Float`. Default `0`.
+     * @param decay The amount the light dims along the distance of the light. Expects a `Float`. Default `2`.
+     */
     constructor(
         color?: ColorRepresentation,
         intensity?: number,
@@ -19,61 +46,119 @@ export class SpotLight extends Light {
     );
 
     /**
-     * @default 'SpotLight'
+     * Read-only flag to check if a given object is of type {@link SpotLight}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
      */
-    type: string;
+    readonly isSpotLight: true;
 
     /**
-     * This is set equal to {@link Object3D.DEFAULT_UP} (0, 1, 0), so that the light shines from the top down.
-     *
-     * @default {@link Object3D.DEFAULT_UP}
+     * A Read-only _string_ to check if `this` object type.
+     * @remarks Sub-classes will update this value.
+     * @defaultValue `SpotLight`
+     */
+    override readonly type: string | 'SpotLight';
+
+    /**
+     * This is set equal to {@link THREE.Object3D.DEFAULT_UP | Object3D.DEFAULT_UP} (0, 1, 0), so that the light shines from the top down.
+     * @defaultValue `{@link Object3D.DEFAULT_UP}`
      */
     position: Vector3;
 
     /**
-     * Spotlight focus points at target.position.
-     * @default new THREE.Object3D()
+     * The {@link SpotLight} points from its {@link SpotLight.position | position} to target.position.
+     * @remarks
+     * **Note**: For the target's position to be changed to anything other than the default,
+     * it must be added to the {@link Scene | scene} using
+     *
+     * ```typescript
+     * scene.add( light.target );
+     * ```
+     *
+     * This is so that the target's {@link Object3D.matrixWorld | matrixWorld} gets automatically updated each frame.
+     * It is also possible to set the target to be another object in the scene (anything with a {@link THREE.Object3D.position | position} property), like so:
+     * ```typescript
+     * const targetObject = new THREE.Object3D();
+     * scene.add(targetObject);
+     * light.target = targetObject;
+     * ```
+     * The {@link SpotLight} will now track the target object.
+     * @defaultValue `new THREE.Object3D()` _The default position of the target is *(0, 0, 0)*._
      */
     target: Object3D;
 
     /**
-     * Light's intensity.
-     * @default 2
+     * If set to `true` light will cast dynamic shadows.
+     * @remarks  **Warning**: This is expensive and requires tweaking to get shadows looking right. the {@link THREE.SpotLightShadow | SpotLightShadow} for details.
+     * @defaultValue `false`
+     */
+    override castShadow: boolean;
+
+    /**
+     * The light's intensity.
+     * @remarks Changing the intensity will also change the light's power.
+     * When **{@link WebGLRenderer.physicallyCorrectLights | Physically correct} rendering mode** — intensity is the luminous intensity of the light measured in candela (cd).
+     * @remarks Expects a `Float`
+     * @defaultValue `1`
      */
     intensity: number;
 
     /**
-     * If non-zero, light will attenuate linearly from maximum intensity at light position down to zero at distance.
-     * @default 0
+     * When **Default mode** — When distance is zero, light does not attenuate. When distance is non-zero,
+     * light will attenuate linearly from maximum intensity at the light's position down to zero at this distance from the light.
+     *
+     * When **{@link WebGLRenderer.physicallyCorrectLights | Physically correct} rendering mode** — When distance is zero,
+     * light will attenuate according to inverse-square law to infinite distance.
+     * When distance is non-zero, light will attenuate according to inverse-square law until near the distance cutoff,
+     * where it will then attenuate quickly and smoothly to `0`. Inherently, cutoffs are not physically correct.
+     * @remarks Expects a `Float`
+     * @defaultValue `0.0`
      */
     distance: number;
 
     /**
      * Maximum extent of the spotlight, in radians, from its direction.
-     * @default Math.PI / 3.
+     * @remarks Should be no more than `Math.PI/2`.
+     * @remarks Expects a `Float`
+     * @defaultValue `Math.PI / 3`
      */
     angle: number;
 
     /**
-     * @default 1
+     * The amount the light dims along the distance of the light.
+     * In **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** — the default value should not be changed.
+     * @remarks Expects a `Float`
+     * @defaultValue `2`
      */
     decay: number;
 
     /**
-     * @default new THREE.SpotLightShadow()
+     * A {@link THREE.SpotLightShadow | SpotLightShadow} used to calculate shadows for this light.
+     * @defaultValue `new THREE.SpotLightShadow()`
      */
     shadow: SpotLightShadow;
+
+    /**
+     * The light's power.
+     * @remarks Changing the power will also change the light's intensity.
+     * In **{@link WebGLRenderer.physicallyCorrectLights | physically correct} rendering mode** —  power is the luminous power of the light measured in lumens (lm).
+     * @remarks Expects a `Float`
+     */
     power: number;
 
     /**
-     * @default 0
+     * Percent of the {@link SpotLight} cone that is attenuated due to penumbra.
+     * @remarks Takes values between zero and 1.
+     * @remarks Expects a `Float`
+     * @defaultValue `0.0`
      */
     penumbra: number;
 
     /**
-     * @default null
+     * A {@link THREE.Texture | Texture} used to modulate the color of the light.
+     * The spot light color is mixed with the _RGB_ value of this texture, with a ratio corresponding to its alpha value.
+     * The cookie-like masking effect is reproduced using pixel values (0, 0, 0, 1-cookie_value).
+     * @remarks **Warning**: {@link SpotLight.map} is disabled if {@link SpotLight.castShadow} is `false`.
      */
     map: Texture | null;
-
-    readonly isSpotLight: true;
 }

three/src/lights/SpotLightShadow.d.ts

@@ -1,12 +1,72 @@
 import { PerspectiveCamera } from './../cameras/PerspectiveCamera';
 import { LightShadow } from './LightShadow';
 
-export class SpotLightShadow extends LightShadow {
-    camera: PerspectiveCamera;
+/**
+ * This is used internally by {@link SpotLight | SpotLights} for calculating shadows.
+ * @example
+ * ```typescript
+ * //Create a WebGLRenderer and turn on shadows in the renderer
+ * const renderer = new THREE.WebGLRenderer();
+ * renderer.shadowMap.enabled = true;
+ * renderer.shadowMap.type = THREE.PCFSoftShadowMap; // default THREE.PCFShadowMap
+ * //Create a SpotLight and turn on shadows for the light
+ * const light = new THREE.SpotLight(0xffffff);
+ * light.castShadow = true; // default false
+ * scene.add(light);
+ * //Set up shadow properties for the light
+ * light.shadow.mapSize.width = 512; // default
+ * light.shadow.mapSize.height = 512; // default
+ * light.shadow.camera.near = 0.5; // default
+ * light.shadow.camera.far = 500; // default
+ * light.shadow.focus = 1; // default
+ * //Create a sphere that cast shadows (but does not receive them)
+ * const sphereGeometry = new THREE.SphereGeometry(5, 32, 32);
+ * const sphereMaterial = new THREE.MeshStandardMaterial({
+ *     color: 0xff0000
+ * });
+ * const sphere = new THREE.Mesh(sphereGeometry, sphereMaterial);
+ * sphere.castShadow = true; //default is false
+ * sphere.receiveShadow = false; //default
+ * scene.add(sphere);
+ * //Create a plane that receives shadows (but does not cast them)
+ * const planeGeometry = new THREE.PlaneGeometry(20, 20, 32, 32);
+ * const planeMaterial = new THREE.MeshStandardMaterial({
+ *     color: 0x00ff00
+ * })
+ * const plane = new THREE.Mesh(planeGeometry, planeMaterial);
+ * plane.receiveShadow = true;
+ * scene.add(plane);
+ * //Create a helper for the shadow camera (optional)
+ * const helper = new THREE.CameraHelper(light.shadow.camera);
+ * scene.add(helper);
+ * ```
+ * @see {@link https://threejs.org/docs/index.html#api/en/lights/shadows/SpotLightShadow | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/lights/SpotLightShadow.js | Source}
+ */
+export class SpotLightShadow extends LightShadow<PerspectiveCamera> {
+    /**
+     * Read-only flag to check if a given object is of type {@link SpotLightShadow}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
     readonly isSpotLightShadow: true;
 
     /**
-     * @default 1
+     * The light's view of the world.
+     * @remarks This is used to generate a depth map of the scene; objects behind other objects from the light's perspective will be in shadow.
+     * @remarks
+     * The {@link THREE.PerspectiveCamera.fov | fov} will track the {@link THREE.SpotLight.angle | angle} property
+     * of the owning {@link SpotLight | SpotLight} via the {@link SpotLightShadow.update | update} method.
+     * Similarly, the {@link THREE.PerspectiveCamera.aspect | aspect} property will track the aspect of the {@link LightShadow.mapSize | mapSize}.
+     * If the {@link SpotLight.distance | distance} property of the light is set, the {@link THREE.PerspectiveCamera.far | far} clipping plane will track that, otherwise it defaults to `500`.
+     * @defaultValue is a {@link THREE.PerspectiveCamera | PerspectiveCamera} with {@link THREE.PerspectiveCamera.near | near} clipping plane at `0.5`.
+     */
+    camera: PerspectiveCamera;
+
+    /**
+     * Used to focus the shadow camera.
+     * @remarks The camera's field of view is set as a percentage of the spotlight's field-of-view. Range is `[0, 1]`. 0`.
+     * @defaultValue `1`
      */
     focus: number;
 }

three/src/materials/LineBasicMaterial.d.ts

@@ -1,5 +1,6 @@
-import { Color, ColorRepresentation } from './../math/Color';
+import { Color, ColorRepresentation } from '../math/Color';
 import { MaterialParameters, Material } from './Material';
+import { Texture } from '../textures/Texture';
 
 export interface LineBasicMaterialParameters extends MaterialParameters {
     color?: ColorRepresentation | undefined;
@@ -43,5 +44,10 @@ export class LineBasicMaterial extends Material {
      */
     linejoin: string;
 
+    /**
+     * Sets the color of the lines using data from a {@link Texture}.
+     */
+    map: Texture | null;
+
     setValues(parameters: LineBasicMaterialParameters): void;
 }

three/src/materials/MeshDistanceMaterial.d.ts

@@ -46,21 +46,6 @@ export class MeshDistanceMaterial extends Material {
      */
     displacementBias: number;
 
-    /**
-     * @default 1000
-     */
-    farDistance: number;
-
-    /**
-     * @default 1
-     */
-    nearDistance: number;
-
-    /**
-     * @default new THREE.Vector3()
-     */
-    referencePosition: Vector3;
-
     /**
      * @default false
      */

three/src/materials/ShaderMaterial.d.ts

@@ -89,7 +89,7 @@ export class ShaderMaterial extends Material {
     };
 
     /**
-     * @default { 'color': [ 1, 1, 1 ], 'uv': [ 0, 0 ], 'uv2': [ 0, 0 ] }
+     * @default { 'color': [ 1, 1, 1 ], 'uv': [ 0, 0 ], 'uv1': [ 0, 0 ] }
      */
     defaultAttributeValues: any;
 

three/src/math/Color.d.ts

@@ -1,7 +1,9 @@
 import { ColorSpace } from '../constants';
+import { Matrix3 } from './Matrix3';
+import { Vector3 } from './Vector3';
 
-import { BufferAttribute } from './../core/BufferAttribute';
-import { InterleavedBufferAttribute } from './../core/InterleavedBufferAttribute';
+import { BufferAttribute } from '../core/BufferAttribute';
+import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute';
 
 export { SRGBToLinear } from './ColorManagement';
 
@@ -203,6 +205,13 @@ export class Color {
     b: number;
 
     set(color: ColorRepresentation): Color;
+
+    /**
+     * Sets this color's {@link r}, {@link g} and {@link b} components from the x, y, and z components of the specified
+     * {@link Vector3 | vector}.
+     */
+    setFromVector3(vector: Vector3): this;
+
     setScalar(scalar: number): Color;
     setHex(hex: number, colorSpace?: ColorSpace): Color;
 
@@ -295,6 +304,12 @@ export class Color {
     add(color: Color): this;
     addColors(color1: Color, color2: Color): this;
     addScalar(s: number): this;
+
+    /**
+     * Applies the transform {@link Matrix3 | m} to this color's RGB components.
+     */
+    applyMatrix3(m: Matrix3): this;
+
     sub(color: Color): this;
     multiply(color: Color): this;
     multiplyScalar(s: number): this;
@@ -326,6 +341,12 @@ export class Color {
      */
     toArray(xyz: ArrayLike<number>, offset?: number): ArrayLike<number>;
 
+    /**
+     * This method defines the serialization result of Color.
+     * @return The color as a hexadecimal value.
+     */
+    toJSON(): number;
+
     fromBufferAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, index: number): this;
 
     [Symbol.iterator](): Generator<number, void>;

three/src/math/Quaternion.d.ts

@@ -138,6 +138,12 @@ export class Quaternion {
      */
     toArray(array: ArrayLike<number>, offset?: number): ArrayLike<number>;
 
+    /**
+     * This method defines the serialization result of Quaternion.
+     * @return The numerical elements of this quaternion in an array of format [x, y, z, w].
+     */
+    toJSON(): [number, number, number, number];
+
     /**
      * Sets x, y, z, w properties of this quaternion from the attribute.
      * @param attribute the source attribute.

three/src/math/Triangle.d.ts

@@ -1,5 +1,6 @@
 import { Vector2 } from './Vector2';
 import { Vector3 } from './Vector3';
+import { Vector4 } from './Vector4';
 import { Plane } from './Plane';
 import { Box3 } from './Box3';
 
@@ -39,7 +40,13 @@ export class Triangle {
     getNormal(target: Vector3): Vector3;
     getPlane(target: Plane): Plane;
     getBarycoord(point: Vector3, target: Vector3): Vector3;
+    /**
+     * @deprecated Triangle.getUV() has been renamed to Triangle.getInterpolation().
+     */
     getUV(point: Vector3, uv1: Vector2, uv2: Vector2, uv3: Vector2, target: Vector2): Vector2;
+    getInterpolation(point: Vector3, v1: Vector2, v2: Vector2, v3: Vector2, target: Vector2): Vector2;
+    getInterpolation(point: Vector3, v1: Vector3, v2: Vector3, v3: Vector3, target: Vector3): Vector3;
+    getInterpolation(point: Vector3, v1: Vector4, v2: Vector4, v3: Vector4, target: Vector4): Vector4;
     containsPoint(point: Vector3): boolean;
     intersectsBox(box: Box3): boolean;
     isFrontFacing(direction: Vector3): boolean;
@@ -49,6 +56,9 @@ export class Triangle {
     static getNormal(a: Vector3, b: Vector3, c: Vector3, target: Vector3): Vector3;
     static getBarycoord(point: Vector3, a: Vector3, b: Vector3, c: Vector3, target: Vector3): Vector3;
     static containsPoint(point: Vector3, a: Vector3, b: Vector3, c: Vector3): boolean;
+    /**
+     * @deprecated THREE.Triangle.getUV() has been renamed to THREE.Triangle.getInterpolation().
+     */
     static getUV(
         point: Vector3,
         p1: Vector3,
@@ -59,5 +69,35 @@ export class Triangle {
         uv3: Vector2,
         target: Vector2,
     ): Vector2;
+    static getInterpolation(
+        point: Vector3,
+        p1: Vector3,
+        p2: Vector3,
+        p3: Vector3,
+        v1: Vector2,
+        v2: Vector2,
+        v3: Vector2,
+        target: Vector2,
+    ): Vector2;
+    static getInterpolation(
+        point: Vector3,
+        p1: Vector3,
+        p2: Vector3,
+        p3: Vector3,
+        v1: Vector3,
+        v2: Vector3,
+        v3: Vector3,
+        target: Vector3,
+    ): Vector3;
+    static getInterpolation(
+        point: Vector3,
+        p1: Vector3,
+        p2: Vector3,
+        p3: Vector3,
+        v1: Vector4,
+        v2: Vector4,
+        v3: Vector4,
+        target: Vector4,
+    ): Vector4;
     static isFrontFacing(a: Vector3, b: Vector3, c: Vector3, direction: Vector3): boolean;
 }

three/src/math/Vector2.d.ts

@@ -354,6 +354,11 @@ export class Vector2 implements Vector {
      */
     angle(): number;
 
+    /**
+     * Returns the angle between this vector and vector {@link Vector2 | v} in radians.
+     */
+    angleTo(v: Vector2): number;
+
     /**
      * Computes distance of this vector to v.
      */