monolith

public

Star0

Fork 0

Watch0

93 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `82c94edb8c50`

tarball

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

5 files changed+60-25

monolith: keep closing windows' last frames in the window model

Ghost carried a VulkanTexture, so the animator, which otherwise only plans geometry and timing, depended on the GPU. Wm::last_frames now holds the frame, keyed by window and pruned with the ghosts.

Modified file: crates/monolith/src/anim.rs+2 additions−8 deletions@@ -6,8 +6,7 @@ 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::{Effect, Transition, VulkanTexture};
-use smithay::utils::{Logical, Rectangle, Transform};
+use monolith_render_vk::{Effect, Transition};
 use std::collections::HashMap;
 
 const VELOCITY_DT_NS: u64 = 1_000_000;
@@ -21,16 +20,11 @@ pub struct Animator {
 }
 
 /// A closed tiled window that stays in its output's plan, shrinking to
-/// `seed` with the last frame its client showed.
+/// `seed`. `Wm::last_frames` holds what it shows.
 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>,
     pub born: u64,
 }
 

Modified file: crates/monolith/src/scene.rs+13 additions−8 deletions@@ -44,7 +44,12 @@ pub fn build(
     output: Option<&Output>,
     unmanaged: &[X11Surface],
 ) -> Vec<Draw> {
-    let (layout, anim, windows) = wm.parts();
+    let crate::wm::Parts {
+        layout,
+        anim,
+        windows,
+        last_frames,
+    } = wm.parts();
     let Some(area) = layout.output(o).map(|out| out.area) else {
         return Vec::new();
     };
@@ -53,8 +58,8 @@ pub fn build(
     let mut tiled = Vec::new();
     let mut above = Vec::new();
     for g in anim.ghosts().iter().filter(|g| g.output == o) {
-        if let Some(r) = anim.tiled(o, g.id, now) {
-            ghosts.push((g, local(r)));
+        if let (Some(r), Some(frame)) = (anim.tiled(o, g.id, now), last_frames.get(&g.id)) {
+            ghosts.push((g, frame, local(r)));
         }
     }
     let arr = layout.arrange(o);
@@ -118,18 +123,18 @@ pub fn build(
             border_elements(&mut out, borders, r, deco.border as i32, color, alpha);
         }
     }
-    for (g, r) in ghosts.into_iter().rev() {
+    for (g, frame, r) in ghosts.into_iter().rev() {
         let Some((at, size)) = pixels(r) else {
             continue;
         };
         let src = Rectangle::new(
-            g.geometry.loc.to_f64(),
+            frame.geometry.loc.to_f64(),
             (f64::from(size.0), f64::from(size.1)).into(),
         );
         out.push(Draw::Effect(EffectElement::new(
-            &g.texture,
-            g.scale,
-            g.transform,
+            &frame.texture,
+            frame.scale,
+            frame.transform,
             src,
             at,
             size,

Modified file: crates/monolith/src/state.rs+1−1

@@ -197,7 +197,7 @@ impl State {

197197 crate::backend::Backend::Nested(_) => crate::nested::render(self),

198198 crate::backend::Backend::Starting => {}

199199 }

200- self.wm.anim.prune(now_ns());

200+ self.wm.prune(now_ns());

201201 self.confirm_lock();

202202 self.complete_captures();

203203 if std::mem::take(&mut self.dirty.snapshot) {

Modified file: crates/monolith/src/windows.rs+10 additions−5 deletions@@ -1,6 +1,6 @@
 use crate::anim::Ghost;
 use crate::state::{State, now_ns};
-use crate::wm::{identity, root};
+use crate::wm::{LastFrame, identity, root};
 use monolith_layout::{Rect, WindowId};
 use monolith_render_vk::VulkanTexture;
 use smithay::backend::renderer::Renderer;
@@ -157,14 +157,19 @@ impl State {
         })
         .flatten();
         if let Some((texture, scale, transform)) = snapshot {
+            self.wm.last_frames.insert(
+                id,
+                LastFrame {
+                    texture,
+                    scale,
+                    transform,
+                    geometry: window.geometry(),
+                },
+            );
             self.wm.anim.add_ghost(Ghost {
                 id,
                 output: o,
                 seed: seed.rect,
-                texture,
-                scale,
-                transform,
-                geometry: window.geometry(),
                 born: now_ns(),
             });
         }

Modified file: crates/monolith/src/wm.rs+34 additions−3 deletions@@ -4,12 +4,13 @@
 use crate::anim::Animator;
 
 use monolith_layout::{Layout, OutputId, Rect, WindowId};
+use monolith_render_vk::VulkanTexture;
 use slotmap::SecondaryMap;
 use smithay::backend::renderer::element::solid::SolidColorBuffer;
 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;
-use smithay::utils::Rectangle;
+use smithay::utils::{Logical, Rectangle, Transform};
 use smithay::wayland::compositor::with_states;
 use smithay::wayland::foreign_toplevel_list::ForeignToplevelHandle;
 use smithay::wayland::seat::WaylandFocus;
@@ -28,6 +29,23 @@ pub struct Wm {
     pub anim: Animator,
     /// A layer surface given the keyboard by a click, like a launcher.
     pub layer_focus: Option<WlSurface>,
+    /// What closed windows still show while their ghost animates.
+    pub last_frames: HashMap<WindowId, LastFrame>,
+}
+
+pub struct LastFrame {
+    pub texture: VulkanTexture,
+    pub scale: i32,
+    pub transform: Transform,
+    /// Window geometry inside the buffer.
+    pub geometry: Rectangle<i32, Logical>,
+}
+
+pub struct Parts<'a> {
+    pub layout: &'a Layout,
+    pub anim: &'a Animator,
+    pub windows: &'a mut SecondaryMap<WindowId, WindowState>,
+    pub last_frames: &'a HashMap<WindowId, LastFrame>,
 }
 
 pub struct WindowState {
@@ -74,6 +92,7 @@ impl Wm {
             popups: PopupManager::default(),
             anim,
             layer_focus: None,
+            last_frames: HashMap::new(),
         }
     }
 
@@ -152,8 +171,20 @@ impl Wm {
 
     /// The layout and animator to read alongside the records to write, which
     /// a frame needs at once.
-    pub fn parts(&mut self) -> (&Layout, &Animator, &mut SecondaryMap<WindowId, WindowState>) {
-        (&self.layout, &self.anim, &mut self.windows)
+    pub fn parts(&mut self) -> Parts<'_> {
+        Parts {
+            layout: &self.layout,
+            anim: &self.anim,
+            windows: &mut self.windows,
+            last_frames: &self.last_frames,
+        }
+    }
+
+    pub fn prune(&mut self, now: u64) {
+        self.anim.prune(now);
+        let ghosts = self.anim.ghosts();
+        self.last_frames
+            .retain(|id, _| ghosts.iter().any(|g| g.id == *id));
     }
 
     pub fn any_awaiting(&self) -> bool {

monolith

Commit 82c94edb8c50

Commit `82c94edb8c50`