Skip to content

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

14.2 KB
Raw Blame
use super::*;
use crate::lighting::{HdrSource, environment_input::EnvironmentInput};
use solidcraft_geom::{Aabb3, Mesh};
use std::sync::Arc;

fn input() -> EnvironmentInput {
    let mut bytes = b"#?RADIANCE\nFORMAT=32-bit_rle_rgbe\nPRIMARIES=0.64 0.33 0.30 0.60 0.15 0.06 0.3127 0.3290\n\n-Y 2 +X 4\n".to_vec();
    for _ in 0..8 {
        bytes.extend_from_slice(&[128, 64, 32, 129]);
    }
    EnvironmentInput::new(HdrSource::new(bytes).unwrap(), 0.0, 1.0, 64).unwrap()
}
fn scene() -> ProductScene {
    let mesh = Arc::new(Mesh {
        positions: vec![Vec3::new(-10.0, -10.0, 0.0), Vec3::new(10.0, -10.0, 0.0), Vec3::new(10.0, 10.0, 0.0), Vec3::new(-10.0, 10.0, 0.0)],
        normals: vec![Vec3::Z; 4],
        triangles: vec![[0, 1, 2], [0, 2, 3]],
        tri_face: vec![0, 0],
        ..Default::default()
    });
    ProductScene {
        bounds: mesh.bounds(),
        meshes: vec![crate::ProductMesh {
            transmission: None,
            name: "Original conductor plate".into(),
            mesh,
            color: [255; 3],
            opacity: 1.0,
            surface: Some(OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 1.0, 1.0, 1.5).unwrap()),
            faces: Vec::new(),
        }],
    }
}
fn request() -> ImageRequest {
    let mut camera = crate::Camera { distance: 50.0, ..Default::default() };
    camera.set_view(crate::StandardView::Top);
    ImageRequest {
        studio_weights: None,
        environment: None,
        textures: None,
        integrator: job::Integrator::Raytrace,
        raytrace: Some(RaytraceOptions { lights: Some(Vec::new()), ..Default::default() }),
        camera,
        width: 9,
        height: 9,
        background: [13, 27, 41],
        transparent_background: false,
    }
}
fn png(source: ProductScene, environment: Option<EnvironmentInput>) -> Vec<u8> {
    let request = request();
    let options = request.raytrace.clone().unwrap();
    let mut task = ImageTask::new_with_environment(source, request, CancelToken::default(), options, environment).unwrap();
    for _ in 0..200_000 {
        if let TaskPoll::Complete(png) = task.step(16384).unwrap() {
            return png;
        }
    }
    panic!("bounded environment fixture did not complete");
}

#[test]
fn real_cpu_png_conductor_matches_independent_environment_quadrature_once() {
    let baseline = ::image::load_from_memory(&png(scene(), None)).unwrap().to_rgba8();
    let rendered = png(scene(), Some(input()));
    assert_eq!(rendered, png(scene(), Some(input())));
    let image = ::image::load_from_memory(&rendered).unwrap().to_rgba8();
    // Independent roughness-one white-conductor f*cos= z/(2*pi*(1+z)).
    // The fixed 8x8 solid-angle strata integrate 4 positive z rows, each 8 samples.
    let factor = [0.125, 0.375, 0.625, 0.875].into_iter().map(|z| z / (1.0 + z)).sum::<f64>() / 4.0;
    let expected = [factor, factor * 0.5, factor * 0.25].map(|r| encode8(r / (1.0 + r)));
    assert_eq!(image.get_pixel(4, 4).0, [expected[0], expected[1], expected[2], 255]);
    assert_eq!(baseline.get_pixel(4, 4).0, [0, 0, 0, 255]);
    let empty = ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY };
    let background = ::image::load_from_memory(&png(empty, Some(input()))).unwrap().to_rgba8();
    assert!(background.pixels().all(|p| p.0 == [13, 27, 41, 255]));
}

struct ProgressiveHdrResult {
    previews: Vec<(u32, Vec<u8>)>,
    png: Vec<u8>,
    work: u64,
}

fn progressive_hdr_png(samples_per_pixel: u32, seed: u32, quantum: usize, environment: Option<EnvironmentInput>) -> ProgressiveHdrResult {
    let mut request = request();
    let mut options = request.raytrace.clone().unwrap();
    options.progressive = Some(job::CpuProgressiveOptions { samples_per_pixel, seed });
    options.reflections = Some(job::ReflectionOptions {
        bodies: vec![job::ReflectionBody { body: "Original conductor plate".into(), mode: job::ReflectionMode::RoughSpecular }],
        samples: 1,
        max_bounces: 2,
    });
    request.raytrace = Some(options.clone());
    let mut task = ImageTask::new_with_environment(scene(), request, CancelToken::default(), options, environment).unwrap();
    let mut previews = Vec::new();
    for _ in 0..300_000 {
        match task.step_with_previews(quantum).unwrap() {
            ImagePoll::Pending(_) => {}
            ImagePoll::Preview { png, samples_per_pixel } => previews.push((samples_per_pixel, png)),
            ImagePoll::Complete(png) => return ProgressiveHdrResult { previews, png, work: task.work.used() },
        }
    }
    panic!("bounded progressive HDR fixture did not finish");
}

fn progressive_hdr_expected(samples: u32, seed: u32) -> [u8; 4] {
    // Independent normal-view, white-conductor reference at roughness one.
    // The centre pixel (40) stays inside the plate for every camera jitter.
    // GGX gives z = 1 - 2*u and weight = 2*z/(1+z) for z > 0; other
    // attempts are null events, not replacement samples. Only the variate
    // sequence is shared with production: no BSDF, PDF or film code is used.
    let sum: f64 = (0..samples)
        .map(|ordinal| {
            let z = 1.0 - 2.0 * progressive::variates(seed, 40, ordinal, 0x100)[0];
            if z > 0.0 { 2.0 * z / (1.0 + z) } else { 0.0 }
        })
        .sum();
    let mean = sum / f64::from(samples);
    // The original HDR is constant linear RGB (1, 0.5, 0.25). Average in
    // linear space over ALL attempts, then apply the display response once.
    let rgb = [mean, mean * 0.5, mean * 0.25].map(|r| encode8(r / (1.0 + r)));
    [rgb[0], rgb[1], rgb[2], 255]
}

fn centre(png: &[u8]) -> [u8; 4] {
    ::image::load_from_memory(png).unwrap().to_rgba8().get_pixel(4, 4).0
}

#[test]
fn progressive_hdr_and_rough_reflections_keep_the_same_absolute_prefix_at_every_quantum() {
    for target in [3, 7] {
        let checkpoints: Vec<_> = (1..target).collect();
        let result = progressive_hdr_png(target, 82, 1, Some(input()));
        assert_eq!(result.previews.iter().map(|(n, _)| *n).collect::<Vec<_>>(), checkpoints);
        let other = progressive_hdr_png(target, 82, 16384, Some(input()));
        assert_eq!(result.previews, other.previews);
        assert_eq!(result.png, other.png);
        assert_eq!(result.work, other.work);
        for (samples, checkpoint) in result.previews {
            assert_eq!(progressive_hdr_png(samples, 82, 3, Some(input())).png, checkpoint);
            assert_eq!(centre(&checkpoint), progressive_hdr_expected(samples, 82));
        }
        assert_eq!(centre(&result.png), progressive_hdr_expected(target, 82));
    }
}

#[test]
fn progressive_hdr_rough_reflections_count_null_events_in_the_linear_mean() {
    // Preserve the previously failing seed rather than picking a brighter one:
    // its first three attempts are all null, and later attempts receive HDR.
    assert_eq!(progressive_hdr_expected(3, 82), [0, 0, 0, 255]);
    assert_ne!(progressive_hdr_expected(7, 82), [0, 0, 0, 255]);
    for seed in [0, 82, u32::MAX] {
        for samples in [1, 3, 7] {
            let result = progressive_hdr_png(samples, seed, 37, Some(input()));
            assert_eq!(centre(&result.png), progressive_hdr_expected(samples, seed), "seed={seed}, samples={samples}");
            let image = ::image::load_from_memory(&result.png).unwrap().to_rgba8();
            assert_eq!(image.get_pixel(0, 0).0, [13, 27, 41, 255], "HDR must not replace the display background");
            let unlit = progressive_hdr_png(samples, seed, 37, None);
            assert_eq!(centre(&unlit.png), [0, 0, 0, 255], "no direct lights or environment means zero radiance");
        }
    }
}

#[test]
fn environment_decode_and_secondary_visibility_share_cancellation_and_work_budget() {
    for during_visibility in [false, true] {
        let request = request();
        let options = request.raytrace.clone().unwrap();
        let cancel = CancelToken::default();
        let mut task = ImageTask::new_with_environment(scene(), request, cancel.clone(), options, Some(input())).unwrap();
        if during_visibility {
            for _ in 0..100_000 {
                assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
                if task.pending.as_ref().is_some_and(|p| p.environment_cursor.is_some()) {
                    break;
                }
            }
            assert!(task.pending.as_ref().is_some_and(|p| p.environment_cursor.is_some()));
        }
        // Cancellation must win before any image publication, including decode preparation.
        cancel.cancel();
        assert_eq!(task.step(1).err().unwrap().code, ErrorCode::Cancelled);
    }
    let request = request();
    let options = request.raytrace.clone().unwrap();
    let mut task = ImageTask::new_with_environment(scene(), request, CancelToken::default(), options, Some(input())).unwrap();
    task.work = WorkBudget::new(1).unwrap();
    assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
    assert_eq!(task.step(1).err().unwrap().code, ErrorCode::LimitExceeded);
}

#[cfg(not(target_arch = "wasm32"))]
#[test]
fn native_host_captured_source_completes_and_releases_work_lease() {
    let host = job::CpuHost::for_platform().unwrap();
    assert!(host.descriptor_for(job::Integrator::Raytrace).unwrap().profiles[0].features.contains(&crate::RenderFeature::Hdri));
    assert!(!host.descriptor_for(job::Integrator::Raster).unwrap().profiles[0].features.contains(&crate::RenderFeature::Hdri));
    let handle = host.submit_with_environment(job::JobId { session: 1693, serial: 1, generation: 1 }, 1, scene(), request(), Some(input())).unwrap();
    assert_eq!(handle.wait_timeout(std::time::Duration::from_secs(60)).unwrap().progress.phase, Phase::Completed);
    let frame = handle.frame().unwrap().unwrap();
    assert!(host.admitted_bytes() >= frame.png().len() as u64 + 1024);
    drop(host);
    drop(frame);
    drop(handle);
}

#[test]
fn environment_visibility_respects_four_work_units_per_quantum_and_cancel() {
    let request = request();
    let options = request.raytrace.clone().unwrap();
    let cancel = CancelToken::default();
    let mut task = ImageTask::new_with_environment(scene(), request, cancel.clone(), options, Some(input())).unwrap();
    for _ in 0..100_000 {
        assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
        if task.pending.as_ref().is_some_and(|p| p.environment_cursor.is_some()) {
            break;
        }
    }
    assert!(task.pending.as_ref().is_some_and(|p| p.environment_cursor.is_some()));
    for _ in 0..32 {
        let before = task.work.used();
        assert!(matches!(task.step(4).unwrap(), TaskPoll::Pending(_)));
        assert!(task.work.used() - before <= 4, "visibility continuation double-charged shading and traversal");
    }
    cancel.cancel();
    assert_eq!(task.step(4).err().unwrap().code, ErrorCode::Cancelled);
}

#[test]
fn all_pixel_traversal_to_shading_transitions_debit_at_most_one_unit() {
    for (directional, shadows) in [(false, true), (true, true), (true, false)] {
        let mut request = request();
        let mut options = request.raytrace.clone().unwrap();
        options.shadows = shadows;
        if directional {
            options.lights = Some(vec![job::DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 1.0 }]);
        }
        request.raytrace = Some(options.clone());
        let cancel = CancelToken::default();
        let mut task = ImageTask::new_with_environment(scene(), request, cancel.clone(), options, Some(input())).unwrap();
        while task.bvh.is_none() {
            assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
        }
        let mut primary_transitions = 0;
        let mut directional_transitions = 0;
        for _ in 0..200_000 {
            if task.pixel == 81 {
                break;
            }
            let primary = task.pending.as_ref().is_some_and(|p| p.hit.is_none());
            let light_before = task.pending.as_ref().map(|p| p.light);
            let before = task.work.used();
            task.pixel_one().unwrap();
            assert!(task.work.used() - before <= 1, "traversal completion must yield before shading/sample debit");
            if primary && task.pending.as_ref().is_some_and(|p| p.hit.is_some()) {
                primary_transitions += 1;
            }
            if light_before == Some(0) && task.pending.as_ref().is_some_and(|p| p.light == 1) {
                directional_transitions += 1;
            }
        }
        assert_eq!(task.pixel, 81);
        assert!(primary_transitions > 0);
        if directional && shadows {
            assert!(directional_transitions > 0);
        }
        cancel.cancel();
        assert_eq!(task.step(4).err().unwrap().code, ErrorCode::Cancelled);
    }
}

#[test]
fn explicit_cpu_profiles_admit_large_images_without_allocating_a_film() {
    let empty = ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY };
    let mut request = request();
    request.width = 3840;
    request.height = 2160;
    let mut options = request.raytrace.clone().unwrap();
    options.progressive = Some(job::CpuProgressiveOptions { samples_per_pixel: 128, seed: 9 });
    request.raytrace = Some(options.clone());
    assert!(admit(&empty, &request, &options).is_err());
    if usize::BITS < 64 || cfg!(target_arch = "wasm32") {
        return;
    }
    options.budget = job::CpuBudget::Studio;
    request.raytrace = Some(options.clone());
    let studio = admit(&empty, &request, &options).unwrap();
    assert!(studio.estimated_total_bytes > 384 * 1024 * 1024);
    assert!(studio.estimated_total_bytes < options.budget.limits().max_job_bytes);
    request.width = 7680;
    request.height = 4320;
    assert!(admit(&empty, &request, &options).is_err());
    options.budget = job::CpuBudget::Workstation;
    request.raytrace = Some(options.clone());
    let workstation = admit(&empty, &request, &options).unwrap();
    assert!(workstation.estimated_total_bytes > studio.estimated_total_bytes);
    assert!(workstation.estimated_total_bytes < options.budget.limits().max_job_bytes);
    for budget in [job::CpuBudget::Studio, job::CpuBudget::Workstation] {
        let count = budget.limits().max_triangles as usize;
        let bytes = BvhBuilder::required_bytes(count, count, limits(budget)).unwrap();
        assert!(bytes < budget.limits().max_job_bytes);
    }
    assert!(BvhBuilder::required_bytes(2_000_000, 2_000_000, limits(job::CpuBudget::Compact)).is_err());
}