Struct View 

pub struct View { /* private fields */ }

A View is a 2D camera. It’s the screen viewport. You can make multiple views and use them as Minimap, 2nd player screen etc… The view is attached to a gust::Window.

Implementations

impl View

pub fn new(pos: Point<f32>, rect: Rect<f32>) -> View

Create a new View from a pos point and a Rect

pub fn reset(&mut self, rect: Rect<f32>)

Reset the rect if you don’t want to you can use (set_sizes)[]

pub fn set_center(&mut self, pos: Point<f32>)

Set pos of the view (usefull for game like 2D Zelda-Like)

Examples found in repository

examples/view.rs (line 54)

fn event_process(event: Event, window: &mut Window) {
    match event.1 {
        Events::Key(Key::Escape, _, _, _) => {
            window.close();
        }
        Events::Key(Key::Up, _, _, _) => {
            window.view_mut().zoom(2.0);
        }
        Events::Key(Key::Down, _, _, _) => {
            window.view_mut().zoom(0.5);
        }
        Events::CursorPos(x, y) => {
            let center = Vector::new(x as f32, y as f32);
            window.view_mut().set_center(center);
            window.set_mouse_pos(center)
        }
        _ => println!("Another event !"),
    }
}

pub fn set_viewport(&mut self, viewport: Rect<f32>)

Set the viewport of the view (the viewport is given as a float factor 0.5 / 1.0 / 0.2 etc) That way people can simply handle screen part.

pub fn set_sizes(&mut self, sizes: Vector<f32>)

Set the size of the rect

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

Move the view from actual position with the offset offset.

pub fn update(&mut self)

Update the view: Apply all transformations.

Examples found in repository

examples/view.rs (line 28)

fn main() {
    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");
    let tex_leave = Rc::new(Texture::from_path("examples/texture/Z.png").unwrap());
    let tex_dirt = Rc::new(Texture::from_path("examples/texture/Dirt.png").unwrap());
    let event_handler = EventHandler::new(&window);
    let mut sprite = Sprite::from(&tex_dirt);
    let mut leave = Sprite::from(&tex_leave);

    leave.set_position(Point::new(300.0, 300.0));
    window.set_clear_color(Color::new(0.0, 0.0, 1.0));
    window.enable_cursor();
    window.poll(None);
    leave.set_scale(Vector::new(0.5, 0.5));
    leave
        .set_origin_to_center()
        .unwrap_or_else(|e| println!("{}", e));
    while window.is_open() {
        window.poll_events();
        leave.rotate(1.0);
        leave.update();
        sprite.update();
        window.view_mut().update();

        for event in event_handler.fetch() {
            event_process(event, &mut window);
        }

        window.clear();
        window.draw(&mut sprite);
        window.draw(&mut leave);
        window.display();
    }
}

pub fn set_zoom(&mut self, zoom: f32)

Set the view zoom.

pub fn zoom(&mut self, zoom: f32)

Multiply the current zoom by this one.

Examples found in repository

examples/view.rs (line 47)

fn event_process(event: Event, window: &mut Window) {
    match event.1 {
        Events::Key(Key::Escape, _, _, _) => {
            window.close();
        }
        Events::Key(Key::Up, _, _, _) => {
            window.view_mut().zoom(2.0);
        }
        Events::Key(Key::Down, _, _, _) => {
            window.view_mut().zoom(0.5);
        }
        Events::CursorPos(x, y) => {
            let center = Vector::new(x as f32, y as f32);
            window.view_mut().set_center(center);
            window.set_mouse_pos(center)
        }
        _ => println!("Another event !"),
    }
}

pub fn get_zoom(&self) -> f32

Return zoom.

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

Return projection Matrix4.

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

Return sizes in a Vector.

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

Return position of the view in a Vector.

Trait Implementations

impl Clone for View

fn clone(&self) -> View

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for View

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Rect<f32>> for View

fn from(rect: Rect<f32>) -> View

Converts to this type from the input type.

impl PartialEq for View

fn eq(&self, other: &View) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for View