use std::{error::Error, fmt};
use sim_engine::{
LogicalScreenPosition, LogicalViewport, LogicalViewportError, RendererPresentMode,
WgpuRendererOptions,
};
use winit::{
dpi::{PhysicalPosition, PhysicalSize},
event::{MouseButton as PlatformMouseButton, MouseScrollDelta},
};
use crate::input::{InputEvent, MouseButton, PointerSample, ScrollDelta, ScrollDeltaError};
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum DesktopPointerError {
Scroll(ScrollDeltaError),
RelativeMotion(crate::input::RelativePointerMotionError),
InvalidScaleFactor {
scale_factor: f64,
},
InvalidPosition {
x: f64,
y: f64,
scale_factor: f64,
},
LogicalViewport(LogicalViewportError),
}
impl fmt::Display for DesktopPointerError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Scroll(error) => write!(formatter, "invalid pointer wheel displacement: {error}"),
Self::RelativeMotion(error) => {
write!(formatter, "invalid relative pointer motion: {error}")
}
Self::InvalidScaleFactor { scale_factor } => {
write!(formatter, "invalid pointer display scale {scale_factor}")
}
Self::InvalidPosition { x, y, scale_factor } => write!(
formatter,
"physical pointer ({x}, {y}) cannot form finite logical coordinates at scale {scale_factor}"
),
Self::LogicalViewport(error) => write!(formatter, "pointer viewport failed: {error}"),
}
}
}
impl Error for DesktopPointerError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::Scroll(error) => Some(error),
Self::RelativeMotion(error) => Some(error),
Self::LogicalViewport(error) => Some(error),
Self::InvalidScaleFactor { .. } | Self::InvalidPosition { .. } => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(super) struct DesktopPointerGeometry {
physical_size: PhysicalSize<u32>,
scale_factor: f64,
physical_cursor: Option<PhysicalPosition<f64>>,
}
impl DesktopPointerGeometry {
pub(super) const fn empty() -> Self {
Self {
physical_size: PhysicalSize::new(0, 0),
scale_factor: 1.0,
physical_cursor: None,
}
}
pub(super) fn new(
physical_size: PhysicalSize<u32>,
scale_factor: f64,
) -> Result<Self, DesktopPointerError> {
validate_scale_factor(scale_factor)?;
let geometry = Self {
physical_size,
scale_factor,
physical_cursor: None,
};
geometry.logical_viewport()?;
Ok(geometry)
}
pub(super) const fn physical_size(self) -> PhysicalSize<u32> {
self.physical_size
}
pub(super) const fn scale_factor(self) -> f64 {
self.scale_factor
}
pub(super) fn cursor_moved(
&mut self,
position: PhysicalPosition<f64>,
) -> Result<InputEvent, DesktopPointerError> {
let logical_position = self.logical_position(position)?;
let Some(viewport) = self.logical_viewport()? else {
return Ok(self.cursor_left());
};
let sample = PointerSample::new(logical_position, viewport)
.map_err(|_| self.position_error(position))?;
self.physical_cursor = Some(position);
Ok(InputEvent::pointer_moved(sample))
}
pub(super) fn cursor_left(&mut self) -> InputEvent {
self.physical_cursor = None;
InputEvent::PointerLeft
}
pub(super) fn mouse_wheel(
self,
delta: MouseScrollDelta,
) -> Result<InputEvent, DesktopPointerError> {
let delta = match delta {
MouseScrollDelta::LineDelta(x, y) => ScrollDelta::lines(f64::from(x), f64::from(y)),
MouseScrollDelta::PixelDelta(position) => ScrollDelta::pixels(
position.x / self.scale_factor,
position.y / self.scale_factor,
),
}
.map_err(DesktopPointerError::Scroll)?;
Ok(InputEvent::mouse_wheel(delta))
}
pub(super) fn resized(
&mut self,
physical_size: PhysicalSize<u32>,
) -> Result<Option<InputEvent>, DesktopPointerError> {
self.replace_geometry(Self {
physical_size,
..*self
})
}
pub(super) fn scale_factor_changed(
&mut self,
scale_factor: f64,
) -> Result<Option<InputEvent>, DesktopPointerError> {
validate_scale_factor(scale_factor)?;
self.replace_geometry(Self {
scale_factor,
..*self
})
}
fn replace_geometry(
&mut self,
mut next: Self,
) -> Result<Option<InputEvent>, DesktopPointerError> {
let event = if next.logical_viewport()?.is_none() {
Some(next.cursor_left())
} else if let Some(position) = next.physical_cursor {
Some(next.cursor_moved(position)?)
} else {
None
};
*self = next;
Ok(event)
}
fn logical_viewport(self) -> Result<Option<LogicalViewport>, DesktopPointerError> {
if super::extent_is_occluded(self.physical_size.width, self.physical_size.height) {
return Ok(None);
}
let scale_factor = self.scale_factor as f32;
LogicalViewport::new(
self.physical_size.width as f32 / scale_factor,
self.physical_size.height as f32 / scale_factor,
)
.map(Some)
.map_err(DesktopPointerError::LogicalViewport)
}
fn logical_position(
self,
position: PhysicalPosition<f64>,
) -> Result<LogicalScreenPosition, DesktopPointerError> {
let logical = LogicalScreenPosition::new(
(position.x / self.scale_factor) as f32,
(position.y / self.scale_factor) as f32,
);
if !position.x.is_finite() || !position.y.is_finite() || !logical.is_finite() {
return Err(self.position_error(position));
}
Ok(logical)
}
const fn position_error(self, position: PhysicalPosition<f64>) -> DesktopPointerError {
DesktopPointerError::InvalidPosition {
x: position.x,
y: position.y,
scale_factor: self.scale_factor,
}
}
}
fn validate_scale_factor(scale_factor: f64) -> Result<(), DesktopPointerError> {
WgpuRendererOptions::new(RendererPresentMode::Vsync, scale_factor)
.map(|_| ())
.map_err(|_| DesktopPointerError::InvalidScaleFactor { scale_factor })
}
pub(super) const fn map_mouse_button(button: PlatformMouseButton) -> Option<MouseButton> {
match button {
PlatformMouseButton::Left => Some(MouseButton::Left),
PlatformMouseButton::Right => Some(MouseButton::Right),
PlatformMouseButton::Middle => Some(MouseButton::Middle),
PlatformMouseButton::Back
| PlatformMouseButton::Forward
| PlatformMouseButton::Other(_) => None,
}
}