sim_logic/platform/desktop/
pointer.rs1use std::{error::Error, fmt};
4
5use sim_engine::{
6 LogicalScreenPosition, LogicalViewport, LogicalViewportError, RendererPresentMode,
7 WgpuRendererOptions,
8};
9use winit::{
10 dpi::{PhysicalPosition, PhysicalSize},
11 event::{MouseButton as PlatformMouseButton, MouseScrollDelta},
12};
13
14use crate::input::{InputEvent, MouseButton, PointerSample, ScrollDelta, ScrollDeltaError};
15
16#[derive(Debug, Clone, Copy, PartialEq)]
21pub enum DesktopPointerError {
22 Scroll(ScrollDeltaError),
24 RelativeMotion(crate::input::RelativePointerMotionError),
26 InvalidScaleFactor {
28 scale_factor: f64,
30 },
31 InvalidPosition {
34 x: f64,
36 y: f64,
38 scale_factor: f64,
40 },
41 LogicalViewport(LogicalViewportError),
43}
44
45impl fmt::Display for DesktopPointerError {
46 fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
47 match self {
48 Self::Scroll(error) => write!(formatter, "invalid pointer wheel displacement: {error}"),
49 Self::RelativeMotion(error) => {
50 write!(formatter, "invalid relative pointer motion: {error}")
51 }
52 Self::InvalidScaleFactor { scale_factor } => {
53 write!(formatter, "invalid pointer display scale {scale_factor}")
54 }
55 Self::InvalidPosition { x, y, scale_factor } => write!(
56 formatter,
57 "physical pointer ({x}, {y}) cannot form finite logical coordinates at scale {scale_factor}"
58 ),
59 Self::LogicalViewport(error) => write!(formatter, "pointer viewport failed: {error}"),
60 }
61 }
62}
63
64impl Error for DesktopPointerError {
65 fn source(&self) -> Option<&(dyn Error + 'static)> {
66 match self {
67 Self::Scroll(error) => Some(error),
68 Self::RelativeMotion(error) => Some(error),
69 Self::LogicalViewport(error) => Some(error),
70 Self::InvalidScaleFactor { .. } | Self::InvalidPosition { .. } => None,
71 }
72 }
73}
74
75#[derive(Debug, Clone, Copy, PartialEq)]
76pub(super) struct DesktopPointerGeometry {
77 physical_size: PhysicalSize<u32>,
78 scale_factor: f64,
79 physical_cursor: Option<PhysicalPosition<f64>>,
80}
81
82impl DesktopPointerGeometry {
83 pub(super) const fn empty() -> Self {
84 Self {
85 physical_size: PhysicalSize::new(0, 0),
86 scale_factor: 1.0,
87 physical_cursor: None,
88 }
89 }
90
91 pub(super) fn new(
92 physical_size: PhysicalSize<u32>,
93 scale_factor: f64,
94 ) -> Result<Self, DesktopPointerError> {
95 validate_scale_factor(scale_factor)?;
96 let geometry = Self {
97 physical_size,
98 scale_factor,
99 physical_cursor: None,
100 };
101 geometry.logical_viewport()?;
102 Ok(geometry)
103 }
104
105 pub(super) const fn physical_size(self) -> PhysicalSize<u32> {
106 self.physical_size
107 }
108
109 pub(super) const fn scale_factor(self) -> f64 {
110 self.scale_factor
111 }
112
113 pub(super) fn cursor_moved(
114 &mut self,
115 position: PhysicalPosition<f64>,
116 ) -> Result<InputEvent, DesktopPointerError> {
117 let logical_position = self.logical_position(position)?;
118 let Some(viewport) = self.logical_viewport()? else {
119 return Ok(self.cursor_left());
120 };
121 let sample = PointerSample::new(logical_position, viewport)
122 .map_err(|_| self.position_error(position))?;
123 self.physical_cursor = Some(position);
124 Ok(InputEvent::pointer_moved(sample))
125 }
126
127 pub(super) fn cursor_left(&mut self) -> InputEvent {
128 self.physical_cursor = None;
129 InputEvent::PointerLeft
130 }
131
132 pub(super) fn mouse_wheel(
133 self,
134 delta: MouseScrollDelta,
135 ) -> Result<InputEvent, DesktopPointerError> {
136 let delta = match delta {
137 MouseScrollDelta::LineDelta(x, y) => ScrollDelta::lines(f64::from(x), f64::from(y)),
138 MouseScrollDelta::PixelDelta(position) => ScrollDelta::pixels(
139 position.x / self.scale_factor,
140 position.y / self.scale_factor,
141 ),
142 }
143 .map_err(DesktopPointerError::Scroll)?;
144 Ok(InputEvent::mouse_wheel(delta))
145 }
146
147 pub(super) fn resized(
148 &mut self,
149 physical_size: PhysicalSize<u32>,
150 ) -> Result<Option<InputEvent>, DesktopPointerError> {
151 self.replace_geometry(Self {
152 physical_size,
153 ..*self
154 })
155 }
156
157 pub(super) fn scale_factor_changed(
158 &mut self,
159 scale_factor: f64,
160 ) -> Result<Option<InputEvent>, DesktopPointerError> {
161 validate_scale_factor(scale_factor)?;
162 self.replace_geometry(Self {
163 scale_factor,
164 ..*self
165 })
166 }
167
168 fn replace_geometry(
169 &mut self,
170 mut next: Self,
171 ) -> Result<Option<InputEvent>, DesktopPointerError> {
172 let event = if next.logical_viewport()?.is_none() {
173 Some(next.cursor_left())
174 } else if let Some(position) = next.physical_cursor {
175 Some(next.cursor_moved(position)?)
176 } else {
177 None
178 };
179 *self = next;
181 Ok(event)
182 }
183
184 fn logical_viewport(self) -> Result<Option<LogicalViewport>, DesktopPointerError> {
185 if super::extent_is_occluded(self.physical_size.width, self.physical_size.height) {
186 return Ok(None);
187 }
188 let scale_factor = self.scale_factor as f32;
191 LogicalViewport::new(
192 self.physical_size.width as f32 / scale_factor,
193 self.physical_size.height as f32 / scale_factor,
194 )
195 .map(Some)
196 .map_err(DesktopPointerError::LogicalViewport)
197 }
198
199 fn logical_position(
200 self,
201 position: PhysicalPosition<f64>,
202 ) -> Result<LogicalScreenPosition, DesktopPointerError> {
203 let logical = LogicalScreenPosition::new(
204 (position.x / self.scale_factor) as f32,
205 (position.y / self.scale_factor) as f32,
206 );
207 if !position.x.is_finite() || !position.y.is_finite() || !logical.is_finite() {
208 return Err(self.position_error(position));
209 }
210 Ok(logical)
211 }
212
213 const fn position_error(self, position: PhysicalPosition<f64>) -> DesktopPointerError {
214 DesktopPointerError::InvalidPosition {
215 x: position.x,
216 y: position.y,
217 scale_factor: self.scale_factor,
218 }
219 }
220}
221
222fn validate_scale_factor(scale_factor: f64) -> Result<(), DesktopPointerError> {
223 WgpuRendererOptions::new(RendererPresentMode::Vsync, scale_factor)
225 .map(|_| ())
226 .map_err(|_| DesktopPointerError::InvalidScaleFactor { scale_factor })
227}
228
229pub(super) const fn map_mouse_button(button: PlatformMouseButton) -> Option<MouseButton> {
230 match button {
231 PlatformMouseButton::Left => Some(MouseButton::Left),
232 PlatformMouseButton::Right => Some(MouseButton::Right),
233 PlatformMouseButton::Middle => Some(MouseButton::Middle),
234 PlatformMouseButton::Back
235 | PlatformMouseButton::Forward
236 | PlatformMouseButton::Other(_) => None,
237 }
238}