monolith

public

Star0

Fork 0

Watch0

128 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `0b68ce424a32`

tarball

atagen <boss@atagen.co>2026-10-18 03:18 UTC

2 files changed+61-4

render-vk: map draws through the rotated output size

Draws arrive in the output space after the transform, but VulkanFrame mapped them into the framebuffer against the unrotated size. For 90 and 270 degree transforms on a non-square output that put content at a large offset or skewed it, while 180 hid the bug by keeping the size. Smithay's pixman and GLES renderers both swap the size first.

Modified file: crates/render-vk/src/frame.rs+8 additions−4 deletions@@ -27,6 +27,9 @@ pub struct VulkanFrame<'frame, 'buffer> {
     renderer: &'frame mut VulkanRenderer,
     target: &'frame mut VulkanTarget<'buffer>,
     output: Size<i32, Physical>,
+    /// The output rotated into the space draws are given in, which differs
+    /// from `output` for 90 and 270 degree transforms.
+    area: Size<i32, Physical>,
     transform: Transform,
     ops: Vec<Op>,
     clip: Option<Clip>,
@@ -63,6 +66,7 @@ impl<'frame, 'buffer> VulkanFrame<'frame, 'buffer> {
             renderer,
             target,
             output,
+            area: transform.transform_size(output),
             transform,
             ops: Vec::new(),
             clip: None,
@@ -81,7 +85,7 @@ impl<'frame, 'buffer> VulkanFrame<'frame, 'buffer> {
         };
         let [tl, tr, br, bl] = c.radii;
         let corners = [[tl, 0.0], [tr, 0.0], [bl, 0.0], [br, 0.0]];
-        let (fb, r) = to_framebuffer(c.rect, corners, self.output, self.transform);
+        let (fb, r) = to_framebuffer(c.rect, corners, self.area, self.transform);
         let rect = [
             fb.loc.x as f32,
             fb.loc.y as f32,
@@ -98,7 +102,7 @@ impl<'frame, 'buffer> VulkanFrame<'frame, 'buffer> {
     }
 
     fn fb_rect(&self, r: Rectangle<i32, Physical>) -> Option<vk::Rect2D> {
-        let r = rect_to_framebuffer(r, self.output, self.transform)
+        let r = rect_to_framebuffer(r, self.area, self.transform)
             .intersection(Rectangle::from_size(self.fb_size()))?;
         Some(vk::Rect2D {
             offset: vk::Offset2D {
@@ -175,7 +179,7 @@ impl<'frame, 'buffer> VulkanFrame<'frame, 'buffer> {
             return Ok(());
         }
         let uvs = texture_uvs(src, dst.size, texture.size(), src_transform);
-        let (fb, uv) = to_framebuffer(dst, uvs, self.output, self.transform);
+        let (fb, uv) = to_framebuffer(dst, uvs, self.area, self.transform);
         let (clip, radii, ring) = self.clip_push();
         let push = Push {
             dst: self.ndc(fb),
@@ -236,7 +240,7 @@ impl Frame for VulkanFrame<'_, '_> {
         if scissors.is_empty() {
             return Ok(());
         }
-        let (fb, _) = to_framebuffer(dst, [[0.0; 2]; 4], self.output, self.transform);
+        let (fb, _) = to_framebuffer(dst, [[0.0; 2]; 4], self.area, self.transform);
         let (clip, radii, ring) = self.clip_push();
         let push = Push {
             dst: self.ndc(fb),

Modified file: crates/render-vk/tests/golden.rs+53 additions@@ -185,3 +185,56 @@ fn clip_radius_stays_on_its_corner_when_rotated() {
     }
     assert_eq!(at(&px, W / 2, H / 2), GREEN);
 }
+
+/// Draws arrive in the rotated space, which for a quarter turn on a wide
+/// output is tall, so its far corner has to land inside the framebuffer.
+#[test]
+fn quarter_turn_on_a_wide_output_fills_it() {
+    let (fw, fh) = (64, 32);
+    let mut renderer = VulkanRenderer::new().expect("no usable Vulkan device");
+    let mut image = renderer
+        .create_buffer(Fourcc::Argb8888, (fw, fh).into())
+        .unwrap();
+    for transform in [Transform::_90, Transform::_270, Transform::Flipped90] {
+        let mut target = renderer.bind(&mut image).unwrap();
+        let mut frame = renderer
+            .render(&mut target, (fw, fh).into(), transform)
+            .unwrap();
+        let area = Rectangle::from_size((fh, fw).into());
+        frame.clear(rgba(BLACK), &[area]).unwrap();
+        let near = Rectangle::new((0, 0).into(), (8, 8).into());
+        let far = Rectangle::new((fh - 8, fw - 8).into(), (8, 8).into());
+        frame
+            .draw_solid(near, &[Rectangle::from_size(near.size)], rgba(GREEN))
+            .unwrap();
+        frame
+            .draw_solid(far, &[Rectangle::from_size(far.size)], rgba(RED))
+            .unwrap();
+        frame.finish().unwrap().wait().unwrap();
+        drop(target);
+        let target = renderer.bind(&mut image).unwrap();
+        let mapping = renderer
+            .copy_framebuffer(
+                &target,
+                Rectangle::from_size((fw, fh).into()),
+                Fourcc::Abgr8888,
+            )
+            .unwrap();
+        let px = renderer
+            .map_texture(&mapping)
+            .unwrap()
+            .as_chunks::<4>()
+            .0
+            .to_vec();
+        let at = |x: i32, y: i32| px[(y * fw + x) as usize];
+        let corners = [(0, 0), (fw - 1, 0), (0, fh - 1), (fw - 1, fh - 1)];
+        let green: Vec<_> = corners
+            .iter()
+            .filter(|&&(x, y)| at(x, y) == GREEN)
+            .collect();
+        let red: Vec<_> = corners.iter().filter(|&&(x, y)| at(x, y) == RED).collect();
+        assert_eq!((green.len(), red.len()), (1, 1), "{transform:?}");
+        let (g, r) = (green[0], red[0]);
+        assert!(g.0 != r.0 && g.1 != r.1, "{transform:?} not diagonal");
+    }
+}

monolith

Commit 0b68ce424a32

Commit `0b68ce424a32`