sim-engine 0.4.1

A validated high-performance visualization engine for simulations
Documentation
//! Actual retained/generated draw accounting and optional timing-hook regressions.

use super::*;

pub(in crate::renderer) fn assert_gpu_scene_timing_and_upload_contract(
    device: &wgpu::Device,
    queue: &wgpu::Queue,
    format: wgpu::TextureFormat,
) {
    let identity = Arc::new(());
    let target = surface::test_target(device, &identity, format, 64, 64);
    let mut renderer = Mesh3dRenderer::new(device, format);
    let mut timing = gpu_timing::GpuTimingCollector::new(device, queue, true);
    let camera = 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();
    let triangle = Mesh3d::new(
        vec![
            Vec3::new(-0.5, -0.5, 0.0).unwrap(),
            Vec3::new(0.5, -0.5, 0.0).unwrap(),
            Vec3::new(0.0, 0.5, 0.0).unwrap(),
        ],
        vec![0, 1, 2],
    )
    .unwrap();
    let mesh = create_retained_mesh(device, queue, Arc::clone(&identity), triangle).unwrap();
    let mut scene = Scene3d::new(Color::BLACK).unwrap();
    for _ in 0..17 {
        scene
            .try_push(
                &mesh,
                Transform3d::IDENTITY,
                MeshStyle3d::surface(SurfaceStyle3d::opaque(Color::WHITE).unwrap()),
            )
            .unwrap();
    }
    let expected_bytes =
        std::mem::size_of::<Camera3dUniform>() + 17 * std::mem::size_of::<MeshInstanceGpu>();
    let native = Mesh3dRenderBudget::default().with_surface_policy(SurfaceRasterization3d::Native);
    let old_gpu = renderer.retained_frame_gpu_bytes();
    let first = renderer
        .render_scene3d_with_timing(
            device,
            queue,
            &identity,
            &target,
            &scene,
            camera,
            native,
            Some(&mut timing),
        )
        .unwrap();
    assert_eq!(first.uploaded_bytes(), expected_bytes);
    assert_eq!(first.draw_call_count(), 1);
    assert_eq!(first.upload_calls(), 2);
    assert_eq!(first.buffer_allocation_count(), 1);
    assert_eq!(renderer.edge_object_capacity, INITIAL_INSTANCE_CAPACITY);
    assert_eq!(renderer.edge_object_bytes.capacity(), 0);
    assert_eq!(
        first.upload(),
        first.preflight_duration() + first.staging_upload_duration()
    );
    assert_eq!(
        first.retained_frame_cpu_bytes(),
        first.staging_capacity_bytes()
    );
    assert_eq!(
        first.retained_frame_cpu_bytes(),
        first.peak_frame_cpu_bytes()
    );
    assert_eq!(
        first.retained_frame_gpu_bytes(),
        renderer.retained_frame_gpu_bytes()
    );
    assert_eq!(
        first.peak_frame_gpu_bytes(),
        old_gpu + renderer.instance_buffer.size() as usize
    );
    let reused = renderer
        .render_scene3d_with_timing(
            device,
            queue,
            &identity,
            &target,
            &scene,
            camera,
            native,
            Some(&mut timing),
        )
        .unwrap();
    assert_eq!(reused.uploaded_bytes(), 0);
    assert_eq!(reused.draw_call_count(), 1);
    assert_eq!(reused.upload_calls(), 0);
    assert_eq!(reused.buffer_allocation_count(), 0);
    assert_eq!(
        reused.retained_frame_gpu_bytes(),
        first.retained_frame_gpu_bytes()
    );
    assert_eq!(
        reused.peak_frame_gpu_bytes(),
        reused.retained_frame_gpu_bytes()
    );
    assert_eq!(
        reused.peak_frame_cpu_bytes(),
        reused.retained_frame_cpu_bytes()
    );

    let source = Mesh3d::with_attributes(
        vec![
            Vec3::new(-1.5, -0.5, 0.0).unwrap(),
            Vec3::new(0.5, -0.5, 0.0).unwrap(),
            Vec3::new(0.5, 0.5, 0.0).unwrap(),
            Vec3::new(-1.5, 0.5, 0.0).unwrap(),
        ],
        vec![0, 1, 2, 0, 2, 3],
        vec![],
        crate::Mesh3dAttributes::new()
            .with_vertex_colors(vec![Color::WHITE; 4])
            .unwrap()
            .with_normals(vec![Vec3::Z; 4])
            .unwrap(),
    )
    .unwrap();
    let mesh = create_retained_mesh(device, queue, Arc::clone(&identity), source).unwrap();
    let mut crossing_scene = Scene3d::new(Color::BLACK).unwrap();
    crossing_scene
        .try_push(
            &mesh,
            Transform3d::IDENTITY,
            MeshStyle3d::surface(
                SurfaceStyle3d::opaque(Color::WHITE)
                    .unwrap()
                    .with_lighting(SurfaceLighting3d::Lambert),
            ),
        )
        .unwrap();
    let generated = renderer
        .render_scene3d_with_timing(
            device,
            queue,
            &identity,
            &target,
            &crossing_scene,
            camera,
            Mesh3dRenderBudget::default(),
            Some(&mut timing),
        )
        .unwrap();
    assert!(generated.preflight().generated_vertex_count() > 0);
    assert_eq!(generated.upload_calls(), 4);
    assert_eq!(generated.buffer_allocation_count(), 3);
    assert_eq!(
        generated.uploaded_bytes(),
        std::mem::size_of::<MeshInstanceGpu>() + generated.preflight().generated_upload_bytes()
    );
    assert_eq!(
        generated.staging_capacity_bytes(),
        generated.retained_frame_cpu_bytes()
    );
    assert!(generated.peak_frame_cpu_bytes() >= generated.staging_capacity_bytes());
    let before = timing.statistics();
    assert!(
        renderer
            .render_scene3d_with_timing(
                device,
                queue,
                &identity,
                &target,
                &crossing_scene,
                camera,
                Mesh3dRenderBudget::new(0, 0, 0),
                Some(&mut timing),
            )
            .is_err()
    );
    assert_eq!(timing.statistics().submitted(), before.submitted());
    assert_eq!(timing.statistics().pending(), before.pending());
    let reports = [first, reused, generated];
    let mut seen = [false; 3];
    let deadline = Instant::now() + Duration::from_secs(20);
    while timing.statistics().pending() > 0 {
        for sample in timing.collect(device).samples() {
            let index = reports
                .iter()
                .position(|report| report.gpu_timing_id() == Some(sample.id()))
                .expect("GPU timing must match an actual submitted 3D report");
            assert_eq!(sample.source(), GpuTimingSource::Scene3d);
            assert!(!seen[index]);
            seen[index] = true;
        }
        assert!(Instant::now() < deadline, "timed 3D reports did not finish");
        std::thread::yield_now();
    }
    assert_eq!(seen, [true; 3]);
    assert_eq!(timing.statistics().map_failures(), 0);
    assert_eq!(timing.statistics().invalid_samples(), 0);
    assert_eq!(timing.statistics().poll_failures(), 0);
}