@openglobus/og 0.18.0 → 0.18.2

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

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

@@ -1,8 +1,5 @@
-import {EPS10} from "../math";
-import {Box} from "../bv/Box";
-import {Sphere} from "../bv/Sphere";
-import {Vec3} from "./Vec3";
-
+import { EPS10 } from "../math";
+import { Vec3 } from "./Vec3";
 /**
  * Represents a ray that extends infinitely from the provided origin in the provided direction.
  * @class
@@ -10,47 +7,26 @@ import {Vec3} from "./Vec3";
  * @param {Vec3} direction - The direction of the ray.
  */
 export class Ray {
-    /**
-     * The origin of the ray.
-     * @public
-     * @type {Vec3}
-     */
-    public origin: Vec3;
-
-    /**
-     * The direction of the ray.
-     * @public
-     * @type {Vec3}
-     */
-    public direction: Vec3;
-
-    constructor(origin: Vec3 = Vec3.ZERO, direction: Vec3 = Vec3.ZERO) {
-
+    constructor(origin = Vec3.ZERO, direction = Vec3.ZERO) {
         this.origin = origin;
-
         this.direction = direction;
     }
-
     /** @const */
     static get OUTSIDE() {
         return 0;
     }
-
     /** @const */
     static get INSIDE() {
         return 1;
     }
-
     /** @const */
     static get INPLANE() {
         return 2;
     }
-
     /** @const */
     static get AWAY() {
         return 3;
     }
-
     /**
      * Sets a ray parameters.
      * @public
@@ -58,22 +34,20 @@ export class Ray {
      * @param {Vec3} direction - The direction of the ray.
      * @returns {Ray}
      */
-    public set(origin: Vec3, direction: Vec3): Ray {
+    set(origin, direction) {
         this.origin = origin;
         this.direction = direction;
         return this;
     }
-
     /**
      * Computes the point along the ray on the distance.
      * @public
      * @param {number} distance - Point distance.
      * @returns {Vec3}
      */
-    public getPoint(distance: number): Vec3 {
+    getPoint(distance) {
         return Vec3.add(this.origin, this.direction.scaleTo(distance));
     }
-
     /**
      * Returns ray hit a triange result.
      * @public
@@ -84,37 +58,32 @@ export class Ray {
      * @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): number {
+    hitTriangle(v0, v1, v2, res) {
         let u = v1.sub(v0);
         let v = v2.sub(v0);
         let n = u.cross(v);
-
         let w0 = this.origin.sub(v0);
         let a = -n.dot(w0);
         let b = n.dot(this.direction);
-
         // ray is  parallel to triangle plane
         if (Math.abs(b) < EPS10) {
             if (a === 0) {
                 res.copy(this.origin);
                 // ray lies in triangle plane
                 return Ray.INPLANE;
-            } else {
+            }
+            else {
                 // ray disjoint from plane
                 return Ray.OUTSIDE;
             }
         }
-
         let r = a / b;
-
         // intersect point of ray and plane
         res.copy(this.origin.add(this.direction.scaleTo(r)));
-
         // ray goes away from triangle
         if (r < 0.0) {
             return Ray.AWAY;
         }
-
         // is res point inside the triangle?
         let uu = u.dot(u);
         let uv = u.dot(v);
@@ -123,20 +92,16 @@ export class Ray {
         let wu = w.dot(u);
         let wv = w.dot(v);
         let D = uv * uv - uu * vv;
-
         let s = (uv * wv - vv * wu) / D;
         if (s < 0.0 || s > 1.0) {
             return Ray.OUTSIDE;
         }
-
         let t = (uv * wu - uu * wv) / D;
         if (t < 0.0 || s + t > 1.0) {
             return Ray.OUTSIDE;
         }
-
         return Ray.INSIDE;
     }
-
     /**
      * 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
@@ -146,57 +111,45 @@ export class Ray {
      * @param {Vec3} res - Hit point object pointer that stores hit result.
      * @returns {number}
      */
-    public hitPlane(v0: Vec3, v1: Vec3, v2: Vec3, res: Vec3): number {
+    hitPlane(v0, v1, v2, res) {
         let u = Vec3.sub(v1, v0);
         let v = Vec3.sub(v2, v0);
         let n = u.cross(v);
-
         let w0 = Vec3.sub(this.origin, v0);
         let a = -n.dot(w0);
         let b = n.dot(this.direction);
-
         // ray is  parallel to the plane
         if (Math.abs(b) < EPS10) {
             if (a === 0) {
                 return Ray.OUTSIDE;
             }
         }
-
         let r = a / b;
-
         if (r < 0) {
             return Ray.OUTSIDE;
         }
-
         let d = this.direction.scaleTo(r);
-
         // intersect point of ray and plane
         res.x = this.origin.x + d.x;
         res.y = this.origin.y + d.y;
         res.z = this.origin.z + d.z;
-
         return Ray.INSIDE;
     }
-
     /**
      * 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) {
-        let r = sphere.radius,
-            c = sphere.center,
-            o = this.origin,
-            d = this.direction;
-
+    hitSphere(sphere) {
+        let r = sphere.radius, c = sphere.center, o = this.origin, d = this.direction;
         let vpc = Vec3.sub(c, o);
-
         if (vpc.dot(d) < 0) {
             var l = vpc.length();
             if (l > r) {
                 return null;
-            } else if (l === r) {
+            }
+            else if (l === r) {
                 return o.clone();
             }
             let pc = c.projToRay(o, vpc);
@@ -205,18 +158,21 @@ export class Ray {
             let di1 = dist - Vec3.sub(pc, o).length();
             let intersection = Vec3.add(o, d.scaleTo(di1));
             return intersection;
-        } else {
+        }
+        else {
             let pc = c.projToRay(o, d);
             var cpcl = Vec3.sub(c, pc).length();
             if (cpcl > sphere.radius) {
                 return null;
-            } else {
+            }
+            else {
                 let dist = Math.sqrt(r * r - cpcl * cpcl);
                 let di1;
                 pc.subA(o);
                 if (vpc.length() > r) {
                     di1 = pc.length() - dist;
-                } else {
+                }
+                else {
                     di1 = pc.length() + dist;
                 }
                 let intersection = Vec3.add(o, d.scaleTo(di1));
@@ -224,10 +180,9 @@ export class Ray {
             }
         }
     }
-
-    public hitBox(box: Box) {
+    hitBox(box) {
         //
         // TODO
         //
     }
-}
+}

package/lib/js/math/Vec2.d.ts

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