wip

Author: prokopyl

Cargo.toml

@@ -40,7 +40,7 @@ dpi = "0.1.2"
 tracing = { version = "0.1", optional = true }
 
 [target.'cfg(target_os="linux")'.dependencies]
-x11rb = { version = "0.13.2", features = ["cursor", "resource_manager", "allow-unsafe-code", "dl-libxcb"], default-features = false }
+x11rb = { version = "0.13.2", features = ["cursor", "present", "dri3", "resource_manager", "allow-unsafe-code", "dl-libxcb"], default-features = false }
 xkbcommon-dl = { version = "0.4.2", features = ["x11"] }
 x11-dl = { version = "2.21.0" }
 calloop = "0.14.4"

examples/test-frame-pacing/src/main.rs

@@ -132,6 +132,7 @@ impl WindowHandler for FramePacingTest {
     }
 
     fn on_event(&self, event: Event) -> EventStatus {
+        dbg!(&event);
         if let Event::Keyboard(KeyboardEvent { key, state: KeyState::Down, .. }) = event {
             match key {
                 Key::Named(NamedKey::ArrowLeft) => {
@@ -154,7 +155,7 @@ fn main() -> Result<(), baseview::Error> {
     let window_open_options = WindowSettings::new()
         .with_title("Femtovg on Baseview")
         .with_size(LogicalSize::new(512, 512))
-        .with_gl_config(GlConfig { alpha_bits: 8, ..GlConfig::default() });
+        .with_gl_config(GlConfig { alpha_bits: 8, vsync: true, ..GlConfig::default() });
 
     Window::create(window_open_options, FramePacingTest::new)?.run_until_closed()?;
     Ok(())

src/platform/x11/event_loop.rs

@@ -62,6 +62,8 @@ pub(crate) struct EventLoop {
 
     response_sender: mpsc::Sender<WindowThreadResponseMessage>,
     main_thread: Option<MainThreadCaller>,
+
+    last_rendered_msc: Option<u64>,
 }
 
 const FRAME_INTERVAL: Duration = Duration::from_millis(15);
@@ -75,9 +77,9 @@ impl EventLoop {
     ) -> Result<Self, Error> {
         let loop_handle = inner.handle();
 
-        loop_handle
-            .insert_source(Timer::from_duration(FRAME_INTERVAL), |i, _, e| e.handle_frame(i))
-            .map_err(|e| e.error)?;
+        /*loop_handle
+        .insert_source(Timer::from_duration(FRAME_INTERVAL), |i, _, e| e.handle_frame(i))
+        .map_err(|e| e.error)?;*/
 
         loop_handle
             .insert_source(
@@ -101,6 +103,7 @@ impl EventLoop {
 
             window,
             response_sender,
+            last_rendered_msc: None,
         })
     }
 
@@ -111,7 +114,18 @@ impl EventLoop {
         // when they've all been coalesced.
         self.new_physical_size = None;
 
+        let mut current_sequence_number = None;
+
         while let Some(event) = self.window.connection.conn.poll_for_event()? {
+            let sequence = event.wire_sequence_number();
+
+            if sequence == current_sequence_number {
+                continue;
+            }
+
+            current_sequence_number = sequence;
+
+            //dbg!(event.wire_sequence_number());
             self.handle_xcb_event(event)?;
         }
 
@@ -207,7 +221,10 @@ impl EventLoop {
                 Ok(())
             }
             WindowThreadRequest::Show => {
+                self.window.xcb_window.present_select_input()?.unwrap(); // TODO: unwrap: fallback to timer
                 self.window.xcb_window.map_window()?.check()?;
+                self.window.xcb_window.present_notify(0)?.check().unwrap(); // TODO: unwrap
+                self.window.connection.conn.flush()?;
                 Ok(())
             }
             WindowThreadRequest::Hide => {
@@ -330,6 +347,7 @@ impl EventLoop {
             }
 
             XEvent::ConfigureNotify(event) => {
+                //dbg!(event.width, event.height);
                 let new_physical_size = PhysicalSize::new(event.width, event.height);
 
                 if self.new_physical_size.is_some() || new_physical_size != self.window.get_size() {
@@ -406,8 +424,9 @@ impl EventLoop {
                 self.handle_event(ev);
             }
 
-            XEvent::FocusIn(_) => {
+            XEvent::FocusIn(e) => {
                 self.window.is_focused.set(true);
+                dbg!(e.sequence);
                 self.handle_event(Event::Window(WindowEvent::Focused));
             }
 
@@ -416,6 +435,25 @@ impl EventLoop {
                 self.handle_event(Event::Window(WindowEvent::Unfocused));
             }
 
+            XEvent::PresentCompleteNotify(e) => {
+                //dbg!(e.msc);
+                if Some(e.msc) != self.last_rendered_msc {
+                    //return Ok(());
+
+                    //dbg!(e.msc, self.last_rendered_msc);
+
+                    if let Err(e) = self.handler.on_frame() {
+                        self.run_error = Some(e.into());
+                        self.stop_now();
+                    } else {
+                        self.last_rendered_msc = Some(e.msc);
+                        //dbg!("Present_notify");
+                    }
+                }
+                self.window.xcb_window.present_notify(e.msc.wrapping_add(1))?; // TODO: unwrap
+                self.window.connection.conn.flush()?;
+            }
+
             _ => {}
         }
 

src/platform/x11/xcb_connection.rs

@@ -1,8 +1,9 @@
 use std::cell::RefCell;
 use std::collections::hash_map::{Entry, HashMap};
 use std::sync::Arc;
-use x11rb::connection::Connection;
+use x11rb::connection::{Connection, RequestConnection};
 use x11rb::cursor::Handle as CursorHandle;
+use x11rb::protocol::present;
 use x11rb::protocol::xproto::{self, Cursor, Screen};
 use x11rb::resource_manager;
 
@@ -50,6 +51,8 @@ pub struct X11Connection {
     pub(crate) resources: resource_manager::Database,
     pub(crate) cursor_handle: CursorHandle,
     pub(crate) cursor_cache: RefCell<HashMap<MouseCursor, u32>>,
+
+    pub(crate) present_supported: bool,
 }
 
 impl X11Connection {
@@ -62,12 +65,15 @@ impl X11Connection {
         let resources = resource_manager::new_from_default(xcb_conn)?;
         let cursor_handle = CursorHandle::new(xcb_conn, screen as usize, &resources)?.reply()?;
 
+        let present_supported = conn.extension_information(present::X11_EXTENSION_NAME)?.is_some();
+
         Ok(Self {
             conn: Arc::new(conn),
             atoms,
             resources,
             cursor_handle,
             cursor_cache: RefCell::new(HashMap::new()),
+            present_supported,
         })
     }
 

src/platform/x11/xcb_window.rs

@@ -8,6 +8,8 @@ use x11rb::connection::Connection;
 use x11rb::cookie::VoidCookie;
 use x11rb::errors::{ConnectionError, ReplyOrIdError};
 use x11rb::properties::WmSizeHints;
+use x11rb::protocol::present;
+use x11rb::protocol::present::ConnectionExt;
 use x11rb::protocol::xproto::{
     AtomEnum, ConfigureWindowAux, ConnectionExt as _, CreateWindowAux, EventMask, PropMode,
     WindowClass,
@@ -18,6 +20,7 @@ use x11rb::xcb_ffi::XCBConnection;
 pub struct XcbWindow {
     connection: Rc<X11Connection>,
     window_id: NonZeroU32,
+    present_notify_event_id: Option<NonZeroU32>,
 }
 
 impl XcbWindow {
@@ -59,15 +62,39 @@ impl XcbWindow {
                 .border_pixel(0),
         )?;
 
-        Ok(Self { window_id, connection })
+        let present_notify_event_id = if !connection.present_supported {
+            None
+        } else {
+            let Some(event_id) = NonZero::new(connection.conn.generate_id()?) else {
+                unreachable!();
+            };
+
+            Some(event_id)
+        };
+
+        Ok(Self { window_id, connection, present_notify_event_id })
+    }
+
+    pub fn present_select_input(
+        &self,
+    ) -> Result<Option<VoidCookie<'_, XCBConnection>>, ConnectionError> {
+        let Some(event_id) = self.present_notify_event_id else {
+            return Ok(None);
+        };
+
+        Ok(Some(self.connection.conn.present_select_input(
+            event_id.get(),
+            self.window_id.get(),
+            present::EventMask::COMPLETE_NOTIFY,
+        )?))
     }
 
-    pub fn map_window(&self) -> Result<VoidCookie<'_, XCBConnection>, ReplyOrIdError> {
-        Ok(self.connection.conn.map_window(self.window_id.get())?)
+    pub fn map_window(&self) -> Result<VoidCookie<'_, XCBConnection>, ConnectionError> {
+        self.connection.conn.map_window(self.window_id.get())
     }
 
-    pub fn unmap_window(&self) -> Result<VoidCookie<'_, XCBConnection>, ReplyOrIdError> {
-        Ok(self.connection.conn.unmap_window(self.window_id.get())?)
+    pub fn unmap_window(&self) -> Result<VoidCookie<'_, XCBConnection>, ConnectionError> {
+        self.connection.conn.unmap_window(self.window_id.get())
     }
 
     pub fn resize(
@@ -90,41 +117,51 @@ impl XcbWindow {
         )
     }
 
-    pub fn set_title(&self, title: &str) -> Result<VoidCookie<'_, XCBConnection>, ReplyOrIdError> {
-        Ok(self.connection.conn.change_property8(
+    pub fn set_title(&self, title: &str) -> Result<VoidCookie<'_, XCBConnection>, ConnectionError> {
+        self.connection.conn.change_property8(
             PropMode::REPLACE,
             self.window_id.get(),
             AtomEnum::WM_NAME,
             AtomEnum::STRING,
             title.as_bytes(),
-        )?)
+        )
     }
 
-    pub fn enable_wm_protocols(&self) -> Result<VoidCookie<'_, XCBConnection>, ReplyOrIdError> {
-        Ok(self.connection.conn.change_property32(
+    pub fn enable_wm_protocols(&self) -> Result<VoidCookie<'_, XCBConnection>, ConnectionError> {
+        self.connection.conn.change_property32(
             PropMode::REPLACE,
             self.window_id.get(),
             self.connection.atoms.WM_PROTOCOLS,
             AtomEnum::ATOM,
             &[self.connection.atoms.WM_DELETE_WINDOW],
-        )?)
+        )
     }
 
-    pub fn enable_dnd_protocols(&self) -> Result<VoidCookie<'_, XCBConnection>, ReplyOrIdError> {
-        Ok(self.connection.conn.change_property32(
+    pub fn enable_dnd_protocols(&self) -> Result<VoidCookie<'_, XCBConnection>, ConnectionError> {
+        self.connection.conn.change_property32(
             PropMode::REPLACE,
             self.window_id.get(),
             self.connection.atoms.XdndAware,
             AtomEnum::ATOM,
             &[5u32], // Latest version; hasn't changed since 2002
-        )?)
+        )
     }
 
     pub fn set_size_hints(
         &self, size_hints: WmSizeHints,
-    ) -> Result<VoidCookie<'_, XCBConnection>, ReplyOrIdError> {
-        Ok(size_hints
-            .set_normal_hints(&self.connection.conn as &XCBConnection, self.window_id.get())?)
+    ) -> Result<VoidCookie<'_, XCBConnection>, ConnectionError> {
+        size_hints.set_normal_hints(&self.connection.conn as &XCBConnection, self.window_id.get())
+    }
+
+    pub fn present_supported(&self) -> bool {
+        self.present_notify_event_id.is_some()
+    }
+
+    pub fn present_notify(
+        &self, target_msc: u64,
+    ) -> Result<VoidCookie<'_, XCBConnection>, ConnectionError> {
+        //dbg!(target_msc);
+        self.connection.conn.present_notify_msc(self.window_id.get(), 0, target_msc, 1, 0)
     }
 
     #[inline]
@@ -135,6 +172,17 @@ impl XcbWindow {
 
 impl Drop for XcbWindow {
     fn drop(&mut self) {
+        if let Some(event_id) = self.present_notify_event_id {
+            match self.connection.conn.present_select_input(
+                event_id.get(),
+                self.window_id.get(),
+                present::EventMask::NO_EVENT,
+            ) {
+                Err(e) => crate::warn!("Failed to send request to switch XPresent off: {}", e),
+                Ok(cookie) => cookie.check_warn(),
+            }
+        }
+
         match self.connection.conn.destroy_window(self.window_id.get()) {
             Err(e) => crate::warn!("Failed to send request to destroy X window: {}", e),
             Ok(cookie) => cookie.check_warn(),