monolith

public

Star0

Fork 0

Watch0

11 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `d4a64ce87164`

tarball

atagen <boss@atagen.co>2026-10-16 09:46 UTC

9 files changed+1066-18

monolith: run nested on the Vulkan renderer

The host window is fed through a linux-dmabuf swapchain allocated by render-vk, so the nested path exercises the same buffer sharing the DRM backend will need. Placement is plain side-by-side columns until the planner is wired in at M4. Shm clients go through ImportMemWl, which copies on every commit for now.

Modified file: Cargo.lock+30 additions−7 deletions@@ -100,6 +100,18 @@ dependencies = [
 ]
 
 [[package]]
+name = "calloop-wayland-source"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "138efcf0940a02ebf0cc8d1eff41a1682a46b431630f4c52450d6265876021fa"
+dependencies = [
+ "calloop",
+ "rustix",
+ "wayland-backend",
+ "wayland-client",
+]
+
+[[package]]
 name = "cc"
 version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -376,16 +388,14 @@ dependencies = [
 name = "monolith"
 version = "0.0.0"
 dependencies = [
- "monolith-config",
- "monolith-ipc",
- "monolith-layout",
- "monolith-motion",
- "monolith-planner",
- "monolith-protocols",
+ "calloop-wayland-source",
  "monolith-render-vk",
- "monolith-testkit",
  "smithay",
+ "tracing",
+ "tracing-subscriber",
  "tracy-client",
+ "wayland-client",
+ "wayland-protocols",
 ]
 
 [[package]]
@@ -1008,6 +1018,18 @@ dependencies = [
 ]
 
 [[package]]
+name = "wayland-client"
+version = "0.31.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3c36a0f861ad76d0901f2800b46321410d9f73f2ea88aac0650d86c32688073"
+dependencies = [
+ "bitflags",
+ "rustix",
+ "wayland-backend",
+ "wayland-scanner",
+]
+
+[[package]]
 name = "wayland-protocols"
 version = "0.32.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1015,6 +1037,7 @@ checksum = "23d0c813de3daa2ed6520af85a3bd49b0e722a3078506899aa9686fea58dc4b6"
 dependencies = [
  "bitflags",
  "wayland-backend",
+ "wayland-client",
  "wayland-scanner",
  "wayland-server",
 ]

Modified file: crates/monolith/Cargo.toml+6 additions−10 deletions@@ -12,15 +12,11 @@ workspace = true
 profile = ["dep:tracy-client", "tracy-client/enable"]
 
 [dependencies]
-monolith-config.workspace = true
-monolith-ipc.workspace = true
-monolith-layout.workspace = true
-monolith-motion.workspace = true
-monolith-planner.workspace = true
-monolith-protocols.workspace = true
+calloop-wayland-source = "0.4"
 monolith-render-vk.workspace = true
-smithay.workspace = true
+smithay = { workspace = true, features = ["desktop"] }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 tracy-client = { workspace = true, optional = true }
-
-[dev-dependencies]
-monolith-testkit.workspace = true
+wayland-client = "0.31"
+wayland-protocols = { version = "0.32", features = ["client", "unstable", "staging"] }

Added file: crates/monolith/src/handlers.rs+206 additions@@ -0,0 +1,206 @@
+use crate::state::{ClientState, State};
+use smithay::backend::allocator::dmabuf::Dmabuf;
+use smithay::backend::renderer::ImportDma;
+use smithay::backend::renderer::utils::on_commit_buffer_handler;
+use smithay::desktop::{PopupKind, Window};
+use smithay::input::dnd::{DndGrabHandler, GrabType, Source};
+use smithay::input::pointer::CursorImageStatus;
+use smithay::input::{Seat, SeatHandler, SeatState};
+use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;
+use smithay::reexports::wayland_server::protocol::wl_seat::WlSeat;
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use smithay::reexports::wayland_server::{Client, Resource};
+use smithay::utils::Serial;
+use smithay::wayland::buffer::BufferHandler;
+use smithay::wayland::compositor::{
+    CompositorClientState, CompositorHandler, CompositorState, get_parent, is_sync_subsurface,
+};
+use smithay::wayland::dmabuf::{DmabufGlobal, DmabufHandler, DmabufState, ImportNotifier};
+use smithay::wayland::output::OutputHandler;
+use smithay::wayland::selection::SelectionHandler;
+use smithay::wayland::selection::data_device::{
+    DataDeviceHandler, DataDeviceState, WaylandDndGrabHandler, set_data_device_focus,
+};
+use smithay::wayland::shell::xdg::{
+    PopupSurface, PositionerState, ToplevelSurface, XdgShellHandler, XdgShellState,
+};
+use smithay::wayland::shm::{ShmHandler, ShmState};
+
+impl CompositorHandler for State {
+    fn compositor_state(&mut self) -> &mut CompositorState {
+        &mut self.compositor_state
+    }
+
+    fn client_compositor_state<'a>(&self, client: &'a Client) -> &'a CompositorClientState {
+        &client
+            .get_data::<ClientState>()
+            .expect("every client has ClientState")
+            .compositor_state
+    }
+
+    fn commit(&mut self, surface: &WlSurface) {
+        on_commit_buffer_handler::<Self>(surface);
+        if !is_sync_subsurface(surface) {
+            let mut root = surface.clone();
+            while let Some(parent) = get_parent(&root) {
+                root = parent;
+            }
+            if let Some(window) = self
+                .space
+                .elements()
+                .find(|w| w.toplevel().is_some_and(|t| t.wl_surface() == &root))
+            {
+                window.on_commit();
+            }
+        }
+        if let Some(window) = self
+            .space
+            .elements()
+            .find(|w| w.toplevel().is_some_and(|t| t.wl_surface() == surface))
+            .cloned()
+            && let Some(toplevel) = window.toplevel()
+            && !toplevel.is_initial_configure_sent()
+        {
+            toplevel.send_configure();
+        }
+        self.popups.commit(surface);
+        if let Some(PopupKind::Xdg(popup)) = self.popups.find_popup(surface)
+            && !popup.is_initial_configure_sent()
+        {
+            let _ = popup.send_configure();
+        }
+        self.needs_redraw = true;
+    }
+}
+
+impl BufferHandler for State {
+    fn buffer_destroyed(&mut self, _buffer: &WlBuffer) {}
+}
+
+impl ShmHandler for State {
+    fn shm_state(&self) -> &ShmState {
+        &self.shm_state
+    }
+}
+
+impl DmabufHandler for State {
+    fn dmabuf_state(&mut self) -> &mut DmabufState {
+        &mut self.dmabuf_state
+    }
+
+    fn dmabuf_imported(
+        &mut self,
+        _global: &DmabufGlobal,
+        dmabuf: Dmabuf,
+        notifier: ImportNotifier,
+    ) {
+        if self.renderer.import_dmabuf(&dmabuf, None).is_ok() {
+            let _ = notifier.successful::<State>();
+        } else {
+            notifier.failed();
+        }
+    }
+}
+
+impl XdgShellHandler for State {
+    fn xdg_shell_state(&mut self) -> &mut XdgShellState {
+        &mut self.xdg_shell_state
+    }
+
+    fn new_toplevel(&mut self, surface: ToplevelSurface) {
+        let focus = surface.wl_surface().clone();
+        self.space
+            .map_element(Window::new_wayland_window(surface), (0, 0), true);
+        self.relayout();
+        if let Some(keyboard) = self.seat.get_keyboard() {
+            keyboard.set_focus(self, Some(focus), Serial::from(0));
+        }
+    }
+
+    fn toplevel_destroyed(&mut self, _surface: ToplevelSurface) {
+        self.relayout();
+    }
+
+    fn new_popup(&mut self, surface: PopupSurface, positioner: PositionerState) {
+        surface.with_pending_state(|s| s.geometry = positioner.get_geometry());
+        let _ = self.popups.track_popup(PopupKind::Xdg(surface));
+    }
+
+    fn reposition_request(
+        &mut self,
+        surface: PopupSurface,
+        positioner: PositionerState,
+        token: u32,
+    ) {
+        surface.with_pending_state(|s| {
+            s.geometry = positioner.get_geometry();
+            s.positioner = positioner;
+        });
+        surface.send_repositioned(token);
+    }
+
+    fn grab(&mut self, _surface: PopupSurface, _seat: WlSeat, _serial: Serial) {}
+}
+
+impl SeatHandler for State {
+    type KeyboardFocus = WlSurface;
+    type PointerFocus = WlSurface;
+    type TouchFocus = WlSurface;
+
+    fn seat_state(&mut self) -> &mut SeatState<State> {
+        &mut self.seat_state
+    }
+
+    fn cursor_image(&mut self, _seat: &Seat<Self>, _image: CursorImageStatus) {}
+
+    fn focus_changed(&mut self, seat: &Seat<Self>, focused: Option<&WlSurface>) {
+        let client = focused.and_then(|s| self.display.get_client(s.id()).ok());
+        set_data_device_focus(&self.display, seat, client);
+    }
+}
+
+impl SelectionHandler for State {
+    type SelectionUserData = ();
+}
+
+impl DataDeviceHandler for State {
+    fn data_device_state(&mut self) -> &mut DataDeviceState {
+        &mut self.data_device_state
+    }
+}
+
+impl DndGrabHandler for State {}
+
+impl WaylandDndGrabHandler for State {
+    fn dnd_requested<S: Source>(
+        &mut self,
+        source: S,
+        _icon: Option<WlSurface>,
+        _seat: Seat<Self>,
+        _serial: Serial,
+        _type: GrabType,
+    ) {
+        source.cancel();
+    }
+}
+
+impl OutputHandler for State {}
+
+impl smithay::wayland::pointer_constraints::PointerConstraintsHandler for State {
+    fn new_constraint(
+        &mut self,
+        _surface: &WlSurface,
+        _pointer: &smithay::input::pointer::PointerHandle<Self>,
+    ) {
+    }
+
+    fn cursor_position_hint(
+        &mut self,
+        _surface: &WlSurface,
+        _pointer: &smithay::input::pointer::PointerHandle<Self>,
+        _location: smithay::utils::Point<f64, smithay::utils::Logical>,
+    ) {
+    }
+}
+
+smithay::delegate_dispatch2!(State);

Added file: crates/monolith/src/input.rs+163 additions@@ -0,0 +1,163 @@
+//! Host input forwarded into monolith's seat.
+
+use crate::state::State;
+use smithay::backend::input::{Axis, ButtonState, InputTime, KeyState};
+use smithay::input::keyboard::{FilterResult, Keycode};
+use smithay::input::pointer::{AxisFrame, ButtonEvent, MotionEvent};
+use smithay::utils::{Point, SERIAL_COUNTER};
+use wayland_client::protocol::{wl_keyboard, wl_pointer, wl_seat};
+use wayland_client::{Connection, Dispatch, QueueHandle, WEnum};
+
+impl Dispatch<wl_seat::WlSeat, ()> for State {
+    fn event(
+        _: &mut Self,
+        seat: &wl_seat::WlSeat,
+        event: wl_seat::Event,
+        _: &(),
+        _: &Connection,
+        qh: &QueueHandle<Self>,
+    ) {
+        if let wl_seat::Event::Capabilities {
+            capabilities: WEnum::Value(caps),
+        } = event
+        {
+            if caps.contains(wl_seat::Capability::Pointer) {
+                seat.get_pointer(qh, ());
+            }
+            if caps.contains(wl_seat::Capability::Keyboard) {
+                seat.get_keyboard(qh, ());
+            }
+        }
+    }
+}
+
+impl Dispatch<wl_pointer::WlPointer, ()> for State {
+    fn event(
+        state: &mut Self,
+        _: &wl_pointer::WlPointer,
+        event: wl_pointer::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        let Some(pointer) = state.seat.get_pointer() else {
+            return;
+        };
+        let time = InputTime::now();
+        match event {
+            wl_pointer::Event::Enter {
+                surface_x,
+                surface_y,
+                ..
+            }
+            | wl_pointer::Event::Motion {
+                surface_x,
+                surface_y,
+                ..
+            } => {
+                let pos = Point::from((surface_x, surface_y));
+                if let Some(host) = state.host.as_mut() {
+                    host.pointer_pos = pos;
+                }
+                let under = state.surface_under(pos);
+                pointer.motion(
+                    state,
+                    under,
+                    &MotionEvent {
+                        location: pos,
+                        serial: SERIAL_COUNTER.next_serial(),
+                        time,
+                    },
+                );
+            }
+            wl_pointer::Event::Button {
+                button,
+                state: WEnum::Value(pressed),
+                ..
+            } => {
+                let serial = SERIAL_COUNTER.next_serial();
+                let button_state = match pressed {
+                    wl_pointer::ButtonState::Pressed => ButtonState::Pressed,
+                    _ => ButtonState::Released,
+                };
+                if button_state == ButtonState::Pressed {
+                    focus_under_pointer(state);
+                }
+                pointer.button(
+                    state,
+                    &ButtonEvent {
+                        button,
+                        state: button_state,
+                        serial,
+                        time,
+                    },
+                );
+            }
+            wl_pointer::Event::Axis {
+                axis: WEnum::Value(axis),
+                value,
+                ..
+            } => {
+                let axis = match axis {
+                    wl_pointer::Axis::HorizontalScroll => Axis::Horizontal,
+                    _ => Axis::Vertical,
+                };
+                pointer.axis(state, AxisFrame::new(time).value(axis, value));
+            }
+            wl_pointer::Event::Frame => pointer.frame(state),
+            _ => {}
+        }
+    }
+}
+
+impl Dispatch<wl_keyboard::WlKeyboard, ()> for State {
+    fn event(
+        state: &mut Self,
+        _: &wl_keyboard::WlKeyboard,
+        event: wl_keyboard::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        let Some(keyboard) = state.seat.get_keyboard() else {
+            return;
+        };
+        if let wl_keyboard::Event::Key {
+            key,
+            state: WEnum::Value(pressed),
+            ..
+        } = event
+        {
+            let key_state = match pressed {
+                wl_keyboard::KeyState::Pressed => KeyState::Pressed,
+                _ => KeyState::Released,
+            };
+            let time = InputTime::now();
+            keyboard.input::<(), _>(
+                state,
+                Keycode::new(key + 8),
+                key_state,
+                SERIAL_COUNTER.next_serial(),
+                time,
+                |_, _, _| FilterResult::Forward,
+            );
+        }
+    }
+}
+
+fn focus_under_pointer(state: &mut State) {
+    let Some(pos) = state.host.as_ref().map(|h| h.pointer_pos) else {
+        return;
+    };
+    let Some((window, _)) = state.space.element_under(pos).map(|(w, l)| (w.clone(), l)) else {
+        return;
+    };
+    state.space.raise_element(&window, true);
+    if let (Some(keyboard), Some(toplevel)) = (state.seat.get_keyboard(), window.toplevel()) {
+        keyboard.set_focus(
+            state,
+            Some(toplevel.wl_surface().clone()),
+            SERIAL_COUNTER.next_serial(),
+        );
+    }
+}

Modified file: crates/monolith/src/main.rs+34 additions−1 deletions@@ -1 +1,34 @@
-fn main() {}
+mod handlers;
+mod input;
+mod nested;
+mod state;
+
+use smithay::reexports::calloop::EventLoop;
+use smithay::reexports::wayland_server::Display;
+use state::State;
+use std::process::Command;
+use tracing_subscriber::EnvFilter;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info")),
+        )
+        .init();
+    let mut event_loop: EventLoop<State> = EventLoop::try_new()?;
+    let display: Display<State> = Display::new()?;
+    let mut state = State::new(&mut event_loop, display)?;
+    nested::init(&mut event_loop, &mut state)?;
+    tracing::info!(socket = ?state.socket_name, device = state.renderer.device_name(), "monolith running nested");
+
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    if let Some((program, rest)) = args.split_first() {
+        Command::new(program)
+            .args(rest)
+            .env("WAYLAND_DISPLAY", &state.socket_name)
+            .spawn()?;
+    }
+
+    event_loop.run(None, &mut state, |state| state.after_dispatch())?;
+    Ok(())
+}

Added file: crates/monolith/src/nested.rs+431 additions@@ -0,0 +1,431 @@
+//! Runs monolith as a window inside another Wayland compositor. Frames are
+//! rendered into dmabufs from our own swapchain and handed to the host
+//! through linux-dmabuf, so the nested path exercises the same
+//! render-into-dmabuf code as bare metal.
+
+use crate::state::State;
+use calloop_wayland_source::WaylandSource;
+use monolith_render_vk::VulkanAllocator;
+use smithay::backend::allocator::dmabuf::Dmabuf;
+use smithay::backend::allocator::{Format, Fourcc, Modifier, Slot, Swapchain};
+use smithay::backend::renderer::Bind;
+use smithay::backend::renderer::damage::OutputDamageTracker;
+use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
+use smithay::desktop::space::render_output;
+use smithay::output::{Mode, Output, PhysicalProperties, Subpixel};
+use smithay::reexports::calloop::EventLoop;
+use smithay::utils::{Logical, Point, 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};
+use wayland_protocols::wp::linux_dmabuf::zv1::client::{
+    zwp_linux_buffer_params_v1, zwp_linux_dmabuf_v1,
+};
+use wayland_protocols::xdg::decoration::zv1::client::{
+    zxdg_decoration_manager_v1, zxdg_toplevel_decoration_v1,
+};
+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];
+const DEFAULT_SIZE: (i32, i32) = (1280, 800);
+
+pub struct Host {
+    pub size: Size<i32, Logical>,
+    pub pointer_pos: Point<f64, Logical>,
+    pub output: Output,
+    conn: Connection,
+    qh: QueueHandle<State>,
+    surface: wl_surface::WlSurface,
+    _xdg_surface: xdg_surface::XdgSurface,
+    _toplevel: xdg_toplevel::XdgToplevel,
+    dmabuf: zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1,
+    formats: Vec<Format>,
+    swapchain: Option<Swapchain<VulkanAllocator>>,
+    in_flight: Vec<(wl_buffer::WlBuffer, Slot<Dmabuf>)>,
+    damage: OutputDamageTracker,
+    configured: bool,
+    frame_pending: bool,
+    pending_size: Option<Size<i32, Logical>>,
+}
+
+/// Destroys the host-side buffer when its swapchain slot goes away.
+struct HostBuffer(wl_buffer::WlBuffer);
+
+impl Drop for HostBuffer {
+    fn drop(&mut self) {
+        self.0.destroy();
+    }
+}
+
+pub fn init(
+    event_loop: &mut EventLoop<State>,
+    state: &mut State,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let conn = Connection::connect_to_env()?;
+    let (globals, mut queue) = registry_queue_init::<State>(&conn)?;
+    let qh = queue.handle();
+    let compositor: wl_compositor::WlCompositor = globals.bind(&qh, 4..=6, ())?;
+    let wm_base: xdg_wm_base::XdgWmBase = globals.bind(&qh, 1..=6, ())?;
+    let dmabuf: zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1 = globals.bind(&qh, 3..=3, ())?;
+    // Dropping a proxy handle does not destroy it, so seat events keep reaching input.rs.
+    let _ = globals.bind::<wayland_client::protocol::wl_seat::WlSeat, _, _>(&qh, 1..=7, ());
+
+    let surface = compositor.create_surface(&qh, ());
+    let xdg_surface = wm_base.get_xdg_surface(&surface, &qh, ());
+    let toplevel = xdg_surface.get_toplevel(&qh, ());
+    toplevel.set_title("monolith".into());
+    toplevel.set_app_id("monolith".into());
+    if let Ok(deco) =
+        globals.bind::<zxdg_decoration_manager_v1::ZxdgDecorationManagerV1, _, _>(&qh, 1..=1, ())
+    {
+        deco.get_toplevel_decoration(&toplevel, &qh, ())
+            .set_mode(zxdg_toplevel_decoration_v1::Mode::ServerSide);
+    }
+    surface.commit();
+
+    let output = Output::new(
+        "nested".into(),
+        PhysicalProperties {
+            size: (0, 0).into(),
+            subpixel: Subpixel::Unknown,
+            make: "monolith".into(),
+            model: "nested".into(),
+            serial_number: "0".into(),
+        },
+    );
+    let _global = output.create_global::<State>(&state.display);
+    let mode = Mode {
+        size: DEFAULT_SIZE.into(),
+        refresh: 60_000,
+    };
+    output.change_current_state(
+        Some(mode),
+        Some(Transform::Normal),
+        None,
+        Some((0, 0).into()),
+    );
+    output.set_preferred(mode);
+    state.space.map_output(&output, (0, 0));
+
+    state.host = Some(Host {
+        size: DEFAULT_SIZE.into(),
+        pointer_pos: (0.0, 0.0).into(),
+        damage: OutputDamageTracker::from_output(&output),
+        output,
+        conn: conn.clone(),
+        qh,
+        surface,
+        _xdg_surface: xdg_surface,
+        _toplevel: toplevel,
+        dmabuf,
+        formats: Vec::new(),
+        swapchain: None,
+        in_flight: Vec::new(),
+        configured: false,
+        frame_pending: false,
+        pending_size: None,
+    });
+    queue.roundtrip(state)?;
+    queue.roundtrip(state)?;
+    WaylandSource::new(conn, queue).insert(event_loop.handle())?;
+    Ok(())
+}
+
+/// Renders a frame if something changed and the host is ready for one.
+pub fn render(state: &mut State) {
+    let State {
+        host,
+        renderer,
+        space,
+        needs_redraw,
+        start,
+        ..
+    } = state;
+    let Some(host) = host.as_mut() else { return };
+    if !host.configured || host.frame_pending || !*needs_redraw {
+        return;
+    }
+    if let Some(size) = host.pending_size.take() {
+        host.size = size;
+        let mode = Mode {
+            size: (size.w, size.h).into(),
+            refresh: 60_000,
+        };
+        host.output
+            .change_current_state(Some(mode), None, None, None);
+        host.output.set_preferred(mode);
+        if let Some(sc) = host.swapchain.as_mut() {
+            sc.resize(size.w as u32, size.h as u32);
+        }
+    }
+    if host.swapchain.is_none() {
+        host.swapchain = make_swapchain(renderer, &host.formats, host.size);
+    }
+    let Some(swapchain) = host.swapchain.as_mut() else {
+        return;
+    };
+    let slot = match swapchain.acquire() {
+        Ok(Some(slot)) => slot,
+        Ok(None) => return,
+        Err(e) => {
+            tracing::warn!("failed to allocate a frame buffer: {e}");
+            return;
+        }
+    };
+    let mut dmabuf = (*slot).clone();
+    let damage = {
+        let mut fb = match renderer.bind(&mut dmabuf) {
+            Ok(fb) => fb,
+            Err(e) => {
+                tracing::warn!("cannot render into the swapchain: {e}");
+                return;
+            }
+        };
+        let elements: &[WaylandSurfaceRenderElement<monolith_render_vk::VulkanRenderer>] = &[];
+        match render_output(
+            &host.output,
+            renderer,
+            &mut fb,
+            1.0,
+            slot.age() as usize,
+            [&*space],
+            elements,
+            &mut host.damage,
+            CLEAR,
+        ) {
+            Ok(result) => {
+                if let Err(e) = result.sync.wait() {
+                    tracing::warn!("waiting for the frame failed: {e:?}");
+                }
+                result.damage.cloned()
+            }
+            Err(e) => {
+                tracing::warn!("rendering failed: {e:?}");
+                return;
+            }
+        }
+    };
+    *needs_redraw = false;
+    let elapsed = start.elapsed();
+    for window in space.elements() {
+        window.send_frame(&host.output, elapsed, Some(Duration::ZERO), |_, _| {
+            Some(host.output.clone())
+        });
+    }
+    let Some(damage) = damage else { return };
+    let buffer = match slot.userdata().get::<HostBuffer>() {
+        Some(b) => b.0.clone(),
+        None => {
+            let b = host_buffer(&host.dmabuf, &host.qh, &dmabuf);
+            slot.userdata().insert_if_missing(|| HostBuffer(b.clone()));
+            b
+        }
+    };
+    host.surface.attach(Some(&buffer), 0, 0);
+    for r in &damage {
+        host.surface
+            .damage_buffer(r.loc.x, r.loc.y, r.size.w, r.size.h);
+    }
+    host.surface.frame(&host.qh, ());
+    host.surface.commit();
+    swapchain.submitted(&slot);
+    host.in_flight.push((buffer, slot));
+    host.frame_pending = true;
+    let _ = host.conn.flush();
+}
+
+fn make_swapchain(
+    renderer: &monolith_render_vk::VulkanRenderer,
+    host: &[Format],
+    size: Size<i32, Logical>,
+) -> Option<Swapchain<VulkanAllocator>> {
+    let ours = renderer.render_formats();
+    for fourcc in [Fourcc::Xrgb8888, Fourcc::Argb8888] {
+        let modifiers: Vec<Modifier> = host
+            .iter()
+            .filter(|f| f.code == fourcc && ours.contains(f))
+            .map(|f| f.modifier)
+            .collect();
+        if !modifiers.is_empty() {
+            return Some(Swapchain::new(
+                renderer.allocator(),
+                size.w as u32,
+                size.h as u32,
+                fourcc,
+                modifiers,
+            ));
+        }
+    }
+    tracing::error!("the host compositor and the renderer share no dmabuf format");
+    None
+}
+
+fn host_buffer(
+    dmabuf: &zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1,
+    qh: &QueueHandle<State>,
+    buf: &Dmabuf,
+) -> wl_buffer::WlBuffer {
+    use smithay::backend::allocator::Buffer;
+    let params = dmabuf.create_params(qh, ());
+    let modifier = u64::from(buf.format().modifier);
+    for (i, ((fd, offset), stride)) in buf
+        .handles()
+        .zip(buf.offsets())
+        .zip(buf.strides())
+        .enumerate()
+    {
+        params.add(
+            fd,
+            i as u32,
+            offset,
+            stride,
+            (modifier >> 32) as u32,
+            modifier as u32,
+        );
+    }
+    let buffer = params.create_immed(
+        buf.width() as i32,
+        buf.height() as i32,
+        buf.format().code as u32,
+        zwp_linux_buffer_params_v1::Flags::empty(),
+        qh,
+        (),
+    );
+    params.destroy();
+    buffer
+}
+
+impl Dispatch<wl_registry::WlRegistry, GlobalListContents> for State {
+    fn event(
+        _: &mut Self,
+        _: &wl_registry::WlRegistry,
+        _: wl_registry::Event,
+        _: &GlobalListContents,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+    }
+}
+
+impl Dispatch<xdg_wm_base::XdgWmBase, ()> for State {
+    fn event(
+        _: &mut Self,
+        base: &xdg_wm_base::XdgWmBase,
+        event: xdg_wm_base::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        if let xdg_wm_base::Event::Ping { serial } = event {
+            base.pong(serial);
+        }
+    }
+}
+
+impl Dispatch<xdg_surface::XdgSurface, ()> for State {
+    fn event(
+        state: &mut Self,
+        surface: &xdg_surface::XdgSurface,
+        event: xdg_surface::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        if let xdg_surface::Event::Configure { serial } = event {
+            surface.ack_configure(serial);
+            if let Some(host) = state.host.as_mut() {
+                host.configured = true;
+            }
+            state.needs_redraw = true;
+        }
+    }
+}
+
+impl Dispatch<xdg_toplevel::XdgToplevel, ()> for State {
+    fn event(
+        state: &mut Self,
+        _: &xdg_toplevel::XdgToplevel,
+        event: xdg_toplevel::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        match event {
+            xdg_toplevel::Event::Configure { width, height, .. } if width > 0 && height > 0 => {
+                let size = Size::from((width, height));
+                if let Some(host) = state.host.as_mut()
+                    && host.size != size
+                {
+                    host.pending_size = Some(size);
+                    host.size = size;
+                    state.relayout();
+                }
+            }
+            xdg_toplevel::Event::Close => state.signal.stop(),
+            _ => {}
+        }
+    }
+}
+
+impl Dispatch<zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1, ()> for State {
+    fn event(
+        state: &mut Self,
+        _: &zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1,
+        event: zwp_linux_dmabuf_v1::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        if let zwp_linux_dmabuf_v1::Event::Modifier {
+            format,
+            modifier_hi,
+            modifier_lo,
+        } = event
+            && let (Ok(code), Some(host)) = (Fourcc::try_from(format), state.host.as_mut())
+        {
+            let modifier = Modifier::from((u64::from(modifier_hi) << 32) | u64::from(modifier_lo));
+            host.formats.push(Format { code, modifier });
+        }
+    }
+}
+
+impl Dispatch<wl_buffer::WlBuffer, ()> for State {
+    fn event(
+        state: &mut Self,
+        buffer: &wl_buffer::WlBuffer,
+        event: wl_buffer::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        if let wl_buffer::Event::Release = event
+            && let Some(host) = state.host.as_mut()
+        {
+            host.in_flight.retain(|(b, _)| b != buffer);
+        }
+    }
+}
+
+impl Dispatch<wl_callback::WlCallback, ()> for State {
+    fn event(
+        state: &mut Self,
+        _: &wl_callback::WlCallback,
+        event: wl_callback::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        if let wl_callback::Event::Done { .. } = event
+            && let Some(host) = state.host.as_mut()
+        {
+            host.frame_pending = false;
+        }
+    }
+}
+
+delegate_noop!(State: wl_compositor::WlCompositor);
+delegate_noop!(State: ignore wl_surface::WlSurface);
+delegate_noop!(State: ignore zwp_linux_buffer_params_v1::ZwpLinuxBufferParamsV1);
+delegate_noop!(State: zxdg_decoration_manager_v1::ZxdgDecorationManagerV1);
+delegate_noop!(State: ignore zxdg_toplevel_decoration_v1::ZxdgToplevelDecorationV1);

Added file: crates/monolith/src/state.rs+159 additions@@ -0,0 +1,159 @@
+use crate::nested::Host;
+use monolith_render_vk::VulkanRenderer;
+use smithay::backend::renderer::ImportDma;
+use smithay::desktop::{PopupManager, Space, Window, WindowSurfaceType};
+use smithay::input::{Seat, SeatState};
+use smithay::reexports::calloop::generic::Generic;
+use smithay::reexports::calloop::{EventLoop, Interest, LoopSignal, Mode, PostAction};
+use smithay::reexports::wayland_server::backend::{ClientData, ClientId, DisconnectReason};
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use smithay::reexports::wayland_server::{Display, DisplayHandle};
+use smithay::utils::{Logical, Point, Size};
+use smithay::wayland::compositor::{CompositorClientState, CompositorState};
+use smithay::wayland::dmabuf::{DmabufGlobal, DmabufState};
+use smithay::wayland::output::OutputManagerState;
+use smithay::wayland::selection::data_device::DataDeviceState;
+use smithay::wayland::shell::xdg::XdgShellState;
+use smithay::wayland::shm::ShmState;
+use smithay::wayland::socket::ListeningSocketSource;
+use std::ffi::OsString;
+use std::sync::Arc;
+use std::time::Instant;
+
+pub struct State {
+    pub start: Instant,
+    pub socket_name: OsString,
+    pub display: DisplayHandle,
+    pub signal: LoopSignal,
+    pub renderer: VulkanRenderer,
+    pub space: Space<Window>,
+    pub popups: PopupManager,
+    pub host: Option<Host>,
+    pub needs_redraw: bool,
+
+    pub compositor_state: CompositorState,
+    pub xdg_shell_state: XdgShellState,
+    pub shm_state: ShmState,
+    pub dmabuf_state: DmabufState,
+    pub _dmabuf_global: DmabufGlobal,
+    pub _output_manager_state: OutputManagerState,
+    pub seat_state: SeatState<State>,
+    pub data_device_state: DataDeviceState,
+    pub seat: Seat<State>,
+}
+
+impl State {
+    pub fn new(
+        event_loop: &mut EventLoop<State>,
+        display: Display<State>,
+    ) -> Result<Self, Box<dyn std::error::Error>> {
+        let dh = display.handle();
+        let renderer = VulkanRenderer::new()?;
+        let mut dmabuf_state = DmabufState::new();
+        let dmabuf_global = dmabuf_state.create_global::<State>(&dh, renderer.dmabuf_formats());
+        let mut seat_state = SeatState::new();
+        let mut seat = seat_state.new_wl_seat(&dh, "seat0");
+        seat.add_keyboard(Default::default(), 200, 25)?;
+        seat.add_pointer();
+
+        let listener = ListeningSocketSource::new_auto()?;
+        let socket_name = listener.socket_name().to_os_string();
+        let handle = event_loop.handle();
+        handle.insert_source(listener, |stream, _, state| {
+            if let Err(e) = state
+                .display
+                .insert_client(stream, Arc::new(ClientState::default()))
+            {
+                tracing::warn!("failed to accept client: {e}");
+            }
+        })?;
+        handle.insert_source(
+            Generic::new(display, Interest::READ, Mode::Level),
+            |_, display, state| {
+                // SAFETY: the display is never dropped while the event loop runs.
+                unsafe { display.get_mut().dispatch_clients(state)? };
+                Ok(PostAction::Continue)
+            },
+        )?;
+
+        Ok(Self {
+            start: Instant::now(),
+            socket_name,
+            signal: event_loop.get_signal(),
+            renderer,
+            space: Space::default(),
+            popups: PopupManager::default(),
+            host: None,
+            needs_redraw: true,
+            compositor_state: CompositorState::new::<State>(&dh),
+            xdg_shell_state: XdgShellState::new::<State>(&dh),
+            shm_state: ShmState::new::<State>(&dh, vec![]),
+            dmabuf_state,
+            _dmabuf_global: dmabuf_global,
+            _output_manager_state: OutputManagerState::new_with_xdg_output::<State>(&dh),
+            seat_state,
+            data_device_state: DataDeviceState::new::<State>(&dh),
+            seat,
+            display: dh,
+        })
+    }
+
+    /// Runs after every batch of events, so many client commits produce one frame.
+    pub fn after_dispatch(&mut self) {
+        self.space.refresh();
+        self.popups.cleanup();
+        crate::nested::render(self);
+        let _ = self.display.flush_clients();
+    }
+
+    pub fn output_size(&self) -> Size<i32, Logical> {
+        self.host.as_ref().map_or((1280, 800).into(), |h| h.size)
+    }
+
+    /// Lays toplevels out side by side across the output. A stand-in until
+    /// the layout crate takes over.
+    pub fn relayout(&mut self) {
+        let windows: Vec<Window> = self.space.elements().cloned().collect();
+        let size = self.output_size();
+        let n = windows.len() as i32;
+        if n == 0 {
+            return;
+        }
+        let gap = 8;
+        let w = (size.w - gap * (n + 1)) / n;
+        for (i, window) in windows.into_iter().enumerate() {
+            let loc = (gap + i as i32 * (w + gap), gap);
+            if let Some(toplevel) = window.toplevel() {
+                toplevel.with_pending_state(|s| s.size = Some((w, size.h - 2 * gap).into()));
+                if toplevel.is_initial_configure_sent() {
+                    toplevel.send_pending_configure();
+                }
+            }
+            self.space.map_element(window, loc, false);
+        }
+        self.needs_redraw = true;
+    }
+
+    pub fn surface_under(
+        &self,
+        pos: Point<f64, Logical>,
+    ) -> Option<(WlSurface, Point<f64, Logical>)> {
+        self.space
+            .element_under(pos)
+            .and_then(|(window, location)| {
+                window
+                    .surface_under(pos - location.to_f64(), WindowSurfaceType::ALL)
+                    .map(|(s, p)| (s, (p + location).to_f64()))
+            })
+    }
+}
+
+#[derive(Default)]
+pub struct ClientState {
+    pub compositor_state: CompositorClientState,
+}
+
+impl ClientData for ClientState {
+    fn initialized(&self, _client_id: ClientId) {}
+    fn disconnected(&self, _client_id: ClientId, _reason: DisconnectReason) {}
+}

Modified file: crates/render-vk/src/error.rs+2

@@ -21,6 +21,8 @@ pub enum Error {

2121 DmabufUnsupported,

2222 #[error("cannot import dmabuf with format {0:?}")]

2323 UnsupportedDmabuf(smithay::backend::allocator::Format),

24+ #[error("cannot read the shm buffer")]

25+ ShmAccess,

2426 #[error("interrupted while waiting for a sync point")]

2527 Interrupted,

2628 #[error("invalid size {0}x{1}")]

Modified file: crates/render-vk/src/renderer.rs+35 additions@@ -13,12 +13,16 @@ use gpu_allocator::MemoryLocation;
 use smithay::backend::allocator::Fourcc;
 use smithay::backend::allocator::dmabuf::{Dmabuf, WeakDmabuf};
 use smithay::backend::allocator::format::FormatSet;
+use smithay::backend::renderer::ImportMemWl;
 use smithay::backend::renderer::sync::SyncPoint;
 use smithay::backend::renderer::{
     Bind, ContextId, DebugFlags, ExportMem, ImportDma, ImportDmaWl, ImportMem, Offscreen, Renderer,
     RendererSuper, Texture, TextureFilter,
 };
+use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;
 use smithay::utils::{Buffer, Physical, Rectangle, Size, Transform};
+use smithay::wayland::compositor::SurfaceData;
+use smithay::wayland::shm::{shm_format_to_fourcc, with_buffer_contents};
 use std::collections::HashMap;
 use std::fmt;
 use std::marker::PhantomData;
@@ -873,3 +877,34 @@ impl ExportMem for VulkanRenderer {
         Ok(&mapping.data)
     }
 }
+
+impl ImportMemWl for VulkanRenderer {
+    fn import_shm_buffer(
+        &mut self,
+        buffer: &WlBuffer,
+        _surface: Option<&SurfaceData>,
+        _damage: &[Rectangle<i32, Buffer>],
+    ) -> Result<VulkanTexture, Error> {
+        let (pixels, fourcc, size) = with_buffer_contents(buffer, |ptr, len, data| {
+            let fourcc = shm_format_to_fourcc(data.format).ok_or(Error::ShmAccess)?;
+            let (w, h, stride, offset) = (
+                data.width as usize,
+                data.height as usize,
+                data.stride as usize,
+                data.offset as usize,
+            );
+            let row = w * BYTES_PER_PIXEL;
+            if w == 0 || h == 0 || stride < row || offset + stride * (h - 1) + row > len {
+                return Err(Error::ShmAccess);
+            }
+            let mut pixels = Vec::with_capacity(row * h);
+            for y in 0..h {
+                let line = unsafe { std::slice::from_raw_parts(ptr.add(offset + y * stride), row) };
+                pixels.extend_from_slice(line);
+            }
+            Ok((pixels, fourcc, Size::from((data.width, data.height))))
+        })
+        .map_err(|_| Error::ShmAccess)??;
+        self.import_memory(&pixels, fourcc, size, false)
+    }
+}

monolith

Commit d4a64ce87164

Commit `d4a64ce87164`