@types/three 0.159.0 → 0.161.0

three/src/materials/ShadowMaterial.d.ts

@@ -9,6 +9,13 @@ export interface ShadowMaterialParameters extends MaterialParameters {
 export class ShadowMaterial extends Material {
     constructor(parameters?: ShadowMaterialParameters);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link ShadowMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isShadowMaterial: true;
+
     /**
      * @default 'ShadowMaterial'
      */

three/src/materials/SpriteMaterial.d.ts

@@ -13,6 +13,13 @@ export interface SpriteMaterialParameters extends MaterialParameters {
 
 export class SpriteMaterial extends Material {
     constructor(parameters?: SpriteMaterialParameters);
+    /**
+     * Read-only flag to check if a given object is of type {@link SpriteMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isSpriteMaterial: true;
+
     /**
      * @default 'SpriteMaterial'
      */
@@ -54,8 +61,6 @@ export class SpriteMaterial extends Material {
      */
     fog: boolean;
 
-    readonly isSpriteMaterial: true;
-
     setValues(parameters: SpriteMaterialParameters): void;
     copy(source: SpriteMaterial): this;
 }

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/Matrix4.d.ts

@@ -94,40 +94,40 @@ export class Matrix4 implements Matrix {
         n42: number,
         n43: number,
         n44: number,
-    ): Matrix4;
+    ): this;
 
     /**
      * Resets this matrix to identity.
      */
-    identity(): Matrix4;
+    identity(): this;
     clone(): Matrix4;
     copy(m: Matrix4): this;
-    copyPosition(m: Matrix4): Matrix4;
-    extractBasis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): Matrix4;
-    makeBasis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): Matrix4;
+    copyPosition(m: Matrix4): this;
+    extractBasis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): this;
+    makeBasis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): this;
 
     /**
      * Copies the rotation component of the supplied matrix m into this matrix rotation component.
      */
-    extractRotation(m: Matrix4): Matrix4;
-    makeRotationFromEuler(euler: Euler): Matrix4;
-    makeRotationFromQuaternion(q: Quaternion): Matrix4;
+    extractRotation(m: Matrix4): this;
+    makeRotationFromEuler(euler: Euler): this;
+    makeRotationFromQuaternion(q: Quaternion): this;
     /**
      * Constructs a rotation matrix, looking from eye towards center with defined up vector.
      */
-    lookAt(eye: Vector3, target: Vector3, up: Vector3): Matrix4;
+    lookAt(eye: Vector3, target: Vector3, up: Vector3): this;
 
     /**
      * Multiplies this matrix by m.
      */
-    multiply(m: Matrix4): Matrix4;
+    multiply(m: Matrix4): this;
 
-    premultiply(m: Matrix4): Matrix4;
+    premultiply(m: Matrix4): this;
 
     /**
      * Sets this matrix to a x b.
      */
-    multiplyMatrices(a: Matrix4, b: Matrix4): Matrix4;
+    multiplyMatrices(a: Matrix4, b: Matrix4): this;
 
     /**
      * Sets this matrix to a x b and stores the result into the flat array r.
@@ -140,7 +140,7 @@ export class Matrix4 implements Matrix {
     /**
      * Multiplies this matrix by s.
      */
-    multiplyScalar(s: number): Matrix4;
+    multiplyScalar(s: number): this;
 
     /**
      * Computes determinant of this matrix.
@@ -151,23 +151,23 @@ export class Matrix4 implements Matrix {
     /**
      * Transposes this matrix.
      */
-    transpose(): Matrix4;
+    transpose(): this;
 
     /**
      * Sets the position component for this matrix from vector v.
      */
-    setPosition(v: Vector3): Matrix4;
-    setPosition(x: number, y: number, z: number): Matrix4;
+    setPosition(v: Vector3): this;
+    setPosition(x: number, y: number, z: number): this;
 
     /**
      * Inverts this matrix.
      */
-    invert(): Matrix4;
+    invert(): this;
 
     /**
      * Multiplies the columns of this matrix by vector v.
      */
-    scale(v: Vector3): Matrix4;
+    scale(v: Vector3): this;
 
     getMaxScaleOnAxis(): number;
     /**
@@ -181,21 +181,21 @@ export class Matrix4 implements Matrix {
      *
      * @param theta Rotation angle in radians.
      */
-    makeRotationX(theta: number): Matrix4;
+    makeRotationX(theta: number): this;
 
     /**
      * Sets this matrix as rotation transform around y axis by theta radians.
      *
      * @param theta Rotation angle in radians.
      */
-    makeRotationY(theta: number): Matrix4;
+    makeRotationY(theta: number): this;
 
     /**
      * Sets this matrix as rotation transform around z axis by theta radians.
      *
      * @param theta Rotation angle in radians.
      */
-    makeRotationZ(theta: number): Matrix4;
+    makeRotationZ(theta: number): this;
 
     /**
      * Sets this matrix as rotation transform around axis by angle radians.
@@ -204,27 +204,27 @@ export class Matrix4 implements Matrix {
      * @param axis Rotation axis.
      * @param theta Rotation angle in radians.
      */
-    makeRotationAxis(axis: Vector3, angle: number): Matrix4;
+    makeRotationAxis(axis: Vector3, angle: number): this;
 
     /**
      * Sets this matrix as scale transform.
      */
-    makeScale(x: number, y: number, z: number): Matrix4;
+    makeScale(x: number, y: number, z: number): this;
 
     /**
      * Sets this matrix as shear transform.
      */
-    makeShear(xy: number, xz: number, yx: number, yz: number, zx: number, zy: number): Matrix4;
+    makeShear(xy: number, xz: number, yx: number, yz: number, zx: number, zy: number): this;
 
     /**
      * Sets this matrix to the transformation composed of translation, rotation and scale.
      */
-    compose(translation: Vector3, rotation: Quaternion, scale: Vector3): Matrix4;
+    compose(translation: Vector3, rotation: Quaternion, scale: Vector3): this;
 
     /**
      * Decomposes this matrix into it's position, quaternion and scale components.
      */
-    decompose(translation: Vector3, rotation: Quaternion, scale: Vector3): Matrix4;
+    decompose(translation: Vector3, rotation: Quaternion, scale: Vector3): this;
 
     /**
      * Creates a perspective projection matrix.
@@ -237,7 +237,7 @@ export class Matrix4 implements Matrix {
         near: number,
         far: number,
         coordinateSystem?: CoordinateSystem,
-    ): Matrix4;
+    ): this;
 
     /**
      * Creates an orthographic projection matrix.
@@ -250,7 +250,7 @@ export class Matrix4 implements Matrix {
         near: number,
         far: number,
         coordinateSystem?: CoordinateSystem,
-    ): Matrix4;
+    ): this;
     equals(matrix: Matrix4): boolean;
 
     /**
@@ -258,7 +258,7 @@ export class Matrix4 implements Matrix {
      * @param array the source array or array-like.
      * @param offset (optional) offset into the array-like. Default is 0.
      */
-    fromArray(array: number[] | ArrayLike<number>, offset?: number): Matrix4;
+    fromArray(array: number[] | ArrayLike<number>, offset?: number): this;
 
     /**
      * Returns an array with the values of this matrix, or copies them into the provided array.
@@ -280,7 +280,7 @@ export class Matrix4 implements Matrix {
     /**
      * Set the upper 3x3 elements of this matrix to the values of the Matrix3 m.
      */
-    setFromMatrix3(m: Matrix3): Matrix4;
+    setFromMatrix3(m: Matrix3): this;
 
     /**
      * @deprecated Use {@link Matrix4#copyPosition .copyPosition()} instead.

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/Sphere.d.ts

@@ -6,6 +6,11 @@ import { Matrix4 } from './Matrix4.js';
 export class Sphere {
     constructor(center?: Vector3, radius?: number);
 
+    /**
+     * Read-only flag to check if a given object is of type {@link Sphere}.
+     */
+    readonly isSphere: true;
+
     /**
      * @default new Vector3()
      */

three/src/math/Triangle.d.ts

@@ -39,14 +39,10 @@ export class Triangle {
     getMidpoint(target: Vector3): Vector3;
     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;
+    getBarycoord(point: Vector3, target: Vector3): Vector3 | null;
+    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;
     containsPoint(point: Vector3): boolean;
     intersectsBox(box: Box3): boolean;
     isFrontFacing(direction: Vector3): boolean;
@@ -54,21 +50,8 @@ export class Triangle {
     equals(triangle: Triangle): boolean;
 
     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 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,
@@ -78,7 +61,7 @@ export class Triangle {
         v2: Vector2,
         v3: Vector2,
         target: Vector2,
-    ): Vector2;
+    ): Vector2 | null;
     static getInterpolation(
         point: Vector3,
         p1: Vector3,
@@ -88,7 +71,7 @@ export class Triangle {
         v2: Vector3,
         v3: Vector3,
         target: Vector3,
-    ): Vector3;
+    ): Vector3 | null;
     static getInterpolation(
         point: Vector3,
         p1: Vector3,
@@ -98,6 +81,6 @@ export class Triangle {
         v2: Vector4,
         v3: Vector4,
         target: Vector4,
-    ): Vector4;
+    ): Vector4 | null;
     static isFrontFacing(a: Vector3, b: Vector3, c: Vector3, direction: Vector3): boolean;
 }