@woosh/meep-engine 2.47.1 → 2.47.2

package/src/core/geom/Rectangle.js

@@ -8,212 +8,222 @@ import { intersects1D } from "../math/intersects1D.js";
 import { overlap1D } from "../math/overlap1D.js";
 
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} width
- * @param {number} height
- * @constructor
- */
-function Rectangle(x = 0, y = 0, width = 0, height = 0) {
+class Rectangle {
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @constructor
+     */
+    constructor(x = 0, y = 0, width = 0, height = 0) {
+
+        /**
+         * @readonly
+         * @type {Vector2}
+         */
+        this.position = new Vector2(x, y);
+
+        /**
+         * @readonly
+         * @type {Vector2}
+         */
+        this.size = new Vector2(width, height);
+    }
 
     /**
-     * @type {Vector2}
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
      */
-    this.position = new Vector2(x, y);
+    set(x, y, width, height) {
+        this.size.set(width, height);
+        this.position.set(x, y);
+    }
 
     /**
-     * @type {Vector2}
+     *
+     * @returns {Rectangle}
      */
-    this.size = new Vector2(width, height);
-}
+    clone() {
+        return new Rectangle(this.position.x, this.position.y, this.size.x, this.size.y);
+    }
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} width
- * @param {number} height
- */
-Rectangle.prototype.set = function set(x, y, width, height) {
-    this.size.set(width, height);
-    this.position.set(x, y);
-};
+    /**
+     *
+     * @param {Rectangle} other
+     */
+    copy(other) {
+        this.position.copy(other.position);
+        this.size.copy(other.size);
+    }
 
-/**
- *
- * @returns {Rectangle}
- */
-Rectangle.prototype.clone = function () {
-    return new Rectangle(this.position.x, this.position.y, this.size.x, this.size.y);
-};
+    /**
+     *
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     * @returns {boolean}
+     */
+    _intersects(x0, y0, x1, y1) {
+        const p = this.position;
+        const s = this.size;
 
-/**
- *
- * @param {Rectangle} other
- */
-Rectangle.prototype.copy = function (other) {
-    this.position.copy(other.position);
-    this.size.copy(other.size);
-};
+        const _x0 = p.x;
+        const _y0 = p.y;
 
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} x1
- * @param {number} y1
- * @returns {boolean}
- */
-Rectangle.prototype._intersects = function (x0, y0, x1, y1) {
-    const p = this.position;
-    const s = this.size;
+        return intersects1D(x0, x1, _x0, s.x + _x0) && intersects1D(y0, y1, _y0, _y0 + s.y);
+    }
 
-    const _x0 = p.x;
-    const _y0 = p.y;
+    /**
+     *
+     * @param {Rectangle} other
+     * @returns {boolean}
+     */
+    intersects(other) {
+        const x0 = other.position.x;
+        const y0 = other.position.y;
+        const y1 = other.size.y + y0;
+        const x1 = other.size.x + x0;
+        return this._intersects(x0, y0, x1, y1);
+    }
 
-    return intersects1D(x0, x1, _x0, s.x + _x0) && intersects1D(y0, y1, _y0, _y0 + s.y);
-};
+    /**
+     *
+     * @param {number}  x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     * @returns {boolean}
+     */
+    _overlaps(x0, y0, x1, y1) {
+        const p = this.position;
+        const s = this.size;
 
-/**
- *
- * @param {Rectangle} other
- * @returns {boolean}
- */
-Rectangle.prototype.intersects = function (other) {
-    const x0 = other.position.x;
-    const y0 = other.position.y;
-    const y1 = other.size.y + y0;
-    const x1 = other.size.x + x0;
-    return this._intersects(x0, y0, x1, y1);
-};
+        const _x0 = p.x;
+        const _y0 = p.y;
 
-/**
- *
- * @param {number}  x0
- * @param {number} y0
- * @param {number} x1
- * @param {number} y1
- * @returns {boolean}
- */
-Rectangle.prototype._overlaps = function (x0, y0, x1, y1) {
-    const p = this.position;
-    const s = this.size;
+        return overlap1D(x0, x1, _x0, s.x + _x0) && overlap1D(y0, y1, _y0, _y0 + s.y);
+    }
 
-    const _x0 = p.x;
-    const _y0 = p.y;
+    overlaps(other) {
+        const x0 = other.position.x;
+        const y0 = other.position.y;
+        const y1 = other.size.y + y0;
+        const x1 = other.size.x + x0;
+        return this._overlaps(x0, y0, x1, y1);
+    }
 
-    return overlap1D(x0, x1, _x0, s.x + _x0) && overlap1D(y0, y1, _y0, _y0 + s.y);
-};
+    _resizeToFit(x0, y0, x1, y1) {
+        const size = this.size;
 
-Rectangle.prototype.overlaps = function (other) {
-    const x0 = other.position.x;
-    const y0 = other.position.y;
-    const y1 = other.size.y + y0;
-    const x1 = other.size.x + x0;
-    return this._overlaps(x0, y0, x1, y1);
-};
+        const _x0 = this.position.x;
+        const _y0 = this.position.y;
 
-Rectangle.prototype._resizeToFit = function (x0, y0, x1, y1) {
-    const size = this.size;
+        let _y1 = size.y + _y0;
+        let _x1 = size.x + _x0;
 
-    const _x0 = this.position.x;
-    const _y0 = this.position.y;
+        if (Number.isNaN(_x1)) {
+            _x1 = -Infinity;
+        }
+        if (Number.isNaN(_y1)) {
+            _y1 = -Infinity;
+        }
 
-    let _y1 = size.y + _y0;
-    let _x1 = size.x + _x0;
+        const nX0 = min2(x0, _x0);
+        const nY0 = min2(y0, _y0);
+        const nX1 = max2(x1, _x1);
+        const nY1 = max2(y1, _y1);
 
-    if (Number.isNaN(_x1)) {
-        _x1 = -Infinity;
-    }
-    if (Number.isNaN(_y1)) {
-        _y1 = -Infinity;
+        this.position.set(nX0, nY0);
+        size.set(nX1 - nX0, nY1 - nY0);
     }
 
-    const nX0 = min2(x0, _x0);
-    const nY0 = min2(y0, _y0);
-    const nX1 = max2(x1, _x1);
-    const nY1 = max2(y1, _y1);
+    resizeToFit(other) {
+        const x0 = other.position.x;
+        const y0 = other.position.y;
+        const y1 = other.size.y + y0;
+        const x1 = other.size.x + x0;
 
-    this.position.set(nX0, nY0);
-    size.set(nX1 - nX0, nY1 - nY0);
-};
+        return this._resizeToFit(x0, y0, x1, y1);
+    }
 
-Rectangle.prototype.resizeToFit = function (other) {
-    const x0 = other.position.x;
-    const y0 = other.position.y;
-    const y1 = other.size.y + y0;
-    const x1 = other.size.x + x0;
+    _contains(x0, y0, x1, y1) {
+        const size = this.size;
 
-    return this._resizeToFit(x0, y0, x1, y1);
-};
+        const _x0 = this.position.x;
+        const _y0 = this.position.y;
 
-Rectangle.prototype._contains = function (x0, y0, x1, y1) {
-    const size = this.size;
+        const _y1 = size.y + _y0;
+        const _x1 = size.x + _x0;
 
-    const _x0 = this.position.x;
-    const _y0 = this.position.y;
+        return x0 >= _x0 && x1 <= _x1 && y0 >= _y0 && y1 <= _y1;
+    }
 
-    const _y1 = size.y + _y0;
-    const _x1 = size.x + _x0;
+    contains(other) {
+        const x0 = other.position.x;
+        const y0 = other.position.y;
+        const y1 = other.size.y + y0;
+        const x1 = other.size.x + x0;
 
-    return x0 >= _x0 && x1 <= _x1 && y0 >= _y0 && y1 <= _y1;
-};
+        return this._contains(x0, y0, x1, y1);
+    }
 
-Rectangle.prototype.contains = function (other) {
-    const x0 = other.position.x;
-    const y0 = other.position.y;
-    const y1 = other.size.y + y0;
-    const x1 = other.size.x + x0;
+    /**
+     *
+     * @param {Vector2} result
+     */
+    computeCenter(result) {
+        const p = this.position;
+        const s = this.size;
 
-    return this._contains(x0, y0, x1, y1);
-};
+        const x = p.x + s.x / 2;
+        const y = p.y + s.y / 2;
 
-/**
- *
- * @param {Vector2} result
- */
-Rectangle.prototype.computeCenter = function (result) {
-    const p = this.position;
-    const s = this.size;
+        result.set(x, y);
+    }
 
-    const x = p.x + s.x / 2;
-    const y = p.y + s.y / 2;
+    /**
+     *
+     * @return {number}
+     */
+    computeArea() {
+        return this.size.x * this.size.y;
+    }
 
-    result.set(x, y);
-};
+    /**
+     *
+     * @param {Array.<number>|Float32Array|Float64Array|Uint8Array} target
+     * @param {number} [targetOffset=0]
+     */
+    toArray(target, targetOffset = 0) {
+        target[targetOffset] = this.position.x;
+        target[targetOffset + 1] = this.position.y;
+        target[targetOffset + 2] = this.size.x;
+        target[targetOffset + 3] = this.size.y;
+    }
 
-/**
- *
- * @return {number}
- */
-Rectangle.prototype.computeArea = function () {
-    return this.size.x * this.size.y;
-};
+    toJSON() {
+        return {
+            position: this.position.toJSON(),
+            size: this.size.toJSON()
+        };
+    }
+
+    fromJSON(json) {
+        this.position.fromJSON(json.position);
+        this.size.fromJSON(json.size);
+    }
+}
 
 /**
- *
- * @param {Array.<number>|Float32Array|Float64Array|Uint8Array} target
- * @param {number} [targetOffset=0]
+ * @readonly
+ * @type {boolean}
  */
-Rectangle.prototype.toArray = function (target, targetOffset = 0) {
-    target[targetOffset] = this.position.x;
-    target[targetOffset + 1] = this.position.y;
-    target[targetOffset + 2] = this.size.x;
-    target[targetOffset + 3] = this.size.y;
-};
-
-Rectangle.prototype.toJSON = function () {
-    return {
-        position: this.position.toJSON(),
-        size: this.size.toJSON()
-    };
-};
-
-Rectangle.prototype.fromJSON = function (json) {
-    this.position.fromJSON(json.position);
-    this.size.fromJSON(json.size);
-};
+Rectangle.prototype.isRectangle = true;
 
 export default Rectangle;

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

@@ -126,6 +126,7 @@ export class NodeGraph {
     /**
      * Merge foreign nodes and associated connections into this graph
      * New node instances and connections will be created to reflect these inside this graph
+     * NOTE: parameters on merged nodes are shallow copies
      * @param {NodeInstance[]} nodes
      * @param {Connection[]} [connections]
      * @returns {{connections:Connection[], nodes:NodeInstance[]}} local created instances
@@ -145,7 +146,15 @@ export class NodeGraph {
 
         for (let i = 0; i < additional_node_count; i++) {
             const other_node = nodes[i];
-            this_nodes[other_node.id] = this.createNode(other_node.description);
+
+            const this_node_id = this.createNode(other_node.description);
+            this_nodes[other_node.id] = this_node_id;
+
+            // copy parameters
+            const this_node = this.getNode(this_node_id);
+
+            this_node.setParameters(other_node.parameters);
+
         }
 
         // create connections

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

@@ -3,6 +3,8 @@ import List from "../../../collection/list/List.js";
 import { NodeInstancePortReference } from "./NodeInstancePortReference.js";
 import { PortDirection } from "./PortDirection.js";
 import { isArrayEqual } from "../../../collection/array/isArrayEqual.js";
+import { objectDeepEquals } from "../../object/objectDeepEquals.js";
+import Signal from "../../../events/signal/Signal.js";
 
 /**
  *
@@ -33,10 +35,9 @@ export class NodeInstance {
 
         /**
          * Internal instance data
-         * @type {Array}
+         * @type {Object}
          */
-        this.parameters = [];
-
+        this.parameters = {};
 
         /**
          * @transient
@@ -49,6 +50,27 @@ export class NodeInstance {
          * @type {List<Connection>}
          */
         this.connections = new List();
+
+        /**
+         * @readonly
+         */
+        this.on = {
+            /**
+             * @readonly
+             * @type {Signal<string, *, *>}
+             */
+            parameterChanged: new Signal(),
+            /**
+             * @readonly
+             * @type {Signal<string, *>}
+             */
+            parameterAdded: new Signal(),
+            /**
+             * @readonly
+             * @type {Signal<string, *>}
+             */
+            parameterRemoved: new Signal(),
+        };
     }
 
     /**
@@ -133,31 +155,77 @@ export class NodeInstance {
     }
 
     /**
-     *
-     * @param {number} id
-     * @returns {string|number|boolean}
+     * @template T
+     * @param {string} id
+     * @returns {T|undefined}
      */
     getParameterValue(id) {
+        assert.isString(id, 'id');
+
         return this.parameters[id];
     }
 
     /**
-     *
-     * @param {number} id
-     * @param {string|number|boolean} value
+     * @template T
+     * @param {string} id
+     * @param {T} value
      */
     setParameterValue(id, value) {
-        this.parameters[id] = value;
+        assert.isString(id, 'id');
+        assert.defined(value, 'value');
+
+        const parameters = this.parameters;
+
+        const old_value = parameters[id];
+
+        if (old_value === value) {
+            return;
+        }
+
+        parameters[id] = value;
+
+        if (old_value === undefined) {
+            this.on.parameterAdded.send2(id, value);
+        }
+
+        this.on.parameterChanged.send3(id, value, old_value);
     }
 
     /**
      *
-     * @param {[]} parameters
+     * @param {string} id
+     * @returns {boolean}
+     */
+    deleteParameter(id) {
+        assert.isString(id, 'id');
+
+        const parameters = this.parameters;
+
+        if (!parameters.hasOwnProperty(id)) {
+            return false;
+        }
+
+        const existing = parameters[id];
+
+        delete parameters[id];
+
+        this.on.parameterRemoved.send2(id, existing);
+
+        return true;
+    }
+
+    /**
+     * Will overwrite only those properties that are present in the hash
+     * @param {Object} partial_hash
      */
-    setParameters(parameters) {
-        assert.isArray(parameters, 'parameters');
+    setParameters(partial_hash) {
+        assert.defined(partial_hash, 'parameters')
+
+        for (const key in partial_hash) {
 
-        this.parameters = parameters;
+            this.setParameterValue(key, partial_hash[key]);
+
+        }
     }
 
     /**
@@ -220,7 +288,7 @@ export class NodeInstance {
         return this.id === other.id
             && this.description === other.description
             && isArrayEqual(this.endpoints, other.endpoints)
-            && isArrayEqual(this.parameters, other.parameters)
+            && objectDeepEquals(this.parameters, other.parameters)
             ;
     }
 

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

@@ -2,6 +2,9 @@ import { BinaryClassSerializationAdapter } from "../../storage/binary/BinaryClas
 import { FogOfWar } from "../FogOfWar.js";
 import { serializeRowFirstTable } from "../../../../core/collection/table/serializeRowFirstTable.js";
 import { deserializeRowFirstTable } from "../../../../core/collection/table/deserializeRowFirstTable.js";
+import {
+    Sampler2DSerializationAdapter
+} from "../../../graphics/texture/sampler/serialization/Sampler2DSerializationAdapter.js";
 
 export class FogOfWarSerializationAdapter extends BinaryClassSerializationAdapter {
     constructor() {
@@ -9,6 +12,8 @@ export class FogOfWarSerializationAdapter extends BinaryClassSerializationAdapte
 
         this.klass = FogOfWar;
         this.version = 1;
+
+        this.__sampler_serializer = new Sampler2DSerializationAdapter();
     }
 
     /**
@@ -35,7 +40,7 @@ export class FogOfWarSerializationAdapter extends BinaryClassSerializationAdapte
 
         buffer.writeUint32(color);
 
-        value.sampler.toBinaryBuffer(buffer);
+        this.__sampler_serializer.serialize(buffer,value.sampler);
 
         //serialize reveal state
         serializeRowFirstTable(buffer, value.fadeMask);
@@ -68,7 +73,7 @@ export class FogOfWarSerializationAdapter extends BinaryClassSerializationAdapte
             color_a / 255
         );
 
-        value.sampler.fromBinaryBuffer(buffer);
+        this.__sampler_serializer.deserialize(buffer,value.sampler);
 
         //deserialize reveal state
         deserializeRowFirstTable(buffer, value.fadeMask);