@woosh/meep-engine 2.49.9 → 2.50.0

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;
-
-    }
-
-}

package/src/engine/graphics/texture/sampler/distanceField.js

@@ -1,411 +0,0 @@
-import { BitSet } from "../../../../core/binary/BitSet.js";
-import { assert } from "../../../../core/assert.js";
-import { clamp } from "../../../../core/math/clamp.js";
-import { max2 } from "../../../../core/math/max2.js";
-import { min2 } from "../../../../core/math/min2.js";
-
-/**
- * Naive flood implementation of a distance field computation algorithm
- * @author Alex Goldring Dec 2018
- * @param {Sampler2D} source
- * @param {Sampler2D} destination
- * @param {number} emptyValue
- */
-export function computeSignedDistanceField_(source, destination, emptyValue) {
-    assert.equal(source.itemSize, 1, `unsupported source.itemSize, expected 1, got '${source.itemSize}'`);
-    assert.typeOf(emptyValue, 'number', 'emptyValue');
-
-    let i, j;
-
-    const distanceData = destination.data;
-
-    const visited = new BitSet();
-
-    const openSet = new BitSet();
-
-    //use "flood" algorithm
-
-    //mark all visible tiles as visited
-    const samplerData = source.data;
-    const totalCellCount = samplerData.length;
-
-    function traverseNeighbours(index, visitor) {
-        let i = index - (width + 1);
-
-        const top = index > width;
-        const bottom = index < (totalCellCount - width);
-
-        const x = index % width;
-
-        const left = x > 0;
-        const right = x < width - 1;
-
-        if (top) {
-            if (left) {
-                visitor(i);
-            }
-
-            visitor(i + 1);
-
-            if (right) {
-                visitor(i + 2);
-            }
-        }
-
-        i += width;
-
-        if (left) {
-            visitor(i);
-        }
-
-        if (right) {
-            visitor(i + 2);
-        }
-
-        i += width;
-
-        if (bottom) {
-            if (left) {
-                visitor(i);
-            }
-
-            visitor(i + 1);
-
-            if (right) {
-                visitor(i + 2);
-            }
-        }
-
-    }
-
-    const width = destination.width;
-
-    for (i = 0; i < totalCellCount; i++) {
-        const sampleValue = samplerData[i];
-        if (sampleValue !== emptyValue) {
-            visited.set(i, true);
-            //write distance data
-            distanceData[i] = 0;
-        } else {
-            distanceData[i] = 255;
-        }
-    }
-
-    //populate initial open set
-    for (i = visited.nextSetBit(0); i !== -1; i = visited.nextSetBit(i + 1)) {
-        j = 0;
-        traverseNeighbours(i, function (neighbourIndex) {
-            if (!visited.get(neighbourIndex)) {
-                //increment number of not visited
-                j++;
-            }
-        });
-
-        if (j === 0) {
-            //all neighbours are visited, we can safely ignore this cell
-        } else {
-            openSet.set(i, true);
-        }
-    }
-
-    for (i = openSet.nextSetBit(0); i !== -1; i = openSet.nextSetBit(0)) {
-        //remove from open set
-        openSet.set(i, false);
-
-        const value = distanceData[i];
-
-        traverseNeighbours(i, function (neighbourIndex) {
-            const neighbourValue = value + 1;
-
-            if (visited.get(neighbourIndex)) {
-                if (distanceData[neighbourIndex] <= neighbourValue) {
-                    return;
-                }
-            } else {
-                visited.set(neighbourIndex, true);
-            }
-
-            distanceData[neighbourIndex] = neighbourValue;
-            //add neighbour to open set
-            openSet.set(neighbourIndex, true);
-        });
-    }
-}
-
-/**
- * @param {Sampler2D} source
- * @param {Sampler2D} distanceField
- * @param {number} emptyValue
- */
-export function computeUnsignedDistanceField(source, distanceField, emptyValue) {
-    computeUnsignedDistanceField_Chamfer(source, distanceField, emptyValue, 1, 1, 255);
-}
-
-/**
- * algorithm proposed by Borgefors, Chamfer distance [J. ACM 15 (1968) 600, Comput. Vis. Graph. Image Process. 34 (1986) 344], h
- * @param {Sampler2D} source
- * @param {Sampler2D} distanceField
- * @param {number} emptyValue
- * @param {number} d1 distance between two adjacent pixels in either x or y direction
- * @param {number} d2 distance between two diagonally adjacent pixels
- * @param {number} maxD highest value that distance field can hold
- */
-export function computeUnsignedDistanceField_Chamfer(source, distanceField, emptyValue, d1, d2, maxD) {
-    const sourceData = source.data;
-    const distanceFieldData = distanceField.data;
-
-    const width = source.width;
-    const height = source.height;
-
-    const maxX = width - 1;
-    const maxY = height - 1;
-
-    let x, y, i, v;
-
-    //initialize distance field
-    const dataSize = height * width;
-    for (i = 0; i < dataSize; i++) {
-        if (sourceData[i] !== emptyValue) {
-            distanceFieldData[i] = 0;
-        } else {
-            distanceFieldData[i] = maxD;
-        }
-    }
-
-    //first pass (forward)
-    for (y = 0; y < height; y++) {
-
-        const y_m1 = max2(y - 1, 0);
-
-        const y_w = y * width;
-
-        const y_m1_w = y_m1 * width;
-
-        for (x = 0; x < width; x++) {
-
-            i = y_w + x;
-
-            v = distanceFieldData[i];
-
-            const x_m1 = max2(x - 1, 0);
-            const x_p1 = min2(x + 1, maxX);
-
-            const v0_i = x_m1 + y_m1_w;
-            const v0 = distanceFieldData[v0_i] + d2;
-
-            if (v0 < v) {
-                distanceFieldData[i] = v0;
-                v = v0;
-            }
-
-            const v1_i = x + y_m1_w;
-            const v1 = distanceFieldData[v1_i] + d1;
-
-            if (v1 < v) {
-                distanceFieldData[i] = v1;
-                v = v1;
-            }
-
-            const v2_i = x_p1 + y_m1_w;
-            const v2 = distanceFieldData[v2_i] + d2;
-
-            if (v2 < v) {
-                distanceFieldData[i] = v2;
-                v = v2;
-            }
-
-            const v3_i = x_m1 + y_w;
-            const v3 = distanceFieldData[v3_i] + d1;
-
-            if (v3 < v) {
-                distanceFieldData[i] = v3;
-            }
-        }
-    }
-
-    //second pass (backward)
-    for (y = maxY; y >= 0; y--) {
-        const y_w = y * width;
-
-        const y_p1 = min2(y + 1, maxY);
-        const y_p1_w = y_p1 * width;
-
-        for (x = maxX; x >= 0; x--) {
-            const x_p1 = min2(x + 1, maxX);
-            const x_m1 = max2(x - 1, 0);
-
-            i = y_w + x;
-
-            v = distanceFieldData[i];
-
-            const v0_i = x_p1 + y_w;
-            const v0 = distanceFieldData[v0_i] + d1;
-
-            if (v0 < v) {
-                distanceFieldData[i] = v0;
-                v = v0;
-            }
-
-            const v1_i = x_m1 + y_p1_w;
-            const v1 = distanceFieldData[v1_i] + d2;
-
-            if (v1 < v) {
-                distanceFieldData[i] = v1;
-                v = v1;
-            }
-
-            const v2_i = x + y_p1_w;
-            const v2 = distanceFieldData[v2_i] + d1;
-
-            if (v2 < v) {
-                distanceFieldData[i] = v2;
-                v = v2;
-            }
-
-            const v3_i = x_p1 + y_p1_w;
-            const v3 = distanceFieldData[v3_i] + d2;
-
-            if (v3 < v) {
-                distanceFieldData[i] = v3;
-            }
-        }
-    }
-}
-
-/**
- * algorithm proposed by Borgefors, Chamfer distance [J. ACM 15 (1968) 600, Comput. Vis. Graph. Image Process. 34 (1986) 344], h
- * @param {Sampler2D} source
- * @param {Sampler2D} distanceField
- * @param {number} emptyValue
- * @param {number} d1 distance between two adjacent pixels in either x or y direction
- * @param {number} d2 distance between two diagonally adjacent pixels
- * @param maxD
- */
-export function computeSignedDistanceField_Chamfer(source, distanceField, emptyValue, d1, d2, maxD) {
-    const sourceData = source.data;
-    const distanceFieldData = distanceField.data;
-
-    const width = source.width;
-    const height = source.height;
-
-    const maxX = width - 1;
-    const maxY = height - 1;
-
-    function getS(x, y) {
-        x = clamp(x, 0, maxX);
-        y = clamp(y, 0, maxY);
-
-        const index = x + y * width;
-
-        return sourceData[index];
-    }
-
-    function getD(x, y) {
-        x = clamp(x, 0, maxX);
-        y = clamp(y, 0, maxY);
-
-        const index = x + y * width;
-
-        return distanceFieldData[index];
-    }
-
-    function setD(x, y, v) {
-        x = clamp(x, 0, maxX);
-        y = clamp(y, 0, maxY);
-
-        const index = x + y * width;
-
-        distanceFieldData[index] = min2(v, maxD);
-    }
-
-    let x, y;
-
-    //initialize distance field
-    for (y = 0; y < height; y++) {
-        for (x = 0; x < width; x++) {
-            if (
-                getS(x - 1, y) !== getS(x, y)
-                || getS(x + 1, y) !== getS(x, y)
-                || getS(x, y - 1) !== getS(x, y)
-                || getS(x, y + 1) !== getS(x, y)
-            ) {
-                setD(x, y, 0);
-            } else {
-                setD(x, y, 255);
-            }
-        }
-    }
-
-    //first pass (forward)
-    for (y = 0; y < height; y++) {
-        for (x = 0; x < width; x++) {
-
-            const v = getD(x, y);
-
-            const v0 = getD(x - 1, y - 1) + d2;
-
-            if (v0 < v) {
-                setD(x, y, v0);
-            }
-
-            const v1 = getD(x, y - 1) + d1;
-
-            if (v1 < v) {
-                setD(x, y, v1);
-            }
-
-            const v2 = getD(x + 1, y - 1) + d2;
-
-            if (v2 < v) {
-                setD(x, y, v2);
-            }
-
-            const v3 = getD(x - 1, y) + d1;
-
-            if (v3 < v) {
-                setD(x, y, v3);
-            }
-        }
-    }
-
-    //second pass (backward)
-    for (y = maxY; y >= 0; y--) {
-        for (x = maxX; x >= 0; x--) {
-            const v = getD(x, y);
-
-            const v0 = getD(x + 1, y) + d1;
-
-            if (v0 < v) {
-                setD(x, y, v0);
-            }
-
-            const v1 = getD(x - 1, y + 1) + d2;
-
-            if (v1 < v) {
-                setD(x, y, v1);
-            }
-
-            const v2 = getD(x, y + 1) + d1;
-
-            if (v2 < v) {
-                setD(x, y, v2);
-            }
-
-            const v3 = getD(x + 1, y + 1) + d2;
-
-            if (v3 < v) {
-                setD(x, y, v3);
-            }
-        }
-    }
-
-    //indicate inside & outside
-    for (y = 0; y < height; y++) {
-        for (x = 0; x < width; x++) {
-            if (getS(x, y) !== emptyValue) {
-                //inside
-                setD(x, y, -getD(x, y));
-            }
-        }
-    }
-}