monolith

public

Star0

Fork 0

Watch0

222 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `0b89f53f59e5`

tarball

atagen <boss@atagen.co>2026-10-19 08:38 UTC

5 files changed+213-52

cursor: size theme images to the output scale

The pointer was a fixed 24 pixel image whatever the output, tiny on a scaled panel. Theme shapes are now picked nearest to the cursor size times the scale and stretched to exactly that many pixels, so ImageElement stays unscaled and eligible for the cursor plane. Client cursor surfaces and drag icons are told the scale of the output the pointer is on, and again when it crosses to another.

Modified file: crates/monolith/src/cursor.rs+199 additions−50 deletions@@ -2,30 +2,38 @@
 //! cursor surface wins, otherwise the xcursor theme's default arrow.
 
 use crate::scene::{Draw, to_physical};
-use monolith_render_vk::VulkanRenderer;
+use monolith_render_vk::{VulkanFrame, VulkanRenderer, VulkanTexture};
 use smithay::backend::allocator::Fourcc;
-use smithay::backend::renderer::element::memory::{
-    MemoryRenderBuffer, MemoryRenderBufferRenderElement,
-};
+use smithay::backend::renderer::element::memory::MemoryBuffer;
 use smithay::backend::renderer::element::solid::SolidColorRenderElement;
 use smithay::backend::renderer::element::surface::render_elements_from_surface_tree;
-use smithay::backend::renderer::element::{Id, Kind};
+use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
 use smithay::backend::renderer::utils::CommitCounter;
+use smithay::backend::renderer::{Frame, ImportMem};
 use smithay::input::pointer::CursorIcon;
 use smithay::input::pointer::{CursorImageAttributes, CursorImageStatus};
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
-use smithay::utils::{Logical, Physical, Point, Rectangle, Transform};
+use smithay::utils::user_data::UserDataMap;
+use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Transform};
 use smithay::wayland::compositor::with_states;
 use std::collections::HashMap;
 use std::sync::Mutex;
 
-type Image = Option<(MemoryRenderBuffer, Point<i32, Logical>)>;
+/// A theme shape sized for one output scale.
+struct Prepared {
+    id: Id,
+    pixels: MemoryBuffer,
+    texture: VulkanTexture,
+    hotspot: Point<i32, Physical>,
+}
 
 pub struct Cursor {
     theme: xcursor::CursorTheme,
     size: u32,
-    /// Shapes loaded so far, including ones the theme lacks.
-    images: HashMap<CursorIcon, Image>,
+    /// Every image of the shapes read so far, including ones the theme lacks.
+    files: HashMap<CursorIcon, Option<Vec<xcursor::parser::Image>>>,
+    /// Shapes sized for an output scale, in steps of 1/120.
+    sized: HashMap<(CursorIcon, u32), Option<Prepared>>,
 }
 
 impl Cursor {
@@ -38,9 +46,10 @@ impl Cursor {
         let mut cursor = Self {
             theme: xcursor::CursorTheme::load(&theme),
             size,
-            images: HashMap::new(),
+            files: HashMap::new(),
+            sized: HashMap::new(),
         };
-        if cursor.image(CursorIcon::Default).is_none() {
+        if cursor.file(CursorIcon::Default).is_none() {
             tracing::warn!(theme, "no xcursor theme found, drawing a plain cursor");
         }
         // Reading a shape from the theme takes milliseconds, which in a frame
@@ -64,21 +73,47 @@ impl Cursor {
             CursorIcon::SwResize,
             CursorIcon::SeResize,
         ] {
-            cursor.image(icon);
+            cursor.file(icon);
         }
         cursor
     }
 
-    /// The theme's image for `icon`, falling back to the default arrow.
-    fn image(&mut self, icon: CursorIcon) -> Option<&(MemoryRenderBuffer, Point<i32, Logical>)> {
-        if !self.images.contains_key(&icon) {
+    /// The theme's images for `icon`, falling back to the default arrow.
+    fn file(&mut self, icon: CursorIcon) -> Option<&[xcursor::parser::Image]> {
+        if !self.files.contains_key(&icon) {
             let names = std::iter::once(icon.name()).chain(icon.alt_names().iter().copied());
-            let image = names
+            let images = names
                 .chain(["default", "left_ptr"])
-                .find_map(|n| load_image(&self.theme, n, self.size));
-            self.images.insert(icon, image);
+                .find_map(|n| load_file(&self.theme, n));
+            self.files.insert(icon, images);
+        }
+        self.files.get(&icon)?.as_deref()
+    }
+
+    /// The theme's image nearest the cursor size times `scale`, stretched to
+    /// exactly that size so it covers whole pixels at any scale.
+    fn sized(
+        &mut self,
+        renderer: &mut VulkanRenderer,
+        icon: CursorIcon,
+        scale: f64,
+    ) -> Option<&Prepared> {
+        let key = (icon, (scale * 120.0).round() as u32);
+        if !self.sized.contains_key(&key) {
+            let wanted = ((f64::from(self.size) * scale).round() as u32).max(1);
+            let prepared = self
+                .file(icon)
+                .and_then(|images| images.iter().min_by_key(|i| i.size.abs_diff(wanted)))
+                .and_then(|image| {
+                    prepare(
+                        renderer,
+                        image,
+                        f64::from(wanted) / f64::from(image.size.max(1)),
+                    )
+                });
+            self.sized.insert(key, prepared);
         }
-        self.images.get(&icon).and_then(Option::as_ref)
+        self.sized.get(&key)?.as_ref()
     }
 
     /// Elements for the pointer at `pos`, in output-local coordinates.
@@ -114,44 +149,158 @@ impl Cursor {
                 .map(Draw::Surface)
                 .collect()
             }
-            CursorImageStatus::Named(icon) => match self.image(*icon) {
-                Some((buffer, hotspot)) => MemoryRenderBufferRenderElement::from_buffer(
-                    renderer,
-                    at(*hotspot).to_f64(),
-                    buffer,
-                    None,
-                    None,
-                    None,
-                    Kind::Cursor,
-                )
-                .map(|e| vec![Draw::Memory(e)])
-                .unwrap_or_default(),
-                None => vec![Draw::Border(SolidColorRenderElement::new(
-                    Id::new(),
-                    Rectangle::new(at(Point::default()), (8, 8).into()),
-                    CommitCounter::default(),
-                    [1.0, 1.0, 1.0, 1.0],
-                    Kind::Cursor,
-                ))],
-            },
+            CursorImageStatus::Named(icon) => {
+                let tip = to_physical((pos.x, pos.y), scale);
+                match self.sized(renderer, *icon, scale) {
+                    Some(image) => vec![Draw::Cursor(ImageElement::new(image, tip))],
+                    None => {
+                        let side = (8.0 * scale).round() as i32;
+                        vec![Draw::Border(SolidColorRenderElement::new(
+                            Id::new(),
+                            Rectangle::new(tip, (side, side).into()),
+                            CommitCounter::default(),
+                            [1.0, 1.0, 1.0, 1.0],
+                            Kind::Cursor,
+                        ))]
+                    }
+                }
+            }
         }
     }
 }
 
-fn load_image(theme: &xcursor::CursorTheme, name: &str, size: u32) -> Image {
+fn load_file(theme: &xcursor::CursorTheme, name: &str) -> Option<Vec<xcursor::parser::Image>> {
     let path = theme.load_icon(name)?;
     let bytes = std::fs::read(path).ok()?;
-    let images = xcursor::parser::parse_xcursor(&bytes)?;
-    let image = images.iter().min_by_key(|i| i.size.abs_diff(size))?;
-    let buffer = MemoryRenderBuffer::from_slice(
-        &image.pixels_rgba,
-        Fourcc::Argb8888,
-        (image.width as i32, image.height as i32),
-        1,
-        Transform::Normal,
-        None,
+    xcursor::parser::parse_xcursor(&bytes)
+}
+
+/// Uploads `image` stretched by `ratio`. The theme stores premultiplied BGRA
+/// bytes, which is what Argb8888 means on little endian.
+fn prepare(
+    renderer: &mut VulkanRenderer,
+    image: &xcursor::parser::Image,
+    ratio: f64,
+) -> Option<Prepared> {
+    let (w, h) = (image.width as i32, image.height as i32);
+    let size = (
+        ((f64::from(w) * ratio).round() as i32).max(1),
+        ((f64::from(h) * ratio).round() as i32).max(1),
     );
-    Some((buffer, (image.xhot as i32, image.yhot as i32).into()))
+    let pixels = if (w, h) == size {
+        image.pixels_rgba.clone()
+    } else {
+        stretch(&image.pixels_rgba, (w, h), size)
+    };
+    let texture = renderer
+        .import_memory(&pixels, Fourcc::Argb8888, size.into(), false)
+        .ok()?;
+    Some(Prepared {
+        id: Id::new(),
+        pixels: MemoryBuffer::from_slice(&pixels, Fourcc::Argb8888, size),
+        texture,
+        hotspot: (
+            (f64::from(image.xhot) * ratio).round() as i32,
+            (f64::from(image.yhot) * ratio).round() as i32,
+        )
+            .into(),
+    })
+}
+
+/// Bilinear resampling of 4 byte pixels, which averages evenly when halving.
+fn stretch(src: &[u8], (sw, sh): (i32, i32), (dw, dh): (i32, i32)) -> Vec<u8> {
+    let (fx, fy) = (f64::from(sw) / f64::from(dw), f64::from(sh) / f64::from(dh));
+    let at = |x: i32, y: i32, c: usize| {
+        let (x, y) = (x.clamp(0, sw - 1), y.clamp(0, sh - 1));
+        f64::from(src[(y * sw + x) as usize * 4 + c])
+    };
+    let mut out = Vec::with_capacity((dw * dh * 4) as usize);
+    for y in 0..dh {
+        let sy = (f64::from(y) + 0.5) * fy - 0.5;
+        let y0 = sy.floor();
+        let ty = sy - y0;
+        for x in 0..dw {
+            let sx = (f64::from(x) + 0.5) * fx - 0.5;
+            let x0 = sx.floor();
+            let tx = sx - x0;
+            for c in 0..4 {
+                let (x0, y0) = (x0 as i32, y0 as i32);
+                let top = at(x0, y0, c) * (1.0 - tx) + at(x0 + 1, y0, c) * tx;
+                let bottom = at(x0, y0 + 1, c) * (1.0 - tx) + at(x0 + 1, y0 + 1, c) * tx;
+                out.push((top * (1.0 - ty) + bottom * ty).round() as u8);
+            }
+        }
+    }
+    out
+}
+
+/// A theme image at whole pixels, drawn unscaled so the cursor plane can
+/// take it.
+pub struct ImageElement {
+    id: Id,
+    pixels: MemoryBuffer,
+    texture: VulkanTexture,
+    geometry: Rectangle<i32, Physical>,
+}
+
+impl ImageElement {
+    fn new(image: &Prepared, tip: Point<i32, Physical>) -> Self {
+        let size = image.pixels.size();
+        Self {
+            id: image.id.clone(),
+            pixels: image.pixels.clone(),
+            texture: image.texture.clone(),
+            geometry: Rectangle::new(tip - image.hotspot, (size.w, size.h).into()),
+        }
+    }
+}
+
+impl Element for ImageElement {
+    fn id(&self) -> &Id {
+        &self.id
+    }
+
+    fn current_commit(&self) -> CommitCounter {
+        CommitCounter::default()
+    }
+
+    fn src(&self) -> Rectangle<f64, Buffer> {
+        Rectangle::from_size(self.pixels.size().to_f64())
+    }
+
+    fn geometry(&self, _scale: Scale<f64>) -> Rectangle<i32, Physical> {
+        self.geometry
+    }
+
+    fn kind(&self) -> Kind {
+        Kind::Cursor
+    }
+}
+
+impl RenderElement<VulkanRenderer> for ImageElement {
+    fn draw(
+        &self,
+        frame: &mut VulkanFrame<'_, '_>,
+        src: Rectangle<f64, Buffer>,
+        dst: Rectangle<i32, Physical>,
+        damage: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
+        _cache: Option<&UserDataMap>,
+    ) -> Result<(), monolith_render_vk::Error> {
+        frame.render_texture_from_to(
+            &self.texture,
+            src,
+            dst,
+            damage,
+            opaque_regions,
+            Transform::Normal,
+            1.0,
+        )
+    }
+
+    fn underlying_storage(&self, _renderer: &mut VulkanRenderer) -> Option<UnderlyingStorage<'_>> {
+        Some(UnderlyingStorage::Memory(&self.pixels))
+    }
 }
 
 /// The surface a drag carries under the pointer. `offset` accumulates the

Modified file: crates/monolith/src/input.rs+1

@@ -16,6 +16,7 @@ use smithay::xwayland::xwm::ResizeEdge;

1616 impl State {

1717 pub fn pointer_to(&mut self, pos: Point<f64, Logical>, time: InputTime) {

1818 self.input.pointer_pos = pos;

19+ self.follow_pointer_scale();

1920 self.activity();

2021 if drag_to(self, pos) {

2122 return;

Modified file: crates/monolith/src/scale.rs+9 additions@@ -102,6 +102,15 @@ impl State {
         }
     }
 
+    /// Retells the cursor and drag icon when the pointer crosses to an output.
+    pub fn follow_pointer_scale(&mut self) {
+        let name = self.pointer_output().map(|o| o.name());
+        if self.input.pointer_output != name {
+            self.input.pointer_output = name;
+            self.send_pointer_scales();
+        }
+    }
+
     pub fn pointer_output(&self) -> Option<Output> {
         self.wm
             .space

Modified file: crates/monolith/src/scene.rs+1 additions−2 deletions@@ -5,7 +5,6 @@ use crate::wm::{LastFrame, Wm};
 use monolith_config::Decoration;
 use monolith_layout::{OutputId, Rect, WindowId};
 use monolith_render_vk::{Clip, Effect, VulkanFrame, VulkanRenderer, VulkanTexture};
-use smithay::backend::renderer::element::memory::MemoryRenderBufferRenderElement;
 use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
 use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
 use smithay::backend::renderer::element::surface::render_elements_from_surface_tree;
@@ -27,7 +26,7 @@ smithay::backend::renderer::element::render_elements! {
     Cropped=CropRenderElement<WaylandSurfaceRenderElement<VulkanRenderer>>,
     Texture=PlacedTexture,
     Border=SolidColorRenderElement,
-    Memory=MemoryRenderBufferRenderElement<VulkanRenderer>,
+    Cursor=crate::cursor::ImageElement,
     Rescaled=RescaleRenderElement<WaylandSurfaceRenderElement<VulkanRenderer>>,
     Clipped=ClipElement,
 }

Modified file: crates/monolith/src/state.rs+3 additions@@ -63,6 +63,8 @@ pub struct Input {
     pub dnd_icon: Option<crate::cursor::DndIcon>,
     /// The edges of the window border under the pointer, for the resize cursor.
     pub hover: Option<crate::input::Edges>,
+    /// The output the pointer was last on, whose scale cursor and drag icon surfaces follow.
+    pub pointer_output: Option<String>,
 }
 
 /// What needs doing after this batch of events.
@@ -195,6 +197,7 @@ impl State {
                 cursor_status: CursorImageStatus::default_named(),
                 dnd_icon: None,
                 hover: None,
+                pointer_output: None,
             },
             dirty: Dirty {
                 redraw: true,

monolith

Commit 0b89f53f59e5

Commit `0b89f53f59e5`