monolith

public

Star0

Fork 0

Watch0

111 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `47259c39793f`

tarball

atagen <boss@atagen.co>2026-10-17 10:20 UTC

12 files changed+361-16

render-vk, monolith: round window corners and borders

Every fragment shader cuts its draw to an optional rounded rect from push constants, so windows, ghosts, spawn effects and borders share one clip. The radius comes from decoration.radius, as one number or four corners. Clipped windows report their corners as see-through, or the damage tracker would skip what shows through them.

Modified file: crates/config/default.toml+6 additions@@ -17,10 +17,16 @@ focus_follows_mouse = false
 # Put the pointer in the middle of a window focused from the keyboard, a
 # rule or a new map. Bare metal only, a nested pointer belongs to the host.
 mouse_follows_focus = false
+# A window landing on an empty tag that is not in view brings the tag into
+# view, alongside the tags already shown.
+view_tag_on_first_window = true
 
 [decoration]
 # Borders sit in the gap around each window, so keep them under half the inner gap.
 border = 2
+# Corner radius, one number or [top left, top right, bottom right, bottom left].
+# Fullscreen windows stay square.
+radius = 0
 focused = "#88bfd1"
 unfocused = "#3b4252"
 

Modified file: crates/config/src/lib.rs+28 additions@@ -33,6 +33,9 @@ pub struct General {
     pub move_mode: MoveMode,
     pub focus_follows_mouse: bool,
     pub mouse_follows_focus: bool,
+    /// The first window on an empty tag nobody is viewing brings that tag
+    /// into view on its output.
+    pub view_tag_on_first_window: bool,
 }
 
 #[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
@@ -53,6 +56,7 @@ impl Default for General {
             move_mode: MoveMode::Swap,
             focus_follows_mouse: false,
             mouse_follows_focus: false,
+            view_tag_on_first_window: true,
         }
     }
 }
@@ -94,14 +98,38 @@ pub enum Vrr {
 pub struct Decoration {
     /// Border width in logical pixels, drawn in the gap around each window.
     pub border: u32,
+    pub radius: Corners,
     pub focused: Color,
     pub unfocused: Color,
 }
 
+/// Corner radii in logical pixels, top left, top right, bottom right and
+/// bottom left. One number rounds every corner alike.
+#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
+#[serde(from = "CornersToml")]
+pub struct Corners(pub [u32; 4]);
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+enum CornersToml {
+    All(u32),
+    Each([u32; 4]),
+}
+
+impl From<CornersToml> for Corners {
+    fn from(c: CornersToml) -> Self {
+        match c {
+            CornersToml::All(r) => Self([r; 4]),
+            CornersToml::Each(r) => Self(r),
+        }
+    }
+}
+
 impl Default for Decoration {
     fn default() -> Self {
         Self {
             border: 2,
+            radius: Corners([0; 4]),
             focused: Color::rgb(0x88, 0xbf, 0xd1),
             unfocused: Color::rgb(0x3b, 0x42, 0x52),
         }

Modified file: crates/monolith/src/scene.rs+210 additions−11 deletions@@ -4,7 +4,7 @@
 use crate::wm::Wm;
 use monolith_config::Decoration;
 use monolith_layout::{OutputId, Rect};
-use monolith_render_vk::{Effect, VulkanFrame, VulkanRenderer, VulkanTexture};
+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;
@@ -12,13 +12,14 @@ use smithay::backend::renderer::element::surface::render_elements_from_surface_t
 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::CommitCounter;
 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::desktop::Window;
+use smithay::desktop::{PopupManager, Window};
 use smithay::output::Output;
 use smithay::utils::user_data::UserDataMap;
 use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform};
+use smithay::wayland::compositor::{TraversalAction, with_surface_tree_downward};
 use smithay::wayland::shell::wlr_layer::Layer;
 use smithay::xwayland::X11Surface;
 
@@ -31,6 +32,7 @@ smithay::backend::renderer::element::render_elements! {
     Border=SolidColorRenderElement,
     Memory=MemoryRenderBufferRenderElement<VulkanRenderer>,
     Rescaled=RescaleRenderElement<WaylandSurfaceRenderElement<VulkanRenderer>>,
+    Clipped=ClipElement,
 }
 
 /// Elements for output `o` in its own coordinates, front to back.
@@ -111,7 +113,12 @@ pub fn build(
             continue;
         };
         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();
+        if let Some(clip) = clip {
+            clip_window(&mut out, first, &state.window, clip);
+        }
         if framed && deco.border > 0 {
             let color = if focused == Some(id) {
                 deco.focused.0
@@ -120,7 +127,11 @@ pub fn build(
             };
             let alpha = effect.map_or(1.0, |e| e.progress);
             let borders = &mut state.borders;
-            border_elements(&mut out, borders, r, deco.border as i32, color, alpha);
+            let first = out.len();
+            border_elements(&mut out, borders, r, deco, color, alpha);
+            if let Some(clip) = clip {
+                ring_borders(&mut out, first, clip, deco.border as i32);
+            }
         }
     }
     for (g, frame, r) in ghosts.into_iter().rev() {
@@ -131,7 +142,7 @@ pub fn build(
             frame.geometry.loc.to_f64(),
             (f64::from(size.0), f64::from(size.1)).into(),
         );
-        out.push(Draw::Effect(EffectElement::new(
+        let ghost = Draw::Effect(EffectElement::new(
             &frame.texture,
             frame.scale,
             frame.transform,
@@ -139,7 +150,11 @@ pub fn build(
             at,
             size,
             anim.ghost_effect(g, now),
-        )));
+        ));
+        out.push(match corner_clip(r, deco) {
+            Some(clip) => Draw::Clipped(ClipElement::new(ghost, clip)),
+            None => ghost,
+        });
     }
     if let Some(output) = output {
         crate::layers::elements(&mut out, renderer, output, Layer::Bottom);
@@ -236,22 +251,27 @@ fn window_elements(
 }
 
 /// Four strips just outside `r`, in the gap, so the client keeps its size.
+/// With rounded corners they reach in by the largest radius, to cover the
+/// band the ring curves through inside the window's corners.
 fn border_elements(
     out: &mut Vec<Draw>,
     borders: &mut Option<[SolidColorBuffer; 4]>,
     r: Rect,
-    b: i32,
+    deco: &Decoration,
     color: [f32; 4],
     alpha: f32,
 ) {
     let Some(((x, y), (w, h))) = pixels(r) else {
         return;
     };
+    let b = deco.border as i32;
+    let reach = deco.radius.0.into_iter().max().unwrap_or(0) as i32;
+    let reach = reach.min(w / 2).min(h / 2);
     let strips = [
-        ((x - b, y - b), (w + 2 * b, b)),
-        ((x - b, y + h), (w + 2 * b, b)),
-        ((x - b, y), (b, h)),
-        ((x + w, y), (b, h)),
+        ((x - b, y - b), (w + 2 * b, b + reach)),
+        ((x - b, y + h - reach), (w + 2 * b, b + reach)),
+        ((x - b, y + reach), (b + reach, h - 2 * reach)),
+        ((x + w - reach, y + reach), (b + reach, h - 2 * reach)),
     ];
     let buffers = borders
         .get_or_insert_with(|| std::array::from_fn(|_| SolidColorBuffer::new((0, 0), color)));
@@ -416,3 +436,182 @@ impl RenderElement<VulkanRenderer> for EffectElement {
         )
     }
 }
+
+/// The rounded outline of a framed window at `r`, if it has one.
+fn corner_clip(r: Rect, deco: &Decoration) -> Option<Clip> {
+    let radii = deco.radius.0;
+    if radii == [0; 4] {
+        return None;
+    }
+    let (at, size) = pixels(r)?;
+    Some(Clip {
+        rect: Rectangle::new(at.into(), size.into()),
+        radii: radii.map(|r| r as f32),
+        ring: 0.0,
+    })
+}
+
+/// Clips what a window drew from `first` on, leaving its popups whole.
+fn clip_window(out: &mut [Draw], first: usize, window: &Window, clip: Clip) {
+    let mut popups = std::collections::HashSet::new();
+    if let Some(root) = crate::wm::root(window) {
+        for (popup, _) in PopupManager::popups_for_surface(&root) {
+            with_surface_tree_downward(
+                popup.wl_surface(),
+                (),
+                |_, _, _| TraversalAction::DoChildren(()),
+                |s, _, _| {
+                    popups.insert(Id::from_wayland_resource(s));
+                },
+                |_, _, _| true,
+            );
+        }
+    }
+    for draw in &mut out[first..] {
+        if !popups.contains(draw.id()) {
+            wrap(draw, clip);
+        }
+    }
+}
+
+/// Turns the border strips from `first` on into a ring around the window's
+/// rounded outline.
+fn ring_borders(out: &mut [Draw], first: usize, window: Clip, b: i32) {
+    let grow = |r: f32| if r > 0.0 { r + b as f32 } else { 0.0 };
+    let ring = Clip {
+        rect: Rectangle::new(
+            window.rect.loc - Point::from((b, b)),
+            window.rect.size + Size::from((2 * b, 2 * b)),
+        ),
+        radii: window.radii.map(grow),
+        ring: b as f32,
+    };
+    for draw in &mut out[first..] {
+        wrap(draw, ring);
+    }
+}
+
+fn wrap(draw: &mut Draw, clip: Clip) {
+    let inner = std::mem::replace(draw, Draw::Clipped(ClipElement::empty()));
+    *draw = Draw::Clipped(ClipElement::new(inner, clip));
+}
+
+/// Another element drawn through a rounded clip.
+pub struct ClipElement {
+    inner: Option<Box<Draw>>,
+    clip: Clip,
+    id: Id,
+}
+
+impl ClipElement {
+    fn new(inner: Draw, clip: Clip) -> Self {
+        Self {
+            id: inner.id().clone(),
+            inner: Some(Box::new(inner)),
+            clip,
+        }
+    }
+
+    /// A placeholder while an element is moved into its wrapper.
+    fn empty() -> Self {
+        Self {
+            inner: None,
+            clip: Clip {
+                rect: Rectangle::default(),
+                radii: [0.0; 4],
+                ring: 0.0,
+            },
+            id: Id::new(),
+        }
+    }
+
+    fn inner(&self) -> &Draw {
+        self.inner.as_deref().expect("only placeholders are empty")
+    }
+}
+
+impl Element for ClipElement {
+    fn id(&self) -> &Id {
+        &self.id
+    }
+
+    fn current_commit(&self) -> CommitCounter {
+        self.inner().current_commit()
+    }
+
+    fn location(&self, scale: Scale<f64>) -> Point<i32, Physical> {
+        self.inner().location(scale)
+    }
+
+    fn src(&self) -> Rectangle<f64, Buffer> {
+        self.inner().src()
+    }
+
+    fn transform(&self) -> Transform {
+        self.inner().transform()
+    }
+
+    fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
+        self.inner().geometry(scale)
+    }
+
+    fn damage_since(
+        &self,
+        scale: Scale<f64>,
+        commit: Option<CommitCounter>,
+    ) -> DamageSet<i32, Physical> {
+        self.inner().damage_since(scale, commit)
+    }
+
+    /// A ring hides nothing behind it, and a rounded window hides nothing
+    /// behind its corners.
+    fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
+        if self.clip.ring > 0.0 {
+            return OpaqueRegions::default();
+        }
+        let loc = self.geometry(scale).loc;
+        let c = self.clip.rect;
+        let (right, bottom) = (c.loc.x + c.size.w, c.loc.y + c.size.h);
+        let [tl, tr, br, bl] = self.clip.radii.map(|r| r.ceil() as i32);
+        let corners = [
+            Rectangle::new(c.loc, (tl, tl).into()),
+            Rectangle::new((right - tr, c.loc.y).into(), (tr, tr).into()),
+            Rectangle::new((right - br, bottom - br).into(), (br, br).into()),
+            Rectangle::new((c.loc.x, bottom - bl).into(), (bl, bl).into()),
+        ]
+        .map(|mut r| {
+            r.loc -= loc;
+            r
+        });
+        Rectangle::subtract_rects_many(self.inner().opaque_regions(scale), corners)
+            .into_iter()
+            .collect()
+    }
+
+    fn alpha(&self) -> f32 {
+        self.inner().alpha()
+    }
+
+    fn kind(&self) -> Kind {
+        self.inner().kind()
+    }
+}
+
+impl RenderElement<VulkanRenderer> for ClipElement {
+    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.set_clip(Some(self.clip));
+        let drawn = self
+            .inner()
+            .draw(frame, src, dst, damage, opaque_regions, cache);
+        frame.set_clip(None);
+        drawn
+    }
+}

Added file: crates/render-vk/shaders/clip.glsl+24 additions@@ -0,0 +1,24 @@
+// Coverage of the fragment under the push constant clip, a rounded rect in
+// framebuffer pixels with radii TL, TR, BR, BL. A ring keeps only the band
+// that wide inside the edge, for borders.
+float rounded_box(vec2 p, vec2 half_size, float r) {
+    vec2 q = abs(p) - half_size + r;
+    return length(max(q, 0.0)) + min(max(q.x, q.y), 0.0) - r;
+}
+
+float clip_alpha() {
+    if (pc.clip.z <= 0.0) {
+        return 1.0;
+    }
+    vec2 half_size = pc.clip.zw * 0.5;
+    vec2 p = gl_FragCoord.xy - (pc.clip.xy + half_size);
+    float r = p.x < 0.0 ? (p.y < 0.0 ? pc.radii.x : pc.radii.w)
+                        : (p.y < 0.0 ? pc.radii.y : pc.radii.z);
+    float a = clamp(0.5 - rounded_box(p, half_size, r), 0.0, 1.0);
+    float ring = pc.ring.x;
+    if (ring > 0.0) {
+        float inner = rounded_box(p, half_size - ring, max(r - ring, 0.0));
+        a *= clamp(0.5 + inner, 0.0, 1.0);
+    }
+    return a;
+}

Modified file: crates/render-vk/shaders/effect.frag+2 additions−1 deletions@@ -1,6 +1,7 @@
 #version 450
 #extension GL_GOOGLE_include_directive : require
 #include "push.glsl"
+#include "clip.glsl"
 
 layout(set = 0, binding = 0) uniform sampler2D tex;
 layout(location = 0) in vec2 v_uv;
@@ -23,5 +24,5 @@ vec4 effect(vec4 color, vec2 uv, float progress, int kind) {
 
 void main() {
     vec4 color = texture(tex, v_uv) * pc.color.a;
-    out_color = effect(color, v_uv, pc.effect.x, int(pc.effect.y));
+    out_color = effect(color, v_uv, pc.effect.x, int(pc.effect.y)) * clip_alpha();
 }

Modified file: crates/render-vk/shaders/push.glsl+3

@@ -6,4 +6,7 @@ layout(push_constant) uniform Push {

66 vec4 dst;

77 vec2 uv[4];

88 vec4 effect;

9+ vec4 clip;

10+ vec4 radii;

11+ vec4 ring;

912 } pc;

Modified file: crates/render-vk/shaders/solid.frag+2 additions−1 deletions@@ -1,9 +1,10 @@
 #version 450
 #extension GL_GOOGLE_include_directive : require
 #include "push.glsl"
+#include "clip.glsl"
 
 layout(location = 0) out vec4 out_color;
 
 void main() {
-    out_color = pc.color;
+    out_color = pc.color * clip_alpha();
 }

Modified file: crates/render-vk/shaders/texture.frag+2 additions−1 deletions@@ -1,11 +1,12 @@
 #version 450
 #extension GL_GOOGLE_include_directive : require
 #include "push.glsl"
+#include "clip.glsl"
 
 layout(set = 0, binding = 0) uniform sampler2D tex;
 layout(location = 0) in vec2 v_uv;
 layout(location = 0) out vec4 out_color;
 
 void main() {
-    out_color = texture(tex, v_uv) * pc.color.a;
+    out_color = texture(tex, v_uv) * pc.color.a * clip_alpha();
 }

Modified file: crates/render-vk/src/frame.rs+45 additions@@ -29,6 +29,18 @@ pub struct VulkanFrame<'frame, 'buffer> {
     output: Size<i32, Physical>,
     transform: Transform,
     ops: Vec<Op>,
+    clip: Option<Clip>,
+}
+
+/// A rounded rect in output space that later draws are cut to, until
+/// [`VulkanFrame::set_clip`] changes it. A nonzero `ring` keeps only a band
+/// that wide inside the edge.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Clip {
+    pub rect: Rectangle<i32, Physical>,
+    /// Top left, top right, bottom right and bottom left, in pixels.
+    pub radii: [f32; 4],
+    pub ring: f32,
 }
 
 impl std::fmt::Debug for VulkanFrame<'_, '_> {
@@ -53,9 +65,34 @@ impl<'frame, 'buffer> VulkanFrame<'frame, 'buffer> {
             output,
             transform,
             ops: Vec::new(),
+            clip: None,
         }
     }
 
+    pub fn set_clip(&mut self, clip: Option<Clip>) {
+        self.clip = clip;
+    }
+
+    /// The clip's push constants in framebuffer space, where an output
+    /// transform moves each radius to another corner.
+    fn clip_push(&self) -> ([f32; 4], [f32; 4], [f32; 4]) {
+        let Some(c) = self.clip else {
+            return ([0.0; 4], [0.0; 4], [0.0; 4]);
+        };
+        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 rect = [
+            fb.loc.x as f32,
+            fb.loc.y as f32,
+            fb.size.w as f32,
+            fb.size.h as f32,
+        ];
+        let most = fb.size.w.min(fb.size.h) as f32 / 2.0;
+        let radii = [r[0][0], r[1][0], r[3][0], r[2][0]].map(|r| r.min(most));
+        (rect, radii, [c.ring, 0.0, 0.0, 0.0])
+    }
+
     fn fb_size(&self) -> Size<i32, Physical> {
         (self.target.width() as i32, self.target.height() as i32).into()
     }
@@ -139,11 +176,15 @@ impl<'frame, 'buffer> VulkanFrame<'frame, 'buffer> {
         }
         let uvs = texture_uvs(src, dst.size, texture.size(), src_transform);
         let (fb, uv) = to_framebuffer(dst, uvs, self.output, self.transform);
+        let (clip, radii, ring) = self.clip_push();
         let push = Push {
             dst: self.ndc(fb),
             uv,
             color: [1.0, 1.0, 1.0, alpha],
             effect,
+            clip,
+            radii,
+            ring,
         };
         self.ops.push(Op::Draw {
             kind,
@@ -196,11 +237,15 @@ impl Frame for VulkanFrame<'_, '_> {
             return Ok(());
         }
         let (fb, _) = to_framebuffer(dst, [[0.0; 2]; 4], self.output, self.transform);
+        let (clip, radii, ring) = self.clip_push();
         let push = Push {
             dst: self.ndc(fb),
             uv: [[0.0; 2]; 4],
             color: color.components(),
             effect: [0.0; 4],
+            clip,
+            radii,
+            ring,
         };
         self.ops.push(Op::Draw {
             kind: Kind::Solid,

Modified file: crates/render-vk/src/lib.rs+1−1

@@ -23,6 +23,6 @@ mod transform;

2323

2424 pub use dmabuf::VulkanAllocator;

2525 pub use error::Error;

26-pub use frame::{Effect, Transition, VulkanFrame};

26+pub use frame::{Clip, Effect, Transition, VulkanFrame};

2727 pub use image::{VulkanImage, VulkanMapping, VulkanTarget, VulkanTexture};

2828 pub use renderer::{DmabufImporter, ShmStager, StagedShm, VulkanRenderer};

Modified file: crates/render-vk/src/pipeline.rs+4 additions@@ -15,6 +15,10 @@ pub(crate) struct Push {
     pub uv: [[f32; 2]; 4],
     /// Transition progress and kind, read only by `shaders/effect.frag`.
     pub effect: [f32; 4],
+    /// See `shaders/clip.glsl`. A zero width turns clipping off.
+    pub clip: [f32; 4],
+    pub radii: [f32; 4],
+    pub ring: [f32; 4],
 }
 
 impl Push {

Modified file: crates/render-vk/tests/golden.rs+34 additions−1 deletions@@ -1,7 +1,7 @@
 //! Renders small scenes offscreen and checks pixels. Runs on whatever Vulkan
 //! driver is available. `nix flake check` forces lavapipe.
 
-use monolith_render_vk::{VulkanImage, VulkanRenderer, VulkanTexture};
+use monolith_render_vk::{Clip, VulkanImage, VulkanRenderer, VulkanTexture};
 use smithay::backend::allocator::Fourcc;
 use smithay::backend::renderer::{
     Bind, Color32F, ExportMem, Frame, ImportMem, Offscreen, Renderer,
@@ -152,3 +152,36 @@ fn solid_fill_in_the_corner_keeps_its_colour() {
     });
     assert_eq!(at(&s.pixels(), 56, 56), RED);
 }
+
+/// The radius follows its corner through an output rotation.
+#[test]
+fn clip_radius_stays_on_its_corner_when_rotated() {
+    let corners = [(0, 0), (W - 1, 0), (0, H - 1), (W - 1, H - 1)];
+    let mut s = Scene::new();
+    s.draw(Transform::_90, |f| {
+        f.clear(rgba(BLACK), &[full()]).unwrap();
+        let dst = Rectangle::new((0, 0).into(), (4, 4).into());
+        f.draw_solid(dst, &[Rectangle::from_size(dst.size)], rgba(GREEN))
+            .unwrap();
+    });
+    let px = s.pixels();
+    let top_left = corners
+        .into_iter()
+        .find(|&(x, y)| at(&px, x, y) == GREEN)
+        .unwrap();
+    s.draw(Transform::_90, |f| {
+        f.clear(rgba(BLACK), &[full()]).unwrap();
+        f.set_clip(Some(Clip {
+            rect: full(),
+            radii: [20.0, 0.0, 0.0, 0.0],
+            ring: 0.0,
+        }));
+        f.draw_solid(full(), &[full()], rgba(GREEN)).unwrap();
+    });
+    let px = s.pixels();
+    for (x, y) in corners {
+        let expected = if (x, y) == top_left { BLACK } else { GREEN };
+        assert_eq!(at(&px, x, y), expected, "corner {x},{y}");
+    }
+    assert_eq!(at(&px, W / 2, H / 2), GREEN);
+}

monolith

Commit 47259c39793f

Commit `47259c39793f`