monolith

//! What a frame draws. The space holds final geometry for input, while the

//! scene draws windows where the animator says they are right now.

use crate::wm::{LastFrame, Wm};

use monolith_config::Decoration;

use monolith_layout::{OutputId, Rect, WindowId};

use monolith_render_vk::{Clip, Effect, VulkanFrame, VulkanRenderer, VulkanTexture};

use smithay::backend::renderer::element::memory::MemoryRenderBufferRenderElement;

use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};

use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;

use smithay::backend::renderer::element::surface::render_elements_from_surface_tree;

use smithay::backend::renderer::element::texture::TextureRenderElement;

use smithay::backend::renderer::element::utils::{CropRenderElement, RescaleRenderElement};

use smithay::backend::renderer::element::{AsRenderElements, Element, Id, Kind, RenderElement};

use smithay::backend::renderer::utils::with_renderer_surface_state;

use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};

use smithay::backend::renderer::{ContextId, Renderer, Texture};

use smithay::desktop::{PopupManager, Window};

use smithay::output::Output;

use smithay::utils::user_data::UserDataMap;

use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform};

use smithay::wayland::compositor::{TraversalAction, with_surface_tree_downward};

use smithay::wayland::shell::wlr_layer::Layer;

use smithay::xwayland::X11Surface;

smithay::backend::renderer::element::render_elements! {

    pub Draw<=VulkanRenderer>;

    Surface=WaylandSurfaceRenderElement<VulkanRenderer>,

    Cropped=CropRenderElement<WaylandSurfaceRenderElement<VulkanRenderer>>,

    Texture=TextureRenderElement<VulkanTexture>,

    Effect=EffectElement,

    Border=SolidColorRenderElement,

    Memory=MemoryRenderBufferRenderElement<VulkanRenderer>,

    Rescaled=RescaleRenderElement<WaylandSurfaceRenderElement<VulkanRenderer>>,

    Clipped=ClipElement,

}

/// Elements for output `o` in its own coordinates, front to back.

#[profiling::function]

pub fn build(

    wm: &mut Wm,

    o: OutputId,

    renderer: &mut VulkanRenderer,

    now: u64,

    deco: &Decoration,

    output: Option<&Output>,

    unmanaged: &[X11Surface],

) -> Vec<Draw> {

    let crate::wm::Parts {

        layout,

        anim,

        windows,

        last_frames,

    } = wm.parts();

    let Some(area) = layout.output(o).map(|out| out.area) else {

        return Vec::new();

    };

    let local = |r: Rect| Rect::new(r.x - area.x, r.y - area.y, r.w, r.h);

    let mut ghosts = Vec::new();

    let mut tiled = Vec::new();

    let mut above = Vec::new();

    let mut fading = Vec::new();

    for g in anim.ghosts().iter().filter(|g| g.output == o) {

        let Some(frame) = last_frames.get(&g.id) else {

            continue;

        };

        match g.fixed {

            Some(r) => fading.push((g, frame, local(r))),

            None => {

                if let Some(r) = anim.tiled(o, g.id, now) {

                    ghosts.push((g, frame, local(r)));

                }

            }

        }

    }

    let arr = layout.arrange(o);

    let fullscreen_at_rest = arr

        .fullscreen

        .is_some_and(|w| anim.gliding(w, now).is_none());

    for p in &arr.tiled {

        if Some(p.window) == arr.fullscreen || fullscreen_at_rest {

            continue;

        }

        match anim.gliding(p.window, now) {

            Some(r) => above.push((p.window, local(r), true, true)),

            None => {

                let r = anim.tiled(o, p.window, now).unwrap_or(p.rect);

                tiled.push((p.window, local(r), true, false));

            }

        }

    }

    let float = |&(w, r): &(WindowId, Rect)| {

        let glide = anim.gliding(w, now);

        (w, local(glide.unwrap_or(r)), true, glide.is_some())

    };

    let (over, under): (Vec<_>, Vec<_>) =

        arr.floating.iter().partition(|f| arr.over.contains(&f.0));

    above.extend(under.into_iter().map(float));

    if let Some(w) = arr.fullscreen {

        let glide = anim.gliding(w, now);

        above.push((w, local(glide.unwrap_or(area)), false, glide.is_some()));

    }

    above.extend(over.into_iter().map(float));

    let focused = layout.focused();

    let mut out = Vec::new();

    for x in unmanaged.iter().rev() {

        let Some(surface) = x.wl_surface() else {

            continue;

        };

        let loc = x.geometry().loc;

        let at = Point::<i32, Physical>::from((loc.x - area.x as i32, loc.y - area.y as i32));

        out.extend(

            render_elements_from_surface_tree(renderer, &surface, at, 1.0, 1.0, Kind::Unspecified)

                .into_iter()

                .map(Draw::Surface),

        );

    }

    if let Some(output) = output {

        crate::layers::elements(&mut out, renderer, output, Layer::Overlay);

        if !fullscreen_at_rest {

            crate::layers::elements(&mut out, renderer, output, Layer::Top);

        }

    }

    for (g, frame, r) in fading.into_iter().rev() {

        out.extend(ghost_element(frame, r, anim.ghost_effect(g, now), deco));

    }

    for (id, r, framed, gliding) in tiled.into_iter().chain(above).rev() {

        let Some(state) = windows.get_mut(id) else {

            continue;

        };

        let effect = anim.effect(id, now);

        let first = out.len();

        window_elements(&mut out, renderer, &state.window, r, effect, gliding);

        let clip = framed.then(|| corner_clip(r, deco)).flatten();

        if let Some(clip) = clip {

            clip_window(&mut out, first, &state.window, clip);

        }

        if framed && deco.border > 0 {

            let color = if focused == Some(id) {

                deco.focused.0

            } else {

                deco.unfocused.0

            };

            let alpha = effect.map_or(1.0, |e| e.progress);

            let borders = &mut state.borders;

            let first = out.len();

            border_elements(&mut out, borders, r, deco, color, alpha);

            if let Some(clip) = clip {

                ring_borders(&mut out, first, clip, deco.border as i32);

            }

        }

    }

    for (g, frame, r) in ghosts.into_iter().rev() {

        out.extend(ghost_element(frame, r, anim.ghost_effect(g, now), deco));

    }

    if let Some(output) = output {

        crate::layers::elements(&mut out, renderer, output, Layer::Bottom);

        crate::layers::elements(&mut out, renderer, output, Layer::Background);

    }

    out

}

/// Draws `window` filling `r`. In a planned move a buffer bigger than `r` is

/// cropped and one smaller has its last row and column stretched over the

/// rest, keeping content aligned with its neighbours. A gliding window is

/// scaled instead, so the client resizing mid-glide does not jump.

fn window_elements(

    out: &mut Vec<Draw>,

    renderer: &mut VulkanRenderer,

    window: &Window,

    r: Rect,

    effect: Option<Effect>,

    scaled: bool,

) {

    let Some(((x, y), (w, h))) = pixels(r) else {

        return;

    };

    let geo = window.geometry();

    let loc = Point::<i32, Physical>::from((x - geo.loc.x, y - geo.loc.y));

    let alpha = effect.map_or(1.0, |e| e.progress);

    let elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>> =

        window.render_elements(renderer, loc, Scale::from(1.0), alpha);

    if let Some(effect) = effect {

        effect_elements(out, renderer, window, elems, ((x, y), (w, h)), effect);

        return;

    }

    if scaled && geo.size.w > 0 && geo.size.h > 0 {

        let scale = Scale::from((

            f64::from(w) / f64::from(geo.size.w),

            f64::from(h) / f64::from(geo.size.h),

        ));

        let origin = Point::<i32, Physical>::from((x, y));

        out.extend(

            elems

                .into_iter()

                .map(|e| Draw::Rescaled(RescaleRenderElement::from_element(e, origin, scale))),

        );

        return;

    }

    if (w, h) == (geo.size.w, geo.size.h) {

        out.extend(elems.into_iter().map(Draw::Surface));

        return;

    }

    let crop = Rectangle::new((x, y).into(), (w, h).into());

    out.extend(

        elems

            .into_iter()

            .filter_map(|e| CropRenderElement::from_element(e, 1.0, crop))

            .map(Draw::Cropped),

    );

    let Some(root) = crate::wm::root(window) else {

        return;

    };

    let context = renderer.context_id();

    let Some((tex, scale, transform)) = with_renderer_surface_state(&root, |s| {

        s.texture::<VulkanTexture>(context.clone())

            .cloned()

            .map(|t| (t, s.buffer_scale(), s.buffer_transform()))

    })

    .flatten() else {

        return;

    };

    let (gw, gh) = (geo.size.w, geo.size.h);

    let (cw, ch) = (w.min(gw), h.min(gh));

    let (gx, gy) = (geo.loc.x as f64, geo.loc.y as f64);

    let mut strip = |src: Rectangle<f64, Logical>, at: (i32, i32), size: (i32, i32)| {

        if size.0 >= 1 && size.1 >= 1 {

            out.push(texture(&context, &tex, scale, transform, src, at, size));

        }

    };

    let right = gx + f64::from(gw) - 1.0;

    let bottom = gy + f64::from(gh) - 1.0;

    strip(

        Rectangle::new((right, gy).into(), (1.0, f64::from(ch)).into()),

        (x + gw, y),

        (w - gw, ch),

    );

    strip(

        Rectangle::new((gx, bottom).into(), (f64::from(cw), 1.0).into()),

        (x, y + gh),

        (cw, h - gh),

    );

    strip(

        Rectangle::new((right, bottom).into(), (1.0, 1.0).into()),

        (x + gw, y + gh),

        (w - gw, h - gh),

    );

}

/// Four strips just outside `r`, in the gap, so the client keeps its size.

/// With rounded corners they reach in by the largest radius, to cover the

/// band the ring curves through inside the window's corners.

fn border_elements(

    out: &mut Vec<Draw>,

    borders: &mut Option<[SolidColorBuffer; 4]>,

    r: Rect,

    deco: &Decoration,

    color: [f32; 4],

    alpha: f32,

) {

    let Some(((x, y), (w, h))) = pixels(r) else {

        return;

    };

    let b = deco.border as i32;

    let reach = deco.radius.0.into_iter().max().unwrap_or(0) as i32;

    let reach = reach.min(w / 2).min(h / 2);

    let strips = [

        ((x - b, y - b), (w + 2 * b, b + reach)),

        ((x - b, y + h - reach), (w + 2 * b, b + reach)),

        ((x - b, y + reach), (b + reach, h - 2 * reach)),

        ((x + w - reach, y + reach), (b + reach, h - 2 * reach)),

    ];

    let buffers = borders

        .get_or_insert_with(|| std::array::from_fn(|_| SolidColorBuffer::new((0, 0), color)));

    for (buffer, (at, size)) in buffers.iter_mut().zip(strips) {

        buffer.update(size, color);

        out.push(Draw::Border(SolidColorRenderElement::from_buffer(

            buffer,

            at,

            1.0,

            alpha,

            Kind::Unspecified,

        )));

    }

}

/// Snaps a logical rect to whole pixels by rounding its edges, so neighbours

/// that share an edge stay flush.

fn pixels(r: Rect) -> Option<((i32, i32), (i32, i32))> {

    let (x, y) = (r.x.round() as i32, r.y.round() as i32);

    let w = r.right().round() as i32 - x;

    let h = r.bottom().round() as i32 - y;

    (w >= 1 && h >= 1).then_some(((x, y), (w, h)))

}

fn texture(

    context: &ContextId<VulkanTexture>,

    texture: &VulkanTexture,

    scale: i32,

    transform: Transform,

    src: Rectangle<f64, Logical>,

    at: (i32, i32),

    size: (i32, i32),

) -> Draw {

    Draw::Texture(TextureRenderElement::from_static_texture(

        Id::new(),

        context.clone(),

        Point::<f64, Physical>::from((f64::from(at.0), f64::from(at.1))),

        texture.clone(),

        scale,

        transform,

        None,

        Some(src),

        Some(Size::from(size)),

        None,

        Kind::Unspecified,

    ))

}

/// A window in a spawn transition. Its root surface goes through the effect

/// shader, clamped to fill its rect, and its subsurfaces and popups fade with it.

fn effect_elements(

    out: &mut Vec<Draw>,

    renderer: &mut VulkanRenderer,

    window: &Window,

    elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>>,

    (at, size): ((i32, i32), (i32, i32)),

    effect: Effect,

) {

    let Some(root) = crate::wm::root(window) else {

        return;

    };

    let root_id = Id::from_wayland_resource(&root);

    let crop = Rectangle::new(at.into(), size.into());

    let context = renderer.context_id();

    let root_tex = with_renderer_surface_state(&root, |s| {

        s.texture::<VulkanTexture>(context.clone())

            .cloned()

            .map(|t| (t, s.buffer_scale(), s.buffer_transform()))

    })

    .flatten();

    out.extend(

        elems

            .into_iter()

            .filter(|e| root_tex.is_none() || *e.id() != root_id)

            .filter_map(|e| CropRenderElement::from_element(e, 1.0, crop))

            .map(Draw::Cropped),

    );

    if let Some((tex, scale, transform)) = root_tex {

        let geo = window.geometry();

        let src = Rectangle::new(

            geo.loc.to_f64(),

            (f64::from(size.0), f64::from(size.1)).into(),

        );

        out.push(Draw::Effect(EffectElement::new(

            &tex, scale, transform, src, at, size, effect,

        )));

    }

}

/// A texture drawn through the transition hook in the effect shader.

pub struct EffectElement {

    id: Id,

    texture: VulkanTexture,

    src: Rectangle<f64, Buffer>,

    geometry: Rectangle<i32, Physical>,

    transform: Transform,

    effect: Effect,

}

impl EffectElement {

    fn new(

        texture: &VulkanTexture,

        scale: i32,

        transform: Transform,

        src: Rectangle<f64, Logical>,

        at: (i32, i32),

        size: (i32, i32),

        effect: Effect,

    ) -> Self {

        let bounds = texture.size().to_logical(scale, transform).to_f64();

        Self {

            id: Id::new(),

            texture: texture.clone(),

            src: src.to_buffer(f64::from(scale), transform, &bounds),

            geometry: Rectangle::new(at.into(), size.into()),

            transform,

            effect,

        }

    }

}

impl Element for EffectElement {

    fn id(&self) -> &Id {

        &self.id

    }

    fn current_commit(&self) -> CommitCounter {

        CommitCounter::default()

    }

    fn src(&self) -> Rectangle<f64, Buffer> {

        self.src

    }

    fn geometry(&self, _scale: Scale<f64>) -> Rectangle<i32, Physical> {

        self.geometry

    }

    fn transform(&self) -> Transform {

        self.transform

    }

}

impl RenderElement<VulkanRenderer> for EffectElement {

    fn draw(

        &self,

        frame: &mut VulkanFrame<'_, '_>,

        src: Rectangle<f64, Buffer>,

        dst: Rectangle<i32, Physical>,

        damage: &[Rectangle<i32, Physical>],

        _opaque_regions: &[Rectangle<i32, Physical>],

        _cache: Option<&UserDataMap>,

    ) -> Result<(), monolith_render_vk::Error> {

        frame.render_effect(

            &self.texture,

            src,

            dst,

            damage,

            self.transform,

            1.0,

            self.effect,

        )

    }

}

fn ghost_element(frame: &LastFrame, r: Rect, effect: Effect, deco: &Decoration) -> Option<Draw> {

    let (at, size) = pixels(r)?;

    let src = Rectangle::new(

        frame.geometry.loc.to_f64(),

        (f64::from(size.0), f64::from(size.1)).into(),

    );

    let ghost = Draw::Effect(EffectElement::new(

        &frame.texture,

        frame.scale,

        frame.transform,

        src,

        at,

        size,

        effect,

    ));

    Some(match corner_clip(r, deco) {

        Some(clip) => Draw::Clipped(ClipElement::new(ghost, clip)),

        None => ghost,

    })