@types/three 0.152.1 → 0.154.0

three/src/materials/ShadowMaterial.d.ts

@@ -1,5 +1,5 @@
-import { Color, ColorRepresentation } from './../math/Color';
-import { MaterialParameters, Material } from './Material';
+import { Color, ColorRepresentation } from './../math/Color.js';
+import { MaterialParameters, Material } from './Material.js';
 
 export interface ShadowMaterialParameters extends MaterialParameters {
     color?: ColorRepresentation | undefined;

three/src/materials/SpriteMaterial.d.ts

@@ -1,6 +1,6 @@
-import { Color, ColorRepresentation } from './../math/Color';
-import { Texture } from './../textures/Texture';
-import { MaterialParameters, Material } from './Material';
+import { Color, ColorRepresentation } from './../math/Color.js';
+import { Texture } from './../textures/Texture.js';
+import { MaterialParameters, Material } from './Material.js';
 
 export interface SpriteMaterialParameters extends MaterialParameters {
     color?: ColorRepresentation | undefined;

three/src/math/Box2.d.ts

@@ -1,4 +1,4 @@
-import { Vector2 } from './Vector2';
+import { Vector2 } from './Vector2.js';
 
 // Math //////////////////////////////////////////////////////////////////////////////////
 

three/src/math/Box3.d.ts

@@ -1,10 +1,10 @@
-import { BufferAttribute } from './../core/BufferAttribute';
-import { Vector3 } from './Vector3';
-import { Object3D } from './../core/Object3D';
-import { Sphere } from './Sphere';
-import { Plane } from './Plane';
-import { Matrix4 } from './Matrix4';
-import { Triangle } from './Triangle';
+import { BufferAttribute } from './../core/BufferAttribute.js';
+import { Vector3 } from './Vector3.js';
+import { Object3D } from './../core/Object3D.js';
+import { Sphere } from './Sphere.js';
+import { Plane } from './Plane.js';
+import { Matrix4 } from './Matrix4.js';
+import { Triangle } from './Triangle.js';
 
 export class Box3 {
     constructor(min?: Vector3, max?: Vector3);

three/src/math/Color.d.ts

@@ -1,11 +1,11 @@
-import { ColorSpace } from '../constants';
-import { Matrix3 } from './Matrix3';
-import { Vector3 } from './Vector3';
+import { ColorSpace } from '../constants.js';
+import { Matrix3 } from './Matrix3.js';
+import { Vector3 } from './Vector3.js';
 
-import { BufferAttribute } from '../core/BufferAttribute';
-import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute';
+import { BufferAttribute } from '../core/BufferAttribute.js';
+import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute.js';
 
-export { SRGBToLinear } from './ColorManagement';
+export { SRGBToLinear } from './ColorManagement.js';
 
 declare const _colorKeywords: {
     aliceblue: 0xf0f8ff;
@@ -204,7 +204,8 @@ export class Color {
      */
     b: number;
 
-    set(color: ColorRepresentation): Color;
+    set(color: ColorRepresentation): this;
+    set(r: number, g: number, b: number): this;
 
     /**
      * Sets this color's {@link r}, {@link g} and {@link b} components from the x, y, and z components of the specified

three/src/math/ColorManagement.d.ts

@@ -1,5 +1,5 @@
-import { ColorSpace, DisplayP3ColorSpace, LinearSRGBColorSpace, SRGBColorSpace } from '../constants';
-import { Color } from './Color';
+import { ColorSpace, DisplayP3ColorSpace, LinearSRGBColorSpace, SRGBColorSpace } from '../constants.js';
+import { Color } from './Color.js';
 
 export function SRGBToLinear(c: number): number;
 

three/src/math/Cylindrical.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from './Vector3';
+import { Vector3 } from './Vector3.js';
 
 export class Cylindrical {
     constructor(radius?: number, theta?: number, y?: number);

three/src/math/Euler.d.ts

@@ -1,6 +1,6 @@
-import { Matrix4 } from './Matrix4';
-import { Quaternion } from './Quaternion';
-import { Vector3 } from './Vector3';
+import { Matrix4 } from './Matrix4.js';
+import { Quaternion } from './Quaternion.js';
+import { Vector3 } from './Vector3.js';
 
 export type EulerOrder = 'XYZ' | 'YXZ' | 'ZXY' | 'ZYX' | 'YZX' | 'XZY';
 

three/src/math/Frustum.d.ts

@@ -1,10 +1,11 @@
-import { Plane } from './Plane';
-import { Matrix4 } from './Matrix4';
-import { Object3D } from './../core/Object3D';
-import { Sprite } from './../objects/Sprite';
-import { Sphere } from './Sphere';
-import { Box3 } from './Box3';
-import { Vector3 } from './Vector3';
+import { Plane } from './Plane.js';
+import { Matrix4 } from './Matrix4.js';
+import { Object3D } from './../core/Object3D.js';
+import { Sprite } from './../objects/Sprite.js';
+import { Sphere } from './Sphere.js';
+import { Box3 } from './Box3.js';
+import { Vector3 } from './Vector3.js';
+import { CoordinateSystem } from '../constants.js';
 
 /**
  * Frustums are used to determine what is inside the camera's field of view. They help speed up the rendering process.
@@ -20,7 +21,7 @@ export class Frustum {
     set(p0: Plane, p1: Plane, p2: Plane, p3: Plane, p4: Plane, p5: Plane): Frustum;
     clone(): this;
     copy(frustum: Frustum): this;
-    setFromProjectionMatrix(m: Matrix4): this;
+    setFromProjectionMatrix(m: Matrix4, coordinateSystem?: CoordinateSystem): this;
     intersectsObject(object: Object3D): boolean;
     intersectsSprite(sprite: Sprite): boolean;
     intersectsSphere(sphere: Sphere): boolean;

three/src/math/Line3.d.ts

@@ -1,5 +1,5 @@
-import { Vector3 } from './Vector3';
-import { Matrix4 } from './Matrix4';
+import { Vector3 } from './Vector3.js';
+import { Matrix4 } from './Matrix4.js';
 
 export class Line3 {
     constructor(start?: Vector3, end?: Vector3);

three/src/math/MathUtils.d.ts

@@ -1,10 +1,11 @@
-import { Quaternion } from './Quaternion';
+import { Quaternion } from './Quaternion.js';
 
 /**
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/math/MathUtils.js|src/math/MathUtils.js}
  */
 
 export const DEG2RAD: number;
+
 export const RAD2DEG: number;
 
 export function generateUUID(): string;
@@ -13,10 +14,11 @@ export function generateUUID(): string;
  * Clamps the x to be between a and b.
  *
  * @param value Value to be clamped.
- * @param min Minimum value
+ * @param min Minimum value.
  * @param max Maximum value.
  */
 export function clamp(value: number, min: number, max: number): number;
+
 export function euclideanModulo(n: number, m: number): number;
 
 /**
@@ -30,44 +32,6 @@ export function euclideanModulo(n: number, m: number): number;
  */
 export function mapLinear(x: number, a1: number, a2: number, b1: number, b2: number): number;
 
-export function smoothstep(x: number, min: number, max: number): number;
-
-export function smootherstep(x: number, min: number, max: number): number;
-
-/**
- * Random float from 0 to 1 with 16 bits of randomness.
- * Standard Math.random() creates repetitive patterns when applied over larger space.
- *
- * @deprecated Use {@link Math#random Math.random()}
- */
-export function random16(): number;
-
-/**
- * Random integer from low to high interval.
- */
-export function randInt(low: number, high: number): number;
-
-/**
- * Random float from low to high interval.
- */
-export function randFloat(low: number, high: number): number;
-
-/**
- * Random float from - range / 2 to range / 2 interval.
- */
-export function randFloatSpread(range: number): number;
-
-/**
- * Deterministic pseudo-random float in the interval [ 0, 1 ].
- */
-export function seededRandom(seed?: number): number;
-
-export function degToRad(degrees: number): number;
-
-export function radToDeg(radians: number): number;
-
-export function isPowerOfTwo(value: number): boolean;
-
 export function inverseLerp(x: number, y: number, t: number): number;
 
 /**
@@ -99,18 +63,75 @@ export function damp(x: number, y: number, lambda: number, dt: number): number;
  */
 export function pingpong(x: number, length?: number): number;
 
+export function smoothstep(x: number, min: number, max: number): number;
+
+export function smootherstep(x: number, min: number, max: number): number;
+
 /**
- * @deprecated Use {@link Math#floorPowerOfTwo .floorPowerOfTwo()}
+ * Random integer from low to high interval.
  */
-export function nearestPowerOfTwo(value: number): number;
+export function randInt(low: number, high: number): number;
 
 /**
- * @deprecated Use {@link Math#ceilPowerOfTwo .ceilPowerOfTwo()}
+ * Random float from low to high interval.
  */
-export function nextPowerOfTwo(value: number): number;
+export function randFloat(low: number, high: number): number;
 
-export function floorPowerOfTwo(value: number): number;
+/**
+ * Random float from - range / 2 to range / 2 interval.
+ */
+export function randFloatSpread(range: number): number;
+
+/**
+ * Deterministic pseudo-random float in the interval [ 0, 1 ].
+ */
+export function seededRandom(seed?: number): number;
+
+export function degToRad(degrees: number): number;
+
+export function radToDeg(radians: number): number;
+
+export function isPowerOfTwo(value: number): boolean;
 
 export function ceilPowerOfTwo(value: number): number;
 
+export function floorPowerOfTwo(value: number): number;
+
 export function setQuaternionFromProperEuler(q: Quaternion, a: number, b: number, c: number, order: string): void;
+
+export function denormalize(
+    value: number,
+    array: Float32Array | Uint32Array | Uint16Array | Uint8Array | Int32Array | Int16Array | Int8Array,
+): number;
+
+export function normalize(
+    value: number,
+    array: Float32Array | Uint32Array | Uint16Array | Uint8Array | Int32Array | Int16Array | Int8Array,
+): number;
+
+export const MathUtils: {
+    DEG2RAD: typeof DEG2RAD;
+    RAD2DEG: typeof RAD2DEG;
+    generateUUID: typeof generateUUID;
+    clamp: typeof clamp;
+    euclideanModulo: typeof euclideanModulo;
+    mapLinear: typeof mapLinear;
+    inverseLerp: typeof inverseLerp;
+    lerp: typeof lerp;
+    damp: typeof damp;
+    pingpong: typeof pingpong;
+    smoothstep: typeof smoothstep;
+    smootherstep: typeof smootherstep;
+    randInt: typeof randInt;
+    randFloat: typeof randFloat;
+    randFloatSpread: typeof randFloatSpread;
+    seededRandom: typeof seededRandom;
+    degToRad: typeof degToRad;
+    radToDeg: typeof radToDeg;
+    isPowerOfTwo: typeof isPowerOfTwo;
+    ceilPowerOfTwo: typeof ceilPowerOfTwo;
+    floorPowerOfTwo: typeof floorPowerOfTwo;
+    setQuaternionFromProperEuler: typeof setQuaternionFromProperEuler;
+    normalize: typeof normalize;
+    denormalize: typeof denormalize;
+};

three/src/math/Matrix3.d.ts

@@ -1,7 +1,8 @@
 // https://threejs.org/docs/#api/en/math/Matrix3
 
-import { Matrix4 } from './Matrix4';
-import { Vector3 } from './Vector3';
+import { Matrix4 } from './Matrix4.js';
+import { Vector2 } from './Vector2.js';
+import { Vector3 } from './Vector3.js';
 
 export type Matrix3Tuple = [number, number, number, number, number, number, number, number, number];
 
@@ -55,6 +56,20 @@ export class Matrix3 implements Matrix {
      * Creates an identity matrix.
      */
     constructor();
+    /**
+     * Creates a 3x3 matrix with the given arguments in row-major order.
+     */
+    constructor(
+        n11: number,
+        n12: number,
+        n13: number,
+        n21: number,
+        n22: number,
+        n23: number,
+        n31: number,
+        n32: number,
+        n33: number,
+    );
 
     /**
      * Array with matrix values.
@@ -113,8 +128,8 @@ export class Matrix3 implements Matrix {
      * @param x the amount to translate in the X axis.
      * @param y the amount to translate in the Y axis.
      */
+    makeTranslation(v: Vector2): this;
     makeTranslation(x: number, y: number): this;
-    makeTranslation(x: number, y: number): Matrix3;
 
     /**
      * Sets this matrix as a 2D rotational transformation by theta radians. The resulting matrix will be:

three/src/math/Matrix4.d.ts

@@ -1,7 +1,8 @@
-import { Vector3 } from './Vector3';
-import { Euler } from './Euler';
-import { Quaternion } from './Quaternion';
-import { Matrix, Matrix3 } from './Matrix3';
+import { Vector3 } from './Vector3.js';
+import { Euler } from './Euler.js';
+import { Quaternion } from './Quaternion.js';
+import { Matrix, Matrix3 } from './Matrix3.js';
+import { CoordinateSystem } from '../constants.js';
 
 export type Matrix4Tuple = [
     number,
@@ -41,7 +42,31 @@ export type Matrix4Tuple = [
  * m.multiply( m3 );
  */
 export class Matrix4 implements Matrix {
+    /**
+     * Creates an identity matrix.
+     */
     constructor();
+    /**
+     * Creates a 4x4 matrix with the given arguments in row-major order.
+     */
+    constructor(
+        n11: number,
+        n12: number,
+        n13: number,
+        n14: number,
+        n21: number,
+        n22: number,
+        n23: number,
+        n24: number,
+        n31: number,
+        n32: number,
+        n33: number,
+        n34: number,
+        n41: number,
+        n42: number,
+        n43: number,
+        n44: number,
+    );
 
     /**
      * Array with matrix values.
@@ -147,7 +172,8 @@ export class Matrix4 implements Matrix {
     /**
      * Sets this matrix as translation transform.
      */
-    makeTranslation(x: number, y: number, z: number): Matrix4;
+    makeTranslation(v: Vector3): this;
+    makeTranslation(x: number, y: number, z: number): this;
 
     /**
      * Sets this matrix as rotation transform around x axis by theta radians.
@@ -199,20 +225,31 @@ export class Matrix4 implements Matrix {
      */
     decompose(translation: Vector3, rotation: Quaternion, scale: Vector3): Matrix4;
 
-    /**
-     * Creates a frustum matrix.
-     */
-    makePerspective(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4;
-
     /**
      * Creates a perspective projection matrix.
      */
-    makePerspective(fov: number, aspect: number, near: number, far: number): Matrix4;
+    makePerspective(
+        left: number,
+        right: number,
+        top: number,
+        bottom: number,
+        near: number,
+        far: number,
+        coordinateSystem?: CoordinateSystem,
+    ): Matrix4;
 
     /**
      * Creates an orthographic projection matrix.
      */
-    makeOrthographic(left: number, right: number, top: number, bottom: number, near: number, far: number): Matrix4;
+    makeOrthographic(
+        left: number,
+        right: number,
+        top: number,
+        bottom: number,
+        near: number,
+        far: number,
+        coordinateSystem?: CoordinateSystem,
+    ): Matrix4;
     equals(matrix: Matrix4): boolean;
 
     /**

three/src/math/Plane.d.ts

@@ -1,9 +1,9 @@
-import { Vector3 } from './Vector3';
-import { Sphere } from './Sphere';
-import { Line3 } from './Line3';
-import { Box3 } from './Box3';
-import { Matrix4 } from './Matrix4';
-import { Matrix3 } from './Matrix3';
+import { Vector3 } from './Vector3.js';
+import { Sphere } from './Sphere.js';
+import { Line3 } from './Line3.js';
+import { Box3 } from './Box3.js';
+import { Matrix4 } from './Matrix4.js';
+import { Matrix3 } from './Matrix3.js';
 
 export class Plane {
     constructor(normal?: Vector3, constant?: number);

three/src/math/Quaternion.d.ts

@@ -1,8 +1,8 @@
-import { Euler } from './Euler';
-import { Vector3 } from './Vector3';
-import { Matrix4 } from './Matrix4';
-import { BufferAttribute } from '../core/BufferAttribute';
-import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute';
+import { Euler } from './Euler.js';
+import { Vector3 } from './Vector3.js';
+import { Matrix4 } from './Matrix4.js';
+import { BufferAttribute } from '../core/BufferAttribute.js';
+import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute.js';
 
 /**
  * Implementation of a quaternion. This is used for rotating things without incurring in the dreaded gimbal lock issue, amongst other advantages.

three/src/math/Ray.d.ts

@@ -1,8 +1,8 @@
-import { Vector3 } from './Vector3';
-import { Sphere } from './Sphere';
-import { Plane } from './Plane';
-import { Box3 } from './Box3';
-import { Matrix4 } from './Matrix4';
+import { Vector3 } from './Vector3.js';
+import { Sphere } from './Sphere.js';
+import { Plane } from './Plane.js';
+import { Box3 } from './Box3.js';
+import { Matrix4 } from './Matrix4.js';
 
 export class Ray {
     constructor(origin?: Vector3, direction?: Vector3);

three/src/math/Sphere.d.ts

@@ -1,7 +1,7 @@
-import { Vector3 } from './Vector3';
-import { Box3 } from './Box3';
-import { Plane } from './Plane';
-import { Matrix4 } from './Matrix4';
+import { Vector3 } from './Vector3.js';
+import { Box3 } from './Box3.js';
+import { Plane } from './Plane.js';
+import { Matrix4 } from './Matrix4.js';
 
 export class Sphere {
     constructor(center?: Vector3, radius?: number);

three/src/math/Spherical.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from './Vector3';
+import { Vector3 } from './Vector3.js';
 
 export class Spherical {
     constructor(radius?: number, phi?: number, theta?: number);

three/src/math/SphericalHarmonics3.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from './Vector3';
+import { Vector3 } from './Vector3.js';
 
 export class SphericalHarmonics3 {
     constructor();

three/src/math/Triangle.d.ts

@@ -1,11 +1,11 @@
-import { Vector2 } from './Vector2';
-import { Vector3 } from './Vector3';
-import { Vector4 } from './Vector4';
-import { Plane } from './Plane';
-import { Box3 } from './Box3';
+import { Vector2 } from './Vector2.js';
+import { Vector3 } from './Vector3.js';
+import { Vector4 } from './Vector4.js';
+import { Plane } from './Plane.js';
+import { Box3 } from './Box3.js';
 
-import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute';
-import { BufferAttribute } from '../core/BufferAttribute';
+import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute.js';
+import { BufferAttribute } from '../core/BufferAttribute.js';
 
 export class Triangle {
     constructor(a?: Vector3, b?: Vector3, c?: Vector3);

three/src/math/Vector2.d.ts

@@ -1,5 +1,5 @@
-import { Matrix3 } from './Matrix3';
-import { BufferAttribute } from './../core/BufferAttribute';
+import { Matrix3 } from './Matrix3.js';
+import { BufferAttribute } from './../core/BufferAttribute.js';
 
 export type Vector2Tuple = [number, number];
 
@@ -448,4 +448,9 @@ export class Vector2 implements Vector {
      * Sets this vector's x and y from Math.random
      */
     random(): this;
+
+    /**
+     * Iterating through a Vector2 instance will yield its components (x, y) in the corresponding order.
+     */
+    [Symbol.iterator](): Iterator<number>;
 }

three/src/math/Vector3.d.ts

@@ -1,14 +1,14 @@
-import { Euler } from './Euler';
-import { Matrix3 } from './Matrix3';
-import { Matrix4 } from './Matrix4';
-import { Quaternion } from './Quaternion';
-import { Camera } from '../cameras/Camera';
-import { Spherical } from './Spherical';
-import { Cylindrical } from './Cylindrical';
-import { BufferAttribute } from '../core/BufferAttribute';
-import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute';
-import { Vector } from './Vector2';
-import { Color } from './Color';
+import { Euler } from './Euler.js';
+import { Matrix3 } from './Matrix3.js';
+import { Matrix4 } from './Matrix4.js';
+import { Quaternion } from './Quaternion.js';
+import { Camera } from '../cameras/Camera.js';
+import { Spherical } from './Spherical.js';
+import { Cylindrical } from './Cylindrical.js';
+import { BufferAttribute } from '../core/BufferAttribute.js';
+import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute.js';
+import { Vector } from './Vector2.js';
+import { Color } from './Color.js';
 
 export type Vector3Tuple = [number, number, number];
 
@@ -301,4 +301,9 @@ export class Vector3 implements Vector {
     random(): this;
 
     randomDirection(): this;
+
+    /**
+     * Iterating through a Vector3 instance will yield its components (x, y, z) in the corresponding order.
+     */
+    [Symbol.iterator](): Iterator<number>;
 }

three/src/math/Vector4.d.ts

@@ -1,7 +1,7 @@
-import { Matrix4 } from './Matrix4';
-import { Quaternion } from './Quaternion';
-import { BufferAttribute } from './../core/BufferAttribute';
-import { Vector } from './Vector2';
+import { Matrix4 } from './Matrix4.js';
+import { Quaternion } from './Quaternion.js';
+import { BufferAttribute } from './../core/BufferAttribute.js';
+import { Vector } from './Vector2.js';
 
 export type Vector4Tuple = [number, number, number, number];
 
@@ -220,4 +220,9 @@ export class Vector4 implements Vector {
      * Sets this vector's x, y, z and w from Math.random
      */
     random(): this;
+
+    /**
+     * Iterating through a Vector4 instance will yield its components (x, y, z, w) in the corresponding order.
+     */
+    [Symbol.iterator](): Iterator<number>;
 }

three/src/math/interpolants/CubicInterpolant.d.ts

@@ -1,4 +1,4 @@
-import { Interpolant } from '../Interpolant';
+import { Interpolant } from '../Interpolant.js';
 
 export class CubicInterpolant extends Interpolant {
     constructor(parameterPositions: any, samplesValues: any, sampleSize: number, resultBuffer?: any);

three/src/math/interpolants/DiscreteInterpolant.d.ts

@@ -1,4 +1,4 @@
-import { Interpolant } from '../Interpolant';
+import { Interpolant } from '../Interpolant.js';
 
 export class DiscreteInterpolant extends Interpolant {
     constructor(parameterPositions: any, samplesValues: any, sampleSize: number, resultBuffer?: any);

three/src/math/interpolants/LinearInterpolant.d.ts

@@ -1,4 +1,4 @@
-import { Interpolant } from '../Interpolant';
+import { Interpolant } from '../Interpolant.js';
 
 export class LinearInterpolant extends Interpolant {
     constructor(parameterPositions: any, samplesValues: any, sampleSize: number, resultBuffer?: any);

three/src/math/interpolants/QuaternionLinearInterpolant.d.ts

@@ -1,4 +1,4 @@
-import { Interpolant } from '../Interpolant';
+import { Interpolant } from '../Interpolant.js';
 
 export class QuaternionLinearInterpolant extends Interpolant {
     constructor(parameterPositions: any, samplesValues: any, sampleSize: number, resultBuffer?: any);

three/src/objects/Bone.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from './../core/Object3D';
+import { Object3D } from './../core/Object3D.js';
 
 /**
  * A {@link Bone} which is part of a {@link THREE.Skeleton | Skeleton}

three/src/objects/Group.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from './../core/Object3D';
+import { Object3D } from './../core/Object3D.js';
 
 /**
  * Its purpose is to make working with groups of objects syntactically clearer.