graphics-rs 0.0.10

A simple, extendable, CPU based 2D graphics library. Also supports CloudPoints and rotation!
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

#[derive(Clone, Copy)]
pub struct Vec3<T: Sized + Copy> {
    x: T,
    y: T,
    z: T,
}

impl<T: Sized + Copy> From<(T, T, T)> for Vec3<T> {
    fn from(value: (T, T, T)) -> Self {
        let (x, y, z) = value;
        Vec3::new(x, y, z)
    }
}

impl<T: Sized + Copy> Vec3<T> {
    pub fn new(x: T, y: T, z: T) -> Self {
        Self { x, y, z }
    }

    pub fn x(&self) -> T {
        self.x
    }

    pub fn y(&self) -> T {
        self.y
    }

    pub fn z(&self) -> T {
        self.z
    }

    pub fn set_x(&mut self, x: T) {
        self.x = x;
    }

    pub fn set_y(&mut self, y: T) {
        self.y = y;
    }

    pub fn set_z(&mut self, z: T) {
        self.z = z;
    }

    pub fn set(&mut self, x: T, y: T, z: T) {
        self.x = x;
        self.y = y;
        self.z = z;
    }
}

impl Vec3<i64> {
    pub fn rotate_x(&self, degrees: f64) -> Vec3<i64> {
        let cos = f64::cos(degrees.to_radians());
        let sin = f64::sin(degrees.to_radians());

        let y = (self.y as f64 * cos - self.z as f64 * sin) as i64;
        let z = (self.y as f64 * sin + self.z as f64 * cos) as i64;

        Vec3::<i64>::new(self.x, y, z)
    }

    pub fn rotate_y(&self, degrees: f64) -> Vec3<i64> {
        let cos = f64::cos(degrees.to_radians());
        let sin = f64::sin(degrees.to_radians());

        let x = (self.x as f64 * cos - self.z as f64 * sin) as i64;
        let z = (self.x as f64 * sin + self.z as f64 * cos) as i64;

        Vec3::<i64>::new(x, self.y, z)
    }

    pub fn rotate_z(&self, degrees: f64) -> Vec3<i64> {
        let cos = f64::cos(degrees.to_radians());
        let sin = f64::sin(degrees.to_radians());

        let x = (self.x as f64 * cos - self.y as f64 * sin) as i64;
        let y = (self.x as f64 * sin + self.y as f64 * cos) as i64;

        Vec3::<i64>::new(x, y, self.z)
    }

    pub fn rotate(&self, rotation: &Vec3<f64>) -> Vec3<i64> {
        self.rotate_x(rotation.x)
            .rotate_y(rotation.y)
            .rotate_z(rotation.z)
    }
}

impl Vec3<f64> {
    pub fn magnitude(&self) -> f64 {
        f64::sqrt(self.x.powf(2f64) + self.y.powf(2f64) + self.y.powf(2f64))
    }
}