commit

Author: YaLTeR

Cargo.lock

@@ -32,11 +32,13 @@ tracy-client = { version = "0.18.4", default-features = false }
 # version = "0.4.1"
 git = "https://github.com/Smithay/smithay.git"
 # path = "../smithay"
+rev = "fbbcd475743f96f67fcfc4b4b6a5120e822fcfe2"
 default-features = false
 
 [workspace.dependencies.smithay-drm-extras]
 # version = "0.1.0"
 git = "https://github.com/Smithay/smithay.git"
+rev = "fbbcd475743f96f67fcfc4b4b6a5120e822fcfe2"
 # path = "../smithay/smithay-drm-extras"
 
 [package]

Cargo.toml

@@ -1006,6 +1006,101 @@ where
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Blur {
+    pub off: bool,
+    pub passes: u8,
+    pub offset: f64,
+}
+
+impl Default for Blur {
+    fn default() -> Self {
+        Self {
+            off: false,
+            // TODO: tune, reduce passes
+            passes: 3,
+            offset: 3.,
+        }
+    }
+}
+
+#[derive(knuffel::Decode, Debug, Default, Clone, Copy, PartialEq)]
+pub struct BlurPart {
+    #[knuffel(child)]
+    pub off: bool,
+    #[knuffel(child)]
+    pub on: bool,
+    #[knuffel(child, unwrap(argument))]
+    pub passes: Option<u8>,
+    #[knuffel(child, unwrap(argument))]
+    pub offset: Option<FloatOrInt<0, 100>>,
+}
+
+impl MergeWith<BlurPart> for Blur {
+    fn merge_with(&mut self, part: &BlurPart) {
+        self.off |= part.off;
+        if part.on {
+            self.off = false;
+        }
+
+        merge_clone!((self, part), passes);
+        merge!((self, part), offset);
+    }
+}
+
+#[derive(knuffel::Decode, Debug, Default, Clone, Copy, PartialEq)]
+pub struct BlurRule {
+    #[knuffel(child)]
+    pub off: bool,
+    #[knuffel(child)]
+    pub on: bool,
+}
+
+#[derive(knuffel::Decode, Debug, Default, Clone, Copy, PartialEq)]
+pub struct BackgroundEffectRule {
+    #[knuffel(child, unwrap(argument))]
+    pub xray: Option<bool>,
+    #[knuffel(child, default)]
+    pub blur: BlurRule,
+}
+
+impl MergeWith<Self> for BackgroundEffectRule {
+    fn merge_with(&mut self, part: &Self) {
+        merge_clone_opt!((self, part), xray);
+        merge_on_off!((self.blur, part.blur));
+    }
+}
+
+/// Resolved background effect rule.
+#[derive(Debug, Default, Clone, Copy, PartialEq)]
+pub struct BackgroundEffect {
+    /// Whether to render with xray effect (see through).
+    pub xray: bool,
+
+    /// Whether to blur the background.
+    ///
+    /// - `None`: blur when the window/layer requests it (e.g. through ext-background-effect
+    ///   protocol)
+    /// - `Some(false)`: never blur
+    /// - `Some(true)`: always blur
+    pub blur: Option<bool>,
+}
+
+impl MergeWith<BackgroundEffectRule> for BackgroundEffect {
+    fn merge_with(&mut self, part: &BackgroundEffectRule) {
+        if let Some(x) = part.xray {
+            self.xray = x;
+        }
+
+        if part.blur.on {
+            self.blur = Some(true);
+        }
+        if part.blur.off {
+            self.blur = Some(false);
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use insta::{assert_debug_snapshot, assert_snapshot};

niri-config/src/appearance.rs

@@ -1,4 +1,4 @@
-use crate::appearance::{BlockOutFrom, CornerRadius, ShadowRule};
+use crate::appearance::{BackgroundEffectRule, BlockOutFrom, CornerRadius, ShadowRule};
 use crate::utils::RegexEq;
 
 #[derive(knuffel::Decode, Debug, Default, Clone, PartialEq)]
@@ -20,6 +20,8 @@ pub struct LayerRule {
     pub place_within_backdrop: Option<bool>,
     #[knuffel(child, unwrap(argument))]
     pub baba_is_float: Option<bool>,
+    #[knuffel(child, default)]
+    pub background_effect: BackgroundEffectRule,
 }
 
 #[derive(knuffel::Decode, Debug, Default, Clone, PartialEq)]

niri-config/src/layer_rule.rs

@@ -78,6 +78,7 @@ pub struct Config {
     pub hotkey_overlay: HotkeyOverlay,
     pub config_notification: ConfigNotification,
     pub animations: Animations,
+    pub blur: Blur,
     pub gestures: Gestures,
     pub overview: Overview,
     pub environment: Environment,
@@ -194,6 +195,7 @@ where
                 "hotkey-overlay" => m_merge!(hotkey_overlay),
                 "config-notification" => m_merge!(config_notification),
                 "animations" => m_merge!(animations),
+                "blur" => m_merge!(blur),
                 "gestures" => m_merge!(gestures),
                 "overview" => m_merge!(overview),
                 "xwayland-satellite" => m_merge!(xwayland_satellite),
@@ -1616,6 +1618,11 @@ mod tests {
                     },
                 ),
             },
+            blur: Blur {
+                off: false,
+                passes: 3,
+                offset: 3.0,
+            },
             gestures: Gestures {
                 dnd_edge_view_scroll: DndEdgeViewScroll {
                     trigger_width: 10.0,
@@ -1845,6 +1852,13 @@ mod tests {
                     ),
                     scroll_factor: None,
                     tiled_state: None,
+                    background_effect: BackgroundEffectRule {
+                        xray: None,
+                        blur: BlurRule {
+                            off: false,
+                            on: false,
+                        },
+                    },
                 },
             ],
             layer_rules: [
@@ -1879,6 +1893,13 @@ mod tests {
                     geometry_corner_radius: None,
                     place_within_backdrop: None,
                     baba_is_float: None,
+                    background_effect: BackgroundEffectRule {
+                        xray: None,
+                        blur: BlurRule {
+                            off: false,
+                            on: false,
+                        },
+                    },
                 },
             ],
             binds: Binds(

niri-config/src/lib.rs

@@ -1,6 +1,8 @@
 use niri_ipc::ColumnDisplay;
 
-use crate::appearance::{BlockOutFrom, BorderRule, CornerRadius, ShadowRule, TabIndicatorRule};
+use crate::appearance::{
+    BackgroundEffectRule, BlockOutFrom, BorderRule, CornerRadius, ShadowRule, TabIndicatorRule,
+};
 use crate::layout::DefaultPresetSize;
 use crate::utils::RegexEq;
 use crate::FloatOrInt;
@@ -72,6 +74,8 @@ pub struct WindowRule {
     pub scroll_factor: Option<FloatOrInt<0, 100>>,
     #[knuffel(child, unwrap(argument))]
     pub tiled_state: Option<bool>,
+    #[knuffel(child, default)]
+    pub background_effect: BackgroundEffectRule,
 }
 
 #[derive(knuffel::Decode, Debug, Default, Clone, PartialEq)]

niri-config/src/window_rule.rs

@@ -10,6 +10,7 @@ use super::ResolvedLayerRules;
 use crate::animation::Clock;
 use crate::layout::shadow::Shadow;
 use crate::niri_render_elements;
+use crate::render_helpers::background_effect::{self, BackgroundEffect, BackgroundEffectElement};
 use crate::render_helpers::renderer::NiriRenderer;
 use crate::render_helpers::shadow::ShadowRenderElement;
 use crate::render_helpers::solid_color::{SolidColorBuffer, SolidColorRenderElement};
@@ -31,6 +32,9 @@ pub struct MappedLayer {
     /// The shadow around the surface.
     shadow: Shadow,
 
+    /// The background effect underneath the layer surface geometry.
+    pub background_effect: BackgroundEffect,
+
     /// The view size for the layer surface's output.
     view_size: Size<f64, Logical>,
 
@@ -46,6 +50,7 @@ niri_render_elements! {
         Wayland = WaylandSurfaceRenderElement<R>,
         SolidColor = SolidColorRenderElement,
         Shadow = ShadowRenderElement,
+        BackgroundEffect = BackgroundEffectElement,
     }
 }
 
@@ -70,6 +75,7 @@ impl MappedLayer {
             view_size,
             scale,
             shadow: Shadow::new(shadow_config),
+            background_effect: BackgroundEffect::new(),
             clock,
         }
     }
@@ -103,6 +109,16 @@ impl MappedLayer {
         // FIXME: is_active based on keyboard focus?
         self.shadow
             .update_render_elements(size, true, radius, self.scale, 1.);
+
+        let effect = self.rules.background_effect;
+        self.background_effect
+            .update_params(background_effect::Parameters {
+                corner_radius: radius,
+                xray: effect.xray,
+                // TODO: ext-background-effect
+                blur: effect.blur == Some(true),
+            });
+        self.background_effect.update_size(size);
     }
 
     pub fn are_animations_ongoing(&self) -> bool {
@@ -197,6 +213,12 @@ impl MappedLayer {
         let location = location.to_physical_precise_round(scale).to_logical(scale);
         self.shadow
             .render(renderer, location, &mut |elem| push(elem.into()));
+
+        // TODO subsurfaces peeking out of the main surface? Ext background effect subsurfaces?
+        if let Some(elem) = self.background_effect.render(renderer.as_gles_renderer()) {
+            let location = location.to_physical_precise_round(scale).to_logical(scale);
+            push(elem.with_location(location).into());
+        }
     }
 
     pub fn render_popups<R: NiriRenderer>(

src/layer/mapped.rs

@@ -1,6 +1,6 @@
 use niri_config::layer_rule::{LayerRule, Match};
 use niri_config::utils::MergeWith as _;
-use niri_config::{BlockOutFrom, CornerRadius, ShadowRule};
+use niri_config::{BackgroundEffect, BlockOutFrom, CornerRadius, ShadowRule};
 use smithay::desktop::LayerSurface;
 
 pub mod mapped;
@@ -26,6 +26,9 @@ pub struct ResolvedLayerRules {
 
     /// Whether to bob this window up and down.
     pub baba_is_float: bool,
+
+    /// Background effect configuration.
+    pub background_effect: BackgroundEffect,
 }
 
 impl ResolvedLayerRules {
@@ -70,6 +73,10 @@ impl ResolvedLayerRules {
             }
 
             resolved.shadow.merge_with(&rule.shadow);
+
+            resolved
+                .background_effect
+                .merge_with(&rule.background_effect);
         }
 
         resolved

src/layer/mod.rs

@@ -18,6 +18,7 @@ use super::{
 use crate::animation::{Animation, Clock};
 use crate::layout::SizingMode;
 use crate::niri_render_elements;
+use crate::render_helpers::background_effect::{self, BackgroundEffect, BackgroundEffectElement};
 use crate::render_helpers::border::BorderRenderElement;
 use crate::render_helpers::clipped_surface::{ClippedSurfaceRenderElement, RoundedCornerDamage};
 use crate::render_helpers::damage::ExtraDamage;
@@ -57,6 +58,9 @@ pub struct Tile<W: LayoutElement> {
     /// The black backdrop for fullscreen windows.
     fullscreen_backdrop: SolidColorBuffer,
 
+    /// The background effect underneath the window geometry.
+    pub background_effect: BackgroundEffect,
+
     /// Whether the tile should float upon unfullscreening.
     pub(super) restore_to_floating: bool,
 
@@ -130,6 +134,7 @@ niri_render_elements! {
         ClippedSurface = ClippedSurfaceRenderElement<R>,
         Offscreen = OffscreenRenderElement,
         ExtraDamage = ExtraDamage,
+        BackgroundEffect = BackgroundEffectElement,
     }
 }
 
@@ -192,6 +197,7 @@ impl<W: LayoutElement> Tile<W> {
             shadow: Shadow::new(shadow_config),
             sizing_mode,
             fullscreen_backdrop: SolidColorBuffer::new((0., 0.), [0., 0., 0., 1.]),
+            background_effect: BackgroundEffect::new(),
             restore_to_floating: false,
             floating_window_size: None,
             floating_pos: None,
@@ -455,6 +461,7 @@ impl<W: LayoutElement> Tile<W> {
     pub fn update_render_elements(&mut self, is_active: bool, view_rect: Rectangle<f64, Logical>) {
         let rules = self.window.rules();
         let animated_tile_size = self.animated_tile_size();
+        let animated_window_size = self.animated_window_size();
         let expanded_progress = self.expanded_progress();
 
         let draw_border_with_background = rules
@@ -505,6 +512,16 @@ impl<W: LayoutElement> Tile<W> {
             1. - expanded_progress as f32,
         );
 
+        let effect = rules.background_effect;
+        self.background_effect
+            .update_params(background_effect::Parameters {
+                corner_radius: radius,
+                xray: effect.xray,
+                // TODO: ext-background-effect
+                blur: effect.blur == Some(true),
+            });
+        self.background_effect.update_size(animated_window_size);
+
         let draw_focus_ring_with_background = if self.border.is_off() {
             draw_border_with_background
         } else {
@@ -1283,6 +1300,11 @@ impl<W: LayoutElement> Tile<W> {
             self.shadow
                 .render(renderer, location, &mut |elem| push(elem.into()));
         }
+
+        // TODO subsurfaces peeking out of the main surface? Ext background effect subsurfaces?
+        if let Some(elem) = self.background_effect.render(renderer.as_gles_renderer()) {
+            push(elem.with_location(window_render_loc).into());
+        }
     }
 
     pub fn render<R: NiriRenderer>(