monolith

public

Star0

Fork 0

Watch0

22 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `7373078d1149`

tarball

atagen <boss@atagen.co>2026-10-16 11:25 UTC

3 files changed+156-24

monolith: shrink closed tiled windows into their seed

A closed window stays in its output plan as a ghost drawn from its last texture, aimed at the seed it would hide into. Its neighbours are planned in the same pass, so they close over it without ever overlapping it. A client that drops its buffer before closing still vanishes at once, since there is nothing left to draw.

Modified file: crates/monolith/src/anim.rs+40 additions@@ -6,6 +6,8 @@ use monolith_config::{Animation, AnimationStyle};
 use monolith_layout::{OutputId, Rect, WindowId};
 use monolith_motion::{CubicBezier, Edges, Position, Timeline, group_initial_slope};
 use monolith_planner::{Config as PlanConfig, Plan, Style};
+use monolith_render_vk::VulkanTexture;
+use smithay::utils::{Logical, Rectangle, Transform};
 use std::collections::HashMap;
 
 const VELOCITY_DT_NS: u64 = 1_000_000;
@@ -14,6 +16,20 @@ pub struct Animator {
     pub settings: Animation,
     tracks: HashMap<OutputId, Track>,
     glides: HashMap<WindowId, Glide>,
+    ghosts: Vec<Ghost>,
+}
+
+/// A closed tiled window that stays in its output's plan, shrinking to
+/// `seed` with the last frame its client showed.
+pub struct Ghost {
+    pub id: WindowId,
+    pub output: OutputId,
+    pub seed: Rect,
+    pub texture: VulkanTexture,
+    pub scale: i32,
+    pub transform: Transform,
+    /// Window geometry inside the buffer.
+    pub geometry: Rectangle<i32, Logical>,
 }
 
 struct Track {
@@ -39,6 +55,7 @@ impl Animator {
             settings,
             tracks: HashMap::new(),
             glides: HashMap::new(),
+            ghosts: Vec::new(),
         }
     }
 
@@ -67,6 +84,12 @@ impl Animator {
         seed: impl Fn(WindowId) -> Rect,
     ) {
         let prev = self.tracks.get(&o);
+        let ghosts = self
+            .ghosts
+            .iter()
+            .filter(|g| g.output == o)
+            .map(|g| (g.id, g.seed));
+        let targets: Vec<(WindowId, Rect)> = ghosts.chain(targets.iter().copied()).collect();
         let ids: Vec<WindowId> = targets.iter().map(|(id, _)| *id).collect();
         let to: Vec<Rect> = targets.iter().map(|(_, r)| *r).collect();
         if prev.is_some_and(|t| t.ids == ids && t.plan.keyframes.last() == Some(&to)) {
@@ -167,6 +190,17 @@ impl Animator {
         }
     }
 
+    /// Keeps a closing tiled window in the plan until its track ends. The
+    /// caller retargets afterwards.
+    pub fn add_ghost(&mut self, ghost: Ghost) {
+        self.ghosts.retain(|g| g.id != ghost.id);
+        self.ghosts.push(ghost);
+    }
+
+    pub fn ghosts(&self) -> &[Ghost] {
+        &self.ghosts
+    }
+
     pub fn active(&self, now: u64) -> bool {
         self.tracks.values().any(|t| t.timeline.end_ns() > now)
             || self.glides.values().any(|g| g.timeline.end_ns() > now)
@@ -174,6 +208,12 @@ impl Animator {
 
     pub fn prune(&mut self, now: u64) {
         self.glides.retain(|_, g| g.timeline.end_ns() > now);
+        let tracks = &self.tracks;
+        self.ghosts.retain(|g| {
+            tracks
+                .get(&g.output)
+                .is_some_and(|t| t.timeline.end_ns() > now)
+        });
     }
 }
 

Modified file: crates/monolith/src/scene.rs+65 additions−23 deletions@@ -4,14 +4,14 @@
 use crate::anim::Animator;
 use monolith_layout::{Layout, Rect, WindowId};
 use monolith_render_vk::{VulkanRenderer, VulkanTexture};
-use smithay::backend::renderer::Renderer;
 use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
 use smithay::backend::renderer::element::texture::TextureRenderElement;
 use smithay::backend::renderer::element::utils::CropRenderElement;
 use smithay::backend::renderer::element::{AsRenderElements, Id, Kind};
 use smithay::backend::renderer::utils::with_renderer_surface_state;
+use smithay::backend::renderer::{ContextId, Renderer};
 use smithay::desktop::Window;
-use smithay::utils::{Logical, Physical, Point, Rectangle, Scale, Size};
+use smithay::utils::{Logical, Physical, Point, Rectangle, Scale, Size, Transform};
 use std::collections::HashMap;
 
 smithay::backend::renderer::element::render_elements! {
@@ -29,9 +29,15 @@ pub fn build(
     renderer: &mut VulkanRenderer,
     now: u64,
 ) -> Vec<Draw> {
+    let mut ghosts = Vec::new();
     let mut tiled = Vec::new();
     let mut above = Vec::new();
     for (o, out) in layout.outputs() {
+        for g in anim.ghosts().iter().filter(|g| g.output == o) {
+            if let Some(r) = anim.tiled(o, g.id, now) {
+                ghosts.push((g, r));
+            }
+        }
         let arr = layout.arrange(o);
         let fullscreen_at_rest = arr
             .fullscreen
@@ -61,6 +67,25 @@ pub fn build(
             window_elements(&mut out, renderer, window, r);
         }
     }
+    let context = renderer.context_id();
+    for (g, r) in ghosts.into_iter().rev() {
+        let Some((at, size)) = pixels(r) else {
+            continue;
+        };
+        let src = Rectangle::new(
+            g.geometry.loc.to_f64(),
+            (f64::from(size.0), f64::from(size.1)).into(),
+        );
+        out.push(texture(
+            &context,
+            &g.texture,
+            g.scale,
+            g.transform,
+            src,
+            at,
+            size,
+        ));
+    }
     out
 }
 
@@ -68,12 +93,9 @@ pub fn build(
 /// smaller has its last row and column stretched over the rest, so a resize
 /// in flight never shows a scaled or missing client.
 fn window_elements(out: &mut Vec<Draw>, renderer: &mut VulkanRenderer, window: &Window, r: Rect) {
-    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;
-    if w < 1 || h < 1 {
+    let Some(((x, y), (w, h))) = pixels(r) else {
         return;
-    }
+    };
     let geo = window.geometry();
     let loc = Point::<i32, Physical>::from((x - geo.loc.x, y - geo.loc.y));
     let elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>> =
@@ -93,7 +115,7 @@ fn window_elements(out: &mut Vec<Draw>, renderer: &mut VulkanRenderer, window: &
         return;
     };
     let context = renderer.context_id();
-    let Some((texture, scale, transform)) = with_renderer_surface_state(&root, |s| {
+    let Some((tex, scale, transform)) = with_renderer_surface_state(&root, |s| {
         s.texture::<VulkanTexture>(context.clone())
             .cloned()
             .map(|t| (t, s.buffer_scale(), s.buffer_transform()))
@@ -105,22 +127,9 @@ fn window_elements(out: &mut Vec<Draw>, renderer: &mut VulkanRenderer, window: &
     let (cw, ch) = (w.min(gw), h.min(gh));
     let (gx, gy) = (geo.loc.x as f64, geo.loc.y as f64);
     let mut strip = |src: Rectangle<f64, Logical>, at: (i32, i32), size: (i32, i32)| {
-        if size.0 < 1 || size.1 < 1 {
-            return;
+        if size.0 >= 1 && size.1 >= 1 {
+            out.push(texture(&context, &tex, scale, transform, src, at, size));
         }
-        out.push(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,
-        )));
     };
     let right = gx + f64::from(gw) - 1.0;
     let bottom = gy + f64::from(gh) - 1.0;
@@ -140,3 +149,36 @@ fn window_elements(out: &mut Vec<Draw>, renderer: &mut VulkanRenderer, window: &
         (w - gw, h - gh),
     );
 }
+
+/// 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;
+    (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,
+    ))
+}

Modified file: crates/monolith/src/state.rs+51 additions−1 deletions@@ -1,11 +1,14 @@
-use crate::anim::Animator;
+use crate::anim::{Animator, Ghost};
 use crate::commands::Binds;
 use crate::nested::Host;
 use monolith_config::Config;
 use monolith_layout::{Layout, OutputId, Rect, WindowId};
 use monolith_protocols::workspace::{Group, Snapshot, Workspace, WorkspaceState};
 use monolith_render_vk::VulkanRenderer;
+use monolith_render_vk::VulkanTexture;
 use smithay::backend::renderer::ImportDma;
+use smithay::backend::renderer::Renderer;
+use smithay::backend::renderer::utils::{import_surface_tree, with_renderer_surface_state};
 use smithay::desktop::{PopupManager, Space, Window, WindowSurfaceType};
 use smithay::input::keyboard::{Keycode, XkbConfig};
 use smithay::input::{Seat, SeatState};
@@ -219,12 +222,59 @@ impl State {
         if let Some(id) = self.window_id(surface) {
             if let Some(window) = self.windows.remove(&id) {
                 self.space.unmap_elem(&window);
+                self.leave_ghost(id, &window);
             }
             self.layout.remove_window(id);
             self.apply_layout();
         }
     }
 
+    /// Keeps a visible tiled window's last frame shrinking to its seed while
+    /// its neighbours close over it.
+    fn leave_ghost(&mut self, id: WindowId, window: &Window) {
+        let Some(o) = self.layout.window(id).and_then(|w| w.output) else {
+            return;
+        };
+        let tiled = self
+            .layout
+            .output(o)
+            .is_some_and(|out| out.tree.contains(id));
+        if !tiled || !self.layout.visible(id) {
+            return;
+        }
+        let Some(seed) = self
+            .layout
+            .arrange_hiding(o, &[id])
+            .tiled
+            .into_iter()
+            .find(|p| p.window == id)
+        else {
+            return;
+        };
+        let Some(surface) = window.toplevel().map(|t| t.wl_surface().clone()) else {
+            return;
+        };
+        let _ = import_surface_tree(&mut self.renderer, &surface);
+        let context = self.renderer.context_id();
+        let snapshot = with_renderer_surface_state(&surface, |s| {
+            s.texture::<VulkanTexture>(context.clone())
+                .cloned()
+                .map(|t| (t, s.buffer_scale(), s.buffer_transform()))
+        })
+        .flatten();
+        if let Some((texture, scale, transform)) = snapshot {
+            self.anim.add_ghost(Ghost {
+                id,
+                output: o,
+                seed: seed.rect,
+                texture,
+                scale,
+                transform,
+                geometry: window.geometry(),
+            });
+        }
+    }
+
     pub fn window_id(&self, surface: &WlSurface) -> Option<WindowId> {
         self.windows
             .iter()

monolith

Commit 7373078d1149

Commit `7373078d1149`