@woosh/meep-engine 2.118.11 → 2.118.13

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}
@@ -52152,6 +52154,7 @@ const CAPACITY_GROW_MIN_STEP = 64;
  * @type {number}
  */
 const ELEMENT_WORD_COUNT = 10;
+const ELEMENT_BYTE_COUNT = ELEMENT_WORD_COUNT * 4;
 
 /**
  * How many nodes can be stored in the newly constructed tree before allocation needs to take place
@@ -52189,7 +52192,7 @@ class BVH {
      * If you intend to modify the data directly - make sure you fully understand the implications of doing so
      * @returns {ArrayBuffer}
      */
-    get data_buffer(){
+    get data_buffer() {
         return this.__data_buffer;
     }
 
@@ -52310,19 +52313,23 @@ class BVH {
 
         const old_data_uint32 = this.__data_uint32;
 
-        const new_data_buffer = new ArrayBuffer(new_capacity * ELEMENT_WORD_COUNT * 4);
+        const new_data_buffer = new ArrayBuffer(new_capacity * ELEMENT_BYTE_COUNT);
 
         this.__data_buffer = new_data_buffer;
 
         this.__data_float32 = new Float32Array(new_data_buffer);
         this.__data_uint32 = new Uint32Array(new_data_buffer);
 
-        // copy old data into new buffer
-        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)
-        );
+        if (this.__size > 0) {
+
+            // copy old data into new buffer
+            array_buffer_copy(
+                old_data_uint32.buffer, old_data_uint32.byteOffset,
+                new_data_buffer, 0,
+                Math.min(this.__size * ELEMENT_BYTE_COUNT, new_data_buffer.byteLength)
+            );
+
+        }
 
         this.__capacity = new_capacity;
     }
@@ -61391,10 +61398,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.13",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/bvh3/BVH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BVH.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/BVH.js"],"names":[],"mappings":"AAQA,8BAA+B;AAC/B,+BAAgC;AAChC,+BAAgC;AAChC,8BAA+B;AAE/B;;;;;GAKG;AACH,+BAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,wBAFU,MAAM,CAEoB;AAcpC;;;;;GAKG;AACH,iCAFU,MAAM,CAEqB;AAgBrC;;;;;;GAMG;AACH;IAEI;;;;OAIG;IACH,sBAA2E;IAE3E;;;;;OAKG;IACH,+BAEC;IAED;;;;OAIG;IACH,uBAAsD;IAEtD;;;;OAIG;IACH,sBAAoD;IAEpD;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,eAAW;IAEX;;;;OAIG;IACH,eAAY;IAEZ;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,eAAmB;IAUnB;;;OAGG;IACH,sBAEC;IAdD;;;OAGG;IACH,mBAEC;IAkBD;;;OAGG;IACH,+BAMC;IAlBD;;;OAGG;IACH,4BAEC;IAcD,wBAgBC;IAED;;;;OAIG;IACH,uBAyBC;IAED;;OAEG;IACH,aAIC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAqDlB;IAED;;;;OAIG;IACH,iBAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAOnB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,uBAHW,MAAM,SACN,MAAM,QAOhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAGD;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,QAe/B;IAED;;;;OAIG;IACH,kBAHW,MAAM,QACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,QAAM,QAsB1C;IAED;;;;OAIG;IACH,mBAHW,MAAM,QACN,MAAM,EAAE,QAWlB;IAED;;;;;;;;;OASG;IACH,4BARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAmBhB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAoBlB;IAED;;;;;OAKG;IACH,wCAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAoClB;IAED;;;;;OAKG;IACH,oCAJW,MAAM,WACN,MAAM,WACN,MAAM,QAwChB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CA0GhB;IAED;;;;;OAKG;IACH,wBAqBC;IAED;;;;OAIG;IACH,yBA4BC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CA6ChB;IAED;;;;;;OAMG;IACH,gBAoMC;IAED;;;OAGG;IACH,oBAIC;IAED;;;;OAIG;IACH,yCA8BC;IAED;;;;;OAKG;IACH,+BAJW,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;OAKG;IACH,0BA6BC;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAsCnB;CACJ"}
+{"version":3,"file":"BVH.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/BVH.js"],"names":[],"mappings":"AAQA,8BAA+B;AAC/B,+BAAgC;AAChC,+BAAgC;AAChC,8BAA+B;AAE/B;;;;;GAKG;AACH,+BAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,wBAFU,MAAM,CAEoB;AAcpC;;;;;GAKG;AACH,iCAFU,MAAM,CAEqB;AAiBrC;;;;;;GAMG;AACH;IAEI;;;;OAIG;IACH,sBAA2E;IAE3E;;;;;OAKG;IACH,+BAEC;IAED;;;;OAIG;IACH,uBAAsD;IAEtD;;;;OAIG;IACH,sBAAoD;IAEpD;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,eAAW;IAEX;;;;OAIG;IACH,eAAY;IAEZ;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,eAAmB;IAUnB;;;OAGG;IACH,sBAEC;IAdD;;;OAGG;IACH,mBAEC;IAkBD;;;OAGG;IACH,+BAMC;IAlBD;;;OAGG;IACH,4BAEC;IAcD,wBAgBC;IAED;;;;OAIG;IACH,uBA6BC;IAED;;OAEG;IACH,aAIC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAqDlB;IAED;;;;OAIG;IACH,iBAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAOnB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,uBAHW,MAAM,SACN,MAAM,QAOhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAGD;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,QAe/B;IAED;;;;OAIG;IACH,kBAHW,MAAM,QACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,QAAM,QAsB1C;IAED;;;;OAIG;IACH,mBAHW,MAAM,QACN,MAAM,EAAE,QAWlB;IAED;;;;;;;;;OASG;IACH,4BARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAmBhB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAoBlB;IAED;;;;;OAKG;IACH,wCAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAoClB;IAED;;;;;OAKG;IACH,oCAJW,MAAM,WACN,MAAM,WACN,MAAM,QAwChB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CA0GhB;IAED;;;;;OAKG;IACH,wBAqBC;IAED;;;;OAIG;IACH,yBA4BC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CA6ChB;IAED;;;;;;OAMG;IACH,gBAoMC;IAED;;;OAGG;IACH,oBAIC;IAED;;;;OAIG;IACH,yCA8BC;IAED;;;;;OAKG;IACH,+BAJW,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;OAKG;IACH,0BA6BC;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAsCnB;CACJ"}

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

@@ -44,6 +44,7 @@ const CAPACITY_GROW_MIN_STEP = 64;
  * @type {number}
  */
 export const ELEMENT_WORD_COUNT = 10;
+const ELEMENT_BYTE_COUNT = ELEMENT_WORD_COUNT * 4;
 
 /**
  * How many nodes can be stored in the newly constructed tree before allocation needs to take place
@@ -81,7 +82,7 @@ export class BVH {
      * If you intend to modify the data directly - make sure you fully understand the implications of doing so
      * @returns {ArrayBuffer}
      */
-    get data_buffer(){
+    get data_buffer() {
         return this.__data_buffer;
     }
 
@@ -203,19 +204,23 @@ export class BVH {
 
         const old_data_uint32 = this.__data_uint32;
 
-        const new_data_buffer = new ArrayBuffer(new_capacity * ELEMENT_WORD_COUNT * 4);
+        const new_data_buffer = new ArrayBuffer(new_capacity * ELEMENT_BYTE_COUNT);
 
         this.__data_buffer = new_data_buffer;
 
         this.__data_float32 = new Float32Array(new_data_buffer);
         this.__data_uint32 = new Uint32Array(new_data_buffer);
 
-        // copy old data into new buffer
-        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)
-        );
+        if (this.__size > 0) {
+
+            // copy old data into new buffer
+            array_buffer_copy(
+                old_data_uint32.buffer, old_data_uint32.byteOffset,
+                new_data_buffer, 0,
+                Math.min(this.__size * ELEMENT_BYTE_COUNT, new_data_buffer.byteLength)
+            );
+
+        }
 
         this.__capacity = new_capacity;
     }

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;
+
                 }
+
             }
         }