Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

6.5 KB
Raw Blame
//! Original MIT OR Apache-2.0 analytic fixtures for the shared CPU/GPU dielectric contract.
//! Provenance: elementary Fresnel s/p equations, Snell law and Beer-Lambert attenuation.
//! No external assets or renderer outputs. Tolerances are absolute f64 errors stated per assertion.
//! Import this test module with the optical math module; only the API adapter needs changing.
use super::*;

#[test]
fn oblique_polarizations_and_snell_match_independent_angle_equations() {
    let brewster = 1.5_f64.atan();
    for angle in [0.3, brewster - 1e-4, brewster, brewster + 1e-4, 1.2] {
        let transmitted_angle = (angle.sin() / 1.5).asin();
        let expected_s = ((angle - transmitted_angle).sin() / (angle + transmitted_angle).sin()).powi(2);
        let expected_p = ((angle - transmitted_angle).tan() / (angle + transmitted_angle).tan()).powi(2);
        let actual = fresnel(angle.cos(), 1.0, 1.5).unwrap();
        assert!((actual.s - expected_s).abs() < 1e-14);
        assert!((actual.p - expected_p).abs() < 1e-14);
        let incident = Vec3::new(angle.sin(), 0.0, -angle.cos());
        let outgoing = refract(incident, Vec3::Z, 1.0, 1.5).unwrap().unwrap();
        assert!((outgoing.x - transmitted_angle.sin()).abs() < 1e-14);
        assert!((outgoing.z + transmitted_angle.cos()).abs() < 1e-14);
        let reversed = refract(-outgoing, -Vec3::Z, 1.5, 1.0).unwrap().unwrap();
        assert!((reversed + incident).len() < 1e-13);
    }
    let critical = (1.0_f64 / 1.5).asin();
    assert!(fresnel((critical - 1e-5).cos(), 1.5, 1.0).unwrap().transmitted_cosine.is_some());
    assert!(fresnel((critical + 1e-5).cos(), 1.5, 1.0).unwrap().transmitted_cosine.is_none());
    assert!(refract(Vec3::new(0.9, 0.0, -(1.0_f64 - 0.81).sqrt()), Vec3::Z, 1.5, 1.0).unwrap().is_none());
    let zero_sheet = Transmission::new(Vec3::new(100.0, 100.0, 100.0), Some(0.0)).unwrap();
    let (r, t) = slab(zero_sheet, 0.0, 1.0, 1.0, 1.5).unwrap();
    assert!((r.x + t.x - 1.0).abs() < 1e-14);
    assert!((t.x - 0.96_f64.powi(2) / (1.0 - 0.04_f64.powi(2))).abs() < 1e-14);
}

#[test]
fn exact_fresnel_brewster_critical_and_index_matched_limits() {
    for n in [1.0_f64, 1.33, 1.5, 3.0] {
        assert!((fresnel(1.0, 1.0, n).unwrap().reflectance() - ((n - 1.0) / (n + 1.0)).powi(2)).abs() < 1e-15);
        assert!(fresnel(n.atan().cos(), 1.0, n).unwrap().p < 1e-30);
    }
    assert_eq!(fresnel(0.5, 1.5, 1.0).unwrap().transmitted_cosine, None);
    assert_eq!(fresnel(0.0, 1.0, 1.0).unwrap().reflectance(), 0.0);
    assert_eq!(fresnel(0.0, 1.0, 1.5).unwrap().reflectance(), 1.0);
    for cosine in [0.01, 0.3, 0.9, 1.0] {
        let f = fresnel(cosine, 1.0, 1.5).unwrap();
        let reverse = fresnel(f.transmitted_cosine.unwrap(), 1.5, 1.0).unwrap();
        assert!((f.reflectance() - reverse.reflectance()).abs() < 1e-12);
    }
}

#[test]
fn beer_lambert_slab_and_lossless_energy() {
    let t = Transmission::new(Vec3::new(-0.5_f64.ln(), -0.8_f64.ln(), 0.0) / 10.0, None).unwrap();
    assert!((t.attenuation(20.0).unwrap() - Vec3::new(0.25, 0.64, 1.0)).len() < 1e-15);
    let (r, through) = slab(t, 10.0, 1.0, 1.0, 1.5).unwrap();
    assert!((through.x - 0.96_f64.powi(2) * 0.5 / (1.0 - 0.04_f64.powi(2) * 0.25)).abs() < 1e-15);
    assert!((r.z + through.z - 1.0).abs() < 1e-15);
    assert!(r.x + through.x < 1.0);
    let clear = Transmission::new(Vec3::ZERO, None).unwrap();
    for cosine in [0.001, 0.1, 0.5, 1.0] {
        let (r, t) = slab(clear, 1.0, cosine, 1.0, 1.5).unwrap();
        assert!((r.x + t.x - 1.0).abs() < 1e-13);
    }
}

#[test]
fn hostile_optics_are_rejected_without_clamping() {
    for v in [f64::NAN, f64::INFINITY, -1.0, 100.01] {
        assert!(Transmission::new(Vec3::new(v, 0.0, 0.0), None).is_err());
    }
    for v in [f64::NAN, f64::INFINITY, -1.0, 10000.01] {
        assert!(Transmission::new(Vec3::ZERO, Some(v)).is_err());
    }
    assert!(Transmission::new(Vec3::ZERO, Some(0.0)).is_ok());
    assert!(fresnel(f64::NAN, 1.0, 1.5).is_err());
    assert!(fresnel(0.5, f64::INFINITY, 1.5).is_err());
    assert!(refract(Vec3::ZERO, Vec3::Z, 1.0, 1.5).is_err());
    assert!(refract(Vec3::Z, Vec3::Z, 1.0, 1.5).is_err());
}

#[test]
fn zero_thickness_matched_sheet_transmits_at_exact_grazing() {
    let sheet = Transmission::new(Vec3::new(100.0, 10.0, 1.0), Some(0.0)).unwrap();
    for index in [1.0, 1.33, 1.5, 3.0] {
        for cosine in [0.0, f64::EPSILON, 0.5, 1.0] {
            let (reflected, transmitted) = slab(sheet, 0.0, cosine, index, index).unwrap();
            assert_eq!(reflected, Vec3::ZERO);
            assert_eq!(transmitted, Vec3::new(1.0, 1.0, 1.0));
        }
        // Positive physical thickness requires an actual crossing direction.
        assert_eq!(slab(sheet, 1.0, 0.0, index, index), Err(TransmissionError::Angle));
    }
    // Zero thickness does not override total internal reflection.
    let (reflected, transmitted) = slab(sheet, 0.0, 0.5, 1.5, 1.0).unwrap();
    assert_eq!(reflected, Vec3::new(1.0, 1.0, 1.0));
    assert_eq!(transmitted, Vec3::ZERO);
}

#[test]
fn slab_energy_and_beer_order_hold_across_the_admitted_optical_domain() {
    let clear = Transmission::new(Vec3::ZERO, None).unwrap();
    let tinted = Transmission::new(Vec3::new(0.001, 0.1, 100.0), None).unwrap();
    for outside in [1.0, 1.33, 1.5, 3.0] {
        for inside in [1.0, 1.33, 1.5, 3.0] {
            for cosine in [0.0, 1e-12, 0.01, 0.5, 0.9, 1.0] {
                for thickness in [0.0, 1e-12, 1.0, 10000.0] {
                    if cosine == 0.0 && outside == inside && thickness > 0.0 {
                        continue;
                    }
                    let (r0, t0) = slab(clear, thickness, cosine, outside, inside).unwrap();
                    let (r, t) = slab(tinted, thickness, cosine, outside, inside).unwrap();
                    for (reflectance, transmittance, lossless_r, lossless_t) in
                        [(r.x, t.x, r0.x, t0.x), (r.y, t.y, r0.y, t0.y), (r.z, t.z, r0.z, t0.z)]
                    {
                        assert!(reflectance.is_finite() && transmittance.is_finite());
                        assert!((0.0..=1.0).contains(&reflectance));
                        assert!((0.0..=1.0).contains(&transmittance));
                        assert!((lossless_r + lossless_t - 1.0).abs() < 1e-12);
                        assert!(reflectance <= lossless_r + 1e-12);
                        assert!(transmittance <= lossless_t + 1e-12);
                        assert!(reflectance + transmittance <= 1.0 + 1e-12);
                    }
                    assert!(t.x >= t.y && t.y >= t.z);
                }
            }
        }
    }
}