monolith

public

Star0

Fork 0

Watch0

46 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `8e6f96f0a32d`

tarball

atagen <boss@atagen.co>2026-10-16 22:17 UTC

4 files changed+102-9

monolith: drive adaptive sync for fullscreen windows

With VRR on, frames go out as soon as there is something new instead of waiting for a deadline, since the panel follows whatever pace the client sets. Pointer motion alone is capped at 60 Hz so moving the mouse over a game does not drag the refresh rate up. Only connectors reporting VrrSupport::Supported are touched, which avoids a modeset on every fullscreen toggle.

Modified file: crates/config/default.toml+4 additions@@ -19,6 +19,10 @@ border = 2
 focused = "#88bfd1"
 unfocused = "#3b4252"
 
+[output]
+# Variable refresh rate on outputs that support it, off, on, or fullscreen.
+vrr = "fullscreen"
+
 [animation]
 enabled = true
 # orthogonal moves each window along one axis per phase, direct allows both.

Modified file: crates/config/src/lib.rs+20 additions@@ -12,6 +12,7 @@ pub const DEFAULT: &str = include_str!("../default.toml");
 #[derive(Debug, Clone)]
 pub struct Config {
     pub general: General,
+    pub output: Outputs,
     pub decoration: Decoration,
     pub animation: Animation,
     pub keyboard: Keyboard,
@@ -68,6 +69,22 @@ impl Default for Gaps {
     }
 }
 
+#[derive(Deserialize, Debug, Clone, PartialEq, Default)]
+#[serde(default, deny_unknown_fields)]
+pub struct Outputs {
+    pub vrr: Vrr,
+}
+
+#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum Vrr {
+    Off,
+    On,
+    /// Only while a fullscreen window is shown, where a game sets the pace.
+    #[default]
+    Fullscreen,
+}
+
 #[derive(Deserialize, Debug, Clone, PartialEq)]
 #[serde(default, deny_unknown_fields)]
 pub struct Decoration {
@@ -256,6 +273,8 @@ struct Raw {
     #[serde(default)]
     decoration: Decoration,
     #[serde(default)]
+    output: Outputs,
+    #[serde(default)]
     binds: BTreeMap<String, Words>,
     #[serde(default)]
     rules: Vec<RawRule>,
@@ -335,6 +354,7 @@ impl Config {
             general: raw.general,
             animation: raw.animation,
             decoration: raw.decoration,
+            output: raw.output,
             keyboard: raw.keyboard,
             binds,
             rules,

Modified file: crates/monolith/src/drm.rs+75 additions−9 deletions@@ -4,9 +4,11 @@
 
 use crate::scene::Draw;
 use crate::state::{State, now_ns};
+use monolith_config::Vrr;
 use monolith_layout::{OutputId, Rect};
 use smithay::backend::allocator::Fourcc;
 use smithay::backend::allocator::gbm::{GbmAllocator, GbmBufferFlags, GbmDevice};
+use smithay::backend::drm::VrrSupport;
 use smithay::backend::drm::compositor::FrameFlags;
 use smithay::backend::drm::exporter::gbm::GbmFramebufferExporter;
 use smithay::backend::drm::output::{DrmOutput, DrmOutputManager, DrmOutputRenderElements};
@@ -37,6 +39,9 @@ use std::path::{Path, PathBuf};
 use std::time::Duration;
 
 const CLEAR: [f32; 4] = [0.07, 0.075, 0.09, 1.0];
+/// Frames that only move the cursor stay at or below 60 Hz under VRR, so the
+/// mouse does not override the refresh rate a game is pacing.
+const CURSOR_FRAME_NS: u64 = 16_666_667;
 
 type Allocator = GbmAllocator<DrmDeviceFd>;
 type Exporter = GbmFramebufferExporter<DrmDeviceFd>;
@@ -72,6 +77,10 @@ struct Surface {
     /// Frames presented since `stats_since`, for the once-a-second debug line.
     presented: u32,
     stats_since: u64,
+    vrr_capable: bool,
+    vrr_on: bool,
+    /// Only the cursor moved, which under VRR is drawn at a capped rate.
+    cursor_redraw: bool,
 }
 
 impl Surface {
@@ -378,11 +387,22 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
             return;
         }
     };
+    let vrr_capable = matches!(
+        out.with_compositor(|c| c.vrr_supported(connector.handle())),
+        Ok(VrrSupport::Supported)
+    );
     space.map_output(&output, position);
     let (w, h) = mode.size();
     let area = Rect::new(x, 0.0, f64::from(w), f64::from(h));
     let id = layout.add_output(&name, area);
-    tracing::info!(name, w, h, refresh = mode.vrefresh(), "output connected");
+    tracing::info!(
+        name,
+        w,
+        h,
+        refresh = mode.vrefresh(),
+        vrr_capable,
+        "output connected"
+    );
     drm.surfaces.insert(
         crtc,
         Surface {
@@ -397,6 +417,9 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
             budget: Budget::new(),
             presented: 0,
             stats_since: 0,
+            vrr_capable,
+            vrr_on: false,
+            cursor_redraw: false,
             refresh_ns: 1_000_000_000_000 / u64::from(wl_mode.refresh.max(1) as u32),
         },
     );
@@ -464,7 +487,7 @@ fn on_vblank(state: &mut State, crtc: crtc::Handle, meta: &mut Option<DrmEventMe
             surface.stats_since = t;
         }
     }
-    if surface.redraw {
+    if surface.redraw || surface.cursor_redraw {
         schedule(state, crtc);
     }
 }
@@ -482,6 +505,25 @@ fn schedule(state: &mut State, crtc: crtc::Handle) {
         return;
     }
     let now = now_ns();
+    if surface.vrr_on {
+        let since_flip = surface
+            .last_vblank_ns
+            .map_or(u64::MAX, |l| now.saturating_sub(l));
+        if surface.redraw || since_flip >= CURSOR_FRAME_NS {
+            draw(state, crtc, now);
+            return;
+        }
+        let wait = Timer::from_duration(Duration::from_nanos(CURSOR_FRAME_NS - since_flip));
+        let token = drm.handle.insert_source(wait, move |_, _, state| {
+            if let Some(s) = state.drm.as_mut().and_then(|d| d.surfaces.get_mut(&crtc)) {
+                s.scheduled = None;
+            }
+            draw(state, crtc, now_ns());
+            TimeoutAction::Drop
+        });
+        surface.scheduled = token.ok();
+        return;
+    }
     let Some((vblank, start)) = surface.next_deadline(now) else {
         draw(state, crtc, now);
         return;
@@ -513,15 +555,16 @@ pub fn render(state: &mut State) {
     let Some(drm) = state.drm.as_mut() else {
         return;
     };
-    if std::mem::take(&mut state.needs_redraw) {
-        for s in drm.surfaces.values_mut() {
-            s.redraw = true;
-        }
+    let cursor = std::mem::take(&mut state.cursor_moved);
+    let all = std::mem::take(&mut state.needs_redraw);
+    for s in drm.surfaces.values_mut() {
+        s.redraw |= all;
+        s.cursor_redraw |= cursor;
     }
     let ready: Vec<crtc::Handle> = drm
         .surfaces
         .iter()
-        .filter(|(_, s)| s.redraw && !s.queued)
+        .filter(|(_, s)| (s.redraw || s.cursor_redraw) && !s.queued)
         .map(|(c, _)| *c)
         .collect();
     for crtc in ready {
@@ -560,6 +603,29 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     if surface.queued {
         return false;
     }
+    surface.cursor_redraw = false;
+    let want_vrr = surface.vrr_capable
+        && match config.output.vrr {
+            Vrr::Off => false,
+            Vrr::On => true,
+            Vrr::Fullscreen => layout.arrange(surface.id).fullscreen.is_some(),
+        };
+    if want_vrr != surface.vrr_on {
+        match surface.drm.with_compositor(|c| c.use_vrr(want_vrr)) {
+            Ok(()) => {
+                surface.vrr_on = want_vrr;
+                tracing::info!(
+                    output = surface.output.name(),
+                    vrr = want_vrr,
+                    "adaptive sync"
+                );
+            }
+            Err(e) => {
+                tracing::warn!("could not switch adaptive sync: {e}");
+                surface.vrr_capable = false;
+            }
+        }
+    }
     let began = std::time::Instant::now();
     let now = target;
     let Some(area) = layout.output(surface.id).map(|o| o.area) else {
@@ -650,7 +716,7 @@ fn on_input(state: &mut State, event: InputEvent<LibinputInputBackend>) {
             let pos = clamp(state, state.pointer_pos + event.delta());
             state.pointer_to(pos, event.time());
             state.pointer_frame();
-            state.needs_redraw = true;
+            state.cursor_moved = true;
         }
         InputEvent::PointerMotionAbsolute { event } => {
             let Some(area) = state.layout.outputs().next().map(|(_, o)| o.area) else {
@@ -660,7 +726,7 @@ fn on_input(state: &mut State, event: InputEvent<LibinputInputBackend>) {
             let pos = Point::from((area.x + p.x, area.y + p.y));
             state.pointer_to(pos, event.time());
             state.pointer_frame();
-            state.needs_redraw = true;
+            state.cursor_moved = true;
         }
         InputEvent::PointerButton { event } => {
             let time = event.time();

Modified file: crates/monolith/src/state.rs+3 additions@@ -50,6 +50,8 @@ pub struct State {
     pub cursor: crate::cursor::Cursor,
     pub cursor_status: CursorImageStatus,
     pub needs_redraw: bool,
+    /// The pointer moved, which on its own only redraws the cursor.
+    pub cursor_moved: bool,
 
     pub layout: Layout,
     pub windows: HashMap<WindowId, Window>,
@@ -150,6 +152,7 @@ impl State {
             cursor: crate::cursor::Cursor::load(),
             cursor_status: CursorImageStatus::default_named(),
             needs_redraw: true,
+            cursor_moved: false,
             layout,
             windows: HashMap::new(),
             unmapped: Vec::new(),

monolith

Commit 8e6f96f0a32d

Commit `8e6f96f0a32d`