@woosh/meep-engine 2.46.35 → 2.47.1

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

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