2024-04-30 00:49:41 +00:00
|
|
|
#![allow(deprecated)]
|
2024-03-03 23:51:53 +00:00
|
|
|
#![allow(missing_docs)]
|
|
|
|
|
|
|
|
use bevy_ecs::prelude::*;
|
|
|
|
use bevy_input::keyboard::KeyboardInput;
|
|
|
|
use bevy_input::touch::TouchInput;
|
|
|
|
use bevy_input::{
|
2024-06-04 12:44:25 +00:00
|
|
|
gestures::*,
|
flush key_input cache when Bevy loses focus (Adopted) (#13678)
This was adopted from #12878. I rebased the changes resolved the
following merge conflicts:
- moved over the changes originally done in bevy_winit/src/lib.rs's
`handle_winit_event` into bevy_winit/src/state.rs's `window_event`
function
- moved WinitEvent::KeyboardFocusLost event forwarding originally done
in bevy_winit/src/winit_event.rs to the equivalent in
bevy_winit/src/state.rs
Tested this by following the modified keyboard_input example from the
original PR.
First, I verified I could reproduce the issue without the changes. Then,
after applying the changes, I verified that when I Alt+Tabbed away from
the running example that the log showed I released Alt and when I tabbed
back it didn't behave like Alt was stuck.
The following is from the original pull request by @gavlig
# Objective
This helps avoiding stuck key presses after switching from and back to
Bevy window. Key press event gets stuck because window loses focus
before receiving a key release event thus we end up with false positive
in ButtonInput.
## Solution
I saw two ways to fix this:
1. add bevy_window as dependency and read WindowFocus events
2. add a KeyboardFocusLost event specifically for this.
I chose the latter because adding another dependency felt wrong, but if
that is more preferable changing this pr won't be a problem. Also if
someone sees another way please let me know.
To test the bug use this small modification over
examples/keyboard_input.rs: (it will work only if you have Alt-Tab
combination for switching between windows in your OS, otherwise change
AltLeft accordingly)
```
//! Demonstrates handling a key press/release.
use bevy::{prelude::*, input::keyboard::KeyboardInput};
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_systems(Update, keyboard_input_system)
.run();
}
/// This system prints 'Alt' key state
fn keyboard_input_system(keyboard_input: Res<ButtonInput<KeyCode>>, mut
keyboard_input_events: EventReader<KeyboardInput>) {
for event in keyboard_input_events.read() {
info!("{:?}", event);
}
if keyboard_input.pressed(KeyCode::AltLeft) {
info!("'Alt' currently pressed");
}
if keyboard_input.just_pressed(KeyCode::AltLeft) {
info!("'Alt' just pressed");
}
if keyboard_input.just_released(KeyCode::AltLeft) {
info!("'Alt' just released");
}
}
```
Here i made a quick video with demo of the fix:
https://youtu.be/qTvUCk4IHvo In first part i press Alt and Alt+Tab to
switch back and forth from example app, logs will indicate that too. In
second part I applied fix and you'll see that Alt will no longer be
pressed when window gets unfocused
## Migration Guide
`WinitEvent` has a new enum variant: `WinitEvent::KeyboardFocusLost`.
Co-authored-by: gavlig <gavlig@gmail.com>
2024-06-05 02:06:47 +00:00
|
|
|
keyboard::KeyboardFocusLost,
|
2024-03-03 23:51:53 +00:00
|
|
|
mouse::{MouseButtonInput, MouseMotion, MouseWheel},
|
|
|
|
};
|
|
|
|
use bevy_reflect::Reflect;
|
2024-03-04 07:48:09 +00:00
|
|
|
#[cfg(feature = "serialize")]
|
|
|
|
use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
|
2024-03-03 23:51:53 +00:00
|
|
|
use bevy_window::{
|
fix: upgrade to winit v0.30 (#13366)
# Objective
- Upgrade winit to v0.30
- Fixes https://github.com/bevyengine/bevy/issues/13331
## Solution
This is a rewrite/adaptation of the new trait system described and
implemented in `winit` v0.30.
## Migration Guide
The custom UserEvent is now renamed as WakeUp, used to wake up the loop
if anything happens outside the app (a new
[custom_user_event](https://github.com/bevyengine/bevy/pull/13366/files#diff-2de8c0a8d3028d0059a3d80ae31b2bbc1cde2595ce2d317ea378fe3e0cf6ef2d)
shows this behavior.
The internal `UpdateState` has been removed and replaced internally by
the AppLifecycle. When changed, the AppLifecycle is sent as an event.
The `UpdateMode` now accepts only two values: `Continuous` and
`Reactive`, but the latter exposes 3 new properties to enable reactive
to device, user or window events. The previous `UpdateMode::Reactive` is
now equivalent to `UpdateMode::reactive()`, while
`UpdateMode::ReactiveLowPower` to `UpdateMode::reactive_low_power()`.
The `ApplicationLifecycle` has been renamed as `AppLifecycle`, and now
contains the possible values of the application state inside the event
loop:
* `Idle`: the loop has not started yet
* `Running` (previously called `Started`): the loop is running
* `WillSuspend`: the loop is going to be suspended
* `Suspended`: the loop is suspended
* `WillResume`: the loop is going to be resumed
Note: the `Resumed` state has been removed since the resumed app is just
running.
Finally, now that `winit` enables this, it extends the `WinitPlugin` to
support custom events.
## Test platforms
- [x] Windows
- [x] MacOs
- [x] Linux (x11)
- [x] Linux (Wayland)
- [x] Android
- [x] iOS
- [x] WASM/WebGPU
- [x] WASM/WebGL2
## Outstanding issues / regressions
- [ ] iOS: build failed in CI
- blocking, but may just be flakiness
- [x] Cross-platform: when the window is maximised, changes in the scale
factor don't apply, to make them apply one has to make the window
smaller again. (Re-maximising keeps the updated scale factor)
- non-blocking, but good to fix
- [ ] Android: it's pretty easy to quickly open and close the app and
then the music keeps playing when suspended.
- non-blocking but worrying
- [ ] Web: the application will hang when switching tabs
- Not new, duplicate of https://github.com/bevyengine/bevy/issues/13486
- [ ] Cross-platform?: Screenshot failure, `ERROR present_frames:
wgpu_core::present: No work has been submitted for this frame before`
taking the first screenshot, but after pressing space
- non-blocking, but good to fix
---------
Co-authored-by: François <francois.mockers@vleue.com>
2024-06-03 13:06:48 +00:00
|
|
|
AppLifecycle, CursorEntered, CursorLeft, CursorMoved, FileDragAndDrop, Ime, ReceivedCharacter,
|
|
|
|
RequestRedraw, WindowBackendScaleFactorChanged, WindowCloseRequested, WindowCreated,
|
|
|
|
WindowDestroyed, WindowFocused, WindowMoved, WindowOccluded, WindowResized,
|
2024-03-03 23:51:53 +00:00
|
|
|
WindowScaleFactorChanged, WindowThemeChanged,
|
|
|
|
};
|
|
|
|
|
|
|
|
/// Wraps all `bevy_window` events in a common enum.
|
|
|
|
///
|
|
|
|
/// Read these events with `EventReader<WinitEvent>` if you need to
|
|
|
|
/// access window events in the order they were received from `winit`.
|
|
|
|
/// Otherwise, the event types are individually readable with
|
|
|
|
/// `EventReader<E>` (e.g. `EventReader<KeyboardInput>`).
|
|
|
|
#[derive(Event, Debug, Clone, PartialEq, Reflect)]
|
|
|
|
#[reflect(Debug, PartialEq)]
|
|
|
|
#[cfg_attr(
|
|
|
|
feature = "serialize",
|
|
|
|
derive(serde::Serialize, serde::Deserialize),
|
|
|
|
reflect(Serialize, Deserialize)
|
|
|
|
)]
|
|
|
|
pub enum WinitEvent {
|
fix: upgrade to winit v0.30 (#13366)
# Objective
- Upgrade winit to v0.30
- Fixes https://github.com/bevyengine/bevy/issues/13331
## Solution
This is a rewrite/adaptation of the new trait system described and
implemented in `winit` v0.30.
## Migration Guide
The custom UserEvent is now renamed as WakeUp, used to wake up the loop
if anything happens outside the app (a new
[custom_user_event](https://github.com/bevyengine/bevy/pull/13366/files#diff-2de8c0a8d3028d0059a3d80ae31b2bbc1cde2595ce2d317ea378fe3e0cf6ef2d)
shows this behavior.
The internal `UpdateState` has been removed and replaced internally by
the AppLifecycle. When changed, the AppLifecycle is sent as an event.
The `UpdateMode` now accepts only two values: `Continuous` and
`Reactive`, but the latter exposes 3 new properties to enable reactive
to device, user or window events. The previous `UpdateMode::Reactive` is
now equivalent to `UpdateMode::reactive()`, while
`UpdateMode::ReactiveLowPower` to `UpdateMode::reactive_low_power()`.
The `ApplicationLifecycle` has been renamed as `AppLifecycle`, and now
contains the possible values of the application state inside the event
loop:
* `Idle`: the loop has not started yet
* `Running` (previously called `Started`): the loop is running
* `WillSuspend`: the loop is going to be suspended
* `Suspended`: the loop is suspended
* `WillResume`: the loop is going to be resumed
Note: the `Resumed` state has been removed since the resumed app is just
running.
Finally, now that `winit` enables this, it extends the `WinitPlugin` to
support custom events.
## Test platforms
- [x] Windows
- [x] MacOs
- [x] Linux (x11)
- [x] Linux (Wayland)
- [x] Android
- [x] iOS
- [x] WASM/WebGPU
- [x] WASM/WebGL2
## Outstanding issues / regressions
- [ ] iOS: build failed in CI
- blocking, but may just be flakiness
- [x] Cross-platform: when the window is maximised, changes in the scale
factor don't apply, to make them apply one has to make the window
smaller again. (Re-maximising keeps the updated scale factor)
- non-blocking, but good to fix
- [ ] Android: it's pretty easy to quickly open and close the app and
then the music keeps playing when suspended.
- non-blocking but worrying
- [ ] Web: the application will hang when switching tabs
- Not new, duplicate of https://github.com/bevyengine/bevy/issues/13486
- [ ] Cross-platform?: Screenshot failure, `ERROR present_frames:
wgpu_core::present: No work has been submitted for this frame before`
taking the first screenshot, but after pressing space
- non-blocking, but good to fix
---------
Co-authored-by: François <francois.mockers@vleue.com>
2024-06-03 13:06:48 +00:00
|
|
|
AppLifecycle(AppLifecycle),
|
2024-03-03 23:51:53 +00:00
|
|
|
CursorEntered(CursorEntered),
|
|
|
|
CursorLeft(CursorLeft),
|
|
|
|
CursorMoved(CursorMoved),
|
|
|
|
FileDragAndDrop(FileDragAndDrop),
|
|
|
|
Ime(Ime),
|
|
|
|
ReceivedCharacter(ReceivedCharacter),
|
|
|
|
RequestRedraw(RequestRedraw),
|
|
|
|
WindowBackendScaleFactorChanged(WindowBackendScaleFactorChanged),
|
|
|
|
WindowCloseRequested(WindowCloseRequested),
|
|
|
|
WindowCreated(WindowCreated),
|
|
|
|
WindowDestroyed(WindowDestroyed),
|
|
|
|
WindowFocused(WindowFocused),
|
|
|
|
WindowMoved(WindowMoved),
|
|
|
|
WindowOccluded(WindowOccluded),
|
|
|
|
WindowResized(WindowResized),
|
|
|
|
WindowScaleFactorChanged(WindowScaleFactorChanged),
|
|
|
|
WindowThemeChanged(WindowThemeChanged),
|
|
|
|
|
|
|
|
MouseButtonInput(MouseButtonInput),
|
|
|
|
MouseMotion(MouseMotion),
|
|
|
|
MouseWheel(MouseWheel),
|
|
|
|
|
2024-06-04 12:44:25 +00:00
|
|
|
PinchGesture(PinchGesture),
|
|
|
|
RotationGesture(RotationGesture),
|
|
|
|
DoubleTapGesture(DoubleTapGesture),
|
|
|
|
PanGesture(PanGesture),
|
2024-03-03 23:51:53 +00:00
|
|
|
|
|
|
|
TouchInput(TouchInput),
|
|
|
|
|
|
|
|
KeyboardInput(KeyboardInput),
|
flush key_input cache when Bevy loses focus (Adopted) (#13678)
This was adopted from #12878. I rebased the changes resolved the
following merge conflicts:
- moved over the changes originally done in bevy_winit/src/lib.rs's
`handle_winit_event` into bevy_winit/src/state.rs's `window_event`
function
- moved WinitEvent::KeyboardFocusLost event forwarding originally done
in bevy_winit/src/winit_event.rs to the equivalent in
bevy_winit/src/state.rs
Tested this by following the modified keyboard_input example from the
original PR.
First, I verified I could reproduce the issue without the changes. Then,
after applying the changes, I verified that when I Alt+Tabbed away from
the running example that the log showed I released Alt and when I tabbed
back it didn't behave like Alt was stuck.
The following is from the original pull request by @gavlig
# Objective
This helps avoiding stuck key presses after switching from and back to
Bevy window. Key press event gets stuck because window loses focus
before receiving a key release event thus we end up with false positive
in ButtonInput.
## Solution
I saw two ways to fix this:
1. add bevy_window as dependency and read WindowFocus events
2. add a KeyboardFocusLost event specifically for this.
I chose the latter because adding another dependency felt wrong, but if
that is more preferable changing this pr won't be a problem. Also if
someone sees another way please let me know.
To test the bug use this small modification over
examples/keyboard_input.rs: (it will work only if you have Alt-Tab
combination for switching between windows in your OS, otherwise change
AltLeft accordingly)
```
//! Demonstrates handling a key press/release.
use bevy::{prelude::*, input::keyboard::KeyboardInput};
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_systems(Update, keyboard_input_system)
.run();
}
/// This system prints 'Alt' key state
fn keyboard_input_system(keyboard_input: Res<ButtonInput<KeyCode>>, mut
keyboard_input_events: EventReader<KeyboardInput>) {
for event in keyboard_input_events.read() {
info!("{:?}", event);
}
if keyboard_input.pressed(KeyCode::AltLeft) {
info!("'Alt' currently pressed");
}
if keyboard_input.just_pressed(KeyCode::AltLeft) {
info!("'Alt' just pressed");
}
if keyboard_input.just_released(KeyCode::AltLeft) {
info!("'Alt' just released");
}
}
```
Here i made a quick video with demo of the fix:
https://youtu.be/qTvUCk4IHvo In first part i press Alt and Alt+Tab to
switch back and forth from example app, logs will indicate that too. In
second part I applied fix and you'll see that Alt will no longer be
pressed when window gets unfocused
## Migration Guide
`WinitEvent` has a new enum variant: `WinitEvent::KeyboardFocusLost`.
Co-authored-by: gavlig <gavlig@gmail.com>
2024-06-05 02:06:47 +00:00
|
|
|
KeyboardFocusLost(KeyboardFocusLost),
|
2024-03-03 23:51:53 +00:00
|
|
|
}
|
|
|
|
|
fix: upgrade to winit v0.30 (#13366)
# Objective
- Upgrade winit to v0.30
- Fixes https://github.com/bevyengine/bevy/issues/13331
## Solution
This is a rewrite/adaptation of the new trait system described and
implemented in `winit` v0.30.
## Migration Guide
The custom UserEvent is now renamed as WakeUp, used to wake up the loop
if anything happens outside the app (a new
[custom_user_event](https://github.com/bevyengine/bevy/pull/13366/files#diff-2de8c0a8d3028d0059a3d80ae31b2bbc1cde2595ce2d317ea378fe3e0cf6ef2d)
shows this behavior.
The internal `UpdateState` has been removed and replaced internally by
the AppLifecycle. When changed, the AppLifecycle is sent as an event.
The `UpdateMode` now accepts only two values: `Continuous` and
`Reactive`, but the latter exposes 3 new properties to enable reactive
to device, user or window events. The previous `UpdateMode::Reactive` is
now equivalent to `UpdateMode::reactive()`, while
`UpdateMode::ReactiveLowPower` to `UpdateMode::reactive_low_power()`.
The `ApplicationLifecycle` has been renamed as `AppLifecycle`, and now
contains the possible values of the application state inside the event
loop:
* `Idle`: the loop has not started yet
* `Running` (previously called `Started`): the loop is running
* `WillSuspend`: the loop is going to be suspended
* `Suspended`: the loop is suspended
* `WillResume`: the loop is going to be resumed
Note: the `Resumed` state has been removed since the resumed app is just
running.
Finally, now that `winit` enables this, it extends the `WinitPlugin` to
support custom events.
## Test platforms
- [x] Windows
- [x] MacOs
- [x] Linux (x11)
- [x] Linux (Wayland)
- [x] Android
- [x] iOS
- [x] WASM/WebGPU
- [x] WASM/WebGL2
## Outstanding issues / regressions
- [ ] iOS: build failed in CI
- blocking, but may just be flakiness
- [x] Cross-platform: when the window is maximised, changes in the scale
factor don't apply, to make them apply one has to make the window
smaller again. (Re-maximising keeps the updated scale factor)
- non-blocking, but good to fix
- [ ] Android: it's pretty easy to quickly open and close the app and
then the music keeps playing when suspended.
- non-blocking but worrying
- [ ] Web: the application will hang when switching tabs
- Not new, duplicate of https://github.com/bevyengine/bevy/issues/13486
- [ ] Cross-platform?: Screenshot failure, `ERROR present_frames:
wgpu_core::present: No work has been submitted for this frame before`
taking the first screenshot, but after pressing space
- non-blocking, but good to fix
---------
Co-authored-by: François <francois.mockers@vleue.com>
2024-06-03 13:06:48 +00:00
|
|
|
impl From<AppLifecycle> for WinitEvent {
|
|
|
|
fn from(e: AppLifecycle) -> Self {
|
|
|
|
Self::AppLifecycle(e)
|
2024-03-03 23:51:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<CursorEntered> for WinitEvent {
|
|
|
|
fn from(e: CursorEntered) -> Self {
|
|
|
|
Self::CursorEntered(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<CursorLeft> for WinitEvent {
|
|
|
|
fn from(e: CursorLeft) -> Self {
|
|
|
|
Self::CursorLeft(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<CursorMoved> for WinitEvent {
|
|
|
|
fn from(e: CursorMoved) -> Self {
|
|
|
|
Self::CursorMoved(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<FileDragAndDrop> for WinitEvent {
|
|
|
|
fn from(e: FileDragAndDrop) -> Self {
|
|
|
|
Self::FileDragAndDrop(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<Ime> for WinitEvent {
|
|
|
|
fn from(e: Ime) -> Self {
|
|
|
|
Self::Ime(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<ReceivedCharacter> for WinitEvent {
|
|
|
|
fn from(e: ReceivedCharacter) -> Self {
|
|
|
|
Self::ReceivedCharacter(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<RequestRedraw> for WinitEvent {
|
|
|
|
fn from(e: RequestRedraw) -> Self {
|
|
|
|
Self::RequestRedraw(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<WindowBackendScaleFactorChanged> for WinitEvent {
|
|
|
|
fn from(e: WindowBackendScaleFactorChanged) -> Self {
|
|
|
|
Self::WindowBackendScaleFactorChanged(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<WindowCloseRequested> for WinitEvent {
|
|
|
|
fn from(e: WindowCloseRequested) -> Self {
|
|
|
|
Self::WindowCloseRequested(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<WindowCreated> for WinitEvent {
|
|
|
|
fn from(e: WindowCreated) -> Self {
|
|
|
|
Self::WindowCreated(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<WindowDestroyed> for WinitEvent {
|
|
|
|
fn from(e: WindowDestroyed) -> Self {
|
|
|
|
Self::WindowDestroyed(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<WindowFocused> for WinitEvent {
|
|
|
|
fn from(e: WindowFocused) -> Self {
|
|
|
|
Self::WindowFocused(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<WindowMoved> for WinitEvent {
|
|
|
|
fn from(e: WindowMoved) -> Self {
|
|
|
|
Self::WindowMoved(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<WindowOccluded> for WinitEvent {
|
|
|
|
fn from(e: WindowOccluded) -> Self {
|
|
|
|
Self::WindowOccluded(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<WindowResized> for WinitEvent {
|
|
|
|
fn from(e: WindowResized) -> Self {
|
|
|
|
Self::WindowResized(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<WindowScaleFactorChanged> for WinitEvent {
|
|
|
|
fn from(e: WindowScaleFactorChanged) -> Self {
|
|
|
|
Self::WindowScaleFactorChanged(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<WindowThemeChanged> for WinitEvent {
|
|
|
|
fn from(e: WindowThemeChanged) -> Self {
|
|
|
|
Self::WindowThemeChanged(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<MouseButtonInput> for WinitEvent {
|
|
|
|
fn from(e: MouseButtonInput) -> Self {
|
|
|
|
Self::MouseButtonInput(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<MouseMotion> for WinitEvent {
|
|
|
|
fn from(e: MouseMotion) -> Self {
|
|
|
|
Self::MouseMotion(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<MouseWheel> for WinitEvent {
|
|
|
|
fn from(e: MouseWheel) -> Self {
|
|
|
|
Self::MouseWheel(e)
|
|
|
|
}
|
|
|
|
}
|
2024-06-04 12:44:25 +00:00
|
|
|
impl From<PinchGesture> for WinitEvent {
|
|
|
|
fn from(e: PinchGesture) -> Self {
|
|
|
|
Self::PinchGesture(e)
|
2024-03-03 23:51:53 +00:00
|
|
|
}
|
|
|
|
}
|
2024-06-04 12:44:25 +00:00
|
|
|
impl From<RotationGesture> for WinitEvent {
|
|
|
|
fn from(e: RotationGesture) -> Self {
|
|
|
|
Self::RotationGesture(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<DoubleTapGesture> for WinitEvent {
|
|
|
|
fn from(e: DoubleTapGesture) -> Self {
|
|
|
|
Self::DoubleTapGesture(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<PanGesture> for WinitEvent {
|
|
|
|
fn from(e: PanGesture) -> Self {
|
|
|
|
Self::PanGesture(e)
|
2024-03-03 23:51:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<TouchInput> for WinitEvent {
|
|
|
|
fn from(e: TouchInput) -> Self {
|
|
|
|
Self::TouchInput(e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl From<KeyboardInput> for WinitEvent {
|
|
|
|
fn from(e: KeyboardInput) -> Self {
|
|
|
|
Self::KeyboardInput(e)
|
|
|
|
}
|
|
|
|
}
|
flush key_input cache when Bevy loses focus (Adopted) (#13678)
This was adopted from #12878. I rebased the changes resolved the
following merge conflicts:
- moved over the changes originally done in bevy_winit/src/lib.rs's
`handle_winit_event` into bevy_winit/src/state.rs's `window_event`
function
- moved WinitEvent::KeyboardFocusLost event forwarding originally done
in bevy_winit/src/winit_event.rs to the equivalent in
bevy_winit/src/state.rs
Tested this by following the modified keyboard_input example from the
original PR.
First, I verified I could reproduce the issue without the changes. Then,
after applying the changes, I verified that when I Alt+Tabbed away from
the running example that the log showed I released Alt and when I tabbed
back it didn't behave like Alt was stuck.
The following is from the original pull request by @gavlig
# Objective
This helps avoiding stuck key presses after switching from and back to
Bevy window. Key press event gets stuck because window loses focus
before receiving a key release event thus we end up with false positive
in ButtonInput.
## Solution
I saw two ways to fix this:
1. add bevy_window as dependency and read WindowFocus events
2. add a KeyboardFocusLost event specifically for this.
I chose the latter because adding another dependency felt wrong, but if
that is more preferable changing this pr won't be a problem. Also if
someone sees another way please let me know.
To test the bug use this small modification over
examples/keyboard_input.rs: (it will work only if you have Alt-Tab
combination for switching between windows in your OS, otherwise change
AltLeft accordingly)
```
//! Demonstrates handling a key press/release.
use bevy::{prelude::*, input::keyboard::KeyboardInput};
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.add_systems(Update, keyboard_input_system)
.run();
}
/// This system prints 'Alt' key state
fn keyboard_input_system(keyboard_input: Res<ButtonInput<KeyCode>>, mut
keyboard_input_events: EventReader<KeyboardInput>) {
for event in keyboard_input_events.read() {
info!("{:?}", event);
}
if keyboard_input.pressed(KeyCode::AltLeft) {
info!("'Alt' currently pressed");
}
if keyboard_input.just_pressed(KeyCode::AltLeft) {
info!("'Alt' just pressed");
}
if keyboard_input.just_released(KeyCode::AltLeft) {
info!("'Alt' just released");
}
}
```
Here i made a quick video with demo of the fix:
https://youtu.be/qTvUCk4IHvo In first part i press Alt and Alt+Tab to
switch back and forth from example app, logs will indicate that too. In
second part I applied fix and you'll see that Alt will no longer be
pressed when window gets unfocused
## Migration Guide
`WinitEvent` has a new enum variant: `WinitEvent::KeyboardFocusLost`.
Co-authored-by: gavlig <gavlig@gmail.com>
2024-06-05 02:06:47 +00:00
|
|
|
impl From<KeyboardFocusLost> for WinitEvent {
|
|
|
|
fn from(e: KeyboardFocusLost) -> Self {
|
|
|
|
Self::KeyboardFocusLost(e)
|
|
|
|
}
|
|
|
|
}
|