monolith

//! Bare metal. A libseat session, udev for the primary GPU and its

//! connectors, libinput for input, and one smithay DRM output per connector,

//! each rendered when its own vblank lands.

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};

use smithay::backend::drm::{

    DrmDevice, DrmDeviceFd, DrmEvent, DrmEventMetadata, DrmEventTime, DrmNode, NodeType,

};

use smithay::backend::input::{

    AbsolutePositionEvent, Axis, AxisSource, Event, InputEvent, KeyboardKeyEvent, PointerAxisEvent,

    PointerButtonEvent, PointerMotionEvent,

};

use smithay::backend::libinput::{LibinputInputBackend, LibinputSessionInterface};

use smithay::backend::session::libseat::LibSeatSession;

use smithay::backend::session::{Event as SessionEvent, Session};

use smithay::backend::udev::{UdevBackend, UdevEvent, all_gpus, primary_gpu};

use smithay::input::pointer::AxisFrame;

use smithay::output::{Mode, Output, PhysicalProperties, Scale, Subpixel};

use smithay::reexports::calloop::timer::{TimeoutAction, Timer};

use smithay::reexports::calloop::{EventLoop, LoopHandle, RegistrationToken};

use smithay::reexports::drm::Device as _;

use smithay::reexports::drm::control::{ModeTypeFlags, connector, crtc};

use smithay::reexports::input::Libinput;

use smithay::reexports::rustix::fs::OFlags;

use smithay::utils::{DeviceFd, Point, Transform};

use smithay::wayland::drm_syncobj::{DrmSyncobjState, supports_syncobj_eventfd};

use smithay_drm_extras::drm_scanner::{DrmScanEvent, DrmScanner};

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];

/// 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>;

type Manager = DrmOutputManager<Allocator, Exporter, (), DrmDeviceFd>;

type Out = DrmOutput<Allocator, Exporter, (), DrmDeviceFd>;

pub struct Drm {

    pub session: LibSeatSession,

    libinput: Libinput,

    handle: LoopHandle<'static, State>,

    node: DrmNode,

    manager: Manager,

    scanner: DrmScanner,

    nvidia: bool,

    frame_flags: FrameFlags,

    surfaces: HashMap<crtc::Handle, Surface>,

}

struct Surface {

    output: Output,

    id: OutputId,

    drm: Out,

    /// A frame is on its way to the screen and its vblank has not landed.

    queued: bool,

    redraw: bool,

    last_vblank_ns: Option<u64>,

    refresh_ns: u64,

    /// The pending render, timed to start just in time for `target_ns`.

    scheduled: Option<RegistrationToken>,

    /// The vblank the frame being drawn or queued is meant for.

    target_ns: Option<u64>,

    budget: Budget,

    /// 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 {

    /// The first vblank a render starting at `now` can still make, and the

    /// latest moment to start it.

    fn next_deadline(&self, now: u64) -> Option<(u64, u64)> {

        let last = self.last_vblank_ns?;

        let refresh = self.refresh_ns;

        if refresh == 0 {

            return None;

        }

        let budget = self.budget.ns().min(refresh);

        let periods = (now + budget).saturating_sub(last).div_ceil(refresh).max(1);

        let vblank = last + periods * refresh;

        Some((vblank, vblank - budget))

    }

}

/// How long before a vblank rendering must start. A high percentile of

/// recent CPU render times covers the CPU side without one spike inflating

/// it, and a slack that grows on every missed vblank and shrinks over seconds

/// while frames land covers GPU time and the commit.

struct Budget {

    renders: VecDeque<u64>,

    slack_ns: u64,

    /// The slack that last proved enough after a miss. Decay stops there

    /// for `floor_frames` frames, so it does not keep rediscovering the same

    /// limit one dropped frame at a time.

    floor_ns: u64,

    floor_frames: u64,

}

impl Budget {

    const KEEP: usize = 32;

    const MIN_SLACK_NS: u64 = 1_000_000;

    const STEP_NS: u64 = 500_000;

    const DECAY_NS: u64 = 1_000;

    const FLOOR_NS: u64 = 30_000_000_000;

    fn new() -> Self {

        Self {

            renders: VecDeque::with_capacity(Self::KEEP),

            slack_ns: 2_000_000,

            floor_ns: 0,

            floor_frames: 0,

        }

    }

    fn ns(&self) -> u64 {

        let mut renders: Vec<u64> = self.renders.iter().copied().collect();

        renders.sort_unstable();

        let p90 = renders

            .get(renders.len().saturating_sub(1) * 9 / 10)

            .copied()

            .unwrap_or(0);

        p90 + self.slack_ns

    }

    fn record(&mut self, render_ns: u64) {

        if self.renders.len() == Self::KEEP {

            self.renders.pop_front();

        }

        self.renders.push_back(render_ns);

    }

    fn missed(&mut self, refresh_ns: u64) {

        self.slack_ns = (self.slack_ns + Self::STEP_NS).min(refresh_ns / 2);

        self.floor_ns = self.slack_ns;

        self.floor_frames = Self::FLOOR_NS / refresh_ns.max(1);

    }

    fn landed(&mut self) {

        self.floor_frames = self.floor_frames.saturating_sub(1);

        let floor = if self.floor_frames > 0 {

            self.floor_ns

        } else {

            Self::MIN_SLACK_NS

        };

        self.slack_ns = self.slack_ns.saturating_sub(Self::DECAY_NS).max(floor);

    }

}

/// The GPU monolith drives on bare metal, the seat's primary or else its

/// first.

pub fn primary() -> Result<PathBuf, Box<dyn std::error::Error>> {

    let seat = std::env::var("XDG_SEAT").unwrap_or_else(|_| "seat0".into());

    Ok(match primary_gpu(&seat)? {

        Some(p) => p,

        None => all_gpus(&seat)?.into_iter().next().ok_or("no GPU found")?,

    })

}

pub fn init(

    event_loop: &mut EventLoop<'static, State>,

    state: &mut State,

    path: &Path,

) -> Result<(), Box<dyn std::error::Error>> {

    let (mut session, notifier) = LibSeatSession::new()?;

    let seat = session.seat();

    let node = DrmNode::from_path(path)?;

    tracing::info!(path = %path.display(), "primary GPU");

    let fd = session.open(

        path,

        OFlags::RDWR | OFlags::CLOEXEC | OFlags::NOCTTY | OFlags::NONBLOCK,

    )?;

    let fd = DrmDeviceFd::new(DeviceFd::from(fd));

    let (device, drm_events) = DrmDevice::new(fd.clone(), true)?;

    let nvidia = device

        .get_driver()

        .map(|d| d.name().to_string_lossy().to_lowercase().contains("nvidia"))

        .unwrap_or(false);

    if supports_syncobj_eventfd(&fd) {

        state.syncobj = Some(DrmSyncobjState::new::<State>(&state.display, fd.clone()));

    } else {

        tracing::info!("no syncobj eventfd support, clients stay on implicit sync");

    }

    let gbm = GbmDevice::new(fd)?;

    let render_node = node

        .node_with_type(NodeType::Render)

        .and_then(Result::ok)

        .unwrap_or(node);

    let allocator = GbmAllocator::new(

        gbm.clone(),

        GbmBufferFlags::RENDERING | GbmBufferFlags::SCANOUT,

    );

    let exporter = GbmFramebufferExporter::new(gbm.clone(), render_node.into());

    let render_formats: Vec<_> = state.renderer.render_formats().iter().copied().collect();

    let manager = DrmOutputManager::new(

        device,

        allocator,

        exporter,

        Some(gbm),

        [Fourcc::Xrgb8888, Fourcc::Argb8888],

        render_formats,

    );

    let mut libinput =

        Libinput::new_with_udev::<LibinputSessionInterface<LibSeatSession>>(session.clone().into());

    libinput

        .udev_assign_seat(&seat)

        .map_err(|()| "libinput could not take the seat")?;

    let handle = event_loop.handle();

    handle.insert_source(

        LibinputInputBackend::new(libinput.clone()),

        |event, _, state| {

            on_input(state, event);

        },

    )?;

    handle.insert_source(notifier, |event, _, state| match event {

        SessionEvent::PauseSession => {

            if let Some(drm) = state.drm.as_mut() {

                drm.libinput.suspend();

                drm.manager.pause();

            }

        }

        SessionEvent::ActivateSession => {

            if let Some(drm) = state.drm.as_mut() {

                if drm.libinput.resume().is_err() {

                    tracing::warn!("libinput did not resume");

                }

                if let Err(e) = drm.manager.lock().activate(false) {

                    tracing::warn!("could not reactivate the GPU: {e}");

                }

                for s in drm.surfaces.values_mut() {

                    s.queued = false;

                    s.redraw = true;

                }

            }

            state.needs_redraw = true;

        }

    })?;

    handle.insert_source(drm_events, |event, meta, state| match event {

        DrmEvent::VBlank(crtc) => on_vblank(state, crtc, meta),

        DrmEvent::Error(e) => tracing::warn!("drm: {e}"),

    })?;

    let udev = UdevBackend::new(&seat)?;

    handle.insert_source(udev, move |event, _, state| {

        if let UdevEvent::Changed { device_id } = event

            && state

                .drm

                .as_ref()

                .is_some_and(|d| d.node.dev_id() == device_id)

        {

            scan(state);

        }

    })?;

    state.drm = Some(Drm {

        session,

        libinput,

        handle,

        node,

        manager,

        scanner: DrmScanner::new(),

        nvidia,

        frame_flags: if std::env::var_os("MONOLITH_NO_SCANOUT").is_some() {

            FrameFlags::empty()

        } else {

            FrameFlags::DEFAULT

        },

        surfaces: HashMap::new(),

    });

    scan(state);

    Ok(())

}

/// Brings outputs in line with what is plugged in.

fn scan(state: &mut State) {

    let Some(drm) = state.drm.as_mut() else {

        return;

    };

    let events: Vec<DrmScanEvent> = match drm.scanner.scan_connectors(drm.manager.device()) {

        Ok(result) => result.into_iter().collect(),

        Err(e) => {

            tracing::warn!("scanning connectors failed: {e}");

            return;

        }

    };

    for event in events {

        match event {

            DrmScanEvent::Connected {

                connector,

                crtc: Some(crtc),

            } => connect(state, connector, crtc),

            DrmScanEvent::Disconnected {

                crtc: Some(crtc), ..

            } => disconnect(state, crtc),

            _ => {}

        }

    }

    state.apply_layout();

}

fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {

    let name = format!(

        "{}-{}",

        connector.interface().as_str(),

        connector.interface_id()

    );

    let Some(&mode) = connector

        .modes()

        .iter()

        .find(|m| m.mode_type().contains(ModeTypeFlags::PREFERRED))

        .or_else(|| connector.modes().first())

    else {

        tracing::warn!(name, "connector has no modes");

        return;

    };

    let State {

        drm: Some(drm),

        renderer,

        layout,

        space,

        display,

        ..

    } = state

    else {

        return;

    };

    let (mm_w, mm_h) = connector.size().unwrap_or((0, 0));

    let output = Output::new(

        name.clone(),

        PhysicalProperties {

            size: (mm_w as i32, mm_h as i32).into(),

            subpixel: Subpixel::Unknown,

            make: "Unknown".into(),

            model: name.clone(),

            serial_number: String::new(),

        },

    );

    let wl_mode = Mode::from(mode);

    let x = layout

        .outputs()

        .map(|(_, o)| o.area.right())

        .fold(0.0, f64::max);

    let position = Point::from((x as i32, 0));

    output.change_current_state(

        Some(wl_mode),

        Some(Transform::Normal),

        Some(Scale::Integer(1)),

        Some(position),

    );

    output.set_preferred(wl_mode);

    output.create_global::<State>(display);

    let mut planes = drm.manager.device().planes(&crtc).ok();

    if drm.nvidia

        && let Some(p) = planes.as_mut()

    {

        // NVIDIA's overlay planes break composition, as anvil also found.

        p.overlay.clear();

    }

    let out = match drm.manager.lock().initialize_output::<_, Draw>(

        crtc,

        mode,

        &[connector.handle()],

        &output,

        planes,

        renderer,

        &DrmOutputRenderElements::default(),

    ) {

        Ok(out) => out,

        Err(e) => {

            tracing::warn!(name, "could not light up the output: {e}");

            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(),

        vrr_capable,

        "output connected"

    );

    drm.surfaces.insert(

        crtc,

        Surface {

            output,

            id,

            drm: out,

            queued: false,

            redraw: true,

            last_vblank_ns: None,

            scheduled: None,

            target_ns: None,

            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),

        },

    );

}

fn disconnect(state: &mut State, crtc: crtc::Handle) {

    let Some(drm) = state.drm.as_mut() else {

        return;

    };

    let Some(surface) = drm.surfaces.remove(&crtc) else {

        return;

    };

    if let Some(token) = surface.scheduled {

        drm.handle.remove(token);

    }

    tracing::info!(name = surface.output.name(), "output disconnected");

    state.space.unmap_output(&surface.output);

    state.layout.remove_output(surface.id);

}

/// The smithay output for a layout output, for protocols that need one.

pub fn output_for(drm: &Drm, id: OutputId) -> Option<Output> {

    drm.surfaces

        .values()

        .find(|s| s.id == id)

        .map(|s| s.output.clone())

}

fn on_vblank(state: &mut State, crtc: crtc::Handle, meta: &mut Option<DrmEventMetadata>) {

    let Some(surface) = state.drm.as_mut().and_then(|d| d.surfaces.get_mut(&crtc)) else {

        return;

    };

    if let Err(e) = surface.drm.frame_submitted() {

        tracing::warn!("frame was not submitted: {e}");

    }

    surface.queued = false;

    if let Some(DrmEventTime::Monotonic(t)) = meta.as_ref().map(|m| m.time) {

        let t = t.as_nanos() as u64;

        if let Some(target) = surface.target_ns.take() {

            if t > target + surface.refresh_ns / 2 {

                surface.budget.missed(surface.refresh_ns);

                tracing::debug!(

                    output = surface.output.name(),

                    late_ns = t - target,

                    budget_ns = surface.budget.ns(),

                    "frame missed its vblank"

                );

            } else {

                surface.budget.landed();

            }

        }

        surface.last_vblank_ns = Some(t);

        surface.presented += 1;

        let window = t.saturating_sub(surface.stats_since);

        if window >= 1_000_000_000 {

            let vblanks = window / surface.refresh_ns.max(1);

            tracing::debug!(

                output = surface.output.name(),

                presented = surface.presented,

                vblanks,

                budget_us = surface.budget.ns() / 1000,

                "frame rate"

            );

            surface.presented = 0;

            surface.stats_since = t;

        }

    }

    if surface.redraw || surface.cursor_redraw {

        schedule(state, crtc);

    }

}

/// Starts a render at the last moment that still makes the next reachable

/// vblank, so commits arriving until then make it into the frame.

fn schedule(state: &mut State, crtc: crtc::Handle) {

    let Some(drm) = state.drm.as_mut() else {

        return;

    };

    let Some(surface) = drm.surfaces.get_mut(&crtc) else {

        return;

    };

    if surface.queued || surface.scheduled.is_some() {

        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;

    };

    surface.target_ns = Some(vblank);

    let wait = Timer::from_duration(Duration::from_nanos(start.saturating_sub(now)));

    let token = drm.handle.insert_source(wait, move |_, _, state| {

        let target = state.drm.as_mut().and_then(|d| {

            let s = d.surfaces.get_mut(&crtc)?;

            s.scheduled = None;

            s.target_ns

        });

        if let Some(target) = target {

            draw(state, crtc, target);

        }

        TimeoutAction::Drop

    });

    surface.scheduled = token.ok();

}

fn draw(state: &mut State, crtc: crtc::Handle, target: u64) {

    if render_surface(state, crtc, target) {

        schedule(state, crtc);

    }

}

/// Renders every output that has something new and no frame in flight.

pub fn render(state: &mut State) {

    let Some(drm) = state.drm.as_mut() else {

        return;

    };

    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.cursor_redraw) && !s.queued)

        .map(|(c, _)| *c)

        .collect();

    for crtc in ready {

        schedule(state, crtc);

    }

}

/// Draws one output for the vblank at `target`. Returns whether it still

/// animates without a frame in flight, and so needs another render.

#[profiling::function]

fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {

    let State {

        drm: Some(drm),

        renderer,

        layout,

        windows,

        anim,

        borders,

        config,

        space,

        start,

        cursor,

        cursor_status,

        pointer_pos,

        ..

    } = state

    else {

        return false;

    };

    if !drm.session.is_active() {

        return false;

    }

    let Some(surface) = drm.surfaces.get_mut(&crtc) else {

        return false;

    };

    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 {

        return false;

    };

    let mut elements = Vec::new();

    let local = *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(cursor.elements(renderer, cursor_status, local));

    }

    let scene_began = std::time::Instant::now();

    elements.extend(crate::scene::build(

        layout,

        surface.id,

        windows,

        anim,

        renderer,

        now,

        &config.decoration,

        borders,

    ));

    let scene_ns = scene_began.elapsed().as_nanos() as u64;

    let animating = anim.active(now);

    anim.prune(now);

    let render_began = std::time::Instant::now();

    let cpu_began = thread_cpu_ns();

    let mut queue_ns = 0;

    match surface

        .drm

        .render_frame(renderer, &elements, CLEAR, drm.frame_flags)

    {

        Ok(result) if !result.is_empty => {

            let queue_began = std::time::Instant::now();

            match surface.drm.queue_frame(()) {

                Ok(()) => surface.queued = true,

                Err(e) => tracing::warn!("queueing a frame failed: {e}"),

            }

            queue_ns = queue_began.elapsed().as_nanos() as u64;

        }

        Ok(_) => {}

        Err(e) => tracing::warn!("rendering failed: {e}"),

    }

    let render_cpu_ns = thread_cpu_ns() - cpu_began;

    let render_ns = render_began.elapsed().as_nanos() as u64 - queue_ns;

    let took = began.elapsed().as_nanos() as u64;

    surface.budget.record(took);

    if took > surface.refresh_ns / 2 {

        tracing::debug!(

            output = surface.output.name(),

            took_ns = took,

            scene_ns,

            render_ns,

            render_cpu_ns,

            queue_ns,

            "slow frame"

        );

    }

    if !surface.queued {

        surface.target_ns = None;

    }

    surface.redraw = animating;

    let elapsed = start.elapsed();

    let output = surface.output.clone();

    for window in space.elements_for_output(&output) {

        window.send_frame(&output, elapsed, Some(Duration::ZERO), |_, _| {

            Some(output.clone())

        });

    }

    animating && !surface.queued

}

/// CPU time this thread has used, to tell a render that works from one that

/// waits or is descheduled.

fn thread_cpu_ns() -> u64 {

    let t = smithay::reexports::rustix::time::clock_gettime(

        smithay::reexports::rustix::time::ClockId::ThreadCPUTime,

    );

    t.tv_sec as u64 * 1_000_000_000 + t.tv_nsec as u64

}

fn on_input(state: &mut State, event: InputEvent<LibinputInputBackend>) {

    match event {

        InputEvent::Keyboard { event } => {

            let time = event.time();

            state.key(event.key_code(), event.state(), time);

        }

        InputEvent::PointerMotion { event } => {

            let pos = clamp(state, state.pointer_pos + event.delta());

            state.pointer_to(pos, event.time());

            state.pointer_frame();

            state.cursor_moved = true;

        }

        InputEvent::PointerMotionAbsolute { event } => {

            let Some(area) = state.layout.outputs().next().map(|(_, o)| o.area) else {

                return;

            };

            let p = event.position_transformed((area.w as i32, area.h as i32).into());

            let pos = Point::from((area.x + p.x, area.y + p.y));

            state.pointer_to(pos, event.time());

            state.pointer_frame();

            state.cursor_moved = true;

        }

        InputEvent::PointerButton { event } => {

            let time = event.time();

            state.pointer_button(event.button_code(), event.state(), time);

            state.pointer_frame();

        }

        InputEvent::PointerAxis { event } => {

            let source = event.source();

            let mut frame = AxisFrame::new(event.time()).source(source);

            for axis in [Axis::Horizontal, Axis::Vertical] {

                if let Some(v120) = event.amount_v120(axis) {

                    frame = frame.v120(axis, v120 as i32);

                }

                let amount = event

                    .amount(axis)

                    .or_else(|| event.amount_v120(axis).map(|v| v * 15.0 / 120.0));

                match amount {

                    Some(a) if a != 0.0 => frame = frame.value(axis, a),

                    Some(_) if source == AxisSource::Finger => frame = frame.stop(axis),

                    _ => {}

                }

            }

            state.pointer_axis(frame);

            state.pointer_frame();

        }

        _ => {}

    }

}

/// Keeps the pointer on some output, sliding along the edge it hit.

fn clamp(

    state: &State,

    pos: Point<f64, smithay::utils::Logical>,

) -> Point<f64, smithay::utils::Logical> {

    let inside = |a: &Rect, p: Point<f64, smithay::utils::Logical>| {

        p.x >= a.x && p.y >= a.y && p.x < a.right() && p.y < a.bottom()

    };

    let areas: Vec<Rect> = state.layout.outputs().map(|(_, o)| o.area).collect();

    if areas.iter().any(|a| inside(a, pos)) {

        return pos;

    }

    let Some(a) = areas

        .iter()

        .find(|a| inside(a, state.pointer_pos))

        .or(areas.first())

    else {

        return pos;

    };

    Point::from((

        pos.x.clamp(a.x, a.right() - 1.0),

        pos.y.clamp(a.y, a.bottom() - 1.0),

    ))

}