@openglobus/og 0.22.2 → 0.24.0

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

@@ -118,13 +118,18 @@ export declare class Quat {
      * @returns {Quat} -
      */
     static getRotationBetweenVectorsUp(source: Vec3, dest: Vec3, up: Vec3): Quat;
-    static setFromEulerAngles(pitch: number, yaw: number, roll: number): Quat;
     /**
      * Returns true if the components are zero.
      * @public
      * @returns {boolean} -
      */
     isZero(): boolean;
+    /**
+     * Returns true if a component is NaN.
+     * @public
+     * @returns {boolean} -
+     */
+    isNaN(): boolean;
     /**
      * Clear Quat. Sets zeroes.
      * @public
@@ -167,6 +172,13 @@ export declare class Quat {
      * @returns {Quat} -
      */
     add(q: Quat): Quat;
+    /**
+     * Computes the componentwise sum of two Quats.
+     * @public
+     * @param {Quat} q - Quat to add.
+     * @returns {Quat} -
+     */
+    addRes(q: Quat, res: Quat): Quat;
     /**
      * Computes the componentwise difference of two Quats.
      * @public
@@ -194,6 +206,15 @@ export declare class Quat {
      * @returns {Array.<number>} - (exactly 4 entries)
      */
     toVec(): [number, number, number, number];
+    get xyz(): Vec3;
+    /**
+     * 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;
     /**
      * Sets current quaternion by spherical coordinates.
      * @public
@@ -203,20 +224,12 @@ export declare class Quat {
      * @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;
+    getSphericalCoords(): any;
     /**
      * Sets current Quat representing a rotation around an axis.
      * @public
@@ -228,9 +241,16 @@ export declare class Quat {
     /**
      * Returns axis and angle of the current Quat.
      * @public
-     * @returns {Object} -
+     * @returns { axis: Vec3, angle: number } -
      */
-    getAxisAngle(): any;
+    getAxisAngle(): {
+        axis: Vec3;
+        angle: number;
+    };
+    getPitch(): number;
+    getYaw(): number;
+    getRoll(): number;
+    setPitchYawRoll(pitchRad: number, yawRad: number, rollRad: number, frame?: Quat): Quat;
     /**
      * Sets current Quat by Euler's angles.
      * @public
@@ -274,6 +294,14 @@ export declare class Quat {
      * @returns {Vec3} -
      */
     mulVec3(v: Vec3): Vec3;
+    /**
+     * Returns quaternion and vector production.
+     * @public
+     * @param {Vec3} v - 3d Vector.
+     * @param {Vec3} res - result output vector.
+     * @returns {Vec3} -
+     */
+    mulVec3Res(v: Vec3, res: Vec3): Vec3;
     /**
      * Computes the product of two Quats.
      * @public
@@ -281,6 +309,13 @@ export declare class Quat {
      * @returns {Quat} -
      */
     mul(q: Quat): Quat;
+    /**
+     * Computes the product of two Quats.
+     * @public
+     * @param {Quat} q - Quat to multiply.
+     * @returns {Quat} -
+     */
+    mulRes(q: Quat, res: Quat): Quat;
     /**
      * Computes the product of two Quats.
      * @public
@@ -340,27 +375,6 @@ export declare class Quat {
      * @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.

package/lib/js/math/Quat.js

@@ -2,6 +2,7 @@ import * as math from "../math";
 import { Vec3 } from "./Vec3";
 import { Mat4 } from "./Mat4";
 import { Mat3 } from "./Mat3";
+import { PI_TWO } from "../math";
 /**
  * A set of 4-dimensional coordinates used to represent rotation in 3-dimensional space.
  * @constructor
@@ -166,10 +167,10 @@ export class Quat {
         let rotAxis = source.cross(dest).normalize();
         return Quat.axisAngleToQuat(rotAxis, rotAngle);
     }
-    static setFromEulerAngles(pitch, yaw, roll) {
-        let res = new Quat();
-        return res.setFromEulerAngles(pitch, yaw, roll);
-    }
+    // static setFromEulerAngles(pitch: number, yaw: number, roll: number): Quat {
+    //     let res = new Quat();
+    //     return res.setFromEulerAngles(pitch, yaw, roll);
+    // }
     /**
      * Returns true if the components are zero.
      * @public
@@ -178,6 +179,14 @@ export class Quat {
     isZero() {
         return this.x === 0.0 && this.y === 0.0 && this.z === 0.0 && this.w === 0.0;
     }
+    /**
+     * Returns true if a component is NaN.
+     * @public
+     * @returns {boolean} -
+     */
+    isNaN() {
+        return isNaN(this.x) || isNaN(this.y) || isNaN(this.z) || isNaN(this.w);
+    }
     /**
      * Clear Quat. Sets zeroes.
      * @public
@@ -245,6 +254,15 @@ export class Quat {
     add(q) {
         return new Quat(this.x + q.x, this.y + q.y, this.z + q.z, this.w + q.w);
     }
+    /**
+     * Computes the componentwise sum of two Quats.
+     * @public
+     * @param {Quat} q - Quat to add.
+     * @returns {Quat} -
+     */
+    addRes(q, res) {
+        return res.set(this.x + q.x, this.y + q.y, this.z + q.z, this.w + q.w);
+    }
     /**
      * Computes the componentwise difference of two Quats.
      * @public
@@ -284,26 +302,8 @@ export class Quat {
     toVec() {
         return [this.x, this.y, this.z, this.w];
     }
-    /**
-     * 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, lon, angle) {
-        let sin_a = Math.sin(angle / 2);
-        let cos_a = Math.cos(angle / 2);
-        let sin_lat = Math.sin(lat);
-        let cos_lat = Math.cos(lat);
-        let sin_long = Math.sin(lon);
-        let cos_long = Math.cos(lon);
-        this.x = sin_a * cos_lat * sin_long;
-        this.y = sin_a * sin_lat;
-        this.z = sin_a * sin_lat * cos_long;
-        this.w = cos_a;
-        return this;
+    get xyz() {
+        return new Vec3(this.x, this.y, this.z);
     }
     /**
      * Sets rotation with the given heading and up vectors.
@@ -347,12 +347,33 @@ export class Quat {
         }
         return this;
     }
+    /**
+     * 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, lon, angle) {
+        let sin_a = Math.sin(angle / 2);
+        let cos_a = Math.cos(angle / 2);
+        let sin_lat = Math.sin(lat);
+        let cos_lat = Math.cos(lat);
+        let sin_long = Math.sin(lon);
+        let cos_long = Math.cos(lon);
+        this.x = sin_a * cos_lat * sin_long;
+        this.y = sin_a * sin_lat;
+        this.z = sin_a * sin_lat * cos_long;
+        this.w = cos_a;
+        return this;
+    }
     /**
      * Gets spherical coordinates.
      * @public
      * @returns {Object} Returns object with latitude, longitude and alpha.
      */
-    toSphericalCoords() {
+    getSphericalCoords() {
         let cos_a = this.w;
         let sin_a = Math.sqrt(1.0 - cos_a * cos_a);
         // var angle = Math.acos(cos_a) * 2;
@@ -395,7 +416,7 @@ export class Quat {
     /**
      * Returns axis and angle of the current Quat.
      * @public
-     * @returns {Object} -
+     * @returns { axis: Vec3, angle: number } -
      */
     getAxisAngle() {
         let x = this.x, y = this.y, z = this.z, w = this.w;
@@ -420,6 +441,24 @@ export class Quat {
             angle: angle
         };
     }
+    getPitch() {
+        let sinPitch = -2 * (this.y * this.z - this.w * this.x);
+        return Math.abs(sinPitch) >= 1
+            ? Math.sign(sinPitch) * PI_TWO
+            : Math.asin(sinPitch);
+    }
+    getYaw() {
+        return -Math.atan2(2 * (this.x * this.z + this.w * this.y), 1 - 2 * (this.y * this.y + this.x * this.x));
+    }
+    getRoll() {
+        return Math.atan2(2 * (this.x * this.y + this.w * this.z), 1 - 2 * (this.z * this.z + this.x * this.x));
+    }
+    setPitchYawRoll(pitchRad, yawRad, rollRad, frame = Quat.IDENTITY) {
+        let qp = Quat.xRotation(-pitchRad);
+        let qy = Quat.yRotation(yawRad);
+        let qr = Quat.zRotation(-rollRad);
+        return this.copy(qr.mul(qp).mul(qy).mul(frame).conjugate());
+    }
     /**
      * Sets current Quat by Euler's angles.
      * @public
@@ -574,6 +613,22 @@ export class Quat {
         d = -b * d - f * e - h * g;
         return new Vec3(i * a + d * -b + j * -h - k * -f, j * a + d * -f + k * -b - i * -h, k * a + d * -h + i * -f - j * -b);
     }
+    /**
+     * Returns quaternion and vector production.
+     * @public
+     * @param {Vec3} v - 3d Vector.
+     * @param {Vec3} res - result output vector.
+     * @returns {Vec3} -
+     */
+    mulVec3Res(v, res) {
+        // t = 2 * cross(q.xyz, v)
+        // v' = v + q.w * t + cross(q.xyz, t)
+        let d = v.x, e = v.y, g = v.z;
+        let b = this.x, f = this.y, h = this.z, a = this.w;
+        let i = a * d + f * g - h * e, j = a * e + h * d - b * g, k = a * g + b * e - f * d;
+        d = -b * d - f * e - h * g;
+        return res.set(i * a + d * -b + j * -h - k * -f, j * a + d * -f + k * -b - i * -h, k * a + d * -h + i * -f - j * -b);
+    }
     /**
      * Computes the product of two Quats.
      * @public
@@ -585,6 +640,17 @@ export class Quat {
         let f = q.x, h = q.y, i = q.z, b = q.w;
         return new Quat(d * b + a * f + e * i - g * h, e * b + a * h + g * f - d * i, g * b + a * i + d * h - e * f, a * b - d * f - e * h - g * i);
     }
+    /**
+     * Computes the product of two Quats.
+     * @public
+     * @param {Quat} q - Quat to multiply.
+     * @returns {Quat} -
+     */
+    mulRes(q, res) {
+        let d = this.x, e = this.y, g = this.z, a = this.w;
+        let f = q.x, h = q.y, i = q.z, b = q.w;
+        return res.set(d * b + a * f + e * i - g * h, e * b + a * h + g * f - d * i, g * b + a * i + d * h - e * f, a * b - d * f - e * h - g * i);
+    }
     /**
      * Computes the product of two Quats.
      * @public
@@ -708,70 +774,6 @@ export class Quat {
         }
         return new Quat(scale0 * ax + scale1 * bx, scale0 * ay + scale1 * by, scale0 * az + scale1 * bz, scale0 * aw + scale1 * bw);
     }
-    /**
-     * Returns a roll angle in radians.
-     * @public
-     * @param {Boolean} [reprojectAxis] -
-     * @returns {Number} -
-     */
-    getRoll(reprojectAxis = false) {
-        let x = this.x, y = this.y, z = this.z, w = this.w;
-        if (reprojectAxis) {
-            let fTy = 2.0 * y;
-            let fTz = 2.0 * z;
-            let fTwz = fTz * w;
-            let fTxy = fTy * x;
-            let fTyy = fTy * y;
-            let fTzz = fTz * z;
-            return Math.atan2(fTxy + fTwz, 1.0 - (fTyy + fTzz));
-        }
-        else {
-            return Math.atan2(2 * (x * y + w * z), w * w + x * x - y * y - z * z);
-        }
-    }
-    /**
-     * Returns a pitch angle in radians.
-     * @public
-     * @param {Boolean} [reprojectAxis] -
-     * @returns {number} -
-     */
-    getPitch(reprojectAxis = false) {
-        let x = this.x, y = this.y, z = this.z, w = this.w;
-        if (reprojectAxis) {
-            let fTx = 2.0 * x;
-            let fTz = 2.0 * z;
-            let fTwx = fTx * w;
-            let fTxx = fTx * x;
-            let fTyz = fTz * y;
-            let fTzz = fTz * z;
-            return Math.atan2(fTyz + fTwx, 1.0 - (fTxx + fTzz));
-        }
-        else {
-            return Math.atan2(2 * (y * z + w * x), w * w - x * x - y * y + z * z);
-        }
-    }
-    /**
-     * Returns a yaw angle in radians.
-     * @public
-     * @param {Boolean} [reprojectAxis] -
-     * @returns {number} -
-     */
-    getYaw(reprojectAxis = false) {
-        let x = this.x, y = this.y, z = this.z, w = this.w;
-        if (reprojectAxis) {
-            let fTx = 2.0 * x;
-            let fTy = 2.0 * y;
-            let fTz = 2.0 * z;
-            let fTwy = fTy * w;
-            let fTxx = fTx * x;
-            let fTxz = fTz * x;
-            let fTyy = fTy * y;
-            return Math.atan2(fTxz + fTwy, 1.0 - (fTxx + fTyy));
-        }
-        else {
-            return Math.asin(-2 * (x * z - w * y));
-        }
-    }
 }
 /**
  * Creates Quat instance.

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

@@ -1,6 +1,7 @@
 import { Box } from "../bv/Box";
 import { Sphere } from "../bv/Sphere";
 import { Vec3 } from "./Vec3";
+import { Plane } from "./Plane";
 /**
  * Represents a ray that extends infinitely from the provided origin in the provided direction.
  * @class
@@ -38,14 +39,13 @@ export declare class Ray {
      */
     set(origin: Vec3, direction: Vec3): Ray;
     /**
-     * Computes the point along the ray on the distance.
-     * @public
-     * @param {number} distance - Point distance.
-     * @returns {Vec3}
+     * Get a point on the ray at a given distance `t`.
+     * @param {number} distance - Distance from the origin along the ray.
+     * @returns {Vec3} The point at distance `t`.
      */
     getPoint(distance: number): Vec3;
     /**
-     * Returns ray hit a triange result.
+     * Returns ray hit a triangle result.
      * @public
      * @param {Vec3} v0 - First triangle corner coordinate.
      * @param {Vec3} v1 - Second triangle corner coordinate.
@@ -54,17 +54,13 @@ export declare 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: Vec3, v1: Vec3, v2: Vec3, res: Vec3): number;
+    hitTriangleRes(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}
+     * Finds the intersection of the ray with a plane.
+     * @param {Plane} plane - The plane to intersect with.
+     * @returns {Vec3 | null} The intersection point or null if no intersection.
      */
-    hitPlane(v0: Vec3, v1: Vec3, v2: Vec3, res: Vec3): number;
+    hitPlaneRes(plane: Plane, res: Vec3): number;
     /**
      * Returns a ray hit sphere coordiante. If there isn't hit returns null.
      * @public

package/lib/js/math/Ray.js

@@ -40,16 +40,15 @@ export class Ray {
         return this;
     }
     /**
-     * Computes the point along the ray on the distance.
-     * @public
-     * @param {number} distance - Point distance.
-     * @returns {Vec3}
+     * Get a point on the ray at a given distance `t`.
+     * @param {number} distance - Distance from the origin along the ray.
+     * @returns {Vec3} The point at distance `t`.
      */
     getPoint(distance) {
         return Vec3.add(this.origin, this.direction.scaleTo(distance));
     }
     /**
-     * Returns ray hit a triange result.
+     * Returns ray hit a triangle result.
      * @public
      * @param {Vec3} v0 - First triangle corner coordinate.
      * @param {Vec3} v1 - Second triangle corner coordinate.
@@ -58,7 +57,7 @@ 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) {
+    hitTriangleRes(v0, v1, v2, res) {
         let u = v1.sub(v0);
         let v = v2.sub(v0);
         let n = u.cross(v);
@@ -102,37 +101,61 @@ export class Ray {
         }
         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
+    //  * @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 hitPlaneRes(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);
+    //
+    //     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;
+    // }
     /**
-     * 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}
+     * Finds the intersection of the ray with a plane.
+     * @param {Plane} plane - The plane to intersect with.
+     * @returns {Vec3 | null} The intersection point or null if no intersection.
      */
-    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) {
+    hitPlaneRes(plane, res) {
+        const d = this.direction.dot(plane.n);
+        if (Math.abs(d) < EPS10) {
             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;
+        const t = plane.p.sub(this.origin).dot(plane.n) / d;
+        if (t < 0) {
+            return Ray.AWAY;
+        }
+        res.copy(this.getPoint(t));
         return Ray.INSIDE;
     }
     /**

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

@@ -92,6 +92,15 @@ export declare class Vec2 {
      * @returns {Vec2}
      */
     static orthoNormalize(normal: Vec2, tangent: Vec2): Vec2;
+    /**
+     * Get projection of the vector to plane where n - normal to the plane.
+     * @static
+     * @param {Vec2} b - Vector to project.
+     * @param {Vec2} n - Plane normal.
+     * @param {Vec2} [def] - Default value for non existed result.
+     * @returns {Vec2} -
+     */
+    static proj_b_to_plane(b: Vec2, n: Vec2, def?: Vec3): Vec2;
     /**
      * Converts to 3d vector, third value is 0.0.
      * @public
@@ -221,10 +230,17 @@ export declare class Vec2 {
     clear(): Vec2;
     /**
      * Returns normalized vector.
+     * @deprecated
      * @public
      * @returns {Vec2}
      */
     normal(): Vec2;
+    /**
+     * Returns normalized vector.
+     * @public
+     * @returns {Vec2}
+     */
+    getNormal(): Vec2;
     /**
      * Normalize current vector.
      * @public
@@ -299,6 +315,12 @@ export declare class Vec2 {
      * @returns {Vec2}
      */
     slerp(v2: Vec2, t: number): Vec2;
+    /**
+     * Returns true if vector's values are zero.
+     * @public
+     * @returns {boolean} -
+     */
+    isZero(): boolean;
 }
 /**
  * Vector 2d object creator.

package/lib/js/math/Vec2.js

@@ -122,6 +122,21 @@ export class Vec2 {
         normal.scale(tangent.dot(normal));
         return tangent.sub(normal).normalize();
     }
+    /**
+     * Get projection of the vector to plane where n - normal to the plane.
+     * @static
+     * @param {Vec2} b - Vector to project.
+     * @param {Vec2} n - Plane normal.
+     * @param {Vec2} [def] - Default value for non existed result.
+     * @returns {Vec2} -
+     */
+    static proj_b_to_plane(b, n, def) {
+        let res = b.sub(n.scaleTo(n.dot(b) / n.dot(n)));
+        if (def && res.isZero()) {
+            return new Vec2(def.x, def.y);
+        }
+        return res;
+    }
     /**
      * Converts to 3d vector, third value is 0.0.
      * @public
@@ -302,10 +317,19 @@ export class Vec2 {
     }
     /**
      * Returns normalized vector.
+     * @deprecated
      * @public
      * @returns {Vec2}
      */
     normal() {
+        return this.getNormal();
+    }
+    /**
+     * Returns normalized vector.
+     * @public
+     * @returns {Vec2}
+     */
+    getNormal() {
         let res = new Vec2();
         res.copy(this);
         let length = 1.0 / res.length();
@@ -450,6 +474,14 @@ export class Vec2 {
         }
         return Vec2.add(this.scale(scale0), v2.scale(scale1));
     }
+    /**
+     * Returns true if vector's values are zero.
+     * @public
+     * @returns {boolean} -
+     */
+    isZero() {
+        return !(this.x || this.y);
+    }
 }
 /**
  * Vector 2d object creator.