Implement window closing animations

4 files changed, 411 insertions, 10 deletions

diff --git a/src/layout/closing_window.rs b/src/layout/closing_window.rs
new file mode 100644
index 00000000..ec565ebf
--- /dev/null
+++ b/src/layout/closing_window.rs
@@ -0,0 +1,177 @@
+use std::time::Duration;
+
+use anyhow::Context as _;
+use niri_config::BlockOutFrom;
+use smithay::backend::allocator::Fourcc;
+use smithay::backend::renderer::element::texture::{TextureBuffer, TextureRenderElement};
+use smithay::backend::renderer::element::utils::{
+    Relocate, RelocateRenderElement, RescaleRenderElement,
+};
+use smithay::backend::renderer::element::{Kind, RenderElement};
+use smithay::backend::renderer::gles::{GlesRenderer, GlesTexture};
+use smithay::utils::{Logical, Point, Scale, Transform};
+
+use crate::animation::Animation;
+use crate::niri_render_elements;
+use crate::render_helpers::primary_gpu_texture::PrimaryGpuTextureRenderElement;
+use crate::render_helpers::{render_to_texture, RenderSnapshot, RenderTarget};
+
+#[derive(Debug)]
+pub struct ClosingWindow {
+    /// Contents of the window.
+    buffer: TextureBuffer<GlesTexture>,
+
+    /// Blocked-out contents of the window.
+    blocked_out_buffer: TextureBuffer<GlesTexture>,
+
+    /// Where the window should be blocked out from.
+    block_out_from: Option<BlockOutFrom>,
+
+    /// Center of the window geometry.
+    center: Point<i32, Logical>,
+
+    /// Position in the workspace.
+    pos: Point<i32, Logical>,
+
+    /// How much the buffer should be offset.
+    buffer_offset: Point<i32, Logical>,
+
+    /// How much the blocked-out buffer should be offset.
+    blocked_out_buffer_offset: Point<i32, Logical>,
+
+    /// The closing animation.
+    anim: Animation,
+
+    /// Alpha the animation should start from.
+    starting_alpha: f32,
+
+    /// Scale the animation should start from.
+    starting_scale: f64,
+}
+
+niri_render_elements! {
+    ClosingWindowRenderElement => {
+        Texture = RelocateRenderElement<RescaleRenderElement<PrimaryGpuTextureRenderElement>>,
+    }
+}
+
+impl ClosingWindow {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new<E: RenderElement<GlesRenderer>>(
+        renderer: &mut GlesRenderer,
+        snapshot: RenderSnapshot<E>,
+        scale: i32,
+        center: Point<i32, Logical>,
+        pos: Point<i32, Logical>,
+        anim: Animation,
+        starting_alpha: f32,
+        starting_scale: f64,
+    ) -> anyhow::Result<Self> {
+        let _span = tracy_client::span!("ClosingWindow::new");
+
+        let mut render_to_buffer = |elements: Vec<E>| -> anyhow::Result<_> {
+            let geo = elements
+                .iter()
+                .map(|ele| ele.geometry(Scale::from(f64::from(scale))))
+                .reduce(|a, b| a.merge(b))
+                .unwrap_or_default();
+
+            let elements = elements.iter().rev().map(|ele| {
+                RelocateRenderElement::from_element(
+                    ele,
+                    (-geo.loc.x, -geo.loc.y),
+                    Relocate::Relative,
+                )
+            });
+            let offset = geo.loc.to_logical(scale);
+
+            let (texture, _sync_point) = render_to_texture(
+                renderer,
+                geo.size,
+                Scale::from(scale as f64),
+                Transform::Normal,
+                Fourcc::Abgr8888,
+                elements,
+            )
+            .context("error rendering to texture")?;
+
+            let buffer =
+                TextureBuffer::from_texture(renderer, texture, scale, Transform::Normal, None);
+            Ok((buffer, offset))
+        };
+
+        let (buffer, buffer_offset) =
+            render_to_buffer(snapshot.contents).context("error rendering contents")?;
+        let (blocked_out_buffer, blocked_out_buffer_offset) =
+            render_to_buffer(snapshot.blocked_out_contents)
+                .context("error rendering blocked-out contents")?;
+
+        Ok(Self {
+            buffer,
+            blocked_out_buffer,
+            block_out_from: snapshot.block_out_from,
+            center,
+            pos,
+            buffer_offset,
+            blocked_out_buffer_offset,
+            anim,
+            starting_alpha,
+            starting_scale,
+        })
+    }
+
+    pub fn advance_animations(&mut self, current_time: Duration) {
+        self.anim.set_current_time(current_time);
+    }
+
+    pub fn are_animations_ongoing(&self) -> bool {
+        !self.anim.is_done()
+    }
+
+    pub fn render(
+        &self,
+        view_pos: i32,
+        scale: Scale<f64>,
+        target: RenderTarget,
+    ) -> ClosingWindowRenderElement {
+        let val = self.anim.value();
+
+        let block_out = match self.block_out_from {
+            None => false,
+            Some(BlockOutFrom::Screencast) => target == RenderTarget::Screencast,
+            Some(BlockOutFrom::ScreenCapture) => target != RenderTarget::Output,
+        };
+        let (buffer, offset) = if block_out {
+            (&self.blocked_out_buffer, self.blocked_out_buffer_offset)
+        } else {
+            (&self.buffer, self.buffer_offset)
+        };
+
+        let elem = TextureRenderElement::from_texture_buffer(
+            Point::from((0., 0.)),
+            buffer,
+            Some(val.clamp(0., 1.) as f32 * self.starting_alpha),
+            None,
+            None,
+            Kind::Unspecified,
+        );
+
+        let elem = PrimaryGpuTextureRenderElement(elem);
+
+        let elem = RescaleRenderElement::from_element(
+            elem,
+            (self.center - offset).to_physical_precise_round(scale),
+            ((val / 5. + 0.8) * self.starting_scale).max(0.),
+        );
+
+        let mut location = self.pos + offset;
+        location.x -= view_pos;
+        let elem = RelocateRenderElement::from_element(
+            elem,
+            location.to_physical_precise_round(scale),
+            Relocate::Relative,
+        );
+
+        elem.into()
+    }
+}
diff --git a/src/layout/mod.rs b/src/layout/mod.rs
index 9db7b140..18870025 100644
--- a/src/layout/mod.rs
+++ b/src/layout/mod.rs
@@ -39,6 +39,7 @@ use niri_ipc::SizeChange;
 use smithay::backend::renderer::element::solid::SolidColorRenderElement;
 use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
 use smithay::backend::renderer::element::Id;
+use smithay::backend::renderer::gles::GlesRenderer;
 use smithay::output::Output;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::utils::{Logical, Point, Scale, Size, Transform};
@@ -47,11 +48,13 @@ use self::monitor::Monitor;
 pub use self::monitor::MonitorRenderElement;
 use self::workspace::{compute_working_area, Column, ColumnWidth, OutputId, Workspace};
 use crate::niri_render_elements;
+use crate::render_helpers::primary_gpu_texture::PrimaryGpuTextureRenderElement;
 use crate::render_helpers::renderer::NiriRenderer;
-use crate::render_helpers::RenderTarget;
+use crate::render_helpers::{RenderSnapshot, RenderTarget};
 use crate::utils::output_size;
 use crate::window::ResolvedWindowRules;
 
+pub mod closing_window;
 pub mod focus_ring;
 pub mod monitor;
 pub mod tile;
@@ -64,6 +67,13 @@ niri_render_elements! {
     }
 }
 
+niri_render_elements! {
+    LayoutElementSnapshotRenderElements => {
+        Texture = PrimaryGpuTextureRenderElement,
+        SolidColor = SolidColorRenderElement,
+    }
+}
+
 pub trait LayoutElement {
     /// Type that can be used as a unique ID of this element.
     type Id: PartialEq;
@@ -100,6 +110,8 @@ pub trait LayoutElement {
         target: RenderTarget,
     ) -> Vec<LayoutElementRenderElement<R>>;
 
+    fn take_last_render(&self) -> RenderSnapshot<LayoutElementSnapshotRenderElements>;
+
     fn request_size(&self, size: Size<i32, Logical>);
     fn request_fullscreen(&self, size: Size<i32, Logical>);
     fn min_size(&self) -> Size<i32, Logical>;
@@ -1750,6 +1762,35 @@ impl<W: LayoutElement> Layout<W> {
         }
     }
 
+    pub fn start_close_animation_for_window(
+        &mut self,
+        renderer: &mut GlesRenderer,
+        window: &W::Id,
+    ) {
+        let _span = tracy_client::span!("Layout::start_close_animation_for_window");
+
+        match &mut self.monitor_set {
+            MonitorSet::Normal { monitors, .. } => {
+                for mon in monitors {
+                    for ws in &mut mon.workspaces {
+                        if ws.has_window(window) {
+                            ws.start_close_animation_for_window(renderer, window);
+                            return;
+                        }
+                    }
+                }
+            }
+            MonitorSet::NoOutputs { workspaces, .. } => {
+                for ws in workspaces {
+                    if ws.has_window(window) {
+                        ws.start_close_animation_for_window(renderer, window);
+                        return;
+                    }
+                }
+            }
+        }
+    }
+
     pub fn refresh(&mut self) {
         let _span = tracy_client::span!("Layout::refresh");
 
@@ -1889,6 +1930,10 @@ mod tests {
             vec![]
         }
 
+        fn take_last_render(&self) -> RenderSnapshot<LayoutElementSnapshotRenderElements> {
+            RenderSnapshot::default()
+        }
+
         fn request_size(&self, size: Size<i32, Logical>) {
             self.0.requested_size.set(Some(size));
             self.0.pending_fullscreen.set(false);
diff --git a/src/layout/tile.rs b/src/layout/tile.rs
index ed71d8a0..fb825184 100644
--- a/src/layout/tile.rs
+++ b/src/layout/tile.rs
@@ -3,17 +3,22 @@ use std::rc::Rc;
 use std::time::Duration;
 
 use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
-use smithay::backend::renderer::element::utils::RescaleRenderElement;
+use smithay::backend::renderer::element::utils::{
+    Relocate, RelocateRenderElement, RescaleRenderElement,
+};
 use smithay::backend::renderer::element::{Element, Kind};
+use smithay::backend::renderer::gles::GlesRenderer;
 use smithay::utils::{Logical, Point, Rectangle, Scale, Size};
 
 use super::focus_ring::{FocusRing, FocusRingRenderElement};
-use super::{LayoutElement, LayoutElementRenderElement, Options};
+use super::{
+    LayoutElement, LayoutElementRenderElement, LayoutElementSnapshotRenderElements, Options,
+};
 use crate::animation::Animation;
 use crate::niri_render_elements;
 use crate::render_helpers::offscreen::OffscreenRenderElement;
 use crate::render_helpers::renderer::NiriRenderer;
-use crate::render_helpers::RenderTarget;
+use crate::render_helpers::{RenderSnapshot, RenderTarget};
 
 /// Toplevel window with decorations.
 #[derive(Debug)]
@@ -58,6 +63,14 @@ niri_render_elements! {
     }
 }
 
+niri_render_elements! {
+    TileSnapshotRenderElement => {
+        LayoutElement = RelocateRenderElement<LayoutElementSnapshotRenderElements>,
+        FocusRing = FocusRingRenderElement,
+        SolidColor = SolidColorRenderElement,
+    }
+}
+
 impl<W: LayoutElement> Tile<W> {
     pub fn new(window: W, options: Rc<Options>) -> Self {
         Self {
@@ -129,6 +142,10 @@ impl<W: LayoutElement> Tile<W> {
         ));
     }
 
+    pub fn open_animation(&self) -> &Option<Animation> {
+        &self.open_animation
+    }
+
     pub fn window(&self) -> &W {
         &self.window
     }
@@ -399,4 +416,54 @@ impl<W: LayoutElement> Tile<W> {
             None.into_iter().chain(Some(elements).into_iter().flatten())
         }
     }
+
+    pub fn take_snapshot_for_close_anim(
+        &self,
+        renderer: &mut GlesRenderer,
+        scale: Scale<f64>,
+        view_size: Size<i32, Logical>,
+    ) -> RenderSnapshot<TileSnapshotRenderElement> {
+        let snapshot = self.window.take_last_render();
+        if snapshot.contents.is_empty() {
+            return RenderSnapshot::default();
+        }
+
+        let mut process = |contents| {
+            let mut rv = vec![];
+
+            let buf_pos =
+                (self.window_loc() + self.window.buf_loc()).to_physical_precise_round(scale);
+            for elem in contents {
+                let elem = RelocateRenderElement::from_element(elem, buf_pos, Relocate::Relative);
+                rv.push(elem.into());
+            }
+
+            if let Some(width) = self.effective_border_width() {
+                rv.extend(
+                    self.border
+                        .render(renderer, Point::from((width, width)), scale, view_size)
+                        .map(Into::into),
+                );
+            }
+
+            if self.is_fullscreen {
+                let elem = SolidColorRenderElement::from_buffer(
+                    &self.fullscreen_backdrop,
+                    Point::from((0, 0)),
+                    scale,
+                    1.,
+                    Kind::Unspecified,
+                );
+                rv.push(elem.into());
+            }
+
+            rv
+        };
+
+        RenderSnapshot {
+            contents: process(snapshot.contents),
+            blocked_out_contents: process(snapshot.blocked_out_contents),
+            block_out_from: snapshot.block_out_from,
+        }
+    }
 }
diff --git a/src/layout/workspace.rs b/src/layout/workspace.rs
index ab23a1f0..61cf6e79 100644
--- a/src/layout/workspace.rs
+++ b/src/layout/workspace.rs
@@ -5,6 +5,7 @@ use std::time::Duration;
 
 use niri_config::{CenterFocusedColumn, PresetWidth, Struts};
 use niri_ipc::SizeChange;
+use smithay::backend::renderer::gles::GlesRenderer;
 use smithay::desktop::{layer_map_for_output, Window};
 use smithay::output::Output;
 use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel;
@@ -12,6 +13,7 @@ use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::utils::{Logical, Point, Rectangle, Scale, Size};
 use smithay::wayland::compositor::send_surface_state;
 
+use super::closing_window::{ClosingWindow, ClosingWindowRenderElement};
 use super::tile::{Tile, TileRenderElement};
 use super::{LayoutElement, Options};
 use crate::animation::Animation;
@@ -76,6 +78,9 @@ pub struct Workspace<W: LayoutElement> {
     /// The value is the view offset that the previous column had before, to restore it.
     activate_prev_column_on_removal: Option<i32>,
 
+    /// Windows in the closing animation.
+    closing_windows: Vec<ClosingWindow>,
+
     /// Configurable properties of the layout.
     pub options: Rc<Options>,
 
@@ -100,6 +105,7 @@ impl WorkspaceId {
 niri_render_elements! {
     WorkspaceRenderElement<R> => {
         Tile = TileRenderElement<R>,
+        ClosingWindow = ClosingWindowRenderElement,
     }
 }
 
@@ -243,6 +249,7 @@ impl<W: LayoutElement> Workspace<W> {
             view_offset: 0,
             view_offset_adj: None,
             activate_prev_column_on_removal: None,
+            closing_windows: vec![],
             options,
             id: WorkspaceId::next(),
         }
@@ -259,6 +266,7 @@ impl<W: LayoutElement> Workspace<W> {
             view_offset: 0,
             view_offset_adj: None,
             activate_prev_column_on_removal: None,
+            closing_windows: vec![],
             options,
             id: WorkspaceId::next(),
         }
@@ -283,10 +291,17 @@ impl<W: LayoutElement> Workspace<W> {
             let is_active = is_active && col_idx == self.active_column_idx;
             col.advance_animations(current_time, is_active);
         }
+
+        self.closing_windows.retain_mut(|closing| {
+            closing.advance_animations(current_time);
+            closing.are_animations_ongoing()
+        });
     }
 
     pub fn are_animations_ongoing(&self) -> bool {
-        self.view_offset_adj.is_some() || self.columns.iter().any(Column::are_animations_ongoing)
+        self.view_offset_adj.is_some()
+            || self.columns.iter().any(Column::are_animations_ongoing)
+            || !self.closing_windows.is_empty()
     }
 
     pub fn update_config(&mut self, options: Rc<Options>) {
@@ -897,6 +912,97 @@ impl<W: LayoutElement> Workspace<W> {
         self.activate_column(column_idx);
     }
 
+    pub fn start_close_animation_for_window(
+        &mut self,
+        renderer: &mut GlesRenderer,
+        window: &W::Id,
+    ) {
+        let (tile, mut tile_pos) = self
+            .tiles_in_render_order()
+            .find(|(tile, _)| tile.window().id() == window)
+            .unwrap();
+
+        // FIXME: workspaces should probably cache their last used scale so they can be correctly
+        // rendered even with no outputs connected.
+        let output_scale = self
+            .output
+            .as_ref()
+            .map(|o| Scale::from(o.current_scale().fractional_scale()))
+            .unwrap_or(Scale::from(1.));
+
+        let snapshot = tile.take_snapshot_for_close_anim(renderer, output_scale, self.view_size);
+        if snapshot.contents.is_empty() {
+            return;
+        };
+
+        let col_idx = self
+            .columns
+            .iter()
+            .position(|col| col.contains(window))
+            .unwrap();
+
+        let removing_last = self.columns[col_idx].tiles.len() == 1;
+        let offset = self.column_x(col_idx + 1) - self.column_x(col_idx);
+
+        let mut center = Point::from((0, 0));
+        center.x += tile.tile_size().w / 2;
+        center.y += tile.tile_size().h / 2;
+
+        tile_pos.x += self.view_pos();
+
+        if col_idx < self.active_column_idx && removing_last {
+            tile_pos.x -= offset;
+        }
+
+        // FIXME: this is a bit cursed since it's relying on Tile's internal details.
+        let (starting_alpha, starting_scale) = if let Some(anim) = tile.open_animation() {
+            let val = anim.value();
+            (val.clamp(0., 1.) as f32, (val / 2. + 0.5).max(0.))
+        } else {
+            (1., 1.)
+        };
+
+        let anim = Animation::new(
+            1.,
+            0.,
+            0.,
+            self.options.animations.window_close,
+            niri_config::Animation::default_window_close(),
+        );
+
+        let res = ClosingWindow::new(
+            renderer,
+            snapshot,
+            output_scale.x as i32,
+            center,
+            tile_pos,
+            anim,
+            starting_alpha,
+            starting_scale,
+        );
+        match res {
+            Ok(closing) => {
+                self.closing_windows.push(closing);
+            }
+            Err(err) => {
+                warn!("error creating a closing window animation: {err:?}");
+            }
+        }
+
+        // Also move the other columns.
+        if removing_last {
+            if self.active_column_idx <= col_idx {
+                for col in &mut self.columns[col_idx + 1..] {
+                    col.animate_move_from(offset);
+                }
+            } else {
+                for col in &mut self.columns[..col_idx] {
+                    col.animate_move_from(-offset);
+                }
+            }
+        }
+    }
+
     #[cfg(test)]
     pub fn verify_invariants(&self) {
         assert!(self.view_size.w > 0);
@@ -1354,10 +1460,6 @@ impl<W: LayoutElement> Workspace<W> {
         renderer: &mut R,
         target: RenderTarget,
     ) -> Vec<WorkspaceRenderElement<R>> {
-        if self.columns.is_empty() {
-            return vec![];
-        }
-
         // FIXME: workspaces should probably cache their last used scale so they can be correctly
         // rendered even with no outputs connected.
         let output_scale = self
@@ -1367,8 +1469,18 @@ impl<W: LayoutElement> Workspace<W> {
             .unwrap_or(Scale::from(1.));
 
         let mut rv = vec![];
-        let mut first = true;
 
+        // Draw the closing windows on top.
+        let view_pos = self.view_pos();
+        for closing in &self.closing_windows {
+            rv.push(closing.render(view_pos, output_scale, target).into());
+        }
+
+        if self.columns.is_empty() {
+            return rv;
+        }
+
+        let mut first = true;
         for (tile, tile_pos) in self.tiles_in_render_order() {
             // For the active tile (which comes first), draw the focus ring.
             let focus_ring = first;