@openglobus/og 0.11.7 → 0.12.3

package/types/math/Quat.d.ts

@@ -0,0 +1,379 @@
+/**
+ * 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 function quat(x?: number, y?: number, z?: number, w?: number): Quat;
+/**
+ * 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 class Quat {
+    /**
+     * 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 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 exaclty in the same
+     * direction than 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;
+    /**
+     * @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.
+     */
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    /**
+     * The X component.
+     * @public
+     * @type {Number}
+     * @default 0.0
+     */
+    public x: number;
+    /**
+     * The Y component.
+     * @public
+     * @type {Number}
+     * @default 0.0
+     */
+    public y: number;
+    /**
+     * The Z component.
+     * @public
+     * @type {Number}
+     * @default 0.0
+     */
+    public z: number;
+    /**
+     * The W component.
+     * @public
+     * @type {Number}
+     * @default 0.0
+     */
+    public w: number;
+    /**
+     * Returns true if the components are zero.
+     * @public
+     * @param {Quat} q - Quat to subtract.
+     * @returns {Quat} -
+     */
+    public isZero(): Quat;
+    /**
+     * Clear Quat. Sets zeroes.
+     * @public
+     * @returns {Quat} -
+     */
+    public 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} -
+     */
+    public set(x?: number, y?: number, z?: number, w?: number): Quat;
+    /**
+     * Copy Quat values.
+     * @public
+     * @param {Quat} q - Copy Quat.
+     * @returns {Quat} -
+     */
+    public copy(q: Quat): Quat;
+    /**
+     * Set current Quat instance to identity Quat.
+     * @public
+     * @returns {Quat} -
+     */
+    public setIdentity(): Quat;
+    /**
+     * Duplicates a Quat instance.
+     * @public
+     * @returns {Quat} -
+     */
+    public clone(): Quat;
+    /**
+     * Computes the componentwise sum of two Quats.
+     * @public
+     * @param {Quat} q - Quat to add.
+     * @returns {Quat} -
+     */
+    public add(q: Quat): Quat;
+    /**
+     * Computes the componentwise difference of two Quats.
+     * @public
+     * @param {Quat} q - Quat to subtract.
+     * @returns {Quat} -
+     */
+    public sub(q: Quat): Quat;
+    /**
+     * Multiplies the provided Quat componentwise by the provided scalar.
+     * @public
+     * @param {Number} scale - The scalar to multiply with.
+     * @returns {Quat} -
+     */
+    public scaleTo(scale: number): Quat;
+    /**
+     * Multiplies the provided Quat componentwise.
+     * @public
+     * @param {Number} scale - The scalar to multiply with.
+     * @returns {Quat} -
+     */
+    public scale(scale: number): Quat;
+    /**
+     * Converts Quat values to array.
+     * @public
+     * @returns {Array.<number>} - (exactly 4 entries)
+     */
+    public toVec(): Array<number>;
+    /**
+     * Sets current quaternion by spherical coordinates.
+     * @public
+     * @param {number} lat - Latitude.
+     * @param {number} lon - Longitude.
+     * @param {number} angle - Angle in radians.
+     * @returns {Quat} -
+     */
+    public 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.
+     */
+    public 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} -
+     */
+    public setFromAxisAngle(axis: Vec3, angle: number): Quat;
+    /**
+     * Returns axis and angle of the current Quat.
+     * @public
+     * @returns {Object} -
+     */
+    public 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} -
+     */
+    public setFromEulerAngles(pitch: number, yaw: number, roll: number): Quat;
+    /**
+     * Returns Euler's angles of the current Quat.
+     * @public
+     * @returns {Object} -
+     */
+    public getEulerAngles(): any;
+    /**
+     * Computes a Quat from the provided 4x4 matrix instance.
+     * @public
+     * @param {Mat4} m - The rotation matrix.
+     * @returns {Quat} -
+     */
+    public setFromMatrix4(m: Mat4): Quat;
+    /**
+     * Converts current Quat to the rotation 4x4 matrix.
+     * @public
+     * @returns {Mat4} -
+     */
+    public getMat4(out: any): Mat4;
+    /**
+     * Converts current Quat to the rotation 3x3 matrix.
+     * @public
+     * @returns {Mat3} -
+     * @todo NOT TESTED
+     */
+    public getMat3(): Mat3;
+    /**
+     * Returns quatrenion and vector production.
+     * @public
+     * @param {Vec3} v - 3d Vector.
+     * @returns {Vec3} -
+     */
+    public mulVec3(v: Vec3): Vec3;
+    /**
+     * Computes the product of two Quats.
+     * @public
+     * @param {Quat} q - Quat to multiply.
+     * @returns {Quat} -
+     */
+    public mul(q: Quat): Quat;
+    /**
+     * Computes the product of two Quats.
+     * @public
+     * @param {Quat} q - Quat to multiply.
+     * @returns {Quat} -
+     */
+    public mulA(q: Quat): Quat;
+    /**
+     * Gets the conjugate of the Quat.
+     * @public
+     * @returns {Quat} -
+     */
+    public conjugate(): Quat;
+    /**
+     * Computes the inverse of the Quat.
+     * @public
+     * @returns {Quat} -
+     */
+    public inverse(): Quat;
+    /**
+     * Computes a magnitude of the Quat.
+     * @public
+     * @returns {number} -
+     */
+    public magnitude(): number;
+    /**
+     * Computes a squared magnitude of the Quat.
+     * @public
+     * @returns {number} -
+     */
+    public magnitude2(): number;
+    /**
+     * Computes the dot (scalar) product of two Quats.
+     * @public
+     * @param {Quat} q - Second quatrnion.
+     * @returns {number} -
+     */
+    public dot(q: Quat): number;
+    /**
+     * Current Quat normalization.
+     * @public
+     * @returns {Quat} -
+     */
+    public normalize(): Quat;
+    /**
+     * Compares two Quats.
+     * @public
+     * @param {Quat} q - Second quatrnion.
+     * @returns {Boolean} -
+     */
+    public 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} -
+     */
+    public slerp(b: Quat, t: number): Quat;
+    /**
+     * Returns a roll angle in radians.
+     * @public
+     * @param {Boolean} [reprojectAxis] -
+     * @returns {Number} -
+     */
+    public getRoll(reprojectAxis?: boolean): number;
+    /**
+     * Returns a pitch angle in radians.
+     * @public
+     * @param {Boolean} [reprojectAxis] -
+     * @returns {number} -
+     */
+    public getPitch(reprojectAxis?: boolean): number;
+    /**
+     * Returns a yaw angle in radians.
+     * @public
+     * @param {Boolean} [reprojectAxis] -
+     * @returns {number} -
+     */
+    public getYaw(reprojectAxis?: boolean): number;
+}
+import { Vec3 } from "./Vec3.js";
+import { Mat4 } from "./Mat4.js";
+import { Mat3 } from "./Mat3.js";

package/types/math/Ray.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Ray object creator.
+ * @function
+ * @param {Vec3} origin - The origin of the ray.
+ * @param {Vec3} direction - The direction of the ray.
+ * @returns {Ray}
+ */
+export function ray(origin: Vec3, direction: Vec3): Ray;
+/**
+ * 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 class Ray {
+    /** @const */
+    static get OUTSIDE(): number;
+    /** @const */
+    static get INSIDE(): number;
+    /** @const */
+    static get INPLANE(): number;
+    /** @const */
+    static get AWAY(): number;
+    constructor(origin: any, direction: any);
+    /**
+     * The origin of the ray.
+     * @public
+     * @type {Vec3}
+     */
+    public origin: Vec3;
+    /**
+     * The direction of the ray.
+     * @public
+     * @type {Vec3}
+     */
+    public direction: Vec3;
+    /**
+     * Sets a ray parameters.
+     * @public
+     * @param {Vec3} origin - The origin of the ray.
+     * @param {Vec3} direction - The direction of the ray.
+     * @returns {Ray}
+     */
+    public set(origin: Vec3, direction: Vec3): Ray;
+    /**
+     * Computes the point along the ray on the distance.
+     * @public
+     * @param {number} distance - Point distance.
+     * @returns {Vec3}
+     */
+    public 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).
+     */
+    public hitTriangle(v0: Vec3, v1: Vec3, v2: Vec3, res: Vec3, normal: any): 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}
+     */
+    public 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}
+     */
+    public hitSphere(sphere: Sphere): Vec3;
+    hitBox(box: any): void;
+}
+import { Vec3 } from "./Vec3.js";