@needle-tools/three 0.169.12 → 0.169.14

package/types/src/math/Vector2.d.ts

@@ -0,0 +1,321 @@
+import { BufferAttribute } from "../core/BufferAttribute.js";
+import { Matrix3 } from "./Matrix3.js";
+
+export type Vector2Tuple = [x: number, y: number];
+
+export interface Vector2Like {
+    readonly x: number;
+    readonly y: number;
+}
+
+/**
+ * 2D vector.
+ */
+export class Vector2 {
+    constructor(x?: number, y?: number);
+
+    /**
+     * @default 0
+     */
+    x: number;
+
+    /**
+     * @default 0
+     */
+    y: number;
+    width: number;
+    height: number;
+    readonly isVector2: true;
+
+    /**
+     * Sets value of this vector.
+     */
+    set(x: number, y: number): this;
+
+    /**
+     * Sets the x and y values of this vector both equal to scalar.
+     */
+    setScalar(scalar: number): this;
+
+    /**
+     * Sets X component of this vector.
+     */
+    setX(x: number): this;
+
+    /**
+     * Sets Y component of this vector.
+     */
+    setY(y: number): this;
+
+    /**
+     * Sets a component of this vector.
+     */
+    setComponent(index: number, value: number): this;
+
+    /**
+     * Gets a component of this vector.
+     */
+    getComponent(index: number): number;
+
+    /**
+     * Returns a new Vector2 instance with the same `x` and `y` values.
+     */
+    clone(): this;
+
+    /**
+     * Copies value of v to this vector.
+     */
+    copy(v: Vector2Like): this;
+
+    /**
+     * Adds v to this vector.
+     */
+    add(v: Vector2Like): this;
+
+    /**
+     * Adds the scalar value s to this vector's x and y values.
+     */
+    addScalar(s: number): this;
+
+    /**
+     * Sets this vector to a + b.
+     */
+    addVectors(a: Vector2Like, b: Vector2Like): this;
+
+    /**
+     * Adds the multiple of v and s to this vector.
+     */
+    addScaledVector(v: Vector2Like, s: number): this;
+
+    /**
+     * Subtracts v from this vector.
+     */
+    sub(v: Vector2Like): this;
+
+    /**
+     * Subtracts s from this vector's x and y components.
+     */
+    subScalar(s: number): this;
+
+    /**
+     * Sets this vector to a - b.
+     */
+    subVectors(a: Vector2Like, b: Vector2Like): this;
+
+    /**
+     * Multiplies this vector by v.
+     */
+    multiply(v: Vector2Like): this;
+
+    /**
+     * Multiplies this vector by scalar s.
+     */
+    multiplyScalar(scalar: number): this;
+
+    /**
+     * Divides this vector by v.
+     */
+    divide(v: Vector2Like): this;
+
+    /**
+     * Divides this vector by scalar s.
+     * Set vector to ( 0, 0 ) if s == 0.
+     */
+    divideScalar(s: number): this;
+
+    /**
+     * Multiplies this vector (with an implicit 1 as the 3rd component) by m.
+     */
+    applyMatrix3(m: Matrix3): this;
+
+    /**
+     * 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: 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: 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.
+     * If this vector's x or y value is less than the min vector's x or y value, it is replaced by the corresponding value.
+     * @param min the minimum x and y values.
+     * @param max the maximum x and y values in the desired range.
+     */
+    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.
+     * If this vector's x or y values are less than the min value, they are replaced by the min value.
+     * @param min the minimum value the components will be clamped to.
+     * @param max the maximum value the components will be clamped to.
+     */
+    clampScalar(min: number, max: number): this;
+
+    /**
+     * If this vector's length is greater than the max value, it is replaced by the max value.
+     * If this vector's length is less than the min value, it is replaced by the min value.
+     * @param min the minimum value the length will be clamped to.
+     * @param max the maximum value the length will be clamped to.
+     */
+    clampLength(min: number, max: number): this;
+
+    /**
+     * The components of the vector are rounded down to the nearest integer value.
+     */
+    floor(): this;
+
+    /**
+     * The x and y components of the vector are rounded up to the nearest integer value.
+     */
+    ceil(): this;
+
+    /**
+     * The components of the vector are rounded to the nearest integer value.
+     */
+    round(): this;
+
+    /**
+     * The components of the vector are rounded towards zero (up if negative, down if positive) to an integer value.
+     */
+    roundToZero(): this;
+
+    /**
+     * Inverts this vector.
+     */
+    negate(): this;
+
+    /**
+     * Computes dot product of this vector and v.
+     */
+    dot(v: Vector2Like): number;
+
+    /**
+     * Computes cross product of this vector and v.
+     */
+    cross(v: Vector2Like): number;
+
+    /**
+     * Computes squared length of this vector.
+     */
+    lengthSq(): number;
+
+    /**
+     * Computes length of this vector.
+     */
+    length(): number;
+
+    /**
+     * Computes the Manhattan length of this vector.
+     *
+     * see {@link http://en.wikipedia.org/wiki/Taxicab_geometry|Wikipedia: Taxicab Geometry}
+     */
+    manhattanLength(): number;
+
+    /**
+     * Normalizes this vector.
+     */
+    normalize(): this;
+
+    /**
+     * computes the angle in radians with respect to the positive x-axis
+     */
+    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.
+     */
+    distanceTo(v: Vector2Like): number;
+
+    /**
+     * Computes squared distance of this vector to v.
+     */
+    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: Vector2Like): number;
+
+    /**
+     * Normalizes this vector and multiplies it by l.
+     */
+    setLength(length: number): this;
+
+    /**
+     * Linearly interpolates between this vector and v, where alpha is the distance along the line - alpha = 0 will be this vector, and alpha = 1 will be v.
+     * @param v vector to interpolate towards.
+     * @param alpha interpolation factor in the closed interval [0, 1].
+     */
+    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.
+     * @param v1 the starting vector.
+     * @param v2 vector to interpolate towards.
+     * @param alpha interpolation factor in the closed interval [0, 1].
+     */
+    lerpVectors(v1: Vector2Like, v2: Vector2Like, alpha: number): this;
+
+    /**
+     * Checks for strict equality of this vector and v.
+     */
+    equals(v: Vector2Like): boolean;
+
+    /**
+     * Sets this vector's x and y value from the provided array or array-like.
+     * @param array the source array or array-like.
+     * @param offset (optional) offset into the array. Default is 0.
+     */
+    fromArray(array: number[] | ArrayLike<number>, offset?: number): this;
+
+    /**
+     * Returns an array [x, y], or copies x and y into the provided array.
+     * @param array (optional) array to store the vector to. If this is not provided, a new array will be created.
+     * @param offset (optional) optional offset into the array.
+     * @return The created or provided array.
+     */
+    toArray(array?: number[], offset?: number): number[];
+    toArray(array?: Vector2Tuple, offset?: 0): Vector2Tuple;
+
+    /**
+     * Copies x and y into the provided array-like.
+     * @param array array-like to store the vector to.
+     * @param offset (optional) optional offset into the array.
+     * @return The provided array-like.
+     */
+    toArray(array: ArrayLike<number>, offset?: number): ArrayLike<number>;
+
+    /**
+     * Sets this vector's x and y values from the attribute.
+     * @param attribute the source attribute.
+     * @param index index in the attribute.
+     */
+    fromBufferAttribute(attribute: BufferAttribute, index: number): this;
+
+    /**
+     * Rotates the vector around center by angle radians.
+     * @param center the point around which to rotate.
+     * @param angle the angle to rotate, in radians.
+     */
+    rotateAround(center: Vector2Like, angle: number): this;
+
+    /**
+     * 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>;
+}

package/types/src/math/Vector3.d.ts

@@ -0,0 +1,301 @@
+import { Camera } from "../cameras/Camera.js";
+import { BufferAttribute } from "../core/BufferAttribute.js";
+import { InterleavedBufferAttribute } from "../core/InterleavedBufferAttribute.js";
+import { RGB } from "./Color.js";
+import { Cylindrical } from "./Cylindrical.js";
+import { Euler } from "./Euler.js";
+import { Matrix3 } from "./Matrix3.js";
+import { Matrix4 } from "./Matrix4.js";
+import { QuaternionLike } from "./Quaternion.js";
+import { Spherical } from "./Spherical.js";
+
+export type Vector3Tuple = [number, number, number];
+
+export interface Vector3Like {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
+
+/**
+ * 3D vector.
+ *
+ * see {@link https://github.com/mrdoob/three.js/blob/master/src/math/Vector3.js}
+ *
+ * @example
+ * const a = new THREE.Vector3( 1, 0, 0 );
+ * const b = new THREE.Vector3( 0, 1, 0 );
+ * const c = new THREE.Vector3();
+ * c.crossVectors( a, b );
+ */
+export class Vector3 {
+    constructor(x?: number, y?: number, z?: number);
+
+    /**
+     * @default 0
+     */
+    x: number;
+
+    /**
+     * @default 0
+     */
+    y: number;
+
+    /**
+     * @default 0
+     */
+    z: number;
+    readonly isVector3: true;
+
+    /**
+     * Sets value of this vector.
+     */
+    set(x: number, y: number, z: number): this;
+
+    /**
+     * Sets all values of this vector.
+     */
+    setScalar(scalar: number): this;
+
+    /**
+     * Sets x value of this vector.
+     */
+    setX(x: number): this;
+
+    /**
+     * Sets y value of this vector.
+     */
+    setY(y: number): this;
+
+    /**
+     * Sets z value of this vector.
+     */
+    setZ(z: number): this;
+
+    setComponent(index: number, value: number): this;
+
+    getComponent(index: number): number;
+
+    /**
+     * Clones this vector.
+     */
+    clone(): this;
+
+    /**
+     * Copies value of v to this vector.
+     */
+    copy(v: Vector3Like): this;
+
+    /**
+     * Adds v to this vector.
+     */
+    add(v: Vector3Like): this;
+
+    addScalar(s: number): this;
+
+    /**
+     * Sets this vector to a + b.
+     */
+    addVectors(a: Vector3Like, b: Vector3Like): this;
+
+    addScaledVector(v: Vector3, s: number): this;
+
+    /**
+     * Subtracts v from this vector.
+     */
+    sub(a: Vector3Like): this;
+
+    subScalar(s: number): this;
+
+    /**
+     * Sets this vector to a - b.
+     */
+    subVectors(a: Vector3Like, b: Vector3Like): this;
+
+    multiply(v: Vector3Like): this;
+
+    /**
+     * Multiplies this vector by scalar s.
+     */
+    multiplyScalar(s: number): this;
+
+    multiplyVectors(a: Vector3Like, b: Vector3Like): this;
+
+    applyEuler(euler: Euler): this;
+
+    applyAxisAngle(axis: Vector3, angle: number): this;
+
+    applyMatrix3(m: Matrix3): this;
+
+    applyNormalMatrix(m: Matrix3): this;
+
+    applyMatrix4(m: Matrix4): this;
+
+    applyQuaternion(q: QuaternionLike): this;
+
+    project(camera: Camera): this;
+
+    unproject(camera: Camera): this;
+
+    transformDirection(m: Matrix4): this;
+
+    divide(v: Vector3Like): this;
+
+    /**
+     * Divides this vector by scalar s.
+     * Set vector to ( 0, 0, 0 ) if s == 0.
+     */
+    divideScalar(s: number): this;
+
+    min(v: Vector3Like): this;
+
+    max(v: Vector3Like): this;
+
+    clamp(min: Vector3Like, max: Vector3Like): this;
+
+    clampScalar(min: number, max: number): this;
+
+    clampLength(min: number, max: number): this;
+
+    floor(): this;
+
+    ceil(): this;
+
+    round(): this;
+
+    roundToZero(): this;
+
+    /**
+     * Inverts this vector.
+     */
+    negate(): this;
+
+    /**
+     * Computes dot product of this vector and v.
+     */
+    dot(v: Vector3Like): number;
+
+    /**
+     * Computes squared length of this vector.
+     */
+    lengthSq(): number;
+
+    /**
+     * Computes length of this vector.
+     */
+    length(): number;
+
+    /**
+     * Computes the Manhattan length of this vector.
+     *
+     * see {@link http://en.wikipedia.org/wiki/Taxicab_geometry|Wikipedia: Taxicab Geometry}
+     */
+    manhattanLength(): number;
+
+    /**
+     * Normalizes this vector.
+     */
+    normalize(): this;
+
+    /**
+     * Normalizes this vector and multiplies it by l.
+     */
+    setLength(l: number): this;
+    lerp(v: Vector3Like, alpha: number): this;
+
+    lerpVectors(v1: Vector3Like, v2: Vector3Like, alpha: number): this;
+
+    /**
+     * Sets this vector to cross product of itself and v.
+     */
+    cross(a: Vector3Like): this;
+
+    /**
+     * Sets this vector to cross product of a and b.
+     */
+    crossVectors(a: Vector3Like, b: Vector3Like): this;
+    projectOnVector(v: Vector3): this;
+    projectOnPlane(planeNormal: Vector3): this;
+    reflect(vector: Vector3Like): this;
+    angleTo(v: Vector3): number;
+
+    /**
+     * Computes distance of this vector to v.
+     */
+    distanceTo(v: Vector3Like): number;
+
+    /**
+     * Computes squared distance of this vector to v.
+     */
+    distanceToSquared(v: Vector3Like): 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: Vector3Like): number;
+
+    setFromSpherical(s: Spherical): this;
+    setFromSphericalCoords(r: number, phi: number, theta: number): this;
+    setFromCylindrical(s: Cylindrical): this;
+    setFromCylindricalCoords(radius: number, theta: number, y: number): this;
+    setFromMatrixPosition(m: Matrix4): this;
+    setFromMatrixScale(m: Matrix4): this;
+    setFromMatrixColumn(matrix: Matrix4, index: number): this;
+    setFromMatrix3Column(matrix: Matrix3, index: number): this;
+
+    /**
+     * Sets this vector's {@link x}, {@link y} and {@link z} components from the x, y, and z components of the specified {@link Euler Euler Angle}.
+     */
+    setFromEuler(e: Euler): 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: RGB): this;
+
+    /**
+     * Checks for strict equality of this vector and v.
+     */
+    equals(v: Vector3Like): boolean;
+
+    /**
+     * Sets this vector's x, y and z value from the provided array or array-like.
+     * @param array the source array or array-like.
+     * @param offset (optional) offset into the array. Default is 0.
+     */
+    fromArray(array: number[] | ArrayLike<number>, offset?: number): this;
+
+    /**
+     * Returns an array [x, y, z], or copies x, y and z into the provided array.
+     * @param array (optional) array to store the vector to. If this is not provided, a new array will be created.
+     * @param offset (optional) optional offset into the array.
+     * @return The created or provided array.
+     */
+    toArray(array?: number[], offset?: number): number[];
+    toArray(array?: Vector3Tuple, offset?: 0): Vector3Tuple;
+
+    /**
+     * Copies x, y and z into the provided array-like.
+     * @param array array-like to store the vector to.
+     * @param offset (optional) optional offset into the array-like.
+     * @return The provided array-like.
+     */
+    toArray(array: ArrayLike<number>, offset?: number): ArrayLike<number>;
+
+    fromBufferAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, index: number): this;
+
+    /**
+     * Sets this vector's x, y and z from Math.random
+     */
+    random(): this;
+
+    randomDirection(): this;
+
+    /**
+     * Iterating through a Vector3 instance will yield its components (x, y, z) in the corresponding order.
+     */
+    [Symbol.iterator](): Iterator<number>;
+}