Struct Events 

pub struct Events {

    pub keys: [ButtonState; 256],
    pub mouse_buttons: [ButtonState; 8],
    pub mouse_scroll_line: Option<(f32, f32)>,
    pub mouse_scroll_pixel: Option<(f64, f64)>,
    pub modifiers: ModifiersState,
    pub gamepad_connected: [bool; 4],
    pub gamepad_buttons: [[ButtonState; 20]; 4],
    pub gamepad_axes: [[f32; 6]; 4],
    pub resize_event: Option<Size2D>,
    pub close_requested: bool,
    pub focused: bool,
    pub frame: u64,
    pub network: NetworkEvents,
}

Per-frame input state snapshot.

Events holds all input state for a single frame. It is populated by calling process_window_event and process_gilrs_event as events arrive, then frozen for the frame. At the end of the frame, end_frame advances the frame counter and clears transient state.

Keyboard

use optic_window::*;

if events.key(KeyCode::Space, Is::Pressed) {
    // space was just pressed this frame
}
if events.key(KeyCode::ControlLeft, Is::Held) {
    // ctrl is held down
}

Mouse

use optic_window::*;

if events.mouse(Mouse::Left, Is::Pressed) {
    // left click this frame
}

Gamepad

use optic_window::*;

if events.gamepad_button(0, GamepadButton::A, Is::Pressed) {
    // gamepad 0 pressed A this frame
}
let axis = events.gamepad_axis(0, GamepadAxis::LeftX);

Fields

keys: [ButtonState; 256]

mouse_buttons: [ButtonState; 8]

mouse_scroll_line: Option<(f32, f32)>

mouse_scroll_pixel: Option<(f64, f64)>

modifiers: ModifiersState

gamepad_connected: [bool; 4]

gamepad_buttons: [[ButtonState; 20]; 4]

gamepad_axes: [[f32; 6]; 4]

resize_event: Option<Size2D>

close_requested: bool

focused: bool

frame: u64

network: NetworkEvents

Implementations

impl Events

pub const GAMEPAD_AXIS_DEADZONE: f32 = 0.15

Default deadzone for gamepad analog axes.

pub fn new() -> Self

Create a new, empty event state (frame = 1, focused = true).

pub fn clear(&mut self)

Reset all state to defaults. Does not advance the frame counter.

pub fn process_window_event(&mut self, event: &WindowEvent, _window: &Window)

Process a single winit WindowEvent, updating internal state.

Called by the game loop for each event in the winit event queue.

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

Process a single gilrs gamepad event.

pub fn end_frame(&mut self)

Advance the frame counter and clear per-frame transient state.

Must be called at the end of every frame. Resets scroll deltas, resize events, and network events. The close_requested flag persists across frames (the user must manually clear it).

pub fn key(&self, kc: KeyCode, action: Is) -> bool

Query a single key by KeyCode and Is action.

pub fn key_combo(&self, primary: KeyCode, modifier: KeyCode, action: Is) -> bool

Query a key combo: primary must match action while modifier is held.

use optic_window::*;

if events.key_combo(KeyCode::KeyC, KeyCode::ControlLeft, Is::Pressed) {
    // Ctrl+C was pressed
}

pub fn key_combo_n(&self, keys: &[(KeyCode, Is)]) -> bool

Query multiple keys simultaneously — all must match their respective actions.

pub fn any_key(&self, action: Is) -> bool

True if any key matches the given action.

pub fn mouse(&self, m: Mouse, action: Is) -> bool

Query a mouse button by Mouse and Is action.

pub fn any_mouse(&self, action: Is) -> bool

True if any mouse button matches the given action.

pub fn gamepad_connected(&self, id: usize) -> bool

True if a gamepad with the given id is currently connected.

pub fn gamepad_count(&self) -> usize

Number of currently connected gamepads.

pub fn gamepad_button( &self, id: usize, button: GamepadButton, action: Is, ) -> bool

Query a gamepad button by GamepadButton and Is action.

pub fn any_gamepad_button(&self, id: usize, action: Is) -> bool

True if any button on the given gamepad matches the action.

pub fn any_gamepad(&self, action: Is) -> bool

True if any button on any connected gamepad matches the action.

pub fn gamepad_axis_raw(&self, id: usize, axis: GamepadAxis) -> f32

Raw gamepad axis value (no deadzone applied).

pub fn gamepad_axis(&self, id: usize, axis: GamepadAxis) -> f32

Gamepad axis value with the default deadzone ([GAMEPAD_AXIS_DEADZONE]).

Values below the deadzone are snapped to 0.0.

pub fn gamepad_axis_deadzoned( &self, id: usize, axis: GamepadAxis, deadzone: f32, ) -> f32

Gamepad axis value with a custom deadzone.