@woosh/meep-engine 2.131.48 → 2.132.1

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

@@ -0,0 +1,151 @@
+import { Uint32Heap } from "../../../../../../collection/heap/Uint32Heap.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { bt_mesh_compute_edge_distance_eikonal } from "./bt_mesh_compute_edge_distance_eikonal.js";
+
+/**
+ * Build distance field for a given island (group of faces).
+ * Distances are calculated as shortest from the boundary.
+ *
+ * Distances are the shortest distances from the boundary along the mesh.
+ * Only the island vertices are considered.
+ *
+ * Unreachable vertices are marked with Infinity distance.
+ * @param {Map<number, number>} vertex_boundary_distances Mapping from vertex ID to distance from boundary. The result is stored here.
+ * @param {BinaryTopology} mesh
+ * @param {Set<number>} island_vertices
+ * @param {Set<number>} boundary_vertices Subset of island_vertices that are on the boundary.
+ */
+export function bt_mesh_build_boundary_distance_field(
+    vertex_boundary_distances,
+    mesh,
+    island_vertices,
+    boundary_vertices
+) {
+
+    const heap = new Uint32Heap(island_vertices.size);
+
+    // initialize distances
+    for (const v of island_vertices) {
+        if (boundary_vertices.has(v)) {
+            vertex_boundary_distances.set(v, 0);
+            heap.insert(v, 0);
+        } else {
+            vertex_boundary_distances.set(v, Infinity);
+        }
+    }
+
+    const scratch_vertex = new Float32Array(3);
+
+    while (!heap.is_empty()) {
+        const current_vertex = heap.pop_min();
+        const current_distance = vertex_boundary_distances.get(current_vertex);
+
+        // Traverse disk cycle to get neighboring edges
+        const e_first = mesh.vertex_read_edge(current_vertex);
+        if (e_first === NULL_POINTER) {
+            continue;
+        }
+
+        let e_curr = e_first;
+        do {
+            const v1 = mesh.edge_read_vertex1(e_curr);
+            const v2 = mesh.edge_read_vertex2(e_curr);
+
+            const is_v1 = v1 === current_vertex;
+            const v_other = is_v1 ? v2 : v1;
+
+            // ---------------------------------------------------------
+            // STEP A: Vertex Update (Dijkstra Fallback)
+            // ---------------------------------------------------------
+            // We must attempt to update the neighbor (v_other) directly from current_vertex.
+            // This ensures that 'v_other' gets a valid distance (if it was Infinity),
+            // allowing the subsequent Eikonal step to have a valid edge to propagate from.
+
+            // 1. Read coordinates to compute edge length
+            mesh.vertex_read_coordinate(scratch_vertex, 0, current_vertex);
+            const cx = scratch_vertex[0];
+            const cy = scratch_vertex[1];
+            const cz = scratch_vertex[2];
+
+            mesh.vertex_read_coordinate(scratch_vertex, 0, v_other);
+            const ox = scratch_vertex[0];
+            const oy = scratch_vertex[1];
+            const oz = scratch_vertex[2];
+
+            const edge_len = Math.hypot(cx - ox, cy - oy, cz - oz);
+            const new_neighbor_dist = current_distance + edge_len;
+
+            let other_distance = vertex_boundary_distances.get(v_other);
+
+            // Update v_other if the direct edge path is shorter than what it currently has
+            if (new_neighbor_dist < other_distance) {
+                vertex_boundary_distances.set(v_other, new_neighbor_dist);
+                heap.insert_or_update(v_other, new_neighbor_dist);
+                // Update local variable so STEP B uses the tighter bound immediately
+                other_distance = new_neighbor_dist;
+            }
+
+            // ---------------------------------------------------------
+            // STEP B: Edge Update (Eikonal)
+            // ---------------------------------------------------------
+            // Now that we've ensured v_other is as up-to-date as possible,
+            // we check if we can form a valid front (edge) to update the triangle's 3rd vertex.
+
+            if (other_distance !== undefined && other_distance !== Infinity) {
+
+                // Find the faces (triangles) sharing this edge using the radial cycle
+                const l_first = mesh.edge_read_loop(e_curr);
+
+                if (l_first !== NULL_POINTER) {
+                    let l_curr = l_first;
+                    do {
+                        const face = mesh.loop_read_face(l_curr);
+
+                        // Find the 3rd "target" vertex of this triangular face
+                        let fl = mesh.face_read_loop(face);
+                        let v_target = -1;
+
+
+                        // TODO assert the 3-vertex assumption
+
+                        // Iterate max 3 times (explicitly assuming faces are triangles)
+                        for (let i = 0; i < 3; i++) {
+                            const fv = mesh.loop_read_vertex(fl);
+                            if (fv !== v1 && fv !== v2) {
+                                v_target = fv;
+                                break;
+                            }
+                            fl = mesh.loop_read_next(fl);
+                        }
+
+                        // If we found a valid 3rd vertex inside our island, attempt to relax its distance
+                        if (v_target !== -1 && island_vertices.has(v_target)) {
+
+                            const new_distance = bt_mesh_compute_edge_distance_eikonal(
+                                mesh,
+                                current_vertex,
+                                v_other,
+                                current_distance,
+                                other_distance,
+                                v_target
+                            );
+
+                            const existing_distance = vertex_boundary_distances.get(v_target);
+
+                            if (new_distance < existing_distance) {
+                                vertex_boundary_distances.set(v_target, new_distance);
+                                heap.insert_or_update(v_target, new_distance);
+                            }
+                        }
+
+                        // Move to the next face sharing this edge
+                        l_curr = mesh.loop_read_radial_next(l_curr);
+                    } while (l_curr !== l_first && l_curr !== NULL_POINTER);
+                }
+            }
+
+            // Move to the next edge in the vertex's disk cycle
+            e_curr = is_v1 ? mesh.edge_read_v1_disk_next(e_curr) : mesh.edge_read_v2_disk_next(e_curr);
+        } while (e_curr !== e_first && e_curr !== NULL_POINTER);
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Solves the quadratic Eikonal equation for a triangle.
+ * Based on the Kimmel-Sethian update for Fast Marching Methods.
+ * @param {BinaryTopology} mesh
+ * @param {number} v0 Vertex ID of edge start
+ * @param {number} v1 Vertex ID of edge end
+ * @param {number} d0 Distance at v0
+ * @param {number} d1 Distance at v1
+ * @param {number} v_target The vertex we are solving for
+ * @returns {number} The exact geodesic distance
+ */
+export function bt_mesh_compute_edge_distance_eikonal(mesh: BinaryTopology, v0: number, v1: number, d0: number, d1: number, v_target: number): number;
+//# sourceMappingURL=bt_mesh_compute_edge_distance_eikonal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_compute_edge_distance_eikonal.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_compute_edge_distance_eikonal.js"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,gFAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,GACJ,MAAM,CA8BlB"}

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

@@ -0,0 +1,46 @@
+import {
+    line3_compute_segment_point_distance_eikonal
+} from "../../../../line/line3_compute_segment_point_distance_eikonal.js";
+
+const scratch_vertex = new Float32Array(3);
+
+/**
+ * Solves the quadratic Eikonal equation for a triangle.
+ * Based on the Kimmel-Sethian update for Fast Marching Methods.
+ * @param {BinaryTopology} mesh
+ * @param {number} v0 Vertex ID of edge start
+ * @param {number} v1 Vertex ID of edge end
+ * @param {number} d0 Distance at v0
+ * @param {number} d1 Distance at v1
+ * @param {number} v_target The vertex we are solving for
+ * @returns {number} The exact geodesic distance
+ */
+export function bt_mesh_compute_edge_distance_eikonal(
+    mesh,
+    v0, v1,
+    d0, d1,
+    v_target
+) {
+    // 1. Read Coordinates
+    mesh.vertex_read_coordinate(scratch_vertex, 0, v0);
+    const ax = scratch_vertex[0];
+    const ay = scratch_vertex[1];
+    const az = scratch_vertex[2];
+
+    mesh.vertex_read_coordinate(scratch_vertex, 0, v1);
+    const bx = scratch_vertex[0];
+    const by = scratch_vertex[1];
+    const bz = scratch_vertex[2];
+
+    mesh.vertex_read_coordinate(scratch_vertex, 0, v_target);
+    const cx = scratch_vertex[0];
+    const cy = scratch_vertex[1];
+    const cz = scratch_vertex[2];
+
+    return line3_compute_segment_point_distance_eikonal(
+        d0, d1,
+        ax, ay, az,
+        bx, by, bz,
+        cx, cy, cz
+    );
+}

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

@@ -0,0 +1,9 @@
+/**
+ * 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: BinaryTopology): number[][];
+//# sourceMappingURL=bt_mesh_compute_face_islands.d.ts.map

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

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

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

@@ -0,0 +1,78 @@
+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;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Shortest distance from a vertex to a given edge.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} v Vertex ID
+ * @param {number} e Edge ID
+ * @returns {number}
+ */
+export function bt_vertex_distance_to_edge(mesh: BinaryTopology, v: number, e: number): number;
+//# sourceMappingURL=bt_vertex_distance_to_edge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_vertex_distance_to_edge.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_vertex_distance_to_edge.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,oEAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAqClB"}

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

@@ -0,0 +1,48 @@
+import { line3_compute_segment_point_distance_sqr } from "../../../../line/line3_compute_segment_point_distance_sqr.js";
+
+const scratch_vertex = new Float32Array(3);
+
+/**
+ * Shortest distance from a vertex to a given edge.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} v Vertex ID
+ * @param {number} e Edge ID
+ * @returns {number}
+ */
+export function bt_vertex_distance_to_edge(mesh, v, e) {
+
+    const e_v1 = mesh.edge_read_vertex1(e);
+    const e_v2 = mesh.edge_read_vertex2(e);
+
+    if (e_v1 === v || e_v2 === v) {
+        // vertex is on edge
+        return 0;
+    }
+
+    mesh.vertex_read_coordinate(scratch_vertex, 0, v);
+
+    const px = scratch_vertex[0];
+    const py = scratch_vertex[1];
+    const pz = scratch_vertex[2];
+
+    mesh.vertex_read_coordinate(scratch_vertex, 0, e_v1);
+
+    const ax = scratch_vertex[0];
+    const ay = scratch_vertex[1];
+    const az = scratch_vertex[2];
+
+    mesh.vertex_read_coordinate(scratch_vertex, 0, e_v2);
+
+    const bx = scratch_vertex[0];
+    const by = scratch_vertex[1];
+    const bz = scratch_vertex[2];
+
+    const d2 = line3_compute_segment_point_distance_sqr(
+        ax, ay, az,
+        bx, by, bz,
+        px, py, pz
+    );
+
+    return Math.sqrt(d2);
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Straight-line distance between two vertices in the mesh.
+ * @param {BinaryTopology} mesh
+ * @param {number} v1
+ * @param {number} v2
+ * @returns {number}
+ */
+export function bt_vertex_distance_to_vertex(mesh: BinaryTopology, v1: number, v2: number): number;
+//# sourceMappingURL=bt_vertex_distance_to_vertex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_vertex_distance_to_vertex.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_vertex_distance_to_vertex.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,uEAJW,MAAM,MACN,MAAM,GACJ,MAAM,CAmBlB"}

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

@@ -0,0 +1,31 @@
+import { v3_distance } from "../../../../../vec3/v3_distance.js";
+
+const scratch_vertex = new Float32Array(3);
+
+/**
+ * Straight-line distance between two vertices in the mesh.
+ * @param {BinaryTopology} mesh
+ * @param {number} v1
+ * @param {number} v2
+ * @returns {number}
+ */
+export function bt_vertex_distance_to_vertex(mesh, v1, v2) {
+    mesh.vertex_read_coordinate(scratch_vertex, 0, v1);
+
+    const x0 = scratch_vertex[0];
+    const y0 = scratch_vertex[1];
+    const z0 = scratch_vertex[2];
+
+    mesh.vertex_read_coordinate(scratch_vertex, 0, v2);
+
+    const x1 = scratch_vertex[0];
+    const y1 = scratch_vertex[1];
+    const z1 = scratch_vertex[2];
+
+    return v3_distance(
+        x0, y0, z0,
+        x1, y1, z1,
+    );
+}
+
+

package/src/core/geom/3d/topology/struct/prototypeBinaryTopology.js

@@ -6,7 +6,7 @@ import {
 import { noop } from "../../../../function/noop.js";
 import { number_pretty_print } from "../../../../primitives/numbers/number_pretty_print.js";
 import { BinaryTopology } from "./binary/BinaryTopology.js";
-import { bt_index_geometry_to_topology } from "./binary/io/bt_index_geometry_to_topology.js";
+import { bt_mesh_from_indexed_geometry } from "./binary/io/bt_mesh_from_indexed_geometry.js";
 import { TopoMesh } from "./TopoMesh.js";
 
 function promise_ply(url) {
@@ -33,7 +33,7 @@ async function main() {
 
     console.time('topo build - bin');
     // console.profile('topo build - bin');
-    bt_index_geometry_to_topology(mesh, index_array, positions_array);
+    bt_mesh_from_indexed_geometry(mesh, index_array, positions_array);
     // console.profileEnd('topo build - bin');
     console.timeEnd('topo build - bin');
     //

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

@@ -0,0 +1,19 @@
+/**
+ * Calculates the incenter of a triangle.
+ *
+ * @see https://en.wikipedia.org/wiki/Incenter
+ * @param {number[]|Float32Array|Float64Array|ArrayLike<number>} output
+ * @param {number} output_offset
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @returns {boolean} true when the result was calculated, false for degenerate triangle
+ */
+export function triangle3_incenter(output: number[] | Float32Array | Float64Array | ArrayLike<number>, output_offset: number, x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): boolean;
+//# sourceMappingURL=triangle3_incenter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"triangle3_incenter.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/triangle3_incenter.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,2CAbW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAAC,UAAU,MAAM,CAAC,iBACpD,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CA4CnB"}

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

@@ -0,0 +1,60 @@
+/**
+ * Calculates the incenter of a triangle.
+ *
+ * @see https://en.wikipedia.org/wiki/Incenter
+ * @param {number[]|Float32Array|Float64Array|ArrayLike<number>} output
+ * @param {number} output_offset
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @returns {boolean} true when the result was calculated, false for degenerate triangle
+ */
+export function triangle3_incenter(
+    output, output_offset,
+    x0, y0, z0,
+    x1, y1, z1,
+    x2, y2, z2
+) {
+    // Calculate edge lengths opposite to each vertex
+
+    // 'a' is length of edge v1-v2 (opposite v0)
+    const dxA = x2 - x1;
+    const dyA = y2 - y1;
+    const dzA = z2 - z1;
+
+    const a = Math.sqrt(dxA * dxA + dyA * dyA + dzA * dzA);
+
+    // 'b' is length of edge v2-v0 (opposite v1)
+    const dxB = x0 - x2;
+    const dyB = y0 - y2;
+    const dzB = z0 - z2;
+
+    const b = Math.sqrt(dxB * dxB + dyB * dyB + dzB * dzB);
+
+    // 'c' is length of edge v0-v1 (opposite v2)
+    const dxC = x1 - x0;
+    const dyC = y1 - y0;
+    const dzC = z1 - z0;
+
+    const c = Math.sqrt(dxC * dxC + dyC * dyC + dzC * dzC);
+
+    const perimeter = a + b + c;
+
+    if (perimeter <= 0) {
+        // 0 perimeter triangle
+        return false;
+    }
+
+    output[output_offset] = (a * x0 + b * x1 + c * x2) / perimeter;
+    output[output_offset + 1] = (a * y0 + b * y1 + c * y2) / perimeter;
+    output[output_offset + 2] = (a * z0 + b * z1 + c * z2) / perimeter;
+
+    return true;
+
+}

package/src/core/math/hash/lowbias32.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Excellent 32bit hash function.
+ *
+ * Based on work by TheIronBorn circa 2022.
+ * @param {number} v
+ * @returns {number}
+ */
+export function lowbias32(v: number): number;
+//# sourceMappingURL=lowbias32.d.ts.map

package/src/core/math/hash/lowbias32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lowbias32.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/hash/lowbias32.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,6BAHW,MAAM,GACJ,MAAM,CAclB"}

package/src/core/math/hash/lowbias32.js

@@ -0,0 +1,20 @@
+/**
+ * Excellent 32bit hash function.
+ *
+ * Based on work by TheIronBorn circa 2022.
+ * @param {number} v
+ * @returns {number}
+ */
+export function lowbias32(v) {
+
+    let x = v;
+
+    x ^= x >>> 16;
+    x = Math.imul(x, 0x21f0aaad);
+    x ^= x >>> 15;
+    x = Math.imul(x, 0xd35a2d97)
+    x ^= x >>> 15;
+
+    return x >>> 0;
+
+}

package/src/core/process/task/util/iteratorTask.d.ts

@@ -2,10 +2,10 @@
  *
  * @param {string} name
  * @param {Iterator} iterator
- * @param {(TaskSignal.Continue)|(TaskSignal.Yield)} [cycle_signal] what to signal at the end of each iteration, Continue will provide better throughput, whereas Yield will produce very low load on the CPU
+ * @param {TaskSignal} [cycle_signal] what to signal at the end of each iteration, Continue will provide better throughput, whereas Yield will produce very low load on the CPU
  * @returns {Task}
  */
-export function iteratorTask(name: string, iterator: Iterator<any, any, undefined>, cycle_signal?: (TaskSignal.Continue) | (TaskSignal.Yield)): Task;
+export function iteratorTask(name: string, iterator: Iterator<any, any, undefined>, cycle_signal?: TaskSignal): Task;
 import { TaskSignal } from "../TaskSignal.js";
 import Task from "../Task.js";
 //# sourceMappingURL=iteratorTask.d.ts.map

package/src/core/process/task/util/iteratorTask.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"iteratorTask.d.ts","sourceRoot":"","sources":["../../../../../../src/core/process/task/util/iteratorTask.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,mCALW,MAAM,0DAEN,CAAC,WAAW,QAAQ,CAAC,GAAC,CAAC,WAAW,KAAK,CAAC,GACtC,IAAI,CAoBhB;2BA7B0B,kBAAkB;iBAD5B,YAAY"}
+{"version":3,"file":"iteratorTask.d.ts","sourceRoot":"","sources":["../../../../../../src/core/process/task/util/iteratorTask.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,mCALW,MAAM,0DAEN,UAAU,GACR,IAAI,CAoBhB;2BA3B0B,kBAAkB;iBAD5B,YAAY"}

package/src/core/process/task/util/iteratorTask.js

@@ -1,13 +1,13 @@
-import Task from "../Task.js";
-import { TaskSignal } from "../TaskSignal.js";
 import { assert } from "../../../assert.js";
 import { anyOf, equalTo } from "../../../debug/matchers/matchers.js";
+import Task from "../Task.js";
+import { TaskSignal } from "../TaskSignal.js";
 
 /**
  *
  * @param {string} name
  * @param {Iterator} iterator
- * @param {(TaskSignal.Continue)|(TaskSignal.Yield)} [cycle_signal] what to signal at the end of each iteration, Continue will provide better throughput, whereas Yield will produce very low load on the CPU
+ * @param {TaskSignal} [cycle_signal] what to signal at the end of each iteration, Continue will provide better throughput, whereas Yield will produce very low load on the CPU
  * @returns {Task}
  */
 export function iteratorTask(name, iterator, cycle_signal = TaskSignal.Continue) {

package/src/engine/graphics/particles/particular/engine/utils/distrubuteParticlesOnMesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"distrubuteParticlesOnMesh.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/utils/distrubuteParticlesOnMesh.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,mDALW,eAAe,QACf,kBAAgB,kCAEhB,MAAM,QA0BhB;AAGD;;;;;;;;GAQG;AACH,8CAPW,MAAM,8CAGN,MAAM,+CA6IhB;gCAxL+B,+BAA+B"}
+{"version":3,"file":"distrubuteParticlesOnMesh.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/graphics/particles/particular/engine/utils/distrubuteParticlesOnMesh.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,mDALW,eAAe,QACf,kBAAgB,kCAEhB,MAAM,QA0BhB;AAGD;;;;;;;;GAQG;AACH,8CAPW,MAAM,8CAGN,MAAM,+CA6IhB;gCAvL+B,+BAA+B"}

package/src/engine/graphics/particles/particular/engine/utils/distrubuteParticlesOnMesh.js

@@ -1,9 +1,9 @@
+import { roundFair } from "../../../../../../core/math/random/roundFair.js";
 import { seededRandom } from "../../../../../../core/math/random/seededRandom.js";
-import { ParticleEmitterFlag } from "../emitter/ParticleEmitterFlag.js";
 import { computeMeshSurfaceArea } from "../../../../geometry/computeMeshSurfaceArea.js";
-import { ParticleEmitter } from "../emitter/ParticleEmitter.js";
 import { computeSkinnedMeshVertices } from "../../../../geometry/skining/computeSkinnedMeshVertices.js";
-import { roundFair } from "../../../../../../core/math/random/roundFair.js";
+import { ParticleEmitter } from "../emitter/ParticleEmitter.js";
+import { ParticleEmitterFlag } from "../emitter/ParticleEmitterFlag.js";
 
 /**
  *
@@ -144,7 +144,7 @@ export function distributePointsOnMesh(count, mesh, transform, randomSeed, callb
             const cy = points[c3 + 1];
             const cz = points[c3 + 2];
 
-            //pick random point on the triangle
+            // pick random point on the triangle using barycentric coordinates
             // method from here: https://math.stackexchange.com/questions/538458/triangle-point-picking-in-3d
             const cax = cx - ax;
             const cay = cy - ay;

package/src/engine/graphics/render/forward_plus/query/detailed_sphere_frustum_intersection_test.js

@@ -1,8 +1,8 @@
+import {
+    line3_compute_segment_point_distance_sqr
+} from "../../../../../core/geom/3d/line/line3_compute_segment_point_distance_sqr.js";
 import { v3_distance_sqr } from "../../../../../core/geom/vec3/v3_distance_sqr.js";
 import { biplanar_edge_mapping, triplanar_corner_mapping } from "./cube_mapping.js";
-import {
-    line3_computeSegmentPointDistance_sqr
-} from "../../../../../core/geom/3d/line/line3_computeSegmentPointDistance_sqr.js";
 
 /**
  *
@@ -67,7 +67,7 @@ export function detailed_sphere_frustum_intersection_test(
         const point_1_y = points[corner_address_1 + 1];
         const point_1_z = points[corner_address_1 + 2];
 
-        const distance_to_frustum_sqr = line3_computeSegmentPointDistance_sqr(
+        const distance_to_frustum_sqr = line3_compute_segment_point_distance_sqr(
             point_0_x, point_0_y, point_0_z,
             point_1_x, point_1_y, point_1_z,
             light_x, light_y, light_z