@woosh/meep-engine 2.49.2 → 2.49.4

package/src/core/geom/3d/compute_triangle_normal.js

@@ -1,55 +1,5 @@
-import { v3_length_sqr } from "../v3_length_sqr.js";
 import { vec3 } from "gl-matrix";
-
-/**
- *
- * @param {number[]} result
- * @param {number} result_offset
- * @param {number} vAx
- * @param {number} vAy
- * @param {number} vAz
- * @param {number} vBx
- * @param {number} vBy
- * @param {number} vBz
- * @param {number} vCx
- * @param {number} vCy
- * @param {number} vCz
- */
-export function v3_compute_triangle_normal(result, result_offset, vAx, vAy, vAz, vBx, vBy, vBz, vCx, vCy, vCz) {
-    //compute CB and AB vectors
-    const vCBx = vCx - vBx;
-    const vCBy = vCy - vBy;
-    const vCBz = vCz - vBz;
-
-    const vABx = vAx - vBx;
-    const vABy = vAy - vBy;
-    const vABz = vAz - vBz;
-
-    //compute triangle normal
-    const crossX = vCBy * vABz - vCBz * vABy;
-    const crossY = vCBz * vABx - vCBx * vABz;
-    const crossZ = vCBx * vABy - vCBy * vABx;
-
-    const l_sqr = v3_length_sqr(crossX, crossY, crossZ);
-
-    if (l_sqr === 0) {
-        // degenerate triangle, provide arbitrary invalid result
-        result[result_offset] = 0;
-        result[result_offset + 1] = 1;
-        result[result_offset + 2] = 0;
-        return;
-    }
-
-    const l_inv = 1 / Math.sqrt(l_sqr);
-
-    const x = crossX * l_inv;
-    const y = crossY * l_inv;
-    const z = crossZ * l_inv;
-
-    result[result_offset] = x;
-    result[result_offset + 1] = y;
-    result[result_offset + 2] = z;
-}
+import { v3_compute_triangle_normal } from "./v3_compute_triangle_normal.js";
 
 /**
  *

package/src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js

@@ -613,9 +613,9 @@ function windowSH(output, output_offset, input, input_offset, numBands, channel_
 
 /**
  *
- * @param {number[]} result
+ * @param {number[]|Float32Array} result
  * @param {number} result_offset
- * @param {number[]} harmonics
+ * @param {number[]|Float32Array} harmonics
  * @param {number} harmonics_offset
  * @param {number} dimension_count
  */

package/src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.spec.js

@@ -0,0 +1,27 @@
+import { sh3_dering_optimize_positive } from "./sh3_dering_optimize_positive.js";
+
+test("de-ringing produces plausible numeric values", () => {
+
+    const result = [];
+
+    const harmonics = new Float32Array(9);
+
+    harmonics.fill(1);
+
+    sh3_dering_optimize_positive(
+        result, 0,
+        harmonics,
+        0,
+        1
+    );
+
+    for (let i = 0; i < 9; i++) {
+
+        const element = result[i];
+
+        expect(element).not.toBeNaN();
+        expect(Number.isFinite(element)).toBe(true);
+
+    }
+
+});

package/src/core/geom/3d/triangle/computeTriangleRayIntersection.spec.js

@@ -0,0 +1,25 @@
+import { computeTriangleRayIntersection } from "./computeTriangleRayIntersection.js";
+import { SurfacePoint3 } from "../SurfacePoint3.js";
+
+test("simple axis aligned intersection", () => {
+    const sp = new SurfacePoint3();
+
+    expect(computeTriangleRayIntersection(
+        sp,
+        0, 0, -1,
+        0, 0, 1,
+        -1, -1, 0,
+        1, -1, 0,
+        0, 1, 0
+    )).toBe(true);
+
+    expect(computeTriangleRayIntersection(
+        sp,
+        0, 0, -1,
+        0, 0, -1,
+        -1, -1, 0,
+        1, -1, 0,
+        0, 1, 0
+    )).toBe(false);
+
+});

package/src/core/geom/3d/v3_compute_triangle_normal.js

@@ -0,0 +1,51 @@
+import { v3_length_sqr } from "../v3_length_sqr.js";
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {number} vAx
+ * @param {number} vAy
+ * @param {number} vAz
+ * @param {number} vBx
+ * @param {number} vBy
+ * @param {number} vBz
+ * @param {number} vCx
+ * @param {number} vCy
+ * @param {number} vCz
+ */
+export function v3_compute_triangle_normal(result, result_offset, vAx, vAy, vAz, vBx, vBy, vBz, vCx, vCy, vCz) {
+    //compute CB and AB vectors
+    const vCBx = vCx - vBx;
+    const vCBy = vCy - vBy;
+    const vCBz = vCz - vBz;
+
+    const vABx = vAx - vBx;
+    const vABy = vAy - vBy;
+    const vABz = vAz - vBz;
+
+    //compute triangle normal
+    const crossX = vCBy * vABz - vCBz * vABy;
+    const crossY = vCBz * vABx - vCBx * vABz;
+    const crossZ = vCBx * vABy - vCBy * vABx;
+
+    const l_sqr = v3_length_sqr(crossX, crossY, crossZ);
+
+    if (l_sqr === 0) {
+        // degenerate triangle, provide arbitrary invalid result
+        result[result_offset] = 0;
+        result[result_offset + 1] = 1;
+        result[result_offset + 2] = 0;
+        return;
+    }
+
+    const l_inv = 1 / Math.sqrt(l_sqr);
+
+    const x = crossX * l_inv;
+    const y = crossY * l_inv;
+    const z = crossZ * l_inv;
+
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
+}

package/src/core/geom/3d/v3_compute_triangle_normal.spec.js

@@ -0,0 +1,27 @@
+import { v3_compute_triangle_normal } from "./v3_compute_triangle_normal.js";
+
+test("axis aligned triangles on +X plane", () => {
+    const result = [];
+
+    v3_compute_triangle_normal(
+        result, 0,
+        0, -1, -1,
+        0, 1, -1,
+        0, 0, 1,
+    );
+
+    expect(result).toEqual([+1, 0, 0]);
+});
+
+test("axis aligned triangles on -X plane", () => {
+    const result = [];
+
+    v3_compute_triangle_normal(
+        result, 0,
+        0, 0, 1,
+        0, 1, -1,
+        0, -1, -1,
+    );
+
+    expect(result).toEqual([-1, 0, 0]);
+});

package/src/core/geom/packing/miniball/Miniball.spec.js

@@ -0,0 +1,11 @@
+import { Miniball } from "./Miniball.js";
+import { PointSet } from "./PointSet.js";
+
+test("single point in 1d", () => {
+
+    const miniball = new Miniball(new PointSet(1, 1, [7]));
+
+    expect(miniball.center()).toEqual([7]);
+    expect(miniball.radius()).toEqual(0);
+
+});

package/src/core/graph/SquareMatrix.js

@@ -53,15 +53,7 @@ export class SquareMatrix {
      * @param {SquareMatrix} other
      */
     subtract(other) {
-        const size = this.size;
-        const data_length = size * size;
-
-        const this_data = this.data;
-        const other_data = other.data;
-
-        for (let i = 0; i < data_length; i++) {
-            this_data[i] -= other_data[i];
-        }
+        this.subtractMatrices(this,other);
     }
 
     /**

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

@@ -0,0 +1,23 @@
+import { graph_k_means_cluster } from "./graph_k_means_cluster.js";
+import { Graph } from "./v2/Graph.js";
+
+test("empty graph", () => {
+    const graph = new Graph();
+
+    const clusters = graph_k_means_cluster(graph, 0, 0);
+
+    expect(Array.isArray(clusters)).toBe(true);
+    expect(clusters.length).toBe(0);
+});
+
+test("2-node graph with k=1", () => {
+    const graph = new Graph();
+    graph.addNode(3);
+    graph.addNode(7);
+
+    const clusters = graph_k_means_cluster(graph, 1, 0);
+
+    expect(Array.isArray(clusters)).toBe(true);
+    expect(clusters.length).toBe(1);
+    expect(clusters.map(cluster => cluster.sort())).toEqual([[0, 1]]);
+});

package/src/core/{land → lang}/reactive/compileReactiveExpression.spec.js

@@ -9,11 +9,11 @@ import { ReactiveGreaterThanOrEqual } from "../../model/reactive/model/comparati
 import { ReactiveLessThan } from "../../model/reactive/model/comparative/ReactiveLessThan.js";
 import { ReactiveLessThanOrEqual } from "../../model/reactive/model/comparative/ReactiveLessThanOrEqual.js";
 import { ReactiveNotEquals } from "../../model/reactive/model/comparative/ReactiveNotEquals.js";
-import { ReactiveAnd } from "../../model/reactive/model/logic/ReactiveAnd.d.ts";
+import { ReactiveAnd } from "../../model/reactive/model/logic/ReactiveAnd.js";
 import { ReactiveNot } from "../../model/reactive/model/logic/ReactiveNot.js";
 import { ReactiveOr } from "../../model/reactive/model/logic/ReactiveOr.js";
 import { ReactiveLiteralNumber } from "../../model/reactive/model/terminal/ReactiveLiteralNumber.js";
-import { ReactiveReference } from "../../model/reactive/model/terminal/ReactiveReference.d.ts";
+import { ReactiveReference } from "../../model/reactive/model/terminal/ReactiveReference.js";
 import { compileReactiveExpression } from "./compileReactiveExpression.js";
 
 test('compile: REFERENCE', () => {

package/src/core/model/reactive/trigger/ReactiveTrigger.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../assert.js";
-import { compileReactiveExpression } from "../../../land/reactive/compileReactiveExpression.js";
+import { compileReactiveExpression } from "../../../lang/reactive/compileReactiveExpression.js";
 import DataType from "../../../parser/simple/DataType.js";
 import { inferReactiveExpressionTypes } from "../transform/ReactiveTypeInferrence.js";
 

package/src/engine/ecs/dynamic_actions/actions/definition/SendRequestActionDescription.js

@@ -2,7 +2,7 @@ import { AbstractActionDescription } from "./AbstractActionDescription.js";
 import { assert } from "../../../../../core/assert.js";
 import { ActionBehavior } from "../../../../intelligence/behavior/primitive/ActionBehavior.js";
 import { Transform } from "../../../transform/Transform.js";
-import { compileReactiveExpression } from "../../../../../core/land/reactive/compileReactiveExpression.js";
+import { compileReactiveExpression } from "../../../../../core/lang/reactive/compileReactiveExpression.js";
 
 export class SendRequestActionDescription extends AbstractActionDescription {
     constructor() {

package/src/engine/ecs/dynamic_actions/actions/definition/WhiteToBlackboardActionDescription.js

@@ -1,7 +1,7 @@
 import { AbstractActionDescription } from "./AbstractActionDescription.js";
 import { ActionBehavior } from "../../../../intelligence/behavior/primitive/ActionBehavior.js";
 import { Blackboard } from "../../../../intelligence/blackboard/Blackboard.js";
-import { compileReactiveExpression } from "../../../../../core/land/reactive/compileReactiveExpression.js";
+import { compileReactiveExpression } from "../../../../../core/lang/reactive/compileReactiveExpression.js";
 import { assert } from "../../../../../core/assert.js";
 
 export class WhiteToBlackboardActionDescription extends AbstractActionDescription {

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescription.js

@@ -2,7 +2,7 @@ import UUID from "../../../../core/UUID.js";
 import { assert } from "../../../../core/assert.js";
 import { inferReactiveExpressionTypes } from "../../../../core/model/reactive/transform/ReactiveTypeInferrence.js";
 import DataType from "../../../../core/parser/simple/DataType.js";
-import { compileReactiveExpression } from "../../../../core/land/reactive/compileReactiveExpression.js";
+import { compileReactiveExpression } from "../../../../core/lang/reactive/compileReactiveExpression.js";
 import { deserializeActionFromJSON } from "../actions/definition/deserializeActionFromJSON.js";
 import { DynamicRuleCooldownDescription } from "./DynamicRuleCooldownDescription.js";
 

package/src/engine/ecs/fow/FogOfWarRevealer.js

@@ -1,5 +1,4 @@
 import Vector1 from "../../../core/geom/Vector1.js";
-import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
 
 export class FogOfWarRevealer {
     constructor() {
@@ -28,29 +27,3 @@ export class FogOfWarRevealer {
 FogOfWarRevealer.typeName = 'FogOfWarRevealer';
 
 
-export class FogOfWarRevealerSerializationAdapter extends BinaryClassSerializationAdapter {
-    constructor() {
-        super();
-
-        this.klass = FogOfWarRevealer;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {FogOfWarRevealer} value
-     */
-    serialize(buffer, value) {
-        value.radius.toBinaryBuffer(buffer);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {FogOfWarRevealer} value
-     */
-    deserialize(buffer, value) {
-        value.radius.fromBinaryBuffer(buffer);
-    }
-}

package/src/engine/ecs/fow/serialization/FogOfWarRevealerSerializationAdapter.js

@@ -0,0 +1,29 @@
+import { BinaryClassSerializationAdapter } from "../../storage/binary/BinaryClassSerializationAdapter.js";
+import { FogOfWarRevealer } from "../FogOfWarRevealer.js";
+
+export class FogOfWarRevealerSerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = FogOfWarRevealer;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {FogOfWarRevealer} value
+     */
+    serialize(buffer, value) {
+        value.radius.toBinaryBuffer(buffer);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {FogOfWarRevealer} value
+     */
+    deserialize(buffer, value) {
+        value.radius.fromBinaryBuffer(buffer);
+    }
+}

package/src/engine/ecs/transform/TransformSerializationAdapter.spec.js

@@ -0,0 +1,28 @@
+import { TransformSerializationAdapter } from "./TransformSerializationAdapter.js";
+import { Transform } from "./Transform.js";
+import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
+
+test("to/from consistency", () => {
+    const adapter = new TransformSerializationAdapter();
+
+    const expected = new Transform();
+    expected.position.set(1, 3, -7.3);
+    expected.scale.set(-5, 7, -13.8);
+    expected.rotation.set(17, -27, 31, 37);
+
+    expected.rotation.normalize();
+
+    const buffer = new BinaryBuffer();
+
+    adapter.serialize(buffer, expected);
+
+    buffer.position = 0;
+
+    const actual = new Transform();
+
+    adapter.deserialize(buffer, actual);
+
+    expect(actual.position.roughlyEquals(expected.position)).toBe(true);
+    expect(actual.scale.roughlyEquals(expected.scale)).toBe(true);
+    expect(actual.rotation.roughlyEquals(expected.rotation, 0.001)).toBe(true);
+});

package/src/engine/knowledge/database/StaticKnowledgeDataTable.spec.js

@@ -0,0 +1,5 @@
+import { StaticKnowledgeDataTable } from "./StaticKnowledgeDataTable.js";
+
+test("constructor does not throw", () => {
+    expect(() => new StaticKnowledgeDataTable()).not.toThrow();
+});

package/src/engine/options/Option.js

@@ -1,8 +1,16 @@
 import { noop } from "../../core/function/Functions.js";
 import Signal from "../../core/events/signal/Signal.js";
 import { OptionAbstract } from "./OptionAbstract.js";
+import { assert } from "../../core/assert.js";
 
 export class Option extends OptionAbstract {
+
+    on = {
+        written: new Signal(),
+        writeFailed: new Signal(),
+        settingsUpdated: new Signal()
+    };
+
     /**
      *
      * @param {string} id
@@ -16,18 +24,32 @@ export class Option extends OptionAbstract {
     }) {
         super(id);
 
+        assert.isFunction(read, 'read');
+
         const self = this;
 
         function wrappedWrite(v) {
-            const result = write(v);
-
-            if (result !== undefined && typeof result.then === "function") {
-                result.then(
-                    () => self.on.written.dispatch(v),
-                    (e) => self.on.writeFailed.dispatch(v, e)
-                );
-            } else {
-                self.on.written.dispatch(v);
+            let result;
+
+            let exception_thrown = false;
+
+            try {
+                result = write(v);
+            } catch (e) {
+                exception_thrown = true;
+
+                self.on.writeFailed.send2(v, e);
+            }
+
+            if (!exception_thrown) {
+                if (result !== undefined && typeof result.then === "function") {
+                    result.then(
+                        () => self.on.written.send1(v),
+                        (e) => self.on.writeFailed.send2(v, e)
+                    );
+                } else {
+                    self.on.written.send1(v);
+                }
             }
 
             return result;
@@ -43,13 +65,13 @@ export class Option extends OptionAbstract {
          */
         this.isTransient = (settings.transient === true);
 
-        this.on = {
-            written: new Signal(),
-            writeFailed: new Signal(),
-            settingsUpdated: new Signal()
-        };
     }
 
+    /**
+     *
+     * @param {string} key
+     * @param {number|boolean|string} value
+     */
     setSetting(key, value) {
         this.settings[key] = value;
 

package/src/engine/options/Option.spec.js

@@ -0,0 +1,69 @@
+import { Option } from "./Option.js";
+import { returnOne } from "../../core/function/Functions.js";
+
+test("constructing a simple valid option", () => {
+    const option = new Option("x", returnOne);
+
+    expect(option.id).toEqual('x');
+});
+
+test("'written' signal is invoked after write succeeds", () => {
+
+    let value = 13;
+
+    const opt = new Option("x", () => value, v => value = v);
+
+    const callback = jest.fn();
+
+    opt.on.written.add(callback);
+
+    opt.write(7);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+});
+
+test("'writeFailed' signal is invoked after write throws", () => {
+
+    let value = 13;
+
+    const opt = new Option("x", () => value, v => value = v);
+
+    const callback = jest.fn();
+
+    opt.on.written.add(callback);
+
+    opt.write(7);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+});
+
+test("toJSON", () => {
+
+    let value = 13;
+
+    const opt = new Option("x", () => value, v => value = v);
+
+    expect(opt.toJSON()).toBe(13);
+
+});
+
+test("fromJSON", () => {
+
+    let value = 1;
+
+    const opt = new Option("x", () => value, v => value = v);
+
+    opt.fromJSON(17);
+
+    expect(value).toBe(17);
+
+
+});
+
+test("computePath on a detached option should be just the ID of that option", () => {
+    const op = new Option("x", returnOne);
+
+    expect(op.computePath()).toEqual(["x"]);
+});
+

package/src/engine/reference/v2/Reference.d.ts

@@ -3,6 +3,8 @@ import Signal from "../../../core/events/signal/Signal";
 export class Reference<T> {
     readonly onReleased: Signal<Reference<T>, T>
 
+    readonly bound: boolean
+
     getValue(): T | null
 
     release(): void

package/src/engine/reference/v2/Reference.js

@@ -27,6 +27,9 @@ export class Reference {
      */
     #is_bound = false;
 
+    get bound(){
+        return this.#is_bound;
+    }
 
     /**
      *

package/src/engine/reference/v2/Reference.spec.js

@@ -0,0 +1,44 @@
+import { Reference } from "./Reference.js";
+
+test("constructor does not throw", () => {
+    expect(() => new Reference()).not.toThrow();
+});
+
+test("newly created reference is unbound", () => {
+
+    const ref = new Reference();
+
+    expect(ref.bound).toBe(false);
+
+});
+
+test("bind sets value", () => {
+    const ref = new Reference();
+
+    ref.bind(7);
+
+    expect(ref.getValue()).toBe(7);
+    expect(ref.bound).toBe(true);
+});
+
+test("re-binding a live reference throws an exception", () => {
+
+    const ref = new Reference();
+
+    ref.bind(7);
+
+    expect(() => ref.bind(13)).toThrow();
+
+});
+
+test("release resets reference", () => {
+
+    const ref = new Reference();
+
+    ref.bind(7);
+
+    ref.release();
+
+    expect(ref.getValue()).toBeNull();
+    expect(ref.bound).toBe(false);
+});

package/src/core/bvh2/bvh3/BVHNodeProxy.js

@@ -1,53 +0,0 @@
-export class BVHNodeProxy {
-    constructor() {
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__node = -1;
-
-        /**
-         *
-         * @type {ExplicitBinaryBoundingVolumeHierarchy|null}
-         * @private
-         */
-        this.__tree = null;
-    }
-
-    /**
-     *
-     * @param {number} node
-     * @param {ExplicitBinaryBoundingVolumeHierarchy} tree
-     */
-    bind(node, tree) {
-        this.__node = node;
-        this.__tree = tree;
-    }
-
-    /**
-     *
-     * @param {number} x0
-     * @param {number} y0
-     * @param {number} z0
-     * @param {number} x1
-     * @param {number} y1
-     * @param {number} z1
-     */
-    set_bounds(x0, y0, z0, x1, y1, z1) {
-        this.__tree.node_set_aabb_primitive(this.__node,
-            x0, y0, z0, x1, y1, z1
-        );
-    }
-
-    disconnect() {
-        this.__tree.remove_leaf(this.__node);
-    }
-
-    destroy() {
-        this.__tree.release_node(this.__node);
-
-        this.__tree = null;
-        this.__node = -1;
-    }
-}