sim-engine 0.4.2

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

mod retained_lookup;

#[test]
fn scalar_lut_accounting_matches_one_entry_cache_runs() {
    const BYTES: usize = COLOR_MAP_LUT_SIZE as usize * 4;
    let a = [1; BYTES];
    let b = [2; BYTES];
    let adjacent = vec![
        ScalarLutPlan {
            sort_key: (0, 0),
            lut: a,
        },
        ScalarLutPlan {
            sort_key: (0, 2),
            lut: a,
        },
    ];
    assert_eq!(
        scalar_lut_counts_with_inserted(&adjacent, 1, &a, Some(&a)),
        (0, 1)
    );
    assert_eq!(
        scalar_lut_counts_with_inserted(&adjacent, 1, &b, Some(&a)),
        (2, 3),
        "A, B, A performs two uploads and keeps three LUT allocations alive"
    );
    assert_eq!(
        scalar_lut_counts_with_inserted(&adjacent[..1], 1, &b, None),
        (2, 2)
    );
}

#[test]
fn image_and_glyph_sprite_bounds_include_final_clip_arithmetic() {
    let source = ImageTexelRect::new(0, 0, 1, 1).unwrap();
    let safe = ImageSprite2d::new(
        source,
        LogicalViewportRegion::new(
            LogicalScreenPosition::new(0.0, 0.0),
            LogicalViewport::new(1.0, 1.0).unwrap(),
        )
        .unwrap(),
        Color::WHITE,
    )
    .unwrap();
    let overflowing = ImageSprite2d::new(
        source,
        LogicalViewportRegion::new(
            LogicalScreenPosition::new(-2.0e38, 0.0),
            LogicalViewport::new(3.0e38, 1.0).unwrap(),
        )
        .unwrap(),
        Color::WHITE,
    )
    .unwrap();
    let one_pixel_clip = [2.0, -2.0, -1.0, 1.0];

    assert!(image_sprites_are_safe_for_target(
        &[safe],
        Vec2::ZERO,
        one_pixel_clip,
    ));
    assert!(!image_sprites_are_safe_for_target(
        &[overflowing],
        Vec2::ZERO,
        one_pixel_clip,
    ));
}

#[test]
fn frame_budget_accepts_exact_limit_and_rejects_one_over() {
    let budget = FrameBudget::new(1, 2, 3, 4, 5, 6);
    let exact = FrameStatistics {
        pass_count: 1,
        command_count: 2,
        vertex_count: 3,
        streaming_vertex_count: 0,
        reused_vertex_count: 0,
        upload_bytes: 4,
        streaming_upload_bytes: 0,
        texture_bytes: 5,
        retained_cpu_bytes: 7,
        retained_buffer_bytes: 8,
        draw_calls: 6,
        source_counts: FrameSourceStatistics::single(FrameSourceKind::StreamingScene),
    };
    assert_eq!(validate_frame_budget(budget, exact), Ok(()));
    assert_eq!(
        validate_frame_budget(
            budget,
            FrameStatistics {
                draw_calls: 7,
                ..exact
            }
        ),
        Err(FrameComposerError::BudgetExceeded {
            resource: FrameBudgetResource::DrawCalls,
            limit: 6,
            actual: 7,
        })
    );
}

#[test]
fn frame_statistics_group_sources_and_retained_memory_without_changing_budgets() {
    let streaming = FrameStatistics {
        pass_count: 1,
        retained_cpu_bytes: 128,
        source_counts: FrameSourceStatistics::single(FrameSourceKind::StreamingScene),
        ..FrameStatistics::default()
    };
    let glyph = FrameStatistics {
        pass_count: 1,
        retained_cpu_bytes: 256,
        retained_buffer_bytes: 512,
        source_counts: FrameSourceStatistics::single(FrameSourceKind::Glyph),
        ..FrameStatistics::default()
    };

    let combined = streaming.adding(glyph);

    assert_eq!(combined.pass_count(), 2);
    assert_eq!(combined.retained_cpu_bytes(), 384);
    assert_eq!(combined.retained_buffer_bytes(), 512);
    assert_eq!(combined.source_counts().streaming_scenes(), 1);
    assert_eq!(combined.source_counts().glyph_runs(), 1);
    assert_eq!(combined.source_counts().total(), 2);
    assert_eq!(
        validate_frame_budget(FrameBudget::new(2, 0, 0, 0, 0, 0), combined),
        Ok(())
    );
}

#[test]
fn repeated_retained_references_count_each_allocation_once() {
    let first = RetainedResourceKey {
        address: 0x1000,
        class: 3,
    };
    let second = RetainedResourceKey {
        address: 0x2000,
        class: 7,
    };
    let resources = [
        RetainedResourceAccounting::new(first, 128, 256, 0),
        RetainedResourceAccounting::new(first, 128, 256, 0),
        RetainedResourceAccounting::new(second, 64, 0, 512),
    ];

    let (first_frame, missing) =
        account_new_retained_resources(&[], &resources, FrameStatistics::default());
    assert_eq!(missing, 2);
    assert_eq!(first_frame.retained_cpu_bytes(), 192);
    assert_eq!(first_frame.retained_buffer_bytes(), 256);
    assert_eq!(first_frame.texture_bytes(), 512);

    let (repeated, missing) =
        account_new_retained_resources(&[first, second], &resources, FrameStatistics::default());
    assert_eq!(missing, 0);
    assert_eq!(repeated.retained_cpu_bytes(), 0);
    assert_eq!(repeated.retained_buffer_bytes(), 0);
    assert_eq!(repeated.texture_bytes(), 0);
}

#[test]
fn frame_report_exposes_single_present_contract_and_skipped_zeroes() {
    let drawn = FrameReport {
        status: RenderStatus::Drawn,
        statistics: FrameStatistics::default(),
        metrics: RendererFrameMetrics::default(),
        gpu_timing_id: None,
    };
    assert_eq!(drawn.command_encoder_count(), 1);
    assert_eq!(drawn.render_pass_count(), 1);
    assert_eq!(drawn.queue_submission_count(), 1);
    assert_eq!(drawn.surface_present_count(), 1);

    let skipped = FrameReport {
        status: RenderStatus::Skipped(RendererSurfaceStatus::Occluded),
        ..drawn
    };
    assert_eq!(skipped.command_encoder_count(), 0);
    assert_eq!(skipped.render_pass_count(), 0);
    assert_eq!(skipped.queue_submission_count(), 0);
    assert_eq!(skipped.surface_present_count(), 0);
    assert_eq!(skipped.gpu_timing_id(), None);

    let planned = FrameStatistics {
        upload_bytes: 128,
        streaming_upload_bytes: 96,
        vertex_count: 12,
        ..FrameStatistics::default()
    };
    let skipped_statistics = planned.without_uploads();
    assert_eq!(skipped_statistics.upload_bytes(), 0);
    assert_eq!(skipped_statistics.streaming_upload_bytes(), 0);
    assert_eq!(skipped_statistics.vertex_count(), 12);
}

#[test]
fn frame_items_sort_stably_by_order_then_insertion() {
    let scene = Scene::new(Color::BLACK).unwrap();
    let camera = Camera2d::default();
    let mut items = [
        FrameItem::Scene {
            scene: &scene,
            camera,
            options: FramePassOptions::new(4),
            insertion: 0,
        },
        FrameItem::Scene {
            scene: &scene,
            camera,
            options: FramePassOptions::new(-1),
            insertion: 1,
        },
        FrameItem::Scene {
            scene: &scene,
            camera,
            options: FramePassOptions::new(4),
            insertion: 2,
        },
    ];
    items.sort_unstable_by_key(FrameItem::sort_key);
    assert_eq!(
        items.iter().map(FrameItem::sort_key).collect::<Vec<_>>(),
        vec![(-1, 1), (4, 0), (4, 2)]
    );
}

#[test]
fn late_streaming_transform_rejection_rolls_back_appended_vertices() {
    let mut scene = Scene::new(Color::BLACK).unwrap();
    scene
        .try_line(
            Vec2::new(1.0e30, 0.0),
            Vec2::new(1.1e30, 0.0),
            1.0,
            Color::WHITE,
        )
        .unwrap();
    let viewport = LogicalViewport::new(64.0, 64.0).unwrap();
    let camera = Camera2d::new(Vec2::ZERO, 1.0e10).unwrap();
    let uniform = CameraUniform::new_in_region(camera, viewport, Vec2::ZERO, viewport).unwrap();
    let resolved = ResolvedViewport {
        viewport,
        origin: Vec2::ZERO,
        scissor: ScissorRect {
            x: 0,
            y: 0,
            width: 64,
            height: 64,
        },
        item_clip: None,
        item_clipped_out: false,
    };
    let mut vertices = Vec::new();
    let mut ready = Vec::new();
    let mut statistics = FrameStatistics::default();
    let mut aggregate = TessellationStats::default();

    assert_eq!(
        prepare_streaming_scene_resolved(
            &scene,
            uniform,
            resolved,
            &mut vertices,
            &mut ready,
            &mut statistics,
            &mut aggregate,
            &mut Vec::new(),
            &mut RendererPreparationMetrics::default(),
        ),
        Err(FrameComposerError::Frame(
            RendererFrameError::InvalidGeometryTransform
        ))
    );
    assert!(vertices.is_empty());
    assert!(ready.is_empty());
    assert_eq!(statistics, FrameStatistics::default());
    assert_eq!(aggregate, TessellationStats::default());
}

#[test]
fn streaming_screen_scene_rejects_generated_subnormal_geometry() {
    let viewport = LogicalViewport::new(64.0, 64.0).unwrap();
    let mut scene = ScreenScene::new(Color::BLACK).unwrap();
    scene
        .try_circle(
            LogicalScreenPosition::new(32.0, 32.0),
            crate::LogicalPixels::new(f32::MIN_POSITIVE).unwrap(),
            ShapeStyle::filled(Color::WHITE),
        )
        .unwrap();
    let camera = screen_camera(viewport).unwrap();
    let uniform = CameraUniform::new_in_region(camera, viewport, Vec2::ZERO, viewport).unwrap();
    let resolved = ResolvedViewport {
        viewport,
        origin: Vec2::ZERO,
        scissor: ScissorRect {
            x: 0,
            y: 0,
            width: 64,
            height: 64,
        },
        item_clip: None,
        item_clipped_out: false,
    };
    let mut vertices = Vec::new();
    let mut ready = Vec::new();
    let mut statistics = FrameStatistics::default();
    let mut aggregate = TessellationStats::default();

    assert_eq!(
        prepare_streaming_scene_resolved(
            scene.as_scene(),
            uniform,
            resolved,
            &mut vertices,
            &mut ready,
            &mut statistics,
            &mut aggregate,
            &mut Vec::new(),
            &mut RendererPreparationMetrics::default(),
        ),
        Err(FrameComposerError::Frame(
            RendererFrameError::InvalidGeometryTransform
        ))
    );
    assert!(vertices.is_empty());
    assert!(ready.is_empty());
}

#[test]
fn scissor_intersection_rejects_disjoint_rectangles() {
    let first = ScissorRect {
        x: 2,
        y: 3,
        width: 8,
        height: 9,
    };
    let overlapping = ScissorRect {
        x: 8,
        y: 10,
        width: 8,
        height: 8,
    };
    assert_eq!(
        intersect_scissors(first, overlapping),
        Some(ScissorRect {
            x: 8,
            y: 10,
            width: 2,
            height: 2,
        })
    );
    assert_eq!(
        intersect_scissors(
            first,
            ScissorRect {
                x: 10,
                y: 3,
                width: 2,
                height: 2,
            }
        ),
        None
    );
}

#[test]
fn target_destination_maps_logical_region_to_clip_space() {
    let target = LogicalViewport::new(800.0, 600.0).unwrap();
    let region = LogicalViewportRegion::new(
        LogicalScreenPosition::new(200.0, 150.0),
        LogicalViewport::new(400.0, 300.0).unwrap(),
    )
    .unwrap();
    let uniform = CompositeUniform::in_region(0.5, region, target).unwrap();
    assert_eq!(uniform.opacity[0], 0.5);
    assert_eq!(uniform.destination, [0.5, 0.5, 0.0, 0.0]);
}