@woosh/meep-engine 2.49.9 → 2.50.1

package/src/engine/graphics/sh3/path_tracer/make_sky_hosek.js

@@ -3,7 +3,7 @@ import {
     sky_hosek_precompute
 } from "../sky/hosek/sky_hosek_compute_irradiance_by_direction.js";
 import { vec3 } from "gl-matrix";
-import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { max2 } from "../../../../core/math/max2.js";
 
 export function make_sky_hosek(sun = [0, 1, 0], turbidity = 1, overcast = 0, albedo = [0, 0, 0]) {

package/src/engine/graphics/sh3/prototypeSH3Probe.js

@@ -19,7 +19,7 @@ import { Transform } from "../../ecs/transform/Transform.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
 import { is_typed_array_equals } from "../../../core/collection/array/typed/is_typed_array_equals.js";
-import { array_copy } from "../../../core/collection/array/copyArray.js";
+import { array_copy } from "../../../core/collection/array/array_copy.js";
 import { randomFloatBetween } from "../../../core/math/random/randomFloatBetween.js";
 import { GLTFAssetLoader } from "../../asset/loaders/GLTFAssetLoader.js";
 import { three_object_to_entity_composition } from "../ecs/mesh-v2/three_object_to_entity_composition.js";

package/src/engine/graphics/texture/3d/scs3d_read_2d_slice.js

@@ -1,4 +1,4 @@
-import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
 
 /**
  *

package/src/engine/graphics/texture/CanvasClone.js

@@ -3,7 +3,11 @@
  */
 
 
-
+/**
+ *
+ * @param {HTMLCanvasElement} oldCanvas
+ * @return {HTMLCanvasElement}
+ */
 function cloneCanvas(oldCanvas) {
 
     //create a new canvas

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

@@ -92,50 +92,14 @@ export class Sampler2D {
     }
 
     /**
+     * @deprecated
      * @param {number[]} result
+     * @param {number} result_offset
      * @param {number} [channel=0]
+     * @returns {number} number of matches written to result array
      */
-    computeMinIndices(result, 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}`);
-
-        assert.ok(Array.isArray(result), "result is not an array");
-
-        const data = this.data;
-
-        const l = data.length;
-
-        if (l === 0) {
-            //no data
-            return;
-        }
-
-        let bestValue = data[channel];
-
-        let resultCount = 0;
-
-        for (let i = channel + itemSize; i < l; i += itemSize) {
-            const value = data[i];
-
-            if (bestValue > value) {
-                bestValue = value;
-                //drop result
-                resultCount = 1;
-
-                result[0] = i;
-            } else if (value === bestValue) {
-                result[resultCount++] = i;
-            }
-
-        }
-
-        //crop results
-        if (resultCount < result.length) {
-            result.splice(resultCount, result.length - resultCount);
-        }
+    computeMinIndices(result, result_offset = 0, channel = 0) {
+        throw new Error("deprecated, use sampler2d_channel_compute_min_indices")
     }
 
     /**
@@ -410,7 +374,7 @@ export class Sampler2D {
      *
      * @param {number} x
      * @param {number} y
-     * @param {number[]} result
+     * @param {number[]|Float32Array|Float64Array} result
      * @param {number} result_offset
      */
     sampleBilinear(x, y, result, result_offset = 0) {
@@ -446,6 +410,12 @@ export class Sampler2D {
      * @returns {number}
      */
     sampleChannelBilinear(x, y, channel) {
+        assert.isNumber(x, 'x');
+        assert.notNaN(x, 'x');
+
+        assert.isNumber(y, 'y');
+        assert.notNaN(y, 'y');
+
         assert.isNonNegativeInteger(channel, 'channel');
 
         const itemSize = this.itemSize;
@@ -548,6 +518,7 @@ export class Sampler2D {
         assert.isNumber(channel, "channel");
 
         assert.isNonNegativeInteger(channel, 'channel');
+        assert.lessThanOrEqual(channel, this.itemSize);
 
         const index = (y * this.width + x) * this.itemSize + channel;
 
@@ -933,6 +904,7 @@ export class Sampler2D {
 
     /**
      * Fill data values with zeros for a given area
+     * Specialized version of `fill` method, optimized for speed
      * @param {Number} x
      * @param {Number} y
      * @param {Number} width
@@ -1205,39 +1177,6 @@ export class Sampler2D {
         throw new Error('Deprecated, use Sampler2DSerializationAdapter instead');
     }
 
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {function(x:number, y:number, value:number, index:number):boolean?} visitor
-     * @param {*} [thisArg]
-     */
-    traverseOrthogonalNeighbours(x, y, visitor, thisArg) {
-        const width = this.width;
-        const height = this.height;
-
-        const index = this.point2index(x, y);
-
-        let i = 0;
-        const data = this.data;
-        if (x > 0) {
-            i = index - 1;
-            visitor.call(thisArg, x - 1, y, data[i], i);
-        }
-        if (x < width - 1) {
-            i = index + 1;
-            visitor.call(thisArg, x + 1, y, data[i], i);
-        }
-        if (y > 0) {
-            i = index - width;
-            visitor.call(thisArg, x, y - 1, data[i], i);
-        }
-        if (y < height - 1) {
-            i = index + width;
-            visitor.call(thisArg, x, y + 1, data[i], i);
-        }
-    }
-
     /**
      *
      * @param {Sampler2D} other

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

@@ -1,24 +1,24 @@
 /**
  * @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 {*}
+ * @param {number} xf
+ * @param {number} yf
+ * @param {number} p00
+ * @param {number} p01
+ * @param {number} p02
+ * @param {number} p03
+ * @param {number} p10
+ * @param {number} p11
+ * @param {number} p12
+ * @param {number} p13
+ * @param {number} p20
+ * @param {number} p21
+ * @param {number} p22
+ * @param {number} p23
+ * @param {number} p30
+ * @param {number} p31
+ * @param {number} p32
+ * @param {number} p33
+ * @returns {number}
  */
 export function bicubic(
     xf, yf

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

@@ -0,0 +1,10 @@
+import { convertSampler2D2DataURL } from "./convertSampler2D2DataURL.js";
+import { Sampler2D } from "./Sampler2D.js";
+
+// currently does not run in Node.js context due to reliance on HTMLCanvasElement that is absent in Node.js
+test.skip("result is a data URL", () => {
+    const result = convertSampler2D2DataURL(Sampler2D.uint8(4, 1, 1));
+
+    expect(typeof result).toBe('string');
+    expect(result.startsWith("data://")).toBe(true);
+});

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

@@ -0,0 +1,90 @@
+import { copy_Sampler2D_channel_data } from "./copy_Sampler2D_channel_data.js";
+import { Sampler2D } from "./Sampler2D.js";
+
+test("should throw when dimensions do not match", () => {
+    expect(() => copy_Sampler2D_channel_data(
+        Sampler2D.uint8(1, 1, 1),
+        Sampler2D.uint8(1, 2, 1),
+    )).toThrow();
+
+    expect(() => copy_Sampler2D_channel_data(
+        Sampler2D.uint8(1, 2, 1),
+        Sampler2D.uint8(1, 1, 1),
+    )).toThrow();
+
+    expect(() => copy_Sampler2D_channel_data(
+        Sampler2D.uint8(1, 1, 2),
+        Sampler2D.uint8(1, 1, 1),
+    )).toThrow();
+
+    expect(() => copy_Sampler2D_channel_data(
+        Sampler2D.uint8(1, 1, 1),
+        Sampler2D.uint8(1, 1, 2),
+    )).toThrow();
+
+    expect(() => copy_Sampler2D_channel_data(
+        Sampler2D.uint8(1, 2, 2),
+        Sampler2D.uint8(1, 1, 1),
+    )).toThrow();
+
+    expect(() => copy_Sampler2D_channel_data(
+        Sampler2D.uint8(1, 1, 1),
+        Sampler2D.uint8(1, 2, 2),
+    )).toThrow();
+});
+
+test("channel counts match", () => {
+    const source = Sampler2D.uint8(1, 1, 1);
+    source.writeChannel(0, 0, 0, 7);
+
+    const target = Sampler2D.uint8(1, 1, 1);
+
+    copy_Sampler2D_channel_data(source, target);
+
+    expect(target.readChannel(0, 0, 0)).toEqual(7);
+});
+
+test("from 2 channels to 1", () => {
+
+    const source = Sampler2D.uint8(2, 1, 1);
+    source.writeChannel(0, 0, 0, 7);
+    source.writeChannel(0, 0, 1, 13);
+
+    const target = Sampler2D.uint8(1, 1, 1);
+
+    copy_Sampler2D_channel_data(source, target);
+
+    expect(target.readChannel(0, 0, 0)).toEqual(7);
+});
+
+test("from 3 channels to 4", () => {
+
+    const source = Sampler2D.uint8(3, 1, 1);
+    source.set(0, 0, [3, 7, 13]);
+
+    const target = Sampler2D.uint8(4, 1, 1);
+
+    copy_Sampler2D_channel_data(source, target);
+
+    const sample = [];
+
+    target.read(0, 0, sample);
+
+    expect(sample).toEqual([3, 7, 13, 255]);
+});
+
+test("from 2 channels to 4", () => {
+
+    const source = Sampler2D.uint8(2, 1, 1);
+    source.set(0, 0, [3, 7]);
+
+    const target = Sampler2D.uint8(4, 1, 1);
+
+    copy_Sampler2D_channel_data(source, target);
+
+    const sample = [];
+
+    target.read(0, 0, sample);
+
+    expect(sample).toEqual([3, 3, 3, 7]);
+});

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

@@ -1,5 +1,6 @@
-import Vector4 from "../../../../core/geom/Vector4.js";
 import { Sampler2D } from "./Sampler2D.js";
+import { vector_nd_normalize } from "../../../../core/math/vector_nd_normalize.js";
+import { vector_nd_dot } from "../../../../core/math/vector_nd_dot.js";
 
 /**
  *
@@ -8,8 +9,10 @@ import { Sampler2D } from "./Sampler2D.js";
  * @returns {Sampler2D}
  */
 export function differenceSampler(sampler0, sampler1) {
-    let v0 = new Vector4();
-    let v1 = new Vector4();
+    const dimension_count = sampler0.itemSize;
+
+    const v0 = new Float64Array(dimension_count);
+    const v1 = new Float64Array(dimension_count);
     //
     const width = sampler0.width;
     const height = sampler0.height;
@@ -17,12 +20,14 @@ export function differenceSampler(sampler0, sampler1) {
     const difference = new Float32Array(width * height);
     for (let y = 0; y < height; y++) {
         for (let x = 0; x < width; x++) {
-            v0 = sampler0.get(x, y, v0);
-            v1 = sampler1.get(x, y, v1);
-            v0.normalize();
-            v1.normalize();
+            sampler0.sampleBilinear(x, y, v0);
+            sampler1.sampleBilinear(x, y, v1);
+
+            vector_nd_normalize(v0, v0, dimension_count);
+            vector_nd_normalize(v1, v1, dimension_count);
+
             //check distance
-            difference[x + y * width] = 1 - v0.dot(v1);
+            difference[x + y * width] = 1 - vector_nd_dot(v0, v1, dimension_count);
         }
     }
     //

package/src/engine/graphics/texture/sampler/distance/computeSignedDistanceField_Chamfer.js

@@ -0,0 +1,140 @@
+import { clamp } from "../../../../../core/math/clamp.js";
+import { min2 } from "../../../../../core/math/min2.js";
+
+/**
+ * algorithm proposed by Borgefors, Chamfer distance [J. ACM 15 (1968) 600, Comput. Vis. Graph. Image Process. 34 (1986) 344], h
+ * @param {Sampler2D} source
+ * @param {Sampler2D} distanceField
+ * @param {number} emptyValue
+ * @param {number} d1 distance between two adjacent pixels in either x or y direction
+ * @param {number} d2 distance between two diagonally adjacent pixels
+ * @param maxD
+ */
+export function computeSignedDistanceField_Chamfer(source, distanceField, emptyValue, d1, d2, maxD) {
+    const sourceData = source.data;
+    const distanceFieldData = distanceField.data;
+
+    const width = source.width;
+    const height = source.height;
+
+    const maxX = width - 1;
+    const maxY = height - 1;
+
+    function getS(x, y) {
+        x = clamp(x, 0, maxX);
+        y = clamp(y, 0, maxY);
+
+        const index = x + y * width;
+
+        return sourceData[index];
+    }
+
+    function getD(x, y) {
+        x = clamp(x, 0, maxX);
+        y = clamp(y, 0, maxY);
+
+        const index = x + y * width;
+
+        return distanceFieldData[index];
+    }
+
+    function setD(x, y, v) {
+        x = clamp(x, 0, maxX);
+        y = clamp(y, 0, maxY);
+
+        const index = x + y * width;
+
+        distanceFieldData[index] = min2(v, maxD);
+    }
+
+    let x, y;
+
+    //initialize distance field
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            if (
+                getS(x - 1, y) !== getS(x, y)
+                || getS(x + 1, y) !== getS(x, y)
+                || getS(x, y - 1) !== getS(x, y)
+                || getS(x, y + 1) !== getS(x, y)
+            ) {
+                setD(x, y, 0);
+            } else {
+                setD(x, y, 255);
+            }
+        }
+    }
+
+    //first pass (forward)
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+
+            const v = getD(x, y);
+
+            const v0 = getD(x - 1, y - 1) + d2;
+
+            if (v0 < v) {
+                setD(x, y, v0);
+            }
+
+            const v1 = getD(x, y - 1) + d1;
+
+            if (v1 < v) {
+                setD(x, y, v1);
+            }
+
+            const v2 = getD(x + 1, y - 1) + d2;
+
+            if (v2 < v) {
+                setD(x, y, v2);
+            }
+
+            const v3 = getD(x - 1, y) + d1;
+
+            if (v3 < v) {
+                setD(x, y, v3);
+            }
+        }
+    }
+
+    //second pass (backward)
+    for (y = maxY; y >= 0; y--) {
+        for (x = maxX; x >= 0; x--) {
+            const v = getD(x, y);
+
+            const v0 = getD(x + 1, y) + d1;
+
+            if (v0 < v) {
+                setD(x, y, v0);
+            }
+
+            const v1 = getD(x - 1, y + 1) + d2;
+
+            if (v1 < v) {
+                setD(x, y, v1);
+            }
+
+            const v2 = getD(x, y + 1) + d1;
+
+            if (v2 < v) {
+                setD(x, y, v2);
+            }
+
+            const v3 = getD(x + 1, y + 1) + d2;
+
+            if (v3 < v) {
+                setD(x, y, v3);
+            }
+        }
+    }
+
+    //indicate inside & outside
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            if (getS(x, y) !== emptyValue) {
+                //inside
+                setD(x, y, -getD(x, y));
+            }
+        }
+    }
+}

package/src/engine/graphics/texture/sampler/distance/computeSignedDistanceField_NaiveFlood.js

@@ -0,0 +1,130 @@
+import { assert } from "../../../../../core/assert.js";
+import { BitSet } from "../../../../../core/binary/BitSet.js";
+
+/**
+ * Naive flood implementation of a distance field computation algorithm
+ * @author Alex Goldring Dec 2018
+ * @param {Sampler2D} source
+ * @param {Sampler2D} destination
+ * @param {number} emptyValue
+ */
+export function computeSignedDistanceField_NaiveFlood(source, destination, emptyValue) {
+    assert.equal(source.itemSize, 1, `unsupported source.itemSize, expected 1, got '${source.itemSize}'`);
+    assert.typeOf(emptyValue, 'number', 'emptyValue');
+
+    let i, j;
+
+    const distanceData = destination.data;
+
+    const visited = new BitSet();
+
+    const openSet = new BitSet();
+
+    //use "flood" algorithm
+
+    //mark all visible tiles as visited
+    const samplerData = source.data;
+    const totalCellCount = samplerData.length;
+
+    function traverseNeighbours(index, visitor) {
+        let i = index - (width + 1);
+
+        const top = index > width;
+        const bottom = index < (totalCellCount - width);
+
+        const x = index % width;
+
+        const left = x > 0;
+        const right = x < width - 1;
+
+        if (top) {
+            if (left) {
+                visitor(i);
+            }
+
+            visitor(i + 1);
+
+            if (right) {
+                visitor(i + 2);
+            }
+        }
+
+        i += width;
+
+        if (left) {
+            visitor(i);
+        }
+
+        if (right) {
+            visitor(i + 2);
+        }
+
+        i += width;
+
+        if (bottom) {
+            if (left) {
+                visitor(i);
+            }
+
+            visitor(i + 1);
+
+            if (right) {
+                visitor(i + 2);
+            }
+        }
+
+    }
+
+    const width = destination.width;
+
+    for (i = 0; i < totalCellCount; i++) {
+        const sampleValue = samplerData[i];
+        if (sampleValue !== emptyValue) {
+            visited.set(i, true);
+            //write distance data
+            distanceData[i] = 0;
+        } else {
+            distanceData[i] = 255;
+        }
+    }
+
+    //populate initial open set
+    for (i = visited.nextSetBit(0); i !== -1; i = visited.nextSetBit(i + 1)) {
+        j = 0;
+        traverseNeighbours(i, function (neighbourIndex) {
+            if (!visited.get(neighbourIndex)) {
+                //increment number of not visited
+                j++;
+            }
+        });
+
+        if (j === 0) {
+            //all neighbours are visited, we can safely ignore this cell
+        } else {
+            openSet.set(i, true);
+        }
+    }
+
+    for (i = openSet.nextSetBit(0); i !== -1; i = openSet.nextSetBit(0)) {
+        //remove from open set
+        openSet.set(i, false);
+
+        const value = distanceData[i];
+
+        traverseNeighbours(i, function (neighbourIndex) {
+            const neighbourValue = value + 1;
+
+            if (visited.get(neighbourIndex)) {
+                if (distanceData[neighbourIndex] <= neighbourValue) {
+                    return;
+                }
+            } else {
+                visited.set(neighbourIndex, true);
+            }
+
+            distanceData[neighbourIndex] = neighbourValue;
+            //add neighbour to open set
+            openSet.set(neighbourIndex, true);
+        });
+    }
+}

package/src/engine/graphics/texture/sampler/distance/computeUnsignedDistanceField.js

@@ -0,0 +1,10 @@
+import { computeUnsignedDistanceField_Chamfer } from "./computeUnsignedDistanceField_Chamfer.js";
+
+/**
+ * @param {Sampler2D} source
+ * @param {Sampler2D} distanceField
+ * @param {number} emptyValue
+ */
+export function computeUnsignedDistanceField(source, distanceField, emptyValue) {
+    computeUnsignedDistanceField_Chamfer(source, distanceField, emptyValue, 1, 1, 255);
+}