@woosh/meep-engine 2.43.38 → 2.43.40

package/core/geom/Vector4.d.ts

@@ -15,6 +15,11 @@ export default class Vector4 {
     z: number
     w: number
 
+    0: number
+    1: number
+    2: number
+    3: number
+
     public readonly onChanged: Signal<number, number, number, number, number, number, number, number>;
 
     constructor()
@@ -25,9 +30,9 @@ export default class Vector4 {
 
     copy(other: Vector4Like): void
 
-    readFromArray(array:ArrayLike<number>, offset:number):void
+    readFromArray(array:ArrayLike<number>, offset?:number):void
 
-    writeToArray(array:ArrayLike<number>, offset:number):void
+    writeToArray(array:ArrayLike<number>, offset?:number):void
 
     asArray(): number[]
 

package/core/geom/Vector4.js

@@ -6,7 +6,7 @@ import { assert } from "../assert.js";
 import { Signal } from "../events/signal/Signal.js";
 import { lerp } from "../math/lerp.js";
 import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
 
 /**
  *
@@ -105,11 +105,11 @@ class Vector4 {
      * @constructor
      * @class
      */
-    constructor(x, y, z, w) {
-        this.x = (typeof x === "number") ? x : 0;
-        this.y = (typeof x === "number") ? y : 0;
-        this.z = (typeof z === "number") ? z : 0;
-        this.w = (typeof w === "number") ? w : 1;
+    constructor(x = 0, y = 0, z = 0, w = 0) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
 
         this.onChanged = new Signal();
     }
@@ -135,7 +135,7 @@ class Vector4 {
      * @param {number[]} array
      * @param {number} offset
      */
-    readFromArray(array, offset) {
+    readFromArray(array, offset = 0) {
         this.set(
             array[offset],
             array[offset + 1],
@@ -149,7 +149,7 @@ class Vector4 {
      * @param {number[]} array
      * @param {number} offset
      */
-    writeToArray(array, offset) {
+    writeToArray(array, offset = 0) {
         array[offset] = this.x;
         array[offset + 1] = this.y;
         array[offset + 2] = this.z;

package/core/math/hash/computeHashFloatArray.js

@@ -1,4 +1,4 @@
-import { computeHashFloat } from "./computeHashFloat.js";
+import { computeHashFloat } from "../../primitives/numbers/computeHashFloat.js";
 
 /**
  *

package/core/math/hash/computeObjectHash.js

@@ -1,5 +1,5 @@
 import { computeStringHash } from "../../primitives/strings/computeStringHash.js";
-import { computeHashFloat } from "./computeHashFloat.js";
+import { computeHashFloat } from "../../primitives/numbers/computeHashFloat.js";
 
 /**
  * Recursively computes object hash
@@ -18,37 +18,37 @@ export function computeObjectHash(value, depth = 3) {
 
     let hash = 0;
 
-    for (let p in value) {
+    const pType = typeof value;
 
-        hash = ((hash << 5) - hash) + computeStringHash(p);
+    if (pType === "string") {
+        hash = computeStringHash(value);
+    } else if (pType === "number") {
+        hash = computeHashFloat(value);
+    } else if (pType === "boolean") {
+        hash = value ? 1 : 0;
+    } else if (pType === "object") {
 
-        const pValue = value[p];
+        if (depth <= 0) {
+            hash = 3;
+        } else {
+
+            for (let p in value) {
+
+                const pNameHash = computeStringHash(p);
+
+                const pValue = value[p];
 
-        const pType = typeof pValue;
+                const pHash = pNameHash ^ computeObjectHash(pValue, depth - 1);
 
-        let pHash;
-        if (pType === "string") {
-            pHash = computeStringHash(pValue);
-        } else if (pType === "number") {
-            pHash = computeHashFloat(pValue);
-        } else if (pType === "boolean") {
-            pHash = pValue ? 1 : 0;
-        } else if (pType === "object") {
+                hash = ((hash << 5) - hash) + pHash;
 
-            if (depth <= 0) {
-                pHash = 3;
-            } else {
-                pHash = computeObjectHash(pValue, depth - 1);
+                hash |= 0; // Convert to 32bit integer
             }
 
-        } else {
-            pHash = 0;
         }
 
-        hash = ((hash << 5) - hash) + pHash;
-
-        hash |= 0; // Convert to 32bit integer
     }
 
+
     return hash;
 }

package/core/math/hash/computeObjectHash.spec.js

@@ -0,0 +1,42 @@
+import { computeObjectHash } from "./computeObjectHash.js";
+
+/**
+ *
+ * @param {number} hash
+ */
+function validateHash(hash){
+    expect(typeof hash).toBe('number');
+    expect(hash).not.toBeNaN();
+    expect(Number.isFinite(hash)).toBe(true);
+    expect(Number.isInteger(hash)).toBe(true);
+}
+
+test('primitives produce valid hash',()=>{
+    validateHash( computeObjectHash(undefined));
+    validateHash( computeObjectHash(null));
+    validateHash( computeObjectHash(0));
+    validateHash( computeObjectHash(1));
+    validateHash( computeObjectHash(""));
+    validateHash( computeObjectHash("hello"));
+    validateHash( computeObjectHash(false));
+    validateHash( computeObjectHash(true));
+    validateHash( computeObjectHash({}));
+});
+
+test('nested object hash is stable',()=>{
+    const test_object = {
+        a:{
+            b:7
+        },
+        c: "hello"
+    };
+
+    expect(computeObjectHash(test_object)).toEqual(computeObjectHash(test_object));
+
+    expect(computeObjectHash(test_object)).not.toEqual(computeObjectHash({
+        a:{
+            b:5
+        },
+        c: "hello"
+    }));
+});

package/core/math/interval/NumericInterval.js

@@ -7,7 +7,7 @@
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
 import { inverseLerp } from "../inverseLerp.js";
-import { computeHashFloat } from "../hash/computeHashFloat.js";
+import { computeHashFloat } from "../../primitives/numbers/computeHashFloat.js";
 
 export class NumericInterval {
     /**

package/core/model/BoundedValue.js

@@ -5,7 +5,7 @@
 
 import Signal from "../events/signal/Signal.js";
 import { inverseLerp } from "../math/inverseLerp.js";
-import { computeHashFloat } from "../math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
 
 /**
  *

package/core/model/node-graph/Connection.js

@@ -65,8 +65,8 @@ export class Connection {
      * @param {NodeInstancePortReference} endpoint
      */
     setSource(endpoint) {
-        assert.notEqual(endpoint, undefined, 'endpoint is undefined');
-        assert.notEqual(endpoint, null, 'endpoint is null');
+        assert.defined(endpoint, 'endpoint');
+        assert.notNull(endpoint, 'endpoint');
 
         this.source = endpoint;
     }
@@ -76,8 +76,8 @@ export class Connection {
      * @param {NodeInstancePortReference} endpoint
      */
     setTarget(endpoint) {
-        assert.notEqual(endpoint, undefined, 'endpoint is undefined');
-        assert.notEqual(endpoint, null, 'endpoint is null');
+        assert.defined(endpoint, 'endpoint');
+        assert.notNull(endpoint, 'endpoint');
 
         this.target = endpoint;
     }
@@ -88,8 +88,8 @@ export class Connection {
      * @returns {boolean}
      */
     isAttachedToNode(id) {
-        assert.typeOf(id, 'number', 'id');
-        assert.ok(Number.isInteger(id), `id must be an integer, instead was '${id}'`);
+        assert.isNumber(id, 'id');
+        assert.isInteger(id, 'id');
 
         return this.source.instance.id === id || this.target.instance.id === id;
     }

package/core/model/node-graph/DataType.js

@@ -25,18 +25,19 @@ export class DataType {
     equals(other) {
         return this.id === other.id && this.name === other.name;
     }
-}
 
-/**
- *
- * @param {number} id
- * @param {string} name
- */
-DataType.from = function (id, name) {
-    const r = new DataType();
+    /**
+     *
+     * @param {number} id
+     * @param {string} name
+     * @returns {DataType}
+     */
+    static from(id, name) {
+        const r = new DataType();
 
-    r.id = id;
-    r.name = name;
+        r.id = id;
+        r.name = name;
 
-    return r;
-};
+        return r;
+    }
+}

package/core/model/node-graph/NodeGraph.js

@@ -62,19 +62,43 @@ export class NodeGraph {
     /**
      *
      * @param {number} id
-     * @returns {NodeInstance}
+     * @returns {NodeInstance|undefined}
      */
     getNode(id) {
-        return this.nodes.find(node => node.id === id);
+        const nodes = this.nodes;
+        const n = nodes.length;
+
+        for (let i = 0; i < n; i++) {
+            const node = nodes[i];
+
+            if (node.id === id) {
+                return node;
+            }
+        }
+
+        // node not found, return undefined
+        return undefined;
     }
 
     /**
      *
      * @param {number} id
-     * @returns {Connection}
+     * @returns {Connection|undefined}
      */
     getConnection(id) {
-        return this.connections.find(connection => connection.id === id);
+        const connections = this.connections;
+        const n = connections.length;
+
+        for (let i = 0; i < n; i++) {
+            const connection = connections[i];
+
+            if (connection.id === id) {
+                return connection;
+            }
+        }
+
+        // nothing found, undefined will be returned
+        return undefined;
     }
 
     /**
@@ -123,7 +147,7 @@ export class NodeGraph {
 
         const id_obtained = this.__idpNodes.getSpecific(node.id);
 
-        if (!id_obtained) {
+        if (id_obtained === false) {
             throw new Error(`Node with id '${node.id}' already exists`);
         }
 
@@ -241,6 +265,7 @@ export class NodeGraph {
      *
      * @param {number} id
      * @param {number[]} result IDs of attached connections
+     * @returns {number} number of found connections
      */
     getConnectionsAttachedToNode(id, result) {
         let count = 0;

package/core/model/node-graph/node/NodeDescription.js

@@ -1,5 +1,4 @@
 import { assert } from "../../../assert.js";
-import { BitSet } from "../../../binary/BitSet.js";
 import { NodeParameterDataType } from "./parameter/NodeParameterDataType.js";
 import { NodeParameterDescription } from "./parameter/NodeParameterDescription.js";
 import { Port } from "./Port.js";
@@ -11,17 +10,22 @@ import { Port } from "./Port.js";
  * @returns {number}
  */
 function pickNewSetId(things) {
-    const ids = new BitSet();
 
-    things.forEach((v, id) => ids.set(id, true));
 
-    const id = ids.nextClearBit(0);
+    const n = things.length;
+
+    let r = n;
+
+    for (let i = 0; i < n; i++) {
+
+        if (things[i] === undefined) {
+            r = i;
+            break;
+        }
 
-    if (id === -1) {
-        return 0;
-    } else {
-        return id;
     }
+
+    return r;
 }
 
 export class NodeDescription {
@@ -61,15 +65,14 @@ export class NodeDescription {
     createParameter(name, type, defaultValue) {
 
         assert.typeOf(name, 'string', 'name');
-        assert.ok(Object.values(NodeParameterDataType).includes(type), `Unknown type '${type}'`);
+        assert.enum(type, NodeParameterDataType, 'type');
 
 
         //if default value is not given, pick one
         if (defaultValue === undefined) {
             switch (type) {
-                case NodeParameterDataType.Integer:
                 //intended fallthrough
-                case  NodeParameterDataType.Float:
+                case  NodeParameterDataType.Number:
                     defaultValue = 0;
                     break;
                 case NodeParameterDataType.Boolean:

package/core/model/node-graph/node/NodeDescription.spec.js

@@ -0,0 +1,14 @@
+import { NodeDescription } from "./NodeDescription.js";
+import { DataType } from "../DataType.js";
+import { PortDirection } from "./PortDirection.js";
+
+const DUMMY_TYPE = DataType.from(0, 'dummy');
+
+test('ports are assigned unique IDs', () => {
+    const node = new NodeDescription();
+
+    const id_a = node.createPort(DUMMY_TYPE, 'a', PortDirection.Unspecified);
+    const id_b = node.createPort(DUMMY_TYPE, 'b', PortDirection.Unspecified);
+
+    expect(id_a).not.toEqual(id_b);
+});

package/core/model/node-graph/node/NodeInstance.js

@@ -148,8 +148,8 @@ export class NodeInstance {
 
     /**
      *
-     * @param {number} port Port Id
-     * @returns {ConnectionEndpoint|null}
+     * @param {number} port Port ID
+     * @returns {NodeInstancePortReference|null}
      */
     getEndpoint(port) {
         const endpoints = this.endpoints;

package/core/model/node-graph/node/parameter/NodeParameterDescription.js

@@ -5,7 +5,7 @@ export class NodeParameterDescription {
     constructor() {
         this.name = "";
         this.id = 0;
-        this.type = NodeParameterDataType.Float;
+        this.type = NodeParameterDataType.Number;
 
         /**
          *

package/core/model/reactive/model/terminal/ReactiveLiteralNumber.js

@@ -2,7 +2,7 @@ import { assert } from "../../../../assert.js";
 import Signal from "../../../../events/signal/Signal.js";
 import DataType from "../../../../parser/simple/DataType.js";
 import { ReactiveExpression } from "../ReactiveExpression.js";
-import { computeHashFloat } from "../../../../math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../../../../primitives/numbers/computeHashFloat.js";
 
 const dummySignal = new Signal();
 

package/core/model/stat/LinearModifier.js

@@ -1,5 +1,5 @@
 import { assert } from "../../assert.js";
-import { computeHashFloat } from "../../math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../../primitives/numbers/computeHashFloat.js";
 
 
 /**

package/engine/Engine.d.ts

@@ -18,7 +18,7 @@ export interface IEngineInitializationOptions {
 export default class Engine {
     constructor(platform: EnginePlatform, options?: IEngineInitializationOptions);
 
-    public get viewStack(): View
+    readonly viewStack: View
 
     public readonly entityManager: EntityManager
     public readonly sceneManager: SceneManager

package/engine/asset/loaders/material/computeMaterialHash.js

@@ -2,7 +2,7 @@ import { planeHash } from "./planeHash.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
 import { computeHashArray } from "../../../../core/collection/array/computeHashArray.js";
 import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { textureHashById } from "./textureHashById.js";
 import { computeHashColor } from "./computeHashColor.js";
 

package/engine/asset/loaders/material/computeTextureHash.js

@@ -1,6 +1,6 @@
 import { computeImageBitmapHash } from "./computeImageBitmapHash.js";
 import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { murmur3_32 } from "../../../../core/math/hash/murmur3_32.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
 

package/engine/ecs/animation/Animation.js

@@ -9,7 +9,7 @@ import ObservedInteger from "../../../core/model/ObservedInteger.js";
 import Vector1 from "../../../core/geom/Vector1.js";
 import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
 import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../../../core/math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
 
 /**
  *

package/engine/ecs/animation/InverseKinematics.js

@@ -2,7 +2,7 @@ import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSe
 import { NumericInterval } from "../../../core/math/interval/NumericInterval.js";
 import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
 import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../../../core/math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
 
 class IKConstraint {
     constructor() {

package/engine/ecs/dynamic_actions/actions/definition/WeightedRandomActionDescription.js

@@ -1,7 +1,7 @@
 import { AbstractActionDescription } from "./AbstractActionDescription.js";
 import { WeightedRandomBehavior } from "../../../../intelligence/behavior/selector/WeightedRandomBehavior.js";
 import { WeightedElement } from "../../../../intelligence/behavior/selector/WeightedElement.js";
-import { computeHashFloat } from "../../../../../core/math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../../../../../core/primitives/numbers/computeHashFloat.js";
 
 export class WeightedRandomActionDescription extends AbstractActionDescription {
     constructor() {

package/engine/ecs/gui/position/ViewportPosition.js

@@ -6,7 +6,7 @@ import Vector2 from "../../../../core/geom/Vector2.js";
 import ObservedBoolean from "../../../../core/model/ObservedBoolean.js";
 import { BinaryClassSerializationAdapter } from "../../storage/binary/BinaryClassSerializationAdapter.js";
 import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 
 /**
  * @readonly

package/engine/ecs/transform/Transform.js

@@ -28,33 +28,35 @@ export class Transform {
     constructor() {
 
         /**
-         *
+         * World-space position
          * @type {Vector3}
          * @readonly
          */
         this.position = new Vector3(0, 0, 0);
 
         /**
-         *
+         * World-space rotation
          * @type {Quaternion}
          * @readonly
          */
         this.rotation = new Quaternion(0, 0, 0, 1);
 
         /**
-         *
+         * World-space scale
          * @type {Vector3}
          * @readonly
          */
         this.scale = new Vector3(1, 1, 1);
 
         /**
+         * World-space transform matrix, position, rotation and scale must match, but shear can be different
          * @readonly
          * @type {Float32Array}
          */
         this.matrix = allocate_transform_m4();
 
         /**
+         * Various bit flags, see {@link TransformFlags}
          * @protected
          * @type {number}
          */
@@ -136,7 +138,6 @@ export class Transform {
         return (this.flags & flag) === flag;
     }
 
-
     updateMatrix() {
         compose_matrix4_array(this.matrix, this.position, this.rotation, this.scale);
     }
@@ -275,7 +276,7 @@ export class Transform {
     }
 
     /**
-     *
+     * @deprecated use `fromMatrix4` directly instead
      * @param {THREE.Matrix4} matrix
      */
     fromThreeMatrix4(matrix) {
@@ -283,7 +284,7 @@ export class Transform {
     }
 
     /**
-     *
+     * @deprecated use `toMatrix4` directly instead
      * @param {Matrix4} matrix
      */
     toThreeMatrix(matrix) {
@@ -314,6 +315,12 @@ export class Transform {
         compose_matrix4_array(result, this.position, this.rotation, this.scale);
     }
 
+    /**
+     * reset transform, resulting transform is an identity matrix
+     *      - position: [0,0,0]
+     *      - rotation: [0,0,0,1]
+     *      - scale:    [1,1,1]
+     */
     makeIdentity() {
         this.position.copy(Vector3.zero);
         this.rotation.copy(Quaternion.identity);
@@ -335,11 +342,16 @@ Transform.prototype.isTransform = true;
 
 
 /**
+ * @deprecated use {@link Quaternion.rotateTowards} instead
  * @param {Quaternion} sourceQuaternion
  * @param {Vector3} targetVector
  * @param {Number} limit
  */
-Transform.adjustRotation = function (sourceQuaternion, targetVector, limit) {
-    sourceQuaternion.lookRotation(targetVector, Vector3.up);
+Transform.adjustRotation = function (sourceQuaternion, targetVector, limit = Infinity) {
+    const q = new Quaternion();
+
+    q.lookRotation(targetVector);
+
+    sourceQuaternion.rotateTowards(q, limit);
 };
 

package/engine/graphics/ecs/animation/animator/AnimationClip.js

@@ -3,7 +3,7 @@ import { AnimationClipFlag } from "./AnimationClipFlag.js";
 import { LoopOnce, LoopRepeat } from "three";
 import { AnimationEventTypes } from "./AnimationEventTypes.js";
 import { computeHashIntegerArray } from "../../../../../core/collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../../../../../core/math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../../../../../core/primitives/numbers/computeHashFloat.js";
 
 export class AnimationClip {
     constructor() {

package/engine/graphics/ecs/animation/animator/AnimationNotification.js

@@ -1,5 +1,5 @@
 import { computeHashIntegerArray } from "../../../../../core/collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../../../../../core/math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../../../../../core/primitives/numbers/computeHashFloat.js";
 
 export class AnimationNotification {
     constructor() {

package/engine/graphics/ecs/animation/animator/graph/AnimationGraph.js

@@ -10,7 +10,7 @@ import {
 import { assert } from "../../../../../../core/assert.js";
 import { threeUpdateTransform } from "../../../../util/threeUpdateTransform.js";
 import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../../../../../../core/math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../../../../../../core/primitives/numbers/computeHashFloat.js";
 
 export class AnimationGraph {
     constructor() {

package/engine/graphics/ecs/animation/animator/graph/definition/AnimationTransitionDefinition.js

@@ -1,6 +1,6 @@
 import { computeStringHash } from "../../../../../../../core/primitives/strings/computeStringHash.js";
 import { computeHashIntegerArray } from "../../../../../../../core/collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../../../../../../../core/math/hash/computeHashFloat.js";
+import { computeHashFloat } from "../../../../../../../core/primitives/numbers/computeHashFloat.js";
 
 export class AnimationTransitionDefinition {
     constructor() {