Merge remote-tracking branch 'upstream/wip/branch' into feat/blur

Author: busyoGG

Cargo.lock

@@ -30,8 +30,9 @@ tracy-client = { version = "0.18.4", default-features = false }
 
 [workspace.dependencies.smithay]
 # version = "0.4.1"
-git = "https://github.com/Smithay/smithay.git"
+git = "https://github.com/YaLTeR/smithay.git"
 # path = "../smithay"
+rev = "5f784c9ad6ae619c880e4713e120b281e2ce5383"
 default-features = false
 
 [workspace.dependencies.smithay-drm-extras]
@@ -93,6 +94,7 @@ tracing-subscriber.workspace = true
 tracing.workspace = true
 tracy-client.workspace = true
 wayland-backend = "0.3.12"
+wayland-protocols-plasma = { version = "0.3.10", features = ["server"] }
 wayland-scanner = "0.31.8"
 xcursor = "0.3.10"
 zbus = { version = "5.13.0", optional = true }

Cargo.toml

@@ -314,36 +314,64 @@ impl From<FocusRing> for Border {
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Blur {
-    pub on: bool,
-    pub passes: u32,
-    pub radius: FloatOrInt<0, 1024>,
-    pub noise: FloatOrInt<0, 1024>,
+    pub off: bool,
+    pub passes: u8,
+    pub offset: f64,
+    pub noise: f64,
+    pub saturation: f64,
     pub ignore_alpha: FloatOrInt<0, 1>,
     pub blur_when_keyboard_focused: bool,
 }
 
+#[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>>,
+    #[knuffel(child, unwrap(argument))]
+    pub noise: Option<FloatOrInt<0, 1000>>,
+    #[knuffel(child, unwrap(argument))]
+    pub saturation: Option<FloatOrInt<0, 1000>>,
+    #[knuffel(child, unwrap(argument))]
+    pub ignore_alpha: Option<FloatOrInt<0, 1>>,
+    #[knuffel(child, unwrap(argument))]
+    pub blur_when_keyboard_focused: Option<bool>,
+}
+
 impl Default for Blur {
     fn default() -> Self {
         Self {
-            // off: false,
-            on: false,
+            off: false,
             passes: 2,
-            radius: FloatOrInt(0.0),
-            noise: FloatOrInt(0.0),
+            offset: 3.,
+            noise: 0.02,
             ignore_alpha: FloatOrInt(0.),
             blur_when_keyboard_focused: false,
+            saturation: 1.5,
         }
     }
 }
 
-impl MergeWith<BlurRule> for Blur {
-    fn merge_with(&mut self, part: &BlurRule) {
-        self.on |= part.on;
-        if part.off {
-            self.on = false;
+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, radius, noise, ignore_alpha, blur_when_keyboard_focused);
+        merge_clone!(
+            (self, part),
+            ignore_alpha,
+            passes,
+            blur_when_keyboard_focused
+        );
+
+        merge!((self, part), offset, noise, saturation);
     }
 }
 
@@ -688,24 +716,6 @@ pub struct BorderRule {
     pub urgent_gradient: Option<Gradient>,
 }
 
-#[derive(knuffel::Decode, Debug, Default, Clone, Copy, PartialEq)]
-pub struct BlurRule {
-    #[knuffel(child)]
-    pub off: bool,
-    #[knuffel(child)]
-    pub on: bool,
-    #[knuffel(child, unwrap(argument))]
-    pub passes: Option<u32>,
-    #[knuffel(child, unwrap(argument))]
-    pub radius: Option<FloatOrInt<0, 1024>>,
-    #[knuffel(child, unwrap(argument))]
-    pub noise: Option<FloatOrInt<0, 1024>>,
-    #[knuffel(child, unwrap(argument))]
-    pub ignore_alpha: Option<FloatOrInt<0, 1>>,
-    #[knuffel(child, unwrap(argument))]
-    pub blur_when_keyboard_focused: Option<bool>,
-}
-
 #[derive(knuffel::Decode, Debug, Default, Clone, Copy, PartialEq)]
 pub struct ShadowRule {
     #[knuffel(child)]
@@ -759,10 +769,18 @@ impl MergeWith<Self> for BorderRule {
     }
 }
 
-impl MergeWith<Self> for BlurRule {
+impl MergeWith<Self> for BlurPart {
     fn merge_with(&mut self, part: &Self) {
         merge_on_off!((self, part));
-        merge_clone_opt!((self, part), passes, radius, noise, ignore_alpha,blur_when_keyboard_focused);
+        merge_clone_opt!(
+            (self, part),
+            passes,
+            offset,
+            saturation,
+            noise,
+            ignore_alpha,
+            blur_when_keyboard_focused
+        );
     }
 }
 
@@ -1078,6 +1096,72 @@ where
     }
 }
 
+#[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,
+    #[knuffel(child, unwrap(argument))]
+    pub noise: Option<FloatOrInt<0, 1000>>,
+    #[knuffel(child, unwrap(argument))]
+    pub saturation: Option<FloatOrInt<0, 1000>>,
+}
+
+impl MergeWith<Self> for BackgroundEffectRule {
+    fn merge_with(&mut self, part: &Self) {
+        merge_clone_opt!((self, part), xray, noise, saturation);
+        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: Option<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>,
+
+    pub noise: Option<f64>,
+    pub saturation: Option<f64>,
+}
+
+impl MergeWith<BackgroundEffectRule> for BackgroundEffect {
+    fn merge_with(&mut self, part: &BackgroundEffectRule) {
+        merge_clone_opt!((self, part), xray);
+
+        if part.blur.on {
+            self.blur = Some(true);
+        }
+        if part.blur.off {
+            self.blur = Some(false);
+        }
+
+        if let Some(x) = part.noise {
+            self.noise = Some(x.0);
+        }
+
+        if let Some(x) = part.saturation {
+            self.saturation = Some(x.0);
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use insta::{assert_debug_snapshot, assert_snapshot};

niri-config/src/appearance.rs

@@ -1,4 +1,4 @@
-use crate::appearance::{BlockOutFrom, BlurRule, CornerRadius, ShadowRule};
+use crate::appearance::{BackgroundEffectRule, BlockOutFrom, CornerRadius, ShadowRule};
 use crate::utils::RegexEq;
 
 #[derive(knuffel::Decode, Debug, Default, Clone, PartialEq)]
@@ -14,8 +14,8 @@ pub struct LayerRule {
     pub block_out_from: Option<BlockOutFrom>,
     #[knuffel(child, default)]
     pub shadow: ShadowRule,
-    #[knuffel(child, default)]
-    pub blur: BlurRule,
+    // #[knuffel(child, default)]
+    // pub blur: BlurRule,
     #[knuffel(child)]
     pub geometry_corner_radius: Option<CornerRadius>,
     #[knuffel(child, unwrap(argument))]
@@ -26,6 +26,8 @@ pub struct LayerRule {
     pub transparent_block: Option<bool>,
     #[knuffel(child, unwrap(argument))]
     pub rounding_exponent: Option<f32>,
+    #[knuffel(child, default)]
+    pub background_effect: BackgroundEffectRule,
 }
 
 #[derive(knuffel::Decode, Debug, Default, Clone, PartialEq)]

niri-config/src/layer_rule.rs

@@ -27,7 +27,6 @@ pub struct Layout {
     pub gaps: f64,
     pub struts: Struts,
     pub background_color: Color,
-    pub blur: Blur,
     pub background_in_working_area_only: bool,
     pub fullscreen_backdrop_color: Color,
 }
@@ -58,7 +57,6 @@ impl Default for Layout {
                 PresetSize::Proportion(2. / 3.),
             ],
             background_color: DEFAULT_BACKGROUND_COLOR,
-            blur: Default::default(),
             background_in_working_area_only: false,
             fullscreen_backdrop_color: DEFAULT_BACKDROP_COLOR,
         }
@@ -78,7 +76,6 @@ impl MergeWith<LayoutPart> for Layout {
             empty_workspace_above_first,
             background_in_working_area_only,
             gaps,
-            blur,
         );
 
         merge_clone!(