monolith

public

Star0

Fork 0

Watch0

258 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `39d2db731e01`

tarball

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

1 file changed+85-41

scene: give overshoot strips the window's opacity and a stable identity

PlacedTexture took a fresh Id and a constant commit counter every frame, so the strips at fractional scales damaged their area on every frame and an idle screen kept flipping. They now keep one Id per window and strip role and follow the root surface's commit. The strips also ignored the opacity rule, window_elements and effect_elements share a Spot instead of positional scale and opacity, and the CSD inset and drawn size round by edges so the crop decision agrees with pixels().

Modified file: crates/monolith/src/scene.rs+85 additions−41 deletions@@ -178,16 +178,8 @@ pub fn build(
         let effect = anim.effect(id, now);
         let first = out.len();
         let opacity = state.rule.opacity.unwrap_or(1.0);
-        window_elements(
-            &mut out,
-            renderer,
-            &state.window,
-            r,
-            effect,
-            gliding,
-            scale,
-            opacity,
-        );
+        let spot = Spot { r, scale, opacity };
+        window_elements(&mut out, renderer, &state.window, &spot, effect, gliding);
         let clip = framed.then(|| corner_clip(r, deco, scale)).flatten();
         if let Some(clip) = clip {
             clip_window(&mut out, first, clip);
@@ -230,23 +222,20 @@ pub fn build(
 /// cropped and one smaller has its last row and column stretched over the
 /// rest, keeping content aligned with its neighbours. A gliding window is
 /// scaled instead, so the client resizing mid-glide does not jump.
-#[expect(clippy::too_many_arguments)]
 fn window_elements(
     out: &mut Vec<Draw>,
     renderer: &mut VulkanRenderer,
     window: &Window,
-    r: Rect,
+    spot: &Spot,
     effect: Option<Effect>,
     scaled: bool,
-    scale: f64,
-    opacity: f32,
 ) {
-    let Some(((x, y), (w, h))) = pixels(r, scale) else {
+    let Spot { scale, opacity, .. } = *spot;
+    let Some(((x, y), (w, h))) = spot.pixels() else {
         return;
     };
     let geo = window.geometry();
-    let inset = geo.loc.to_physical_precise_round::<_, i32>(scale);
-    let drawn: Size<i32, Physical> = geo.size.to_physical_precise_round(scale);
+    let (inset, drawn) = edges(geo, scale);
     let loc = Point::<i32, Physical>::from((x - inset.x, y - inset.y));
     let alpha = effect.map_or(1.0, |e| e.progress) * opacity;
     let elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>> = match window.toplevel() {
@@ -261,16 +250,7 @@ fn window_elements(
         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,
-            scale,
-            opacity,
-        );
+        effect_elements(out, renderer, window, elems, spot, effect);
         return;
     }
     if scaled && drawn.w > 0 && drawn.h > 0 {
@@ -301,31 +281,43 @@ fn window_elements(
         return;
     };
     let context = renderer.context_id();
-    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 {
+    let Some((tex, buffer_scale, transform, view, commit)) =
+        with_renderer_surface_state(&root, |s| {
+            let texture = s.texture::<VulkanTexture>(context.clone())?.clone();
+            Some((
+                texture,
+                s.buffer_scale(),
+                s.buffer_transform(),
+                s.view()?,
+                s.current_commit(),
+            ))
+        })
+        .flatten()
+    else {
         return;
     };
+    let ids = window.user_data().get_or_insert_threadsafe(StripIds::new);
     let (gw, gh) = (drawn.w, drawn.h);
     let (cw, ch) = (w.min(gw), h.min(gh));
     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)| {
+    let mut strip = |id: &Id, 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();
             let src = src.to_buffer(f64::from(buffer_scale), transform, &bounds);
-            out.push(Draw::Texture(PlacedTexture::new(
-                &tex, transform, src, at, size, None,
-            )));
+            let mut placed = PlacedTexture::new(&tex, transform, src, at, size, None);
+            placed.id = id.clone();
+            placed.commit = commit;
+            placed.alpha = opacity;
+            out.push(Draw::Texture(placed));
         }
     };
     let pixel = 1.0 / f64::from(buffer_scale);
     let right = gx + geo_src.size.w - pixel;
     let bottom = gy + geo_src.size.h - pixel;
     strip(
+        &ids.right,
         Rectangle::new(
             (right, gy).into(),
             (pixel, f64::from(ch) / scale * ratio.1).into(),
@@ -334,6 +326,7 @@ fn window_elements(
         (w - gw, ch),
     );
     strip(
+        &ids.bottom,
         Rectangle::new(
             (gx, bottom).into(),
             (f64::from(cw) / scale * ratio.0, pixel).into(),
@@ -342,6 +335,7 @@ fn window_elements(
         (cw, h - gh),
     );
     strip(
+        &ids.corner,
         Rectangle::new((right, bottom).into(), (pixel, pixel).into()),
         (x + gw, y + gh),
         (w - gw, h - gh),
@@ -428,17 +422,18 @@ fn border_width(deco: &Decoration, scale: f64) -> i32 {
 
 /// A window in a spawn transition. Its root surface goes through the effect
 /// shader, clamped to fill its rect, and its subsurfaces fade with it.
-#[expect(clippy::too_many_arguments)]
 fn effect_elements(
     out: &mut Vec<Draw>,
     renderer: &mut VulkanRenderer,
     window: &Window,
     elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>>,
-    (at, size): ((i32, i32), (i32, i32)),
+    spot: &Spot,
     effect: Effect,
-    scale: f64,
-    opacity: f32,
 ) {
+    let Spot { scale, opacity, .. } = *spot;
+    let Some((at, size)) = spot.pixels() else {
+        return;
+    };
     let Some(root) = crate::wm::root(window) else {
         return;
     };
@@ -474,10 +469,54 @@ fn effect_elements(
     }
 }
 
+/// Where and how a window is drawn, in logical units and at an output scale.
+struct Spot {
+    r: Rect,
+    scale: f64,
+    opacity: f32,
+}
+
+impl Spot {
+    fn pixels(&self) -> Option<((i32, i32), (i32, i32))> {
+        pixels(self.r, self.scale)
+    }
+}
+
+/// The inset and size of a window geometry in physical pixels, rounding both
+/// edges so the size agrees with the rect `pixels` snaps a window to.
+fn edges(geo: Rectangle<i32, Logical>, scale: f64) -> (Point<i32, Physical>, Size<i32, Physical>) {
+    let round = |v: i32| (f64::from(v) * scale).round() as i32;
+    let (x, y) = (round(geo.loc.x), round(geo.loc.y));
+    let size = (
+        round(geo.loc.x + geo.size.w) - x,
+        round(geo.loc.y + geo.size.h) - y,
+    );
+    ((x, y).into(), size.into())
+}
+
+/// The ids of the strips drawn past a window that is smaller than its rect,
+/// kept so an unchanged window does not damage its area every frame.
+struct StripIds {
+    right: Id,
+    bottom: Id,
+    corner: Id,
+}
+
+impl StripIds {
+    fn new() -> Self {
+        Self {
+            right: Id::new(),
+            bottom: Id::new(),
+            corner: Id::new(),
+        }
+    }
+}
+
 /// A texture at a physical rectangle, drawn plainly or through the
 /// transition hook in the effect shader.
 pub struct PlacedTexture {
     id: Id,
+    commit: CommitCounter,
     texture: VulkanTexture,
     src: Rectangle<f64, Buffer>,
     geometry: Rectangle<i32, Physical>,
@@ -497,6 +536,7 @@ impl PlacedTexture {
     ) -> Self {
         Self {
             id: Id::new(),
+            commit: CommitCounter::default(),
             texture: texture.clone(),
             src,
             geometry: Rectangle::new(at.into(), size.into()),
@@ -513,13 +553,17 @@ impl Element for PlacedTexture {
     }
 
     fn current_commit(&self) -> CommitCounter {
-        CommitCounter::default()
+        self.commit
     }
 
     fn src(&self) -> Rectangle<f64, Buffer> {
         self.src
     }
 
+    fn alpha(&self) -> f32 {
+        self.alpha
+    }
+
     fn geometry(&self, _scale: Scale<f64>) -> Rectangle<i32, Physical> {
         self.geometry
     }

monolith

Commit 39d2db731e01

Commit `39d2db731e01`