Merge pull request #114 from plof27/add-trimesh-plane-intersection

Add functionality to intersect a `TriMesh` with a plane

crates/parry3d/tests/geometry/mod.rs

@@ -6,4 +6,5 @@ mod cylinder_cuboid_contact;
 mod epa3;
 mod still_objects_toi;
 mod time_of_impact3;
+mod trimesh_intersection;
 mod trimesh_trimesh_toi;

crates/parry3d/tests/geometry/trimesh_intersection.rs

@@ -0,0 +1,123 @@
+use na::{Point3, Vector3};
+use parry3d::math::{Isometry, Real};
+use parry3d::query::IntersectResult;
+use parry3d::shape::TriMesh;
+
+fn build_diamond(position: &Isometry<Real>) -> TriMesh {
+    // Two tetrahedrons sharing a face
+    let points = vec![
+        position * Point3::new(0.0, 2.0, 0.0),
+        position * Point3::new(-2.0, -1.0, 0.0),
+        position * Point3::new(0.0, 0.0, 2.0),
+        position * Point3::new(2.0, -1.0, 0.0),
+        position * Point3::new(0.0, 0.0, -2.0),
+    ];
+
+    let indices = vec![
+        [0u32, 1, 2],
+        [0, 2, 3],
+        [1, 2, 3],
+        [0, 1, 4],
+        [0, 4, 3],
+        [1, 4, 3],
+    ];
+
+    TriMesh::new(points, indices)
+}
+
+#[test]
+fn trimesh_plane_edge_intersection() {
+    let mesh = build_diamond(&Isometry::identity());
+
+    let result = mesh.intersection_with_local_plane(&Vector3::ith_axis(2), 0.5, std::f32::EPSILON);
+
+    assert!(matches!(result, IntersectResult::Intersect(_)));
+
+    if let IntersectResult::Intersect(line) = result {
+        // Need to check points individually since order is not garunteed
+        let vertices = line.vertices();
+        assert_eq!(vertices.len(), 3);
+        assert!(vertices.contains(&Point3::new(-1.5, -0.75, 0.5)));
+        assert!(vertices.contains(&Point3::new(1.5, -0.75, 0.5)));
+        assert!(vertices.contains(&Point3::new(0.0, 1.5, 0.5)));
+    }
+}
+
+#[test]
+fn trimesh_plane_vertex_intersection() {
+    let mesh = build_diamond(&Isometry::identity());
+
+    let result = mesh.intersection_with_local_plane(&Vector3::ith_axis(2), 0.0, std::f32::EPSILON);
+
+    assert!(matches!(result, IntersectResult::Intersect(_)));
+
+    if let IntersectResult::Intersect(line) = result {
+        // Need to check points individually since order is not garunteed
+        let vertices = line.vertices();
+        assert_eq!(vertices.len(), 3);
+        assert!(vertices.contains(&Point3::new(-2.0, -1.0, 0.0)));
+        assert!(vertices.contains(&Point3::new(2.0, -1.0, 0.0)));
+        assert!(vertices.contains(&Point3::new(0.0, 2.0, 0.0)));
+    }
+}
+
+#[test]
+fn trimesh_plane_mixed_intersection() {
+    let mesh = build_diamond(&Isometry::identity());
+
+    let result = mesh.intersection_with_local_plane(&Vector3::ith_axis(0), 0.0, std::f32::EPSILON);
+
+    assert!(matches!(result, IntersectResult::Intersect(_)));
+
+    if let IntersectResult::Intersect(line) = result {
+        // Need to check points individually since order is not garunteed
+        let vertices = line.vertices();
+        assert_eq!(vertices.len(), 4);
+        assert!(vertices.contains(&Point3::new(0.0, 2.0, 0.0)));
+        assert!(vertices.contains(&Point3::new(0.0, 0.0, 2.0)));
+        assert!(vertices.contains(&Point3::new(0.0, -1.0, 0.0)));
+        assert!(vertices.contains(&Point3::new(0.0, 0.0, -2.0)));
+    }
+}
+
+#[test]
+fn trimesh_plane_multi_intersection() {
+    let mut mesh = build_diamond(&Isometry::identity());
+    mesh.append(&build_diamond(&Isometry::translation(-5.0, 0.0, 0.0)));
+
+    let result = mesh.intersection_with_local_plane(&Vector3::ith_axis(2), 0.5, std::f32::EPSILON);
+
+    assert!(matches!(result, IntersectResult::Intersect(_)));
+
+    if let IntersectResult::Intersect(line) = result {
+        // Need to check points individually since order is not garunteed
+        let vertices = line.vertices();
+        assert_eq!(vertices.len(), 6);
+
+        assert!(vertices.contains(&Point3::new(-1.5, -0.75, 0.5)));
+        assert!(vertices.contains(&Point3::new(1.5, -0.75, 0.5)));
+        assert!(vertices.contains(&Point3::new(0.0, 1.5, 0.5)));
+
+        assert!(vertices.contains(&Point3::new(-6.5, -0.75, 0.5)));
+        assert!(vertices.contains(&Point3::new(-3.5, -0.75, 0.5)));
+        assert!(vertices.contains(&Point3::new(-5.0, 1.5, 0.5)));
+    }
+}
+
+#[test]
+fn trimesh_plane_above() {
+    let mesh = build_diamond(&Isometry::identity());
+
+    let result = mesh.intersection_with_local_plane(&Vector3::ith_axis(2), -5.0, std::f32::EPSILON);
+
+    assert!(matches!(result, IntersectResult::Positive));
+}
+
+#[test]
+fn trimesh_plane_below() {
+    let mesh = build_diamond(&Isometry::identity());
+
+    let result = mesh.intersection_with_local_plane(&Vector3::ith_axis(2), 5.0, std::f32::EPSILON);
+
+    assert!(matches!(result, IntersectResult::Negative));
+}

src/query/mod.rs

@@ -41,7 +41,7 @@ pub use self::point::{PointProjection, PointQuery, PointQueryWithLocation};
 pub use self::query_dispatcher::PersistentQueryDispatcher;
 pub use self::query_dispatcher::{QueryDispatcher, QueryDispatcherChain};
 pub use self::ray::{Ray, RayCast, RayIntersection, SimdRay};
-pub use self::split::SplitResult;
+pub use self::split::{IntersectResult, SplitResult};
 pub use self::time_of_impact::{time_of_impact, TOIStatus, TOI};
 
 mod clip;

src/query/split/mod.rs

@@ -1,4 +1,4 @@
-pub use self::split::SplitResult;
+pub use self::split::{IntersectResult, SplitResult};
 
 mod split;
 mod split_aabb;

src/query/split/split.rs

@@ -8,3 +8,13 @@ pub enum SplitResult<T> {
     /// The shape being split is fully contained in the positive half-space of the plane.
     Positive,
 }
+
+/// The result of a plane-intersection operation.
+pub enum IntersectResult<T> {
+    /// The intersect operation yielded a result, lying in the plane
+    Intersect(T),
+    /// The shape being intersected is fully contained in the negative half-space of the plane.
+    Negative,
+    /// The shape being intersected is fully contained in the positive half-space of the plane.
+    Positive,
+}