@woosh/meep-engine 2.43.1 → 2.43.4

package/core/binary/BinaryBuffer.js

@@ -343,7 +343,7 @@ export class BinaryBuffer {
      *
      * @param {number} destination_offset starting index in the destination array
      * @param {number} length number of elements to read
-     * @param {Uint32Array} destination
+     * @param {Uint32Array|number[]|ArrayLike<number>} destination
      */
     readUint32Array(destination, destination_offset, length) {
         for (let i = 0; i < length; i++) {
@@ -707,6 +707,18 @@ export class BinaryBuffer {
         this.position = end;
     }
 
+    /**
+     *
+     * @param {Uint32Array|number[]|ArrayLike<number>} source
+     * @param {number} source_offset
+     * @param {number} length
+     */
+    writeUint32Array(source, source_offset, length) {
+        for (let i = 0; i < length; i++) {
+            this.writeUint32(source[source_offset + i]);
+        }
+    }
+
     /**
      *
      * @param {Uint8Array|Uint8ClampedArray} array

package/core/binary/BitSet.js

@@ -403,9 +403,9 @@ BitSet.prototype.set = function (bitIndex, value) {
 
         if (bitIndex === this.__length - 1) {
             // trim down set size potentially
-            const newLastSetBit = this.previousSetBit(bitIndex);
+            // const newLastSetBit = this.previousSetBit(bitIndex);
 
-            this.__setLength(newLastSetBit + 1);
+            this.__setLength(bitIndex );
         }
     }
 

package/core/bvh2/aabb3/aabb3_array_combine.js

@@ -4,8 +4,8 @@ import { min2 } from "../../math/min2.js";
 import { max2 } from "../../math/max2.js";
 
 /**
- *
- * @param {ArrayLike<number>|number[]} result
+ * Merge bounds of two axis-aligned bounding boxes, the result is a box that tightly bounds inputs
+ * @param {ArrayLike<number>|number[]} result where resulting value is written to
  * @param {ArrayLike<number>|number[]} a
  * @param {ArrayLike<number>|number[]} b
  */

package/core/collection/RingBuffer.js

@@ -1,4 +1,5 @@
 import { assert } from "../assert.js";
+import { min2 } from "../math/min2.js";
 
 export class RingBuffer {
     /**
@@ -12,7 +13,7 @@ export class RingBuffer {
         assert.isNonNegativeInteger(size, 'size');
 
         /**
-         *
+         * Capacity of the buffer, number of slots
          * @type {number}
          */
         this.size = size;
@@ -30,7 +31,7 @@ export class RingBuffer {
         this.tail = 0;
 
         /**
-         *
+         * Number of used slots. Starts at 0, goes up to {@link #size}
          * @type {number}
          */
         this.count = 0;
@@ -51,6 +52,7 @@ export class RingBuffer {
 
         this.data = array;
         this.size = new_size;
+        this.count = min2(new_size, this.count);
 
         this.clear();
 

package/core/collection/RingBuffer.spec.js

@@ -0,0 +1,59 @@
+import { RingBuffer } from "./RingBuffer.js";
+
+test("constructor doesn't throw", () => {
+    expect(() => new RingBuffer(1)).not.toThrow();
+});
+
+test("size set from constructor", () => {
+    const sut = new RingBuffer(7);
+
+    expect(sut.size).toBe(7);
+});
+
+test("circular overwriting", () => {
+    const sut = new RingBuffer(2);
+
+    sut.push(3);
+    sut.push(7);
+    sut.push(11);
+
+    expect(sut.contains(3)).toBe(false);
+    expect(sut.contains(7)).toBe(true);
+    expect(sut.contains(11)).toBe(true);
+});
+
+test("empty buffer count must be 0", () => {
+    const sut = new RingBuffer(1);
+
+    expect(sut.count).toBe(0);
+});
+
+test("buffer count works as expected", () => {
+    const sut = new RingBuffer(2);
+
+    expect(sut.count).toBe(0);
+
+    sut.push(1);
+
+    expect(sut.count).toBe(1);
+
+    sut.push(3);
+
+    expect(sut.count).toBe(2);
+
+    sut.push(7);
+
+    expect(sut.count).toBe(2);
+});
+
+test("resizing changes capacity", () => {
+    const sut = new RingBuffer(2);
+
+    sut.resize(1);
+
+    expect(sut.size).toBe(1);
+
+    sut.resize(3);
+
+    expect(sut.size).toBe(3);
+});

package/core/collection/array/ArrayIteratorRandom.js

@@ -1,6 +1,6 @@
 import { seededRandom } from "../../math/random/seededRandom.js";
-import { randomizeArrayElementOrder } from "../ArrayUtils.js";
 import { AbstractArrayIterator } from "./AbstractArrayIterator.js";
+import { randomizeArrayElementOrder } from "./randomizeArrayElementOrder.js";
 
 export class ArrayIteratorRandom extends AbstractArrayIterator {
     constructor() {

package/core/collection/{ArrayUtils.spec.js → array/arrayPickBestElement.spec.js}

@@ -1,4 +1,4 @@
-import { arrayPickBestElement } from "./array/arrayPickBestElement.js";
+import { arrayPickBestElement } from "./arrayPickBestElement.js";
 
 test("arrayPickBestElement largest number", () => {
     expect(

package/core/collection/array/arrayPickBestElements.js

@@ -0,0 +1,51 @@
+import { assert } from "../../assert.js";
+
+/**
+ * @template T
+ * @param {T[]} array
+ * @param {function(T):number} scoreFunction
+ * @returns {T[]}
+ */
+export function arrayPickBestElements(array, scoreFunction) {
+    assert.notEqual(array, undefined, 'array is undefined');
+    assert.isArray(array, 'array');
+
+    assert.typeOf(scoreFunction, 'function', 'scoreFunction');
+
+    let bestScore;
+
+    const size = array.length;
+
+    if (size === 0) {
+        return [];
+    }
+
+    const first = array[0];
+
+    bestScore = scoreFunction(first);
+
+    assert.isNumber(bestScore, 'bestScore');
+
+    const result = [first];
+
+    for (let i = 1; i < size; i++) {
+        const el = array[i];
+
+        // compute score
+        const score = scoreFunction(el);
+
+        assert.isNumber(score, 'score');
+
+        if (score > bestScore) {
+            bestScore = score;
+
+            result.splice(0, result.length);
+
+            result.push(el);
+        } else if (score === bestScore) {
+            result.push(el);
+        }
+    }
+
+    return result;
+}

package/core/collection/array/arrayPickMinElement.js

@@ -0,0 +1,43 @@
+import { assert } from "../../assert.js";
+
+/**
+ * @template T
+ * @param {T[]} array
+ * @param {function(T):number} scoreFunction
+ * @returns {T}
+ */
+export function arrayPickMinElement(array, scoreFunction) {
+    assert.notEqual(array, undefined, 'array is undefined');
+    assert.typeOf(scoreFunction, 'function', 'scoreFunction');
+
+    let bestElement;
+    let bestScore;
+
+    const size = array.length;
+
+    if (size === 0) {
+        return undefined;
+    }
+
+    bestElement = array[0];
+
+    bestScore = scoreFunction(bestElement);
+
+    assert.typeOf(bestScore, 'number', 'bestScore');
+
+    for (let i = 1; i < size; i++) {
+        const el = array[i];
+
+        // compute score
+        const score = scoreFunction(el);
+
+        assert.typeOf(score, 'number', 'score');
+
+        if (score < bestScore) {
+            bestScore = score;
+            bestElement = el;
+        }
+    }
+
+    return bestElement;
+}

package/core/collection/array/arrayQuickSort.js

@@ -1,4 +1,4 @@
-import { arraySwapElements } from "../ArrayUtils.js";
+import { arraySwapElements } from "./arraySwapElements.js";
 
 const stack = [];
 

package/core/collection/array/arraySetSortingDiff.js

@@ -3,7 +3,7 @@ import { assert } from "../../assert.js";
 //
 
 /**
- * Based on 2-way merge algorith from wiki: https://en.wikipedia.org/wiki/K-way_merge_algorithm
+ * Based on 2-way merge algorithm from wiki: https://en.wikipedia.org/wiki/K-way_merge_algorithm
  * @template T
  * @param {T[]} a
  * @param {T[]} b

package/core/collection/array/arraySwapElements.js

@@ -0,0 +1,12 @@
+/**
+ * @template T
+ * @param {T[]} array
+ * @param {number} index0
+ * @param {number} index1
+ */
+export function arraySwapElements(array, index0, index1) {
+    const t = array[index0];
+
+    array[index0] = array[index1];
+    array[index1] = t;
+}

package/core/collection/array/array_range_equal_strict.js

@@ -0,0 +1,22 @@
+/**
+ * Checks that elements in supplied arrays are exactly equal within a certain range defined by a pair of offsets and element count (length)
+ * @template T
+ * @param {T[]} a
+ * @param {number} offset_a
+ * @param {T[]} b
+ * @param {number} offset_b
+ * @param {number} length
+ * @returns {boolean}
+ */
+export function array_range_equal_strict(a, offset_a, b, offset_b, length) {
+
+    for (let i = 0; i < length; i++) {
+
+        if (a[offset_a + i] !== b[offset_b + i]) {
+            return false;
+        }
+
+    }
+
+    return true;
+}

package/core/collection/array/groupArrayBy.js

@@ -0,0 +1,42 @@
+import { returnZero } from "../../function/Functions.js";
+import { HashMap } from "../HashMap.js";
+
+/**
+ * @template T,K
+ * @param {T[]} array
+ * @param {function(T):K} groupingFunction
+ * @param keyHashFunction
+ * @returns {Map<K,T[]>}
+ */
+export function groupArrayBy(array, groupingFunction, keyHashFunction = returnZero) {
+    const result = new HashMap({
+        keyHashFunction,
+        keyEqualityFunction(a, b) {
+            if (a === b) {
+                return true;
+            }
+
+            if (typeof a === "object" && a !== null && typeof a.equals === "function") {
+                return a.equals(b);
+            }
+
+            return false;
+        }
+    });
+
+    for (let i = 0; i < array.length; i++) {
+        const element = array[i];
+
+        const groupKey = groupingFunction(element);
+
+        const group = result.get(groupKey);
+
+        if (group === undefined) {
+            result.set(groupKey, [element]);
+        } else {
+            group.push(element);
+        }
+    }
+
+    return result;
+}

package/core/collection/array/isArrayEqual.js

@@ -0,0 +1,50 @@
+/**
+ * @template T,R
+ * @param {T[]} first
+ * @param {R[]} second
+ * @return {boolean}
+ */
+export function isArrayEqual(first, second) {
+
+    const il = first.length;
+
+    if (il !== second.length) return false;
+
+    let i = 0;
+
+    for (; i < il; i++) {
+
+        const a = first[i];
+        const b = second[i];
+
+        if (a === b) {
+            continue;
+        }
+
+
+        if (a === undefined) {
+            //a is undefined, and B is something else
+            return false;
+        }
+
+        if (a === null) {
+            //a is null and B is something else
+            return false;
+        }
+
+        //try "equals" method
+        if (typeof a.equals === "function") {
+
+            if (!a.equals(b)) {
+                return false;
+            }
+
+        } else {
+            return false;
+        }
+
+    }
+
+    return true;
+
+}

package/core/collection/array/randomMultipleFromArray.js

@@ -0,0 +1,34 @@
+import { randomizeArrayElementOrder } from "./randomizeArrayElementOrder.js";
+import { min2 } from "../../math/min2.js";
+
+/**
+ * Pick multiple random items from an array
+ *
+ * @template T
+ * @param {function} random
+ * @param {T[]} source
+ * @param {T[]} target
+ * @param {number} count how many items to pick
+ * @returns {T}
+ */
+export function randomMultipleFromArray(random, source, target, count) {
+
+    const order = [];
+
+    const source_length = source.length;
+    for (let i = 0; i < source_length; i++) {
+        order[i] = i;
+    }
+
+    randomizeArrayElementOrder(random, order);
+
+    const target_length = min2(source_length, count);
+
+    for (let i = 0; i < target_length; i++) {
+        const index = order[i];
+        const element = source[index];
+        target.push(element);
+    }
+
+    return target_length;
+}

package/core/collection/array/randomizeArrayElementOrder.js

@@ -0,0 +1,23 @@
+import { randomIntegerBetween } from "../../math/random/randomIntegerBetween.js";
+import { arraySwapElements } from "./arraySwapElements.js";
+
+/**
+ * @template T
+ * @param {function} random
+ * @param {T[]} array
+ */
+export function randomizeArrayElementOrder(random, array) {
+    const n = array.length;
+
+    const lastValidIndex = n - 1;
+
+    for (let i = 0; i < n; i++) {
+        const t = randomIntegerBetween(random, 0, lastValidIndex);
+
+        if (t === i) {
+            continue;
+        }
+
+        arraySwapElements(array, i, t);
+    }
+}

package/core/color/sRGB_to_linear.js

@@ -1,4 +1,9 @@
-function convert(c) {
+/**
+ *
+ * @param {number} c
+ * @return {number|number}
+ */
+export function convert_channel_sRGB_to_linear(c) {
     return (c < 0.04045) ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
 }
 
@@ -10,7 +15,7 @@ function convert(c) {
  * @param {number} input_offset
  */
 export function sRGB_to_linear(output, output_offset, input, input_offset) {
-    output[output_offset] = convert(input[input_offset]);
-    output[output_offset + 1] = convert(input[input_offset + 1]);
-    output[output_offset + 2] = convert(input[input_offset + 2]);
+    output[output_offset] = convert_channel_sRGB_to_linear(input[input_offset]);
+    output[output_offset + 1] = convert_channel_sRGB_to_linear(input[input_offset + 1]);
+    output[output_offset + 2] = convert_channel_sRGB_to_linear(input[input_offset + 2]);
 }

package/core/geom/2d/convex-hull/convex_hull_monotone_2d.js

@@ -57,7 +57,7 @@ export function convex_hull_monotone_2d(points) {
 
         //Insert into upper list
         m = upper.length
-        while (m > 1 && orient(
+        while (m > 1 && orientation3_v2(
             points[upper[m - 2]],
             points[upper[m - 1]],
             p) >= 0) {

package/core/geom/3d/aabb/aabb3_build_frustum.js

@@ -1,5 +1,5 @@
 /**
- *
+ * Build orthographic frustum from an axis-aligned bounding box
  * @param {number[]} result
  * @param {number} x0
  * @param {number} y0

package/core/geom/3d/aabb/compute_aabb_from_points.js

@@ -2,7 +2,7 @@ import { min2 } from "../../../math/min2.js";
 import { max2 } from "../../../math/max2.js";
 
 /**
- *
+ * Multidimensional axis-aligned bounding box calculation
  * @param {number[]} result
  * @param {number[]} input
  * @param {number} input_count

package/core/geom/3d/frustum/frustum3_computeNearestPointToPoint.js

@@ -1,9 +1,11 @@
 import { computePlanePlaneIntersection } from "../../Plane.js";
 import Vector3 from "../../Vector3.js";
 import { plane3_projectPoint } from "../plane/plane3_projectPoint.js";
-import { plane_three_computeConvex3PlaneIntersection } from "../plane/plane_computeConvex3PlaneIntersection.js";
 import { ray_computeNearestPointToPoint } from "../ray/ray_computeNearestPointToPoint.js";
 import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
+import {
+    plane_three_computeConvex3PlaneIntersection
+} from "../plane/plane_three_compute_convex3_plane_intersection.js";
 
 /**
  *

package/core/geom/3d/morton/v3_morton_encode_transformed.spec.js

@@ -0,0 +1,20 @@
+import { v3_morton_encode_transformed } from "./v3_morton_encode_transformed.js";
+import { MATRIX_4_IDENTITY } from "../matrix/MATRIX_4_IDENTITY.js";
+
+test("valid number with identity transform", () => {
+    const v = v3_morton_encode_transformed(0, 0, 0, MATRIX_4_IDENTITY);
+
+    expect(typeof v).toBe('number');
+    expect(v).not.toBeNaN();
+});
+
+test("different coordinates produce different hashes", () => {
+    expect(v3_morton_encode_transformed(1, 0, 0, MATRIX_4_IDENTITY))
+        .not.toEqual(v3_morton_encode_transformed(0, 0, 0, MATRIX_4_IDENTITY));
+
+    expect(v3_morton_encode_transformed(0, 1, 0, MATRIX_4_IDENTITY))
+        .not.toEqual(v3_morton_encode_transformed(0, 0, 0, MATRIX_4_IDENTITY));
+
+    expect(v3_morton_encode_transformed(0, 0, 1, MATRIX_4_IDENTITY))
+        .not.toEqual(v3_morton_encode_transformed(0, 0, 0, MATRIX_4_IDENTITY));
+});

package/core/geom/3d/plane/orient3d_fast.js

@@ -1,4 +1,6 @@
 /**
+ * Non-robust
+ *
  * Return a positive value if the point pd lies below the
  * plane passing through pa, pb, and pc; "below" is defined so
  * that pa, pb, and pc appear in counterclockwise order when
@@ -24,24 +26,23 @@ export function orient3d_fast(points, a, b, c, d) {
     const c3 = c * 3;
 
     const d_x = points[d3];
-
-    const adx = points[a3] - d_x;
-    const bdx = points[b3] - d_x;
-    const cdx = points[c3] - d_x;
-
     const d_y = points[d3 + 1];
+    const d_z = points[d3 + 2];
 
+    const adx = points[a3] - d_x;
     const ady = points[a3 + 1] - d_y;
-    const bdy = points[b3 + 1] - d_y;
-    const cdy = points[c3 + 1] - d_y;
+    const adz = points[a3 + 2] - d_z;
 
-    const d_z = points[d3 + 2];
+    const bdx = points[b3] - d_x;
+    const bdy = points[b3 + 1] - d_y;
+    const cdz = points[c3 + 2] - d_z;
 
-    const adz = points[a3 + 2] - d_z;
+    const cdx = points[c3] - d_x;
+    const cdy = points[c3 + 1] - d_y;
     const bdz = points[b3 + 2] - d_z;
-    const cdz = points[c3 + 2] - d_z;
 
     return adx * (bdy * cdz - bdz * cdy)
         + bdx * (cdy * adz - cdz * ady)
         + cdx * (ady * bdz - adz * bdy);
 }
+

package/core/geom/3d/plane/orient3d_robust.js

@@ -0,0 +1,41 @@
+import { orient3d } from "robust-predicates";
+
+/**
+ *
+ * @param {number[]} points
+ * @param {number} a index of point a
+ * @param {number} b index of point b
+ * @param {number} c index of point c
+ * @param {number} d index of point d
+ * @returns {number}
+ */
+export function orient3d_robust(
+    points,
+    a, b, c, d
+) {
+
+
+    const a3 = a * 3;
+    const b3 = b * 3;
+    const c3 = c * 3;
+    const d3 = d * 3;
+
+    const ax = points[a3];
+    const ay = points[a3 + 1];
+    const az = points[a3 + 2];
+
+    const bx = points[b3];
+    const by = points[b3 + 1];
+    const bz = points[b3 + 2];
+
+    const cx = points[c3];
+    const cy = points[c3 + 1];
+    const cz = points[c3 + 2];
+
+    const dx = points[d3];
+    const dy = points[d3 + 1];
+    const dz = points[d3 + 2];
+
+
+    return orient3d(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz);
+}

package/core/geom/3d/plane/plane_computeConvex3PlaneIntersection.js

@@ -1,28 +1,5 @@
 import { v3_dot } from "../../v3_dot.js";
 
-/**
- *
- * @param {number[]} result
- * @param {number} result_offset
- * @param {Plane} a
- * @param {Plane} b
- * @param {Plane} c
- * @returns {boolean}
- */
-export function plane_three_computeConvex3PlaneIntersection(result, result_offset, a, b, c) {
-    const a_normal = a.normal;
-    const b_normal = b.normal;
-    const c_normal = c.normal;
-
-    return plane_computeConvex3PlaneIntersection(
-        result,
-        result_offset,
-        a_normal.x, a_normal.y, a_normal.z, a.constant,
-        b_normal.x, b_normal.y, b_normal.z, b.constant,
-        c_normal.x, c_normal.y, c_normal.z, c.constant,
-    );
-}
-
 /**
  * Given 3 planes, compute point of their intersection.
  * This only works when the planes are "convex", that is - no two planes are parallel.