@woosh/meep-engine 2.50.2 → 2.51.0

package/src/engine/graphics/texture/sampler/filter/mitchell_v1.js

@@ -0,0 +1,21 @@
+import { assert } from "../../../../../core/assert.js";
+
+/**
+ * Hand-optimized mitchell function with c = 0.3333333 and b = 0.3333333
+ * NOTE: assumes non-negative values only
+ * @param {number} x
+ * @returns {number}
+ */
+export function mitchell_v1(x) {
+    assert.greaterThanOrEqual(x, 0);
+
+    if (x < 1.0) {
+        return 0.8888888888888888 + x * x * (-2 + x * 1.1666666666666667);
+    }
+    if (x < 2.0) {
+        return 1.7777777777777777 + x * (-3.3333333333333335 + x * (2 + x * -0.3888888888888889));
+    }
+    return 0.0;
+}
+
+mitchell_v1.support = 2;

package/src/engine/graphics/texture/sampler/filter/sampler2d_scale_down_generic.js

@@ -3,27 +3,30 @@ import { min2 } from "../../../../../core/math/min2.js";
 
 /**
  *
- * @param {Sampler2D} source
- * @param {Sampler2D} destination
+ * @param {Sampler2D} input
+ * @param {Sampler2D} output
  * @param {(number)=>number|{support:number}} weight_computer
  * @param {number} support size of support kernel
  */
-export function sampler2d_scale_down_generic(source, destination, weight_computer, support = weight_computer.support) {
+export function sampler2d_scale_down_generic(
+    input, output,
+    weight_computer, support = weight_computer.support
+) {
 
-    const d_w = destination.width;
-    const d_h = destination.height;
+    const d_w = output.width;
+    const d_h = output.height;
 
-    const item_size = destination.itemSize;
+    const item_size = output.itemSize;
 
-    const source_width = source.width;
-    const source_height = source.height;
+    const source_width = input.width;
+    const source_height = input.height;
 
     if (source_width < d_w || source_height < d_h) {
         throw new Error('Invalid scale, source is larger than destination in at least 1 dimension');
     }
 
-    const source_data = source.data;
-    const destination_data = destination.data;
+    const source_data = input.data;
+    const destination_data = output.data;
 
     const ratio_x = source_width / d_w;
     const ratio_y = source_height / d_h;
@@ -35,7 +38,7 @@ export function sampler2d_scale_down_generic(source, destination, weight_compute
     const range2_x = Math.ceil(ratio_x * support / 2);
     const range2_y = Math.ceil(ratio_y * support / 2);
 
-    const sample = new Array(item_size);
+    const sample = new Float64Array(item_size);
 
     let v, u, i, j, k;
 
@@ -55,11 +58,6 @@ export function sampler2d_scale_down_generic(source, destination, weight_compute
             const source_x1 = min2(i_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);
@@ -102,6 +100,9 @@ export function sampler2d_scale_down_generic(source, destination, weight_compute
 
             for (i = 0; i < item_size; i++) {
                 destination_data[texel_address + i] = sample[i] * inv_z;
+
+                // reset sample for next tap
+                sample[i] = 0;
             }
         }
     }

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

@@ -2,20 +2,22 @@ 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 { filter_lanczos3, sampler2D_scale_down_lanczos } from "./sampler2_d_scale_down_lanczos.js";
+import { sampler2d_scale_down_lanczos } from "./resize/sampler2d_scale_down_lanczos.js";
 import { Sampler2D } from "./Sampler2D.js";
-import { genericResampleSampler2D } from "./genericResampleSampler2D.js";
+import { sampler2d_scale_generic } from "./resize/sampler2d_scale_generic.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
 import LabelView from "../../../../view/common/LabelView.js";
 import EmptyView from "../../../../view/elements/EmptyView.js";
-import { sampler2d_downsample_mipmap } from "./resize/sampler2d_downsample_mipmap.js";
+import { sampler2d_scale_down_mipmap } from "./resize/sampler2d_scale_down_mipmap.js";
 import { kaiser_bessel_window } from "./filter/kaiser_bessel_window.js";
 import { sampler2d_scale_down_generic } from "./filter/sampler2d_scale_down_generic.js";
-import { mitchell, mitchell_v1 } from "./filter/mitchell.js";
+import { mitchell } from "./filter/mitchell.js";
 import { kaiser_1 } from "./filter/kaiser_1.js";
 import { triangle } from "./filter/triangle.js";
 import { box } from "./filter/box.js";
 import { gaussian } from "./filter/gaussian.js";
+import { mitchell_v1 } from "./filter/mitchell_v1.js";
+import { filter_lanczos3 } from "./filter/filter_lanczos3.js";
 
 function grid({ engine, input, transforms, size = new Vector2(input.width, input.height), display_labels = true }) {
 
@@ -158,7 +160,7 @@ new EngineHarness().initialize({
 
     // sampler2D_lanczos(source, small);
     console.time('filter');
-    sampler2D_scale_down_lanczos(source, small, 3);
+    sampler2d_scale_down_lanczos(source, small, 3);
     console.timeEnd('filter');
 
     display(engine, small, COMPARE_X_OFFSET, 0);
@@ -170,7 +172,7 @@ new EngineHarness().initialize({
 
     const small_scale_2 = Sampler2D.uint8(source.itemSize, TARGET_WIDTH, TARGET_HEIGHT);
     console.time('filter-generic');
-    genericResampleSampler2D(source, small_scale_2);
+    sampler2d_scale_generic(source, small_scale_2);
     console.timeEnd('filter-generic');
     display(engine, small_scale_2, COMPARE_X_OFFSET, TARGET_HEIGHT);
 })
@@ -251,7 +253,7 @@ function test_sampling(source, engine) {
                 params.label = 'mip';
 
 
-                sampler2d_downsample_mipmap(input, out);
+                sampler2d_scale_down_mipmap(input, out);
 
             },
             (out, input, params) => {
@@ -261,7 +263,7 @@ function test_sampling(source, engine) {
 
                 // return;
 
-                sampler2D_scale_down_lanczos(input, out, lobes);
+                sampler2d_scale_down_lanczos(input, out, lobes);
 
             },
             (out, input, params) => {
@@ -283,7 +285,7 @@ function test_sampling(source, engine) {
 
                 return;
 
-                sampler2D_scale_down_lanczos(input, out, lobes);
+                sampler2d_scale_down_lanczos(input, out, lobes);
 
             },
             (out, input, params) => {

package/src/engine/graphics/texture/sampler/{scaleSampler2D.js → resize/sampler2d_scale.js}

@@ -1,15 +1,15 @@
-import { assert } from "../../../../core/assert.js";
+import { assert } from "../../../../../core/assert.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";
+import { Sampler2D } from "../Sampler2D.js";
+import { sampler2d_scale_up_linear } from "./sampler2d_scale_up_linear.js";
+import { sampler2d_scale_generic } from "./sampler2d_scale_generic.js";
 
 /**
  *
  * @param {Sampler2D} input
  * @param {Sampler2D} output
  */
-export function scaleSampler2D(input, output) {
+export function sampler2d_scale(input, output) {
     assert.equal(input.isSampler2D, true, 'input.isSampler2D !== true');
     assert.equal(output.isSampler2D, true, 'output.isSampler2D !== true');
 
@@ -32,13 +32,13 @@ export function scaleSampler2D(input, output) {
             sampler2d_scale_down_linear(input, output);
         } else {
             // generic downsample
-            genericResampleSampler2D(input, output, 3);
+            sampler2d_scale_generic(input, output);
         }
     } else if (sourceWidth < targetWidth && sourceHeight < targetHeight) {
         // upscaling
-        upsampleSampler2D(input, output);
+        sampler2d_scale_up_linear(input, output);
     } else {
         // mixed resampling
-        genericResampleSampler2D(input, output);
+        sampler2d_scale_generic(input, output);
     }
 }

package/src/engine/graphics/texture/sampler/resize/sampler2d_scale.spec.js

@@ -0,0 +1,73 @@
+import { Sampler2D } from "../Sampler2D.js";
+import { sampler2d_scale } from "./sampler2d_scale.js";
+
+test("scale 1:1", () => {
+
+    const input = new Sampler2D(new Uint8Array([17]), 1, 1, 1);
+    const output = new Sampler2D(new Uint8Array([3]), 1, 1, 1);
+
+    sampler2d_scale(input, output);
+
+    expect(output.readChannel(0, 0, 0)).toEqual(17);
+});
+
+test("scale up 1x1 to 2x2", () => {
+    const input = new Sampler2D([7], 1, 1, 1);
+    const output = new Sampler2D([1, 2, 3, 4], 1, 2, 2);
+
+    sampler2d_scale(input, output);
+
+    expect(output.readChannel(0, 0, 0)).toBe(7);
+    expect(output.readChannel(1, 0, 0)).toBe(7);
+    expect(output.readChannel(0, 1, 0)).toBe(7);
+    expect(output.readChannel(1, 1, 0)).toBe(7);
+});
+
+test("scale up 1x1 to 3x1", () => {
+    const input = new Sampler2D([7], 1, 1, 1);
+    const output = new Sampler2D([1, 2, 3], 1, 3, 1);
+
+    sampler2d_scale(input, output);
+
+    expect(output.readChannel(0, 0, 0)).toBe(7);
+    expect(output.readChannel(1, 0, 0)).toBe(7);
+    expect(output.readChannel(2, 0, 0)).toBe(7);
+});
+
+test("scale up 1x1 to 1x3", () => {
+    const input = new Sampler2D([7], 1, 1, 1);
+    const output = new Sampler2D([1, 2, 3], 1, 1, 3);
+
+    sampler2d_scale(input, output);
+
+    expect(output.readChannel(0, 0, 0)).toBe(7);
+    expect(output.readChannel(0, 1, 0)).toBe(7);
+    expect(output.readChannel(0, 2, 0)).toBe(7);
+});
+
+test("scale down 2x2 to 1x1", () => {
+    const output = new Sampler2D([7], 1, 1, 1);
+    const input = new Sampler2D([1, 2, 3, 4], 1, 2, 2);
+
+    sampler2d_scale(input, output);
+
+    expect(output.readChannel(0, 0, 0)).toBeCloseTo(2.5);
+});
+
+test("scale down 3x1 to 1x1", () => {
+    const output = new Sampler2D([7], 1, 1, 1);
+    const input = new Sampler2D([1, 2, 3], 1, 3, 1);
+
+    sampler2d_scale(input, output);
+
+    expect(output.readChannel(0, 0, 0)).toBeCloseTo(2);
+});
+
+test("scale down 1x3 to 1x1", () => {
+    const output = new Sampler2D([7], 1, 1, 1);
+    const input = new Sampler2D([1, 2, 3], 1, 1, 3);
+
+    sampler2d_scale(input, output);
+
+    expect(output.readChannel(0, 0, 0)).toBeCloseTo(2);
+});

package/src/engine/graphics/texture/sampler/{sampler2_d_scale_down_lanczos.js → resize/sampler2d_scale_down_lanczos.js}

@@ -1,5 +1,5 @@
-import { max2 } from "../../../../core/math/max2.js";
-import { min2 } from "../../../../core/math/min2.js";
+import { max2 } from "../../../../../core/math/max2.js";
+import { min2 } from "../../../../../core/math/min2.js";
 
 
 /**
@@ -63,27 +63,6 @@ function lanczos_orig(x, lobes) {
     return (lobes * Math.sin(Math.PI * x) * Math.sin(Math.PI * x / lobes)) / (Math.PI * Math.PI * x * x);
 }
 
-export function filter_lanczos3(x) {
-    // assume the input is positive
-
-    // if (x < 0) {
-    //     x = -x;
-    // }
-
-    if (x > 3) {
-        return 0;
-    }
-
-    if (x < 1.1920929e-7) {
-        return 1;
-    }
-
-    return (3 * Math.sin(Math.PI * x) * Math.sin(Math.PI * x / 3)) / (Math.PI * Math.PI * x * x);
-
-}
-
-filter_lanczos3.support = 3;
-
 
 /**
  * Good for down-sampling
@@ -91,7 +70,7 @@ filter_lanczos3.support = 3;
  * @param {Sampler2D} destination
  * @param {number} [lobes]
  */
-export function sampler2D_scale_down_lanczos(source, destination, lobes = 2) {
+export function sampler2d_scale_down_lanczos(source, destination, lobes = 2) {
 
     const d_w = destination.width;
     const d_h = destination.height;

package/src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_lanczos.spec.js

@@ -0,0 +1,29 @@
+import { sampler2d_scale_down_lanczos } from "./sampler2d_scale_down_lanczos.js";
+import { Sampler2D } from "../Sampler2D.js";
+
+test("scale down 2x2 to 1x1 single channel", () => {
+    const input = new Sampler2D([1, 2, 3, 4], 1, 2, 2);
+    const output = new Sampler2D([7], 1, 1, 1);
+
+    sampler2d_scale_down_lanczos(input, output);
+
+    expect(output.readChannel(0, 0, 0)).toBeCloseTo(2.5);
+});
+
+test("scale down 3x1 to 1x1", () => {
+    const input = new Sampler2D([1, 2, 3], 1, 3, 1);
+    const output = new Sampler2D([7], 1, 1, 1);
+
+    sampler2d_scale_down_lanczos(input, output);
+
+    expect(output.readChannel(0, 0, 0)).toBeCloseTo(2);
+});
+
+test("scale down 1x3 to 1x1", () => {
+    const input = new Sampler2D([1, 2, 3], 1, 1, 3);
+    const output = new Sampler2D([7], 1, 1, 1);
+
+    sampler2d_scale_down_lanczos(input, output);
+
+    expect(output.readChannel(0, 0, 0)).toBeCloseTo(2);
+});

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

@@ -1,4 +1,4 @@
-import { assert } from "../../../../core/assert.js";
+import { assert } from "../../../../../core/assert.js";
 
 /**
  *
@@ -6,8 +6,8 @@ import { assert } from "../../../../core/assert.js";
  * @param {Sampler2D} output
  */
 export function sampler2d_scale_down_linear(input, output) {
-    assert.notEqual(input, undefined, 'input is undefined');
-    assert.notEqual(output, undefined, 'output is undefined');
+    assert.defined(input, 'input');
+    assert.defined(output, 'output');
 
     const iW = input.width;
     const iH = input.height;
@@ -21,8 +21,8 @@ export function sampler2d_scale_down_linear(input, output) {
 
     assert.equal(input.itemSize, output.itemSize, `input.itemSize(=${input.itemSize}) is not equal to output.itemSize(=${output.itemSize})`);
 
-    assert.ok(Number.isInteger(sW), `x scale must be an integer, instead was ${sW}`);
-    assert.ok(Number.isInteger(sH), `y scale must be an integer, instead was ${sH}`);
+    assert.notNaN(sW, "x scale");
+    assert.notNaN(sH, "y scale");
 
     assert.ok(sW >= 1, `x scale must be positive, instead was ${sW}`);
     assert.ok(sH >= 1, `y scale must be positive, instead was ${sH}`);

package/src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_linear.spec.js

@@ -0,0 +1,44 @@
+import { Sampler2D } from "../Sampler2D.js";
+import { sampler2d_scale_down_linear } from "./sampler2d_scale_down_linear.js";
+
+test('2x2 -> 1x1, 2 channels', () => {
+    const input = Sampler2D.float32(2, 2, 2);
+    const output = Sampler2D.float32(2, 1, 1);
+
+    input.set(0, 0, [1, 3]);
+    input.set(1, 0, [5, 7]);
+    input.set(0, 1, [11, 13]);
+    input.set(1, 1, [17, 19]);
+
+    sampler2d_scale_down_linear(input, output);
+
+    expect(output.data[0]).toEqual(8.5);
+    expect(output.data[1]).toEqual(10.5);
+});
+
+test("scale down 2x2 to 1x1 single channel", () => {
+    const output = new Sampler2D([7], 1, 1, 1);
+    const input = new Sampler2D([1, 2, 3, 4], 1, 2, 2);
+
+    sampler2d_scale_down_linear(input, output);
+
+    expect(output.readChannel(0, 0, 0)).toBeCloseTo(2.5);
+});
+
+test("scale down 3x1 to 1x1", () => {
+    const output = new Sampler2D([7], 1, 1, 1);
+    const input = new Sampler2D([1, 2, 3], 1, 3, 1);
+
+    sampler2d_scale_down_linear(input, output);
+
+    expect(output.readChannel(0, 0, 0)).toBeCloseTo(2);
+});
+
+test("scale down 1x3 to 1x1", () => {
+    const output = new Sampler2D([7], 1, 1, 1);
+    const input = new Sampler2D([1, 2, 3], 1, 1, 3);
+
+    sampler2d_scale_down_linear(input, output);
+
+    expect(output.readChannel(0, 0, 0)).toBeCloseTo(2);
+});

package/src/engine/graphics/texture/sampler/resize/{sampler2d_downsample_mipmap.js → sampler2d_scale_down_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";
 
@@ -8,7 +8,7 @@ import { lerp } from "../../../../../core/math/lerp.js";
  * @param {Sampler2D} source
  * @param {Sampler2D} destination
  */
-export function sampler2d_downsample_mipmap(source, destination) {
+export function sampler2d_scale_down_mipmap(source, destination) {
     let current_mip = source;
     let previous_mip = source;
 

package/src/engine/graphics/texture/sampler/resize/{sampler2d_downsample_mipmap.spec.js → sampler2d_scale_down_mipmap.spec.js}

@@ -1,5 +1,5 @@
 import { Sampler2D } from "../Sampler2D.js";
-import { sampler2d_downsample_mipmap } from "./sampler2d_downsample_mipmap.js";
+import { sampler2d_scale_down_mipmap } from "./sampler2d_scale_down_mipmap.js";
 
 test("downsample solid fill from 2x2 to 1x1", () => {
     const input = Sampler2D.uint8(1, 2, 2);
@@ -7,7 +7,7 @@ test("downsample solid fill from 2x2 to 1x1", () => {
     input.data.fill(7);
 
     const result = Sampler2D.uint8(1, 1, 1);
-    sampler2d_downsample_mipmap(input, result);
+    sampler2d_scale_down_mipmap(input, result);
 
     expect(result.readChannel(0, 0, 0)).toBeCloseTo(7)
 });

package/src/engine/graphics/texture/sampler/{genericResampleSampler2D.js → resize/sampler2d_scale_generic.js}

@@ -1,18 +1,22 @@
-import { max2 } from "../../../../core/math/max2.js";
+import { max2 } from "../../../../../core/math/max2.js";
+import { assert } from "../../../../../core/assert.js";
 
 /**
- *
- * @param {Sampler2D} source
- * @param {Sampler2D} target
+ * Relatively slow, but handles all cases
+ * @param {Sampler2D} input
+ * @param {Sampler2D} output
  */
-export function genericResampleSampler2D(source, target) {
-    const target_width = target.width;
-    const target_height = target.height;
+export function sampler2d_scale_generic(input, output) {
+    assert.defined(input, 'input');
+    assert.defined(output, 'output');
+
+    const target_width = output.width;
+    const target_height = output.height;
 
     // build kernel
 
-    const u_scale = source.width / target_width;
-    const v_scale = source.height / target_height;
+    const u_scale = input.width / target_width;
+    const v_scale = input.height / target_height;
 
     const kernel_width = max2(1, Math.ceil(u_scale));
     const kernel_height = max2(1, Math.ceil(v_scale));
@@ -20,7 +24,7 @@ export function genericResampleSampler2D(source, target) {
     const kernel_size = kernel_width * kernel_height;
     const kernel_size_inv = 1 / kernel_size;
 
-    const itemSize = source.itemSize;
+    const itemSize = input.itemSize;
 
     const sample = new Float32Array(itemSize);
 
@@ -47,7 +51,7 @@ export function genericResampleSampler2D(source, target) {
                 for (k_x = 0; k_x < kernel_width; k_x++) {
 
                     for (i = 0; i < itemSize; i++) {
-                        sample[i] += source.sampleChannelBilinear(source_x + k_x, source_y + k_y, i);
+                        sample[i] += input.sampleChannelBilinear(source_x + k_x, source_y + k_y, i);
                     }
 
                 }
@@ -55,7 +59,7 @@ export function genericResampleSampler2D(source, target) {
 
             for (i = 0; i < itemSize; i++) {
                 // dilute sample
-                target.data[output_texel_address + i] = sample[i] * kernel_size_inv;
+                output.data[output_texel_address + i] = sample[i] * kernel_size_inv;
 
                 //reset sample
                 sample[i] = 0;

package/src/engine/graphics/texture/sampler/{upsampleSampler2D.js → resize/sampler2d_scale_up_linear.js}

@@ -1,11 +1,14 @@
-import { assert } from "../../../../core/assert.js";
+import { assert } from "../../../../../core/assert.js";
 
 /**
  *
  * @param {Sampler2D} input
  * @param {Sampler2D} output
  */
-export function upsampleSampler2D(input, output) {
+export function sampler2d_scale_up_linear(input, output) {
+    assert.defined(input, 'input');
+    assert.defined(output, 'output');
+
     const targetItemSize = output.itemSize;
 
     assert.equal(input.itemSize, targetItemSize, 'both source and target must have the same number of channels');

package/src/engine/graphics/texture/sampler/resize/sampler2d_scale_up_linear.spec.js

@@ -0,0 +1,14 @@
+import { sampler2d_scale_up_linear } from "./sampler2d_scale_up_linear.js";
+import { Sampler2D } from "../Sampler2D.js";
+
+test("scale up 1x1 to 2x2", () => {
+    const input = new Sampler2D([7], 1, 1, 1);
+    const output = new Sampler2D([1, 2, 3, 4], 1, 2, 2);
+
+    sampler2d_scale_up_linear(input, output);
+
+    expect(output.readChannel(0, 0, 0)).toBe(7);
+    expect(output.readChannel(1, 0, 0)).toBe(7);
+    expect(output.readChannel(0, 1, 0)).toBe(7);
+    expect(output.readChannel(1, 1, 0)).toBe(7);
+});

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

@@ -24,7 +24,7 @@ export function sampler2d_channel_compute_min_indices(
 
     assert.isArrayLike(result, "result");
 
-    const data = this.data;
+    const data = sampler.data;
 
     const l = data.length;
 
@@ -35,7 +35,9 @@ export function sampler2d_channel_compute_min_indices(
 
     let bestValue = data[channel];
 
-    let result_count = 0;
+    result[result_offset] = 0;
+
+    let result_count = 1;
 
     for (let i = channel + itemSize; i < l; i += itemSize) {
         const value = data[i];

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

@@ -0,0 +1,15 @@
+import { sampler2d_channel_compute_min_indices } from "./sampler2d_channel_compute_min_indices.js";
+import { Sampler2D } from "./Sampler2D.js";
+
+test("sanity", () => {
+    const result = [];
+
+    const index_count = sampler2d_channel_compute_min_indices(
+        result, 0,
+        new Sampler2D([1, 2], 1, 2, 1),
+        0
+    );
+
+    expect(index_count).toEqual(1);
+    expect(result).toEqual([0]);
+});

package/src/engine/graphics/texture/sampler/util/drawSamplerHTML.js

@@ -1,5 +1,5 @@
 import { Sampler2D } from "../Sampler2D.js";
-import { scaleSampler2D } from "../scaleSampler2D.js";
+import { sampler2d_scale } from "../resize/sampler2d_scale.js";
 import convertSampler2D2Canvas from "../Sampler2D2Canvas.js";
 import { typedArrayConstructorByInstance } from "../typedArrayConstructorByInstance.js";
 
@@ -31,7 +31,7 @@ export function drawSamplerHTML(parentNode, sampler, x, y, scale, offset, size)
 
     const target = new Sampler2D(new TA(target_width * target_height * sampler.itemSize), sampler.itemSize, target_width, target_height);
 
-    scaleSampler2D(sampler, target);
+    sampler2d_scale(sampler, target);
 
     const c = convertSampler2D2Canvas(target, scale, offset);
     c.style.zIndex = 1000;

package/src/engine/graphics/three/expand_aabb_by_transformed_three_object.js

@@ -0,0 +1,66 @@
+import { ensureGeometryBoundingBox } from "../util/ensureGeometryBoundingBox.js";
+import { aabb3_matrix4_project } from "../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
+import { aabb3_array_combine } from "../../../core/geom/3d/aabb/aabb3_array_combine.js";
+import { m4_multiply } from "../../../core/geom/3d/matrix/m4_multiply.js";
+
+const scratch_aabb3_array_0 = new Float32Array(6);
+const scratch_aabb3_array_1 = new Float32Array(6);
+
+/**
+ *
+ * @param {number[]|Float32Array} result
+ * @param {Object3D} object
+ * @param {number[]|Float32Array} transform
+ */
+export function expand_aabb_by_transformed_three_object(result, object, transform) {
+
+    /**
+     * @type {BufferGeometry}
+     */
+    const geometry = object.geometry;
+
+    if (geometry !== undefined) {
+
+        ensureGeometryBoundingBox(geometry);
+
+        const gbb = geometry.boundingBox;
+
+        const min = gbb.min;
+
+        const x0 = min.x;
+        const y0 = min.y;
+        const z0 = min.z;
+
+        const max = gbb.max;
+
+        const x1 = max.x;
+        const y1 = max.y;
+        const z1 = max.z;
+
+        scratch_aabb3_array_0[0] = x0;
+        scratch_aabb3_array_0[1] = y0;
+        scratch_aabb3_array_0[2] = z0;
+
+        scratch_aabb3_array_0[3] = x1;
+        scratch_aabb3_array_0[4] = y1;
+        scratch_aabb3_array_0[5] = z1;
+
+        aabb3_matrix4_project(scratch_aabb3_array_1, scratch_aabb3_array_0, transform);
+
+        aabb3_array_combine(result, result, scratch_aabb3_array_1);
+    }
+
+    const children = object.children;
+    const child_count = children.length;
+
+    for (let i = 0; i < child_count; i++) {
+        const child_matrix = new Float32Array(16);
+
+        const child = children[i];
+
+        m4_multiply(child_matrix, transform, child.matrix.elements)
+
+        expand_aabb_by_transformed_three_object(result, child, child_matrix);
+    }
+
+}