@woosh/meep-engine 2.46.36 → 2.47.2

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

@@ -78,59 +78,15 @@ export class Sampler2D {
          * @type {number}
          */
         this.version = 0;
-        /**
-         * @readonly
-         * @type {boolean}
-         */
-        this.isSampler2D = true;
     }
 
     /**
+     * @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");
     }
 
     /**
@@ -152,7 +108,7 @@ export class Sampler2D {
 
         if (l === 0) {
             //no data
-            return undefined;
+            return;
         }
 
         let bestValue = data[channel];
@@ -178,56 +134,15 @@ export class Sampler2D {
         if (resultCount < result.length) {
             result.splice(resultCount, result.length - resultCount);
         }
-
-        return;
     }
 
     /**
+     * @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");
     }
 
     /**
@@ -717,74 +632,6 @@ export class Sampler2D {
         result.set(x, y);
     }
 
-    /**
-     *
-     * @param {number} scale
-     * @param {number} offset
-     * @return {function(index:int, array:ArrayLike, x:int, y:int)}
-     */
-    makeArrayFiller(scale, offset) {
-        scale = scale || 255;
-        offset = offset || 0;
-
-        const sampler = this;
-        const v4 = [1 / scale, 1 / scale, 1 / scale, 1 / scale];
-
-        //
-        function fillDD1(index, array, x, y) {
-            const val = (sampler.sampleChannelBilinear(x, y, 0) + offset) * scale | 0;
-            array[index] = val;
-            array[index + 1] = val;
-            array[index + 2] = val;
-            array[index + 3] = 255;
-        }
-
-        function fillDD2(index, array, x, y) {
-            sampler.sampleBilinear(x, y, v4, 0);
-            const val = (v4[0] + offset) * scale | 0;
-            array.fill(val, index, index + 3);
-            array[index + 3] = (v4[1] + offset) * scale | 0;
-        }
-
-        function fillDD3(index, array, x, y) {
-
-            sampler.sampleBilinear(x, y, v4, 0);
-
-            array[index] = (v4[0] + offset) * scale | 0;
-            array[index + 1] = (v4[1] + offset) * scale | 0;
-            array[index + 2] = (v4[2] + offset) * scale | 0;
-            array[index + 3] = 255;
-        }
-
-        function fillDD4(index, array, x, y) {
-            sampler.sampleBilinear(x, y, v4, 0);
-            array[index] = (v4[0] + offset) * scale | 0;
-            array[index + 1] = (v4[1] + offset) * scale | 0;
-            array[index + 2] = (v4[2] + offset) * scale | 0;
-            array[index + 3] = (v4[3] + offset) * scale | 0;
-        }
-
-        let fillDD;
-        switch (sampler.itemSize) {
-            case 1:
-                fillDD = fillDD1;
-                break;
-            case 2:
-                fillDD = fillDD2;
-                break;
-            case 3:
-                fillDD = fillDD3;
-                break;
-            case 4:
-                fillDD = fillDD4;
-                break;
-            default :
-                throw new Error("unsupported item size");
-                break;
-        }
-        return fillDD;
-    }
-
     /**
      * Copy a patch from another sampler with a margin.
      * This is useful for texture rendering where filtering can cause bleeding along the edges of the patch.
@@ -1361,28 +1208,7 @@ export class Sampler2D {
      * @param {BinaryBuffer} buffer
      */
     toBinaryBuffer(buffer) {
-        const width = this.width;
-        const height = this.height;
-
-        const itemSize = this.itemSize;
-
-        buffer.writeUint16(width);
-        buffer.writeUint16(height);
-
-        buffer.writeUint8(itemSize);
-
-        if (this.data instanceof Uint8Array) {
-            //data type
-            buffer.writeUint8(0);
-
-
-            const byteSize = width * height * itemSize;
-
-            buffer.writeBytes(this.data, 0, byteSize);
-
-        } else {
-            throw new TypeError(`Unsupported data type`);
-        }
+        throw new Error('Deprecated, use Sampler2DSerializationAdapter instead');
     }
 
     /**
@@ -1390,24 +1216,7 @@ export class Sampler2D {
      * @param {BinaryBuffer} buffer
      */
     fromBinaryBuffer(buffer) {
-        this.width = buffer.readUint16();
-        this.height = buffer.readUint16();
-
-        this.itemSize = buffer.readUint8();
-
-        const dataType = buffer.readUint8();
-
-        if (dataType === 0) {
-
-            const numBytes = this.height * this.width * this.itemSize;
-            this.data = new Uint8Array(numBytes);
-
-            buffer.readBytes(this.data, 0, numBytes);
-
-            this.version++;
-        } else {
-            throw new TypeError(`Unsupported data type (${dataType})`);
-        }
+        throw new Error('Deprecated, use Sampler2DSerializationAdapter instead');
     }
 
     /**
@@ -1652,6 +1461,11 @@ export class Sampler2D {
 
 }
 
+/**
+ * @readonly
+ * @type {boolean}
+ */
+Sampler2D.prototype.isSampler2D = true;
 
 /**
  * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/

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";
 
 /**
  *
@@ -12,7 +12,7 @@ import { sample2d_write_to_canvas_raw } from "./sample2d_write_to_canvas_raw.js"
  * @param {Number} [scale]
  * @param {Number} [offset]
  * @param {HTMLCanvasElement} [canvas] if no canvas is supplied, a new one will be created
- * @param {function(index:int, array:ArrayLike<number>, x:int, y:int)} [fillDD] allows you to supply mapping function, if none is given - one will be created from sampler using {@link Sampler2D#makeArrayFiller}
+ * @param {function(index:int, array:ArrayLike<number>, x:int, y:int)} [fillDD] allows you to supply mapping function, if none is given - one will be created from sampler
  * @returns {HTMLCanvasElement} canvas
  */
 function convertSampler2D2Canvas(sampler, scale = 255, offset = 0, canvas, fillDD) {
@@ -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_make_array_filler_function.js

@@ -0,0 +1,65 @@
+/**
+ *
+ * @param {Sampler2D} sampler
+ * @param {number} scale
+ * @param {number} offset
+ * @return {function(index:int, array:ArrayLike, x:int, y:int)}
+ */
+export function sampler2d_make_array_filler_function(sampler, scale=255, offset=0){
+
+    const v4 = [1 / scale, 1 / scale, 1 / scale, 1 / scale];
+
+    //
+    function fillDD1(index, array, x, y) {
+        const val = (sampler.sampleChannelBilinear(x, y, 0) + offset) * scale | 0;
+        array[index] = val;
+        array[index + 1] = val;
+        array[index + 2] = val;
+        array[index + 3] = 255;
+    }
+
+    function fillDD2(index, array, x, y) {
+        sampler.sampleBilinear(x, y, v4, 0);
+        const val = (v4[0] + offset) * scale | 0;
+        array.fill(val, index, index + 3);
+        array[index + 3] = (v4[1] + offset) * scale | 0;
+    }
+
+    function fillDD3(index, array, x, y) {
+
+        sampler.sampleBilinear(x, y, v4, 0);
+
+        array[index] = (v4[0] + offset) * scale | 0;
+        array[index + 1] = (v4[1] + offset) * scale | 0;
+        array[index + 2] = (v4[2] + offset) * scale | 0;
+        array[index + 3] = 255;
+    }
+
+    function fillDD4(index, array, x, y) {
+        sampler.sampleBilinear(x, y, v4, 0);
+        array[index] = (v4[0] + offset) * scale | 0;
+        array[index + 1] = (v4[1] + offset) * scale | 0;
+        array[index + 2] = (v4[2] + offset) * scale | 0;
+        array[index + 3] = (v4[3] + offset) * scale | 0;
+    }
+
+    let fillDD;
+    switch (sampler.itemSize) {
+        case 1:
+            fillDD = fillDD1;
+            break;
+        case 2:
+            fillDD = fillDD2;
+            break;
+        case 3:
+            fillDD = fillDD3;
+            break;
+        case 4:
+            fillDD = fillDD4;
+            break;
+        default :
+            throw new Error("unsupported item size");
+            break;
+    }
+    return fillDD;
+}

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);

package/src/engine/graphics/texture/sampler/{sample2d_write_to_canvas_raw.js → sampler2d_write_to_canvas_raw.js}

@@ -1,12 +1,16 @@
 import { Sampler2D } from "./Sampler2D.js";
 import { sampler2d_to_uint8_RGBA } from "./sampler2d_to_uint8_RGBA.js";
+import { assert } from "../../../../core/assert.js";
 
 /**
  *
  * @param {Sampler2D} sampler
  * @param {HTMLCanvasElement} canvas
  */
-export function sample2d_write_to_canvas_raw(sampler, canvas) {
+export function sampler2d_write_to_canvas_raw(sampler, canvas) {
+
+    assert.defined(sampler, 'sampler');
+    assert.defined(canvas, 'canvas');
 
     const width = sampler.width;
     const height = sampler.height;

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

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { sampler2D_scale_down_linear } from "./sampler2D_scale_down_linear.js";
+import { sampler2d_scale_down_linear } from "./sampler2d_scale_down_linear.js";
 import { Sampler2D } from "./Sampler2D.js";
 import { upsampleSampler2D } from "./upsampleSampler2D.js";
 import { genericResampleSampler2D } from "./genericResampleSampler2D.js";
@@ -29,7 +29,7 @@ export 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, 3);

package/src/engine/input/ecs/util/TerrainCameraTargetSampler.js

@@ -1,5 +1,5 @@
 import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
-import { sampler2D_scale_down_linear } from "../../../graphics/texture/sampler/sampler2D_scale_down_linear.js";
+import { sampler2d_scale_down_linear } from "../../../graphics/texture/sampler/sampler2d_scale_down_linear.js";
 import { computeWholeDivisorLow } from "../../../../core/math/computeWholeDivisorLow.js";
 
 /**
@@ -20,7 +20,7 @@ export function buildCameraTargetSampler({ heightSampler }) {
 
     const result = Sampler2D.float32(1, s(heightSampler.width), s(heightSampler.height));
 
-    sampler2D_scale_down_linear(heightSampler, result);
+    sampler2d_scale_down_linear(heightSampler, result);
 
     return result;
 }

package/src/engine/ui/tiles2d/computeTileGridMove.js

@@ -16,8 +16,8 @@ import { aabb2_contains, aabb2_overlapExists } from "../../../core/geom/AABB2.js
  * @returns {TileMoveProgram}
  */
 export function computeTileGridMove(tile, targetX, targetY, source, target) {
-    assert.typeOf(targetX, 'number', 'targetX');
-    assert.typeOf(targetY, 'number', 'targetY');
+    assert.isNumber(targetX, 'targetX');
+    assert.isNumber(targetY, 'targetY');
 
     assert.defined(tile, 'tile');
     assert.defined(source, 'source');