M3: STL/OBJ import with mesh validation, mass/COM/inertia, material database, RON scene with content-addressed blobs and v0->v1 migration. M4: deterministic heightmap terrain, trimesh colliders, wgpu renderer with instancing and depth, winit app with 1 kHz physics, fly camera, on-screen metrics overlay and per-frame CSV/dev logs. Docs: UI, logging, network and headless CLI plans.
135 lines
3.5 KiB
Rust
135 lines
3.5 KiB
Rust
//! Headless rendering tests.
|
|
|
|
use super::*;
|
|
use crate::{Camera, Gpu, Instance, MeshData, Scene};
|
|
|
|
const SIZE: u32 = 256;
|
|
const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8UnormSrgb;
|
|
|
|
fn setup(size: (u32, u32)) -> (Gpu, Renderer) {
|
|
let gpu = Gpu::headless().expect("headless adapter");
|
|
let renderer = Renderer::new(gpu.device(), gpu.queue(), FORMAT, size).expect("renderer");
|
|
(gpu, renderer)
|
|
}
|
|
|
|
fn sloped_terrain() -> Scene {
|
|
let mesh = MeshData {
|
|
vertices: vec![
|
|
[-2.0, -2.0, -0.6],
|
|
[2.0, -2.0, 0.6],
|
|
[2.0, 2.0, 0.6],
|
|
[-2.0, 2.0, -0.6],
|
|
],
|
|
indices: vec![0, 1, 2, 0, 2, 3],
|
|
};
|
|
let mut scene = Scene::new(mesh);
|
|
scene.instances.push(Instance::box_at(
|
|
[0.0, 0.0, 1.2],
|
|
[1.0, 1.0, 1.0],
|
|
[0.9, 0.4, 0.2, 1.0],
|
|
));
|
|
scene
|
|
}
|
|
|
|
fn orbit_camera() -> Camera {
|
|
Camera::look_at([4.0, -6.0, 5.0], [0.0, 0.0, 0.0], [0.0, 0.0, 1.0])
|
|
.with_projection(0.9, 1.0, 0.1, 100.0)
|
|
}
|
|
|
|
fn pixel_at(pixels: &[u8], size: (u32, u32), x: u32, y: u32) -> [u8; 4] {
|
|
let index = (y * size.0 + x) as usize * 4;
|
|
[
|
|
pixels[index],
|
|
pixels[index + 1],
|
|
pixels[index + 2],
|
|
pixels[index + 3],
|
|
]
|
|
}
|
|
|
|
#[test]
|
|
fn renders_terrain_and_box() {
|
|
let (_gpu, mut renderer) = setup((SIZE, SIZE));
|
|
let scene = sloped_terrain();
|
|
renderer.draw(&scene, &orbit_camera()).expect("draw");
|
|
let pixels = renderer.pixels().expect("pixels");
|
|
assert_eq!(pixels.len(), (SIZE * SIZE * 4) as usize);
|
|
|
|
let corner = pixel_at(&pixels, (SIZE, SIZE), 2, 2);
|
|
let centre = pixel_at(&pixels, (SIZE, SIZE), SIZE / 2, SIZE / 2);
|
|
assert_ne!(
|
|
corner, centre,
|
|
"the scene must cover the centre of the frame"
|
|
);
|
|
|
|
let covered = pixels
|
|
.as_chunks::<4>()
|
|
.0
|
|
.iter()
|
|
.filter(|pixel| {
|
|
pixel
|
|
.iter()
|
|
.zip(corner.iter())
|
|
.any(|(channel, reference)| channel.abs_diff(*reference) > 8)
|
|
})
|
|
.count();
|
|
assert!(
|
|
covered > (SIZE * SIZE / 10) as usize,
|
|
"only {covered} pixels differ from the corner"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn resize_reallocates_the_pixel_buffer() {
|
|
let (_gpu, mut renderer) = setup((SIZE, SIZE));
|
|
let scene = sloped_terrain();
|
|
renderer.draw(&scene, &orbit_camera()).expect("first draw");
|
|
renderer.resize((64, 96)).expect("resize");
|
|
assert_eq!(renderer.size(), (64, 96));
|
|
renderer.draw(&scene, &orbit_camera()).expect("second draw");
|
|
let pixels = renderer.pixels().expect("pixels");
|
|
assert_eq!(pixels.len(), (64 * 96 * 4) as usize);
|
|
}
|
|
|
|
#[test]
|
|
fn zero_size_target_is_skipped() {
|
|
let (_gpu, mut renderer) = setup((SIZE, SIZE));
|
|
let scene = sloped_terrain();
|
|
renderer.resize((0, 0)).expect("resize to zero");
|
|
renderer
|
|
.draw(&scene, &orbit_camera())
|
|
.expect("skipped draw");
|
|
assert!(renderer.pixels().expect("pixels").is_empty());
|
|
renderer.resize((32, 32)).expect("resize back");
|
|
renderer
|
|
.draw(&scene, &orbit_camera())
|
|
.expect("draw after resize");
|
|
assert_eq!(
|
|
renderer.pixels().expect("pixels").len(),
|
|
(32 * 32 * 4) as usize
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn near_box_covers_far_box() {
|
|
let (_gpu, mut renderer) = setup((SIZE, SIZE));
|
|
let mut scene = Scene::new(MeshData::default());
|
|
scene.instances.push(Instance::box_at(
|
|
[0.0, 0.0, 0.0],
|
|
[2.0, 2.0, 2.0],
|
|
[1.0, 0.0, 0.0, 1.0],
|
|
));
|
|
scene.instances.push(Instance::box_at(
|
|
[0.0, 4.0, 0.0],
|
|
[2.0, 2.0, 2.0],
|
|
[0.0, 0.0, 1.0, 1.0],
|
|
));
|
|
let camera = Camera::look_at([0.0, -8.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 1.0])
|
|
.with_projection(0.9, 1.0, 0.1, 100.0);
|
|
renderer.draw(&scene, &camera).expect("draw");
|
|
let pixels = renderer.pixels().expect("pixels");
|
|
let centre = pixel_at(&pixels, (SIZE, SIZE), SIZE / 2, SIZE / 2);
|
|
assert!(
|
|
centre[0] > centre[2],
|
|
"near red box should cover the far blue one: {centre:?}"
|
|
);
|
|
}
|