monolith

public

Star0

Fork 0

Watch0

220 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `188ed0425658`

tarball

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

3 files changed+63-28

scene: map strips and effects through the surface view

Window strips, spawn effects and ghosts sampled the texture in surface coordinates as if they were its own, which only holds without a viewport destination. A fractional scale client sets one, so the stretched last column came from inside the window.

Modified file: crates/monolith/src/scene.rs+51 additions−20 deletions@@ -12,7 +12,7 @@ use smithay::backend::renderer::element::surface::render_elements_from_surface_t
 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::utils::{CommitCounter, DamageSet, OpaqueRegions, SurfaceView};
 use smithay::backend::renderer::{Frame, Renderer, Texture};
 use smithay::desktop::Window;
 use smithay::output::Output;
@@ -280,17 +280,18 @@ fn window_elements(
         return;
     };
     let context = renderer.context_id();
-    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()))
+    let Some((tex, buffer_scale, transform, view)) = with_renderer_surface_state(&root, |s| {
+        let texture = s.texture::<VulkanTexture>(context.clone())?.clone();
+        Some((texture, s.buffer_scale(), s.buffer_transform(), s.view()?))
     })
     .flatten() else {
         return;
     };
     let (gw, gh) = (drawn.w, drawn.h);
     let (cw, ch) = (w.min(gw), h.min(gh));
-    let (gx, gy) = (f64::from(geo.loc.x), f64::from(geo.loc.y));
+    let ratio = source_ratio(&view);
+    let geo_src = to_source(&view, geo.to_f64());
+    let (gx, gy) = (geo_src.loc.x, geo_src.loc.y);
     let mut strip = |src: Rectangle<f64, Logical>, at: (i32, i32), size: (i32, i32)| {
         if size.0 >= 1 && size.1 >= 1 {
             let bounds = tex.size().to_logical(buffer_scale, transform).to_f64();
@@ -301,15 +302,21 @@ fn window_elements(
         }
     };
     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;
+    let right = gx + geo_src.size.w - pixel;
+    let bottom = gy + geo_src.size.h - pixel;
     strip(
-        Rectangle::new((right, gy).into(), (pixel, f64::from(ch) / scale).into()),
+        Rectangle::new(
+            (right, gy).into(),
+            (pixel, f64::from(ch) / scale * ratio.1).into(),
+        ),
         (x + gw, y),
         (w - gw, ch),
     );
     strip(
-        Rectangle::new((gx, bottom).into(), (f64::from(cw) / scale, pixel).into()),
+        Rectangle::new(
+            (gx, bottom).into(),
+            (f64::from(cw) / scale * ratio.0, pixel).into(),
+        ),
         (x, y + gh),
         (cw, h - gh),
     );
@@ -367,6 +374,25 @@ fn pixels(r: Rect, scale: f64) -> Option<((i32, i32), (i32, i32))> {
     (w >= 1 && h >= 1).then_some(((x, y), (w, h)))
 }
 
+/// How many logical units of the texture one logical unit of the surface
+/// covers, which a viewport destination makes differ from 1.
+fn source_ratio(view: &SurfaceView) -> (f64, f64) {
+    (
+        view.src.size.w / f64::from(view.dst.w.max(1)),
+        view.src.size.h / f64::from(view.dst.h.max(1)),
+    )
+}
+
+/// Maps a rectangle in surface coordinates to the logical coordinates of the
+/// texture behind them.
+pub fn to_source(view: &SurfaceView, r: Rectangle<f64, Logical>) -> Rectangle<f64, Logical> {
+    let (rx, ry) = source_ratio(view);
+    Rectangle::new(
+        (view.src.loc.x + r.loc.x * rx, view.src.loc.y + r.loc.y * ry).into(),
+        (r.size.w * rx, r.size.h * ry).into(),
+    )
+}
+
 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()
 }
@@ -397,9 +423,8 @@ fn effect_elements(
     let crop = Rectangle::new(at.into(), size.into());
     let context = renderer.context_id();
     let root_tex = with_renderer_surface_state(&root, |s| {
-        s.texture::<VulkanTexture>(context.clone())
-            .cloned()
-            .map(|t| (t, s.buffer_scale(), s.buffer_transform()))
+        let texture = s.texture::<VulkanTexture>(context.clone())?.clone();
+        Some((texture, s.buffer_scale(), s.buffer_transform(), s.view()?))
     })
     .flatten();
     out.extend(
@@ -409,11 +434,14 @@ fn effect_elements(
             .filter_map(|e| CropRenderElement::from_element(e, scale, crop))
             .map(Draw::Cropped),
     );
-    if let Some((tex, buffer_scale, transform)) = root_tex {
+    if let Some((tex, buffer_scale, transform, view)) = root_tex {
         let geo = window.geometry();
-        let src = Rectangle::new(
-            geo.loc.to_f64(),
-            (f64::from(size.0) / scale, f64::from(size.1) / scale).into(),
+        let src = to_source(
+            &view,
+            Rectangle::new(
+                geo.loc.to_f64(),
+                (f64::from(size.0) / scale, f64::from(size.1) / scale).into(),
+            ),
         );
         let bounds = tex.size().to_logical(buffer_scale, transform).to_f64();
         let src = src.to_buffer(f64::from(buffer_scale), transform, &bounds);
@@ -516,9 +544,12 @@ fn ghost_element(
     scale: f64,
 ) -> Option<Draw> {
     let (at, size) = pixels(r, scale)?;
-    let src = Rectangle::new(
-        frame.geometry.loc.to_f64(),
-        (f64::from(size.0) / scale, f64::from(size.1) / scale).into(),
+    let src = to_source(
+        &frame.view,
+        Rectangle::new(
+            frame.geometry.loc.to_f64(),
+            (f64::from(size.0) / scale, f64::from(size.1) / scale).into(),
+        ),
     );
     let bounds = frame
         .texture

Modified file: crates/monolith/src/windows.rs+8 additions−8 deletions@@ -434,14 +434,14 @@ impl State {
         // below already holds.
         let geometry = window.geometry();
         with_renderer_surface_state(&surface, |s| {
-            s.texture::<VulkanTexture>(context.clone())
-                .cloned()
-                .map(|texture| LastFrame {
-                    texture,
-                    scale: s.buffer_scale(),
-                    transform: s.buffer_transform(),
-                    geometry,
-                })
+            let texture = s.texture::<VulkanTexture>(context.clone())?.clone();
+            Some(LastFrame {
+                texture,
+                scale: s.buffer_scale(),
+                transform: s.buffer_transform(),
+                geometry,
+                view: s.view()?,
+            })
         })
         .flatten()
     }

Modified file: crates/monolith/src/wm.rs+4 additions@@ -7,6 +7,7 @@ use monolith_layout::{Layout, OutputId, Rect, WindowId};
 use monolith_render_vk::VulkanTexture;
 use slotmap::SecondaryMap;
 use smithay::backend::renderer::element::solid::SolidColorBuffer;
+use smithay::backend::renderer::utils::SurfaceView;
 use smithay::desktop::{PopupManager, Space, Window};
 use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel::State as XdgState;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
@@ -39,6 +40,9 @@ pub struct LastFrame {
     pub transform: Transform,
     /// Window geometry inside the buffer.
     pub geometry: Rectangle<i32, Logical>,
+    /// Where the surface's own coordinates sit in the texture, which a
+    /// viewport makes more than a scale.
+    pub view: SurfaceView,
 }
 
 pub struct Parts<'a> {

monolith

Commit 188ed0425658

Commit `188ed0425658`