ege 0.1.1

Small easy to use game engine
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

use std::ops::{Add, AddAssign, Div, Mul, Sub};

use super::constants::PI_f32;

/// Degrees, radians, and milliradians as ``f32``
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Angle {
    Degrees(f32),
    Radians(f32),
    MilliRadians(f32),
}

impl Angle {
    pub fn as_degress(self) -> Self {
        return match self {
            Angle::Degrees(_d) => self,
            Angle::Radians(r) => Angle::Degrees(r * (180.0 / PI_f32)),
            Angle::MilliRadians(mr) => Angle::Degrees(mr * 180.0 / (PI_f32 * 1000.0)),
        };
    }

    pub fn as_radians(self) -> Self {
        return match self {
            Angle::Degrees(d) => Angle::Radians(d * (PI_f32 / 180.0)),
            Angle::Radians(_r) => self,
            Angle::MilliRadians(mr) => Angle::Radians(mr / 1000.0),
        };
    }

    pub fn as_milliradians(self) -> Self {
        return match self {
            Angle::Degrees(d) => Angle::MilliRadians(d * (1000.0 * PI_f32) / 180.0),
            Angle::Radians(r) => Angle::MilliRadians(r * 1000.0),
            Angle::MilliRadians(_mr) => self,
        };
    }

    pub fn value(self) -> f32 {
        return match self {
            Angle::Degrees(d) => d,
            Angle::Radians(r) => r,
            Angle::MilliRadians(mr) => mr,
        };
    }
}

impl Add for Angle {
    type Output = Self;

    fn add(self, rhs: Self) -> Self::Output {
        return match self {
            Angle::Degrees(d) => Angle::Degrees(d + rhs.as_degress().value()),
            Angle::Radians(r) => Angle::Radians(r + rhs.as_radians().value()),
            Angle::MilliRadians(mr) => Angle::MilliRadians(mr + rhs.as_milliradians().value()),
        };
    }
}

impl AddAssign for Angle {
    fn add_assign(&mut self, rhs: Self) {
        *self = match self {
            Angle::Degrees(d) => Angle::Degrees(*d + rhs.as_degress().value()),
            Angle::Radians(r) => Angle::Radians(*r + rhs.as_radians().value()),
            Angle::MilliRadians(mr) => Angle::MilliRadians(*mr + rhs.as_milliradians().value()),
        };
    }
}

impl Sub for Angle {
    type Output = Self;

    fn sub(self, rhs: Self) -> Self::Output {
        return match self {
            Angle::Degrees(d) => Angle::Degrees(d - rhs.as_degress().value()),
            Angle::Radians(r) => Angle::Radians(r - rhs.as_radians().value()),
            Angle::MilliRadians(mr) => Angle::MilliRadians(mr - rhs.as_milliradians().value()),
        };
    }
}

impl Mul for Angle {
    type Output = Self;

    fn mul(self, rhs: Self) -> Self::Output {
        return match self {
            Angle::Degrees(d) => Angle::Degrees(d * rhs.as_degress().value()),
            Angle::Radians(r) => Angle::Radians(r * rhs.as_radians().value()),
            Angle::MilliRadians(mr) => Angle::MilliRadians(mr * rhs.as_milliradians().value()),
        };
    }
}

impl Div for Angle {
    type Output = Self;

    fn div(self, rhs: Self) -> Self::Output {
        return match self {
            Angle::Degrees(d) => Angle::Degrees(d / rhs.as_degress().value()),
            Angle::Radians(r) => Angle::Radians(r / rhs.as_radians().value()),
            Angle::MilliRadians(mr) => Angle::MilliRadians(mr / rhs.as_milliradians().value()),
        };
    }
}