@woosh/meep-engine 2.49.6 → 2.49.8

package/src/core/fsm/simple/SimpleStateMachine.spec.js

@@ -0,0 +1,75 @@
+import { SimpleStateMachine } from "./SimpleStateMachine.js";
+import { SimpleStateMachineDescription } from "./SimpleStateMachineDescription.js";
+
+test("constructor does not throw", () => {
+    const description = new SimpleStateMachineDescription();
+
+    expect(() => new SimpleStateMachine(description)).not.toThrow();
+});
+
+
+test("state entry event handler is fired as expected", () => {
+
+    const description = new SimpleStateMachineDescription();
+
+    const a = description.createState();
+    const b = description.createState();
+
+    description.createEdge(a, b);
+
+    const fsm = new SimpleStateMachine(description);
+
+    fsm.setState(a);
+
+    const entry_callback = jest.fn();
+
+    fsm.addEventHandlerStateEntry(b, entry_callback);
+
+    fsm.setState(b);
+
+    expect(entry_callback).toHaveBeenCalledTimes(1);
+    expect(entry_callback).toHaveBeenCalledWith(b, a);
+});
+
+test("state exit event handler is fired as expected", () => {
+
+    const description = new SimpleStateMachineDescription();
+
+    const a = description.createState();
+    const b = description.createState();
+
+    description.createEdge(a, b);
+
+    const fsm = new SimpleStateMachine(description);
+
+    fsm.setState(a);
+
+    const entry_callback = jest.fn();
+
+    fsm.addEventHandlerStateExit(a, entry_callback);
+
+    fsm.setState(b);
+
+    expect(entry_callback).toHaveBeenCalledTimes(1);
+    expect(entry_callback).toHaveBeenCalledWith(a, b);
+});
+
+test("'advance' moves us to the next state in the chain", () => {
+
+
+    const description = new SimpleStateMachineDescription();
+
+    const a = description.createState();
+    const b = description.createState();
+
+    description.createEdge(a, b);
+
+    const fsm = new SimpleStateMachine(description);
+
+    fsm.setState(a);
+
+    fsm.advance(0);
+
+    expect(fsm.getState()).toBe(b);
+
+});

package/src/core/fsm/simple/SimpleStateMachineDescription.js

@@ -141,7 +141,7 @@ export class SimpleStateMachineDescription {
      *
      * @param {number} start
      * @param {number} goal
-     * @returns {number[]}
+     * @returns {number[]|null}
      */
     findPath(start, goal) {
         assert.ok(this.stateExists(start), `start state ${start} doesn't exist`);

package/src/core/fsm/simple/SimpleStateMachineDescription.spec.js

@@ -69,3 +69,35 @@ test('getIncomingStates', () => {
     expect(smd.getIncomingStates(b)).toEqual([a]);
     expect(smd.getIncomingStates(c)).toEqual([a]);
 });
+
+test('edgeExists', () => {
+
+    const smd = new SimpleStateMachineDescription();
+
+    const a = smd.createState();
+    const b = smd.createState();
+
+    expect(smd.edgeExists(a, b)).toBe(false);
+    expect(smd.edgeExists(b, a)).toBe(false);
+
+    smd.createEdge(a, b);
+
+    expect(smd.edgeExists(a, b)).toEqual(true);
+    expect(smd.edgeExists(b, a)).toEqual(false);
+});
+
+test("findPath sanity check", () => {
+
+    const smd = new SimpleStateMachineDescription();
+
+    const a = smd.createState();
+    const b = smd.createState();
+
+    expect(smd.findPath(a, a)).toEqual([a]);
+
+    expect(smd.findPath(a, b)).toEqual(null);
+
+    smd.createEdge(a, b);
+
+    expect(smd.findPath(a, b)).toEqual([a, b]);
+});

package/src/core/geom/2d/Rectangle.spec.js

@@ -1,4 +1,19 @@
 import Rectangle from "./Rectangle.js";
+import Vector2 from "../Vector2.js";
+
+test("constructor", () => {
+    expect(() => new Rectangle()).not.toThrow();
+});
+
+test("default constructor produces 0 size rectangle with valid position", () => {
+    const r = new Rectangle();
+
+    expect(r.size.x).toBe(0);
+    expect(r.size.y).toBe(0);
+
+    expect(r.position.x).not.toBeNaN();
+    expect(r.position.y).not.toBeNaN();
+});
 
 test("toArray works correctly", () => {
     const v = new Rectangle(1, 2, 3, 4);
@@ -9,3 +24,39 @@ test("toArray works correctly", () => {
 
     expect(actual).toEqual([1, 2, 3, 4]);
 });
+
+test("toJSON", () => {
+    const r = new Rectangle(1, 3, 7, 11);
+
+    expect(r.toJSON()).toEqual({
+        position: { x: 1, y: 3 },
+        size: { x: 7, y: 11 }
+    });
+});
+
+test("fromJSON", () => {
+
+    const r = new Rectangle();
+
+    r.fromJSON({
+        position: { x: 1, y: 3 },
+        size: { x: 7, y: 11 }
+    });
+
+    expect(r.position.x).toBe(1);
+    expect(r.position.y).toBe(3);
+
+    expect(r.size.x).toBe(7);
+    expect(r.size.y).toBe(11);
+});
+
+test("computeCenter", () => {
+    const r = new Rectangle(1, 3, 7, 11);
+
+    const center = new Vector2();
+
+    r.computeCenter(center);
+
+    expect(center.x).toBe(4.5);
+    expect(center.y).toBe(8.5);
+});

package/src/core/geom/3d/aabb/aabb3_intersects_ray.spec.js

@@ -1,6 +1,96 @@
 import { seededRandom } from "../../../math/random/seededRandom.js";
 import { aabb3_intersects_ray } from "./aabb3_intersects_ray.js";
 
+test("axis aligned ray on X", () => {
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        -1, 0, 0,
+        1, 0, 0
+    )).toBe(true);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        -1, 0, 0,
+        -1, 0, 0
+    )).toBe(false);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        1, 0, 0,
+        -1, 0, 0
+    )).toBe(true);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        1, 0, 0,
+        1, 0, 0
+    )).toBe(false);
+});
+
+test("axis aligned ray on Y", () => {
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, -1, 0,
+        0, 1, 0
+    )).toBe(true);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, -1, 0,
+        0, -1, 0
+    )).toBe(false);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, 1, 0,
+        0, -1, 0
+    )).toBe(true);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, 1, 0,
+        0, 1, 0
+    )).toBe(false);
+});
+
+test("axis aligned ray on Z", () => {
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, 0, -1,
+        0, 0, 1
+    )).toBe(true);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, 0, -1,
+        0, 0, -1
+    )).toBe(false);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, 0, 1,
+        0, 0, -1
+    )).toBe(true);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, 0, 1,
+        0, 0, 1
+    )).toBe(false);
+});
+
 test.skip("performance raycast", () => {
     const rng = seededRandom(42);
 

package/src/core/geom/3d/line/line3_compute_nearest_point_to_point.spec.js

@@ -0,0 +1,61 @@
+import { line3_compute_nearest_point_to_point } from "./line3_compute_nearest_point_to_point.js";
+
+test("aligned with the start of the line", () => {
+    const result = [];
+
+    line3_compute_nearest_point_to_point(result, 0,
+        1, 3, 7, 11, 13, 17,
+        1, 3, 7
+    );
+
+    expect(result).toEqual([1, 3, 7])
+});
+
+test("aligned with the end of the line", () => {
+    const result = [];
+
+    line3_compute_nearest_point_to_point(result, 0,
+        1, 3, 7, 11, 13, 17,
+        11, 13, 17
+    );
+
+    expect(result).toEqual([11, 13, 17])
+});
+
+test("ref point is on line past line ends", () => {
+
+    const result = [];
+
+    line3_compute_nearest_point_to_point(result, 0,
+        -1, 0, 0, 3, 0, 0,
+        -2, 0, 0
+    );
+
+    expect(result).toEqual([-1, 0, 0])
+
+    line3_compute_nearest_point_to_point(result, 0,
+        -1, 0, 0, 3, 0, 0,
+        7, 0, 0
+    );
+
+    expect(result).toEqual([3, 0, 0])
+});
+
+test("ref point is on the line", () => {
+
+    const result = [];
+
+    line3_compute_nearest_point_to_point(result, 0,
+        -1, 0, 0, 3, 0, 0,
+        1, 0, 0
+    );
+
+    expect(result).toEqual([1, 0, 0])
+
+    line3_compute_nearest_point_to_point(result, 0,
+        -1, 0, 0, 3, 0, 0,
+        2, 0, 0
+    );
+
+    expect(result).toEqual([2, 0, 0])
+});

package/src/core/geom/3d/morton/mortonEncode_magicbits.js

@@ -1,37 +1,4 @@
-/**
- * method to separate bits from a given integer 3 positions apart
- * we only look at the first 10 bits
- *
- * @example when input is ABC, output bits are A00B00C
- * @param {number} a
- * @returns {number}
- */
-function split_by_3(a) {
-    let x = a;
-    x = (x | x << 16) & 0x30000ff;
-    x = (x | x << 8) & 0x0300f00f;
-    x = (x | x << 4) & 0x30c30c3;
-    x = (x | x << 2) & 0x9249249;
-    return x;
-}
-
-/**
- * method to separate bits from a given integer 2 positions apart
- *
- * @example when input is ABC, output bits are A00B00C
- * @see https://github.com/Forceflow/libmorton/blob/234a443ca8e2c64f6385f1a9d6ee10a70d08a3fa/include/libmorton/morton2D.h#L99
- * @param {number} a
- * @returns {number}
- */
-export function split_by_2(a) {
-    let x = a;
-    x = (x | x << 16) & 0x0000FFFF;
-    x = (x | x << 8) & 0x00FF00FF;
-    x = (x | x << 4) & 0x0F0F0F0F;
-    x = (x | x << 2) & 0x33333333;
-    x = (x | x << 1) & 0x55555555;
-    return x;
-}
+import { split_by_3 } from "./split_by_3.js";
 
 /**
  * Based on article and C++ source code:

package/src/core/geom/3d/morton/split_by_2.js

@@ -0,0 +1,17 @@
+/**
+ * method to separate bits from a given integer 2 positions apart
+ *
+ * @example when input is ABC, output bits are A00B00C
+ * @see https://github.com/Forceflow/libmorton/blob/234a443ca8e2c64f6385f1a9d6ee10a70d08a3fa/include/libmorton/morton2D.h#L99
+ * @param {number} a
+ * @returns {number}
+ */
+export function split_by_2(a) {
+    let x = a;
+    x = (x | x << 16) & 0x0000FFFF;
+    x = (x | x << 8) & 0x00FF00FF;
+    x = (x | x << 4) & 0x0F0F0F0F;
+    x = (x | x << 2) & 0x33333333;
+    x = (x | x << 1) & 0x55555555;
+    return x;
+}

package/src/core/geom/3d/morton/split_by_3.js

@@ -0,0 +1,16 @@
+/**
+ * method to separate bits from a given integer 3 positions apart
+ * we only look at the first 10 bits
+ *
+ * @example when input is ABC, output bits are A00B00C
+ * @param {number} a
+ * @returns {number}
+ */
+export function split_by_3(a) {
+    let x = a;
+    x = (x | x << 16) & 0x30000ff;
+    x = (x | x << 8) & 0x0300f00f;
+    x = (x | x << 4) & 0x30c30c3;
+    x = (x | x << 2) & 0x9249249;
+    return x;
+}

package/src/core/geom/3d/plane/computePlaneLineIntersection.js

@@ -15,7 +15,12 @@ import { v3_dot } from "../../v3_dot.js";
  * @param {number} dist Plane distance
  * @returns {boolean} true if intersection is found, false otherwise
  */
-export function computePlaneLineIntersection(out, originX, originY, originZ, directionX, directionY, directionZ, normalX, normalY, normalZ, dist) {
+export function computePlaneLineIntersection(
+    out,
+    originX, originY, originZ,
+    directionX, directionY, directionZ,
+    normalX, normalY, normalZ, dist
+) {
     const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
 
     const p = v3_dot(normalX, normalY, normalZ, originX, originY, originZ) + dist;

package/src/core/geom/3d/sphere/sphere_intersects_ray.spec.js

@@ -47,3 +47,14 @@ test("ray from +Z to -Z intersects sphere", () => {
         0, 0, -1
     )).toBe(true);
 });
+
+
+// negative cases
+
+test("ray from -X to -X", () => {
+    expect(sphere_intersects_ray(
+        0, 0, 0, 1,
+        -2, 0, 0,
+        -1, 0, 0
+    )).toBe(false);
+});

package/src/core/geom/3d/sphere/sphere_radius_sqr_from_v3_array_transformed.spec.js

@@ -0,0 +1,8 @@
+import { sphere_radius_sqr_from_v3_array_transformed } from "./sphere_radius_sqr_from_v3_array_transformed.js";
+import { MATRIX_4_IDENTITY } from "../matrix/MATRIX_4_IDENTITY.js";
+
+test("base case", () => {
+    expect(sphere_radius_sqr_from_v3_array_transformed([0, 0, 0], 3, MATRIX_4_IDENTITY)).toBe(0);
+    expect(sphere_radius_sqr_from_v3_array_transformed([1, 0, 0], 3, MATRIX_4_IDENTITY)).toBe(1);
+    expect(sphere_radius_sqr_from_v3_array_transformed([-1, 0, 0], 3, MATRIX_4_IDENTITY)).toBe(1);
+});

package/src/core/geom/3d/topology/samples/sampleFloodFill.js

@@ -9,7 +9,7 @@ import { topo_mesh_to_three_buffer_geometry } from "../topo_mesh_to_three_buffer
 import { three_buffer_geometry_to_topo_mesh } from "../three_buffer_geometry_to_topo_mesh.js";
 import { mesh_flood_fill } from "../util/mesh_flood_fill.js";
 import { compute_aabb_from_points } from "../../aabb/compute_aabb_from_points.js";
-import { AABB3 } from "../../../../bvh2/aabb3/AABB3.js";
+import { AABB3 } from "../../../../geom/3d/aabb/AABB3.js";
 import { mergeVertices } from "three/examples/jsm/utils/BufferGeometryUtils.js";
 import { makeGeometryIndexed } from "../../../../../engine/graphics/geometry/buffered/makeGeometryIndexed.js";
 import { v3_dot } from "../../../v3_dot.js";
@@ -23,10 +23,10 @@ import { SGMeshEvents } from "../../../../../engine/graphics/ecs/mesh-v2/aggrega
 import { Color } from "../../../../color/Color.js";
 import { seededRandom } from "../../../../math/random/seededRandom.js";
 import { expandConnectivityByLocality } from "../expandConnectivityByLocality.js";
-import { buildCubeURLs } from "../../../../../engine/graphics/texture/cubemap/buildCubeURLs.js";
 import { EntityNode } from "../../../../../engine/ecs/parent/EntityNode.js";
 import { TransformAttachmentSystem } from "../../../../../engine/ecs/transform-attachment/TransformAttachmentSystem.js";
 import { make_ray_from_viewport_position } from "../../../../../engine/graphics/make_ray_from_viewport_position.js";
+import { load_and_set_cubemap_v0 } from "../../../../../engine/graphics/load_and_set_cubemap_v0.js";
 
 const harness = new EngineHarness();
 
@@ -98,7 +98,7 @@ async function main(engine) {
         enableTerrain: false
     });
 
-    engine.graphics.loadEnvironmentMap(buildCubeURLs('data/textures/cubemaps/hip_miramar/32/', '.png'));
+    load_and_set_cubemap_v0(engine.graphics,'data/textures/cubemaps/hip_miramar/32/', '.png')
 
     const path = 'data/models/sponza-pbr/gltf/sponza.glb';
 

package/src/core/geom/3d/topology/struct/binary/io/OrderedEdge.js

@@ -1,4 +1,4 @@
-import { split_by_2 } from "../../../../morton/mortonEncode_magicbits.js";
+import { split_by_2 } from "../../../../morton/split_by_2.js";
 
 export class OrderedEdge {
     /**

package/src/core/geom/random/randomPointOnBox.spec.js

@@ -0,0 +1,57 @@
+import { randomPointOnBox } from "./randomPointOnBox.js";
+
+function assert_point_on_box(sample) {
+
+    const x = sample[0];
+    const y = sample[1];
+    const z = sample[2];
+
+    function assert_range(v) {
+        expect(v).toBeGreaterThanOrEqual(-0.5);
+        expect(v).toBeLessThanOrEqual(0.5);
+    }
+
+    if (Math.abs(x) === 0.5 && Math.abs(y) === 0.5) {
+        assert_range(z);
+    } else if (Math.abs(x) === 0.5 && Math.abs(z) === 0.5) {
+        assert_range(y);
+    } else if (Math.abs(y) === 0.5 && Math.abs(z) === 0.5) {
+        assert_range(x);
+    } else if (Math.abs(x) === 0.5) {
+        assert_range(y);
+        assert_range(z);
+    } else if (Math.abs(y) === 0.5) {
+        assert_range(x);
+        assert_range(z);
+    } else if (Math.abs(z) === 0.5) {
+        assert_range(y);
+        assert_range(x);
+    } else {
+        throw new Error(`Unexpected ${sample}`);
+    }
+
+}
+
+test("samples are on box shell", () => {
+    function validate(sample_value) {
+
+        const sample = [];
+
+        randomPointOnBox(() => sample_value, sample, 0);
+
+        assert_point_on_box(sample);
+    }
+
+    validate(0);
+    validate(1);
+
+    validate(0.1);
+    validate(0.2);
+    validate(0.3);
+    validate(0.4);
+    validate(0.5);
+    validate(0.6);
+    validate(0.7);
+    validate(0.8);
+    validate(0.9);
+});

package/src/core/math/computeGreatestCommonDivisor.spec.js

@@ -0,0 +1,9 @@
+import { computeGreatestCommonDivisor } from "./computeGreatestCommonDivisor.js";
+
+test("1 and 1", () => {
+    expect(computeGreatestCommonDivisor(1, 1)).toBe(1);
+});
+
+test("6 and 9", () => {
+    expect(computeGreatestCommonDivisor(6, 9)).toBe(3);
+});

package/src/core/math/statistics/computeStatisticalMean.spec.js

@@ -0,0 +1,9 @@
+import { computeStatisticalMean } from "./computeStatisticalMean.js";
+
+test("from just 1 item", () => {
+    expect(computeStatisticalMean([-7])).toEqual(-7)
+});
+
+test("from 2 items", () => {
+    expect(computeStatisticalMean([-7, 17])).toEqual(5)
+});

package/src/core/math/statistics/halton_sequence.spec.js

@@ -5,7 +5,12 @@ test("unique values in base 10", () => {
     const values = [];
 
     for (let i = 0; i < 10; i++) {
-        values.push(halton_sequence(10, i));
+        const v = halton_sequence(10, i);
+
+        expect(v).toBeGreaterThanOrEqual(0);
+        expect(v).toBeLessThanOrEqual(1);
+
+        values.push(v);
     }
 
     values.sort();

package/src/core/model/node-graph/node/Port.spec.js

@@ -40,5 +40,14 @@ test("equality works as intended", () => {
     b.id = a.id;
 
     expect(b.equals(a)).toEqual(true);
-    
+
+});
+
+test("toString on newly crated instance produces a valid string", () => {
+    const port = new Port();
+
+    const s = port.toString();
+
+    expect(typeof s).toBe('string');
+    expect(s.trim().length).toBeGreaterThan(0); // non-empty
 });

package/src/core/model/reactive/evaluation/MultiPredicateEvaluator.js

@@ -1,7 +1,6 @@
 import { assert } from "../../../assert.js";
 import { BitSet } from "../../../binary/BitSet.js";
 import { HashMap } from "../../../collection/HashMap.js";
-import { returnZero } from "../../../function/Functions.js";
 import { max2 } from "../../../math/max2.js";
 import DataType from "../../../parser/simple/DataType.js";
 
@@ -95,15 +94,13 @@ class ExpressionNode {
 
 /**
  *
- * @param {ExpressionNode} n
- * @return {number}
+ * @param {ReactiveExpression} exp
+ * @returns {number}
  */
-function scoreNode(n) {
-    return n.getScore();
+function scoreByTreeSize(exp){
+    return  exp.computeTreeSize();
 }
 
-const temp_array = [];
-
 /**
  * Evaluate given state against multiple predicates, order of evaluation is controlled by scoring function, highest score nodes are evaluated first
  */
@@ -112,7 +109,7 @@ export class MultiPredicateEvaluator {
      *
      * @param {function(ReactiveExpression):number} scoringFunction
      */
-    constructor(scoringFunction = returnZero) {
+    constructor(scoringFunction = scoreByTreeSize) {
         /**
          *
          * @type {function(ReactiveExpression): number}

package/src/core/model/reactive/evaluation/MultiPredicateEvaluator.spec.js

@@ -9,6 +9,47 @@ import { MultiPredicateEvaluator } from "./MultiPredicateEvaluator.js";
 import { randomFromArray } from "../../../math/random/randomFromArray.js";
 import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
 import { randomIntegerBetween } from "../../../math/random/randomIntegerBetween.js";
+import { ReactiveEquals } from "../model/comparative/ReactiveEquals.js";
+
+test('constructor does not throw', () => {
+    expect(() => new MultiPredicateEvaluator()).not.toThrow();
+});
+
+test('build empty', () => {
+    const processor = new MultiPredicateEvaluator();
+
+    expect(() => processor.build([])).not.toThrow();
+});
+
+test('match against empty list of predicates', () => {
+
+    const processor = new MultiPredicateEvaluator();
+    processor.build([]);
+
+    processor.initialize({});
+
+    expect(processor.next()).toBeUndefined();
+});
+
+test('match against one predicate', () => {
+
+    const processor = new MultiPredicateEvaluator();
+
+    const predicate = ReactiveEquals.from(new ReactiveReference('a'), ReactiveLiteralNumber.from(7));
+
+    processor.build([predicate]);
+
+    processor.initialize({ a: 1 });
+
+    expect(processor.next()).toBeUndefined();
+
+    processor.finalize();
+    processor.initialize({ a: 7 });
+
+    expect(processor.next()).toBe(predicate);
+    expect(processor.next()).toBeUndefined();
+
+});
 
 test.skip('performance', () => {
     const random = seededRandom(12319);