Skip to content

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

7.2 KB
Raw Blame
use super::*;
use crate::lighting::{HdrDecodeTask, HdrSource, HdrTaskPoll};

fn decoded(pixels: [[u8; 4]; 8], header: &str) -> DecodedHdr {
    let mut bytes = format!("#?RADIANCE\nFORMAT=32-bit_rle_rgbe\n{header}\n-Y 2 +X 4\n").into_bytes();
    for pixel in pixels {
        bytes.extend_from_slice(&pixel);
    }
    let mut task = HdrDecodeTask::new(HdrSource::new(bytes).unwrap()).unwrap();
    for _ in 0..100 {
        if let HdrTaskPoll::Complete(decoded) = task.step(100, || false).unwrap() {
            return decoded;
        }
    }
    panic!("bounded fixture failed to decode");
}
fn prepared(decoded: &DecodedHdr, rotation: f64, intensity: f64) -> Environment<'_> {
    let mut task = EnvironmentPreparation::new(decoded, rotation, intensity).unwrap();
    while !task.step(1, || Ok(())).unwrap() {}
    task.finish().unwrap()
}

#[test]
fn constant_source_has_uniform_solid_angle_pdf_and_exact_radiance_integral() {
    let data = decoded([[128, 64, 32, 129]; 8], "");
    let env = prepared(&data, 0.0, 2.0);
    let expected = Vec3::new(2.0, 1.0, 0.5);
    let mut integral = Vec3::ZERO;
    for i in 0..64 {
        let sample = env.sample([(f64::from(i) + 0.5) / 64.0, 0.37]).unwrap();
        assert!((sample.direction.len() - 1.0).abs() < 1e-14);
        assert_eq!(sample.radiance_source_rgb, expected);
        assert_eq!(env.pdf_solid_angle(sample.direction).unwrap(), sample.pdf_solid_angle);
        integral += sample.radiance_source_rgb / sample.pdf_solid_angle / 64.0;
    }
    assert!((integral - expected * (4.0 * PI)).len() < 1e-12);
    assert!((env.pdf_solid_angle(Vec3::Z).unwrap() * 4.0 * PI - 1.0).abs() < 1e-15);
}

#[test]
fn z_up_uv_centres_seam_poles_and_positive_rotation_are_explicit() {
    let data = decoded([[128, 0, 0, 129]; 8], "");
    let env = prepared(&data, 0.0, 1.0);
    assert_eq!(env.uv(Vec3::X).unwrap(), [0.0, 0.5]);
    assert_eq!(env.uv(Vec3::Y).unwrap(), [0.25, 0.5]);
    assert_eq!(env.uv(Vec3::Z).unwrap(), [0.0, 0.0]);
    assert_eq!(env.uv(-Vec3::Z).unwrap(), [0.0, 1.0]);
    let rotated = prepared(&data, PI / 2.0, 1.0);
    assert_eq!(rotated.uv(Vec3::Y).unwrap(), [0.0, 0.5]);
    assert!(env.uv(Vec3::new(1.0, -1e-8, 0.0)).unwrap()[0] > 0.99);
    let theta = PI / 4.0;
    let phi = PI / 4.0;
    let centre = Vec3::new(theta.sin() * phi.cos(), theta.sin() * phi.sin(), theta.cos());
    let uv = env.uv(centre).unwrap();
    assert!((uv[0] - 0.125).abs() < 1e-14 && (uv[1] - 0.25).abs() < 1e-14);
}

#[test]
fn bright_texel_integral_matches_its_independent_spherical_cell_area() {
    let mut pixels = [[0; 4]; 8];
    pixels[0] = [128, 0, 0, 129];
    let data = decoded(pixels, "");
    let env = prepared(&data, 0.0, 1.0);
    let mut integral = 0.0;
    // 4x2: first cell has phi width pi/2 and z width 1, solid angle pi/2.
    for y in 0..8 {
        for x in 0..8 {
            let sample = env.sample([(f64::from(y) + 0.5) / 8.0, (f64::from(x) + 0.5) / 8.0]).unwrap();
            integral += sample.radiance_source_rgb.x / sample.pdf_solid_angle / 64.0;
        }
    }
    assert!((integral - PI / 2.0).abs() < 1e-14);
    let black = decoded([[0; 4]; 8], "");
    let env = prepared(&black, 0.0, 1.0);
    let sample = env.sample([0.3, 0.7]).unwrap();
    assert_eq!(sample.radiance_source_rgb, Vec3::ZERO);
    assert_eq!(sample.pdf_solid_angle, 1.0 / (4.0 * PI));
}

#[test]
fn caller_budget_cancellation_consumes_preparation_and_preserves_owner_capacity() {
    let data = decoded([[128, 0, 0, 129]; 8], "");
    let bytes = data.retained_pixel_bytes().unwrap();
    let mut task = EnvironmentPreparation::new(&data, 0.0, 1.0).unwrap();
    let mut charged = 0;
    assert!(
        !task
            .step(3, || {
                charged += 1;
                Ok(())
            })
            .unwrap()
    );
    assert_eq!(charged, 3);
    assert_eq!(task.step(1, || Err(HdrError::new(HdrErrorCode::Cancelled, "cancel"))).unwrap_err().code, HdrErrorCode::Cancelled);
    assert!(task.finish().is_err());
    assert_eq!(data.retained_pixel_bytes().unwrap(), bytes);
    let mut task = EnvironmentPreparation::new(&data, 0.0, 1.0).unwrap();
    assert_eq!(task.step(1, || Err(HdrError::new(HdrErrorCode::LimitExceeded, "shared work"))).unwrap_err().code, HdrErrorCode::LimitExceeded);
    assert!(task.finish().is_err());
}

#[test]
fn source_colour_is_not_assumed_srgb_and_decoder_corrections_are_not_reapplied() {
    let raw = decoded([[128, 64, 32, 129]; 8], "EXPOSURE=2\nCOLORCORR=2 1 1\n");
    let env = prepared(&raw, 0.0, 1.0);
    assert_eq!(env.radiance_source_rgb(Vec3::X).unwrap(), Vec3::new(0.25, 0.25, 0.125));
    assert!(env.radiance_linear_srgb(Vec3::X).is_err());
    for header in ["PRIMARIES=0.64 0.33 0.29 0.60 0.15 0.06 0.3333 0.3333\n", "PRIMARIES=0.64 0.33 0.30 0.60 0.15 0.06 0.3127 0.3290\n"] {
        let data = decoded([[128, 0, 0, 129]; 8], header);
        let env = prepared(&data, 0.0, 1.0);
        assert_eq!(env.require_linear_srgb().is_ok(), data.info().primaries == Some([0.64, 0.33, 0.30, 0.60, 0.15, 0.06, 0.3127, 0.3290]));
    }
}

#[test]
fn hostile_options_variates_and_directions_refuse_without_panics() {
    let data = decoded([[128, 0, 0, 129]; 8], "");
    for (rotation, intensity) in [(f64::NAN, 1.0), (0.0, f64::INFINITY), (0.0, -1.0), (0.0, 65.0)] {
        assert!(EnvironmentPreparation::new(&data, rotation, intensity).is_err());
    }
    assert!(EnvironmentPreparation::new(&data, 0.0, 1.0).unwrap().finish().is_err());
    let env = prepared(&data, 0.0, 0.0);
    for u in [[0.0, 0.5], [1.0, 0.5], [f64::NAN, 0.5]] {
        assert!(env.sample(u).is_err());
    }
    for d in [Vec3::ZERO, Vec3::new(f64::INFINITY, 0.0, 0.0)] {
        assert!(env.uv(d).is_err());
        assert!(env.pdf_solid_angle(d).is_err());
    }
    assert_eq!(env.radiance_source_rgb(Vec3::new(f64::MAX, f64::MAX, 0.0)).unwrap(), Vec3::ZERO);
}

#[test]
fn direct_conductor_estimates_average_once_and_do_not_cross_geometry() {
    let data = decoded([[128, 64, 32, 129]; 8], "PRIMARIES=0.64 0.33 0.30 0.60 0.15 0.06 0.3127 0.3290\n");
    let env = prepared(&data, 0.0, 1.0);
    let surface = crate::surface::OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 1.0, 1.0, 1.5).unwrap();
    let mut mean = Vec3::ZERO;
    for i in 0..4096 {
        let u = [(f64::from(i) + 0.5) / 4096.0, 0.375];
        let sample = env.direct_sample_linear_srgb(u, surface, Vec3::Z, Vec3::Z, Vec3::Z).unwrap();
        mean += sample.contribution_linear_srgb / 4096.0;
    }
    // Independent white-conductor roughness=1 normal-view integral:
    // 2*pi*integral_0^1 z/(2*pi*(1+z)) dz = 1-ln(2).
    assert!((mean - Vec3::new(1.0, 0.5, 0.25) * (1.0 - 2.0_f64.ln())).len() < 3e-8);
    let blocked = env.direct_sample_linear_srgb([0.25, 0.375], surface, Vec3::Z, -Vec3::Z, Vec3::Z).unwrap();
    assert_eq!(blocked.contribution_linear_srgb, Vec3::ZERO);
    for view in [Vec3::new(0.99, 0.0, -0.1), Vec3::X] {
        let crossed = env.direct_sample_linear_srgb([0.25, 0.01], surface, Vec3::new(0.8, 0.0, 0.6), Vec3::Z, view).unwrap();
        assert_eq!(crossed.contribution_linear_srgb, Vec3::ZERO);
    }
    assert!(env.direct_sample_linear_srgb([0.25, 0.01], surface, Vec3::Z, Vec3::Z, Vec3::ZERO).is_err());
    let unknown = decoded([[128, 0, 0, 129]; 8], "");
    assert!(prepared(&unknown, 0.0, 1.0).direct_sample_linear_srgb([0.25, 0.375], surface, Vec3::Z, Vec3::Z, Vec3::Z).is_err());
}