@woosh/meep-engine 2.49.9 → 2.50.0

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

@@ -0,0 +1,183 @@
+import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
+import { Sampler2D } from "../Sampler2D.js";
+import { randomIntegerBetween } from "../../../../../core/math/random/randomIntegerBetween.js";
+import { computeUnsignedDistanceField } from "./computeUnsignedDistanceField.js";
+
+test('empty', () => {
+    const source = Sampler2D.uint8(1, 0, 0);
+    const target = Sampler2D.uint8(1, 0, 0);
+
+    computeUnsignedDistanceField(source, target, 0);
+});
+
+test('1 pixel empty source', () => {
+    const source = Sampler2D.uint8(1, 1, 1);
+    const target = Sampler2D.uint8(1, 1, 1);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(255);
+});
+
+test('1 pixel filled source', () => {
+    const source = Sampler2D.uint8(1, 1, 1);
+    source.set(0, 0, [255]);
+
+    const target = Sampler2D.uint8(1, 1, 1);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(0);
+});
+
+test('3x3 pixel source with filled middle', () => {
+    const source = Sampler2D.uint8(1, 3, 3);
+    source.set(1, 1, [255]);
+
+    const target = Sampler2D.uint8(1, 3, 3);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(1);
+    expect(target.readChannel(1, 0, 0)).toBe(1);
+    expect(target.readChannel(2, 0, 0)).toBe(1);
+
+    expect(target.readChannel(0, 1, 0)).toBe(1);
+    expect(target.readChannel(1, 1, 0)).toBe(0);
+    expect(target.readChannel(2, 1, 0)).toBe(1);
+
+    expect(target.readChannel(0, 2, 0)).toBe(1);
+    expect(target.readChannel(1, 2, 0)).toBe(1);
+    expect(target.readChannel(2, 2, 0)).toBe(1);
+});
+
+test('3x3 pixel source with empty middle', () => {
+    const source = Sampler2D.uint8(1, 3, 3);
+    source.data.fill(255);
+    source.set(1, 1, [0]);
+
+    const target = Sampler2D.uint8(1, 3, 3);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(0);
+    expect(target.readChannel(1, 0, 0)).toBe(0);
+    expect(target.readChannel(2, 0, 0)).toBe(0);
+
+    expect(target.readChannel(0, 1, 0)).toBe(0);
+    expect(target.readChannel(1, 1, 0)).toBe(1);
+    expect(target.readChannel(2, 1, 0)).toBe(0);
+
+    expect(target.readChannel(0, 2, 0)).toBe(0);
+    expect(target.readChannel(1, 2, 0)).toBe(0);
+    expect(target.readChannel(2, 2, 0)).toBe(0);
+});
+
+test('3x3 pixel source with empty corners', () => {
+    const source = Sampler2D.uint8(1, 3, 3);
+    source.data.fill(255);
+    source.set(0, 0, [0]);
+    source.set(2, 0, [0]);
+    source.set(0, 2, [0]);
+    source.set(2, 2, [0]);
+
+    const target = Sampler2D.uint8(1, 3, 3);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(1);
+    expect(target.readChannel(1, 0, 0)).toBe(0);
+    expect(target.readChannel(2, 0, 0)).toBe(1);
+
+    expect(target.readChannel(0, 1, 0)).toBe(0);
+    expect(target.readChannel(1, 1, 0)).toBe(0);
+    expect(target.readChannel(2, 1, 0)).toBe(0);
+
+    expect(target.readChannel(0, 2, 0)).toBe(1);
+    expect(target.readChannel(1, 2, 0)).toBe(0);
+    expect(target.readChannel(2, 2, 0)).toBe(1);
+});
+
+test('3x3 pixel source with filled corners', () => {
+    const source = Sampler2D.uint8(1, 3, 3);
+    source.data.fill(0);
+    source.set(0, 0, [255]);
+    source.set(2, 0, [255]);
+    source.set(0, 2, [255]);
+    source.set(2, 2, [255]);
+
+    const target = Sampler2D.uint8(1, 3, 3);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(0);
+    expect(target.readChannel(1, 0, 0)).toBe(1);
+    expect(target.readChannel(2, 0, 0)).toBe(0);
+
+    expect(target.readChannel(0, 1, 0)).toBe(1);
+    expect(target.readChannel(1, 1, 0)).toBe(1);
+    expect(target.readChannel(2, 1, 0)).toBe(1);
+
+    expect(target.readChannel(0, 2, 0)).toBe(0);
+    expect(target.readChannel(1, 2, 0)).toBe(1);
+    expect(target.readChannel(2, 2, 0)).toBe(0);
+});
+
+test('3x1 pixel source with 1 filled corner', () => {
+    const source = Sampler2D.uint8(1, 3, 1);
+    source.data.fill(0);
+    source.set(0, 0, [255]);
+
+    const target = Sampler2D.uint8(1, 3, 1);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(0);
+    expect(target.readChannel(1, 0, 0)).toBe(1);
+    expect(target.readChannel(2, 0, 0)).toBe(2);
+});
+
+test('3x3 pixel source with 1 filled corner', () => {
+    const source = Sampler2D.uint8(1, 3, 3);
+    source.data.fill(0);
+    source.set(0, 0, [255]);
+
+    const target = Sampler2D.uint8(1, 3, 3);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(0);
+    expect(target.readChannel(1, 0, 0)).toBe(1);
+    expect(target.readChannel(2, 0, 0)).toBe(2);
+
+    expect(target.readChannel(0, 1, 0)).toBe(1);
+    expect(target.readChannel(1, 1, 0)).toBe(1);
+    expect(target.readChannel(2, 1, 0)).toBe(2);
+
+    expect(target.readChannel(0, 2, 0)).toBe(2);
+    expect(target.readChannel(1, 2, 0)).toBe(2);
+    expect(target.readChannel(2, 2, 0)).toBe(2);
+});
+
+test.skip('performance', () => {
+
+    const sizeX = 100;
+    const sizeY = 100;
+
+    const source = Sampler2D.uint8(1, sizeX, sizeY);
+
+    const random = seededRandom(42);
+    source.data.fill(0);
+    for (let i = 0; i < source.data.length * 0.1; i++) {
+        const x = randomIntegerBetween(random, 0, sizeX);
+        const y = randomIntegerBetween(random, 0, sizeY);
+        source.set(x, y, [255]);
+    }
+
+    const target = Sampler2D.uint8(1, sizeX, sizeY);
+
+    console.time('p');
+    computeUnsignedDistanceField(source, target, 0);
+    console.timeEnd('p');
+
+});

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

@@ -0,0 +1,133 @@
+import { max2 } from "../../../../../core/math/max2.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 {number} maxD highest value that distance field can hold
+ */
+export function computeUnsignedDistanceField_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;
+
+    let x, y, i, v;
+
+    //initialize distance field
+    const dataSize = height * width;
+    for (i = 0; i < dataSize; i++) {
+        if (sourceData[i] !== emptyValue) {
+            distanceFieldData[i] = 0;
+        } else {
+            distanceFieldData[i] = maxD;
+        }
+    }
+
+    //first pass (forward)
+    for (y = 0; y < height; y++) {
+
+        const y_m1 = max2(y - 1, 0);
+
+        const y_w = y * width;
+
+        const y_m1_w = y_m1 * width;
+
+        for (x = 0; x < width; x++) {
+
+            i = y_w + x;
+
+            v = distanceFieldData[i];
+
+            const x_m1 = max2(x - 1, 0);
+            const x_p1 = min2(x + 1, maxX);
+
+            const v0_i = x_m1 + y_m1_w;
+            const v0 = distanceFieldData[v0_i] + d2;
+
+            if (v0 < v) {
+                distanceFieldData[i] = v0;
+                v = v0;
+            }
+
+            const v1_i = x + y_m1_w;
+            const v1 = distanceFieldData[v1_i] + d1;
+
+            if (v1 < v) {
+                distanceFieldData[i] = v1;
+                v = v1;
+            }
+
+            const v2_i = x_p1 + y_m1_w;
+            const v2 = distanceFieldData[v2_i] + d2;
+
+            if (v2 < v) {
+                distanceFieldData[i] = v2;
+                v = v2;
+            }
+
+            const v3_i = x_m1 + y_w;
+            const v3 = distanceFieldData[v3_i] + d1;
+
+            if (v3 < v) {
+                distanceFieldData[i] = v3;
+            }
+        }
+    }
+
+    //second pass (backward)
+    for (y = maxY; y >= 0; y--) {
+        const y_w = y * width;
+
+        const y_p1 = min2(y + 1, maxY);
+        const y_p1_w = y_p1 * width;
+
+        for (x = maxX; x >= 0; x--) {
+            const x_p1 = min2(x + 1, maxX);
+            const x_m1 = max2(x - 1, 0);
+
+            i = y_w + x;
+
+            v = distanceFieldData[i];
+
+            const v0_i = x_p1 + y_w;
+            const v0 = distanceFieldData[v0_i] + d1;
+
+            if (v0 < v) {
+                distanceFieldData[i] = v0;
+                v = v0;
+            }
+
+            const v1_i = x_m1 + y_p1_w;
+            const v1 = distanceFieldData[v1_i] + d2;
+
+            if (v1 < v) {
+                distanceFieldData[i] = v1;
+                v = v1;
+            }
+
+            const v2_i = x + y_p1_w;
+            const v2 = distanceFieldData[v2_i] + d1;
+
+            if (v2 < v) {
+                distanceFieldData[i] = v2;
+                v = v2;
+            }
+
+            const v3_i = x_p1 + y_p1_w;
+            const v3 = distanceFieldData[v3_i] + d2;
+
+            if (v3 < v) {
+                distanceFieldData[i] = v3;
+            }
+        }
+    }
+}

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

@@ -1,3 +1,5 @@
+import { assert } from "../../../../../core/assert.js";
+
 const b = 1.0 / 3.0;
 const c = 1.0 / 3.0;
 
@@ -33,6 +35,7 @@ export function mitchell(x) {
     }
     return 0.0;
 }
+
 mitchell.support = 2;
 
 /**
@@ -42,6 +45,7 @@ mitchell.support = 2;
  * @returns {number}
  */
 export function mitchell_v1(x) {
+    assert.greaterThanOrEqual(x, 0);
 
     if (x < 1.0) {
         return 0.8888888888888888 + x * x * (-2 + x * 1.1666666666666667);

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

@@ -14,7 +14,9 @@ import { GameAssetType } from "../../../asset/GameAssetType.js";
 export default function loadSampler2D(url, assetManager) {
     return new Promise(function (resolve, reject) {
         assetManager.get({
-            path: url, type: GameAssetType.Image, callback: (asset) => {
+            path: url,
+            type: GameAssetType.Image,
+            callback: (asset) => {
                 const imageData = asset.create();
 
                 const width = imageData.width;
@@ -32,7 +34,8 @@ export default function loadSampler2D(url, assetManager) {
                 }
                 const sampler2D = new Sampler2D(buffer, 1, width, height);
                 resolve(sampler2D);
-            }, failure: reject
+            },
+            failure: reject
         });
     });
 };

package/src/engine/graphics/texture/sampler/resize/sampler2d_downsample_mipmap.js

@@ -44,12 +44,15 @@ export function sampler2d_downsample_mipmap(source, destination) {
     const m0_sx = (current_mip.width + 1) / (current_mip.width);
     const m0_sy = (current_mip.height + 1) / (current_mip.height);
 
+    const destination_v_scale = dest_height > 1 ? 1 / (dest_height - 1) : 0;
+    const destination_u_scale = dest_width > 1 ? 1 / (dest_width - 1) : 0;
+
     for (let y = 0; y < dest_height; y++) {
-        const v = y / (dest_height - 1);
+        const v = y * destination_v_scale;
 
         for (let x = 0; x < dest_width; x++) {
 
-            const u = x / (dest_width - 1);
+            const u = x * destination_u_scale;
 
             for (let i = 0; i < itemSize; i++) {
 
@@ -58,7 +61,9 @@ export function sampler2d_downsample_mipmap(source, destination) {
 
                 const c_out = lerp(c0, c1, mip_mix);
 
-                destination.data[(y * dest_width + x) * itemSize + i] = c_out;
+                const destination_address = (y * dest_width + x) * itemSize + i;
+
+                destination.data[destination_address] = c_out;
             }
         }
     }

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

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

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

@@ -0,0 +1,58 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {number[]|Float32Array|Uint8Array|Uint32Array} result
+ * @param {number} result_offset
+ * @param {Sampler2D} sampler
+ * @param {number} [channel]
+ * @return {number}
+ */
+export function sampler2d_channel_compute_min_indices(
+    result, result_offset,
+    sampler, channel = 0
+) {
+    assert.defined(sampler, 'sampler');
+    assert.isNonNegativeInteger(result_offset, 'result_offset');
+
+    const itemSize = sampler.itemSize;
+
+    assert.isNumber(channel, "channel");
+    assert.isNonNegativeInteger(channel, '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.isArrayLike(result, "result");
+
+    const data = this.data;
+
+    const l = data.length;
+
+    if (l === 0) {
+        //no data
+        return 0;
+    }
+
+    let bestValue = data[channel];
+
+    let result_count = 0;
+
+    for (let i = channel + itemSize; i < l; i += itemSize) {
+        const value = data[i];
+
+        if (bestValue > value) {
+            bestValue = value;
+            //drop result
+            result_count = 1;
+
+            result[result_offset] = i;
+        } else if (value === bestValue) {
+            result[result_offset + result_count] = i;
+
+            result_count++;
+        }
+
+    }
+
+    return result_count;
+}

package/src/engine/graphics/trail/TemporalPath.js

@@ -59,33 +59,6 @@ TemporalPath.prototype.update = function (timeDelta) {
     this.updateSequence();
 };
 
-
-/**
- *
- * @param {number} t value between 0..1, falls between points p1 and p2
- * @param {number[]} p0
- * @param {number[]} p1
- * @param {number[]} p2
- * @param {number[]} p3
- * @param {number[]} result
- */
-function catmullRomSample(t, p0, p1, p2, p3, result) {
-
-    for (let j = 0; j < 4; j++) {
-        const v0 = p0[j];
-        const v1 = p1[j];
-        const v2 = p2[j];
-        const v3 = p3[j];
-
-        const t2 = t * t;
-        const t3 = t2 * t;
-
-        const qT = 0.5 * (2 * v1 + (v2 - v0) * t + (2 * v0 - 5 * v1 + 4 * v2 - v3) * t2 + (3 * v1 - v0 - 3 * v2 + v3) * t3);
-
-        result[j] = qT;
-    }
-}
-
 /**
  * @returns {number}
  */
@@ -133,15 +106,6 @@ TemporalPath.prototype.computeLength = function () {
     return result;
 };
 
-/**
- *
- * @param {number} sampleCount
- * @param {Float32Array} result
- */
-TemporalPath.prototype.sampleSmoothPath = function (sampleCount, result) {
-
-};
-
 /**
  *
  * @param {number} x

package/src/engine/intelligence/behavior/composite/ParallelBehavior.spec.js

@@ -21,7 +21,7 @@ test("1 succeeding child", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Succeeded);
+    expect(p.tick(1)).toBe(BehaviorStatus.Succeeded);
 
     p.finalize();
 
@@ -43,8 +43,8 @@ test("1 succeeding child, 1 tick delay", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Running);
-    expect(p.tick()).toBe(BehaviorStatus.Succeeded);
+    expect(p.tick(1)).toBe(BehaviorStatus.Running);
+    expect(p.tick(1)).toBe(BehaviorStatus.Succeeded);
 
     p.finalize();
 
@@ -66,7 +66,7 @@ test("1 failing child", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Failed);
+    expect(p.tick(1)).toBe(BehaviorStatus.Failed);
 
     p.finalize();
 
@@ -88,8 +88,8 @@ test("1 failing child, 1 tick delay", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Running);
-    expect(p.tick()).toBe(BehaviorStatus.Failed);
+    expect(p.tick(1)).toBe(BehaviorStatus.Running);
+    expect(p.tick(1)).toBe(BehaviorStatus.Failed);
 
     p.finalize();
 
@@ -111,7 +111,7 @@ test("policy success-One, failure-One. Succeeding", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Succeeded);
+    expect(p.tick(1)).toBe(BehaviorStatus.Succeeded);
 });
 
 test("policy success-All, failure-One. Succeeding", () => {
@@ -127,8 +127,8 @@ test("policy success-All, failure-One. Succeeding", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Running);
-    expect(p.tick()).toBe(BehaviorStatus.Succeeded);
+    expect(p.tick(1)).toBe(BehaviorStatus.Running);
+    expect(p.tick(1)).toBe(BehaviorStatus.Succeeded);
 });
 
 test("policy success-One, failure-One. Failing", () => {
@@ -144,7 +144,7 @@ test("policy success-One, failure-One. Failing", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Failed);
+    expect(p.tick(1)).toBe(BehaviorStatus.Failed);
 });
 
 test("policy success-One, failure-All. Failing", () => {
@@ -160,6 +160,6 @@ test("policy success-One, failure-All. Failing", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Running);
-    expect(p.tick()).toBe(BehaviorStatus.Failed);
+    expect(p.tick(1)).toBe(BehaviorStatus.Running);
+    expect(p.tick(1)).toBe(BehaviorStatus.Failed);
 });

package/src/engine/intelligence/behavior/composite/SequenceBehavior.spec.js

@@ -0,0 +1,17 @@
+import { SequenceBehavior } from "./SequenceBehavior.js";
+import { SucceedingBehavior } from "../primitive/SucceedingBehavior.js";
+import { BehaviorStatus } from "../BehaviorStatus.js";
+
+test("constructor does not throw", () => {
+    expect(() => new SequenceBehavior()).not.toThrow();
+});
+
+test("succeed in 1 tick with 1 succeeding child", () => {
+
+    const b = SequenceBehavior.from([new SucceedingBehavior()]);
+
+    b.initialize();
+
+    expect(b.tick(1)).toEqual(BehaviorStatus.Succeeded);
+
+});

package/src/engine/intelligence/behavior/primitive/SucceedingBehavior.js

@@ -36,6 +36,8 @@ export class SucceedingBehavior extends Behavior {
             return BehaviorStatus.Running;
         }
     }
+
+    static INSTANCE = new SucceedingBehavior();
 }
 
 SucceedingBehavior.typeName = "SucceedingBehavior";

package/src/engine/knowledge/database/StaticKnowledgeDataTable.d.ts

@@ -1,3 +1,9 @@
-export class StaticKnowledgeDataTable {
+export class StaticKnowledgeDataTable<T> {
+    reset(): void
 
+    size(): number
+
+    get(id: string): T | null
+
+    add(item: T): boolean
 }

package/src/engine/knowledge/database/StaticKnowledgeDataTable.spec.js

@@ -3,3 +3,24 @@ import { StaticKnowledgeDataTable } from "./StaticKnowledgeDataTable.js";
 test("constructor does not throw", () => {
     expect(() => new StaticKnowledgeDataTable()).not.toThrow();
 });
+
+test("resetting empty works as expected", () => {
+    const table = new StaticKnowledgeDataTable();
+
+    table.reset();
+
+    expect(table.size()).toEqual(0);
+});
+
+test("getter", () => {
+
+    const table = new StaticKnowledgeDataTable();
+
+    expect(table.get("x")).toEqual(null);
+
+    const item = { id: "x" };
+
+    table.add(item);
+
+    expect(table.get('x')).toBe(item);
+});

package/src/engine/knowledge/database/StaticKnowledgeDataTableDescriptor.d.ts

@@ -1,7 +1,7 @@
 import {StaticKnowledgeDataTable} from "./StaticKnowledgeDataTable";
 
-export class StaticKnowledgeDataTableDescriptor {
-    public table: StaticKnowledgeDataTable
+export class StaticKnowledgeDataTableDescriptor<T> {
+    public table: StaticKnowledgeDataTable<T>
     public id: string
     public source: string
 }

package/src/engine/logging/ConsoleLoggerBackend.js

@@ -3,6 +3,10 @@ import { LogLevel } from "./LogLevel.js";
 
 let instance;
 
+/**
+ * Directs output into system console
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/console
+ */
 export class ConsoleLoggerBackend extends LoggerBackend {
     log(level, message) {
         switch (level) {

package/src/engine/logging/VoidLoggerBackend.js

@@ -0,0 +1,12 @@
+import { LoggerBackend } from "./LoggerBackend.js";
+
+/**
+ * Non-logging backend, used for testing or when log collection is unwanted
+ */
+export class VoidLoggerBackend extends LoggerBackend {
+    log(level, message) {
+        // do nothing
+    }
+
+    static INSTANCE = new VoidLoggerBackend()
+}