sim-engine 0.4.1

A validated high-performance visualization engine for simulations
Documentation
use std::sync::{
    Arc,
    atomic::{AtomicUsize, Ordering},
    mpsc,
};

use super::config::recovery_quarantine_has_capacity;
use super::*;
use crate::LogicalScreenVector;

mod cpu_validation_diagnostics;

mod clipping;
mod configuration;
mod gpu_oracle;
mod gpu_pixels;
mod particles;
mod shapes;
mod strokes;
mod validation;

fn tessellate_for_test(scene: &Scene) -> (Vec<Vertex>, Vec<PreparedDrawBatch>) {
    let mut vertices = Vec::new();
    let mut draw_batches = Vec::new();
    tessellate_scene(scene, &mut vertices, &mut draw_batches)
        .expect("validated test scene should tessellate within its budget");
    (vertices, draw_batches)
}

fn vertex_screen_position(vertex: Vertex, camera: Camera2d, viewport: LogicalViewport) -> Vec2 {
    let Some(uniform) = CameraUniform::new(camera, viewport) else {
        panic!("test camera uniform should be finite");
    };
    let world = Vec2::new(vertex.world_position[0], vertex.world_position[1]);
    let mut screen = uniform.world_to_screen(world, vertex.depth)
        + uniform.direction_to_screen(Vec2::new(vertex.world_offset[0], vertex.world_offset[1]))
        + Vec2::new(vertex.screen_offset[0], vertex.screen_offset[1]);
    if vertex.normal_distance.abs() > 0.0 || vertex.tangent_distance.abs() > 0.0 {
        let previous = uniform.direction_to_screen(Vec2::new(
            vertex.previous_direction[0],
            vertex.previous_direction[1],
        ));
        let next = uniform.direction_to_screen(Vec2::new(
            vertex.next_direction[0],
            vertex.next_direction[1],
        ));
        let previous_tangent = previous.normalized();
        let next_tangent = next.normalized();
        let previous_normal = previous_tangent.perp();
        let next_normal = next_tangent.perp();
        let combined_normal = previous_normal + next_normal;
        let turn = previous_tangent
            .x
            .mul_add(next_tangent.y, -previous_tangent.y * next_tangent.x);
        let reverses = turn.abs() <= 0.000001 && previous_tangent.dot(next_tangent) < 0.0;
        let side = vertex.normal_distance.signum();
        let outer_side = -turn.signum();
        let mut extrusion =
            next_normal * vertex.normal_distance + next_tangent * vertex.tangent_distance;
        let mut miter_offset = Vec2::ZERO;
        let mut miter_multiple = f32::INFINITY;
        let mut miter_valid = false;
        if combined_normal.length_squared() > 0.000001 {
            let miter = combined_normal.normalized();
            let denominator = miter.dot(next_normal);
            if denominator.abs() > 0.001 {
                miter_multiple = (1.0 / denominator).abs();
                miter_offset = miter * (vertex.normal_distance / denominator);
                miter_valid = true;
            }
        }
        if (1.0..=3.0).contains(&vertex.stroke_role) {
            if reverses {
                extrusion = Vec2::ZERO;
            } else if turn.abs() <= 0.000001 {
                extrusion = next_normal * vertex.normal_distance;
            } else if side * outer_side <= 0.0 {
                extrusion = if miter_valid && miter_multiple <= vertex.miter_limit {
                    miter_offset
                } else {
                    Vec2::ZERO
                };
            } else if vertex.stroke_role == 2.0
                && miter_valid
                && miter_multiple <= vertex.miter_limit
            {
                extrusion = miter_offset;
            } else if vertex.stroke_parameter < 0.0 {
                extrusion = previous_normal * vertex.normal_distance;
            } else {
                extrusion = next_normal * vertex.normal_distance;
            }
            extrusion += next_tangent * vertex.tangent_distance;
        } else if vertex.stroke_role >= 4.0 {
            let inner = matches!(vertex.stroke_role as i32, 5 | 7 | 9);
            let candidate_side = if inner { -side } else { side };
            let mut join_active = turn.abs() > 0.000001 && candidate_side * outer_side > 0.0;
            if matches!(vertex.stroke_role as i32, 6 | 7) {
                join_active &= !miter_valid || miter_multiple > vertex.miter_limit;
            }
            extrusion = if !join_active {
                Vec2::ZERO
            } else if inner {
                if miter_valid && miter_multiple <= vertex.miter_limit {
                    miter_offset
                } else {
                    Vec2::ZERO
                }
            } else if vertex.stroke_role == 8.0 {
                let start = previous_normal * candidate_side;
                let finish = next_normal * candidate_side;
                let angle = start
                    .x
                    .mul_add(finish.y, -start.y * finish.x)
                    .atan2(start.dot(finish))
                    * vertex.stroke_parameter;
                Vec2::new(
                    start.x.mul_add(angle.cos(), -start.y * angle.sin()),
                    start.x.mul_add(angle.sin(), start.y * angle.cos()),
                ) * vertex.normal_distance.abs()
            } else if vertex.stroke_parameter < 0.0 {
                previous_normal * vertex.normal_distance
            } else {
                next_normal * vertex.normal_distance
            };
        } else if miter_valid && miter_multiple <= vertex.miter_limit {
            extrusion = miter_offset + next_tangent * vertex.tangent_distance;
        }
        screen += extrusion;
    }
    screen
}

#[test]
fn offscreen_gpu_readback_verifies_camera_depth_and_clip_contract() {
    gpu_oracle::run();
}