@woosh/meep-engine 2.50.3 → 2.52.0

package/src/core/bvh2/bvh3/query/bvh_query_leaves_generic.spec.js

@@ -0,0 +1,22 @@
+import { ExplicitBinaryBoundingVolumeHierarchy } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { bvh_query_leaves_generic } from "./bvh_query_leaves_generic.js";
+import { BVHQueryAny } from "./BVHQueryAny.js";
+
+test("all-accepting query", () => {
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    const leaf_a = bvh.allocate_node();
+    const leaf_b = bvh.allocate_node();
+
+    bvh.insert_leaf(leaf_a);
+    bvh.insert_leaf(leaf_b);
+
+    const result = [];
+
+    const count = bvh_query_leaves_generic(result, 1, bvh, bvh.root, BVHQueryAny.INSTANCE);
+
+    expect(count).toBe(2);
+    expect(result).toContain(leaf_a);
+    expect(result).toContain(leaf_b);
+
+});

package/src/core/bvh2/bvh3/query/bvh_query_leaves_ray.js

@@ -13,6 +13,7 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 /**
  *
  * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number} root
  * @param {number[]} result
  * @param {number} result_offset
  * @param {number} origin_x
@@ -24,12 +25,11 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  * @returns {number}
  */
 export function bvh_query_leaves_ray(
-    bvh,
+    bvh, root,
     result, result_offset,
     origin_x, origin_y, origin_z,
     direction_x, direction_y, direction_z
 ) {
-    const root = bvh.root;
 
     if (root === NULL_NODE) {
         return 0;

package/src/core/bvh2/bvh3/query/bvh_query_leaves_ray.spec.js

@@ -0,0 +1,64 @@
+import { ExplicitBinaryBoundingVolumeHierarchy } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { bvh_query_leaves_ray } from "./bvh_query_leaves_ray.js";
+
+/**
+ *
+ * @param {number[]} leaves
+ */
+function makeBVH(...leaves) {
+
+    const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    for (let i = 0; i < leaves.length; i++) {
+
+        const node = bvh.allocate_node();
+
+        bvh.node_set_aabb(node, leaves[i]);
+        bvh.node_set_user_data(node, i);
+
+        bvh.insert_leaf(node);
+    }
+
+    return bvh;
+}
+
+test("cast positive -X to +X, 1 node", () => {
+
+    const bvh = makeBVH(
+        [1, 3, 5, 7, 11, 13]
+    );
+
+    const result = [];
+
+    const match_count = bvh_query_leaves_ray(
+        bvh, bvh.root,
+        result, 0,
+        -1, 4, 6,
+        1, 0, 0
+    );
+
+    expect(match_count).toBe(1);
+
+    expect(result[0]).toEqual(0);
+});
+
+test("cast positive -X to +X, 1/2 nodes", () => {
+
+    const bvh = makeBVH(
+        [-4, 3, 5, -2, 11, 13],
+        [1, 3, 5, 7, 11, 13]
+    );
+
+    const result = [];
+
+    const match_count = bvh_query_leaves_ray(
+        bvh, bvh.root,
+        result, 0,
+        -1, 4, 6,
+        1, 0, 0
+    );
+
+    expect(match_count).toBe(1);
+
+    expect(result[0]).toEqual(1);
+});

package/src/core/bvh2/bvh3/query/bvh_query_user_data_generic.js

@@ -9,16 +9,15 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
  * @param {number[]} result
  * @param {number} result_offset
+ * @param {number} root
  * @param {BVHQuery} query
  * @returns {number}
  */
 export function bvh_query_user_data_generic(
     result, result_offset,
-    bvh, query
+    bvh,root, query
 ) {
 
-    const root = bvh.root;
-
     if (root === NULL_NODE) {
         return 0;
     }

package/src/core/bvh2/visual/convert_bvh_to_dot_format_string.js

@@ -1,4 +1,4 @@
-import { convertGraphToDotString } from "../../graph/convertGraphToDotString.js";
+import { convert_graph_to_dot_string } from "../../graph/convert_graph_to_dot_string.js";
 import { bvh_traverse_pre_order_using_stack } from "../traversal/bvh_traverse_pre_order_using_stack.js";
 import { Graph } from "../../graph/v2/Graph.js";
 import { Edge, EdgeDirectionType } from "../../graph/Edge.js";
@@ -46,5 +46,5 @@ export function bvh_to_graph(bvh) {
  */
 export function convert_bvh_to_dot_format_string(bvh) {
     const graph = bvh_to_graph(bvh);
-    return convertGraphToDotString({ graph: graph });
+    return convert_graph_to_dot_string({ graph: graph });
 }

package/src/core/cache/Cache.js

@@ -5,9 +5,10 @@ import { returnOne, returnZero, strictEquals } from "../function/Functions.js";
 import { CacheElement } from "./CacheElement.js";
 import { collectIteratorValueToArray } from "../collection/collectIteratorValueToArray.js";
 
+// TODO validate hashes of held elements to keep them up to date. Keys are assumed to be immutable, but this assumption may be broken by users
+
 /**
  * Hash-based cache, uses LRU (least-recently-used) eviction policy
- * TODO validate hashes of held elements to keep them up to date. Keys are assumed to be immutable, but this assumption may be broken by users
  * @template Key, Value
  * @extends Map<Key,Value>
  */
@@ -403,7 +404,7 @@ export class Cache {
     }
 
     /**
-     * Remove without triggering {@link #removeListener}
+     * Remove without triggering {@link #onRemoved}
      * NOTE: please be sure you understand what you're doing when you use this method
      * @param {Key} key
      * @returns {boolean} true if element was removed, false otherwise
@@ -469,20 +470,17 @@ export class Cache {
 /**
  * Shortcut for "Map" class spec compliance
  * @readonly
- * @type {Cache.put}
  */
 Cache.prototype.set = Cache.prototype.put;
 
 /**
  * Shortcut for "Map" class spec compliance
  * @readonly
- * @type {Cache.remove}
  */
 Cache.prototype.delete = Cache.prototype.remove;
 
 /**
  * Shortcut for "Map" class spec compliance
  * @readonly
- * @type {Cache.contains}
  */
 Cache.prototype.has = Cache.prototype.contains;

package/src/core/cache/CacheElement.js

@@ -1,6 +1,7 @@
 /**
  * Doubly-linked list implementation for key-value pairs
  * @template Key, Value
+ * @class
  */
 export class CacheElement {
     /**

package/src/core/geom/2d/quad-tree/PointQuadTree.js

@@ -170,7 +170,17 @@ class PointQuadTree {
         this.br = undefined;
     }
 
+    /**
+     *
+     * @param {T} p
+     * @param {number} x
+     * @param {number} y
+     * @return {Element}
+     */
     insert(p, x, y) {
+        assert.isNumber(x, 'x');
+        assert.isNumber(y, 'y');
+
         const element = new Element(p, x, y);
 
         this.resizeToFit(x, y); //adjust size if needed

package/src/core/geom/3d/aabb/aabb3_array_combine.js

@@ -5,9 +5,9 @@ import { max2 } from "../../../math/max2.js";
 
 /**
  * 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
+ * @param {ArrayLike<number>|number[]|Float32Array} result where resulting value is written to
+ * @param {ArrayLike<number>|number[]|Float32Array} a
+ * @param {ArrayLike<number>|number[]|Float32Array} b
  */
 export function aabb3_array_combine(result, a, b) {
     result[0] = min2(a[0], b[0]);

package/src/core/geom/3d/aabb/aabb3_from_threejs_geometry.js

@@ -0,0 +1,41 @@
+import { assert } from "../../../assert.js";
+
+/**
+ *
+ * @param {number[]|ArrayLike<number>|Float32Array} result
+ * @param {BufferGeometry} geometry
+ */
+export function aabb3_from_threejs_geometry(result, geometry) {
+    const gbb = geometry.boundingBox;
+
+    assert.notNull(gbb, 'boundingBox');
+
+    const min = gbb.min;
+    const max = gbb.max;
+
+    const x0 = min.x;
+    const y0 = min.y;
+    const z0 = min.z;
+
+    const x1 = max.x;
+    const y1 = max.y;
+    const z1 = max.z;
+
+    // validate bounds
+    assert.notNaN(x0, 'x0');
+    assert.notNaN(y0, 'y0');
+    assert.notNaN(z0, 'z0');
+
+    assert.notNaN(x1, 'x1');
+    assert.notNaN(y1, 'y1');
+    assert.notNaN(z1, 'z1');
+
+    // marshal into transform-accepted format
+    result[0] = x0;
+    result[1] = y0;
+    result[2] = z0;
+
+    result[3] = x1;
+    result[4] = y1;
+    result[5] = z1;
+}

package/src/core/geom/3d/topology/struct/TopoMesh.js

@@ -8,7 +8,8 @@ import { tm_kill_only_vert } from "../tm_kill_only_vert.js";
 import { tm_kill_only_edge } from "../tm_kill_only_edge.js";
 import { tm_kill_only_face } from "../tm_kill_only_face.js";
 import { query_edge_other_vertex } from "../query/query_edge_other_vertex.js";
-import { formatNumberByThousands } from "../../../../NumberFormat.js";
+
+import { number_format_by_thousands } from "../../../../primitives/numbers/number_format_by_thousands.js";
 
 export class TopoMesh {
     constructor() {
@@ -643,7 +644,7 @@ export class TopoMesh {
     }
 
     toString() {
-        return `TopoMesh{ vertices: ${formatNumberByThousands(this.vertices.length)}, edges: ${formatNumberByThousands(this.getEdges().size)}, faces: ${formatNumberByThousands(this.getFaces().size)} }`;
+        return `TopoMesh{ vertices: ${number_format_by_thousands(this.vertices.length)}, edges: ${number_format_by_thousands(this.getEdges().size)}, faces: ${number_format_by_thousands(this.getFaces().size)} }`;
     }
 }
 

package/src/core/geom/3d/topology/struct/prototypeBinaryTopology.js

@@ -5,8 +5,8 @@ import { BinaryTopology } from "./binary/BinaryTopology.js";
 import {
     compute_buffer_geometry_byte_size
 } from "../../../../../engine/graphics/geometry/buffered/compute_buffer_geometry_byte_size.js";
-import { prettyPrint } from "../../../../NumberFormat.js";
 import { TopoMesh } from "./TopoMesh.js";
+import { number_pretty_print } from "../../../../primitives/numbers/number_pretty_print.js";
 
 function promise_ply(url) {
 
@@ -44,9 +44,9 @@ async function main() {
 
     console.log(mesh, lucy_geom);
 
-    console.log(`source mesh size: ${prettyPrint(compute_buffer_geometry_byte_size(lucy_geom))} bytes`);
-    console.log(`binary topology size: ${prettyPrint(mesh.byteSize)} bytes`);
-    console.log(`object topology size: ${prettyPrint(topoMesh.byteSize)} bytes`);
+    console.log(`source mesh size: ${number_pretty_print(compute_buffer_geometry_byte_size(lucy_geom))} bytes`);
+    console.log(`binary topology size: ${number_pretty_print(mesh.byteSize)} bytes`);
+    console.log(`object topology size: ${number_pretty_print(topoMesh.byteSize)} bytes`);
 
     window.topo_obj = topoMesh;
 }

package/src/core/geom/Vector2.d.ts

@@ -23,6 +23,8 @@ export default class Vector2 {
 
     _sub(x: number, y: number): void
 
+    lerpVectors(a: Vector2, b: Vector2, f: number): void
+
     abs(): void
 
     round(): void
@@ -31,6 +33,8 @@ export default class Vector2 {
 
     ceil(): void
 
+    rotate(angle: number): void
+
     copy(other: Vector2): void
 
     clone(): Vector2
@@ -39,8 +43,13 @@ export default class Vector2 {
 
     roughlyEquals(other: Vector2, tolerance?: number): boolean
 
+    hash(): number
+
     distanceTo(other: Vector2): number
 
+    manhattanDistanceTo(other: Vector2): number
+
+
     isZero(): boolean
 
     readFromArray(array: ArrayLike<number>, offset?: number): void

package/src/core/geom/Vector2.js

@@ -450,7 +450,10 @@ class Vector2 {
      * @param {number} fraction
      */
     lerpVectors(a, b, fraction) {
-        v2Lerp(this, a, b, fraction);
+        const x = lerp(a.x, b.x, fraction);
+        const y = lerp(a.y, b.y, fraction);
+
+        this.set(x, y);
     }
 
     /**
@@ -538,7 +541,7 @@ class Vector2 {
      *
      * @returns {number}
      */
-    hashCode() {
+    hash() {
         const x = Math.sin(this.x) * 1367130550;
         const y = Math.sin(this.y) * 1367130550;
 
@@ -550,7 +553,7 @@ class Vector2 {
     }
 
     /**
-     *
+     * Rotation is counter-clockwise
      * @param {number} angle in radians
      */
     rotate(angle) {
@@ -558,7 +561,7 @@ class Vector2 {
         const cos = Math.cos(angle);
 
         const x = this.x * cos - this.y * sin
-        const y = this.x * sin - this.y * cos;
+        const y = this.x * sin + this.y * cos;
 
         this.set(x, y);
     }
@@ -597,7 +600,7 @@ class Vector2 {
      * @return {boolean}
      */
     roughlyEquals(other, tolerance) {
-        return this._roughlyEquals(other.x, other.y,  tolerance);
+        return this._roughlyEquals(other.x, other.y, tolerance);
     }
 
     /**
@@ -677,23 +680,6 @@ Vector2.one = Object.freeze(new Vector2(1, 1));
  * @type {boolean}
  */
 Vector2.prototype.isVector2 = true;
-
-/**
- *
- * @param {Vector2} result
- * @param {Vector2} a
- * @param {Vector2} b
- * @param {number} fraction
- */
-function v2Lerp(result, a, b, fraction) {
-
-    const x = lerp(a.x, b.x, fraction);
-    const y = lerp(a.y, b.y, fraction);
-
-    result.set(x, y);
-}
-
-
 /**
  *
  * @param {number} x0

package/src/core/geom/Vector2.spec.js

@@ -8,6 +8,21 @@ test("setting x and y via constructor", () => {
     expect(v.y).toBe(13);
 });
 
+test("array-style accessors", () => {
+
+    const v = new Vector2();
+
+    v[0] = 3;
+    v[1] = -7;
+
+    expect(v[0]).toEqual(3);
+    expect(v.x).toEqual(3);
+
+    expect(v[1]).toEqual(-7);
+    expect(v.y).toEqual(-7);
+
+});
+
 test('add works', () => {
     const a = new Vector2(1, 3);
     const b = new Vector2(5, 7);
@@ -140,3 +155,141 @@ test("onChange is dispatched when y changes via set", () => {
 
     expect(changeHandler).toHaveBeenLastCalledWith(2, 3, 1, 3);
 });
+
+test("rotate", () => {
+
+    const v = new Vector2(0, 0);
+
+    v.rotate(0);
+
+    expect(v.x).toBeCloseTo(0);
+    expect(v.y).toBeCloseTo(0);
+
+    v.set(1, 0);
+
+    v.rotate(0);
+
+    expect(v.x).toBeCloseTo(1);
+    expect(v.y).toBeCloseTo(0);
+
+    v.set(0, 1);
+
+    v.rotate(0);
+
+    expect(v.x).toBeCloseTo(0);
+    expect(v.y).toBeCloseTo(1);
+
+    v.set(1, 0);
+
+    v.rotate(Math.PI);
+
+    expect(v.x).toBeCloseTo(-1);
+    expect(v.y).toBeCloseTo(0);
+
+    v.set(-1, 0);
+
+    v.rotate(Math.PI);
+
+    expect(v.x).toBeCloseTo(1);
+    expect(v.y).toBeCloseTo(0);
+
+    v.set(0, 1);
+
+    v.rotate(Math.PI);
+
+    expect(v.x).toBeCloseTo(0);
+    expect(v.y).toBeCloseTo(-1);
+
+    v.set(0, -1);
+
+    v.rotate(Math.PI);
+
+    expect(v.x).toBeCloseTo(0);
+    expect(v.y).toBeCloseTo(1);
+
+    v.set(1, 1);
+
+    v.rotate(Math.PI * 0.5);
+
+    expect(v.x).toBeCloseTo(-1);
+    expect(v.y).toBeCloseTo(1);
+});
+
+test("hash", () => {
+
+    function validate(x, y) {
+
+        const v = new Vector2(x, y);
+
+        const hash = v.hash();
+
+        expect(hash).toEqual(v.hash()); // stability
+        expect(typeof hash).toBe("number");
+        expect(Number.isInteger(hash)).toBe(true);
+
+    }
+
+    validate(0, 0);
+    validate(0, 1);
+    validate(1, 0);
+    validate(1, 1);
+
+    validate(0, -1);
+    validate(-1, 0);
+    validate(-1, -1);
+});
+
+test("normalize", () => {
+
+    const v = new Vector2(1, 1);
+
+    v.normalize();
+
+    const s = 1 / Math.SQRT2;
+
+    expect(v.x).toBeCloseTo(s);
+    expect(v.y).toBeCloseTo(s);
+
+    v.set(-1, -1);
+
+    v.normalize();
+
+    expect(v.x).toBeCloseTo(-s);
+    expect(v.y).toBeCloseTo(-s);
+
+});
+
+test("length", () => {
+
+    expect(new Vector2(1, 0).length()).toBeCloseTo(1);
+    expect(new Vector2(0, 1).length()).toBeCloseTo(1);
+
+    expect(new Vector2(1, 1).length()).toBeCloseTo(Math.SQRT2);
+
+    expect(new Vector2(-1, 1).length()).toBeCloseTo(Math.SQRT2);
+
+    expect(new Vector2(1, -1).length()).toBeCloseTo(Math.SQRT2);
+
+    expect(new Vector2(-1, -1).length()).toBeCloseTo(Math.SQRT2);
+});
+
+
+test("manhattanDistanceTo", () => {
+    const a = new Vector2(1, 3);
+    const b = new Vector2(5, 11);
+
+    expect(a.manhattanDistanceTo(b)).toEqual(12)
+});
+
+test("lerpVectors", () => {
+
+
+    const a = new Vector2(-1, 3);
+    const b = new Vector2(5, -11);
+
+    a.lerpVectors(a, b, 0.1);
+
+    expect(a.x).toBeCloseTo(-1 * 0.9 + 5 * 0.1);
+    expect(a.y).toBeCloseTo(3 * 0.9 - 11 * 0.1);
+
+});

package/src/core/graph/{convertGraphToDotString.js → convert_graph_to_dot_string.js}

@@ -13,7 +13,7 @@ function defaultNodeToDot(node){
  * @param {function(Node):string} nodeToDot
  * @returns {string}
  */
-export function convertGraphToDotString({
+export function convert_graph_to_dot_string({
                                             graph,
                                             nodeToDot=defaultNodeToDot
 }) {

package/src/core/graph/convert_graph_to_dot_string.spec.js

@@ -0,0 +1,28 @@
+import { convert_graph_to_dot_string } from "./convert_graph_to_dot_string.js";
+import { Graph } from "./v2/Graph.js";
+import { EdgeDirectionType } from "./Edge.js";
+
+test("empty graph should produce valid string", () => {
+    const dot = convert_graph_to_dot_string({
+        graph: new Graph()
+    });
+
+    expect(typeof dot).toEqual("string");
+    expect(dot.trim().length).toBeGreaterThan(0);
+});
+
+test("graph with 2 nodes and an edge should produce valid string", () => {
+    const graph = new Graph();
+
+    graph.addNode(1);
+    graph.addNode(2);
+
+    graph.createEdge(1, 2, EdgeDirectionType.Forward);
+
+    const dot = convert_graph_to_dot_string({
+        graph: graph
+    });
+
+    expect(typeof dot).toEqual("string");
+    expect(dot.trim().length).toBeGreaterThan(0);
+});

package/src/core/math/noise/sdnoise.js

@@ -195,7 +195,7 @@ function grad4(result, hash) {
  * @param {number[]} derivatives
  * @returns {number}
  */
-function sdnoise1(derivatives, x) {
+export function sdnoise1(derivatives, x) {
     const i0 = x | 0;
     const i1 = i0 + 1;
 
@@ -207,8 +207,7 @@ function sdnoise1(derivatives, x) {
     let t1, t20, t40, t21, t41, x21;
 
     const x20 = x0 * x0;
-    const t0 = 1.0
-    f - x20;
+    const t0 = 1.0 - x20;
 //  if(t0 < 0.0f) t0 = 0.0f; // Never happens for 1D: x0<=1 always
     t20 = t0 * t0;
     t40 = t20 * t20;
@@ -218,8 +217,7 @@ function sdnoise1(derivatives, x) {
     n0 = t40 * gx0 * x0;
 
     x21 = x1 * x1;
-    t1 = 1.0
-    f - x21;
+    t1 = 1.0 - x21;
 //  if(t1 < 0.0f) t1 = 0.0f; // Never happens for 1D: |x1|<=1 always
     t21 = t1 * t1;
     t41 = t21 * t21;
@@ -265,7 +263,7 @@ const G2 = 0.21132486540518713;
  * @param {number[]} derivatives
  * @returns {number}
  */
-function sdnoise2(derivatives, x, y) {
+export function sdnoise2(derivatives, x, y) {
     let n0, n1, n2; /* Noise contributions from the three simplex corners */
     let gx0, gy0, gx1, gy1, gx2, gy2; /* Gradients at simplex corners */
     let t0, t1, t2, x1, x2, y1, y2;
@@ -280,7 +278,7 @@ function sdnoise2(derivatives, x, y) {
     let ii, i = xs | 0;
     let jj, j = ys | 0;
 
-    const t = (float)(i + j) * G2;
+    const t = (i + j) * G2;
     const X0 = i - t; /* Unskew the cell origin back to (x,y) space */
     const Y0 = j - t;
     const x0 = x - X0; /* The x,y distances from the cell origin */