@openglobus/og 0.24.2 → 0.25.0

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

@@ -1,72 +0,0 @@
-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
- * @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;
-    /**
-     * 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 triangle 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).
-     */
-    hitTriangleRes(v0: Vec3, v1: Vec3, v2: Vec3, res: Vec3): 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.
-     */
-    hitPlaneRes(plane: Plane, 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/lib/js/math/Ray.js

@@ -1,211 +0,0 @@
-import { EPS10 } from "../math";
-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 class Ray {
-    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
-     * @param {Vec3} origin - The origin of the ray.
-     * @param {Vec3} direction - The direction of the ray.
-     * @returns {Ray}
-     */
-    set(origin, direction) {
-        this.origin = origin;
-        this.direction = direction;
-        return this;
-    }
-    /**
-     * 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 triangle 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).
-     */
-    hitTriangleRes(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 {
-                // 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);
-        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;
-        }
-        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
-    //  * @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;
-    // }
-    /**
-     * 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.
-     */
-    hitPlaneRes(plane, res) {
-        const d = this.direction.dot(plane.n);
-        if (Math.abs(d) < EPS10) {
-            return Ray.OUTSIDE;
-        }
-        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;
-    }
-    /**
-     * Returns a ray hit sphere coordiante. If there isn't hit returns null.
-     * @public
-     * @param {Sphere} sphere - Sphere object.
-     * @returns {Vec3}
-     */
-    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) {
-                return o.clone();
-            }
-            let pc = c.projToRay(o, vpc);
-            var lc = Vec3.sub(pc, c).length();
-            let dist = Math.sqrt(r * r - lc * lc);
-            let di1 = dist - Vec3.sub(pc, o).length();
-            let intersection = Vec3.add(o, d.scaleTo(di1));
-            return intersection;
-        }
-        else {
-            let pc = c.projToRay(o, d);
-            var cpcl = Vec3.sub(c, pc).length();
-            if (cpcl > sphere.radius) {
-                return null;
-            }
-            else {
-                let dist = Math.sqrt(r * r - cpcl * cpcl);
-                let di1;
-                pc.subA(o);
-                if (vpc.length() > r) {
-                    di1 = pc.length() - dist;
-                }
-                else {
-                    di1 = pc.length() + dist;
-                }
-                let intersection = Vec3.add(o, d.scaleTo(di1));
-                return intersection;
-            }
-        }
-    }
-    hitBox(box) {
-        //
-        // TODO
-        //
-    }
-}

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

@@ -1,332 +0,0 @@
-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;
-    /**
-     * 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
-     * @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.
-     * @deprecated
-     * @public
-     * @returns {Vec2}
-     */
-    normal(): Vec2;
-    /**
-     * Returns normalized vector.
-     * @public
-     * @returns {Vec2}
-     */
-    getNormal(): 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;
-    /**
-     * Returns true if vector's values are zero.
-     * @public
-     * @returns {boolean} -
-     */
-    isZero(): boolean;
-}
-/**
- * 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;