monolith

//! Renders small scenes offscreen and checks pixels. Runs on whatever Vulkan

//! driver is available. `nix flake check` forces lavapipe.

use monolith_render_vk::{Clip, VulkanImage, VulkanRenderer, VulkanTexture};

use smithay::backend::allocator::Fourcc;

use smithay::backend::renderer::{

    Bind, Color32F, ExportMem, Frame, ImportMem, Offscreen, Renderer,

};

use smithay::utils::{Physical, Rectangle, Transform};

const W: i32 = 64;

const H: i32 = 64;

type Pixel = [u8; 4];

const RED: Pixel = [255, 0, 0, 255];

const GREEN: Pixel = [0, 255, 0, 255];

const WHITE: Pixel = [255, 255, 255, 255];

const BLACK: Pixel = [0, 0, 0, 255];

struct Scene {

    renderer: VulkanRenderer,

    image: VulkanImage,

}

impl Scene {

    fn new() -> Self {

        let mut renderer = VulkanRenderer::new().expect("no usable Vulkan device");

        let image = renderer

            .create_buffer(Fourcc::Argb8888, (W, H).into())

            .unwrap();

        Self { renderer, image }

    }

    fn draw(

        &mut self,

        transform: Transform,

        f: impl FnOnce(&mut monolith_render_vk::VulkanFrame<'_, '_>),

    ) {

        let mut target = self.renderer.bind(&mut self.image).unwrap();

        let mut frame = self

            .renderer

            .render(&mut target, (W, H).into(), transform)

            .unwrap();

        f(&mut frame);

        frame.finish().unwrap().wait().unwrap();

    }

    /// Pixels as RGBA, whatever the image's byte order.

    fn pixels(&mut self) -> Vec<Pixel> {

        let target = self.renderer.bind(&mut self.image).unwrap();

        let mapping = self

            .renderer

            .copy_framebuffer(

                &target,

                Rectangle::from_size((W, H).into()),

                Fourcc::Abgr8888,

            )

            .unwrap();

        self.renderer

            .map_texture(&mapping)

            .unwrap()

            .as_chunks::<4>()

            .0

            .to_vec()

    }

    fn texture(&mut self, size: (i32, i32), rgba: &[Pixel]) -> VulkanTexture {

        let bytes: Vec<u8> = rgba.iter().flatten().copied().collect();

        self.renderer

            .import_memory(&bytes, Fourcc::Abgr8888, size.into(), false)

            .unwrap()

    }

}

fn at(pixels: &[Pixel], x: i32, y: i32) -> Pixel {

    pixels[(y * W + x) as usize]

}

fn full() -> Rectangle<i32, Physical> {

    Rectangle::from_size((W, H).into())

}

fn rgba(p: Pixel) -> Color32F {

    p.map(|c| f32::from(c) / 255.0).into()

}

#[test]

fn partial_clear_keeps_previous_contents() {

    let mut s = Scene::new();

    s.draw(Transform::Normal, |f| {

        f.clear(rgba(RED), &[full()]).unwrap()

    });

    s.draw(Transform::Normal, |f| {

        f.clear(

            rgba(GREEN),

            &[Rectangle::new((0, 0).into(), (32, 64).into())],

        )

        .unwrap()

    });

    let px = s.pixels();

    assert_eq!(at(&px, 0, 0), GREEN);

    assert_eq!(at(&px, 63, 0), RED);

}

#[test]

fn alpha_blends_premultiplied() {

    let mut s = Scene::new();

    let tex = s.texture((1, 1), &[WHITE]);

    s.draw(Transform::Normal, |f| {

        f.clear(rgba(BLACK), &[full()]).unwrap();

        f.render_texture_from_to(

            &tex,

            Rectangle::from_size((1.0, 1.0).into()),

            full(),

            &[full()],

            &[],

            Transform::Normal,

            0.5,

        )

        .unwrap();

    });

    let p = at(&s.pixels(), 32, 32);

    assert!(

        (127..=129).contains(&p[0]) && p[0] == p[1] && p[1] == p[2],

        "{p:?}"

    );

}

#[test]

fn output_transform_moves_content() {

    let mut s = Scene::new();

    s.draw(Transform::_180, |f| {

        f.clear(rgba(BLACK), &[full()]).unwrap();

        let dst = Rectangle::new((0, 0).into(), (16, 16).into());

        f.draw_solid(dst, &[Rectangle::from_size(dst.size)], rgba(GREEN))

            .unwrap();

    });

    let px = s.pixels();

    assert_eq!(at(&px, 0, 0), BLACK);

    assert_eq!(at(&px, 63, 63), GREEN);

}

#[test]

fn solid_fill_in_the_corner_keeps_its_colour() {

    let mut s = Scene::new();

    s.draw(Transform::Normal, |f| {

        f.clear(rgba(BLACK), &[full()]).unwrap();

        let dst = Rectangle::new((48, 48).into(), (16, 16).into());

        f.draw_solid(dst, &[Rectangle::from_size(dst.size)], rgba(RED))

            .unwrap();

    });

    assert_eq!(at(&s.pixels(), 56, 56), RED);

}

/// The radius follows its corner through an output rotation.

#[test]

fn clip_radius_stays_on_its_corner_when_rotated() {

    let corners = [(0, 0), (W - 1, 0), (0, H - 1), (W - 1, H - 1)];

    let mut s = Scene::new();

    s.draw(Transform::_90, |f| {

        f.clear(rgba(BLACK), &[full()]).unwrap();

        let dst = Rectangle::new((0, 0).into(), (4, 4).into());

        f.draw_solid(dst, &[Rectangle::from_size(dst.size)], rgba(GREEN))

            .unwrap();

    });

    let px = s.pixels();

    let top_left = corners

        .into_iter()

        .find(|&(x, y)| at(&px, x, y) == GREEN)

        .unwrap();

    s.draw(Transform::_90, |f| {

        f.clear(rgba(BLACK), &[full()]).unwrap();

        f.set_clip(Some(Clip {

            rect: full(),

            radii: [20.0, 0.0, 0.0, 0.0],

            ring: 0.0,

        }));

        f.draw_solid(full(), &[full()], rgba(GREEN)).unwrap();

    });

    let px = s.pixels();

    for (x, y) in corners {

        let expected = if (x, y) == top_left { BLACK } else { GREEN };

        assert_eq!(at(&px, x, y), expected, "corner {x},{y}");

    }

    assert_eq!(at(&px, W / 2, H / 2), GREEN);

}

/// Draws arrive in the rotated space, which for a quarter turn on a wide

/// output is tall, so its far corner has to land inside the framebuffer.

#[test]

fn quarter_turn_on_a_wide_output_fills_it() {

    let (fw, fh) = (64, 32);

    let mut renderer = VulkanRenderer::new().expect("no usable Vulkan device");

    let mut image = renderer

        .create_buffer(Fourcc::Argb8888, (fw, fh).into())

        .unwrap();

    for transform in [Transform::_90, Transform::_270, Transform::Flipped90] {

        let mut target = renderer.bind(&mut image).unwrap();

        let mut frame = renderer

            .render(&mut target, (fw, fh).into(), transform)

            .unwrap();

        let area = Rectangle::from_size((fh, fw).into());

        frame.clear(rgba(BLACK), &[area]).unwrap();

        let near = Rectangle::new((0, 0).into(), (8, 8).into());

        let far = Rectangle::new((fh - 8, fw - 8).into(), (8, 8).into());

        frame

            .draw_solid(near, &[Rectangle::from_size(near.size)], rgba(GREEN))

            .unwrap();

        frame

            .draw_solid(far, &[Rectangle::from_size(far.size)], rgba(RED))

            .unwrap();

        frame.finish().unwrap().wait().unwrap();

        drop(target);

        let target = renderer.bind(&mut image).unwrap();

        let mapping = renderer

            .copy_framebuffer(

                &target,

                Rectangle::from_size((fw, fh).into()),

                Fourcc::Abgr8888,

            )

            .unwrap();

        let px = renderer

            .map_texture(&mapping)

            .unwrap()

            .as_chunks::<4>()

            .0

            .to_vec();

        let at = |x: i32, y: i32| px[(y * fw + x) as usize];

        let corners = [(0, 0), (fw - 1, 0), (0, fh - 1), (fw - 1, fh - 1)];

        let green: Vec<_> = corners

            .iter()

            .filter(|&&(x, y)| at(x, y) == GREEN)

            .collect();

        let red: Vec<_> = corners.iter().filter(|&&(x, y)| at(x, y) == RED).collect();

        assert_eq!((green.len(), red.len()), (1, 1), "{transform:?}");

        let (g, r) = (green[0], red[0]);

        assert!(g.0 != r.0 && g.1 != r.1, "{transform:?} not diagonal");

    }

}

#[test]

fn queued_uploads_to_one_texture_land_in_order() {

    let mut s = Scene::new();

    let size = (2, 2);

    let bytes = |p: Pixel| -> Vec<u8> { [p; 4].iter().flatten().copied().collect() };

    let tex = s.texture(size, &[RED; 4]);

    for colour in [WHITE, GREEN] {

        s.renderer

            .update_memory(&tex, &bytes(colour), Rectangle::from_size(size.into()))

            .unwrap();

    }

    let read = s

        .renderer

        .copy_texture(&tex, Rectangle::from_size(size.into()), Fourcc::Abgr8888)

        .unwrap();

    assert_eq!(s.renderer.map_texture(&read).unwrap()[..4], GREEN);

    s.renderer

        .update_memory(&tex, &bytes(WHITE), Rectangle::from_size(size.into()))

        .unwrap();

    s.renderer

        .update_memory(&tex, &bytes(RED), Rectangle::from_size(size.into()))

        .unwrap();

    s.draw(Transform::Normal, |f| {

        f.render_texture_from_to(

            &tex,

            Rectangle::from_size((2.0, 2.0).into()),

            full(),

            &[full()],

            &[],

            Transform::Normal,

            1.0,

        )

        .unwrap();

    });

    assert_eq!(at(&s.pixels(), 32, 32), RED);

}