@woosh/meep-engine 2.89.5 → 2.91.0

package/src/core/geom/2d/r-tree/StaticR2Tree.js

@@ -0,0 +1,384 @@
+import { assert } from "../../../assert.js";
+import { ceilPowerOfTwo } from "../../../binary/operations/ceilPowerOfTwo.js";
+import { split_by_2 } from "../../../binary/split_by_2.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
+import { array_swap } from "../../../collection/array/array_swap.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { aabb2_array_combine } from "../aabb/aabb2_array_combine.js";
+
+const BINARY_NODE_SIZE = 4;
+const LEAF_NODE_SIZE = 5;
+const BOX_BYTE_SIZE = 4;
+
+/**
+ * Assumes data will be normalized to 0...1 value range
+ * @param {Float32Array} data
+ * @param {number} address
+ * @param {number} bounds_x0
+ * @param {number} bounds_y0
+ * @param {number} multiplier_x
+ * @param {number} multiplier_y
+ * @returns {number}
+ */
+function build_normalized_morton_2d(
+    data, address,
+    bounds_x0, bounds_y0,
+    multiplier_x, multiplier_y
+) {
+
+    const x0 = data[address];
+    const y0 = data[address + 1];
+    const x1 = data[address + 3];
+    const y1 = data[address + 4];
+
+    const cx = (x0 + x1) * 0.5;
+    const cy = (y0 + y1) * 0.5;
+
+    const normalized_x = (cx - bounds_x0) * multiplier_x
+    const normalized_y = (cy - bounds_y0) * multiplier_y
+
+    return (split_by_2(normalized_y) << 1)
+        | split_by_2(normalized_x)
+        ;
+}
+
+/**
+ *
+ * @param {Float32Array} data
+ * @param {number} destination
+ * @param {number} source
+ */
+function copy_box_zero_size(data, destination, source) {
+    assert.isNonNegativeInteger(destination, 'destination');
+    assert.isNonNegativeInteger(source, 'source');
+
+    const x = data[source];
+    const y = data[source + 1];
+
+    assert.notNaN(x, 'x');
+    assert.notNaN(y, 'y');
+
+    data[destination] = x;
+    data[destination + 1] = y;
+
+    data[destination + 2] = x;
+    data[destination + 3] = y;
+}
+
+
+/**
+ * NOTE: code is based on BinaryUint32BVH
+ * NOTE: this code is mostly untested
+ */
+export class StaticR2Tree {
+
+    /**
+     * @type {ArrayBuffer}
+     * @private
+     */
+    __data_buffer;
+
+    /**
+     * @readonly
+     * @private
+     * @type {Uint32Array}
+     */
+    __data_uint32;
+
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __node_count_binary = 0;
+
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __node_count_leaf = 0;
+
+    constructor() {
+        this.setBuffer(new ArrayBuffer(320));
+    }
+
+
+    /**
+     *
+     * @param {ArrayBuffer} buffer
+     */
+    setBuffer(buffer) {
+        assert.defined(buffer, 'buffer');
+
+        this.__data_buffer = buffer;
+
+        this.__data_float32 = new Float32Array(this.__data_buffer);
+        this.__data_uint32 = new Uint32Array(this.__data_buffer);
+    }
+
+
+    initialize_structure() {
+        // compute memory requirements
+        const word_count = this.__node_count_binary * BINARY_NODE_SIZE + this.__node_count_leaf * LEAF_NODE_SIZE;
+        const storage_size = word_count * 4;
+
+        // possibly resize the storage
+        if (this.__data_buffer.byteLength < storage_size) {
+            this.setBuffer(new ArrayBuffer(storage_size));
+        }
+    }
+
+    /**
+     *
+     * @param {number} count
+     */
+    setLeafCount(count) {
+        this.__node_count_leaf = count;
+
+        const twoLeafLimit = ceilPowerOfTwo(count);
+
+        if (count <= 1) {
+            // special case
+            this.__node_count_binary = twoLeafLimit;
+        } else {
+            this.__node_count_binary = twoLeafLimit - 1;
+        }
+
+    }
+
+
+    /**
+     *
+     * @param {number} index
+     * @param {number} payload
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     */
+    setLeafData(
+        index, payload,
+        x0, y0,
+        x1, y1
+    ) {
+        assert.notNaN(x0, 'x0');
+        assert.notNaN(y0, 'y0');
+        assert.notNaN(x1, 'x1');
+        assert.notNaN(y1, 'y1');
+
+        assert.isNonNegativeInteger(payload, 'payload');
+
+        const address = index * LEAF_NODE_SIZE + this.__node_count_binary * BINARY_NODE_SIZE;
+
+        const float32 = this.__data_float32;
+
+        float32[address] = x0;
+        float32[address + 1] = y0;
+        float32[address + 2] = x1;
+        float32[address + 3] = y1;
+
+        this.__data_uint32[address + 4] = payload;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    getLeafBlockAddress() {
+        return this.__node_count_binary * BINARY_NODE_SIZE;
+    }
+
+    /**
+     *
+     * @param {number} leaf_index
+     * @returns {number}
+     */
+    readLeafPayload(leaf_index) {
+        const block_address = this.getLeafBlockAddress();
+
+        const address = block_address + leaf_index * LEAF_NODE_SIZE + BOX_BYTE_SIZE;
+
+        return this.__data_uint32[address];
+    }
+
+
+    /**
+     * Sort leaf nodes according to their morton codes
+     * @param {number[]} bounds
+     */
+    sort_morton(bounds) {
+
+        const leaf_block_address = this.__node_count_binary * BINARY_NODE_SIZE;
+
+        if (this.__node_count_leaf < 2) {
+            // no swaps available
+            return;
+        }
+
+        const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+        const stack_top = stack.pointer;
+
+        let stackPointer = stack_top + 2;
+        let iL, iR;
+
+
+        stack[0] = 0; // first node
+        stack[1] = this.__node_count_leaf - 1; // last node
+
+        const data = this.__data_float32;
+
+
+        const bounds_x0 = bounds[0];
+        const bounds_y0 = bounds[1];
+
+        const bounds_span_x = bounds[2] - bounds_x0;
+        const bounds_span_y = bounds[3] - bounds_y0;
+
+        const bounds_multiplier_x = 4095 / bounds_span_x;
+        const bounds_multiplier_y = 4095 / bounds_span_y;
+
+        while (stackPointer > stack_top) {
+            stackPointer -= 2;
+
+            const right = stack[stackPointer + 1];
+            const left = stack[stackPointer];
+
+            iL = left;
+            iR = right;
+
+            const pivot_index = (left + right) >>> 1;
+
+            const pivot_address = pivot_index * LEAF_NODE_SIZE + leaf_block_address;
+
+            const pivot = build_normalized_morton_2d(data, pivot_address, bounds_x0, bounds_y0, bounds_multiplier_x, bounds_multiplier_y);
+
+            /* partition */
+            while (iL <= iR) {
+                while (build_normalized_morton_2d(data, iL * LEAF_NODE_SIZE + leaf_block_address, bounds_x0, bounds_y0, bounds_multiplier_x, bounds_multiplier_y) < pivot) {
+                    iL++;
+                }
+
+                while (build_normalized_morton_2d(data, iR * LEAF_NODE_SIZE + leaf_block_address, bounds_x0, bounds_y0, bounds_multiplier_x, bounds_multiplier_y) > pivot) {
+                    iR--;
+                }
+
+                if (iL <= iR) {
+
+                    if (iL !== iR) {
+                        //do swap
+                        this.__swap_leaves(iL, iR);
+                    }
+
+                    iL++;
+                    iR--;
+                }
+            }
+
+            /* recursion */
+            if (left < iR) {
+                stack[stackPointer++] = left;
+                stack[stackPointer++] = iR;
+            }
+            if (iL < right) {
+                stack[stackPointer++] = iL;
+                stack[stackPointer++] = right;
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {number} i
+     * @param {number} j
+     * @private
+     */
+    __swap_leaves(i, j) {
+        const leaf_block_address = this.getLeafBlockAddress();
+        const a = i * LEAF_NODE_SIZE + leaf_block_address;
+        const b = j * LEAF_NODE_SIZE + leaf_block_address;
+
+        const float32 = this.__data_float32;
+
+        array_swap(
+            float32, a,
+            float32, b,
+            LEAF_NODE_SIZE
+        );
+    }
+
+    /**
+     * Assemble leaf nodes into hierarchy, set binary node bounds iteratively bottom up
+     */
+    build() {
+        const binary_node_count = this.__node_count_binary;
+
+        const leaf_node_block_address = binary_node_count * BINARY_NODE_SIZE;
+
+        let level = Math.floor(Math.log(binary_node_count) / Math.log(2));
+
+        let i, offset, level_node_count;
+        //NOTE: building first level separately allows to avoid some switching logic needed to determine what is the type of lower level node
+        //build one level above leaf nodes
+        level_node_count = Math.pow(2, level);
+        offset = (level_node_count - 1) * BINARY_NODE_SIZE;
+
+        let parentIndex;
+
+        const node_count_leaf = this.__node_count_leaf;
+
+        const float32 = this.__data_float32;
+
+        // build bottom-most level, just above the leaves
+        for (i = 0; i < level_node_count; i++) {
+            const leaf_index_0 = i << 1;
+            const leaf_index_1 = leaf_index_0 + 1;
+
+            const leaf_offset_0 = leaf_node_block_address + leaf_index_0 * LEAF_NODE_SIZE;
+            const leaf_offset_1 = leaf_node_block_address + leaf_index_1 * LEAF_NODE_SIZE;
+
+            if (leaf_index_1 < node_count_leaf) {
+                // both children nodes are valid
+                aabb2_array_combine(
+                    float32, offset,
+                    float32, leaf_offset_0,
+                    float32, leaf_offset_1
+                );
+            } else if (leaf_index_0 < node_count_leaf) {
+                // only left child node is valid
+                array_copy(float32, leaf_offset_0, float32, offset, 6);
+            } else {
+                //initialize to 0-size box same position as previous node
+                copy_box_zero_size(this.__data_float32, offset, (offset - BINARY_NODE_SIZE));
+            }
+
+            offset += BINARY_NODE_SIZE;
+        }
+
+        level--;
+
+        //build intermediate nodes
+        for (; level >= 0; level--) {
+            level_node_count = 1 << level;
+            parentIndex = (level_node_count - 1);
+
+            for (i = 0; i < level_node_count; i++) {
+
+                const childIndex0 = (parentIndex << 1) + 1;
+
+                const address_parent = parentIndex * BINARY_NODE_SIZE;
+
+                const address_child_0 = childIndex0 * BINARY_NODE_SIZE;
+                const address_child_1 = address_child_0 + BINARY_NODE_SIZE;
+
+                aabb2_array_combine(
+                    float32, address_parent,
+                    float32, address_child_0,
+                    float32, address_child_1
+                );
+
+                parentIndex++;
+            }
+        }
+    }
+}

package/src/core/geom/2d/r-tree/StaticR2Tree.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=StaticR2Tree.spec.d.ts.map

package/src/core/geom/2d/r-tree/StaticR2Tree.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StaticR2Tree.spec.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/r-tree/StaticR2Tree.spec.js"],"names":[],"mappings":""}

package/src/core/geom/2d/r-tree/StaticR2Tree.spec.js

@@ -0,0 +1,62 @@
+import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
+import { seededRandom } from "../../../math/random/seededRandom.js";
+import { StaticR2Tree } from "./StaticR2Tree.js";
+
+
+test.skip("performance, insertion 1m random", () => {
+    const tree = new StaticR2Tree();
+
+    const random = seededRandom(42);
+
+    const N = 1000000;
+
+    const boxes = new Float32Array(N * 4);
+
+    for (let i = 0; i < N; i++) {
+
+        const position_x = randomFloatBetween(random, 0, 98);
+        const position_y = randomFloatBetween(random, 0, 98);
+
+        const size_x = randomFloatBetween(random, 0.1, 2);
+        const size_y = randomFloatBetween(random, 0.1, 2);
+
+
+        const i4 = i * 4;
+        boxes[i4] = position_x;
+        boxes[i4 + 1] = position_y;
+        boxes[i4 + 2] = position_x + size_x;
+        boxes[i4 + 3] = position_y + size_y;
+    }
+
+    tree.setLeafCount(N);
+    tree.initialize_structure();
+
+    // perform insertion
+    const t0 = performance.now();
+
+    for (let i = 0; i < N; i++) {
+        const i4 = i * 4;
+
+        const x0 = boxes[i4];
+        const y0 = boxes[i4 + 1];
+        const x1 = boxes[i4 + 2];
+        const y1 = boxes[i4 + 3];
+
+        tree.setLeafData(i, i,
+            x0,
+            y0,
+            x1,
+            y1
+        );
+    }
+
+    tree.sort_morton([0,0,100,100])
+
+    tree.build();
+
+    const duration = performance.now() - t0;
+
+    const duration_seconds = duration * 1e-3;
+
+    console.log(`Duration ${duration_seconds}s, ${(N / duration_seconds).toFixed(2)} records per second`);
+});

package/src/core/geom/3d/morton/mortonEncode_magicbits.js

@@ -1,4 +1,4 @@
-import { split_by_3 } from "./split_by_3.js";
+import { split_by_3 } from "../../../binary/split_by_3.js";
 
 /**
  * Based on article and C++ source code:

package/src/core/geom/3d/topology/struct/binary/io/OrderedEdge.js

@@ -1,4 +1,4 @@
-import { split_by_2 } from "../../../../morton/split_by_2.js";
+import { split_by_2 } from "../../../../../../binary/split_by_2.js";
 
 export class OrderedEdge {
     /**

package/src/engine/graphics/render/forward_plus/LightManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightManager.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/forward_plus/LightManager.js"],"names":[],"mappings":"AAqIA;IAiBQ;;;;OAIG;IACH,2BAAgD;IAEhD,oCAAoC;IACpC,yCAA4C;IAE5C;;;;;;;;OAQG;IACH,0BAKC;IAYD;;;;;OAKG;IACH,+BAAoD;IAMpD;;;;;OAKG;IACH,8BAAmD;IAMnD;;;;OAIG;IACH,uCAAiF;IAUjF;;;;;OAKG;IACH,+BAEE;IAEF;;;;OAIG;IACH,iCAA8E;IAE9E;;;;OAIG;IACH,2BAAmC;IAEnC;;;;;OAKG;IACH,kCAAoE;IACpE;;;;;OAKG;IACH,kCAAoE;IAEpE;;;;OAIG;IACH,gCAAiC;IAEjC;;;;OAIG;IACH,6BAAiD;IACjD;;;;OAIG;IACH,6BAAiD;IAEjD;;;;OAIG;IACH,uBAAmC;IAEnC;;;;OAIG;IACH,8BAAiD;IAEjD;;;;OAIG;IACH,4BAA+C;IAG/C;;;;OAIG;IACH,yBAA2C;IAE3C;;;;OAIG;IACH,iCAAmD;IAUnD;;;;;OAKG;IACH,kCAAqC;IAErC;;;;OAIG;IACH,mCAAsC;IAK1C,0BAEC;IAED;;;;;;OAMG;IACH,0CAQC;IAED;;;OAGG;IACH,uCAEC;IAED,qCAQC;IAED;;;;;;OAMG;IACH,4CAgBC;IAED,iCAIC;IAED,gCA6BC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;OAGG;IACH,oBAFa,WAAW,CAIvB;IAED;;;OAGG;IACH,kBAFa,WAAW,CAIvB;IAED;;OAEG;IACH,sBAFa,aAAa,CAIzB;IAED;;OAEG;IACH,wBAFa,WAAW,CAIvB;IAED;;;OAGG;IACH,iBAFa,SAAS,OAAO,CAAC,CAI7B;IAED;;;OAGG;IACH,yCAKC;IAED;;;;OAIG;IACH,qCAyBC;IAED;;;;OAIG;IACH,uCA8BC;IAED;;;;OAIG;IACH,qCAMC;IAED;;;;OAIG;IACH,uCAKC;IAED;;;;;OAKG;IACH,4CAJW,mBAAmB,GACjB,MAAM,CAalB;IAED;;;;;;OAMG;IACH,+BAgCC;IAED;;;OAGG;IACH,6BAoBC;IAED,6BAYC;IAGD;;;;OAIG;IACH,6BAMC;IAED,mCA0EC;IAED,mCAgFC;IAED;;;OAGG;IACH,oCAiJC;IAED;;;OAGG;IACH,uCAUC;IAED;;;OAGG;IACH,oCAOC;IAED;;;OAGG;IACH,uCAWC;IAED;;;OAGG;IACH,mBAFW,SAAO,MAAM,iBAAiB,QAmDxC;IAED,gBAKC;IAED;;;;;OAKG;IACH,wBAJW,MAAM,KACN,MAAM,KACN,MAAM,QA2ChB;IAED;;;;OAIG;IACH,gCAFa,OAAO,CAInB;IAED;;;OAGG;IACH,qCAMC;IAED;;;;OAIG;IACH,mCAFa,OAAO,CAiBnB;;CACJ;4BAxrCM,OAAO;8BAAP,OAAO;oBAmBM,kCAAkC;oCAiBlB,0BAA0B"}
+{"version":3,"file":"LightManager.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/forward_plus/LightManager.js"],"names":[],"mappings":"AAqIA;IAiBQ;;;;OAIG;IACH,2BAAgD;IAEhD,oCAAoC;IACpC,yCAA4C;IAE5C;;;;;;;;OAQG;IACH,0BAKC;IAYD;;;;;OAKG;IACH,+BAAoD;IAMpD;;;;;OAKG;IACH,8BAAmD;IAMnD;;;;OAIG;IACH,uCAAiF;IAUjF;;;;;OAKG;IACH,+BAEE;IAEF;;;;OAIG;IACH,iCAA8E;IAE9E;;;;OAIG;IACH,2BAAmC;IAEnC;;;;;OAKG;IACH,kCAAoE;IACpE;;;;;OAKG;IACH,kCAAoE;IAEpE;;;;OAIG;IACH,gCAAiC;IAEjC;;;;OAIG;IACH,6BAAiD;IACjD;;;;OAIG;IACH,6BAAiD;IAEjD;;;;OAIG;IACH,uBAAmC;IAEnC;;;;OAIG;IACH,8BAAiD;IAEjD;;;;OAIG;IACH,4BAA+C;IAG/C;;;;OAIG;IACH,yBAA2C;IAE3C;;;;OAIG;IACH,iCAAmD;IAUnD;;;;;OAKG;IACH,kCAAqC;IAErC;;;;OAIG;IACH,mCAAsC;IAK1C,0BAEC;IAED;;;;;;OAMG;IACH,0CAQC;IAED;;;OAGG;IACH,uCAEC;IAED,qCAQC;IAED;;;;;;OAMG;IACH,4CAgBC;IAED,iCAIC;IAED,gCA6BC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;OAGG;IACH,oBAFa,WAAW,CAIvB;IAED;;;OAGG;IACH,kBAFa,WAAW,CAIvB;IAED;;OAEG;IACH,sBAFa,aAAa,CAIzB;IAED;;OAEG;IACH,wBAFa,WAAW,CAIvB;IAED;;;OAGG;IACH,iBAFa,SAAS,OAAO,CAAC,CAI7B;IAED;;;OAGG;IACH,yCAKC;IAED;;;;OAIG;IACH,qCAyBC;IAED;;;;OAIG;IACH,uCA8BC;IAED;;;;OAIG;IACH,qCAMC;IAED;;;;OAIG;IACH,uCAKC;IAED;;;;;OAKG;IACH,4CAJW,mBAAmB,GACjB,MAAM,CAalB;IAED;;;;;;OAMG;IACH,+BAgCC;IAED;;;OAGG;IACH,6BAoBC;IAED,6BAYC;IAGD;;;;OAIG;IACH,6BAMC;IAED,mCA0EC;IAED,mCAgFC;IAED;;;OAGG;IACH,oCAmJC;IAED;;;OAGG;IACH,uCAUC;IAED;;;OAGG;IACH,oCAOC;IAED;;;OAGG;IACH,uCAWC;IAED;;;OAGG;IACH,mBAFW,SAAO,MAAM,iBAAiB,QAmDxC;IAED,gBAKC;IAED;;;;;OAKG;IACH,wBAJW,MAAM,KACN,MAAM,KACN,MAAM,QA2ChB;IAED;;;;OAIG;IACH,gCAFa,OAAO,CAInB;IAED;;;OAGG;IACH,qCAMC;IAED;;;;OAIG;IACH,mCAFa,OAAO,CAiBnB;;CACJ;4BA1rCM,OAAO;8BAAP,OAAO;oBAmBM,kCAAkC;oCAiBlB,0BAA0B"}

package/src/engine/graphics/render/forward_plus/LightManager.js

@@ -958,6 +958,7 @@ export class LightManager {
 
                     const tile_data_offset = tile_index * 4;
 
+                    //assign lights
                     lookup_address_offset += assign_cluster(
                         tile_data_offset,
                         bvh_lights,
@@ -967,6 +968,7 @@ export class LightManager {
                         light_source_data
                     );
 
+                    // assign decals
                     const decal_count = assign_cluster(
                         tile_data_offset + 2,
                         bvh_decals,

package/src/engine/graphics/render/forward_plus/cluster/read_plane_pair.d.ts

@@ -1,5 +1,5 @@
 /**
- * Read out a pair of planes from an numeric array
+ * Read out a pair of planes from a numeric array
  * @param {number[]|Float32Array} source
  * @param {number} source_offset
  * @param {number[]|Float64Array|Float32Array} destination

package/src/engine/graphics/render/forward_plus/cluster/read_plane_pair.js

@@ -1,5 +1,5 @@
 /**
- * Read out a pair of planes from an numeric array
+ * Read out a pair of planes from a numeric array
  * @param {number[]|Float32Array} source
  * @param {number} source_offset
  * @param {number[]|Float64Array|Float32Array} destination

package/src/engine/graphics/texture/virtual/tile/compose_tile_address.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../../core/assert.js";
-import { split_by_2 } from "../../../../../core/geom/3d/morton/split_by_2.js";
+import { split_by_2 } from "../../../../../core/binary/split_by_2.js";
 
 /**
  *

package/src/engine/graphics/texture/virtual/tile/tile_address_to_finger_print.js

@@ -1,4 +1,4 @@
-import { split_by_2 } from "../../../../../core/geom/3d/morton/split_by_2.js";
+import { split_by_2 } from "../../../../../core/binary/split_by_2.js";
 import { compose_finger_print } from "./compose_finger_print.js";
 
 /**

package/src/engine/input/devices/KeyboardDevice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KeyboardDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/KeyboardDevice.js"],"names":[],"mappings":";AAkDA;IAgBI;;;OAGG;IACH,wBAFW,WAAW,GAAC,OAAO,EA+B7B;IA/CD;;OAEG;IACH;;;MAGE;IAEF;;;OAGG;IACH,mBAAU;IAkBN;;;OAGG;IACH,YAFU,WAAW,CAEO;IAyDhC,cAGC;IAED,aAGC;;CACJ;mBApJkB,uCAAuC"}
+{"version":3,"file":"KeyboardDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/KeyboardDevice.js"],"names":[],"mappings":";AAkDA;IAgBI;;;OAGG;IACH,wBAFW,WAAW,GAAC,OAAO,EA+B7B;IA/CD;;OAEG;IACH;;;MAGE;IAEF;;;OAGG;IACH,mBAAU;IAkBN;;;OAGG;IACH,YAFU,WAAW,CAEO;IA+DhC,cAGC;IAED,aAGC;;CACJ;mBA1JkB,uCAAuC"}

package/src/engine/input/devices/KeyboardDevice.js

@@ -3,9 +3,9 @@
  */
 
 import Signal from "../../../core/events/signal/Signal.js";
-import { KeyCodes } from './KeyCodes.js';
 import { KeyboardEvents } from "./events/KeyboardEvents.js";
 import { InputDeviceSwitch } from "./InputDeviceSwitch.js";
+import { KeyCodes } from './KeyCodes.js';
 
 /**
  *
@@ -105,6 +105,12 @@ class KeyboardDevice {
      * @private
      */
     #handlerKeyDown = (event) => {
+        if (event.repeat) {
+            // ignore automatic repetition
+            // see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/repeat
+            return;
+        }
+
         this.on.down.send1(event);
 
         //hook up dispatch handler for individual keys

package/src/core/geom/3d/morton/de_interleave_2_bits.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"de_interleave_2_bits.spec.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/morton/de_interleave_2_bits.spec.js"],"names":[],"mappings":""}

package/src/core/geom/3d/morton/de_interleave_bits_by_2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"de_interleave_bits_by_2.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/morton/de_interleave_bits_by_2.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,kDAHW,MAAM,GACJ,MAAM,CAWlB"}

package/src/core/geom/3d/morton/reinterpret_float32_as_int32.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reinterpret_float32_as_int32.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/morton/reinterpret_float32_as_int32.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,oDAHW,MAAM,GACJ,MAAM,CAKlB"}

package/src/core/geom/3d/morton/split_by_2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"split_by_2.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/morton/split_by_2.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,8BAHW,MAAM,GACJ,MAAM,CAUlB"}

package/src/core/geom/3d/morton/split_by_3.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"split_by_3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/morton/split_by_3.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,8BAHW,MAAM,GACJ,MAAM,CASlB"}