@openglobus/og 0.19.3 → 0.20.0

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

@@ -0,0 +1,195 @@
+import { Mat3 } from "./Mat3";
+import { Vec3 } from "./Vec3";
+import { Vec4 } from "./Vec4";
+export type NumberArray16 = [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+/**
+ * Class represents a 4x4 matrix.
+ * @class
+ */
+export declare class Mat4 {
+    /**
+     * A 4x4 matrix, index-able as a column-major order array.
+     * @public
+     * @type {Array.<number>}
+     */
+    _m: NumberArray16;
+    constructor();
+    /**
+     * Returns identity matrix instance.
+     * @static
+     * @returns {Mat4} -
+     */
+    static identity(): Mat4;
+    /**
+     * Sets column-major order array matrix.
+     * @public
+     * @param {Array.<number>} m - Matrix array.
+     * @returns {Mat4} -
+     */
+    set(m: NumberArray16): Mat4;
+    /**
+     * Duplicates a Matrix3 instance.
+     * @public
+     * @returns {Mat4} -
+     */
+    clone(): Mat4;
+    /**
+     * Copy matrix.
+     * @public
+     * @param {Mat4} a - Matrix to copy.
+     * @return {Mat4}
+     */
+    copy(a: Mat4): Mat4;
+    /**
+     * Converts to 3x3 matrix.
+     * @public
+     * @returns {Mat3} -
+     */
+    toMatrix3(): Mat3;
+    /**
+     * Multiply to 3d vector.
+     * @public
+     * @param {Vec3} p - 3d vector.
+     * @returns {Vec3} -
+     */
+    mulVec3(p: Vec3): Vec3;
+    /**
+     * Multiply to 4d vector.
+     * @public
+     * @param {Vec4} p - 4d vector.
+     * @returns {Vec4} -
+     */
+    mulVec4(p: Vec4): Vec4;
+    /**
+     * Creates an inverse 3x3 matrix of the current.
+     * @public
+     * @returns {Mat3} -
+     */
+    toInverseMatrix3(): Mat3 | undefined;
+    /**
+     * Creates an inverse matrix of the current.
+     * @public
+     * @returns {Mat4} -
+     */
+    inverseTo(res?: Mat4): Mat4;
+    /**
+     * Creates a transposed matrix of the current.
+     * @public
+     * @returns {Mat4} -
+     */
+    transposeTo(): Mat4;
+    /**
+     * Sets matrix to identity.
+     * @public
+     * @returns {Mat4} -
+     */
+    setIdentity(): Mat4;
+    /**
+     * Computes the product of two matrices.
+     * @public
+     * @param {Mat4} mx - Matrix to multiply.
+     * @returns {Mat4} -
+     */
+    mul(mx: Mat4): Mat4;
+    /**
+     * Add translation vector to the current matrix.
+     * @public
+     * @param {Vec3} v - Translate vector.
+     * @returns {Mat4} -
+     */
+    translate(v: Vec3): Mat4;
+    /**
+     * Sets translation matrix to the position.
+     * @public
+     * @param {Vec3} v - Translate to position.
+     * @returns {Mat4} -
+     */
+    translateToPosition(v: Vec3): Mat4;
+    /**
+     * Rotate current matrix around the aligned axis and angle.
+     * @public
+     * @param {Vec3} u - Aligned axis.
+     * @param {number} angle - Aligned axis angle in radians.
+     * @returns {Mat4} -
+     */
+    rotate(u: Vec3, angle: number): Mat4;
+    /**
+     * Sets current rotation matrix around the aligned axis and angle.
+     * @public
+     * @param {Vec3} u - Aligned axis.
+     * @param {number} angle - Aligned axis angle in radians.
+     * @returns {Mat4} -
+     */
+    setRotation(u: Vec3, angle: number): Mat4;
+    /**
+     * Gets the rotation matrix from one vector to another.
+     * @public
+     * @param {Vec3} a - First vector.
+     * @param {Vec3} b - Second vector.
+     * @returns {Mat4} -
+     */
+    rotateBetweenVectors(a: Vec3, b: Vec3): Mat4;
+    /**
+     * Scale current matrix to the vector values.
+     * @public
+     * @param {Vec3} v - Scale vector.
+     * @returns {Mat4} -
+     */
+    scale(v: Vec3): Mat4;
+    /**
+     * Sets perspective projection matrix frustum values.
+     * @public
+     * @param {number} left -
+     * @param {number} right -
+     * @param {number} bottom -
+     * @param {number} top -
+     * @param {number} near -
+     * @param {number} far -
+     * @returns {Mat4} -
+     */
+    setPerspective(left: number, right: number, bottom: number, top: number, near: number, far: number): Mat4;
+    /**
+     * Creates current orthographic projection matrix.
+     * @public
+     * @param {number} left -
+     * @param {number} right -
+     * @param {number} bottom -
+     * @param {number} top -
+     * @param {number} near -
+     * @param {number} far -
+     * @return {Mat4} -
+     */
+    setOrtho(left: number, right: number, bottom: number, top: number, near: number, far: number): Mat4;
+    /**
+     * Sets current rotation matrix by euler's angles.
+     * @public
+     * @param {number} ax - Rotation angle in radians around X axis.
+     * @param {number} ay - Rotation angle in radians around Y axis.
+     * @param {number} az - Rotation angle in radians around Z axis.
+     * @returns {Mat4} -
+     */
+    eulerToMatrix(ax: number, ay: number, az: number): Mat4;
+}
+/**
+ * Mat4 factory.
+ * @static
+ * @returns {Mat4} -
+ */
+export declare function mat4(): Mat4;

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

@@ -0,0 +1,20 @@
+import { Vec3 } from "./Vec3";
+import { Line3 } from "./Line3";
+/**
+ * Plane class.
+ * @constructor
+ * @param {Vec3} [p] - Plane point.
+ * @param {Vec3} [n] - Planet normal.
+ */
+declare class Plane {
+    p: Vec3;
+    n: Vec3;
+    constructor(p: Vec3, n: Vec3);
+    set(p: Vec3, n: Vec3): void;
+    getNormal(): Vec3;
+    distance(p: Vec3): number;
+    getProjection(v: Vec3, def?: Vec3): Vec3;
+    getProjectionPoint(p: Vec3, vh?: Vec3): Vec3;
+    getIntersection(Pn1: Plane, Pn2: Plane, L: Line3): number;
+}
+export { Plane };

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

@@ -0,0 +1,373 @@
+import { Vec3 } from "./Vec3";
+import { Mat4 } from "./Mat4";
+import { Mat3 } from "./Mat3";
+/**
+ * A set of 4-dimensional coordinates used to represent rotation in 3-dimensional space.
+ * @constructor
+ * @param {Number} [x=0.0] The X component.
+ * @param {Number} [y=0.0] The Y component.
+ * @param {Number} [z=0.0] The Z component.
+ * @param {Number} [w=0.0] The W component.
+ */
+export declare class Quat {
+    /**
+     * The X component.
+     * @public
+     * @type {Number}
+     * @default 0.0
+     */
+    x: number;
+    /**
+     * The Y component.
+     * @public
+     * @type {Number}
+     * @default 0.0
+     */
+    y: number;
+    /**
+     * The Z component.
+     * @public
+     * @type {Number}
+     * @default 0.0
+     */
+    z: number;
+    /**
+     * The W component.
+     * @public
+     * @type {Number}
+     * @default 0.0
+     */
+    w: number;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    /**
+     * Identity Quat.
+     * @const
+     * @type {Quat}
+     */
+    static get IDENTITY(): Quat;
+    /**
+     * Returns a Quat represents rotation around X axis.
+     * @static
+     * @param {number} a - The angle in radians to rotate around the axis.
+     * @returns {Quat} -
+     */
+    static xRotation(a: number): Quat;
+    /**
+     * Returns a Quat represents rotation around Y axis.
+     * @static
+     * @param {number} a - The angle in radians to rotate around the axis.
+     * @returns {Quat} -
+     */
+    static yRotation(a: number): Quat;
+    /**
+     * Returns a Quat represents rotation around Z axis.
+     * @static
+     * @param {number} a - The angle in radians to rotate around the axis.
+     * @returns {Quat} -
+     */
+    static zRotation(a: number): Quat;
+    /**
+     * Computes a Quat representing a rotation around an axis.
+     * @static
+     * @param {Vec3} axis - The axis of rotation.
+     * @param {number} [angle=0.0] The angle in radians to rotate around the axis.
+     * @returns {Quat} -
+     */
+    static axisAngleToQuat(axis: Vec3, angle?: number): Quat;
+    /**
+     * Computes a rotation from the given heading and up vector.
+     * @static
+     * @param {Vec3} forward - Heading target coordinates.
+     * @param {Vec3} up - Up vector.
+     * @returns {Quat} -
+     */
+    static getLookRotation(forward: Vec3, up: Vec3): Quat;
+    /**
+     * Computes a Quat from source point heading to the destination point.
+     * @static
+     * @param {Vec3} sourcePoint - Source coordinate.
+     * @param {Vec3} destPoint - Destination coordinate.
+     * @returns {Quat} -
+     */
+    static getLookAtSourceDest(sourcePoint: Vec3, destPoint: Vec3): Quat;
+    /**
+     * Compute rotation between two vectors.
+     * @static
+     * @param {Vec3} u - First vector.
+     * @param {Vec3} v - Second vector.
+     * @returns {Quat} -
+     */
+    static getRotationBetweenVectors(u: Vec3, v: Vec3): Quat;
+    /**
+     * Compute rotation between two vectors.
+     * @static
+     * @param {Vec3} u - First vector.
+     * @param {Vec3} v - Second vector.
+     * @param {Quat} res
+     * @returns {Quat} -
+     */
+    static getRotationBetweenVectorsRes(u: Vec3, v: Vec3, res: Quat): Quat;
+    /**
+     * Compute rotation between two vectors with around vector up
+     * for exactly opposite vectors. If vectors exactly in the same
+     * direction as returns identity Quat.
+     * @static
+     * @param {Vec3} source - First vector.
+     * @param {Vec3} dest - Second vector.
+     * @param {Vec3} up - Up vector.
+     * @returns {Quat} -
+     */
+    static getRotationBetweenVectorsUp(source: Vec3, dest: Vec3, up: Vec3): Quat;
+    /**
+     * Returns true if the components are zero.
+     * @public
+     * @returns {boolean} -
+     */
+    isZero(): boolean;
+    /**
+     * Clear Quat. Sets zeroes.
+     * @public
+     * @returns {Quat} -
+     */
+    clear(): Quat;
+    /**
+     * Sets Quat values.
+     * @public
+     * @param {Number} [x=0.0] The X component.
+     * @param {Number} [y=0.0] The Y component.
+     * @param {Number} [z=0.0] The Z component.
+     * @param {Number} [w=0.0] The W component.
+     * @returns {Quat} -
+     */
+    set(x: number, y: number, z: number, w: number): Quat;
+    /**
+     * Copy Quat values.
+     * @public
+     * @param {Quat} q - Copy Quat.
+     * @returns {Quat} -
+     */
+    copy(q: Quat): Quat;
+    /**
+     * Set current Quat instance to identity Quat.
+     * @public
+     * @returns {Quat} -
+     */
+    setIdentity(): Quat;
+    /**
+     * Duplicates a Quat instance.
+     * @public
+     * @returns {Quat} -
+     */
+    clone(): Quat;
+    /**
+     * Computes the componentwise sum of two Quats.
+     * @public
+     * @param {Quat} q - Quat to add.
+     * @returns {Quat} -
+     */
+    add(q: Quat): Quat;
+    /**
+     * Computes the componentwise difference of two Quats.
+     * @public
+     * @param {Quat} q - Quat to subtract.
+     * @returns {Quat} -
+     */
+    sub(q: Quat): Quat;
+    /**
+     * Multiplies the provided Quat componentwise by the provided scalar.
+     * @public
+     * @param {Number} scale - The scalar to multiply with.
+     * @returns {Quat} -
+     */
+    scaleTo(scale: number): Quat;
+    /**
+     * Multiplies the provided Quat componentwise.
+     * @public
+     * @param {Number} scale - The scalar to multiply with.
+     * @returns {Quat} -
+     */
+    scale(scale: number): Quat;
+    /**
+     * Converts Quat values to array.
+     * @public
+     * @returns {Array.<number>} - (exactly 4 entries)
+     */
+    toVec(): [number, number, number, number];
+    /**
+     * Sets current quaternion by spherical coordinates.
+     * @public
+     * @param {number} lat - Latitude.
+     * @param {number} lon - Longitude.
+     * @param {number} angle - Angle in radians.
+     * @returns {Quat} -
+     */
+    setFromSphericalCoords(lat: number, lon: number, angle: number): Quat;
+    /**
+     * Sets rotation with the given heading and up vectors.
+     * @static
+     * @param {Vec3} forward - Heading target coordinates.
+     * @param {Vec3} up - Up vector.
+     * @returns {Quat} -
+     */
+    setLookRotation(forward: Vec3, up: Vec3): Quat;
+    /**
+     * Gets spherical coordinates.
+     * @public
+     * @returns {Object} Returns object with latitude, longitude and alpha.
+     */
+    toSphericalCoords(): any;
+    /**
+     * Sets current Quat representing a rotation around an axis.
+     * @public
+     * @param {Vec3} axis - The axis of rotation.
+     * @param {number} angle The angle in radians to rotate around the axis.
+     * @returns {Quat} -
+     */
+    setFromAxisAngle(axis: Vec3, angle: number): Quat;
+    /**
+     * Returns axis and angle of the current Quat.
+     * @public
+     * @returns {Object} -
+     */
+    getAxisAngle(): any;
+    /**
+     * Sets current Quat by Euler's angles.
+     * @public
+     * @param {number} pitch - Pitch angle in degrees.
+     * @param {number} yaw - Yaw angle in degrees.
+     * @param {number} roll - Roll angle in degrees.
+     * @returns {Quat} -
+     */
+    setFromEulerAngles(pitch: number, yaw: number, roll: number): Quat;
+    /**
+     * Returns Euler's angles of the current Quat.
+     * @public
+     * @returns {Object} -
+     */
+    getEulerAngles(): any;
+    /**
+     * Computes a Quat from the provided 4x4 matrix instance.
+     * @public
+     * @param {Mat4} mx - The rotation matrix.
+     * @returns {Quat} -
+     */
+    setFromMatrix4(mx: Mat4): Quat;
+    /**
+     * Converts current Quat to the rotation 4x4 matrix.
+     * @public
+     * @params {Mat4} [out] - Output matrix
+     * @returns {Mat4} -
+     */
+    getMat4(out?: Mat4): Mat4;
+    /**
+     * Converts current Quat to the rotation 3x3 matrix.
+     * @public
+     * @returns {Mat3} -
+     * @todo NOT TESTED
+     */
+    getMat3(): Mat3;
+    /**
+     * Returns quaternion and vector production.
+     * @public
+     * @param {Vec3} v - 3d Vector.
+     * @returns {Vec3} -
+     */
+    mulVec3(v: Vec3): Vec3;
+    /**
+     * Computes the product of two Quats.
+     * @public
+     * @param {Quat} q - Quat to multiply.
+     * @returns {Quat} -
+     */
+    mul(q: Quat): Quat;
+    /**
+     * Computes the product of two Quats.
+     * @public
+     * @param {Quat} q - Quat to multiply.
+     * @returns {Quat} -
+     */
+    mulA(q: Quat): Quat;
+    /**
+     * Gets the conjugate of the Quat.
+     * @public
+     * @returns {Quat} -
+     */
+    conjugate(): Quat;
+    /**
+     * Computes the inverse of the Quat.
+     * @public
+     * @returns {Quat} -
+     */
+    inverse(): Quat;
+    /**
+     * Computes a magnitude of the Quat.
+     * @public
+     * @returns {number} -
+     */
+    magnitude(): number;
+    /**
+     * Computes a squared magnitude of the Quat.
+     * @public
+     * @returns {number} -
+     */
+    magnitude2(): number;
+    /**
+     * Computes the dot (scalar) product of two Quats.
+     * @public
+     * @param {Quat} q - Second quaternion.
+     * @returns {number} -
+     */
+    dot(q: Quat): number;
+    /**
+     * Current Quat normalization.
+     * @public
+     * @returns {Quat} -
+     */
+    normalize(): Quat;
+    /**
+     * Compares two Quats.
+     * @public
+     * @param {Quat} q - Second quaternion.
+     * @returns {Boolean} -
+     */
+    isEqual(q: Quat): boolean;
+    /**
+     * Performs a spherical linear interpolation between two Quats.
+     * @public
+     * @param {Quat} b - The end rotation Quat.
+     * @param {number} t - interpolation amount between the two Quats.
+     * @returns {Quat} -
+     */
+    slerp(b: Quat, t: number): Quat;
+    /**
+     * Returns a roll angle in radians.
+     * @public
+     * @param {Boolean} [reprojectAxis] -
+     * @returns {Number} -
+     */
+    getRoll(reprojectAxis?: boolean): number;
+    /**
+     * Returns a pitch angle in radians.
+     * @public
+     * @param {Boolean} [reprojectAxis] -
+     * @returns {number} -
+     */
+    getPitch(reprojectAxis?: boolean): number;
+    /**
+     * Returns a yaw angle in radians.
+     * @public
+     * @param {Boolean} [reprojectAxis] -
+     * @returns {number} -
+     */
+    getYaw(reprojectAxis?: boolean): number;
+}
+/**
+ * Creates Quat instance.
+ * @function
+ * @param {Number} [x=0.0] The X component.
+ * @param {Number} [y=0.0] The Y component.
+ * @param {Number} [z=0.0] The Z component.
+ * @param {Number} [w=0.0] The W component.
+ * @returns {Quat} -
+ */
+export declare function quat(x?: number, y?: number, z?: number, w?: number): Quat;

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

@@ -0,0 +1,76 @@
+import { Box } from "../bv/Box";
+import { Sphere } from "../bv/Sphere";
+import { Vec3 } from "./Vec3";
+/**
+ * Represents a ray that extends infinitely from the provided origin in the provided direction.
+ * @class
+ * @param {Vec3} origin - The origin of the ray.
+ * @param {Vec3} direction - The direction of the ray.
+ */
+export declare class Ray {
+    /**
+     * The origin of the ray.
+     * @public
+     * @type {Vec3}
+     */
+    origin: Vec3;
+    /**
+     * The direction of the ray.
+     * @public
+     * @type {Vec3}
+     */
+    direction: Vec3;
+    constructor(origin?: Vec3, direction?: Vec3);
+    /** @const */
+    static get OUTSIDE(): number;
+    /** @const */
+    static get INSIDE(): number;
+    /** @const */
+    static get INPLANE(): number;
+    /** @const */
+    static get AWAY(): number;
+    /**
+     * Sets a ray parameters.
+     * @public
+     * @param {Vec3} origin - The origin of the ray.
+     * @param {Vec3} direction - The direction of the ray.
+     * @returns {Ray}
+     */
+    set(origin: Vec3, direction: Vec3): Ray;
+    /**
+     * Computes the point along the ray on the distance.
+     * @public
+     * @param {number} distance - Point distance.
+     * @returns {Vec3}
+     */
+    getPoint(distance: number): Vec3;
+    /**
+     * Returns ray hit a triange result.
+     * @public
+     * @param {Vec3} v0 - First triangle corner coordinate.
+     * @param {Vec3} v1 - Second triangle corner coordinate.
+     * @param {Vec3} v2 - Third triangle corner coordinate.
+     * @param {Vec3} res - Hit point object pointer that stores hit result.
+     * @returns {number} - Hit code, could 0 - og.Ray.OUTSIDE, 1 - og.Ray.INSIDE,
+     *      2 - og.Ray.INPLANE and 3 - og.Ray.AWAY(ray goes away from triangle).
+     */
+    hitTriangle(v0: Vec3, v1: Vec3, v2: Vec3, res: Vec3): number;
+    /**
+     * Gets a ray hit a plane result. If the ray cross the plane returns 1 - og.Ray.INSIDE otherwise returns 0 - og.Ray.OUTSIDE.
+     * @public
+     * @param {Vec3} v0 - First plane point.
+     * @param {Vec3} v1 - Second plane point.
+     * @param {Vec3} v2 - Third plane point.
+     * @param {Vec3} res - Hit point object pointer that stores hit result.
+     * @returns {number}
+     */
+    hitPlane(v0: Vec3, v1: Vec3, v2: Vec3, res: Vec3): number;
+    /**
+     * Returns a ray hit sphere coordiante. If there isn't hit returns null.
+     * @public
+     * @param {Sphere} sphere - Sphere object.
+     * @returns {Vec3}
+     */
+    hitSphere(sphere: Sphere): Vec3 | null;
+    hitBox(box: Box): void;
+}