parry2d 0.26.0

2 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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use crate::math::Real;
use crate::partitioning::BvhNode;
use crate::query::{Ray, RayCast, RayIntersection};
use crate::shape::{CompositeShapeRef, Compound, Polyline, TypedCompositeShape};

impl<S: TypedCompositeShape> CompositeShapeRef<'_, S> {
    /// Casts a ray on this composite shape.
    ///
    /// The ray is effectively limited to a segment that starts at `Ray::origin` and ends at
    /// `Ray::origin + Ray::direction * max_time_of_impact`. Set `max_time_of_impact` to `Real::MAX`
    /// for an unbounded ray.
    ///
    /// If `solid` is `false`, then the sub-shapes of `self` are seen as hollow and the ray won’t
    /// immediately stop until it reaches a boundary even if it started inside a shape.
    ///
    /// Returns the ray’s time of impact and the index of the sub-shape of `self` that was hit.
    /// The hit point can be retrieved with `ray.point_at(t)` where `t` is the value returned
    /// by this function.
    #[inline]
    pub fn cast_local_ray(
        &self,
        ray: &Ray,
        max_time_of_impact: Real,
        solid: bool,
    ) -> Option<(u32, Real)> {
        let hit = self
            .0
            .bvh()
            .cast_ray(ray, max_time_of_impact, |primitive, best_so_far| {
                self.0.map_typed_part_at(primitive, |pose, part, _| {
                    if let Some(pose) = pose {
                        part.cast_ray(pose, ray, best_so_far, solid)
                    } else {
                        part.cast_local_ray(ray, best_so_far, solid)
                    }
                })?
            })?;
        (hit.1 < max_time_of_impact).then_some(hit)
    }

    /// Same as [`Self::cast_local_ray`] but also computes the normal at the hit location.
    #[inline]
    pub fn cast_local_ray_and_get_normal(
        &self,
        ray: &Ray,
        max_time_of_impact: Real,
        solid: bool,
    ) -> Option<(u32, RayIntersection)> {
        self.0.bvh().find_best(
            max_time_of_impact,
            |node: &BvhNode, best_so_far| node.cast_ray(ray, best_so_far),
            |primitive, best_so_far| {
                self.0.map_typed_part_at(primitive, |pose, part, _| {
                    if let Some(pose) = pose {
                        part.cast_ray_and_get_normal(pose, ray, best_so_far, solid)
                    } else {
                        part.cast_local_ray_and_get_normal(ray, best_so_far, solid)
                    }
                })?
            },
        )
    }
}

impl RayCast for Polyline {
    #[inline]
    fn cast_local_ray(&self, ray: &Ray, max_time_of_impact: Real, solid: bool) -> Option<Real> {
        CompositeShapeRef(self)
            .cast_local_ray(ray, max_time_of_impact, solid)
            .map(|hit| hit.1)
    }

    #[inline]
    fn cast_local_ray_and_get_normal(
        &self,
        ray: &Ray,
        max_time_of_impact: Real,
        solid: bool,
    ) -> Option<RayIntersection> {
        CompositeShapeRef(self)
            .cast_local_ray_and_get_normal(ray, max_time_of_impact, solid)
            .map(|hit| hit.1)
    }
}

impl RayCast for Compound {
    #[inline]
    fn cast_local_ray(&self, ray: &Ray, max_time_of_impact: Real, solid: bool) -> Option<Real> {
        CompositeShapeRef(self)
            .cast_local_ray(ray, max_time_of_impact, solid)
            .map(|hit| hit.1)
    }

    #[inline]
    fn cast_local_ray_and_get_normal(
        &self,
        ray: &Ray,
        max_time_of_impact: Real,
        solid: bool,
    ) -> Option<RayIntersection> {
        CompositeShapeRef(self)
            .cast_local_ray_and_get_normal(ray, max_time_of_impact, solid)
            .map(|hit| hit.1)
    }
}