Implement window resize animations

1 files changed, 334 insertions, 24 deletions

diff --git a/src/layout/tile.rs b/src/layout/tile.rs
index 1fcf4f1b..578de86a 100644
--- a/src/layout/tile.rs
+++ b/src/layout/tile.rs
@@ -1,21 +1,31 @@
+use std::cell::OnceCell;
 use std::cmp::max;
 use std::rc::Rc;
 use std::time::Duration;
 
+use niri_config::BlockOutFrom;
+use smithay::backend::allocator::Fourcc;
 use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
 use smithay::backend::renderer::element::utils::RescaleRenderElement;
 use smithay::backend::renderer::element::{Element, Kind};
-use smithay::backend::renderer::gles::GlesRenderer;
-use smithay::utils::{Logical, Point, Rectangle, Scale, Size};
+use smithay::backend::renderer::gles::{GlesRenderer, GlesTexture};
+use smithay::utils::{Logical, Physical, Point, Rectangle, Scale, Size, Transform};
 
 use super::focus_ring::{FocusRing, FocusRingRenderElement};
-use super::{LayoutElement, LayoutElementRenderElement, Options};
+use super::{
+    AnimationSnapshot, LayoutElement, LayoutElementRenderElement, Options,
+    RESIZE_ANIMATION_THRESHOLD,
+};
 use crate::animation::Animation;
 use crate::niri_render_elements;
+use crate::render_helpers::crossfade::CrossfadeRenderElement;
 use crate::render_helpers::offscreen::OffscreenRenderElement;
 use crate::render_helpers::primary_gpu_texture::PrimaryGpuTextureRenderElement;
 use crate::render_helpers::renderer::NiriRenderer;
-use crate::render_helpers::{RenderSnapshot, RenderTarget, ToRenderElement};
+use crate::render_helpers::shaders::Shaders;
+use crate::render_helpers::{
+    render_to_encompassing_texture, RenderSnapshot, RenderTarget, ToRenderElement,
+};
 
 /// Toplevel window with decorations.
 #[derive(Debug)]
@@ -47,6 +57,12 @@ pub struct Tile<W: LayoutElement> {
     /// The animation upon opening a window.
     open_animation: Option<Animation>,
 
+    /// The animation of the window resizing.
+    resize_animation: Option<ResizeAnimation>,
+
+    /// The animation of a tile visually moving.
+    move_animation: Option<MoveAnimation>,
+
     /// Configurable properties of the layout.
     options: Rc<Options>,
 }
@@ -57,17 +73,41 @@ niri_render_elements! {
         FocusRing = FocusRingRenderElement,
         SolidColor = SolidColorRenderElement,
         Offscreen = RescaleRenderElement<OffscreenRenderElement>,
+        Crossfade = CrossfadeRenderElement,
     }
 }
 
 niri_render_elements! {
-    TileSnapshotRenderElement => {
+    TileSnapshotContentsRenderElement => {
         Texture = PrimaryGpuTextureRenderElement,
+        SolidColor = SolidColorRenderElement,
+    }
+}
+
+niri_render_elements! {
+    TileSnapshotRenderElement => {
+        Contents = RescaleRenderElement<TileSnapshotContentsRenderElement>,
         FocusRing = FocusRingRenderElement,
         SolidColor = SolidColorRenderElement,
     }
 }
 
+#[derive(Debug)]
+struct ResizeAnimation {
+    anim: Animation,
+    size_from: Size<i32, Logical>,
+    snapshot: AnimationSnapshot,
+    /// Snapshot rendered into a texture (happens lazily).
+    snapshot_texture: OnceCell<Option<(GlesTexture, Rectangle<i32, Physical>)>>,
+    snapshot_blocked_out_texture: OnceCell<Option<(GlesTexture, Rectangle<i32, Physical>)>>,
+}
+
+#[derive(Debug)]
+struct MoveAnimation {
+    anim: Animation,
+    from: Point<i32, Logical>,
+}
+
 impl<W: LayoutElement> Tile<W> {
     pub fn new(window: W, options: Rc<Options>) -> Self {
         Self {
@@ -78,6 +118,8 @@ impl<W: LayoutElement> Tile<W> {
             fullscreen_backdrop: SolidColorBuffer::new((0, 0), [0., 0., 0., 1.]),
             fullscreen_size: Default::default(),
             open_animation: None,
+            resize_animation: None,
+            move_animation: None,
             options,
         }
     }
@@ -93,16 +135,76 @@ impl<W: LayoutElement> Tile<W> {
         if self.fullscreen_size != Size::from((0, 0)) {
             self.is_fullscreen = self.window.is_fullscreen();
         }
+
+        if let Some(animate_from) = self.window.take_animation_snapshot() {
+            let size_from = if let Some(resize) = self.resize_animation.take() {
+                // Compute like in animated_window_size(), but using the snapshot geometry (since
+                // the current one is already overwritten).
+                let mut size = animate_from.size;
+
+                let val = resize.anim.value();
+                let size_from = resize.size_from;
+
+                size.w = (size_from.w as f64 + (size.w - size_from.w) as f64 * val).round() as i32;
+                size.h = (size_from.h as f64 + (size.h - size_from.h) as f64 * val).round() as i32;
+
+                size
+            } else {
+                animate_from.size
+            };
+
+            let change = self.window.size().to_point() - size_from.to_point();
+            let change = max(change.x.abs(), change.y.abs());
+            if change > RESIZE_ANIMATION_THRESHOLD {
+                let anim = Animation::new(
+                    0.,
+                    1.,
+                    0.,
+                    self.options.animations.window_resize,
+                    niri_config::Animation::default_window_resize(),
+                );
+                self.resize_animation = Some(ResizeAnimation {
+                    anim,
+                    size_from,
+                    snapshot: animate_from,
+                    snapshot_texture: OnceCell::new(),
+                    snapshot_blocked_out_texture: OnceCell::new(),
+                });
+            } else {
+                self.resize_animation = None;
+            }
+        }
     }
 
     pub fn advance_animations(&mut self, current_time: Duration, is_active: bool) {
+        if let Some(anim) = &mut self.open_animation {
+            anim.set_current_time(current_time);
+            if anim.is_done() {
+                self.open_animation = None;
+            }
+        }
+
+        if let Some(resize) = &mut self.resize_animation {
+            resize.anim.set_current_time(current_time);
+            if resize.anim.is_done() {
+                self.resize_animation = None;
+            }
+        }
+
+        if let Some(move_) = &mut self.move_animation {
+            move_.anim.set_current_time(current_time);
+            if move_.anim.is_done() {
+                self.move_animation = None;
+            }
+        }
+
         let draw_border_with_background = self
             .window
             .rules()
             .draw_border_with_background
             .unwrap_or_else(|| !self.window.has_ssd());
         self.border
-            .update(self.window.size(), !draw_border_with_background);
+            .update(self.animated_window_size(), !draw_border_with_background);
         self.border.set_active(is_active);
 
         let draw_focus_ring_with_background = if self.effective_border_width().is_some() {
@@ -111,22 +213,24 @@ impl<W: LayoutElement> Tile<W> {
             draw_border_with_background
         };
         self.focus_ring
-            .update(self.tile_size(), !draw_focus_ring_with_background);
+            .update(self.animated_tile_size(), !draw_focus_ring_with_background);
         self.focus_ring.set_active(is_active);
-
-        match &mut self.open_animation {
-            Some(anim) => {
-                anim.set_current_time(current_time);
-                if anim.is_done() {
-                    self.open_animation = None;
-                }
-            }
-            None => (),
-        }
     }
 
     pub fn are_animations_ongoing(&self) -> bool {
         self.open_animation.is_some()
+            || self.resize_animation.is_some()
+            || self.move_animation.is_some()
+    }
+
+    pub fn render_offset(&self) -> Point<i32, Logical> {
+        let mut offset = Point::from((0., 0.));
+
+        if let Some(move_) = &self.move_animation {
+            offset += move_.from.to_f64().upscale(move_.anim.value());
+        }
+
+        offset.to_i32_round()
     }
 
     pub fn start_open_animation(&mut self) {
@@ -143,6 +247,24 @@ impl<W: LayoutElement> Tile<W> {
         &self.open_animation
     }
 
+    pub fn resize_animation(&self) -> Option<&Animation> {
+        self.resize_animation.as_ref().map(|resize| &resize.anim)
+    }
+
+    pub fn animate_move_from_with_config(
+        &mut self,
+        from: Point<i32, Logical>,
+        config: niri_config::Animation,
+        default: niri_config::Animation,
+    ) {
+        let current_offset = self.render_offset();
+
+        self.move_animation = Some(MoveAnimation {
+            anim: Animation::new(1., 0., 0., config, default),
+            from: from + current_offset,
+        });
+    }
+
     pub fn window(&self) -> &W {
         &self.window
     }
@@ -217,6 +339,39 @@ impl<W: LayoutElement> Tile<W> {
         self.window.size()
     }
 
+    fn animated_window_size(&self) -> Size<i32, Logical> {
+        let mut size = self.window.size();
+
+        if let Some(resize) = &self.resize_animation {
+            let val = resize.anim.value();
+            let size_from = resize.size_from;
+
+            size.w = (size_from.w as f64 + (size.w - size_from.w) as f64 * val).round() as i32;
+            size.h = (size_from.h as f64 + (size.h - size_from.h) as f64 * val).round() as i32;
+        }
+
+        size
+    }
+
+    fn animated_tile_size(&self) -> Size<i32, Logical> {
+        let mut size = self.animated_window_size();
+
+        if self.is_fullscreen {
+            // Normally we'd just return the fullscreen size here, but this makes things a bit
+            // nicer if a fullscreen window is bigger than the fullscreen size for some reason.
+            size.w = max(size.w, self.fullscreen_size.w);
+            size.h = max(size.h, self.fullscreen_size.h);
+            return size;
+        }
+
+        if let Some(width) = self.effective_border_width() {
+            size.w = size.w.saturating_add(width * 2);
+            size.h = size.h.saturating_add(width * 2);
+        }
+
+        size
+    }
+
     pub fn buf_loc(&self) -> Point<i32, Logical> {
         let mut loc = Point::from((0, 0));
         loc += self.window_loc();
@@ -234,7 +389,7 @@ impl<W: LayoutElement> Tile<W> {
         activation_region.to_f64().contains(point)
     }
 
-    pub fn request_tile_size(&mut self, mut size: Size<i32, Logical>) {
+    pub fn request_tile_size(&mut self, mut size: Size<i32, Logical>, animate: bool) {
         // Can't go through effective_border_width() because we might be fullscreen.
         if !self.border.is_off() {
             let width = self.border.width();
@@ -242,7 +397,7 @@ impl<W: LayoutElement> Tile<W> {
             size.h = max(1, size.h - width * 2);
         }
 
-        self.window.request_size(size);
+        self.window.request_size(size, animate);
     }
 
     pub fn tile_width_for_window_width(&self, size: i32) -> i32 {
@@ -330,11 +485,85 @@ impl<W: LayoutElement> Tile<W> {
             self.window.rules().opacity.unwrap_or(1.).clamp(0., 1.)
         };
 
-        let rv = self
-            .window
-            .render(renderer, location + self.window_loc(), scale, alpha, target)
+        let window_loc = self.window_loc();
+        let window_size = self.window_size();
+        let animated_window_size = self.animated_window_size();
+        let window_render_loc = location + window_loc;
+        let area = Rectangle::from_loc_and_size(window_render_loc, animated_window_size);
+
+        let gles_renderer = renderer.as_gles_renderer();
+
+        // If we're resizing, try to render a crossfade, or a fallback.
+        let mut crossfade = None;
+        let mut crossfade_fallback = None;
+
+        if let Some(resize) = &self.resize_animation {
+            if Shaders::get(gles_renderer).crossfade.is_some() {
+                if let Some(texture_from) = resize.rendered_texture(gles_renderer, scale, target) {
+                    let window_elements =
+                        self.window
+                            .render(gles_renderer, Point::from((0, 0)), scale, 1., target);
+                    let current = render_to_encompassing_texture(
+                        gles_renderer,
+                        scale,
+                        Transform::Normal,
+                        Fourcc::Abgr8888,
+                        &window_elements,
+                    )
+                    .map_err(|err| warn!("error rendering window to texture: {err:?}"))
+                    .ok();
+
+                    if let Some((texture_current, _sync_point, texture_current_geo)) = current {
+                        let elem = CrossfadeRenderElement::new(
+                            gles_renderer,
+                            area,
+                            scale,
+                            texture_from.clone(),
+                            resize.snapshot.size,
+                            (texture_current, texture_current_geo),
+                            window_size,
+                            resize.anim.clamped_value().clamp(0., 1.) as f32,
+                            alpha,
+                        )
+                        .expect("we checked the crossfade shader above");
+                        self.window
+                            .set_offscreen_element_id(Some(elem.id().clone()));
+                        crossfade = Some(elem.into());
+                    }
+                }
+            }
+
+            if crossfade.is_none() {
+                let fallback_buffer = SolidColorBuffer::new(area.size, [1., 0., 0., 1.]);
+                crossfade_fallback = Some(
+                    SolidColorRenderElement::from_buffer(
+                        &fallback_buffer,
+                        area.loc.to_physical_precise_round(scale),
+                        scale,
+                        alpha,
+                        Kind::Unspecified,
+                    )
+                    .into(),
+                );
+                self.window.set_offscreen_element_id(None);
+            }
+        }
+
+        // If we're not resizing, render the window itself.
+        let mut window = None;
+        if crossfade.is_none() && crossfade_fallback.is_none() {
+            window = Some(
+                self.window
+                    .render(renderer, window_render_loc, scale, alpha, target)
+                    .into_iter()
+                    .map(Into::into),
+            );
+        }
+
+        let rv = crossfade
             .into_iter()
-            .map(Into::into);
+            .chain(crossfade_fallback)
+            .chain(window.into_iter().flatten());
 
         let elem = self.effective_border_width().map(|width| {
             self.border
@@ -422,7 +651,7 @@ impl<W: LayoutElement> Tile<W> {
         contents: Vec<C>,
     ) -> Vec<TileSnapshotRenderElement>
     where
-        E: Into<TileSnapshotRenderElement>,
+        E: Into<TileSnapshotContentsRenderElement>,
         C: ToRenderElement<RenderElement = E>,
     {
         let alpha = if self.is_fullscreen {
@@ -431,10 +660,18 @@ impl<W: LayoutElement> Tile<W> {
             self.window.rules().opacity.unwrap_or(1.).clamp(0., 1.)
         };
 
+        let window_size = self.window_size();
+        let animated_window_size = self.animated_window_size();
+        let animated_scale = animated_window_size.to_f64() / window_size.to_f64();
+
         let mut rv = vec![];
 
         for baked in contents {
             let elem = baked.to_render_element(self.window_loc(), scale, alpha, Kind::Unspecified);
+            let elem: TileSnapshotContentsRenderElement = elem.into();
+
+            let origin = self.window_loc().to_physical_precise_round(scale);
+            let elem = RescaleRenderElement::from_element(elem, origin, animated_scale);
             rv.push(elem.into());
         }
 
@@ -483,3 +720,76 @@ impl<W: LayoutElement> Tile<W> {
         }
     }
 }
+
+impl ResizeAnimation {
+    fn rendered_texture(
+        &self,
+        renderer: &mut GlesRenderer,
+        scale: Scale<f64>,
+        target: RenderTarget,
+    ) -> &Option<(GlesTexture, Rectangle<i32, Physical>)> {
+        let block_out = match self.snapshot.render.block_out_from {
+            None => false,
+            Some(BlockOutFrom::Screencast) => target == RenderTarget::Screencast,
+            Some(BlockOutFrom::ScreenCapture) => target != RenderTarget::Output,
+        };
+
+        if block_out {
+            self.snapshot_blocked_out_texture.get_or_init(|| {
+                let _span = tracy_client::span!("ResizeAnimation::rendered_texture");
+
+                let elements: Vec<_> = self
+                    .snapshot
+                    .render
+                    .blocked_out_contents
+                    .iter()
+                    .map(|baked| {
+                        baked.to_render_element(Point::from((0, 0)), scale, 1., Kind::Unspecified)
+                    })
+                    .collect();
+
+                match render_to_encompassing_texture(
+                    renderer,
+                    scale,
+                    Transform::Normal,
+                    Fourcc::Abgr8888,
+                    &elements,
+                ) {
+                    Ok((texture, _sync_point, geo)) => Some((texture, geo)),
+                    Err(err) => {
+                        warn!("error rendering snapshot to texture: {err:?}");
+                        None
+                    }
+                }
+            })
+        } else {
+            self.snapshot_texture.get_or_init(|| {
+                let _span = tracy_client::span!("ResizeAnimation::rendered_texture");
+
+                let elements: Vec<_> = self
+                    .snapshot
+                    .render
+                    .contents
+                    .iter()
+                    .map(|baked| {
+                        baked.to_render_element(Point::from((0, 0)), scale, 1., Kind::Unspecified)
+                    })
+                    .collect();
+
+                match render_to_encompassing_texture(
+                    renderer,
+                    scale,
+                    Transform::Normal,
+                    Fourcc::Abgr8888,
+                    &elements,
+                ) {
+                    Ok((texture, _sync_point, geo)) => Some((texture, geo)),
+                    Err(err) => {
+                        warn!("error rendering snapshot to texture: {err:?}");
+                        None
+                    }
+                }
+            })
+        }
+    }
+}