Struct Input 

pub struct Input {

    pub gilrs: Option<Gilrs>,
    pub mouse_x: f32,
    pub mouse_y: f32,
    pub left_pressed: bool,
    pub left_just_pressed: bool,
    pub left_just_released: bool,
    pub scroll_delta: f32,
    pub text_input: Vec<char>,
    pub backspace: bool,
    pub enter: bool,
    pub escape: bool,
    pub tab: bool,
    pub arrow_left: bool,
    pub arrow_right: bool,
    pub arrow_up: bool,
    pub arrow_down: bool,
    pub shift: bool,
    pub ctrl: bool,
    pub key_a: bool,
    pub key_c: bool,
    pub key_x: bool,
    pub key_v: bool,
    pub space: bool,
    pub home: bool,
    pub last_hw_key: Option<Instant>,
    /* private fields */
}

Raw input state in grid units (1080-unit tall coordinate space).

Updated every frame from winit events via Input::handle_event and from gilrs events via Input::poll_gamepad or Input::handle_gamepad_event. Single-frame pulse fields (left_just_pressed, arrow_left, …) are cleared by Input::begin_frame at the end of each frame.

Fields

gilrs: Option<Gilrs>

Optional owned gilrs instance. Present in standalone mode; None in overlay mode where the caller drives Input::handle_gamepad_event directly.

mouse_x: f32

Cursor X position in grid units (origin at screen centre, right = +).

mouse_y: f32

Cursor Y position in grid units (origin at screen centre, down = +).

left_pressed: bool

true while the left mouse button is held.

left_just_pressed: bool

true on the first frame the left mouse button goes down.

left_just_released: bool

true on the first frame the left mouse button is released.

scroll_delta: f32

Lines scrolled this frame; positive = scroll down.

text_input: Vec<char>

Printable characters typed this frame (from event.text, handles IME / dead keys).

backspace: bool

true if backspace was pressed this frame.

enter: bool

true if Enter/Return was pressed this frame.

escape: bool

true if Escape was pressed this frame.

tab: bool

true if Tab was pressed this frame.

arrow_left: bool

Arrow-left pulse this frame (fires on key-down and during auto-repeat).

arrow_right: bool

Arrow-right pulse this frame (fires on key-down and during auto-repeat).

arrow_up: bool

Arrow-up pulse this frame (fires on key-down and during auto-repeat).

arrow_down: bool

Arrow-down pulse this frame (fires on key-down and during auto-repeat).

shift: bool

true while Shift is held.

ctrl: bool

true while Ctrl is held.

key_a: bool

true if the ‘A’ key was pressed this frame (regardless of modifiers).

key_c: bool

true if the ‘C’ key was pressed this frame.

key_x: bool

true if the ‘X’ key was pressed this frame.

key_v: bool

true if the ‘V’ key was pressed this frame.

space: bool

true if Space or the gamepad South button was pressed this frame.

home: bool

true if the gamepad Mode/Guide button was pressed this frame.

last_hw_key: Option<Instant>

Timestamp of the last hardware keyboard event; used by Input::keyboard_present.

Implementations

impl Input

pub const fn new() -> Self

Create a zeroed Input with no gilrs instance.

pub fn new_with_gilrs() -> Self

Like Input::new, but attempts to initialise gilrs for automatic gamepad polling.

pub fn poll_gamepad(&mut self)

Poll the owned gilrs instance (if any) and map events onto input flags.

Uses take / put-back to avoid borrowing self.gilrs while dispatching to handle_gamepad_event, eliminating the per-frame Vec allocation the naive approach would require.

pub fn handle_gamepad_event(&mut self, event: Event)

Feed a single gilrs event in manually.

Used in overlay mode where the caller owns the Gilrs instance and drains it themselves, or in tests.

pub fn begin_frame(&mut self, dt: f32)

Clear all single-frame pulse flags and advance arrow auto-repeat timers.

Call exactly once per frame, after all widgets have read input but before the next frame’s events are collected. Note that shift and ctrl are not cleared here — they are held-modifier flags updated on key press/release, not single-frame pulses.

pub fn keyboard_present(&self) -> bool

Returns true if a hardware keyboard key was pressed within the last 3 seconds.

Used to decide whether to show the on-screen keyboard: if a physical keyboard is present and recently active, suppress the OSK.

pub fn handle_event(&mut self, event: &WindowEvent, pw: f32, ph: f32)

Feed a raw winit WindowEvent into the input state.

pw and ph are the current window pixel dimensions; they are needed to convert cursor pixel coordinates into the 1080-unit grid space.

Trait Implementations

impl Default for Input

fn default() -> Self

Returns the “default value” for a type.