@woosh/meep-engine 2.49.9 → 2.50.1

package/src/core/geom/2d/LineSegment2.js

@@ -1,175 +0,0 @@
-/**
- * 2-D line Mathematics
- * @author Alex Goldring 2019
- * @copyright Alex Goldring 2019
- */
-
-/**
- *
- * @constructor
- */
-function LineSegment2() {
-
-}
-
-/**
- * @param {Vector2} p0
- * @param {Vector2} p1
- * @param {Vector2} p2
- * @param {Vector2} p3
- * @returns {[number,number]}
- */
-export function computeLine2Intersection(p0, p1, p2, p3) {
-    const p0_x = p0.x;
-    const p0_y = p0.y;
-    const p1_x = p1.x;
-    const p1_y = p1.y;
-    const p2_x = p2.x;
-    const p2_y = p2.y;
-    const p3_x = p3.x;
-    const p3_y = p3.y;
-
-    const result = [];
-
-    if (line2_line2_intersection(result, p0_x, p0_y, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y)) {
-        return result;
-    } else {
-        return null; // No collision
-    }
-
-}
-
-/**
- *
- * @param {number[]} result
- * @param {number} a0_x
- * @param {number} a0_y
- * @param {number} a1_x
- * @param {number} a1_y
- * @param {number} b2_x
- * @param {number} b2_y
- * @param {number} b3_x
- * @param {number} b3_y
- * @return {boolean}
- */
-export function line2_line2_intersection(result, a0_x, a0_y, a1_x, a1_y, b2_x, b2_y, b3_x, b3_y) {
-
-    const s1_x = a1_x - a0_x;
-    const s1_y = a1_y - a0_y;
-    const s2_x = b3_x - b2_x;
-    const s2_y = b3_y - b2_y;
-
-    const dy_02 = a0_y - b2_y;
-    const dx_02 = a0_x - b2_x;
-
-    const denom = -s2_x * s1_y + s1_x * s2_y;
-
-    const s = (-s1_y * dx_02 + s1_x * dy_02) / denom;
-    const t = (s2_x * dy_02 - s2_y * dx_02) / denom;
-
-    if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
-        // Collision detected
-
-        const intX = a0_x + (t * s1_x);
-        const intY = a0_y + (t * s1_y);
-
-        result[0] = intX;
-        result[1] = intY;
-
-        return true;
-    }
-
-    return false; // No collision
-}
-
-/**
- * Adapted from answer by iMalc from stackoverflow.com "how do you detect where two line segments intersect"
- * @link https://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
- * @param {Vector2} a0 start of first segment
- * @param {Vector2} a1 end of first segment
- * @param {Vector2} b0 start of second segment
- * @param {Vector2} b1 end of second segment
- * @param {Vector2} result resulting intersection point will be stored here if intersection exists
- * @returns {boolean} True if segments intersect, False otherwise
- */
-function intersectionPoint(a0, a1, b0, b1, result) {
-    return intersectionPointRaw(a0.x, a0.y, a1.x, a1.y, b0.x, b0.y, b1.x, b1.y, result);
-}
-
-/**
- *
- * @param {number} a0_x
- * @param {number} a0_y
- * @param {number} a1_x
- * @param {number} a1_y
- * @param {number} b0_x
- * @param {number} b0_y
- * @param {number} b1_x
- * @param {number} b1_y
- * @returns {boolean} True if segments intersect, False otherwise
- * @public
- */
-export function line2SegmentsIntersect(a0_x, a0_y, a1_x, a1_y, b0_x, b0_y, b1_x, b1_y) {
-    const s1_x = a1_x - a0_x;
-    const s1_y = a1_y - a0_y;
-    const s2_x = b1_x - b0_x;
-    const s2_y = b1_y - b0_y;
-
-
-    const denom = (-s2_x * s1_y + s1_x * s2_y);
-
-    const dy0_ab = a0_y - b0_y;
-    const dx0_ab = a0_x - b0_x;
-
-    const s = (-s1_y * dx0_ab + s1_x * dy0_ab) / denom;
-    const t = (s2_x * dy0_ab - s2_y * dx0_ab) / denom;
-
-    return s >= 0 && s <= 1 && t >= 0 && t <= 1;
-}
-
-
-/**
- *
- * @param {number} a0_x
- * @param {number} a0_y
- * @param {number} a1_x
- * @param {number} a1_y
- * @param {number} b0_x
- * @param {number} b0_y
- * @param {number} b1_x
- * @param {number} b1_y
- * @param {Vector2} result resulting intersection point will be stored here if intersection exists
- * @returns {boolean} True if segments intersect, False otherwise
- * @public
- */
-function intersectionPointRaw(a0_x, a0_y, a1_x, a1_y, b0_x, b0_y, b1_x, b1_y, result) {
-    const s1_x = a1_x - a0_x;
-    const s1_y = a1_y - a0_y;
-    const s2_x = b1_x - b0_x;
-    const s2_y = b1_y - b0_y;
-
-
-    const denom = (-s2_x * s1_y + s1_x * s2_y);
-
-    const s = (-s1_y * (a0_x - b0_x) + s1_x * (a0_y - b0_y)) / denom;
-    const t = (s2_x * (a0_y - b0_y) - s2_y * (a0_x - b0_x)) / denom;
-
-    if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
-        // Collision detected
-
-        const i_x = a0_x + (t * s1_x);
-        const i_y = a0_y + (t * s1_y);
-
-        result.set(i_x, i_y);
-
-        return true;
-    }
-
-
-    return false;
-}
-
-LineSegment2.intersectionPoint = intersectionPoint;
-LineSegment2.intersectionPointRaw = intersectionPointRaw;
-
-export default LineSegment2;

package/src/core/geom/3d/plane/computePlaneRayIntersection.js

@@ -1,55 +0,0 @@
-import { v3_dot } from "../../v3_dot.js";
-
-/**
- *
- * @param {Vector3} out Result will be written here
- * @param {number} originX Ray origin
- * @param {number} originY Ray origin
- * @param {number} originZ Ray origin
- * @param {number} directionX Ray direction
- * @param {number} directionY Ray direction
- * @param {number} directionZ Ray direction
- * @param {number} normalX Plane normal
- * @param {number} normalY Plane normal
- * @param {number} normalZ Plane normal
- * @param {number} dist Plane distance
- * @returns {boolean} true if intersection is found, false otherwise
- */
-export function computePlaneRayIntersection(out, originX, originY, originZ, directionX, directionY, directionZ, normalX, normalY, normalZ, dist) {
-    const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
-
-    const p = v3_dot(normalX, normalY, normalZ, originX, originY, originZ) + dist;
-
-    if (denom !== 0) {
-
-        const t = -p / denom;
-
-        if (t < 0) {
-            return false;
-        }
-
-        out.set(
-            directionX * t + originX,
-            directionY * t + originY,
-            directionZ * t + originZ
-        );
-
-        return true;
-
-    } else {
-
-        if (p === 0) {
-
-            out.set(originX, originY, originZ);
-
-            return true;
-
-        } else {
-
-            //no intersection
-            return false;
-
-        }
-
-    }
-}

package/src/core/geom/Matrix4.js

@@ -1,275 +0,0 @@
-import Vector3 from "./Vector3.js";
-
-const _z = new Vector3();
-const _x = new Vector3();
-const _y = new Vector3();
-
-/**
- * @deprecated use arrays instead or mat4 from gl-matrix
- */
-export class Matrix4 {
-    /**
-     *
-     * @constructor
-     * @class
-     */
-    constructor() {
-        console.warn("deprecated, use plain arrays or Float32Array instead")
-
-        this.a0 = 1;
-        this.a1 = 0;
-        this.a2 = 0;
-        this.a3 = 0;
-
-        this.b0 = 0;
-        this.b1 = 1;
-        this.b2 = 0;
-        this.b3 = 0;
-
-        this.c0 = 0;
-        this.c1 = 0;
-        this.c2 = 1;
-        this.c3 = 0;
-
-        this.d0 = 0;
-        this.d1 = 0;
-        this.d2 = 0;
-        this.d3 = 1;
-    }
-
-    /**
-     *
-     * @param {Vector3} eye
-     * @param {Vector3} target
-     * @param {Vector3} up
-     */
-    lookAt(eye, target, up) {
-        // compute direction vector
-        _z.subVectors(eye, target);
-
-        const delta_length_sqr = _z.lengthSqr();
-
-        if (delta_length_sqr === 0) {
-            // eye and target are at the same place
-            _z.set(0, 0, 1);
-        }
-
-        _z.normalize();
-        _x.crossVectors(up, _z);
-
-        if (_x.lengthSqr() === 0) {
-            // up and direction are parallel
-
-            // jitter direction a little
-            if (Math.abs(up.z) === 1) {
-                _z.x += 0.0001;
-            } else {
-                _z.z += 0.0001;
-            }
-
-            // recompute normalized direction and cross product
-            _z.normalize();
-
-            _x.crossVectors(up, _z);
-        }
-
-        _x.normalize();
-
-        _y.crossVectors(_z, _x);
-
-        this.a0 = _x.x;
-        this.a1 = _x.y;
-        this.a2 = _x.z;
-
-        this.b0 = _y.x;
-        this.b1 = _y.y;
-        this.b2 = _y.z;
-
-        this.c0 = _z.x;
-        this.c1 = _z.y;
-        this.c2 = _z.z;
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    determinant() {
-
-        const n11 = this.a0;
-        const n12 = this.b0;
-        const n13 = this.c0;
-        const n14 = this.d0;
-
-        const n21 = this.a1;
-        const n22 = this.b1;
-        const n23 = this.c1;
-        const n24 = this.d1;
-
-        const n31 = this.a2;
-        const n32 = this.b2;
-        const n33 = this.c2;
-        const n34 = this.d2;
-
-        const n41 = this.a3;
-        const n42 = this.b3;
-        const n43 = this.c3;
-        const n44 = this.d3;
-
-        //TODO: make this more efficient
-        //( based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm )
-
-        return (
-            n41 * (
-                +n14 * n23 * n32
-                - n13 * n24 * n32
-                - n14 * n22 * n33
-                + n12 * n24 * n33
-                + n13 * n22 * n34
-                - n12 * n23 * n34
-            ) +
-            n42 * (
-                +n11 * n23 * n34
-                - n11 * n24 * n33
-                + n14 * n21 * n33
-                - n13 * n21 * n34
-                + n13 * n24 * n31
-                - n14 * n23 * n31
-            ) +
-            n43 * (
-                +n11 * n24 * n32
-                - n11 * n22 * n34
-                - n14 * n21 * n32
-                + n12 * n21 * n34
-                + n14 * n22 * n31
-                - n12 * n24 * n31
-            ) +
-            n44 * (
-                -n13 * n22 * n31
-                - n11 * n23 * n32
-                + n11 * n22 * n33
-                + n13 * n21 * n32
-                - n12 * n21 * n33
-                + n12 * n23 * n31
-            )
-
-        );
-
-    }
-
-    /**
-     *
-     * @param {Vector3} position
-     * @param {Quaternion} rotation
-     * @param {Vector3} scale
-     */
-    compose(position, rotation, scale) {
-        var x = rotation.x, y = rotation.y, z = rotation.z, w = rotation.w;
-
-        var x2 = x + x, y2 = y + y, z2 = z + z;
-        var xx = x * x2, xy = x * y2, xz = x * z2;
-        var yy = y * y2, yz = y * z2, zz = z * z2;
-        var wx = w * x2, wy = w * y2, wz = w * z2;
-
-        var sx = scale.x, sy = scale.y, sz = scale.z;
-
-        this.a0 = (1 - (yy + zz)) * sx;
-        this.a1 = (xy + wz) * sx;
-        this.a2 = (xz - wy) * sx;
-        this.a3 = 0;
-
-        this.b0 = (xy - wz) * sy;
-        this.b1 = (1 - (xx + zz)) * sy;
-        this.b2 = (yz + wx) * sy;
-        this.b3 = 0;
-
-        this.c0 = (xz + wy) * sz;
-        this.c1 = (yz - wx) * sz;
-        this.c2 = (1 - (xx + yy)) * sz;
-        this.c3 = 0;
-
-        this.d0 = position.x;
-        this.d1 = position.y;
-        this.d2 = position.z;
-        this.d3 = 1;
-    }
-
-    decompose(position, rotation, scale) {
-
-
-        let sx = Math.hypot(this.a0, this.a1, this.a2);
-        const sy = Math.hypot(this.b0, this.b1, this.b2);
-        const sz = Math.hypot(this.c0, this.c1, this.c2);
-
-        // if determine is negative, we need to invert one scale
-        const det = this.determinant();
-        if (det < 0) sx = -sx;
-
-        position.set(
-            this.d0,
-            this.d1,
-            this.d2
-        );
-
-        // scale the rotation part
-        const invSX = 1 / sx;
-        const invSY = 1 / sy;
-        const invSZ = 1 / sz;
-
-        const i_a0 = this.a0 * invSX;
-        const i_a1 = this.a1 * invSX;
-        const i_a2 = this.a2 * invSX;
-
-        const i_b0 = this.b0 * invSY;
-        const i_b1 = this.b1 * invSY;
-        const i_b2 = this.b2 * invSY;
-
-        const i_c0 = this.c0 * invSZ;
-        const i_c1 = this.c1 * invSZ;
-        const i_c2 = this.c2 * invSZ;
-
-        rotation.__setFromRotationMatrix(i_a0, i_b0, i_c0, i_a1, i_b1, i_c1, i_a2, i_b2, i_c2);
-
-        scale.set(sx, sy, sz);
-    }
-
-    /**
-     *
-     * @param {Matrix4} a
-     * @param {Matrix4} b
-     */
-    multiplyMatrices(a, b) {
-
-        const a11 = a.a0, a12 = a.b0, a13 = a.c0, a14 = a.d0;
-        const a21 = a.a1, a22 = a.b1, a23 = a.c1, a24 = a.d1;
-        const a31 = a.a2, a32 = a.b2, a33 = a.c2, a34 = a.d2;
-        const a41 = a.a3, a42 = a.b3, a43 = a.c3, a44 = a.d3;
-
-        const b11 = b.a0, b12 = b.b0, b13 = b.c0, b14 = b.d0;
-        const b21 = b.a1, b22 = b.b1, b23 = b.c1, b24 = b.d1;
-        const b31 = b.a2, b32 = b.b2, b33 = b.c2, b34 = b.d2;
-        const b41 = b.a3, b42 = b.b3, b43 = b.c3, b44 = b.d3;
-
-        this.a0 = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;
-        this.b0 = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;
-        this.c0 = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;
-        this.d0 = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;
-
-        this.a1 = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;
-        this.b1 = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;
-        this.c1 = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;
-        this.d1 = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;
-
-        this.a2 = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;
-        this.b2 = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;
-        this.c2 = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;
-        this.d2 = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;
-
-        this.a3 = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;
-        this.b3 = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;
-        this.c3 = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;
-        this.d3 = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;
-
-    }
-
-}