@needle-tools/three 0.169.12 → 0.169.13

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

@@ -0,0 +1,189 @@
+import { BufferAttribute } from "../core/BufferAttribute.js";
+import { InterleavedBufferAttribute } from "../core/InterleavedBufferAttribute.js";
+import { Euler } from "./Euler.js";
+import { Matrix4 } from "./Matrix4.js";
+import { Vector3, Vector3Like } from "./Vector3.js";
+
+export interface QuaternionLike {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly w: number;
+}
+
+export type QuaternionTuple = [x: number, y: number, z: number, w: number];
+
+/**
+ * Implementation of a quaternion. This is used for rotating things without incurring in the dreaded gimbal lock issue, amongst other advantages.
+ *
+ * @example
+ * const quaternion = new THREE.Quaternion();
+ * quaternion.setFromAxisAngle( new THREE.Vector3( 0, 1, 0 ), Math.PI / 2 );
+ * const vector = new THREE.Vector3( 1, 0, 0 );
+ * vector.applyQuaternion( quaternion );
+ */
+export class Quaternion {
+    /**
+     * @param x x coordinate
+     * @param y y coordinate
+     * @param z z coordinate
+     * @param w w coordinate
+     */
+    constructor(x?: number, y?: number, z?: number, w?: number);
+
+    /**
+     * @default 0
+     */
+    x: number;
+
+    /**
+     * @default 0
+     */
+    y: number;
+
+    /**
+     * @default 0
+     */
+    z: number;
+
+    /**
+     * @default 1
+     */
+    w: number;
+    readonly isQuaternion: true;
+
+    /**
+     * Sets values of this quaternion.
+     */
+    set(x: number, y: number, z: number, w: number): this;
+
+    /**
+     * Clones this quaternion.
+     */
+    clone(): this;
+
+    /**
+     * Copies values of q to this quaternion.
+     */
+    copy(q: QuaternionLike): this;
+
+    /**
+     * Sets this quaternion from rotation specified by Euler angles.
+     */
+    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: 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): this;
+    setFromUnitVectors(vFrom: Vector3, vTo: Vector3Like): this;
+    angleTo(q: Quaternion): number;
+    rotateTowards(q: Quaternion, step: number): this;
+
+    identity(): this;
+
+    /**
+     * Inverts this quaternion.
+     */
+    invert(): this;
+
+    conjugate(): this;
+    dot(v: Quaternion): number;
+    lengthSq(): number;
+
+    /**
+     * Computes length of this quaternion.
+     */
+    length(): number;
+
+    /**
+     * Normalizes this quaternion.
+     */
+    normalize(): this;
+
+    /**
+     * Multiplies this quaternion by b.
+     */
+    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): this;
+
+    slerp(qb: Quaternion, t: number): this;
+    slerpQuaternions(qa: Quaternion, qb: Quaternion, t: number): this;
+    equals(v: Quaternion): boolean;
+
+    /**
+     * Sets this quaternion's x, y, z and w 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, w], or copies x, y, z and w into the provided array.
+     * @param array (optional) array to store the quaternion 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?: QuaternionTuple, offset?: 0): QuaternionTuple;
+
+    /**
+     * Copies x, y, z and w into the provided array-like.
+     * @param array array-like to store the quaternion to.
+     * @param offset (optional) optional offset into the array.
+     * @return The provided array-like.
+     */
+    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.
+     * @param index index in the attribute.
+     */
+    fromBufferAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, index: number): this;
+
+    _onChange(callback: () => void): this;
+    _onChangeCallback: () => void;
+
+    static slerpFlat(
+        dst: number[],
+        dstOffset: number,
+        src0: number[],
+        srcOffset: number,
+        src1: number[],
+        stcOffset1: number,
+        t: number,
+    ): void;
+
+    static multiplyQuaternionsFlat(
+        dst: number[],
+        dstOffset: number,
+        src0: number[],
+        srcOffset: number,
+        src1: number[],
+        stcOffset1: number,
+    ): number[];
+
+    random(): this;
+
+    [Symbol.iterator](): Generator<number, void>;
+}

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

@@ -0,0 +1,60 @@
+import { Box3 } from "./Box3.js";
+import { Matrix4 } from "./Matrix4.js";
+import { Plane } from "./Plane.js";
+import { Sphere } from "./Sphere.js";
+import { Vector3 } from "./Vector3.js";
+
+export class Ray {
+    constructor(origin?: Vector3, direction?: Vector3);
+
+    /**
+     * @default new THREE.Vector3()
+     */
+    origin: Vector3;
+
+    /**
+     * @default new THREE.Vector3( 0, 0, - 1 )
+     */
+    direction: Vector3;
+
+    set(origin: Vector3, direction: Vector3): Ray;
+    clone(): this;
+    copy(ray: Ray): this;
+    at(t: number, target: Vector3): Vector3;
+    lookAt(v: Vector3): Ray;
+    recast(t: number): Ray;
+    closestPointToPoint(point: Vector3, target: Vector3): Vector3;
+    distanceToPoint(point: Vector3): number;
+    distanceSqToPoint(point: Vector3): number;
+    distanceSqToSegment(
+        v0: Vector3,
+        v1: Vector3,
+        optionalPointOnRay?: Vector3,
+        optionalPointOnSegment?: Vector3,
+    ): number;
+    intersectSphere(sphere: Sphere, target: Vector3): Vector3 | null;
+    intersectsSphere(sphere: Sphere): boolean;
+    distanceToPlane(plane: Plane): number;
+    intersectPlane(plane: Plane, target: Vector3): Vector3 | null;
+    intersectsPlane(plane: Plane): boolean;
+    intersectBox(box: Box3, target: Vector3): Vector3 | null;
+    intersectsBox(box: Box3): boolean;
+    intersectTriangle(a: Vector3, b: Vector3, c: Vector3, backfaceCulling: boolean, target: Vector3): Vector3 | null;
+    applyMatrix4(matrix4: Matrix4): Ray;
+    equals(ray: Ray): boolean;
+
+    /**
+     * @deprecated Use {@link Ray#intersectsBox .intersectsBox()} instead.
+     */
+    isIntersectionBox(b: any): any;
+
+    /**
+     * @deprecated Use {@link Ray#intersectsPlane .intersectsPlane()} instead.
+     */
+    isIntersectionPlane(p: any): any;
+
+    /**
+     * @deprecated Use {@link Ray#intersectsSphere .intersectsSphere()} instead.
+     */
+    isIntersectionSphere(s: any): any;
+}

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

@@ -0,0 +1,47 @@
+import { Box3 } from "./Box3.js";
+import { Matrix4 } from "./Matrix4.js";
+import { Plane } from "./Plane.js";
+import { Vector3 } from "./Vector3.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()
+     */
+    center: Vector3;
+
+    /**
+     * @default 1
+     */
+    radius: number;
+
+    set(center: Vector3, radius: number): Sphere;
+    setFromPoints(points: Vector3[], optionalCenter?: Vector3): Sphere;
+    clone(): this;
+    copy(sphere: Sphere): this;
+    expandByPoint(point: Vector3): this;
+    isEmpty(): boolean;
+    makeEmpty(): this;
+    containsPoint(point: Vector3): boolean;
+    distanceToPoint(point: Vector3): number;
+    intersectsSphere(sphere: Sphere): boolean;
+    intersectsBox(box: Box3): boolean;
+    intersectsPlane(plane: Plane): boolean;
+    clampPoint(point: Vector3, target: Vector3): Vector3;
+    getBoundingBox(target: Box3): Box3;
+    applyMatrix4(matrix: Matrix4): Sphere;
+    translate(offset: Vector3): Sphere;
+    equals(sphere: Sphere): boolean;
+    union(sphere: Sphere): this;
+
+    /**
+     * @deprecated Use {@link Sphere#isEmpty .isEmpty()} instead.
+     */
+    empty(): any;
+}

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

@@ -0,0 +1,27 @@
+import { Vector3 } from "./Vector3.js";
+
+export class Spherical {
+    constructor(radius?: number, phi?: number, theta?: number);
+
+    /**
+     * @default 1
+     */
+    radius: number;
+
+    /**
+     * @default 0
+     */
+    phi: number;
+
+    /**
+     * @default 0
+     */
+    theta: number;
+
+    set(radius: number, phi: number, theta: number): this;
+    clone(): this;
+    copy(other: Spherical): this;
+    makeSafe(): this;
+    setFromVector3(v: Vector3): this;
+    setFromCartesianCoords(x: number, y: number, z: number): this;
+}

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

@@ -0,0 +1,50 @@
+import { Vector3 } from "./Vector3.js";
+
+export class SphericalHarmonics3 {
+    constructor();
+
+    /**
+     * @default [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3(),
+     * new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()]
+     */
+    coefficients: Vector3[];
+    readonly isSphericalHarmonics3: true;
+
+    set(coefficients: Vector3[]): SphericalHarmonics3;
+    zero(): SphericalHarmonics3;
+    add(sh: SphericalHarmonics3): SphericalHarmonics3;
+    addScaledSH(sh: SphericalHarmonics3, s: number): SphericalHarmonics3;
+    scale(s: number): SphericalHarmonics3;
+    lerp(sh: SphericalHarmonics3, alpha: number): SphericalHarmonics3;
+    equals(sh: SphericalHarmonics3): boolean;
+    copy(sh: SphericalHarmonics3): SphericalHarmonics3;
+    clone(): this;
+
+    /**
+     * Sets the values of this spherical harmonics 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 with the values of this spherical harmonics, or copies them into the provided array.
+     * @param array (optional) array to store the spherical harmonics 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[];
+
+    /**
+     * Returns an array with the values of this spherical harmonics, or copies them into the provided array-like.
+     * @param array array-like to store the spherical harmonics to.
+     * @param offset (optional) optional offset into the array-like.
+     * @return The provided array-like.
+     */
+    toArray(array: ArrayLike<number>, offset?: number): ArrayLike<number>;
+
+    getAt(normal: Vector3, target: Vector3): Vector3;
+    getIrradianceAt(normal: Vector3, target: Vector3): Vector3;
+
+    static getBasisAt(normal: Vector3, shBasis: number[]): void;
+}

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

@@ -0,0 +1,110 @@
+import { Box3 } from "./Box3.js";
+import { Plane } from "./Plane.js";
+import { Vector2 } from "./Vector2.js";
+import { Vector3 } from "./Vector3.js";
+import { Vector4 } from "./Vector4.js";
+
+import { BufferAttribute } from "../core/BufferAttribute.js";
+import { InterleavedBufferAttribute } from "../core/InterleavedBufferAttribute.js";
+
+export class Triangle {
+    constructor(a?: Vector3, b?: Vector3, c?: Vector3);
+
+    /**
+     * @default new THREE.Vector3()
+     */
+    a: Vector3;
+
+    /**
+     * @default new THREE.Vector3()
+     */
+    b: Vector3;
+
+    /**
+     * @default new THREE.Vector3()
+     */
+    c: Vector3;
+
+    set(a: Vector3, b: Vector3, c: Vector3): Triangle;
+    setFromPointsAndIndices(points: Vector3[], i0: number, i1: number, i2: number): this;
+    setFromAttributeAndIndices(
+        attribute: BufferAttribute | InterleavedBufferAttribute,
+        i0: number,
+        i1: number,
+        i2: number,
+    ): this;
+    clone(): this;
+    copy(triangle: Triangle): this;
+    getArea(): number;
+    getMidpoint(target: Vector3): Vector3;
+    getNormal(target: Vector3): Vector3;
+    getPlane(target: Plane): Plane;
+    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;
+    closestPointToPoint(point: Vector3, target: Vector3): Vector3;
+    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 | null;
+    static containsPoint(point: Vector3, a: Vector3, b: Vector3, c: Vector3): boolean;
+    static getInterpolation(
+        point: Vector3,
+        p1: Vector3,
+        p2: Vector3,
+        p3: Vector3,
+        v1: Vector2,
+        v2: Vector2,
+        v3: Vector2,
+        target: Vector2,
+    ): Vector2 | null;
+    static getInterpolation(
+        point: Vector3,
+        p1: Vector3,
+        p2: Vector3,
+        p3: Vector3,
+        v1: Vector3,
+        v2: Vector3,
+        v3: Vector3,
+        target: Vector3,
+    ): Vector3 | null;
+    static getInterpolation(
+        point: Vector3,
+        p1: Vector3,
+        p2: Vector3,
+        p3: Vector3,
+        v1: Vector4,
+        v2: Vector4,
+        v3: Vector4,
+        target: Vector4,
+    ): Vector4 | null;
+    static getInterpolatedAttribute(
+        attr: BufferAttribute,
+        i1: number,
+        i2: number,
+        i3: number,
+        barycoord: Vector3,
+        target: Vector2,
+    ): Vector2;
+    static getInterpolatedAttribute(
+        attr: BufferAttribute,
+        i1: number,
+        i2: number,
+        i3: number,
+        barycoord: Vector3,
+        target: Vector3,
+    ): Vector3;
+    static getInterpolatedAttribute(
+        attr: BufferAttribute,
+        i1: number,
+        i2: number,
+        i3: number,
+        barycoord: Vector3,
+        target: Vector4,
+    ): Vector4;
+    static isFrontFacing(a: Vector3, b: Vector3, c: Vector3, direction: Vector3): boolean;
+}