monolith

public

Star0

Fork 0

Watch0

219 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `2e852b236c45`

tarball

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

7 files changed+250-140

render: draw every element at the output's scale

Scene, layers, popups, the lock surface, the cursor, the drag icon and capture all hard-coded scale 1, so a fractional output scale would have drawn logical sizes as pixels. Window rects are snapped to the physical grid by edge, borders keep one width on every side, and the damage trackers for capture now take the target's scale.

Modified file: crates/monolith/src/capture.rs+39 additions−9 deletions@@ -166,11 +166,30 @@ impl State {
                 let mode = output.current_mode()?;
                 output.current_transform().transform_size(mode.size).into()
             }
-            Target::Window(id) => self.wm.window(*id)?.geometry().size.into(),
+            Target::Window(id) => {
+                let size = self.wm.window(*id)?.geometry().size;
+                size.to_physical_precise_round::<_, i32>(self.target_scale(target))
+                    .into()
+            }
         };
         (size.0 > 0 && size.1 > 0).then_some(size)
     }
 
+    /// An output's own scale, and a window's is the one of the output it is on.
+    fn target_scale(&self, target: &Target) -> f64 {
+        let output = match target {
+            Target::Output(name) => self.output_named(name).map(|(_, output)| output),
+            Target::Window(id) => self
+                .wm
+                .get(*id)
+                .and_then(|s| s.placed)
+                .map(|(_, _, o)| o)
+                .or_else(|| self.wm.layout.window(*id)?.output)
+                .and_then(|o| self.backend.output(o)),
+        };
+        output.map_or(1.0, |o| o.current_scale().fractional_scale())
+    }
+
     fn constraints(&self, size: (i32, i32)) -> BufferConstraints {
         let dma = self.backend.render_node().map(|node| {
             let mut formats: Vec<(Fourcc, Vec<_>)> = Vec::new();
@@ -203,6 +222,7 @@ impl State {
             frame.fail(CaptureFailureReason::BufferConstraints);
             return;
         }
+        let scale = self.target_scale(&target);
         let elements = match &target {
             Target::Output(name) => {
                 let Some((o, output)) = self.output_named(name) else {
@@ -225,7 +245,7 @@ impl State {
             }
             Target::Window(id) => match self.wm.window(*id) {
                 Some(_) if self.services.lock.active() => Vec::new(),
-                Some(window) => window_elements(&mut self.renderer, window),
+                Some(window) => window_elements(&mut self.renderer, window, scale),
                 None => {
                     frame.fail(CaptureFailureReason::Stopped);
                     return;
@@ -234,8 +254,8 @@ impl State {
         };
         let buffer = frame.buffer();
         let result = match get_dmabuf(&buffer) {
-            Ok(dmabuf) => self.capture_dmabuf(dmabuf.clone(), size, &elements),
-            Err(_) => self.capture_shm(&buffer, size, &elements),
+            Ok(dmabuf) => self.capture_dmabuf(dmabuf.clone(), size, scale, &elements),
+            Err(_) => self.capture_shm(&buffer, size, scale, &elements),
         };
         match result {
             Ok(()) => {
@@ -253,10 +273,11 @@ impl State {
         &mut self,
         mut dmabuf: Dmabuf,
         size: (i32, i32),
+        scale: f64,
         elements: &[Draw],
     ) -> Result<(), Box<dyn std::error::Error>> {
         let mut fb = self.renderer.bind(&mut dmabuf)?;
-        let mut tracker = OutputDamageTracker::new(size, 1.0, Transform::Normal);
+        let mut tracker = OutputDamageTracker::new(size, scale, Transform::Normal);
         let result = tracker.render_output(&mut self.renderer, &mut fb, 0, elements, CLEAR)?;
         result.sync.wait()?;
         Ok(())
@@ -266,13 +287,14 @@ impl State {
         &mut self,
         buffer: &WlBuffer,
         size: (i32, i32),
+        scale: f64,
         elements: &[Draw],
     ) -> Result<(), Box<dyn std::error::Error>> {
         let format = with_buffer_contents_mut(buffer, |_, _, data| data.format)?;
         let fourcc = shm_format_to_fourcc(format).ok_or("unsupported shm format")?;
         let mut image: VulkanImage = self.renderer.create_buffer(fourcc, size.into())?;
         let mut fb = self.renderer.bind(&mut image)?;
-        let mut tracker = OutputDamageTracker::new(size, 1.0, Transform::Normal);
+        let mut tracker = OutputDamageTracker::new(size, scale, Transform::Normal);
         let result = tracker.render_output(&mut self.renderer, &mut fb, 0, elements, CLEAR)?;
         result.sync.wait()?;
         let region = Rectangle::from_size(Size::from(size));
@@ -302,10 +324,18 @@ impl State {
 }
 
 /// A window alone, with its popups, its geometry at the origin.
-fn window_elements(renderer: &mut VulkanRenderer, window: &smithay::desktop::Window) -> Vec<Draw> {
-    let at = Point::from((-window.geometry().loc.x, -window.geometry().loc.y));
+fn window_elements(
+    renderer: &mut VulkanRenderer,
+    window: &smithay::desktop::Window,
+    scale: f64,
+) -> Vec<Draw> {
+    let inset = window
+        .geometry()
+        .loc
+        .to_physical_precise_round::<_, i32>(scale);
+    let at = Point::from((-inset.x, -inset.y));
     let elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>> =
-        window.render_elements(renderer, at, Scale::from(1.0), 1.0);
+        window.render_elements(renderer, at, Scale::from(scale), 1.0);
     elems.into_iter().map(Draw::Surface).collect()
 }
 

Modified file: crates/monolith/src/cursor.rs+12 additions−6 deletions@@ -1,7 +1,7 @@
 //! The pointer image on bare metal, where nothing else draws one. A client
 //! cursor surface wins, otherwise the xcursor theme's default arrow.
 
-use crate::scene::Draw;
+use crate::scene::{Draw, to_physical};
 use monolith_render_vk::VulkanRenderer;
 use smithay::backend::allocator::Fourcc;
 use smithay::backend::renderer::element::memory::{
@@ -87,10 +87,11 @@ impl Cursor {
         renderer: &mut VulkanRenderer,
         status: &CursorImageStatus,
         pos: Point<f64, Logical>,
+        scale: f64,
     ) -> Vec<Draw> {
         let at = |hotspot: Point<i32, Logical>| -> Point<i32, Physical> {
             let p = pos - hotspot.to_f64();
-            (p.x.round() as i32, p.y.round() as i32).into()
+            to_physical((p.x, p.y), scale)
         };
         match status {
             CursorImageStatus::Hidden => Vec::new(),
@@ -105,7 +106,7 @@ impl Cursor {
                     renderer,
                     surface,
                     at(hotspot),
-                    1.0,
+                    scale,
                     1.0,
                     Kind::Cursor,
                 )
@@ -162,13 +163,18 @@ pub struct DndIcon {
 
 impl DndIcon {
     /// Elements for the icon with the pointer at `pos`, in output-local coordinates.
-    pub fn elements(&self, renderer: &mut VulkanRenderer, pos: Point<f64, Logical>) -> Vec<Draw> {
+    pub fn elements(
+        &self,
+        renderer: &mut VulkanRenderer,
+        pos: Point<f64, Logical>,
+        scale: f64,
+    ) -> Vec<Draw> {
         let p = pos + self.offset.to_f64();
         render_elements_from_surface_tree(
             renderer,
             &self.surface,
-            (p.x.round() as i32, p.y.round() as i32),
-            1.0,
+            to_physical((p.x, p.y), scale),
+            scale,
             1.0,
             Kind::Unspecified,
         )

Modified file: crates/monolith/src/frame.rs+7 additions−2 deletions@@ -38,6 +38,7 @@ pub fn compose(
     cursor: bool,
 ) -> Vec<Draw> {
     let mut elements = Vec::new();
+    let scale = output.current_scale().fractional_scale();
     if let Some(area) = ctx.wm.layout.output(o).map(|out| out.area) {
         let pos = ctx.input.pointer_pos;
         if area.contains(pos.x, pos.y) {
@@ -45,10 +46,14 @@ pub fn compose(
             if cursor {
                 let resize = ctx.input.resize_icon().map(CursorImageStatus::Named);
                 let status = resize.as_ref().unwrap_or(&ctx.input.cursor_status);
-                elements.extend(ctx.input.cursor.elements(ctx.renderer, status, local));
+                elements.extend(
+                    ctx.input
+                        .cursor
+                        .elements(ctx.renderer, status, local, scale),
+                );
             }
             if let Some(icon) = &ctx.input.dnd_icon {
-                elements.extend(icon.elements(ctx.renderer, local));
+                elements.extend(icon.elements(ctx.renderer, local, scale));
             }
         }
     }

Modified file: crates/monolith/src/layers.rs+8 additions−5 deletions@@ -1,7 +1,7 @@
 //! wlr-layer-shell, for bars, launchers, wallpapers and notifications.
 
 use crate::focus::Focus;
-use crate::scene::Draw;
+use crate::scene::{Draw, to_physical};
 use crate::state::State;
 use monolith_layout::{Insets, OutputId};
 use monolith_render_vk::VulkanRenderer;
@@ -255,24 +255,25 @@ impl State {
 
 /// Draws an output's layer surfaces on `layer`, front to back.
 pub fn elements(out: &mut Vec<Draw>, renderer: &mut VulkanRenderer, output: &Output, layer: Layer) {
+    let scale = output.current_scale().fractional_scale();
     let map = layer_map_for_output(output);
     for l in map.layers_on(layer).rev() {
         let Some(geo) = map.layer_geometry(l) else {
             continue;
         };
-        let at = geo.loc.to_physical(1);
+        let at = to_physical((geo.loc.x.into(), geo.loc.y.into()), scale);
         let elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>> =
             if matches!(layer, Layer::Bottom | Layer::Background) {
                 render_elements_from_surface_tree(
                     renderer,
                     l.wl_surface(),
                     at,
-                    1.0,
+                    scale,
                     1.0,
                     Kind::Unspecified,
                 )
             } else {
-                l.render_elements(renderer, at, Scale::from(1.0), 1.0)
+                l.render_elements(renderer, at, Scale::from(scale), 1.0)
             };
         out.extend(elems.into_iter().map(Draw::Surface));
     }
@@ -281,11 +282,13 @@ pub fn elements(out: &mut Vec<Draw>, renderer: &mut VulkanRenderer, output: &Out
 /// The popups of the layer surfaces below the windows. Those surfaces draw
 /// without them, so a menu is not hidden by the window it opens over.
 pub fn lower_popups(out: &mut Vec<Draw>, renderer: &mut VulkanRenderer, output: &Output) {
+    let scale = output.current_scale().fractional_scale();
     let map = layer_map_for_output(output);
     for layer in [Layer::Bottom, Layer::Background] {
         for l in map.layers_on(layer).rev() {
             if let Some(geo) = map.layer_geometry(l) {
-                crate::popups::elements(out, renderer, l.wl_surface(), geo.loc, 1.0);
+                let at = to_physical((geo.loc.x.into(), geo.loc.y.into()), scale);
+                crate::popups::elements(out, renderer, l.wl_surface(), at, scale, 1.0);
             }
         }
     }

Modified file: crates/monolith/src/lock.rs+1−1

@@ -176,7 +176,7 @@ pub fn elements(lock: &Lock, renderer: &mut VulkanRenderer, output: &Output) ->

176176 renderer,

177177 surface.wl_surface(),

178178 (0, 0),

179- 1.0,

179+ output.current_scale().fractional_scale(),

180180 1.0,

181181 Kind::Unspecified,

182182 )

Modified file: crates/monolith/src/popups.rs+23 additions−13 deletions@@ -128,13 +128,15 @@ pub fn placed(
     root: &WlSurface,
     geometry_at: Point<i32, Logical>,
 ) -> Vec<(WlSurface, Point<i32, Logical>)> {
+    offsets(root)
+        .into_iter()
+        .map(|(popup, at)| (popup, geometry_at + at))
+        .collect()
+}
+
+fn offsets(root: &WlSurface) -> Vec<(WlSurface, Point<i32, Logical>)> {
     PopupManager::popups_for_surface(root)
-        .map(|(popup, at)| {
-            (
-                popup.wl_surface().clone(),
-                geometry_at + at - popup.geometry().loc,
-            )
-        })
+        .map(|(popup, at)| (popup.wl_surface().clone(), at - popup.geometry().loc))
         .collect()
 }
 
@@ -150,20 +152,28 @@ pub fn hit(
     })
 }
 
-/// Draws `root`'s popups with its window geometry at `geometry_at`.
+/// Draws `root`'s popups with its window geometry at `geometry_at` pixels.
 pub fn elements(
     out: &mut Vec<Draw>,
     renderer: &mut VulkanRenderer,
     root: &WlSurface,
-    geometry_at: Point<i32, Logical>,
+    geometry_at: Point<i32, Physical>,
+    scale: f64,
     alpha: f32,
 ) {
-    for (popup, at) in placed(root, geometry_at) {
-        let at = Point::<i32, Physical>::from((at.x, at.y));
+    for (popup, offset) in offsets(root) {
+        let at = geometry_at + crate::scene::to_physical((offset.x.into(), offset.y.into()), scale);
         out.extend(
-            render_elements_from_surface_tree(renderer, &popup, at, 1.0, alpha, Kind::Unspecified)
-                .into_iter()
-                .map(Draw::Surface),
+            render_elements_from_surface_tree(
+                renderer,
+                &popup,
+                at,
+                scale,
+                alpha,
+                Kind::Unspecified,
+            )
+            .into_iter()
+            .map(Draw::Surface),
         );
     }
 }

Modified file: crates/monolith/src/scene.rs+160 additions−104 deletions@@ -9,12 +9,11 @@ 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;
-use smithay::backend::renderer::element::texture::TextureRenderElement;
 use smithay::backend::renderer::element::utils::{CropRenderElement, RescaleRenderElement};
 use smithay::backend::renderer::element::{AsRenderElements, Element, Id, Kind, RenderElement};
 use smithay::backend::renderer::utils::with_renderer_surface_state;
 use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
-use smithay::backend::renderer::{ContextId, Renderer, Texture};
+use smithay::backend::renderer::{Frame, Renderer, Texture};
 use smithay::desktop::Window;
 use smithay::output::Output;
 use smithay::utils::user_data::UserDataMap;
@@ -26,8 +25,7 @@ smithay::backend::renderer::element::render_elements! {
     pub Draw<=VulkanRenderer>;
     Surface=WaylandSurfaceRenderElement<VulkanRenderer>,
     Cropped=CropRenderElement<WaylandSurfaceRenderElement<VulkanRenderer>>,
-    Texture=TextureRenderElement<VulkanTexture>,
-    Effect=EffectElement,
+    Texture=PlacedTexture,
     Border=SolidColorRenderElement,
     Memory=MemoryRenderBufferRenderElement<VulkanRenderer>,
     Rescaled=RescaleRenderElement<WaylandSurfaceRenderElement<VulkanRenderer>>,
@@ -54,6 +52,7 @@ pub fn build(
     let Some(area) = layout.output(o).map(|out| out.area) else {
         return Vec::new();
     };
+    let scale = output.map_or(1.0, |o| o.current_scale().fractional_scale());
     let local = |r: Rect| Rect::new(r.x - area.x, r.y - area.y, r.w, r.h);
     let mut ghosts = Vec::new();
     let mut tiled = Vec::new();
@@ -107,11 +106,21 @@ pub fn build(
             continue;
         };
         let loc = x.geometry().loc;
-        let at = Point::<i32, Physical>::from((loc.x - area.x as i32, loc.y - area.y as i32));
+        let at = to_physical(
+            (f64::from(loc.x) - area.x, f64::from(loc.y) - area.y),
+            scale,
+        );
         out.extend(
-            render_elements_from_surface_tree(renderer, &surface, at, 1.0, 1.0, Kind::Unspecified)
-                .into_iter()
-                .map(Draw::Surface),
+            render_elements_from_surface_tree(
+                renderer,
+                &surface,
+                at,
+                scale,
+                1.0,
+                Kind::Unspecified,
+            )
+            .into_iter()
+            .map(Draw::Surface),
         );
     }
     if let Some(output) = output {
@@ -128,11 +137,18 @@ pub fn build(
         let Some(root) = windows.get(id).and_then(|s| s.window.toplevel()) else {
             continue;
         };
-        let Some(((x, y), _)) = pixels(r) else {
+        let Some(((x, y), _)) = pixels(r, scale) else {
             continue;
         };
         let alpha = anim.effect(id, now).map_or(1.0, |e| e.progress);
-        crate::popups::elements(&mut out, renderer, root.wl_surface(), (x, y).into(), alpha);
+        crate::popups::elements(
+            &mut out,
+            renderer,
+            root.wl_surface(),
+            (x, y).into(),
+            scale,
+            alpha,
+        );
     }
     if let Some(output) = output
         && !fullscreen_at_rest
@@ -140,7 +156,13 @@ pub fn build(
         crate::layers::lower_popups(&mut out, renderer, output);
     }
     for (g, frame, r) in fading.into_iter().rev() {
-        out.extend(ghost_element(frame, r, anim.ghost_effect(g, now), deco));
+        out.extend(ghost_element(
+            frame,
+            r,
+            anim.ghost_effect(g, now),
+            deco,
+            scale,
+        ));
     }
     for (id, r, framed, gliding) in tiled.into_iter().chain(above).rev() {
         let Some(state) = windows.get_mut(id) else {
@@ -148,8 +170,8 @@ pub fn build(
         };
         let effect = anim.effect(id, now);
         let first = out.len();
-        window_elements(&mut out, renderer, &state.window, r, effect, gliding);
-        let clip = framed.then(|| corner_clip(r, deco)).flatten();
+        window_elements(&mut out, renderer, &state.window, r, effect, gliding, scale);
+        let clip = framed.then(|| corner_clip(r, deco, scale)).flatten();
         if let Some(clip) = clip {
             clip_window(&mut out, first, clip);
         }
@@ -164,14 +186,20 @@ pub fn build(
             let alpha = effect.map_or(1.0, |e| e.progress);
             let borders = &mut state.borders;
             let first = out.len();
-            border_elements(&mut out, borders, r, deco, color, alpha);
+            border_elements(&mut out, borders, r, deco, color, alpha, scale);
             if let Some(clip) = clip {
-                ring_borders(&mut out, first, clip, deco.border as i32);
+                ring_borders(&mut out, first, clip, border_width(deco, scale));
             }
         }
     }
     for (g, frame, r) in ghosts.into_iter().rev() {
-        out.extend(ghost_element(frame, r, anim.ghost_effect(g, now), deco));
+        out.extend(ghost_element(
+            frame,
+            r,
+            anim.ghost_effect(g, now),
+            deco,
+            scale,
+        ));
     }
     if let Some(output) = output {
         crate::layers::elements(&mut out, renderer, output, Layer::Bottom);
@@ -191,42 +219,53 @@ fn window_elements(
     r: Rect,
     effect: Option<Effect>,
     scaled: bool,
+    scale: f64,
 ) {
-    let Some(((x, y), (w, h))) = pixels(r) else {
+    let Some(((x, y), (w, h))) = pixels(r, scale) else {
         return;
     };
     let geo = window.geometry();
-    let loc = Point::<i32, Physical>::from((x - geo.loc.x, y - geo.loc.y));
+    let inset = geo.loc.to_physical_precise_round::<_, i32>(scale);
+    let drawn: Size<i32, Physical> = geo.size.to_physical_precise_round(scale);
+    let loc = Point::<i32, Physical>::from((x - inset.x, y - inset.y));
     let alpha = effect.map_or(1.0, |e| e.progress);
     let elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>> = match window.toplevel() {
         Some(t) => render_elements_from_surface_tree(
             renderer,
             t.wl_surface(),
             loc,
-            1.0,
+            scale,
             alpha,
             Kind::Unspecified,
         ),
-        None => window.render_elements(renderer, loc, Scale::from(1.0), alpha),
+        None => window.render_elements(renderer, loc, Scale::from(scale), alpha),
     };
     if let Some(effect) = effect {
-        effect_elements(out, renderer, window, elems, ((x, y), (w, h)), effect);
+        effect_elements(
+            out,
+            renderer,
+            window,
+            elems,
+            ((x, y), (w, h)),
+            effect,
+            scale,
+        );
         return;
     }
-    if scaled && geo.size.w > 0 && geo.size.h > 0 {
-        let scale = Scale::from((
-            f64::from(w) / f64::from(geo.size.w),
-            f64::from(h) / f64::from(geo.size.h),
+    if scaled && drawn.w > 0 && drawn.h > 0 {
+        let factor = Scale::from((
+            f64::from(w) / f64::from(drawn.w),
+            f64::from(h) / f64::from(drawn.h),
         ));
         let origin = Point::<i32, Physical>::from((x, y));
         out.extend(
             elems
                 .into_iter()
-                .map(|e| Draw::Rescaled(RescaleRenderElement::from_element(e, origin, scale))),
+                .map(|e| Draw::Rescaled(RescaleRenderElement::from_element(e, origin, factor))),
         );
         return;
     }
-    if (w, h) == (geo.size.w, geo.size.h) {
+    if (w, h) == (drawn.w, drawn.h) {
         out.extend(elems.into_iter().map(Draw::Surface));
         return;
     }
@@ -234,14 +273,14 @@ fn window_elements(
     out.extend(
         elems
             .into_iter()
-            .filter_map(|e| CropRenderElement::from_element(e, 1.0, crop))
+            .filter_map(|e| CropRenderElement::from_element(e, scale, crop))
             .map(Draw::Cropped),
     );
     let Some(root) = crate::wm::root(window) else {
         return;
     };
     let context = renderer.context_id();
-    let Some((tex, scale, transform)) = with_renderer_surface_state(&root, |s| {
+    let Some((tex, buffer_scale, transform)) = with_renderer_surface_state(&root, |s| {
         s.texture::<VulkanTexture>(context.clone())
             .cloned()
             .map(|t| (t, s.buffer_scale(), s.buffer_transform()))
@@ -249,28 +288,33 @@ fn window_elements(
     .flatten() else {
         return;
     };
-    let (gw, gh) = (geo.size.w, geo.size.h);
+    let (gw, gh) = (drawn.w, drawn.h);
     let (cw, ch) = (w.min(gw), h.min(gh));
-    let (gx, gy) = (geo.loc.x as f64, geo.loc.y as f64);
+    let (gx, gy) = (f64::from(geo.loc.x), f64::from(geo.loc.y));
     let mut strip = |src: Rectangle<f64, Logical>, at: (i32, i32), size: (i32, i32)| {
         if size.0 >= 1 && size.1 >= 1 {
-            out.push(texture(&context, &tex, scale, transform, src, at, size));
+            let bounds = tex.size().to_logical(buffer_scale, transform).to_f64();
+            let src = src.to_buffer(f64::from(buffer_scale), transform, &bounds);
+            out.push(Draw::Texture(PlacedTexture::new(
+                &tex, transform, src, at, size, None,
+            )));
         }
     };
-    let right = gx + f64::from(gw) - 1.0;
-    let bottom = gy + f64::from(gh) - 1.0;
+    let pixel = 1.0 / f64::from(buffer_scale);
+    let right = gx + f64::from(geo.size.w) - pixel;
+    let bottom = gy + f64::from(geo.size.h) - pixel;
     strip(
-        Rectangle::new((right, gy).into(), (1.0, f64::from(ch)).into()),
+        Rectangle::new((right, gy).into(), (pixel, f64::from(ch) / scale).into()),
         (x + gw, y),
         (w - gw, ch),
     );
     strip(
-        Rectangle::new((gx, bottom).into(), (f64::from(cw), 1.0).into()),
+        Rectangle::new((gx, bottom).into(), (f64::from(cw) / scale, pixel).into()),
         (x, y + gh),
         (cw, h - gh),
     );
     strip(
-        Rectangle::new((right, bottom).into(), (1.0, 1.0).into()),
+        Rectangle::new((right, bottom).into(), (pixel, pixel).into()),
         (x + gw, y + gh),
         (w - gw, h - gh),
     );
@@ -286,12 +330,13 @@ fn border_elements(
     deco: &Decoration,
     color: [f32; 4],
     alpha: f32,
+    scale: f64,
 ) {
-    let Some(((x, y), (w, h))) = pixels(r) else {
+    let Some(((x, y), (w, h))) = pixels(r, scale) else {
         return;
     };
-    let b = deco.border as i32;
-    let reach = deco.radius.0.into_iter().max().unwrap_or(0) as i32;
+    let b = border_width(deco, scale);
+    let reach = (f64::from(deco.radius.0.into_iter().max().unwrap_or(0)) * scale).round() as i32;
     let reach = reach.min(w / 2).min(h / 2);
     let strips = [
         ((x - b, y - b), (w + 2 * b, b + reach)),
@@ -313,37 +358,25 @@ fn border_elements(
     }
 }
 
-/// Snaps a logical rect to whole pixels by rounding its edges, so neighbours
-/// that share an edge stay flush.
-fn pixels(r: Rect) -> Option<((i32, i32), (i32, i32))> {
-    let (x, y) = (r.x.round() as i32, r.y.round() as i32);
-    let w = r.right().round() as i32 - x;
-    let h = r.bottom().round() as i32 - y;
+/// Snaps a logical rect to whole physical pixels by rounding its edges, so
+/// neighbours that share an edge stay flush.
+fn pixels(r: Rect, scale: f64) -> Option<((i32, i32), (i32, i32))> {
+    let (x, y) = ((r.x * scale).round() as i32, (r.y * scale).round() as i32);
+    let w = (r.right() * scale).round() as i32 - x;
+    let h = (r.bottom() * scale).round() as i32 - y;
     (w >= 1 && h >= 1).then_some(((x, y), (w, h)))
 }
 
-fn texture(
-    context: &ContextId<VulkanTexture>,
-    texture: &VulkanTexture,
-    scale: i32,
-    transform: Transform,
-    src: Rectangle<f64, Logical>,
-    at: (i32, i32),
-    size: (i32, i32),
-) -> Draw {
-    Draw::Texture(TextureRenderElement::from_static_texture(
-        Id::new(),
-        context.clone(),
-        Point::<f64, Physical>::from((f64::from(at.0), f64::from(at.1))),
-        texture.clone(),
-        scale,
-        transform,
-        None,
-        Some(src),
-        Some(Size::from(size)),
-        None,
-        Kind::Unspecified,
-    ))
+pub fn to_physical(p: (f64, f64), scale: f64) -> Point<i32, Physical> {
+    ((p.0 * scale).round() as i32, (p.1 * scale).round() as i32).into()
+}
+
+/// The border width in physical pixels, the same on every side of a window.
+fn border_width(deco: &Decoration, scale: f64) -> i32 {
+    match deco.border {
+        0 => 0,
+        b => ((f64::from(b) * scale).round() as i32).max(1),
+    }
 }
 
 /// A window in a spawn transition. Its root surface goes through the effect
@@ -355,6 +388,7 @@ fn effect_elements(
     elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>>,
     (at, size): ((i32, i32), (i32, i32)),
     effect: Effect,
+    scale: f64,
 ) {
     let Some(root) = crate::wm::root(window) else {
         return;
@@ -372,46 +406,52 @@ fn effect_elements(
         elems
             .into_iter()
             .filter(|e| root_tex.is_none() || *e.id() != root_id)
-            .filter_map(|e| CropRenderElement::from_element(e, 1.0, crop))
+            .filter_map(|e| CropRenderElement::from_element(e, scale, crop))
             .map(Draw::Cropped),
     );
-    if let Some((tex, scale, transform)) = root_tex {
+    if let Some((tex, buffer_scale, transform)) = root_tex {
         let geo = window.geometry();
         let src = Rectangle::new(
             geo.loc.to_f64(),
-            (f64::from(size.0), f64::from(size.1)).into(),
+            (f64::from(size.0) / scale, f64::from(size.1) / scale).into(),
         );
-        out.push(Draw::Effect(EffectElement::new(
-            &tex, scale, transform, src, at, size, effect,
+        let bounds = tex.size().to_logical(buffer_scale, transform).to_f64();
+        let src = src.to_buffer(f64::from(buffer_scale), transform, &bounds);
+        out.push(Draw::Texture(PlacedTexture::new(
+            &tex,
+            transform,
+            src,
+            at,
+            size,
+            Some(effect),
         )));
     }
 }
 
-/// A texture drawn through the transition hook in the effect shader.
-pub struct EffectElement {
+/// A texture at a physical rectangle, drawn plainly or through the
+/// transition hook in the effect shader.
+pub struct PlacedTexture {
     id: Id,
     texture: VulkanTexture,
     src: Rectangle<f64, Buffer>,
     geometry: Rectangle<i32, Physical>,
     transform: Transform,
-    effect: Effect,
+    effect: Option<Effect>,
 }
 
-impl EffectElement {
+impl PlacedTexture {
     fn new(
         texture: &VulkanTexture,
-        scale: i32,
         transform: Transform,
-        src: Rectangle<f64, Logical>,
+        src: Rectangle<f64, Buffer>,
         at: (i32, i32),
         size: (i32, i32),
-        effect: Effect,
+        effect: Option<Effect>,
     ) -> Self {
-        let bounds = texture.size().to_logical(scale, transform).to_f64();
         Self {
             id: Id::new(),
             texture: texture.clone(),
-            src: src.to_buffer(f64::from(scale), transform, &bounds),
+            src,
             geometry: Rectangle::new(at.into(), size.into()),
             transform,
             effect,
@@ -419,7 +459,7 @@ impl EffectElement {
     }
 }
 
-impl Element for EffectElement {
+impl Element for PlacedTexture {
     fn id(&self) -> &Id {
         &self.id
     }
@@ -441,59 +481,75 @@ impl Element for EffectElement {
     }
 }
 
-impl RenderElement<VulkanRenderer> for EffectElement {
+impl RenderElement<VulkanRenderer> for PlacedTexture {
     fn draw(
         &self,
         frame: &mut VulkanFrame<'_, '_>,
         src: Rectangle<f64, Buffer>,
         dst: Rectangle<i32, Physical>,
         damage: &[Rectangle<i32, Physical>],
-        _opaque_regions: &[Rectangle<i32, Physical>],
+        opaque_regions: &[Rectangle<i32, Physical>],
         _cache: Option<&UserDataMap>,
     ) -> Result<(), monolith_render_vk::Error> {
-        frame.render_effect(
-            &self.texture,
-            src,
-            dst,
-            damage,
-            self.transform,
-            1.0,
-            self.effect,
-        )
+        match self.effect {
+            Some(effect) => {
+                frame.render_effect(&self.texture, src, dst, damage, self.transform, 1.0, effect)
+            }
+            None => frame.render_texture_from_to(
+                &self.texture,
+                src,
+                dst,
+                damage,
+                opaque_regions,
+                self.transform,
+                1.0,
+            ),
+        }
     }
 }
 
-fn ghost_element(frame: &LastFrame, r: Rect, effect: Effect, deco: &Decoration) -> Option<Draw> {
-    let (at, size) = pixels(r)?;
+fn ghost_element(
+    frame: &LastFrame,
+    r: Rect,
+    effect: Effect,
+    deco: &Decoration,
+    scale: f64,
+) -> Option<Draw> {
+    let (at, size) = pixels(r, scale)?;
     let src = Rectangle::new(
         frame.geometry.loc.to_f64(),
-        (f64::from(size.0), f64::from(size.1)).into(),
+        (f64::from(size.0) / scale, f64::from(size.1) / scale).into(),
     );
-    let ghost = Draw::Effect(EffectElement::new(
+    let bounds = frame
+        .texture
+        .size()
+        .to_logical(frame.scale, frame.transform)
+        .to_f64();
+    let src = src.to_buffer(f64::from(frame.scale), frame.transform, &bounds);
+    let ghost = Draw::Texture(PlacedTexture::new(
         &frame.texture,
-        frame.scale,
         frame.transform,
         src,
         at,
         size,
-        effect,
+        Some(effect),
     ));
-    Some(match corner_clip(r, deco) {
+    Some(match corner_clip(r, deco, scale) {
         Some(clip) => Draw::Clipped(ClipElement::new(ghost, clip)),
         None => ghost,
     })
 }
 
 /// The rounded outline of a framed window at `r`, if it has one.
-fn corner_clip(r: Rect, deco: &Decoration) -> Option<Clip> {
+fn corner_clip(r: Rect, deco: &Decoration, scale: f64) -> Option<Clip> {
     let radii = deco.radius.0;
     if radii == [0; 4] {
         return None;
     }
-    let (at, size) = pixels(r)?;
+    let (at, size) = pixels(r, scale)?;
     Some(Clip {
         rect: Rectangle::new(at.into(), size.into()),
-        radii: radii.map(|r| r as f32),
+        radii: radii.map(|r| r as f32 * scale as f32),
         ring: 0.0,
     })
 }

monolith

Commit 2e852b236c45

Commit `2e852b236c45`