Implement ext-background-effect for popups

Author: YaLTeR

docs/wiki/Window-Effects.md

@@ -62,3 +62,19 @@ Non-xray effects are currently experimental because they have some known limitat
 
 - They disappear during window open/close animations and while dragging a tiled window.
 Fixing this requries a refactor to the niri rendering code to defer offscreen rendering, and possibly other refactors.
+
+### Implementation notes
+
+The `ext-background-effect` protocol supports any wl_surface.
+We currently implement it only for toplevels, layer surfaces, and pop-ups, which should cover the vast majority of what's actually used by applications.
+
+For pop-ups, effects default to *non-xray* because pop-ups generally appear on top of windows.
+
+In particular, the following surface types don't support `ext-background-effect`.
+They can be implemented as the need arises.
+
+- Subsurfaces. Would require implementing `clip-to-geometry` support for background effects.
+- Lock surfaces. Not useful as it would just show our red locked session background.
+- Cursor and drag-and-drop icon.
+The main challenge here will be screencasts where the cursor is rendered separately.
+This is problematic because non-xray effects require rendering the whole scene in one go rather than separately.

src/layer/mapped.rs

@@ -255,7 +255,8 @@ impl MappedLayer {
 
     pub fn render_popups<R: NiriRenderer>(
         &self,
-        ctx: RenderCtx<R>,
+        mut ctx: RenderCtx<R>,
+        ns: Option<usize>,
         location: Point<f64, Logical>,
         push: &mut dyn FnMut(LayerSurfaceRenderElement<R>),
     ) {
@@ -269,17 +270,28 @@ impl MappedLayer {
 
         let surface = self.surface.wl_surface();
         for (popup, offset) in PopupManager::popups_for_surface(surface) {
+            let surface = popup.wl_surface();
             let surface_loc = location + (offset - popup.geometry().loc).to_f64();
 
             push_elements_from_surface_tree(
                 ctx.renderer,
-                popup.wl_surface(),
+                surface,
                 surface_loc.to_physical_precise_round(scale),
                 scale,
                 alpha,
                 Kind::ScanoutCandidate,
                 &mut |elem| push(elem.into()),
             );
+
+            background_effect::render_for_surface(
+                surface,
+                ctx.as_gles(),
+                ns,
+                self.blur_config,
+                surface_loc,
+                scale,
+                &mut |elem| push(elem.into()),
+            );
         }
     }
 }

src/layout/mod.rs

@@ -114,6 +114,7 @@ niri_render_elements! {
     LayoutElementRenderElement<R> => {
         Wayland = WaylandSurfaceRenderElement<R>,
         SolidColor = SolidColorRenderElement,
+        BackgroundEffect = BackgroundEffectElement,
     }
 }
 

src/layout/tile.rs

@@ -1205,6 +1205,12 @@ impl<W: LayoutElement> Tile<W> {
                     // Otherwise, render the solid color as is.
                     LayoutElementRenderElement::SolidColor(elem).into()
                 }
+                elem @ LayoutElementRenderElement::BackgroundEffect(_) => {
+                    // This is only used on popups for now. If subsurface blur is implemented, this
+                    // will need to be handled somehow.
+                    error!("background effect clipping is unimplemented");
+                    elem.into()
+                }
             };
 
             if clip_to_geometry && clip_shader.is_some() {

src/niri.rs

@@ -4522,14 +4522,14 @@ impl Niri {
     fn render_layer_popups<R: NiriRenderer>(
         &self,
         mut ctx: RenderCtx<R>,
-        _ns: Option<usize>,
+        ns: Option<usize>,
         layer_map: &LayerMap,
         layer: Layer,
         for_backdrop: bool,
         push: &mut dyn FnMut(LayerSurfaceRenderElement<R>),
     ) {
         for (mapped, geo) in self.layers_in_render_order(layer_map, layer, for_backdrop) {
-            mapped.render_popups(ctx.r(), geo.loc.to_f64(), push);
+            mapped.render_popups(ctx.r(), ns, geo.loc.to_f64(), push);
         }
     }
 

src/render_helpers/background_effect.rs

@@ -330,3 +330,60 @@ pub fn render_for_tile(
         background_effect.render(ctx, ns, params, xray_pos, push);
     });
 }
+
+pub fn render_for_surface(
+    surface: &WlSurface,
+    ctx: RenderCtx<GlesRenderer>,
+    ns: Option<usize>,
+    blur_config: niri_config::Blur,
+    location: Point<f64, Logical>,
+    scale: Scale<f64>,
+    push: &mut dyn FnMut(BackgroundEffectElement),
+) {
+    let blur_region = with_states(surface, get_cached_blur_region);
+    let Some(rects) = blur_region else {
+        return;
+    };
+    if rects.is_empty() {
+        return;
+    }
+
+    with_states(surface, |states| {
+        let mut main_surface_geo = surface_geo(states).unwrap_or_default().to_f64();
+        main_surface_geo.loc += location;
+
+        let subregion = TransformedRegion {
+            rects,
+            scale: Scale::from(1.),
+            offset: main_surface_geo.loc,
+        };
+
+        let geometry = main_surface_geo
+            .to_physical_precise_round(scale)
+            .to_logical(scale);
+
+        let params = RenderParams {
+            geometry,
+            subregion: Some(subregion),
+            clip: None,
+            scale: scale.x,
+        };
+
+        let background_effect = SurfaceBackgroundEffect::get(states);
+        let mut background_effect = background_effect.0.lock().unwrap();
+
+        background_effect.update_config(blur_config);
+        background_effect.update_render_elements(
+            CornerRadius::default(),
+            niri_config::BackgroundEffect {
+                // We don't do xray on popups.
+                xray: Some(false),
+                ..Default::default()
+            },
+            // We always have a blur region.
+            true,
+        );
+
+        background_effect.render(ctx, ns, params, XrayPos::default(), push);
+    });
+}

src/ui/mru.rs

@@ -421,6 +421,12 @@ impl Thumbnail {
                 // Otherwise, render the solid color as is.
                 LayoutElementRenderElement::SolidColor(elem).into()
             }
+            elem @ LayoutElementRenderElement::BackgroundEffect(_) => {
+                // This is only used on popups for now. If subsurface blur is implemented, this
+                // will need to be handled somehow.
+                error!("background effect clipping is unimplemented");
+                elem.into()
+            }
         };
 
         let downscale = move |elem| {

src/window/mapped.rs

@@ -658,7 +658,7 @@ impl LayoutElement for Mapped {
 
     fn render_popups<R: NiriRenderer>(
         &self,
-        ctx: RenderCtx<R>,
+        mut ctx: RenderCtx<R>,
         location: Point<f64, Logical>,
         scale: Scale<f64>,
         alpha: f32,
@@ -670,17 +670,28 @@ impl LayoutElement for Mapped {
 
         let surface = self.toplevel().wl_surface();
         for (popup, offset) in PopupManager::popups_for_surface(surface) {
+            let surface = popup.wl_surface();
             let surface_loc = location + (offset - popup.geometry().loc).to_f64();
 
             push_elements_from_surface_tree(
                 ctx.renderer,
-                popup.wl_surface(),
+                surface,
                 surface_loc.to_physical_precise_round(scale),
                 scale,
                 alpha,
                 Kind::ScanoutCandidate,
                 &mut |elem| push(elem.into()),
             );
+
+            background_effect::render_for_surface(
+                surface,
+                ctx.as_gles(),
+                None,
+                self.blur_config,
+                surface_loc,
+                scale,
+                &mut |elem| push(elem.into()),
+            );
         }
     }