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

use crate::{Vector, Color};
use sfml::{
    graphics::{RenderWindow, RenderTarget, RectangleShape, Transformable, Shape, CircleShape},
    system::Vector2f
};


/// This struct stores a rectangle that
/// can be rendered to the window.
pub struct Rect {
    pos: Vector<u16>,
    size: Vector<u16>,
    color: Color,
    border_size: Option<u16>,
    border_color: Option<Color>,
}
impl Rect {
    /// Create a new rectangle that can be rendered to the window.
    /// 
    /// ### Arguments
    /// * `pos`: [Into]<[Vector]<[u16]>> - The topleft position.
    /// * `size`: [Into]<[Vector]<[u16]>> - The width & height.
    /// * `color`: [Color] - The fill color.
    pub fn new<V: Into<Vector<u16>>>(pos: V, size: V, color: Color) -> Rect {
        Rect { pos: pos.try_into().unwrap(), size: size.try_into().unwrap(), color, border_size: None, border_color: None }
    }

    /// Creates a border around the rect.
    pub fn border(&mut self, border_size: u16, border_color: Color) {
        self.border_size = Some(border_size);
        self.border_color = Some(border_color);
    }

    /// Changed the center rect position
    pub fn center(&mut self, center: Vector<u16>) {
        self.pos = center - self.size / 2;
    }

    /// Renders the rect to the given window.
    pub fn render(&self, window: &mut RenderWindow) {
        let mut r = RectangleShape::new();
        let pos = self.pos.cast::<f32>();
        let size = self.size.cast::<f32>();

        r.set_position(Vector2f::new(pos.0, pos.1));
        r.set_size(Vector2f::new(size.0, size.1));
        r.set_fill_color(self.color);
        if self.border_size.is_some() {
            r.set_outline_thickness(self.border_size.unwrap() as f32);
            r.set_outline_color(self.border_color.unwrap_or(Color::WHITE));
        }
        window.draw(&r);
    }
}


/// This struct stores a circle that
/// can be rendered to the window.
pub struct Circle {
    pos: Vector<u16>,
    radius: u16,
    color: Color,
    border_size: Option<u16>,
    border_color: Option<Color>,
}
impl Circle {
    /// Create a new circle that can be rendered to the window.
    /// 
    /// ### Arguments
    /// * `pos`: [Into]<[Vector]<[u16]>> - The topleft position.
    /// * `radius`: [u16] - The circle radius.
    /// * `color`: [Color] - The fill color.
    pub fn new<V: Into<Vector<u16>>>(pos: V, radius: u16, color: Color) -> Circle {
        Circle { pos: pos.try_into().unwrap(), radius, color, border_size: None, border_color: None }
    }

    /// Creates a border around the rect.
    pub fn border(&mut self, border_size: u16, border_color: Color) {
        self.border_size = Some(border_size);
        self.border_color = Some(border_color);
    }

    /// Renders the circle to the given window.
    pub fn render(&self, window: &mut RenderWindow) {
        let mut c = CircleShape::new(self.radius as f32, 30);
        let pos = (self.pos - self.radius).cast::<f32>();

        c.set_position(Vector2f::new(pos.0, pos.1));
        c.set_fill_color(self.color);
        if self.border_size.is_some() {
            c.set_outline_thickness(self.border_size.unwrap() as f32);
            c.set_outline_color(self.border_color.unwrap_or(Color::WHITE));
        }
        window.draw(&c);
    }
}


/// This struct stores a line that
/// can be rendered to the window.
pub struct Line {
    start: Vector<u16>,
    end: Vector<u16>,
    color: Color,
    thickness: u16,
}
impl Line {
    /// Create a new line that can be rendered to the window.
    /// 
    /// ### Arguments
    /// * `start`: [Into]<[Vector]<[u16]>> - The start position.
    /// * `end`: [Into]<[Vector]<[u16]>> - The end position.
    /// * `color`: [Color] - The fill color.
    /// * `thickness`: [u16] - The lines thickness.
    pub fn new<V: Into<Vector<u16>>>(start: V, end: V, color: Color, thickness: u16) -> Line {
        Line { start: start.try_into().unwrap(), end: end.try_into().unwrap(), color, thickness }
    }

    /// Create a new line based on the start pos & direction vector.
    /// 
    /// ### Arguments
    /// * `start`: [Into]<[Vector]<[u16]>> - The start position.
    /// * `dir`: [Into]<[Vector]<[u16]>> - The direction vector.
    /// * `color`: [Color] - The fill color.
    /// * `thickness`: [u16] - The lines thickness.
    pub fn from_vec<V: Into<Vector<u16>>>(start: V, dir: V, color: Color, thickness: u16) -> Line {
        let start_v: Vector<u16> = start.try_into().unwrap();
        let dir_v: Vector<u16> = dir.try_into().unwrap();
        Line { start: start_v, end: start_v + dir_v, color, thickness }
    }

    /// Renders the line to the given window.
    pub fn render(&self, window: &mut RenderWindow) {
        let mut r = RectangleShape::new();
        let start = self.start.cast::<f32>();
        let end = self.end.cast::<f32>();

        r.set_position((start.0, start.1));
        r.set_origin((0., (self.thickness / 2) as f32));
        r.set_size(Vector2f::new((start - end).mag(), self.thickness as f32));
        r.set_fill_color(self.color);

        // Calculate angle
        let dir: Vector<f32> = (start - end).norm();
        let angle = dir.1.atan2(dir.0).to_degrees() + 180.;
        r.set_rotation(angle);

        window.draw(&r);
    }
}