@openglobus/og 0.19.3 → 0.20.0

package/lib/@openglobus/js/math/Vec3.d.ts

@@ -0,0 +1,472 @@
+import { Quat } from "./Quat";
+import { Vec4, NumberArray4 } from "./Vec4";
+import { NumberArray2 } from "./Vec2";
+export type NumberArray3 = [number, number, number];
+/**
+ * Class represents a 3d vector.
+ * @class
+ * @param {number} [x] - First value.
+ * @param {number} [y] - Second value.
+ * @param {number} [z] - Third value.
+ */
+export declare class Vec3 {
+    /**
+     * @public
+     * @type {number}
+     */
+    x: number;
+    /**
+     * @public
+     * @type {number}
+     */
+    y: number;
+    /**
+     * @public
+     * @type {number}
+     */
+    z: number;
+    constructor(x?: number, y?: number, z?: number);
+    /** @const */
+    static get UP(): Vec3;
+    /** @const */
+    static get DOWN(): Vec3;
+    /** @const */
+    static get RIGHT(): Vec3;
+    /** @const */
+    static get LEFT(): Vec3;
+    /** @const */
+    static get FORWARD(): Vec3;
+    /** @const */
+    static get BACKWARD(): Vec3;
+    /** @const */
+    static get ZERO(): Vec3;
+    /** @const */
+    static get UNIT_X(): Vec3;
+    /** @const */
+    static get UNIT_Y(): Vec3;
+    /** @const */
+    static get UNIT_Z(): Vec3;
+    /** @const */
+    static get NORTH(): Vec3;
+    /**
+     * Separate 63 bit Vec3 to two Vec3 32-bit float values.
+     * @function
+     * @param {Vec3} v - Double type value.
+     * @param {Vec3} high - Out vector high values.
+     * @param {Vec3} low - Out vector low values.
+     */
+    static doubleToTwoFloats(v: Vec3, high: Vec3, low: Vec3): void;
+    /**
+     * Separate 63 bit Vec3 to two Vec3 32-bit float values.
+     * @function
+     * @param {Vec3} v - Double type value.
+     * @param {Float32Array} high - Out vector high values.
+     * @param {Float32Array} low - Out vector low values.
+     * @returns {Array.<number>} Encoded array. (exactly 2 entries)
+     */
+    static doubleToTwoFloat32Array(v: Vec3, high: Float32Array | NumberArray3, low: Float32Array | NumberArray3): void;
+    /**
+     * Creates 3d vector from array.
+     * @function
+     * @param {NumberArray2 | NumberArray3 | NumberArray4} arr - Input array (exactly 3 entries)
+     * @returns {Vec3} -
+     */
+    static fromVec(arr: NumberArray2 | NumberArray3 | NumberArray4): Vec3;
+    /**
+     * Gets angle between two vectors.
+     * @static
+     * @param {Vec3} a - First vector.
+     * @param {Vec3} b - Second vector.
+     * @returns {number} -
+     */
+    static angle(a: Vec3, b: Vec3): number;
+    /**
+     * Returns two vectors linear interpolation.
+     * @static
+     * @param {Vec3} v1 - Start vector.
+     * @param {Vec3} v2 - End vector.
+     * @param {number} l - Interpolate value.
+     * @returns {Vec3} -
+     */
+    static lerp(v1: Vec3, v2: Vec3, l: number): Vec3;
+    /**
+     * Returns summary vector.
+     * @static
+     * @param {Vec3} a - First vector.
+     * @param {Vec3} b - Second vector.
+     * @returns {Vec3} - Summary vector.
+     */
+    static add(a: Vec3, b: Vec3): Vec3;
+    /**
+     * Returns two vectors subtraction.
+     * @static
+     * @param {Vec3} a - First vector.
+     * @param {Vec3} b - Second vector.
+     * @returns {Vec3} - Vectors subtraction.
+     */
+    static sub(a: Vec3, b: Vec3): Vec3;
+    /**
+     * Returns scaled vector.
+     * @static
+     * @param {Vec3} a - Input vector.
+     * @param {number} scale - Scale value.
+     * @returns {Vec3} -
+     */
+    static scale(a: Vec3, scale: number): Vec3;
+    /**
+     * Returns two vectors production.
+     * @static
+     * @param {Vec3} a - First vector.
+     * @param {Vec3} b - Second vector.
+     * @returns {Vec3} -
+     */
+    static mul(a: Vec3, b: Vec3): Vec3;
+    /**
+     * Returns true if two vectors are non-collinear.
+     * @public
+     * @param {Vec3} a - First vector.
+     * @param {Vec3} b - Second vector.
+     * @returns {Vec3} -
+     */
+    static noncollinear(a: Vec3, b: Vec3): boolean;
+    /**
+     * Get projection of the vector to plane where n - normal to the plane.
+     * @static
+     * @param {Vec3} b - Vector to project.
+     * @param {Vec3} n - Plane normal.
+     * @param {Vec3} [def] - Default value for non existed result.
+     * @returns {Vec3} -
+     */
+    static proj_b_to_plane(b: Vec3, n: Vec3, def?: Vec3): Vec3;
+    /**
+     * Get projection of the first vector to the second.
+     * @static
+     * @param {Vec3} b - First vector.
+     * @param {Vec3} a - Second vector.
+     * @returns {Vec3} -
+     */
+    static proj_b_to_a(b: Vec3, a: Vec3): Vec3;
+    /**
+     * Makes vectors normalized and orthogonal to each other.
+     * Normalizes normal. Normalizes tangent and makes sure it is orthogonal to normal (that is, angle between them is 90 degrees).
+     * @static
+     * @param {Vec3} normal - Normal vector.
+     * @param {Vec3} tangent - Tangent vector.
+     * @returns {Vec3} -
+     */
+    static orthoNormalize(normal: Vec3, tangent: Vec3): Vec3;
+    /**
+     * Returns vector components division product one to another.
+     * @static
+     * @param {Vec3} a - First vector.
+     * @param {Vec3} b - Second vector.
+     * @returns {Vec3} -
+     */
+    static div(a: Vec3, b: Vec3): Vec3;
+    static length2(a: Vec3): number;
+    static dot(a: Vec3, b: Vec3): number;
+    /**
+     * Converts to 4d vector, Fourth value is 1.0.
+     * @public
+     * @returns {Vec4} -
+     */
+    toVec4(): Vec4;
+    /**
+     * Returns clone vector.
+     * @public
+     * @returns {Vec3} -
+     */
+    clone(): Vec3;
+    /**
+     * Converts vector to text string.
+     * @public
+     * @returns {string} -
+     */
+    toString(): string;
+    /**
+     * Returns true if vector's values are zero.
+     * @public
+     * @returns {boolean} -
+     */
+    isZero(): boolean;
+    /**
+     * Get projection of the first vector to the second.
+     * @static
+     * @param {Vec3} a - Project vector.
+     * @returns {Vec3} -
+     */
+    projToVec(a: Vec3): Vec3;
+    /**
+     * Compares with vector. Returns true if it equals another.
+     * @public
+     * @param {Vec3} p - Vector to compare.
+     * @returns {boolean} -
+     */
+    equal(p: Vec3): boolean;
+    /**
+     * Copy input vector's values.
+     * @param {Vec3} p - Vector to copy.
+     * @returns {Vec3} -
+     */
+    copy(p: Vec3): Vec3;
+    /**
+     * Gets vector's length.
+     * @public
+     * @returns {number} -
+     */
+    length(): number;
+    /**
+     * Returns squared vector's length.
+     * @public
+     * @returns {number} -
+     */
+    length2(): number;
+    /**
+     * Converts vector's values to a quaternion object.
+     * @public
+     * @returns {Quat} -
+     */
+    getQuat(): Quat;
+    /**
+     * Adds vector to the current.
+     * @public
+     * @param {Vec3} p - Point to add.
+     * @returns {Vec3} -
+     */
+    addA(p: Vec3): Vec3;
+    /**
+     * Gets two vectors summarization.
+     * @public
+     * @param {Vec3} p - Vector to add.
+     * @returns {Vec3} Returns a sum vector.
+     */
+    add(p: Vec3): Vec3;
+    /**
+     * Subtract vector from the current.
+     * @public
+     * @param {Vec3} p - Subtract vector.
+     * @returns {Vec3} -
+     */
+    subA(p: Vec3): Vec3;
+    /**
+     * Gets vector subtraction.
+     * @public
+     * @param {Vec3} p - Subtract vector.
+     * @return {Vec3} Returns new instance of a subtraction
+     */
+    sub(p: Vec3): Vec3;
+    /**
+     * Scale current vector.
+     * @public
+     * @param {number} scale - Scale value.
+     * @returns {Vec3} -
+     */
+    scale(scale: number): Vec3;
+    /**
+     * Scale current vector to another instance.
+     * @public
+     * @param {number} scale - Scale value.
+     * @returns {Vec3} -
+     */
+    scaleTo(scale: number): Vec3;
+    /**
+     * Multiply current vector object to another and store result in the current instance.
+     * @public
+     * @param {Vec3} vec - Multiply vector.
+     * @returns {Vec3} -
+     */
+    mulA(vec: Vec3): Vec3;
+    /**
+     * Multiply current vector object to another and returns new vector instance.
+     * @public
+     * @param {Vec3} vec - Multiply vector.
+     * @returns {Vec3} -
+     */
+    mul(vec: Vec3): Vec3;
+    /**
+     * Divide current vector's components to another. Results stores in the current vector object.
+     * @public
+     * @param {Vec3} vec - Div vector.
+     * @returns {Vec3} -
+     */
+    divA(vec: Vec3): Vec3;
+    /**
+     * Divide current vector's components to another and returns new vector instance.
+     * @public
+     * @param {Vec3} vec - Div vector.
+     * @returns {Vec3} -
+     */
+    div(vec: Vec3): Vec3;
+    /**
+     * Gets vectors dot production.
+     * @public
+     * @param {Vec3} a - Another vector.
+     * @returns {number} -
+     */
+    dot(a: Vec3): number;
+    /**
+     * Gets vectors dot production.
+     * @public
+     * @param {Array.<number>} arr - Array vector. (exactly 3 entries)
+     * @returns {number} -
+     */
+    dotArr(arr: NumberArray3 | NumberArray4): number;
+    /**
+     * Gets vectors cross production.
+     * @public
+     * @param {Vec3} point3 - Another vector.
+     * @returns {Vec3} -
+     */
+    cross(point3: Vec3): Vec3;
+    /**
+     * Sets vector to zero.
+     * @public
+     * @returns {Vec3} -
+     */
+    clear(): Vec3;
+    /**
+     * Returns normalized vector.
+     * @public
+     * @returns {Vec3} -
+     */
+    getNormal(): Vec3;
+    /**
+     * Returns normalized vector.
+     * @deprecated
+     * @public
+     * @returns {Vec3} -
+     */
+    normal(): Vec3;
+    /**
+     * Returns normalized negate vector.
+     * @public
+     * @returns {Vec3} -
+     */
+    normalNegate(): Vec3;
+    /**
+     * Returns normalized negate scale vector.
+     * @public
+     * @returns {Vec3} -
+     */
+    normalNegateScale(scale: number): Vec3;
+    /**
+     * Returns normalized scale vector.
+     * @public
+     * @returns {Vec3} -
+     */
+    normalScale(scale: number): Vec3;
+    /**
+     * Normalize current vector.
+     * @public
+     * @returns {Vec3} -
+     */
+    normalize(): Vec3;
+    /**
+     * Converts vector to a number array.
+     * @public
+     * @returns {Array.<number>} - (exactly 3 entries)
+     * @deprecated
+     */
+    toVec(): NumberArray3;
+    /**
+     * Converts vector to a number array.
+     * @public
+     * @returns {Array.<number>} - (exactly 3 entries)
+     */
+    toArray(): NumberArray3;
+    /**
+     * Gets distance to point.
+     * @public
+     * @param {Vec3} p - Distant point.
+     * @returns {number} -
+     */
+    distance(p: Vec3): number;
+    /**
+     * Gets square distance to point.
+     * @public
+     * @param {Vec3} p - Distant point.
+     * @returns {number} -
+     */
+    distance2(p: Vec3): number;
+    /**
+     * Sets vector's values.
+     * @public
+     * @param {number} x - Value X.
+     * @param {number} y - Value Y.
+     * @param {number} z - Value Z.
+     * @returns {Vec3} -
+     */
+    set(x: number, y: number, z: number): Vec3;
+    /**
+     * Negate current vector.
+     * @public
+     * @returns {Vec3} -
+     */
+    negate(): Vec3;
+    /**
+     * Negate current vector to another instance.
+     * @public
+     * @returns {Vec3} -
+     */
+    negateTo(): Vec3;
+    /**
+     * Gets projected point coordinates of the current vector on the ray.
+     * @public
+     * @param {Vec3} pos - Ray position.
+     * @param {Vec3} direction - Ray direction.
+     * @returns {Vec3} -
+     */
+    projToRay(pos: Vec3, direction: Vec3): Vec3;
+    /**
+     * Gets angle between two vectors.
+     * @public
+     * @param {Vec3} a - Another vector.
+     * @returns {number} -
+     */
+    angle(a: Vec3): number;
+    /**
+     * Returns two vectors linear interpolation.
+     * @public
+     * @param {Vec3} v2 - End vector.
+     * @param {number} l - Interpolate value.
+     * @returns {Vec3} -
+     */
+    lerp(v2: Vec3, l: number): Vec3;
+    /**
+     * Returns vector interpolation by v(t) = v1 * t + v2 * (1 - t)
+     * @public
+     * @param {Vec3} v2 - End vector.
+     * @param {number} t - Interpolate value.
+     * @returns {Vec3} -
+     */
+    smerp(v2: Vec3, t: number): Vec3;
+    static get LERP_DELTA(): number;
+    /**
+     * Spherically interpolates between two vectors.
+     * Interpolates between current and v2 vector by amount t. The difference between this and linear interpolation (aka, "lerp") is that
+     * the vectors are treated as directions rather than points in space. The direction of the returned vector is interpolated
+     * by the angle and its magnitude is interpolated between the magnitudes of from and to.
+     * @public
+     * @param {Vec3} v2 -
+     * @param {number} t - The parameter t is clamped to the range [0, 1].
+     * @returns {Vec3} -
+     */
+    slerp(v2: Vec3, t: number): Vec3;
+    /**
+     * Gets the shortest arc quaternion to rotate this vector to the destination vector.
+     * @param {Vec3} dest -
+     * @param {Vec3} fallbackAxis -
+     * @returns {Quat} -
+     * @todo: TEST IT!
+     */
+    getRotationTo(dest: Vec3, fallbackAxis: Vec3): Quat;
+}
+/**
+ * Vector 3d object creator.
+ * @function
+ * @param {number} [x] - value X.
+ * @param {number} [y] - value Y.
+ * @param {number} [z] - value Z.
+ * @returns {Vec3} -
+ */
+export declare function vec3(x?: number, y?: number, z?: number): Vec3;

package/lib/@openglobus/js/math/Vec4.d.ts

@@ -0,0 +1,163 @@
+import { Vec3 } from "./Vec3";
+export type NumberArray4 = [number, number, number, number];
+/**
+ * Class represents a 4d vector.
+ * @class
+ * @param {number} [x] - First value.
+ * @param {number} [y] - Second value.
+ * @param {number} [z] - Third value.
+ * @param {number} [w] - Fourth value.
+ */
+export declare class Vec4 {
+    /**
+     * @public
+     * @type {number}
+     */
+    x: number;
+    /**
+     * @public
+     * @type {number}
+     */
+    y: number;
+    /**
+     * @public
+     * @type {number}
+     */
+    z: number;
+    /**
+     * @public
+     * @type {number}
+     */
+    w: number;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    /**
+     * Identity vector [0,0,0,1].
+     * @const
+     * @type {Vec4}
+     */
+    static get identity(): Vec4;
+    /**
+     * Creates 4d vector from array.
+     * @function
+     * @param {Array.<number>} arr - Array of four values
+     * @returns {Vec4}
+     */
+    static fromVec(arr: NumberArray4): Vec4;
+    /**
+     * Converts to Vec3, without fourth value.
+     * @public
+     * @returns {Vec3}
+     */
+    toVec3(): Vec3;
+    /**
+     * Returns clone vector.
+     * @public
+     * @returns {Vec4}
+     */
+    clone(): Vec4;
+    /**
+     * Compares with vector. Returns true if it equals another.
+     * @public
+     * @param {Vec4} v - Vector to compare.
+     * @returns {boolean}
+     */
+    equal(v: Vec4): boolean;
+    /**
+     * Copy input vector's values.
+     * @param {Vec4} v - Vector to copy.
+     * @returns {Vec4}
+     */
+    copy(v: Vec4): Vec4;
+    /**
+     * Converts vector to a number array.
+     * @public
+     * @returns {Array.<number>} - (exactly 4 entries)
+     */
+    toArray(): NumberArray4;
+    /**
+     * Converts vector to a number array.
+     * @public
+     * @returns {Array.<number>} - (exactly 4 entries)
+     */
+    toArray3(): [number, number, number];
+    /**
+     * Sets vector's values.
+     * @public
+     * @param {number} x - Value X.
+     * @param {number} y - Value Y.
+     * @param {number} z - Value Z.
+     * @param {number} w - Value W.
+     * @returns {Vec4}
+     */
+    set(x: number, y: number, z: number, w: number): Vec4;
+    /**
+     * Adds vector to the current.
+     * @public
+     * @param {Vec4} v - Vector to add.
+     * @returns {Vec4}
+     */
+    addA(v: Vec4): Vec4;
+    /**
+     * Subtract vector from the current.
+     * @public
+     * @param {Vec4} v - Subtract vector.
+     * @returns {Vec4}
+     */
+    subA(v: Vec4): Vec4;
+    /**
+     * Scale current vector.
+     * @public
+     * @param {number} scale - Scale value.
+     * @returns {Vec4}
+     */
+    scale(scale: number): Vec4;
+    /**
+     * Makes vector affinity. Thereby fourth component becomes to 1.0.
+     * @public
+     * @returns {Vec4}
+     */
+    affinity(): Vec4;
+    /**
+     * Scale current vector to another instance.
+     * @public
+     * @param {number} scale - Scale value.
+     * @returns {Vec3}
+     */
+    scaleTo(scale: number): Vec4;
+    /**
+     * Vector's edge function that returns vector where each component is 0.0 if it's smaller than edge and otherwise 1.0.
+     * @public
+     * @returns {Vec4}
+     */
+    getStep(edge: number): Vec4;
+    /**
+     * The vector frac function returns the vector of fractional parts of each value, i.e. x minus floor(x).
+     * @public
+     * @param {Vec4} v - Input vector
+     * @returns {Vec4}
+     */
+    getFrac(v: Vec4): Vec4;
+    /**
+     * Gets vectors dot production.
+     * @public
+     * @param {Vec4} v - Another vector.
+     * @returns {number} - Dot product.
+     */
+    dot(v: Vec4): number;
+    /**
+     * Returns true if vector's values are zero.
+     * @public
+     * @returns {boolean} -
+     */
+    isZero(): boolean;
+}
+/**
+ * Vector 4d object creator.
+ * @function
+ * @param {number} [x] - First value.
+ * @param {number} [y] - Second value.
+ * @param {number} [z] - Third value.
+ * @param {number} [w] - Fourth value.
+ * @returns {Vec4}
+ */
+export declare function vec4(x?: number, y?: number, z?: number, w?: number): Vec4;

package/lib/@openglobus/js/math/coder.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @module og/math/coder
+ */
+import { NumberArray4, Vec4 } from "./Vec4";
+import { NumberArray3 } from "./Vec3";
+import { NumberArray2, Vec2 } from "./Vec2";
+/**
+ * Encode 32 bit float value to the RGBA vector.
+ * @function
+ * @param {number} v - 32 bit float value.
+ * @returns {Vec4} - RGBA vector value.
+ */
+export declare function encodeFloatToRGBA(v: number): Vec4;
+/**
+ * Decode RGBA vector to 32 bit float value.
+ * @function
+ * @param {Vec4} rgba - RGBA encoded 32 bit float value.
+ * @returns {number} - Float value.
+ */
+export declare function decodeFloatFromRGBA(rgba: Vec4): number;
+/**
+ * Decode RGBA vector to 32 bit float value.
+ * @function
+ * @param {NumberArray4 | NumberArray3} arr - RGBA encoded 32 bit float value.
+ * @param {boolean} [use32=false] Use 32 bit result
+ * @returns {number} - Float value.
+ */
+export declare function decodeFloatFromRGBAArr(arr: NumberArray4 | NumberArray3 | Uint8Array, use32?: boolean): number;
+/**
+ * Separate 64 bit value to two 32-bit float values.
+ * @function
+ * @param {number} value - Double type value.
+ * @returns {Float32Array} Encoded array. (exactly 2 entries)
+ */
+export declare function doubleToTwoFloats(value: number): Float32Array;
+/**
+ * Separate 64 bit value to two 32-bit float values.
+ * @function
+ * @param {number} value - Double type value.
+ * @param {NumberArray2 | Float32Array} - Reference out array.
+ * @returns {NumberArray2 | Float32Array} Encoded array. (exactly 2 entries)
+ */
+export declare function doubleToTwoFloats2(value: number, highLowArr: NumberArray2 | Float32Array): NumberArray2 | Float32Array;
+/**
+ * Separate 64 bit value to two 32-bit float values.
+ * @function
+ * @param {number} value - Double type value.
+ * @param {Vec2} highLowVec - Reference out vector object.
+ * @returns {Vec2} Encoded array. (exactly 2 entries)
+ */
+export declare function doubleToTwoFloatsV2(value: number, highLowVec: Vec2): Vec2;

package/lib/@openglobus/js/math/index.d.ts

@@ -0,0 +1,11 @@
+import { Line2 } from './Line2';
+import { Line3 } from './Line3';
+import { Mat3 } from './Mat3';
+import { Mat4 } from './Mat4';
+import { Plane } from './Plane';
+import { Quat } from './Quat';
+import { Ray } from './Ray';
+import { Vec2, NumberArray2 } from './Vec2';
+import { Vec3, NumberArray3 } from './Vec3';
+import { Vec4, NumberArray4 } from './Vec4';
+export { Line2, Line3, Mat3, Mat4, Plane, Quat, Ray, Vec2, Vec3, Vec4, type NumberArray2, type NumberArray3, type NumberArray4 };