@woosh/meep-engine 2.118.11 → 2.118.12

package/build/meep.module.js

@@ -52062,6 +52062,8 @@ function array_buffer_copy(
     target, target_offset,
     byte_length
 ) {
+    // assert.ok(source instanceof ArrayBuffer || source instanceof SharedArrayBuffer,'source is not an ArrayBuffer');
+    // assert.ok(target instanceof ArrayBuffer || target instanceof SharedArrayBuffer,'source is not an ArrayBuffer');
 
     /**
      * @type {Uint8Array|Uint16Array|Uint32Array}
@@ -61391,10 +61393,25 @@ function typed_array_copy(source, destination) {
     const destination_size = destination.length;
 
     if (destination_size >= source.length) {
+
         destination.set(source, 0);
+
+    } else if (source.constructor === destination.constructor) {
+
+        // same type
+        array_buffer_copy(
+            source.buffer,
+            source.byteOffset,
+            destination.buffer,
+            destination.byteOffset,
+            Math.min(source.byteLength, destination.byteLength)
+        );
+
     } else {
+
         // destination is smaller than source, crop source data
         array_copy(source, 0, destination, 0, destination_size);
+
     }
 }
 

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.118.11",
+  "version": "2.118.12",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js

@@ -1,6 +1,6 @@
 import { assert } from "../../assert.js";
-import { array_copy } from "../../collection/array/array_copy.js";
 import { array_quick_sort_by_lookup_uint } from "../../collection/array/array_quick_sort_by_lookup_uint.js";
+import { typed_array_copy } from "../../collection/array/typed/typed_array_copy.js";
 import { AABB3 } from "../../geom/3d/aabb/AABB3.js";
 import { aabb3_from_v3_array } from "../../geom/3d/aabb/aabb3_from_v3_array.js";
 import { aabb3_compute_from_triangle } from "../../geom/3d/aabb3_compute_from_triangle.js";
@@ -56,7 +56,6 @@ export function ebvh_build_for_geometry_morton(
     bvh.__size = node_total_count;
 
 
-
     // indices of triangles, but sorted by morton codes
     const sorted_triangle_order = new Uint32Array(tri_count);
 
@@ -128,8 +127,9 @@ export function ebvh_build_for_geometry_morton(
 
     // record newly generated nodes as "unprocessed"
     const unprocessed_nodes = new Uint32Array(tri_count);
-    array_copy(nodes, 0, unprocessed_nodes, 0, tri_count);
+
+    typed_array_copy(nodes, unprocessed_nodes);
 
     // assign root
-    bvh.root = ebvh_build_hierarchy(bvh, unprocessed_nodes, tri_count, nodes, tri_count, quality );
+    bvh.root = ebvh_build_hierarchy(bvh, unprocessed_nodes, tri_count, nodes, tri_count, quality);
 }

package/src/core/collection/array/typed/array_buffer_copy.js

@@ -18,8 +18,8 @@ export function array_buffer_copy(
     assert.isNonNegativeInteger(source_offset, 'source_offset');
     assert.isNonNegativeInteger(target_offset, 'target_offset');
     assert.isNonNegativeInteger(byte_length, 'byte_length');
-    assert.ok(source instanceof ArrayBuffer || source instanceof SharedArrayBuffer,'source is not an ArrayBuffer');
-    assert.ok(target instanceof ArrayBuffer || target instanceof SharedArrayBuffer,'source is not an ArrayBuffer');
+    // assert.ok(source instanceof ArrayBuffer || source instanceof SharedArrayBuffer,'source is not an ArrayBuffer');
+    // assert.ok(target instanceof ArrayBuffer || target instanceof SharedArrayBuffer,'source is not an ArrayBuffer');
 
     /**
      * @type {Uint8Array|Uint16Array|Uint32Array}

package/src/core/collection/array/typed/typed_array_copy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typed_array_copy.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/typed_array_copy.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,yCAHW,aAAW,YAAY,GAAC,UAAU,GAAC,WAAW,eAC9C,aAAW,YAAY,GAAC,UAAU,GAAC,WAAW,QAWxD"}
+{"version":3,"file":"typed_array_copy.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/typed_array_copy.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,yCAHW,aAAW,YAAY,GAAC,UAAU,GAAC,WAAW,eAC9C,aAAW,YAAY,GAAC,UAAU,GAAC,WAAW,QA0BxD"}

package/src/core/collection/array/typed/typed_array_copy.js

@@ -1,4 +1,5 @@
 import { array_copy } from "../array_copy.js";
+import { array_buffer_copy } from "./array_buffer_copy.js";
 
 
 /**
@@ -10,9 +11,24 @@ export function typed_array_copy(source, destination) {
     const destination_size = destination.length;
 
     if (destination_size >= source.length) {
+
         destination.set(source, 0);
+
+    } else if (source.constructor === destination.constructor) {
+
+        // same type
+        array_buffer_copy(
+            source.buffer,
+            source.byteOffset,
+            destination.buffer,
+            destination.byteOffset,
+            Math.min(source.byteLength, destination.byteLength)
+        );
+
     } else {
+
         // destination is smaller than source, crop source data
         array_copy(source, 0, destination, 0, destination_size);
+
     }
 }

package/src/core/geom/3d/aabb/aabb3_compute_surface_area.js

@@ -8,11 +8,9 @@
  * @param {number} z1
  * @returns {number}
  */
-function aabb3_compute_surface_area(x0, y0, z0, x1, y1, z1) {
+export function aabb3_compute_surface_area(x0, y0, z0, x1, y1, z1) {
     const dx = x1 - x0;
     const dy = y1 - y0;
     const dz = z1 - z0;
     return (dy * (dx + dz) + dz * dx) * 2; //2 of each side
 }
-
-export { aabb3_compute_surface_area };

package/src/engine/graphics/geometry/optimization/VertexCacheOptimizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VertexCacheOptimizer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/optimization/VertexCacheOptimizer.js"],"names":[],"mappings":"AAgaA;;;;;;GAMG;AACH,yDALW,MAAM,EAAE,GAAC,WAAW,WACpB,MAAM,EAAE,GAAC,WAAW,eACpB,MAAM,gBACN,MAAM,QAIhB;AAED;;;;;;GAMG;AACH,8DALW,MAAM,EAAE,GAAC,WAAW,WACpB,MAAM,EAAE,GAAC,WAAW,eACpB,MAAM,gBACN,MAAM,QAIhB"}
+{"version":3,"file":"VertexCacheOptimizer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/optimization/VertexCacheOptimizer.js"],"names":[],"mappings":"AA8aA;;;;;;GAMG;AACH,yDALW,MAAM,EAAE,GAAC,WAAW,WACpB,MAAM,EAAE,GAAC,WAAW,eACpB,MAAM,gBACN,MAAM,QAIhB;AAED;;;;;;GAMG;AACH,8DALW,MAAM,EAAE,GAAC,WAAW,WACpB,MAAM,EAAE,GAAC,WAAW,eACpB,MAAM,gBACN,MAAM,QAIhB"}

package/src/engine/graphics/geometry/optimization/VertexCacheOptimizer.js

@@ -8,10 +8,9 @@ const kCacheSizeMax = 16;
 const kValenceMax = 8;
 
 class VertexScoreTable {
-    constructor() {
-        this.cache = new Float32Array(1 + kCacheSizeMax);
-        this.live = new Float32Array(1 + kValenceMax);
-    }
+
+    cache = new Float32Array(1 + kCacheSizeMax);
+    live = new Float32Array(1 + kValenceMax);
 
     /**
      *
@@ -42,11 +41,10 @@ const kVertexScoreTableStrip = VertexScoreTable.from(
 );
 
 class TriangleAdjacency {
-    constructor() {
-        this.counts = new Uint32Array(1);
-        this.offsets = new Uint32Array(1);
-        this.data = new Uint32Array(1);
-    }
+
+    counts = new Uint32Array(1);
+    offsets = new Uint32Array(1);
+    data = new Uint32Array(1);
 
     /**
      *
@@ -76,42 +74,48 @@ function buildTriangleAdjacency(adjacency, indices, index_count, vertex_count) {
     // fill triangle counts
     // adjacency.counts.fill(0);// unnecessary, new arrays are already zero-filled
 
+    const adjacency_counts = adjacency.counts;
+
     for (let i = 0; i < index_count; ++i) {
         const index = indices[i];
 
         assert.lessThan(index, vertex_count);
 
-        adjacency.counts[index]++;
+        adjacency_counts[index]++;
     }
 
     // fill offset table
     let offset = 0;
 
+    const adjacency_offsets = adjacency.offsets;
+
     for (let i = 0; i < vertex_count; ++i) {
-        adjacency.offsets[i] = offset;
-        offset += adjacency.counts[i];
+        adjacency_offsets[i] = offset;
+        offset += adjacency_counts[i];
     }
 
     assert.equal(offset, index_count);
 
+    const adjacency_data = adjacency.data;
+
     // fill triangle data
     for (let i = 0; i < face_count; ++i) {
         const i3 = i * 3;
 
-        const a = indices[i3 + 0];
+        const a = indices[i3];
         const b = indices[i3 + 1];
         const c = indices[i3 + 2];
 
-        adjacency.data[adjacency.offsets[a]++] = i;
-        adjacency.data[adjacency.offsets[b]++] = i;
-        adjacency.data[adjacency.offsets[c]++] = i;
+        adjacency_data[adjacency_offsets[a]++] = i;
+        adjacency_data[adjacency_offsets[b]++] = i;
+        adjacency_data[adjacency_offsets[c]++] = i;
     }
 
     // fix offsets that have been disturbed by the previous pass
     for (let i = 0; i < vertex_count; ++i) {
         // assert(adjacency.offsets[i] >= adjacency.counts[i]);
 
-        adjacency.offsets[i] -= adjacency.counts[i];
+        adjacency_offsets[i] -= adjacency_counts[i];
     }
 }
 
@@ -236,8 +240,9 @@ function meshopt_optimizeVertexCacheTable(destination, indices, index_count, ver
     assert.equal(index_count % 3, 0);
 
     // guard for empty meshes
-    if (index_count === 0 || vertex_count === 0)
+    if (index_count === 0 || vertex_count === 0) {
         return;
+    }
 
     // support in-place optimization
     if (destination === indices) {
@@ -273,9 +278,10 @@ function meshopt_optimizeVertexCacheTable(destination, indices, index_count, ver
     const triangle_scores = new Float32Array(face_count);
 
     for (let i = 0; i < face_count; ++i) {
+
         const i3 = i * 3;
 
-        const a = indices[i3 + 0];
+        const a = indices[i3];
         const b = indices[i3 + 1];
         const c = indices[i3 + 2];
 
@@ -296,16 +302,17 @@ function meshopt_optimizeVertexCacheTable(destination, indices, index_count, ver
 
         const in_tri_3 = current_triangle * 3;
 
-        const a = indices[in_tri_3 + 0];
+        const a = indices[in_tri_3];
         const b = indices[in_tri_3 + 1];
         const c = indices[in_tri_3 + 2];
 
         // output indices
         const out_tri_3 = output_triangle * 3;
 
-        destination[out_tri_3 + 0] = a;
+        destination[out_tri_3] = a;
         destination[out_tri_3 + 1] = b;
         destination[out_tri_3 + 2] = c;
+
         output_triangle++;
 
         // update emitted flags
@@ -327,8 +334,11 @@ function meshopt_optimizeVertexCacheTable(destination, indices, index_count, ver
             }
         }
 
+        // swap caches
         const cache_temp = cache;
-        cache = cache_new, cache_new = cache_temp;
+        cache = cache_new;
+        cache_new = cache_temp;
+
         cache_count = cache_write > cache_size ? cache_size : cache_write;
 
         // update live triangle counts
@@ -346,13 +356,17 @@ function meshopt_optimizeVertexCacheTable(destination, indices, index_count, ver
             const neighbours_size = adjacency.counts[index];
 
             for (let i = 0; i < neighbours_size; ++i) {
+
                 const tri = neighbours[i + neighbour_offset];
 
                 if (tri === current_triangle) {
+
                     neighbours[neighbour_offset + i] = neighbours[neighbour_offset + neighbours_size - 1];
                     adjacency.counts[index]--;
                     break;
+
                 }
+
             }
         }