X11 impl

Author: prokopyl

Cargo.toml

@@ -96,7 +96,18 @@ objc2-app-kit = { version = "0.3.2", default-features = false, features = [
 ] }
 
 [workspace]
-members = ["examples/cursors", "examples/open_parented", "examples/open_window", "examples/plugin_clack", "examples/render_femtovg", "examples/render_wgpu", "examples/plugin_clack_femtovg", "examples/test-frame-pacing", "examples/external-wakeup"]
+members = [
+    "examples/cursors",
+    "examples/open_parented",
+    "examples/open_window",
+    "examples/plugin_clack",
+    "examples/render_femtovg",
+    "examples/render_wgpu",
+    "examples/plugin_clack_femtovg",
+    "examples/test-frame-pacing",
+    "examples/external-wakeup",
+    "tests/partial-rendering"
+]
 
 [lints.clippy]
 missing-safety-doc = "allow"

src/handler.rs

@@ -1,10 +1,24 @@
 use super::*;
+use crate::dpi::{PhysicalPosition, PhysicalSize};
 use crate::platform::Result;
 
 #[non_exhaustive]
+#[derive(Debug, Copy, Clone)]
 pub enum DamageArea {
     FullWindow,
-    // Later: single rect, perhaps list of rects
+    Rect { position: PhysicalPosition<u32>, size: PhysicalSize<u32> },
+}
+
+impl DamageArea {
+    pub(crate) fn from_rect_and_window_size(
+        position: PhysicalPosition<u32>, size: PhysicalSize<u32>, window_size: PhysicalSize<u32>,
+    ) -> Self {
+        if position.x == 0 && position.y == 0 && size == window_size {
+            Self::FullWindow
+        } else {
+            Self::Rect { position, size }
+        }
+    }
 }
 
 pub trait WindowHandler: 'static {

src/platform/x11/event_loop.rs

@@ -9,12 +9,13 @@ use crate::platform::x11::error::FatalError;
 use crate::platform::x11::window_thread::{
     HostCallback, WindowThreadRequest, WindowThreadResponseMessage,
 };
-use crate::warn;
 use crate::wrappers::xkbcommon::XkbcommonState;
+use crate::{warn, DamageArea};
 use crate::{Event, MouseButton, MouseEvent, ScrollDelta, WindowEvent, WindowHandler, WindowSize};
 use calloop::generic::Generic;
 use calloop::timer::{TimeoutAction, Timer};
 use calloop::{Interest, LoopHandle, LoopSignal, Mode, PostAction};
+use dpi::PhysicalInsets;
 use std::rc::Rc;
 use std::sync::mpsc;
 use std::sync::mpsc::Receiver;
@@ -482,7 +483,17 @@ impl EventLoop {
             }
 
             XEvent::Expose(e) if e.window == self.window.raw_id() => {
-                self.window.present_notify_requested.set(true)
+                if e.count == 0 {
+                    self.window.present_notify_requested.set(true);
+                }
+
+                let current_window_size = self.new_size.unwrap_or_else(|| self.window.get_size());
+
+                self.handler.damage(DamageArea::from_rect_and_window_size(
+                    PhysicalPosition::new(e.x, e.y).cast(),
+                    PhysicalSize::new(e.width, e.height).cast(),
+                    current_window_size.cast(),
+                ));
             }
 
             ////

tests/partial-rendering/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "partial-rendering"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+baseview = { path = "../..", features = ["opengl"] }
+femtovg = "0.27.0"
+rand = "0.10.3"
+color = "0.3.3"

tests/partial-rendering/src/main.rs

@@ -0,0 +1,142 @@
+use baseview::dpi::{LogicalSize, PhysicalPosition, PhysicalSize};
+use baseview::gl::{GlConfig, GlContext};
+use baseview::{
+    DamageArea, Event, EventStatus, HandlerError, Window, WindowContext, WindowHandler,
+    WindowSettings, WindowSize,
+};
+use color::{Hsl, OpaqueColor};
+use femtovg::renderer::OpenGl;
+use femtovg::{Canvas, Color};
+use std::cell::{Cell, RefCell};
+
+struct FemtovgExample {
+    gl_context: GlContext,
+    canvas: RefCell<Canvas<OpenGl>>,
+    damage_handler: DamageHandler,
+}
+
+impl FemtovgExample {
+    fn new(window_context: WindowContext) -> Result<Self, HandlerError> {
+        let Some(gl_context) = window_context.gl_context() else { unreachable!() };
+        unsafe { gl_context.make_current()? };
+
+        let renderer =
+            unsafe { OpenGl::new_from_function_cstr(|s| gl_context.get_proc_address(s)) }?;
+
+        let mut canvas = Canvas::new(renderer)?;
+        let size = window_context.size();
+
+        canvas.set_size(size.physical.width, size.physical.height, size.scale_factor as f32);
+
+        unsafe { gl_context.make_not_current()? };
+        Ok(Self { gl_context, canvas: canvas.into(), damage_handler: DamageHandler::new() })
+    }
+}
+
+impl WindowHandler for FemtovgExample {
+    fn draw(&self) -> Result<(), HandlerError> {
+        let context = &self.gl_context;
+        unsafe { context.make_current()? };
+
+        let mut canvas = self.canvas.borrow_mut();
+
+        let screen_height = canvas.height();
+        let screen_width = canvas.width();
+
+        let color_of_the_day = new_random_color();
+
+        if self.damage_handler.is_full_screen_clear() {
+            canvas.clear_rect(0, 0, screen_width, screen_height, color_of_the_day);
+        } else {
+            while let Some((pos, size)) = self.damage_handler.next_damage() {
+                dbg!((pos, size));
+                canvas.clear_rect(pos.x, pos.y, size.width, size.height, color_of_the_day);
+            }
+        }
+
+        self.damage_handler.clear();
+
+        // Tell renderer to execute all drawing commands
+        canvas.flush();
+        context.swap_buffers()?;
+        unsafe { context.make_not_current()? };
+
+        Ok(())
+    }
+
+    fn damage(&self, area: DamageArea) {
+        eprintln!("Damaged: {area:?}");
+        match area {
+            DamageArea::FullWindow => self.damage_handler.set_full_screen_clear(),
+            DamageArea::Rect { position, size } => {
+                self.damage_handler.add_damaged_rect(position, size)
+            }
+            _ => {}
+        }
+    }
+
+    fn resized(&self, new_size: WindowSize) -> Result<(), HandlerError> {
+        let size = new_size.physical;
+        self.canvas.borrow_mut().set_size(size.width, size.height, new_size.scale_factor as f32);
+
+        Ok(())
+    }
+
+    fn on_event(&self, _event: Event) -> EventStatus {
+        EventStatus::Ignored
+    }
+}
+
+fn main() -> Result<(), baseview::Error> {
+    unsafe { baseview::assume_standalone_in_process() };
+
+    let window_open_options = WindowSettings::new()
+        .with_title("Baseview Partial redraw example")
+        .with_size(LogicalSize::new(512, 512))
+        .with_gl_config(GlConfig { alpha_bits: 8, ..GlConfig::default() });
+
+    let window = Window::create(window_open_options, |ctx| FemtovgExample::new(ctx))?;
+
+    window.run_until_closed()?;
+    Ok(())
+}
+
+fn new_random_color() -> Color {
+    let hue = rand::random_range(0.0..360.0);
+    let hsv_color = OpaqueColor::<Hsl>::new([hue, 100.0, 15.0]);
+    let color = hsv_color.to_rgba8();
+
+    Color::rgb(color.r, color.g, color.b)
+}
+
+struct DamageHandler {
+    full_screen: Cell<bool>,
+    damaged_rects: RefCell<Vec<(PhysicalPosition<u32>, PhysicalSize<u32>)>>,
+}
+
+impl DamageHandler {
+    fn new() -> Self {
+        Self { full_screen: false.into(), damaged_rects: RefCell::new(Vec::with_capacity(8)) }
+    }
+
+    fn is_full_screen_clear(&self) -> bool {
+        self.full_screen.get()
+    }
+
+    fn set_full_screen_clear(&self) {
+        self.full_screen.set(true)
+    }
+
+    fn clear(&self) {
+        self.full_screen.set(false);
+        self.damaged_rects.borrow_mut().clear();
+    }
+
+    fn next_damage(&self) -> Option<(PhysicalPosition<u32>, PhysicalSize<u32>)> {
+        self.damaged_rects.borrow_mut().pop()
+    }
+
+    fn add_damaged_rect(&self, position: PhysicalPosition<u32>, size: PhysicalSize<u32>) {
+        self.damaged_rects.borrow_mut().push((position, size));
+    }
+}