Struct Input 

pub struct Input { /* private fields */ }

Implementations

impl Input

pub fn mouse_position(&self) -> Point2

Returns the current mouse position in pixels.

Examples found in repository

examples/input.rs (line 27)

fn main() {
    let mut runner = est_render::runner::new().expect("Failed to create runner");

    let _window = runner
        .create_window("Input Example", Point2::new(800, 600))
        .build()
        .expect("Failed to create window");

    let window2 = runner
        .create_window("Second Window", Point2::new(800, 600))
        .build()
        .expect("Failed to create second window");

    let input = runner.create_input(None);
    let mut input2 = runner.create_input(Some(&window2));

    input2.listen_keyboard_event(|key, pressed| {
        println!("Second window keyboard event: {} - {}", key, pressed);
    });

    while runner.pump_events(None) {
        if input.mouse_pressed_once("Left") {
            println!("Mouse position: {:?}", input.mouse_position());
        }

        if input2.mouse_pressed_once("Left") {
            println!("Mouse position in second window: {:?}", input2.mouse_position());
        }
    }
}

pub fn mouse_pressed(&self, button: &str) -> bool

Returns true if the mouse button is currently pressed down.

Expected button names are:

• “Left”
• “Right”
• “Middle”
• “Back”
• “Forward”

pub fn mouse_pressed_once(&self, button: &str) -> bool

Returns true if the mouse button was pressed once since the last call to this method.

See Input::mouse_pressed for expected button names.

Examples found in repository

examples/input.rs (line 26)

fn main() {
    let mut runner = est_render::runner::new().expect("Failed to create runner");

    let _window = runner
        .create_window("Input Example", Point2::new(800, 600))
        .build()
        .expect("Failed to create window");

    let window2 = runner
        .create_window("Second Window", Point2::new(800, 600))
        .build()
        .expect("Failed to create second window");

    let input = runner.create_input(None);
    let mut input2 = runner.create_input(Some(&window2));

    input2.listen_keyboard_event(|key, pressed| {
        println!("Second window keyboard event: {} - {}", key, pressed);
    });

    while runner.pump_events(None) {
        if input.mouse_pressed_once("Left") {
            println!("Mouse position: {:?}", input.mouse_position());
        }

        if input2.mouse_pressed_once("Left") {
            println!("Mouse position in second window: {:?}", input2.mouse_position());
        }
    }
}

pub fn key_pressed(&self, key: &str) -> bool

Returns true if the key is currently pressed down.

The key should be a string representation of the key, such as “a”, “Enter”, “Space”, etc.

The normal key names are used, such as:

• “a”
• “b”
• etc.

The modifier keys are also supported such as:

• “Shift”
• etc.

Which also can be combined with other keys, such as:

• “A” (Shift + “a”)
• “B” (Shift + “b”)
• etc.

This also supports unknown scancodes!

pub fn key_pressed_once(&self, key: &str) -> bool

Returns true if the key was pressed once since the last call to this method.

See Input::key_pressed for expected key names.

pub fn listen_mouse_event<F>(&mut self, event: F)

where F: Fn(&str, Point2, bool) + Send + Sync + 'static,

Listens for mouse events.

pub fn listen_mouse_move_event<F>(&mut self, event: F)

where F: Fn(Point2) + Send + Sync + 'static,

Listens for mouse move events.

pub fn listen_keyboard_event<F>(&mut self, event: F)

where F: Fn(&str, bool) + Send + Sync + 'static,

Listens for keyboard events.

Examples found in repository

examples/input.rs (lines 21-23)

fn main() {
    let mut runner = est_render::runner::new().expect("Failed to create runner");

    let _window = runner
        .create_window("Input Example", Point2::new(800, 600))
        .build()
        .expect("Failed to create window");

    let window2 = runner
        .create_window("Second Window", Point2::new(800, 600))
        .build()
        .expect("Failed to create second window");

    let input = runner.create_input(None);
    let mut input2 = runner.create_input(Some(&window2));

    input2.listen_keyboard_event(|key, pressed| {
        println!("Second window keyboard event: {} - {}", key, pressed);
    });

    while runner.pump_events(None) {
        if input.mouse_pressed_once("Left") {
            println!("Mouse position: {:?}", input.mouse_position());
        }

        if input2.mouse_pressed_once("Left") {
            println!("Mouse position in second window: {:?}", input2.mouse_position());
        }
    }
}

Trait Implementations

impl Clone for Input

fn clone(&self) -> Input

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Input

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

Formats the value using the given formatter.