@woosh/meep-engine 2.34.48 → 2.34.49

package/core/binary/BitSet.js

@@ -59,7 +59,6 @@ const SHRINK_FACTOR = 0.5;
  */
 const RESIZE_COUNT_THRESHOLD = 128;
 
-
 /**
  * Dynamically sized bit field
  * @constructor
@@ -389,6 +388,7 @@ BitSet.prototype.set = function (bitIndex, value) {
         const bitIndexInc = bitIndex + 1;
 
         if (bitIndexInc > this.__length) {
+            // ensure capacity
             this.__setLength(bitIndexInc);
         }
 
@@ -401,6 +401,7 @@ BitSet.prototype.set = function (bitIndex, value) {
         this.__data_uint32[word_offset] &= ~word_mask;
 
         if (bitIndex === this.__length - 1) {
+            // trim down set size potentially
             const newLastSetBit = this.previousSetBit(bitIndex);
 
             this.__setLength(newLastSetBit + 1);
@@ -538,9 +539,13 @@ BitSet.prototype.reset = function () {
     if (current_length <= 0) {
         // no action required
         return;
+    } else if (current_length <= 32) {
+        // one word, set first word to 0 manually
+        this.__data_uint32[0] = 0;
+    } else {
+        this.__data_uint32.fill(0, 0, Math.ceil(current_length / 32));
     }
 
-    this.__data_uint32.fill(0, 0, Math.ceil(current_length / 32));
     this.__length = 0;
 };
 

package/core/geom/3d/frustum/frustum_from_projection_matrix_array.js

@@ -7,53 +7,56 @@
  * @param {number} z
  * @param {number} w
  */
-function array_set_plane_normalized(destination, destination_offset, x, y, z, w) {
+function array_set_plane_normalized(
+    destination, destination_offset,
+    x, y, z, w
+) {
     // compute vector length
     const length = Math.hypot(x, y, z);
 
-    const inverseNormalLength = 1.0 / length;
+    const inverse_length = 1.0 / length;
 
     // apply normalization
-    destination[destination_offset] = x * inverseNormalLength;
-    destination[destination_offset + 1] = y * inverseNormalLength;
-    destination[destination_offset + 2] = z * inverseNormalLength;
-    destination[destination_offset + 3] = w * inverseNormalLength;
+    destination[destination_offset] = x * inverse_length;
+    destination[destination_offset + 1] = y * inverse_length;
+    destination[destination_offset + 2] = z * inverse_length;
+    destination[destination_offset + 3] = w * inverse_length;
 }
 
 /**
  * Set frustum from projection matrix
  * @param {number[]|Float32Array} frustum_planes
- * @param {number[]} me
+ * @param {number[]} m4
  */
-export function frustum_from_projection_matrix_array(frustum_planes, me) {
+export function frustum_from_projection_matrix_array(frustum_planes, m4) {
 
-    const me0 = me[0];
-    const me3 = me[3];
+    const me0 = m4[0];
+    const me3 = m4[3];
 
-    const me4 = me[4];
-    const me7 = me[7];
+    const me4 = m4[4];
+    const me7 = m4[7];
 
-    const me8 = me[8];
-    const me11 = me[11];
+    const me8 = m4[8];
+    const me11 = m4[11];
 
-    const me12 = me[12];
-    const me15 = me[15];
+    const me12 = m4[12];
+    const me15 = m4[15];
 
     array_set_plane_normalized(frustum_planes, 0, me3 - me0, me7 - me4, me11 - me8, me15 - me12);
     array_set_plane_normalized(frustum_planes, 4, me3 + me0, me7 + me4, me11 + me8, me15 + me12);
 
-    const me1 = me[1];
-    const me5 = me[5];
-    const me9 = me[9];
-    const me13 = me[13];
+    const me1 = m4[1];
+    const me5 = m4[5];
+    const me9 = m4[9];
+    const me13 = m4[13];
 
     array_set_plane_normalized(frustum_planes, 8, me3 + me1, me7 + me5, me11 + me9, me15 + me13);
     array_set_plane_normalized(frustum_planes, 12, me3 - me1, me7 - me5, me11 - me9, me15 - me13);
 
-    const me2 = me[2];
-    const me6 = me[6];
-    const me10 = me[10];
-    const me14 = me[14];
+    const me2 = m4[2];
+    const me6 = m4[6];
+    const me10 = m4[10];
+    const me14 = m4[14];
 
     array_set_plane_normalized(frustum_planes, 16, me3 - me2, me7 - me6, me11 - me10, me15 - me14);
     array_set_plane_normalized(frustum_planes, 20, me3 + me2, me7 + me6, me11 + me10, me15 + me14);

package/engine/asset/loaders/geometry/geometry/computeGeometryEquality.js

@@ -1,4 +1,5 @@
 import { isArrayEqualStrict } from "../../../../../core/collection/array/isArrayEqualStrict.js";
+import { is_typed_array_equals } from "../../../../../core/collection/array/typed/is_typed_array_equals.js";
 
 
 /**
@@ -46,7 +47,7 @@ export function computeGeometryEquality(a, b) {
         const a_attribute = a.attributes[key];
         const b_attribute = b.attributes[key];
 
-        if (!isArrayEqualStrict(a_attribute.array, b_attribute.array)) {
+        if (!is_typed_array_equals(a_attribute.array, b_attribute.array)) {
             return false;
         }
     }

package/engine/graphics/micron/convert_three_object_to_micron.js

@@ -76,8 +76,6 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
 
         await micron_cache.set(g, micron_geometry);
 
-        // console.log(micron_geometry);
-
         return micron_geometry;
     }
 

package/engine/graphics/micron/format/MicronGeometryPatch.js

@@ -1,6 +1,6 @@
-import { squirrel3 } from "../../../../core/math/hash/squirrel3.js";
 import { ConicRay } from "../../../../core/geom/ConicRay.js";
 import { vec4 } from "gl-matrix";
+import { assert } from "../../../../core/assert.js";
 
 /**
  * Patches are organized into a tree hierarchy
@@ -13,18 +13,11 @@ export class MicronGeometryPatch {
          */
         this.id = 0;
 
-        /**
-         * Continuous memory region for various pieces of data to get better memory access patterns
-         * All pieces of data end up in a continuous piece of memory, resulting in better cache coherence
-         * @type {ArrayBuffer}
-         */
-        const array_buffer = new ArrayBuffer((6 + 6 + 24) * 4);
-
         /**
          * Bounds are used to determine screen error and whether a patch should be subdivided or not for rendering
          * @type {number[]}
          */
-        this.bounding_box = new Float32Array(array_buffer, 0, 6);
+        this.bounding_box = null;
 
         /**
          *
@@ -36,13 +29,21 @@ export class MicronGeometryPatch {
          *
          * @type {number[]|Float32Array}
          */
-        this.group_bounding_box = new Float32Array(array_buffer, 6 * 4, 6);
+        this.group_bounding_box = null;
 
         /**
          *
          * @type {number[]|Float32Array}
          */
-        this.group_bounding_box_corners = new Float32Array(array_buffer, 12 * 4, 24);
+        this.group_bounding_box_corners = null;
+
+        /**
+         * Continuous memory region for various pieces of data to get better memory access patterns
+         * All pieces of data end up in a continuous piece of memory, resulting in better cache coherence
+         * @type {ArrayBuffer}
+         */
+        const array_buffer = new ArrayBuffer(144);
+        this.allocate_metadata(array_buffer, 0);
 
         /**
          *
@@ -114,21 +115,25 @@ export class MicronGeometryPatch {
     }
 
     /**
-     * @deprecated
+     *
+     * @param {ArrayBuffer} buffer
+     * @param {number} offset
+     * @returns {number}
      */
-    get parent() {
-        throw new Error('Single parent is no longer supported, use .parents instead');
-    }
+    allocate_metadata(buffer, offset) {
+        assert.greaterThanOrEqual(buffer.byteLength, offset + 144, 'buffer underflow');
 
-    /**
-     * @deprecated
-     */
-    set parent(v) {
-        throw new Error('Single parent is no longer supported, use .parents instead');
+        this.bounding_box = new Float32Array(buffer, offset, 6);
+
+        this.group_bounding_box = new Float32Array(buffer, offset + 24, 6);
+
+        this.group_bounding_box_corners = new Float32Array(buffer, offset + 48, 24);
+
+        return 144;
     }
 
     hash() {
-        return squirrel3(this.id);
+        return this.id;
     }
 
     computeByteSize() {
@@ -136,8 +141,13 @@ export class MicronGeometryPatch {
 
         result += this.face_indices.buffer.byteLength;
 
-        for (let i = 0; i < this.vertex_attribute_arrays.length; i++) {
-            result += this.vertex_attribute_arrays[i].buffer.byteLength;
+        const attribute_arrays = this.vertex_attribute_arrays;
+        const attribute_count = attribute_arrays.length;
+
+        for (let i = 0; i < attribute_count; i++) {
+            const attribute_array = attribute_arrays[i];
+
+            result += attribute_array.buffer.byteLength;
         }
 
         return result;

package/engine/graphics/micron/format/serialization/MicronGeometryBinarySerializationAdapter.js

@@ -79,12 +79,18 @@ export class MicronGeometryBinarySerializationAdapter extends BinaryClassSeriali
 
         const patches = [];
 
+        // for the sake of speed, we will allocate all metadata in the same piece of memory to make traversal of patch hierarchy faster
+        const md_buffer = new ArrayBuffer(patch_count * 144);
+        let md_buffer_offset = 0;
+
         // build initial patches
         for (let i = 0; i < patch_count; i++) {
             const patch = new MicronGeometryPatch();
 
             patch.id = i;
 
+            md_buffer_offset += patch.allocate_metadata(md_buffer, md_buffer_offset);
+
             patches[i] = patch;
         }
 

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -1,10 +1,8 @@
 import {
     AmbientLight,
     BoxBufferGeometry,
-    CameraHelper,
     CubeTextureLoader,
     DirectionalLight,
-    DirectionalLightHelper,
     FrontSide,
     Matrix4,
     Mesh,
@@ -64,6 +62,10 @@ metrics.create({
     name: 'adapter_update', buffer_size: METRIC_BUFFER_SIZE
 });
 
+metrics.create({
+    name: 'debug_v0', buffer_size: METRIC_BUFFER_SIZE
+});
+
 let container, stats;
 
 let camera, scene, renderer;
@@ -480,7 +482,7 @@ function init() {
     // gltf_sample('moicon/03_Jan_22_Demo/worker_test/model.gltf');
     // gltf_sample('moicon/A4/A4/model.gltf');
     gltf_sample('moicon/ztest_object_many_pieces/model.gltf');
-    // gltf_grid('moicon/ztest_object_many_pieces/model.gltf', 3, 3);
+    // gltf_grid('moicon/ztest_object_many_pieces/model.gltf', 10, 10);
 
     document.addEventListener("mousemove", onDocumentMouseMove);
 

package/engine/graphics/micron/render/VirtualGeometryBuilder.js

@@ -4,6 +4,7 @@ import { RefinementSpec } from "./refinement/RefinementSpec.js";
 import { ActivePatchList } from "./refinement/ActivePatchList.js";
 import { mat4 } from "gl-matrix";
 import { get_geometry_patch_cut } from "./refinement/get_geometry_patch_cut.js";
+import { traverseThreeObject } from "../../ecs/highlight/renderer/traverseThreeObject.js";
 
 /**
  * @readonly
@@ -106,7 +107,7 @@ export class VirtualGeometryBuilder {
     }
 
     /**
-     *
+     * @private
      * @param {THREE.Object3D|ThreeMicronMesh} object
      */
     buildForObject(object) {
@@ -133,15 +134,6 @@ export class VirtualGeometryBuilder {
                 );
             }
         }
-
-        const children = object.children;
-        const children_count = children.length;
-
-        for (let i = 0; i < children_count; i++) {
-            const child = children[i];
-
-            this.buildForObject(child);
-        }
     }
 
     /**
@@ -211,10 +203,11 @@ export class VirtualGeometryBuilder {
         const n = this.input_scene_length;
         const input_objects = this.input_scene;
 
+
         for (let i = 0; i < n; i++) {
             const object3D = input_objects[i];
 
-            this.buildForObject(object3D);
+            traverseThreeObject(object3D, this.buildForObject, this);
         }
 
 

package/engine/graphics/micron/render/refinement/RefinementSpec.js

@@ -50,17 +50,6 @@ export class RefinementSpec {
          * @type {Float32Array}
          */
         this.frustum_f32 = new Float32Array(array_buffer, 64, 24);
-
-
-        /**
-         * Object-space camera position
-         * @type {Float32Array}
-         */
-        this.view_position = new Float32Array(3);
-    }
-
-    get frustum() {
-        throw new Error('deprecated, use .frustum_f32 instead');
     }
 
     /**

package/engine/graphics/micron/render/refinement/get_geometry_patch_cut.js

@@ -40,6 +40,8 @@ export function get_geometry_patch_cut(
     const projection_matrix = spec.projection_matrix;
     const error_threshold = spec.error_threshold_normalized;
 
+    const geometry_id = geometry.id;
+
     let output_patch_cursor = destination_offset;
 
     let i;
@@ -111,7 +113,7 @@ export function get_geometry_patch_cut(
         }
 
         patch_instance.instance_id = instance_id;
-        patch_instance.geometry_id = geometry.id;
+        patch_instance.geometry_id = geometry_id;
         patch_instance.patch = patch;
         patch_instance.transform = transform;
 

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.48",
+  "version": "2.34.49",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",