Struct InputManager 

pub struct InputManager { /* private fields */ }

Input management resource for ECS integration.

Tracks keyboard, mouse, and gamepad input state across frames, enabling queries for current state, just pressed, and just released. Also supports action mapping for semantic input handling.

Implementations

impl InputManager

pub fn map_action(&mut self, action: impl Into<String>, binding: InputBinding)

Maps an input binding to an action.

An action can have multiple bindings. If the action already exists, the binding is added to its list. Duplicate bindings are allowed.

Example

use goud_engine::ecs::{InputManager, InputBinding};
use glfw::Key;

let mut input = InputManager::new();
input.map_action("Jump", InputBinding::Key(Key::Space));
input.map_action("Jump", InputBinding::Key(Key::W)); // Alternative binding

pub fn unmap_action(&mut self, action: &str, binding: InputBinding) -> bool

Unmaps a specific input binding from an action.

Returns true if the binding was removed, false if it wasn’t found.

pub fn clear_action(&mut self, action: &str) -> bool

Removes all bindings for an action.

Returns true if the action existed and was removed.

pub fn clear_all_actions(&mut self)

Removes all action mappings.

pub fn get_action_bindings(&self, action: &str) -> &[InputBinding]

Returns all bindings for an action.

Returns an empty slice if the action doesn’t exist.

pub fn has_action(&self, action: &str) -> bool

Returns true if the action has any bindings.

pub fn action_names(&self) -> impl Iterator<Item = &str>

Returns an iterator over all action names.

pub fn action_count(&self) -> usize

Returns the number of registered actions.

pub fn action_pressed(&self, action: &str) -> bool

Returns true if ANY binding for the action is currently pressed.

Returns false if the action doesn’t exist or has no bindings.

pub fn action_just_pressed(&self, action: &str) -> bool

Returns true if ANY binding for the action was just pressed this frame.

Returns false if the action doesn’t exist or has no bindings.

pub fn action_just_released(&self, action: &str) -> bool

Returns true if ANY binding for the action was just released this frame.

Returns false if the action doesn’t exist or has no bindings.

pub fn action_strength(&self, action: &str) -> f32

Returns the strength of the action (0.0-1.0).

For digital inputs (keys, buttons), this returns 1.0 if pressed, 0.0 otherwise. This method exists for future analog input support (triggers, analog sticks).

impl InputManager

pub fn buffer_duration(&self) -> Duration

Returns the current buffer duration.

pub fn set_buffer_duration(&mut self, duration: Duration)

Sets the buffer duration for input sequences.

This determines how long inputs are remembered for combo detection.

pub fn buffer_size(&self) -> usize

Returns the number of inputs currently in the buffer.

pub fn clear_buffer(&mut self)

Clears the input buffer.

Useful when resetting combos or canceling sequences.

pub fn sequence_detected(&self, sequence: &[InputBinding]) -> bool

Checks if a sequence of inputs was pressed within the buffer duration.

Returns true if all bindings in the sequence were pressed in order, with each subsequent input occurring within the buffer window.

Example

use goud_engine::ecs::{InputManager, InputBinding};
use glfw::Key;

let mut input = InputManager::new();

// Detect "Down, Down, Forward, Punch" combo (fighting game)
let combo = vec![
    InputBinding::Key(Key::Down),
    InputBinding::Key(Key::Down),
    InputBinding::Key(Key::Right),
    InputBinding::Key(Key::Space),
];

if input.sequence_detected(&combo) {
    player.perform_special_move();
}

pub fn consume_sequence(&mut self, sequence: &[InputBinding]) -> bool

Checks if a sequence was pressed and clears the buffer if detected.

This is useful for consuming combos so they don’t trigger multiple times.

Returns true if the sequence was detected and consumed.

pub fn time_since_last_input(&self) -> Option<f32>

Returns the time since the last buffered input in seconds.

Returns None if the buffer is empty.

pub fn buffered_inputs(&self) -> impl Iterator<Item = (InputBinding, f32)> + '_

Returns all inputs in the buffer (oldest to newest).

Useful for debugging or visualizing input history.

impl InputManager

pub fn press_gamepad_button(&mut self, gamepad_id: usize, button: u32)

Sets a gamepad button as pressed.

Panics

Panics if gamepad_id >= 4.

pub fn release_gamepad_button(&mut self, gamepad_id: usize, button: u32)

Sets a gamepad button as released.

Panics

Panics if gamepad_id >= 4.

pub fn gamepad_button_pressed(&self, gamepad_id: usize, button: u32) -> bool

Returns true if the gamepad button is currently pressed.

Returns false if gamepad_id is invalid.

pub fn gamepad_button_just_pressed( &self, gamepad_id: usize, button: u32, ) -> bool

Returns true if the gamepad button was just pressed this frame.

pub fn gamepad_button_just_released( &self, gamepad_id: usize, button: u32, ) -> bool

Returns true if the gamepad button was just released this frame.

pub fn set_gamepad_axis( &mut self, gamepad_id: usize, axis: GamepadAxis, value: f32, )

Sets a gamepad analog axis value (-1.0 to 1.0).

Values within the deadzone threshold are clamped to 0.0.

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

Returns the current value of a gamepad analog axis (-1.0 to 1.0).

Returns 0.0 if the gamepad or axis doesn’t exist.

pub fn gamepad_left_stick(&self, gamepad_id: usize) -> Vec2

Returns the left stick as a Vec2 (x, y) where -1.0 is left/down and 1.0 is right/up.

Returns Vec2::zero() if the gamepad doesn’t exist.

pub fn gamepad_right_stick(&self, gamepad_id: usize) -> Vec2

Returns the right stick as a Vec2 (x, y) where -1.0 is left/down and 1.0 is right/up.

Returns Vec2::zero() if the gamepad doesn’t exist.

pub fn gamepad_left_trigger(&self, gamepad_id: usize) -> f32

Returns the left trigger value (0.0 to 1.0).

Returns 0.0 if the gamepad doesn’t exist.

pub fn gamepad_right_trigger(&self, gamepad_id: usize) -> f32

Returns the right trigger value (0.0 to 1.0).

Returns 0.0 if the gamepad doesn’t exist.

pub fn set_gamepad_connected(&mut self, gamepad_id: usize, connected: bool)

Sets the connection status of a gamepad.

pub fn is_gamepad_connected(&self, gamepad_id: usize) -> bool

Returns true if the gamepad is currently connected.

pub fn connected_gamepad_count(&self) -> usize

Returns the number of connected gamepads.

pub fn connected_gamepads(&self) -> impl Iterator<Item = usize> + '_

Returns an iterator over all connected gamepad IDs.

pub fn set_gamepad_vibration(&mut self, gamepad_id: usize, intensity: f32)

Sets the vibration intensity for a gamepad (0.0-1.0).

Note: Actual vibration must be implemented by the platform layer. This only tracks the requested vibration intensity.

pub fn gamepad_vibration(&self, gamepad_id: usize) -> f32

Returns the current vibration intensity for a gamepad (0.0-1.0).

pub fn stop_gamepad_vibration(&mut self, gamepad_id: usize)

Stops vibration for a gamepad (sets intensity to 0.0).

pub fn stop_all_vibration(&mut self)

Stops vibration for all gamepads.

pub fn analog_deadzone(&self) -> f32

Returns the current analog deadzone threshold (0.0-1.0).

Default is 0.1 (10%).

pub fn set_analog_deadzone(&mut self, deadzone: f32)

Sets the analog deadzone threshold (0.0-1.0).

Analog axis values within this threshold are clamped to 0.0. This prevents stick drift and accidental input.

impl InputManager

pub fn new() -> Self

Creates a new InputManager with no inputs pressed.

Default buffer duration is 200ms, suitable for most combo detection.

pub fn with_buffer_duration(buffer_duration: Duration) -> Self

Creates a new InputManager with custom buffer duration.

The buffer duration determines how long inputs are remembered for sequence detection.

• Short durations (50-100ms): Strict, requires fast input
• Medium durations (200-300ms): Balanced, works for most games
• Long durations (500ms+): Lenient, easier for casual players

pub fn update(&mut self)

Updates the input state for the next frame.

This should be called at the start of each frame, before any input queries. It copies current state to previous state and resets deltas.

pub fn press_key(&mut self, key: Key)

Sets a key as pressed.

pub fn release_key(&mut self, key: Key)

Sets a key as released.

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

Returns true if the key is currently pressed.

pub fn key_just_pressed(&self, key: Key) -> bool

Returns true if the key was just pressed this frame.

True only on the first frame the key is pressed.

pub fn key_just_released(&self, key: Key) -> bool

Returns true if the key was just released this frame.

True only on the first frame the key is released.

pub fn keys_pressed(&self) -> impl Iterator<Item = &Key>

Returns an iterator over all currently pressed keys.

pub fn press_mouse_button(&mut self, button: MouseButton)

Sets a mouse button as pressed.

pub fn release_mouse_button(&mut self, button: MouseButton)

Sets a mouse button as released.

pub fn mouse_button_pressed(&self, button: MouseButton) -> bool

Returns true if the mouse button is currently pressed.

pub fn mouse_button_just_pressed(&self, button: MouseButton) -> bool

Returns true if the mouse button was just pressed this frame.

pub fn mouse_button_just_released(&self, button: MouseButton) -> bool

Returns true if the mouse button was just released this frame.

pub fn mouse_buttons_pressed(&self) -> impl Iterator<Item = &MouseButton>

Returns an iterator over all currently pressed mouse buttons.

pub fn set_mouse_position(&mut self, position: Vec2)

Updates the mouse position.

pub fn mouse_position(&self) -> Vec2

Returns the current mouse position in screen coordinates.

pub fn mouse_delta(&self) -> Vec2

Returns the mouse movement delta since last frame.

pub fn add_scroll_delta(&mut self, delta: Vec2)

Updates the mouse scroll delta.

pub fn scroll_delta(&self) -> Vec2

Returns the mouse scroll delta for this frame.

pub fn clear(&mut self)

Clears all input state (useful for focus loss or pausing).

Trait Implementations

impl Clone for InputManager

fn clone(&self) -> InputManager

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InputManager

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

Formats the value using the given formatter.

impl Default for InputManager

fn default() -> Self

Returns the “default value” for a type.