dc3f801239
# Objective The [Stageless RFC](https://github.com/bevyengine/rfcs/pull/45) involves allowing exclusive systems to be referenced and ordered relative to parallel systems. We've agreed that unifying systems under `System` is the right move. This is an alternative to #4166 (see rationale in the comments I left there). Note that this builds on the learnings established there (and borrows some patterns). ## Solution This unifies parallel and exclusive systems under the shared `System` trait, removing the old `ExclusiveSystem` trait / impls. This is accomplished by adding a new `ExclusiveFunctionSystem` impl similar to `FunctionSystem`. It is backed by `ExclusiveSystemParam`, which is similar to `SystemParam`. There is a new flattened out SystemContainer api (which cuts out a lot of trait and type complexity). This means you can remove all cases of `exclusive_system()`: ```rust // before commands.add_system(some_system.exclusive_system()); // after commands.add_system(some_system); ``` I've also implemented `ExclusiveSystemParam` for `&mut QueryState` and `&mut SystemState`, which makes this possible in exclusive systems: ```rust fn some_exclusive_system( world: &mut World, transforms: &mut QueryState<&Transform>, state: &mut SystemState<(Res<Time>, Query<&Player>)>, ) { for transform in transforms.iter(world) { println!("{transform:?}"); } let (time, players) = state.get(world); for player in players.iter() { println!("{player:?}"); } } ``` Note that "exclusive function systems" assume `&mut World` is present (and the first param). I think this is a fair assumption, given that the presence of `&mut World` is what defines the need for an exclusive system. I added some targeted SystemParam `static` constraints, which removed the need for this: ``` rust fn some_exclusive_system(state: &mut SystemState<(Res<'static, Time>, Query<&'static Player>)>) {} ``` ## Related - #2923 - #3001 - #3946 ## Changelog - `ExclusiveSystem` trait (and implementations) has been removed in favor of sharing the `System` trait. - `ExclusiveFunctionSystem` and `ExclusiveSystemParam` were added, enabling flexible exclusive function systems - `&mut SystemState` and `&mut QueryState` now implement `ExclusiveSystemParam` - Exclusive and parallel System configuration is now done via a unified `SystemDescriptor`, `IntoSystemDescriptor`, and `SystemContainer` api. ## Migration Guide Calling `.exclusive_system()` is no longer required (or supported) for converting exclusive system functions to exclusive systems: ```rust // Old (0.8) app.add_system(some_exclusive_system.exclusive_system()); // New (0.9) app.add_system(some_exclusive_system); ``` Converting "normal" parallel systems to exclusive systems is done by calling the exclusive ordering apis: ```rust // Old (0.8) app.add_system(some_system.exclusive_system().at_end()); // New (0.9) app.add_system(some_system.at_end()); ``` Query state in exclusive systems can now be cached via ExclusiveSystemParams, which should be preferred for clarity and performance reasons: ```rust // Old (0.8) fn some_system(world: &mut World) { let mut transforms = world.query::<&Transform>(); for transform in transforms.iter(world) { } } // New (0.9) fn some_system(world: &mut World, transforms: &mut QueryState<&Transform>) { for transform in transforms.iter(world) { } } ```
103 lines
3.0 KiB
Rust
103 lines
3.0 KiB
Rust
mod axis;
|
|
pub mod gamepad;
|
|
mod input;
|
|
pub mod keyboard;
|
|
pub mod mouse;
|
|
pub mod touch;
|
|
|
|
pub use axis::*;
|
|
use bevy_ecs::schedule::{IntoSystemDescriptor, SystemLabel};
|
|
pub use input::*;
|
|
|
|
pub mod prelude {
|
|
#[doc(hidden)]
|
|
pub use crate::{
|
|
gamepad::{
|
|
Gamepad, GamepadAxis, GamepadAxisType, GamepadButton, GamepadButtonType, GamepadEvent,
|
|
GamepadEventType, Gamepads,
|
|
},
|
|
keyboard::{KeyCode, ScanCode},
|
|
mouse::MouseButton,
|
|
touch::{TouchInput, Touches},
|
|
Axis, Input,
|
|
};
|
|
}
|
|
|
|
use bevy_app::prelude::*;
|
|
use keyboard::{keyboard_input_system, KeyCode, KeyboardInput, ScanCode};
|
|
use mouse::{mouse_button_input_system, MouseButton, MouseButtonInput, MouseMotion, MouseWheel};
|
|
use prelude::Gamepads;
|
|
use touch::{touch_screen_input_system, TouchInput, Touches};
|
|
|
|
use gamepad::{
|
|
gamepad_connection_system, gamepad_event_system, GamepadAxis, GamepadButton, GamepadEvent,
|
|
GamepadEventRaw, GamepadSettings,
|
|
};
|
|
|
|
/// Adds keyboard and mouse input to an App
|
|
#[derive(Default)]
|
|
pub struct InputPlugin;
|
|
|
|
#[derive(Debug, PartialEq, Eq, Clone, Hash, SystemLabel)]
|
|
pub struct InputSystem;
|
|
|
|
impl Plugin for InputPlugin {
|
|
fn build(&self, app: &mut App) {
|
|
app
|
|
// keyboard
|
|
.add_event::<KeyboardInput>()
|
|
.init_resource::<Input<KeyCode>>()
|
|
.init_resource::<Input<ScanCode>>()
|
|
.add_system_to_stage(
|
|
CoreStage::PreUpdate,
|
|
keyboard_input_system.label(InputSystem),
|
|
)
|
|
// mouse
|
|
.add_event::<MouseButtonInput>()
|
|
.add_event::<MouseMotion>()
|
|
.add_event::<MouseWheel>()
|
|
.init_resource::<Input<MouseButton>>()
|
|
.add_system_to_stage(
|
|
CoreStage::PreUpdate,
|
|
mouse_button_input_system.label(InputSystem),
|
|
)
|
|
// gamepad
|
|
.add_event::<GamepadEvent>()
|
|
.add_event::<GamepadEventRaw>()
|
|
.init_resource::<GamepadSettings>()
|
|
.init_resource::<Gamepads>()
|
|
.init_resource::<Input<GamepadButton>>()
|
|
.init_resource::<Axis<GamepadAxis>>()
|
|
.init_resource::<Axis<GamepadButton>>()
|
|
.add_system_to_stage(
|
|
CoreStage::PreUpdate,
|
|
gamepad_event_system.label(InputSystem),
|
|
)
|
|
.add_system_to_stage(
|
|
CoreStage::PreUpdate,
|
|
gamepad_connection_system.after(InputSystem),
|
|
)
|
|
// touch
|
|
.add_event::<TouchInput>()
|
|
.init_resource::<Touches>()
|
|
.add_system_to_stage(
|
|
CoreStage::PreUpdate,
|
|
touch_screen_input_system.label(InputSystem),
|
|
);
|
|
}
|
|
}
|
|
|
|
/// The current "press" state of an element
|
|
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
|
|
pub enum ButtonState {
|
|
Pressed,
|
|
Released,
|
|
}
|
|
|
|
impl ButtonState {
|
|
pub fn is_pressed(&self) -> bool {
|
|
matches!(self, ButtonState::Pressed)
|
|
}
|
|
}
|