alex/beta-minecraft-rust

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use raw_window_handle::{HasDisplayHandle, HasWindowHandle, RawDisplayHandle, RawWindowHandle};
use wayland_client::backend::{Backend, InvalidId, ObjectId, WaylandError};
use wayland_client::globals::{GlobalError, GlobalListContents, registry_queue_init};
use wayland_client::protocol::wl_pointer::{self, WlPointer};
use wayland_client::protocol::wl_registry::{self, WlRegistry};
use wayland_client::protocol::wl_seat::{self, WlSeat};
use wayland_client::protocol::wl_surface::WlSurface;
use wayland_client::{
    Connection, Dispatch, DispatchError, EventQueue, Proxy, QueueHandle, WEnum, delegate_noop,
};
use wayland_protocols::wp::pointer_warp::v1::client::wp_pointer_warp_v1::WpPointerWarpV1;
use winit::window::Window;

#[derive(Debug, thiserror::Error)]
pub enum WarpError {
    #[error(transparent)]
    Handle(#[from] raw_window_handle::HandleError),
    #[error(transparent)]
    Global(#[from] GlobalError),
    #[error(transparent)]
    Id(#[from] InvalidId),
    #[error(transparent)]
    Dispatch(#[from] DispatchError),
    #[error(transparent)]
    Wayland(#[from] WaylandError),
}

/// Moves the pointer through `wp_pointer_warp_v1` on winit's Wayland connection, using a
/// dedicated `wl_pointer` to learn the enter serial winit keeps private.
pub struct PointerWarp {
    queue: EventQueue<State>,
    state: State,
    manager: WpPointerWarpV1,
    surface: WlSurface,
}

#[derive(Default)]
struct State {
    pointer: Option<WlPointer>,
    serial: Option<u32>,
}

impl PointerWarp {
    /// `None` when not on Wayland or the compositor lacks the protocol.
    pub fn new(window: &Window) -> Result<Option<Self>, WarpError> {
        let (RawDisplayHandle::Wayland(display), RawWindowHandle::Wayland(surface)) = (
            window.display_handle()?.as_raw(),
            window.window_handle()?.as_raw(),
        ) else {
            return Ok(None);
        };
        // Safety: winit keeps the display and surface alive for as long as the window
        let backend = unsafe { Backend::from_foreign_display(display.display.as_ptr().cast()) };
        let connection = Connection::from_backend(backend);
        let surface =
            unsafe { ObjectId::from_ptr(WlSurface::interface(), surface.surface.as_ptr().cast()) }?;
        let surface = WlSurface::from_id(&connection, surface)?;
        let (globals, mut queue) = registry_queue_init::<State>(&connection)?;
        let handle = queue.handle();
        let (Ok(manager), Ok(_)) = (
            globals.bind::<WpPointerWarpV1, _, _>(&handle, 1..=1, ()),
            globals.bind::<WlSeat, _, _>(&handle, 1..=5, ()),
        ) else {
            return Ok(None);
        };
        let mut state = State::default();
        queue.roundtrip(&mut state)?;
        Ok(Some(Self {
            queue,
            state,
            manager,
            surface,
        }))
    }

    /// Warps to a surface-local logical position; `false` while the pointer is outside.
    pub fn warp(&mut self, x: f64, y: f64) -> Result<bool, WarpError> {
        self.queue.dispatch_pending(&mut self.state)?;
        let (Some(pointer), Some(serial)) = (&self.state.pointer, self.state.serial) else {
            return Ok(false);
        };
        self.manager
            .warp_pointer(&self.surface, pointer, x, y, serial);
        self.queue.flush()?;
        Ok(true)
    }
}

impl Dispatch<WlRegistry, GlobalListContents> for State {
    fn event(
        _: &mut Self,
        _: &WlRegistry,
        _: wl_registry::Event,
        _: &GlobalListContents,
        _: &Connection,
        _: &QueueHandle<Self>,
    ) {
    }
}

impl Dispatch<WlSeat, ()> for State {
    fn event(
        state: &mut Self,
        seat: &WlSeat,
        event: wl_seat::Event,
        _: &(),
        _: &Connection,
        handle: &QueueHandle<Self>,
    ) {
        if let wl_seat::Event::Capabilities {
            capabilities: WEnum::Value(capabilities),
        } = event
            && capabilities.contains(wl_seat::Capability::Pointer)
            && state.pointer.is_none()
        {
            state.pointer = Some(seat.get_pointer(handle, ()));
        }
    }
}

impl Dispatch<WlPointer, ()> for State {
    fn event(
        state: &mut Self,
        _: &WlPointer,
        event: wl_pointer::Event,
        _: &(),
        _: &Connection,
        _: &QueueHandle<Self>,
    ) {
        match event {
            wl_pointer::Event::Enter { serial, .. } => state.serial = Some(serial),
            wl_pointer::Event::Leave { .. } => state.serial = None,
            _ => {}
        }
    }
}

delegate_noop!(State: ignore WpPointerWarpV1);