@woosh/meep-engine/src/core/geom/Vector4.d.ts

Pure JavaScript game engine. Fully featured and production ready.

/**
 * Class representing a 4D vector. A 4D vector is an ordered quadruplet of numbers (labeled x, y, z, and w), which can be used to represent a number of things, such as:
 *
 * A point in 4D space.
 * A direction and length in 4D space. The length will always be the Euclidean distance (straight-line distance) from `(0, 0, 0, 0)` to `(x, y, z, w)` and the direction is also measured from `(0, 0, 0, 0)` towards `(x, y, z, w)`.
 * Any arbitrary ordered quadruplet of numbers.
 * There are other things a 4D vector can be used to represent, however these are the most common uses.
 *
 * Iterating through a Vector4 instance will yield its components (x, y, z, w) in the corresponding order.
 *
 * @implements Iterable<number>
 */
export class Vector4 implements Iterable<number> {
    /**
     *
     * @param {Vector4} v0
     * @param {Vector4} v1
     * @param {Number} f interpolation fraction
     * @param {Vector4} result
     */
    static lerp(v0: Vector4, v1: Vector4, f: number, result: Vector4): void;
    /**
     *
     * @param {number} [x=0]
     * @param {number} [y=0]
     * @param {number} [z=0]
     * @param {number} [w=0]
     * @constructor
     * @class
     */
    constructor(x?: number, y?: number, z?: number, w?: number);
    /**
     *
     * @type {number}
     */
    x: number;
    /**
     *
     * @type {number}
     */
    y: number;
    /**
     *
     * @type {number}
     */
    z: number;
    /**
     *
     * @type {number}
     */
    w: number;
    /**
     * Dispatched when the value changes
     * @readonly
     * @type {Signal<number,number,number,number,number,number,number,number>}
     */
    readonly onChanged: Signal<number, number, number, number, number, number, number, number>;
    /**
     *
     * @param {number} v
     */
    set 0(arg: number);
    /**
     *
     * @returns {number}
     */
    get 0(): number;
    /**
     *
     * @param {number} v
     */
    set 1(arg: number);
    /**
     *
     * @returns {number}
     */
    get 1(): number;
    /**
     *
     * @param {number} v
     */
    set 2(arg: number);
    /**
     *
     * @returns {number}
     */
    get 2(): number;
    /**
     *
     * @param {number} v
     */
    set 3(arg: number);
    /**
     *
     * @returns {number}
     */
    get 3(): number;
    /**
     *
     * @param {number[]} array
     * @param {number} offset
     */
    readFromArray(array: number[], offset?: number): void;
    /**
     *
     * @param {number[]} array
     * @param {number} offset
     */
    writeToArray(array: number[], offset?: number): void;
    /**
     *
     * @param {Number} x
     * @param {Number} y
     * @param {Number} z
     * @param {Number} w
     * @returns {Vector4}
     */
    set(x: number, y: number, z: number, w: number): Vector4;
    /**
     *
     * @param {Vector3} v3
     */
    multiplyVector3(v3: Vector3): void;
    /**
     *
     * @param {Number} value
     * @returns {Vector4}
     */
    multiplyScalar(value: number): Vector4;
    /**
     *
     * @param {number} a0
     * @param {number} a1
     * @param {number} a2
     * @param {number} a3
     * @param {number} b0
     * @param {number} b1
     * @param {number} b2
     * @param {number} b3
     * @param {number} c0
     * @param {number} c1
     * @param {number} c2
     * @param {number} c3
     * @param {number} d0
     * @param {number} d1
     * @param {number} d2
     * @param {number} d3
     * @returns {Vector4} this
     */
    _applyMatrix4(a0: number, a1: number, a2: number, a3: number, b0: number, b1: number, b2: number, b3: number, c0: number, c1: number, c2: number, c3: number, d0: number, d1: number, d2: number, d3: number): Vector4;
    /**
     *
     * @param {Vector4} other
     * @returns {number}
     */
    dot(other: Vector4): number;
    /**
     * Add XYZ components from another vector
     * @param {Vector3|Vector4} v3
     * @returns {Vector4}
     */
    add3(v3: Vector3 | Vector4): Vector4;
    /**
     * @deprecated use {@link applyMatrix4} directly instead
     * @param {Matrix4} m
     * @returns {Vector4} this
     */
    threeApplyMatrix4(m: Matrix4): Vector4;
    /**
     *
     * @param {number[]|Float32Array} m 4x4 transformation matrix
     * @return {Vector4}
     */
    applyMatrix4(m: number[] | Float32Array): Vector4;
    /**
     *
     * @param {Vector4} vec4
     * @returns {Vector4}
     */
    copy(vec4: Vector4): Vector4;
    /**
     *
     * @returns {Vector4}
     */
    clone(): Vector4;
    /**
     *
     * @param {Quaternion} q
     */
    applyQuaternion(q: Quaternion): void;
    /**
     *
     * @param {Vector4} vec4
     * @returns {boolean}
     */
    equals(vec4: Vector4): boolean;
    /**
     *
     * @return {number}
     */
    hash(): number;
    /**
     * @param {Vector4} v0
     * @param {Vector4} v1
     * @param {Number} f interpolation fraction
     */
    lerpVectors(v0: Vector4, v1: Vector4, f: number): void;
    toArray: (result: number[]) => void;
    /**
     * @returns {number[]}
     */
    asArray(): number[];
    /**
     *
     * @param {number[]} data
     * @param {number} offset
     */
    setFromArray(data: number[], offset: number): void;
    toJSON(): {
        x: number;
        y: number;
        z: number;
        w: number;
    };
    fromJSON(json: any): void;
    /**
     *
     * @param {BinaryBuffer} buffer
     */
    toBinaryBuffer(buffer: BinaryBuffer): void;
    /**
     *
     * @param {BinaryBuffer} buffer
     */
    fromBinaryBuffer(buffer: BinaryBuffer): void;
    /**
     * @readonly
     * @type {boolean}
     */
    readonly isVector4: boolean;
    fromArray: (array: number[], offset?: number) => void;
    [Symbol.iterator](): Generator<number, void, unknown>;
}
export namespace Vector4 {
    let typeName: string;
}
export default Vector4;
//# sourceMappingURL=Vector4.d.ts.map