monolith

public

Star0

Fork 0

Watch0

20 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `2af1d8c55876`

tarball

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

11 files changed+502-26

monolith: animate layout changes through the planner

Each output keeps one plan over every tiled window, with hidden and new windows as the zero-size seeds the layout already gives them, so spawning, viewing and hiding all go through the planner. The space keeps final geometry for input while the scene draws sampled rects. Clients get their final size at once, and their buffers are cropped or edge-stretched to the animated rect instead of scaled. A replan starts from the drawn positions and keeps each group moving at the speed it had.

Modified file: Cargo.lock+2

@@ -398,6 +398,8 @@ dependencies = [

398398 "monolith-config",

399399 "monolith-ipc",

400400 "monolith-layout",

401+ "monolith-motion",

402+ "monolith-planner",

401403 "monolith-protocols",

402404 "monolith-render-vk",

403405 "pound",

Modified file: crates/config/default.toml+7 additions@@ -10,6 +10,13 @@ startup = []
 mod = "super"
 gaps = { inner = 8, outer = 8 }
 
+[animation]
+enabled = true
+# orthogonal moves each window along one axis per phase, direct allows both.
+style = "orthogonal"
+phase_ms = 160
+curve = [0.45, 0.0, 0.2, 1.0]
+
 [keyboard]
 layout = ""
 repeat_delay = 200

Modified file: crates/config/src/lib.rs+33 additions@@ -12,6 +12,7 @@ pub const DEFAULT: &str = include_str!("../default.toml");
 #[derive(Debug, Clone)]
 pub struct Config {
     pub general: General,
+    pub animation: Animation,
     pub keyboard: Keyboard,
     pub binds: Vec<Bind>,
     pub rules: Vec<Rule>,
@@ -54,6 +55,35 @@ impl Default for Gaps {
 
 #[derive(Deserialize, Debug, Clone, PartialEq)]
 #[serde(default, deny_unknown_fields)]
+pub struct Animation {
+    pub enabled: bool,
+    pub style: AnimationStyle,
+    /// Every phase of a planned transition lasts this long.
+    pub phase_ms: u64,
+    /// A cubic bezier, as in CSS.
+    pub curve: [f64; 4],
+}
+
+impl Default for Animation {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            style: AnimationStyle::Orthogonal,
+            phase_ms: 160,
+            curve: [0.45, 0.0, 0.2, 1.0],
+        }
+    }
+}
+
+#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum AnimationStyle {
+    Orthogonal,
+    Direct,
+}
+
+#[derive(Deserialize, Debug, Clone, PartialEq)]
+#[serde(default, deny_unknown_fields)]
 pub struct Keyboard {
     pub rules: String,
     pub model: String,
@@ -166,6 +196,8 @@ struct Raw {
     #[serde(default)]
     keyboard: Keyboard,
     #[serde(default)]
+    animation: Animation,
+    #[serde(default)]
     binds: BTreeMap<String, Words>,
     #[serde(default)]
     rules: Vec<RawRule>,
@@ -243,6 +275,7 @@ impl Config {
             .collect::<Result<_, Error>>()?;
         Ok(Self {
             general: raw.general,
+            animation: raw.animation,
             keyboard: raw.keyboard,
             binds,
             rules,

Modified file: crates/layout/src/lib.rs+9 additions−2 deletions@@ -783,14 +783,21 @@ impl Layout {
     /// Target geometry for everything on `o`, in output-local logical
     /// coordinates offset by the output's area.
     pub fn arrange(&self, o: OutputId) -> Arrangement {
+        self.arrange_hiding(o, &[])
+    }
+
+    /// Like `arrange` with `hide` treated as hidden, which places them on the
+    /// seeds they would grow from.
+    pub fn arrange_hiding(&self, o: OutputId, hide: &[WindowId]) -> Arrangement {
         let Some(out) = self.outputs.get(o) else {
             return Arrangement::default();
         };
         let area = inset(out.area, self.gaps.outer);
-        let vis = self.vis_on(o);
+        let shown = self.vis_on(o);
+        let vis = &|w: WindowId| shown(w) && !hide.contains(&w);
         let tiled = out
             .tree
-            .arrange(area, self.gaps.inner, &vis)
+            .arrange(area, self.gaps.inner, vis)
             .into_iter()
             .map(|(window, rect)| Placed {
                 window,

Modified file: crates/monolith/Cargo.toml+2

@@ -16,6 +16,8 @@ calloop-wayland-source = "0.4"

1616 monolith-config.workspace = true

1717 monolith-ipc.workspace = true

1818 monolith-layout.workspace = true

19+monolith-motion.workspace = true

20+monolith-planner.workspace = true

1921 monolith-protocols.workspace = true

2022 monolith-render-vk.workspace = true

2123 pound = "0.5"

Added file: crates/monolith/src/anim.rs+213 additions@@ -0,0 +1,213 @@
+//! Layout transitions. Each output has one track, a plan over every tiled
+//! window it holds, with hidden windows as zero-size seeds. Switches between
+//! tiled, floating and fullscreen glide directly above the tiled layer.
+
+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 std::collections::HashMap;
+
+const VELOCITY_DT_NS: u64 = 1_000_000;
+
+pub struct Animator {
+    pub settings: Animation,
+    tracks: HashMap<OutputId, Track>,
+    glides: HashMap<WindowId, Glide>,
+}
+
+struct Track {
+    ids: Vec<WindowId>,
+    plan: Plan,
+    timeline: Timeline,
+    base: CubicBezier,
+    /// Each window's curve in the first phase. A replan can start a group
+    /// with the speed it already had, later phases always use `base`.
+    first: Vec<CubicBezier>,
+}
+
+struct Glide {
+    from: Rect,
+    to: Rect,
+    timeline: Timeline,
+    curve: CubicBezier,
+}
+
+impl Animator {
+    pub fn new(settings: Animation) -> Self {
+        Self {
+            settings,
+            tracks: HashMap::new(),
+            glides: HashMap::new(),
+        }
+    }
+
+    fn base(&self) -> CubicBezier {
+        let [x1, y1, x2, y2] = self.settings.curve;
+        let c = CubicBezier::new(x1, y1, x2, y2);
+        if c.is_valid() { c } else { CubicBezier::EASE }
+    }
+
+    fn phase_ns(&self) -> u64 {
+        if self.settings.enabled {
+            self.settings.phase_ms * 1_000_000
+        } else {
+            0
+        }
+    }
+
+    /// Plans `o`'s tiled windows from where they are drawn now to `targets`.
+    /// Windows the track has never seen start from `seed`.
+    pub fn retarget(
+        &mut self,
+        o: OutputId,
+        now: u64,
+        targets: &[(WindowId, Rect)],
+        gap: f64,
+        seed: impl Fn(WindowId) -> Rect,
+    ) {
+        let prev = self.tracks.get(&o);
+        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)) {
+            return;
+        }
+        let from: Vec<Rect> = ids
+            .iter()
+            .map(|&id| {
+                prev.and_then(|t| t.sample(id, now))
+                    .unwrap_or_else(|| seed(id))
+            })
+            .collect();
+        let cfg = PlanConfig {
+            style: match self.settings.style {
+                AnimationStyle::Orthogonal => Style::Orthogonal,
+                AnimationStyle::Direct => Style::Direct,
+            },
+            gap,
+            ..PlanConfig::default()
+        };
+        let plan = if self.phase_ns() == 0 {
+            monolith_planner::plan(&to, &to, &cfg)
+        } else {
+            monolith_planner::plan(&from, &to, &cfg)
+        };
+        let base = self.base();
+        let phase_secs = self.phase_ns() as f64 / 1e9;
+        let mut first = vec![base; ids.len()];
+        if plan.phases() > 0 {
+            for g in &plan.groups {
+                let movers = g.members.iter().map(|&i| {
+                    let v = prev.map_or([0.0; 4], |t| t.velocity(ids[i], now));
+                    let d = sub(edges(&plan.keyframes[1][i]), edges(&plan.keyframes[0][i]));
+                    (v, d)
+                });
+                if let Some(slope) = group_initial_slope(movers, phase_secs) {
+                    let curve = base.with_initial_slope(slope);
+                    for &i in &g.members {
+                        first[i] = curve;
+                    }
+                }
+            }
+        }
+        let timeline = Timeline {
+            start_ns: now,
+            phase_ns: self.phase_ns(),
+            phases: plan.phases(),
+        };
+        self.tracks.insert(
+            o,
+            Track {
+                ids,
+                plan,
+                timeline,
+                base,
+                first,
+            },
+        );
+    }
+
+    /// Where a tiled window on `o` is drawn at `now`.
+    pub fn tiled(&self, o: OutputId, id: WindowId, now: u64) -> Option<Rect> {
+        self.tracks.get(&o)?.sample(id, now)
+    }
+
+    /// Glides a window that changed between tiled, floating and fullscreen.
+    pub fn glide(&mut self, id: WindowId, from: Rect, to: Rect, now: u64) {
+        let phases = if self.phase_ns() == 0 { 0 } else { 2 };
+        self.glides.insert(
+            id,
+            Glide {
+                from,
+                to,
+                timeline: Timeline {
+                    start_ns: now,
+                    phase_ns: self.phase_ns(),
+                    phases,
+                },
+                curve: self.base(),
+            },
+        );
+    }
+
+    pub fn stop_glide(&mut self, id: WindowId) {
+        self.glides.remove(&id);
+    }
+
+    pub fn gliding(&self, id: WindowId, now: u64) -> Option<Rect> {
+        let g = self.glides.get(&id)?;
+        match g.timeline.locate(now) {
+            Position::Finished => None,
+            Position::NotStarted => Some(g.from),
+            Position::Phase { phase, t } => {
+                let total = g.timeline.phases as f64;
+                let s = g.curve.sample((phase as f64 + t) / total);
+                Some(g.from.lerp(&g.to, s))
+            }
+        }
+    }
+
+    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)
+    }
+
+    pub fn prune(&mut self, now: u64) {
+        self.glides.retain(|_, g| g.timeline.end_ns() > now);
+    }
+}
+
+impl Track {
+    fn sample(&self, id: WindowId, now: u64) -> Option<Rect> {
+        let i = self.ids.iter().position(|&x| x == id)?;
+        let keys = &self.plan.keyframes;
+        Some(match self.timeline.locate(now) {
+            Position::NotStarted => keys.first()?[i],
+            Position::Finished => keys.last()?[i],
+            Position::Phase { phase, t } => {
+                let curve = if phase == 0 { self.first[i] } else { self.base };
+                keys[phase][i].lerp(&keys[phase + 1][i], curve.sample(t))
+            }
+        })
+    }
+
+    /// Edge velocities in logical pixels per second.
+    fn velocity(&self, id: WindowId, now: u64) -> Edges {
+        let (Some(a), Some(b)) = (
+            self.sample(id, now.saturating_sub(VELOCITY_DT_NS)),
+            self.sample(id, now),
+        ) else {
+            return [0.0; 4];
+        };
+        let d = sub(edges(&b), edges(&a));
+        d.map(|x| x * 1e9 / VELOCITY_DT_NS as f64)
+    }
+}
+
+fn edges(r: &Rect) -> Edges {
+    [r.x, r.right(), r.y, r.bottom()]
+}
+
+fn sub(a: Edges, b: Edges) -> Edges {
+    [a[0] - b[0], a[1] - b[1], a[2] - b[2], a[3] - b[3]]
+}

Modified file: crates/monolith/src/commands.rs+1

@@ -181,6 +181,7 @@ impl State {

181181 let keyboard_changed = config.keyboard != self.config.keyboard;

182182 self.binds = Binds::new(&config);

183183 self.layout.gaps = crate::state::gaps(&config);

184+ self.anim.settings = config.animation.clone();

184185 self.config = config;

185186 if keyboard_changed {

186187 self.reconfigure_keyboard();

Modified file: crates/monolith/src/main.rs+2 additions@@ -1,9 +1,11 @@
+mod anim;
 mod commands;
 mod handlers;
 mod input;
 mod ipc;
 mod launch;
 mod nested;
+mod scene;
 mod state;
 
 use monolith_ipc::{Command, Query, Request};

Modified file: crates/monolith/src/nested.rs+20 additions−16 deletions@@ -11,8 +11,6 @@ use smithay::backend::allocator::dmabuf::Dmabuf;
 use smithay::backend::allocator::{Format, Fourcc, Modifier, Slot, Swapchain};
 use smithay::backend::renderer::Bind;
 use smithay::backend::renderer::damage::OutputDamageTracker;
-use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
-use smithay::desktop::space::render_output;
 use smithay::output::{Mode, Output, PhysicalProperties, Subpixel};
 use smithay::reexports::calloop::EventLoop;
 use smithay::utils::{Logical, Point, Size, Transform};
@@ -148,6 +146,9 @@ pub fn render(state: &mut State) {
         space,
         needs_redraw,
         start,
+        layout,
+        windows,
+        anim,
         ..
     } = state;
     let Some(host) = host.as_mut() else { return };
@@ -181,6 +182,7 @@ pub fn render(state: &mut State) {
             return;
         }
     };
+    let now = crate::state::now_ns();
     let mut dmabuf = (*slot).clone();
     let damage = {
         let mut fb = match renderer.bind(&mut dmabuf) {
@@ -190,18 +192,11 @@ pub fn render(state: &mut State) {
                 return;
             }
         };
-        let elements: &[WaylandSurfaceRenderElement<monolith_render_vk::VulkanRenderer>] = &[];
-        match render_output(
-            &host.output,
-            renderer,
-            &mut fb,
-            1.0,
-            slot.age() as usize,
-            [&*space],
-            elements,
-            &mut host.damage,
-            CLEAR,
-        ) {
+        let elements = crate::scene::build(layout, windows, anim, renderer, now);
+        match host
+            .damage
+            .render_output(renderer, &mut fb, slot.age() as usize, &elements, CLEAR)
+        {
             Ok(result) => {
                 if let Err(e) = result.sync.wait() {
                     tracing::warn!("waiting for the frame failed: {e:?}");
@@ -214,14 +209,23 @@ pub fn render(state: &mut State) {
             }
         }
     };
-    *needs_redraw = false;
+    *needs_redraw = anim.active(now);
+    anim.prune(now);
     let elapsed = start.elapsed();
     for window in space.elements() {
         window.send_frame(&host.output, elapsed, Some(Duration::ZERO), |_, _| {
             Some(host.output.clone())
         });
     }
-    let Some(damage) = damage else { return };
+    let Some(damage) = damage else {
+        if *needs_redraw {
+            host.surface.frame(&host.qh, ());
+            host.surface.commit();
+            host.frame_pending = true;
+            let _ = host.conn.flush();
+        }
+        return;
+    };
     let buffer = match slot.userdata().get::<HostBuffer>() {
         Some(b) => b.0.clone(),
         None => {

Added file: crates/monolith/src/scene.rs+142 additions@@ -0,0 +1,142 @@
+//! What a frame draws. The space holds final geometry for input, while the
+//! scene draws windows where the animator says they are right now.
+
+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::desktop::Window;
+use smithay::utils::{Logical, Physical, Point, Rectangle, Scale, Size};
+use std::collections::HashMap;
+
+smithay::backend::renderer::element::render_elements! {
+    pub Draw<=VulkanRenderer>;
+    Surface=WaylandSurfaceRenderElement<VulkanRenderer>,
+    Cropped=CropRenderElement<WaylandSurfaceRenderElement<VulkanRenderer>>,
+    Texture=TextureRenderElement<VulkanTexture>,
+}
+
+/// Elements for every output, front to back.
+pub fn build(
+    layout: &Layout,
+    windows: &HashMap<WindowId, Window>,
+    anim: &Animator,
+    renderer: &mut VulkanRenderer,
+    now: u64,
+) -> Vec<Draw> {
+    let mut tiled = Vec::new();
+    let mut above = Vec::new();
+    for (o, out) in layout.outputs() {
+        let arr = layout.arrange(o);
+        let fullscreen_at_rest = arr
+            .fullscreen
+            .is_some_and(|w| anim.gliding(w, now).is_none());
+        for p in &arr.tiled {
+            if Some(p.window) == arr.fullscreen || fullscreen_at_rest {
+                continue;
+            }
+            match anim.gliding(p.window, now) {
+                Some(r) => above.push((p.window, r)),
+                None => {
+                    let r = anim.tiled(o, p.window, now).unwrap_or(p.rect);
+                    tiled.push((p.window, r));
+                }
+            }
+        }
+        for &(w, r) in &arr.floating {
+            above.push((w, anim.gliding(w, now).unwrap_or(r)));
+        }
+        if let Some(w) = arr.fullscreen {
+            above.push((w, anim.gliding(w, now).unwrap_or(out.area)));
+        }
+    }
+    let mut out = Vec::new();
+    for (id, r) in tiled.into_iter().chain(above).rev() {
+        if let Some(window) = windows.get(&id) {
+            window_elements(&mut out, renderer, window, r);
+        }
+    }
+    out
+}
+
+/// Draws `window` filling `r`. A buffer bigger than `r` is cropped, and one
+/// 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 {
+        return;
+    }
+    let geo = window.geometry();
+    let loc = Point::<i32, Physical>::from((x - geo.loc.x, y - geo.loc.y));
+    let elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>> =
+        window.render_elements(renderer, loc, Scale::from(1.0), 1.0);
+    if (w, h) == (geo.size.w, geo.size.h) {
+        out.extend(elems.into_iter().map(Draw::Surface));
+        return;
+    }
+    let crop = Rectangle::new((x, y).into(), (w, h).into());
+    out.extend(
+        elems
+            .into_iter()
+            .filter_map(|e| CropRenderElement::from_element(e, 1.0, crop))
+            .map(Draw::Cropped),
+    );
+    let Some(root) = window.toplevel().map(|t| t.wl_surface().clone()) else {
+        return;
+    };
+    let context = renderer.context_id();
+    let Some((texture, scale, transform)) = with_renderer_surface_state(&root, |s| {
+        s.texture::<VulkanTexture>(context.clone())
+            .cloned()
+            .map(|t| (t, s.buffer_scale(), s.buffer_transform()))
+    })
+    .flatten() else {
+        return;
+    };
+    let (gw, gh) = (geo.size.w, geo.size.h);
+    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;
+        }
+        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;
+    strip(
+        Rectangle::new((right, gy).into(), (1.0, f64::from(ch)).into()),
+        (x + gw, y),
+        (w - gw, ch),
+    );
+    strip(
+        Rectangle::new((gx, bottom).into(), (f64::from(cw), 1.0).into()),
+        (x, y + gh),
+        (cw, h - gh),
+    );
+    strip(
+        Rectangle::new((right, bottom).into(), (1.0, 1.0).into()),
+        (x + gw, y + gh),
+        (w - gw, h - gh),
+    );
+}

Modified file: crates/monolith/src/state.rs+71 additions−8 deletions@@ -1,3 +1,4 @@
+use crate::anim::Animator;
 use crate::commands::Binds;
 use crate::nested::Host;
 use monolith_config::Config;
@@ -14,7 +15,7 @@ use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel::Sta
 use smithay::reexports::wayland_server::backend::{ClientData, ClientId, DisconnectReason};
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::reexports::wayland_server::{Display, DisplayHandle, Resource};
-use smithay::utils::{Logical, Point, SERIAL_COUNTER, Size};
+use smithay::utils::{Clock, Logical, Monotonic, Point, SERIAL_COUNTER, Size};
 use smithay::wayland::compositor::{CompositorClientState, CompositorState, with_states};
 use smithay::wayland::dmabuf::{DmabufGlobal, DmabufState};
 use smithay::wayland::output::OutputManagerState;
@@ -27,7 +28,7 @@ use std::collections::HashMap;
 use std::ffi::OsString;
 use std::path::PathBuf;
 use std::sync::Arc;
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 pub struct State {
     pub start: Instant,
@@ -54,6 +55,10 @@ pub struct State {
     pub ipc: crate::ipc::Server,
     pub launches: crate::launch::Launches,
     pub workspaces: WorkspaceState,
+    pub anim: Animator,
+    /// How each shown window was placed by the last layout pass, to spot
+    /// switches between tiled, floating and fullscreen.
+    pub last_kind: HashMap<WindowId, (Kind, Rect, OutputId)>,
 
     pub compositor_state: CompositorState,
     pub xdg_shell_state: XdgShellState,
@@ -111,6 +116,7 @@ impl State {
         let mut layout = Layout::default();
         layout.gaps = gaps(&config);
         let binds = Binds::new(&config);
+        let animation = config.animation.clone();
         Ok(Self {
             start: Instant::now(),
             socket_name,
@@ -132,6 +138,8 @@ impl State {
             ipc: crate::ipc::Server::default(),
             launches: Default::default(),
             workspaces: WorkspaceState::new::<State>(&dh),
+            anim: Animator::new(animation),
+            last_kind: HashMap::new(),
             compositor_state: CompositorState::new::<State>(&dh),
             xdg_shell_state: XdgShellState::new::<State>(&dh),
             _xdg_decoration_state: XdgDecorationState::new::<State>(&dh),
@@ -226,27 +234,78 @@ impl State {
 
     /// Pushes the layout's target geometry into the space and to clients.
     pub fn apply_layout(&mut self) {
+        let now = now_ns();
         let mut shown = Vec::new();
+        let mut tracks = Vec::new();
         let outputs: Vec<OutputId> = self.layout.outputs().map(|(o, _)| o).collect();
         for o in outputs {
             let arr = self.layout.arrange(o);
             let area = self.layout.output(o).map(|o| o.area).unwrap_or_default();
             for p in &arr.tiled {
                 if p.visible && arr.fullscreen != Some(p.window) {
-                    shown.push((p.window, p.rect, Kind::Tiled));
+                    shown.push((p.window, p.rect, Kind::Tiled, o));
                 }
             }
             for &(w, rect) in &arr.floating {
                 if arr.fullscreen != Some(w) {
-                    shown.push((w, rect, Kind::Floating));
+                    shown.push((w, rect, Kind::Floating, o));
                 }
             }
             if let Some(w) = arr.fullscreen {
-                shown.push((w, area, Kind::Fullscreen));
+                shown.push((w, area, Kind::Fullscreen, o));
             }
+            let targets: Vec<(WindowId, Rect)> =
+                arr.tiled.iter().map(|p| (p.window, p.rect)).collect();
+            tracks.push((o, targets));
         }
+
+        let mut glides = Vec::new();
+        for &(id, rect, kind, _) in &shown {
+            match self.last_kind.get(&id) {
+                Some(&(was, from, o)) if was != kind => {
+                    let from = self
+                        .anim
+                        .gliding(id, now)
+                        .or_else(|| {
+                            (was == Kind::Tiled)
+                                .then(|| self.anim.tiled(o, id, now))
+                                .flatten()
+                        })
+                        .unwrap_or(from);
+                    glides.push((id, from, rect));
+                }
+                Some(&(Kind::Floating, from, _)) if from != rect => self.anim.stop_glide(id),
+                _ => {}
+            }
+        }
+        let gap = self.layout.gaps.inner;
+        for (o, targets) in tracks {
+            let new: Vec<WindowId> = targets
+                .iter()
+                .map(|t| t.0)
+                .filter(|&id| self.anim.tiled(o, id, now).is_none())
+                .collect();
+            let seeds: HashMap<WindowId, Rect> = if new.is_empty() {
+                HashMap::new()
+            } else {
+                self.layout
+                    .arrange_hiding(o, &new)
+                    .tiled
+                    .into_iter()
+                    .map(|p| (p.window, p.rect))
+                    .collect()
+            };
+            self.anim.retarget(o, now, &targets, gap, |id| {
+                seeds.get(&id).copied().unwrap_or_default()
+            });
+        }
+        for (id, from, to) in glides {
+            self.anim.glide(id, from, to, now);
+        }
+        self.last_kind = shown.iter().map(|&(id, r, k, o)| (id, (k, r, o))).collect();
+
         let mut mapped = Vec::new();
-        for (id, rect, kind) in shown {
+        for (id, rect, kind, _) in shown {
             if let Some(window) = self.windows.get(&id)
                 && configure(window, rect, kind)
             {
@@ -350,8 +409,8 @@ impl State {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum Kind {
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Kind {
     Tiled,
     Floating,
     Fullscreen,
@@ -395,6 +454,10 @@ fn configure(window: &Window, rect: Rect, kind: Kind) -> bool {
     true
 }
 
+pub fn now_ns() -> u64 {
+    Duration::from(Clock::<Monotonic>::new().now()).as_nanos() as u64
+}
+
 pub fn identity(t: &smithay::wayland::shell::xdg::ToplevelSurface) -> (String, String) {
     with_states(t.wl_surface(), |s| {
         let data = s

monolith

Commit 2af1d8c55876

Commit `2af1d8c55876`