@woosh/meep-engine 2.46.36 → 2.47.1

package/build/meep.module.js

@@ -48206,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.isNumber(channel, "channel");
-        assert.isNonNegativeInteger(channel , 'channel');
-        assert.lessThan(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");
     }
 
     /**
@@ -48303,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");
     }
 
     /**
@@ -54838,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');
 
@@ -55051,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);
@@ -65567,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}
@@ -65594,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.36",
+  "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/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

@@ -86,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.isNumber(channel, "channel");
-        assert.isNonNegativeInteger(channel , 'channel');
-        assert.lessThan(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");
     }
 
     /**
@@ -183,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;

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

@@ -0,0 +1,51 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {Sampler2D} sampler
+ * @param {number} [channel=0]
+ * @returns {undefined|{x: number, index:number, y: number, value: number}}
+ */
+export 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
+    };
+}

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

@@ -0,0 +1,40 @@
+import { Sampler2D } from "./Sampler2D.js";
+import { sampler2d_channel_compute_max } from "./sampler2d_channel_compute_max.js";
+
+test('computeMax itemSize=1, 0x0', () => {
+    const ut = Sampler2D.int8(1, 0, 0);
+
+    expect(sampler2d_channel_compute_max(ut,0)).toEqual(undefined);
+});
+
+test('computeMax itemSize=1, 1x1', () => {
+    const ut = Sampler2D.int8(1, 1, 1);
+
+    ut.set(0, 0, [7]);
+
+    expect(sampler2d_channel_compute_max(ut,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(sampler2d_channel_compute_max(ut,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(sampler2d_channel_compute_max(ut,0)).toEqual({ value: 7, x: 0, y: 1, index: 4 });
+
+    expect(sampler2d_channel_compute_max(ut,1)).toEqual({ value: 13, x: 1, y: 0, index: 3 });
+});

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

@@ -0,0 +1,51 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {Sampler2D} sampler
+ * @param {number} [channel=0]
+ * @returns {undefined|{x: number, index:number, y: number, value: number}}
+ */
+export 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
+    };
+}

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

@@ -3,6 +3,8 @@ import { min2 } from "../../../../core/math/min2.js";
 import { max2 } from "../../../../core/math/max2.js";
 import { isTypedArray } from "../../../../core/collection/array/typed/isTypedArray.js";
 import { typedArrayToDataType } from "../../../../core/collection/array/typedArrayToDataType.js";
+import { sampler2d_channel_compute_max } from "./sampler2d_channel_compute_max.js";
+import { sampler2d_channel_compute_min } from "./sampler2d_channel_compute_min.js";
 
 /**
  *
@@ -31,8 +33,8 @@ export function sampler2d_compute_texel_value_conversion_scale_to_uint8(sampler)
         max = -Infinity;
         for (let i = 0; i < sampler.itemSize; i++) {
 
-            min = min2(min, sampler.computeMin(i).value)
-            max = max2(min, sampler.computeMax(i).value)
+            min = min2(min,sampler2d_channel_compute_min(sampler,i).value)
+            max = max2(min, sampler2d_channel_compute_max(sampler,i).value)
         }
     }
 

package/src/engine/graphics/texture/sampler/{sampler2D_scale_down_linear.js → sampler2d_scale_down_linear.js}

@@ -5,7 +5,7 @@ import { assert } from "../../../../core/assert.js";
  * @param {Sampler2D} input
  * @param {Sampler2D} output
  */
-export function sampler2D_scale_down_linear(input, output) {
+export function sampler2d_scale_down_linear(input, output) {
     assert.notEqual(input, undefined, 'input is undefined');
     assert.notEqual(output, undefined, 'output is undefined');
 

package/src/engine/graphics/texture/sampler/{downsampleSample2D.spec.js → sampler2d_scale_down_linear.spec.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";
 
 test('2x2 -> 1x1 2x channel', () => {
     const input = Sampler2D.float32(2, 2, 2);
@@ -10,7 +10,7 @@ test('2x2 -> 1x1 2x channel', () => {
     input.set(0, 1, [11, 13]);
     input.set(1, 1, [17, 19]);
 
-    sampler2D_scale_down_linear(input, output);
+    sampler2d_scale_down_linear(input, output);
 
     expect(output.data[0]).toEqual(8.5);
     expect(output.data[1]).toEqual(10.5);