@woosh/meep-engine 2.48.23 → 2.49.0

package/src/core/geom/ConicRay.js

@@ -7,194 +7,202 @@ import { EPSILON } from "../math/EPSILON.js";
 
 
 /**
- *
- * @constructor
+ * Represents a direction vector+angle
+ * Mainly used inside particle systems for pick a motion direction at spawn
  */
-export function ConicRay() {
+export class ConicRay {
     /**
-     * Must be normalized
-     * @type {Vector3}
+     *
+     * @constructor
      */
-    this.direction = new Vector3(0, 1, 0);
-
-    /**
-     * Semi-angle of the cone, that is the angle between the center axis and the edge of the cone
-     * In radians
-     * @type {number}
-     */
-    this.angle = 0;
-}
+    constructor() {
+        /**
+         * Must be normalized
+         * @type {Vector3}
+         */
+        this.direction = new Vector3(0, 1, 0);
+
+        /**
+         * Semi-angle of the cone, that is the angle between the center axis and the edge of the cone
+         * In radians
+         * @type {number}
+         */
+        this.angle = 0;
+    }
 
-ConicRay.prototype.toJSON = function () {
-    return {
-        direction: this.direction.toJSON(),
-        angle: this.angle
-    };
-};
+    toJSON() {
+        return {
+            direction: this.direction.toJSON(),
+            angle: this.angle
+        };
+    }
 
-ConicRay.prototype.fromJSON = function (json) {
-    this.direction.fromJSON(json.direction);
-    this.angle = json.angle;
-};
+    fromJSON(json) {
+        this.direction.fromJSON(json.direction);
+        this.angle = json.angle;
+    }
 
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-ConicRay.prototype.toBinaryBuffer = function (buffer) {
-    buffer.writeFloat64(this.angle);
-    this.direction.toBinaryBufferFloat32(buffer);
-};
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        buffer.writeFloat64(this.angle);
+        this.direction.toBinaryBufferFloat32(buffer);
+    }
 
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-ConicRay.prototype.fromBinaryBuffer = function (buffer) {
-    this.angle = buffer.readFloat64();
-    this.direction.fromBinaryBufferFloat32(buffer);
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer) {
+        this.angle = buffer.readFloat64();
+        this.direction.fromBinaryBufferFloat32(buffer);
 
-    //normalize direction
-    this.direction.normalize();
-};
+        //normalize direction
+        this.direction.normalize();
+    }
 
-/**
- *
- * @param {ConicRay} other
- * @returns {boolean}
- */
-ConicRay.prototype.equals = function (other) {
-    return this.angle === other.angle && this.direction.equals(other.direction);
-};
+    /**
+     *
+     * @param {ConicRay} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.angle === other.angle && this.direction.equals(other.direction);
+    }
 
-/**
- *
- * @param {ConicRay} other
- * @param {number} tolerance
- * @returns {boolean}
- */
-ConicRay.prototype.roughlyEquals = function (other, tolerance = EPSILON) {
-    return epsilonEquals(this.angle, other.angle, tolerance) && this.direction.roughlyEquals(other.direction, tolerance);
-};
+    /**
+     *
+     * @param {ConicRay} other
+     * @param {number} tolerance
+     * @returns {boolean}
+     */
+    roughlyEquals(other, tolerance = EPSILON) {
+        return epsilonEquals(this.angle, other.angle, tolerance)
+            && this.direction.roughlyEquals(other.direction, tolerance);
+    }
 
-ConicRay.prototype.hash = function () {
-    return computeHashIntegerArray(
-        computeHashFloat(this.angle),
-        this.direction.hash()
-    );
-};
+    hash() {
+        return computeHashIntegerArray(
+            computeHashFloat(this.angle),
+            this.direction.hash()
+        );
+    }
 
-/**
- *
- * @param {ConicRay} other
- */
-ConicRay.prototype.copy = function (other) {
-    this.direction.copy(other.direction);
-    this.angle = other.angle;
-}
+    /**
+     *
+     * @param {ConicRay} other
+     */
+    copy(other) {
+        this.direction.copy(other.direction);
+        this.angle = other.angle;
+    }
 
-/**
- * Includes boundary matches
- * @param {Vector3} v3
- * @returns {boolean}
- */
-ConicRay.prototype.containsDirectionVector = function (v3) {
-    const angular_distance = this.direction.angleTo(v3);
+    /**
+     * Includes boundary matches
+     * @param {Vector3} v3
+     * @returns {boolean}
+     */
+    containsDirectionVector(v3) {
+        const angular_distance = this.direction.angleTo(v3);
 
-    return angular_distance <= this.angle;
-};
+        return angular_distance <= this.angle;
+    }
 
-/**
- * NOTE: Heavily based on a stackoverflow answer
- * @see https://stackoverflow.com/questions/38997302/create-random-unit-vector-inside-a-defined-conical-region/39003745#39003745
- * @param {function} random
- * @param {Vector3} result
- */
-ConicRay.prototype.sampleRandomDirection = function (random, result) {
-    const coneAngle = this.angle;
+    /**
+     * NOTE: Heavily based on a stackoverflow answer
+     * @see https://stackoverflow.com/questions/38997302/create-random-unit-vector-inside-a-defined-conical-region/39003745#39003745
+     * @param {function} random
+     * @param {Vector3} result
+     */
+    sampleRandomDirection(random, result) {
+        const coneAngle = this.angle;
 
-    if (coneAngle === 0) {
-        //fast path, just copy ray direction
-        result.copy(this.direction);
-        return;
-    }
+        if (coneAngle === 0) {
+            //fast path, just copy ray direction
+            result.copy(this.direction);
+            return;
+        }
 
-    // Generate points on the spherical cap around the north pole [1].
-    // [1] See https://math.stackexchange.com/a/205589/81266
-    const angleCosine = Math.cos(coneAngle);
+        // Generate points on the spherical cap around the north pole [1].
+        // [1] See https://math.stackexchange.com/a/205589/81266
+        const angleCosine = Math.cos(coneAngle);
 
-    const z = random() * (1 - angleCosine) + angleCosine;
+        const z = random() * (1 - angleCosine) + angleCosine;
 
-    const phi = random() * 6.28318530718; //2*pi
+        const phi = random() * 6.28318530718; //2*pi
 
-    const zSqr = z * z;
+        const zSqr = z * z;
 
-    const zSqrtNeg = Math.sqrt(1 - zSqr);
+        const zSqrtNeg = Math.sqrt(1 - zSqr);
 
-    const x = zSqrtNeg * Math.cos(phi);
-    const y = zSqrtNeg * Math.sin(phi);
+        const x = zSqrtNeg * Math.cos(phi);
+        const y = zSqrtNeg * Math.sin(phi);
 
-    // If the spherical cap is centered around the north pole, we're done.
-    const direction = this.direction;
-    if (direction._equals(0, 0, 1)) {
-        result.set(x, y, z);
-        return;
-    }
+        // If the spherical cap is centered around the north pole, we're done.
+        const direction = this.direction;
+        if (direction._equals(0, 0, 1)) {
+            result.set(x, y, z);
+            return;
+        }
 
-    assert.ok(direction.isNormalized(), 'direction vector must be normalized');
+        assert.ok(direction.isNormalized(), 'direction vector must be normalized');
 
-    // Find the rotation axis `u` and rotation angle `rot` [1]
+        // Find the rotation axis `u` and rotation angle `rot` [1]
 
-    const dX = direction.x;
-    const dY = direction.y;
-    const dZ = direction.z;
+        const dX = direction.x;
+        const dY = direction.y;
+        const dZ = direction.z;
 
-    //compute u
-    //compute rotation angle
-    const rot = Math.acos(dZ);
+        //compute u
+        //compute rotation angle
+        const rot = Math.acos(dZ);
 
 
-    // Convert rotation axis and angle to 3x3 rotation matrix [2]
-    // [2] See https://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle
+        // Convert rotation axis and angle to 3x3 rotation matrix [2]
+        // [2] See https://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle
 
-    //write matrix
-    const c = dZ;
-    const s = Math.sin(rot);
-    const t = 1 - c;
-    const tx = -t * dY;
-    const ty = t * dX;
+        //write matrix
+        const c = dZ;
+        const s = Math.sin(rot);
+        const t = 1 - c;
+        const tx = -t * dY;
+        const ty = t * dX;
 
-    //build relevant terms of the matrix
-    const n11 = c - tx * dY;
-    const n12 = tx * dX;
-    const n22 = ty * dX + c;
-    const n13 = s * dX;
-    const n32 = -s * dY;
+        //build relevant terms of the matrix
+        const n11 = c - tx * dY;
+        const n12 = tx * dX;
+        const n22 = ty * dX + c;
+        const n13 = s * dX;
+        const n32 = -s * dY;
 
 
-    // Rotate [x; y; z] from north pole to `coneDir`.
-    const _x = n11 * x + n12 * y + n13 * z;
-    const _y = n12 * x + n22 * y + -n32 * z;
-    const _z = -n13 * x + n32 * y + c * z;
+        // Rotate [x; y; z] from north pole to `coneDir`.
+        const _x = n11 * x + n12 * y + n13 * z;
+        const _y = n12 * x + n22 * y + -n32 * z;
+        const _z = -n13 * x + n32 * y + c * z;
 
-    result.set(_x, _y, _z);
-};
+        result.set(_x, _y, _z);
+    }
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @param {number} angle
- * @returns {ConicRay}
- */
-ConicRay.fromScalars = function (x, y, z, angle) {
-    assert.greaterThanOrEqual(angle, 0, 'angle must be non-negative');
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} angle
+     * @returns {ConicRay}
+     */
+    static fromScalars(x, y, z, angle) {
+        assert.greaterThanOrEqual(angle, 0, 'angle must be non-negative');
 
-    const r = new ConicRay();
+        const r = new ConicRay();
 
-    r.angle = angle;
-    r.direction.set(x, y, z);
+        r.angle = angle;
+        r.direction.set(x, y, z);
 
-    return r;
+        return r;
+    }
 }
+

package/src/core/geom/Matrix4.js

@@ -14,6 +14,8 @@ export class Matrix4 {
      * @class
      */
     constructor() {
+        console.warn("deprecated, use plain arrays or Float32Array instead")
+
         this.a0 = 1;
         this.a1 = 0;
         this.a2 = 0;

package/src/core/geom/Quaternion.js

@@ -1125,7 +1125,25 @@ class Quaternion {
      * @param {number} m33
      * @returns {Quaternion}
      */
-    __setFromRotationMatrix(m11, m12, m13, m21, m22, m23, m31, m32, m33) {
+    __setFromRotationMatrix(
+        m11, m12, m13,
+        m21, m22, m23,
+        m31, m32, m33
+    ) {
+
+        assert.notNaN(m11,'m11');
+        assert.notNaN(m12,'m12');
+        assert.notNaN(m13,'m13');
+
+        assert.notNaN(m21,'m21');
+        assert.notNaN(m22,'m22');
+        assert.notNaN(m23,'m23');
+
+        assert.notNaN(m31,'m31');
+        assert.notNaN(m32,'m32');
+        assert.notNaN(m33,'m33');
+
+
         const trace = m11 + m22 + m33;
 
         let x, y, z, w, s;

package/src/core/geom/packing/max-rect/MaxRectangles.js

@@ -1,221 +1,15 @@
 import BinaryHeap from "../../../collection/heap/FastBinaryHeap.js";
 import { assert } from "../../../assert.js";
-import { max2 } from "../../../math/max2.js";
-import { min2 } from "../../../math/min2.js";
 import { QuadTreeDatum } from "../../2d/quad-tree/QuadTreeDatum.js";
 import { QuadTreeNode } from "../../2d/quad-tree/QuadTreeNode.js";
 import AABB2 from "../../2d/aabb/AABB2.js";
 import Vector2 from "../../Vector2.js";
-import { removeRedundantBoxesArray } from "./removeRedundantBoxesArray.js";
 import { removeRedundantBoxes } from "./removeRedundantBoxes.js";
+import { costByRemainingArea } from "./cost/costByRemainingArea.js";
+import { findBestContainer } from "./findBestContainer.js";
+import { packOneBox } from "./packOneBox.js";
 
 
-/**
- *
- * @param {number} containerWidth
- * @param {number} containerHeight
- * @param {number} childWidth
- * @param {number} childHeight
- * @returns {number}
- */
-function costByRemainingArea(containerWidth, containerHeight, childWidth, childHeight) {
-    const dW = containerWidth - childWidth;
-    const dH = containerHeight - childHeight;
-
-    return dW * containerHeight + dH * childWidth;
-}
-
-/**
- *
- * @param {number} containerWidth
- * @param {number} containerHeight
- * @param {number} childWidth
- * @param {number} childHeight
- * @returns {number}
- */
-function costByBestShortSide(containerWidth, containerHeight, childWidth, childHeight) {
-    return Math.min(containerWidth - childWidth, containerHeight - childHeight);
-}
-
-/**
- *
- * @param {number} width
- * @param {number} height
- * @param {QuadTreeNode} boxes
- * @param {function(containerWidth:number, containerHeight:number, childWidth:number, childHeight:number):number} costFunction
- * @returns {QuadTreeDatum} suitable container box
- */
-function findBestContainer(width, height, boxes, costFunction) {
-    let best = null;
-    let bestScore = Number.POSITIVE_INFINITY;
-
-    const visitor = (node) => {
-
-        if (node.getWidth() < width) {
-            //too small, don't traverse deeper
-            return false;
-        }
-
-        if (node.getHeight() < height) {
-            //too small, don't traverse deeper
-            return false;
-        }
-
-        const data = node.data;
-        const numBoxes = data.length;
-
-        for (let i = 0; i < numBoxes; i++) {
-            const box = data[i];
-
-            const bW = box.getWidth();
-
-            if (bW < width) {
-                //too small
-                continue;
-            }
-
-            const bH = box.getHeight();
-
-            if (bH < height) {
-                //too small
-                continue;
-            }
-
-            const cost = costFunction(bW, bH, width, height);
-            if (cost < bestScore) {
-                bestScore = cost;
-                best = box;
-            }
-        }
-
-        return true;
-    };
-
-    boxes.traversePreOrder(visitor);
-
-    return best;
-}
-
-/**
- * Cut out a region from given set of boxes
- * @param {AABB2} scissor area to be cut out
- * @param {QuadTreeNode} boxes
- */
-function cutArea(scissor, boxes) {
-
-    /**
-     *
-     * @type {QuadTreeDatum[]}
-     */
-    const additions = [];
-
-    /**
-     *
-     * @type {QuadTreeDatum[]}
-     */
-    const removals = [];
-
-    /**
-     *
-     * @param {QuadTreeDatum} box
-     */
-    function visitOverlap(box) {
-        removals.push(box);
-
-
-        //compute overlap region
-        const x0 = max2(scissor.x0, box.x0);
-        const x1 = min2(scissor.x1, box.x1);
-
-        const y0 = max2(scissor.y0, box.y0);
-        const y1 = min2(scissor.y1, box.y1);
-
-
-        //create 4 boxes around overlap
-        if (x0 > box.x0) {
-            //add left box
-            additions.push(new QuadTreeDatum(box.x0, box.y0, x0, box.y1));
-        }
-        if (x1 < box.x1) {
-            //add right box
-            additions.push(new QuadTreeDatum(x1, box.y0, box.x1, box.y1));
-        }
-        if (y0 > box.y0) {
-            //add top box
-            additions.push(new QuadTreeDatum(box.x0, box.y0, box.x1, y0));
-        }
-        if (y1 < box.y1) {
-            //add bottom box
-            additions.push(new QuadTreeDatum(box.x0, y1, box.x1, box.y1));
-        }
-
-    }
-
-    boxes.traverseRectangleIntersections(scissor.x0, scissor.y0, scissor.x1, scissor.y1, visitOverlap);
-
-    let i, l;
-    //perform removals
-    for (i = 0, l = removals.length; i < l; i++) {
-        const removal = removals[i];
-        removal.disconnect();
-    }
-
-    //drop potential overlaps between additions
-    removeRedundantBoxesArray(additions);
-
-    //perform additions
-    for (i = 0, l = additions.length; i < l; i++) {
-        const addition = additions[i];
-
-        boxes.insertDatum(addition);
-    }
-}
-
-/**
- *
- * @param {AABB2} box
- * @param {QuadTreeNode} free
- * @returns {boolean}
- */
-function packOneBox(box, free) {
-    const w = box.getWidth();
-    const h = box.getHeight();
-
-    const container = findBestContainer(w, h, free, costByRemainingArea);
-
-    if (container === null) {
-        //couldn't find a place for box
-        return false;
-    }
-
-    //remove container from free set
-    container.disconnect();
-
-    //place box at bottom left of the container
-    const y0 = container.y0;
-    const x0 = container.x0;
-
-    box.set(x0, y0, x0 + w, y0 + h);
-
-    //update remaining set by removing this box area from free set
-    cutArea(box, free);
-
-    //split remaining space
-    if (box.y1 !== container.y1) {
-        const splitA = new QuadTreeDatum(container.x0, box.y1, container.x1, container.y1);
-
-        free.insertDatum(splitA);
-    }
-
-    if (box.x1 !== container.x1) {
-        const splitB = new QuadTreeDatum(box.x1, container.y0, container.x1, container.y1);
-        free.insertDatum(splitB);
-    }
-
-
-    return true;
-}
-
 export class MaxRectanglesPacker {
     /**
      *
@@ -456,13 +250,9 @@ export class MaxRectanglesPacker {
  * @param {AABB2[]} boxes
  * @returns {boolean} true if packing was successful, false otherwise
  */
-function packMaxRectangles(width, height, boxes) {
+export function packMaxRectangles(width, height, boxes) {
 
     const packer = new MaxRectanglesPacker(width, height);
 
     return packer.addMany(boxes);
 }
-
-export {
-    packMaxRectangles
-};

package/src/core/geom/packing/max-rect/cost/costByBestShortSide.js

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {number} containerWidth
+ * @param {number} containerHeight
+ * @param {number} childWidth
+ * @param {number} childHeight
+ * @returns {number}
+ */
+export function costByBestShortSide(containerWidth, containerHeight, childWidth, childHeight) {
+    return Math.min(containerWidth - childWidth, containerHeight - childHeight);
+}

package/src/core/geom/packing/max-rect/cost/costByRemainingArea.js

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param {number} containerWidth
+ * @param {number} containerHeight
+ * @param {number} childWidth
+ * @param {number} childHeight
+ * @returns {number}
+ */
+export function costByRemainingArea(containerWidth, containerHeight, childWidth, childHeight) {
+    const dW = containerWidth - childWidth;
+    const dH = containerHeight - childHeight;
+
+    return dW * containerHeight + dH * childWidth;
+}