sust 0.3.1

A 2d rust rendering engine powered by sfml & egui that mainly renders shapes. This can be used to visualize algorithms on a grid based surface
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
151
152
153
154

use std::ops::{Add, Sub, Mul, Div, Neg};
use sfml::window::VideoMode;


/// A Vector can represent a point / a direction ...  containing one x & y coordinate
/// The type of the coordinates can be any type of number.
#[derive(Debug, Clone, Copy)]
pub struct Vector<T: num::Num> (pub T, pub T);


impl<T: num::Num + num::NumCast + Copy> Vector<T> {
    /// Cast the x & y coordinates to the given type.
    /// 
    /// ### Generic Arguments
    /// * `U`: [num::Num] + [num::NumCast] - The new type of x & y.
    pub fn cast<U: num::Num + num::NumCast>(self) -> Vector<U> {
        Vector(num::cast(self.0).unwrap(), num::cast(self.1).unwrap())
    }

    /// Get the scalar product of this vector and rhs.
    /// The scalar product of two vectors means multiplying each coordinate of lhs with 
    /// the opposite coordinate of lhs and adding them all together.
    /// 
    /// ### Generic Arguments
    /// * `U`: [num::NumCast] - The type of the scalar product.
    pub fn scalar<U: num::NumCast>(self, rhs: Vector<T>) -> U {
        num::cast(self.0 * rhs.0 + self.1 * rhs.1).unwrap()
    }

    /// Get the magnitude / length of this vector.
    /// The length can be calculated by getting the square root of 
    /// the scalar product with this vector as both operands.
    /// 
    /// ### Generic Arguments
    /// * `U`: [num::Float] - The type of magnitude.
    pub fn mag<U: num::Float>(self) -> U {
        let scalar: U = self.scalar(self);
        scalar.sqrt()
    }

    /// Normalize the vector by setting its magnitude / length to 1,
    /// turning it into what is called a unit vector.
    /// This is done by dividing both coordinates with the magnitude / length.
    /// This vector does not get modified. This function returns a copy of normalized self.
    /// 
    /// ### Generic Arguments
    /// * `U`: [num::Float] - The type of the result vector.
    pub fn norm<U: num::Float>(self) -> Vector<U> {
        let mag = self.mag::<U>();
        let mut new = Vector::<U>(num::cast(self.0).unwrap(), num::cast(self.1).unwrap());
        if mag > num::cast(0).unwrap() {
            new.0 = new.0 / mag;
            new.1 = new.1 / mag;
        }
        new
    }
}


// Into implementations
impl<T: num::Num + num::NumCast> Into<VideoMode> for Vector<T> {
    fn into(self) -> VideoMode {
        VideoMode { 
            width: num::cast(self.0).unwrap(), 
            height: num::cast(self.1).unwrap(), 
            bits_per_pixel: VideoMode::desktop_mode().bits_per_pixel 
        }
    }
}

impl<T: num::Num> Into<Vector<T>> for (T, T)  {
    fn into(self) -> Vector<T> {
        Vector(self.0, self.1)
    }
}

// <========================================>
// <=== Arith. Operator with rhs: Vector ===>
// <========================================>

// Add with rhs: Vector
impl<T: num::Num> Add<Vector<T>> for Vector<T> {
    type Output = Self;
    fn add(self, rhs: Vector<T>) -> Self::Output {
        Self(self.0 + rhs.0, self.1 + rhs.1)
    }
}
// Sub with rhs: Vector
impl<T: num::Num> Sub<Vector<T>> for Vector<T> {
    type Output = Self;
    fn sub(self, rhs: Vector<T>) -> Self::Output {
        Self(self.0 - rhs.0, self.1 - rhs.1)
    }
}
// Mul with rhs: Vector
impl<T: num::Num> Mul<Vector<T>> for Vector<T> {
    type Output = Self;
    fn mul(self, rhs: Vector<T>) -> Self::Output {
        Self(self.0 * rhs.0, self.1 * rhs.1)
    }
}
// Div with rhs: Vector
impl<T: num::Num> Div<Vector<T>> for Vector<T> {
    type Output = Self;
    fn div(self, rhs: Vector<T>) -> Self::Output {
        Self(self.0 / rhs.0, self.1 / rhs.1)
    }
}


// <===================================>
// <=== Arith. Operator with rhs: T ===>
// <===================================>

// Add with rhs: T
impl<T: num::Num + Copy> Add<T> for Vector<T> {
    type Output = Self;
    fn add(self, rhs: T) -> Self::Output {
        Self(self.0 + rhs, self.1 + rhs)
    }
}
// Sub with rhs: T
impl<T: num::Num + Copy> Sub<T> for Vector<T> {
    type Output = Self;
    fn sub(self, rhs: T) -> Self::Output {
        Self(self.0 - rhs, self.1 - rhs)
    }
}
// Mul with rhs: T
impl<T: num::Num + Copy> Mul<T> for Vector<T> {
    type Output = Self;
    fn mul(self, rhs: T) -> Self::Output {
        Self(self.0 * rhs, self.1 * rhs)
    }
}
// Div with rhs: T
impl<T: num::Num + Copy> Div<T> for Vector<T> {
    type Output = Self;
    fn div(self, rhs: T) -> Self::Output {
        Self(self.0 / rhs, self.1 / rhs)
    }
}


// <======================>
// <=== Unary Operator ===>
// <======================>

impl<T: num::Num + Neg<Output = T>> Neg for Vector<T> {
    type Output = Self;
    fn neg(self) -> Self::Output {
        Self(-self.0, -self.1)
    }
}