@woosh/meep-engine 2.43.1 → 2.43.3

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/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/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

@@ -24,22 +24,20 @@ 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)

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.

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

@@ -0,0 +1,24 @@
+import { plane_computeConvex3PlaneIntersection } from "./plane_computeConvex3PlaneIntersection.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,
+    );
+}

package/core/geom/3d/shape/UnionShape3D.js

@@ -4,7 +4,7 @@ import { binarySearchHighIndex } from "../../../collection/array/binarySearchHig
 import { compareNumbers } from "../../../primitives/numbers/compareNumbers.js";
 import { min2 } from "../../../math/min2.js";
 import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
-import { isArrayEqual } from "../../../collection/ArrayUtils.js";
+import { isArrayEqual } from "../../../collection/array/isArrayEqual.js";
 
 /**
  * To avoid severe performance overhead, we limit number of possible rejections

package/core/geom/3d/tetrahedra/README.md

@@ -1,6 +1,15 @@
 collection of tools for working with tetrahedra (3d simplex)
 
-The main feature is tetrahedrasation (triangulation in 3d space) 
+The main feature is tetrahedrasation (triangulation in 3d space)
+
+### Optimization
+
+Optimize tetrahedrons to reduce number of thin and long tetras ([link](https://gitlab.onelab.info/gmsh/gmsh/-/blob/master/contrib/hxt/tetMesh/src/HXTSPR.c))
+
+## lighting
+[Ray-Traced Irradiance Fields (Presented by NVIDIA)](https://www.youtube.com/watch?v=KufJBCTdn_o)
+https://www.youtube.com/watch?v=pYY7iiVkyYE
+
 
 References
 ---