@openglobus/og 0.18.0 → 0.18.2

package/{src/math/Plane.ts → lib/js/math/Plane.js}

@@ -1,8 +1,6 @@
-import {EPS5} from "../math";
-import {Vec3} from "./Vec3";
-import {Line3} from "./Line3";
-
-const DISJOINT = 0
+import { EPS5 } from "../math";
+import { Vec3 } from "./Vec3";
+const DISJOINT = 0;
 const COINCIDE = 1;
 const INTERSECT = 2;
 /**
@@ -12,52 +10,39 @@ const INTERSECT = 2;
  * @param {Vec3} [n] - Planet normal.
  */
 class Plane {
-    public p: Vec3;
-    public n: Vec3;
-
-    constructor(p: Vec3, n: Vec3) {
+    constructor(p, n) {
         this.p = p ? p.clone() : new Vec3();
         this.n = n ? n.clone() : this.p.normal();
     }
-
-    public set(p: Vec3, n: Vec3) {
+    set(p, n) {
         this.p.copy(p);
         this.n.copy(n);
     }
-
-    public getNormal(): Vec3 {
+    getNormal() {
         return this.n.clone();
     }
-
-    public distance(p: Vec3): number {
+    distance(p) {
         let pp = this.getProjection(p);
         return p.distance(pp);
     }
-
-    public getProjection(v: Vec3, def?: Vec3): Vec3 {
+    getProjection(v, def) {
         return Vec3.proj_b_to_plane(v, this.n, def);
     }
-
-    public getProjectionPoint(p: Vec3, vh?: Vec3): Vec3 {
-        let v = p.sub(this.p),
-            n = this.n,
-            dist = v.dot(n);
-
+    getProjectionPoint(p, vh) {
+        let v = p.sub(this.p), n = this.n, dist = v.dot(n);
         if (vh) {
             vh.copy(n.scale(dist));
-        } else {
+        }
+        else {
             vh = n.scale(dist);
         }
         return p.sub(vh);
     }
-
-    public getIntersection(Pn1: Plane, Pn2: Plane, L: Line3): number {
+    getIntersection(Pn1, Pn2, L) {
         let u = Pn1.n.cross(Pn2.n);
-
         let ax = u.x >= 0 ? u.x : -u.x;
         let ay = u.y >= 0 ? u.y : -u.y;
         let az = u.z >= 0 ? u.z : -u.z;
-
         // test if the two planes are parallel
         if (ax + ay + az < EPS5) {
             // Pn1 and Pn2 are near parallel
@@ -66,48 +51,50 @@ class Plane {
             if (Pn1.n.dot(v) == 0) {
                 // Pn2.V0 lies in Pn1
                 return COINCIDE; // Pn1 and Pn2 coincide
-            } else {
+            }
+            else {
                 return DISJOINT; // Pn1 and Pn2 are disjoint
             }
         }
-
         // Pn1 and Pn2 intersect in a line
         // first determine max abs coordinate of cross product
         let maxc; // max coordinate
         if (ax > ay) {
             if (ax > az) {
                 maxc = 1;
-            } else {
+            }
+            else {
                 maxc = 3;
             }
-        } else {
+        }
+        else {
             if (ay > az) {
                 maxc = 2;
-            } else {
+            }
+            else {
                 maxc = 3;
             }
         }
-
         // next, to get a point on the intersect line
         // zero the max coord, and solve for the other two
         let iP = new Vec3(); // intersect point
-
         let d1, d2; // the constants in the 2 plane equations
         d1 = -Pn1.n.dot(Pn1.p); // note: could be pre-stored  with plane
         d2 = -Pn2.n.dot(Pn2.p); // ditto
-
         // select max coordinate
         if (maxc === 1) {
             // intersect with x=0
             iP.x = 0;
             iP.y = (d2 * Pn1.n.z - d1 * Pn2.n.z) / u.x;
             iP.z = (d1 * Pn2.n.y - d2 * Pn1.n.y) / u.x;
-        } else if (maxc === 2) {
+        }
+        else if (maxc === 2) {
             // intersect with y=0
             iP.x = (d1 * Pn2.n.z - d2 * Pn1.n.z) / u.y;
             iP.y = 0;
             iP.z = (d2 * Pn1.n.x - d1 * Pn2.n.x) / u.y;
-        } else if (maxc === 3) {
+        }
+        else if (maxc === 3) {
             // intersect with z=0
             iP.x = (d2 * Pn1.n.y - d1 * Pn2.n.y) / u.z;
             iP.y = (d1 * Pn2.n.x - d2 * Pn1.n.x) / u.z;
@@ -118,5 +105,4 @@ class Plane {
         return INTERSECT;
     }
 }
-
-export {Plane};
+export { Plane };

package/lib/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;