auburn 0.1.4

Fast and simple physics library.
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
106
107
108
109
110
111
112
113
114

use crate::Square;

use super::*;

/// 2D ellipse centered at the origin, with radii for the x and y axes.
///
/// Ellipses are really stupid shapes and we could care less about them.
#[derive(Default, Clone, Copy, PartialEq, Debug)]
#[cfg_attr(feature = "bevy", derive(bevy::prelude::Component))]
pub struct Ellipse2d {
    pub radii: Vec2,
}

//

impl SymmetricBoundingBox2d for Ellipse2d {
    fn symmetric_bounding_box(&self) -> Box2d {
        Box2d::with_halfdims(self.radii.x, self.radii.y)
    }
}

impl Ellipse2d {
    /// The intercept of a ray starting at the ellipse's center.
    fn intercept_ray(&self, dir: Vec2) -> Vec2 {
        dir * (dir / self.radii).length_recip()
    }

    fn extreme_point_direction(&self, dir: Vec2) -> Vec2 {
        let a = self.radii.x;
        let b = self.radii.y;
        Vec2::new(a * a * dir.x, b * b * dir.y)
    }

    fn extreme_point_by_composing(&self, dir: Vec2) -> Vec2 {
        self.intercept_ray(self.extreme_point_direction(dir))
    }

    fn extreme_point_expanded(&self, dir: Vec2) -> Vec2 {
        let a = self.radii.x;
        let b = self.radii.y;
        let ap = a * dir.x;
        let bq = b * dir.y;
        let d = Vec2::new(ap, bq).length_recip();
        Vec2::new(a * ap * d, b * bq * d)
    }
}

impl ExtremePoint2d for Ellipse2d {
    fn extreme_point(&self, direction: Vec2) -> Vec2 {
        self.extreme_point_expanded(direction)
    }
}

impl MinkowskiNegationIsIdentity for Ellipse2d {}

// @note(lubo): Ellipse + Ellipse != Ellipse
// impl MinkowskiSum<Ellipse2d> for Ellipse2d {}

// @note(lubo): This could potentially work but why bother
// impl MinkowskiSum<Box2d> for Ellipse2d {}

// Collides

impl CollidesRel2d<Point> for Ellipse2d {
    fn collides_rel(&self, t: &Point, rel: &impl Transformation2d) -> bool {
        let delta = rel.apply_origin();
        (delta.x / self.radii.x).square() + (delta.y / self.radii.y).square() <= 1.0
    }
}

// Penetrates

// Sdf

// Sdf Vector

#[cfg(test)]
mod tests {
    use super::*;

    const E1: Ellipse2d = Ellipse2d {
        radii: Vec2::new(2.0, 0.5),
    };

    #[test]
    fn test_ellipse_extreme_point() {
        assert_eq!(E1.extreme_point(Vec2::X), Vec2::new(2.0, 0.0));
        assert_eq!(E1.extreme_point(Vec2::Y), Vec2::new(0.0, 0.5));
        assert_eq!(E1.extreme_point(-Vec2::X), Vec2::new(-2.0, 0.0));
        assert_eq!(E1.extreme_point(-Vec2::Y), Vec2::new(0.0, -0.5));
    }

    #[test]
    fn test_extreme_point_compose() {
        assert_eq!(E1.extreme_point_by_composing(Vec2::X), Vec2::new(2.0, 0.0));
        assert_eq!(E1.extreme_point_by_composing(Vec2::Y), Vec2::new(0.0, 0.5));
        assert_eq!(
            E1.extreme_point_by_composing(-Vec2::X),
            Vec2::new(-2.0, 0.0)
        );
        assert_eq!(
            E1.extreme_point_by_composing(-Vec2::Y),
            Vec2::new(0.0, -0.5)
        );
    }

    #[test]
    fn test_extreme_point_expanded() {
        assert_eq!(E1.extreme_point_expanded(Vec2::X), Vec2::new(2.0, 0.0));
        assert_eq!(E1.extreme_point_expanded(Vec2::Y), Vec2::new(0.0, 0.5));
        assert_eq!(E1.extreme_point_expanded(-Vec2::X), Vec2::new(-2.0, 0.0));
        assert_eq!(E1.extreme_point_expanded(-Vec2::Y), Vec2::new(0.0, -0.5));
    }
}