Skip to main content

sim_logic/platform/desktop/
pointer.rs

1//! Event-ordered desktop geometry, independent from live window queries.
2
3use 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/// Invalid desktop geometry encountered before collecting a pointer sample.
17///
18/// The adapter reports this through [`super::DesktopRunError::Pointer`] and
19/// stops before the invalid geometry reaches a logical frame.
20#[derive(Debug, Clone, Copy, PartialEq)]
21pub enum DesktopPointerError {
22    /// A line or converted logical-pixel wheel displacement exceeded its bounds.
23    Scroll(ScrollDeltaError),
24    /// Raw relative motion or its coalesced displacement exceeded its bounds.
25    RelativeMotion(crate::input::RelativePointerMotionError),
26    /// The display scale cannot support Sim;Engine's logical pixel conversion.
27    InvalidScaleFactor {
28        /// Rejected physical pixels per logical pixel.
29        scale_factor: f64,
30    },
31    /// A physical cursor position was non-finite or its logical coordinates
32    /// could not be represented as finite `f32` values.
33    InvalidPosition {
34        /// Rejected horizontal coordinate in physical pixels.
35        x: f64,
36        /// Rejected vertical coordinate in physical pixels.
37        y: f64,
38        /// Event-time physical pixels per logical pixel.
39        scale_factor: f64,
40    },
41    /// A nonzero physical extent could not form positive finite logical dimensions.
42    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        // A failed conversion leaves both geometry and the known cursor intact.
180        *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        // Match the renderer's f32 viewport arithmetic while retaining the
189        // original physical extent and scale for later delivered events.
190        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    // Reuse Engine's supported conversion range without creating a renderer.
224    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}