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

};

use smithay::utils::{Physical, Rectangle, Size, 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 BLUE: Pixel = [0, 0, 255, 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 clears_to_a_colour() {

    let mut s = Scene::new();

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

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

    });

    let px = s.pixels();

    assert!(px.iter().all(|&p| p == RED));

}

#[test]

fn solid_fill_respects_its_rectangle() {

    let mut s = Scene::new();

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

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

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

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

            .unwrap();

    });

    let px = s.pixels();

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

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

    assert_eq!(at(&px, 15, 16), BLACK);

    assert_eq!(at(&px, 48, 47), BLACK);

}

#[test]

fn damage_limits_drawing() {

    let mut s = Scene::new();

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

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

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

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

    });

    let px = s.pixels();

    assert_eq!(at(&px, 7, 7), BLUE);

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

}

#[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 textures_sample_with_nearest_filtering() {

    let mut s = Scene::new();

    s.renderer.upscale_filter(TextureFilter::Nearest).unwrap();

    let tex = s.texture((2, 2), &[RED, GREEN, BLUE, WHITE]);

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

    });

    let px = s.pixels();

    assert_eq!(at(&px, 8, 8), RED);

    assert_eq!(at(&px, 56, 8), GREEN);

    assert_eq!(at(&px, 8, 56), BLUE);

    assert_eq!(at(&px, 56, 56), WHITE);

}

#[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 offscreen_images_can_be_sampled() {

    let mut s = Scene::new();

    let mut inner = s

        .renderer

        .create_buffer(Fourcc::Argb8888, Size::from((4, 4)))

        .unwrap();

    {

        let mut t = s.renderer.bind(&mut inner).unwrap();

        let mut f = s

            .renderer

            .render(&mut t, (4, 4).into(), Transform::Normal)

            .unwrap();

        f.clear(rgba(BLUE), &[Rectangle::from_size((4, 4).into())])

            .unwrap();

        f.finish().unwrap().wait().unwrap();

    }

    let tex = inner.texture();

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

        f.render_texture_from_to(

            &tex,

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

            full(),

            &[full()],

            &[],

            Transform::Normal,

            1.0,

        )

        .unwrap();

    });

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

}

#[test]

fn reports_the_device() {

    let r = VulkanRenderer::new().unwrap();

    eprintln!("rendering on {}", r.device_name());

    assert!(!r.device_name().is_empty());

}

#[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);

}