config: [blur] add blur-when-keyboard-focused

Author: busyoGG

README.md

@@ -49,6 +49,7 @@ layer-rule{
         passes 1
         radius 4
         ignore-alpha 0.1 // 透明度剔除
+        blur-when-keyboard-focused true // 只在键盘聚焦时进行模糊
     }
 }
 ```

niri-config/src/appearance.rs

@@ -319,6 +319,7 @@ pub struct Blur {
     pub radius: FloatOrInt<0, 1024>,
     pub noise: FloatOrInt<0, 1024>,
     pub ignore_alpha: FloatOrInt<0, 1>,
+    pub blur_when_keyboard_focused: bool,
 }
 
 impl Default for Blur {
@@ -330,6 +331,7 @@ impl Default for Blur {
             radius: FloatOrInt(0.0),
             noise: FloatOrInt(0.0),
             ignore_alpha: FloatOrInt(0.),
+            blur_when_keyboard_focused: false,
         }
     }
 }
@@ -341,7 +343,7 @@ impl MergeWith<BlurRule> for Blur {
             self.on = false;
         }
 
-        merge_clone!((self, part), passes, radius, noise, ignore_alpha);
+        merge_clone!((self, part), passes, radius, noise, ignore_alpha, blur_when_keyboard_focused);
     }
 }
 
@@ -700,6 +702,8 @@ pub struct BlurRule {
     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)]

src/layer/mapped.rs

@@ -201,8 +201,6 @@ impl MappedLayer {
         fx_buffers: Option<EffectsFramebufffersUserData>,
         push: &mut dyn FnMut(LayerSurfaceRenderElement<R>),
     ) {
-        let mut gles_elems: Option<Vec<LayerSurfaceRenderElement<GlesRenderer>>> = None;
-
         let scale = Scale::from(self.scale);
         let alpha = self.rules.opacity.unwrap_or(1.).clamp(0., 1.);
         let location = location + self.bob_offset();
@@ -236,23 +234,26 @@ impl MappedLayer {
                 &mut |elem| push(elem.into()),
             );
 
-            gles_elems = Some(render_elements_from_surface_tree(
-                renderer.as_gles_renderer(),
-                surface,
-                buf_pos.to_physical_precise_round(scale),
-                scale,
-                alpha,
-                Kind::ScanoutCandidate,
-            ));
-
             if self.blur_config.on
+                && (!self.blur_config.blur_when_keyboard_focused
+                    || self.blur_config.blur_when_keyboard_focused
+                        && self.surface.can_receive_keyboard_focus())
             /* && matches!(self.surface.layer(), Layer::Top | Layer::Overlay) */
             {
                 if let Some(fx_buffers) = fx_buffers {
                     let fx_buffers_rc = fx_buffers;
                     let fx_buffers = fx_buffers_rc.borrow();
 
-                    // debug!("render layer blur {:?}", self.rules.blur);
+                    let gles_elems: Option<Vec<LayerSurfaceRenderElement<GlesRenderer>>> =
+                        Some(render_elements_from_surface_tree(
+                            renderer.as_gles_renderer(),
+                            surface,
+                            buf_pos.to_physical_precise_round(scale),
+                            scale,
+                            alpha,
+                            Kind::ScanoutCandidate,
+                        ));
+
                     // TODO: respect sync point?
                     let alpha_tex = gles_elems
                         .and_then(|gles_elems| {
@@ -328,8 +329,6 @@ impl MappedLayer {
 
             let size = popup.geometry().size.to_f64();
 
-            let mut gles_elems: Option<Vec<LayerSurfaceRenderElement<GlesRenderer>>> = None;
-
             {
                 push_elements_from_surface_tree(
                     renderer,
@@ -342,18 +341,20 @@ impl MappedLayer {
                 );
             }
 
-            gles_elems = Some(render_elements_from_surface_tree(
-                renderer.as_gles_renderer(),
-                popup.wl_surface(),
-                (buf_pos + offset.to_f64()).to_physical_precise_round(scale),
-                scale,
-                alpha,
-                Kind::ScanoutCandidate,
-            ));
-
             if self.blur_config.on {
                 if let Some(fx_buffers_rc) = fx_buffers.as_ref() {
                     let fx_buffers = fx_buffers_rc.borrow();
+
+                    let gles_elems: Option<Vec<LayerSurfaceRenderElement<GlesRenderer>>> =
+                        Some(render_elements_from_surface_tree(
+                            renderer.as_gles_renderer(),
+                            popup.wl_surface(),
+                            (buf_pos + offset.to_f64()).to_physical_precise_round(scale),
+                            scale,
+                            alpha,
+                            Kind::ScanoutCandidate,
+                        ));
+
                     let alpha_tex = gles_elems
                         .and_then(|gles_elems| {
                             let transform = fx_buffers.transform();

src/layer/mod.rs

@@ -59,6 +59,7 @@ impl ResolvedLayerRules {
                 radius: None,
                 noise: None,
                 ignore_alpha: None,
+                blur_when_keyboard_focused: None,
             },
             geometry_corner_radius: None,
             place_within_backdrop: false,

src/render_helpers/blur/element.rs

@@ -6,7 +6,7 @@ use smithay::backend::renderer::element::texture::TextureRenderElement;
 use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
 use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer, GlesTexture, Uniform};
 use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
-use smithay::backend::renderer::Renderer;
+use smithay::backend::renderer::{Renderer, Texture};
 use smithay::output::Output;
 use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform};
 

src/render_helpers/blur/mod.rs

@@ -130,7 +130,7 @@ impl EffectsFramebuffers {
                 size.to_logical(1).to_buffer(1, Transform::Normal),
             )
         }
-
+ 
         let mut sample_effects: Vec<GlesTexture> = Vec::new();
         let mut sample_fbos: Vec<u32> = Vec::new();
         for i in 0..8 {
@@ -441,10 +441,11 @@ pub(super) unsafe fn get_main_buffer_blur(
 
     let dst_expanded = {
         let mut dst = dst;
-        let size =
-            (2f32.powi(blur_config.passes as i32 + 1) * blur_config.radius.0 as f32).ceil() as i32;
-        dst.loc -= Point::from((size, size)).upscale(8);
-        dst.size += Size::from((size, size)).upscale(16);
+        // let size =
+        //     (2f32.powi(blur_config.passes as i32 + 1) * blur_config.radius.0 as f32).ceil() as i32;
+        let size= blur_config.radius.0 as i32;
+        dst.loc -= Point::from((size, size));
+        dst.size += Size::from((size, size)).upscale(2);
         dst
     };
 
@@ -547,13 +548,13 @@ pub(super) unsafe fn get_main_buffer_blur(
         // ];
         for i in 0..passes {
             let (sample_buffer, render_buffer, render_buffer_fbo) = fx_buffers.sample_buffers(i);
-            let damage = dst_expanded.downscale(1 << (i + 1));
+            // let damage = dst_expanded.downscale(1 << (i + 1));
             let tex_size_down = sample_buffer.size(); // 当前 FBO 尺寸
             let half_pixel = [0.5 / tex_size_down.w as f32, 0.5 / tex_size_down.h as f32];
-            debug!(
-                "dst_expanded {:?} tex_size_down {:?}",
-                dst_expanded, tex_size_down
-            );
+            // debug!(
+            //     "dst_expanded {:?} tex_size_down {:?}",
+            //     dst_expanded, tex_size_down
+            // );
             render_blur_pass_with_gl(
                 gl,
                 vbos,
@@ -567,7 +568,7 @@ pub(super) unsafe fn get_main_buffer_blur(
                 &shaders.down,
                 half_pixel,
                 blur_config.clone(),
-                damage,
+                // damage,
                 render_buffer_fbo,
                 i,
             )?;
@@ -582,7 +583,7 @@ pub(super) unsafe fn get_main_buffer_blur(
             // let (sample_buffer, render_buffer) = fx_buffers.buffers();
             let (render_buffer, sample_buffer, render_buffer_fbo) =
                 fx_buffers.sample_buffers_rev(i);
-            let damage = dst_expanded.downscale(1 << (passes - 1 - i));
+            // let damage = dst_expanded.downscale(1 << (passes - 1 - i));
             let tex_size_down = sample_buffer.size(); // 当前 FBO 尺寸
             let half_pixel = [0.5 / tex_size_down.w as f32, 0.5 / tex_size_down.h as f32];
             render_blur_pass_with_gl(
@@ -598,7 +599,7 @@ pub(super) unsafe fn get_main_buffer_blur(
                 &shaders.up,
                 half_pixel,
                 blur_config.clone(),
-                damage,
+                // damage,
                 render_buffer_fbo,
                 i,
             )?;
@@ -800,7 +801,7 @@ unsafe fn render_blur_pass_with_gl(
     config: Blur,
     // dst is the region that should have blur
     // it gets up/downscaled with passes
-    _damage: Rectangle<i32, Physical>,
+    // _damage: Rectangle<i32, Physical>,
     render_buffer_fbo: u32,
     i: usize,
 ) -> Result<(), GlesError> {