056f12236e
# Objective - Fixes #5083 ## Solution I looked at the implementation of those events. I noticed that they both are adaptations of `winit`'s `DeviceEvent`/`WindowEvent` enum variants. Therefore I based the description of the items on the documentation provided by the upstream crate. I also added a link to `CursorMoved`, just like `MouseMotion` already has. ## Observations - Looking at the implementation of `MouseMotion`, I noticed the `DeviceId` field of the `winit` event is discarded by `bevy_input`. This means that in the case a machine has multiple pointing devices, it is impossible to distinguish to which one the event is referring to. **EDIT:** just tested, `MouseMotion` events are emitted for movement of both mice.
110 lines
3.8 KiB
Rust
110 lines
3.8 KiB
Rust
use crate::{ButtonState, Input};
|
|
use bevy_ecs::{event::EventReader, system::ResMut};
|
|
use bevy_math::Vec2;
|
|
|
|
/// A mouse button input event.
|
|
///
|
|
/// This event is the translated version of the `WindowEvent::MouseInput` from the `winit` crate.
|
|
///
|
|
/// ## Usage
|
|
///
|
|
/// The event is read inside of the [`mouse_button_input_system`](crate::mouse::mouse_button_input_system)
|
|
/// to update the [`Input<MouseButton>`](crate::Input<MouseButton>) resource.
|
|
#[derive(Debug, Clone)]
|
|
pub struct MouseButtonInput {
|
|
/// The mouse button assigned to the event.
|
|
pub button: MouseButton,
|
|
/// The pressed state of the button.
|
|
pub state: ButtonState,
|
|
}
|
|
|
|
/// A button on a mouse device.
|
|
///
|
|
/// ## Usage
|
|
///
|
|
/// It is used as the generic `T` value of an [`Input`](crate::Input) to create a `bevy`
|
|
/// resource.
|
|
///
|
|
/// ## Updating
|
|
///
|
|
/// The resource is updated inside of the [`mouse_button_input_system`](crate::mouse::mouse_button_input_system).
|
|
#[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
|
|
pub enum MouseButton {
|
|
/// The left mouse button.
|
|
Left,
|
|
/// The right mouse button.
|
|
Right,
|
|
/// The middle mouse button.
|
|
Middle,
|
|
/// Another mouse button with the associated number.
|
|
Other(u16),
|
|
}
|
|
|
|
/// An event reporting the change in physical position of a pointing device.
|
|
///
|
|
/// This represents raw, unfiltered physical motion.
|
|
/// It is the translated version of [`DeviceEvent::MouseMotion`] from the `winit` crate.
|
|
///
|
|
/// All pointing devices connected to a single machine at the same time can emit the event independently.
|
|
/// However, the event data does not make it possible to distinguish which device it is referring to.
|
|
///
|
|
/// [`DeviceEvent::MouseMotion`]: https://docs.rs/winit/latest/winit/event/enum.DeviceEvent.html#variant.MouseMotion
|
|
#[derive(Debug, Clone)]
|
|
pub struct MouseMotion {
|
|
/// The change in the position of the pointing device since the last event was sent.
|
|
pub delta: Vec2,
|
|
}
|
|
|
|
/// The scroll unit.
|
|
///
|
|
/// Describes how a value of a [`MouseWheel`](crate::mouse::MouseWheel) event has to be interpreted.
|
|
///
|
|
/// The value of the event can either be interpreted as the amount of lines or the amount of pixels
|
|
/// to scroll.
|
|
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
|
|
pub enum MouseScrollUnit {
|
|
/// The line scroll unit.
|
|
///
|
|
/// The delta of the associated [`MouseWheel`](crate::mouse::MouseWheel) event corresponds
|
|
/// to the amount of lines or rows to scroll.
|
|
Line,
|
|
/// The pixel scroll unit.
|
|
///
|
|
/// The delta of the associated [`MouseWheel`](crate::mouse::MouseWheel) event corresponds
|
|
/// to the amount of pixels to scroll.
|
|
Pixel,
|
|
}
|
|
|
|
/// A mouse wheel event.
|
|
///
|
|
/// This event is the translated version of the `WindowEvent::MouseWheel` from the `winit` crate.
|
|
#[derive(Debug, Clone)]
|
|
pub struct MouseWheel {
|
|
/// The mouse scroll unit.
|
|
pub unit: MouseScrollUnit,
|
|
/// The horizontal scroll value.
|
|
pub x: f32,
|
|
/// The vertical scroll value.
|
|
pub y: f32,
|
|
}
|
|
|
|
/// Updates the [`Input<MouseButton>`] resource with the latest [`MouseButtonInput`] events.
|
|
///
|
|
/// ## Differences
|
|
///
|
|
/// The main difference between the [`MouseButtonInput`] event and the [`Input<MouseButton>`] resource is that
|
|
/// the latter has convenient functions like [`Input::pressed`], [`Input::just_pressed`] and [`Input::just_released`].
|
|
pub fn mouse_button_input_system(
|
|
mut mouse_button_input: ResMut<Input<MouseButton>>,
|
|
mut mouse_button_input_events: EventReader<MouseButtonInput>,
|
|
) {
|
|
mouse_button_input.clear();
|
|
for event in mouse_button_input_events.iter() {
|
|
match event.state {
|
|
ButtonState::Pressed => mouse_button_input.press(event.button),
|
|
ButtonState::Released => mouse_button_input.release(event.button),
|
|
}
|
|
}
|
|
}
|