@woosh/meep-engine 2.109.20 → 2.109.21

package/build/meep.module.js

@@ -12,9 +12,7 @@ function isArrayEqualStrict(a, b) {
         return false;
     }
 
-    let i = 0;
-
-    for (; i < il; i++) {
+    for (let i = 0; i < il; i++) {
 
         if (a[i] !== b[i]) {
             return false;
@@ -49014,7 +49012,7 @@ function compute_typed_array_constructor_from_data_type(dt) {
 //
 
 /**
- *
+ * Optimized equality method for typed arrays, typically significantly faster than `isArrayEqualStrict`, especially for larger arrays
  * @param {Uint8Array|Uint32Array} a
  * @param {Uint8Array|Uint32Array} b
  * @returns {boolean}
@@ -49032,7 +49030,12 @@ function is_typed_array_equals(a, b) {
         return false;
     }
 
-    if (a_length < 128) {
+    if (a_length === 0) {
+        // both arrays are empty
+        return true;
+    }
+
+    if (a_length < 128) { // size is determined empirically, nothing special about the number itself
         // small array, do direct compare
         return isArrayEqualStrict(a, b);
     }
@@ -49071,6 +49074,7 @@ function is_typed_array_equals(a, b) {
         a_proxy = new Uint32Array(a_buffer, a.byteOffset, byte_length / 4);
         b_proxy = new Uint32Array(b_buffer, b.byteOffset, byte_length / 4);
     } else if (bytes_per_element < 2 && byte_length % 2 === 0) {
+        // 2 byte alignment, can use uint16
         a_proxy = new Uint16Array(a_buffer, a.byteOffset, byte_length / 2);
         b_proxy = new Uint16Array(b_buffer, b.byteOffset, byte_length / 2);
     }

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.109.20",
+  "version": "2.109.21",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

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

@@ -66,7 +66,7 @@ export function bvh_query_leaves_ray_segment(
             float32[address], float32[address + 1], float32[address + 2],
             float32[address + 3], float32[address + 4], float32[address + 5],
             origin_x, origin_y, origin_z,
-            direction_x, direction_y, direction_z,
+            1 / direction_x, 1 / direction_y, 1 / direction_z,
             t_min, t_max
         );
 

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

@@ -70,7 +70,7 @@ export function bvh_query_user_data_ray_segment(
             float32[address], float32[address + 1], float32[address + 2],
             float32[address + 3], float32[address + 4], float32[address + 5],
             origin_x, origin_y, origin_z,
-            direction_x, direction_y, direction_z,
+            1 / direction_x, 1 / direction_y, 1 / direction_z,
             t_min, t_max
         );
 

package/src/core/collection/array/isArrayEqualStrict.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isArrayEqualStrict.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/isArrayEqualStrict.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,sCAJW,QAAM,UAAU,KAChB,QAAM,UAAU,GACd,OAAO,CAsBnB"}
+{"version":3,"file":"isArrayEqualStrict.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/isArrayEqualStrict.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,sCAJW,QAAM,UAAU,KAChB,QAAM,UAAU,GACd,OAAO,CAoBnB"}

package/src/core/collection/array/isArrayEqualStrict.js

@@ -12,9 +12,7 @@ export function isArrayEqualStrict(a, b) {
         return false;
     }
 
-    let i = 0;
-
-    for (; i < il; i++) {
+    for (let i = 0; i < il; i++) {
 
         if (a[i] !== b[i]) {
             return false;

package/src/core/collection/array/typed/is_typed_array_equals.d.ts

@@ -1,5 +1,5 @@
 /**
- *
+ * Optimized equality method for typed arrays, typically significantly faster than `isArrayEqualStrict`, especially for larger arrays
  * @param {Uint8Array|Uint32Array} a
  * @param {Uint8Array|Uint32Array} b
  * @returns {boolean}

package/src/core/collection/array/typed/is_typed_array_equals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"is_typed_array_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/is_typed_array_equals.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,yCAJW,UAAU,GAAC,WAAW,KACtB,UAAU,GAAC,WAAW,GACpB,OAAO,CA2DnB"}
+{"version":3,"file":"is_typed_array_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/typed/is_typed_array_equals.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,yCAJW,UAAU,GAAC,WAAW,KACtB,UAAU,GAAC,WAAW,GACpB,OAAO,CAiEnB"}

package/src/core/collection/array/typed/is_typed_array_equals.js

@@ -2,7 +2,7 @@
 import { isArrayEqualStrict } from "../isArrayEqualStrict.js";
 
 /**
- *
+ * Optimized equality method for typed arrays, typically significantly faster than `isArrayEqualStrict`, especially for larger arrays
  * @param {Uint8Array|Uint32Array} a
  * @param {Uint8Array|Uint32Array} b
  * @returns {boolean}
@@ -20,7 +20,12 @@ export function is_typed_array_equals(a, b) {
         return false;
     }
 
-    if (a_length < 128) {
+    if (a_length === 0) {
+        // both arrays are empty
+        return true;
+    }
+
+    if (a_length < 128) { // size is determined empirically, nothing special about the number itself
         // small array, do direct compare
         return isArrayEqualStrict(a, b);
     }
@@ -59,6 +64,7 @@ export function is_typed_array_equals(a, b) {
         a_proxy = new Uint32Array(a_buffer, a.byteOffset, byte_length / 4);
         b_proxy = new Uint32Array(b_buffer, b.byteOffset, byte_length / 4);
     } else if (bytes_per_element < 2 && byte_length % 2 === 0) {
+        // 2 byte alignment, can use uint16
         a_proxy = new Uint16Array(a_buffer, a.byteOffset, byte_length / 2);
         b_proxy = new Uint16Array(b_buffer, b.byteOffset, byte_length / 2);
     }

package/src/core/geom/3d/aabb/aabb3_array_near_distance_to_intersection_ray_segment.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @see Ray Tracing Gems II, Chapter 2 "RAY AXIS-ALIGNED BOUNDING BOX INTERSECTION"
+ * @param {number[]|Float32Array} box
+ * @param {number} box_address
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} inv_direction_x 1/ direction_X
+ * @param {number} inv_direction_y 1/ direction_Y
+ * @param {number} inv_direction_z 1/ direction_Z
+ * @param {number} min_distance
+ * @param {number} max_distance
+ * @returns {number}
+ */
+export function aabb3_array_near_distance_to_intersection_ray_segment(box: number[] | Float32Array, box_address: number, origin_x: number, origin_y: number, origin_z: number, inv_direction_x: number, inv_direction_y: number, inv_direction_z: number, min_distance: number, max_distance: number): number;
+//# sourceMappingURL=aabb3_array_near_distance_to_intersection_ray_segment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_array_near_distance_to_intersection_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_array_near_distance_to_intersection_ray_segment.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,2EAZW,MAAM,EAAE,GAAC,YAAY,eACrB,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,mBACN,MAAM,mBACN,MAAM,mBACN,MAAM,gBACN,MAAM,gBACN,MAAM,GACJ,MAAM,CAelB"}

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

@@ -0,0 +1,30 @@
+import { aabb3_near_distance_to_intersection_ray_segment } from "./aabb3_near_distance_to_intersection_ray_segment.js";
+
+/**
+ * @see Ray Tracing Gems II, Chapter 2 "RAY AXIS-ALIGNED BOUNDING BOX INTERSECTION"
+ * @param {number[]|Float32Array} box
+ * @param {number} box_address
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} inv_direction_x 1/ direction_X
+ * @param {number} inv_direction_y 1/ direction_Y
+ * @param {number} inv_direction_z 1/ direction_Z
+ * @param {number} min_distance
+ * @param {number} max_distance
+ * @returns {number}
+ */
+export function aabb3_array_near_distance_to_intersection_ray_segment(
+    box, box_address,
+    origin_x, origin_y, origin_z,
+    inv_direction_x, inv_direction_y, inv_direction_z,
+    min_distance, max_distance) {
+    return aabb3_near_distance_to_intersection_ray_segment(
+        box[box_address], box[box_address + 1], box[box_address + 2],
+        box[box_address + 3], box[box_address + 4], box[box_address + 5],
+
+        origin_x, origin_y, origin_z,
+        inv_direction_x, inv_direction_y, inv_direction_z,
+        min_distance, max_distance
+    );
+}

package/src/core/geom/3d/aabb/aabb3_intersects_ray_segment.d.ts

@@ -9,13 +9,12 @@
  * @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} inv_direction_x 1/ direction_X
+ * @param {number} inv_direction_y 1/ direction_Y
+ * @param {number} inv_direction_z 1/ direction_Z
  * @param {number} min_distance
  * @param {number} max_distance
  * @returns {boolean}
- * @returns {boolean}
  */
-export function aabb3_intersects_ray_segment(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, min_distance: number, max_distance: number): boolean;
+export function aabb3_intersects_ray_segment(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, origin_x: number, origin_y: number, origin_z: number, inv_direction_x: number, inv_direction_y: number, inv_direction_z: number, min_distance: number, max_distance: number): boolean;
 //# sourceMappingURL=aabb3_intersects_ray_segment.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"aabb3_intersects_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_intersects_ray_segment.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,iDAjBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,gBACN,MAAM,GACJ,OAAO,CA+CnB"}
+{"version":3,"file":"aabb3_intersects_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_intersects_ray_segment.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,iDAhBW,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,OAAO,CA2CnB"}

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

@@ -12,19 +12,18 @@ import { min2 } from "../../../math/min2.js";
  * @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} inv_direction_x 1/ direction_X
+ * @param {number} inv_direction_y 1/ direction_Y
+ * @param {number} inv_direction_z 1/ direction_Z
  * @param {number} min_distance
  * @param {number} max_distance
  * @returns {boolean}
- * @returns {boolean}
  */
 export function aabb3_intersects_ray_segment(
     x0, y0, z0,
     x1, y1, z1,
     origin_x, origin_y, origin_z,
-    direction_x, direction_y, direction_z,
+    inv_direction_x, inv_direction_y, inv_direction_z,
     min_distance, max_distance
 ) {
 
@@ -37,9 +36,6 @@ export function aabb3_intersects_ray_segment(
     const _y1 = y1 - origin_y;
     const _z1 = z1 - origin_z;
 
-    const inv_direction_x = 1 / direction_x;
-    const inv_direction_y = 1 / direction_y;
-    const inv_direction_z = 1 / direction_z;
 
     // Absolute distances to lower and upper box coordinates
     const t_lower_x = _x0 * inv_direction_x;
@@ -64,4 +60,5 @@ export function aabb3_intersects_ray_segment(
     const t_box_max = Math.min(t_max_x, t_max_y, t_max_z, max_distance);
 
     return t_box_min <= t_box_max;
-}
+}
+

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

@@ -0,0 +1,20 @@
+/**
+ * @see Ray Tracing Gems II, Chapter 2 "RAY AXIS-ALIGNED BOUNDING BOX INTERSECTION"
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} inv_direction_x 1/ direction_X
+ * @param {number} inv_direction_y 1/ direction_Y
+ * @param {number} inv_direction_z 1/ direction_Z
+ * @param {number} min_distance
+ * @param {number} max_distance
+ * @returns {number} Infinity when no intersection found
+ */
+export function aabb3_near_distance_to_intersection_ray_segment(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, origin_x: number, origin_y: number, origin_z: number, inv_direction_x: number, inv_direction_y: number, inv_direction_z: number, min_distance: number, max_distance: number): number;
+//# sourceMappingURL=aabb3_near_distance_to_intersection_ray_segment.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,67 @@
+import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
+
+/**
+ * @see Ray Tracing Gems II, Chapter 2 "RAY AXIS-ALIGNED BOUNDING BOX INTERSECTION"
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} inv_direction_x 1/ direction_X
+ * @param {number} inv_direction_y 1/ direction_Y
+ * @param {number} inv_direction_z 1/ direction_Z
+ * @param {number} min_distance
+ * @param {number} max_distance
+ * @returns {number} Infinity when no intersection found
+ */
+export function aabb3_near_distance_to_intersection_ray_segment(
+    x0, y0, z0,
+    x1, y1, z1,
+    origin_x, origin_y, origin_z,
+    inv_direction_x, inv_direction_y, inv_direction_z,
+    min_distance, max_distance
+) {
+
+    // move aabb into ray space
+    const _x0 = x0 - origin_x;
+    const _y0 = y0 - origin_y;
+    const _z0 = z0 - origin_z;
+
+    const _x1 = x1 - origin_x;
+    const _y1 = y1 - origin_y;
+    const _z1 = z1 - origin_z;
+
+
+    // Absolute distances to lower and upper box coordinates
+    const t_lower_x = _x0 * inv_direction_x;
+    const t_lower_y = _y0 * inv_direction_y;
+    const t_lower_z = _z0 * inv_direction_z;
+
+    const t_upper_x = _x1 * inv_direction_x;
+    const t_upper_y = _y1 * inv_direction_y;
+    const t_upper_z = _z1 * inv_direction_z;
+
+    // The four t-intervals (for x-/y-/z-slabs, and ray p(t))
+    const t_min_x = min2(t_lower_x, t_upper_x);
+    const t_min_y = min2(t_lower_y, t_upper_y);
+    const t_min_z = min2(t_lower_z, t_upper_z);
+
+    const t_max_x = max2(t_lower_x, t_upper_x);
+    const t_max_y = max2(t_lower_y, t_upper_y);
+    const t_max_z = max2(t_lower_z, t_upper_z);
+
+    // Easy to remember: ``max of mins, and min of maxes''
+    const t_box_min = Math.max(t_min_x, t_min_y, t_min_z, min_distance);
+    const t_box_max = Math.min(t_max_x, t_max_y, t_max_z, max_distance);
+
+    if (t_box_min > t_box_max) {
+        return Infinity;
+    }
+
+    return t_box_min;
+}

package/src/core/geom/3d/line/line3_compute_nearest_point_to_point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line3_compute_nearest_point_to_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_nearest_point_to_point.js"],"names":[],"mappings":"AAGA,sLAgCC"}
+{"version":3,"file":"line3_compute_nearest_point_to_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_nearest_point_to_point.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,6DAZW,MAAM,EAAE,iBACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QAkChB"}

package/src/core/geom/3d/line/line3_compute_nearest_point_to_point.js

@@ -1,6 +1,20 @@
-import { v3_dot } from "../../vec3/v3_dot.js";
 import { clamp01 } from "../../../math/clamp01.js";
+import { v3_dot } from "../../vec3/v3_dot.js";
 
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} ref_x
+ * @param {number} ref_y
+ * @param {number} ref_z
+ */
 export function line3_compute_nearest_point_to_point(
     result, result_offset,
     ax, ay, az,

package/src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.d.ts

@@ -5,6 +5,7 @@
  * @param {number} output_offset
  * @param {number} u range [-1,1]
  * @param {number} v range [-1,1]
+ * @returns {number} length of octahedral vector, larger value means more distortion
  */
-export function decode_octahedron_to_unit(output: number[] | Vector3 | Float32Array, output_offset: number, u: number, v: number): void;
+export function decode_octahedron_to_unit(output: number[] | Vector3 | Float32Array, output_offset: number, u: number, v: number): number;
 //# sourceMappingURL=decode_octahedron_to_unit.d.ts.map

package/src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode_octahedron_to_unit.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,kDALW,MAAM,EAAE,aAAS,YAAY,iBAC7B,MAAM,KACN,MAAM,KACN,MAAM,QA0BhB"}
+{"version":3,"file":"decode_octahedron_to_unit.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,kDANW,MAAM,EAAE,aAAS,YAAY,iBAC7B,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CA8BlB"}

package/src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js

@@ -8,6 +8,7 @@ import { v3_length } from "../../../vec3/v3_length.js";
  * @param {number} output_offset
  * @param {number} u range [-1,1]
  * @param {number} v range [-1,1]
+ * @returns {number} length of octahedral vector, larger value means more distortion
  */
 export function decode_octahedron_to_unit(
     output, output_offset,
@@ -28,9 +29,13 @@ export function decode_octahedron_to_unit(
     }
 
     // normalize
-    const m = 1 / v3_length(v_x, v_y, v_z);
+    const octahedral_length = v3_length(v_x, v_y, v_z);
+
+    const m = 1 / octahedral_length;
 
     output[output_offset] = v_x * m;
     output[output_offset + 1] = v_y * m;
     output[output_offset + 2] = v_z * m;
+
+    return octahedral_length;
 }

package/src/core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.d.ts

@@ -0,0 +1,20 @@
+/**
+ *
+ * @param {number[]} result result is written as a 2d vector, since barycentrics add up to 1, we omit the last value
+ * @param {number} result_offset
+ * @param {number} px reference point
+ * @param {number} py reference point
+ * @param {number} pz reference point
+ * @param {number} ax Triangle apex A
+ * @param {number} ay Triangle apex A
+ * @param {number} az Triangle apex A
+ * @param {number} bx Triangle apex B
+ * @param {number} by Triangle apex B
+ * @param {number} bz Triangle apex B
+ * @param {number} cx Triangle apex C
+ * @param {number} cy Triangle apex C
+ * @param {number} cz Triangle apex C
+ * @returns {void}
+ */
+export function computeTriangleClosestPointToPointBarycentric(result: number[], result_offset: number, px: number, py: number, pz: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): void;
+//# sourceMappingURL=computeTriangleClosestPointToPointBarycentric.d.ts.map

package/src/core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeTriangleClosestPointToPointBarycentric.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,sEAhBW,MAAM,EAAE,iBACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CAgIhB"}

package/src/core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.js

@@ -0,0 +1,147 @@
+import { v3_dot } from "../../vec3/v3_dot.js";
+
+/**
+ *
+ * @param {number[]} result result is written as a 2d vector, since barycentrics add up to 1, we omit the last value
+ * @param {number} result_offset
+ * @param {number} px reference point
+ * @param {number} py reference point
+ * @param {number} pz reference point
+ * @param {number} ax Triangle apex A
+ * @param {number} ay Triangle apex A
+ * @param {number} az Triangle apex A
+ * @param {number} bx Triangle apex B
+ * @param {number} by Triangle apex B
+ * @param {number} bz Triangle apex B
+ * @param {number} cx Triangle apex C
+ * @param {number} cy Triangle apex C
+ * @param {number} cz Triangle apex C
+ * @returns {void}
+ */
+export function computeTriangleClosestPointToPointBarycentric(
+    result, result_offset,
+    px, py, pz,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+){
+
+    let v, w;
+
+    // algorithm thanks to Real-Time Collision Detection by Christer Ericson,
+    // published by Morgan Kaufmann Publishers, (c) 2005 Elsevier Inc.,
+    // under the accompanying license; see chapter 5.1.5 for detailed explanation.
+    // basically, we're distinguishing which of the voronoi regions of the triangle
+    // the point lies in with the minimum amount of redundant computation.
+
+    // localize coordinates with respect to A
+    const _vab_x = bx - ax;
+    const _vab_y = by - ay;
+    const _vab_z = bz - az;
+
+    const _vac_x = cx - ax;
+    const _vac_y = cy - ay;
+    const _vac_z = cz - az;
+
+    const _vap_x = px - ax;
+    const _vap_y = py - ay;
+    const _vap_z = pz - az;
+
+    const d1 = v3_dot(_vab_x, _vab_y, _vab_z,  _vap_x, _vap_y, _vap_z );
+    const d2 = v3_dot(_vac_x, _vac_y, _vac_z,  _vap_x, _vap_y, _vap_z );
+
+    if ( d1 <= 0 && d2 <= 0 ) {
+
+        // vertex region of A; barycentric coords (1, 0, 0)
+
+        result[result_offset] = 1;
+        result[result_offset+1] = 0;
+
+        return;
+
+    }
+
+    const _vbp_x = px - bx;
+    const _vbp_y = py - by;
+    const _vbp_z = pz - bz;
+
+    const d3 = v3_dot(_vab_x, _vab_y, _vab_z,  _vbp_x, _vbp_y, _vbp_z );
+    const d4 = v3_dot(_vac_x, _vac_y, _vac_z,  _vbp_x, _vbp_y, _vbp_z );
+
+    if ( d3 >= 0 && d4 <= d3 ) {
+
+        // vertex region of B; barycentric coords (0, 1, 0)
+
+        result[result_offset] = 0;
+        result[result_offset+1] = 1;
+
+        return;
+
+    }
+
+    const vc = d1 * d4 - d3 * d2;
+    if ( vc <= 0 && d1 >= 0 && d3 <= 0 ) {
+
+        v = d1 / ( d1 - d3 );
+        // edge region of AB; barycentric coords (1-v, v, 0)
+
+        result[result_offset] = 1-v;
+        result[result_offset+1] = v;
+
+        return;
+
+    }
+
+    const _vcp_x = px - cx;
+    const _vcp_y = py - cy;
+    const _vcp_z = pz - cz;
+
+    const d5 = v3_dot(_vab_x, _vab_y, _vab_z,  _vcp_x, _vcp_y, _vcp_z );
+    const d6 = v3_dot(_vac_x, _vac_y, _vac_z,  _vcp_x, _vcp_y, _vcp_z );
+
+    if ( d6 >= 0 && d5 <= d6 ) {
+
+        // vertex region of C; barycentric coords (0, 0, 1)
+
+        result[result_offset] = 0;
+        result[result_offset+1] = 0;
+
+        return;
+
+    }
+
+    const vb = d5 * d2 - d1 * d6;
+    if ( vb <= 0 && d2 >= 0 && d6 <= 0 ) {
+
+        w = d2 / ( d2 - d6 );
+
+        // edge region of AC; barycentric coords (1-w, 0, w)
+
+        result[result_offset] = 1-w;
+        result[result_offset+1] = 0;
+
+        return;
+
+    }
+
+    const va = d3 * d6 - d5 * d4;
+    if ( va <= 0 && ( d4 - d3 ) >= 0 && ( d5 - d6 ) >= 0 ) {
+
+        w = ( d4 - d3 ) / ( ( d4 - d3 ) + ( d5 - d6 ) );
+        // edge region of BC; barycentric coords (0, 1-w, w)
+
+        result[result_offset] = 0;
+        result[result_offset+1] = 1-w;
+
+        return;
+
+    }
+
+    // face region
+    const denom = 1 / ( va + vb + vc );
+    const u = va * denom
+    v = vb * denom;
+
+    result[result_offset] = u;
+    result[result_offset+1] = v;
+}

package/src/core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=computeTriangleClosestPointToPointBarycentric.spec.d.ts.map

package/src/core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeTriangleClosestPointToPointBarycentric.spec.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.spec.js"],"names":[],"mappings":""}