@woosh/meep-engine 2.163.6 → 2.163.8

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_fill_small_holes.js

@@ -94,23 +94,29 @@ function fill_loop(mesh, cycle) {
 }
 
 /**
- * Fill boundary holes that are too thin for the agent to occupy.
+ * Fill inner boundary holes whose mean width falls below `min_width`.
  *
- * Erosion/clearance can leave a hair-thin sliver hole hugging an obstacle's offset edge (a strip of
- * cells that are actually clear but get pinched off into their own tiny loop). Such a hole is narrower
- * than the agent, so it can never be a real navigation obstacle - it is numerical noise that inflates
- * the boundary, the face count, and the loop count. This fills any inner loop whose mean width
- * (2*area/perimeter, the inradius of an equivalent disc) is below the agent radius. The single
- * largest-area loop (the outer boundary) is never filled.
+ * A mesh can contain hair-thin sliver holes - a strip of degenerate faces pinched off into its own
+ * tiny boundary loop - that are numerical noise rather than meaningful openings. Such slivers inflate
+ * the boundary length, the face count, and the loop count. This measures every boundary loop's mean
+ * width (2*area/perimeter, the inradius of the area-equivalent disc) and fills each inner loop narrower
+ * than `min_width`. The single largest-area loop is treated as the outer boundary and is never filled.
  *
- * @param {BinaryTopology} mesh
- * @param {number} agent_radius
+ * @param {BinaryTopology} mesh mesh whose boundary loops are inspected and (where too thin) filled in place
+ * @param {number} min_width minimum mean width an inner loop must have to be kept; thinner loops are filled
  * @returns {number} number of holes filled
  */
-export function bt_mesh_fill_small_holes(mesh, agent_radius) {
-    if (agent_radius <= 0) return 0;
+export function bt_mesh_fill_small_holes(mesh, min_width) {
+    if (min_width <= 0) return 0;
 
-    const cycles = bt_mesh_walk_boundary_loops(mesh);
+    let cycles;
+    try {
+        cycles = bt_mesh_walk_boundary_loops(mesh);
+    } catch (e) {
+        // a malformed (pinched) boundary can arise at float32-precision limits (e.g. geometry far from
+        // the origin); skip hole-filling rather than aborting the whole build
+        return 0;
+    }
     if (cycles.length <= 1) return 0;
 
     // measure every loop; the largest-area one is the outer boundary and is never filled
@@ -133,8 +139,8 @@ export function bt_mesh_fill_small_holes(mesh, agent_radius) {
         if (i === outer) continue;
         const { perimeter, area } = measures[i];
         if (perimeter <= 0) continue;
-        // mean width of the hole = 2*area/perimeter; fill when the agent disc cannot fit
-        if (2 * area / perimeter < agent_radius) {
+        // mean width of the hole = 2*area/perimeter; fill when it is below the requested threshold
+        if (2 * area / perimeter < min_width) {
             fill_loop(mesh, cycles[i]);
             filled++;
         }

package/src/core/geom/3d/topology/struct/binary/query/bt_face_island_flood_fill.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Flood-fill the connected component(s) of faces reachable from `seed_faces`, crossing shared edges.
+ *
+ * Faces already marked in `visited` are skipped; every face this call reaches is marked in `visited`
+ * and appended to `out`. Sharing one `visited` set across calls lets a caller partition a whole mesh
+ * into disjoint islands (see {@link bt_mesh_compute_face_islands}), while a fresh `visited` set
+ * re-derives a single island from its seeds (e.g. after the island's faces were subdivided - the new
+ * split halves stay edge-connected to the seed faces).
+ *
+ * @param {BinaryTopology} mesh
+ * @param {ArrayLike<number>} seed_faces face IDs to start from; non-allocated seeds are ignored
+ * @param {number[]} out destination array; discovered face IDs are appended in place
+ * @param {BitSet} visited shared visited set; faces already set are not revisited
+ * @returns {number} the number of faces appended to `out`
+ */
+export function bt_face_island_flood_fill(mesh: BinaryTopology, seed_faces: ArrayLike<number>, out: number[], visited: BitSet): number;
+//# sourceMappingURL=bt_face_island_flood_fill.d.ts.map

package/src/core/geom/3d/topology/struct/binary/query/bt_face_island_flood_fill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_face_island_flood_fill.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_face_island_flood_fill.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,4EALW,UAAU,MAAM,CAAC,OACjB,MAAM,EAAE,oBAEN,MAAM,CA2BlB"}

package/src/core/geom/3d/topology/struct/binary/query/bt_face_island_flood_fill.js

@@ -0,0 +1,45 @@
+import { bt_face_get_neighbour_faces } from "./bt_face_get_neighbour_faces.js";
+
+const _neighbours = [];
+
+/**
+ * Flood-fill the connected component(s) of faces reachable from `seed_faces`, crossing shared edges.
+ *
+ * Faces already marked in `visited` are skipped; every face this call reaches is marked in `visited`
+ * and appended to `out`. Sharing one `visited` set across calls lets a caller partition a whole mesh
+ * into disjoint islands (see {@link bt_mesh_compute_face_islands}), while a fresh `visited` set
+ * re-derives a single island from its seeds (e.g. after the island's faces were subdivided - the new
+ * split halves stay edge-connected to the seed faces).
+ *
+ * @param {BinaryTopology} mesh
+ * @param {ArrayLike<number>} seed_faces face IDs to start from; non-allocated seeds are ignored
+ * @param {number[]} out destination array; discovered face IDs are appended in place
+ * @param {BitSet} visited shared visited set; faces already set are not revisited
+ * @returns {number} the number of faces appended to `out`
+ */
+export function bt_face_island_flood_fill(mesh, seed_faces, out, visited) {
+    const start = out.length;
+    const faces = mesh.faces;
+
+    const open = [];
+    for (let i = 0; i < seed_faces.length; i++) {
+        const s = seed_faces[i];
+        if (!faces.is_allocated(s)) continue;
+        if (visited.getAndSet(s)) continue;
+        open.push(s);
+    }
+
+    while (open.length > 0) {
+        const f = open.pop();
+        out.push(f);
+
+        const neighbour_count = bt_face_get_neighbour_faces(_neighbours, 0, mesh, f);
+        for (let i = 0; i < neighbour_count; i++) {
+            const g = _neighbours[i];
+            if (visited.getAndSet(g)) continue;
+            open.push(g);
+        }
+    }
+
+    return out.length - start;
+}

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_boundary_euclidean_distance_field.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Gather the geometry of a set of boundary edges into a flat segment buffer for fast distance queries.
+ *
+ * Each edge contributes 6 consecutive numbers: `ax, ay, az, bx, by, bz`. The buffer is reused: it is
+ * written from index 0 and truncated to the exact number of values produced, so callers can keep a
+ * single array alive across many invocations without churning the garbage collector.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {Iterable<number>} boundary_edges boundary edge IDs
+ * @param {number[]} out_segments reused output buffer (filled and length-truncated in place)
+ * @returns {number} the number of segments written
+ */
+export function bt_collect_boundary_segments(mesh: BinaryTopology, boundary_edges: Iterable<number>, out_segments: number[]): number;
+/**
+ * Exact straight-line (Euclidean) distance from a point to the nearest boundary segment.
+ *
+ * @param {number[]} segments flat segment buffer (6 numbers per segment) from {@link bt_collect_boundary_segments}
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @returns {number} the distance, or `Infinity` when the buffer is empty
+ */
+export function bt_point_distance_to_segments(segments: number[], px: number, py: number, pz: number): number;
+/**
+ * Build a Euclidean boundary distance field for an island: for every island vertex, the exact
+ * straight-line distance to the nearest boundary segment.
+ *
+ * This is line-of-sight clearance to the nearest wall. It differs from
+ * {@link bt_mesh_build_boundary_distance_field}, which measures geodesic (along-surface) distance via
+ * an eikonal solve. Euclidean clearance is the correct metric for "how far is this point from any
+ * obstacle as the crow flies" - e.g. agent clearance during navmesh erosion - and, unlike the
+ * geodesic field, it is independent of how the interior happens to be triangulated.
+ *
+ * @param {Map<number, number>} vertex_boundary_distances result map (vertex ID -> distance); cleared then filled
+ * @param {BinaryTopology} mesh
+ * @param {Iterable<number>} island_vertices the vertices to evaluate
+ * @param {number[]} segments flat boundary segment buffer from {@link bt_collect_boundary_segments}
+ */
+export function bt_mesh_build_boundary_euclidean_distance_field(vertex_boundary_distances: Map<number, number>, mesh: BinaryTopology, island_vertices: Iterable<number>, segments: number[]): void;
+//# sourceMappingURL=bt_mesh_build_boundary_euclidean_distance_field.d.ts.map

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_boundary_euclidean_distance_field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_build_boundary_euclidean_distance_field.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_boundary_euclidean_distance_field.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,mFAJW,SAAS,MAAM,CAAC,gBAChB,MAAM,EAAE,GACN,MAAM,CAgBlB;AAED;;;;;;;;GAQG;AACH,wDANW,MAAM,EAAE,MACR,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAelB;AAED;;;;;;;;;;;;;;GAcG;AACH,2FALW,IAAI,MAAM,EAAE,MAAM,CAAC,yCAEnB,SAAS,MAAM,CAAC,YAChB,MAAM,EAAE,QAclB"}

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_boundary_euclidean_distance_field.js

@@ -0,0 +1,84 @@
+import { line3_compute_segment_point_distance_sqr } from "../../../../line/line3_compute_segment_point_distance_sqr.js";
+
+const _v = new Float32Array(3);
+
+/**
+ * Gather the geometry of a set of boundary edges into a flat segment buffer for fast distance queries.
+ *
+ * Each edge contributes 6 consecutive numbers: `ax, ay, az, bx, by, bz`. The buffer is reused: it is
+ * written from index 0 and truncated to the exact number of values produced, so callers can keep a
+ * single array alive across many invocations without churning the garbage collector.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {Iterable<number>} boundary_edges boundary edge IDs
+ * @param {number[]} out_segments reused output buffer (filled and length-truncated in place)
+ * @returns {number} the number of segments written
+ */
+export function bt_collect_boundary_segments(mesh, boundary_edges, out_segments) {
+    let w = 0;
+    let count = 0;
+
+    for (const e of boundary_edges) {
+        mesh.vertex_read_coordinate(_v, 0, mesh.edge_read_vertex1(e));
+        out_segments[w++] = _v[0]; out_segments[w++] = _v[1]; out_segments[w++] = _v[2];
+        mesh.vertex_read_coordinate(_v, 0, mesh.edge_read_vertex2(e));
+        out_segments[w++] = _v[0]; out_segments[w++] = _v[1]; out_segments[w++] = _v[2];
+        count++;
+    }
+
+    out_segments.length = w;
+    return count;
+}
+
+/**
+ * Exact straight-line (Euclidean) distance from a point to the nearest boundary segment.
+ *
+ * @param {number[]} segments flat segment buffer (6 numbers per segment) from {@link bt_collect_boundary_segments}
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @returns {number} the distance, or `Infinity` when the buffer is empty
+ */
+export function bt_point_distance_to_segments(segments, px, py, pz) {
+    let best_sq = Infinity;
+
+    for (let i = 0; i < segments.length; i += 6) {
+        const d_sq = line3_compute_segment_point_distance_sqr(
+            segments[i], segments[i + 1], segments[i + 2],
+            segments[i + 3], segments[i + 4], segments[i + 5],
+            px, py, pz
+        );
+        if (d_sq < best_sq) best_sq = d_sq;
+    }
+
+    return best_sq === Infinity ? Infinity : Math.sqrt(best_sq);
+}
+
+/**
+ * Build a Euclidean boundary distance field for an island: for every island vertex, the exact
+ * straight-line distance to the nearest boundary segment.
+ *
+ * This is line-of-sight clearance to the nearest wall. It differs from
+ * {@link bt_mesh_build_boundary_distance_field}, which measures geodesic (along-surface) distance via
+ * an eikonal solve. Euclidean clearance is the correct metric for "how far is this point from any
+ * obstacle as the crow flies" - e.g. agent clearance during navmesh erosion - and, unlike the
+ * geodesic field, it is independent of how the interior happens to be triangulated.
+ *
+ * @param {Map<number, number>} vertex_boundary_distances result map (vertex ID -> distance); cleared then filled
+ * @param {BinaryTopology} mesh
+ * @param {Iterable<number>} island_vertices the vertices to evaluate
+ * @param {number[]} segments flat boundary segment buffer from {@link bt_collect_boundary_segments}
+ */
+export function bt_mesh_build_boundary_euclidean_distance_field(
+    vertex_boundary_distances,
+    mesh,
+    island_vertices,
+    segments
+) {
+    vertex_boundary_distances.clear();
+
+    for (const v of island_vertices) {
+        mesh.vertex_read_coordinate(_v, 0, v);
+        vertex_boundary_distances.set(v, bt_point_distance_to_segments(segments, _v[0], _v[1], _v[2]));
+    }
+}

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_compute_face_islands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_compute_face_islands.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_compute_face_islands.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,oEAFa,MAAM,EAAE,EAAE,CAqEtB"}
+{"version":3,"file":"bt_mesh_compute_face_islands.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_compute_face_islands.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,oEAFa,MAAM,EAAE,EAAE,CA4CtB"}

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_compute_face_islands.js

@@ -1,78 +1,53 @@
-import { BitSet } from "../../../../../../binary/BitSet.js";
-import { bt_face_get_neighbour_faces } from "./bt_face_get_neighbour_faces.js";
-
-/**
- * Find groups of connected faces in the mesh. Faces are considered connected if they share an edge.
- * If the entire mesh is connected - there will be a single island.
- *
- * @param {BinaryTopology} mesh
- * @returns {number[][]} each island is a sequence of face IDs
- */
-export function bt_mesh_compute_face_islands(mesh) {
-    /**
-     *
-     * @type {number[][]}
-     */
-    const result = [];
-
-    // traverse over all faced in the mesh, flood-filling to build islands
-    const closed_set = new BitSet();
-
-    const faces = mesh.faces;
-
-    /**
-     * @type {number}
-     */
-    const face_count = faces.size;
-
-    /**
-     *
-     * @type {number[]}
-     */
-    const scratch_neighbours = [];
-
-    for (let seed_face_id = 0; seed_face_id < face_count; seed_face_id++) {
-        if (closed_set.getAndSet(seed_face_id)) {
-            // already processed
-            continue;
-        }
-
-        if (!faces.is_allocated(seed_face_id)) {
-            // a hole
-            continue;
-        }
-
-        // start a new island
-
-        /**
-         *
-         * @type {number[]}
-         */
-        const island = [];
-
-        result.push(island);
-
-        const open = [seed_face_id];
-
-        while (open.length > 0) {
-            const face_id = open.pop();
-
-            island.push(face_id);
-
-            const neighbour_count = bt_face_get_neighbour_faces(scratch_neighbours, 0, mesh, face_id);
-
-            for (let i = 0; i < neighbour_count; i++) {
-                const neighbour_id = scratch_neighbours[i];
-
-                if (closed_set.getAndSet(neighbour_id)) {
-                    continue;
-                }
-
-                open.push(neighbour_id);
-            }
-        }
-
-    }
-
-    return result;
-}
+import { BitSet } from "../../../../../../binary/BitSet.js";
+import { bt_face_island_flood_fill } from "./bt_face_island_flood_fill.js";
+
+/**
+ * Find groups of connected faces in the mesh. Faces are considered connected if they share an edge.
+ * If the entire mesh is connected - there will be a single island.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {number[][]} each island is a sequence of face IDs
+ */
+export function bt_mesh_compute_face_islands(mesh) {
+    /**
+     * @type {number[][]}
+     */
+    const result = [];
+
+    // shared visited set; flood fill marks every face it reaches so each face lands in exactly one island
+    const closed_set = new BitSet();
+
+    const faces = mesh.faces;
+
+    /**
+     * @type {number}
+     */
+    const face_count = faces.size;
+
+    // reused single-element seed buffer, avoids allocating an array per island
+    const seed = [0];
+
+    for (let seed_face_id = 0; seed_face_id < face_count; seed_face_id++) {
+        if (closed_set.get(seed_face_id)) {
+            // already part of an island
+            continue;
+        }
+
+        if (!faces.is_allocated(seed_face_id)) {
+            // a hole
+            continue;
+        }
+
+        /**
+         * @type {number[]}
+         */
+        const island = [];
+
+        seed[0] = seed_face_id;
+        bt_face_island_flood_fill(mesh, seed, island, closed_set);
+
+        result.push(island);
+    }
+
+    return result;
+}

package/src/core/geom/vec3/v3_matrix3_rotate.d.ts

@@ -0,0 +1,16 @@
+/**
+ *
+ * Perform rotation on a direction vector using a 3x3 (column-major) transform matrix.
+ * Input is expected to be normalized.
+ * Correctly handles non-uniform scaling.
+ * Output is normalized.
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number[]|Float32Array} mat3
+ */
+export function v3_matrix3_rotate(output: number[] | Float32Array, output_offset: number, x: number, y: number, z: number, mat3: number[] | Float32Array): void;
+//# sourceMappingURL=v3_matrix3_rotate.d.ts.map

package/src/core/geom/vec3/v3_matrix3_rotate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_matrix3_rotate.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_matrix3_rotate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,0CAPW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,QAkC/B"}

package/src/core/geom/vec3/v3_matrix3_rotate.js

@@ -0,0 +1,49 @@
+import { v3_length } from "./v3_length.js";
+
+/**
+ *
+ * Perform rotation on a direction vector using a 3x3 (column-major) transform matrix.
+ * Input is expected to be normalized.
+ * Correctly handles non-uniform scaling.
+ * Output is normalized.
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number[]|Float32Array} mat3
+ */
+export function v3_matrix3_rotate(
+    output, output_offset,
+    x, y, z,
+    mat3
+) {
+
+    const _x = mat3[0] * x + mat3[3] * y + mat3[6] * z;
+    const _y = mat3[1] * x + mat3[4] * y + mat3[7] * z;
+    const _z = mat3[2] * x + mat3[5] * y + mat3[8] * z;
+
+    // perform normalization
+    const length = v3_length(_x, _y, _z);
+
+    if (length > 1e-7) {
+
+        // re-normalize
+        const norm = 1 / length;
+
+        output[output_offset] = _x * norm;
+        output[output_offset + 1] = _y * norm;
+        output[output_offset + 2] = _z * norm;
+
+    } else {
+
+        // The transform is invalid.
+        // Provide arbitrary vector.
+
+        output[output_offset] = 0;
+        output[output_offset + 1] = 0;
+        output[output_offset + 2] = 0;
+
+    }
+}

package/src/core/geom/vec3/v3_orthonormal_matrix_from_normal.d.ts

@@ -1,10 +1,10 @@
 /**
  * Build orthonormal matrix from direction vector
- * @param {number[]} out
+ * @param {number[]|Float32Array|Float64Array} out
  * @param {number} out_offset
  * @param {number} dir_x
  * @param {number} dir_y
  * @param {number} dir_z
  */
-export function v3_orthonormal_matrix_from_normal(out: number[], out_offset: number, dir_x: number, dir_y: number, dir_z: number): void;
+export function v3_orthonormal_matrix_from_normal(out: number[] | Float32Array | Float64Array, out_offset: number, dir_x: number, dir_y: number, dir_z: number): void;
 //# sourceMappingURL=v3_orthonormal_matrix_from_normal.d.ts.map

package/src/core/geom/vec3/v3_orthonormal_matrix_from_normal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_orthonormal_matrix_from_normal.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_orthonormal_matrix_from_normal.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,uDANW,MAAM,EAAE,cACR,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QAsChB"}
+{"version":3,"file":"v3_orthonormal_matrix_from_normal.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_orthonormal_matrix_from_normal.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,uDANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QAsChB"}

package/src/core/geom/vec3/v3_orthonormal_matrix_from_normal.js

@@ -1,47 +1,47 @@
-import { v3_length } from "./v3_length.js";
-
-/**
- * Build orthonormal matrix from direction vector
- * @param {number[]} out
- * @param {number} out_offset
- * @param {number} dir_x
- * @param {number} dir_y
- * @param {number} dir_z
- */
-export function v3_orthonormal_matrix_from_normal(out, out_offset, dir_x, dir_y, dir_z) {
-    // we build orthonormal vectors with respect to the direction vector
-    let o1_x, o1_y, o1_z;
-
-    if (Math.abs(dir_x) > Math.abs(dir_z)) {
-        o1_x = -dir_y;
-        o1_y = dir_x;
-        o1_z = 0;
-    } else {
-        o1_x = 0;
-        o1_y = -dir_z;
-        o1_z = dir_y;
-    }
-
-    // normalize orthonormal vector
-    const o1_norm = 1 / v3_length(o1_x, o1_y, o1_z);
-
-    o1_x *= o1_norm;
-    o1_y *= o1_norm;
-    o1_z *= o1_norm;
-
-    const o2_x = dir_y * o1_z - dir_z * o1_y;
-    const o2_y = dir_z * o1_x - dir_x * o1_z;
-    const o2_z = dir_x * o1_y - dir_y * o1_x;
-
-    out[out_offset] = o1_x;
-    out[out_offset + 1] = o1_y;
-    out[out_offset + 2] = o1_z;
-
-    out[out_offset + 3] = o2_x;
-    out[out_offset + 4] = o2_y;
-    out[out_offset + 5] = o2_z;
-
-    out[out_offset + 6] = dir_x;
-    out[out_offset + 7] = dir_y;
-    out[out_offset + 8] = dir_z;
+import { v3_length } from "./v3_length.js";
+
+/**
+ * Build orthonormal matrix from direction vector
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number} dir_x
+ * @param {number} dir_y
+ * @param {number} dir_z
+ */
+export function v3_orthonormal_matrix_from_normal(out, out_offset, dir_x, dir_y, dir_z) {
+    // we build orthonormal vectors with respect to the direction vector
+    let o1_x, o1_y, o1_z;
+
+    if (Math.abs(dir_x) > Math.abs(dir_z)) {
+        o1_x = -dir_y;
+        o1_y = dir_x;
+        o1_z = 0;
+    } else {
+        o1_x = 0;
+        o1_y = -dir_z;
+        o1_z = dir_y;
+    }
+
+    // normalize orthonormal vector
+    const o1_norm = 1 / v3_length(o1_x, o1_y, o1_z);
+
+    o1_x *= o1_norm;
+    o1_y *= o1_norm;
+    o1_z *= o1_norm;
+
+    const o2_x = dir_y * o1_z - dir_z * o1_y;
+    const o2_y = dir_z * o1_x - dir_x * o1_z;
+    const o2_z = dir_x * o1_y - dir_y * o1_x;
+
+    out[out_offset] = o1_x;
+    out[out_offset + 1] = o1_y;
+    out[out_offset + 2] = o1_z;
+
+    out[out_offset + 3] = o2_x;
+    out[out_offset + 4] = o2_y;
+    out[out_offset + 5] = o2_z;
+
+    out[out_offset + 6] = dir_x;
+    out[out_offset + 7] = dir_y;
+    out[out_offset + 8] = dir_z;
 }

package/src/engine/graphics/sh3/path_tracer/sampling/getBiasedNormalSample.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getBiasedNormalSample.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/sampling/getBiasedNormalSample.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,2CAPW,MAAM,EAAE,cACR,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,SACN,MAAM,gBACK,MAAM,QAsD3B"}
+{"version":3,"file":"getBiasedNormalSample.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/path_tracer/sampling/getBiasedNormalSample.js"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,2CAPW,MAAM,EAAE,cACR,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,SACN,MAAM,gBACK,MAAM,QA6B3B"}

package/src/engine/graphics/sh3/path_tracer/sampling/getBiasedNormalSample.js

@@ -1,6 +1,9 @@
-import { v3_length } from "../../../../../core/geom/vec3/v3_length.js";
+import { v3_matrix3_rotate } from "../../../../../core/geom/vec3/v3_matrix3_rotate.js";
+import { v3_orthonormal_matrix_from_normal } from "../../../../../core/geom/vec3/v3_orthonormal_matrix_from_normal.js";
 import { PI2 } from "../../../../../core/math/PI2.js";
 
+const mat3 = new Float32Array(9);
+
 /**
  * @see 2003 "Global Illumination Compendium" by Philip Dutré (equation 36)
  * @see http://blog.hvidtfeldts.net/index.php/2015/01/path-tracing-3d-fractals/
@@ -24,29 +27,7 @@ export function getBiasedNormalSample(
     const dir_y = normal[normal_offset + 1];
     const dir_z = normal[normal_offset + 2];
 
-    // we build orthonormal vectors with respect to the direction vector
-    let o1_x, o1_y, o1_z;
-
-    if (Math.abs(dir_x) > Math.abs(dir_z)) {
-        o1_x = -dir_y;
-        o1_y = dir_x;
-        o1_z = 0;
-    } else {
-        o1_x = 0;
-        o1_y = -dir_z;
-        o1_z = dir_y;
-    }
-
-    // normalize orthonormal vector
-    const o1_norm = 1 / v3_length(o1_x, o1_y, o1_z);
-
-    o1_x *= o1_norm;
-    o1_y *= o1_norm;
-    o1_z *= o1_norm;
-
-    const o2_x = dir_y * o1_z - dir_z * o1_y;
-    const o2_y = dir_z * o1_x - dir_x * o1_z;
-    const o2_z = dir_x * o1_y - dir_y * o1_x;
+    v3_orthonormal_matrix_from_normal(mat3, 0, dir_x, dir_y, dir_z);
 
     // we can skip normalizing second orthonormal vector, as it will be guaranteed to be unit length already
     // for explanation, see https://math.stackexchange.com/questions/23259/is-the-cross-product-of-two-unit-vectors-itself-a-unit-vector#:~:text=If%20you%20know%20that%20the,(a%20length%20of%20one).
@@ -59,9 +40,6 @@ export function getBiasedNormalSample(
     const k0 = Math.cos(r_x) * oneminus;
     const k1 = Math.sin(r_x) * oneminus;
 
-
-    out[out_offset] = k0 * o1_x + k1 * o2_x + r_y * dir_x;
-    out[out_offset + 1] = k0 * o1_y + k1 * o2_y + r_y * dir_y;
-    out[out_offset + 2] = k0 * o1_z + k1 * o2_z + r_y * dir_z;
+    v3_matrix3_rotate(out, 3, k0, k1, r_y, mat3);
 }