@types/three 0.160.0 → 0.161.0

three/src/extras/core/Curve.d.ts

@@ -1,4 +1,4 @@
-import { Vector } from '../../math/Vector2.js';
+import { Vector2 } from '../../math/Vector2.js';
 import { Vector3 } from '../../math/Vector3.js';
 
 /**
@@ -25,7 +25,7 @@ import { Vector3 } from '../../math/Vector3.js';
  * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/Curve | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/Curve.js | Source}
  */
-export abstract class Curve<T extends Vector> {
+export abstract class Curve<TVector extends Vector2 | Vector3> {
     protected constructor();
 
     /**
@@ -49,26 +49,26 @@ export abstract class Curve<T extends Vector> {
      * @param t A position on the curve. Must be in the range `[ 0, 1 ]`. Expects a `Float`
      * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created. Default `new T`.
      */
-    getPoint(t: number, optionalTarget?: T): T;
+    getPoint(t: number, optionalTarget?: TVector): TVector;
 
     /**
      * Returns a vector for a given position on the {@link Curve} according to the arc length.
      * @param u A position on the {@link Curve} according to the arc length. Must be in the range `[ 0, 1 ]`. Expects a `Float`
      * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created. Default `new T`.
      */
-    getPointAt(u: number, optionalTarget?: T): T;
+    getPointAt(u: number, optionalTarget?: TVector): TVector;
 
     /**
      * Returns a set of divisions `+1` points using {@link .getPoint | getPoint(t)}.
      * @param divisions Number of pieces to divide the {@link Curve} into. Expects a `Integer`. Default `5`
      */
-    getPoints(divisions?: number): T[];
+    getPoints(divisions?: number): TVector[];
 
     /**
      * Returns a set of divisions `+1` equi-spaced points using {@link .getPointAt | getPointAt(u)}.
      * @param divisions Number of pieces to divide the {@link Curve} into. Expects a `Integer`. Default `5`
      */
-    getSpacedPoints(divisions?: number): T[];
+    getSpacedPoints(divisions?: number): TVector[];
 
     /**
      * Get total {@link Curve} arc length.
@@ -107,14 +107,14 @@ export abstract class Curve<T extends Vector> {
      * @param t A position on the curve. Must be in the range `[ 0, 1 ]`. Expects a `Float`
      * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created.
      */
-    getTangent(t: number, optionalTarget?: T): T;
+    getTangent(t: number, optionalTarget?: TVector): TVector;
 
     /**
      * Returns tangent at a point which is equidistant to the ends of the {@link Curve} from the point given in {@link .getTangent}.
      * @param u A position on the {@link Curve} according to the arc length. Must be in the range `[ 0, 1 ]`. Expects a `Float`
      * @param optionalTarget If specified, the result will be copied into this Vector, otherwise a new Vector will be created.
      */
-    getTangentAt(u: number, optionalTarget?: T): T;
+    getTangentAt(u: number, optionalTarget?: TVector): TVector;
 
     /**
      * Generates the Frenet Frames
@@ -141,7 +141,7 @@ export abstract class Curve<T extends Vector> {
      * Copies another {@link Curve} object to this instance.
      * @param source
      */
-    copy(source: Curve<T>): this;
+    copy(source: Curve<TVector>): this;
 
     /**
      * Returns a JSON object representation of this instance.

three/src/extras/core/CurvePath.d.ts

@@ -1,5 +1,6 @@
 import { Curve } from './Curve.js';
-import { Vector } from '../../math/Vector2.js';
+import { Vector2 } from '../../math/Vector2.js';
+import { Vector3 } from '../../math/Vector3.js';
 
 /**
  * Curved Path - a curve path is simply a array of connected curves, but retains the api of a curve.
@@ -8,7 +9,7 @@ import { Vector } from '../../math/Vector2.js';
  * @see {@link https://threejs.org/docs/index.html#api/en/extras/core/CurvePath | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/core/CurvePath.js | Source}
  */
-export class CurvePath<T extends Vector> extends Curve<T> {
+export class CurvePath<TVector extends Vector2 | Vector3> extends Curve<TVector> {
     /**
      * The constructor take no parameters.
      */
@@ -25,7 +26,7 @@ export class CurvePath<T extends Vector> extends Curve<T> {
      * The array of {@link Curve | Curves}.
      * @defaultValue `[]`
      */
-    curves: Array<Curve<T>>;
+    curves: Array<Curve<TVector>>;
 
     /**
      * Whether or not to automatically close the path.
@@ -37,13 +38,13 @@ export class CurvePath<T extends Vector> extends Curve<T> {
      * Add a curve to the {@link .curves} array.
      * @param curve
      */
-    add(curve: Curve<T>): void;
+    add(curve: Curve<TVector>): void;
     /**
      * Adds a {@link LineCurve | lineCurve} to close the path.
      */
     closePath(): this;
 
-    getPoint(t: number, optionalTarget?: T): T;
+    getPoint(t: number, optionalTarget?: TVector): TVector;
 
     /**
      * Get list of cumulative curve lengths of the curves in the {@link .curves} array.
@@ -58,11 +59,11 @@ export class CurvePath<T extends Vector> extends Curve<T> {
      * For example, for a {@link THREE.LineCurve | LineCurve}, the returned number of points is always just 2.
      * @param divisions Number of pieces to divide the curve into. Expects a `Integer`. Default `12`
      */
-    override getPoints(divisions?: number): T[];
+    override getPoints(divisions?: number): TVector[];
 
     /**
      * Returns a set of divisions `+1` equi-spaced points using {@link .getPointAt | getPointAt(u)}.
      * @param divisions Number of pieces to divide the curve into. Expects a `Integer`. Default `40`
      */
-    override getSpacedPoints(divisions?: number): T[];
+    override getSpacedPoints(divisions?: number): TVector[];
 }

three/src/geometries/RingGeometry.d.ts

@@ -21,7 +21,7 @@ export class RingGeometry extends BufferGeometry {
      * @param innerRadius Expects a `Float`. Default `0.5`.
      * @param outerRadius Expects a `Float`. Default `1`.
      * @param thetaSegments Number of segments. A higher number means the ring will be more round. Minimum is 3. Expects a `Integer`. Default `32`.
-     * @param phiSegments Minimum is 1. Expects a `Integer`. Default `1`.
+     * @param phiSegments Number of segments per ring segment. Minimum is `1`. Expects a `Integer`. Default `1`.
      * @param thetaStart Starting angle. Expects a `Float`. Default `0`.
      * @param thetaLength Central angle. Expects a `Float`. Default `Math.PI * 2`.
      */

three/src/materials/Material.d.ts

@@ -91,7 +91,9 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
     alphaTest: number;
 
     /**
-     * Enables alpha to coverage. Can only be used with MSAA-enabled rendering contexts.
+     * 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
+     * alphaTest-clipped edges.
      * @default false
      */
     alphaToCoverage: boolean;

three/src/materials/ShaderMaterial.d.ts

@@ -92,7 +92,14 @@ export class ShaderMaterial extends Material {
     derivatives: any;
 
     /**
-     * @default { derivatives: false, fragDepth: false, drawBuffers: false, shaderTextureLOD: false, clipCullDistance: false }
+     * @default {
+     *   derivatives: false,
+     *   fragDepth: false,
+     *   drawBuffers: false,
+     *   shaderTextureLOD: false,
+     *   clipCullDistance: false,
+     *   multiDraw: false
+     * }
      */
     extensions: {
         derivatives: boolean;
@@ -100,6 +107,7 @@ export class ShaderMaterial extends Material {
         drawBuffers: boolean;
         shaderTextureLOD: boolean;
         clipCullDistance: boolean;
+        multiDraw: boolean;
     };
 
     /**

three/src/math/Color.d.ts

@@ -255,7 +255,7 @@ export class Color {
      * Copies given color.
      * @param color Color to copy.
      */
-    copy(color: Color): this;
+    copy(color: this): this;
 
     /**
      * Copies given color making conversion from sRGB to linear space.

three/src/math/Quaternion.d.ts

@@ -1,9 +1,16 @@
 import { Euler } from './Euler.js';
-import { Vector3 } from './Vector3.js';
+import { Vector3, Vector3Like } from './Vector3.js';
 import { Matrix4 } from './Matrix4.js';
 import { BufferAttribute } from '../core/BufferAttribute.js';
 import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute.js';
 
+export interface QuaternionLike {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly w: number;
+}
+
 /**
  * Implementation of a quaternion. This is used for rotating things without incurring in the dreaded gimbal lock issue, amongst other advantages.
  *
@@ -46,7 +53,7 @@ export class Quaternion {
     /**
      * Sets values of this quaternion.
      */
-    set(x: number, y: number, z: number, w: number): Quaternion;
+    set(x: number, y: number, z: number, w: number): this;
 
     /**
      * Clones this quaternion.
@@ -56,36 +63,36 @@ export class Quaternion {
     /**
      * Copies values of q to this quaternion.
      */
-    copy(q: Quaternion): this;
+    copy(q: QuaternionLike): this;
 
     /**
      * Sets this quaternion from rotation specified by Euler angles.
      */
-    setFromEuler(euler: Euler, update?: boolean): Quaternion;
+    setFromEuler(euler: Euler, update?: boolean): this;
 
     /**
      * Sets this quaternion from rotation specified by axis and angle.
      * Adapted from http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm.
      * Axis have to be normalized, angle is in radians.
      */
-    setFromAxisAngle(axis: Vector3, angle: number): Quaternion;
+    setFromAxisAngle(axis: Vector3Like, angle: number): this;
 
     /**
      * Sets this quaternion from rotation component of m. Adapted from http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm.
      */
-    setFromRotationMatrix(m: Matrix4): Quaternion;
-    setFromUnitVectors(vFrom: Vector3, vTo: Vector3): Quaternion;
+    setFromRotationMatrix(m: Matrix4): this;
+    setFromUnitVectors(vFrom: Vector3, vTo: Vector3Like): this;
     angleTo(q: Quaternion): number;
-    rotateTowards(q: Quaternion, step: number): Quaternion;
+    rotateTowards(q: Quaternion, step: number): this;
 
-    identity(): Quaternion;
+    identity(): this;
 
     /**
      * Inverts this quaternion.
      */
-    invert(): Quaternion;
+    invert(): this;
 
-    conjugate(): Quaternion;
+    conjugate(): this;
     dot(v: Quaternion): number;
     lengthSq(): number;
 
@@ -97,22 +104,22 @@ export class Quaternion {
     /**
      * Normalizes this quaternion.
      */
-    normalize(): Quaternion;
+    normalize(): this;
 
     /**
      * Multiplies this quaternion by b.
      */
-    multiply(q: Quaternion): Quaternion;
-    premultiply(q: Quaternion): Quaternion;
+    multiply(q: Quaternion): this;
+    premultiply(q: Quaternion): this;
 
     /**
      * Sets this quaternion to a x b
      * Adapted from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm.
      */
-    multiplyQuaternions(a: Quaternion, b: Quaternion): Quaternion;
+    multiplyQuaternions(a: Quaternion, b: Quaternion): this;
 
-    slerp(qb: Quaternion, t: number): Quaternion;
-    slerpQuaternions(qa: Quaternion, qb: Quaternion, t: number): Quaternion;
+    slerp(qb: Quaternion, t: number): this;
+    slerpQuaternions(qa: Quaternion, qb: Quaternion, t: number): this;
     equals(v: Quaternion): boolean;
 
     /**
@@ -149,9 +156,9 @@ export class Quaternion {
      * @param attribute the source attribute.
      * @param index index in the attribute.
      */
-    fromBufferAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, index: number): Quaternion;
+    fromBufferAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, index: number): this;
 
-    _onChange(callback: () => void): Quaternion;
+    _onChange(callback: () => void): this;
     _onChangeCallback: () => void;
 
     static slerpFlat(
@@ -173,17 +180,7 @@ export class Quaternion {
         stcOffset1: number,
     ): number[];
 
-    /**
-     * @deprecated Use qm.slerpQuaternions( qa, qb, t ) instead..
-     */
-    static slerp(qa: Quaternion, qb: Quaternion, qm: Quaternion, t: number): number;
-
-    /**
-     * @deprecated Use {@link Vector#applyQuaternion vector.applyQuaternion( quaternion )} instead.
-     */
-    multiplyVector3(v: any): any;
-
-    random(): Quaternion;
+    random(): this;
 
     [Symbol.iterator](): Generator<number, void>;
 }

three/src/math/Triangle.d.ts

@@ -40,10 +40,6 @@ export class Triangle {
     getNormal(target: Vector3): Vector3;
     getPlane(target: Plane): Plane;
     getBarycoord(point: Vector3, target: Vector3): Vector3 | null;
-    /**
-     * @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 | null;
     getInterpolation(point: Vector3, v1: Vector3, v2: Vector3, v3: Vector3, target: Vector3): Vector3 | null;
     getInterpolation(point: Vector3, v1: Vector4, v2: Vector4, v3: Vector4, target: Vector4): Vector4 | null;
@@ -56,19 +52,6 @@ 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 | null;
     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,
-        p2: Vector3,
-        p3: Vector3,
-        uv1: Vector2,
-        uv2: Vector2,
-        uv3: Vector2,
-        target: Vector2,
-    ): Vector2;
     static getInterpolation(
         point: Vector3,
         p1: Vector3,

three/src/math/Vector2.d.ts

@@ -3,140 +3,15 @@ import { BufferAttribute } from '../core/BufferAttribute.js';
 
 export type Vector2Tuple = [number, number];
 
-/**
- * ( interface Vector<T> )
- *
- * Abstract interface of {@link https://github.com/mrdoob/three.js/blob/master/src/math/Vector2.js|Vector2},
- * {@link https://github.com/mrdoob/three.js/blob/master/src/math/Vector3.js|Vector3}
- * and {@link https://github.com/mrdoob/three.js/blob/master/src/math/Vector4.js|Vector4}.
- *
- * Currently the members of Vector is NOT type safe because it accepts different typed vectors.
- *
- * Those definitions will be changed when TypeScript innovates Generics to be type safe.
- *
- * @example
- * const v:THREE.Vector = new THREE.Vector3();
- * v.addVectors(new THREE.Vector2(0, 1), new THREE.Vector2(2, 3)); // invalid but compiled successfully
- */
-export interface Vector {
-    setComponent(index: number, value: number): this;
-
-    getComponent(index: number): number;
-
-    set(...args: number[]): this;
-
-    setScalar(scalar: number): this;
-
-    /**
-     * copy(v:T):T;
-     */
-    copy(v: Vector): this;
-
-    /**
-     * NOTE: The second argument is deprecated.
-     *
-     * add(v:T):T;
-     */
-    add(v: Vector): this;
-
-    /**
-     * addVectors(a:T, b:T):T;
-     */
-    addVectors(a: Vector, b: Vector): this;
-
-    addScaledVector(vector: Vector, scale: number): this;
-
-    /**
-     * Adds the scalar value s to this vector's values.
-     */
-    addScalar(scalar: number): this;
-
-    /**
-     * sub(v:T):T;
-     */
-    sub(v: Vector): this;
-
-    /**
-     * subVectors(a:T, b:T):T;
-     */
-    subVectors(a: Vector, b: Vector): this;
-
-    /**
-     * multiplyScalar(s:number):T;
-     */
-    multiplyScalar(s: number): this;
-
-    /**
-     * divideScalar(s:number):T;
-     */
-    divideScalar(s: number): this;
-
-    /**
-     * negate():T;
-     */
-    negate(): this;
-
-    /**
-     * dot(v:T):T;
-     */
-    dot(v: Vector): number;
-
-    /**
-     * lengthSq():number;
-     */
-    lengthSq(): number;
-
-    /**
-     * length():number;
-     */
-    length(): number;
-
-    /**
-     * normalize():T;
-     */
-    normalize(): this;
-
-    /**
-     * NOTE: Vector4 doesn't have the property.
-     *
-     * distanceTo(v:T):number;
-     */
-    distanceTo?(v: Vector): number;
-
-    /**
-     * NOTE: Vector4 doesn't have the property.
-     *
-     * distanceToSquared(v:T):number;
-     */
-    distanceToSquared?(v: Vector): number;
-
-    /**
-     * setLength(l:number):T;
-     */
-    setLength(l: number): this;
-
-    /**
-     * lerp(v:T, alpha:number):T;
-     */
-    lerp(v: Vector, alpha: number): this;
-
-    /**
-     * equals(v:T):boolean;
-     */
-    equals(v: Vector): boolean;
-
-    /**
-     * clone():T;
-     */
-    clone(): Vector;
+export interface Vector2Like {
+    readonly x: number;
+    readonly y: number;
 }
 
 /**
  * 2D vector.
- *
- * ( class Vector2 implements Vector<Vector2> )
  */
-export class Vector2 implements Vector {
+export class Vector2 {
     constructor(x?: number, y?: number);
 
     /**
@@ -190,12 +65,12 @@ export class Vector2 implements Vector {
     /**
      * Copies value of v to this vector.
      */
-    copy(v: Vector2): this;
+    copy(v: Vector2Like): this;
 
     /**
      * Adds v to this vector.
      */
-    add(v: Vector2, w?: Vector2): this;
+    add(v: Vector2Like): this;
 
     /**
      * Adds the scalar value s to this vector's x and y values.
@@ -205,17 +80,17 @@ export class Vector2 implements Vector {
     /**
      * Sets this vector to a + b.
      */
-    addVectors(a: Vector2, b: Vector2): this;
+    addVectors(a: Vector2Like, b: Vector2Like): this;
 
     /**
      * Adds the multiple of v and s to this vector.
      */
-    addScaledVector(v: Vector2, s: number): this;
+    addScaledVector(v: Vector2Like, s: number): this;
 
     /**
      * Subtracts v from this vector.
      */
-    sub(v: Vector2): this;
+    sub(v: Vector2Like): this;
 
     /**
      * Subtracts s from this vector's x and y components.
@@ -225,12 +100,12 @@ export class Vector2 implements Vector {
     /**
      * Sets this vector to a - b.
      */
-    subVectors(a: Vector2, b: Vector2): this;
+    subVectors(a: Vector2Like, b: Vector2Like): this;
 
     /**
      * Multiplies this vector by v.
      */
-    multiply(v: Vector2): this;
+    multiply(v: Vector2Like): this;
 
     /**
      * Multiplies this vector by scalar s.
@@ -240,7 +115,7 @@ export class Vector2 implements Vector {
     /**
      * Divides this vector by v.
      */
-    divide(v: Vector2): this;
+    divide(v: Vector2Like): this;
 
     /**
      * Divides this vector by scalar s.
@@ -256,12 +131,12 @@ export class Vector2 implements Vector {
     /**
      * If this vector's x or y value is greater than v's x or y value, replace that value with the corresponding min value.
      */
-    min(v: Vector2): this;
+    min(v: Vector2Like): this;
 
     /**
      * If this vector's x or y value is less than v's x or y value, replace that value with the corresponding max value.
      */
-    max(v: Vector2): this;
+    max(v: Vector2Like): this;
 
     /**
      * If this vector's x or y value is greater than the max vector's x or y value, it is replaced by the corresponding value.
@@ -269,7 +144,7 @@ export class Vector2 implements Vector {
      * @param min the minimum x and y values.
      * @param max the maximum x and y values in the desired range.
      */
-    clamp(min: Vector2, max: Vector2): this;
+    clamp(min: Vector2Like, max: Vector2Like): this;
 
     /**
      * If this vector's x or y values are greater than the max value, they are replaced by the max value.
@@ -315,12 +190,12 @@ export class Vector2 implements Vector {
     /**
      * Computes dot product of this vector and v.
      */
-    dot(v: Vector2): number;
+    dot(v: Vector2Like): number;
 
     /**
      * Computes cross product of this vector and v.
      */
-    cross(v: Vector2): number;
+    cross(v: Vector2Like): number;
 
     /**
      * Computes squared length of this vector.
@@ -332,11 +207,6 @@ export class Vector2 implements Vector {
      */
     length(): number;
 
-    /**
-     * @deprecated Use {@link Vector2#manhattanLength .manhattanLength()} instead.
-     */
-    lengthManhattan(): number;
-
     /**
      * Computes the Manhattan length of this vector.
      *
@@ -362,24 +232,19 @@ export class Vector2 implements Vector {
     /**
      * Computes distance of this vector to v.
      */
-    distanceTo(v: Vector2): number;
+    distanceTo(v: Vector2Like): number;
 
     /**
      * Computes squared distance of this vector to v.
      */
-    distanceToSquared(v: Vector2): number;
-
-    /**
-     * @deprecated Use {@link Vector2#manhattanDistanceTo .manhattanDistanceTo()} instead.
-     */
-    distanceToManhattan(v: Vector2): number;
+    distanceToSquared(v: Vector2Like): number;
 
     /**
      * Computes the Manhattan length (distance) from this vector to the given vector v
      *
      * see {@link http://en.wikipedia.org/wiki/Taxicab_geometry|Wikipedia: Taxicab Geometry}
      */
-    manhattanDistanceTo(v: Vector2): number;
+    manhattanDistanceTo(v: Vector2Like): number;
 
     /**
      * Normalizes this vector and multiplies it by l.
@@ -391,7 +256,7 @@ export class Vector2 implements Vector {
      * @param v vector to interpolate towards.
      * @param alpha interpolation factor in the closed interval [0, 1].
      */
-    lerp(v: Vector2, alpha: number): this;
+    lerp(v: Vector2Like, alpha: number): this;
 
     /**
      * Sets this vector to be the vector linearly interpolated between v1 and v2 where alpha is the distance along the line connecting the two vectors - alpha = 0 will be v1, and alpha = 1 will be v2.
@@ -399,12 +264,12 @@ export class Vector2 implements Vector {
      * @param v2 vector to interpolate towards.
      * @param alpha interpolation factor in the closed interval [0, 1].
      */
-    lerpVectors(v1: Vector2, v2: Vector2, alpha: number): this;
+    lerpVectors(v1: Vector2Like, v2: Vector2Like, alpha: number): this;
 
     /**
      * Checks for strict equality of this vector and v.
      */
-    equals(v: Vector2): boolean;
+    equals(v: Vector2Like): boolean;
 
     /**
      * Sets this vector's x and y value from the provided array or array-like.
@@ -442,7 +307,7 @@ export class Vector2 implements Vector {
      * @param center the point around which to rotate.
      * @param angle the angle to rotate, in radians.
      */
-    rotateAround(center: Vector2, angle: number): this;
+    rotateAround(center: Vector2Like, angle: number): this;
 
     /**
      * Sets this vector's x and y from Math.random