@openglobus/og 0.17.1 → 0.18.0

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

@@ -1,7 +1,7 @@
-"use strict";
-
-import { EPS10 } from "../math.js";
-import { Vec3 } from "./Vec3.js";
+import {EPS10} from "../math";
+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.
@@ -10,20 +10,25 @@ import { Vec3 } from "./Vec3.js";
  * @param {Vec3} direction - The direction of the ray.
  */
 export class Ray {
-    constructor(origin = Vec3.ZERO, direction = Vec3.ZERO) {
-        /**
-         * The origin of the ray.
-         * @public
-         * @type {Vec3}
-         */
-        this.origin = origin || new Vec3();
-
-        /**
-         * The direction of the ray.
-         * @public
-         * @type {Vec3}
-         */
-        this.direction = direction || new Vec3();
+    /**
+     * 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) {
+
+        this.origin = origin;
+
+        this.direction = direction;
     }
 
     /** @const */
@@ -53,7 +58,7 @@ export class Ray {
      * @param {Vec3} direction - The direction of the ray.
      * @returns {Ray}
      */
-    set(origin, direction) {
+    public set(origin: Vec3, direction: Vec3): Ray {
         this.origin = origin;
         this.direction = direction;
         return this;
@@ -65,7 +70,7 @@ export class Ray {
      * @param {number} distance - Point distance.
      * @returns {Vec3}
      */
-    getPoint(distance) {
+    public getPoint(distance: number): Vec3 {
         return Vec3.add(this.origin, this.direction.scaleTo(distance));
     }
 
@@ -79,14 +84,14 @@ 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).
      */
-    hitTriangle(v0, v1, v2, res) {
-        var u = v1.sub(v0);
-        var v = v2.sub(v0);
-        var n = u.cross(v);
+    public hitTriangle(v0: Vec3, v1: Vec3, v2: Vec3, res: Vec3): number {
+        let u = v1.sub(v0);
+        let v = v2.sub(v0);
+        let n = u.cross(v);
 
-        var w0 = this.origin.sub(v0);
-        var a = -n.dot(w0);
-        var b = n.dot(this.direction);
+        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) {
@@ -100,7 +105,7 @@ export class Ray {
             }
         }
 
-        var r = a / b;
+        let r = a / b;
 
         // intersect point of ray and plane
         res.copy(this.origin.add(this.direction.scaleTo(r)));
@@ -111,20 +116,20 @@ export class Ray {
         }
 
         // is res point inside the triangle?
-        var uu = u.dot(u);
-        var uv = u.dot(v);
-        var vv = v.dot(v);
-        var w = res.sub(v0);
-        var wu = w.dot(u);
-        var wv = w.dot(v);
-        var D = uv * uv - uu * vv;
-
-        var s = (uv * wv - vv * wu) / D;
+        let uu = u.dot(u);
+        let uv = u.dot(v);
+        let vv = v.dot(v);
+        let w = res.sub(v0);
+        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;
         }
 
-        var t = (uv * wu - uu * wv) / D;
+        let t = (uv * wu - uu * wv) / D;
         if (t < 0.0 || s + t > 1.0) {
             return Ray.OUTSIDE;
         }
@@ -141,14 +146,14 @@ export class Ray {
      * @param {Vec3} res - Hit point object pointer that stores hit result.
      * @returns {number}
      */
-    hitPlane(v0, v1, v2, res) {
-        var u = Vec3.sub(v1, v0);
-        var v = Vec3.sub(v2, v0);
-        var n = u.cross(v);
+    public hitPlane(v0: Vec3, v1: Vec3, v2: Vec3, res: Vec3): number {
+        let u = Vec3.sub(v1, v0);
+        let v = Vec3.sub(v2, v0);
+        let n = u.cross(v);
 
-        var w0 = Vec3.sub(this.origin, v0);
-        var a = -n.dot(w0);
-        var b = n.dot(this.direction);
+        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) {
@@ -157,13 +162,13 @@ export class Ray {
             }
         }
 
-        var r = a / b;
+        let r = a / b;
 
         if (r < 0) {
             return Ray.OUTSIDE;
         }
 
-        var d = this.direction.scaleTo(r);
+        let d = this.direction.scaleTo(r);
 
         // intersect point of ray and plane
         res.x = this.origin.x + d.x;
@@ -179,12 +184,14 @@ export class Ray {
      * @param {Sphere} sphere - Sphere object.
      * @returns {Vec3}
      */
-    hitSphere(sphere) {
-        var r = sphere.radius,
+    public hitSphere(sphere: Sphere) {
+        let r = sphere.radius,
             c = sphere.center,
             o = this.origin,
             d = this.direction;
-        var vpc = Vec3.sub(c, o);
+
+        let vpc = Vec3.sub(c, o);
+
         if (vpc.dot(d) < 0) {
             var l = vpc.length();
             if (l > r) {
@@ -218,20 +225,9 @@ export class Ray {
         }
     }
 
-    hitBox(box) {
+    public hitBox(box: Box) {
         //
         // TODO
         //
     }
-}
-
-/**
- * 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, direction) {
-    return new Ray(origin, direction);
-}
+}

package/src/{og/math/Vec2.js → math/Vec2.ts}

@@ -1,6 +1,6 @@
-"use strict";
+import {Vec3} from "./Vec3";
 
-import { Vec3 } from "./Vec3.js";
+export type NumberArray2 = [number, number];
 
 /**
  * Class represents a 3d vector.
@@ -9,37 +9,46 @@ import { Vec3 } from "./Vec3.js";
  * @param {number} [y] - Second value.
  */
 export class Vec2 {
-    constructor(x = 0.0, y = 0.0) {
-        /**
-         * @public
-         * @type {number}
-         */
-        this.x = x || 0.0;
-
-        /**
-         * @public
-         * @type {number}
-         */
-        this.y = y || 0.0;
+
+    /**
+     * @public
+     * @type {number}
+     */
+    public x: number;
+
+    /**
+     * @public
+     * @type {number}
+     */
+    public y: number;
+
+    constructor(x: number = 0.0, y: number = 0.0) {
+        this.x = x;
+        this.y = y;
     }
+
     /** @const */
-    static get UP() {
+    static get UP(): Vec2 {
         return new Vec2(0, 1);
     }
+
     /** @const */
-    static get DOWN() {
+    static get DOWN(): Vec2 {
         return new Vec2(0, -1);
     }
+
     /** @const */
-    static get RIGHT() {
+    static get RIGHT(): Vec2 {
         return new Vec2(1, 0);
     }
+
     /** @const */
-    static get LEFT() {
+    static get LEFT(): Vec2 {
         return new Vec2(-1, 0);
     }
+
     /** @const */
-    static get ZERO() {
+    static get ZERO(): Vec2 {
         return new Vec2();
     }
 
@@ -50,7 +59,7 @@ export class Vec2 {
      * @param {Vec2} b - Second vector.
      * @returns {Vec2} - Summary vector.
      */
-    static add(a, b) {
+    static add(a: Vec2, b: Vec2): Vec2 {
         const res = new Vec2(a.x, a.y);
         res.addA(b);
         return res;
@@ -63,7 +72,7 @@ export class Vec2 {
      * @param {Vec2} b - Second vector.
      * @returns {Vec2} - Vectors subtraction.
      */
-    static sub(a, b) {
+    static sub(a: Vec2, b: Vec2): Vec2 {
         var res = new Vec2(a.x, a.y);
         res.subA(b);
         return res;
@@ -76,8 +85,8 @@ export class Vec2 {
      * @param {number} scale - Scale value.
      * @returns {Vec2}
      */
-    static scale(a, scale) {
-        var res = new Vec2(a.x, a.y);
+    static scale(a: Vec2, scale: number): Vec2 {
+        let res = new Vec2(a.x, a.y);
         res.scale(scale);
         return res;
     }
@@ -89,8 +98,8 @@ export class Vec2 {
      * @param {Vec2} b - Second vector.
      * @returns {Vec2}
      */
-    static mul(a, b) {
-        var res = new Vec2(a.x, a.y);
+    static mul(a: Vec2, b: Vec2): Vec2 {
+        let res = new Vec2(a.x, a.y);
         res.mulA(b);
         return res;
     }
@@ -102,8 +111,8 @@ export class Vec2 {
      * @param {Vec2} b - Second vector.
      * @returns {Vec2}
      */
-    static div(a, b) {
-        var res = new Vec2(a.x, a.y);
+    static div(a: Vec2, b: Vec2): Vec2 {
+        let res = new Vec2(a.x, a.y);
         res.divA(b);
         return res;
     }
@@ -115,7 +124,7 @@ export class Vec2 {
      * @param {Vec2} a - Second vector.
      * @returns {Vec2}
      */
-    static proj_b_to_a(b, a) {
+    static proj_b_to_a(b: Vec2, a: Vec2): Vec2 {
         return a.scaleTo(a.dot(b) / a.dot(a));
     }
 
@@ -126,7 +135,7 @@ export class Vec2 {
      * @param {Vec2} b - Second vector.
      * @returns {number}
      */
-    static angle(a, b) {
+    static angle(a: Vec2, b: Vec2): number {
         return Math.acos(a.dot(b) / Math.sqrt(a.length2() * b.length2()));
     }
 
@@ -137,8 +146,8 @@ export class Vec2 {
      * @param {Vec2} tangent - Tangent vector.
      * @returns {Vec2}
      */
-    static orthoNormalize(normal, tangent) {
-        normal = normal.norm();
+    static orthoNormalize(normal: Vec2, tangent: Vec2): Vec2 {
+        normal = normal.normal();
         normal.scale(tangent.dot(normal));
         return tangent.sub(normal).normalize();
     }
@@ -148,7 +157,7 @@ export class Vec2 {
      * @public
      * @returns {Vec3}
      */
-    toVector3() {
+    public toVector3(): Vec3 {
         return new Vec3(this.x, this.y, 0);
     }
 
@@ -157,7 +166,7 @@ export class Vec2 {
      * @public
      * @returns {Vec2}
      */
-    clone() {
+    public clone(): Vec2 {
         return new Vec2(this.x, this.y);
     }
 
@@ -167,7 +176,7 @@ export class Vec2 {
      * @param {Vec2} p - Vector to compare.
      * @returns {boolean}
      */
-    equal(p) {
+    public equal(p: Vec2): boolean {
         return this.x === p.x && this.y === p.y;
     }
 
@@ -176,7 +185,7 @@ export class Vec2 {
      * @param {Vec2} point2 - Vector to copy.
      * @returns {Vec2}
      */
-    copy(point2) {
+    public copy(point2: Vec2): Vec2 {
         this.x = point2.x;
         this.y = point2.y;
         return this;
@@ -187,7 +196,7 @@ export class Vec2 {
      * @public
      * @returns {number}
      */
-    length() {
+    public length(): number {
         return Math.sqrt(this.x * this.x + this.y * this.y);
     }
 
@@ -196,7 +205,7 @@ export class Vec2 {
      * @public
      * @returns {number}
      */
-    length2() {
+    public length2(): number {
         return this.x * this.x + this.y * this.y;
     }
 
@@ -206,7 +215,7 @@ export class Vec2 {
      * @param {Vec2}
      * @returns {Vec2}
      */
-    addA(v) {
+    public addA(v: Vec2): Vec2 {
         this.x += v.x;
         this.y += v.y;
         return this;
@@ -218,7 +227,7 @@ export class Vec2 {
      * @param {Vec2}
      * @returns {Vec2}
      */
-    add(v) {
+    public add(v: Vec2): Vec2 {
         return new Vec2(this.x + v.x, this.y + v.y);
     }
 
@@ -228,7 +237,7 @@ export class Vec2 {
      * @param {Vec2} v - Subtract vector.
      * @returns {Vec2}
      */
-    subA(v) {
+    public subA(v: Vec2): Vec2 {
         this.x -= v.x;
         this.y -= v.y;
         return this;
@@ -240,7 +249,7 @@ export class Vec2 {
      * @param {Vec2} v - Subtract vector.
      * @returns {Vec2}
      */
-    sub(v) {
+    public sub(v: Vec2): Vec2 {
         return new Vec2(this.x - v.x, this.y - v.y);
     }
 
@@ -250,7 +259,7 @@ export class Vec2 {
      * @param {number} scale - Scale value.
      * @returns {Vec2}
      */
-    scale(scale) {
+    public scale(scale: number): Vec2 {
         this.x *= scale;
         this.y *= scale;
         return this;
@@ -262,7 +271,7 @@ export class Vec2 {
      * @param {number} scale - Scale value.
      * @returns {Vec2}
      */
-    scaleTo(scale) {
+    public scaleTo(scale: number): Vec2 {
         return new Vec2(this.x * scale, this.y * scale);
     }
 
@@ -272,7 +281,7 @@ export class Vec2 {
      * @param {Vec2} vec - Multiply vector.
      * @returns {Vec2}
      */
-    mulA(vec) {
+    public mulA(vec: Vec2): Vec2 {
         this.x *= vec.x;
         this.y *= vec.y;
         return this;
@@ -284,7 +293,7 @@ export class Vec2 {
      * @param {Vec2} vec - Multiply vector.
      * @returns {Vec2}
      */
-    mul(vec) {
+    public mul(vec: Vec2): Vec2 {
         return new Vec2(this.x * vec.x, this.y * vec.y);
     }
 
@@ -294,7 +303,7 @@ export class Vec2 {
      * @param {Vec2}
      * @returns {Vec2}
      */
-    divA(vec) {
+    public divA(vec: Vec2): Vec2 {
         this.x /= vec.x;
         this.y /= vec.y;
         return this;
@@ -306,7 +315,7 @@ export class Vec2 {
      * @param {Vec2} v - Another vector.
      * @returns {number}
      */
-    dot(v) {
+    public dot(v: Vec2): number {
         return v.x * this.x + v.y * this.y;
     }
 
@@ -316,7 +325,7 @@ export class Vec2 {
      * @param {Array.<number>} arr - Array vector. (exactly 2 entries)
      * @returns {number}
      */
-    dotArr(arr) {
+    public dotArr(arr: NumberArray2): number {
         return arr[0] * this.x + arr[1] * this.y;
     }
 
@@ -324,9 +333,9 @@ export class Vec2 {
      * Gets vectors cross production.
      * @public
      * @param {Vec2} v - Another vector.
-     * @returns {Vec2}
+     * @returns {number}
      */
-    cross(v) {
+    public cross(v: Vec2): number {
         return this.x * v.y - this.y * v.x;
     }
 
@@ -335,7 +344,7 @@ export class Vec2 {
      * @public
      * @returns {Vec2}
      */
-    clear() {
+    public clear(): Vec2 {
         this.x = this.y = 0;
         return this;
     }
@@ -345,11 +354,11 @@ export class Vec2 {
      * @public
      * @returns {Vec2}
      */
-    normal() {
-        var res = new Vec2();
+    public normal(): Vec2 {
+        let res = new Vec2();
         res.copy(this);
 
-        var length = 1.0 / res.length();
+        let length = 1.0 / res.length();
 
         res.x *= length;
         res.y *= length;
@@ -362,8 +371,8 @@ export class Vec2 {
      * @public
      * @returns {Vec2}
      */
-    normalize() {
-        var length = 1.0 / this.length();
+    public normalize(): Vec2 {
+        let length = 1.0 / this.length();
 
         this.x *= length;
         this.y *= length;
@@ -376,7 +385,7 @@ export class Vec2 {
      * @public
      * @returns {Array.<number>} - (exactly 2 entries)
      */
-    toVec() {
+    public toVec(): NumberArray2 {
         return [this.x, this.y];
     }
 
@@ -386,8 +395,8 @@ export class Vec2 {
      * @param {Vec2} p - Distant point.
      * @returns {number}
      */
-    distance(p) {
-        var vec = Vec2.sub(this, p);
+    public distance(p: Vec2): number {
+        let vec = Vec2.sub(this, p);
         return vec.length();
     }
 
@@ -398,7 +407,7 @@ export class Vec2 {
      * @param {number} y - Value Y.
      * @returns {Vec2}
      */
-    set(x, y) {
+    public set(x: number, y: number): Vec2 {
         this.x = x;
         this.y = y;
         return this;
@@ -409,7 +418,7 @@ export class Vec2 {
      * @public
      * @returns {Vec2}
      */
-    negate() {
+    public negate(): Vec2 {
         this.x = -this.x;
         this.y = -this.y;
         return this;
@@ -420,7 +429,7 @@ export class Vec2 {
      * @public
      * @returns {Vec2}
      */
-    negateTo() {
+    public negateTo(): Vec2 {
         return new Vec2(-this.x, -this.y);
     }
 
@@ -431,8 +440,8 @@ export class Vec2 {
      * @param {Vec2} direction - Ray direction.
      * @returns {Vec2}
      */
-    projToRay(pos, direction) {
-        var v = Vec2.proj_b_to_a(Vec2.sub(this, pos), direction);
+    public projToRay(pos: Vec2, direction: Vec2): Vec2 {
+        let v = Vec2.proj_b_to_a(Vec2.sub(this, pos), direction);
         v.add(pos);
         return v;
     }
@@ -443,7 +452,7 @@ export class Vec2 {
      * @param {Vec2} a - Another vector.
      * @returns {number}
      */
-    angle(a) {
+    public angle(a: Vec2): number {
         return Vec2.angle(this, a);
     }
 
@@ -454,8 +463,8 @@ export class Vec2 {
      * @param {number} l - Interpolate value.
      * @returns {Vec2}
      */
-    lerp(v1, v2, l) {
-        var res = Vec2.clone(this);
+    public lerp(v1: Vec2, v2: Vec2, l: number): Vec2 {
+        let res = this.clone();
         if (l <= 0.0) {
             res.copy(v1);
         } else if (l >= 1.0) {
@@ -466,7 +475,7 @@ export class Vec2 {
         return res;
     }
 
-    static get LERP_DELTA() {
+    static get LERP_DELTA(): number {
         return 1e-6;
     }
 
@@ -476,23 +485,23 @@ export class Vec2 {
      * 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 {Vec2} v2
      * @param {number} t - The parameter t is clamped to the range [0, 1].
      * @returns {Vec2}
      */
-    slerp(v2, t) {
-        var res = new Vec2();
+    public slerp(v2: Vec2, t: number): Vec2 {
+        let res = new Vec2();
 
         if (t <= 0.0) {
             res.copy(this);
-            return;
+            return res;
         } else if (t >= 1.0) {
             res.copy(v2);
-            return;
+            return res;
         }
 
-        var omega, sinom, scale0, scale1;
-        var cosom = this.dot(v2);
+        let omega, sinom, scale0, scale1;
+        let cosom = this.dot(v2);
 
         if (1.0 - cosom > Vec2.LERP_DELTA) {
             omega = Math.acos(cosom);
@@ -515,6 +524,6 @@ export class Vec2 {
  * @param {number} [y] - Second value.
  * @returns {Vec2}
  */
-export function vec2(x, y) {
+export function vec2(x: number = 0, y: number = 0): Vec2 {
     return new Vec2(x, y);
 }