@woosh/meep-engine 2.117.21 → 2.117.22

package/build/meep.cjs

@@ -52066,19 +52066,52 @@ class TerrainPreview {
 const UINT32_MAX = 4294967295;
 
 /**
- * Assumes arrays have the same type
- * @param {TypedArray|Float32Array|Uint8Array|Uint32Array} source
- * @param {TypedArray|Float32Array|Uint8Array|Uint32Array} destination
+ * This is essentially a {@link memcopy} implementation for ArrayBuffers
+ * NOTE: allocates light-weight typed arrays under the hood, so beware of potential GC implications. Generally not an issue, unless you're copying very large number of very small arrays, consider alternatives such as {@link array_copy} instead
+ * @param {ArrayBuffer} source
+ * @param {number} source_offset
+ * @param {ArrayBuffer} target
+ * @param {number} target_offset
+ * @param {number} byte_length
  */
-function typed_array_copy(source, destination) {
-    const destination_size = destination.length;
+function array_buffer_copy(
+    source, source_offset,
+    target, target_offset,
+    byte_length
+) {
+
+    /**
+     * @type {Uint8Array|Uint16Array|Uint32Array}
+     */
+    let source_array;
+    /**
+     * @type {Uint8Array|Uint16Array|Uint32Array}
+     */
+    let target_array;
+
+    const alignment = largest_common_alignment_uint32(source_offset,target_offset,byte_length);
+
+    if (
+        alignment === 4
+    ) {
+        // aligned on 4-byte boundary
+        source_array = new Uint32Array(source, source_offset, byte_length >>> 2);
+        target_array = new Uint32Array(target, target_offset, byte_length >>> 2);
+
+    } else if (
+        alignment === 2
+    ) {
+        // aligned on 2-byte boundary
+        source_array = new Uint16Array(source, source_offset, byte_length >>> 1);
+        target_array = new Uint16Array(target, target_offset, byte_length >>> 1);
 
-    if (destination_size >= source.length) {
-        destination.set(source, 0);
     } else {
-        // destination is smaller than source, crop source data
-        array_copy(source, 0, destination, 0, destination_size);
+        // worst-case, assume 1-byte boundary
+        source_array = new Uint8Array(source, source_offset, byte_length);
+        target_array = new Uint8Array(target, target_offset, byte_length);
     }
+
+    target_array.set(source_array);
 }
 
 /**
@@ -52292,7 +52325,11 @@ class BVH {
         this.__data_uint32 = new Uint32Array(new_data_buffer);
 
         // copy old data into new buffer
-        typed_array_copy(old_data_uint32, this.__data_uint32);
+        array_buffer_copy(
+            old_data_uint32.buffer, old_data_uint32.byteOffset,
+            new_data_buffer, 0,
+            Math.min(old_data_uint32.byteLength, new_data_buffer.byteLength)
+        );
 
         this.__capacity = new_capacity;
     }
@@ -61430,6 +61467,22 @@ Cache.prototype.delete = Cache.prototype.remove;
  */
 Cache.prototype.has = Cache.prototype.contains;
 
+/**
+ * Assumes arrays have the same type
+ * @param {TypedArray|Float32Array|Uint8Array|Uint32Array} source
+ * @param {TypedArray|Float32Array|Uint8Array|Uint32Array} destination
+ */
+function typed_array_copy(source, destination) {
+    const destination_size = destination.length;
+
+    if (destination_size >= source.length) {
+        destination.set(source, 0);
+    } else {
+        // destination is smaller than source, crop source data
+        array_copy(source, 0, destination, 0, destination_size);
+    }
+}
+
 /**
  *
  * @param {Object} a