From dd011f1012e10b1e3a1dbe100cb603a457bba12a Mon Sep 17 00:00:00 2001 From: Ivan Molodetskikh Date: Tue, 9 Apr 2024 22:37:10 +0400 Subject: Implement window closing animations --- src/layout/closing_window.rs | 177 +++++++++++++++++++++++++++++++++++++++++++ src/layout/mod.rs | 47 +++++++++++- src/layout/tile.rs | 73 +++++++++++++++++- src/layout/workspace.rs | 124 ++++++++++++++++++++++++++++-- 4 files changed, 411 insertions(+), 10 deletions(-) create mode 100644 src/layout/closing_window.rs (limited to 'src/layout') 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, + + /// Blocked-out contents of the window. + blocked_out_buffer: TextureBuffer, + + /// Where the window should be blocked out from. + block_out_from: Option, + + /// Center of the window geometry. + center: Point, + + /// Position in the workspace. + pos: Point, + + /// How much the buffer should be offset. + buffer_offset: Point, + + /// How much the blocked-out buffer should be offset. + blocked_out_buffer_offset: Point, + + /// 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>, + } +} + +impl ClosingWindow { + #[allow(clippy::too_many_arguments)] + pub fn new>( + renderer: &mut GlesRenderer, + snapshot: RenderSnapshot, + scale: i32, + center: Point, + pos: Point, + anim: Animation, + starting_alpha: f32, + starting_scale: f64, + ) -> anyhow::Result { + let _span = tracy_client::span!("ClosingWindow::new"); + + let mut render_to_buffer = |elements: Vec| -> 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, + 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>; + fn take_last_render(&self) -> RenderSnapshot; + fn request_size(&self, size: Size); fn request_fullscreen(&self, size: Size); fn min_size(&self) -> Size; @@ -1750,6 +1762,35 @@ impl Layout { } } + 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 { + RenderSnapshot::default() + } + fn request_size(&self, size: Size) { 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, + FocusRing = FocusRingRenderElement, + SolidColor = SolidColorRenderElement, + } +} + impl Tile { pub fn new(window: W, options: Rc) -> Self { Self { @@ -129,6 +142,10 @@ impl Tile { )); } + pub fn open_animation(&self) -> &Option { + &self.open_animation + } + pub fn window(&self) -> &W { &self.window } @@ -399,4 +416,54 @@ impl Tile { None.into_iter().chain(Some(elements).into_iter().flatten()) } } + + pub fn take_snapshot_for_close_anim( + &self, + renderer: &mut GlesRenderer, + scale: Scale, + view_size: Size, + ) -> RenderSnapshot { + 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 { /// The value is the view offset that the previous column had before, to restore it. activate_prev_column_on_removal: Option, + /// Windows in the closing animation. + closing_windows: Vec, + /// Configurable properties of the layout. pub options: Rc, @@ -100,6 +105,7 @@ impl WorkspaceId { niri_render_elements! { WorkspaceRenderElement => { Tile = TileRenderElement, + ClosingWindow = ClosingWindowRenderElement, } } @@ -243,6 +249,7 @@ impl Workspace { 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 Workspace { 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 Workspace { 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) { @@ -897,6 +912,97 @@ impl Workspace { 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 Workspace { renderer: &mut R, target: RenderTarget, ) -> Vec> { - 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 Workspace { .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; -- cgit