@woosh/meep-engine 2.133.3 → 2.134.0

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

@@ -1,190 +1,212 @@
-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;
-
-    }
-
-}
+import { BVH } from "../../../core/bvh2/bvh3/BVH.js";
+import { BinaryTopology, NULL_POINTER } from "../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
+import { bt_faces_shared_loop } from "../../../core/geom/3d/topology/struct/binary/query/bt_faces_shared_loop.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 { bvh_query_nearest_face } from "./bvh_query_nearest_face.js";
+import { funnel_string_pull } from "./funnel_string_pull.js";
+
+/**
+ * Hard cap on the number of faces we traverse in a single path query.
+ * Limits scratch buffer sizes; paths longer than this are truncated by the A* search.
+ * @type {number}
+ */
+const MAX_FACE_PATH_LENGTH = 1024;
+
+// face path IDs or (later) final path vertex indices
+const scratch_array_u32 = new Uint32Array(MAX_FACE_PATH_LENGTH);
+
+// one more portal than face-path length (start portal + one between each consecutive pair of faces + goal portal)
+const MAX_PORTAL_COUNT = MAX_FACE_PATH_LENGTH + 1;
+
+// [left0, right0, left1, right1, ...]
+const scratch_portal_vertices = new Uint32Array(MAX_PORTAL_COUNT * 2);
+
+// flat XYZ triples, one per portal
+const scratch_portal_normals = new Float32Array(MAX_PORTAL_COUNT * 3);
+
+// flat XYZ triples; indices 0 and 1 are start/goal, then 2 vertices per intermediate portal
+const scratch_vertices = new Float32Array((2 + (MAX_PORTAL_COUNT - 2) * 2) * 3);
+
+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_angle] 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_angle = Math.PI / 4,
+              up = Vector3.up,
+          }) {
+
+        navmesh_build_topology({
+            destination: this.topology,
+            source,
+            agent_radius,
+            agent_height,
+            agent_max_climb_angle,
+            up,
+        });
+
+        bvh_build_from_bt_mesh(this.bvh, this.topology);
+    }
+
+
+    /**
+     * Compute a walkable path between the two points.
+     * The result is a sequence of 3d points written into `output`. First point matches start, last point matches goal (snapped onto the mesh).
+     *
+     * @param {Float32Array} output packed XYZ triples
+     * @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} number of 3d points written to `output` (0 if no path was found)
+     */
+    find_path(
+        output,
+        start_x, start_y, start_z,
+        goal_x, goal_y, goal_z
+    ) {
+
+        const mesh = this.topology;
+        const bvh = this.bvh;
+
+        const start_face_id = bvh_query_nearest_face(bvh, mesh, start_x, start_y, start_z);
+
+        if (start_face_id === NULL_POINTER) {
+            // probably topology is empty
+            return 0;
+        }
+
+        const goal_face_id = bvh_query_nearest_face(bvh, mesh, goal_x, goal_y, goal_z);
+
+        if (goal_face_id === NULL_POINTER) {
+            // should never happen if we got the start face
+            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);
+
+        if (face_path_length === 0) {
+            // no face path exists (disconnected topology)
+            return 0;
+        }
+
+        // build portals
+        // ==================
+
+        // initialize vertex data pool, vertex index 0 = start, vertex index 1 = goal
+        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;
+
+        let next_vertex_index = 2;
+
+        // start portal, degenerate portal at the start point, exiting the start face
+        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;
+
+        // intermediate portals sit on the shared edge between two consecutive faces along the path;
+        // the edge is read in the winding order of the face we are exiting, giving a directed (left, right) pair
+        for (let i = 1; i < face_path_length; i++) {
+
+            const face_from = scratch_array_u32[i - 1];
+            const face_to = scratch_array_u32[i];
+
+            const loop = bt_faces_shared_loop(mesh, face_from, face_to);
+
+            const left_vertex = mesh.loop_read_vertex(loop);
+            const right_vertex = mesh.loop_read_vertex(mesh.loop_read_next(loop));
+
+            const left_index = next_vertex_index++;
+            const right_index = next_vertex_index++;
+
+            mesh.vertex_read_coordinate(scratch_vertices, left_index * 3, left_vertex);
+            mesh.vertex_read_coordinate(scratch_vertices, right_index * 3, right_vertex);
+
+            const portal_address = portal_index * 2;
+            scratch_portal_vertices[portal_address] = left_index;
+            scratch_portal_vertices[portal_address + 1] = right_index;
+
+            mesh.face_read_normal(scratch_portal_normals, portal_index * 3, face_from);
+
+            portal_index++;
+        }
+
+        // goal portal, degenerate at the goal point, uses the normal of the face containing the goal
+        const goal_portal_address = portal_index * 2;
+
+        scratch_portal_vertices[goal_portal_address] = 1;
+        scratch_portal_vertices[goal_portal_address + 1] = 1;
+
+        mesh.face_read_normal(scratch_portal_normals, portal_index * 3, goal_face_id);
+
+        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/build/navmesh_build_topology.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"navmesh_build_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/navmesh_build_topology.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;GAUG;AACH,wKATW,cAAc,QAoJxB;+BApL8B,mEAAmE"}
+{"version":3,"file":"navmesh_build_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/mesh/build/navmesh_build_topology.js"],"names":[],"mappings":"AAsCA;;;;;;;;;;GAUG;AACH,wKATW,cAAc,QA2JxB;+BAjM8B,mEAAmE"}

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

@@ -4,6 +4,9 @@ import { BinaryTopology } from "../../../../core/geom/3d/topology/struct/binary/
 import {
     bt_mesh_cleanup_faceless_references
 } from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_cleanup_faceless_references.js";
+import {
+    bt_mesh_compute_face_normals
+} from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_compute_face_normals.js";
 
 import {
     bt_mesh_face_decouple_islands
@@ -15,6 +18,9 @@ import {
     bt_mesh_from_unindexed_geometry
 } from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_from_unindexed_geometry.js";
 import { bt_mesh_triangulate } from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_triangulate.js";
+import {
+    bt_mesh_fuse_duplicate_edges
+} from "../../../../core/geom/3d/topology/struct/binary/io/edge/bt_mesh_fuse_duplicate_edges.js";
 import {
     bt_merge_verts_by_distance
 } from "../../../../core/geom/3d/topology/struct/binary/io/vertex/bt_merge_verts_by_distance.js";
@@ -149,18 +155,22 @@ export function navmesh_build_topology({
 
         const mesh = new BinaryTopology();
 
-        // build topology
+        // raw_triangles may have stale tail data from filtering steps above (e.g. height clearance);
+        // bt_mesh_from_unindexed_geometry reads the whole array, so trim to the live range first.
+        raw_triangles.length = triangle_count * 9;
+
         bt_mesh_from_unindexed_geometry(mesh, raw_triangles);
 
+        // fuse coincident positions so neighbouring triangles share a vertex id...
+        bt_merge_verts_by_distance(mesh, 1e-6);
+
+        // ...then fuse the resulting duplicate edges so they share an edge id too,
+        // which is what the loop-based neighbour queries rely on
+        bt_mesh_fuse_duplicate_edges(mesh);
+
         const mesh_bounds = new Float32Array(6);
         bvh.node_get_aabb(bvh.root, mesh_bounds);
 
-        // dedupe vertices
-        bt_merge_verts_by_distance(
-            mesh,
-            1e-6
-        );
-
         const islands = bt_mesh_compute_face_islands(mesh);
 
         // enabled us to modify islands independently
@@ -176,6 +186,9 @@ export function navmesh_build_topology({
         // remove dangling references
         bt_mesh_cleanup_faceless_references(mesh);
 
+        // face normals are consumed by navigation queries (string-pulling portal normals), populate them now
+        bt_mesh_compute_face_normals(mesh);
+
         // write out to destination
         destination.copy(mesh);
     }

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

@@ -0,0 +1,15 @@
+/**
+ * Find the face of `mesh` whose surface is closest to the given point.
+ * Expects `bvh` to have been built by {@link bvh_build_from_bt_mesh}, so each leaf's user data is a face ID.
+ * Faces are expected to be triangles (as produced by the navmesh build pipeline).
+ *
+ * @param {BVH} bvh
+ * @param {BinaryTopology} mesh
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} [max_distance=Infinity] optional cutoff, only faces within this distance are considered
+ * @returns {number} face ID of the nearest face, or {@link NULL_POINTER} if no face was found within the cutoff
+ */
+export function bvh_query_nearest_face(bvh: BVH, mesh: BinaryTopology, x: number, y: number, z: number, max_distance?: number): number;
+//# sourceMappingURL=bvh_query_nearest_face.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bvh_query_nearest_face.d.ts","sourceRoot":"","sources":["../../../../../src/engine/navigation/mesh/bvh_query_nearest_face.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;GAYG;AACH,0EANW,MAAM,KACN,MAAM,KACN,MAAM,iBACN,MAAM,GACJ,MAAM,CA+FlB"}

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

@@ -0,0 +1,131 @@
+import { assert } from "../../../core/assert.js";
+import {
+    COLUMN_CHILD_1,
+    COLUMN_CHILD_2,
+    COLUMN_USER_DATA,
+    ELEMENT_WORD_COUNT,
+    NULL_NODE
+} from "../../../core/bvh2/bvh3/BVH.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import {
+    aabb3_unsigned_distance_sqr_to_point
+} from "../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
+import { NULL_POINTER } from "../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
+import {
+    computeTriangleClosestPointToPointBarycentric
+} from "../../../core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+const scratch_barycentric = new Float32Array(2);
+const scratch_coord_a = new Float32Array(3);
+const scratch_coord_b = new Float32Array(3);
+const scratch_coord_c = new Float32Array(3);
+
+/**
+ * Find the face of `mesh` whose surface is closest to the given point.
+ * Expects `bvh` to have been built by {@link bvh_build_from_bt_mesh}, so each leaf's user data is a face ID.
+ * Faces are expected to be triangles (as produced by the navmesh build pipeline).
+ *
+ * @param {BVH} bvh
+ * @param {BinaryTopology} mesh
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} [max_distance=Infinity] optional cutoff, only faces within this distance are considered
+ * @returns {number} face ID of the nearest face, or {@link NULL_POINTER} if no face was found within the cutoff
+ */
+export function bvh_query_nearest_face(bvh, mesh, x, y, z, max_distance = Infinity) {
+    assert.defined(bvh, "bvh");
+    assert.defined(mesh, "mesh");
+    assert.equal(mesh.isBinaryTopology, true, "mesh.isBinaryTopology !== true");
+
+    const root = bvh.root;
+
+    if (root === NULL_NODE) {
+        return NULL_POINTER;
+    }
+
+    const stack_top = stack.pointer++;
+
+    stack[stack_top] = root;
+
+    let best_face = NULL_POINTER;
+    let best_distance_sqr = max_distance * max_distance;
+
+    const float32 = bvh.__data_float32;
+    const uint32 = bvh.__data_uint32;
+
+    do {
+        stack.pointer--;
+
+        const node = stack[stack.pointer];
+        const address = node * ELEMENT_WORD_COUNT;
+
+        // lower bound on distance via AABB
+        const aabb_distance_sqr = aabb3_unsigned_distance_sqr_to_point(
+            float32[address], float32[address + 1], float32[address + 2],
+            float32[address + 3], float32[address + 4], float32[address + 5],
+            x, y, z
+        );
+
+        if (aabb_distance_sqr >= best_distance_sqr) {
+            // this subtree cannot contain a closer face
+            continue;
+        }
+
+        const child_1 = uint32[address + COLUMN_CHILD_1];
+
+        if (child_1 !== NULL_NODE) {
+            // internal node, descend into both children
+            stack[stack.pointer++] = child_1;
+            stack[stack.pointer++] = uint32[address + COLUMN_CHILD_2];
+            continue;
+        }
+
+        // leaf node: refine with actual triangle distance
+        const face_id = uint32[address + COLUMN_USER_DATA];
+
+        const loop_a = mesh.face_read_loop(face_id);
+
+        if (loop_a === NULL_POINTER) {
+            continue;
+        }
+
+        const loop_b = mesh.loop_read_next(loop_a);
+        const loop_c = mesh.loop_read_next(loop_b);
+
+        mesh.vertex_read_coordinate(scratch_coord_a, 0, mesh.loop_read_vertex(loop_a));
+        mesh.vertex_read_coordinate(scratch_coord_b, 0, mesh.loop_read_vertex(loop_b));
+        mesh.vertex_read_coordinate(scratch_coord_c, 0, mesh.loop_read_vertex(loop_c));
+
+        computeTriangleClosestPointToPointBarycentric(
+            scratch_barycentric, 0,
+            x, y, z,
+            scratch_coord_a[0], scratch_coord_a[1], scratch_coord_a[2],
+            scratch_coord_b[0], scratch_coord_b[1], scratch_coord_b[2],
+            scratch_coord_c[0], scratch_coord_c[1], scratch_coord_c[2]
+        );
+
+        const weight_a = scratch_barycentric[0];
+        const weight_b = scratch_barycentric[1];
+        const weight_c = 1 - weight_a - weight_b;
+
+        const contact_x = scratch_coord_a[0] * weight_a + scratch_coord_b[0] * weight_b + scratch_coord_c[0] * weight_c;
+        const contact_y = scratch_coord_a[1] * weight_a + scratch_coord_b[1] * weight_b + scratch_coord_c[1] * weight_c;
+        const contact_z = scratch_coord_a[2] * weight_a + scratch_coord_b[2] * weight_b + scratch_coord_c[2] * weight_c;
+
+        const dx = contact_x - x;
+        const dy = contact_y - y;
+        const dz = contact_z - z;
+
+        const triangle_distance_sqr = dx * dx + dy * dy + dz * dz;
+
+        if (triangle_distance_sqr < best_distance_sqr) {
+            best_distance_sqr = triangle_distance_sqr;
+            best_face = face_id;
+        }
+    } while (stack.pointer > stack_top);
+
+    return best_face;
+}

package/src/engine/physics/gjk/gjk.d.ts

@@ -0,0 +1,16 @@
+/**
+ * GJK intersection test for two convex shapes.
+ *
+ * Determines whether two convex shapes overlap by iteratively building a simplex
+ * in the Minkowski difference space. If the origin is enclosed by the simplex,
+ * the shapes intersect.
+ *
+ * Adapted from https://github.com/kevinmoran/GJK/blob/master/GJK.h
+ *
+ * @param {number[]|Float32Array} simplex Working buffer for simplex vertices (4 vec3s). Must have length >= 12.
+ * @param {AbstractShape3D} shape_a
+ * @param {AbstractShape3D} shape_b
+ * @returns {boolean} true if the shapes intersect
+ */
+export function gjk(simplex: number[] | Float32Array, shape_a: AbstractShape3D, shape_b: AbstractShape3D): boolean;
+//# sourceMappingURL=gjk.d.ts.map

package/src/engine/physics/gjk/gjk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gjk.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/gjk/gjk.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;GAaG;AACH,6BALW,MAAM,EAAE,GAAC,YAAY,uDAGnB,OAAO,CAkGnB"}