@woosh/meep-engine 2.33.76 → 2.34.0

package/core/collection/Set.js

@@ -4,7 +4,6 @@
 
 
 import Signal from "../events/signal/Signal.js";
-import { strictEquals } from "../function/Functions.js";
 
 /**
  * Structure with event signals for observing changes.
@@ -165,64 +164,4 @@ class Set {
 }
 
 
-/**
- * @template T
- * @param {T[]} array
- * @param {T} element
- * @param {function(a:T,b:T):boolean} equals
- * @returns {number}
- */
-export function arrayIndexByEquality(array, element, equals) {
-    const n = array.length;
-
-    for (let i = 0; i < n; i++) {
-        const el = array[i];
-
-        if (equals(element, el)) {
-            return i;
-        }
-    }
-
-    return -1;
-}
-
-/**
- * @template T
- * @param {T[]} a
- * @param {T[]} b
- * @param {function(a:T,b:T):boolean} [equals]
- * @returns {{uniqueA:T[], uniqueB:T[], common:T[]}}
- */
-export function arraySetDiff(a, b, equals = strictEquals) {
-    const uniqueA = a.slice();
-    const uniqueB = b.slice();
-
-    const common = [];
-
-    let lA = uniqueA.length;
-
-    let i;
-    for (i = 0; i < lA; i++) {
-        const elA = uniqueA[i];
-
-        const j = arrayIndexByEquality(uniqueB, elA, equals);
-
-        if (j !== -1) {
-            common.push(elA);
-
-            uniqueA.splice(i, 1);
-            uniqueB.splice(j, 1);
-
-            i--;
-            lA--;
-        }
-    }
-
-    return {
-        uniqueA,
-        uniqueB,
-        common
-    };
-}
-
 export default Set;

package/core/collection/array/arrayIndexByEquality.js

@@ -0,0 +1,20 @@
+/**
+ * @template T
+ * @param {T[]} array
+ * @param {T} element
+ * @param {function(a:T,b:T):boolean} equals
+ * @returns {number}
+ */
+export function arrayIndexByEquality(array, element, equals) {
+    const n = array.length;
+
+    for (let i = 0; i < n; i++) {
+        const el = array[i];
+
+        if (equals(element, el)) {
+            return i;
+        }
+    }
+
+    return -1;
+}

package/core/collection/array/arraySetDiff.js

@@ -0,0 +1,42 @@
+import { strictEquals } from "../../function/Functions.js";
+import { arrayIndexByEquality } from "./arrayIndexByEquality.js";
+
+/**
+ * @template T
+ * @param {T[]} a
+ * @param {T[]} b
+ * @param {function(a:T,b:T):boolean} [equals]
+ * @returns {{uniqueA:T[], uniqueB:T[], common:T[]}}
+ */
+export function arraySetDiff(a, b, equals = strictEquals) {
+    const uniqueA = a.slice();
+    const uniqueB = b.slice();
+
+    const common = [];
+
+    let lA = uniqueA.length;
+
+    let i;
+    for (i = 0; i < lA; i++) {
+        const elA = uniqueA[i];
+
+        const j = arrayIndexByEquality(uniqueB, elA, equals);
+
+        if (j !== -1) {
+            common.push(elA);
+
+            uniqueA.splice(i, 1);
+            uniqueB.splice(j, 1);
+
+            i--;
+            lA--;
+        }
+    }
+
+    return {
+        uniqueA,
+        uniqueB,
+        common
+    };
+}
+

package/core/collection/array/arraySetSortingDiff.js

@@ -0,0 +1,67 @@
+import { assert } from "../../assert.js";
+
+//
+
+/**
+ * Based on 2-way merge algorith from wiki: https://en.wikipedia.org/wiki/K-way_merge_algorithm
+ * @template T
+ * @param {T[]} a
+ * @param {T[]} b
+ * @param {function(a:T,b:T):number} [compare]
+ * @returns {{uniqueA:T[], uniqueB:T[], common:T[]}}
+ */
+export function arraySetSortingDiff(a, b, compare) {
+    assert.isFunction(compare, 'compare');
+
+    const uniqueA = a.slice();
+    const uniqueB = b.slice();
+
+    // sort both a and b
+    uniqueA.sort(compare);
+    uniqueB.sort(compare);
+
+    const common = [];
+
+    let lA = uniqueA.length;
+    let lB = uniqueB.length;
+
+    let i;
+    let j;
+    let cursor_j = 0;
+
+    for (i = 0; i < lA; i++) {
+        const el_a = uniqueA[i];
+
+        for (j = cursor_j; j < lB; j++) {
+            const el_b = uniqueB[j];
+
+            const diff = compare(el_a, el_b);
+
+            if (diff === 0) {
+                common.push(el_a);
+
+                uniqueA.splice(i, 1);
+                uniqueB.splice(j, 1);
+
+                i--;
+                j--;
+
+                lA--;
+                lB--;
+
+            } else if (diff > 0) {
+                cursor_j++;
+            } else {
+                // too far
+                break;
+            }
+        }
+
+    }
+
+    return {
+        uniqueA,
+        uniqueB,
+        common
+    };
+}

package/core/collection/array/arraySetSortingDiff.spec.js

@@ -0,0 +1,74 @@
+import { arraySetSortingDiff } from "./arraySetSortingDiff.js";
+import { compareNumbers } from "../../primitives/numbers/compareNumbers.js";
+
+test('two empty inputs', () => {
+    expect(arraySetSortingDiff([], [], compareNumbers)).toEqual({
+        uniqueA: [],
+        uniqueB: [],
+        common: []
+    });
+});
+
+test('[] and [1] inputs', () => {
+    expect(arraySetSortingDiff([], [1], compareNumbers)).toEqual({
+        uniqueA: [],
+        uniqueB: [1],
+        common: []
+    });
+});
+
+test('[1] and [] inputs', () => {
+    expect(arraySetSortingDiff([1], [], compareNumbers)).toEqual({
+        uniqueA: [1],
+        uniqueB: [],
+        common: []
+    });
+});
+
+test('[1] and [1] inputs', () => {
+    expect(arraySetSortingDiff([1], [1], compareNumbers)).toEqual({
+        uniqueA: [],
+        uniqueB: [],
+        common: [1]
+    });
+});
+
+test('[1] and [1,2] inputs', () => {
+    expect(arraySetSortingDiff([1], [1, 2], compareNumbers)).toEqual({
+        uniqueA: [],
+        uniqueB: [2],
+        common: [1]
+    });
+});
+
+test('[1,2] and [1] inputs', () => {
+    expect(arraySetSortingDiff([1, 2], [1], compareNumbers)).toEqual({
+        uniqueA: [2],
+        uniqueB: [],
+        common: [1]
+    });
+});
+
+test('[5,4,3,2,1] and [1,2,3,4,5] inputs', () => {
+    expect(arraySetSortingDiff([5, 4, 3, 2, 1], [1, 2, 3, 4, 5], compareNumbers)).toEqual({
+        uniqueA: [],
+        uniqueB: [],
+        common: [1, 2, 3, 4, 5]
+    });
+});
+
+test('[5,1] and [1,2,3,4,5] inputs', () => {
+    expect(arraySetSortingDiff([5, 1], [1, 2, 3, 4, 5], compareNumbers)).toEqual({
+        uniqueA: [],
+        uniqueB: [2,3,4],
+        common: [1, 5]
+    });
+});
+
+test('[1,2,3,4,5] and [5,1] inputs', () => {
+    expect(arraySetSortingDiff([1, 2, 3, 4, 5], [5, 1], compareNumbers)).toEqual({
+        uniqueA: [2,3,4],
+        uniqueB: [],
+        common: [1, 5]
+    });
+});

package/core/collection/array/array_filter_by_multiple.js

@@ -0,0 +1,36 @@
+/**
+ * @template T
+ * @param {T[]} input_items
+ * @param {((T)=>boolean)[]} filters
+ * @return {T[]}
+ */
+export function array_filter_by_multiple(input_items, filters) {
+
+    const filter_count = filters.length;
+
+    if (filter_count === 0) {
+        // special case, no filters
+        return input_items;
+    }
+
+    const filtered = [];
+
+    const input_item_count = input_items.length;
+
+
+    main_loop:for (let i = 0; i < input_item_count; i++) {
+        const d = input_items[i];
+        for (let j = 0; j < filter_count; j++) {
+            const filter = filters[j];
+
+            if (filter(d) === false) {
+                continue main_loop;
+            }
+        }
+
+        // filters passed
+        filtered.push(d);
+    }
+
+    return filtered;
+}

package/core/collection/array/weightedRandomFromArray.js

@@ -3,7 +3,11 @@ import { compareNumbers } from "../../primitives/numbers/compareNumbers.js";
 import { binarySearchHighIndex } from "./binarySearchHighIndex.js";
 
 
-const weights = [];
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_weights = [];
 
 /**
  * @template T
@@ -16,8 +20,8 @@ const weights = [];
  */
 export function weightedRandomFromArray(array, random, weight, weightContext, length = array.length) {
     assert.isArray(array, 'array');
-    assert.typeOf(random, 'function', 'random');
-    assert.typeOf(weight, 'function', 'weight');
+    assert.isFunction(random, 'random');
+    assert.isFunction(weight, 'weight');
 
     if (length === 0) {
         return undefined;
@@ -36,12 +40,12 @@ export function weightedRandomFromArray(array, random, weight, weightContext, le
             weight_total += w;
         }
 
-        weights[i] = weight_total;
+        scratch_weights[i] = weight_total;
     }
 
     const target_weight = random() * weight_total;
 
-    const index = binarySearchHighIndex(weights, target_weight, compareNumbers, 0, length - 1);
+    const index = binarySearchHighIndex(scratch_weights, target_weight, compareNumbers, 0, length - 1);
 
     return array[index];
 }

package/core/collection/list/FilteredListProjection.js

@@ -1,7 +1,7 @@
 import { frameThrottle } from "../../../engine/graphics/FrameThrottle.js";
 import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
-import { arraySetDiff } from "../Set.js";
 import List from "./List.js";
+import { arraySetDiff } from "../array/arraySetDiff.js";
 
 export class FilteredListProjection {
     /**

package/core/collection/list/List.js

@@ -6,7 +6,8 @@
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
 import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
-import { arrayIndexByEquality, arraySetDiff } from "../Set.js";
+import { arraySetDiff } from "../array/arraySetDiff.js";
+import { arrayIndexByEquality } from "../array/arrayIndexByEquality.js";
 
 
 /**

package/core/geom/3d/topology/compareEdges.js

@@ -0,0 +1,16 @@
+import { compareVertices } from "./compareVertices.js";
+
+/**
+ *
+ * @param {TopoEdge} a
+ * @param {TopoEdge} b
+ * @returns {number}
+ */
+function compareEdges(a, b) {
+    const v0 = compareVertices(a.v0, b.v0);
+    if (v0 !== 0) {
+        return v0;
+    }
+
+    return compareVertices(a.v0, b.v0);
+}

package/core/geom/3d/topology/compareFaces.js

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {TopoTriangle} a
+ * @param {TopoTriangle} b
+ * @returns {number}
+ */
+export function compareFaces(a, b) {
+    return a.index - b.index;
+}

package/core/geom/3d/topology/compareVertices.js

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {TopoVertex} a
+ * @param {TopoVertex} b
+ * @returns {number}
+ */
+export function compareVertices(a, b) {
+    return a.index - b.index;
+}

package/core/geom/3d/topology/computeTopoMeshVertexDuplicates.js

@@ -7,7 +7,10 @@ import { mortonEncode_magicbits } from "../morton/mortonEncode_magicbits.js";
  * @param {TopoVertex} b
  */
 function isPositionEquivalent(a, b) {
-    return epsilonEquals(b.x, a.x, EPSILON) && epsilonEquals(b.y, a.y, EPSILON) && epsilonEquals(b.z, a.z, EPSILON);
+    return epsilonEquals(b.x, a.x, EPSILON)
+        && epsilonEquals(b.y, a.y, EPSILON)
+        && epsilonEquals(b.z, a.z, EPSILON)
+        ;
 }
 
 /**
@@ -31,8 +34,9 @@ function recordDuplicate(result, a, b) {
 /**
  *
  * @param {TopoMesh} mesh
+ * @param {AABB3} aabb
  */
-export function computeTopoMeshVertexDuplicates(mesh) {
+export function computeTopoMeshVertexDuplicates(mesh, aabb) {
     const vertices = mesh.vertices;
 
     const n = vertices.length;
@@ -46,11 +50,26 @@ export function computeTopoMeshVertexDuplicates(mesh) {
      */
     const result = new Map();
 
+    let i, j;
+
+    const x0 = aabb.x0;
+    const y0 = aabb.y0;
+    const z0 = aabb.z0;
+
+    // 10 bit quantization
+    const e_x = 1023 / aabb.getExtentsX();
+    const e_y = 1023 / aabb.getExtentsY();
+    const e_z = 1023 / aabb.getExtentsZ();
+
     //
-    for (let i = 0; i < n; i++) {
+    for (i = 0; i < n; i++) {
         const vertex_a = vertices[i];
 
-        const morton = mortonEncode_magicbits(vertex_a.x*1000, vertex_a.y*1000, vertex_a.z*1000);
+        const morton = mortonEncode_magicbits(
+            Math.round((vertex_a.x - x0) * e_x),
+            Math.round((vertex_a.y - y0) * e_y),
+            Math.round((vertex_a.z - z0) * e_z)
+        );
 
         let spatial_bucket = spatial_hash[morton];
         if (spatial_bucket === undefined) {
@@ -59,7 +78,7 @@ export function computeTopoMeshVertexDuplicates(mesh) {
         } else {
             // look at others in the bucket
             const bucket_size = spatial_bucket.length;
-            for (let j = 0; j < bucket_size; j++) {
+            for (j = 0; j < bucket_size; j++) {
                 /**
                  * @type {TopoVertex}
                  */
@@ -77,4 +96,4 @@ export function computeTopoMeshVertexDuplicates(mesh) {
     }
 
     return result;
-}
+}

package/core/geom/3d/topology/expandConnectivityByLocality.js

@@ -1,35 +1,46 @@
 import { array_copy } from "../../../collection/array/copyArray.js";
-import { arraySetDiff } from "../../../collection/Set.js";
 import { computeTopoMeshVertexDuplicates } from "./computeTopoMeshVertexDuplicates.js";
+import { arraySetSortingDiff } from "../../../collection/array/arraySetSortingDiff.js";
+import { compareFaces } from "./compareFaces.js";
 
 /**
  *
+ * @param {TopoEdge[]} result
  * @param {TopoVertex[]} source_a
  * @param {TopoVertex[]} source_b
- * @returns {TopoEdge[]}
+ * @returns {number} number of elements placed into the result array
  */
-function findCommonDuplicateEdges(source_a, source_b) {
-    const result = [];
+function findCommonDuplicateEdges(result, source_a, source_b) {
+    let i, j;
+    let result_count = 0;
 
     const na = source_a.length;
-    for (let i = 0; i < na; i++) {
+
+    for (i = 0; i < na; i++) {
         const v_a = source_a[i];
 
         const edges_a = v_a.edges;
 
         const edge_count_a = edges_a.length;
-        for (let j = 0; j < edge_count_a; j++) {
+        for (j = 0; j < edge_count_a; j++) {
             const topoEdge = edges_a[j];
 
             const other_vertex_a = topoEdge.getOtherVertex(v_a);
 
             if (source_b.includes(other_vertex_a)) {
-                result.push(topoEdge);
+                const existing_result_place = result.indexOf(topoEdge);
+
+                if (existing_result_place > result_count || existing_result_place === -1) {
+                    // not included in result set yet
+                    result[result_count] = topoEdge;
+                    result_count++;
+                }
+
             }
         }
     }
 
-    return result;
+    return result_count;
 }
 
 /**
@@ -41,23 +52,30 @@ function connectEdges(a, b) {
     const faces_a = a.faces;
     const faces_b = b.faces;
 
-    const diff = arraySetDiff(faces_a, faces_b);
+    const diff = arraySetSortingDiff(faces_a, faces_b, compareFaces);
 
-    array_copy(diff.uniqueA, 0, faces_b, faces_b.length, diff.uniqueA.length);
-    array_copy(diff.uniqueB, 0, faces_a, faces_a.length, diff.uniqueB.length);
+    const unique_a = diff.uniqueA;
+    const unique_b = diff.uniqueB;
 
+    array_copy(unique_a, 0, faces_b, faces_b.length, unique_a.length);
+    array_copy(unique_b, 0, faces_a, faces_a.length, unique_b.length);
 }
 
 /**
- *
+ * Connect together vertices that are spatially on top of one another
  * @param {TopoMesh} mesh
+ * @param {AABB3} aabb
  */
-export function expandConnectivityByLocality(mesh) {
+export function expandConnectivityByLocality(mesh, aabb) {
+    const duplicate_edges = [];
 
-    const vertex_duplicates = computeTopoMeshVertexDuplicates(mesh);
+    const vertex_duplicates = computeTopoMeshVertexDuplicates(mesh, aabb);
 
     // find duplicate edges from vertices
     const edges = mesh.getEdges();
+
+    let j;
+
     for (let topoEdge of edges) {
 
         const duplicate_v0s = vertex_duplicates.get(topoEdge.v0);
@@ -74,12 +92,10 @@ export function expandConnectivityByLocality(mesh) {
             continue;
         }
 
-        const dulicate_edges = findCommonDuplicateEdges(duplicate_v0s, duplicate_v1s);
-
-        const n = dulicate_edges.length;
+        const n = findCommonDuplicateEdges(duplicate_edges, duplicate_v0s, duplicate_v1s);
 
-        for (let j = 0; j < n; j++) {
-            const dulicateEdge = dulicate_edges[j];
+        for (j = 0; j < n; j++) {
+            const dulicateEdge = duplicate_edges[j];
             connectEdges(topoEdge, dulicateEdge);
         }
     }

package/core/geom/Vector2.js

@@ -332,8 +332,13 @@ class Vector2 {
         return { x: this.x, y: this.y };
     }
 
-    fromJSON({ x = 0, y = 0 }) {
-        this.set(x, y);
+    fromJSON(json) {
+        if (typeof json === "number") {
+            this.set(json, json);
+        } else {
+            const { x = 0, y = 0 } = json;
+            this.set(x, y);
+        }
     }
 
     /**

package/core/geom/Vector3.js

@@ -11,7 +11,7 @@ import { sign } from "../math/sign.js";
 import { v3_dot } from "./v3_dot.js";
 import { v3_length_sqr } from "./v3_length_sqr.js";
 import { v3_length } from "./v3_length.js";
-import { v3_angle_between, v3_angle_between_atan2 } from "./v3_angle_between.js";
+import { v3_angle_between } from "./v3_angle_between.js";
 import { v3_lerp } from "./v3_lerp.js";
 import { v3_slerp } from "./v3_slerp.js";
 import { computeHashFloat } from "../math/hash/computeHashFloat.js";
@@ -448,7 +448,7 @@ class Vector3 {
      * @returns {number}
      */
     angleTo(other) {
-        return v3_angle_between_atan2(this.x, this.y, this.z, other.x, other.y, other.z);
+        return v3_angle_between(this.x, this.y, this.z, other.x, other.y, other.z);
     }
 
     /**

package/core/geom/v3_angle_between.js

@@ -31,7 +31,7 @@ export function v3_angle_between(x0, y0, z0, x1, y1, z1) {
 }
 
 /**
- *
+ * @see https://stackoverflow.com/questions/21483999/using-atan2-to-find-angle-between-two-vectors
  * @param {number} x0
  * @param {number} y0
  * @param {number} z0
@@ -41,6 +41,8 @@ export function v3_angle_between(x0, y0, z0, x1, y1, z1) {
  * @returns {number}
  */
 export function v3_angle_between_atan2(x0, y0, z0, x1, y1, z1) {
+    // angle = atan2(norm(cross(a,b)), dot(a,b))
+
     const cx = y0 * z1 - z0 * y1;
     const cy = z0 * x1 - x0 * z1;
     const cz = x0 * y1 - y0 * x1;

package/editor/view/ecs/components/items/ItemContainerController.stories.js

@@ -1,7 +1,7 @@
 import { storiesOf } from "@storybook/html/dist/client/preview";
 import { Localization } from "../../../../../core/Localization.js";
 import { ItemContainerController } from "./ItemContainerController.js";
-import ItemContainer from "../../../../../../model/game/ecs/component/ItemContainer.js";
+import ItemContainer from "../../../../../../model/game/ecs/component/item_container/ItemContainer.js";
 import Item from "../../../../../../model/game/ecs/component/Item.js";
 import { EngineHarness } from "../../../../../engine/EngineHarness.js";
 import { assert } from "../../../../../core/assert.js";

package/engine/asset/loaders/image/ImageDecoderWorker.js

@@ -19,10 +19,11 @@ async function decode_png(png_bytes) {
         // console.profileEnd('decode');
 
         resolve({
-            data: uint_channels.data,
+            data: uint_channels.data.buffer,
             width,
             height,
-            itemSize: uint_channels.itemSize
+            itemSize: uint_channels.itemSize,
+            bitDepth: uint_channels.bitDepth
         });
     });
 }

package/engine/asset/loaders/image/ImageRGBADataAsset.js

@@ -1,4 +1,5 @@
 import { Asset } from "../../Asset.js";
+import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
 
 export class ImageRGBADataAsset extends Asset {
     /**
@@ -39,11 +40,6 @@ export class ImageRGBADataAsset extends Asset {
     }
 
     create() {
-        return {
-            data: this.data,
-            width: this.width,
-            height: this.height,
-            itemSize: this.itemSize
-        };
+        return new Sampler2D(this.data, this.itemSize, this.width, this.height);
     }
 }