Add a semi-working debug-toggle-damage binding

niri-config/src/lib.rs

@@ -847,6 +847,7 @@ pub enum Action {
     PowerOffMonitors,
     ToggleDebugTint,
     DebugToggleOpaqueRegions,
+    DebugToggleDamage,
     Spawn(#[knuffel(arguments)] Vec<String>),
     #[knuffel(skip)]
     ConfirmScreenshot,
@@ -984,6 +985,7 @@ impl From<niri_ipc::Action> for Action {
             niri_ipc::Action::MoveWorkspaceToMonitorUp => Self::MoveWorkspaceToMonitorUp,
             niri_ipc::Action::ToggleDebugTint => Self::ToggleDebugTint,
             niri_ipc::Action::DebugToggleOpaqueRegions => Self::DebugToggleOpaqueRegions,
+            niri_ipc::Action::DebugToggleDamage => Self::DebugToggleDamage,
         }
     }
 }

niri-ipc/src/lib.rs

@@ -219,6 +219,8 @@ pub enum Action {
     ToggleDebugTint,
     /// Toggle visualization of render element opaque regions.
     DebugToggleOpaqueRegions,
+    /// Toggle visualization of output damage.
+    DebugToggleDamage,
 }
 
 /// Change in window or column size.

src/backend/tty.rs

@@ -58,6 +58,7 @@ use wayland_protocols::wp::presentation_time::server::wp_presentation_feedback;
 use super::{IpcOutputMap, RenderResult};
 use crate::frame_clock::FrameClock;
 use crate::niri::{Niri, RedrawState, State};
+use crate::render_helpers::debug::draw_damage;
 use crate::render_helpers::renderer::AsGlesRenderer;
 use crate::render_helpers::{resources, shaders, RenderTarget};
 use crate::utils::{get_monotonic_time, logical_output};
@@ -1243,9 +1244,15 @@ impl Tty {
         };
 
         // Render the elements.
-        let elements =
+        let mut elements =
             niri.render::<TtyRenderer>(&mut renderer, output, true, RenderTarget::Output);
 
+        // Visualize the damage, if enabled.
+        if niri.debug_draw_damage {
+            let output_state = niri.output_state.get_mut(output).unwrap();
+            draw_damage(&mut output_state.debug_damage_tracker, &mut elements);
+        }
+
         // Hand them over to the DRM.
         let drm_compositor = &mut surface.compositor;
         match drm_compositor.render_frame::<_, _>(&mut renderer, &elements, [0.; 4]) {

src/backend/winit.rs

@@ -19,6 +19,7 @@ use smithay::reexports::winit::window::WindowBuilder;
 
 use super::{IpcOutputMap, RenderResult};
 use crate::niri::{Niri, RedrawState, State};
+use crate::render_helpers::debug::draw_damage;
 use crate::render_helpers::{resources, shaders, RenderTarget};
 use crate::utils::{get_monotonic_time, logical_output};
 
@@ -159,13 +160,19 @@ impl Winit {
         let _span = tracy_client::span!("Winit::render");
 
         // Render the elements.
-        let elements = niri.render::<GlesRenderer>(
+        let mut elements = niri.render::<GlesRenderer>(
             self.backend.renderer(),
             output,
             true,
             RenderTarget::Output,
         );
 
+        // Visualize the damage, if enabled.
+        if niri.debug_draw_damage {
+            let output_state = niri.output_state.get_mut(output).unwrap();
+            draw_damage(&mut output_state.debug_damage_tracker, &mut elements);
+        }
+
         // Hand them over to winit.
         self.backend.bind().unwrap();
         let age = self.backend.buffer_age().unwrap();

src/input.rs

@@ -372,6 +372,9 @@ impl State {
                 self.niri.debug_draw_opaque_regions = !self.niri.debug_draw_opaque_regions;
                 self.niri.queue_redraw_all();
             }
+            Action::DebugToggleDamage => {
+                self.niri.debug_toggle_damage();
+            }
             Action::Spawn(command) => {
                 spawn(command);
             }

src/niri.rs

@@ -13,6 +13,7 @@ use anyhow::{ensure, Context};
 use calloop::futures::Scheduler;
 use niri_config::{Config, Key, Modifiers, PreviewRender, TrackLayout};
 use smithay::backend::allocator::Fourcc;
+use smithay::backend::renderer::damage::OutputDamageTracker;
 use smithay::backend::renderer::element::memory::MemoryRenderBufferRenderElement;
 use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
 use smithay::backend::renderer::element::surface::{
@@ -238,6 +239,7 @@ pub struct Niri {
     pub exit_confirm_dialog: Option<ExitConfirmDialog>,
 
     pub debug_draw_opaque_regions: bool,
+    pub debug_draw_damage: bool,
 
     #[cfg(feature = "dbus")]
     pub dbus: Option<crate::dbus::DBusServers>,
@@ -287,6 +289,8 @@ pub struct OutputState {
     pub lock_render_state: LockRenderState,
     pub lock_surface: Option<LockSurface>,
     pub lock_color_buffer: SolidColorBuffer,
+    /// Damage tracker used for the debug damage visualization.
+    pub debug_damage_tracker: OutputDamageTracker,
 }
 
 #[derive(Default)]
@@ -1426,6 +1430,7 @@ impl Niri {
             exit_confirm_dialog,
 
             debug_draw_opaque_regions: false,
+            debug_draw_damage: false,
 
             #[cfg(feature = "dbus")]
             dbus: None,
@@ -1630,6 +1635,7 @@ impl Niri {
             lock_render_state,
             lock_surface: None,
             lock_color_buffer: SolidColorBuffer::new(size, CLEAR_COLOR_LOCKED),
+            debug_damage_tracker: OutputDamageTracker::from_output(&output),
         };
         let rv = self.output_state.insert(output.clone(), state);
         assert!(rv.is_none(), "output was already tracked");
@@ -2477,6 +2483,7 @@ impl Niri {
         if self.debug_draw_opaque_regions {
             draw_opaque_regions(&mut elements, output_scale);
         }
+
         elements
     }
 
@@ -3188,6 +3195,18 @@ impl Niri {
         }
     }
 
+    pub fn debug_toggle_damage(&mut self) {
+        self.debug_draw_damage = !self.debug_draw_damage;
+
+        if self.debug_draw_damage {
+            for (output, state) in &mut self.output_state {
+                state.debug_damage_tracker = OutputDamageTracker::from_output(output);
+            }
+        }
+
+        self.queue_redraw_all();
+    }
+
     pub fn open_screenshot_ui(&mut self, renderer: &mut GlesRenderer) {
         if self.is_locked() || self.screenshot_ui.is_open() {
             return;

src/render_helpers/debug.rs

@@ -1,3 +1,4 @@
+use smithay::backend::renderer::damage::OutputDamageTracker;
 use smithay::backend::renderer::element::solid::SolidColorRenderElement;
 use smithay::backend::renderer::element::{Element, Id, Kind};
 use smithay::backend::renderer::utils::CommitCounter;
@@ -56,3 +57,25 @@ pub fn draw_opaque_regions<R: NiriRenderer>(
         }
     }
 }
+
+pub fn draw_damage<R: NiriRenderer>(
+    damage_tracker: &mut OutputDamageTracker,
+    elements: &mut Vec<OutputRenderElements<R>>,
+) {
+    let _span = tracy_client::span!("draw_damage");
+
+    let Ok((Some(damage), _)) = damage_tracker.damage_output(1, elements) else {
+        return;
+    };
+
+    for rect in damage {
+        let color = SolidColorRenderElement::new(
+            Id::new(),
+            *rect,
+            CommitCounter::default(),
+            [0.3, 0., 0., 0.3],
+            Kind::Unspecified,
+        );
+        elements.insert(0, OutputRenderElements::SolidColor(color));
+    }
+}

wiki/Configuration:-Debug-Options.md

@@ -166,3 +166,15 @@ binds {
     Mod+Shift+Ctrl+O { debug-toggle-opaque-regions; }
 }
 ```
+
+#### `debug-toggle-damage`
+
+<sup>Since: 0.1.6</sup>
+
+Tints damaged regions with red.
+
+```
+binds {
+    Mod+Shift+Ctrl+D { debug-toggle-damage; }
+}
+```