@woosh/meep-engine 2.34.32 → 2.34.33

package/engine/Engine.js

@@ -131,6 +131,11 @@ class Engine {
             const v_fps = (1 / stats.mean).toFixed(2);
 
 
+            // clear stats
+            m_render.clear();
+            m_sim.clear();
+            m_frame.clear();
+
             return `FPS: ${v_fps}, RENDER: ${v_render}ms, SIMULATION: ${v_sim}ms`;
         });
 

package/engine/development/performance/AbstractMetric.js

@@ -21,4 +21,8 @@ export class AbstractMetric {
     computeStats(result) {
         throw new Error('Not implemented');
     }
+
+    clear(){
+        throw new Error('Not implemented');
+    }
 }

package/engine/development/performance/RingBufferMetric.js

@@ -31,4 +31,8 @@ export class RingBufferMetric extends AbstractMetric {
         result.max = computeArrayMax(array, 0, data_count);
         result.min = computeArrayMin(array, 0, data_count);
     }
+
+    clear() {
+        this.__data.clear();
+    }
 }

package/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js

@@ -81,6 +81,9 @@ export class ShadedGeometrySystem extends System {
 
         const leaf_node = sg.bvh;
 
+        // record entity on the BVH leaf
+        leaf_node.entity = entity;
+
         // remember entity for lookups
         sg.__entity = entity;
 

package/engine/graphics/micron/build/fill_patch_geometry_data.js

@@ -130,30 +130,31 @@ const DataConverterType = {
  * @returns {DataConverterType}
  */
 function compute_attribute_data_converter(source, spec) {
-    if (spec.type === DataType.Float16) {
+    const target_type = spec.type;
+    if (target_type === DataType.Float16) {
         return DataConverterType.Number2HalfFloat;
     } else if (spec.normalized && !source.normalized) {
         // source data can be normalized but isn't
-        if (spec.type === DataType.Int8) {
+        if (target_type === DataType.Int8) {
             return DataConverterType.Normalize2Int8;
         } else {
-            throw new Error(`Unsupported normalized type '${spec.type}'`);
+            throw new Error(`Unsupported normalized type '${target_type}'`);
         }
     } else {
         const source_array = source.array;
 
         const source_type = typedArrayToDataType(source_array);
 
-        const target_byte_size = dataTypeByteSize(spec.type);
+        const target_byte_size = dataTypeByteSize(target_type);
         const source_byte_size = dataTypeByteSize(source_type)
 
         if (target_byte_size !== source_byte_size) {
             // wrong data size
 
-            if (spec.type === DataType.Uint8 && source_type === DataType.Uint16) {
+            if (target_type === DataType.Uint8 && source_type === DataType.Uint16) {
                 return DataConverterType.ResampleNormalized_Uint16_to_Uint8;
             } else {
-                throw new Error(`Unsupported conversion ${source_type} -> `);
+                throw new Error(`Unsupported conversion ${source_type} -> ${target_type}`);
             }
 
         } else {

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.34.32",
+  "version": "2.34.33",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",