@woosh/meep-engine 2.131.48 → 2.132.1

package/src/engine/navigation/ecs/components/Path.js

@@ -3,8 +3,8 @@ import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
 import { RowFirstTable } from "../../../../core/collection/table/RowFirstTable.js";
 import { RowFirstTableSpec } from "../../../../core/collection/table/RowFirstTableSpec.js";
 import {
-    line3_computeSegmentPointDistance_sqr
-} from "../../../../core/geom/3d/line/line3_computeSegmentPointDistance_sqr.js";
+    line3_compute_segment_point_distance_sqr
+} from "../../../../core/geom/3d/line/line3_compute_segment_point_distance_sqr.js";
 import { v3_distance } from "../../../../core/geom/vec3/v3_distance.js";
 import { clamp } from "../../../../core/math/clamp.js";
 import { lerp } from "../../../../core/math/lerp.js";
@@ -318,7 +318,7 @@ class Path {
             this.readPositionToArray(i, p1, 0);
 
             //
-            const distance_sqr = line3_computeSegmentPointDistance_sqr(
+            const distance_sqr = line3_compute_segment_point_distance_sqr(
                 p0[0], p0[1], p0[2],
                 p1[0], p1[1], p1[2],
                 reference.x, reference.y, reference.z

package/src/engine/navigation/grid/find_path_on_grid_astar.d.ts

@@ -1,10 +1,10 @@
 /**
  *
  * @param {number[]|Uint8Array|Uint16Array|Float32Array} field
- * @param {number} width
- * @param {number} height
- * @param {number} start
- * @param {number} goal
+ * @param {number} width X resolution of the search grid
+ * @param {number} height Y resolution of the search grid
+ * @param {number} start index of the starting position
+ * @param {number} goal index of the destination position
  * @param {number} block_value value in the field that signifies impassible obstacle
  * @returns {Array.<number>} array of indices representing path from start to end
  */

package/src/engine/navigation/grid/find_path_on_grid_astar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find_path_on_grid_astar.d.ts","sourceRoot":"","sources":["../../../../../src/engine/navigation/grid/find_path_on_grid_astar.js"],"names":[],"mappings":"AAoMA;;;;;;;;;GASG;AACH,+CARW,MAAM,EAAE,GAAC,UAAU,GAAC,WAAW,GAAC,YAAY,SAC5C,MAAM,UACN,MAAM,SACN,MAAM,QACN,MAAM,eACN,MAAM,GACJ,MAAO,MAAM,CAAC,CA2F1B"}
+{"version":3,"file":"find_path_on_grid_astar.d.ts","sourceRoot":"","sources":["../../../../../src/engine/navigation/grid/find_path_on_grid_astar.js"],"names":[],"mappings":"AAoMA;;;;;;;;;GASG;AACH,+CARW,MAAM,EAAE,GAAC,UAAU,GAAC,WAAW,GAAC,YAAY,SAC5C,MAAM,UACN,MAAM,SACN,MAAM,QACN,MAAM,eACN,MAAM,GACJ,MAAO,MAAM,CAAC,CA4F1B"}

package/src/engine/navigation/grid/find_path_on_grid_astar.js

@@ -197,10 +197,10 @@ let g_score = new Float32Array(1024);
 /**
  *
  * @param {number[]|Uint8Array|Uint16Array|Float32Array} field
- * @param {number} width
- * @param {number} height
- * @param {number} start
- * @param {number} goal
+ * @param {number} width X resolution of the search grid
+ * @param {number} height Y resolution of the search grid
+ * @param {number} start index of the starting position
+ * @param {number} goal index of the destination position
  * @param {number} block_value value in the field that signifies impassible obstacle
  * @returns {Array.<number>} array of indices representing path from start to end
  */
@@ -226,6 +226,7 @@ export function find_path_on_grid_astar(
     const cell_count = width * height;
 
     if (g_score.length < cell_count) {
+        // resize scratch
         g_score = new Float32Array(cell_count);
     }
 

package/src/engine/navigation/mesh/NavigationMesh.d.ts

@@ -0,0 +1,32 @@
+export class NavigationMesh {
+    topology: BinaryTopology;
+    /**
+     * Used for raycasts and neighborhood search.
+     * @type {BVH}
+     */
+    bvh: BVH;
+    /**
+     * Build from given scene geometry
+     * @param {BinaryTopology} source
+     * @param {number} [agent_radius]
+     * @param {number} [agent_height]
+     * @param {number} [agent_max_climb] In radians, how steep of an angle can the agent go up by
+     * @param {Vector3} [up] Defines world's "UP" direction, this is what the agent will respect for climbing constraint
+     */
+    build({ source, agent_radius, agent_height, agent_max_climb, up, }: BinaryTopology): void;
+    /**
+     *
+     * @param {Float32Array} output
+     * @param {number} start_x
+     * @param {number} start_y
+     * @param {number} start_z
+     * @param {number} goal_x
+     * @param {number} goal_y
+     * @param {number} goal_z
+     * @returns {number}
+     */
+    find_path(output: Float32Array, start_x: number, start_y: number, start_z: number, goal_x: number, goal_y: number, goal_z: number): number;
+}
+import { BinaryTopology } from "../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
+import { BVH } from "../../../core/bvh2/bvh3/BVH.js";
+//# sourceMappingURL=NavigationMesh.d.ts.map

package/src/engine/navigation/mesh/NavigationMesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavigationMesh.d.ts","sourceRoot":"","sources":["../../../../../src/engine/navigation/mesh/NavigationMesh.js"],"names":[],"mappings":"AAmCA;IAEI,yBAAgC;IAEhC;;;OAGG;IACH,KAFU,GAAG,CAEG;IAEhB;;;;;;;OAOG;IACH,oEANW,cAAc,QAwBxB;IAGD;;;;;;;;;;OAUG;IACH,kBATW,YAAY,WACZ,MAAM,WACN,MAAM,WACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAwGlB;CAEJ;+BA3L4C,gEAAgE;oBAFzF,gCAAgC"}

package/src/engine/navigation/mesh/NavigationMesh.js

@@ -0,0 +1,190 @@
+import { BVH } from "../../../core/bvh2/bvh3/BVH.js";
+import { array_copy } from "../../../core/collection/array/array_copy.js";
+import { BinaryTopology, NULL_POINTER } from "../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { bt_mesh_face_find_path } from "./bt_mesh_face_find_path.js";
+import { navmesh_build_topology } from "./build/navmesh_build_topology.js";
+import { bvh_build_from_bt_mesh } from "./bvh_build_from_bt_mesh.js";
+import { funnel_string_pull } from "./funnel_string_pull.js";
+
+const scratch_array_u32 = new Uint32Array(1024);
+
+const scratch_portal_vertices = new Uint32Array(1024 * 2);
+
+const scratch_portal_normals = new Float32Array(1024 * 3);
+
+const scratch_vertices = new Float32Array(1024 * 3 * 3);
+
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {BinaryTopology} topology
+ * @param {BVH} bvh
+ * @returns {number} face id, or {@link NULL_POINTER} if not found
+ */
+function query_nearest_face(
+    x, y, z,
+    topology,
+    bvh,
+) {
+
+    throw new Error('Not implemented');
+}
+
+export class NavigationMesh {
+
+    topology = new BinaryTopology();
+
+    /**
+     * Used for raycasts and neighborhood search.
+     * @type {BVH}
+     */
+    bvh = new BVH();
+
+    /**
+     * Build from given scene geometry
+     * @param {BinaryTopology} source
+     * @param {number} [agent_radius]
+     * @param {number} [agent_height]
+     * @param {number} [agent_max_climb] In radians, how steep of an angle can the agent go up by
+     * @param {Vector3} [up] Defines world's "UP" direction, this is what the agent will respect for climbing constraint
+     */
+    build({
+              source,
+              agent_radius = 0,
+              agent_height = 0,
+              agent_max_climb = Math.PI / 4,
+              up = Vector3.up,
+          }) {
+
+        navmesh_build_topology({
+            destination: this.topology,
+            source,
+            agent_radius,
+            agent_height,
+            agent_max_climb,
+            up,
+        });
+
+        bvh_build_from_bt_mesh(this.bvh, this.topology);
+    }
+
+
+    /**
+     *
+     * @param {Float32Array} output
+     * @param {number} start_x
+     * @param {number} start_y
+     * @param {number} start_z
+     * @param {number} goal_x
+     * @param {number} goal_y
+     * @param {number} goal_z
+     * @returns {number}
+     */
+    find_path(
+        output,
+        start_x, start_y, start_z,
+        goal_x, goal_y, goal_z
+    ) {
+
+        const mesh = this.topology;
+
+        const start_face_id = query_nearest_face(start_x, start_y, start_z, mesh, this.bvh);
+
+        if (start_face_id === NULL_POINTER) {
+            // probably topology is empty
+            return 0;
+        }
+
+        const goal_face_id = query_nearest_face(goal_x, goal_y, goal_z, mesh, this.bvh);
+
+        if (goal_face_id === NULL_POINTER) {
+            // should never happen
+            return 0;
+        }
+
+        if (goal_face_id === start_face_id) {
+            // path within the same triangle
+
+            output[0] = start_x;
+            output[1] = start_y;
+            output[2] = start_z;
+
+            output[3] = goal_x;
+            output[4] = goal_y;
+            output[5] = goal_z;
+
+            return 2;
+        }
+
+        const face_path_length = bt_mesh_face_find_path(scratch_array_u32, start_face_id, goal_face_id, mesh);
+
+        // build portals
+        // ==================
+
+        // initialize vertex data pool
+        scratch_vertices[0] = start_x;
+        scratch_vertices[1] = start_y;
+        scratch_vertices[2] = start_z;
+
+        scratch_vertices[3] = goal_x;
+        scratch_vertices[4] = goal_y;
+        scratch_vertices[5] = goal_z;
+
+
+        // add start portal
+        scratch_portal_vertices[0] = 0;
+        scratch_portal_vertices[1] = 0;
+
+        mesh.face_read_normal(scratch_portal_normals, 0, start_face_id);
+
+        let portal_index = 1;
+
+        for (let i = 0; i < face_path_length; i++) {
+
+            const face_id = scratch_array_u32[i];
+
+            // TODO IMPLEMENTATION OF PORTAL SEQUENCE GOES HERE
+
+        }
+
+        // add goal portal
+        scratch_portal_vertices[portal_index] = 1;
+        scratch_portal_vertices[portal_index + 1] = 0;
+
+        // copy last portal normal
+        array_copy(
+            scratch_portal_normals, (portal_index - 1) * 2,
+            scratch_portal_normals, portal_index * 2,
+            3
+        );
+
+        portal_index++;
+
+        // execute string pulling
+        const path_vertex_count = funnel_string_pull(
+            scratch_array_u32,
+            0,
+            scratch_portal_vertices,
+            scratch_portal_normals,
+            portal_index,
+            scratch_vertices,
+        );
+
+        // build the final path
+        for (let i = 0; i < path_vertex_count; i++) {
+            const vertex_index = scratch_array_u32[i];
+
+            output[i * 3] = scratch_vertices[vertex_index * 3];
+            output[i * 3 + 1] = scratch_vertices[vertex_index * 3 + 1];
+            output[i * 3 + 2] = scratch_vertices[vertex_index * 3 + 2];
+
+        }
+
+        return path_vertex_count;
+
+    }
+
+}

package/src/engine/navigation/mesh/NavigationMeshAgent.d.ts

@@ -0,0 +1,9 @@
+export class NavigationMeshAgent {
+    /**
+     * How wide is the agent.
+     * A mouse will have a tiny radius, a car will have a large one.
+     * @type {number}
+     */
+    radius: number;
+}
+//# sourceMappingURL=NavigationMeshAgent.d.ts.map

package/src/engine/navigation/mesh/NavigationMeshAgent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavigationMeshAgent.d.ts","sourceRoot":"","sources":["../../../../../src/engine/navigation/mesh/NavigationMeshAgent.js"],"names":[],"mappings":"AAAA;IAEI;;;;OAIG;IACH,QAFU,MAAM,CAEL;CAGd"}

package/src/engine/navigation/mesh/NavigationMeshAgent.js

@@ -0,0 +1,11 @@
+export class NavigationMeshAgent{
+
+    /**
+     * How wide is the agent.
+     * A mouse will have a tiny radius, a car will have a large one.
+     * @type {number}
+     */
+    radius = 0;
+
+
+}

package/src/engine/navigation/mesh/README.md

@@ -0,0 +1,3 @@
+Navigation Mesh implementation.
+
+Based on https://github.com/donmccurdy/three-pathfinding

package/src/engine/navigation/mesh/bt_mesh_face_find_path.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Find a path through topology faces.
+ * If a path is found - the result will contain start and goal faces.
+ *
+ * NOTE: if either start or goal faces are not part of the topology - an empty path will be produced.
+ *
+ * @param {number[]|Uint32Array} output path will be written here as a sequence of face IDs
+ * @param {number} start_face_id
+ * @param {number} goal_face_id
+ * @param {BinaryTopology} topology
+ * @returns {number} number of faces that make up the path. This will be 0 if no path is found.
+ */
+export function bt_mesh_face_find_path(output: number[] | Uint32Array, start_face_id: number, goal_face_id: number, topology: BinaryTopology): number;
+//# sourceMappingURL=bt_mesh_face_find_path.d.ts.map

package/src/engine/navigation/mesh/bt_mesh_face_find_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_face_find_path.d.ts","sourceRoot":"","sources":["../../../../../src/engine/navigation/mesh/bt_mesh_face_find_path.js"],"names":[],"mappings":"AAsHA;;;;;;;;;;;GAWG;AACH,+CANW,MAAM,EAAE,GAAC,WAAW,iBACpB,MAAM,gBACN,MAAM,6BAEJ,MAAM,CA0ElB"}

package/src/engine/navigation/mesh/bt_mesh_face_find_path.js

@@ -0,0 +1,203 @@
+import { assert } from "../../../core/assert.js";
+import { Uint32Heap } from "../../../core/collection/heap/Uint32Heap.js";
+import { bt_face_get_centroid } from "../../../core/geom/3d/topology/struct/binary/query/bt_face_get_centroid.js";
+import {
+    bt_face_get_neighbour_faces
+} from "../../../core/geom/3d/topology/struct/binary/query/bt_face_get_neighbour_faces.js";
+
+const open = new Uint32Heap();
+
+/**
+ *
+ * @type {Set<number>}
+ */
+const closed = new Set();
+
+/**
+ *
+ * @type {Map<number, number>}
+ */
+const g_score = new Map();
+
+/**
+ * Note that we limit the supported number of neighbors, a reasonable meshes will fit this criteria
+ * @type {Uint32Array}
+ */
+const neighbors = new Uint32Array(256);
+
+const scratch_array_f32 = new Float32Array(6);
+
+/**
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {BinaryTopology} topology
+ * @returns {number}
+ */
+function heuristic(a, b, topology) {
+    // compare centroid distances
+    bt_face_get_centroid(scratch_array_f32, 0, topology, a);
+    bt_face_get_centroid(scratch_array_f32, 3, topology, b);
+
+    // delta
+    const dx = scratch_array_f32[0] - scratch_array_f32[3];
+    const dy = scratch_array_f32[1] - scratch_array_f32[4];
+    const dz = scratch_array_f32[2] - scratch_array_f32[5];
+
+    // distance
+    return dx * dx + dy * dy + dz * dz;
+}
+
+/**
+ *
+ * @param {number[]|Uint32Array} output
+ * @param {number} goal
+ * @param {Map<number, number>} g_score
+ * @param {BinaryTopology} topology
+ * @returns {number}
+ */
+function construct_path(output, goal, g_score, topology) {
+
+    let current = goal;
+    let path_length = 0;
+
+    // 1. Walk back via lowest g-score path until we get to 0 (start)
+    while (true) {
+        output[path_length++] = current;
+
+        const current_g = g_score.get(current);
+
+        // If we reached the start node (g_score === 0), we're done traversing
+        if (current_g === 0) {
+            break;
+        }
+
+        const neighbor_count = bt_face_get_neighbour_faces(neighbors, 0, topology, current);
+
+        let best_neighbor = -1;
+        let lowest_g = Infinity;
+
+        // Find the neighbor with the lowest g_score
+        for (let i = 0; i < neighbor_count; i++) {
+            const neighbor = neighbors[i];
+
+            if (g_score.has(neighbor)) {
+                const g = g_score.get(neighbor);
+
+                if (g < lowest_g) {
+                    lowest_g = g;
+                    best_neighbor = neighbor;
+                }
+
+            }
+        }
+
+        // Safeguard: Break if no valid neighbor is found or if we aren't strictly descending.
+        // (Since your traversal_cost is currently 1.0, lowest_g should be current_g - 1.0)
+        if (best_neighbor === -1 || lowest_g >= current_g) {
+            break;
+        }
+
+        current = best_neighbor;
+    }
+
+    // 2. Reverse the path in-place to get START -> GOAL order
+    const half_length = Math.floor(path_length / 2);
+
+    for (let i = 0; i < half_length; i++) {
+        const mirror_i = path_length - 1 - i;
+        const temp = output[i];
+
+        output[i] = output[mirror_i];
+        output[mirror_i] = temp;
+    }
+
+    return path_length;
+}
+
+
+/**
+ * Find a path through topology faces.
+ * If a path is found - the result will contain start and goal faces.
+ *
+ * NOTE: if either start or goal faces are not part of the topology - an empty path will be produced.
+ *
+ * @param {number[]|Uint32Array} output path will be written here as a sequence of face IDs
+ * @param {number} start_face_id
+ * @param {number} goal_face_id
+ * @param {BinaryTopology} topology
+ * @returns {number} number of faces that make up the path. This will be 0 if no path is found.
+ */
+export function bt_mesh_face_find_path(
+    output,
+    start_face_id,
+    goal_face_id,
+    topology,
+) {
+    assert.isArrayLike(output, 'output');
+    assert.isNonNegativeInteger(start_face_id, 'start_face_id');
+    assert.isNonNegativeInteger(goal_face_id, 'goal_face_id');
+    assert.notNull(topology, 'topology');
+    assert.defined(topology, 'topology');
+    assert.equal(topology.isBinaryTopology, true, 'topology.isBinaryTopology !== true');
+
+    // TODO we can switch traversal to edges instead, that way we can get much better distance heuristics
+    //      we don't know where exactly we're going to cross through the triangle, but we know we're going to cross the edge at least, which narrows the domain
+
+    open.clear();
+    closed.clear();
+    g_score.clear();
+
+    g_score.set(start_face_id, 0);
+
+    open.insert(start_face_id, heuristic(start_face_id, goal_face_id, topology));
+
+    while (!open.is_empty()) {
+
+        const current_node = open.pop_min();
+
+        if (current_node === goal_face_id) {
+            // Reached the goal
+            return construct_path(output, goal_face_id, g_score, topology);
+        }
+
+        closed.add(current_node);
+
+        const neighbor_count = bt_face_get_neighbour_faces(neighbors, 0, topology, current_node);
+
+        for (let i = 0; i < neighbor_count; i++) {
+
+            const neighbor = neighbors[i];
+
+            if (closed.has(neighbor)) {
+                // already closed
+                continue;
+            }
+
+            // TODO compute correct traversal cost based on triangle size
+            const traversal_cost = 1.0;
+
+            const current_g_score = g_score.get(current_node);
+
+            const cost_so_far = current_g_score + traversal_cost;
+
+            if (!g_score.has(neighbor) || cost_so_far < g_score.get(neighbor)) {
+                // better path
+
+                g_score.set(neighbor, cost_so_far);
+
+                const remaining_heuristic = heuristic(neighbor, goal_face_id, topology);
+
+                const refined_heuristic = cost_so_far + remaining_heuristic;
+
+                open.insert_or_update(neighbor, refined_heuristic);
+
+            }
+
+        }
+
+    }
+
+    // No result found
+    return 0;
+}

package/src/engine/navigation/mesh/build/bvh_build_from_unindexed_triangles.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {BVH} bvh
+ * @param {number[]|Float32Array} triangles
+ * @param {number} triangle_count
+ */
+export function bvh_build_from_unindexed_triangles(bvh: BVH, triangles: number[] | Float32Array, triangle_count: number): void;
+//# sourceMappingURL=bvh_build_from_unindexed_triangles.d.ts.map

package/src/engine/navigation/mesh/build/bvh_build_from_unindexed_triangles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh_build_from_unindexed_triangles.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/bvh_build_from_unindexed_triangles.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wEAHW,MAAM,EAAE,GAAC,YAAY,kBACrB,MAAM,QAyChB"}

package/src/engine/navigation/mesh/build/bvh_build_from_unindexed_triangles.js

@@ -0,0 +1,46 @@
+/**
+ *
+ * @param {BVH} bvh
+ * @param {number[]|Float32Array} triangles
+ * @param {number} triangle_count
+ */
+export function bvh_build_from_unindexed_triangles(
+    bvh,
+    triangles,
+    triangle_count,
+) {
+
+    for (let i = 0; i < triangle_count; i++) {
+        const triangle_address = i * 9;
+
+        const ax = triangles[triangle_address];
+        const ay = triangles[triangle_address + 1];
+        const az = triangles[triangle_address + 2];
+
+        const bx = triangles[triangle_address + 3];
+        const by = triangles[triangle_address + 4];
+        const bz = triangles[triangle_address + 5];
+
+        const cx = triangles[triangle_address + 6];
+        const cy = triangles[triangle_address + 7];
+        const cz = triangles[triangle_address + 8];
+
+        const bounds_x0 = Math.min(ax, bx, cx);
+        const bounds_x1 = Math.max(ax, bx, cx);
+        const bounds_z0 = Math.min(az, bz, cz);
+
+        const bounds_y0 = Math.min(ay, by, cy);
+        const bounds_y1 = Math.max(ay, by, cy);
+        const bounds_z1 = Math.max(az, bz, cz);
+
+        const node = bvh.allocate_node();
+
+        bvh.node_set_user_data(node, i);
+        bvh.node_set_aabb_primitive(node,
+            bounds_x0, bounds_y0, bounds_z0,
+            bounds_x1, bounds_y1, bounds_z1
+        );
+
+        bvh.insert_leaf(node);
+    }
+}

package/src/engine/navigation/mesh/build/enforce_agent_height_clearance.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {BVH} bvh
+ * @param {number} agent_height
+ * @param {number} agent_radius
+ * @param {number} triangle_count
+ * @param {number[]} triangles
+ * @param {function():number} random
+ * @returns {number} new triangle count
+ */
+export function enforce_agent_height_clearance({ bvh, agent_height, agent_radius, triangle_count, triangles, random }: BVH): number;
+//# sourceMappingURL=enforce_agent_height_clearance.d.ts.map

package/src/engine/navigation/mesh/build/enforce_agent_height_clearance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforce_agent_height_clearance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/enforce_agent_height_clearance.js"],"names":[],"mappings":"AA4CA;;;;;;;;;GASG;AACH,6HAFa,MAAM,CAuJlB"}