@woosh/meep-engine 2.131.33 → 2.131.35

package/package.json

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

package/src/core/bvh2/binary/2/bvh32_query_user_data_ray.d.ts

@@ -9,7 +9,8 @@
  * @param {number} direction_x
  * @param {number} direction_y
  * @param {number} direction_z
+ * @param {number} max_distance tMax for the ray, can set to Infinity if you don't care.
  * @returns {number}
  */
-export function bvh32_query_user_data_ray(result: number[], result_offset: number, bvh: BinaryUint32BVH, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number): number;
+export function bvh32_query_user_data_ray(result: number[], result_offset: number, bvh: BinaryUint32BVH, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, max_distance: number): number;
 //# sourceMappingURL=bvh32_query_user_data_ray.d.ts.map

package/src/core/bvh2/binary/2/bvh32_query_user_data_ray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh32_query_user_data_ray.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/binary/2/bvh32_query_user_data_ray.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AACH,kDAXW,MAAM,EAAE,iBACR,MAAM,kCAEN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,MAAM,CAgFlB"}
+{"version":3,"file":"bvh32_query_user_data_ray.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/binary/2/bvh32_query_user_data_ray.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,kDAZW,MAAM,EAAE,iBACR,MAAM,kCAEN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,GACJ,MAAM,CA8FlB"}

package/src/core/bvh2/binary/2/bvh32_query_user_data_ray.js

@@ -1,5 +1,8 @@
+import { assert } from "../../../assert.js";
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { aabb3_array_intersects_ray } from "../../../geom/3d/aabb/aabb3_array_intersects_ray.js";
+import {
+    aabb3_near_distance_to_intersection_ray_segment
+} from "../../../geom/3d/aabb/aabb3_near_distance_to_intersection_ray_segment.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
@@ -14,14 +17,19 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  * @param {number} direction_x
  * @param {number} direction_y
  * @param {number} direction_z
+ * @param {number} max_distance tMax for the ray, can set to Infinity if you don't care.
  * @returns {number}
  */
 export function bvh32_query_user_data_ray(
     result, result_offset,
     bvh,
     origin_x, origin_y, origin_z,
-    direction_x, direction_y, direction_z
+    direction_x, direction_y, direction_z,
+    max_distance,
 ) {
+
+    assert.isNumber(max_distance, "max_distance");
+
     let hit_count = 0;
 
     const binary_node_count = bvh.binary_node_count;
@@ -48,6 +56,11 @@ export function bvh32_query_user_data_ray(
     const float32 = bvh.float32;
     const uint32 = bvh.uint32;
 
+
+    const inv_direction_x = 1 / direction_x;
+    const inv_direction_y = 1 / direction_y;
+    const inv_direction_z = 1 / direction_z;
+
     do {
         stack.pointer--;
 
@@ -56,11 +69,16 @@ export function bvh32_query_user_data_ray(
 
         const node_address = bvh.getNodeAddress(node_index);
 
-        if (!aabb3_array_intersects_ray(
-            float32, node_address,
+        const t = aabb3_near_distance_to_intersection_ray_segment(
+            float32[node_address], float32[node_address + 1], float32[node_address + 2],
+            float32[node_address + 3], float32[node_address + 4], float32[node_address + 5],
             origin_x, origin_y, origin_z,
-            direction_x, direction_y, direction_z
-        )) {
+            inv_direction_x, inv_direction_y, inv_direction_z,
+            0,
+            max_distance
+        );
+
+        if (t >= max_distance) {
             continue;
         }
 

package/src/core/bvh2/bvh3/ebvh_optimize_treelet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_optimize_treelet.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_optimize_treelet.js"],"names":[],"mappings":"AAuNA;;;;;;;GAOG;AACH,uDAHW,MAAM,iBACN,MAAM,QA+IhB"}
+{"version":3,"file":"ebvh_optimize_treelet.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_optimize_treelet.js"],"names":[],"mappings":"AAgRA;;;;;;;GAOG;AACH,uDAHW,MAAM,iBACN,MAAM,QA+IhB"}

package/src/core/bvh2/bvh3/ebvh_optimize_treelet.js

@@ -1,15 +1,16 @@
 import { assert } from "../../assert.js";
 import { lsb_32 } from "../../binary/lsb_32.js";
 import { bitCount } from "../../binary/operations/bitCount.js";
-import { NULL_NODE } from "./BVH.js";
+import { ELEMENT_WORD_COUNT, NULL_NODE } from "./BVH.js";
 
 // Common continuous memory region for better cache performance
-const scratch_memory = new ArrayBuffer((256 * 3 + 16) * 4);
+const scratch_memory = new ArrayBuffer((256 * 3 + 16) * 4 + 256 * 6 * 4);
 
-const scratch_areas = new Float32Array(scratch_memory, 0, 256);
-const scratch_cost = new Float32Array(scratch_memory, 1024, 256);
-const scratch_partitions = new Uint32Array(scratch_memory, 2048, 256);
-const scratch_treelet = new Uint32Array(scratch_memory, 3072, 16);
+const scratch_bounds = new Float32Array(scratch_memory, 0, 256 * 6);
+const scratch_areas = new Float32Array(scratch_memory, 6144, 256);
+const scratch_cost = new Float32Array(scratch_memory, 7168, 256);
+const scratch_partitions = new Uint32Array(scratch_memory, 8192, 256);
+const scratch_treelet = new Uint32Array(scratch_memory, 9216, 16);
 
 /**
  *
@@ -74,28 +75,84 @@ function optimize_treelet(bvh, root, leaves, leaf_count) {
 
     // see "Fast Parallel Construction of High-Quality Bounding Volume Hierarchies", Algorithm 2
 
+    const bvh_float32 = bvh.data_float32;
+
     // Calculate surface area for each subset
-    for (let i = 0; i < leaf_count; i++) {
-        const leaf_0 = leaves[i];
-        for (let j = i + 1; j < leaf_count; j++) {
-            const leaf_1 = leaves[j];
+    const mask_limit = (1 << leaf_count) - 1;
+
+    for (let s = 1; s <= mask_limit; s++) {
+        let min_x, min_y, min_z, max_x, max_y, max_z;
+
+        // Check if 's' is a power of 2 (i.e., a single leaf)
+        // (s & (s-1)) === 0 is the standard trick for this
+        const is_a_leaf = (s & (s - 1)) === 0;
+
+        if (is_a_leaf) {
+            // --- CASE A: LEAF ---
+            // Map the mask bit back to a linear index (0..7)
+            const leaf_index = lsb_32(s);
+
+            // Read from your compact linear array
+            const node = leaves[leaf_index];
+
+            const source_offset = node * ELEMENT_WORD_COUNT;
+
+            min_x = bvh_float32[source_offset];
+            min_y = bvh_float32[source_offset + 1];
+            min_z = bvh_float32[source_offset + 2];
+            max_x = bvh_float32[source_offset + 3];
+            max_y = bvh_float32[source_offset + 4];
+            max_z = bvh_float32[source_offset + 5];
+
+            // Initialize base cost for leaf (SAH_COST_TRIANGLE * Area)
+            // (Calculated below)
+        } else {
+            // --- CASE B: SUBSET ---
+            // Split s into: LSB (Leaf) + Rest (Subset)
+            // Both of these are < s, so they are guaranteed to be initialized.
+            const mask_lsb = s & -s;       // Extract lowest set bit
+            const mask_rest = s ^ mask_lsb; // The rest of the bits
+
+            const i_lsb = mask_lsb * 6;
+            const i_rest = mask_rest * 6;
+
+            // Merge bounds
+            min_x = Math.min(scratch_bounds[i_lsb],     scratch_bounds[i_rest]);
+            min_y = Math.min(scratch_bounds[i_lsb + 1], scratch_bounds[i_rest + 1]);
+            min_z = Math.min(scratch_bounds[i_lsb + 2], scratch_bounds[i_rest + 2]);
+            max_x = Math.max(scratch_bounds[i_lsb + 3], scratch_bounds[i_rest + 3]);
+            max_y = Math.max(scratch_bounds[i_lsb + 4], scratch_bounds[i_rest + 4]);
+            max_z = Math.max(scratch_bounds[i_lsb + 5], scratch_bounds[i_rest + 5]);
+        }
 
-            const s = (1 << i) | (1 << j);
+        // --- STORE ---
+        const dest_offset = s * 6;
 
-            scratch_areas[s] = bvh.node_get_combined_surface_area(leaf_0, leaf_1)
-        }
-    }
+        scratch_bounds[dest_offset]     = min_x;
+        scratch_bounds[dest_offset + 1] = min_y;
+        scratch_bounds[dest_offset + 2] = min_z;
+        scratch_bounds[dest_offset + 3] = max_x;
+        scratch_bounds[dest_offset + 4] = max_y;
+        scratch_bounds[dest_offset + 5] = max_z;
 
-    // Initialize costs of individual leaves
-    for (let i = 0; i < leaf_count; i++) {
-        const leaf = leaves[i];
+        // Calculate Surface Area
+        const dx = max_x - min_x;
+        const dy = max_y - min_y;
+        const dz = max_z - min_z;
 
-        scratch_cost[1 << i] = SAH_COST_TRIANGLE * bvh.node_get_surface_area(leaf);
+        const area = 2.0 * (dx * dy + dy * dz + dz * dx);
+
+        scratch_areas[s] = area;
+
+        if(is_a_leaf){
+            // Initialize costs of individual leaves
+            scratch_cost[s] = SAH_COST_TRIANGLE * area;
+        }
     }
 
     // Optimize every subset of leaves
     for (let k = 2; k <= leaf_count; k++) {
-        for (let s = 1; s <= (1 << leaf_count) - 1; s++) {
+        for (let s = 1; s <= mask_limit; s++) {
             if (bitCount(s) !== k) {
                 continue;
             }
@@ -322,7 +379,7 @@ export function ebvh_optimize_treelet(
 
         } else if (came_from_type === CAME_FROM_TYPE_PARENT) {
             const child1 = bvh.node_get_child1(node);
-            const child2 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
 
             if (child1 !== NULL_NODE) {
                 came_from_type = CAME_FROM_TYPE_PARENT;

package/src/core/geom/3d/aabb/aabb3_near_distance_to_intersection_ray_segment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_near_distance_to_intersection_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_near_distance_to_intersection_ray_segment.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,oEAhBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,mBACN,MAAM,mBACN,MAAM,mBACN,MAAM,gBACN,MAAM,gBACN,MAAM,GACJ,MAAM,CA+ClB"}
+{"version":3,"file":"aabb3_near_distance_to_intersection_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_near_distance_to_intersection_ray_segment.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,oEAhBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,mBACN,MAAM,mBACN,MAAM,mBACN,MAAM,gBACN,MAAM,gBACN,MAAM,GACJ,MAAM,CAgDlB"}

package/src/core/geom/3d/aabb/aabb3_near_distance_to_intersection_ray_segment.js

@@ -60,6 +60,7 @@ export function aabb3_near_distance_to_intersection_ray_segment(
     const t_box_max = Math.min(t_max_x, t_max_y, t_max_z, max_distance);
 
     if (t_box_min > t_box_max) {
+        // signal a miss
         return Infinity;
     }
 

package/src/engine/ecs/terrain/tiles/TerrainTile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TerrainTile.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/tiles/TerrainTile.js"],"names":[],"mappings":";AAgCA;;GAEG;AACH;IACI,sBAA6B;IAC7B,eAA0B;IAC1B,cAAyB;IACzB,kBAAyB;IACzB,4BAAoC;IAEpC;;;OAGG;IACH,mBAAgB;IAChB,uGAAiE;IAGjE;;;OAGG;IACH,UAFU,MAAM,cAAc,CAEd;IAEhB;;;OAGG;IACH,WAFU,OAAO,CAEA;IAEjB;;;OAGG;IACH,cAFU,SAAS,CAEY;IAE/B;;;OAGG;IACH,KAFU,eAAe,CAEd;IAEX;;;OAGG;IACH,SAFU,OAAO,CAED;IAChB;;;OAGG;IACH,mBAFU,OAAO,CAES;IAC1B,uBAAmB;IAEnB;;;OAGG;IACH,SAFU,OAAO,WAAW,CAAC,CAEN;IACvB,4DAA2B;IAE3B;;;;OAIG;IACH,kBAWE;IAEF;;;;;OAKG;IACH,+BAAiG;IAEjG;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAqBZ;;;OAGG;IACH,6BAGC;IAfD;;;OAGG;IACH,0BAEC;IAWD;;;;;;;;;;OAUG;IACH,yBATW,aAAa,WACb,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACL,OAAO,CAkDlB;IAED,+CAKC;IAED,8CAOC;IAED;;;;;;;;;;OAUG;IACH,mBATW,WAAW,GAAC,SAAS,UACrB,WAAW,GAAC,SAAS,QACrB,WAAW,GAAC,SAAS,SACrB,WAAW,GAAC,SAAS,WACrB,WAAW,GAAC,SAAS,YACrB,WAAW,GAAC,SAAS,cACrB,WAAW,GAAC,SAAS,eACrB,WAAW,GAAC,SAAS,QAsN/B;IAED,2BAmFC;IAED;;;;OAIG;IACH,mCAHW,MAAM,cACN,MAAM,QAIhB;IAED,gBAYC;IAED;;;;OAIG;IACH,gBAHW;QAAC,QAAQ,CAAC;QAAC,GAAG,CAAC,EAAC;YAAC,UAAU,EAAC,MAAM,CAAC;YAAC,IAAI,EAAC,WAAW,CAAA;SAAC,CAAA;KAAC,QAoDhE;CACJ;oBAzlBmB,kCAAkC;4BAG1B,2CAA2C;sDAZhE,OAAO;0BAEY,yCAAyC;gCADnC,mDAAmD;mBAGhE,0CAA0C;8BAI/B,2CAA2C"}
+{"version":3,"file":"TerrainTile.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/tiles/TerrainTile.js"],"names":[],"mappings":";AAgCA;;GAEG;AACH;IACI,sBAA6B;IAC7B,eAA0B;IAC1B,cAAyB;IACzB,kBAAyB;IACzB,4BAAoC;IAEpC;;;OAGG;IACH,mBAAgB;IAChB,uGAAiE;IAGjE;;;OAGG;IACH,UAFU,MAAM,cAAc,CAEd;IAEhB;;;OAGG;IACH,WAFU,OAAO,CAEA;IAEjB;;;OAGG;IACH,cAFU,SAAS,CAEY;IAE/B;;;OAGG;IACH,KAFU,eAAe,CAEd;IAEX;;;OAGG;IACH,SAFU,OAAO,CAED;IAChB;;;OAGG;IACH,mBAFU,OAAO,CAES;IAC1B,uBAAmB;IAEnB;;;OAGG;IACH,SAFU,OAAO,WAAW,CAAC,CAEN;IACvB,4DAA2B;IAE3B;;;;OAIG;IACH,kBAWE;IAEF;;;;;OAKG;IACH,+BAAiG;IAEjG;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAqBZ;;;OAGG;IACH,6BAGC;IAfD;;;OAGG;IACH,0BAEC;IAWD;;;;;;;;;;OAUG;IACH,yBATW,aAAa,WACb,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACL,OAAO,CAmDlB;IAED,+CAKC;IAED,8CAOC;IAED;;;;;;;;;;OAUG;IACH,mBATW,WAAW,GAAC,SAAS,UACrB,WAAW,GAAC,SAAS,QACrB,WAAW,GAAC,SAAS,SACrB,WAAW,GAAC,SAAS,WACrB,WAAW,GAAC,SAAS,YACrB,WAAW,GAAC,SAAS,cACrB,WAAW,GAAC,SAAS,eACrB,WAAW,GAAC,SAAS,QAsN/B;IAED,2BAmFC;IAED;;;;OAIG;IACH,mCAHW,MAAM,cACN,MAAM,QAIhB;IAED,gBAYC;IAED;;;;OAIG;IACH,gBAHW;QAAC,QAAQ,CAAC;QAAC,GAAG,CAAC,EAAC;YAAC,UAAU,EAAC,MAAM,CAAC;YAAC,IAAI,EAAC,WAAW,CAAA;SAAC,CAAA;KAAC,QAoDhE;CACJ;oBA1lBmB,kCAAkC;4BAG1B,2CAA2C;sDAZhE,OAAO;0BAEY,yCAAyC;gCADnC,mDAAmD;mBAGhE,0CAA0C;8BAI/B,2CAA2C"}

package/src/engine/ecs/terrain/tiles/TerrainTile.js

@@ -199,7 +199,8 @@ class TerrainTile {
             attribute_position.normalized,
             geometryIndices,
             _originX, _originY, _originZ,
-            _directionX, _directionY, _directionZ
+            _directionX, _directionY, _directionZ,
+            Infinity,
         );
 
         if (hit_found) {

package/src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GeometrySpatialQueryAccelerator.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js"],"names":[],"mappings":"AAiBA;IACI,iCA4BC;IArBG;;;OAGG;IACH,cAeE;IAIN;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;OAKG;IACH,4CAJW,MAAM,cAAc,UACpB,OAAO,GACL,OAAO,CAuCnB;IAED;;;;;;OAMG;IACH,gEAJW,MAAM,cAAc,OACpB,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GACtC,OAAO,CASlB;IAED;;;;;;;;;;;OAWG;IACH,oEATW,MAAM,cAAc,gBACpB,MAAM,gBACN,MAAM,gBACN,MAAM,mBACN,MAAM,mBACN,MAAM,mBACN,MAAM,GACL,OAAO,CA8ClB;IAED;;;;;;;OAOG;IACH,0DALW,MAAM,cAAc,gDAGlB,OAAO,CAcnB;IAED;;;;OAIG;IACH,gCAHW,MAAM,cAAc,GAClB,OAAO,CAMnB;IAED;;;;OAIG;IACH,sBAHW,MAAM,cAAc,GAClB,eAAe,CAiB3B;IAED;;;;OAIG;IACH,oBAyBC;CAEJ;;kBAIS,+BAA+B;;gCAjRT,sDAAsD"}
+{"version":3,"file":"GeometrySpatialQueryAccelerator.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js"],"names":[],"mappings":"AAiBA;IACI,iCA4BC;IArBG;;;OAGG;IACH,cAeE;IAIN;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;OAKG;IACH,4CAJW,MAAM,cAAc,UACpB,OAAO,GACL,OAAO,CAuCnB;IAED;;;;;;OAMG;IACH,gEAJW,MAAM,cAAc,OACpB,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GACtC,OAAO,CASlB;IAED;;;;;;;;;;;OAWG;IACH,oEATW,MAAM,cAAc,gBACpB,MAAM,gBACN,MAAM,gBACN,MAAM,mBACN,MAAM,mBACN,MAAM,mBACN,MAAM,GACL,OAAO,CAyDlB;IAED;;;;;;;OAOG;IACH,0DALW,MAAM,cAAc,gDAGlB,OAAO,CAcnB;IAED;;;;OAIG;IACH,gCAHW,MAAM,cAAc,GAClB,OAAO,CAMnB;IAED;;;;OAIG;IACH,sBAHW,MAAM,cAAc,GAClB,eAAe,CAiB3B;IAED;;;;OAIG;IACH,oBAyBC;CAEJ;;kBAIS,+BAA+B;;gCA5RT,sDAAsD"}

package/src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js

@@ -177,7 +177,18 @@ export class GeometrySpatialQueryAccelerator {
 
         }
 
-        return bvh32_geometry_raycast(destination, bvh, position_data, position_data_offset, stride, position_attribute.normalized, geometryIndices, ray_origin_x, ray_origin_y, ray_origin_z, ray_direction_x, ray_direction_y, ray_direction_z);
+        return bvh32_geometry_raycast(
+            destination,
+            bvh,
+            position_data,
+            position_data_offset,
+            stride,
+            position_attribute.normalized,
+            geometryIndices,
+            ray_origin_x, ray_origin_y, ray_origin_z,
+            ray_direction_x, ray_direction_y, ray_direction_z,
+            Infinity
+        );
 
     }
 

package/src/engine/graphics/geometry/buffered/query/bvh32_geometry_raycast.d.ts

@@ -7,14 +7,15 @@
  * @param {number} vertex_stride Unless you're using an interleaved buffer, this should be 3
  * @param {boolean} vertex_data_normalized do we need to denormalize vertex data?
  * @param {number[]|ArrayLike<number>|undefined} indices if this is set to undefined - implicit indexing will be used
- * @param {number} originX
- * @param {number} originY
- * @param {number} originZ
- * @param {number} directionX
- * @param {number} directionY
- * @param {number} directionZ
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} max_distance How far can the ray travel from origin? tMax
  * @returns {boolean}
  */
-export function bvh32_geometry_raycast(result: SurfacePoint3, bvh: BinaryUint32BVH, vertices: number[] | ArrayLike<number>, vertex_offset: number, vertex_stride: number, vertex_data_normalized: boolean, indices: number[] | ArrayLike<number> | undefined, originX: number, originY: number, originZ: number, directionX: number, directionY: number, directionZ: number): boolean;
+export function bvh32_geometry_raycast(result: SurfacePoint3, bvh: BinaryUint32BVH, vertices: number[] | ArrayLike<number>, vertex_offset: number, vertex_stride: number, vertex_data_normalized: boolean, indices: number[] | ArrayLike<number> | undefined, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, max_distance: number): boolean;
 import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
 //# sourceMappingURL=bvh32_geometry_raycast.d.ts.map

package/src/engine/graphics/geometry/buffered/query/bvh32_geometry_raycast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh32_geometry_raycast.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_raycast.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;GAgBG;AACH,+CAfW,aAAa,kCAEb,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,WACpC,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,OAAO,CAwGnB;8BA7H6B,8CAA8C"}
+{"version":3,"file":"bvh32_geometry_raycast.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_raycast.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;GAiBG;AACH,+CAhBW,aAAa,kCAEb,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,YACpC,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,GACJ,OAAO,CA2GnB;8BAjI6B,8CAA8C"}

package/src/engine/graphics/geometry/buffered/query/bvh32_geometry_raycast.js

@@ -18,12 +18,13 @@ const scratch_hit = new SurfacePoint3()
  * @param {number} vertex_stride Unless you're using an interleaved buffer, this should be 3
  * @param {boolean} vertex_data_normalized do we need to denormalize vertex data?
  * @param {number[]|ArrayLike<number>|undefined} indices if this is set to undefined - implicit indexing will be used
- * @param {number} originX
- * @param {number} originY
- * @param {number} originZ
- * @param {number} directionX
- * @param {number} directionY
- * @param {number} directionZ
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} max_distance How far can the ray travel from origin? tMax
  * @returns {boolean}
  */
 export function bvh32_geometry_raycast(
@@ -32,22 +33,25 @@ export function bvh32_geometry_raycast(
     vertices, vertex_offset, vertex_stride,
     vertex_data_normalized,
     indices,
-    originX, originY, originZ,
-    directionX, directionY, directionZ
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    max_distance
 ) {
 
     assert.isBoolean(vertex_data_normalized, 'vertex_data_normalized');
+    assert.isNumber(max_distance, 'max_distance');
 
     let hit_found = false;
 
     const hit_count = bvh32_query_user_data_ray(
         scratch_array, 0,
         bvh,
-        originX, originY, originZ,
-        directionX, directionY, directionZ
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z,
+        max_distance,
     );
 
-    let best_distance = Infinity;
+    let best_distance_sqr = max_distance * max_distance;
 
     let a, b, c;
 
@@ -90,7 +94,7 @@ export function bvh32_geometry_raycast(
         let cz = vertices[c_address + 2];
 
         // denormalize if necessary
-        if(vertex_data_normalized) {
+        if (vertex_data_normalized) {
             ax = typed_array_value_denormalize(ax, vertices);
             ay = typed_array_value_denormalize(ay, vertices);
             az = typed_array_value_denormalize(az, vertices);
@@ -106,8 +110,8 @@ export function bvh32_geometry_raycast(
 
         const triangle_hit_found = computeTriangleRayIntersection(
             scratch_hit,
-            originX, originY, originZ,
-            directionX, directionY, directionZ,
+            origin_x, origin_y, origin_z,
+            direction_x, direction_y, direction_z,
             ax, ay, az,
             bx, by, bz,
             cx, cy, cz
@@ -119,10 +123,10 @@ export function bvh32_geometry_raycast(
 
         hit_found = true;
 
-        const distance_sqr = scratch_hit.position._distanceSqrTo(originX, originY, originZ);
+        const distance_sqr = scratch_hit.position._distanceSqrTo(origin_x, origin_y, origin_z);
 
-        if (distance_sqr < best_distance) {
-            best_distance = distance_sqr;
+        if (distance_sqr < best_distance_sqr) {
+            best_distance_sqr = distance_sqr;
             result.copy(scratch_hit);
         }
     }