@woosh/meep-engine 2.33.2 → 2.33.6

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

@@ -1,102 +1,8 @@
 import { ActivePatchRecord } from "./ActivePatchRecord.js";
 import { ActivePatchFlags } from "./ActivePatchFlags.js";
-import { PI_HALF } from "../../../../../core/math/MathUtils.js";
-import { v3_angleBetween } from "../../../../../core/geom/Vector3.js";
 import { aabb3_project_to_2d } from "../../../../../core/geom/3d/aabb/aabb3_compute_projected_area.js";
-import AABB2 from "../../../../../core/geom/AABB2.js";
-import { approximateTriangleArea } from "../approximateTriangleArea.js";
 import { BitSet } from "../../../../../core/binary/BitSet.js";
-
-const scratch_aabb2 = new AABB2();
-
-/**
- *
- * @param {RefinementSpec} refinement_spec
- * @param {MicronGeometryPatch} patch
- * @returns {boolean}
- */
-function is_patch_facing_back(refinement_spec, patch) {
-
-    const normal_cone = patch.normal_cone;
-    const normal_cone_angle = normal_cone.angle;
-
-    // Do normal cone check against view angle
-    if (normal_cone_angle < PI_HALF) {
-        // compute view direction
-        // TODO position might be way off from the surface center, as well as patch might curve a lot more than expected, need to account for that
-
-        const bounds_center_x = patch.bounding_sphere[0];
-        const bounds_center_y = patch.bounding_sphere[1];
-        const bounds_center_z = patch.bounding_sphere[2];
-
-        const view_direction_x = refinement_spec.view_position[0] - bounds_center_x;
-        const view_direction_y = refinement_spec.view_position[1] - bounds_center_y;
-        const view_direction_z = refinement_spec.view_position[2] - bounds_center_z;
-
-        // compute view angle of the bounding sphere
-        const normal_cone_direction = normal_cone.direction;
-
-        const angle = v3_angleBetween(
-            view_direction_x, view_direction_y, view_direction_z,
-            normal_cone_direction.x, normal_cone_direction.y, normal_cone_direction.z
-        );
-
-        if (angle > normal_cone_angle + PI_HALF) {
-            return false;
-        }
-
-    }
-
-    return true;
-}
-
-/**
- *
- * @param {RefinementSpec} refinement_spec
- * @param {MicronGeometryPatch} node
- * @returns {boolean}
- */
-function is_patch_visible(refinement_spec, node) {
-
-    // check if node is in view frustum
-    const bounding_box = node.bounding_box;
-    const in_view_frustum = bounding_box.intersectFrustum(refinement_spec.frustum);
-
-    if (!in_view_frustum) {
-        // outside of view frustum, cull
-        return false;
-    }
-
-
-    // compute projected bounds of the patch
-    aabb3_project_to_2d(scratch_aabb2, bounding_box, refinement_spec.projection_matrix);
-
-    // Cull by screen area
-    const normalized_screen_area = scratch_aabb2.computeArea();
-    const patch_screen_area = normalized_screen_area * refinement_spec.viewport_area;
-
-    if (patch_screen_area < refinement_spec.error_threshold) {
-        // the whole patch is too small, cull
-        return false;
-    }
-
-    return true;
-}
-
-/**
- *
- * @param {AABB3} bounding_box
- * @param {RefinementSpec} spec
- * @returns {number}
- */
-function compute_projected_area(bounding_box, spec) {
-    aabb3_project_to_2d(scratch_aabb2, bounding_box, spec.projection_matrix);
-
-    // Cull by screen area
-    const normalized_screen_area = scratch_aabb2.computeArea();
-    const patch_screen_area = normalized_screen_area * spec.viewport_area;
-    return patch_screen_area;
-}
+import { aabb3_intersects_frustum } from "../../../../../core/bvh2/aabb3/aabb3_intersects_frustum.js";
 
 export class ActivePatchList {
     constructor() {
@@ -117,6 +23,19 @@ export class ActivePatchList {
          * @type {BitSet}
          */
         this.unfolded = new BitSet();
+
+        // prevent re-allocation related thrashing
+        this.unfolded.preventShrink();
+    }
+
+    clear() {
+        const unfolded = this.unfolded;
+
+        unfolded.reset();
+
+        ActivePatchRecord.pool_release_all(this.records);
+
+        this.records = null;
     }
 
     /**
@@ -124,13 +43,16 @@ export class ActivePatchList {
      * @param {MicronGeometry} geometry
      */
     initializeFromGeometry(geometry) {
-        const record = ActivePatchRecord.fromPatch(geometry.root);
+        this.clear();
 
+        const record = ActivePatchRecord.pool_get();
+
+        record.patch = geometry.root;
         record.link_next = null;
         record.link_previous = null;
 
-        this.unfolded.reset();
-        this.unfolded.set(record.patch.id, true);
+        const unfolded = this.unfolded;
+        unfolded.set(record.patch.id, true);
 
         this.records = record;
     }
@@ -138,6 +60,7 @@ export class ActivePatchList {
     /**
      *
      * @param {ActivePatchRecord} record
+     * @returns {ActivePatchRecord}
      */
     node_split(record) {
 
@@ -150,19 +73,24 @@ export class ActivePatchList {
 
             const child_id = child.id;
 
-            if (unfolded.get(child_id)) {
+            if (unfolded.getAndSet(child_id)) {
                 // already unfolded, skip
                 continue;
             }
 
-            const child_record = ActivePatchRecord.fromPatch(child);
+            const child_record = ActivePatchRecord.pool_get();
+            child_record.patch = child;
 
             this.record_insert_after(record, child_record);
-
-            unfolded.set(child_id, true);
         }
 
         this.record_remove(record);
+
+        const next = record.link_next;
+
+        ActivePatchRecord.pool_release(record);
+
+        return next;
     }
 
     /**
@@ -226,36 +154,6 @@ export class ActivePatchList {
         this.record_remove(b);
     }
 
-    /**
-     *
-     * @param {ActivePatchRecord} record
-     * @param {RefinementSpec} spec
-     */
-    node_try_merge(record, spec) {
-        const next = record.link_next;
-        if (next === null) {
-            // no next record
-            return;
-        }
-
-        return;
-
-        const parent = record.patch.parent;
-
-        if (parent !== next.patch.parent) {
-            // not a sibling
-            return;
-        }
-
-        const patch_screen_area = compute_projected_area(parent.bounding_box, spec);
-
-        const approximate_triangle_area = patch_screen_area * approximateTriangleArea(parent);
-
-        if (approximate_triangle_area <= spec.error_threshold) {
-            this.node_merge(record, next);
-        }
-
-    }
 
     /**
      * Populate with LOD-X of a given geometry
@@ -286,7 +184,13 @@ export class ActivePatchList {
      */
     refine(spec) {
 
-        for (let record = this.records; record !== null; record = record.link_next) {
+        const frustum_planes = spec.frustum_f32;
+        const projection_matrix = spec.projection_matrix;
+        const error_threshold = spec.error_threshold_normalized;
+
+        let record = this.records
+
+        for (; record !== null;) {
 
             const node = record.patch;
 
@@ -297,32 +201,17 @@ export class ActivePatchList {
              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 bounding_box = node.bounding_box;
-            const in_view_frustum = bounding_box.intersectFrustum(spec.frustum);
+            const in_view_frustum = aabb3_intersects_frustum(node.bounding_box, frustum_planes);
 
             if (!in_view_frustum) {
                 // outside of view frustum, cull
                 if (prev_is_visible) {
                     record.clearFlag(ActivePatchFlags.Visible);
                 }
+                record = record.link_next;
                 continue;
             }
 
-            // compute projected bounds of the patch
-            // const patch_screen_area = compute_projected_area(bounding_box, spec);
-
-            // const patch_is_too_small_to_be_seen = patch_screen_area < spec.error_threshold;
-            //
-            // if (patch_is_too_small_to_be_seen) {
-            //     // the whole patch is too small, cull
-            //     if (prev_is_visible) {
-            //         record.clearFlag(ActivePatchFlags.Visible);
-            //     }
-            //
-            //     // try to merge with sibling
-            //     continue;
-            // }
-
             if (!prev_is_visible) {
                 record.setFlag(ActivePatchFlags.Visible);
             }
@@ -340,22 +229,17 @@ export class ActivePatchList {
                 // not the lowest level of LOD, see if subdivision might be necessary
 
                 // compute average triangle area
-                const group_screen_area = compute_projected_area(node.group_bounding_box, spec);
+                const group_screen_area = aabb3_project_to_2d(node.group_bounding_box_corners, projection_matrix);
                 const screen_space_error = node.group_error * group_screen_area;
 
-
-                if (screen_space_error > spec.error_threshold) {
+                if (screen_space_error > error_threshold) {
                     // error too large, needs to be split
-                    this.node_split(record);
+                    record = this.node_split(record);
                     continue;
                 }
             }
 
-
-            // check if record and its sibling can be merged
-            // if (approximate_triangle_area < spec.error_threshold) {
-            //     this.node_try_merge(record, spec);
-            // }
+            record = record.link_next;
         }
     }
 }

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

@@ -60,8 +60,6 @@ export class ActivePatchRecord {
         patch_pool_size--;
 
         // reset record
-        r.link_next = null;
-
         r.flags = 0;
 
         return r;
@@ -91,6 +89,10 @@ export class ActivePatchRecord {
      * @param {ActivePatchRecord} r
      */
     static pool_release_all(r) {
+        if (r === null) {
+            return;
+        }
+
         let p = r;
 
         for (; patch_pool_size < patch_limit;) {

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

@@ -0,0 +1,98 @@
+import Vector2 from "../../../../../core/geom/Vector2.js";
+import { mat4 } from "gl-matrix";
+import { array_setFromProjectionMatrix } from "./array_setFromProjectionMatrix.js";
+
+export class RefinementSpec {
+    constructor() {
+
+        /**
+         * Viewport resolution
+         * @type {Vector2}
+         */
+        this.resolution = new Vector2();
+
+        /**
+         * Number of pixels in the viewport
+         * @type {number}
+         */
+        this.viewport_area = 0;
+
+        /**
+         * How much error to accept when deciding to subdivide a cluster
+         * Measured in pixels
+         * Higher value will result in better performance but more visible artifacts
+         * @type {number}
+         */
+        this.error_threshold = 1;
+
+        /**
+         * Error threshold as a fraction of the screen area instead of pixels, derived internally from pixel value
+         * @type {number}
+         */
+        this.error_threshold_normalized = 1;
+
+        /**
+         * Continuous memory region for faster access
+         * @type {ArrayBuffer}
+         */
+        const array_buffer = new ArrayBuffer(160);
+
+        /**
+         * Object-space camera frustum
+         * Frustum planes in compact form
+         * @type {Float32Array}
+         */
+        this.frustum_f32 = new Float32Array(array_buffer, 0, 24);
+
+
+        /**
+         * Contains transformation from camera space to object space
+         * @type {Float32Array|number[]|mat4}
+         */
+        this.projection_matrix = new Float32Array(array_buffer, 24 * 4, 16);
+
+        /**
+         * Model world transform
+         * @type {Float32Array|number[]|mat4}
+         */
+        // this.transform = new Float32Array(16);
+
+        /**
+         * Object-space camera position
+         * @type {Float32Array}
+         */
+        this.view_position = new Float32Array(3);
+    }
+
+    get frustum() {
+        throw new Error('deprecated, use .frustum_f32 instead');
+    }
+
+    setResolution(x, y) {
+        this.resolution.set(x, y);
+
+        this.viewport_area = x * y;
+
+        this.error_threshold_normalized = this.error_threshold / this.viewport_area;
+    }
+
+    /**
+     *
+     * @param {number[]|mat4|Float32Array|ArrayLike<number>} transform world-space object transform
+     * @param {number[]|mat4|Float32Array|ArrayLike<number>} matrix_world_inverse camera's world inverse matrix
+     * @param {number[]|mat4|Float32Array|ArrayLike<number>} matrix_projection camera's projection matrix
+     */
+    build(transform, matrix_world_inverse, matrix_projection) {
+        // const _transform = this.transform;
+        // _transform.set(transform);
+
+        // build projection matrix
+        const projection_matrix = this.projection_matrix;
+
+        mat4.multiply(projection_matrix, matrix_world_inverse, transform);
+        mat4.multiply(projection_matrix, matrix_projection, projection_matrix);
+
+        // compute view frustum in model-space
+        array_setFromProjectionMatrix(this.frustum_f32, projection_matrix);
+    }
+}

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

@@ -0,0 +1,25 @@
+import { v3_length } from "../../../../../core/geom/Vector3.js";
+
+/**
+ * Normalize a plane in-place
+ * @param {number[]} source
+ * @param {number} source_offset
+ */
+function array_normalize_plane(source, source_offset) {
+    const _x = source[source_offset];
+    const _y = source[source_offset + 1];
+    const _z = source[source_offset + 2];
+
+    const length = v3_length(_x, _y, _z);
+
+    const inverseNormalLength = 1.0 / length;
+
+    /*
+    By re-using values already in the registers instead of using *= we save a few extra READ ops
+     */
+    source[source_offset] = _x * inverseNormalLength;
+    source[source_offset + 1] = _y * inverseNormalLength;
+    source[source_offset + 2] = _z * inverseNormalLength;
+
+    source[source_offset + 3] *= inverseNormalLength;
+}

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

@@ -0,0 +1,60 @@
+import { v3_length } from "../../../../../core/geom/Vector3.js";
+
+/**
+ *
+ * @param {number[]} destination
+ * @param {number} destination_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} w
+ */
+function array_set_plane_normalized(destination, destination_offset, x, y, z, w) {
+    const length = v3_length(x, y, z);
+
+    const inverseNormalLength = 1.0 / length;
+
+    destination[destination_offset] = x * inverseNormalLength;
+    destination[destination_offset + 1] = y * inverseNormalLength;
+    destination[destination_offset + 2] = z * inverseNormalLength;
+    destination[destination_offset + 3] = w * inverseNormalLength;
+}
+
+/**
+ *
+ * @param {number[]|Float32Array} frustum_planes
+ * @param {number[]} me
+ */
+export function array_setFromProjectionMatrix(frustum_planes, me) {
+
+    const me0 = me[0];
+    const me3 = me[3];
+
+    const me4 = me[4];
+    const me7 = me[7];
+
+    const me8 = me[8];
+    const me11 = me[11];
+
+    const me12 = me[12];
+    const me15 = me[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];
+
+    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];
+
+    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/graphics/micron/render/refinement/is_patch_facing_back.js

@@ -0,0 +1,43 @@
+import { PI_HALF } from "../../../../../core/math/MathUtils.js";
+import { v3_angleBetween } from "../../../../../core/geom/Vector3.js";
+
+/**
+ *
+ * @param {RefinementSpec} refinement_spec
+ * @param {MicronGeometryPatch} patch
+ * @returns {boolean}
+ */
+function is_patch_facing_back(refinement_spec, patch) {
+
+    const normal_cone = patch.normal_cone;
+    const normal_cone_angle = normal_cone.angle;
+
+    // Do normal cone check against view angle
+    if (normal_cone_angle < PI_HALF) {
+        // compute view direction
+        // TODO position might be way off from the surface center, as well as patch might curve a lot more than expected, need to account for that
+
+        const bounds_center_x = patch.bounding_sphere[0];
+        const bounds_center_y = patch.bounding_sphere[1];
+        const bounds_center_z = patch.bounding_sphere[2];
+
+        const view_direction_x = refinement_spec.view_position[0] - bounds_center_x;
+        const view_direction_y = refinement_spec.view_position[1] - bounds_center_y;
+        const view_direction_z = refinement_spec.view_position[2] - bounds_center_z;
+
+        // compute view angle of the bounding sphere
+        const normal_cone_direction = normal_cone.direction;
+
+        const angle = v3_angleBetween(
+            view_direction_x, view_direction_y, view_direction_z,
+            normal_cone_direction.x, normal_cone_direction.y, normal_cone_direction.z
+        );
+
+        if (angle > normal_cone_angle + PI_HALF) {
+            return false;
+        }
+
+    }
+
+    return true;
+}

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

@@ -0,0 +1,37 @@
+import AABB2 from "../../../../../core/geom/AABB2.js";
+import { aabb3_project_to_2d } from "../../../../../core/geom/3d/aabb/aabb3_compute_projected_area.js";
+
+const scratch_aabb2 = new AABB2();
+
+/**
+ *
+ * @param {RefinementSpec} refinement_spec
+ * @param {MicronGeometryPatch} node
+ * @returns {boolean}
+ */
+function is_patch_visible(refinement_spec, node) {
+
+    // check if node is in view frustum
+    const bounding_box = node.bounding_box;
+    const in_view_frustum = bounding_box.intersectFrustum(refinement_spec.frustum);
+
+    if (!in_view_frustum) {
+        // outside of view frustum, cull
+        return false;
+    }
+
+
+    // compute projected bounds of the patch
+    aabb3_project_to_2d(scratch_aabb2, bounding_box, refinement_spec.projection_matrix);
+
+    // Cull by screen area
+    const normalized_screen_area = scratch_aabb2.computeArea();
+    const patch_screen_area = normalized_screen_area * refinement_spec.viewport_area;
+
+    if (patch_screen_area < refinement_spec.error_threshold) {
+        // the whole patch is too small, cull
+        return false;
+    }
+
+    return true;
+}

package/engine/graphics/micron/render/v1/MaterialVertexSpec.js

@@ -12,6 +12,27 @@ export class MaterialVertexSpec {
         this.material = null;
     }
 
+    /**
+     *
+     * @param {MaterialVertexSpec} other
+     */
+    copy(other) {
+        this.spec = other.spec;
+        this.material = other.material;
+    }
+
+    /**
+     *
+     * @return {MaterialVertexSpec}
+     */
+    clone() {
+        const r = new MaterialVertexSpec();
+
+        r.copy(this);
+
+        return r;
+    }
+
     /**
      * @param {MicronVertexDataSpec} spec
      * @param {Material} material

package/engine/graphics/micron/render/v1/VGThreeRenderer.js

@@ -7,6 +7,12 @@ import { HashMap } from "../../../../../core/collection/HashMap.js";
 import Signal from "../../../../../core/events/signal/Signal.js";
 import { array_copy } from "../../../../../core/collection/array/copyArray.js";
 
+/**
+ *
+ * @type {MaterialVertexSpec}
+ */
+const scratch_mvc = new MaterialVertexSpec();
+
 export class VGThreeRenderer {
     constructor() {
         this.geometry = new VirtualGeometry();
@@ -32,13 +38,6 @@ export class VGThreeRenderer {
          */
         this.__contexts_array = [];
 
-        /**
-         *
-         * @type {Scene|null}
-         * @private
-         */
-        this.__scene = null;
-
         /**
          *
          * @type {Object3D[]}
@@ -75,14 +74,18 @@ export class VGThreeRenderer {
      * @private
      */
     __obtain_material(spec, m) {
-        const key = MaterialVertexSpec.from(spec, m);
+        scratch_mvc.material = m;
+        scratch_mvc.spec = spec;
 
-        const existing = this.material_contexts.get(key);
+        const existing = this.material_contexts.get(scratch_mvc);
 
         if (existing !== undefined) {
             return existing;
         }
 
+        // create a separate instance to be stored alongside the context
+        const key = scratch_mvc.clone();
+
         const ctx = new MaterialContext(spec, m);
 
         ctx.init(this.__gl_context);

package/engine/graphics/micron/util/unit_hemioct.spec.js

@@ -1,5 +1,5 @@
 import { decode_hemioct_to_unit, encode_unit_to_hemioct } from "./encode_unit3_hemioct.js";
-import { v3Length_i } from "../../../../core/geom/Vector3.js";
+import { v3_length } from "../../../../core/geom/Vector3.js";
 
 test('encode-decode', () => {
     const v0 = [];
@@ -7,7 +7,7 @@ test('encode-decode', () => {
 
     function validate(x, y, z) {
         // normalize input
-        const l = 1 / v3Length_i(x, y, z);
+        const l = 1 / v3_length(x, y, z);
 
         const _x = x * l;
         const _y = y * l;