What is the correct way of processing input with FixedUpdate systems?

[horazont]

Hello everyone!

I would like to understand the interaction of Input<_> (key codes in particular) and FixedUpdate systems. What is the correct way of scheduling input processing when the main game logic uses FixedUpdate for physics simulations?

• The Update schedule is run after FixedUpdate, which makes it a bit unsuitable because I'd like to make use of input as soon as possible.
• I could process input in FixedUpdate; does that work correctly with just_pressed et al., even if FixedUpdate runs more than once in a single App update? What happens if the user presses a button between two FixedUpdate schedules within the same App update?

Currently, I have input processing in FixedUpdate which seems to work alright. Is that the correct way of doing it?

Thanks!

[richardhozak]

There's still an issue #6183 when you use Res<Input<KeyCode>> (or Res<Input<ScanCode>> for that matter) in FixedUpdate, that you can miss the inputs. With #10077 merged in Bevy 0.12.1 you at least get KeyboardInput events that are not lost.

So if you want to use Input<KeyCode> in FixedUpdate, what you can do is fill Input<KeyCode> yourself and have it as local param in your system:

fn handle_input(
    mut keys: Local<Input<KeyCode>>,
    mut keyboard_input_events: EventReader<KeyboardInput>,
) {
    keys.clear();
    for event in keyboard_input_events.read() {
        if let Some(key_code) = event.key_code {
            match event.state {
                ButtonState::Pressed => keys.press(key_code),
                ButtonState::Released => keys.release(key_code),
            }
        }
    }

    // do something with inputs

    let up = keys.pressed(KeyCode::Up);
    let down = keys.pressed(KeyCode::Down);
    let left = keys.pressed(KeyCode::Left);
    let right = keys.pressed(KeyCode::Right);
    let respawn = keys.just_pressed(KeyCode::Return);
}

You fill Local<Input<KeyCode>> with events from keyboard and you can use it the same way as you would Res<Input<KeyCode>>.

If you want to use this with ScanCode you need to add another Local<Input<ScanCode>> and then fill it with event.scan_code the same way it is done with event.key_code.

[horazont]

Thanks! I made my own copy of Input<> with its own update systems which looks like this:

use std::hash::Hash;
use std::ops::{Deref, DerefMut};

use bevy::{
	input::{keyboard::KeyboardInput, ButtonState},
	prelude::*,
};

pub struct FixedInputPlugin;

impl Plugin for FixedInputPlugin {
	fn build(&self, app: &mut App) {
		app.insert_resource(FixedInput::<KeyCode>::default())
			.insert_resource(FixedInput::<ScanCode>::default())
			.add_systems(FixedUpdate, keyboard_fixed_input_system);
	}
}

#[derive(Resource)]
pub struct FixedInput<T: Copy + Eq + Hash + Send + Sync + 'static> {
	inner: Input<T>,
}

impl<T: Copy + Eq + Hash + Send + Sync + 'static> Default for FixedInput<T> {
	fn default() -> Self {
		Self { inner: default() }
	}
}

impl<T: Copy + Eq + Hash + Send + Sync + 'static> Deref for FixedInput<T> {
	type Target = Input<T>;

	fn deref(&self) -> &Self::Target {
		&self.inner
	}
}

impl<T: Copy + Eq + Hash + Send + Sync + 'static> DerefMut for FixedInput<T> {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.inner
	}
}

pub fn keyboard_fixed_input_system(
	mut keycodes: ResMut<FixedInput<KeyCode>>,
	mut scancodes: ResMut<FixedInput<ScanCode>>,
	mut events: EventReader<KeyboardInput>,
) {
	keycodes.clear();
	scancodes.clear();
	for event in events.read() {
		match event.state {
			ButtonState::Pressed => {
				if let Some(keycode) = event.key_code {
					keycodes.press(keycode);
				}
				scancodes.press(ScanCode(event.scan_code));
			}
			ButtonState::Released => {
				if let Some(keycode) = event.key_code {
					keycodes.release(keycode);
				}
				scancodes.release(ScanCode(event.scan_code));
			}
		}
	}
}

By running keyboard_fixed_input_system in FixedUpdate, I get what I need---I just need to schedule the other stuff in FixedUpdate after the keyboard_fixed_input_system, but that's easy.

[richardhozak]

Yeah, your solution is more useful if you want to handle inputs across multiple systems in FixedUpdate. Note that bevy has util derives for Deref and DerefMut, you can simplify your solution a bit:

use std::hash::Hash;

use bevy::{
    input::{keyboard::KeyboardInput, ButtonState},
    prelude::*,
};

pub struct FixedInputPlugin;

impl Plugin for FixedInputPlugin {
    fn build(&self, app: &mut App) {
        app.insert_resource(FixedInput::<KeyCode>::default())
            .insert_resource(FixedInput::<ScanCode>::default())
            .add_systems(FixedUpdate, keyboard_fixed_input_system);
    }
}

#[derive(Resource, Deref, DerefMut)]
pub struct FixedInput<T: Copy + Eq + Hash + Send + Sync + 'static>(Input<T>);

impl<T: Copy + Eq + Hash + Send + Sync + 'static> Default for FixedInput<T> {
    fn default() -> Self {
        Self(default())
    }
}

pub fn keyboard_fixed_input_system(
    mut keycodes: ResMut<FixedInput<KeyCode>>,
    mut scancodes: ResMut<FixedInput<ScanCode>>,
    mut events: EventReader<KeyboardInput>,
) {
    keycodes.clear();
    scancodes.clear();
    for event in events.read() {
        match event.state {
            ButtonState::Pressed => {
                if let Some(keycode) = event.key_code {
                    keycodes.press(keycode);
                }
                scancodes.press(ScanCode(event.scan_code));
            }
            ButtonState::Released => {
                if let Some(keycode) = event.key_code {
                    keycodes.release(keycode);
                }
                scancodes.release(ScanCode(event.scan_code));
            }
        }
    }
}