@woosh/meep-engine 2.43.17 → 2.43.19

package/core/bvh2/bvh3/{bvh_collect_user_data.js → query/bvh_collect_user_data.js}

@@ -1,6 +1,6 @@
 //
 
-import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.d.ts";
 
 const traversal_stack = [];
 /**

package/core/bvh2/bvh3/{bvh_query_leaves_generic.js → query/bvh_query_leaves_generic.js}

@@ -1,4 +1,4 @@
-import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
 
 /**
  *

package/core/bvh2/bvh3/query/bvh_query_leaves_ray.js

@@ -0,0 +1,97 @@
+import { aabb3_intersects_ray } from "../../aabb3/aabb3_intersects_ray.js";
+import {
+    COLUMN_CHILD_1,
+    COLUMN_CHILD_2,
+    ELEMENT_WORD_COUNT,
+    NULL_NODE
+} from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const traversal_stack = new Uint32Array(2048);
+
+
+/**
+ *
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {number}
+ */
+export function bvh_query_leaves_ray(
+    bvh,
+    result, result_offset,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
+) {
+    const root = bvh.root;
+
+    if (root === NULL_NODE) {
+        return 0;
+    }
+
+
+    traversal_stack[0] = root;
+
+    let result_cursor = result_offset;
+    /**
+     *
+     * @type {number}
+     */
+    let traversal_cursor = 1;
+
+    /*
+     For performance, we bind data directly to avoid extra copies required to read out AABB
+     */
+    const float32 = bvh.__data_float32;
+    const uint32 = bvh.__data_uint32;
+
+    do {
+        traversal_cursor--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = traversal_stack[traversal_cursor];
+
+        const address = node * ELEMENT_WORD_COUNT;
+
+        // test node against the ray
+        const intersects = aabb3_intersects_ray(
+            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
+        );
+
+        if (!intersects) {
+            continue;
+        }
+
+        // get fist child to check if this is a leaf node or not
+        const child_1 = uint32[address + COLUMN_CHILD_1];
+
+        if (child_1 !== NULL_NODE) {
+
+            // this is not a leaf node, push children onto traversal stack
+            traversal_stack[traversal_cursor++] = child_1;
+            traversal_stack[traversal_cursor++] = uint32[address + COLUMN_CHILD_2];
+
+        } else {
+            // leaf node
+
+            result[result_cursor++] = node;
+        }
+    } while (traversal_cursor > 0);
+
+    return result_cursor - result_offset;
+}

package/core/bvh2/bvh3/{bvh_query_user_data_generic.js → query/bvh_query_user_data_generic.js}

@@ -1,4 +1,4 @@
-import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
 
 /**
  *

package/core/bvh2/bvh3/{bvh_query_user_data_nearest_to_point.js → query/bvh_query_user_data_nearest_to_point.js}

@@ -1,6 +1,6 @@
-import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
-import { aabb3_signed_distance_sqr_to_point } from "../aabb3/aabb3_signed_distance_sqr_to_point.js";
-import { max2 } from "../../math/max2.js";
+import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { aabb3_signed_distance_sqr_to_point } from "../../aabb3/aabb3_signed_distance_sqr_to_point.js";
+import { max2 } from "../../../math/max2.js";
 
 /**
  *

package/core/bvh2/bvh3/{bvh_query_user_data_nearest_to_point.spec.js → query/bvh_query_user_data_nearest_to_point.spec.js}

@@ -1,4 +1,4 @@
-import { ExplicitBinaryBoundingVolumeHierarchy } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { ExplicitBinaryBoundingVolumeHierarchy } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
 import { bvh_query_user_data_nearest_to_point } from "./bvh_query_user_data_nearest_to_point.js";
 
 /**

package/core/bvh2/bvh3/{bvh_query_user_data_overlaps_frustum.js → query/bvh_query_user_data_overlaps_frustum.js}

@@ -1,6 +1,6 @@
 //
-import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
-import { aabb3_array_intersects_frustum_degree } from "../aabb3/aabb3_array_intersects_frustum_degree.js";
+import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
+import { aabb3_array_intersects_frustum_degree } from "../../aabb3/aabb3_array_intersects_frustum_degree.js";
 import { bvh_collect_user_data } from "./bvh_collect_user_data.js";
 
 const traversal_stack = [];

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

@@ -4,7 +4,7 @@
 import { array_copy } from "../../../collection/array/copyArray.js";
 import { NULL_NODE } from "../ExplicitBinaryBoundingVolumeHierarchy.js";
 import { aabb3_array_intersects_frustum_degree } from "../../aabb3/aabb3_array_intersects_frustum_degree.js";
-import { bvh_collect_user_data } from "../bvh_collect_user_data.js";
+import { bvh_collect_user_data } from "./bvh_collect_user_data.js";
 import { v3_distance_above_plane } from "../../../geom/v3_distance_above_plane.js";
 
 const traversal_stack = [];

package/core/collection/array/arrayQuickSort.js

@@ -4,7 +4,7 @@ const stack = [];
 
 /**
  * @template T
- * @param {T[]} data
+ * @param {T[]|ArrayLike<number>|Uint32Array} data
  * @param {function(T):number} score_function
  * @param {*} score_function_context
  * @param {number} start

package/core/collection/array/typed/typed_array_copy.js

@@ -3,8 +3,8 @@ import { array_copy } from "../copyArray.js";
 
 /**
  * Assumes arrays have the same type
- * @param {TypedArray|Float32Array|Uint8Array} source
- * @param {TypedArray|Float32Array|Uint8Array} destination
+ * @param {TypedArray|Float32Array|Uint8Array|Uint32Array} source
+ * @param {TypedArray|Float32Array|Uint8Array|Uint32Array} destination
  */
 export function typed_array_copy(source, destination) {
     const destination_size = destination.length;

package/core/geom/3d/aabb/compute_aabb_from_points.js

@@ -4,11 +4,12 @@ import { max2 } from "../../../math/max2.js";
 /**
  * Multidimensional axis-aligned bounding box calculation
  * @param {number[]} result
- * @param {number[]} input
+ * @param {number[]|ArrayLike<number>} input
+ * @param {number} input_offset
  * @param {number} input_count
  * @param {number} d number of dimensions
  */
-export function compute_aabb_from_points(result, input, input_count, d) {
+export function compute_aabb_from_points(result, input, input_offset, input_count, d) {
     let i = 0;
     let j = 0;
 
@@ -19,7 +20,7 @@ export function compute_aabb_from_points(result, input, input_count, d) {
 
     for (i = 0; i < input_count; i++) {
         for (j = 0; j < d; j++) {
-            const v = input[i*d + j];
+            const v = input[input_count + i * d + j];
 
             result[j] = min2(result[j], v);
             result[j + d] = max2(result[j + d], v);

package/core/geom/3d/compute_triangle_normal.js

@@ -0,0 +1,76 @@
+import { v3_length_sqr } from "../v3_length_sqr.js";
+import { vec3 } from "gl-matrix";
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {number} vAx
+ * @param {number} vAy
+ * @param {number} vAz
+ * @param {number} vBx
+ * @param {number} vBy
+ * @param {number} vBz
+ * @param {number} vCx
+ * @param {number} vCy
+ * @param {number} vCz
+ */
+export function v3_compute_triangle_normal(result, result_offset, vAx, vAy, vAz, vBx, vBy, vBz, vCx, vCy, vCz) {
+    //compute CB and AB vectors
+    const vCBx = vCx - vBx;
+    const vCBy = vCy - vBy;
+    const vCBz = vCz - vBz;
+
+    const vABx = vAx - vBx;
+    const vABy = vAy - vBy;
+    const vABz = vAz - vBz;
+
+    //compute triangle normal
+    const crossX = vCBy * vABz - vCBz * vABy;
+    const crossY = vCBz * vABx - vCBx * vABz;
+    const crossZ = vCBx * vABy - vCBy * vABx;
+
+    const l_sqr = v3_length_sqr(crossX, crossY, crossZ);
+
+    if (l_sqr === 0) {
+        // degenerate triangle, provide arbitrary invalid result
+        result[result_offset] = 0;
+        result[result_offset + 1] = 1;
+        result[result_offset + 2] = 0;
+        return;
+    }
+
+    const l_inv = 1 / Math.sqrt(l_sqr);
+
+    const x = crossX * l_inv;
+    const y = crossY * l_inv;
+    const z = crossZ * l_inv;
+
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
+}
+
+/**
+ *
+ * @param {number[]|vec3} result
+ * @param {number[]} vA
+ * @param {number[]} vB
+ * @param {number[]} vC
+ */
+export function compute_triangle_normal(result, vA, vB, vC) {
+
+    const vAx = vA[0];
+    const vAy = vA[1];
+    const vAz = vA[2];
+
+    const vBx = vB[0];
+    const vBy = vB[1];
+    const vBz = vB[2];
+
+    const vCx = vC[0];
+    const vCy = vC[1];
+    const vCz = vC[2];
+
+    v3_compute_triangle_normal(result, 0, vAx, vAy, vAz, vBx, vBy, vBz, vCx, vCy, vCz);
+}

package/core/geom/3d/topology/samples/sampleFloodFill.js

@@ -211,7 +211,7 @@ async function main(engine) {
 
                 const aabb_array = [];
                 const position_attribute = geometry.getAttribute('position');
-                compute_aabb_from_points(aabb_array, position_attribute.array, position_attribute.count, 3);
+                compute_aabb_from_points(aabb_array, position_attribute.array, 0, position_attribute.count, 3);
                 const aabb3 = new AABB3(...aabb_array);
                 //
                 // weld_duplicate_vertices(topo, aabb3);

package/core/geom/3d/topology/simplify/compute_face_normal_change_dot_product.js

@@ -1,5 +1,5 @@
 import { v3_dot } from "../../../v3_dot.js";
-import { compute_triangle_normal } from "../struct/TopoTriangle.js";
+import { compute_triangle_normal } from "../../compute_triangle_normal.js";
 
 const scratch_normal = new Float32Array(3);
 

package/core/geom/3d/topology/simplify/quadratic/Quadratic3.js

@@ -1,8 +1,8 @@
 import { v3_dot } from "../../../../v3_dot.js";
 import { fabsf } from "../../../../../math/fabsf.js";
 import { vec3 } from "gl-matrix";
-import { compute_triangle_normal } from "../../struct/TopoTriangle.js";
 import { EPSILON } from "../../../../../math/EPSILON.js";
+import { compute_triangle_normal } from "../../../compute_triangle_normal.js";
 
 const scratch_v3 = new Float32Array(3);
 

package/core/geom/3d/topology/struct/TopoTriangle.js

@@ -3,63 +3,7 @@ import { array_push_if_unique } from "../../../../collection/array/array_push_if
 import { assert } from "../../../../assert.js";
 import { array_remove_first } from "../../../../collection/array/array_remove_first.js";
 import { vec3 } from "gl-matrix";
-import { v3_length_sqr } from "../../../v3_length_sqr.js";
-
-/**
- *
- * @param {number[]|vec3} result
- * @param {Vector3|Vector3Like|TopoVertex|{x:number,y:number,z:number}} vA
- * @param {Vector3|Vector3Like|TopoVertex|{x:number,y:number,z:number}} vB
- * @param {Vector3|Vector3Like|TopoVertex|{x:number,y:number,z:number}} vC
- */
-export function compute_triangle_normal(result, vA, vB, vC) {
-
-    const vAx = vA.x
-    const vAy = vA.y
-    const vAz = vA.z
-
-    const vBx = vB.x
-    const vBy = vB.y
-    const vBz = vB.z
-
-    const vCx = vC.x
-    const vCy = vC.y
-    const vCz = vC.z
-
-    //compute CB and AB vectors
-    const vCBx = vCx - vBx;
-    const vCBy = vCy - vBy;
-    const vCBz = vCz - vBz;
-
-    const vABx = vAx - vBx;
-    const vABy = vAy - vBy;
-    const vABz = vAz - vBz;
-
-    //compute triangle normal
-    const crossX = vCBy * vABz - vCBz * vABy;
-    const crossY = vCBz * vABx - vCBx * vABz;
-    const crossZ = vCBx * vABy - vCBy * vABx;
-
-    const l_sqr = v3_length_sqr(crossX, crossY, crossZ);
-
-    if (l_sqr === 0) {
-        // degenerate triangle, provide arbitrary invalid result
-        vec3.set(result, 0, 0, 0);
-        return;
-    }
-
-    const l_inv = 1 / Math.sqrt(l_sqr);
-
-    const x = crossX * l_inv;
-    const y = crossY * l_inv;
-    const z = crossZ * l_inv;
-
-
-    vec3.set(
-        result,
-        x, y, z
-    );
-}
+import { compute_triangle_normal } from "../../compute_triangle_normal.js";
 
 let index_counter = 0;
 

package/core/geom/3d/topology/tm_face_normal.js

@@ -1,4 +1,4 @@
-import { compute_triangle_normal } from "./struct/TopoTriangle.js";
+import { compute_triangle_normal } from "../compute_triangle_normal.js";
 
 /**
  *

package/core/geom/3d/topology/tm_vertex_compute_normal.js

@@ -1,4 +1,4 @@
-import { compute_triangle_normal } from "./struct/TopoTriangle.js";
+import { compute_triangle_normal } from "../compute_triangle_normal.js";
 //
 
 

package/core/geom/3d/triangle/computeTriangleRayIntersection.js

@@ -30,43 +30,43 @@ export function computeTriangleRayIntersection(
     bx, by, bz,
     cx, cy, cz
 ) {
-    assert.isNumber(ax,'ax');
-    assert.isNumber(ay,'ay');
-    assert.isNumber(az,'az');
+    assert.isNumber(ax, 'ax');
+    assert.isNumber(ay, 'ay');
+    assert.isNumber(az, 'az');
 
-    assert.isNumber(bx,'bx');
-    assert.isNumber(by,'by');
-    assert.isNumber(bz,'bz');
+    assert.isNumber(bx, 'bx');
+    assert.isNumber(by, 'by');
+    assert.isNumber(bz, 'bz');
 
-    assert.isNumber(cx,'cx');
-    assert.isNumber(cy,'cy');
-    assert.isNumber(cz,'cz');
+    assert.isNumber(cx, 'cx');
+    assert.isNumber(cy, 'cy');
+    assert.isNumber(cz, 'cz');
 
     // nan checks
-    assert.notNaN(ax,'ax');
-    assert.notNaN(ay,'ay');
-    assert.notNaN(az,'az');
+    assert.notNaN(ax, 'ax');
+    assert.notNaN(ay, 'ay');
+    assert.notNaN(az, 'az');
 
-    assert.notNaN(bx,'bx');
-    assert.notNaN(by,'by');
-    assert.notNaN(bz,'bz');
+    assert.notNaN(bx, 'bx');
+    assert.notNaN(by, 'by');
+    assert.notNaN(bz, 'bz');
 
-    assert.notNaN(cx,'cx');
-    assert.notNaN(cy,'cy');
-    assert.notNaN(cz,'cz');
+    assert.notNaN(cx, 'cx');
+    assert.notNaN(cy, 'cy');
+    assert.notNaN(cz, 'cz');
 
     // finate number check
-    assert.isFiniteNumber(ax,'ax');
-    assert.isFiniteNumber(ay,'ay');
-    assert.isFiniteNumber(az,'az');
+    assert.isFiniteNumber(ax, 'ax');
+    assert.isFiniteNumber(ay, 'ay');
+    assert.isFiniteNumber(az, 'az');
 
-    assert.isFiniteNumber(bx,'bx');
-    assert.isFiniteNumber(by,'by');
-    assert.isFiniteNumber(bz,'bz');
+    assert.isFiniteNumber(bx, 'bx');
+    assert.isFiniteNumber(by, 'by');
+    assert.isFiniteNumber(bz, 'bz');
 
-    assert.isFiniteNumber(cx,'cx');
-    assert.isFiniteNumber(cy,'cy');
-    assert.isFiniteNumber(cz,'cz');
+    assert.isFiniteNumber(cx, 'cx');
+    assert.isFiniteNumber(cy, 'cy');
+    assert.isFiniteNumber(cz, 'cz');
 
 
     // edge1 = a - b
@@ -157,3 +157,171 @@ export function computeTriangleRayIntersection(
 
     return true;
 }
+
+/**
+ * Compute barycentric coordinates for triangle intersection
+ * Operates on edges, this is optimized for raytracing, as same edges are required to reconstruct various attributes later on
+ * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
+ * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
+ * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
+ * @param {number[]} result
+ * @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} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} edge1_x
+ * @param {number} edge1_y
+ * @param {number} edge1_z
+ * @param {number} edge2_x
+ * @param {number} edge2_y
+ * @param {number} edge2_z
+ * @return {boolean}
+ */
+export function computeTriangleRayIntersectionBarycentricEdge(result, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, ax, ay, az, edge1_x, edge1_y, edge1_z, edge2_x, edge2_y, edge2_z) {
+    // begin calculating determinant - also used to calculate U parameter
+
+    // CROSS(pvec, dir, edge2)
+    const pvec_x = direction_y * edge2_z - direction_z * edge2_y;
+    const pvec_y = direction_z * edge2_x - direction_x * edge2_z;
+    const pvec_z = direction_x * edge2_y - direction_y * edge2_x;
+
+    //if determinant is near zero, ray lies in plane of triangle
+    const det = v3_dot(edge1_x, edge1_y, edge1_z, pvec_x, pvec_y, pvec_z);
+
+    if (det <= 0) {
+        // back-face culling
+        return false;
+    }
+
+    // calculate distance from vert0 to ray origin (not really, but okay)
+    const tvec_x = origin_x - ax;
+    const tvec_y = origin_y - ay;
+    const tvec_z = origin_z - az;
+
+    // calculate u
+    let u = v3_dot(tvec_x, tvec_y, tvec_z, pvec_x, pvec_y, pvec_z);
+
+    if (u < 0 || u > det) {
+        // outside of bounds of the triangle
+        return false;
+    }
+
+    // prepare to test V parameter
+    // CROSS(qvec, tvec, edge1)
+    const qvec_x = tvec_y * edge1_z - tvec_z * edge1_y;
+    const qvec_y = tvec_z * edge1_x - tvec_x * edge1_z;
+    const qvec_z = tvec_x * edge1_y - tvec_y * edge1_x;
+
+    // calculate V parameter
+    let v = v3_dot(direction_x, direction_y, direction_z, qvec_x, qvec_y, qvec_z);
+
+    if (v < 0 || u + v > det) {
+        // out of bounds
+        return false;
+    }
+
+
+    const inv_det = 1 / det;
+
+    // calculate t, scale parameter, ray intersects triangle
+    const t = v3_dot(edge2_x, edge2_y, edge2_z, qvec_x, qvec_y, qvec_z) * inv_det;
+
+    u *= inv_det;
+    v *= inv_det;
+
+    result[0] = t;
+    result[1] = u;
+    result[2] = v;
+
+    return true;
+}
+
+/**
+ * Compute barycentric coordinates for triangle intersection
+ * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
+ * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
+ * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
+ * @param {number[]} result [t,u,v, normal_x, normal_y, normal_z] will be written here
+ * @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} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {boolean}
+ */
+export function computeTriangleRayIntersectionBarycentric(
+    result,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+    assert.isNumber(ax, 'ax');
+    assert.isNumber(ay, 'ay');
+    assert.isNumber(az, 'az');
+
+    assert.isNumber(bx, 'bx');
+    assert.isNumber(by, 'by');
+    assert.isNumber(bz, 'bz');
+
+    assert.isNumber(cx, 'cx');
+    assert.isNumber(cy, 'cy');
+    assert.isNumber(cz, 'cz');
+
+    // nan checks
+    assert.notNaN(ax, 'ax');
+    assert.notNaN(ay, 'ay');
+    assert.notNaN(az, 'az');
+
+    assert.notNaN(bx, 'bx');
+    assert.notNaN(by, 'by');
+    assert.notNaN(bz, 'bz');
+
+    assert.notNaN(cx, 'cx');
+    assert.notNaN(cy, 'cy');
+    assert.notNaN(cz, 'cz');
+
+    // finate number check
+    assert.isFiniteNumber(ax, 'ax');
+    assert.isFiniteNumber(ay, 'ay');
+    assert.isFiniteNumber(az, 'az');
+
+    assert.isFiniteNumber(bx, 'bx');
+    assert.isFiniteNumber(by, 'by');
+    assert.isFiniteNumber(bz, 'bz');
+
+    assert.isFiniteNumber(cx, 'cx');
+    assert.isFiniteNumber(cy, 'cy');
+    assert.isFiniteNumber(cz, 'cz');
+
+
+    // find vectors for two edges sharing vert
+
+    // edge1 = a - b
+    const edge1_x = bx - ax;
+    const edge1_y = by - ay;
+    const edge1_z = bz - az;
+
+    // edge2 = c - a
+    const edge2_x = cx - ax;
+    const edge2_y = cy - ay;
+    const edge2_z = cz - az;
+
+    return computeTriangleRayIntersectionBarycentricEdge(result, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, ax, ay, az, edge1_x, edge1_y, edge1_z, edge2_x, edge2_y, edge2_z);
+}

package/core/geom/Vector3.js

@@ -305,6 +305,18 @@ class Vector3 {
         return this;
     }
 
+    /**
+     *
+     * @param {Vector3} first
+     * @param {Vector3} second
+     */
+    crossVectors(first, second) {
+        const ax = first.x, ay = first.y, az = first.z;
+        const bx = second.x, by = second.y, bz = second.z;
+
+        this._crossVectors(ax, ay, az, bx, by, bz);
+    }
+
     /**
      *
      * @param {number} ax
@@ -322,18 +334,6 @@ class Vector3 {
         this.set(x, y, z);
     }
 
-    /**
-     *
-     * @param {Vector3} first
-     * @param {Vector3} second
-     */
-    crossVectors(first, second) {
-        const ax = first.x, ay = first.y, az = first.z;
-        const bx = second.x, by = second.y, bz = second.z;
-
-        this._crossVectors(ax, ay, az, bx, by, bz);
-    }
-
     /**
      * Sets all components of the vector to absolute value (positive)
      * @returns {Vector3}