kopia lustrzana https://github.com/Tldraw/Tldraw
311 wiersze
8.5 KiB
TypeScript
311 wiersze
8.5 KiB
TypeScript
export declare class Vec {
|
|
/**
|
|
* Clamp a value into a range.
|
|
* @param n
|
|
* @param min
|
|
*/
|
|
static clamp(n: number, min: number): number;
|
|
static clamp(n: number, min: number, max: number): number;
|
|
/**
|
|
* Clamp a value into a range.
|
|
* @param n
|
|
* @param min
|
|
*/
|
|
static clampV(A: number[], min: number): number[];
|
|
static clampV(A: number[], min: number, max: number): number[];
|
|
/**
|
|
* Negate a vector.
|
|
* @param A
|
|
*/
|
|
static neg: (A: number[]) => number[];
|
|
/**
|
|
* Add vectors.
|
|
* @param A
|
|
* @param B
|
|
*/
|
|
static add: (A: number[], B: number[]) => number[];
|
|
/**
|
|
* Add scalar to vector.
|
|
* @param A
|
|
* @param B
|
|
*/
|
|
static addScalar: (A: number[], n: number) => number[];
|
|
/**
|
|
* Subtract vectors.
|
|
* @param A
|
|
* @param B
|
|
*/
|
|
static sub: (A: number[], B: number[]) => number[];
|
|
/**
|
|
* Subtract scalar from vector.
|
|
* @param A
|
|
* @param B
|
|
*/
|
|
static subScalar: (A: number[], n: number) => number[];
|
|
/**
|
|
* Get the vector from vectors A to B.
|
|
* @param A
|
|
* @param B
|
|
*/
|
|
static vec: (A: number[], B: number[]) => number[];
|
|
/**
|
|
* Vector multiplication by scalar
|
|
* @param A
|
|
* @param n
|
|
*/
|
|
static mul: (A: number[], n: number) => number[];
|
|
/**
|
|
* Multiple two vectors.
|
|
* @param A
|
|
* @param B
|
|
*/
|
|
static mulV: (A: number[], B: number[]) => number[];
|
|
/**
|
|
* Vector division by scalar.
|
|
* @param A
|
|
* @param n
|
|
*/
|
|
static div: (A: number[], n: number) => number[];
|
|
/**
|
|
* Vector division by vector.
|
|
* @param A
|
|
* @param n
|
|
*/
|
|
static divV: (A: number[], B: number[]) => number[];
|
|
/**
|
|
* Perpendicular rotation of a vector A
|
|
* @param A
|
|
*/
|
|
static per: (A: number[]) => number[];
|
|
/**
|
|
* Dot product
|
|
* @param A
|
|
* @param B
|
|
*/
|
|
static dpr: (A: number[], B: number[]) => number;
|
|
/**
|
|
* Cross product (outer product) | A X B |
|
|
* @param A
|
|
* @param B
|
|
*/
|
|
static cpr: (A: number[], B: number[]) => number;
|
|
/**
|
|
* Cross (for point in polygon)
|
|
*
|
|
*/
|
|
static cross(x: number[], y: number[], z: number[]): number;
|
|
/**
|
|
* Length of the vector squared
|
|
* @param A
|
|
*/
|
|
static len2: (A: number[]) => number;
|
|
/**
|
|
* Length of the vector
|
|
* @param A
|
|
*/
|
|
static len: (A: number[]) => number;
|
|
/**
|
|
* Project A over B
|
|
* @param A
|
|
* @param B
|
|
*/
|
|
static pry: (A: number[], B: number[]) => number;
|
|
/**
|
|
* Get normalized / unit vector.
|
|
* @param A
|
|
*/
|
|
static uni: (A: number[]) => number[];
|
|
/**
|
|
* Get normalized / unit vector.
|
|
* @param A
|
|
*/
|
|
static normalize: (A: number[]) => number[];
|
|
/**
|
|
* Get the tangent between two vectors.
|
|
* @param A
|
|
* @param B
|
|
* @returns
|
|
*/
|
|
static tangent: (A: number[], B: number[]) => number[];
|
|
/**
|
|
* Dist length from A to B squared.
|
|
* @param A
|
|
* @param B
|
|
*/
|
|
static dist2: (A: number[], B: number[]) => number;
|
|
/**
|
|
* Dist length from A to B
|
|
* @param A
|
|
* @param B
|
|
*/
|
|
static dist: (A: number[], B: number[]) => number;
|
|
/**
|
|
* A faster, though less accurate method for testing distances. Maybe faster?
|
|
* @param A
|
|
* @param B
|
|
* @returns
|
|
*/
|
|
static fastDist: (A: number[], B: number[]) => number[];
|
|
/**
|
|
* Angle between vector A and vector B in radians
|
|
* @param A
|
|
* @param B
|
|
*/
|
|
static ang: (A: number[], B: number[]) => number;
|
|
/**
|
|
* Angle between vector A and vector B in radians
|
|
* @param A
|
|
* @param B
|
|
*/
|
|
static angle: (A: number[], B: number[]) => number;
|
|
/**
|
|
* Mean between two vectors or mid vector between two vectors
|
|
* @param A
|
|
* @param B
|
|
*/
|
|
static med: (A: number[], B: number[]) => number[];
|
|
/**
|
|
* Vector rotation by r (radians)
|
|
* @param A
|
|
* @param r rotation in radians
|
|
*/
|
|
static rot: (A: number[], r?: number) => number[];
|
|
/**
|
|
* Rotate a vector around another vector by r (radians)
|
|
* @param A vector
|
|
* @param C center
|
|
* @param r rotation in radians
|
|
*/
|
|
static rotWith: (A: number[], C: number[], r?: number) => number[];
|
|
/**
|
|
* Check of two vectors are identical.
|
|
* @param A
|
|
* @param B
|
|
*/
|
|
static isEqual: (A: number[], B: number[]) => boolean;
|
|
/**
|
|
* Interpolate vector A to B with a scalar t
|
|
* @param A
|
|
* @param B
|
|
* @param t scalar
|
|
*/
|
|
static lrp: (A: number[], B: number[], t: number) => number[];
|
|
/**
|
|
* Interpolate from A to B when curVAL goes fromVAL: number[] => to
|
|
* @param A
|
|
* @param B
|
|
* @param from Starting value
|
|
* @param to Ending value
|
|
* @param s Strength
|
|
*/
|
|
static int: (A: number[], B: number[], from: number, to: number, s?: number) => number[];
|
|
/**
|
|
* Get the angle between the three vectors A, B, and C.
|
|
* @param p1
|
|
* @param pc
|
|
* @param p2
|
|
*/
|
|
static ang3: (p1: number[], pc: number[], p2: number[]) => number;
|
|
/**
|
|
* Absolute value of a vector.
|
|
* @param A
|
|
* @returns
|
|
*/
|
|
static abs: (A: number[]) => number[];
|
|
static rescale: (a: number[], n: number) => number[];
|
|
/**
|
|
* Get whether p1 is left of p2, relative to pc.
|
|
* @param p1
|
|
* @param pc
|
|
* @param p2
|
|
*/
|
|
static isLeft: (p1: number[], pc: number[], p2: number[]) => number;
|
|
/**
|
|
* Get whether p1 is left of p2, relative to pc.
|
|
* @param p1
|
|
* @param pc
|
|
* @param p2
|
|
*/
|
|
static clockwise: (p1: number[], pc: number[], p2: number[]) => boolean;
|
|
/**
|
|
* Round a vector to the a given precision.
|
|
* @param a
|
|
* @param d
|
|
*/
|
|
static toFixed: (a: number[], d?: number) => number[];
|
|
/**
|
|
* Snap vector to nearest step.
|
|
* @param A
|
|
* @param step
|
|
* @example
|
|
* ```ts
|
|
* Vec.snap([10.5, 28], 10) // [10, 30]
|
|
* ```
|
|
*/
|
|
static snap(a: number[], step?: number): number[];
|
|
/**
|
|
* Get the nearest point on a line with a known unit vector that passes through point A
|
|
* @param A Any point on the line
|
|
* @param u The unit vector for the line.
|
|
* @param P A point not on the line to test.
|
|
* @returns
|
|
*/
|
|
static nearestPointOnLineThroughPoint: (A: number[], u: number[], P: number[]) => number[];
|
|
/**
|
|
* Distance between a point and a line with a known unit vector that passes through a point.
|
|
* @param A Any point on the line
|
|
* @param u The unit vector for the line.
|
|
* @param P A point not on the line to test.
|
|
* @returns
|
|
*/
|
|
static distanceToLineThroughPoint: (A: number[], u: number[], P: number[]) => number;
|
|
/**
|
|
* Get the nearest point on a line segment between A and B
|
|
* @param A The start of the line segment
|
|
* @param B The end of the line segment
|
|
* @param P The off-line point
|
|
* @param clamp Whether to clamp the point between A and B.
|
|
* @returns
|
|
*/
|
|
static nearestPointOnLineSegment: (A: number[], B: number[], P: number[], clamp?: boolean) => number[];
|
|
/**
|
|
* Distance between a point and the nearest point on a line segment between A and B
|
|
* @param A The start of the line segment
|
|
* @param B The end of the line segment
|
|
* @param P The off-line point
|
|
* @param clamp Whether to clamp the point between A and B.
|
|
* @returns
|
|
*/
|
|
static distanceToLineSegment: (A: number[], B: number[], P: number[], clamp?: boolean) => number;
|
|
/**
|
|
* Push a point A towards point B by a given distance.
|
|
* @param A
|
|
* @param B
|
|
* @param d
|
|
* @returns
|
|
*/
|
|
static nudge: (A: number[], B: number[], d: number) => number[];
|
|
/**
|
|
* Push a point in a given angle by a given distance.
|
|
* @param A
|
|
* @param B
|
|
* @param d
|
|
*/
|
|
static nudgeAtAngle: (A: number[], a: number, d: number) => number[];
|
|
/**
|
|
* Round a vector to a precision length.
|
|
* @param a
|
|
* @param n
|
|
*/
|
|
static toPrecision: (a: number[], n?: number) => number[];
|
|
/**
|
|
* Get an array of points (with simulated pressure) between two points.
|
|
* @param A The first point.
|
|
* @param B The second point.
|
|
* @param steps The number of points to return.
|
|
* @param ease An easing function to apply to the simulated pressure.
|
|
*/
|
|
static pointsBetween: (A: number[], B: number[], steps?: number) => number[][];
|
|
}
|
|
export default Vec;
|
|
//# sourceMappingURL=index.d.ts.map
|