@woosh/meep-engine 2.46.35 → 2.47.1

package/build/meep.module.js

@@ -48165,6 +48165,10 @@ class Sampler2D {
             throw new Error("data was undefined");
         }
 
+        if (data.length < width * height * itemSize) {
+            throw new Error(`Buffer underflow, data.length(=${data.length}) is too small. Expected at least ${width * height * itemSize}`);
+        }
+
         /**
          *
          * @type {Number}
@@ -48202,51 +48206,12 @@ class Sampler2D {
     }
 
     /**
+     * @deprecated
      * @param {number} [channel=0]
      * @returns {{x: number, index: number, y: number, value: number}}
      */
     computeMax(channel = 0) {
-        const itemSize = this.itemSize;
-
-        assert.typeOf(channel, "number", "channel");
-        assert.ok(channel >= 0, `channel must be >= 0, was ${channel}`);
-        assert.ok(channel < itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
-
-        const data = this.data;
-
-        const l = data.length;
-
-        if (l === 0) {
-            //no data
-            return undefined;
-        }
-
-        let bestValue = data[channel];
-        let bestIndex = channel;
-
-        for (let i = channel + itemSize; i < l; i += itemSize) {
-            const value = data[i];
-
-            if (bestValue < value) {
-                bestValue = value;
-                bestIndex = i;
-            }
-
-        }
-
-        const width = this.width;
-
-        const itemIndex = (bestIndex / this.itemSize) | 0;
-
-        const x = itemIndex % width;
-        const y = (itemIndex / width) | 0;
-
-        return {
-            index: bestIndex,
-            value: bestValue,
-            x,
-            y
-        };
+       throw new Error("deprecated, use sampler2d_channel_compute_max");
     }
 
     /**
@@ -48299,51 +48264,12 @@ class Sampler2D {
     }
 
     /**
+     * @deprecated
      * @param {number} [channel=0]
      * @returns {{x: number, index: number, y: number, value: number}}
      */
     computeMin(channel = 0) {
-        const itemSize = this.itemSize;
-
-        assert.typeOf(channel, "number", "channel");
-        assert.ok(channel >= 0, `channel must be >= 0, was ${channel}`);
-        assert.ok(channel < itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
-
-        const data = this.data;
-
-        const l = data.length;
-
-        if (l === 0) {
-            //no data
-            return undefined;
-        }
-
-        let bestValue = data[channel];
-        let bestIndex = channel;
-
-        for (let i = channel + itemSize; i < l; i += itemSize) {
-            const value = data[i];
-
-            if (bestValue > value) {
-                bestValue = value;
-                bestIndex = i;
-            }
-
-        }
-
-        const width = this.width;
-
-        const itemIndex = (bestIndex / this.itemSize) | 0;
-
-        const x = itemIndex % width;
-        const y = (itemIndex / width) | 0;
-
-        return {
-            index: bestIndex,
-            value: bestValue,
-            x,
-            y
-        };
+        throw new Error("deprecated, use sampler2d_channel_compute_min");
     }
 
     /**
@@ -54834,7 +54760,7 @@ class ObservedString extends String {
  * @param {Sampler2D} input
  * @param {Sampler2D} output
  */
-function sampler2D_scale_down_linear(input, output) {
+function sampler2d_scale_down_linear(input, output) {
     assert.notEqual(input, undefined, 'input is undefined');
     assert.notEqual(output, undefined, 'output is undefined');
 
@@ -55047,7 +54973,7 @@ function scaleSampler2D(input, output) {
         // downscaling
         if (Number.isInteger(sourceWidth / targetWidth) && Number.isInteger(sourceHeight / targetHeight)) {
             // dimensions are multiples of source/target
-            sampler2D_scale_down_linear(input, output);
+            sampler2d_scale_down_linear(input, output);
         } else {
             // generic downsample
             genericResampleSampler2D(input, output);
@@ -65563,6 +65489,106 @@ WorkerBuilder.prototype.build = function () {
     return proxy;
 };
 
+/**
+ *
+ * @param {Sampler2D} sampler
+ * @param {number} [channel=0]
+ * @returns {undefined|{x: number, index:number, y: number, value: number}}
+ */
+function sampler2d_channel_compute_max(sampler, channel=0){
+    const itemSize = sampler.itemSize;
+
+    assert.isNumber(channel, "channel");
+    assert.isNonNegativeInteger(channel , 'channel');
+    assert.lessThan(channel, itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
+
+    const data = sampler.data;
+
+    const l = data.length;
+
+    if (l === 0) {
+        //no data
+        return undefined;
+    }
+
+    let bestValue = data[channel];
+    let bestIndex = channel;
+
+    for (let i = channel + itemSize; i < l; i += itemSize) {
+        const value = data[i];
+
+        if (bestValue < value) {
+            bestValue = value;
+            bestIndex = i;
+        }
+
+    }
+
+    const width = this.width;
+
+    const itemIndex = (bestIndex / itemSize) | 0;
+
+    const x = itemIndex % width;
+    const y = (itemIndex / width) | 0;
+
+    return {
+        index: bestIndex,
+        value: bestValue,
+        x,
+        y
+    };
+}
+
+/**
+ *
+ * @param {Sampler2D} sampler
+ * @param {number} [channel=0]
+ * @returns {undefined|{x: number, index:number, y: number, value: number}}
+ */
+function sampler2d_channel_compute_min(sampler, channel=0){
+    const itemSize = sampler.itemSize;
+
+    assert.isNumber(channel, "channel");
+    assert.isNonNegativeInteger(channel , 'channel');
+    assert.lessThan(channel, itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
+
+    const data = sampler.data;
+
+    const l = data.length;
+
+    if (l === 0) {
+        //no data
+        return undefined;
+    }
+
+    let bestValue = data[channel];
+    let bestIndex = channel;
+
+    for (let i = channel + itemSize; i < l; i += itemSize) {
+        const value = data[i];
+
+        if (bestValue > value) {
+            bestValue = value;
+            bestIndex = i;
+        }
+
+    }
+
+    const width = this.width;
+
+    const itemIndex = (bestIndex / itemSize) | 0;
+
+    const x = itemIndex % width;
+    const y = (itemIndex / width) | 0;
+
+    return {
+        index: bestIndex,
+        value: bestValue,
+        x,
+        y
+    };
+}
+
 /**
  *
  * @return {WorkerProxy}
@@ -65590,8 +65616,8 @@ function makeTerrainWorkerProxy() {
 
             useSampler(function (sampler) {
 
-                const min = sampler.computeMin();
-                const max = sampler.computeMax();
+                const min = sampler2d_channel_compute_min(sampler);
+                const max = sampler2d_channel_compute_max(sampler);
 
                 resolve({
                     min: min.value,

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.46.35",
+  "version": "2.47.1",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {
@@ -13,7 +13,8 @@
       "import": "./build/meep.module.js",
       "require": "./build/meep.cjs"
     },
-    "./src/*": "./src/*"
+    "./src/*": "./src/*",
+    "./editor/*": "./editor/*"
   },
   "scripts": {
     "build-module": "rollup -c rollup.config.js",

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

@@ -35,11 +35,11 @@ export function orient3d_fast(points, a, b, c, d) {
 
     const bdx = points[b3] - d_x;
     const bdy = points[b3 + 1] - d_y;
-    const cdz = points[c3 + 2] - d_z;
+    const bdz = points[b3 + 2] - d_z;
 
     const cdx = points[c3] - d_x;
     const cdy = points[c3 + 1] - d_y;
-    const bdz = points[b3 + 2] - d_z;
+    const cdz = points[c3 + 2] - d_z;
 
     return adx * (bdy * cdz - bdz * cdy)
         + bdx * (cdy * adz - cdz * ady)

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

@@ -40,21 +40,25 @@ export class NodeGraph {
          */
         this.on = {
             /**
+             * @readonly
              * @type {Signal<NodeInstance,number>}
              */
             nodeAdded: this.nodes.on.added,
 
             /**
+             * @readonly
              * @type {Signal<NodeInstance,number>}
              */
             nodeRemoved: this.nodes.on.removed,
 
             /**
+             * @readonly
              * @type {Signal<Connection,number>}
              */
             connectionAdded: this.connections.on.added,
 
             /**
+             * @readonly
              * @type {Signal<Connection,number>}
              */
             connectionRemoved: this.connections.on.removed

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

@@ -3,6 +3,7 @@ import { NodeParameterDataType } from "./parameter/NodeParameterDataType.js";
 import { NodeParameterDescription } from "./parameter/NodeParameterDescription.js";
 import { Port } from "./Port.js";
 import { PortDirection } from "./PortDirection.js";
+import Signal from "../../../events/signal/Signal.js";
 
 
 /**
@@ -38,7 +39,7 @@ let node_id_counter = 0;
 export class NodeDescription {
     constructor() {
         /**
-         *
+         * Useful human-readable label
          * @type {string}
          */
         this.name = "";
@@ -63,6 +64,22 @@ export class NodeDescription {
          * @type {NodeParameterDescription[]}
          */
         this.parameters = [];
+
+        /**
+         * @readonly
+         */
+        this.on = {
+            /**
+             * @readonly
+             * @type {Signal<Port>}
+             */
+            portAdded: new Signal(),
+            /**
+             * @readonly
+             * @type {Signal<Port>}
+             */
+            portRemoved: new Signal()
+        };
     }
 
     /**
@@ -70,7 +87,7 @@ export class NodeDescription {
      * @returns {Port[]}
      */
     get outPorts() {
-        return this.ports.filter(p => p.direction === PortDirection.Out);
+        return this.getPortsByDirection(PortDirection.Out);
     }
 
     /**
@@ -78,7 +95,7 @@ export class NodeDescription {
      * @returns {Port[]}
      */
     get inPorts() {
-        return this.ports.filter(p => p.direction === PortDirection.In);
+        return this.getPortsByDirection(PortDirection.In);
     }
 
     /**
@@ -165,6 +182,8 @@ export class NodeDescription {
         assert.equal(type.isDataType, true, 'type.isDataType !== true');
 
         assert.defined(direction, 'direction');
+        assert.enum(direction, PortDirection, 'direction');
+
         assert.isString(name, 'name');
 
         const port = new Port();
@@ -179,9 +198,38 @@ export class NodeDescription {
 
         this.ports.push(port);
 
+        this.on.portAdded.send1(port);
+
         return id;
     }
 
+    /**
+     *
+     * @param {number} id port ID
+     * @returns {boolean} true if port was deleted, false if port wasn't found
+     */
+    deletePort(id) {
+        assert.defined(id, 'id');
+        assert.isNumber(id, 'id');
+        assert.isNonNegativeInteger(id, 'id');
+
+        const ports = this.ports;
+        const port_count = ports.length;
+        for (let i = 0; i < port_count; i++) {
+            const port = ports[i];
+
+            if (port.id === id) {
+                ports.splice(i, 1);
+
+                this.on.portRemoved.send1(port);
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     /**
      *
      * @param {number} id
@@ -190,7 +238,10 @@ export class NodeDescription {
     getPortById(id) {
         assert.isNonNegativeInteger(id, 'id');
 
-        for (const port of this.ports) {
+        const ports = this.ports;
+        const port_count = ports.length;
+        for (let i = 0; i < port_count; i++) {
+            const port = ports[i];
             if (port.id === id) {
                 return port;
             }

package/src/engine/ecs/terrain/ecs/makeTerrainWorkerProxy.js

@@ -1,4 +1,6 @@
 import WorkerBuilder from "../../../../core/process/worker/WorkerBuilder.js";
+import { sampler2d_channel_compute_max } from "../../../graphics/texture/sampler/sampler2d_channel_compute_max.js";
+import { sampler2d_channel_compute_min } from "../../../graphics/texture/sampler/sampler2d_channel_compute_min.js";
 
 /**
  *
@@ -27,8 +29,8 @@ export function makeTerrainWorkerProxy() {
 
             useSampler(function (sampler) {
 
-                const min = sampler.computeMin();
-                const max = sampler.computeMax();
+                const min = sampler2d_channel_compute_min(sampler);
+                const max = sampler2d_channel_compute_max(sampler);
 
                 resolve({
                     min: min.value,

package/src/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -46,7 +46,7 @@ import { StaticMaterialCache } from "../../asset/loaders/material/StaticMaterial
 import convertSampler2D2Canvas from "../texture/sampler/Sampler2D2Canvas.js";
 import { CanvasView } from "../../../view/elements/CanvasView.js";
 import { Sampler2D } from "../texture/sampler/Sampler2D.js";
-import { sampler2D_scale_down_linear } from "../texture/sampler/sampler2D_scale_down_linear.js";
+import { sampler2d_scale_down_linear } from "../texture/sampler/sampler2d_scale_down_linear.js";
 import { ShadowMapRenderer } from "../shadows/ShadowMapRenderer.js";
 import { mat4 } from "gl-matrix";
 import { seededRandom } from "../../../core/math/random/seededRandom.js";
@@ -133,7 +133,7 @@ function debug_shadow_map() {
 
     const resampled = Sampler2D.uint8(4, 512, 512);
 
-    sampler2D_scale_down_linear(sampler, resampled);
+    sampler2d_scale_down_linear(sampler, resampled);
 
     convertSampler2D2Canvas(resampled, 1, 0, cv.el);
 

package/src/engine/graphics/texture/sampler/Sampler2D.js

@@ -45,6 +45,10 @@ export class Sampler2D {
             throw new Error("data was undefined");
         }
 
+        if (data.length < width * height * itemSize) {
+            throw new Error(`Buffer underflow, data.length(=${data.length}) is too small. Expected at least ${width * height * itemSize}`);
+        }
+
         /**
          *
          * @type {Number}
@@ -82,51 +86,12 @@ export class Sampler2D {
     }
 
     /**
+     * @deprecated
      * @param {number} [channel=0]
      * @returns {{x: number, index: number, y: number, value: number}}
      */
     computeMax(channel = 0) {
-        const itemSize = this.itemSize;
-
-        assert.typeOf(channel, "number", "channel");
-        assert.ok(channel >= 0, `channel must be >= 0, was ${channel}`);
-        assert.ok(channel < itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
-
-        const data = this.data;
-
-        const l = data.length;
-
-        if (l === 0) {
-            //no data
-            return undefined;
-        }
-
-        let bestValue = data[channel];
-        let bestIndex = channel;
-
-        for (let i = channel + itemSize; i < l; i += itemSize) {
-            const value = data[i];
-
-            if (bestValue < value) {
-                bestValue = value;
-                bestIndex = i;
-            }
-
-        }
-
-        const width = this.width;
-
-        const itemIndex = (bestIndex / this.itemSize) | 0;
-
-        const x = itemIndex % width;
-        const y = (itemIndex / width) | 0;
-
-        return {
-            index: bestIndex,
-            value: bestValue,
-            x,
-            y
-        };
+       throw new Error("deprecated, use sampler2d_channel_compute_max");
     }
 
     /**
@@ -179,51 +144,12 @@ export class Sampler2D {
     }
 
     /**
+     * @deprecated
      * @param {number} [channel=0]
      * @returns {{x: number, index: number, y: number, value: number}}
      */
     computeMin(channel = 0) {
-        const itemSize = this.itemSize;
-
-        assert.typeOf(channel, "number", "channel");
-        assert.ok(channel >= 0, `channel must be >= 0, was ${channel}`);
-        assert.ok(channel < itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
-
-        const data = this.data;
-
-        const l = data.length;
-
-        if (l === 0) {
-            //no data
-            return undefined;
-        }
-
-        let bestValue = data[channel];
-        let bestIndex = channel;
-
-        for (let i = channel + itemSize; i < l; i += itemSize) {
-            const value = data[i];
-
-            if (bestValue > value) {
-                bestValue = value;
-                bestIndex = i;
-            }
-
-        }
-
-        const width = this.width;
-
-        const itemIndex = (bestIndex / this.itemSize) | 0;
-
-        const x = itemIndex % width;
-        const y = (itemIndex / width) | 0;
-
-        return {
-            index: bestIndex,
-            value: bestValue,
-            x,
-            y
-        };
+        throw new Error("deprecated, use sampler2d_channel_compute_min");
     }
 
     /**

package/src/engine/graphics/texture/sampler/Sampler2D.spec.js

@@ -119,43 +119,6 @@ test('set and get consistency itemSize=4, 2x2', () => {
     expect(sample).toEqual([13, 14, 15, 16]);
 });
 
-test('computeMax itemSize=1, 0x0', () => {
-    const ut = Sampler2D.int8(1, 0, 0);
-
-    expect(ut.computeMax(0)).toEqual(undefined);
-});
-
-test('computeMax itemSize=1, 1x1', () => {
-    const ut = Sampler2D.int8(1, 1, 1);
-
-    ut.set(0, 0, [7]);
-
-    expect(ut.computeMax(0)).toEqual({ value: 7, x: 0, y: 0, index: 0 });
-});
-
-test('computeMax itemSize=1, 2x2', () => {
-    const ut = Sampler2D.int8(1, 2, 2);
-
-    ut.set(0, 0, [3]);
-    ut.set(1, 0, [-7]);
-    ut.set(0, 1, [7]);
-    ut.set(1, 1, [4]);
-
-    expect(ut.computeMax(0)).toEqual({ value: 7, x: 0, y: 1, index: 2 });
-});
-
-test('computeMax itemSize=2, 2x2', () => {
-    const ut = Sampler2D.int8(2, 2, 2);
-
-    ut.set(0, 0, [3, 8]);
-    ut.set(1, 0, [-7, 13]);
-    ut.set(0, 1, [7, 1]);
-    ut.set(1, 1, [4, -3]);
-
-    expect(ut.computeMax(0)).toEqual({ value: 7, x: 0, y: 1, index: 4 });
-
-    expect(ut.computeMax(1)).toEqual({ value: 13, x: 1, y: 0, index: 3 });
-});
 
 test('sampleChannelBilinear 1x1 exact', () => {
     const s = Sampler2D.uint8(1, 1, 1);

package/src/engine/graphics/texture/sampler/Sampler2D2Canvas.js

@@ -4,7 +4,7 @@
 
 
 import { Sampler2D } from "./Sampler2D.js";
-import { sample2d_write_to_canvas_raw } from "./sample2d_write_to_canvas_raw.js";
+import { sampler2d_write_to_canvas_raw } from "./sampler2d_write_to_canvas_raw.js";
 
 /**
  *
@@ -85,7 +85,7 @@ function convertSampler2D2Canvas(sampler, scale = 255, offset = 0, canvas, fillD
 
     }
 
-    sample2d_write_to_canvas_raw(converted_sampler, canvas);
+    sampler2d_write_to_canvas_raw(converted_sampler, canvas);
 
     return canvas;
 }

package/src/engine/graphics/texture/sampler/resize/sampler2d_downsample_mipmap.js

@@ -1,5 +1,5 @@
 import { Sampler2D } from "../Sampler2D.js";
-import { sampler2D_scale_down_linear } from "../sampler2D_scale_down_linear.js";
+import { sampler2d_scale_down_linear } from "../sampler2d_scale_down_linear.js";
 import { inverseLerp } from "../../../../../core/math/inverseLerp.js";
 import { lerp } from "../../../../../core/math/lerp.js";
 
@@ -24,7 +24,7 @@ export function sampler2d_downsample_mipmap(source, destination) {
 
         const out = new Sampler2D(new current_mip.data.constructor(new_w * new_h * itemSize), itemSize, new_w, new_h);
 
-        sampler2D_scale_down_linear(current_mip, out);
+        sampler2d_scale_down_linear(current_mip, out);
 
         previous_mip = current_mip;
         current_mip = out;