monolith

public

Star0

Fork 0

Watch0

76 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `867b15d7c12f`

tarball

atagen <boss@atagen.co>2026-10-17 03:12 UTC

6 files changed+115-87

monolith: share one frame path between the backends and capture

DRM, nested and screen capture each assembled cursor plus lock-or-scene and sent frame callbacks their own way, and had already drifted. Nested sent callbacks to every window rather than those on its output. compose and send_frame_callbacks are now the only copies. Animation pruning moved out of each output's render into after_dispatch at the current time. With two outputs at different rates, the one rendering later could otherwise prune state the other still had to draw.

Modified file: crates/monolith/src/capture.rs+14 additions−35 deletions@@ -1,6 +1,7 @@
 //! ext-image-copy-capture of outputs and single windows, for grim and screen
 //! sharing portals.
 
+use crate::frame::{CLEAR, FrameCtx};
 use crate::scene::Draw;
 use crate::state::{State, now_ns};
 use monolith_layout::{OutputId, WindowId};
@@ -204,7 +205,19 @@ impl State {
                     frame.fail(CaptureFailureReason::Stopped);
                     return;
                 };
-                self.output_elements(o, &output, session.draw_cursor())
+                let ctx = FrameCtx {
+                    renderer: &mut self.renderer,
+                    wm: &mut self.wm,
+                    input: &mut self.input,
+                    lock: &self.services.lock,
+                    deco: &self.settings.config.decoration,
+                    unmanaged: self
+                        .services
+                        .xwayland
+                        .as_ref()
+                        .map_or(&[], |x| &x.unmanaged),
+                };
+                crate::frame::compose(ctx, o, &output, now_ns(), session.draw_cursor())
             }
             Target::Window(id) => match self.wm.window(*id) {
                 Some(window) => window_elements(&mut self.renderer, window),
@@ -274,38 +287,6 @@ impl State {
         Ok(())
     }
 
-    /// Everything output `o` shows, as the backends draw it.
-    pub fn output_elements(&mut self, o: OutputId, output: &Output, cursor: bool) -> Vec<Draw> {
-        let now = now_ns();
-        let mut elements = Vec::new();
-        if cursor && let Some(area) = self.wm.layout.output(o).map(|out| out.area) {
-            let local = self.input.pointer_pos - Point::from((area.x, area.y));
-            if local.x >= 0.0 && local.y >= 0.0 && local.x < area.w && local.y < area.h {
-                elements.extend(self.input.cursor.elements(
-                    &mut self.renderer,
-                    &self.input.cursor_status,
-                    local,
-                ));
-            }
-        }
-        match crate::lock::elements(&self.services.lock, &mut self.renderer, output) {
-            Some(locked) => elements.extend(locked),
-            None => elements.extend(crate::scene::build(
-                &mut self.wm,
-                o,
-                &mut self.renderer,
-                now,
-                &self.settings.config.decoration,
-                Some(output),
-                self.services
-                    .xwayland
-                    .as_ref()
-                    .map_or(&[], |x| &x.unmanaged),
-            )),
-        }
-        elements
-    }
-
     fn output_named(&self, name: &str) -> Option<(OutputId, Output)> {
         self.wm
             .layout
@@ -325,5 +306,3 @@ fn window_elements(renderer: &mut VulkanRenderer, window: &smithay::desktop::Win
 
 /// Marks a session that has had a frame, so later ones wait for damage.
 struct Delivered;
-
-const CLEAR: [f32; 4] = [0.07, 0.075, 0.09, 1.0];

Modified file: crates/monolith/src/drm.rs+12 additions−31 deletions@@ -41,7 +41,7 @@ use std::collections::{HashMap, VecDeque};
 use std::path::{Path, PathBuf};
 use std::time::Duration;
 
-const CLEAR: [f32; 4] = [0.07, 0.075, 0.09, 1.0];
+use crate::frame::{CLEAR, FrameCtx};
 /// 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;
@@ -658,30 +658,21 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     }
     let began = std::time::Instant::now();
     let now = target;
-    let Some(area) = wm.layout.output(surface.id).map(|o| o.area) else {
+    if wm.layout.output(surface.id).is_none() {
         return false;
-    };
-    let mut elements = Vec::new();
-    let local = input.pointer_pos - Point::from((area.x, area.y));
-    if local.x >= 0.0 && local.y >= 0.0 && local.x < area.w && local.y < area.h {
-        elements.extend(input.cursor.elements(renderer, &input.cursor_status, local));
     }
     let scene_began = std::time::Instant::now();
-    match crate::lock::elements(lock, renderer, &surface.output) {
-        Some(locked) => elements.extend(locked),
-        None => elements.extend(crate::scene::build(
-            wm,
-            surface.id,
-            renderer,
-            now,
-            &settings.config.decoration,
-            Some(&surface.output),
-            xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
-        )),
-    }
+    let ctx = FrameCtx {
+        renderer: &mut *renderer,
+        wm: &mut *wm,
+        input: &mut *input,
+        lock: &*lock,
+        deco: &settings.config.decoration,
+        unmanaged: xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
+    };
+    let elements = crate::frame::compose(ctx, surface.id, &surface.output, now, true);
     let scene_ns = scene_began.elapsed().as_nanos() as u64;
     let animating = wm.anim.active(now);
-    wm.anim.prune(now);
     let render_began = std::time::Instant::now();
     let cpu_began = thread_cpu_ns();
     let mut queue_ns = 0;
@@ -724,17 +715,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     }
     surface.redraw = animating;
     let elapsed = core.start.elapsed();
-    let output = surface.output.clone();
-    if lock.active() {
-        crate::lock::send_frames(lock, &output, elapsed);
-        return animating && !surface.queued;
-    }
-    for window in wm.space.elements_for_output(&output) {
-        window.send_frame(&output, elapsed, Some(Duration::ZERO), |_, _| {
-            Some(output.clone())
-        });
-    }
-    crate::layers::send_frames(&output, elapsed);
+    crate::frame::send_frame_callbacks(wm, lock, &surface.output, elapsed);
     animating && !surface.queued
 }
 

Added file: crates/monolith/src/frame.rs+75 additions@@ -0,0 +1,75 @@
+//! What every output shows, shared by the backends and screen capture.
+//! Backends only decide when to draw and how to present.
+
+use crate::lock::Lock;
+use crate::scene::Draw;
+use crate::state::Input;
+use crate::wm::Wm;
+use monolith_config::Decoration;
+use monolith_layout::OutputId;
+use monolith_render_vk::VulkanRenderer;
+use smithay::output::Output;
+use smithay::utils::Point;
+use smithay::xwayland::X11Surface;
+use std::time::Duration;
+
+pub const CLEAR: [f32; 4] = [0.07, 0.075, 0.09, 1.0];
+
+/// Everything a frame reads, borrowed apart from the rest of the state.
+pub struct FrameCtx<'a> {
+    pub renderer: &'a mut VulkanRenderer,
+    pub wm: &'a mut Wm,
+    pub input: &'a mut Input,
+    pub lock: &'a Lock,
+    pub deco: &'a Decoration,
+    pub unmanaged: &'a [X11Surface],
+}
+
+/// The elements output `o` shows at `now`, front to back. `cursor` draws the
+/// pointer, which a nested session leaves to its host.
+pub fn compose(
+    ctx: FrameCtx<'_>,
+    o: OutputId,
+    output: &Output,
+    now: u64,
+    cursor: bool,
+) -> Vec<Draw> {
+    let mut elements = Vec::new();
+    if cursor && let Some(area) = ctx.wm.layout.output(o).map(|out| out.area) {
+        let local = ctx.input.pointer_pos - Point::from((area.x, area.y));
+        if local.x >= 0.0 && local.y >= 0.0 && local.x < area.w && local.y < area.h {
+            elements.extend(ctx.input.cursor.elements(
+                ctx.renderer,
+                &ctx.input.cursor_status,
+                local,
+            ));
+        }
+    }
+    match crate::lock::elements(ctx.lock, ctx.renderer, output) {
+        Some(locked) => elements.extend(locked),
+        None => elements.extend(crate::scene::build(
+            ctx.wm,
+            o,
+            ctx.renderer,
+            now,
+            ctx.deco,
+            Some(output),
+            ctx.unmanaged,
+        )),
+    }
+    elements
+}
+
+/// Lets clients shown on `output` draw their next frame.
+pub fn send_frame_callbacks(wm: &Wm, lock: &Lock, output: &Output, elapsed: Duration) {
+    if lock.active() {
+        crate::lock::send_frames(lock, output, elapsed);
+        return;
+    }
+    for window in wm.space.elements_for_output(output) {
+        window.send_frame(output, elapsed, Some(Duration::ZERO), |_, _| {
+            Some(output.clone())
+        });
+    }
+    crate::layers::send_frames(output, elapsed);
+}

Modified file: crates/monolith/src/main.rs+1

@@ -6,6 +6,7 @@ mod commands;

66 mod cursor;

77 mod drm;

88 mod focus;

9+mod frame;

910 mod globals;

1011 mod handlers;

1112 mod idle;

Modified file: crates/monolith/src/nested/mod.rs+12 additions−21 deletions@@ -18,7 +18,6 @@ use smithay::backend::renderer::damage::OutputDamageTracker;
 use smithay::output::{Mode, Output, PhysicalProperties, Subpixel};
 use smithay::reexports::calloop::EventLoop;
 use smithay::utils::{Logical, Size, Transform};
-use std::time::Duration;
 use wayland_client::globals::{GlobalListContents, registry_queue_init};
 use wayland_client::protocol::{wl_buffer, wl_callback, wl_compositor, wl_registry, wl_surface};
 use wayland_client::{Connection, Dispatch, QueueHandle, delegate_noop};
@@ -31,7 +30,7 @@ use wayland_protocols::xdg::decoration::zv1::client::{
 };
 use wayland_protocols::xdg::shell::client::{xdg_surface, xdg_toplevel, xdg_wm_base};
 
-const CLEAR: [f32; 4] = [0.07, 0.075, 0.09, 1.0];
+use crate::frame::{CLEAR, FrameCtx};
 const DEFAULT_SIZE: (i32, i32) = (1280, 800);
 const CLOCK_MONOTONIC: u32 = 1;
 
@@ -175,6 +174,7 @@ pub fn render(state: &mut State) {
         backend,
         renderer,
         wm,
+        input,
         dirty,
         core,
         settings,
@@ -231,17 +231,15 @@ pub fn render(state: &mut State) {
             }
         };
         let o = host.output_id;
-        let elements = crate::lock::elements(lock, renderer, &host.output).unwrap_or_else(|| {
-            crate::scene::build(
-                wm,
-                o,
-                renderer,
-                now,
-                &settings.config.decoration,
-                Some(&host.output),
-                xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
-            )
-        });
+        let ctx = FrameCtx {
+            renderer: &mut *renderer,
+            wm: &mut *wm,
+            input: &mut *input,
+            lock: &*lock,
+            deco: &settings.config.decoration,
+            unmanaged: xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
+        };
+        let elements = crate::frame::compose(ctx, o, &host.output, now, false);
         match host
             .damage
             .render_output(renderer, &mut fb, slot.age() as usize, &elements, CLEAR)
@@ -259,16 +257,9 @@ pub fn render(state: &mut State) {
         }
     };
     dirty.redraw = wm.anim.active(now);
-    wm.anim.prune(now);
     lock.shown(&host.output);
     let elapsed = core.start.elapsed();
-    crate::lock::send_frames(lock, &host.output, elapsed);
-    for window in wm.space.elements().filter(|_| !lock.active()) {
-        window.send_frame(&host.output, elapsed, Some(Duration::ZERO), |_, _| {
-            Some(host.output.clone())
-        });
-    }
-    crate::layers::send_frames(&host.output, elapsed);
+    crate::frame::send_frame_callbacks(wm, lock, &host.output, elapsed);
     if damage.is_some() {
         captures.output_damaged(&host.output);
     }

Modified file: crates/monolith/src/state.rs+1

@@ -193,6 +193,7 @@ impl State {

193193 crate::backend::Backend::Nested(_) => crate::nested::render(self),

194194 crate::backend::Backend::Starting => {}

195195 }

196+ self.wm.anim.prune(now_ns());

196197 self.confirm_lock();

197198 self.complete_captures();

198199 crate::ipc::broadcast(self);

monolith

Commit 867b15d7c12f

Commit `867b15d7c12f`