@woosh/meep-engine 2.37.18 → 2.38.0

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

@@ -1,5 +1,4 @@
 import { Sampler2D } from "./Sampler2D.js";
-import Vector4 from "../../../../core/geom/Vector4.js";
 
 test("constructor arguments", () => {
     const uint8Array = new Uint8Array(24);
@@ -18,7 +17,7 @@ test("get method v1 1x1", () => {
 
     const ut = new Sampler2D(uint8Array, 1, 1, 1);
 
-    expect(ut.get(0, 0)).toBe(7);
+    expect(ut.readChannel(0, 0, 0)).toBe(7);
 });
 
 test("resize uint8 v1 1x1 to 2x3", () => {
@@ -32,7 +31,7 @@ test("resize uint8 v1 1x1 to 2x3", () => {
     expect(s.height).toBe(3);
 
     //old data is preserved
-    expect(s.get(0, 0)).toBe(1);
+    expect(s.readChannel(0, 0, 0)).toBe(1);
 
     expect(s.data.length).toBe(6);
 });
@@ -49,8 +48,8 @@ test("resize uint8 v1 1x2 to 2x3", () => {
     expect(s.height).toBe(3);
 
     //old data is preserved
-    expect(s.get(0, 0)).toBe(1);
-    expect(s.get(0, 1)).toBe(3);
+    expect(s.readChannel(0, 0, 0)).toBe(1);
+    expect(s.readChannel(0, 1, 0)).toBe(3);
 
     expect(s.data.length).toBe(6);
 });
@@ -67,8 +66,8 @@ test("resize uint8 v1 2x3 to 1x2", () => {
     expect(s.height).toBe(2);
 
     //old data is preserved
-    expect(s.get(0, 0)).toBe(1);
-    expect(s.get(0, 1)).toBe(3);
+    expect(s.readChannel(0, 0, 0)).toBe(1);
+    expect(s.readChannel(0, 1, 0)).toBe(3);
 
     expect(s.data.length).toBe(2);
 });
@@ -83,10 +82,10 @@ test("get method v1 2x2", () => {
 
     const ut = new Sampler2D(uint8Array, 1, 2, 2);
 
-    expect(ut.get(0, 0)).toBe(7);
-    expect(ut.get(1, 0)).toBe(11);
-    expect(ut.get(0, 1)).toBe(13);
-    expect(ut.get(1, 1)).toBe(5);
+    expect(ut.readChannel(0, 0, 0)).toBe(7);
+    expect(ut.readChannel(1, 0, 0)).toBe(11);
+    expect(ut.readChannel(0, 1, 0)).toBe(13);
+    expect(ut.readChannel(1, 1, 0)).toBe(5);
 });
 
 
@@ -100,23 +99,23 @@ test('set and get consistency itemSize=4, 2x2', () => {
     ut.set(1, 1, [13, 14, 15, 16]);
 
 
-    const sample = new Vector4();
+    const sample = [];
 
-    ut.get(0, 0, sample);
+    ut.read(0, 0, sample);
 
-    expect(sample.asArray()).toEqual([1, 2, 3, 4]);
+    expect(sample).toEqual([1, 2, 3, 4]);
 
-    ut.get(1, 0, sample);
+    ut.read(1, 0, sample);
 
-    expect(sample.asArray()).toEqual([5, 6, 7, 8]);
+    expect(sample).toEqual([5, 6, 7, 8]);
 
-    ut.get(0, 1, sample);
+    ut.read(0, 1, sample);
 
-    expect(sample.asArray()).toEqual([9, 10, 11, 12]);
+    expect(sample).toEqual([9, 10, 11, 12]);
 
-    ut.get(1, 1, sample);
+    ut.read(1, 1, sample);
 
-    expect(sample.asArray()).toEqual([13, 14, 15, 16]);
+    expect(sample).toEqual([13, 14, 15, 16]);
 });
 
 test('computeMax itemSize=1, 0x0', () => {
@@ -192,11 +191,11 @@ test('sampleChannelBilinear 2x2', () => {
     expect(s.sampleChannelBilinear(1, 1, 0)).toBe(11);
 
 
-    expect(s.sampleChannelBilinear(0.5, 0, 0)).toBe(3);
-    expect(s.sampleChannelBilinear(0, 0.5, 0)).toBe(4);
-    expect(s.sampleChannelBilinear(0.5, 0.5, 0)).toBe(6);
-    expect(s.sampleChannelBilinear(1, 0.5, 0)).toBe(8);
-    expect(s.sampleChannelBilinear(0.5, 1, 0)).toBe(9);
+    expect(s.sampleChannelBilinear(0.5, 0, 0)).toBeCloseTo(3);
+    expect(s.sampleChannelBilinear(0, 0.5, 0)).toBeCloseTo(4);
+    expect(s.sampleChannelBilinear(0.5, 0.5, 0)).toBeCloseTo(6);
+    expect(s.sampleChannelBilinear(1, 0.5, 0)).toBeCloseTo(8);
+    expect(s.sampleChannelBilinear(0.5, 1, 0)).toBeCloseTo(9);
 
 
 });
@@ -256,7 +255,7 @@ describe("copy method", () => {
 
         target.copy(source, 0, 0, 1, 1, 1, 1);
 
-        expect(target.get(1, 1)).toBe(2);
+        expect(target.readChannel(1, 1, 0)).toBe(2);
     });
 });
 
@@ -271,22 +270,22 @@ describe("copyWithMargin method", () => {
         target.copyWithMargin(source, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1);
 
         //top left
-        expect(target.get(0, 0)).toEqual(2);
+        expect(target.readChannel(0, 0, 0)).toEqual(2);
         //top
-        expect(target.get(1, 0)).toEqual(2);
+        expect(target.readChannel(1, 0, 0)).toEqual(2);
         //top right
-        expect(target.get(2, 0)).toEqual(2);
+        expect(target.readChannel(2, 0, 0)).toEqual(2);
         //left
-        expect(target.get(0, 1)).toEqual(2);
+        expect(target.readChannel(0, 1, 0)).toEqual(2);
         //copied region
-        expect(target.get(1, 1)).toEqual(2);
+        expect(target.readChannel(1, 1, 0)).toEqual(2);
         //right
-        expect(target.get(2, 1)).toEqual(2);
+        expect(target.readChannel(2, 1, 0)).toEqual(2);
         //bottom left
-        expect(target.get(0, 2)).toEqual(2);
+        expect(target.readChannel(0, 2, 0)).toEqual(2);
         //bottom
-        expect(target.get(1, 2)).toEqual(2);
+        expect(target.readChannel(1, 2, 0)).toEqual(2);
         //bottom right
-        expect(target.get(2, 2)).toEqual(2);
+        expect(target.readChannel(2, 2, 0)).toEqual(2);
     });
 });

package/engine/graphics/texture/sampler/bicubic.js

@@ -0,0 +1,59 @@
+/**
+ * @see https://github.com/hughsk/bicubic/blob/master/index.js
+ * @param xf
+ * @param yf
+ * @param p00
+ * @param p01
+ * @param p02
+ * @param p03
+ * @param p10
+ * @param p11
+ * @param p12
+ * @param p13
+ * @param p20
+ * @param p21
+ * @param p22
+ * @param p23
+ * @param p30
+ * @param p31
+ * @param p32
+ * @param p33
+ * @returns {*}
+ */
+export function bicubic(
+    xf, yf
+    , p00, p01, p02, p03
+    , p10, p11, p12, p13
+    , p20, p21, p22, p23
+    , p30, p31, p32, p33
+) {
+    var yf2 = yf * yf
+    var xf2 = xf * xf
+    var xf3 = xf * xf2
+
+    var x00 = p03 - p02 - p00 + p01
+    var x01 = p00 - p01 - x00
+    var x02 = p02 - p00
+    var x0 = x00 * xf3 + x01 * xf2 + x02 * xf + p01
+
+    var x10 = p13 - p12 - p10 + p11
+    var x11 = p10 - p11 - x10
+    var x12 = p12 - p10
+    var x1 = x10 * xf3 + x11 * xf2 + x12 * xf + p11
+
+    var x20 = p23 - p22 - p20 + p21
+    var x21 = p20 - p21 - x20
+    var x22 = p22 - p20
+    var x2 = x20 * xf3 + x21 * xf2 + x22 * xf + p21
+
+    var x30 = p33 - p32 - p30 + p31
+    var x31 = p30 - p31 - x30
+    var x32 = p32 - p30
+    var x3 = x30 * xf3 + x31 * xf2 + x32 * xf + p31
+
+    var y0 = x3 - x2 - x0 + x1
+    var y1 = x0 - x1 - y0
+    var y2 = x2 - x0
+
+    return y0 * yf * yf2 + y1 * yf2 + y2 * yf + x1
+}

package/engine/graphics/texture/sampler/downsampleSample2D.spec.js

@@ -1,5 +1,5 @@
 import { Sampler2D } from "./Sampler2D.js";
-import { downsampleSampler2D } from "./downsampleSampler2D.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]);
 
-    downsampleSampler2D(input, output);
+    sampler2D_scale_down_linear(input, output);
 
     expect(output.data[0]).toEqual(8.5);
     expect(output.data[1]).toEqual(10.5);

package/engine/graphics/texture/sampler/genericResampleSampler2D.js

@@ -11,8 +11,6 @@ export function genericResampleSampler2D(source, target) {
 
     // build kernel
 
-    // TODO add gaussian weights kernel for samples
-
     const u_scale = source.width / target_width;
     const v_scale = source.height / target_height;
 

package/engine/graphics/texture/sampler/prototypeSamplerFiltering.js

@@ -0,0 +1,146 @@
+import { EngineHarness } from "../../../EngineHarness.js";
+import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
+import sampler2D2Canvas from "./Sampler2D2Canvas.js";
+import { CanvasView } from "../../../../view/elements/CanvasView.js";
+import { sampler2D_scale_down_lanczos } from "./sampler2_d_scale_down_lanczos.js";
+import { Sampler2D } from "./Sampler2D.js";
+import { genericResampleSampler2D } from "./genericResampleSampler2D.js";
+import Vector2 from "../../../../core/geom/Vector2.js";
+
+function grid(engine, input, transforms, size = new Vector2(input.width, input.height)) {
+
+    for (let i = 0; i < transforms.length; i++) {
+        const out = input.clone();
+
+        out.resize(size.x, size.y);
+
+        transforms[i](out, input);
+
+        display(engine, out, i * (size.x + 4), 0);
+    }
+
+}
+
+
+function display(engine, sampler, x = 0, y = 0) {
+
+    const view = new CanvasView();
+    view.size.set(sampler.width, sampler.height);
+    sampler2D2Canvas(sampler, 1, 0, view.el);
+
+    view.css({
+        position: 'absolute',
+        top: `${y}px`,
+        left: `${x}px`
+    });
+
+    engine.gameView.addChild(view);
+}
+
+
+new EngineHarness().initialize({
+    configuration(config) {
+        config.addLoader('image', new ImageRGBADataLoader());
+    }
+}).then(async engine => {
+
+    const asset = await engine.assetManager.promise("data/textures/utility/Lenna.png", 'image');
+    // const asset = await engine.assetManager.promise("data/textures/utility/resolver.jpeg", 'image');
+    // const asset = await engine.assetManager.promise("data/textures/icons/500_skill_icons_02/Skill_nobg/skill_492_noBG.png", 'image');
+    // const asset = await engine.assetManager.promise("data/textures/utility/sampling-test.png", 'image');
+
+    const source = asset.create();
+
+    test_sampling(source, engine)
+
+    engine.graphics.getRenderer().setClearColor('green');
+
+    return;
+    const TARGET_SCALE = 0.2;
+
+    // display(source);
+
+    const TARGET_HEIGHT = Math.ceil(source.height * TARGET_SCALE);
+    const TARGET_WIDTH = Math.ceil(source.width * TARGET_SCALE);
+
+    const COMPARE_X_OFFSET = 0;
+
+    const small = Sampler2D.uint8(source.itemSize, TARGET_WIDTH, TARGET_HEIGHT);
+
+    // sampler2D_lanczos(source, small);
+    console.time('filter');
+    sampler2D_scale_down_lanczos(source, small, 3);
+    console.timeEnd('filter');
+
+    display(engine, small, COMPARE_X_OFFSET, 0);
+
+    // const big = Sampler2D.uint8(source.itemSize, Math.ceil(source.width / TARGET_SCALE), Math.ceil(source.height / TARGET_SCALE));
+    // sampler2D_scale_down_lanczos(source, big,3);
+    //
+    // display(big, 0, source.height);
+
+    const small_scale_2 = Sampler2D.uint8(source.itemSize, TARGET_WIDTH, TARGET_HEIGHT);
+    console.time('filter-generic');
+    genericResampleSampler2D(source, small_scale_2);
+    console.timeEnd('filter-generic');
+    display(engine, small_scale_2, COMPARE_X_OFFSET, TARGET_HEIGHT);
+})
+
+function test_sampling(source, engine) {
+    grid(engine, source, [
+        (out, input) => {
+            const sample = [];
+            for (let y = 0; y < out.height; y++) {
+
+                for (let x = 0; x < out.width; x++) {
+
+                    input.sampleNearestUV(x / (out.width - 1), y / (out.height - 1), sample);
+
+                    out.set(x, y, sample);
+                }
+            }
+        },
+        (out, input) => {
+            const sample = new Uint8ClampedArray(4);
+            for (let y = 0; y < out.height; y++) {
+
+                for (let x = 0; x < out.width; x++) {
+
+                    input.sampleBilinearUV(x / (out.width - 1), y / (out.height - 1), sample);
+
+                    out.set(x, y, sample);
+                }
+            }
+        },
+        (out, input) => {
+            const sample = new Uint8ClampedArray(4);
+            for (let y = 0; y < out.height; y++) {
+
+                for (let x = 0; x < out.width; x++) {
+
+                    input.sampleBicubicUV(x / (out.width - 1), y / (out.height - 1), sample);
+
+                    out.set(x, y, sample);
+                }
+            }
+        },
+        (out, input) => {
+            const sample = new Uint8ClampedArray(4);
+            for (let y = 0; y < out.height; y++) {
+
+                for (let x = 0; x < out.width; x++) {
+
+                    input.sampleCatmullRomUV(x / (out.width - 1), y / (out.height - 1), sample);
+
+                    out.set(x, y, sample);
+                }
+            }
+        }
+    ], new Vector2(
+        200, 200
+    ));
+}
+
+function lanczos() {
+
+}

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

@@ -5,7 +5,7 @@ import { assert } from "../../../../core/assert.js";
  * @param {Sampler2D} input
  * @param {Sampler2D} output
  */
-export function downsampleSampler2D(input, output) {
+export function sampler2D_scale_down_linear(input, output) {
     assert.notEqual(input, undefined, 'input is undefined');
     assert.notEqual(output, undefined, 'output is undefined');
 
@@ -32,6 +32,7 @@ export function downsampleSampler2D(input, output) {
     const sample = new Array(itemSize);
 
     const sampleSize = sW * sH;
+    const sampleSizeInv = 1 / sampleSize;
 
     const iData = input.data;
     const oData = output.data;
@@ -43,9 +44,11 @@ export function downsampleSampler2D(input, output) {
 
         const sampleOffsetY = y * sH;
 
+        const row_address = y * oW * itemSize;
+
         for (x = 0; x < oW; x++) {
 
-            const oAddress = (x + y * oW) * itemSize;
+            const output_texel_address = row_address + x * itemSize;
 
             for (i = 0; i < itemSize; i++) {
                 // reset sample
@@ -57,10 +60,11 @@ export function downsampleSampler2D(input, output) {
             // accumulate sample
             for (j = 0; j < sH; j++) {
                 const row_index = (sampleOffsetY + j) * iW;
+                const texel_offset = row_index + sampleOffsetX;
 
                 for (i = 0; i < sW; i++) {
 
-                    const iAddress = ((sampleOffsetX + i) + row_index) * itemSize;
+                    const iAddress = (texel_offset + i) * itemSize;
 
                     for (k = 0; k < itemSize; k++) {
                         sample[k] += iData[k + iAddress];
@@ -71,7 +75,7 @@ export function downsampleSampler2D(input, output) {
 
             // dilute the sample
             for (i = 0; i < itemSize; i++) {
-                oData[oAddress + i] = sample[i] / sampleSize;
+                oData[output_texel_address + i] = sample[i] * sampleSizeInv;
             }
 
 

package/engine/graphics/texture/sampler/sampler2_d_scale_down_lanczos.js

@@ -0,0 +1,140 @@
+import { max2 } from "../../../../core/math/max2.js";
+import { min2 } from "../../../../core/math/min2.js";
+
+
+/**
+ * @see https://en.wikipedia.org/wiki/Lanczos_resampling
+ * Calculate lanczos weight
+ * @param {number} x
+ * @param {number} lobes
+ * @returns {number}
+ */
+function lanczos(x, lobes) {
+
+    /*
+    // not needed in our case, as X is always positive
+    if (x < 0) {
+        x = -x;
+    }
+
+     */
+
+    if (x > lobes) {
+        return 0;
+    }
+
+    if (x < 1e-16) {
+        return 1;
+    }
+
+    const xx = x / lobes;
+
+    return Math.sin(Math.PI * x) * Math.sin(Math.PI * xx) / (x * x);
+}
+
+export function filter_lanczos3(t) {
+    if (t < 0) {
+        t = -t;
+    }
+    if (t < 3.0) {
+        return Math.sin(t) * Math.sin(t / 3.0);
+    }
+    return 0.0;
+}
+
+filter_lanczos3.support = 3;
+
+
+/**
+ * Good for down-sampling
+ * @param {Sampler2D} source
+ * @param {Sampler2D} destination
+ * @param {number} [lobes]
+ */
+export function sampler2D_scale_down_lanczos(source, destination, lobes = 3) {
+
+    const d_w = destination.width;
+    const d_h = destination.height;
+
+    const item_size = destination.itemSize;
+
+    const source_width = source.width;
+    const source_height = source.height;
+
+    const source_data = source.data;
+    const destination_data = destination.data;
+
+    const ratio_x = source_width / d_w;
+    const ratio_y = source_height / d_h;
+
+
+    const range2_x = Math.ceil(ratio_x * lobes / 2);
+    const range2_y = Math.ceil(ratio_y * lobes / 2);
+
+    const sample = new Array(item_size);
+
+    let v, u, i, j, k;
+
+    for (v = 0; v < d_h; v++) {
+
+        const center_y = (v) * ratio_y;
+        const source_y0 = max2(Math.ceil(center_y - range2_y), 0);
+        const source_y1 = min2(Math.floor(center_y + range2_y), source_height - 1);
+
+        for (u = 0; u < d_w; u++) {
+            const center_x = (u) * ratio_x;
+
+            const source_x0 = max2(Math.ceil(center_x - range2_x), 0);
+            const source_x1 = min2(Math.floor(center_x + range2_x), source_width - 1);
+
+            let z = 0;
+            // reset sample
+            for (i = 0; i < item_size; i++) {
+                sample[i] = 0;
+            }
+
+            for (j = source_y0; j <= source_y1; j++) {
+
+                const f_y = (j - center_y);
+
+                const f_y_rcp2 = f_y * f_y;
+
+                for (i = source_x0; i <= source_x1; i++) {
+
+                    const f_x = (i - center_x);
+
+                    const f_x_rcp2 = f_x * f_x;
+
+                    const distance_from_center_sqr = f_x_rcp2 + f_y_rcp2;
+                    const distance_from_center = Math.sqrt(distance_from_center_sqr);
+
+                    const lanczos_weight = lanczos(distance_from_center, lobes);
+
+                    if (lanczos_weight <= 0) {
+                        continue;
+                    }
+
+                    z += lanczos_weight;
+
+                    const source_texel_address = (j * source_width + i) * item_size;
+
+                    for (k = 0; k < item_size; k++) {
+                        sample[k] += lanczos_weight * source_data[source_texel_address + k];
+                    }
+
+                }
+            }
+
+
+            // dilute sample and write to destination
+            const inv_z = 1 / z;
+
+            const texel_address = (v * d_w + u) * item_size;
+
+            for (i = 0; i < item_size; i++) {
+                destination_data[texel_address + i] = sample[i] * inv_z;
+            }
+        }
+    }
+
+}

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

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { downsampleSampler2D } from "./downsampleSampler2D.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,10 +29,10 @@ export function scaleSampler2D(input, output) {
         // downscaling
         if (Number.isInteger(sourceWidth / targetWidth) && Number.isInteger(sourceHeight / targetHeight)) {
             // dimensions are multiples of source/target
-            downsampleSampler2D(input, output);
+            sampler2D_scale_down_linear(input, output);
         } else {
             // generic downsample
-            genericResampleSampler2D(input, output);
+            genericResampleSampler2D(input, output, 3);
         }
     } else if (sourceWidth < targetWidth && sourceHeight < targetHeight) {
         // upscaling

package/engine/graphics/texture/sampler/writeSampler2DDataToDataTexture.js

@@ -3,7 +3,7 @@ import { LuminanceFormat, RedFormat, RGBAFormat, RGBFormat, RGFormat } from "thr
 /**
  *
  * @param {Sampler2D} sampler
- * @param {DataTexture} texture
+ * @param {THREE.DataTexture} texture
  */
 export function writeSample2DDataToDataTexture(sampler, texture) {
     if (sampler.itemSize === 1) {

package/engine/graphics/util/ScaleObject3ToBox.js

@@ -13,6 +13,19 @@ export function scaleObject3ToBox(object, size, result) {
 
     const boundingBox = new Box3();
 
+    object.traverse(a => {
+        if (a.isMesh) {
+            /**
+             * @type {THREE.BufferGeometry}
+             */
+            const geometry = a.geometry;
+
+            if (geometry.boundingBox === null) {
+                geometry.computeBoundingBox();
+            }
+        }
+    });
+
     boundingBox.expandByObject(object);
 
     //box size
@@ -22,4 +35,4 @@ export function scaleObject3ToBox(object, size, result) {
     result.set(scale, scale, scale);
 
     return actualBoxSize.multiplyScalar(scale);
-}
+}

package/engine/graphics/util/makeMeshPreviewScene.js

@@ -11,6 +11,7 @@ import { rootObject3DFastMatrixUpdate } from "../ecs/mesh/rootObject3DFastMatrix
 import { computeMeshPreviewCameraDistance } from "./computeMeshPreviewCameraDistance.js";
 import { scaleObject3ToBox } from "./ScaleObject3ToBox.js";
 import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
+import AABB2 from "../../../core/geom/AABB2.js";
 
 /**
  *
@@ -19,7 +20,7 @@ import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
  * @param {AABB2} focus
  * @returns {{scene: Scene, camera: PerspectiveCamera}}
  */
-export function makeMeshPreviewScene(mesh, size, focus) {
+export function makeMeshPreviewScene(mesh, size, focus = new AABB2(0, 0, size.x, size.y)) {
     const scene = new ThreeScene();
 
     //lights