sim-engine 0.4.0

A validated high-performance visualization engine for simulations
Documentation
use super::*;

fn camera() -> Camera3d {
    Camera3d::look_at(
        Vec3::new(0.0, 0.0, 3.0).unwrap(),
        Vec3::ZERO,
        Vec3::Y,
        Projection3d::orthographic(world(2.0), 1.0, world(0.5), world(8.0)).unwrap(),
    )
    .unwrap()
}

fn textured_source() -> Mesh3d {
    Mesh3d::textured(
        vec![
            Vec3::new(-0.8, -0.5, 0.0).unwrap(),
            Vec3::new(0.8, -0.5, 0.0).unwrap(),
            Vec3::new(0.0, 0.8, 0.0).unwrap(),
        ],
        vec![crate::TextureCoordinate2d::new(0.25, 0.5).unwrap(); 3],
        vec![0, 1, 2],
        vec![],
    )
    .unwrap()
}

pub(super) fn assert_gpu_sort_budget(
    device: &wgpu::Device,
    queue: &wgpu::Queue,
    format: wgpu::TextureFormat,
) {
    let identity = Arc::new(());
    let mut renderer = Mesh3dRenderer::new(device, format);
    let target = surface::test_target(device, &identity, format, 64, 64);
    let background = Scene3d::with_alpha_background(Color::rgba(0.25, 0.5, 0.75, 0.5)).unwrap();
    renderer
        .render_scene3d(
            device,
            queue,
            &identity,
            &target,
            &background,
            camera(),
            Mesh3dRenderBudget::default(),
        )
        .unwrap();
    let before = surface::test_read_pixels(device, queue, &target);
    let mesh =
        create_retained_mesh(device, queue, Arc::clone(&identity), textured_source()).unwrap();
    let mut scene = Scene3d::with_alpha_background(Color::rgba(0.0, 0.0, 0.0, 0.0)).unwrap();
    let id = scene
        .try_push(
            &mesh,
            Transform3d::IDENTITY,
            MeshStyle3d::surface(SurfaceStyle3d::blend(Color::rgba(1.0, 0.0, 0.0, 0.5)).unwrap()),
        )
        .unwrap();
    let exact = std::mem::size_of::<material::SurfaceDraw>();
    for limit in [0, exact - 1] {
        assert_eq!(
            renderer.render_scene3d(
                device,
                queue,
                &identity,
                &target,
                &scene,
                camera(),
                Mesh3dRenderBudget::default().with_max_sorting_bytes(limit)
            ),
            Err(Mesh3dRenderError::SortingBudgetExceeded {
                limit,
                actual: exact
            })
        );
        assert_eq!(surface::test_read_pixels(device, queue, &target), before);
    }
    let report = renderer
        .render_scene3d(
            device,
            queue,
            &identity,
            &target,
            &scene,
            camera(),
            Mesh3dRenderBudget::default().with_max_sorting_bytes(exact),
        )
        .unwrap();
    assert_eq!(report.preflight().sorting_capacity_bytes(), exact);
    scene
        .set_style(
            id,
            MeshStyle3d::surface(SurfaceStyle3d::mask(Color::WHITE, 0.5).unwrap()),
        )
        .unwrap();
    let report = renderer
        .render_scene3d(
            device,
            queue,
            &identity,
            &target,
            &scene,
            camera(),
            Mesh3dRenderBudget::default().with_max_sorting_bytes(0),
        )
        .unwrap();
    assert_eq!(report.preflight().sorting_capacity_bytes(), 0);
}

pub(super) fn assert_gpu_alpha_recovery(
    source_device: &wgpu::Device,
    source_queue: &wgpu::Queue,
    recovery_device: &wgpu::Device,
    recovery_queue: &wgpu::Queue,
) {
    let format = wgpu::TextureFormat::Rgba8UnormSrgb;
    let identity = Arc::new(());
    let recovered_identity = Arc::new(());
    let mut renderer = Mesh3dRenderer::new(source_device, format);
    let mut recovered_renderer = Mesh3dRenderer::new(recovery_device, format);
    let source_target = surface::test_target(source_device, &identity, format, 64, 64);
    let recovery_target =
        surface::test_target(recovery_device, &recovered_identity, format, 64, 64);
    let pixels = vec![255, 128, 64, 128, 0, 255, 0, 0];
    assert!(matches!(
        texture::create_texture(
            source_device,
            source_queue,
            &identity,
            &renderer.textures.layout,
            2,
            1,
            pixels.clone(),
            ImageBudget::default()
        ),
        Err(Texture3dError::NonOpaquePixel { texel: 0 })
    ));
    let texture = texture::create_texture_with_alpha(
        source_device,
        source_queue,
        &identity,
        &renderer.textures.layout,
        2,
        1,
        pixels.clone(),
        ImageBudget::default(),
    )
    .unwrap();
    assert!(texture.preserves_alpha());
    assert!(matches!(
        TextureMaterial3d::new(&texture, ImageSampling::Nearest, Color::WHITE),
        Err(Texture3dError::NonOpaquePixel { texel: 0 })
    ));
    let first_material = TextureMaterial3d::with_alpha(
        &texture,
        ImageSampling::Nearest,
        Color::rgba(1.0, 1.0, 1.0, 0.75),
    )
    .unwrap();
    let second_material = TextureMaterial3d::with_alpha(
        &texture,
        ImageSampling::Linear,
        Color::rgba(0.5, 1.0, 1.0, 1.0),
    )
    .unwrap();
    let mesh = create_retained_mesh(
        source_device,
        source_queue,
        Arc::clone(&identity),
        textured_source(),
    )
    .unwrap();
    let first = texture::attach_material(&identity, &mesh, &first_material).unwrap();
    let second = texture::attach_material(&identity, &mesh, &second_material).unwrap();
    let mut scene = Scene3d::with_alpha_background(Color::rgba(0.25, 0.5, 0.75, 0.25)).unwrap();
    let transform = |x| {
        Transform3d::new(
            Vec3::new(x, 0.0, 0.0).unwrap(),
            Rotation3d::IDENTITY,
            Vec3::new(0.5, 0.5, 0.5).unwrap(),
        )
        .unwrap()
    };
    let first_id = scene
        .try_push(
            &first,
            transform(-0.5),
            MeshStyle3d::surface(SurfaceStyle3d::blend(Color::rgba(1.0, 1.0, 1.0, 0.5)).unwrap()),
        )
        .unwrap();
    let second_id = scene
        .try_push(
            &second,
            transform(0.5),
            MeshStyle3d::surface(
                SurfaceStyle3d::mask(Color::WHITE, 0.25)
                    .unwrap()
                    .with_sidedness(SurfaceSidedness3d::FrontOnly),
            ),
        )
        .unwrap();
    let styles = [
        scene.instance(first_id).unwrap().style(),
        scene.instance(second_id).unwrap().style(),
    ];
    renderer
        .render_scene3d(
            source_device,
            source_queue,
            &identity,
            &source_target,
            &scene,
            camera(),
            Mesh3dRenderBudget::default(),
        )
        .unwrap();
    let before = surface::test_read_pixels(source_device, source_queue, &source_target);
    let statistics = scene.statistics();
    let report = restore_scene3d_resources(
        recovery_device,
        recovery_queue,
        &recovered_renderer.textures.layout,
        Arc::clone(&recovered_identity),
        &mut scene,
    )
    .unwrap();
    assert_eq!(report.restored_mesh_count(), 1);
    assert_eq!(report.restored_texture_count(), 1);
    assert_eq!(scene.statistics(), statistics);
    assert_eq!(scene.instance(first_id).unwrap().style(), styles[0]);
    assert_eq!(scene.instance(second_id).unwrap().style(), styles[1]);
    for id in [first_id, second_id] {
        let material = scene.instance(id).unwrap().mesh().material().unwrap();
        assert!(material.texture().preserves_alpha());
        assert_eq!(material.texture().pixels(), pixels);
    }
    assert_eq!(
        scene
            .instance(first_id)
            .unwrap()
            .mesh()
            .material()
            .unwrap()
            .tint(),
        first_material.tint()
    );
    assert_eq!(
        scene
            .instance(second_id)
            .unwrap()
            .mesh()
            .material()
            .unwrap()
            .tint(),
        second_material.tint()
    );
    recovered_renderer
        .render_scene3d(
            recovery_device,
            recovery_queue,
            &recovered_identity,
            &recovery_target,
            &scene,
            camera(),
            Mesh3dRenderBudget::default(),
        )
        .unwrap();
    assert_eq!(
        surface::test_read_pixels(recovery_device, recovery_queue, &recovery_target),
        before
    );
    assert_eq!(texture.pixels(), pixels);
    assert!(texture.belongs_to(&identity));
}