Skip to content

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

12.2 KB
Raw Blame
use super::*;
use crate::job::{ReflectionBody, ReflectionMode, ReflectionOptions};
use crate::lighting::{HdrSource, environment_input::EnvironmentInput};
use solidcraft_geom::Mesh;
use std::sync::Arc;

fn environment(bright: bool, rotation: f64) -> 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 i in 0..8 {
        bytes.extend_from_slice(&if bright { if i == 0 { [128, 64, 16, 133] } else { [0; 4] } } else { [128, 64, 32, 129] });
    }
    EnvironmentInput::new(HdrSource::new(bytes).unwrap(), rotation, 1.0, 64).unwrap()
}
fn scene(normal: Vec3) -> ProductScene {
    let normal = normal / normal.len();
    let u = normal.cross(Vec3::X);
    let u = u / u.len() * 10.0;
    let v = normal.cross(u);
    let mesh = Arc::new(Mesh {
        positions: vec![-u - v, u - v, u + v, -u + v],
        normals: vec![normal; 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: "Metal".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(mode: ReflectionMode) -> 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()),
            reflections: Some(ReflectionOptions { bodies: vec![ReflectionBody { body: "Metal".into(), mode }], max_bounces: 1, samples: 64 }),
            ..Default::default()
        }),
        camera,
        width: 9,
        height: 9,
        background: [13, 27, 41],
        transparent_background: false,
    }
}
fn render(scene: ProductScene, request: ImageRequest, input: Option<EnvironmentInput>) -> Vec<u8> {
    let options = request.raytrace.clone().unwrap();
    let mut task = ImageTask::new_with_environment(scene, request, CancelToken::default(), options, input).unwrap();
    for _ in 0..200_000 {
        if let TaskPoll::Complete(png) = task.step(16384).unwrap() {
            return png;
        }
    }
    panic!("bounded environment reflection did not finish");
}
fn centre(bytes: &[u8]) -> [u8; 4] {
    ::image::load_from_memory(bytes).unwrap().to_rgba8().get_pixel(4, 4).0
}
fn expected(radiance: [f64; 3]) -> [u8; 4] {
    let c = radiance.map(|v| encode8(v / (1.0 + v)));
    [c[0], c[1], c[2], 255]
}

#[test]
fn ideal_metal_mirror_receives_environment_once_and_camera_background_stays_independent() {
    let req = request(ReflectionMode::Mirror);
    assert_eq!(centre(&render(scene(Vec3::Z), req.clone(), None)), [0, 0, 0, 255]);
    assert_eq!(centre(&render(scene(Vec3::Z), req.clone(), Some(environment(false, 0.0)))), expected([1.0, 0.5, 0.25]));
    let mut empty = req;
    empty.raytrace.as_mut().unwrap().reflections = Some(ReflectionOptions::default());
    let image = ::image::load_from_memory(&render(
        ProductScene { meshes: Vec::new(), bounds: solidcraft_geom::Aabb3::EMPTY },
        empty,
        Some(environment(false, 0.0)),
    ))
    .unwrap()
    .to_rgba8();
    assert!(image.pixels().all(|p| p.0 == [13, 27, 41, 255]));
}

#[test]
fn rough_metal_environment_matches_independent_sample_weights_without_extra_nee() {
    let mut factor = 0.0;
    // Normal-view white conductor at roughness1: null for z<=0, weight=2z/(1+z).
    // Only the deterministic variate key is shared; no BRDF/PDF implementation is reused.
    for sample in 0..64 {
        let u = reflection::variates(40, sample, 0, 64).unwrap();
        let z = 1.0 - 2.0 * u[0];
        if z > 0.0 {
            factor += 2.0 * z / (1.0 + z) / 64.0;
        }
    }
    let req = request(ReflectionMode::RoughSpecular);
    let png = render(scene(Vec3::Z), req.clone(), Some(environment(false, 0.0)));
    assert_eq!(centre(&png), expected([factor, factor * 0.5, factor * 0.25]));
    assert_eq!(png, render(scene(Vec3::Z), req, Some(environment(false, 0.0))));
}

#[test]
fn combined_hdr_equal_anisotropy_point_and_led_match_independent_radiance_sum() {
    let mut req = anisotropic_request(ReflectionMode::RoughSpecular, true);
    let options = req.raytrace.as_mut().unwrap();
    options.punctual_lights = Some(vec![job::PunctualLightOptions {
        position_mm: [0.0, 0.0, 10.0],
        color: [1.0, 0.5, 0.25],
        intensity: 1.0,
        reference_distance_mm: 10.0,
        minimum_distance_mm: 0.001,
        cone: None,
    }]);
    job::led_strip::LedStripOptions {
        center_mm: [0.0, 0.0, 10.0],
        length_mm: 8.0,
        width_mm: 0.5,
        length_axis: [1.0, 0.0, 0.0],
        width_axis: [0.0, -1.0, 0.0],
        color: [1.0, 0.5, 0.25],
        intensity: 2.0,
    }
    .append_to(options, 1)
    .unwrap();
    let mut reflected = 0.0;
    for sample in 0..64 {
        let u = reflection::variates(40, sample, 0, 64).unwrap();
        let z = 1.0 - 2.0 * u[0];
        if z > 0.0 {
            reflected += 2.0 * z / (1.0 + z) / 64.0;
        }
    }
    // Normal-view white conductor, roughness1: f*cos=1/(4*pi).
    // Point at its reference distance contributes Li=1; LED contributes Le*A/r²=.08.
    // Selected reflection receives HDR through BSDF misses only, never a second NEE term.
    let total = reflected + 1.08 / (4.0 * std::f64::consts::PI);
    let combined = render(scene(Vec3::Z), req.clone(), Some(environment(false, 0.0)));
    assert_eq!(centre(&combined), expected([total, total * 0.5, total * 0.25]));
    req.raytrace.as_mut().unwrap().anisotropic_faces = [None, None];
    assert_eq!(combined, render(scene(Vec3::Z), req, Some(environment(false, 0.0))));
}

#[test]
fn mirror_bright_cell_rotates_in_world_space_without_changing_background() {
    let reflected = Vec3::new(0.5, 0.5, 0.5_f64.sqrt());
    let normal = Vec3::Z + reflected;
    let req = request(ReflectionMode::Mirror);
    assert_eq!(centre(&render(scene(normal), req.clone(), Some(environment(true, 0.0)))), expected([16.0, 8.0, 2.0]));
    assert_eq!(centre(&render(scene(normal), req, Some(environment(true, std::f64::consts::FRAC_PI_2)))), [0, 0, 0, 255]);
}

#[test]
fn unsupported_diffuse_rough_hdr_refuses_and_selector_capacities_remain_accounted() {
    let req = request(ReflectionMode::RoughSpecular);
    let options = req.raytrace.clone().unwrap();
    let mut invalid = scene(Vec3::Z);
    invalid.meshes[0].surface = Some(OpaqueSurface::new(Vec3::new(1.0, 1.0, 1.0), 0.5, 1.0, 1.5).unwrap());
    assert!(ImageTask::new_with_environment(invalid, req.clone(), CancelToken::default(), options.clone(), Some(environment(false, 0.0))).is_err());
    let mut invalid = scene(Vec3::Z);
    invalid.meshes[0].faces.push(crate::FaceAppearance { transmission: None, face: 0, color: [255; 3], opacity: 1.0, surface: None });
    assert!(options.validate_environment_reflections(&invalid).is_err());
    let selectors = options.reflections.as_ref().unwrap();
    assert_eq!(
        options.retained_bytes().unwrap(),
        (selectors.bodies.capacity() * std::mem::size_of::<ReflectionBody>() + selectors.bodies[0].body.capacity()) as u64
    );
    assert!(std::mem::size_of::<ImageTask>() <= 4096, "combined task state must fit the host's admitted slot");
}

#[test]
fn secondary_environment_miss_obeys_shared_work_limit_and_cancel() {
    for cancel_now in [false, true] {
        let req = request(ReflectionMode::Mirror);
        let options = req.raytrace.clone().unwrap();
        let cancel = CancelToken::default();
        let mut task = ImageTask::new_with_environment(scene(Vec3::Z), req, cancel.clone(), options, Some(environment(false, 0.0))).unwrap();
        for _ in 0..100_000 {
            assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
            if task.pending.as_ref().is_some_and(|p| p.bounce > 0) {
                break;
            }
        }
        assert!(task.pending.as_ref().is_some_and(|p| p.bounce > 0));
        if cancel_now {
            cancel.cancel();
            assert_eq!(task.step(1).err().unwrap().code, ErrorCode::Cancelled);
        } else {
            task.work.limit = task.work.used();
            assert_eq!(task.step(1).err().unwrap().code, ErrorCode::LimitExceeded);
        }
    }
}

fn anisotropic_request(mode: ReflectionMode, equal_axes: bool) -> ImageRequest {
    let mut request = request(mode);
    request.raytrace.as_mut().unwrap().anisotropic_faces = [
        Some(job::AnisotropicFaceOptions {
            body_index: 0,
            body_name: "Metal".into(),
            face: 0,
            tangent: [1.0, 0.0, 0.0],
            orientation: job::AnisotropicOrientation::Zero,
            roughness_x: if equal_axes { 1.0 } else { 0.2 },
            roughness_y: if equal_axes { 1.0 } else { 0.6 },
        }),
        None,
    ];
    request
}

#[test]
fn hdr_equal_anisotropic_axes_match_isotropic_reflected_environment_bytes() {
    let plain = render(scene(Vec3::Z), request(ReflectionMode::RoughSpecular), Some(environment(false, 0.0)));
    let request = anisotropic_request(ReflectionMode::RoughSpecular, true);
    assert_eq!(plain, render(scene(Vec3::Z), request, Some(environment(false, 0.0))));
}

#[test]
fn hdr_anisotropic_direct_and_mirror_combinations_refuse_before_pixels() {
    for kind in 0..2 {
        let mut request = anisotropic_request(ReflectionMode::RoughSpecular, false);
        if kind == 0 {
            request.raytrace.as_mut().unwrap().reflections = None;
        } else {
            request.raytrace.as_mut().unwrap().reflections.as_mut().unwrap().bodies[0].mode = ReflectionMode::Mirror;
        }
        let options = request.raytrace.clone().unwrap();
        assert!(ImageTask::new_with_environment(scene(Vec3::Z), request, CancelToken::default(), options, Some(environment(false, 0.0))).is_err());
    }
}

#[test]
fn hdr_anisotropic_secondary_hit_yields_before_another_debit_and_observes_cancel() {
    let mut source = scene(Vec3::new(0.0, -1.0, 1.0));
    // Original planar reflector z=y, with a broad separate horizontal receiver.
    let mesh = Arc::new(Mesh {
        positions: vec![
            Vec3::new(-100.0, -100.0, 10.0),
            Vec3::new(-100.0, 100.0, 10.0),
            Vec3::new(100.0, 100.0, 10.0),
            Vec3::new(100.0, -100.0, 10.0),
        ],
        normals: vec![-Vec3::Z; 4],
        triangles: vec![[0, 1, 2], [0, 2, 3]],
        tri_face: vec![0, 0],
        ..Default::default()
    });
    source.bounds = source.bounds.union(&mesh.bounds());
    source.meshes.push(crate::ProductMesh {
        transmission: None,
        name: "Receiver".into(),
        mesh,
        color: [240, 80, 20],
        opacity: 1.0,
        surface: None,
        faces: Vec::new(),
    });
    let mut request = anisotropic_request(ReflectionMode::RoughSpecular, false);
    request.camera.set_view(crate::StandardView::Front);
    request.width = 1;
    request.height = 1;
    let options = request.raytrace.clone().unwrap();
    let cancel = CancelToken::default();
    let mut task = ImageTask::new_with_environment(source, request, cancel.clone(), options, Some(environment(false, 0.0))).unwrap();
    while task.bvh.is_none() {
        assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
    }
    let mut secondary_hit = false;
    for _ in 0..200_000 {
        let tracing_secondary = task.pending.as_ref().is_some_and(|p| p.bounce > 0 && p.hit.is_none());
        let before = task.work.used();
        assert!(matches!(task.step(1).unwrap(), TaskPoll::Pending(_)));
        assert!(task.work.used() - before <= 1, "secondary hit completion fell through into shading");
        if tracing_secondary && task.pending.as_ref().is_some_and(|p| p.hit.is_some()) {
            secondary_hit = true;
            break;
        }
    }
    assert!(secondary_hit);
    let before = task.work.used();
    assert!(matches!(task.step(4).unwrap(), TaskPoll::Pending(_)));
    assert!(task.work.used() - before <= 4);
    cancel.cancel();
    assert_eq!(task.step(4).err().unwrap().code, ErrorCode::Cancelled);
}