@woosh/meep-engine 2.34.47 → 2.34.48

package/core/binary/BitSet.js

@@ -533,12 +533,14 @@ BitSet.prototype.shift = function (distance, start_index, end_index) {
  * Sets all of the bits in this BitSet to false.
  */
 BitSet.prototype.reset = function () {
-    if (this.__length <= 0) {
+    const current_length = this.__length;
+
+    if (current_length <= 0) {
         // no action required
         return;
     }
 
-    this.__data_uint32.fill(0, 0, Math.ceil(this.__length / 32));
+    this.__data_uint32.fill(0, 0, Math.ceil(current_length / 32));
     this.__length = 0;
 };
 

package/core/geom/3d/aabb/aabb3_estimate_projected_area2.js

@@ -16,7 +16,7 @@ export function aabb3_estimate_projected_area2(aabb, matrix) {
     for (let i = 0; i < 2; i++) {
         for (let j = 0; j < 3; j++) {
 
-            const m_a = i * 4 + j;
+            const m_a = i  + j* 4;
             const m_v = matrix[m_a];
 
             const a = m_v * aabb[j];

package/engine/ecs/foliage/ecs/Foliage2System.js

@@ -111,10 +111,22 @@ export class Foliage2System extends System {
 
         this.renderLayer = graphics.layers.create('instanced-mesh-system');
 
-        graphics.views.elements.forEach(this.__handle_view_added, this);
+        /**
+         *
+         * @type {CameraViewManager}
+         */
+        const views = graphics.views;
+
+        /**
+         *
+         * @type {List<CameraView>}
+         */
+        const view_list = views.elements;
+
+        view_list.forEach(this.__handle_view_added, this);
 
-        graphics.views.elements.on.added.add(this.__handle_view_added, this);
-        graphics.views.elements.on.removed.add(this.__handle_view_removed, this);
+        view_list.on.added.add(this.__handle_view_added, this);
+        view_list.on.removed.add(this.__handle_view_removed, this);
 
         this.renderLayer.buildVisibleSet = (destination, destination_offset, view) => {
             const data = this.data;

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

@@ -226,11 +226,9 @@ export class MicronGeometry {
                     }
 
                     // push to stack
-                    stack[stack_cursor] = child;
+                    stack[stack_cursor++] = child;
 
                     included_set.set(child.id, true);
-
-                    stack_cursor++;
                 }
             }
         }

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -261,8 +261,8 @@ function init() {
 
     // shadow_camera.onBeforeRender = do_vgrt_update;
 
-    scene.add(new CameraHelper(shadow_camera));
-    scene.add(new DirectionalLightHelper(directionalLight));
+    // scene.add(new CameraHelper(shadow_camera));
+    // scene.add(new DirectionalLightHelper(directionalLight));
 
     shadow_camera.updateProjectionMatrix();
 
@@ -459,7 +459,7 @@ function init() {
 
     // sample_gltf_sponza();
     // gltf_sample('data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf');
-    sample_lucy();
+    // sample_lucy();
     // sample_dragon();
     // sample_gltf_hapro_2();
     // sample_gltf_hapro_1();
@@ -479,6 +479,8 @@ function init() {
     // gltf_sample('moicon/03_Jan_22_Demo/8-assets/model.gltf');
     // 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);
 
     document.addEventListener("mousemove", onDocumentMouseMove);
 

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

@@ -1,10 +1,9 @@
 import { array_copy } from "../../../../core/collection/array/copyArray.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
-import { MicronGeometryPatchOccurrence } from "../format/MicronGeometryPatchOccurance.js";
 import { RefinementSpec } from "./refinement/RefinementSpec.js";
 import { ActivePatchList } from "./refinement/ActivePatchList.js";
-import { ActivePatchFlags } from "./refinement/ActivePatchFlags.js";
 import { mat4 } from "gl-matrix";
+import { get_geometry_patch_cut } from "./refinement/get_geometry_patch_cut.js";
 
 /**
  * @readonly
@@ -158,8 +157,6 @@ export class VirtualGeometryBuilder {
         transform,
         apl
     ) {
-        apl.initializeFromGeometry(geometry);
-
         refinement_spec.build(transform, this.view_projection_matrix);
 
         const output = this.output;
@@ -168,48 +165,19 @@ export class VirtualGeometryBuilder {
         output.stats_source_triangle_count += geometry.source_triangle_count;
         output.stats_source_vertex_count += geometry.source_vertex_count;
 
-        // apl.build_from_lod(geometry, 0);
-        apl.refine(refinement_spec);
-
         // build up occurances
         const output_patches = output.patches;
-        let output_patch_cursor = output.patch_count;
-        let patch_instance;
-
-        const geometry_id = geometry.id;
-
-        for (
-            let record = apl.records;
-            record !== null;
-            record = record.link_next
-        ) {
-
-            if (!record.getFlag(ActivePatchFlags.Visible)) {
-                // patch is not visible, skip
-                continue;
-            }
-
-            const patch = record.patch;
-            patch_instance = output_patches[output_patch_cursor];
-
-            if (patch_instance === undefined) {
-                // no instance available for reuse - create a new one
-                patch_instance = new MicronGeometryPatchOccurrence();
-                output_patches[output_patch_cursor] = patch_instance;
-            }
-
-            patch_instance.instance_id = instance_id;
-            patch_instance.geometry_id = geometry_id;
-            patch_instance.patch = patch;
-            patch_instance.transform = transform;
-
-            output_patch_cursor++;
-        }
-
-        output.patch_count = output_patch_cursor;
 
+        const added_patch_count = get_geometry_patch_cut(
+            output_patches,
+            output.patch_count,
+            refinement_spec,
+            geometry,
+            instance_id,
+            transform
+        );
 
-        // TODO sort patches based on camera distance to better utilize z-culling in hardware
+        output.patch_count += added_patch_count;
     }
 
     clearScene() {

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

@@ -0,0 +1,123 @@
+import { BitSet } from "../../../../../core/binary/BitSet.js";
+import { aabb3_intersects_frustum_array } from "../../../../../core/bvh2/aabb3/aabb3_intersects_frustum_array.js";
+import { MicronGeometryPatchOccurrence } from "../../format/MicronGeometryPatchOccurance.js";
+import { aabb3_estimate_projected_area2 } from "../../../../../core/geom/3d/aabb/aabb3_estimate_projected_area2.js";
+
+
+/**
+ *
+ * @type {BitSet}
+ */
+const scratch_traversal_bitset = new BitSet();
+scratch_traversal_bitset.preventShrink();
+
+/**
+ * @readonly
+ * @type {MicronGeometryPatch[]}
+ */
+const scratch_traversal_stack = [];
+
+/**
+ *
+ * @param {MicronGeometryPatchOccurrence[]} destination
+ * @param {number} destination_offset
+ * @param {RefinementSpec} spec
+ * @param {MicronGeometry} geometry
+ * @param instance_id
+ * @param transform
+ * @returns {number}
+ */
+export function get_geometry_patch_cut(
+    destination,
+    destination_offset,
+    spec,
+    geometry,
+    instance_id,
+    transform
+) {
+
+    const frustum_planes = spec.frustum_f32;
+    const projection_matrix = spec.projection_matrix;
+    const error_threshold = spec.error_threshold_normalized;
+
+    let output_patch_cursor = destination_offset;
+
+    let i;
+    let stack_cursor = 1;
+    let patch_instance;
+
+    // initialize stack
+    const stack = scratch_traversal_stack;
+    const root = geometry.root;
+    stack[0] = root;
+
+    const included_set = scratch_traversal_bitset;
+    included_set.reset();
+
+    included_set.set(root.id, true);
+
+    while (stack_cursor > 0) {
+        stack_cursor--;
+
+        const patch = stack[stack_cursor];
+
+        /*
+         check if node is in view frustum
+         NOTE: following suggestion in "FastMesh: Efficient View-dependent Meshing" by Renato Pajarola et al, we can do a more coarse frustum test approximating frustum as a cone initially
+         */
+        const in_view_frustum = aabb3_intersects_frustum_array(patch.bounding_box, frustum_planes);
+
+        if (!in_view_frustum) {
+            continue;
+        }
+
+        // check if record needs to be split
+        if (patch.lod > 0) {
+
+            // not the lowest level of LOD, see if subdivision might be necessary
+
+            // compute average triangle area
+            // const group_screen_area = aabb3_project_to_2d(patch.group_bounding_box_corners, projection_matrix);
+            const group_screen_area = aabb3_estimate_projected_area2(patch.group_bounding_box, projection_matrix);
+            const screen_space_error = patch.group_error * group_screen_area;
+
+            if (screen_space_error > error_threshold) {
+                // error too large, needs to be split
+
+                const children = patch.children;
+                const child_count = children.length;
+
+                for (i = 0; i < child_count; i++) {
+                    const child = children[i];
+
+                    if (included_set.getAndSet(child.id)) {
+                        continue;
+                    }
+
+                    stack[stack_cursor++] = child;
+                }
+
+                continue;
+            }
+        }
+
+
+        patch_instance = destination[output_patch_cursor];
+
+        if (patch_instance === undefined) {
+            // no instance available for reuse - create a new one
+            patch_instance = new MicronGeometryPatchOccurrence();
+            destination[output_patch_cursor] = patch_instance;
+        }
+
+        patch_instance.instance_id = instance_id;
+        patch_instance.geometry_id = geometry.id;
+        patch_instance.patch = patch;
+        patch_instance.transform = transform;
+
+        output_patch_cursor++;
+
+    }
+
+    return output_patch_cursor - destination_offset;
+}

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