Skip to main content

Window

gust_render::window

Struct Window 

Source 
pub struct Window {
    pub height: u32,
    pub width: u32,
    /* private fields */
}
Expand description

Window struct Define a struct by many thing in glfw

Fields§

§height: u32§width: u32

Implementations§

Source§

impl<'a> Window

Window structure implementation

Source

pub fn new(width: u32, height: u32, name: &str) -> Window

Create a new window by default

Examples found in repository?
examples/threads.rs (line 14)
13fn main() {
14    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
15    let event_handler = EventHandler::new(&window);
16    let mut shared = SharedWindow::new(&mut window);
17    let (send, recv) = mpsc::channel();
18
19    let renderer = thread::spawn(move || {
20        render(&mut shared, recv);
21    });
22
23    window.poll(None);
24    while window.is_open() {
25        window.poll_events();
26
27        for event in event_handler.fetch() {
28            match event.1 {
29                pressed!(Escape) => window.close(),
30                _ => {}
31            }
32        }
33    }
34    send.send(()).ok().expect("Failed to send ()");
35
36    renderer.join().unwrap();
37}
More examples
Hide additional examples
examples/event.rs (line 16)
15fn main() {
16    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
17    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
18    let event_handler = EventHandler::new(&window);
19    let mut sprites = HashMap::new();
20    sprites.insert("dirt_1", Sprite::from(&tex_dirt));
21    sprites.insert("dirt_2", Sprite::from(&tex_dirt));
22
23    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
24    window.enable_cursor();
25    window.poll(None);
26    while window.is_open() {
27        window.poll_events();
28
29        for event in event_handler.fetch() {
30            event_process(event, &mut window, &mut sprites);
31        }
32
33        draw(&mut window, &mut sprites);
34    }
35}
examples/batch.rs (line 16)
15fn main() -> Result<(), Box<Error>> {
16    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
17
18    let texture = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
19    let mut batch = SpriteBatch::from(&texture);
20    for i in 0..1_000_000 {
21        let mut data = SpriteData::new(Vector::new(i as f32 * 1.0, i as f32 * 10.0));
22        data.set_texture_raw([Vector::new(0.0, 0.0), Vector::new(1.0, 1.0)]);
23        batch.push_sprite(data);
24    }
25
26    let event_handler = EventHandler::new(&window);
27
28    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
29    window.enable_cursor();
30    window.poll(None);
31    while window.is_open() {
32        window.poll_events();
33        for event in event_handler.fetch() {
34            event_process(event, &mut window, &mut batch);
35        }
36        window.clear();
37        window.draw_mut(&mut batch);
38        window.display();
39    }
40
41    Ok(())
42}
examples/multi_window.rs (line 10)
9fn window1() -> Result<(), Box<Error>> {
10    let mut window = Window::new(600, 600, "Hello1");
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&mut sprite);
38        window.draw(&mut leave);
39        window.display();
40    }
41    Ok(())
42}
43
44fn window2() -> Result<(), Box<Error>> {
45    let mut window = Window::new(500, 500, "Hello2");
46    let font = Rc::new(RefCell::new(
47        Font::from_path("examples/font/terminus.ttf").unwrap(),
48    ));
49    let mut text = Text::from_str(&font, "I've been looking forward to this.");
50    text.set_position(Vector::new(5.0, 40.0));
51    let event_handler = EventHandler::new(&window);
52
53    window.set_clear_color(Color::new(1.0, 0.0, 1.0));
54    window.enable_cursor();
55    window.poll(None);
56
57    while window.is_open() {
58        text.update();
59        window.poll_events();
60
61        for event in event_handler.fetch() {
62            event_process(event, &mut window);
63        }
64
65        window.clear();
66        window.draw(&mut text);
67        window.display();
68    }
69    Ok(())
70}
examples/basic.rs (line 9)
8fn main() -> Result<(), Box<Error>> {
9    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
10
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&sprite);
38        window.draw(&leave);
39        window.display();
40    }
41
42    Ok(())
43}
examples/view.rs (line 8)
7fn main() {
8    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
9    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
10    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
11    let event_handler = EventHandler::new(&window);
12    let mut sprite = Sprite::from(&tex_dirt);
13    let mut leave = Sprite::from(&tex_leave);
14
15    leave.set_position(Point::new(300.0, 300.0));
16    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
17    window.enable_cursor();
18    window.poll(None);
19    leave.set_scale(Vector::new(0.5, 0.5));
20    leave
21        .set_origin_to_center()
22        .unwrap_or_else(|e| println!("{}", e));
23    while window.is_open() {
24        window.poll_events();
25        leave.rotate(1.0);
26        leave.update();
27        sprite.update();
28        window.view_mut().update();
29
30        for event in event_handler.fetch() {
31            event_process(event, &mut window);
32        }
33
34        window.clear();
35        window.draw(&mut sprite);
36        window.draw(&mut leave);
37        window.display();
38    }
39}
Additional examples can be found in:
Source

pub fn set_mouse_pos<T: Scalar + Into<f32>>(&mut self, vec: Vector<T>)

Examples found in repository?
examples/view.rs (line 55)
41fn event_process(event: Event, window: &mut Window) {
42    match event.1 {
43        Events::Key(Key::Escape, _, _, _) => {
44            window.close();
45        }
46        Events::Key(Key::Up, _, _, _) => {
47            window.view_mut().zoom(2.0);
48        }
49        Events::Key(Key::Down, _, _, _) => {
50            window.view_mut().zoom(0.5);
51        }
52        Events::CursorPos(x, y) => {
53            let center = Vector::new(x as f32, y as f32);
54            window.view_mut().set_center(center);
55            window.set_mouse_pos(center)
56        }
57        _ => println!("Another event !"),
58    }
59}
Source

pub fn poll<T: Into<Option<EventType>>>(&mut self, event: T)

Examples found in repository?
examples/threads.rs (line 23)
13fn main() {
14    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
15    let event_handler = EventHandler::new(&window);
16    let mut shared = SharedWindow::new(&mut window);
17    let (send, recv) = mpsc::channel();
18
19    let renderer = thread::spawn(move || {
20        render(&mut shared, recv);
21    });
22
23    window.poll(None);
24    while window.is_open() {
25        window.poll_events();
26
27        for event in event_handler.fetch() {
28            match event.1 {
29                pressed!(Escape) => window.close(),
30                _ => {}
31            }
32        }
33    }
34    send.send(()).ok().expect("Failed to send ()");
35
36    renderer.join().unwrap();
37}
More examples
Hide additional examples
examples/event.rs (line 25)
15fn main() {
16    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
17    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
18    let event_handler = EventHandler::new(&window);
19    let mut sprites = HashMap::new();
20    sprites.insert("dirt_1", Sprite::from(&tex_dirt));
21    sprites.insert("dirt_2", Sprite::from(&tex_dirt));
22
23    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
24    window.enable_cursor();
25    window.poll(None);
26    while window.is_open() {
27        window.poll_events();
28
29        for event in event_handler.fetch() {
30            event_process(event, &mut window, &mut sprites);
31        }
32
33        draw(&mut window, &mut sprites);
34    }
35}
examples/batch.rs (line 30)
15fn main() -> Result<(), Box<Error>> {
16    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
17
18    let texture = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
19    let mut batch = SpriteBatch::from(&texture);
20    for i in 0..1_000_000 {
21        let mut data = SpriteData::new(Vector::new(i as f32 * 1.0, i as f32 * 10.0));
22        data.set_texture_raw([Vector::new(0.0, 0.0), Vector::new(1.0, 1.0)]);
23        batch.push_sprite(data);
24    }
25
26    let event_handler = EventHandler::new(&window);
27
28    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
29    window.enable_cursor();
30    window.poll(None);
31    while window.is_open() {
32        window.poll_events();
33        for event in event_handler.fetch() {
34            event_process(event, &mut window, &mut batch);
35        }
36        window.clear();
37        window.draw_mut(&mut batch);
38        window.display();
39    }
40
41    Ok(())
42}
examples/multi_window.rs (line 24)
9fn window1() -> Result<(), Box<Error>> {
10    let mut window = Window::new(600, 600, "Hello1");
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&mut sprite);
38        window.draw(&mut leave);
39        window.display();
40    }
41    Ok(())
42}
43
44fn window2() -> Result<(), Box<Error>> {
45    let mut window = Window::new(500, 500, "Hello2");
46    let font = Rc::new(RefCell::new(
47        Font::from_path("examples/font/terminus.ttf").unwrap(),
48    ));
49    let mut text = Text::from_str(&font, "I've been looking forward to this.");
50    text.set_position(Vector::new(5.0, 40.0));
51    let event_handler = EventHandler::new(&window);
52
53    window.set_clear_color(Color::new(1.0, 0.0, 1.0));
54    window.enable_cursor();
55    window.poll(None);
56
57    while window.is_open() {
58        text.update();
59        window.poll_events();
60
61        for event in event_handler.fetch() {
62            event_process(event, &mut window);
63        }
64
65        window.clear();
66        window.draw(&mut text);
67        window.display();
68    }
69    Ok(())
70}
examples/basic.rs (line 24)
8fn main() -> Result<(), Box<Error>> {
9    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
10
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&sprite);
38        window.draw(&leave);
39        window.display();
40    }
41
42    Ok(())
43}
examples/view.rs (line 18)
7fn main() {
8    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
9    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
10    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
11    let event_handler = EventHandler::new(&window);
12    let mut sprite = Sprite::from(&tex_dirt);
13    let mut leave = Sprite::from(&tex_leave);
14
15    leave.set_position(Point::new(300.0, 300.0));
16    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
17    window.enable_cursor();
18    window.poll(None);
19    leave.set_scale(Vector::new(0.5, 0.5));
20    leave
21        .set_origin_to_center()
22        .unwrap_or_else(|e| println!("{}", e));
23    while window.is_open() {
24        window.poll_events();
25        leave.rotate(1.0);
26        leave.update();
27        sprite.update();
28        window.view_mut().update();
29
30        for event in event_handler.fetch() {
31            event_process(event, &mut window);
32        }
33
34        window.clear();
35        window.draw(&mut sprite);
36        window.draw(&mut leave);
37        window.display();
38    }
39}
Additional examples can be found in:
Source

pub fn unpoll<T: Into<Option<EventType>>>(&mut self, event: T)

Source

pub fn mouse_pos(&self) -> Vector<f32>

Examples found in repository?
examples/event.rs (line 79)
48fn event_process(event: Event, window: &mut Window, sprites: &mut HashMap<&'static str, Sprite>) {
49    match event.1 {
50        pressed!(Escape) => window.close(),
51        pressed!(Space) => {
52            sprites.get_mut("dirt_1").unwrap().rotate(45.0);
53        }
54        pressed!(W) => {
55            sprites
56                .get_mut("dirt_2")
57                .unwrap()
58                .translate(Vector::new(0.0, -10.0));
59        }
60        pressed!(A) => {
61            sprites
62                .get_mut("dirt_2")
63                .unwrap()
64                .translate(Vector::new(-10.0, 0.0));
65        }
66        pressed!(S) => {
67            sprites
68                .get_mut("dirt_2")
69                .unwrap()
70                .translate(Vector::new(0.0, 10.0));
71        }
72        pressed!(D) => {
73            sprites
74                .get_mut("dirt_2")
75                .unwrap()
76                .translate(Vector::new(10.0, 0.0));
77        }
78        Events::MouseButton(glfw::MouseButtonLeft, Action::Press, _) => {
79            let mouse_pos = window.mouse_pos();
80
81            if let Some(sprite) = sprites.get_mut("dirt_1") {
82                if sprite.contain(mouse_pos) {
83                    sprite.set_color(&Color::blue());
84                }
85            }
86        }
87        _ => {}
88    }
89}
Source

pub fn hide_cursor(&mut self)

Change cursor to hidden mode

Source

pub fn disable_cursor(&mut self)

Change cursor to disabled mode

Source

pub fn enable_cursor(&mut self)

Change cursor to normal mode

Examples found in repository?
examples/event.rs (line 24)
15fn main() {
16    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
17    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
18    let event_handler = EventHandler::new(&window);
19    let mut sprites = HashMap::new();
20    sprites.insert("dirt_1", Sprite::from(&tex_dirt));
21    sprites.insert("dirt_2", Sprite::from(&tex_dirt));
22
23    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
24    window.enable_cursor();
25    window.poll(None);
26    while window.is_open() {
27        window.poll_events();
28
29        for event in event_handler.fetch() {
30            event_process(event, &mut window, &mut sprites);
31        }
32
33        draw(&mut window, &mut sprites);
34    }
35}
More examples
Hide additional examples
examples/batch.rs (line 29)
15fn main() -> Result<(), Box<Error>> {
16    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
17
18    let texture = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
19    let mut batch = SpriteBatch::from(&texture);
20    for i in 0..1_000_000 {
21        let mut data = SpriteData::new(Vector::new(i as f32 * 1.0, i as f32 * 10.0));
22        data.set_texture_raw([Vector::new(0.0, 0.0), Vector::new(1.0, 1.0)]);
23        batch.push_sprite(data);
24    }
25
26    let event_handler = EventHandler::new(&window);
27
28    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
29    window.enable_cursor();
30    window.poll(None);
31    while window.is_open() {
32        window.poll_events();
33        for event in event_handler.fetch() {
34            event_process(event, &mut window, &mut batch);
35        }
36        window.clear();
37        window.draw_mut(&mut batch);
38        window.display();
39    }
40
41    Ok(())
42}
examples/multi_window.rs (line 23)
9fn window1() -> Result<(), Box<Error>> {
10    let mut window = Window::new(600, 600, "Hello1");
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&mut sprite);
38        window.draw(&mut leave);
39        window.display();
40    }
41    Ok(())
42}
43
44fn window2() -> Result<(), Box<Error>> {
45    let mut window = Window::new(500, 500, "Hello2");
46    let font = Rc::new(RefCell::new(
47        Font::from_path("examples/font/terminus.ttf").unwrap(),
48    ));
49    let mut text = Text::from_str(&font, "I've been looking forward to this.");
50    text.set_position(Vector::new(5.0, 40.0));
51    let event_handler = EventHandler::new(&window);
52
53    window.set_clear_color(Color::new(1.0, 0.0, 1.0));
54    window.enable_cursor();
55    window.poll(None);
56
57    while window.is_open() {
58        text.update();
59        window.poll_events();
60
61        for event in event_handler.fetch() {
62            event_process(event, &mut window);
63        }
64
65        window.clear();
66        window.draw(&mut text);
67        window.display();
68    }
69    Ok(())
70}
examples/basic.rs (line 23)
8fn main() -> Result<(), Box<Error>> {
9    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
10
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&sprite);
38        window.draw(&leave);
39        window.display();
40    }
41
42    Ok(())
43}
examples/view.rs (line 17)
7fn main() {
8    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
9    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
10    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
11    let event_handler = EventHandler::new(&window);
12    let mut sprite = Sprite::from(&tex_dirt);
13    let mut leave = Sprite::from(&tex_leave);
14
15    leave.set_position(Point::new(300.0, 300.0));
16    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
17    window.enable_cursor();
18    window.poll(None);
19    leave.set_scale(Vector::new(0.5, 0.5));
20    leave
21        .set_origin_to_center()
22        .unwrap_or_else(|e| println!("{}", e));
23    while window.is_open() {
24        window.poll_events();
25        leave.rotate(1.0);
26        leave.update();
27        sprite.update();
28        window.view_mut().update();
29
30        for event in event_handler.fetch() {
31            event_process(event, &mut window);
32        }
33
34        window.clear();
35        window.draw(&mut sprite);
36        window.draw(&mut leave);
37        window.display();
38    }
39}
examples/font.rs (line 32)
8fn main() {
9    // Create drawer window
10    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
11
12    // Create event handler
13    let event_handler = EventHandler::new(&window);
14
15    // Create font
16    let font = Rc::new(RefCell::new(
17        Font::from_path("examples/font/test.ttf").unwrap(),
18    ));
19
20    // Create text with font
21    let mut text = Text::new(&font);
22    text.set_content("Welcome to Gust you can write text and\na lot more !\t(Like tabs)");
23    text.set_position(Vector::new(100.0, 100.0));
24
25    // Create a 2nd text with font
26    let mut text2 = Text::from_str(&font, "Salut !");
27    text2.set_position(Vector::new(200.0, 200.0));
28    text2.update();
29
30    // Loop preparation
31    window.set_clear_color(Color::new(0.0, 0.0, 0.0));
32    window.enable_cursor();
33    window.poll(None);
34    while window.is_open() {
35        // update text
36        text.update();
37
38        // Poll event
39        window.poll_events();
40        event_handler
41            .fetch()
42            .for_each(|event| handle(&event, &mut window, &mut text));
43
44        // Draw process (Clear -> Draw -> Display)
45        window.clear();
46        window.draw(&text);
47        window.draw(&text2);
48        window.display();
49    }
50}
Additional examples can be found in:
Source

pub fn is_open(&self) -> bool

Check if the window is open

Examples found in repository?
examples/threads.rs (line 24)
13fn main() {
14    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
15    let event_handler = EventHandler::new(&window);
16    let mut shared = SharedWindow::new(&mut window);
17    let (send, recv) = mpsc::channel();
18
19    let renderer = thread::spawn(move || {
20        render(&mut shared, recv);
21    });
22
23    window.poll(None);
24    while window.is_open() {
25        window.poll_events();
26
27        for event in event_handler.fetch() {
28            match event.1 {
29                pressed!(Escape) => window.close(),
30                _ => {}
31            }
32        }
33    }
34    send.send(()).ok().expect("Failed to send ()");
35
36    renderer.join().unwrap();
37}
More examples
Hide additional examples
examples/event.rs (line 26)
15fn main() {
16    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
17    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
18    let event_handler = EventHandler::new(&window);
19    let mut sprites = HashMap::new();
20    sprites.insert("dirt_1", Sprite::from(&tex_dirt));
21    sprites.insert("dirt_2", Sprite::from(&tex_dirt));
22
23    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
24    window.enable_cursor();
25    window.poll(None);
26    while window.is_open() {
27        window.poll_events();
28
29        for event in event_handler.fetch() {
30            event_process(event, &mut window, &mut sprites);
31        }
32
33        draw(&mut window, &mut sprites);
34    }
35}
examples/batch.rs (line 31)
15fn main() -> Result<(), Box<Error>> {
16    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
17
18    let texture = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
19    let mut batch = SpriteBatch::from(&texture);
20    for i in 0..1_000_000 {
21        let mut data = SpriteData::new(Vector::new(i as f32 * 1.0, i as f32 * 10.0));
22        data.set_texture_raw([Vector::new(0.0, 0.0), Vector::new(1.0, 1.0)]);
23        batch.push_sprite(data);
24    }
25
26    let event_handler = EventHandler::new(&window);
27
28    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
29    window.enable_cursor();
30    window.poll(None);
31    while window.is_open() {
32        window.poll_events();
33        for event in event_handler.fetch() {
34            event_process(event, &mut window, &mut batch);
35        }
36        window.clear();
37        window.draw_mut(&mut batch);
38        window.display();
39    }
40
41    Ok(())
42}
examples/multi_window.rs (line 26)
9fn window1() -> Result<(), Box<Error>> {
10    let mut window = Window::new(600, 600, "Hello1");
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&mut sprite);
38        window.draw(&mut leave);
39        window.display();
40    }
41    Ok(())
42}
43
44fn window2() -> Result<(), Box<Error>> {
45    let mut window = Window::new(500, 500, "Hello2");
46    let font = Rc::new(RefCell::new(
47        Font::from_path("examples/font/terminus.ttf").unwrap(),
48    ));
49    let mut text = Text::from_str(&font, "I've been looking forward to this.");
50    text.set_position(Vector::new(5.0, 40.0));
51    let event_handler = EventHandler::new(&window);
52
53    window.set_clear_color(Color::new(1.0, 0.0, 1.0));
54    window.enable_cursor();
55    window.poll(None);
56
57    while window.is_open() {
58        text.update();
59        window.poll_events();
60
61        for event in event_handler.fetch() {
62            event_process(event, &mut window);
63        }
64
65        window.clear();
66        window.draw(&mut text);
67        window.display();
68    }
69    Ok(())
70}
examples/basic.rs (line 26)
8fn main() -> Result<(), Box<Error>> {
9    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
10
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&sprite);
38        window.draw(&leave);
39        window.display();
40    }
41
42    Ok(())
43}
examples/view.rs (line 23)
7fn main() {
8    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
9    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
10    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
11    let event_handler = EventHandler::new(&window);
12    let mut sprite = Sprite::from(&tex_dirt);
13    let mut leave = Sprite::from(&tex_leave);
14
15    leave.set_position(Point::new(300.0, 300.0));
16    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
17    window.enable_cursor();
18    window.poll(None);
19    leave.set_scale(Vector::new(0.5, 0.5));
20    leave
21        .set_origin_to_center()
22        .unwrap_or_else(|e| println!("{}", e));
23    while window.is_open() {
24        window.poll_events();
25        leave.rotate(1.0);
26        leave.update();
27        sprite.update();
28        window.view_mut().update();
29
30        for event in event_handler.fetch() {
31            event_process(event, &mut window);
32        }
33
34        window.clear();
35        window.draw(&mut sprite);
36        window.draw(&mut leave);
37        window.display();
38    }
39}
Additional examples can be found in:
Source

pub fn poll_events(&mut self)

Poll the event

Examples found in repository?
examples/threads.rs (line 25)
13fn main() {
14    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
15    let event_handler = EventHandler::new(&window);
16    let mut shared = SharedWindow::new(&mut window);
17    let (send, recv) = mpsc::channel();
18
19    let renderer = thread::spawn(move || {
20        render(&mut shared, recv);
21    });
22
23    window.poll(None);
24    while window.is_open() {
25        window.poll_events();
26
27        for event in event_handler.fetch() {
28            match event.1 {
29                pressed!(Escape) => window.close(),
30                _ => {}
31            }
32        }
33    }
34    send.send(()).ok().expect("Failed to send ()");
35
36    renderer.join().unwrap();
37}
More examples
Hide additional examples
examples/event.rs (line 27)
15fn main() {
16    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
17    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
18    let event_handler = EventHandler::new(&window);
19    let mut sprites = HashMap::new();
20    sprites.insert("dirt_1", Sprite::from(&tex_dirt));
21    sprites.insert("dirt_2", Sprite::from(&tex_dirt));
22
23    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
24    window.enable_cursor();
25    window.poll(None);
26    while window.is_open() {
27        window.poll_events();
28
29        for event in event_handler.fetch() {
30            event_process(event, &mut window, &mut sprites);
31        }
32
33        draw(&mut window, &mut sprites);
34    }
35}
examples/batch.rs (line 32)
15fn main() -> Result<(), Box<Error>> {
16    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
17
18    let texture = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
19    let mut batch = SpriteBatch::from(&texture);
20    for i in 0..1_000_000 {
21        let mut data = SpriteData::new(Vector::new(i as f32 * 1.0, i as f32 * 10.0));
22        data.set_texture_raw([Vector::new(0.0, 0.0), Vector::new(1.0, 1.0)]);
23        batch.push_sprite(data);
24    }
25
26    let event_handler = EventHandler::new(&window);
27
28    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
29    window.enable_cursor();
30    window.poll(None);
31    while window.is_open() {
32        window.poll_events();
33        for event in event_handler.fetch() {
34            event_process(event, &mut window, &mut batch);
35        }
36        window.clear();
37        window.draw_mut(&mut batch);
38        window.display();
39    }
40
41    Ok(())
42}
examples/multi_window.rs (line 27)
9fn window1() -> Result<(), Box<Error>> {
10    let mut window = Window::new(600, 600, "Hello1");
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&mut sprite);
38        window.draw(&mut leave);
39        window.display();
40    }
41    Ok(())
42}
43
44fn window2() -> Result<(), Box<Error>> {
45    let mut window = Window::new(500, 500, "Hello2");
46    let font = Rc::new(RefCell::new(
47        Font::from_path("examples/font/terminus.ttf").unwrap(),
48    ));
49    let mut text = Text::from_str(&font, "I've been looking forward to this.");
50    text.set_position(Vector::new(5.0, 40.0));
51    let event_handler = EventHandler::new(&window);
52
53    window.set_clear_color(Color::new(1.0, 0.0, 1.0));
54    window.enable_cursor();
55    window.poll(None);
56
57    while window.is_open() {
58        text.update();
59        window.poll_events();
60
61        for event in event_handler.fetch() {
62            event_process(event, &mut window);
63        }
64
65        window.clear();
66        window.draw(&mut text);
67        window.display();
68    }
69    Ok(())
70}
examples/basic.rs (line 27)
8fn main() -> Result<(), Box<Error>> {
9    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
10
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&sprite);
38        window.draw(&leave);
39        window.display();
40    }
41
42    Ok(())
43}
examples/view.rs (line 24)
7fn main() {
8    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
9    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
10    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
11    let event_handler = EventHandler::new(&window);
12    let mut sprite = Sprite::from(&tex_dirt);
13    let mut leave = Sprite::from(&tex_leave);
14
15    leave.set_position(Point::new(300.0, 300.0));
16    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
17    window.enable_cursor();
18    window.poll(None);
19    leave.set_scale(Vector::new(0.5, 0.5));
20    leave
21        .set_origin_to_center()
22        .unwrap_or_else(|e| println!("{}", e));
23    while window.is_open() {
24        window.poll_events();
25        leave.rotate(1.0);
26        leave.update();
27        sprite.update();
28        window.view_mut().update();
29
30        for event in event_handler.fetch() {
31            event_process(event, &mut window);
32        }
33
34        window.clear();
35        window.draw(&mut sprite);
36        window.draw(&mut leave);
37        window.display();
38    }
39}
Additional examples can be found in:
Source

pub fn set_clear_color(&mut self, new_color: Color)

Set clear color

Examples found in repository?
examples/event.rs (line 23)
15fn main() {
16    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
17    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
18    let event_handler = EventHandler::new(&window);
19    let mut sprites = HashMap::new();
20    sprites.insert("dirt_1", Sprite::from(&tex_dirt));
21    sprites.insert("dirt_2", Sprite::from(&tex_dirt));
22
23    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
24    window.enable_cursor();
25    window.poll(None);
26    while window.is_open() {
27        window.poll_events();
28
29        for event in event_handler.fetch() {
30            event_process(event, &mut window, &mut sprites);
31        }
32
33        draw(&mut window, &mut sprites);
34    }
35}
More examples
Hide additional examples
examples/batch.rs (line 28)
15fn main() -> Result<(), Box<Error>> {
16    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
17
18    let texture = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
19    let mut batch = SpriteBatch::from(&texture);
20    for i in 0..1_000_000 {
21        let mut data = SpriteData::new(Vector::new(i as f32 * 1.0, i as f32 * 10.0));
22        data.set_texture_raw([Vector::new(0.0, 0.0), Vector::new(1.0, 1.0)]);
23        batch.push_sprite(data);
24    }
25
26    let event_handler = EventHandler::new(&window);
27
28    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
29    window.enable_cursor();
30    window.poll(None);
31    while window.is_open() {
32        window.poll_events();
33        for event in event_handler.fetch() {
34            event_process(event, &mut window, &mut batch);
35        }
36        window.clear();
37        window.draw_mut(&mut batch);
38        window.display();
39    }
40
41    Ok(())
42}
examples/multi_window.rs (line 22)
9fn window1() -> Result<(), Box<Error>> {
10    let mut window = Window::new(600, 600, "Hello1");
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&mut sprite);
38        window.draw(&mut leave);
39        window.display();
40    }
41    Ok(())
42}
43
44fn window2() -> Result<(), Box<Error>> {
45    let mut window = Window::new(500, 500, "Hello2");
46    let font = Rc::new(RefCell::new(
47        Font::from_path("examples/font/terminus.ttf").unwrap(),
48    ));
49    let mut text = Text::from_str(&font, "I've been looking forward to this.");
50    text.set_position(Vector::new(5.0, 40.0));
51    let event_handler = EventHandler::new(&window);
52
53    window.set_clear_color(Color::new(1.0, 0.0, 1.0));
54    window.enable_cursor();
55    window.poll(None);
56
57    while window.is_open() {
58        text.update();
59        window.poll_events();
60
61        for event in event_handler.fetch() {
62            event_process(event, &mut window);
63        }
64
65        window.clear();
66        window.draw(&mut text);
67        window.display();
68    }
69    Ok(())
70}
examples/basic.rs (line 22)
8fn main() -> Result<(), Box<Error>> {
9    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
10
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&sprite);
38        window.draw(&leave);
39        window.display();
40    }
41
42    Ok(())
43}
examples/view.rs (line 16)
7fn main() {
8    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
9    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
10    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
11    let event_handler = EventHandler::new(&window);
12    let mut sprite = Sprite::from(&tex_dirt);
13    let mut leave = Sprite::from(&tex_leave);
14
15    leave.set_position(Point::new(300.0, 300.0));
16    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
17    window.enable_cursor();
18    window.poll(None);
19    leave.set_scale(Vector::new(0.5, 0.5));
20    leave
21        .set_origin_to_center()
22        .unwrap_or_else(|e| println!("{}", e));
23    while window.is_open() {
24        window.poll_events();
25        leave.rotate(1.0);
26        leave.update();
27        sprite.update();
28        window.view_mut().update();
29
30        for event in event_handler.fetch() {
31            event_process(event, &mut window);
32        }
33
34        window.clear();
35        window.draw(&mut sprite);
36        window.draw(&mut leave);
37        window.display();
38    }
39}
examples/font.rs (line 31)
8fn main() {
9    // Create drawer window
10    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
11
12    // Create event handler
13    let event_handler = EventHandler::new(&window);
14
15    // Create font
16    let font = Rc::new(RefCell::new(
17        Font::from_path("examples/font/test.ttf").unwrap(),
18    ));
19
20    // Create text with font
21    let mut text = Text::new(&font);
22    text.set_content("Welcome to Gust you can write text and\na lot more !\t(Like tabs)");
23    text.set_position(Vector::new(100.0, 100.0));
24
25    // Create a 2nd text with font
26    let mut text2 = Text::from_str(&font, "Salut !");
27    text2.set_position(Vector::new(200.0, 200.0));
28    text2.update();
29
30    // Loop preparation
31    window.set_clear_color(Color::new(0.0, 0.0, 0.0));
32    window.enable_cursor();
33    window.poll(None);
34    while window.is_open() {
35        // update text
36        text.update();
37
38        // Poll event
39        window.poll_events();
40        event_handler
41            .fetch()
42            .for_each(|event| handle(&event, &mut window, &mut text));
43
44        // Draw process (Clear -> Draw -> Display)
45        window.clear();
46        window.draw(&text);
47        window.draw(&text2);
48        window.display();
49    }
50}
Additional examples can be found in:
Source

pub fn close(&mut self)

Close window

Examples found in repository?
examples/font.rs (line 54)
52fn handle(event: &Event, window: &mut Window, text: &mut Text) {
53    match event.1 {
54        Events::Key(Key::Escape, _, Action::Press, _) => window.close(),
55        Events::CursorPos(x, y) => {
56            text.set_position(Vector::new(x as f32, y as f32));
57        }
58        _ => {}
59    }
60}
More examples
Hide additional examples
examples/basic.rs (line 48)
45fn event_process(event: Event, window: &mut Window) {
46    match event.1 {
47        Events::Key(Key::Escape, _, _, _) => {
48            window.close();
49        }
50        Events::MouseButton(_, _, _) => {
51            println!("Mouse button !");
52        }
53        Events::CursorPos(x, y) => {
54            println!("x: {}, y: {}", x, y);
55        }
56        _ => println!("Another event !"),
57    }
58}
examples/multi_window.rs (line 93)
90fn event_process(event: Event, window: &mut Window) {
91    match event.1 {
92        Events::Key(Key::Escape, _, _, _) => {
93            window.close();
94        }
95        Events::MouseButton(_, _, _) => {
96            println!("Mouse button !");
97        }
98        Events::CursorPos(x, y) => {
99            println!("x: {}, y: {}", x, y);
100        }
101        _ => println!("Another event !"),
102    }
103}
examples/texture.rs (line 63)
60fn event_process(event: Event, window: &mut Window, texture: &Texture, sprite: &mut Sprite) {
61    match event.1 {
62        Events::Key(Key::Escape, _, _, _) => {
63            window.close();
64        }
65        Events::MouseButton(_, _, _) => {
66            println!("Dumping texture to test.png");
67            texture.to_file("test.png").unwrap();
68        }
69        Events::CursorPos(x, y) => {
70            sprite.set_position(Vector::new(x as f32, y as f32));
71        }
72        _ => {}
73    }
74}
examples/view.rs (line 44)
41fn event_process(event: Event, window: &mut Window) {
42    match event.1 {
43        Events::Key(Key::Escape, _, _, _) => {
44            window.close();
45        }
46        Events::Key(Key::Up, _, _, _) => {
47            window.view_mut().zoom(2.0);
48        }
49        Events::Key(Key::Down, _, _, _) => {
50            window.view_mut().zoom(0.5);
51        }
52        Events::CursorPos(x, y) => {
53            let center = Vector::new(x as f32, y as f32);
54            window.view_mut().set_center(center);
55            window.set_mouse_pos(center)
56        }
57        _ => println!("Another event !"),
58    }
59}
examples/threads.rs (line 29)
13fn main() {
14    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
15    let event_handler = EventHandler::new(&window);
16    let mut shared = SharedWindow::new(&mut window);
17    let (send, recv) = mpsc::channel();
18
19    let renderer = thread::spawn(move || {
20        render(&mut shared, recv);
21    });
22
23    window.poll(None);
24    while window.is_open() {
25        window.poll_events();
26
27        for event in event_handler.fetch() {
28            match event.1 {
29                pressed!(Escape) => window.close(),
30                _ => {}
31            }
32        }
33    }
34    send.send(()).ok().expect("Failed to send ()");
35
36    renderer.join().unwrap();
37}
Additional examples can be found in:
Source

pub fn clear(&self)

Clear screen

Examples found in repository?
examples/event.rs (line 42)
37fn draw(window: &mut Window, sprites: &mut HashMap<&'static str, Sprite>) {
38    for (_name, sprite) in sprites.iter_mut() {
39        sprite.update();
40    }
41
42    window.clear();
43    window.draw(&sprites["dirt_1"]);
44    window.draw(&sprites["dirt_2"]);
45    window.display();
46}
More examples
Hide additional examples
examples/batch.rs (line 36)
15fn main() -> Result<(), Box<Error>> {
16    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
17
18    let texture = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
19    let mut batch = SpriteBatch::from(&texture);
20    for i in 0..1_000_000 {
21        let mut data = SpriteData::new(Vector::new(i as f32 * 1.0, i as f32 * 10.0));
22        data.set_texture_raw([Vector::new(0.0, 0.0), Vector::new(1.0, 1.0)]);
23        batch.push_sprite(data);
24    }
25
26    let event_handler = EventHandler::new(&window);
27
28    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
29    window.enable_cursor();
30    window.poll(None);
31    while window.is_open() {
32        window.poll_events();
33        for event in event_handler.fetch() {
34            event_process(event, &mut window, &mut batch);
35        }
36        window.clear();
37        window.draw_mut(&mut batch);
38        window.display();
39    }
40
41    Ok(())
42}
examples/multi_window.rs (line 36)
9fn window1() -> Result<(), Box<Error>> {
10    let mut window = Window::new(600, 600, "Hello1");
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&mut sprite);
38        window.draw(&mut leave);
39        window.display();
40    }
41    Ok(())
42}
43
44fn window2() -> Result<(), Box<Error>> {
45    let mut window = Window::new(500, 500, "Hello2");
46    let font = Rc::new(RefCell::new(
47        Font::from_path("examples/font/terminus.ttf").unwrap(),
48    ));
49    let mut text = Text::from_str(&font, "I've been looking forward to this.");
50    text.set_position(Vector::new(5.0, 40.0));
51    let event_handler = EventHandler::new(&window);
52
53    window.set_clear_color(Color::new(1.0, 0.0, 1.0));
54    window.enable_cursor();
55    window.poll(None);
56
57    while window.is_open() {
58        text.update();
59        window.poll_events();
60
61        for event in event_handler.fetch() {
62            event_process(event, &mut window);
63        }
64
65        window.clear();
66        window.draw(&mut text);
67        window.display();
68    }
69    Ok(())
70}
examples/basic.rs (line 36)
8fn main() -> Result<(), Box<Error>> {
9    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
10
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&sprite);
38        window.draw(&leave);
39        window.display();
40    }
41
42    Ok(())
43}
examples/view.rs (line 34)
7fn main() {
8    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
9    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
10    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
11    let event_handler = EventHandler::new(&window);
12    let mut sprite = Sprite::from(&tex_dirt);
13    let mut leave = Sprite::from(&tex_leave);
14
15    leave.set_position(Point::new(300.0, 300.0));
16    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
17    window.enable_cursor();
18    window.poll(None);
19    leave.set_scale(Vector::new(0.5, 0.5));
20    leave
21        .set_origin_to_center()
22        .unwrap_or_else(|e| println!("{}", e));
23    while window.is_open() {
24        window.poll_events();
25        leave.rotate(1.0);
26        leave.update();
27        sprite.update();
28        window.view_mut().update();
29
30        for event in event_handler.fetch() {
31            event_process(event, &mut window);
32        }
33
34        window.clear();
35        window.draw(&mut sprite);
36        window.draw(&mut leave);
37        window.display();
38    }
39}
examples/font.rs (line 45)
8fn main() {
9    // Create drawer window
10    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
11
12    // Create event handler
13    let event_handler = EventHandler::new(&window);
14
15    // Create font
16    let font = Rc::new(RefCell::new(
17        Font::from_path("examples/font/test.ttf").unwrap(),
18    ));
19
20    // Create text with font
21    let mut text = Text::new(&font);
22    text.set_content("Welcome to Gust you can write text and\na lot more !\t(Like tabs)");
23    text.set_position(Vector::new(100.0, 100.0));
24
25    // Create a 2nd text with font
26    let mut text2 = Text::from_str(&font, "Salut !");
27    text2.set_position(Vector::new(200.0, 200.0));
28    text2.update();
29
30    // Loop preparation
31    window.set_clear_color(Color::new(0.0, 0.0, 0.0));
32    window.enable_cursor();
33    window.poll(None);
34    while window.is_open() {
35        // update text
36        text.update();
37
38        // Poll event
39        window.poll_events();
40        event_handler
41            .fetch()
42            .for_each(|event| handle(&event, &mut window, &mut text));
43
44        // Draw process (Clear -> Draw -> Display)
45        window.clear();
46        window.draw(&text);
47        window.draw(&text2);
48        window.display();
49    }
50}
Additional examples can be found in:
Source

pub fn active(&mut self) -> bool

Activate window on OpenGl context

Source

pub fn set_view(&mut self, view: View)

Source

pub fn display(&mut self)

Display the screen

Examples found in repository?
examples/event.rs (line 45)
37fn draw(window: &mut Window, sprites: &mut HashMap<&'static str, Sprite>) {
38    for (_name, sprite) in sprites.iter_mut() {
39        sprite.update();
40    }
41
42    window.clear();
43    window.draw(&sprites["dirt_1"]);
44    window.draw(&sprites["dirt_2"]);
45    window.display();
46}
More examples
Hide additional examples
examples/batch.rs (line 38)
15fn main() -> Result<(), Box<Error>> {
16    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
17
18    let texture = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
19    let mut batch = SpriteBatch::from(&texture);
20    for i in 0..1_000_000 {
21        let mut data = SpriteData::new(Vector::new(i as f32 * 1.0, i as f32 * 10.0));
22        data.set_texture_raw([Vector::new(0.0, 0.0), Vector::new(1.0, 1.0)]);
23        batch.push_sprite(data);
24    }
25
26    let event_handler = EventHandler::new(&window);
27
28    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
29    window.enable_cursor();
30    window.poll(None);
31    while window.is_open() {
32        window.poll_events();
33        for event in event_handler.fetch() {
34            event_process(event, &mut window, &mut batch);
35        }
36        window.clear();
37        window.draw_mut(&mut batch);
38        window.display();
39    }
40
41    Ok(())
42}
examples/multi_window.rs (line 39)
9fn window1() -> Result<(), Box<Error>> {
10    let mut window = Window::new(600, 600, "Hello1");
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&mut sprite);
38        window.draw(&mut leave);
39        window.display();
40    }
41    Ok(())
42}
43
44fn window2() -> Result<(), Box<Error>> {
45    let mut window = Window::new(500, 500, "Hello2");
46    let font = Rc::new(RefCell::new(
47        Font::from_path("examples/font/terminus.ttf").unwrap(),
48    ));
49    let mut text = Text::from_str(&font, "I've been looking forward to this.");
50    text.set_position(Vector::new(5.0, 40.0));
51    let event_handler = EventHandler::new(&window);
52
53    window.set_clear_color(Color::new(1.0, 0.0, 1.0));
54    window.enable_cursor();
55    window.poll(None);
56
57    while window.is_open() {
58        text.update();
59        window.poll_events();
60
61        for event in event_handler.fetch() {
62            event_process(event, &mut window);
63        }
64
65        window.clear();
66        window.draw(&mut text);
67        window.display();
68    }
69    Ok(())
70}
examples/basic.rs (line 39)
8fn main() -> Result<(), Box<Error>> {
9    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
10
11    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
12    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
13    let mut sprite = Sprite::from(&tex_dirt);
14    let mut leave = Sprite::from(&tex_leave);
15    leave.set_position(Point::new(500.0, 500.0));
16    sprite.set_position(Point::new(10.0, 10.0));
17    leave.set_scale(Vector::new(0.5, 0.5));
18    leave.set_origin_to_center()?;
19
20    let event_handler = EventHandler::new(&window);
21
22    window.set_clear_color(Color::new(0.45, 0.0, 1.0));
23    window.enable_cursor();
24    window.poll(None);
25
26    while window.is_open() {
27        window.poll_events();
28        leave.rotate(1.0);
29        leave.update();
30        sprite.update();
31
32        for event in event_handler.fetch() {
33            event_process(event, &mut window);
34        }
35
36        window.clear();
37        window.draw(&sprite);
38        window.draw(&leave);
39        window.display();
40    }
41
42    Ok(())
43}
examples/view.rs (line 37)
7fn main() {
8    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
9    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
10    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
11    let event_handler = EventHandler::new(&window);
12    let mut sprite = Sprite::from(&tex_dirt);
13    let mut leave = Sprite::from(&tex_leave);
14
15    leave.set_position(Point::new(300.0, 300.0));
16    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
17    window.enable_cursor();
18    window.poll(None);
19    leave.set_scale(Vector::new(0.5, 0.5));
20    leave
21        .set_origin_to_center()
22        .unwrap_or_else(|e| println!("{}", e));
23    while window.is_open() {
24        window.poll_events();
25        leave.rotate(1.0);
26        leave.update();
27        sprite.update();
28        window.view_mut().update();
29
30        for event in event_handler.fetch() {
31            event_process(event, &mut window);
32        }
33
34        window.clear();
35        window.draw(&mut sprite);
36        window.draw(&mut leave);
37        window.display();
38    }
39}
examples/font.rs (line 48)
8fn main() {
9    // Create drawer window
10    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
11
12    // Create event handler
13    let event_handler = EventHandler::new(&window);
14
15    // Create font
16    let font = Rc::new(RefCell::new(
17        Font::from_path("examples/font/test.ttf").unwrap(),
18    ));
19
20    // Create text with font
21    let mut text = Text::new(&font);
22    text.set_content("Welcome to Gust you can write text and\na lot more !\t(Like tabs)");
23    text.set_position(Vector::new(100.0, 100.0));
24
25    // Create a 2nd text with font
26    let mut text2 = Text::from_str(&font, "Salut !");
27    text2.set_position(Vector::new(200.0, 200.0));
28    text2.update();
29
30    // Loop preparation
31    window.set_clear_color(Color::new(0.0, 0.0, 0.0));
32    window.enable_cursor();
33    window.poll(None);
34    while window.is_open() {
35        // update text
36        text.update();
37
38        // Poll event
39        window.poll_events();
40        event_handler
41            .fetch()
42            .for_each(|event| handle(&event, &mut window, &mut text));
43
44        // Draw process (Clear -> Draw -> Display)
45        window.clear();
46        window.draw(&text);
47        window.draw(&text2);
48        window.display();
49    }
50}
Additional examples can be found in:
Source

pub fn view(&self) -> &View

Source

pub fn view_mut(&mut self) -> &mut View

Examples found in repository?
examples/view.rs (line 28)
7fn main() {
8    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
9    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
10    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
11    let event_handler = EventHandler::new(&window);
12    let mut sprite = Sprite::from(&tex_dirt);
13    let mut leave = Sprite::from(&tex_leave);
14
15    leave.set_position(Point::new(300.0, 300.0));
16    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
17    window.enable_cursor();
18    window.poll(None);
19    leave.set_scale(Vector::new(0.5, 0.5));
20    leave
21        .set_origin_to_center()
22        .unwrap_or_else(|e| println!("{}", e));
23    while window.is_open() {
24        window.poll_events();
25        leave.rotate(1.0);
26        leave.update();
27        sprite.update();
28        window.view_mut().update();
29
30        for event in event_handler.fetch() {
31            event_process(event, &mut window);
32        }
33
34        window.clear();
35        window.draw(&mut sprite);
36        window.draw(&mut leave);
37        window.display();
38    }
39}
40
41fn event_process(event: Event, window: &mut Window) {
42    match event.1 {
43        Events::Key(Key::Escape, _, _, _) => {
44            window.close();
45        }
46        Events::Key(Key::Up, _, _, _) => {
47            window.view_mut().zoom(2.0);
48        }
49        Events::Key(Key::Down, _, _, _) => {
50            window.view_mut().zoom(0.5);
51        }
52        Events::CursorPos(x, y) => {
53            let center = Vector::new(x as f32, y as f32);
54            window.view_mut().set_center(center);
55            window.set_mouse_pos(center)
56        }
57        _ => println!("Another event !"),
58    }
59}
Source

pub fn set_fps_limit(&mut self, limit: u32) -> u32

Source

pub fn fps_limit(&self) -> u32

Source

pub fn event(&self) -> &EventReceiver

Source

pub fn event_mut(&mut self) -> &mut EventReceiver

Trait Implementations§

Source§

impl Default for Window

Default trait implementation for window

Source§

fn default() -> Window

Returns the “default value” for a type. Read more
Source§

impl Drawer for Window

Source§

fn draw<T: Drawable>(&mut self, drawable: &T)

Function that draw on itself needed by everything that can be draw.
Source§

fn draw_mut<T: DrawableMut>(&mut self, drawable: &mut T)

Function that can draw a DrawableMut.
Source§

fn draw_with_context<T: Drawable>( &mut self, drawable: &mut T, context: &mut Context<'_>, )

Draw with context a Drawable.
Source§

fn draw_with_context_mut<T: DrawableMut>( &mut self, drawable: &mut T, context: &mut Context<'_>, )

Draw with context fonction if you want to define you own fonction
Source§

fn get_sizes(&self) -> Vector<f32>

Source§

fn get_center(&self) -> Vector<f32>

Source§

fn projection(&self) -> &Matrix4<f32>

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> SetParameter for T

Source§

fn set<T>(&mut self, value: T) -> <T as Parameter<Self>>::Result
where T: Parameter<Self>,

Sets value as a parameter of self.
Source§

impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,

Source§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more
Source§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
Source§

unsafe fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
Source§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.