@woosh/meep-engine 2.126.51 → 2.126.53

package/package.json

@@ -5,7 +5,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.126.51",
+  "version": "2.126.53",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.d.ts

@@ -1,5 +1,4 @@
 /**
- *
  * @param {number[]} result
  * @param {number} result_offset
  * @param {number} plane_mask if bit is set to 0, that plane is not allowed to move

package/src/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_tight_near_far_clipping_planes.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.js"],"names":[],"mappings":"AAWA;;;;;;;;GAQG;AACH,+DAPW,MAAM,EAAE,iBACR,MAAM,cACN,MAAM,OACN,GAAG,WACH,MAAM,EAAE,GAAC,SAAS,CAAC,MAAM,CAAC,GAAC,YAAY,GACrC,OAAO,CAkMnB"}
+{"version":3,"file":"compute_tight_near_far_clipping_planes.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.js"],"names":[],"mappings":"AAYA;;;;;;;GAOG;AACH,+DAPW,MAAM,EAAE,iBACR,MAAM,cACN,MAAM,OACN,GAAG,WACH,MAAM,EAAE,GAAC,SAAS,CAAC,MAAM,CAAC,GAAC,YAAY,GACrC,OAAO,CA4MnB"}

package/src/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.js

@@ -1,3 +1,4 @@
+import { assert } from "../../../assert.js";
 import { array_copy } from "../../../collection/array/array_copy.js";
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 import { v3_distance_above_plane } from "../../../geom/vec3/v3_distance_above_plane.js";
@@ -10,7 +11,6 @@ const scratch_aabb = [];
 const scratch_frustum = new Float32Array(24);
 
 /**
- *
  * @param {number[]} result
  * @param {number} result_offset
  * @param {number} plane_mask if bit is set to 0, that plane is not allowed to move
@@ -25,6 +25,8 @@ export function compute_tight_near_far_clipping_planes(
     bvh,
     frustum
 ) {
+    assert.isNonNegativeInteger(result_offset, 'result_offset');
+    assert.isNonNegativeInteger(plane_mask, 'plane_mask');
 
     // initialize result
     array_copy(frustum, 0, scratch_frustum, 0, 24);
@@ -79,12 +81,12 @@ export function compute_tight_near_far_clipping_planes(
         const _y1 = scratch_aabb[4];
         const _z1 = scratch_aabb[5];
 
+        // bitset of relaxed planes affected by this node
+        // lets us discard intermediate nodes that would not affect any planes
+        let collision_mask = 0;
+
         for (let plane_index = 0; plane_index < 6; plane_index++) {
 
-            if (((plane_mask >> plane_index) & 1) === 1) {
-                // plane is not fixed, we're done here
-                continue;
-            }
 
             const plane_address = plane_index * 4;
 
@@ -120,24 +122,43 @@ export function compute_tight_near_far_clipping_planes(
                 z1 = _z0;
             }
 
-            const distance_above_plane = v3_distance_above_plane(
-                x1, y1, z1,
-                plane_normal_x, plane_normal_y, plane_normal_z, plane_offset
-            );
+            if (((plane_mask >> plane_index) & 1) === 1) {
+                // plane is not fixed, we're done here
 
-            if (distance_above_plane < 0) {
-                // below plane, reject this branch
-                continue node_loop;
-            }
+                const distance_above_plane = v3_distance_above_plane(
+                    x0, y0, z0,
+                    plane_normal_x, plane_normal_y, plane_normal_z, 0
+                );
 
-        }
+                if (distance_above_plane < plane_offset) {
+                    collision_mask |= (1 << plane_index);
+                }
+
+            } else {
+
+                // fixed plane
+                const distance_above_plane = v3_distance_above_plane(
+                    x1, y1, z1,
+                    plane_normal_x, plane_normal_y, plane_normal_z, plane_offset
+                );
+
+                if (distance_above_plane < 0) {
+                    // below plane, reject this branch
+                    continue node_loop;
+                }
 
+            }
+        }
 
 
         const node_is_leaf = bvh.node_is_leaf(node);
 
         if (!node_is_leaf) {
-            // TODO skip node if it is fully within unconstrained planes already
+
+            if (collision_mask === 0) {
+                // does not affect any planes, skip
+                continue;
+            }
 
             // inside
             // read in-order
@@ -152,9 +173,9 @@ export function compute_tight_near_far_clipping_planes(
 
             // leaf node
 
-            // update planes
+            // expand planes
             for (let i = 0; i < 6; i++) {
-                if (((plane_mask >> i) & 1) === 1) {
+                if (((collision_mask >> i) & 1) === 1) {
 
                     const plane_address = i * 4;
 
@@ -162,43 +183,32 @@ export function compute_tight_near_far_clipping_planes(
                     const plane_normal_x = scratch_frustum[plane_address];
                     const plane_normal_y = scratch_frustum[plane_address + 1];
                     const plane_normal_z = scratch_frustum[plane_address + 2];
-                    const plane_offset = scratch_frustum[plane_address + 3];
 
-
-                    // construct nearest and farthest corners along the plane normal
+                    // get the nearest corner along the plane normal
                     if (plane_normal_x > 0) {
                         x0 = _x0;
-                        x1 = _x1;
                     } else {
                         x0 = _x1;
-                        x1 = _x0;
                     }
 
                     if (plane_normal_y > 0) {
                         y0 = _y0;
-                        y1 = _y1;
                     } else {
                         y0 = _y1;
-                        y1 = _y0;
                     }
 
                     if (plane_normal_z > 0) {
                         z0 = _z0;
-                        z1 = _z1;
                     } else {
                         z0 = _z1;
-                        z1 = _z0;
                     }
 
-                    const distance_above_plane = v3_distance_above_plane(
+                    // move plane
+                    scratch_frustum[plane_address + 3] = v3_distance_above_plane(
                         x0, y0, z0,
                         plane_normal_x, plane_normal_y, plane_normal_z, 0
                     );
 
-                    if (distance_above_plane < plane_offset) {
-                        // move plane
-                        scratch_frustum[plane_address + 3] = distance_above_plane;
-                    }
                 }
             }