@woosh/meep-engine 2.131.48 → 2.132.0

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

@@ -0,0 +1,204 @@
+import { assert } from "../../../../core/assert.js";
+import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
+import { compute_triangle_area_3d } from "../../../../core/geom/3d/triangle/compute_triangle_area_3d.js";
+import { v3_compute_triangle_normal } from "../../../../core/geom/3d/triangle/v3_compute_triangle_normal.js";
+import { clamp } from "../../../../core/math/clamp.js";
+import { roundFair } from "../../../../core/math/random/roundFair.js";
+
+function generate_hole_shapes_barycentric(
+    holes_positions,
+    hole_size,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz,
+) {
+    throw new Error('Not implemented');
+}
+
+/**
+ *
+ * @param {number[]} output where to write new triangles
+ * @param {number} output_offset
+ * @param {number[][]} hole_shapes
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {number} new triangles added to the output
+ */
+function triangle_punch_holes(
+    output,
+    output_offset,
+    hole_shapes,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz,
+) {
+    throw new Error('Not implemented');
+}
+
+/**
+ *
+ * @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
+                                               }) {
+    console.warn('enforce_agent_height_clearance() is not implemented');
+
+    return triangle_count;
+
+    /**
+     * Spatial resolution for performing clearance checks
+     * @type {number}
+     */
+    const sampling_resolution = Math.min(
+        agent_height / 4,
+        Math.max(agent_radius / 2, 0.001)
+    );
+
+    assert.notNaN(sampling_resolution, 'sampling_resolution');
+    assert.isFinite(sampling_resolution, 'sampling_resolution');
+
+    const sample_area = sampling_resolution * sampling_resolution;
+
+    const triangle_normal = new Float32Array(3);
+    const ray = new Ray3();
+    ray.tMax = agent_height;
+
+    let current_triangle_count = triangle_count;
+
+    for (let i = 0; i < current_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];
+
+        // TODO we can accelerate this by performing a clipping volume query first instead
+        //      majority of the triangles are expected to fully pass clearance, and a single clipping volume test will be able to give us "Not obstructed" answer.
+
+        const triangle_area = compute_triangle_area_3d(
+            ax, ay, az,
+            bx, by, bz,
+            cx, cy, cz
+        );
+
+        if (triangle_area === 0) {
+            // a degenerate triangle, should not happen but no point in sampling
+            continue;
+        }
+
+        // construct normal
+        v3_compute_triangle_normal(
+            triangle_normal, 0,
+            ax, ay, az,
+            bx, by, bz,
+            cx, cy, cz
+        );
+
+        const sample_count_desired = triangle_area / sample_area;
+        const sample_count_rounded = roundFair(sample_count_desired, random);
+
+        // Guard against degenerate cases
+        const SAMPLE_COUNT_MAX = 32000;
+
+        const sample_count = clamp(sample_count_rounded, 1, SAMPLE_COUNT_MAX);
+
+        // perform sampling
+        const normal_x = triangle_normal[0];
+        const normal_y = triangle_normal[1];
+        const normal_z = triangle_normal[2];
+
+        ray.setDirection(normal_x, normal_y, normal_z);
+
+        // construct edges for sampling
+        const e0x = bx - ax;
+        const e0y = by - ay;
+        const e0z = bz - az;
+
+        const e1x = cx - bx;
+        const e1y = cy - by;
+        const e1z = cz - bz;
+
+        /**
+         * Barycentric coordinates of where the holes are
+         * @type {number[]}
+         */
+        const holes = [];
+
+        for (let j = 0; j < sample_count; j++) {
+
+            // perform initial sample
+            const r0 = random();
+            const r1 = random() * (1 - r0);
+
+            const x = ax + r0 * e0x + r1 * e1x;
+            const y = ay + r0 * e0y + r1 * e1y;
+            const z = az + r0 * e0z + r1 * e1z;
+
+            ray.setOrigin(x, y, z);
+
+            // tiny offset to avoid self-occlusion
+            ray.shiftForward(1e-7);
+
+            // TODO actual raycast
+
+            // if we got a hit - create a hole triangle, if no hit - continue
+            holes.push(r0, r1);
+        }
+
+        if (holes.length === 0) {
+            // clearance OK
+            continue;
+        }
+
+        const hole_shapes = generate_hole_shapes_barycentric(
+            holes,
+            sampling_resolution,
+            ax, ay, az,
+            bx, by, bz,
+            cx, cy, cz
+        );
+
+        const added_triangle_count = triangle_punch_holes(
+            triangles,
+            triangle_count,
+            hole_shapes,
+            ax, ay, az,
+            bx, by, bz,
+            cx, cy, cz
+        );
+
+        triangle_count += added_triangle_count;
+
+        // TODO remove the original triangle, cut out the holes and add new triangles back
+    }
+
+    //
+    return current_triangle_count;
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Build from given scene geometry
+ * @param {BinaryTopology} destination
+ * @param {BinaryTopology} source Must be triangulated. Use {@link bt_mesh_triangulate} if needed.
+ * @param {number} [agent_radius]
+ * @param {number} [agent_height]
+ * @param {number} [agent_max_step_height] agent can bridge vertical gaps in topology, such as stepping up a stair
+ * @param {number} [agent_max_step_distance] agent can bridge lateral gaps in topology, such as stepping over a hole in the floor
+ * @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
+ */
+export function navmesh_build_topology({ destination, source, agent_radius, agent_height, agent_max_step_height, agent_max_step_distance, agent_max_climb_angle, up, }: BinaryTopology): void;
+import { BinaryTopology } from "../../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
+//# sourceMappingURL=navmesh_build_topology.d.ts.map

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

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

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

@@ -0,0 +1,183 @@
+import { assert } from "../../../../core/assert.js";
+import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { BinaryTopology } from "../../../../core/geom/3d/topology/struct/binary/BinaryTopology.js";
+import {
+    bt_mesh_cleanup_faceless_references
+} from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_cleanup_faceless_references.js";
+
+import {
+    bt_mesh_face_decouple_islands
+} from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_face_decouple_islands.js";
+import {
+    bt_mesh_face_island_erode
+} from "../../../../core/geom/3d/topology/struct/binary/io/bt_mesh_face_island_erode.js";
+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_merge_verts_by_distance
+} from "../../../../core/geom/3d/topology/struct/binary/io/vertex/bt_merge_verts_by_distance.js";
+import { bt_face_is_degenerate } from "../../../../core/geom/3d/topology/struct/binary/query/bt_face_is_degenerate.js";
+import {
+    bt_mesh_compute_face_islands
+} from "../../../../core/geom/3d/topology/struct/binary/query/bt_mesh_compute_face_islands.js";
+import { v3_angle_between } from "../../../../core/geom/vec3/v3_angle_between.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
+import { seededRandom } from "../../../../core/math/random/seededRandom.js";
+import { bvh_build_from_bt_mesh } from "../bvh_build_from_bt_mesh.js";
+import { bvh_build_from_unindexed_triangles } from "./bvh_build_from_unindexed_triangles.js";
+import { enforce_agent_height_clearance } from "./enforce_agent_height_clearance.js";
+
+
+/**
+ * Build from given scene geometry
+ * @param {BinaryTopology} destination
+ * @param {BinaryTopology} source Must be triangulated. Use {@link bt_mesh_triangulate} if needed.
+ * @param {number} [agent_radius]
+ * @param {number} [agent_height]
+ * @param {number} [agent_max_step_height] agent can bridge vertical gaps in topology, such as stepping up a stair
+ * @param {number} [agent_max_step_distance] agent can bridge lateral gaps in topology, such as stepping over a hole in the floor
+ * @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
+ */
+export function navmesh_build_topology({
+                                           destination,
+                                           source,
+                                           agent_radius = 0,
+                                           agent_height = 2,
+                                           agent_max_step_height = 0,
+                                           agent_max_step_distance = 0,
+                                           agent_max_climb_angle = Math.PI / 4,
+                                           up = Vector3.up,
+                                       }) {
+
+    assert.defined(destination, 'destination');
+    assert.defined(source, 'source');
+
+    assert.greaterThanOrEqual(agent_radius, 0, 'agent_radius');
+    assert.greaterThanOrEqual(agent_height, 0, 'agent_height');
+    assert.greaterThanOrEqual(agent_max_climb_angle, 0, 'agent_max_climb_angle');
+    assert.greaterThanOrEqual(agent_max_step_height, 0, 'agent_max_step_height');
+    assert.greaterThanOrEqual(agent_max_step_distance, 0, 'agent_max_step_distance');
+
+    const random = seededRandom();
+
+    const source_bvh = new BVH();
+
+    // prepare a BVH, we'll need it for height queries later on
+    bvh_build_from_bt_mesh(source_bvh, source);
+
+    const scratch_normal = new Float32Array(3);
+
+    // unpack topology into triangle soup
+    const source_face_count = source.faces.size;
+
+    // TODO add cleanup phase
+    //      - fuse vertices of tiny triangles eliminating them
+    //      - identify flat areas and re-triangulate them to remove unnecessary triangles
+
+    /**
+     *
+     * @type {number[]}
+     */
+    const raw_triangles = [];
+    let triangle_count = 0;
+
+    for (let face_id = 0; face_id < source_face_count; face_id++) {
+
+        source.face_read_normal(scratch_normal, 0, face_id);
+
+        const angle = v3_angle_between(up.x, up.y, up.z, scratch_normal[0], scratch_normal[1], scratch_normal[2]);
+
+        if (angle > agent_max_climb_angle) {
+            // discard
+            continue;
+        }
+
+        if (bt_face_is_degenerate(source, face_id)) {
+            // discard
+            continue;
+        }
+
+        let loop = source.face_read_loop(face_id);
+        const loop_start = loop;
+
+        let face_vertex_count = 0;
+
+        do {
+
+            assert.lessThan(face_vertex_count, 3, 'not a triangle');
+
+            const vertex = source.loop_read_vertex(loop);
+
+            const triangle_offset = triangle_count * 9;
+
+            source.vertex_read_coordinate(raw_triangles, triangle_offset + face_vertex_count * 3, vertex);
+
+            face_vertex_count++;
+
+            loop = source.loop_read_next(loop);
+
+        } while (loop !== loop_start)
+
+        triangle_count++;
+    }
+
+    // knock out holes in triangles based on agent's height
+    if (agent_height > 0) {
+
+        triangle_count = enforce_agent_height_clearance({
+            bvh: source_bvh,
+            agent_height: agent_height,
+            agent_radius: agent_radius,
+            triangle_count: triangle_count,
+            triangles: raw_triangles,
+            random: random
+        });
+
+    }
+
+    {
+        const bvh = new BVH();
+
+        // first dump all triangles into a BVH for speed of access
+        bvh_build_from_unindexed_triangles(bvh, raw_triangles, triangle_count);
+
+        // find possible triangle edge connections, that is - where edges of 2 triangles touch, but don't match exactly.
+        // the touching edges will need to be cut and affected triangles split accordingly
+
+        const mesh = new BinaryTopology();
+
+        // build topology
+        bt_mesh_from_unindexed_geometry(mesh, raw_triangles);
+
+        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
+        bt_mesh_face_decouple_islands(mesh, islands);
+
+        // shrink islands to agent_radius
+        for (const island of islands) {
+            bt_mesh_face_island_erode(mesh, island, agent_radius);
+        }
+
+        // TODO attempt to reduce mesh complexity by re-triangulating flat areas or running a very constrained decimation
+
+        // remove dangling references
+        bt_mesh_cleanup_faceless_references(mesh);
+
+        // write out to destination
+        destination.copy(mesh);
+    }
+
+}

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

@@ -0,0 +1,7 @@
+/**
+ * BVH leaves will contain `face_id` and their bounds will be set from the corresponding face bounds.
+ * @param {BVH} bvh
+ * @param {BinaryTopology} mesh
+ */
+export function bvh_build_from_bt_mesh(bvh: BVH, mesh: BinaryTopology): void;
+//# sourceMappingURL=bvh_build_from_bt_mesh.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bvh_build_from_bt_mesh.d.ts","sourceRoot":"","sources":["../../../../../src/engine/navigation/mesh/bvh_build_from_bt_mesh.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,6EAwDC"}

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

@@ -0,0 +1,64 @@
+import { assert } from "../../../core/assert.js";
+
+/**
+ * BVH leaves will contain `face_id` and their bounds will be set from the corresponding face bounds.
+ * @param {BVH} bvh
+ * @param {BinaryTopology} mesh
+ */
+export function bvh_build_from_bt_mesh(bvh, mesh) {
+    assert.defined(bvh, 'bvh');
+    assert.defined(mesh, 'mesh');
+    assert.equal(mesh.isBinaryTopology, true, 'mesh.isBinaryTopology !== true');
+
+    // clear out the BVH
+    bvh.release_all();
+
+    // NOTE: we assume there are no holes in the allocation, data must be packed
+    const face_count = mesh.faces.size;
+
+    const vertex_position = new Float32Array(3);
+
+    for (let face_id = 0; face_id < face_count; face_id++) {
+        let bounds_x0 = Infinity;
+        let bounds_y0 = Infinity;
+        let bounds_z0 = Infinity;
+
+        let bounds_x1 = -Infinity;
+        let bounds_y1 = -Infinity;
+        let bounds_z1 = -Infinity;
+
+        let loop = mesh.face_read_loop(face_id);
+        const loop_start = loop;
+
+        do {
+            const vertex = mesh.loop_read_vertex(loop);
+
+            mesh.vertex_read_coordinate(vertex_position, 0, vertex);
+
+            const px = vertex_position[0];
+            const py = vertex_position[1];
+            const pz = vertex_position[2];
+
+            bounds_x0 = Math.min(bounds_x0, px);
+            bounds_y0 = Math.min(bounds_y0, py);
+            bounds_z0 = Math.min(bounds_z0, pz);
+
+            bounds_x1 = Math.max(bounds_x1, px);
+            bounds_y1 = Math.max(bounds_y1, py);
+            bounds_z1 = Math.max(bounds_z1, pz);
+
+            loop = mesh.loop_read_next(loop);
+
+        } while (loop !== loop_start)
+
+        const node = bvh.allocate_node();
+
+        bvh.node_set_user_data(node, face_id);
+        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/funnel_string_pull.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Implementation of the string-pulling algorithm for funnel path refinement.
+ * Does not allocate memory.
+ *
+ *
+ * @param {Uint32Array|number[]|ArrayLike<number>} output Indices of vertices are written here
+ * @param {number} output_offset where to start writing into the output, typically you want to pass 0 here.
+ * @param {Uint32Array|Uint16Array|Uint8Array|number[]} portal_vertices Flat array of vertex index pairs [left0,right0, left1, right1 ... leftN, rightN]
+ * @param {Float32Array|number[]|ArrayLike<number>} portal_normals Normal vectors for each portal. Should be set to the triangle normal, which we exit through this portal. can be filled with [up, up, up... ] if your portals lay in the horizontal plane mostly.
+ * @param {number} portal_count how many portals do we have to work with
+ * @param {Float32Array|number[]} vertex_data actual vertex positions
+ * @returns number of vertices written to the output
+ */
+export function funnel_string_pull(output: Uint32Array | number[] | ArrayLike<number>, output_offset: number, portal_vertices: Uint32Array | Uint16Array | Uint8Array | number[], portal_normals: Float32Array | number[] | ArrayLike<number>, portal_count: number, vertex_data: Float32Array | number[]): number;
+//# sourceMappingURL=funnel_string_pull.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"funnel_string_pull.d.ts","sourceRoot":"","sources":["../../../../../src/engine/navigation/mesh/funnel_string_pull.js"],"names":[],"mappings":"AAkGA;;;;;;;;;;;;GAYG;AACH,2CARW,WAAW,GAAC,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBACtC,MAAM,mBACN,WAAW,GAAC,WAAW,GAAC,UAAU,GAAC,MAAM,EAAE,kBAC3C,YAAY,GAAC,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,gBACvC,MAAM,eACN,YAAY,GAAC,MAAM,EAAE,UAoH/B"}