@openglobus/og 0.10.4 → 0.11.1

package/types/math/Mat4.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Mat4 factory.
+ * @static
+ * @returns {og.Mat4} -
+ */
+export function mat4(): any;
+export class Mat4 {
+    /**
+     * Sets column-major order array matrix.
+     * @public
+     * @param {Array.<number>} m - Matrix array.
+     * @returns {og.Mat4} -
+     */
+    public set(m: Array<number>): any;
+    /**
+     * Duplicates a Matrix3 instance.
+     * @public
+     * @returns {og.Mat4} -
+     */
+    public clone(): any;
+    /**
+     * Copy matrix.
+     * @public
+     * @param {og.Mat3} a - Matrix to copy.
+     */
+    public copy(a: any): void;
+    /**
+     * Converts to 3x3 matrix.
+     * @public
+     * @returns {og.Mat3} -
+     */
+    public toMatrix3(): any;
+    /**
+     * Multiply to 3d vector.
+     * @public
+     * @param {og.Vec3} p - 3d vector.
+     * @returns {og.Vec3} -
+     */
+    public mulVec3(p: any): any;
+    /**
+     * Multiply to 4d vector.
+     * @public
+     * @param {og.Vec4} p - 4d vector.
+     * @returns {og.Vec4} -
+     */
+    public mulVec4(p: any): any;
+    /**
+     * Creates an inversed 3x3 matrix of the current.
+     * @public
+     * @returns {og.Mat3} -
+     */
+    public toInverseMatrix3(): any;
+    /**
+     * Creates an inversed matrix of the current.
+     * @public
+     * @returns {og.Mat4} -
+     */
+    public inverseTo(res: any): any;
+    /**
+     * Creates a trasposed matrix of the current.
+     * @public
+     * @returns {og.Mat4} -
+     */
+    public transposeTo(): any;
+    /**
+     * Sets matrix to identity.
+     * @public
+     * @returns {og.Mat4} -
+     */
+    public setIdentity(): any;
+    /**
+     * Computes the product of two matrices.
+     * @public
+     * @param {og.Mat4} mx - Matrix to multiply.
+     * @returns {og.Mat4} -
+     */
+    public mul(mx: any): any;
+    /**
+     * Add translation vector to the current matrix.
+     * @public
+     * @param {og.Vec3} v - Translate vector.
+     * @returns {og.Mat4} -
+     */
+    public translate(v: any): any;
+    /**
+     * Sets translation matrix to the position.
+     * @public
+     * @param {og.Vec3} v - Translate to position.
+     * @returns {og.Mat4} -
+     */
+    public translateToPosition(v: any): any;
+    /**
+     * Rotate currrent matrix around the aligned axis and angle.
+     * @public
+     * @param {og.Vec3} u - Aligned axis.
+     * @param {number} angle - Aligned axis angle in radians.
+     * @returns {og.Mat4} -
+     * @todo: OPTIMIZE: reveal multiplication
+     */
+    public rotate(u: any, angle: number): any;
+    /**
+     * Sets current rotation matrix around the aligned axis and angle.
+     * @public
+     * @param {og.Vec3} u - Aligned axis.
+     * @param {number} angle - Aligned axis angle in radians.
+     * @returns {og.Mat4} -
+     */
+    public setRotation(u: any, angle: number): any;
+    /**
+     * Gets the rotation matrix from one vector to another.
+     * @public
+     * @param {og.Vec3} a - Firtst vector.
+     * @param {og.Vec3} b - Second vector.
+     * @returns {og.Mat4} -
+     */
+    public rotateBetweenVectors(a: any, b: any): any;
+    /**
+     * Scale current matrix to the vector values.
+     * @public
+     * @param {og.Vec3} v - Scale vector.
+     * @returns {og.Mat4} -
+     */
+    public scale(v: any): any;
+    /**
+     * 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 {og.Mat4} -
+     */
+    public setPerspective(left: number, right: number, bottom: number, top: number, near: number, far: number): any;
+    /**
+     * 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 {og.Mat4} -
+     */
+    public setOrtho(left: number, right: number, bottom: number, top: number, near: number, far: number): any;
+    /**
+     * Sets current rotation matrix by euler's angles.
+     * @public
+     * @param {number} ax - Rotation angle in radians arond X axis.
+     * @param {number} ay - Rotation angle in radians arond Y axis.
+     * @param {number} az - Rotation angle in radians arond Z axis.
+     * @returns {og.Mat4} -
+     */
+    public eulerToMatrix(ax: number, ay: number, az: number): any;
+}

package/types/math/Plane.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Plane class.
+ * @constructor
+ * @param {og.Vec3} [p] - Plane point.
+ * @param {og.Vec3} [n] - Planet normal.
+ */
+export class Plane {
+    constructor(p: any, n: any);
+    p: any;
+    n: any;
+    set(p: any, n: any): void;
+    getNormal(): any;
+    distance(p: any): any;
+    getProjection(v: any, def: any): any;
+    getProjectionPoint(p: any, vh: any): any;
+    getIntersection(Pn1: any, Pn2: any, L: any): 1 | 0 | 2;
+}

package/types/math/Vec2.d.ts

@@ -0,0 +1,308 @@
+/**
+ * Vector 2d object creator.
+ * @function
+ * @param {number} [x] - First cvalue.
+ * @param {number} [y] - Second value.
+ * @returns {og.math.Vec2}
+ */
+export function vec2(x?: number, y?: number): any;
+/**
+ * Class represents a 3d vector.
+ * @class
+ * @param {number} [x] - First value.
+ * @param {number} [y] - Second value.
+ */
+export class Vec2 {
+    /** @const */
+    static get UP(): Vec2;
+    /** @const */
+    static get DOWN(): Vec2;
+    /** @const */
+    static get RIGHT(): Vec2;
+    /** @const */
+    static get LEFT(): Vec2;
+    /** @const */
+    static get ZERO(): Vec2;
+    /**
+     * Returns summary vector.
+     * @static
+     * @param {og.math.Vec2} a - First vector.
+     * @param {og.math.Vec2} b - Second vector.
+     * @returns {og.math.Vec2} - Summary vector.
+     */
+    static add(a: any, b: any): any;
+    /**
+     * Returns two vectors subtraction.
+     * @static
+     * @param {og.math.Vec2} a - First vector.
+     * @param {og.math.Vec2} b - Second vector.
+     * @returns {og.math.Vec2} - Vectors subtraction.
+     */
+    static sub(a: any, b: any): any;
+    /**
+     * Returns scaled vector.
+     * @static
+     * @param {og.math.Vec2} a - Input vector.
+     * @param {number} scale - Scale value.
+     * @returns {og.math.Vec2}
+     */
+    static scale(a: any, scale: number): any;
+    /**
+     * Returns two vectors production.
+     * @static
+     * @param {og.math.Vec2} a - First vector.
+     * @param {og.math.Vec2} b - Second vector.
+     * @returns {og.math.Vec2}
+     */
+    static mul(a: any, b: any): any;
+    /**
+     * Returns vector components division product one to another.
+     * @static
+     * @param {og.math.Vec2} a - First vector.
+     * @param {og.math.Vec2} b - Second vector.
+     * @returns {og.math.Vec2}
+     */
+    static div(a: any, b: any): any;
+    /**
+     * Get projection of the first vector to the second.
+     * @static
+     * @param {og.math.Vec2} b - First vector.
+     * @param {og.math.Vec2} a - Second vector.
+     * @returns {og.math.Vec2}
+     */
+    static proj_b_to_a(b: any, a: any): any;
+    /**
+     * Gets angle between two vectors.
+     * @static
+     * @param {og.math.Vec2} a - First vector.
+     * @param {og.math.Vec2} b - Second vector.
+     * @returns {number}
+     */
+    static angle(a: any, b: any): number;
+    /**
+     * Makes vectors normalized and orthogonal to each other.
+     * @static
+     * @param {og.math.Vec2} normal - Normal vector.
+     * @param {og.math.Vec2} tangent - Tangent vector.
+     * @returns {og.math.Vec2}
+     */
+    static orthoNormalize(normal: any, tangent: any): any;
+    static get LERP_DELTA(): number;
+    constructor(x: any, y: any);
+    /**
+     * @public
+     * @type {number}
+     */
+    public x: number;
+    /**
+     * @public
+     * @type {number}
+     */
+    public y: number;
+    /**
+     * Converts to 3d vector, third value is 0.0.
+     * @public
+     * @returns {og.Vec3}
+     */
+    public toVector3(): any;
+    /**
+     * Returns clone vector.
+     * @public
+     * @returns {og.math.Vec2}
+     */
+    public clone(): any;
+    /**
+     * Compares with vector. Returns true if it equals another.
+     * @public
+     * @param {og.math.Vec2} p - Vector to compare.
+     * @returns {boolean}
+     */
+    public equal(p: any): boolean;
+    /**
+     * Copy input vector's values.
+     * @param {og.math.Vec2} point2 - Vector to copy.
+     * @returns {og.math.Vec2}
+     */
+    copy(point2: any): any;
+    /**
+     * Gets vector's length.
+     * @public
+     * @returns {number}
+     */
+    public length(): number;
+    /**
+     * Returns squared vector's length.
+     * @public
+     * @returns {number}
+     */
+    public length2(): number;
+    /**
+     * Adds vector to the current.
+     * @public
+     * @param {og.math.Vec2}
+     * @returns {og.math.Vec2}
+     */
+    public addA(v: any): any;
+    /**
+     * Summarize two vectors.
+     * @public
+     * @param {og.math.Vec2}
+     * @returns {og.math.Vec2}
+     */
+    public add(v: any): any;
+    /**
+     * Subtract vector from the current where results saved on the current instance.
+     * @public
+     * @param {og.math.Vec2} v - Subtract vector.
+     * @returns {og.math.Vec2}
+     */
+    public subA(v: any): any;
+    /**
+     * Subtract vector from the current.
+     * @public
+     * @param {og.math.Vec2} v - Subtract vector.
+     * @returns {og.math.Vec2}
+     */
+    public sub(v: any): any;
+    /**
+     * Scale current vector.
+     * @public
+     * @param {number} scale - Scale value.
+     * @returns {og.math.Vec2}
+     */
+    public scale(scale: number): any;
+    /**
+     * Scale current vector to another instance.
+     * @public
+     * @param {number} scale - Scale value.
+     * @returns {og.math.Vec2}
+     */
+    public scaleTo(scale: number): any;
+    /**
+     * Multiply current vector object to another and store result in the current instance.
+     * @public
+     * @param {og.math.Vec2} vec - Multiply vector.
+     * @returns {og.math.Vec2}
+     */
+    public mulA(vec: any): any;
+    /**
+     * Multiply current vector object to another and returns new vector instance.
+     * @public
+     * @param {og.math.Vec2} vec - Multiply vector.
+     * @returns {og.math.Vec2}
+     */
+    public mul(vec: any): any;
+    /**
+     * Divide current vector's components to another. Results stores in the current vector object.
+     * @public
+     * @param {og.math.Vec2}
+     * @returns {og.math.Vec2}
+     */
+    public divA(vec: any): any;
+    /**
+     * Gets vectors dot production.
+     * @public
+     * @param {og.math.Vec2} v - Another vector.
+     * @returns {number}
+     */
+    public dot(v: any): number;
+    /**
+     * Gets vectors dot production.
+     * @public
+     * @param {Array.<number,number>} arr - Array vector.
+     * @returns {number}
+     */
+    public dotArr(arr: Array<number, number>): number;
+    /**
+     * Gets vectors cross production.
+     * @public
+     * @param {og.math.Vec2} v - Another vector.
+     * @returns {og.math.Vec2}
+     */
+    public cross(v: any): any;
+    /**
+     * Sets vector to zero.
+     * @public
+     * @returns {og.math.Vec2}
+     */
+    public clear(): any;
+    /**
+     * Returns normalized vector.
+     * @public
+     * @returns {og.math.Vec2}
+     */
+    public normal(): any;
+    /**
+     * Normalize current vector.
+     * @public
+     * @returns {og.math.Vec2}
+     */
+    public normalize(): any;
+    /**
+     * Converts vector to a number array.
+     * @public
+     * @returns {Array.<number,number>}
+     */
+    public toVec(): Array<number, number>;
+    /**
+     * Gets distance to point.
+     * @public
+     * @param {og.math.Vec2} p - Distant point.
+     * @returns {number}
+     */
+    public distance(p: any): number;
+    /**
+     * Sets vector's values.
+     * @public
+     * @param {number} x - Value X.
+     * @param {number} y - Value Y.
+     * @returns {og.math.Vec2}
+     */
+    public set(x: number, y: number): any;
+    /**
+     * Negate current vector.
+     * @public
+     * @returns {og.math.Vec2}
+     */
+    public negate(): any;
+    /**
+     * Negate current vector to another instance.
+     * @public
+     * @returns {og.math.Vec2}
+     */
+    public negateTo(): any;
+    /**
+     * Gets projected point coordinates of the current vector on the ray.
+     * @public
+     * @param {og.math.Vec2} pos - Ray position.
+     * @param {og.math.Vec2} direction - Ray direction.
+     * @returns {og.math.Vec2}
+     */
+    public projToRay(pos: any, direction: any): any;
+    /**
+     * Gets angle between two vectors.
+     * @public
+     * @param {og.math.Vec2} a - Another vector.
+     * @returns {number}
+     */
+    public angle(a: any): number;
+    /**
+     * Returns two vectors linear interpolation.
+     * @public
+     * @param {og.math.Vec2} v2 - End vector.
+     * @param {number} l - Interpolate value.
+     * @returns {og.math.Vec2}
+     */
+    public lerp(v1: any, v2: any, l: number): any;
+    /**
+     * 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 {og.math.Vec2} v2 -
+     * @param {number} t - The parameter t is clamped to the range [0, 1].
+     * @returns {og.math.Vec2}
+     */
+    public slerp(v2: any, t: number): any;
+}