parry3d 0.31.1

3 dimensional collision detection library in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use crate::math::Vector;
use crate::query::{PointProjection, PointQuery, PointQueryWithLocation};
use crate::shape::{FeatureId, Segment, SegmentPointLocation};
use crate::utils::relative_eq_vector;

impl PointQuery for Segment {
    #[inline]
    fn project_local_point(&self, pt: Vector, solid: bool) -> PointProjection {
        self.project_local_point_and_get_location(pt, solid).0
    }

    #[inline]
    fn project_local_point_and_get_feature(&self, pt: Vector) -> (PointProjection, FeatureId) {
        let (proj, loc) = self.project_local_point_and_get_location(pt, false);
        let feature = match loc {
            SegmentPointLocation::OnVertex(i) => FeatureId::Vertex(i),
            SegmentPointLocation::OnEdge(..) => {
                #[cfg(feature = "dim2")]
                {
                    let dir = self.scaled_direction();
                    let dpt = pt - proj.point;
                    if dpt.perp_dot(dir) >= 0.0 {
                        FeatureId::Face(0)
                    } else {
                        FeatureId::Face(1)
                    }
                }

                #[cfg(feature = "dim3")]
                {
                    FeatureId::Edge(0)
                }
            }
        };

        (proj, feature)
    }

    // NOTE: the default implementation of `.distance_to_point(...)` will return the error that was
    // eaten by the `::approx_eq(...)` on `project_point(...)`.
}

impl PointQueryWithLocation for Segment {
    type Location = SegmentPointLocation;

    #[inline]
    fn project_local_point_and_get_location(
        &self,
        pt: Vector,
        _: bool,
    ) -> (PointProjection, Self::Location) {
        let ab = self.b - self.a;
        let ap = pt - self.a;
        let ab_ap = ab.dot(ap);
        let sqnab = ab.length_squared();

        let (location, proj) = if ab_ap <= 0.0 {
            // Voronoï region of vertex 'a'.
            (SegmentPointLocation::OnVertex(0), self.a)
        } else if ab_ap >= sqnab {
            // Voronoï region of vertex 'b'.
            (SegmentPointLocation::OnVertex(1), self.b)
        } else {
            assert!(sqnab != 0.0);

            // Voronoï region of the segment interior.
            let u = ab_ap / sqnab;
            let bcoords = [1.0 - u, u];
            (SegmentPointLocation::OnEdge(bcoords), self.a + ab * u)
        };

        // TODO: is this acceptable?
        let inside = relative_eq_vector(proj, pt);

        (PointProjection::new(inside, proj), location)
    }
}