monolith

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

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

use monolith_render_vk::{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);

}