sim-engine 0.4.2

A validated high-performance visualization engine for simulations
Documentation
use super::*;
use crate::{Color, LogicalPixels, LogicalScreenPosition, LogicalScreenVector};

mod certificate;
mod gpu;
mod metadata;
mod targets;
pub(in crate::renderer) use gpu::verify_analytic_primitives;

#[test]
fn conversion_preserves_order_clips_and_rejects_unsupported_commands() {
    use crate::{ScreenScene, ShapeStyle};
    let mut scene = ScreenScene::new(Color::BLACK).unwrap();
    scene
        .try_circle(
            LogicalScreenPosition::new(30.25, 20.5),
            LogicalPixels::new(4.0).unwrap(),
            ShapeStyle::filled(Color::WHITE.with_alpha(0.5)),
        )
        .unwrap();
    scene
        .try_square_rect(
            LogicalScreenPosition::new(17.0, 41.0),
            LogicalScreenVector::new(8.0, 9.0),
            ShapeStyle::filled(Color::WHITE),
        )
        .unwrap();
    let primitives = ScreenPrimitive2d::from_screen_scene(&scene).unwrap();
    assert_eq!(primitives.len(), 2);
    assert_eq!(primitives[0].gpu.anchor, [30.25, -20.5]);
    assert_eq!(primitives[0].gpu.color[3], 0.5);
    assert_eq!(primitives[1].gpu.anchor, [21.0, -45.5]);
    scene
        .try_circle(
            LogicalScreenPosition::new(30.25, 20.5),
            LogicalPixels::new(4.0).unwrap(),
            ShapeStyle::stroked(1.0, Color::WHITE),
        )
        .unwrap();
    assert!(matches!(
        ScreenPrimitive2d::from_screen_scene(&scene),
        Err(ScreenPrimitiveError::UnsupportedCommand { index: 2 })
    ));
}

#[test]
fn analytic_quad_proof_is_viewport_specific_and_preserves_extreme_rejections() {
    use crate::renderer::{CameraUniform, LogicalViewport, screen_camera};
    let primitive = ScreenPrimitive2d::circle(
        LogicalScreenPosition::new(30.25, 20.5),
        LogicalPixels::new(4.0).unwrap(),
        Color::WHITE,
    )
    .unwrap();
    for size in [(1280.0, 800.0), (853.3333, 533.3333), (3840.0, 2160.0)] {
        let viewport = LogicalViewport::new(size.0, size.1).unwrap();
        let uniform = CameraUniform::new(screen_camera(viewport).unwrap(), viewport).unwrap();
        assert!(validation::instances_are_safe(&[primitive.gpu], uniform));
        let mut overflow = uniform;
        overflow.screen_to_clip[0] = f32::MAX;
        assert!(!validation::instances_are_safe(&[primitive.gpu], overflow));
        let mut unsupported_camera = uniform;
        unsupported_camera.world_to_screen_x[0] = 2.0;
        assert!(!validation::instances_are_safe(
            &[primitive.gpu],
            unsupported_camera
        ));
    }
}

#[test]
#[ignore = "release CPU analytic proof diagnostic; excludes GPU and presentation"]
fn analytic_primitives_100_500_2000_cpu_diagnostic() {
    use crate::renderer::{CameraUniform, LogicalViewport, screen_camera};
    use std::{hint::black_box, time::Instant};
    if cfg!(debug_assertions) {
        panic!("diagnostic requires --release");
    }
    let viewport = LogicalViewport::new(1280.0, 800.0).unwrap();
    let uniform = CameraUniform::new(screen_camera(viewport).unwrap(), viewport).unwrap();
    for fixture in ["two_primitives", "math_mixed", "math_ellipse"] {
        for count in [100, 500, 2000] {
            let mut instances = Vec::new();
            for index in 0..count {
                let x = (index % 50) as f32 * 20.0 + 20.0;
                let y = (index / 50) as f32 * 14.0 + 20.0;
                if fixture == "math_ellipse" {
                    for segment in 0..13 {
                        let angle = segment as f32 * std::f32::consts::TAU / 13.0;
                        let next = (segment + 1) as f32 * std::f32::consts::TAU / 13.0;
                        instances.push(
                            ScreenPrimitive2d::round_line(
                                LogicalScreenPosition::new(
                                    x + angle.cos() * 17.0,
                                    y + angle.sin() * 13.0,
                                ),
                                LogicalScreenPosition::new(
                                    x + next.cos() * 17.0,
                                    y + next.sin() * 13.0,
                                ),
                                LogicalPixels::new(1.25).unwrap(),
                                Color::WHITE,
                            )
                            .unwrap()
                            .gpu,
                        );
                    }
                    for offset in [-9.0, 0.0, 9.0] {
                        instances.push(
                            ScreenPrimitive2d::circle(
                                LogicalScreenPosition::new(x + offset, y + 3.5),
                                LogicalPixels::new(4.0).unwrap(),
                                Color::WHITE,
                            )
                            .unwrap()
                            .gpu,
                        );
                        instances.push(
                            ScreenPrimitive2d::rect(
                                LogicalScreenPosition::new(x + offset - 3.125, y - 9.375),
                                LogicalScreenVector::new(6.25, 3.75),
                                Color::WHITE,
                            )
                            .unwrap()
                            .gpu,
                        );
                    }
                    continue;
                }
                instances.push(
                    ScreenPrimitive2d::circle(
                        LogicalScreenPosition::new(x, y),
                        LogicalPixels::new(2.0).unwrap(),
                        Color::WHITE,
                    )
                    .unwrap()
                    .gpu,
                );
                instances.push(
                    ScreenPrimitive2d::round_line(
                        LogicalScreenPosition::new(x, y),
                        LogicalScreenPosition::new(x + 13.0, y + 5.0),
                        LogicalPixels::new(2.0).unwrap(),
                        Color::WHITE,
                    )
                    .unwrap()
                    .gpu,
                );
                if fixture == "math_mixed" {
                    for offset in 1..=12 {
                        let offset = offset as f32 * 0.25;
                        instances.push(
                            ScreenPrimitive2d::round_line(
                                LogicalScreenPosition::new(x + offset, y + offset),
                                LogicalScreenPosition::new(x + 13.0 + offset, y + 5.0 + offset),
                                LogicalPixels::new(2.0).unwrap(),
                                Color::WHITE,
                            )
                            .unwrap()
                            .gpu,
                        );
                    }
                    for offset in [3.0, 6.0] {
                        instances.push(
                            ScreenPrimitive2d::circle(
                                LogicalScreenPosition::new(x + offset, y),
                                LogicalPixels::new(2.0).unwrap(),
                                Color::WHITE,
                            )
                            .unwrap()
                            .gpu,
                        );
                    }
                    for offset in [0.0, 3.0, 6.0] {
                        instances.push(
                            ScreenPrimitive2d::rect(
                                LogicalScreenPosition::new(x + offset, y + 7.0),
                                LogicalScreenVector::new(2.0, 3.0),
                                Color::WHITE,
                            )
                            .unwrap()
                            .gpu,
                        );
                    }
                }
            }
            let certificate = super::certificate::Certificate::new(&instances);
            let fast = certificate.accepts(uniform);
            let primitive_fast_count = instances
                .iter()
                .filter(|instance| {
                    super::certificate::Certificate::new(std::slice::from_ref(*instance))
                        .accepts(uniform)
                })
                .count();
            let operation = || {
                validation::instances_are_safe_accelerated(
                    black_box(&instances),
                    black_box(certificate),
                    black_box(uniform),
                )
            };
            assert!(operation());
            let (_, allocations) = crate::test_allocations::count(operation);
            assert_eq!(allocations, 0);
            let mut samples = Vec::new();
            let mut rebuild_samples = Vec::new();
            for index in 0..12 {
                let start = Instant::now();
                assert!(black_box(operation()));
                if index >= 2 {
                    samples.push(start.elapsed().as_secs_f64() * 1000.0);
                }
                let start = Instant::now();
                black_box(super::certificate::Certificate::new(black_box(&instances)));
                if index >= 2 {
                    rebuild_samples.push(start.elapsed().as_secs_f64() * 1000.0);
                }
            }
            samples.sort_by(f64::total_cmp);
            rebuild_samples.sort_by(f64::total_cmp);
            println!(
                "analytic_primitives fixture={fixture} constructions={count} primitives={} vertices={} upload_bytes={} samples=10 certificate_accepted={fast} primitive_fast_count={primitive_fast_count} validation_p50_p95_p99_ms={:.6}/{:.6}/{:.6} certificate_rebuild_p50_p95_p99_ms={:.6}/{:.6}/{:.6} allocations={allocations}",
                instances.len(),
                instances.len() * 6,
                instances.len() * 64,
                samples[5],
                samples[9],
                samples[9],
                rebuild_samples[5],
                rebuild_samples[9],
                rebuild_samples[9]
            );
        }
    }
}

#[test]
fn compact_layout_and_construction_rejections() {
    assert_eq!(std::mem::size_of::<ScreenPrimitiveGpu>(), 64);
    let point = LogicalScreenPosition::new(12.5, 3.25);
    let length = LogicalPixels::new(2.0).unwrap();
    assert!(ScreenPrimitive2d::circle(point, length, Color::WHITE).is_ok());
    assert!(ScreenPrimitive2d::round_line(point, point, length, Color::WHITE).is_err());
    assert!(
        ScreenPrimitive2d::rect(point, LogicalScreenVector::new(-1.0, 2.0), Color::WHITE).is_err()
    );
    assert!(
        ScreenPrimitive2d::circle(point, length, Color::rgba(f32::NAN, 0.0, 0.0, 1.0)).is_err()
    );
}