@woosh/meep-engine 2.126.43 → 2.126.44

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.43",
+  "version": "2.126.44",
   "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

@@ -2,9 +2,9 @@
  *
  * @param {number[]} result
  * @param {number} result_offset
- * @param {number} constrained_planes_mask if bit is set to 1, that plane is not allowed to move
+ * @param {number} plane_mask if bit is set to 0, that plane is not allowed to move
  * @param {BVH} bvh
  * @param {number[]|ArrayLike<number>|Float32Array} frustum
  */
-export function compute_tight_near_far_clipping_planes(result: number[], result_offset: number, constrained_planes_mask: number, bvh: BVH, frustum: number[] | ArrayLike<number> | Float32Array): boolean;
+export function compute_tight_near_far_clipping_planes(result: number[], result_offset: number, plane_mask: number, bvh: BVH, frustum: number[] | ArrayLike<number> | Float32Array): boolean;
 //# sourceMappingURL=compute_tight_near_far_clipping_planes.d.ts.map

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":"AAcA;;;;;;;GAOG;AACH,+DANW,MAAM,EAAE,iBACR,MAAM,2BACN,MAAM,OACN,GAAG,WACH,MAAM,EAAE,GAAC,SAAS,CAAC,MAAM,CAAC,GAAC,YAAY,WAuIjD"}
+{"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;;;;;;;GAOG;AACH,+DANW,MAAM,EAAE,iBACR,MAAM,cACN,MAAM,OACN,GAAG,WACH,MAAM,EAAE,GAAC,SAAS,CAAC,MAAM,CAAC,GAAC,YAAY,WA+LjD"}

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

@@ -1,28 +1,39 @@
-//
-
-
 import { array_copy } from "../../../collection/array/array_copy.js";
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { aabb3_array_intersects_frustum_degree } from "../../../geom/3d/aabb/aabb3_array_intersects_frustum_degree.js";
 import { v3_distance_above_plane } from "../../../geom/vec3/v3_distance_above_plane.js";
 import { NULL_NODE } from "../BVH.js";
-import { bvh_collect_user_data } from "./bvh_collect_user_data.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 const scratch_aabb = [];
 
+const scratch_frustum = new Float32Array(24);
+
 /**
  *
  * @param {number[]} result
  * @param {number} result_offset
- * @param {number} constrained_planes_mask if bit is set to 1, that plane is not allowed to move
+ * @param {number} plane_mask if bit is set to 0, that plane is not allowed to move
  * @param {BVH} bvh
  * @param {number[]|ArrayLike<number>|Float32Array} frustum
  */
-export function compute_tight_near_far_clipping_planes(result, result_offset, constrained_planes_mask, bvh, frustum) {
+export function compute_tight_near_far_clipping_planes(
+    result,
+    result_offset,
+    plane_mask,
+    bvh,
+    frustum
+) {
+
     // initialize result
-    array_copy(frustum, 0, result, result_offset, 24);
+    array_copy(frustum, 0, scratch_frustum, 0, 24);
+
+    // set output planes to infinity so we can slowly bring them in
+    for (let i = 0; i < 6; i++) {
+        if (((plane_mask >> i) & 1) === 1) {
+            scratch_frustum[i * 4 + 3] = Infinity;
+        }
+    }
 
     const root = bvh.root;
 
@@ -68,13 +79,19 @@ export function compute_tight_near_far_clipping_planes(result, result_offset, co
         const _z1 = scratch_aabb[5];
 
         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;
 
             //read out plane
-            const plane_normal_x = frustum[plane_address];
-            const plane_normal_y = frustum[plane_address + 1];
-            const plane_normal_z = frustum[plane_address + 2];
-            const plane_offset = frustum[plane_address + 3];
+            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
@@ -112,45 +129,81 @@ export function compute_tight_near_far_clipping_planes(result, result_offset, co
                 continue node_loop;
             }
 
-            if ((constrained_planes_mask & (1 << plane_index)) !== 0) {
-                // plane is constrained, we're done here
-                continue;
-            }
-
-            //
-
         }
 
-        const intersection = aabb3_array_intersects_frustum_degree(scratch_aabb, 0, frustum);
-
-        if (intersection === 0) {
-            // fully outside
-            continue;
-        }
 
         const node_is_leaf = bvh.node_is_leaf(node);
 
         if (!node_is_leaf) {
 
-            if (intersection === 2) {
-                // fully inside, fast collection path
-                result_cursor += bvh_collect_user_data(result, result_cursor, bvh, node);
-            } else {
-                // partially inside
-                // read in-order
-                const child1 = bvh.node_get_child1(node);
-                const child2 = bvh.node_get_child2(node);
-
-                // write to stack in reverse order, so that fist child ends up being visited first
-                stack[stack.pointer++] = child1;
-                stack[stack.pointer++] = child2;
-            }
+            // inside
+            // read in-order
+            const child1 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
+
+            // write to stack in reverse order, so that fist child ends up being visited first
+            stack[stack.pointer++] = child1;
+            stack[stack.pointer++] = child2;
 
         } else {
+
             // leaf node
 
+            // update planes
+            for (let i = 0; i < 6; i++) {
+                if (((plane_mask >> i) & 1) === 1) {
+
+                    const plane_address = i * 4;
+
+                    //read out plane
+                    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
+                    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(
+                        x1, y1, z1,
+                        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;
+                    }
+                }
+            }
+
         }
     }
 
-    return true;
+    // TODO check if results are still at infinity
+
+    array_copy(scratch_frustum, 0, result, result_offset, 24);
+
 }