@woosh/meep-engine 2.43.40 → 2.43.42

package/core/binary/BitSet.js

@@ -86,7 +86,6 @@ function BitSet() {
     this.__data_uint32 = new Uint32Array(this.__capacity >> 5);
 
     /**
-     *
      * @type {number}
      */
     this.__shrinkFactor = SHRINK_FACTOR;
@@ -201,7 +200,7 @@ BitSet.prototype.__setLength = function (new_length) {
  * @returns {int} Index of previous set bit, or -1 if no set bit found
  */
 BitSet.prototype.previousSetBit = function (fromIndex) {
-    assert.ok(fromIndex >= 0, `fromIndex must be greater or equal to 0, instead was ${fromIndex}`);
+    assert.isNonNegativeInteger(fromIndex, `fromIndex`);
 
     const index = min2(fromIndex, this.__length - 1);
 
@@ -354,21 +353,6 @@ BitSet.prototype.nextClearBit = function (fromIndex) {
     return set_length;
 };
 
-/**
- * Slow method for scanning through bitset, used for debugging
- * @param {BitSet} set
- * @returns {number}
- */
-function scanToFirstClearBit(set) {
-    for (let i = 0; i <= set.size(); i++) {
-        if (set.get(i) === false) {
-            return i;
-        }
-    }
-
-    return -1;
-}
-
 /**
  *
  * @param {int} bitIndex
@@ -443,7 +427,9 @@ BitSet.prototype.setRange = function (startIndex, endIndex) {
  * @param {number} endIndex clear up to here, excluding this position
  */
 BitSet.prototype.clearRange = function (startIndex, endIndex) {
-    //TODO this can be done more efficiently
+    assert.greaterThanOrEqual(startIndex, 0, "invalid start index");
+    assert.greaterThanOrEqual(endIndex, 0, "invalid end index");
+
     for (let i = startIndex; i < endIndex; i++) {
         this.set(i, false);
     }

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

@@ -3,13 +3,26 @@ import { noop } from "../../function/Functions.js";
 import { objectKeyByValue } from "../object/objectKeyByValue.js";
 import { PortDirection } from "./node/PortDirection.js";
 
+/**
+ *
+ * @type {number}
+ */
+let id_counter = 0;
+
 export class Connection {
     constructor() {
+        /**
+         * @readonly
+         * @type {number}
+         */
+        this.id = id_counter++;
+
         /**
          *
          * @type {NodeInstancePortReference}
          */
         this.source = null;
+
         /**
          *
          * @type {NodeInstancePortReference}
@@ -93,4 +106,32 @@ export class Connection {
 
         return this.source.instance.id === id || this.target.instance.id === id;
     }
+
+    /**
+     *
+     * @param {Connection} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.target === other.target
+            && this.source === other.source
+            ;
+    }
+
+    hash() {
+        const source_hash = this.source !== null ? this.source.id : 0;
+        const target_hash = this.target !== null ? this.target.id : 0;
+
+        // shuffle bits a bit to get better spread
+        return ((source_hash << 16) | (source_hash >>> 16))
+            ^ (target_hash)
+            ;
+    }
 }
+
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+Connection.prototype.isConnection = true;

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

@@ -0,0 +1,21 @@
+import { Connection } from "./Connection.js";
+
+test("stable hash", () => {
+    const a = new Connection();
+    const b = new Connection();
+
+    expect(a.hash()).toEqual(b.hash());
+});
+
+test("equality of fresh instances", () => {
+    const a = new Connection();
+    const b = new Connection();
+
+    expect(a.equals(b)).toBe(true);
+});
+
+test("equality on self", () => {
+    const thing = new Connection();
+
+    expect(thing.equals(thing)).toBe(true);
+});

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

@@ -1,3 +1,5 @@
+import { assert } from "../../assert.js";
+
 export class DataType {
     constructor() {
         /**
@@ -14,7 +16,15 @@ export class DataType {
     }
 
     toString() {
-        return `${this.id}:'${this.name}'`;
+        return `{DataType: id=${this.id}, name='${this.name}' }`;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    hash() {
+        return this.id;
     }
 
     /**
@@ -26,6 +36,18 @@ export class DataType {
         return this.id === other.id && this.name === other.name;
     }
 
+    toJSON() {
+        return { ...this };
+    }
+
+    fromJSON({ id, name }) {
+        assert.isNonNegativeInteger(id, 'id');
+        assert.isString(name, 'name');
+
+        this.id = id;
+        this.name = name;
+    }
+
     /**
      *
      * @param {number} id

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

@@ -0,0 +1,28 @@
+import { DataType } from "./DataType.js";
+
+test('to/from json', () => {
+    const a = DataType.from(7, 'kitty');
+
+    const b = new DataType();
+
+    b.fromJSON(a.toJSON());
+
+    expect(b.id).toBe(a.id);
+    expect(b.name).toBe(a.name);
+
+});
+
+test('equals', () => {
+    const a = DataType.from(7, 'kitty');
+    const b = DataType.from(7, 'kitty');
+    const c = DataType.from(7, 'fluffy');
+    const d = DataType.from(9, 'kitty');
+
+
+    expect(a.equals(b)).toBe(true);
+
+    expect(a.equals(c)).toBe(false);
+    expect(a.equals(d)).toBe(false);
+
+    expect(c.equals(d)).toBe(false);
+});

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

@@ -43,7 +43,7 @@ export class NodeGraph {
 
     /**
      *
-     * @param {function(NodeInstance)} visitor
+     * @param {function(NodeInstance):*} visitor
      * @param [thisArg]
      */
     traverseNodes(visitor, thisArg) {
@@ -52,7 +52,7 @@ export class NodeGraph {
 
     /**
      *
-     * @param {function(Connection)} visitor
+     * @param {function(Connection):*} visitor
      * @param [thisArg]
      */
     traverseConnections(visitor, thisArg) {
@@ -105,15 +105,18 @@ export class NodeGraph {
      *
      * @param {number} node_id
      * @param {number} port_id
-     * @returns {NodeInstancePortReference}
+     * @returns {NodeInstancePortReference|undefined}
      */
     getConnectionEndpoint(node_id, port_id) {
 
         const nodeInstance = this.getNode(node_id);
 
-        const endpoint = nodeInstance.getEndpoint(port_id);
+        if (nodeInstance === undefined) {
+            // no node
+            return undefined;
+        }
 
-        return endpoint;
+        return nodeInstance.getEndpoint(port_id);
     }
 
     /**
@@ -219,13 +222,13 @@ export class NodeGraph {
         //get endpoints
         const sourceEndpoint = sourceNodeInstance.getEndpoint(sourcePort);
 
-        if (sourceEndpoint === null) {
+        if (sourceEndpoint === undefined) {
             throw new Error(`Source port '${sourcePort}' not found`);
         }
 
         const targetEndpoint = targetNodeInstance.getEndpoint(targetPort);
 
-        if (targetEndpoint === null) {
+        if (targetEndpoint === undefined) {
             throw new Error(`Target port '${targetPort}' not found`);
         }
 
@@ -287,3 +290,9 @@ export class NodeGraph {
         return count;
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+NodeGraph.prototype.isNodeGraph = true;

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

@@ -67,19 +67,20 @@ export class NodeDescription {
         assert.typeOf(name, 'string', 'name');
         assert.enum(type, NodeParameterDataType, 'type');
 
+        let _default = defaultValue;
 
         //if default value is not given, pick one
-        if (defaultValue === undefined) {
+        if (_default === undefined) {
             switch (type) {
                 //intended fallthrough
                 case  NodeParameterDataType.Number:
-                    defaultValue = 0;
+                    _default = 0;
                     break;
                 case NodeParameterDataType.Boolean:
-                    defaultValue = false;
+                    _default = false;
                     break;
                 case NodeParameterDataType.String:
-                    defaultValue = "";
+                    _default = "";
                     break;
                 default:
                     throw new Error(`Unknown data type '${type}'`);
@@ -93,7 +94,7 @@ export class NodeDescription {
 
         pd.name = name;
         pd.type = type;
-        pd.defaultValue = defaultValue;
+        pd.defaultValue = _default;
         pd.id = id;
 
         assert.ok(pd.validate(console.error), 'parameter is not valid');
@@ -188,3 +189,9 @@ export class NodeDescription {
         return this.ports
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+NodeDescription.prototype.isNodeDescription = true;

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

@@ -4,13 +4,19 @@ import { NodeInstancePortReference } from "./NodeInstancePortReference.js";
 import { PortDirection } from "./PortDirection.js";
 import { isArrayEqual } from "../../../collection/array/isArrayEqual.js";
 
+/**
+ *
+ * @type {number}
+ */
+let id_counter = 0;
+
 export class NodeInstance {
     constructor() {
         /**
          *
          * @type {number}
          */
-        this.id = 0;
+        this.id = id_counter++;
 
         /**
          *
@@ -149,7 +155,7 @@ export class NodeInstance {
     /**
      *
      * @param {number} port Port ID
-     * @returns {NodeInstancePortReference|null}
+     * @returns {NodeInstancePortReference|undefined}
      */
     getEndpoint(port) {
         const endpoints = this.endpoints;
@@ -161,7 +167,7 @@ export class NodeInstance {
         }
 
         //not found
-        return null;
+        return undefined;
     }
 
     hash() {

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

@@ -1,12 +1,24 @@
 import { assert } from "../../../assert.js";
 import { computeHashIntegerArray } from "../../../collection/array/computeHashIntegerArray.js";
 
+/**
+ *
+ * @type {number}
+ */
+let id_counter = 0;
+
 /**
  * Reference for a port of a node instance
  */
 export class NodeInstancePortReference {
 
     constructor() {
+        /**
+         * @readonly
+         * @type {number}
+         */
+        this.id = id_counter++;
+
         /**
          *
          * @type {NodeInstance}
@@ -75,3 +87,9 @@ export class NodeInstancePortReference {
             ;
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+NodeInstancePortReference.prototype.isNodeInstancePortReference = true;

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

@@ -4,16 +4,25 @@ import { DataType } from "../DataType.js";
 import { NodeDescription } from "./NodeDescription.js";
 import { Port } from "./Port.js";
 
+/**
+ *
+ * @param {Port} port
+ * @return {DataType}
+ */
+function getPortType(port) {
+    return port.dataType;
+}
+
 export class NodeRegistry {
     constructor() {
         /**
-         *
+         * ID -> Node mapping
          * @type {Map<number, NodeDescription>}
          */
         this.nodes = new Map();
 
         /**
-         *
+         * ID -> DataType mapping
          * @type {Map<number, DataType>}
          */
         this.types = new Map();
@@ -31,19 +40,17 @@ export class NodeRegistry {
      * @param {NodeDescription} node
      */
     addNode(node) {
-        assert.notEqual(node, undefined, "node is undefined");
-        assert.notEqual(node, null, "node is null");
+        assert.defined(node, "node");
+        assert.notNull(node, "node");
 
         if (this.nodes.has(node.id)) {
-            console.warn(`Node with id ${node.id} already exists`);
+            // console.warn(`Node with id ${node.id} already exists`);
 
             return false;
         }
 
         //extract types
-        node.getPorts().forEach(port => {
-            this.addType(port.dataType);
-        });
+        node.getPorts().map(getPortType).forEach(this.addType, this);
 
         this.nodes.set(node.id, node);
 
@@ -55,14 +62,27 @@ export class NodeRegistry {
      * @param {DataType} type
      */
     addType(type) {
-        if (this.types.has(type.id)) {
+        if (this.hasType(type)) {
             return false;
         }
 
         this.types.set(type.id, type);
+
         return true;
     }
 
+    /**
+     *
+     * @param {DataType} type
+     * @return {boolean}
+     */
+    hasType(type) {
+        assert.defined(type, 'type');
+        assert.notNull(type, 'type');
+
+        return this.types.has(type.id);
+    }
+
     /**
      *
      * @returns {number}
@@ -123,7 +143,7 @@ export class NodeRegistry {
     }
 
     /**
-     *
+     * NOTE: this only works with un-extended node descriptions
      * @param json
      * @returns {NodeDescription}
      */
@@ -215,3 +235,9 @@ export class NodeRegistry {
         };
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+NodeRegistry.prototype.isNodeRegistry = true;

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

@@ -50,3 +50,28 @@ test("serialize/deserialize 1 node with 1 port", () => {
     expect(port.dataType.name).toBe("kitty");
     expect(port.dataType.id).toBe(42);
 });
+
+test("port types are added automatically when node is added", () => {
+    const registry = new NodeRegistry();
+
+    const type = DataType.from(0, 'a');
+
+    const node = new NodeDescription();
+    node.createPort(type, "port name", PortDirection.In);
+
+    registry.addNode(node);
+
+    expect(registry.hasType(type));
+});
+
+test("hasType", () => {
+    const registry = new NodeRegistry();
+
+    const type = DataType.from(0, 'a');
+
+    expect(registry.hasType(type)).toBe(false);
+
+    registry.addType(type);
+
+    expect(registry.hasType(type)).toBe(true);
+});

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

@@ -2,6 +2,11 @@ import { computeStringHash } from "../../../primitives/strings/computeStringHash
 import { PortDirection } from "./PortDirection.js";
 import { computeHashIntegerArray } from "../../../collection/array/computeHashIntegerArray.js";
 
+/**
+ * @type {number}
+ */
+let id_counter = 0;
+
 export class Port {
     constructor() {
         /**
@@ -14,7 +19,7 @@ export class Port {
          * ID uniquely identifies object within some context. Ids are assumed to be immutable
          * @type {number}
          */
-        this.id = 0;
+        this.id = id_counter++;
 
         /**
          *
@@ -53,3 +58,9 @@ export class Port {
 
     }
 }
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+Port.prototype.isPort = true;

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

@@ -1,5 +1,5 @@
 /**
- *
+ * @readonly
  * @enum
  */
 export const PortDirection = {

package/engine/graphics/render/frame_graph/RenderGraph.js

@@ -338,6 +338,10 @@ export class RenderGraph {
         }
     }
 
+    /**
+     * @see https://en.wikipedia.org/wiki/DOT_(graph_description_language)
+     * @return {string}
+     */
     exportToDot() {
         const out = new LineBuilder();
 
@@ -397,9 +401,9 @@ export class RenderGraph {
             out.dedent();
             out.add("} [color=olivedrab3]");
         }
+        // -- Clusters:
         out.dedent();
         out.add("}");
-        // -- Clusters:
         return out.build();
     }
 }

package/engine/intelligence/behavior/SelectorBehavior.js

@@ -46,7 +46,9 @@ export class SelectorBehavior extends CompositeBehavior {
         }
     }
 
-    initialize() {
+    initialize(context) {
+        super.initialize(context);
+     
         this.__currentBehaviourIndex = 0;
         this.__currentBehaviour = this.__children[0];