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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

mod ball;
mod point;
mod transform;

pub use ball::*;
pub use point::*;
pub use transform::*;

/// Trait for computing Minkowski sum.
///
/// # Example
/// ```
/// use auburn::col2d::*;
/// struct Ball {
///     radius: f32,
/// }
/// impl MinkowskiSum<Ball> for Ball {
///     type Output = Ball;
///
///     fn minkowski_sum(&self, b: &Ball) -> Self::Output {
///         Self::Output {
///             radius: self.radius + b.radius,
///         }
///     }
/// }
/// ```
///
/// # See also
/// * [MinkowskiNegation]
/// * [MinkowskiDifference]
pub trait MinkowskiSum<T> {
    type Output;
    /// Computes Minkowski sum of `self` and `t`.
    ///
    /// # Example
    /// ```
    /// use auburn::col2d::*;
    /// let a = Ball::with_radius(1.0);
    /// let b = Box2d::with_halfdims(0.5, 0.5);
    /// assert_eq!(
    ///     a.minkowski_sum(&b),
    ///     RoundedBox2d::new(Vec2::new(0.5, 0.5), 1.0)
    /// );
    /// ```
    ///
    /// # See also
    /// * [MinkowskiNegation::minkowski_negation]
    /// * [MinkowskiDifference::minkowski_difference]
    fn minkowski_sum(&self, t: &T) -> Self::Output;
}

/// Marker trait for when the Minkowski negation is identity.
/// This would usually be true for shapes centered at the origin and symmetric around it.
///
/// # See also
/// * [MinkowskiNegation]
/// * [MinkowskiSum]
/// * [MinkowskiDifference]
pub trait MinkowskiNegationIsIdentity: Copy {}

/// Trait for computing Minkowski negation.
///
/// # See also
/// * [MinkowskiNegationIsIdentity]
/// * [MinkowskiSum]
/// * [MinkowskiDifference]
pub trait MinkowskiNegation {
    /// Computes Minkowski negation. (Reflection about the origin)
    ///
    /// # Example
    ///
    /// ```
    /// use auburn::col2d::*;
    /// let a = Ball::with_radius(1.0);
    /// assert_eq!(
    ///     a.minkowski_negation(),
    ///     Ball::with_radius(1.0)
    /// );
    /// ```
    ///
    /// # See also
    /// * [MinkowskiSum::minkowski_sum]
    /// * [MinkowskiDifference::minkowski_difference]
    fn minkowski_negation(&self) -> Self;
}

/// Trait for computing Minkowski difference.
///
/// # See also
/// * [MinkowskiSum]
/// * [MinkowskiNegation]
pub trait MinkowskiDifference<T> {
    type Output;
    /// Computes Minkowski difference between `self` and `t`.
    ///
    /// # Example
    /// ```
    /// use auburn::col2d::*;
    /// let a = Ball::with_radius(1.0);
    /// let b = Ball::with_radius(1.0);
    /// assert_eq!(
    ///     a.minkowski_difference(&b),
    ///     Ball::with_radius(2.0)
    /// );
    /// ```
    ///
    /// # Notes
    /// Useful for collisions, since when the difference contains the origin, the shapes overlap.
    ///
    /// Has a default implementation when `Self : MinkowskiSum<T>` and `T : MinkowskiNegation`.
    ///
    /// # See also
    /// * [MinkowskiDifference]
    /// * [MinkowskiSum::minkowski_sum]
    /// * [MinkowskiNegation::minkowski_negation]
    fn minkowski_difference(&self, t: &T) -> Self::Output;
}

pub trait MinkowskiDifferenceLifetimed<'a, T: 'a> {
    type Output: 'a;
    fn minkowski_difference_lt(&'a self, t: &'a T) -> Self::Output;
}

impl<T: MinkowskiNegationIsIdentity> MinkowskiNegation for T {
    fn minkowski_negation(&self) -> Self {
        *self
    }
}

impl<'l, A, B: 'l, C: 'l> MinkowskiDifferenceLifetimed<'l, B> for A
where
    A: MinkowskiDifference<B, Output = C>,
{
    type Output = C;

    fn minkowski_difference_lt(&'_ self, t: &'l B) -> Self::Output {
        MinkowskiDifference::minkowski_difference(self, t)
    }
}

impl<T, U, V> MinkowskiDifference<U> for T
where
    T: MinkowskiSum<U, Output = V>,
    U: MinkowskiNegation,
{
    type Output = V;
    fn minkowski_difference(&self, t: &U) -> Self::Output {
        self.minkowski_sum(&t.minkowski_negation())
    }
}